diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/XI2.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/XI2.h new file mode 100644 index 0000000000000000000000000000000000000000..cc47085df06b084bb2bc91d257d9cd3344817fb9 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/XI2.h @@ -0,0 +1,259 @@ +/* + * Copyright © 2009 Red Hat, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + */ + +#ifndef _XI2_H_ +#define _XI2_H_ + +#define XInput_2_0 7 +/* DO NOT ADD TO THIS LIST. These are libXi-specific defines. + See commit libXi-1.4.2-21-ge8531dd */ + +#define XI_2_Major 2 +#define XI_2_Minor 4 + +/* Property event flags */ +#define XIPropertyDeleted 0 +#define XIPropertyCreated 1 +#define XIPropertyModified 2 + +/* Property modes */ +#define XIPropModeReplace 0 +#define XIPropModePrepend 1 +#define XIPropModeAppend 2 + +/* Special property type used for XIGetProperty */ +#define XIAnyPropertyType 0L + +/* Enter/Leave and Focus In/Out modes */ +#define XINotifyNormal 0 +#define XINotifyGrab 1 +#define XINotifyUngrab 2 +#define XINotifyWhileGrabbed 3 +#define XINotifyPassiveGrab 4 +#define XINotifyPassiveUngrab 5 + +/* Enter/Leave and focus In/out detail */ +#define XINotifyAncestor 0 +#define XINotifyVirtual 1 +#define XINotifyInferior 2 +#define XINotifyNonlinear 3 +#define XINotifyNonlinearVirtual 4 +#define XINotifyPointer 5 +#define XINotifyPointerRoot 6 +#define XINotifyDetailNone 7 + +/* Grab modes */ +#define XIGrabModeSync 0 +#define XIGrabModeAsync 1 +#define XIGrabModeTouch 2 + +/* Grab reply status codes */ +#define XIGrabSuccess 0 +#define XIAlreadyGrabbed 1 +#define XIGrabInvalidTime 2 +#define XIGrabNotViewable 3 +#define XIGrabFrozen 4 + +/* Grab owner events values */ +#define XIOwnerEvents True +#define XINoOwnerEvents False + +/* Passive grab types */ +#define XIGrabtypeButton 0 +#define XIGrabtypeKeycode 1 +#define XIGrabtypeEnter 2 +#define XIGrabtypeFocusIn 3 +#define XIGrabtypeTouchBegin 4 +#define XIGrabtypeGesturePinchBegin 5 +#define XIGrabtypeGestureSwipeBegin 6 + +/* Passive grab modifier */ +#define XIAnyModifier (1U << 31) +#define XIAnyButton 0 +#define XIAnyKeycode 0 + +/* XIAllowEvents event-modes */ +#define XIAsyncDevice 0 +#define XISyncDevice 1 +#define XIReplayDevice 2 +#define XIAsyncPairedDevice 3 +#define XIAsyncPair 4 +#define XISyncPair 5 +#define XIAcceptTouch 6 +#define XIRejectTouch 7 + +/* DeviceChangedEvent change reasons */ +#define XISlaveSwitch 1 +#define XIDeviceChange 2 + +/* Hierarchy flags */ +#define XIMasterAdded (1 << 0) +#define XIMasterRemoved (1 << 1) +#define XISlaveAdded (1 << 2) +#define XISlaveRemoved (1 << 3) +#define XISlaveAttached (1 << 4) +#define XISlaveDetached (1 << 5) +#define XIDeviceEnabled (1 << 6) +#define XIDeviceDisabled (1 << 7) + +/* ChangeHierarchy constants */ +#define XIAddMaster 1 +#define XIRemoveMaster 2 +#define XIAttachSlave 3 +#define XIDetachSlave 4 + +#define XIAttachToMaster 1 +#define XIFloating 2 + +/* Valuator modes */ +#define XIModeRelative 0 +#define XIModeAbsolute 1 + +/* Device types */ +#define XIMasterPointer 1 +#define XIMasterKeyboard 2 +#define XISlavePointer 3 +#define XISlaveKeyboard 4 +#define XIFloatingSlave 5 + +/* Device classes: classes that are not identical to Xi 1.x classes must be + * numbered starting from 8. */ +#define XIKeyClass 0 +#define XIButtonClass 1 +#define XIValuatorClass 2 +#define XIScrollClass 3 +#define XITouchClass 8 +#define XIGestureClass 9 + +/* Scroll class types */ +#define XIScrollTypeVertical 1 +#define XIScrollTypeHorizontal 2 + +/* Scroll class flags */ +#define XIScrollFlagNoEmulation (1 << 0) +#define XIScrollFlagPreferred (1 << 1) + +/* Device event flags (common) */ +/* Device event flags (key events only) */ +#define XIKeyRepeat (1 << 16) +/* Device event flags (pointer events only) */ +#define XIPointerEmulated (1 << 16) +/* Device event flags (touch events only) */ +#define XITouchPendingEnd (1 << 16) +#define XITouchEmulatingPointer (1 << 17) + +/* Barrier event flags */ +#define XIBarrierPointerReleased (1 << 0) +#define XIBarrierDeviceIsGrabbed (1 << 1) + +/* Gesture pinch event flags */ +#define XIGesturePinchEventCancelled (1 << 0) + +/* Gesture swipe event flags */ +#define XIGestureSwipeEventCancelled (1 << 0) + +/* Touch modes */ +#define XIDirectTouch 1 +#define XIDependentTouch 2 + +/* XI2 event mask macros */ +#define XISetMask(ptr, event) (((unsigned char*)(ptr))[(event)>>3] |= (1 << ((event) & 7))) +#define XIClearMask(ptr, event) (((unsigned char*)(ptr))[(event)>>3] &= ~(1 << ((event) & 7))) +#define XIMaskIsSet(ptr, event) (((unsigned char*)(ptr))[(event)>>3] & (1 << ((event) & 7))) +#define XIMaskLen(event) (((event) >> 3) + 1) + +/* Fake device ID's for event selection */ +#define XIAllDevices 0 +#define XIAllMasterDevices 1 + +/* Event types */ +#define XI_DeviceChanged 1 +#define XI_KeyPress 2 +#define XI_KeyRelease 3 +#define XI_ButtonPress 4 +#define XI_ButtonRelease 5 +#define XI_Motion 6 +#define XI_Enter 7 +#define XI_Leave 8 +#define XI_FocusIn 9 +#define XI_FocusOut 10 +#define XI_HierarchyChanged 11 +#define XI_PropertyEvent 12 +#define XI_RawKeyPress 13 +#define XI_RawKeyRelease 14 +#define XI_RawButtonPress 15 +#define XI_RawButtonRelease 16 +#define XI_RawMotion 17 +#define XI_TouchBegin 18 /* XI 2.2 */ +#define XI_TouchUpdate 19 +#define XI_TouchEnd 20 +#define XI_TouchOwnership 21 +#define XI_RawTouchBegin 22 +#define XI_RawTouchUpdate 23 +#define XI_RawTouchEnd 24 +#define XI_BarrierHit 25 /* XI 2.3 */ +#define XI_BarrierLeave 26 +#define XI_GesturePinchBegin 27 /* XI 2.4 */ +#define XI_GesturePinchUpdate 28 +#define XI_GesturePinchEnd 29 +#define XI_GestureSwipeBegin 30 +#define XI_GestureSwipeUpdate 31 +#define XI_GestureSwipeEnd 32 +#define XI_LASTEVENT XI_GestureSwipeEnd +/* NOTE: XI2LASTEVENT in xserver/include/inputstr.h must be the same value + * as XI_LASTEVENT if the server is supposed to handle masks etc. for this + * type of event. */ + +/* Event masks. + * Note: the protocol spec defines a mask to be of (1 << type). Clients are + * free to create masks by bitshifting instead of using these defines. + */ +#define XI_DeviceChangedMask (1 << XI_DeviceChanged) +#define XI_KeyPressMask (1 << XI_KeyPress) +#define XI_KeyReleaseMask (1 << XI_KeyRelease) +#define XI_ButtonPressMask (1 << XI_ButtonPress) +#define XI_ButtonReleaseMask (1 << XI_ButtonRelease) +#define XI_MotionMask (1 << XI_Motion) +#define XI_EnterMask (1 << XI_Enter) +#define XI_LeaveMask (1 << XI_Leave) +#define XI_FocusInMask (1 << XI_FocusIn) +#define XI_FocusOutMask (1 << XI_FocusOut) +#define XI_HierarchyChangedMask (1 << XI_HierarchyChanged) +#define XI_PropertyEventMask (1 << XI_PropertyEvent) +#define XI_RawKeyPressMask (1 << XI_RawKeyPress) +#define XI_RawKeyReleaseMask (1 << XI_RawKeyRelease) +#define XI_RawButtonPressMask (1 << XI_RawButtonPress) +#define XI_RawButtonReleaseMask (1 << XI_RawButtonRelease) +#define XI_RawMotionMask (1 << XI_RawMotion) +#define XI_TouchBeginMask (1 << XI_TouchBegin) +#define XI_TouchEndMask (1 << XI_TouchEnd) +#define XI_TouchOwnershipChangedMask (1 << XI_TouchOwnership) +#define XI_TouchUpdateMask (1 << XI_TouchUpdate) +#define XI_RawTouchBeginMask (1 << XI_RawTouchBegin) +#define XI_RawTouchEndMask (1 << XI_RawTouchEnd) +#define XI_RawTouchUpdateMask (1 << XI_RawTouchUpdate) +#define XI_BarrierHitMask (1 << XI_BarrierHit) +#define XI_BarrierLeaveMask (1 << XI_BarrierLeave) + +#endif /* _XI2_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/XI2proto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/XI2proto.h new file mode 100644 index 0000000000000000000000000000000000000000..aaeac7b382ef53635c936bd994597b894305370a --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/XI2proto.h @@ -0,0 +1,1169 @@ +/* + * Copyright © 2009 Red Hat, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + */ + +/* Conventions for this file: + * Names: + * structs: always typedef'd, prefixed with xXI, CamelCase + * struct members: lower_case_with_underscores + * Exceptions: reqType, ReqType, repType, RepType, sequenceNumber are + * named as such for historical reasons. + * request opcodes: X_XIRequestName as CamelCase + * defines: defines used in client applications must go in XI2.h + * defines used only in protocol handling: XISOMENAME + * + * Data types: unless there is a historical name for a datatype (e.g. + * Window), use stdint types specifying the size of the datatype. + * historical data type names must be defined and undefined at the top and + * end of the file. + * + * General: + * spaces, not tabs. + * structs specific to a request or reply added before the request + * definition. structs used in more than one request, reply or event + * appended to the common structs section before the definition of the + * first request. + * members of structs vertically aligned on column 16 if datatypes permit. + * otherwise aligned on next available 8n column. + */ + +/** + * Protocol definitions for the XI2 protocol. + * This file should not be included by clients that merely use XI2, but do not + * need the wire protocol. Such clients should include XI2.h, or the matching + * header from the library. + * + */ +#ifndef _XI2PROTO_H_ +#define _XI2PROTO_H_ + +#include +#include +#include +#include + +/* make sure types have right sizes for protocol structures. */ +#define Window uint32_t +#define Time uint32_t +#define Atom uint32_t +#define Cursor uint32_t +#define Barrier uint32_t + +/** + * XI2 Request opcodes + */ +#define X_XIQueryPointer 40 +#define X_XIWarpPointer 41 +#define X_XIChangeCursor 42 +#define X_XIChangeHierarchy 43 +#define X_XISetClientPointer 44 +#define X_XIGetClientPointer 45 +#define X_XISelectEvents 46 +#define X_XIQueryVersion 47 +#define X_XIQueryDevice 48 +#define X_XISetFocus 49 +#define X_XIGetFocus 50 +#define X_XIGrabDevice 51 +#define X_XIUngrabDevice 52 +#define X_XIAllowEvents 53 +#define X_XIPassiveGrabDevice 54 +#define X_XIPassiveUngrabDevice 55 +#define X_XIListProperties 56 +#define X_XIChangeProperty 57 +#define X_XIDeleteProperty 58 +#define X_XIGetProperty 59 +#define X_XIGetSelectedEvents 60 +#define X_XIBarrierReleasePointer 61 + +/** Number of XI requests */ +#define XI2REQUESTS (X_XIBarrierReleasePointer - X_XIQueryPointer + 1) +/** Number of XI2 events */ +#define XI2EVENTS (XI_LASTEVENT + 1) + +/************************************************************************************* + * * + * COMMON STRUCTS * + * * + *************************************************************************************/ +/** Fixed point 16.16 */ +typedef int32_t FP1616; + +/** Fixed point 32.32 */ +typedef struct { + int32_t integral; + uint32_t frac; +} FP3232; + +/** + * Struct to describe a device. + * + * For a MasterPointer or a MasterKeyboard, 'attachment' specifies the + * paired master device. + * For a SlaveKeyboard or SlavePointer, 'attachment' specifies the master + * device this device is attached to. + * For a FloatingSlave, 'attachment' is undefined. + */ +typedef struct { + uint16_t deviceid; + uint16_t use; /**< ::XIMasterPointer, ::XIMasterKeyboard, + ::XISlavePointer, ::XISlaveKeyboard, + ::XIFloatingSlave */ + uint16_t attachment; /**< Current attachment or pairing.*/ + uint16_t num_classes; /**< Number of classes following this struct. */ + uint16_t name_len; /**< Length of name in bytes. */ + uint8_t enabled; /**< TRUE if device is enabled. */ + uint8_t pad; +} xXIDeviceInfo; + +/** + * Default template for a device class. + * A device class is equivalent to a device's capabilities. Multiple classes + * are supported per device. + */ +typedef struct { + uint16_t type; /**< One of *class */ + uint16_t length; /**< Length in 4 byte units */ + uint16_t sourceid; /**< source device for this class */ + uint16_t pad; +} xXIAnyInfo; + +/** + * Denotes button capability on a device. + * Struct is followed by a button bit-mask (padded to four byte chunks) and + * then num_buttons * Atom that names the buttons in the device-native setup + * (i.e. ignoring button mappings). + */ +typedef struct { + uint16_t type; /**< Always ButtonClass */ + uint16_t length; /**< Length in 4 byte units */ + uint16_t sourceid; /**< source device for this class */ + uint16_t num_buttons; /**< Number of buttons provided */ +} xXIButtonInfo; + +/** + * Denotes key capability on a device. + * Struct is followed by num_keys * CARD32 that lists the keycodes available + * on the device. + */ +typedef struct { + uint16_t type; /**< Always KeyClass */ + uint16_t length; /**< Length in 4 byte units */ + uint16_t sourceid; /**< source device for this class */ + uint16_t num_keycodes; /**< Number of keys provided */ +} xXIKeyInfo; + +/** + * Denotes an valuator capability on a device. + * One XIValuatorInfo describes exactly one valuator (axis) on the device. + */ +typedef struct { + uint16_t type; /**< Always ValuatorClass */ + uint16_t length; /**< Length in 4 byte units */ + uint16_t sourceid; /**< source device for this class */ + uint16_t number; /**< Valuator number */ + Atom label; /**< Axis label */ + FP3232 min; /**< Min value */ + FP3232 max; /**< Max value */ + FP3232 value; /**< Last published value */ + uint32_t resolution; /**< Resolutions in units/m */ + uint8_t mode; /**< ModeRelative or ModeAbsolute */ + uint8_t pad1; + uint16_t pad2; +} xXIValuatorInfo; + +/*** + * Denotes a scroll valuator on a device. + * One XIScrollInfo describes exactly one scroll valuator that must have a + * XIValuatorInfo struct. + */ +typedef struct { + uint16_t type; /**< Always ValuatorClass */ + uint16_t length; /**< Length in 4 byte units */ + uint16_t sourceid; /**< source device for this class */ + uint16_t number; /**< Valuator number */ + uint16_t scroll_type; /**< ::XIScrollTypeVertical, ::XIScrollTypeHorizontal */ + uint16_t pad0; + uint32_t flags; /**< ::XIScrollFlagEmulate, ::XIScrollFlagPreferred */ + FP3232 increment; /**< Increment for one unit of scrolling */ +} xXIScrollInfo; + +/** + * Denotes multitouch capability on a device. + */ +typedef struct { + uint16_t type; /**< Always TouchClass */ + uint16_t length; /**< Length in 4 byte units */ + uint16_t sourceid; /**< source device for this class */ + uint8_t mode; /**< DirectTouch or DependentTouch */ + uint8_t num_touches; /**< Maximum number of touches (0==unlimited) */ +} xXITouchInfo; + +/** + * Denotes touchpad gesture capability on a device. + */ +typedef struct { + uint16_t type; /**< Always GestureClass */ + uint16_t length; /**< Length in 4 byte units */ + uint16_t sourceid; /**< source device for this class */ + uint8_t num_touches; /**< Maximum number of touches gesture supports (0==unlimited) */ + uint8_t pad0; +} xXIGestureInfo; + +/** + * Used to select for events on a given window. + * Struct is followed by (mask_len * CARD8), with each bit set representing + * the event mask for the given type. A mask bit represents an event type if + * (mask == (1 << type)). + */ +typedef struct { + uint16_t deviceid; /**< Device id to select for */ + uint16_t mask_len; /**< Length of mask in 4 byte units */ +} xXIEventMask; + +/** + * XKB modifier information. + * The effective modifier is a binary mask of base, latched, and locked + * modifiers. + */ +typedef struct +{ + uint32_t base_mods; /**< Logically pressed modifiers */ + uint32_t latched_mods; /**< Logically latched modifiers */ + uint32_t locked_mods; /**< Logically locked modifiers */ + uint32_t effective_mods; /**< Effective modifiers */ +} xXIModifierInfo; + +/** + * XKB group information. + * The effective group is the mathematical sum of base, latched, and locked + * group after group wrapping is taken into account. + */ +typedef struct +{ + uint8_t base_group; /**< Logically "pressed" group */ + uint8_t latched_group; /**< Logically latched group */ + uint8_t locked_group; /**< Logically locked group */ + uint8_t effective_group; /**< Effective group */ +} xXIGroupInfo; + + +/************************************************************************************* + * * + * REQUESTS * + * * + *************************************************************************************/ + +/** + * Query the server for the supported X Input extension version. + */ + +typedef struct { + uint8_t reqType; /**< Input extension major code */ + uint8_t ReqType; /**< Always ::X_XIQueryVersion */ + uint16_t length; /**< Length in 4 byte units */ + uint16_t major_version; + uint16_t minor_version; +} xXIQueryVersionReq; +#define sz_xXIQueryVersionReq 8 + +typedef struct { + uint8_t repType; /**< ::X_Reply */ + uint8_t RepType; /**< Always ::X_XIQueryVersion */ + uint16_t sequenceNumber; + uint32_t length; + uint16_t major_version; + uint16_t minor_version; + uint32_t pad1; + uint32_t pad2; + uint32_t pad3; + uint32_t pad4; + uint32_t pad5; +} xXIQueryVersionReply; +#define sz_xXIQueryVersionReply 32 + +/** + * Query the server for information about a specific device or all input + * devices. + */ +typedef struct { + uint8_t reqType; /**< Input extension major code */ + uint8_t ReqType; /**< Always ::X_XIQueryDevice */ + uint16_t length; /**< Length in 4 byte units */ + uint16_t deviceid; + uint16_t pad; +} xXIQueryDeviceReq; +#define sz_xXIQueryDeviceReq 8 + +typedef struct { + uint8_t repType; /**< ::X_Reply */ + uint8_t RepType; /**< Always ::X_XIQueryDevice */ + uint16_t sequenceNumber; + uint32_t length; + uint16_t num_devices; + uint16_t pad0; + uint32_t pad1; + uint32_t pad2; + uint32_t pad3; + uint32_t pad4; + uint32_t pad5; +} xXIQueryDeviceReply; +#define sz_xXIQueryDeviceReply 32 + +/** + * Select for events on a given window. + */ +typedef struct { + uint8_t reqType; /**< Input extension major code */ + uint8_t ReqType; /**< Always ::X_XISelectEvents */ + uint16_t length; /**< Length in 4 byte units */ + Window win; + uint16_t num_masks; + uint16_t pad; +} xXISelectEventsReq; +#define sz_xXISelectEventsReq 12 + +/** + * Query for selected events on a given window. + */ +typedef struct { + uint8_t reqType; /**< Input extension major code */ + uint8_t ReqType; /**< Always ::X_XIGetSelectedEvents */ + uint16_t length; /**< Length in 4 byte units */ + Window win; +} xXIGetSelectedEventsReq; +#define sz_xXIGetSelectedEventsReq 8 + +typedef struct { + uint8_t repType; /**< Input extension major opcode */ + uint8_t RepType; /**< Always ::X_XIGetSelectedEvents */ + uint16_t sequenceNumber; + uint32_t length; + uint16_t num_masks; /**< Number of xXIEventMask structs + trailing the reply */ + uint16_t pad0; + uint32_t pad1; + uint32_t pad2; + uint32_t pad3; + uint32_t pad4; + uint32_t pad5; +} xXIGetSelectedEventsReply; +#define sz_xXIGetSelectedEventsReply 32 + +/** + * Query the given device's screen/window coordinates. + */ + +typedef struct { + uint8_t reqType; /**< Input extension major code */ + uint8_t ReqType; /**< Always ::X_XIQueryPointer */ + uint16_t length; /**< Length in 4 byte units */ + Window win; + uint16_t deviceid; + uint16_t pad1; +} xXIQueryPointerReq; +#define sz_xXIQueryPointerReq 12 + + +typedef struct { + uint8_t repType; /**< Input extension major opcode */ + uint8_t RepType; /**< Always ::X_XIQueryPointer */ + uint16_t sequenceNumber; + uint32_t length; + Window root; + Window child; + FP1616 root_x; + FP1616 root_y; + FP1616 win_x; + FP1616 win_y; + uint8_t same_screen; + uint8_t pad0; + uint16_t buttons_len; + xXIModifierInfo mods; + xXIGroupInfo group; +} xXIQueryPointerReply; +#define sz_xXIQueryPointerReply 56 + +/** + * Warp the given device's pointer to the specified position. + */ + +typedef struct { + uint8_t reqType; /**< Input extension major code */ + uint8_t ReqType; /**< Always ::X_XIWarpPointer */ + uint16_t length; /**< Length in 4 byte units */ + Window src_win; + Window dst_win; + FP1616 src_x; + FP1616 src_y; + uint16_t src_width; + uint16_t src_height; + FP1616 dst_x; + FP1616 dst_y; + uint16_t deviceid; + uint16_t pad1; +} xXIWarpPointerReq; +#define sz_xXIWarpPointerReq 36 + +/** + * Change the given device's sprite to the given cursor. + */ + +typedef struct { + uint8_t reqType; /**< Input extension major code */ + uint8_t ReqType; /**< Always ::X_XIChangeCursor */ + uint16_t length; /**< Length in 4 byte units */ + Window win; + Cursor cursor; + uint16_t deviceid; + uint16_t pad1; +} xXIChangeCursorReq; +#define sz_xXIChangeCursorReq 16 + +/** + * Modify the device hierarchy. + */ + +typedef struct { + uint8_t reqType; /**< Input extension major code */ + uint8_t ReqType; /**< Always ::X_XIChangeHierarchy */ + uint16_t length; /**< Length in 4 byte units */ + uint8_t num_changes; + uint8_t pad0; + uint16_t pad1; +} xXIChangeHierarchyReq; +#define sz_xXIChangeHierarchyReq 8 + +/** + * Generic header for any hierarchy change. + */ +typedef struct { + uint16_t type; + uint16_t length; /**< Length in 4 byte units */ +} xXIAnyHierarchyChangeInfo; + +/** + * Create a new master device. + * Name of new master follows struct (4-byte padded) + */ +typedef struct { + uint16_t type; /**< Always ::XIAddMaster */ + uint16_t length; /**< 2 + (namelen + padding)/4 */ + uint16_t name_len; + uint8_t send_core; + uint8_t enable; +} xXIAddMasterInfo; + +/** + * Delete a master device. Will automatically delete the master device paired + * with the given master device. + */ +typedef struct { + uint16_t type; /**< Always ::XIRemoveMaster */ + uint16_t length; /**< 3 */ + uint16_t deviceid; + uint8_t return_mode; /**< ::XIAttachToMaster, ::XIFloating */ + uint8_t pad; + uint16_t return_pointer; /**< Pointer to attach slave ptr devices to */ + uint16_t return_keyboard; /**< keyboard to attach slave keybd devices to*/ +} xXIRemoveMasterInfo; + +/** + * Attach an SD to a new device. + * NewMaster has to be of same type (pointer->pointer, keyboard->keyboard); + */ +typedef struct { + uint16_t type; /**< Always ::XIAttachSlave */ + uint16_t length; /**< 2 */ + uint16_t deviceid; + uint16_t new_master; /**< id of new master device */ +} xXIAttachSlaveInfo; + +/** + * Detach an SD from its current master device. + */ +typedef struct { + uint16_t type; /**< Always ::XIDetachSlave */ + uint16_t length; /**< 2 */ + uint16_t deviceid; + uint16_t pad; +} xXIDetachSlaveInfo; + + +/** + * Set the window/client's ClientPointer. + */ +typedef struct { + uint8_t reqType; + uint8_t ReqType; /**< Always ::X_XISetClientPointer */ + uint16_t length; /**< Length in 4 byte units */ + Window win; + uint16_t deviceid; + uint16_t pad1; +} xXISetClientPointerReq; +#define sz_xXISetClientPointerReq 12 + +/** + * Query the given window/client's ClientPointer setting. + */ +typedef struct { + uint8_t reqType; + uint8_t ReqType; /**< Always ::X_GetClientPointer */ + uint16_t length; /**< Length in 4 byte units */ + Window win; +} xXIGetClientPointerReq; +#define sz_xXIGetClientPointerReq 8 + +typedef struct { + uint8_t repType; /**< Input extension major opcode */ + uint8_t RepType; /**< Always ::X_GetClientPointer */ + uint16_t sequenceNumber; + uint32_t length; + BOOL set; /**< client pointer is set? */ + uint8_t pad0; + uint16_t deviceid; + uint32_t pad1; + uint32_t pad2; + uint32_t pad3; + uint32_t pad4; + uint32_t pad5; +} xXIGetClientPointerReply; +#define sz_xXIGetClientPointerReply 32 + +/** + * Set the input focus to the specified window. + */ +typedef struct { + uint8_t reqType; + uint8_t ReqType; /**< Always ::X_XISetFocus */ + uint16_t length; /**< Length in 4 byte units */ + Window focus; + Time time; + uint16_t deviceid; + uint16_t pad0; +} xXISetFocusReq; +#define sz_xXISetFocusReq 16 + +/** + * Query the current input focus. + */ +typedef struct { + uint8_t reqType; + uint8_t ReqType; /**< Always ::X_XIGetDeviceFocus */ + uint16_t length; /**< Length in 4 byte units */ + uint16_t deviceid; + uint16_t pad0; +} xXIGetFocusReq; +#define sz_xXIGetFocusReq 8 + +typedef struct { + uint8_t repType; /**< Input extension major opcode */ + uint8_t RepType; /**< Always ::X_XIGetFocus */ + uint16_t sequenceNumber; + uint32_t length; + Window focus; + uint32_t pad1; + uint32_t pad2; + uint32_t pad3; + uint32_t pad4; + uint32_t pad5; +} xXIGetFocusReply; +#define sz_xXIGetFocusReply 32 + + +/** + * Grab the given device. + */ +typedef struct { + uint8_t reqType; + uint8_t ReqType; /**< Always ::X_XIGrabDevice */ + uint16_t length; /**< Length in 4 byte units */ + Window grab_window; + Time time; + Cursor cursor; + uint16_t deviceid; + uint8_t grab_mode; + uint8_t paired_device_mode; + uint8_t owner_events; + uint8_t pad; + uint16_t mask_len; +} xXIGrabDeviceReq; +#define sz_xXIGrabDeviceReq 24 + +/** + * Return codes from a XIPassiveGrabDevice request. + */ +typedef struct { + uint32_t modifiers; /**< Modifier state */ + uint8_t status; /**< Grab status code */ + uint8_t pad0; + uint16_t pad1; +} xXIGrabModifierInfo; + +typedef struct { + uint8_t repType; /**< Input extension major opcode */ + uint8_t RepType; /**< Always ::X_XIGrabDevice */ + uint16_t sequenceNumber; + uint32_t length; + uint8_t status; + uint8_t pad0; + uint16_t pad1; + uint32_t pad2; + uint32_t pad3; + uint32_t pad4; + uint32_t pad5; + uint32_t pad6; +} xXIGrabDeviceReply; +#define sz_xXIGrabDeviceReply 32 + +/** + * Ungrab the specified device. + * + */ +typedef struct { + uint8_t reqType; + uint8_t ReqType; /**< Always ::X_XIUngrabDevice */ + uint16_t length; /**< Length in 4 byte units */ + Time time; + uint16_t deviceid; + uint16_t pad; +} xXIUngrabDeviceReq; +#define sz_xXIUngrabDeviceReq 12 + + +/** + * Allow or replay events on the specified grabbed device. + */ +typedef struct { + uint8_t reqType; + uint8_t ReqType; /**< Always ::X_XIAllowEvents */ + uint16_t length; /**< Length in 4 byte units */ + Time time; + uint16_t deviceid; + uint8_t mode; + uint8_t pad; +} xXIAllowEventsReq; +#define sz_xXIAllowEventsReq 12 + +/** + * Allow or replay events on the specified grabbed device. + * Since XI 2.2 + */ +typedef struct { + uint8_t reqType; + uint8_t ReqType; /**< Always ::X_XIAllowEvents */ + uint16_t length; /**< Length in 4 byte units */ + Time time; + uint16_t deviceid; + uint8_t mode; + uint8_t pad; + uint32_t touchid; /**< Since XI 2.2 */ + Window grab_window; /**< Since XI 2.2 */ +} xXI2_2AllowEventsReq; +#define sz_xXI2_2AllowEventsReq 20 + + +/** + * Passively grab the device. + */ +typedef struct { + uint8_t reqType; + uint8_t ReqType; /**< Always ::X_XIPassiveGrabDevice */ + uint16_t length; /**< Length in 4 byte units */ + Time time; + Window grab_window; + Cursor cursor; + uint32_t detail; + uint16_t deviceid; + uint16_t num_modifiers; + uint16_t mask_len; + uint8_t grab_type; + uint8_t grab_mode; + uint8_t paired_device_mode; + uint8_t owner_events; + uint16_t pad1; +} xXIPassiveGrabDeviceReq; +#define sz_xXIPassiveGrabDeviceReq 32 + +typedef struct { + uint8_t repType; /**< Input extension major opcode */ + uint8_t RepType; /**< Always ::X_XIPassiveGrabDevice */ + uint16_t sequenceNumber; + uint32_t length; + uint16_t num_modifiers; + uint16_t pad1; + uint32_t pad2; + uint32_t pad3; + uint32_t pad4; + uint32_t pad5; + uint32_t pad6; +} xXIPassiveGrabDeviceReply; +#define sz_xXIPassiveGrabDeviceReply 32 + +/** + * Delete a passive grab for the given device. + */ +typedef struct { + uint8_t reqType; + uint8_t ReqType; /**< Always ::X_XIPassiveUngrabDevice */ + uint16_t length; /**< Length in 4 byte units */ + Window grab_window; + uint32_t detail; + uint16_t deviceid; + uint16_t num_modifiers; + uint8_t grab_type; + uint8_t pad0; + uint16_t pad1; +} xXIPassiveUngrabDeviceReq; +#define sz_xXIPassiveUngrabDeviceReq 20 + +/** + * List all device properties on the specified device. + */ +typedef struct { + uint8_t reqType; + uint8_t ReqType; /**< Always ::X_XIListProperties */ + uint16_t length; /**< Length in 4 byte units */ + uint16_t deviceid; + uint16_t pad; +} xXIListPropertiesReq; +#define sz_xXIListPropertiesReq 8 + +typedef struct { + uint8_t repType; /**< Input extension major opcode */ + uint8_t RepType; /**< Always ::X_XIListProperties */ + uint16_t sequenceNumber; + uint32_t length; + uint16_t num_properties; + uint16_t pad0; + uint32_t pad1; + uint32_t pad2; + uint32_t pad3; + uint32_t pad4; + uint32_t pad5; +} xXIListPropertiesReply; +#define sz_xXIListPropertiesReply 32 + +/** + * Change a property on the specified device. + */ +typedef struct { + uint8_t reqType; + uint8_t ReqType; /**< Always ::X_XIChangeProperty */ + uint16_t length; /**< Length in 4 byte units */ + uint16_t deviceid; + uint8_t mode; + uint8_t format; + Atom property; + Atom type; + uint32_t num_items; +} xXIChangePropertyReq; +#define sz_xXIChangePropertyReq 20 + +/** + * Delete the specified property. + */ +typedef struct { + uint8_t reqType; + uint8_t ReqType; /**< Always X_XIDeleteProperty */ + uint16_t length; /**< Length in 4 byte units */ + uint16_t deviceid; + uint16_t pad0; + Atom property; +} xXIDeletePropertyReq; +#define sz_xXIDeletePropertyReq 12 + +/** + * Query the specified property's values. + */ +typedef struct { + uint8_t reqType; + uint8_t ReqType; /**< Always X_XIGetProperty */ + uint16_t length; /**< Length in 4 byte units */ + uint16_t deviceid; +#if defined(__cplusplus) || defined(c_plusplus) + uint8_t c_delete; +#else + uint8_t delete; +#endif + uint8_t pad0; + Atom property; + Atom type; + uint32_t offset; + uint32_t len; +} xXIGetPropertyReq; +#define sz_xXIGetPropertyReq 24 + +typedef struct { + uint8_t repType; /**< Input extension major opcode */ + uint8_t RepType; /**< Always X_XIGetProperty */ + uint16_t sequenceNumber; + uint32_t length; + Atom type; + uint32_t bytes_after; + uint32_t num_items; + uint8_t format; + uint8_t pad0; + uint16_t pad1; + uint32_t pad2; + uint32_t pad3; +} xXIGetPropertyReply; +#define sz_xXIGetPropertyReply 32 + +typedef struct { + uint16_t deviceid; + uint16_t pad; + Barrier barrier; + uint32_t eventid; +} xXIBarrierReleasePointerInfo; + +typedef struct { + uint8_t reqType; /**< Input extension major opcode */ + uint8_t ReqType; /**< Always X_XIBarrierReleasePointer */ + uint16_t length; + uint32_t num_barriers; + /* array of xXIBarrierReleasePointerInfo */ +} xXIBarrierReleasePointerReq; +#define sz_xXIBarrierReleasePointerReq 8 + +/************************************************************************************* + * * + * EVENTS * + * * + *************************************************************************************/ + +/** + * Generic XI2 event header. All XI2 events use the same header. + */ +typedef struct +{ + uint8_t type; + uint8_t extension; /**< XI extension offset */ + uint16_t sequenceNumber; + uint32_t length; + uint16_t evtype; + uint16_t deviceid; + Time time; +} xXIGenericDeviceEvent; + +/** + * Device hierarchy information. + */ +typedef struct +{ + uint16_t deviceid; + uint16_t attachment; /**< ID of master or paired device */ + uint8_t use; /**< ::XIMasterKeyboard, + ::XIMasterPointer, + ::XISlaveKeyboard, + ::XISlavePointer, + ::XIFloatingSlave */ + BOOL enabled; /**< TRUE if the device is enabled */ + uint16_t pad; + uint32_t flags; /**< ::XIMasterAdded, ::XIMasterRemoved, + ::XISlaveAttached, ::XISlaveDetached, + ::XISlaveAdded, ::XISlaveRemoved, + ::XIDeviceEnabled, ::XIDeviceDisabled */ +} xXIHierarchyInfo; + +/** + * The device hierarchy has been modified. This event includes the device + * hierarchy after the modification has been applied. + */ +typedef struct +{ + uint8_t type; /**< Always GenericEvent */ + uint8_t extension; /**< XI extension offset */ + uint16_t sequenceNumber; + uint32_t length; /**< Length in 4 byte units */ + uint16_t evtype; /**< ::XI_Hierarchy */ + uint16_t deviceid; + Time time; + uint32_t flags; /**< ::XIMasterAdded, ::XIMasterDeleted, + ::XISlaveAttached, ::XISlaveDetached, + ::XISlaveAdded, ::XISlaveRemoved, + ::XIDeviceEnabled, ::XIDeviceDisabled */ + uint16_t num_info; + uint16_t pad0; + uint32_t pad1; + uint32_t pad2; +} xXIHierarchyEvent; + +/** + * A device has changed capabilities. + */ +typedef struct +{ + uint8_t type; /**< Always GenericEvent */ + uint8_t extension; /**< XI extension offset */ + uint16_t sequenceNumber; + uint32_t length; /**< Length in 4 byte units */ + uint16_t evtype; /**< XI_DeviceChanged */ + uint16_t deviceid; /**< Device that has changed */ + Time time; + uint16_t num_classes; /**< Number of classes that have changed */ + uint16_t sourceid; /**< Source of the new classes */ + uint8_t reason; /**< ::XISlaveSwitch, ::XIDeviceChange */ + uint8_t pad0; + uint16_t pad1; + uint32_t pad2; + uint32_t pad3; +} xXIDeviceChangedEvent; + +/** + * The owner of a touch stream has passed on ownership to another client. + */ +typedef struct +{ + uint8_t type; /**< Always GenericEvent */ + uint8_t extension; /**< XI extension offset */ + uint16_t sequenceNumber; + uint32_t length; /**< Length in 4 byte units */ + uint16_t evtype; /**< XI_TouchOwnership */ + uint16_t deviceid; /**< Device that has changed */ + Time time; + uint32_t touchid; + Window root; + Window event; + Window child; +/* └──────── 32 byte boundary ────────┘ */ + uint16_t sourceid; + uint16_t pad0; + uint32_t flags; + uint32_t pad1; + uint32_t pad2; +} xXITouchOwnershipEvent; + +/** + * Default input event for pointer, keyboard or touch input. + */ +typedef struct +{ + uint8_t type; /**< Always GenericEvent */ + uint8_t extension; /**< XI extension offset */ + uint16_t sequenceNumber; + uint32_t length; /**< Length in 4 byte uints */ + uint16_t evtype; + uint16_t deviceid; + Time time; + uint32_t detail; /**< Keycode or button */ + Window root; + Window event; + Window child; +/* └──────── 32 byte boundary ────────┘ */ + FP1616 root_x; /**< Always screen coords, 16.16 fixed point */ + FP1616 root_y; + FP1616 event_x; /**< Always screen coords, 16.16 fixed point */ + FP1616 event_y; + uint16_t buttons_len; /**< Len of button flags in 4 b units */ + uint16_t valuators_len; /**< Len of val. flags in 4 b units */ + uint16_t sourceid; /**< The source device */ + uint16_t pad0; + uint32_t flags; /**< ::XIKeyRepeat */ + xXIModifierInfo mods; + xXIGroupInfo group; +} xXIDeviceEvent; + + +/** + * Sent when an input event is generated. RawEvents include valuator + * information in both device-specific data (i.e. unaccelerated) and + * processed data (i.e. accelerated, if applicable). + */ +typedef struct +{ + uint8_t type; /**< Always GenericEvent */ + uint8_t extension; /**< XI extension offset */ + uint16_t sequenceNumber; + uint32_t length; /**< Length in 4 byte uints */ + uint16_t evtype; /**< ::XI_RawEvent */ + uint16_t deviceid; + Time time; + uint32_t detail; + uint16_t sourceid; /**< The source device (XI 2.1) */ + uint16_t valuators_len; /**< Length of trailing valuator + mask in 4 byte units */ + uint32_t flags; /**< ::XIKeyRepeat */ + uint32_t pad2; +} xXIRawEvent; + +/** + * Note that the layout of root, event, child, root_x, root_y, event_x, + * event_y must be identical to the xXIDeviceEvent. + */ +typedef struct +{ + uint8_t type; /**< Always GenericEvent */ + uint8_t extension; /**< XI extension offset */ + uint16_t sequenceNumber; + uint32_t length; /**< Length in 4 byte uints */ + uint16_t evtype; /**< ::XI_Enter */ + uint16_t deviceid; + Time time; + uint16_t sourceid; + uint8_t mode; + uint8_t detail; + Window root; + Window event; + Window child; +/* └──────── 32 byte boundary ────────┘ */ + FP1616 root_x; + FP1616 root_y; + FP1616 event_x; + FP1616 event_y; + BOOL same_screen; + BOOL focus; + uint16_t buttons_len; /**< Length of trailing button mask + in 4 byte units */ + xXIModifierInfo mods; + xXIGroupInfo group; +} xXIEnterEvent; + +typedef xXIEnterEvent xXILeaveEvent; +typedef xXIEnterEvent xXIFocusInEvent; +typedef xXIEnterEvent xXIFocusOutEvent; + +/** + * Sent when a device property is created, modified or deleted. Does not + * include property data, the client is required to query the data. + */ +typedef struct +{ + uint8_t type; /**< Always GenericEvent */ + uint8_t extension; /**< XI extension offset */ + uint16_t sequenceNumber; + uint32_t length; /**< Length in 4 byte units */ + uint16_t evtype; /**< ::XI_PropertyEvent */ + uint16_t deviceid; + Time time; + Atom property; + uint8_t what; /**< ::XIPropertyDeleted, + ::XIPropertyCreated, + ::XIPropertyMotified */ + uint8_t pad0; + uint16_t pad1; + uint32_t pad2; + uint32_t pad3; +} xXIPropertyEvent; + +typedef struct +{ + uint8_t type; /**< Always GenericEvent */ + uint8_t extension; /**< XI extension offset */ + uint16_t sequenceNumber; + uint32_t length; /**< Length in 4 byte units */ + uint16_t evtype; /**< ::XI_BarrierHit or ::XI_BarrierLeave */ + uint16_t deviceid; + Time time; + uint32_t eventid; + Window root; + Window event; + Barrier barrier; +/* └──────── 32 byte boundary ────────┘ */ + uint32_t dtime; + uint32_t flags; /**< ::XIBarrierPointerReleased + ::XIBarrierDeviceIsGrabbed */ + uint16_t sourceid; + int16_t pad; + FP1616 root_x; + FP1616 root_y; + FP3232 dx; + FP3232 dy; +} xXIBarrierEvent; + +typedef xXIBarrierEvent xXIBarrierHitEvent; +typedef xXIBarrierEvent xXIBarrierPointerReleasedEvent; +typedef xXIBarrierEvent xXIBarrierLeaveEvent; + +/** + * Event for touchpad gesture pinch input events + */ +typedef struct +{ + uint8_t type; /**< Always GenericEvent */ + uint8_t extension; /**< XI extension offset */ + uint16_t sequenceNumber; + uint32_t length; /**< Length in 4 byte uints */ + uint16_t evtype; + uint16_t deviceid; + Time time; + uint32_t detail; /**< The number of touches in the gesture */ + Window root; + Window event; + Window child; +/* └──────── 32 byte boundary ────────┘ */ + FP1616 root_x; /**< Always screen coords, 16.16 fixed point */ + FP1616 root_y; + FP1616 event_x; /**< Always screen coords, 16.16 fixed point */ + FP1616 event_y; + FP1616 delta_x; + FP1616 delta_y; + FP1616 delta_unaccel_x; + FP1616 delta_unaccel_y; + FP1616 scale; + FP1616 delta_angle; + uint16_t sourceid; /**< The source device */ + uint16_t pad0; + xXIModifierInfo mods; + xXIGroupInfo group; + uint32_t flags; /**< ::XIGesturePinchEventCancelled */ +} xXIGesturePinchEvent; + +/** + * Event for touchpad gesture swipe input events + */ +typedef struct +{ + uint8_t type; /**< Always GenericEvent */ + uint8_t extension; /**< XI extension offset */ + uint16_t sequenceNumber; + uint32_t length; /**< Length in 4 byte uints */ + uint16_t evtype; + uint16_t deviceid; + Time time; + uint32_t detail; /**< The number of touches in the gesture */ + Window root; + Window event; + Window child; +/* └──────── 32 byte boundary ────────┘ */ + FP1616 root_x; /**< Always screen coords, 16.16 fixed point */ + FP1616 root_y; + FP1616 event_x; /**< Always screen coords, 16.16 fixed point */ + FP1616 event_y; + FP1616 delta_x; + FP1616 delta_y; + FP1616 delta_unaccel_x; + FP1616 delta_unaccel_y; + uint16_t sourceid; /**< The source device */ + uint16_t pad0; + xXIModifierInfo mods; + xXIGroupInfo group; + uint32_t flags; /**< ::XIGestureSwipeEventCancelled */ +} xXIGestureSwipeEvent; + +#undef Window +#undef Time +#undef Atom +#undef Cursor +#undef Barrier + +#endif /* _XI2PROTO_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/XIproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/XIproto.h new file mode 100644 index 0000000000000000000000000000000000000000..ac1f096f905395b666688e853a671589e54de190 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/XIproto.h @@ -0,0 +1,1758 @@ +/************************************************************ + +Copyright 1989, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +Copyright 1989 by Hewlett-Packard Company, Palo Alto, California. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Hewlett-Packard not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +HEWLETT-PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +HEWLETT-PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + +********************************************************/ + +#ifndef _XIPROTO_H +#define _XIPROTO_H + +#include +#include + +/* make sure types have right sizes for protocol structures. */ +#define Window CARD32 +#define Time CARD32 +#define KeyCode CARD8 +#define Mask CARD32 +#define Atom CARD32 +#define Cursor CARD32 + +/********************************************************* + * + * number of events, errors, and extension name. + * + */ + +#define MORE_EVENTS 0x80 +#define DEVICE_BITS 0x7F + +#define InputClassBits 0x3F /* bits in mode field for input classes */ +#define ModeBitsShift 6 /* amount to shift the remaining bits */ + +#define numInputClasses 7 + +#define IEVENTS 17 /* does NOT include generic events */ +#define IERRORS 5 +#define IREQUESTS 39 + +#define CLIENT_REQ 1 + +typedef struct _XExtEventInfo + { + Mask mask; + BYTE type; + BYTE word; + } XExtEventInfo; + +#ifndef _XITYPEDEF_POINTER +typedef void *Pointer; +#endif + +struct tmask + { + Mask mask; + void *dev; + }; + +/********************************************************* + * + * Event constants used by library. + * + */ + +#define XI_DeviceValuator 0 +#define XI_DeviceKeyPress 1 +#define XI_DeviceKeyRelease 2 +#define XI_DeviceButtonPress 3 +#define XI_DeviceButtonRelease 4 +#define XI_DeviceMotionNotify 5 +#define XI_DeviceFocusIn 6 +#define XI_DeviceFocusOut 7 +#define XI_ProximityIn 8 +#define XI_ProximityOut 9 +#define XI_DeviceStateNotify 10 +#define XI_DeviceMappingNotify 11 +#define XI_ChangeDeviceNotify 12 +#define XI_DeviceKeystateNotify 13 +#define XI_DeviceButtonstateNotify 14 +#define XI_DevicePresenceNotify 15 +#define XI_DevicePropertyNotify 16 + +/********************************************************* + * + * Protocol request constants + * + */ + +#define X_GetExtensionVersion 1 +#define X_ListInputDevices 2 +#define X_OpenDevice 3 +#define X_CloseDevice 4 +#define X_SetDeviceMode 5 +#define X_SelectExtensionEvent 6 +#define X_GetSelectedExtensionEvents 7 +#define X_ChangeDeviceDontPropagateList 8 +#define X_GetDeviceDontPropagateList 9 +#define X_GetDeviceMotionEvents 10 +#define X_ChangeKeyboardDevice 11 +#define X_ChangePointerDevice 12 +#define X_GrabDevice 13 +#define X_UngrabDevice 14 +#define X_GrabDeviceKey 15 +#define X_UngrabDeviceKey 16 +#define X_GrabDeviceButton 17 +#define X_UngrabDeviceButton 18 +#define X_AllowDeviceEvents 19 +#define X_GetDeviceFocus 20 +#define X_SetDeviceFocus 21 +#define X_GetFeedbackControl 22 +#define X_ChangeFeedbackControl 23 +#define X_GetDeviceKeyMapping 24 +#define X_ChangeDeviceKeyMapping 25 +#define X_GetDeviceModifierMapping 26 +#define X_SetDeviceModifierMapping 27 +#define X_GetDeviceButtonMapping 28 +#define X_SetDeviceButtonMapping 29 +#define X_QueryDeviceState 30 +#define X_SendExtensionEvent 31 +#define X_DeviceBell 32 +#define X_SetDeviceValuators 33 +#define X_GetDeviceControl 34 +#define X_ChangeDeviceControl 35 +/* XI 1.5 */ +#define X_ListDeviceProperties 36 +#define X_ChangeDeviceProperty 37 +#define X_DeleteDeviceProperty 38 +#define X_GetDeviceProperty 39 + +/********************************************************* + * + * Protocol request and reply structures. + * + * GetExtensionVersion. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* always X_GetExtensionVersion */ + CARD16 length; + CARD16 nbytes; + CARD8 pad1, pad2; +} xGetExtensionVersionReq; + +typedef struct { + CARD8 repType; /* X_Reply */ + CARD8 RepType; /* always X_GetExtensionVersion */ + CARD16 sequenceNumber; + CARD32 length; + CARD16 major_version; + CARD16 minor_version; + BOOL present; + CARD8 pad1, pad2, pad3; + CARD32 pad01; + CARD32 pad02; + CARD32 pad03; + CARD32 pad04; +} xGetExtensionVersionReply; + +/********************************************************* + * + * ListInputDevices. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* always X_ListInputDevices */ + CARD16 length; +} xListInputDevicesReq; + +typedef struct { + CARD8 repType; /* X_Reply */ + CARD8 RepType; /* always X_ListInputDevices */ + CARD16 sequenceNumber; + CARD32 length; + CARD8 ndevices; + CARD8 pad1, pad2, pad3; + CARD32 pad01; + CARD32 pad02; + CARD32 pad03; + CARD32 pad04; + CARD32 pad05; +} xListInputDevicesReply; + +typedef struct _xDeviceInfo *xDeviceInfoPtr; + +typedef struct _xAnyClassinfo *xAnyClassPtr; + +typedef struct _xAnyClassinfo { +#if defined(__cplusplus) || defined(c_plusplus) + CARD8 c_class; +#else + CARD8 class; +#endif + CARD8 length; + } xAnyClassInfo; + +typedef struct _xDeviceInfo { + CARD32 type; + CARD8 id; + CARD8 num_classes; + CARD8 use; /* IsXPointer | IsXKeyboard | IsXExtension... */ + CARD8 attached; /* id of master dev (if IsXExtension..) */ + } xDeviceInfo; + +typedef struct _xKeyInfo *xKeyInfoPtr; + +typedef struct _xKeyInfo { +#if defined(__cplusplus) || defined(c_plusplus) + CARD8 c_class; +#else + CARD8 class; +#endif + CARD8 length; + KeyCode min_keycode; + KeyCode max_keycode; + CARD16 num_keys; + CARD8 pad1,pad2; + } xKeyInfo; + +typedef struct _xButtonInfo *xButtonInfoPtr; + +typedef struct _xButtonInfo { +#if defined(__cplusplus) || defined(c_plusplus) + CARD8 c_class; +#else + CARD8 class; +#endif + CARD8 length; + CARD16 num_buttons; + } xButtonInfo; + +typedef struct _xValuatorInfo *xValuatorInfoPtr; + +typedef struct _xValuatorInfo { +#if defined(__cplusplus) || defined(c_plusplus) + CARD8 c_class; +#else + CARD8 class; +#endif + CARD8 length; + CARD8 num_axes; + CARD8 mode; + CARD32 motion_buffer_size; + } xValuatorInfo; + +typedef struct _xAxisInfo *xAxisInfoPtr; + +typedef struct _xAxisInfo { + CARD32 resolution; + CARD32 min_value; + CARD32 max_value; + } xAxisInfo; + +/********************************************************* + * + * OpenDevice. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* always X_OpenDevice */ + CARD16 length; + CARD8 deviceid; + BYTE pad1, pad2, pad3; +} xOpenDeviceReq; + +typedef struct { + CARD8 repType; /* X_Reply */ + CARD8 RepType; /* always X_OpenDevice */ + CARD16 sequenceNumber; + CARD32 length; + CARD8 num_classes; + BYTE pad1, pad2, pad3; + CARD32 pad00; + CARD32 pad01; + CARD32 pad02; + CARD32 pad03; + CARD32 pad04; + } xOpenDeviceReply; + +typedef struct { +#if defined(__cplusplus) || defined(c_plusplus) + CARD8 c_class; +#else + CARD8 class; +#endif + CARD8 event_type_base; + } xInputClassInfo; + +/********************************************************* + * + * CloseDevice. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* always X_CloseDevice */ + CARD16 length; + CARD8 deviceid; + BYTE pad1, pad2, pad3; +} xCloseDeviceReq; + +/********************************************************* + * + * SetDeviceMode. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* always X_SetDeviceMode */ + CARD16 length; + CARD8 deviceid; + CARD8 mode; + BYTE pad1, pad2; +} xSetDeviceModeReq; + +typedef struct { + CARD8 repType; /* X_Reply */ + CARD8 RepType; /* always X_SetDeviceMode */ + CARD16 sequenceNumber; + CARD32 length; + CARD8 status; + BYTE pad1, pad2, pad3; + CARD32 pad01; + CARD32 pad02; + CARD32 pad03; + CARD32 pad04; + CARD32 pad05; +} xSetDeviceModeReply; + +/********************************************************* + * + * SelectExtensionEvent. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* always X_SelectExtensionEvent */ + CARD16 length; + Window window; + CARD16 count; + CARD16 pad00; +} xSelectExtensionEventReq; + +/********************************************************* + * + * GetSelectedExtensionEvent. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* X_GetSelectedExtensionEvents */ + CARD16 length; + Window window; +} xGetSelectedExtensionEventsReq; + +typedef struct { + CARD8 repType; /* X_Reply */ + CARD8 RepType; /* GetSelectedExtensionEvents */ + CARD16 sequenceNumber; + CARD32 length; + CARD16 this_client_count; + CARD16 all_clients_count; + CARD32 pad01; + CARD32 pad02; + CARD32 pad03; + CARD32 pad04; + CARD32 pad05; +} xGetSelectedExtensionEventsReply; + +/********************************************************* + * + * ChangeDeviceDontPropagateList. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* X_ChangeDeviceDontPropagateList */ + CARD16 length; + Window window; + CARD16 count; + CARD8 mode; + BYTE pad; +} xChangeDeviceDontPropagateListReq; + +/********************************************************* + * + * GetDeviceDontPropagateList. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* X_GetDeviceDontPropagateList */ + CARD16 length; + Window window; +} xGetDeviceDontPropagateListReq; + +typedef struct { + CARD8 repType; /* X_Reply */ + CARD8 RepType; /* GetDeviceDontPropagateList */ + CARD16 sequenceNumber; + CARD32 length; + CARD16 count; + CARD16 pad00; + CARD32 pad01; + CARD32 pad02; + CARD32 pad03; + CARD32 pad04; + CARD32 pad05; + } xGetDeviceDontPropagateListReply; + +/********************************************************* + * + * GetDeviceMotionEvents. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* always X_GetDeviceMotionEvents*/ + CARD16 length; + Time start; + Time stop; + CARD8 deviceid; + BYTE pad1, pad2, pad3; +} xGetDeviceMotionEventsReq; + +typedef struct { + CARD8 repType; /* X_Reply */ + CARD8 RepType; /* always X_GetDeviceMotionEvents */ + CARD16 sequenceNumber; + CARD32 length; + CARD32 nEvents; + CARD8 axes; + CARD8 mode; + BYTE pad1, pad2; + CARD32 pad01; + CARD32 pad02; + CARD32 pad03; + CARD32 pad04; +} xGetDeviceMotionEventsReply; + +/********************************************************* + * + * ChangeKeyboardDevice. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* X_ChangeKeyboardDevice */ + CARD16 length; + CARD8 deviceid; + BYTE pad1, pad2, pad3; +} xChangeKeyboardDeviceReq; + +typedef struct { + CARD8 repType; /* X_Reply */ + CARD8 RepType; /* always X_ChangeKeyboardDevice*/ + CARD16 sequenceNumber; + CARD32 length; /* 0 */ + CARD8 status; + BYTE pad1, pad2, pad3; + CARD32 pad01; + CARD32 pad02; + CARD32 pad03; + CARD32 pad04; + CARD32 pad05; + } xChangeKeyboardDeviceReply; + +/********************************************************* + * + * ChangePointerDevice. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* X_ChangePointerDevice */ + CARD16 length; + CARD8 xaxis; + CARD8 yaxis; + CARD8 deviceid; + BYTE pad1; +} xChangePointerDeviceReq; + +typedef struct { + CARD8 repType; /* X_Reply */ + CARD8 RepType; /* always X_ChangePointerDevice */ + CARD16 sequenceNumber; + CARD32 length; /* 0 */ + CARD8 status; + BYTE pad1, pad2, pad3; + CARD32 pad01; + CARD32 pad02; + CARD32 pad03; + CARD32 pad04; + CARD32 pad05; + } xChangePointerDeviceReply; + +/********************************************************* + * + * GrabDevice. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* always X_GrabDevice */ + CARD16 length; + Window grabWindow; + Time time; + CARD16 event_count; + CARD8 this_device_mode; + CARD8 other_devices_mode; + BOOL ownerEvents; + CARD8 deviceid; + CARD16 pad01; +} xGrabDeviceReq; + +typedef struct { + CARD8 repType; /* X_Reply */ + CARD8 RepType; /* always X_GrabDevice */ + CARD16 sequenceNumber; + CARD32 length; /* 0 */ + CARD8 status; + BYTE pad1, pad2, pad3; + CARD32 pad01; + CARD32 pad02; + CARD32 pad03; + CARD32 pad04; + CARD32 pad05; + } xGrabDeviceReply; + +/********************************************************* + * + * UngrabDevice. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* always X_UnGrabDevice */ + CARD16 length; + Time time; + CARD8 deviceid; + BYTE pad1, pad2, pad3; +} xUngrabDeviceReq; + +/********************************************************* + * + * GrabDeviceKey. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* always X_GrabDeviceKey */ + CARD16 length; + Window grabWindow; + CARD16 event_count; + CARD16 modifiers; + CARD8 modifier_device; + CARD8 grabbed_device; + CARD8 key; + BYTE this_device_mode; + BYTE other_devices_mode; + BOOL ownerEvents; + BYTE pad1, pad2; +} xGrabDeviceKeyReq; + +/********************************************************* + * + * UngrabDeviceKey. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* always X_UngrabDeviceKey */ + CARD16 length; + Window grabWindow; + CARD16 modifiers; + CARD8 modifier_device; + CARD8 key; + CARD8 grabbed_device; + BYTE pad1, pad2, pad3; +} xUngrabDeviceKeyReq; + +/********************************************************* + * + * GrabDeviceButton. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* always X_GrabDeviceButton */ + CARD16 length; + Window grabWindow; + CARD8 grabbed_device; + CARD8 modifier_device; + CARD16 event_count; + CARD16 modifiers; + BYTE this_device_mode; + BYTE other_devices_mode; + CARD8 button; + BOOL ownerEvents; + BYTE pad1, pad2; +} xGrabDeviceButtonReq; + +/********************************************************* + * + * UngrabDeviceButton. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* always X_UngrabDeviceButton */ + CARD16 length; + Window grabWindow; + CARD16 modifiers; + CARD8 modifier_device; + CARD8 button; + CARD8 grabbed_device; + BYTE pad1, pad2, pad3; +} xUngrabDeviceButtonReq; + +/********************************************************* + * + * AllowDeviceEvents. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* always X_AllowDeviceEvents */ + CARD16 length; + Time time; + CARD8 mode; + CARD8 deviceid; + BYTE pad1, pad2; +} xAllowDeviceEventsReq; + +/********************************************************* + * + * GetDeviceFocus. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* always X_GetDeviceFocus */ + CARD16 length; + CARD8 deviceid; + BYTE pad1, pad2, pad3; +} xGetDeviceFocusReq; + +typedef struct { + CARD8 repType; /* X_Reply */ + CARD8 RepType; /* always X_GetDeviceFocus */ + CARD16 sequenceNumber; + CARD32 length; + CARD32 focus; + Time time; + CARD8 revertTo; + BYTE pad1, pad2, pad3; + CARD32 pad01; + CARD32 pad02; + CARD32 pad03; + } xGetDeviceFocusReply; + +/********************************************************* + * + * SetDeviceFocus. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* always X_SetDeviceFocus */ + CARD16 length; + Window focus; + Time time; + CARD8 revertTo; + CARD8 device; + CARD16 pad01; +} xSetDeviceFocusReq; + +/********************************************************* + * + * GetFeedbackControl. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* X_GetFeedbackControl */ + CARD16 length; + CARD8 deviceid; + BYTE pad1, pad2, pad3; +} xGetFeedbackControlReq; + +typedef struct { + CARD8 repType; /* X_Reply */ + CARD8 RepType; /* always X_GetFeedbackControl */ + CARD16 sequenceNumber; + CARD32 length; + CARD16 num_feedbacks; + CARD16 pad01; + CARD32 pad02; + CARD32 pad03; + CARD32 pad04; + CARD32 pad05; + CARD32 pad06; +} xGetFeedbackControlReply; + +typedef struct { +#if defined(__cplusplus) || defined(c_plusplus) + CARD8 c_class; /* feedback class */ +#else + CARD8 class; /* feedback class */ +#endif + CARD8 id; /* feedback id */ + CARD16 length; /* feedback length */ +} xFeedbackState; + +typedef struct { +#if defined(__cplusplus) || defined(c_plusplus) + CARD8 c_class; +#else + CARD8 class; +#endif + CARD8 id; + CARD16 length; + CARD16 pitch; + CARD16 duration; + CARD32 led_mask; + CARD32 led_values; + BOOL global_auto_repeat; + CARD8 click; + CARD8 percent; + BYTE pad; + BYTE auto_repeats[32]; +} xKbdFeedbackState; + +typedef struct { +#if defined(__cplusplus) || defined(c_plusplus) + CARD8 c_class; +#else + CARD8 class; +#endif + CARD8 id; + CARD16 length; + CARD8 pad1,pad2; + CARD16 accelNum; + CARD16 accelDenom; + CARD16 threshold; +} xPtrFeedbackState; + +typedef struct { +#if defined(__cplusplus) || defined(c_plusplus) + CARD8 c_class; /* feedback class id */ +#else + CARD8 class; /* feedback class id */ +#endif + CARD8 id; + CARD16 length; /* feedback length */ + CARD32 resolution; + INT32 min_value; + INT32 max_value; +} xIntegerFeedbackState; + +typedef struct { +#if defined(__cplusplus) || defined(c_plusplus) + CARD8 c_class; /* feedback class id */ +#else + CARD8 class; /* feedback class id */ +#endif + CARD8 id; + CARD16 length; /* feedback length */ + CARD16 max_symbols; + CARD16 num_syms_supported; +} xStringFeedbackState; + +typedef struct { +#if defined(__cplusplus) || defined(c_plusplus) + CARD8 c_class; /* feedback class id */ +#else + CARD8 class; /* feedback class id */ +#endif + CARD8 id; + CARD16 length; /* feedback length */ + CARD8 percent; + BYTE pad1, pad2, pad3; + CARD16 pitch; + CARD16 duration; +} xBellFeedbackState; + +typedef struct { +#if defined(__cplusplus) || defined(c_plusplus) + CARD8 c_class; /* feedback class id */ +#else + CARD8 class; /* feedback class id */ +#endif + CARD8 id; + CARD16 length; /* feedback length */ + CARD32 led_mask; + CARD32 led_values; +} xLedFeedbackState; + +/********************************************************* + * + * ChangeFeedbackControl. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* X_ChangeFeedbackControl */ + CARD16 length; + CARD32 mask; + CARD8 deviceid; + CARD8 feedbackid; + BYTE pad1, pad2; +} xChangeFeedbackControlReq; + +typedef struct { +#if defined(__cplusplus) || defined(c_plusplus) + CARD8 c_class; /* feedback class id */ +#else + CARD8 class; /* feedback class id */ +#endif + CARD8 id; /* feedback id */ + CARD16 length; /* feedback length */ +} xFeedbackCtl; + +typedef struct { +#if defined(__cplusplus) || defined(c_plusplus) + CARD8 c_class; /* feedback class id */ +#else + CARD8 class; /* feedback class id */ +#endif + CARD8 id; /* feedback length */ + CARD16 length; /* feedback length */ + KeyCode key; + CARD8 auto_repeat_mode; + INT8 click; + INT8 percent; + INT16 pitch; + INT16 duration; + CARD32 led_mask; + CARD32 led_values; +} xKbdFeedbackCtl; + +typedef struct { +#if defined(__cplusplus) || defined(c_plusplus) + CARD8 c_class; /* feedback class id */ +#else + CARD8 class; /* feedback class id */ +#endif + CARD8 id; /* feedback id */ + CARD16 length; /* feedback length */ + CARD8 pad1,pad2; + INT16 num; + INT16 denom; + INT16 thresh; +} xPtrFeedbackCtl; + +typedef struct { +#if defined(__cplusplus) || defined(c_plusplus) + CARD8 c_class; /* feedback class id */ +#else + CARD8 class; /* feedback class id */ +#endif + CARD8 id; /* feedback id */ + CARD16 length; /* feedback length */ + INT32 int_to_display; +} xIntegerFeedbackCtl; + +typedef struct { +#if defined(__cplusplus) || defined(c_plusplus) + CARD8 c_class; /* feedback class id */ +#else + CARD8 class; /* feedback class id */ +#endif + CARD8 id; /* feedback id */ + CARD16 length; /* feedback length */ + CARD8 pad1,pad2; + CARD16 num_keysyms; +} xStringFeedbackCtl; + +typedef struct { +#if defined(__cplusplus) || defined(c_plusplus) + CARD8 c_class; /* feedback class id */ +#else + CARD8 class; /* feedback class id */ +#endif + CARD8 id; /* feedback id */ + CARD16 length; /* feedback length */ + INT8 percent; + BYTE pad1, pad2, pad3; + INT16 pitch; + INT16 duration; +} xBellFeedbackCtl; + +typedef struct { +#if defined(__cplusplus) || defined(c_plusplus) + CARD8 c_class; /* feedback class id */ +#else + CARD8 class; /* feedback class id */ +#endif + CARD8 id; /* feedback id */ + CARD16 length; /* feedback length */ + CARD32 led_mask; + CARD32 led_values; +} xLedFeedbackCtl; + +/********************************************************* + * + * GetDeviceKeyMapping. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* always X_GetDeviceKeyMapping */ + CARD16 length; + CARD8 deviceid; + KeyCode firstKeyCode; + CARD8 count; + BYTE pad1; +} xGetDeviceKeyMappingReq; + +typedef struct { + CARD8 repType; /* X_Reply */ + CARD8 RepType; /* always X_GetDeviceKeyMapping */ + CARD16 sequenceNumber; + CARD32 length; + CARD8 keySymsPerKeyCode; + CARD8 pad0; + CARD16 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xGetDeviceKeyMappingReply; + +/********************************************************* + * + * ChangeDeviceKeyMapping. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* always X_ChangeDeviceKeyMapping */ + CARD16 length; + CARD8 deviceid; + KeyCode firstKeyCode; + CARD8 keySymsPerKeyCode; + CARD8 keyCodes; +} xChangeDeviceKeyMappingReq; + +/********************************************************* + * + * GetDeviceModifierMapping. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* always X_GetDeviceModifierMapping */ + CARD16 length; + CARD8 deviceid; + BYTE pad1, pad2, pad3; +} xGetDeviceModifierMappingReq; + +typedef struct { + CARD8 repType; /* X_Reply */ + CARD8 RepType; /* always X_GetDeviceModifierMapping */ + CARD16 sequenceNumber; + CARD32 length; + CARD8 numKeyPerModifier; + CARD8 pad0; + CARD16 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xGetDeviceModifierMappingReply; + +/********************************************************* + * + * SetDeviceModifierMapping. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* always X_SetDeviceModifierMapping */ + CARD16 length; + CARD8 deviceid; + CARD8 numKeyPerModifier; + CARD16 pad1; +} xSetDeviceModifierMappingReq; + +typedef struct { + CARD8 repType; /* X_Reply */ + CARD8 RepType; /* always X_SetDeviceModifierMapping */ + CARD16 sequenceNumber; + CARD32 length; + CARD8 success; + CARD8 pad0; + CARD16 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xSetDeviceModifierMappingReply; + +/********************************************************* + * + * GetDeviceButtonMapping. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* X_GetDeviceButtonMapping */ + CARD16 length; + CARD8 deviceid; + BYTE pad1, pad2, pad3; +} xGetDeviceButtonMappingReq; + +typedef struct { + CARD8 repType; /* X_Reply */ + CARD8 RepType; /* always X_GetDeviceButtonMapping */ + CARD16 sequenceNumber; + CARD32 length; + CARD8 nElts; + BYTE pad1, pad2, pad3; + CARD32 pad01; + CARD32 pad02; + CARD32 pad03; + CARD32 pad04; + CARD32 pad05; +} xGetDeviceButtonMappingReply; + +/********************************************************* + * + * SetDeviceButtonMapping. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* X_SetDeviceButtonMapping */ + CARD16 length; + CARD8 deviceid; + CARD8 map_length; + BYTE pad1, pad2; +} xSetDeviceButtonMappingReq; + +typedef struct { + CARD8 repType; /* X_Reply */ + CARD8 RepType; /* always X_SetDeviceButtonMapping */ + CARD16 sequenceNumber; + CARD32 length; + CARD8 status; + BYTE pad0; + CARD16 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xSetDeviceButtonMappingReply; + +/********************************************************* + * + * QueryDeviceState. + * + */ + +typedef struct { + CARD8 reqType; + CARD8 ReqType; /* always X_QueryDeviceState */ + CARD16 length; + CARD8 deviceid; + BYTE pad1, pad2, pad3; +} xQueryDeviceStateReq; + +typedef struct { + CARD8 repType; /* X_Reply */ + CARD8 RepType; /* always X_QueryDeviceState */ + CARD16 sequenceNumber; + CARD32 length; + CARD8 num_classes; + BYTE pad0; + CARD16 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xQueryDeviceStateReply; + +typedef struct { +#if defined(__cplusplus) || defined(c_plusplus) + CARD8 c_class; +#else + CARD8 class; +#endif + CARD8 length; + CARD8 num_keys; + BYTE pad1; + CARD8 keys[32]; +} xKeyState; + +typedef struct { +#if defined(__cplusplus) || defined(c_plusplus) + CARD8 c_class; +#else + CARD8 class; +#endif + CARD8 length; + CARD8 num_buttons; + BYTE pad1; + CARD8 buttons[32]; +} xButtonState; + +typedef struct { +#if defined(__cplusplus) || defined(c_plusplus) + CARD8 c_class; +#else + CARD8 class; +#endif + CARD8 length; + CARD8 num_valuators; + CARD8 mode; +} xValuatorState; + +/********************************************************* + * + * SendExtensionEvent. + * THIS REQUEST MUST BE KEPT A MULTIPLE OF 8 BYTES IN LENGTH! + * MORE EVENTS MAY FOLLOW AND THEY MUST BE QUAD-ALIGNED! + * + */ + +typedef struct { + CARD8 reqType; + CARD8 ReqType; /* always X_SendExtensionEvent */ + CARD16 length; + Window destination; + CARD8 deviceid; + BOOL propagate; + CARD16 count; + CARD8 num_events; + BYTE pad1,pad2,pad3; +} xSendExtensionEventReq; + +/********************************************************* + * + * DeviceBell. + * + */ + +typedef struct { + CARD8 reqType; + CARD8 ReqType; /* always X_DeviceBell */ + CARD16 length; + CARD8 deviceid; + CARD8 feedbackid; + CARD8 feedbackclass; + INT8 percent; +} xDeviceBellReq; + +/********************************************************* + * + * SetDeviceValuators. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* always X_SetDeviceValuators */ + CARD16 length; + CARD8 deviceid; + CARD8 first_valuator; + CARD8 num_valuators; + BYTE pad1; +} xSetDeviceValuatorsReq; + +typedef struct { + CARD8 repType; /* X_Reply */ + CARD8 RepType; /* always X_SetDeviceValuators */ + CARD16 sequenceNumber; + CARD32 length; + CARD8 status; + BYTE pad1, pad2, pad3; + CARD32 pad01; + CARD32 pad02; + CARD32 pad03; + CARD32 pad04; + CARD32 pad05; +} xSetDeviceValuatorsReply; + +/********************************************************* + * + * GetDeviceControl. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* always X_GetDeviceControl */ + CARD16 length; + CARD16 control; + CARD8 deviceid; + BYTE pad2; +} xGetDeviceControlReq; + +typedef struct { + CARD8 repType; /* X_Reply */ + CARD8 RepType; /* always X_GetDeviceControl */ + CARD16 sequenceNumber; + CARD32 length; + CARD8 status; + BYTE pad1, pad2, pad3; + CARD32 pad01; + CARD32 pad02; + CARD32 pad03; + CARD32 pad04; + CARD32 pad05; +} xGetDeviceControlReply; + +typedef struct { + CARD16 control; /* control type */ + CARD16 length; /* control length */ +} xDeviceState; + +typedef struct { + CARD16 control; /* control type */ + CARD16 length; /* control length */ + CARD32 num_valuators; /* number of valuators */ +} xDeviceResolutionState; + +typedef struct { + CARD16 control; + CARD16 length; + INT32 min_x; + INT32 max_x; + INT32 min_y; + INT32 max_y; + CARD32 flip_x; + CARD32 flip_y; + CARD32 rotation; + CARD32 button_threshold; +} xDeviceAbsCalibState; + +typedef struct { + CARD16 control; + CARD16 length; + CARD32 offset_x; + CARD32 offset_y; + CARD32 width; + CARD32 height; + CARD32 screen; + CARD32 following; +} xDeviceAbsAreaState; + +typedef struct { + CARD16 control; /* control type */ + CARD16 length; /* control length */ + CARD8 status; + CARD8 iscore; + CARD16 pad1; +} xDeviceCoreState; + +typedef struct { + CARD16 control; /* control type */ + CARD16 length; /* control length */ + CARD8 enable; + CARD8 pad0; + CARD16 pad1; +} xDeviceEnableState; + +/********************************************************* + * + * ChangeDeviceControl. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* always X_ChangeDeviceControl */ + CARD16 length; + CARD16 control; + CARD8 deviceid; + BYTE pad0; +} xChangeDeviceControlReq; + +typedef struct { + CARD8 repType; /* X_Reply */ + CARD8 RepType; /* always X_ChangeDeviceControl */ + CARD16 sequenceNumber; + CARD32 length; + CARD8 status; + BYTE pad1, pad2, pad3; + CARD32 pad01; + CARD32 pad02; + CARD32 pad03; + CARD32 pad04; + CARD32 pad05; +} xChangeDeviceControlReply; + +typedef struct { + CARD16 control; /* control type */ + CARD16 length; /* control length */ +} xDeviceCtl; + +typedef struct { + CARD16 control; /* control type */ + CARD16 length; /* control length */ + CARD8 first_valuator; /* first valuator to change */ + CARD8 num_valuators; /* number of valuators to change*/ + CARD8 pad1,pad2; +} xDeviceResolutionCtl; + +typedef struct { + CARD16 control; + CARD16 length; + INT32 min_x; + INT32 max_x; + INT32 min_y; + INT32 max_y; + CARD32 flip_x; + CARD32 flip_y; + CARD32 rotation; + CARD32 button_threshold; +} xDeviceAbsCalibCtl; + +typedef struct { + CARD16 control; + CARD16 length; + CARD32 offset_x; + CARD32 offset_y; + INT32 width; + INT32 height; + INT32 screen; + CARD32 following; +} xDeviceAbsAreaCtl; + +typedef struct { + CARD16 control; + CARD16 length; + CARD8 status; + CARD8 pad0; + CARD16 pad1; +} xDeviceCoreCtl; + +typedef struct { + CARD16 control; + CARD16 length; + CARD8 enable; + CARD8 pad0; + CARD16 pad1; +} xDeviceEnableCtl; + +/* XI 1.5 */ + +/********************************************************* + * + * ListDeviceProperties. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major opcode */ + CARD8 ReqType; /* always X_ListDeviceProperties */ + CARD16 length; + CARD8 deviceid; + CARD8 pad0; + CARD16 pad1; +} xListDevicePropertiesReq; + +typedef struct { + CARD8 repType; /* X_Reply */ + CARD8 RepType; /* always X_ListDeviceProperties */ + CARD16 sequenceNumber; + CARD32 length; + CARD16 nAtoms; + CARD16 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xListDevicePropertiesReply; + +/********************************************************* + * + * ChangeDeviceProperty. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major opcode */ + CARD8 ReqType; /* always X_ChangeDeviceProperty */ + CARD16 length; + Atom property; + Atom type; + CARD8 deviceid; + CARD8 format; + CARD8 mode; + CARD8 pad; + CARD32 nUnits; +} xChangeDevicePropertyReq; + +/********************************************************* + * + * DeleteDeviceProperty. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major opcode */ + CARD8 ReqType; /* always X_DeleteDeviceProperty */ + CARD16 length; + Atom property; + CARD8 deviceid; + CARD8 pad0; + CARD16 pad1; +} xDeleteDevicePropertyReq; + +/********************************************************* + * + * GetDeviceProperty. + * + */ + +typedef struct { + CARD8 reqType; /* input extension major opcode */ + CARD8 ReqType; /* always X_GetDeviceProperty */ + CARD16 length; + Atom property; + Atom type; + CARD32 longOffset; + CARD32 longLength; + CARD8 deviceid; +#if defined(__cplusplus) || defined(c_plusplus) + BOOL c_delete; +#else + BOOL delete; +#endif + CARD16 pad; +} xGetDevicePropertyReq; + +typedef struct { + CARD8 repType; /* X_Reply */ + CARD8 RepType; /* always X_GetDeviceProperty */ + CARD16 sequenceNumber; + CARD32 length; + Atom propertyType; + CARD32 bytesAfter; + CARD32 nItems; + CARD8 format; + CARD8 deviceid; + CARD16 pad1; + CARD32 pad2; + CARD32 pad3; +} xGetDevicePropertyReply; + + +/********************************************************** + * + * Input extension events. + * + * DeviceValuator + * + */ + +typedef struct + { + BYTE type; + CARD8 deviceid; + CARD16 sequenceNumber; + KeyButMask device_state; + CARD8 num_valuators; + CARD8 first_valuator; + INT32 valuator0; + INT32 valuator1; + INT32 valuator2; + INT32 valuator3; + INT32 valuator4; + INT32 valuator5; + } deviceValuator; + +/********************************************************** + * + * DeviceKeyButtonPointer. + * + * Used for: DeviceKeyPress, DeviceKeyRelease, + * DeviceButtonPress, DeviceButtonRelease, + * ProximityIn, ProximityOut + * DeviceMotionNotify, + * + */ + +typedef struct + { + BYTE type; + BYTE detail; + CARD16 sequenceNumber; + Time time; + Window root; + Window event; + Window child; + INT16 root_x; + INT16 root_y; + INT16 event_x; + INT16 event_y; + KeyButMask state; + BOOL same_screen; + CARD8 deviceid; + } deviceKeyButtonPointer; + +/********************************************************** + * + * DeviceFocus. + * + */ + +typedef struct + { + BYTE type; + BYTE detail; + CARD16 sequenceNumber; + Time time; + Window window; + BYTE mode; + CARD8 deviceid; + BYTE pad1, pad2; + CARD32 pad00; + CARD32 pad01; + CARD32 pad02; + CARD32 pad03; + } deviceFocus; + +/********************************************************** + * + * DeviceStateNotify. + * + * Note that the two high-order bits in the classes_reported + * field are the proximity state (InProximity or OutOfProximity), + * and the device mode (Absolute or Relative), respectively. + * + */ + +typedef struct + { + BYTE type; + BYTE deviceid; + CARD16 sequenceNumber; + Time time; + CARD8 num_keys; + CARD8 num_buttons; + CARD8 num_valuators; + CARD8 classes_reported; + CARD8 buttons[4]; + CARD8 keys[4]; + INT32 valuator0; + INT32 valuator1; + INT32 valuator2; + } deviceStateNotify; + +/********************************************************** + * + * DeviceKeyStateNotify. + * + */ + +typedef struct + { + BYTE type; + BYTE deviceid; + CARD16 sequenceNumber; + CARD8 keys[28]; + } deviceKeyStateNotify; + +/********************************************************** + * + * DeviceButtonStateNotify. + * + */ + +typedef struct + { + BYTE type; + BYTE deviceid; + CARD16 sequenceNumber; + CARD8 buttons[28]; + } deviceButtonStateNotify; + +/********************************************************** + * + * DeviceMappingNotify. + * Fields must be kept in sync with core mappingnotify event. + * + */ + +typedef struct + { + BYTE type; + BYTE deviceid; + CARD16 sequenceNumber; + CARD8 request; + KeyCode firstKeyCode; + CARD8 count; + BYTE pad1; + Time time; + CARD32 pad00; + CARD32 pad01; + CARD32 pad02; + CARD32 pad03; + CARD32 pad04; + } deviceMappingNotify; + +/********************************************************** + * + * ChangeDeviceNotify. + * + */ + +typedef struct + { + BYTE type; + BYTE deviceid; + CARD16 sequenceNumber; + Time time; + CARD8 request; + BYTE pad1, pad2, pad3; + CARD32 pad00; + CARD32 pad01; + CARD32 pad02; + CARD32 pad03; + CARD32 pad04; + } changeDeviceNotify; + +/********************************************************** + * + * devicePresenceNotify. + * + */ + +typedef struct + { + BYTE type; + BYTE pad00; + CARD16 sequenceNumber; + Time time; + BYTE devchange; /* Device{Added|Removed|Enabled|Disabled|ControlChanged} */ + BYTE deviceid; + CARD16 control; + CARD32 pad02; + CARD32 pad03; + CARD32 pad04; + CARD32 pad05; + CARD32 pad06; + } devicePresenceNotify; + + +/********************************************************* + * DevicePropertyNotifyEvent + * + * Sent whenever a device's property changes. + * + */ + +typedef struct + { + BYTE type; + BYTE state; /* NewValue or Deleted */ + CARD16 sequenceNumber; + CARD32 time; + Atom atom; /* affected property */ + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD16 pad5; + CARD8 pad4; + CARD8 deviceid; /* id of device */ + } devicePropertyNotify; + +#undef Window +#undef Time +#undef KeyCode +#undef Mask +#undef Atom +#undef Cursor + +#endif diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/XKB.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/XKB.h new file mode 100644 index 0000000000000000000000000000000000000000..5d3f87016f3a58b38702625fdced7205f084a169 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/XKB.h @@ -0,0 +1,786 @@ +/************************************************************ +Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc. + +Permission to use, copy, modify, and distribute this +software and its documentation for any purpose and without +fee is hereby granted, provided that the above copyright +notice appear in all copies and that both that copyright +notice and this permission notice appear in supporting +documentation, and that the name of Silicon Graphics not be +used in advertising or publicity pertaining to distribution +of the software without specific prior written permission. +Silicon Graphics makes no representation about the suitability +of this software for any purpose. It is provided "as is" +without any express or implied warranty. + +SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS +SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON +GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL +DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE +OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH +THE USE OR PERFORMANCE OF THIS SOFTWARE. + +********************************************************/ + +#ifndef _XKB_H_ +#define _XKB_H_ + + /* + * XKB request codes, used in: + * - xkbReqType field of all requests + * - requestMinor field of some events + */ +#define X_kbUseExtension 0 +#define X_kbSelectEvents 1 +#define X_kbBell 3 +#define X_kbGetState 4 +#define X_kbLatchLockState 5 +#define X_kbGetControls 6 +#define X_kbSetControls 7 +#define X_kbGetMap 8 +#define X_kbSetMap 9 +#define X_kbGetCompatMap 10 +#define X_kbSetCompatMap 11 +#define X_kbGetIndicatorState 12 +#define X_kbGetIndicatorMap 13 +#define X_kbSetIndicatorMap 14 +#define X_kbGetNamedIndicator 15 +#define X_kbSetNamedIndicator 16 +#define X_kbGetNames 17 +#define X_kbSetNames 18 +#define X_kbGetGeometry 19 +#define X_kbSetGeometry 20 +#define X_kbPerClientFlags 21 +#define X_kbListComponents 22 +#define X_kbGetKbdByName 23 +#define X_kbGetDeviceInfo 24 +#define X_kbSetDeviceInfo 25 +#define X_kbSetDebuggingFlags 101 + + /* + * In the X sense, XKB reports only one event. + * The type field of all XKB events is XkbEventCode + */ +#define XkbEventCode 0 +#define XkbNumberEvents (XkbEventCode+1) + + /* + * XKB has a minor event code so it can use one X event code for + * multiple purposes. + * - reported in the xkbType field of all XKB events. + * - XkbSelectEventDetails: Indicates the event for which event details + * are being changed + */ +#define XkbNewKeyboardNotify 0 +#define XkbMapNotify 1 +#define XkbStateNotify 2 +#define XkbControlsNotify 3 +#define XkbIndicatorStateNotify 4 +#define XkbIndicatorMapNotify 5 +#define XkbNamesNotify 6 +#define XkbCompatMapNotify 7 +#define XkbBellNotify 8 +#define XkbActionMessage 9 +#define XkbAccessXNotify 10 +#define XkbExtensionDeviceNotify 11 + + /* + * Event Mask: + * - XkbSelectEvents: Specifies event interest. + */ +#define XkbNewKeyboardNotifyMask (1L << 0) +#define XkbMapNotifyMask (1L << 1) +#define XkbStateNotifyMask (1L << 2) +#define XkbControlsNotifyMask (1L << 3) +#define XkbIndicatorStateNotifyMask (1L << 4) +#define XkbIndicatorMapNotifyMask (1L << 5) +#define XkbNamesNotifyMask (1L << 6) +#define XkbCompatMapNotifyMask (1L << 7) +#define XkbBellNotifyMask (1L << 8) +#define XkbActionMessageMask (1L << 9) +#define XkbAccessXNotifyMask (1L << 10) +#define XkbExtensionDeviceNotifyMask (1L << 11) +#define XkbAllEventsMask (0xFFF) + + /* + * NewKeyboardNotify event details: + */ +#define XkbNKN_KeycodesMask (1L << 0) +#define XkbNKN_GeometryMask (1L << 1) +#define XkbNKN_DeviceIDMask (1L << 2) +#define XkbAllNewKeyboardEventsMask (0x7) + + /* + * AccessXNotify event types: + * - The 'what' field of AccessXNotify events reports the + * reason that the event was generated. + */ +#define XkbAXN_SKPress 0 +#define XkbAXN_SKAccept 1 +#define XkbAXN_SKReject 2 +#define XkbAXN_SKRelease 3 +#define XkbAXN_BKAccept 4 +#define XkbAXN_BKReject 5 +#define XkbAXN_AXKWarning 6 + + /* + * AccessXNotify details: + * - Used as an event detail mask to limit the conditions under which + * AccessXNotify events are reported + */ +#define XkbAXN_SKPressMask (1L << 0) +#define XkbAXN_SKAcceptMask (1L << 1) +#define XkbAXN_SKRejectMask (1L << 2) +#define XkbAXN_SKReleaseMask (1L << 3) +#define XkbAXN_BKAcceptMask (1L << 4) +#define XkbAXN_BKRejectMask (1L << 5) +#define XkbAXN_AXKWarningMask (1L << 6) +#define XkbAllAccessXEventsMask (0x7f) + + /* + * Miscellaneous event details: + * - event detail masks for assorted events that don't really + * have any details. + */ +#define XkbAllStateEventsMask XkbAllStateComponentsMask +#define XkbAllMapEventsMask XkbAllMapComponentsMask +#define XkbAllControlEventsMask XkbAllControlsMask +#define XkbAllIndicatorEventsMask XkbAllIndicatorsMask +#define XkbAllNameEventsMask XkbAllNamesMask +#define XkbAllCompatMapEventsMask XkbAllCompatMask +#define XkbAllBellEventsMask (1L << 0) +#define XkbAllActionMessagesMask (1L << 0) + + /* + * XKB reports one error: BadKeyboard + * A further reason for the error is encoded into to most significant + * byte of the resourceID for the error: + * XkbErr_BadDevice - the device in question was not found + * XkbErr_BadClass - the device was found but it doesn't belong to + * the appropriate class. + * XkbErr_BadId - the device was found and belongs to the right + * class, but not feedback with a matching id was + * found. + * The low byte of the resourceID for this error contains the device + * id, class specifier or feedback id that failed. + */ +#define XkbKeyboard 0 +#define XkbNumberErrors 1 + +#define XkbErr_BadDevice 0xff +#define XkbErr_BadClass 0xfe +#define XkbErr_BadId 0xfd + + /* + * Keyboard Components Mask: + * - Specifies the components that follow a GetKeyboardByNameReply + */ +#define XkbClientMapMask (1L << 0) +#define XkbServerMapMask (1L << 1) +#define XkbCompatMapMask (1L << 2) +#define XkbIndicatorMapMask (1L << 3) +#define XkbNamesMask (1L << 4) +#define XkbGeometryMask (1L << 5) +#define XkbControlsMask (1L << 6) +#define XkbAllComponentsMask (0x7f) + + /* + * State detail mask: + * - The 'changed' field of StateNotify events reports which of + * the keyboard state components have changed. + * - Used as an event detail mask to limit the conditions under + * which StateNotify events are reported. + */ +#define XkbModifierStateMask (1L << 0) +#define XkbModifierBaseMask (1L << 1) +#define XkbModifierLatchMask (1L << 2) +#define XkbModifierLockMask (1L << 3) +#define XkbGroupStateMask (1L << 4) +#define XkbGroupBaseMask (1L << 5) +#define XkbGroupLatchMask (1L << 6) +#define XkbGroupLockMask (1L << 7) +#define XkbCompatStateMask (1L << 8) +#define XkbGrabModsMask (1L << 9) +#define XkbCompatGrabModsMask (1L << 10) +#define XkbLookupModsMask (1L << 11) +#define XkbCompatLookupModsMask (1L << 12) +#define XkbPointerButtonMask (1L << 13) +#define XkbAllStateComponentsMask (0x3fff) + + /* + * Controls detail masks: + * The controls specified in XkbAllControlsMask: + * - The 'changed' field of ControlsNotify events reports which of + * the keyboard controls have changed. + * - The 'changeControls' field of the SetControls request specifies + * the controls for which values are to be changed. + * - Used as an event detail mask to limit the conditions under + * which ControlsNotify events are reported. + * + * The controls specified in the XkbAllBooleanCtrlsMask: + * - The 'enabledControls' field of ControlsNotify events reports the + * current status of the boolean controls. + * - The 'enabledControlsChanges' field of ControlsNotify events reports + * any boolean controls that have been turned on or off. + * - The 'affectEnabledControls' and 'enabledControls' fields of the + * kbSetControls request change the set of enabled controls. + * - The 'accessXTimeoutMask' and 'accessXTimeoutValues' fields of + * an XkbControlsRec specify the controls to be changed if the keyboard + * times out and the values to which they should be changed. + * - The 'autoCtrls' and 'autoCtrlsValues' fields of the PerClientFlags + * request specifies the specify the controls to be reset when the + * client exits and the values to which they should be reset. + * - The 'ctrls' field of an indicator map specifies the controls + * that drive the indicator. + * - Specifies the boolean controls affected by the SetControls and + * LockControls key actions. + */ +#define XkbRepeatKeysMask (1L << 0) +#define XkbSlowKeysMask (1L << 1) +#define XkbBounceKeysMask (1L << 2) +#define XkbStickyKeysMask (1L << 3) +#define XkbMouseKeysMask (1L << 4) +#define XkbMouseKeysAccelMask (1L << 5) +#define XkbAccessXKeysMask (1L << 6) +#define XkbAccessXTimeoutMask (1L << 7) +#define XkbAccessXFeedbackMask (1L << 8) +#define XkbAudibleBellMask (1L << 9) +#define XkbOverlay1Mask (1L << 10) +#define XkbOverlay2Mask (1L << 11) +#define XkbIgnoreGroupLockMask (1L << 12) +#define XkbGroupsWrapMask (1L << 27) +#define XkbInternalModsMask (1L << 28) +#define XkbIgnoreLockModsMask (1L << 29) +#define XkbPerKeyRepeatMask (1L << 30) +#define XkbControlsEnabledMask (1L << 31) + +#define XkbAccessXOptionsMask (XkbStickyKeysMask|XkbAccessXFeedbackMask) + +#define XkbAllBooleanCtrlsMask (0x00001FFF) +#define XkbAllControlsMask (0xF8001FFF) +#define XkbAllControlEventsMask XkbAllControlsMask + + /* + * AccessX Options Mask + * - The 'accessXOptions' field of an XkbControlsRec specifies the + * AccessX options that are currently in effect. + * - The 'accessXTimeoutOptionsMask' and 'accessXTimeoutOptionsValues' + * fields of an XkbControlsRec specify the Access X options to be + * changed if the keyboard times out and the values to which they + * should be changed. + */ +#define XkbAX_SKPressFBMask (1L << 0) +#define XkbAX_SKAcceptFBMask (1L << 1) +#define XkbAX_FeatureFBMask (1L << 2) +#define XkbAX_SlowWarnFBMask (1L << 3) +#define XkbAX_IndicatorFBMask (1L << 4) +#define XkbAX_StickyKeysFBMask (1L << 5) +#define XkbAX_TwoKeysMask (1L << 6) +#define XkbAX_LatchToLockMask (1L << 7) +#define XkbAX_SKReleaseFBMask (1L << 8) +#define XkbAX_SKRejectFBMask (1L << 9) +#define XkbAX_BKRejectFBMask (1L << 10) +#define XkbAX_DumbBellFBMask (1L << 11) +#define XkbAX_FBOptionsMask (0xF3F) +#define XkbAX_SKOptionsMask (0x0C0) +#define XkbAX_AllOptionsMask (0xFFF) + + /* + * XkbUseCoreKbd is used to specify the core keyboard without having + * to look up its X input extension identifier. + * XkbUseCorePtr is used to specify the core pointer without having + * to look up its X input extension identifier. + * XkbDfltXIClass is used to specify "don't care" any place that the + * XKB protocol is looking for an X Input Extension + * device class. + * XkbDfltXIId is used to specify "don't care" any place that the + * XKB protocol is looking for an X Input Extension + * feedback identifier. + * XkbAllXIClasses is used to get information about all device indicators, + * whether they're part of the indicator feedback class + * or the keyboard feedback class. + * XkbAllXIIds is used to get information about all device indicator + * feedbacks without having to list them. + * XkbXINone is used to indicate that no class or id has been specified. + * XkbLegalXILedClass(c) True if 'c' specifies a legal class with LEDs + * XkbLegalXIBellClass(c) True if 'c' specifies a legal class with bells + * XkbExplicitXIDevice(d) True if 'd' explicitly specifies a device + * XkbExplicitXIClass(c) True if 'c' explicitly specifies a device class + * XkbExplicitXIId(c) True if 'i' explicitly specifies a device id + * XkbSingleXIClass(c) True if 'c' specifies exactly one device class, + * including the default. + * XkbSingleXIId(i) True if 'i' specifies exactly one device + * identifier, including the default. + */ +#define XkbUseCoreKbd 0x0100 +#define XkbUseCorePtr 0x0200 +#define XkbDfltXIClass 0x0300 +#define XkbDfltXIId 0x0400 +#define XkbAllXIClasses 0x0500 +#define XkbAllXIIds 0x0600 +#define XkbXINone 0xff00 + +#define XkbLegalXILedClass(c) (((c)==KbdFeedbackClass)||\ + ((c)==LedFeedbackClass)||\ + ((c)==XkbDfltXIClass)||\ + ((c)==XkbAllXIClasses)) +#define XkbLegalXIBellClass(c) (((c)==KbdFeedbackClass)||\ + ((c)==BellFeedbackClass)||\ + ((c)==XkbDfltXIClass)||\ + ((c)==XkbAllXIClasses)) +#define XkbExplicitXIDevice(c) (((c)&(~0xff))==0) +#define XkbExplicitXIClass(c) (((c)&(~0xff))==0) +#define XkbExplicitXIId(c) (((c)&(~0xff))==0) +#define XkbSingleXIClass(c) ((((c)&(~0xff))==0)||((c)==XkbDfltXIClass)) +#define XkbSingleXIId(c) ((((c)&(~0xff))==0)||((c)==XkbDfltXIId)) + +#define XkbNoModifier 0xff +#define XkbNoShiftLevel 0xff +#define XkbNoShape 0xff +#define XkbNoIndicator 0xff + +#define XkbNoModifierMask 0 +#define XkbAllModifiersMask 0xff +#define XkbAllVirtualModsMask 0xffff + +#define XkbNumKbdGroups 4 +#define XkbMaxKbdGroup (XkbNumKbdGroups-1) + +#define XkbMaxMouseKeysBtn 4 + + /* + * Group Index and Mask: + * - Indices into the kt_index array of a key type. + * - Mask specifies types to be changed for XkbChangeTypesOfKey + */ +#define XkbGroup1Index 0 +#define XkbGroup2Index 1 +#define XkbGroup3Index 2 +#define XkbGroup4Index 3 +#define XkbAnyGroup 254 +#define XkbAllGroups 255 + +#define XkbGroup1Mask (1<<0) +#define XkbGroup2Mask (1<<1) +#define XkbGroup3Mask (1<<2) +#define XkbGroup4Mask (1<<3) +#define XkbAnyGroupMask (1<<7) +#define XkbAllGroupsMask (0xf) + + /* + * BuildCoreState: Given a keyboard group and a modifier state, + * construct the value to be reported an event. + * GroupForCoreState: Given the state reported in an event, + * determine the keyboard group. + * IsLegalGroup: Returns TRUE if 'g' is a valid group index. + */ +#define XkbBuildCoreState(m,g) ((((g)&0x3)<<13)|((m)&0xff)) +#define XkbGroupForCoreState(s) (((s)>>13)&0x3) +#define XkbIsLegalGroup(g) (((g)>=0)&&((g)type>=Xkb_SASetMods)&&((a)->type<=XkbSA_LockMods)) +#define XkbIsGroupAction(a) (((a)->type>=XkbSA_SetGroup)&&((a)->type<=XkbSA_LockGroup)) +#define XkbIsPtrAction(a) (((a)->type>=XkbSA_MovePtr)&&((a)->type<=XkbSA_SetPtrDflt)) + + + /* + * Key Behavior Qualifier: + * KB_Permanent indicates that the behavior describes an unalterable + * characteristic of the keyboard, not an XKB software-simulation of + * the listed behavior. + * Key Behavior Types: + * Specifies the behavior of the underlying key. + */ +#define XkbKB_Permanent 0x80 +#define XkbKB_OpMask 0x7f + +#define XkbKB_Default 0x00 +#define XkbKB_Lock 0x01 +#define XkbKB_RadioGroup 0x02 +#define XkbKB_Overlay1 0x03 +#define XkbKB_Overlay2 0x04 + +#define XkbKB_RGAllowNone 0x80 + + /* + * Various macros which describe the range of legal keycodes. + */ +#define XkbMinLegalKeyCode 8 +#define XkbMaxLegalKeyCode 255 +#define XkbMaxKeyCount (XkbMaxLegalKeyCode-XkbMinLegalKeyCode+1) +#define XkbPerKeyBitArraySize ((XkbMaxLegalKeyCode+1)/8) +/* Seems kinda silly to check that an unsigned char is <= 255... */ +#define XkbIsLegalKeycode(k) ((k)>=XkbMinLegalKeyCode) + + /* + * Assorted constants and limits. + */ +#define XkbNumModifiers 8 +#define XkbNumVirtualMods 16 +#define XkbNumIndicators 32 +#define XkbAllIndicatorsMask (0xffffffff) +#define XkbMaxRadioGroups 32 +#define XkbAllRadioGroupsMask (0xffffffff) +#define XkbMaxShiftLevel 63 +#define XkbMaxSymsPerKey (XkbMaxShiftLevel*XkbNumKbdGroups) +#define XkbRGMaxMembers 12 +#define XkbActionMessageLength 6 +#define XkbKeyNameLength 4 +#define XkbMaxRedirectCount 8 + +#define XkbGeomPtsPerMM 10 +#define XkbGeomMaxColors 32 +#define XkbGeomMaxLabelColors 3 +#define XkbGeomMaxPriority 255 + + /* + * Key Type index and mask for the four standard key types. + */ +#define XkbOneLevelIndex 0 +#define XkbTwoLevelIndex 1 +#define XkbAlphabeticIndex 2 +#define XkbKeypadIndex 3 +#define XkbLastRequiredType XkbKeypadIndex +#define XkbNumRequiredTypes (XkbLastRequiredType+1) +#define XkbMaxKeyTypes 255 + +#define XkbOneLevelMask (1<<0) +#define XkbTwoLevelMask (1<<1) +#define XkbAlphabeticMask (1<<2) +#define XkbKeypadMask (1<<3) +#define XkbAllRequiredTypes (0xf) + +#define XkbShiftLevel(n) ((n)-1) +#define XkbShiftLevelMask(n) (1<<((n)-1)) + + /* + * Extension name and version information + */ +#define XkbName "XKEYBOARD" +#define XkbMajorVersion 1 +#define XkbMinorVersion 0 + + /* + * Explicit map components: + * - Used in the 'explicit' field of an XkbServerMap. Specifies + * the keyboard components that should _not_ be updated automatically + * in response to core protocol keyboard mapping requests. + */ +#define XkbExplicitKeyTypesMask (0x0f) +#define XkbExplicitKeyType1Mask (1<<0) +#define XkbExplicitKeyType2Mask (1<<1) +#define XkbExplicitKeyType3Mask (1<<2) +#define XkbExplicitKeyType4Mask (1<<3) +#define XkbExplicitInterpretMask (1<<4) +#define XkbExplicitAutoRepeatMask (1<<5) +#define XkbExplicitBehaviorMask (1<<6) +#define XkbExplicitVModMapMask (1<<7) +#define XkbAllExplicitMask (0xff) + + /* + * Map components masks: + * Those in AllMapComponentsMask: + * - Specifies the individual fields to be loaded or changed for the + * GetMap and SetMap requests. + * Those in ClientInfoMask: + * - Specifies the components to be allocated by XkbAllocClientMap. + * Those in ServerInfoMask: + * - Specifies the components to be allocated by XkbAllocServerMap. + */ +#define XkbKeyTypesMask (1<<0) +#define XkbKeySymsMask (1<<1) +#define XkbModifierMapMask (1<<2) +#define XkbExplicitComponentsMask (1<<3) +#define XkbKeyActionsMask (1<<4) +#define XkbKeyBehaviorsMask (1<<5) +#define XkbVirtualModsMask (1<<6) +#define XkbVirtualModMapMask (1<<7) + +#define XkbAllClientInfoMask (XkbKeyTypesMask|XkbKeySymsMask|XkbModifierMapMask) +#define XkbAllServerInfoMask (XkbExplicitComponentsMask|XkbKeyActionsMask|XkbKeyBehaviorsMask|XkbVirtualModsMask|XkbVirtualModMapMask) +#define XkbAllMapComponentsMask (XkbAllClientInfoMask|XkbAllServerInfoMask) + + /* + * Symbol interpretations flags: + * - Used in the flags field of a symbol interpretation + */ +#define XkbSI_AutoRepeat (1<<0) +#define XkbSI_LockingKey (1<<1) + + /* + * Symbol interpretations match specification: + * - Used in the match field of a symbol interpretation to specify + * the conditions under which an interpretation is used. + */ +#define XkbSI_LevelOneOnly (0x80) +#define XkbSI_OpMask (0x7f) +#define XkbSI_NoneOf (0) +#define XkbSI_AnyOfOrNone (1) +#define XkbSI_AnyOf (2) +#define XkbSI_AllOf (3) +#define XkbSI_Exactly (4) + + /* + * Indicator map flags: + * - Used in the flags field of an indicator map to indicate the + * conditions under which and indicator can be changed and the + * effects of changing the indicator. + */ +#define XkbIM_NoExplicit (1L << 7) +#define XkbIM_NoAutomatic (1L << 6) +#define XkbIM_LEDDrivesKB (1L << 5) + + /* + * Indicator map component specifications: + * - Used by the 'which_groups' and 'which_mods' fields of an indicator + * map to specify which keyboard components should be used to drive + * the indicator. + */ +#define XkbIM_UseBase (1L << 0) +#define XkbIM_UseLatched (1L << 1) +#define XkbIM_UseLocked (1L << 2) +#define XkbIM_UseEffective (1L << 3) +#define XkbIM_UseCompat (1L << 4) + +#define XkbIM_UseNone 0 +#define XkbIM_UseAnyGroup (XkbIM_UseBase|XkbIM_UseLatched|XkbIM_UseLocked\ + |XkbIM_UseEffective) +#define XkbIM_UseAnyMods (XkbIM_UseAnyGroup|XkbIM_UseCompat) + + /* + * Compatibility Map Components: + * - Specifies the components to be allocated in XkbAllocCompatMap. + */ +#define XkbSymInterpMask (1<<0) +#define XkbGroupCompatMask (1<<1) +#define XkbAllCompatMask (0x3) + + /* + * Names component mask: + * - Specifies the names to be loaded or changed for the GetNames and + * SetNames requests. + * - Specifies the names that have changed in a NamesNotify event. + * - Specifies the names components to be allocated by XkbAllocNames. + */ +#define XkbKeycodesNameMask (1<<0) +#define XkbGeometryNameMask (1<<1) +#define XkbSymbolsNameMask (1<<2) +#define XkbPhysSymbolsNameMask (1<<3) +#define XkbTypesNameMask (1<<4) +#define XkbCompatNameMask (1<<5) +#define XkbKeyTypeNamesMask (1<<6) +#define XkbKTLevelNamesMask (1<<7) +#define XkbIndicatorNamesMask (1<<8) +#define XkbKeyNamesMask (1<<9) +#define XkbKeyAliasesMask (1<<10) +#define XkbVirtualModNamesMask (1<<11) +#define XkbGroupNamesMask (1<<12) +#define XkbRGNamesMask (1<<13) +#define XkbComponentNamesMask (0x3f) +#define XkbAllNamesMask (0x3fff) + + /* + * GetByName components: + * - Specifies desired or necessary components to GetKbdByName request. + * - Reports the components that were found in a GetKbdByNameReply + */ +#define XkbGBN_TypesMask (1L << 0) +#define XkbGBN_CompatMapMask (1L << 1) +#define XkbGBN_ClientSymbolsMask (1L << 2) +#define XkbGBN_ServerSymbolsMask (1L << 3) +#define XkbGBN_SymbolsMask (XkbGBN_ClientSymbolsMask|XkbGBN_ServerSymbolsMask) +#define XkbGBN_IndicatorMapMask (1L << 4) +#define XkbGBN_KeyNamesMask (1L << 5) +#define XkbGBN_GeometryMask (1L << 6) +#define XkbGBN_OtherNamesMask (1L << 7) +#define XkbGBN_AllComponentsMask (0xff) + + /* + * ListComponents flags + */ +#define XkbLC_Hidden (1L << 0) +#define XkbLC_Default (1L << 1) +#define XkbLC_Partial (1L << 2) + +#define XkbLC_AlphanumericKeys (1L << 8) +#define XkbLC_ModifierKeys (1L << 9) +#define XkbLC_KeypadKeys (1L << 10) +#define XkbLC_FunctionKeys (1L << 11) +#define XkbLC_AlternateGroup (1L << 12) + + /* + * X Input Extension Interactions + * - Specifies the possible interactions between XKB and the X input + * extension + * - Used to request (XkbGetDeviceInfo) or change (XKbSetDeviceInfo) + * XKB information about an extension device. + * - Reports the list of supported optional features in the reply to + * XkbGetDeviceInfo or in an XkbExtensionDeviceNotify event. + * XkbXI_UnsupportedFeature is reported in XkbExtensionDeviceNotify + * events to indicate an attempt to use an unsupported feature. + */ +#define XkbXI_KeyboardsMask (1L << 0) +#define XkbXI_ButtonActionsMask (1L << 1) +#define XkbXI_IndicatorNamesMask (1L << 2) +#define XkbXI_IndicatorMapsMask (1L << 3) +#define XkbXI_IndicatorStateMask (1L << 4) +#define XkbXI_UnsupportedFeatureMask (1L << 15) +#define XkbXI_AllFeaturesMask (0x001f) +#define XkbXI_AllDeviceFeaturesMask (0x001e) + +#define XkbXI_IndicatorsMask (0x001c) +#define XkbAllExtensionDeviceEventsMask (0x801f) + + /* + * Per-Client Flags: + * - Specifies flags to be changed by the PerClientFlags request. + */ +#define XkbPCF_DetectableAutoRepeatMask (1L << 0) +#define XkbPCF_GrabsUseXKBStateMask (1L << 1) +#define XkbPCF_AutoResetControlsMask (1L << 2) +#define XkbPCF_LookupStateWhenGrabbed (1L << 3) +#define XkbPCF_SendEventUsesXKBState (1L << 4) +#define XkbPCF_AllFlagsMask (0x1F) + + /* + * Debugging flags and controls + */ +#define XkbDF_DisableLocks (1<<0) + +#endif /* _XKB_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/XKBproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/XKBproto.h new file mode 100644 index 0000000000000000000000000000000000000000..6eaec952f59e62db10d25fb643acb2ffb9c014c1 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/XKBproto.h @@ -0,0 +1,1282 @@ +/************************************************************ +Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc. + +Permission to use, copy, modify, and distribute this +software and its documentation for any purpose and without +fee is hereby granted, provided that the above copyright +notice appear in all copies and that both that copyright +notice and this permission notice appear in supporting +documentation, and that the name of Silicon Graphics not be +used in advertising or publicity pertaining to distribution +of the software without specific prior written permission. +Silicon Graphics makes no representation about the suitability +of this software for any purpose. It is provided "as is" +without any express or implied warranty. + +SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS +SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON +GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL +DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE +OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH +THE USE OR PERFORMANCE OF THIS SOFTWARE. + +********************************************************/ + +#ifndef _XKBPROTO_H_ +#define _XKBPROTO_H_ + +#include +#include +#include + +#define Window CARD32 +#define Atom CARD32 +#define Time CARD32 +#define KeyCode CARD8 +#define KeySym CARD32 + +#define XkbPaddedSize(n) ((((unsigned int)(n)+3) >> 2) << 2) + +typedef struct _xkbUseExtension { + CARD8 reqType; + CARD8 xkbReqType; /* always X_KBUseExtension */ + CARD16 length; + CARD16 wantedMajor; + CARD16 wantedMinor; +} xkbUseExtensionReq; +#define sz_xkbUseExtensionReq 8 + +typedef struct _xkbUseExtensionReply { + BYTE type; /* X_Reply */ + BOOL supported; + CARD16 sequenceNumber; + CARD32 length; + CARD16 serverMajor; + CARD16 serverMinor; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xkbUseExtensionReply; +#define sz_xkbUseExtensionReply 32 + +typedef struct _xkbSelectEvents { + CARD8 reqType; + CARD8 xkbReqType; /* X_KBSelectEvents */ + CARD16 length; + CARD16 deviceSpec; + CARD16 affectWhich; + CARD16 clear; + CARD16 selectAll; + CARD16 affectMap; + CARD16 map; +} xkbSelectEventsReq; +#define sz_xkbSelectEventsReq 16 + +typedef struct _xkbBell { + CARD8 reqType; + CARD8 xkbReqType; /* X_KBBell */ + CARD16 length; + CARD16 deviceSpec; + CARD16 bellClass; + CARD16 bellID; + INT8 percent; + BOOL forceSound; + BOOL eventOnly; + CARD8 pad1; + INT16 pitch; + INT16 duration; + CARD16 pad2; + Atom name; + Window window; +} xkbBellReq; +#define sz_xkbBellReq 28 + +typedef struct _xkbGetState { + CARD8 reqType; + CARD8 xkbReqType; /* always X_KBGetState */ + CARD16 length; + CARD16 deviceSpec; + CARD16 pad; +} xkbGetStateReq; +#define sz_xkbGetStateReq 8 + +typedef struct _xkbGetStateReply { + BYTE type; + BYTE deviceID; + CARD16 sequenceNumber; + CARD32 length; + CARD8 mods; + CARD8 baseMods; + CARD8 latchedMods; + CARD8 lockedMods; + CARD8 group; + CARD8 lockedGroup; + INT16 baseGroup; + INT16 latchedGroup; + CARD8 compatState; + CARD8 grabMods; + CARD8 compatGrabMods; + CARD8 lookupMods; + CARD8 compatLookupMods; + CARD8 pad1; + CARD16 ptrBtnState; + CARD16 pad2; + CARD32 pad3; +} xkbGetStateReply; +#define sz_xkbGetStateReply 32 + +typedef struct _xkbLatchLockState { + CARD8 reqType; + CARD8 xkbReqType; /* always X_KBLatchLockState */ + CARD16 length; + CARD16 deviceSpec; + CARD8 affectModLocks; + CARD8 modLocks; + BOOL lockGroup; + CARD8 groupLock; + CARD8 affectModLatches; + CARD8 modLatches; + CARD8 pad; + BOOL latchGroup; + INT16 groupLatch; +} xkbLatchLockStateReq; +#define sz_xkbLatchLockStateReq 16 + +typedef struct _xkbGetControls { + CARD8 reqType; + CARD8 xkbReqType; /* always X_KBGetControls */ + CARD16 length; + CARD16 deviceSpec; + CARD16 pad; +} xkbGetControlsReq; +#define sz_xkbGetControlsReq 8 + +typedef struct _xkbGetControlsReply { + BYTE type; /* X_Reply */ + CARD8 deviceID; + CARD16 sequenceNumber; + CARD32 length; + CARD8 mkDfltBtn; + CARD8 numGroups; + CARD8 groupsWrap; + CARD8 internalMods; + CARD8 ignoreLockMods; + CARD8 internalRealMods; + CARD8 ignoreLockRealMods; + CARD8 pad1; + CARD16 internalVMods; + CARD16 ignoreLockVMods; + CARD16 repeatDelay; + CARD16 repeatInterval; + CARD16 slowKeysDelay; + CARD16 debounceDelay; + CARD16 mkDelay; + CARD16 mkInterval; + CARD16 mkTimeToMax; + CARD16 mkMaxSpeed; + INT16 mkCurve; + CARD16 axOptions; + CARD16 axTimeout; + CARD16 axtOptsMask; + CARD16 axtOptsValues; + CARD16 pad2; + CARD32 axtCtrlsMask; + CARD32 axtCtrlsValues; + CARD32 enabledCtrls; + BYTE perKeyRepeat[XkbPerKeyBitArraySize]; +} xkbGetControlsReply; +#define sz_xkbGetControlsReply 92 + +typedef struct _xkbSetControls { + CARD8 reqType; + CARD8 xkbReqType; /* always X_KBSetControls */ + CARD16 length; + CARD16 deviceSpec; + CARD8 affectInternalMods; + CARD8 internalMods; + CARD8 affectIgnoreLockMods; + CARD8 ignoreLockMods; + CARD16 affectInternalVMods; + CARD16 internalVMods; + CARD16 affectIgnoreLockVMods; + CARD16 ignoreLockVMods; + CARD8 mkDfltBtn; + CARD8 groupsWrap; + CARD16 axOptions; + CARD16 pad1; + CARD32 affectEnabledCtrls; + CARD32 enabledCtrls; + CARD32 changeCtrls; + CARD16 repeatDelay; + CARD16 repeatInterval; + CARD16 slowKeysDelay; + CARD16 debounceDelay; + CARD16 mkDelay; + CARD16 mkInterval; + CARD16 mkTimeToMax; + CARD16 mkMaxSpeed; + INT16 mkCurve; + CARD16 axTimeout; + CARD32 axtCtrlsMask; + CARD32 axtCtrlsValues; + CARD16 axtOptsMask; + CARD16 axtOptsValues; + BYTE perKeyRepeat[XkbPerKeyBitArraySize]; +} xkbSetControlsReq; +#define sz_xkbSetControlsReq 100 + +typedef struct _xkbKTMapEntryWireDesc { + BOOL active; + CARD8 mask; + CARD8 level; + CARD8 realMods; + CARD16 virtualMods; + CARD16 pad; +} xkbKTMapEntryWireDesc; +#define sz_xkbKTMapEntryWireDesc 8 + +typedef struct _xkbKTSetMapEntryWireDesc { + CARD8 level; + CARD8 realMods; + CARD16 virtualMods; +} xkbKTSetMapEntryWireDesc; +#define sz_xkbKTSetMapEntryWireDesc 4 + +typedef struct _xkbModsWireDesc { + CARD8 mask; /* GetMap only */ + CARD8 realMods; + CARD16 virtualMods; +} xkbModsWireDesc; +#define sz_xkbModsWireDesc 4 + +typedef struct _xkbKeyTypeWireDesc { + CARD8 mask; + CARD8 realMods; + CARD16 virtualMods; + CARD8 numLevels; + CARD8 nMapEntries; + BOOL preserve; + CARD8 pad; +} xkbKeyTypeWireDesc; +#define sz_xkbKeyTypeWireDesc 8 + +typedef struct _xkbSymMapWireDesc { + CARD8 ktIndex[XkbNumKbdGroups]; + CARD8 groupInfo; + CARD8 width; + CARD16 nSyms; +} xkbSymMapWireDesc; +#define sz_xkbSymMapWireDesc 8 + +typedef struct _xkbVModMapWireDesc { + KeyCode key; + CARD8 pad; + CARD16 vmods; +} xkbVModMapWireDesc; +#define sz_xkbVModMapWireDesc 4 + +typedef struct _xkbBehaviorWireDesc { + CARD8 key; + CARD8 type; + CARD8 data; + CARD8 pad; +} xkbBehaviorWireDesc; +#define sz_xkbBehaviorWireDesc 4 + +typedef struct _xkbActionWireDesc { + CARD8 type; + CARD8 data[7]; +} xkbActionWireDesc; +#define sz_xkbActionWireDesc 8 + +typedef struct _xkbGetMap { + CARD8 reqType; + CARD8 xkbReqType; /* always X_KBGetMap */ + CARD16 length; + CARD16 deviceSpec; + CARD16 full; + CARD16 partial; + CARD8 firstType; + CARD8 nTypes; + KeyCode firstKeySym; + CARD8 nKeySyms; + KeyCode firstKeyAct; + CARD8 nKeyActs; + KeyCode firstKeyBehavior; + CARD8 nKeyBehaviors; + CARD16 virtualMods; + KeyCode firstKeyExplicit; + CARD8 nKeyExplicit; + KeyCode firstModMapKey; + CARD8 nModMapKeys; + KeyCode firstVModMapKey; + CARD8 nVModMapKeys; + CARD16 pad1; +} xkbGetMapReq; +#define sz_xkbGetMapReq 28 + +typedef struct _xkbGetMapReply { + CARD8 type; /* always X_Reply */ + CARD8 deviceID; + CARD16 sequenceNumber; + CARD32 length; + CARD16 pad1; + KeyCode minKeyCode; + KeyCode maxKeyCode; + CARD16 present; + CARD8 firstType; + CARD8 nTypes; + CARD8 totalTypes; + KeyCode firstKeySym; + CARD16 totalSyms; + CARD8 nKeySyms; + KeyCode firstKeyAct; + CARD16 totalActs; + CARD8 nKeyActs; + KeyCode firstKeyBehavior; + CARD8 nKeyBehaviors; + CARD8 totalKeyBehaviors; + KeyCode firstKeyExplicit; + CARD8 nKeyExplicit; + CARD8 totalKeyExplicit; + KeyCode firstModMapKey; + CARD8 nModMapKeys; + CARD8 totalModMapKeys; + KeyCode firstVModMapKey; + CARD8 nVModMapKeys; + CARD8 totalVModMapKeys; + CARD8 pad2; + CARD16 virtualMods; +} xkbGetMapReply; +#define sz_xkbGetMapReply 40 + +#define XkbSetMapResizeTypes (1L<<0) +#define XkbSetMapRecomputeActions (1L<<1) +#define XkbSetMapAllFlags (0x3) + +typedef struct _xkbSetMap { + CARD8 reqType; + CARD8 xkbReqType; /* always X_KBSetMap */ + CARD16 length; + CARD16 deviceSpec; + CARD16 present; + CARD16 flags; + KeyCode minKeyCode; + KeyCode maxKeyCode; + CARD8 firstType; + CARD8 nTypes; + KeyCode firstKeySym; + CARD8 nKeySyms; + CARD16 totalSyms; + KeyCode firstKeyAct; + CARD8 nKeyActs; + CARD16 totalActs; + KeyCode firstKeyBehavior; + CARD8 nKeyBehaviors; + CARD8 totalKeyBehaviors; + KeyCode firstKeyExplicit; + CARD8 nKeyExplicit; + CARD8 totalKeyExplicit; + KeyCode firstModMapKey; + CARD8 nModMapKeys; + CARD8 totalModMapKeys; + KeyCode firstVModMapKey; + CARD8 nVModMapKeys; + CARD8 totalVModMapKeys; + CARD16 virtualMods; +} xkbSetMapReq; +#define sz_xkbSetMapReq 36 + +typedef struct _xkbSymInterpretWireDesc { + CARD32 sym; + CARD8 mods; + CARD8 match; + CARD8 virtualMod; + CARD8 flags; + xkbActionWireDesc act; +} xkbSymInterpretWireDesc; +#define sz_xkbSymInterpretWireDesc 16 + +typedef struct _xkbGetCompatMap { + CARD8 reqType; + CARD8 xkbReqType; /* always X_KBGetCompatMap */ + CARD16 length; + CARD16 deviceSpec; + CARD8 groups; + BOOL getAllSI; + CARD16 firstSI; + CARD16 nSI; +} xkbGetCompatMapReq; +#define sz_xkbGetCompatMapReq 12 + +typedef struct _xkbGetCompatMapReply { + CARD8 type; /* always X_Reply */ + CARD8 deviceID; + CARD16 sequenceNumber; + CARD32 length; + CARD8 groups; + CARD8 pad1; + CARD16 firstSI; + CARD16 nSI; + CARD16 nTotalSI; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xkbGetCompatMapReply; +#define sz_xkbGetCompatMapReply 32 + +typedef struct _xkbSetCompatMap { + CARD8 reqType; + CARD8 xkbReqType; /* always X_KBSetCompatMap */ + CARD16 length; + CARD16 deviceSpec; + CARD8 pad1; + BOOL recomputeActions; + BOOL truncateSI; + CARD8 groups; + CARD16 firstSI; + CARD16 nSI; + CARD16 pad2; +} xkbSetCompatMapReq; +#define sz_xkbSetCompatMapReq 16 + +typedef struct _xkbGetIndicatorState { + CARD8 reqType; + CARD8 xkbReqType; /* always X_KBGetIndicatorState */ + CARD16 length; + CARD16 deviceSpec; + CARD16 pad1; +} xkbGetIndicatorStateReq; +#define sz_xkbGetIndicatorStateReq 8 + +typedef struct _xkbGetIndicatorStateReply { + CARD8 type; /* always X_Reply */ + CARD8 deviceID; + CARD16 sequenceNumber; + CARD32 length; + CARD32 state; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xkbGetIndicatorStateReply; +#define sz_xkbGetIndicatorStateReply 32 + +typedef struct _xkbGetIndicatorMap { + CARD8 reqType; + CARD8 xkbReqType; /* always X_KBGetIndicatorMap */ + CARD16 length; + CARD16 deviceSpec; + CARD16 pad; + CARD32 which; +} xkbGetIndicatorMapReq; +#define sz_xkbGetIndicatorMapReq 12 + +typedef struct _xkbGetIndicatorMapReply { + CARD8 type; /* always X_Reply */ + CARD8 deviceID; + CARD16 sequenceNumber; + CARD32 length; + CARD32 which; + CARD32 realIndicators; + CARD8 nIndicators; + CARD8 pad1; + CARD16 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xkbGetIndicatorMapReply; +#define sz_xkbGetIndicatorMapReply 32 + +typedef struct _xkbIndicatorMapWireDesc { + CARD8 flags; + CARD8 whichGroups; + CARD8 groups; + CARD8 whichMods; + CARD8 mods; + CARD8 realMods; + CARD16 virtualMods; + CARD32 ctrls; +} xkbIndicatorMapWireDesc; +#define sz_xkbIndicatorMapWireDesc 12 + +typedef struct _xkbSetIndicatorMap { + CARD8 reqType; + CARD8 xkbReqType; /* always X_KBSetIndicatorMap */ + CARD16 length; + CARD16 deviceSpec; + CARD16 pad1; + CARD32 which; +} xkbSetIndicatorMapReq; +#define sz_xkbSetIndicatorMapReq 12 + +typedef struct _xkbGetNamedIndicator { + CARD8 reqType; + CARD8 xkbReqType; /* X_KBGetNamedIndicator */ + CARD16 length; + CARD16 deviceSpec; + CARD16 ledClass; + CARD16 ledID; + CARD16 pad1; + Atom indicator; +} xkbGetNamedIndicatorReq; +#define sz_xkbGetNamedIndicatorReq 16 + +typedef struct _xkbGetNamedIndicatorReply { + BYTE type; + BYTE deviceID; + CARD16 sequenceNumber; + CARD32 length; + Atom indicator; + BOOL found; + BOOL on; + BOOL realIndicator; + CARD8 ndx; + CARD8 flags; + CARD8 whichGroups; + CARD8 groups; + CARD8 whichMods; + CARD8 mods; + CARD8 realMods; + CARD16 virtualMods; + CARD32 ctrls; + BOOL supported; + CARD8 pad1; + CARD16 pad2; +} xkbGetNamedIndicatorReply; +#define sz_xkbGetNamedIndicatorReply 32 + +typedef struct _xkbSetNamedIndicator { + CARD8 reqType; + CARD8 xkbReqType; /* X_KBSetNamedIndicator */ + CARD16 length; + CARD16 deviceSpec; + CARD16 ledClass; + CARD16 ledID; + CARD16 pad1; + Atom indicator; + BOOL setState; + BOOL on; + BOOL setMap; + BOOL createMap; + CARD8 pad2; + CARD8 flags; + CARD8 whichGroups; + CARD8 groups; + CARD8 whichMods; + CARD8 realMods; + CARD16 virtualMods; + CARD32 ctrls; +} xkbSetNamedIndicatorReq; +#define sz_xkbSetNamedIndicatorReq 32 + +typedef struct _xkbGetNames { + CARD8 reqType; + CARD8 xkbReqType; /* always X_KBGetNames */ + CARD16 length; + CARD16 deviceSpec; + CARD16 pad; + CARD32 which; +} xkbGetNamesReq; +#define sz_xkbGetNamesReq 12 + +typedef struct _xkbGetNamesReply { + BYTE type; + BYTE deviceID; + CARD16 sequenceNumber; + CARD32 length; + CARD32 which; + KeyCode minKeyCode; + KeyCode maxKeyCode; + CARD8 nTypes; + CARD8 groupNames; + CARD16 virtualMods; + KeyCode firstKey; + CARD8 nKeys; + CARD32 indicators; + CARD8 nRadioGroups; + CARD8 nKeyAliases; + CARD16 nKTLevels; + CARD32 pad3; +} xkbGetNamesReply; +#define sz_xkbGetNamesReply 32 + +typedef struct _xkbSetNames { + CARD8 reqType; + CARD8 xkbReqType; /* always X_KBSetNames */ + CARD16 length; + CARD16 deviceSpec; + CARD16 virtualMods; + CARD32 which; + CARD8 firstType; + CARD8 nTypes; + CARD8 firstKTLevel; + CARD8 nKTLevels; + CARD32 indicators; + CARD8 groupNames; + CARD8 nRadioGroups; + KeyCode firstKey; + CARD8 nKeys; + CARD8 nKeyAliases; + CARD8 pad1; + CARD16 totalKTLevelNames; +} xkbSetNamesReq; +#define sz_xkbSetNamesReq 28 + +typedef struct _xkbPointWireDesc { + INT16 x; + INT16 y; +} xkbPointWireDesc; +#define sz_xkbPointWireDesc 4 + +typedef struct _xkbOutlineWireDesc { + CARD8 nPoints; + CARD8 cornerRadius; + CARD16 pad; +} xkbOutlineWireDesc; +#define sz_xkbOutlineWireDesc 4 + +typedef struct _xkbShapeWireDesc { + Atom name; + CARD8 nOutlines; + CARD8 primaryNdx; + CARD8 approxNdx; + CARD8 pad; +} xkbShapeWireDesc; +#define sz_xkbShapeWireDesc 8 + +typedef struct _xkbSectionWireDesc { + Atom name; + INT16 top; + INT16 left; + CARD16 width; + CARD16 height; + INT16 angle; + CARD8 priority; + CARD8 nRows; + CARD8 nDoodads; + CARD8 nOverlays; + CARD16 pad; +} xkbSectionWireDesc; +#define sz_xkbSectionWireDesc 20 + +typedef struct _xkbRowWireDesc { + INT16 top; + INT16 left; + CARD8 nKeys; + BOOL vertical; + CARD16 pad; +} xkbRowWireDesc; +#define sz_xkbRowWireDesc 8 + +typedef struct _xkbKeyWireDesc { + CARD8 name[XkbKeyNameLength] _X_NONSTRING; + INT16 gap; + CARD8 shapeNdx; + CARD8 colorNdx; +} xkbKeyWireDesc; +#define sz_xkbKeyWireDesc 8 + +typedef struct _xkbOverlayWireDesc { + Atom name; + CARD8 nRows; + CARD8 pad1; + CARD16 pad2; +} xkbOverlayWireDesc; +#define sz_xkbOverlayWireDesc 8 + +typedef struct _xkbOverlayRowWireDesc { + CARD8 rowUnder; + CARD8 nKeys; + CARD16 pad1; +} xkbOverlayRowWireDesc; +#define sz_xkbOverlayRowWireDesc 4 + +typedef struct _xkbOverlayKeyWireDesc { + CARD8 over[XkbKeyNameLength] _X_NONSTRING; + CARD8 under[XkbKeyNameLength] _X_NONSTRING; +} xkbOverlayKeyWireDesc; +#define sz_xkbOverlayKeyWireDesc 8 + +typedef struct _xkbShapeDoodadWireDesc { + Atom name; + CARD8 type; + CARD8 priority; + INT16 top; + INT16 left; + INT16 angle; + CARD8 colorNdx; + CARD8 shapeNdx; + CARD16 pad1; + CARD32 pad2; +} xkbShapeDoodadWireDesc; +#define sz_xkbShapeDoodadWireDesc 20 + +typedef struct _xkbTextDoodadWireDesc { + Atom name; + CARD8 type; + CARD8 priority; + INT16 top; + INT16 left; + INT16 angle; + CARD16 width; + CARD16 height; + CARD8 colorNdx; + CARD8 pad1; + CARD16 pad2; +} xkbTextDoodadWireDesc; +#define sz_xkbTextDoodadWireDesc 20 + +typedef struct _xkbIndicatorDoodadWireDesc { + Atom name; + CARD8 type; + CARD8 priority; + INT16 top; + INT16 left; + INT16 angle; + CARD8 shapeNdx; + CARD8 onColorNdx; + CARD8 offColorNdx; + CARD8 pad1; + CARD32 pad2; +} xkbIndicatorDoodadWireDesc; +#define sz_xkbIndicatorDoodadWireDesc 20 + +typedef struct _xkbLogoDoodadWireDesc { + Atom name; + CARD8 type; + CARD8 priority; + INT16 top; + INT16 left; + INT16 angle; + CARD8 colorNdx; + CARD8 shapeNdx; + CARD16 pad1; + CARD32 pad2; +} xkbLogoDoodadWireDesc; +#define sz_xkbLogoDoodadWireDesc 20 + +typedef struct _xkbAnyDoodadWireDesc { + Atom name; + CARD8 type; + CARD8 priority; + INT16 top; + INT16 left; + INT16 angle; + CARD32 pad2; + CARD32 pad3; +} xkbAnyDoodadWireDesc; +#define sz_xkbAnyDoodadWireDesc 20 + +typedef union _xkbDoodadWireDesc { + xkbAnyDoodadWireDesc any; + xkbShapeDoodadWireDesc shape; + xkbTextDoodadWireDesc text; + xkbIndicatorDoodadWireDesc indicator; + xkbLogoDoodadWireDesc logo; +} xkbDoodadWireDesc; +#define sz_xkbDoodadWireDesc 20 + +typedef struct _xkbGetGeometry { + CARD8 reqType; + CARD8 xkbReqType; /* always X_KBGetGeometry */ + CARD16 length; + CARD16 deviceSpec; + CARD16 pad; + Atom name; +} xkbGetGeometryReq; +#define sz_xkbGetGeometryReq 12 + +typedef struct _xkbGetGeometryReply { + CARD8 type; /* always X_Reply */ + CARD8 deviceID; + CARD16 sequenceNumber; + CARD32 length; + Atom name; + BOOL found; + CARD8 pad; + CARD16 widthMM; + CARD16 heightMM; + CARD16 nProperties; + CARD16 nColors; + CARD16 nShapes; + CARD16 nSections; + CARD16 nDoodads; + CARD16 nKeyAliases; + CARD8 baseColorNdx; + CARD8 labelColorNdx; +} xkbGetGeometryReply; +#define sz_xkbGetGeometryReply 32 + +typedef struct _xkbSetGeometry { + CARD8 reqType; + CARD8 xkbReqType; /* always X_KBSetGeometry */ + CARD16 length; + CARD16 deviceSpec; + CARD8 nShapes; + CARD8 nSections; + Atom name; + CARD16 widthMM; + CARD16 heightMM; + CARD16 nProperties; + CARD16 nColors; + CARD16 nDoodads; + CARD16 nKeyAliases; + CARD8 baseColorNdx; + CARD8 labelColorNdx; + CARD16 pad; +} xkbSetGeometryReq; +#define sz_xkbSetGeometryReq 28 + +typedef struct _xkbPerClientFlags { + CARD8 reqType; + CARD8 xkbReqType;/* always X_KBPerClientFlags */ + CARD16 length; + CARD16 deviceSpec; + CARD16 pad1; + CARD32 change; + CARD32 value; + CARD32 ctrlsToChange; + CARD32 autoCtrls; + CARD32 autoCtrlValues; +} xkbPerClientFlagsReq; +#define sz_xkbPerClientFlagsReq 28 + +typedef struct _xkbPerClientFlagsReply { + CARD8 type; /* always X_Reply */ + CARD8 deviceID; + CARD16 sequenceNumber; + CARD32 length; + CARD32 supported; + CARD32 value; + CARD32 autoCtrls; + CARD32 autoCtrlValues; + CARD32 pad1; + CARD32 pad2; +} xkbPerClientFlagsReply; +#define sz_xkbPerClientFlagsReply 32 + +typedef struct _xkbListComponents { + CARD8 reqType; + CARD8 xkbReqType; /* always X_KBListComponents */ + CARD16 length; + CARD16 deviceSpec; + CARD16 maxNames; +} xkbListComponentsReq; +#define sz_xkbListComponentsReq 8 + +typedef struct _xkbListComponentsReply { + CARD8 type; /* always X_Reply */ + CARD8 deviceID; + CARD16 sequenceNumber; + CARD32 length; + CARD16 nKeymaps; + CARD16 nKeycodes; + CARD16 nTypes; + CARD16 nCompatMaps; + CARD16 nSymbols; + CARD16 nGeometries; + CARD16 extra; + CARD16 pad1; + CARD32 pad2; + CARD32 pad3; +} xkbListComponentsReply; +#define sz_xkbListComponentsReply 32 + +typedef struct _xkbGetKbdByName { + CARD8 reqType; + CARD8 xkbReqType; /* always X_KBGetKbdByName */ + CARD16 length; + CARD16 deviceSpec; + CARD16 need; /* combination of XkbGBN_* */ + CARD16 want; /* combination of XkbGBN_* */ + BOOL load; + CARD8 pad; +} xkbGetKbdByNameReq; +#define sz_xkbGetKbdByNameReq 12 + +typedef struct _xkbGetKbdByNameReply { + CARD8 type; /* always X_Reply */ + CARD8 deviceID; + CARD16 sequenceNumber; + CARD32 length; + KeyCode minKeyCode; + KeyCode maxKeyCode; + BOOL loaded; + BOOL newKeyboard; + CARD16 found; /* combination of XkbGBN_* */ + CARD16 reported; /* combination of XkbAllComponents */ + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xkbGetKbdByNameReply; +#define sz_xkbGetKbdByNameReply 32 + +typedef struct _xkbDeviceLedsWireDesc { + CARD16 ledClass; + CARD16 ledID; + CARD32 namesPresent; + CARD32 mapsPresent; + CARD32 physIndicators; + CARD32 state; +} xkbDeviceLedsWireDesc; +#define sz_xkbDeviceLedsWireDesc 20 + +typedef struct _xkbGetDeviceInfo { + CARD8 reqType; + CARD8 xkbReqType; /* always X_KBGetDeviceInfo */ + CARD16 length; + CARD16 deviceSpec; + CARD16 wanted; + BOOL allBtns; + CARD8 firstBtn; + CARD8 nBtns; + CARD8 pad; + CARD16 ledClass; + CARD16 ledID; +} xkbGetDeviceInfoReq; +#define sz_xkbGetDeviceInfoReq 16 + +typedef struct _xkbGetDeviceInfoReply { + CARD8 type; /* always X_Reply */ + CARD8 deviceID; + CARD16 sequenceNumber; + CARD32 length; + CARD16 present; + CARD16 supported; + CARD16 unsupported; + CARD16 nDeviceLedFBs; + CARD8 firstBtnWanted; + CARD8 nBtnsWanted; + CARD8 firstBtnRtrn; + CARD8 nBtnsRtrn; + CARD8 totalBtns; + BOOL hasOwnState; + CARD16 dfltKbdFB; + CARD16 dfltLedFB; + CARD16 pad; + Atom devType; +} xkbGetDeviceInfoReply; +#define sz_xkbGetDeviceInfoReply 32 + +typedef struct _xkbSetDeviceInfo { + CARD8 reqType; + CARD8 xkbReqType; /* always X_KBSetDeviceInfo */ + CARD16 length; + CARD16 deviceSpec; + CARD8 firstBtn; + CARD8 nBtns; + CARD16 change; + CARD16 nDeviceLedFBs; +} xkbSetDeviceInfoReq; +#define sz_xkbSetDeviceInfoReq 12 + +typedef struct _xkbSetDebuggingFlags { + CARD8 reqType; + CARD8 xkbReqType; /* always X_KBSetDebuggingFlags */ + CARD16 length; + CARD16 msgLength; + CARD16 pad; + CARD32 affectFlags; + CARD32 flags; + CARD32 affectCtrls; + CARD32 ctrls; +} xkbSetDebuggingFlagsReq; +#define sz_xkbSetDebuggingFlagsReq 24 + +typedef struct _xkbSetDebuggingFlagsReply { + BYTE type; /* X_Reply */ + CARD8 pad0; + CARD16 sequenceNumber; + CARD32 length; + CARD32 currentFlags; + CARD32 currentCtrls; + CARD32 supportedFlags; + CARD32 supportedCtrls; + CARD32 pad1; + CARD32 pad2; +} xkbSetDebuggingFlagsReply; +#define sz_xkbSetDebuggingFlagsReply 32 + + /* + * X KEYBOARD EXTENSION EVENT STRUCTURES + */ + +typedef struct _xkbAnyEvent { + BYTE type; + BYTE xkbType; + CARD16 sequenceNumber; + Time time; + CARD8 deviceID; + CARD8 pad1; + CARD16 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; + CARD32 pad7; +} xkbAnyEvent; +#define sz_xkbAnyEvent 32 + +typedef struct _xkbNewKeyboardNotify { + BYTE type; + BYTE xkbType; + CARD16 sequenceNumber; + Time time; + CARD8 deviceID; + CARD8 oldDeviceID; + KeyCode minKeyCode; + KeyCode maxKeyCode; + KeyCode oldMinKeyCode; + KeyCode oldMaxKeyCode; + CARD8 requestMajor; + CARD8 requestMinor; + CARD16 changed; + CARD8 detail; + CARD8 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xkbNewKeyboardNotify; +#define sz_xkbNewKeyboardNotify 32 + +typedef struct _xkbMapNotify { + BYTE type; + BYTE xkbType; + CARD16 sequenceNumber; + Time time; + CARD8 deviceID; + CARD8 ptrBtnActions; + CARD16 changed; + KeyCode minKeyCode; + KeyCode maxKeyCode; + CARD8 firstType; + CARD8 nTypes; + KeyCode firstKeySym; + CARD8 nKeySyms; + KeyCode firstKeyAct; + CARD8 nKeyActs; + KeyCode firstKeyBehavior; + CARD8 nKeyBehaviors; + KeyCode firstKeyExplicit; + CARD8 nKeyExplicit; + KeyCode firstModMapKey; + CARD8 nModMapKeys; + KeyCode firstVModMapKey; + CARD8 nVModMapKeys; + CARD16 virtualMods; + CARD16 pad1; +} xkbMapNotify; +#define sz_xkbMapNotify 32 + +typedef struct _xkbStateNotify { + BYTE type; + BYTE xkbType; + CARD16 sequenceNumber; + Time time; + CARD8 deviceID; + CARD8 mods; + CARD8 baseMods; + CARD8 latchedMods; + CARD8 lockedMods; + CARD8 group; + INT16 baseGroup; + INT16 latchedGroup; + CARD8 lockedGroup; + CARD8 compatState; + CARD8 grabMods; + CARD8 compatGrabMods; + CARD8 lookupMods; + CARD8 compatLookupMods; + CARD16 ptrBtnState; + CARD16 changed; + KeyCode keycode; + CARD8 eventType; + CARD8 requestMajor; + CARD8 requestMinor; +} xkbStateNotify; +#define sz_xkbStateNotify 32 + +typedef struct _xkbControlsNotify { + BYTE type; + BYTE xkbType; + CARD16 sequenceNumber; + Time time; + CARD8 deviceID; + CARD8 numGroups; + CARD16 pad1; + CARD32 changedControls; + CARD32 enabledControls; + CARD32 enabledControlChanges; + KeyCode keycode; + CARD8 eventType; + CARD8 requestMajor; + CARD8 requestMinor; + CARD32 pad2; +} xkbControlsNotify; +#define sz_xkbControlsNotify 32 + +typedef struct _xkbIndicatorNotify { + BYTE type; + BYTE xkbType; + CARD16 sequenceNumber; + Time time; + CARD8 deviceID; + CARD8 pad1; + CARD16 pad2; + CARD32 state; + CARD32 changed; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xkbIndicatorNotify; +#define sz_xkbIndicatorNotify 32 + +typedef struct _xkbNamesNotify { + BYTE type; + BYTE xkbType; + CARD16 sequenceNumber; + Time time; + CARD8 deviceID; + CARD8 pad1; + CARD16 changed; + CARD8 firstType; + CARD8 nTypes; + CARD8 firstLevelName; + CARD8 nLevelNames; + CARD8 pad2; + CARD8 nRadioGroups; + CARD8 nAliases; + CARD8 changedGroupNames; + CARD16 changedVirtualMods; + CARD8 firstKey; + CARD8 nKeys; + CARD32 changedIndicators; + CARD32 pad3; +} xkbNamesNotify; +#define sz_xkbNamesNotify 32 + +typedef struct _xkbCompatMapNotify { + BYTE type; + BYTE xkbType; + CARD16 sequenceNumber; + Time time; + CARD8 deviceID; + CARD8 changedGroups; + CARD16 firstSI; + CARD16 nSI; + CARD16 nTotalSI; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xkbCompatMapNotify; +#define sz_xkbCompatMapNotify 32 + +typedef struct _xkbBellNotify { + BYTE type; + BYTE xkbType; + CARD16 sequenceNumber; + Time time; + CARD8 deviceID; + CARD8 bellClass; + CARD8 bellID; + CARD8 percent; + CARD16 pitch; + CARD16 duration; + Atom name; + Window window; + BOOL eventOnly; + CARD8 pad1; + CARD16 pad2; + CARD32 pad3; +} xkbBellNotify; +#define sz_xkbBellNotify 32 + +typedef struct _xkbActionMessage { + BYTE type; + BYTE xkbType; + CARD16 sequenceNumber; + Time time; + CARD8 deviceID; + KeyCode keycode; + BOOL press; + BOOL keyEventFollows; + CARD8 mods; + CARD8 group; + CARD8 message[8]; + CARD16 pad1; + CARD32 pad2; + CARD32 pad3; +} xkbActionMessage; +#define sz_xkbActionMessage 32 + +typedef struct _xkbAccessXNotify { + BYTE type; + BYTE xkbType; + CARD16 sequenceNumber; + Time time; + CARD8 deviceID; + KeyCode keycode; + CARD16 detail; + CARD16 slowKeysDelay; + CARD16 debounceDelay; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xkbAccessXNotify; +#define sz_xkbAccessXNotify 32 + +typedef struct _xkbExtensionDeviceNotify { + BYTE type; + BYTE xkbType; + CARD16 sequenceNumber; + Time time; + CARD8 deviceID; + CARD8 pad1; + CARD16 reason; + CARD16 ledClass; + CARD16 ledID; + CARD32 ledsDefined; + CARD32 ledState; + CARD8 firstBtn; + CARD8 nBtns; + CARD16 supported; + CARD16 unsupported; + CARD16 pad3; +} xkbExtensionDeviceNotify; +#define sz_xkbExtensionDeviceNotify 32 + +typedef struct _xkbEvent { + union { + xkbAnyEvent any; + xkbNewKeyboardNotify new_kbd; + xkbMapNotify map; + xkbStateNotify state; + xkbControlsNotify ctrls; + xkbIndicatorNotify indicators; + xkbNamesNotify names; + xkbCompatMapNotify compat; + xkbBellNotify bell; + xkbActionMessage message; + xkbAccessXNotify accessx; + xkbExtensionDeviceNotify device; + } u; +} xkbEvent; +#define sz_xkbEvent 32 + +#undef Window +#undef Atom +#undef Time +#undef KeyCode +#undef KeySym + +#endif /* _XKBPROTO_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/XKBsrv.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/XKBsrv.h new file mode 100644 index 0000000000000000000000000000000000000000..deb71976f3e7eb39462690cf3559cb82c064de9e --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/XKBsrv.h @@ -0,0 +1,1184 @@ +/************************************************************ +Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc. + +Permission to use, copy, modify, and distribute this +software and its documentation for any purpose and without +fee is hereby granted, provided that the above copyright +notice appear in all copies and that both that copyright +notice and this permission notice appear in supporting +documentation, and that the name of Silicon Graphics not be +used in advertising or publicity pertaining to distribution +of the software without specific prior written permission. +Silicon Graphics makes no representation about the suitability +of this software for any purpose. It is provided "as is" +without any express or implied warranty. + +SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS +SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON +GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL +DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE +OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH +THE USE OR PERFORMANCE OF THIS SOFTWARE. + +********************************************************/ + +#ifndef _XKBSRV_H_ +#define _XKBSRV_H_ + +#ifdef XKB_IN_SERVER +#define XkbAllocClientMap SrvXkbAllocClientMap +#define XkbAllocServerMap SrvXkbAllocServerMap +#define XkbChangeTypesOfKey SrvXkbChangeTypesOfKey +#define XkbAddKeyType SrvXkbAddKeyType +#define XkbCopyKeyType SrvXkbCopyKeyType +#define XkbCopyKeyTypes SrvXkbCopyKeyTypes +#define XkbFreeClientMap SrvXkbFreeClientMap +#define XkbFreeServerMap SrvXkbFreeServerMap +#define XkbInitCanonicalKeyTypes SrvXkbInitCanonicalKeyTypes +#define XkbKeyTypesForCoreSymbols SrvXkbKeyTypesForCoreSymbols +#define XkbApplyCompatMapToKey SrvXkbApplyCompatMapToKey +#define XkbUpdateMapFromCore SrvXkbUpdateMapFromCore +#define XkbResizeKeyActions SrvXkbResizeKeyActions +#define XkbResizeKeySyms SrvXkbResizeKeySyms +#define XkbResizeKeyType SrvXkbResizeKeyType +#define XkbAllocCompatMap SrvXkbAllocCompatMap +#define XkbAllocControls SrvXkbAllocControls +#define XkbAllocIndicatorMaps SrvXkbAllocIndicatorMaps +#define XkbAllocKeyboard SrvXkbAllocKeyboard +#define XkbAllocNames SrvXkbAllocNames +#define XkbFreeCompatMap SrvXkbFreeCompatMap +#define XkbFreeControls SrvXkbFreeControls +#define XkbFreeIndicatorMaps SrvXkbFreeIndicatorMaps +#define XkbFreeKeyboard SrvXkbFreeKeyboard +#define XkbFreeNames SrvXkbFreeNames +#define XkbAddDeviceLedInfo SrvXkbAddDeviceLedInfo +#define XkbAllocDeviceInfo SrvXkbAllocDeviceInfo +#define XkbFreeDeviceInfo SrvXkbFreeDeviceInfo +#define XkbResizeDeviceButtonActions SrvXkbResizeDeviceButtonActions +#define XkbLatchModifiers SrvXkbLatchModifiers +#define XkbLatchGroup SrvXkbLatchGroup +#define XkbVirtualModsToReal SrvXkbVirtualModsToReal +#define XkbChangeKeycodeRange SrvXkbChangeKeycodeRange +#define XkbApplyVirtualModChanges SrvXkbApplyVirtualModChanges +#define XkbUpdateActionVirtualMods SrvXkbUpdateActionVirtualMods +#define XkbUpdateKeyTypeVirtualMods SrvXkbUpdateKeyTypeVirtualMods +#endif + +#include +#include +#include "inputstr.h" + +typedef struct _XkbInterest { + DeviceIntPtr dev; + ClientPtr client; + XID resource; + struct _XkbInterest * next; + CARD16 extDevNotifyMask; + CARD16 stateNotifyMask; + CARD16 namesNotifyMask; + CARD32 ctrlsNotifyMask; + CARD8 compatNotifyMask; + BOOL bellNotifyMask; + BOOL actionMessageMask; + CARD16 accessXNotifyMask; + CARD32 iStateNotifyMask; + CARD32 iMapNotifyMask; + CARD16 altSymsNotifyMask; + CARD32 autoCtrls; + CARD32 autoCtrlValues; +} XkbInterestRec,*XkbInterestPtr; + +typedef struct _XkbRadioGroup { + CARD8 flags; + CARD8 nMembers; + CARD8 dfltDown; + CARD8 currentDown; + CARD8 members[XkbRGMaxMembers]; +} XkbRadioGroupRec, *XkbRadioGroupPtr; + +typedef struct _XkbEventCause { + CARD8 kc; + CARD8 event; + CARD8 mjr; + CARD8 mnr; + ClientPtr client; +} XkbEventCauseRec,*XkbEventCausePtr; +#define XkbSetCauseKey(c,k,e) { (c)->kc= (k),(c)->event= (e),\ + (c)->mjr= (c)->mnr= 0; \ + (c)->client= NULL; } +#define XkbSetCauseReq(c,j,n,cl) { (c)->kc= (c)->event= 0,\ + (c)->mjr= (j),(c)->mnr= (n);\ + (c)->client= (cl); } +#define XkbSetCauseCoreReq(c,e,cl) XkbSetCauseReq(c,e,0,cl) +#define XkbSetCauseXkbReq(c,e,cl) XkbSetCauseReq(c,XkbReqCode,e,cl) +#define XkbSetCauseUnknown(c) XkbSetCauseKey(c,0,0) + +#define _OFF_TIMER 0 +#define _KRG_WARN_TIMER 1 +#define _KRG_TIMER 2 +#define _SK_TIMEOUT_TIMER 3 +#define _ALL_TIMEOUT_TIMER 4 + +#define _BEEP_NONE 0 +#define _BEEP_FEATURE_ON 1 +#define _BEEP_FEATURE_OFF 2 +#define _BEEP_FEATURE_CHANGE 3 +#define _BEEP_SLOW_WARN 4 +#define _BEEP_SLOW_PRESS 5 +#define _BEEP_SLOW_ACCEPT 6 +#define _BEEP_SLOW_REJECT 7 +#define _BEEP_SLOW_RELEASE 8 +#define _BEEP_STICKY_LATCH 9 +#define _BEEP_STICKY_LOCK 10 +#define _BEEP_STICKY_UNLOCK 11 +#define _BEEP_LED_ON 12 +#define _BEEP_LED_OFF 13 +#define _BEEP_LED_CHANGE 14 +#define _BEEP_BOUNCE_REJECT 15 + +typedef struct _XkbSrvInfo { + XkbStateRec prev_state; + XkbStateRec state; + XkbDescPtr desc; + + DeviceIntPtr device; + KbdCtrlProcPtr kbdProc; + + XkbRadioGroupPtr radioGroups; + CARD8 nRadioGroups; + CARD8 clearMods; + CARD8 setMods; + INT16 groupChange; + + CARD16 dfltPtrDelta; + + double mouseKeysCurve; + double mouseKeysCurveFactor; + INT16 mouseKeysDX; + INT16 mouseKeysDY; + CARD8 mouseKeysFlags; + Bool mouseKeysAccel; + CARD8 mouseKeysCounter; + + CARD8 lockedPtrButtons; + CARD8 shiftKeyCount; + KeyCode mouseKey; + KeyCode inactiveKey; + KeyCode slowKey; + KeyCode repeatKey; + CARD8 krgTimerActive; + CARD8 beepType; + CARD8 beepCount; + + CARD32 flags; + CARD32 lastPtrEventTime; + CARD32 lastShiftEventTime; + OsTimerPtr beepTimer; + OsTimerPtr mouseKeyTimer; + OsTimerPtr slowKeysTimer; + OsTimerPtr bounceKeysTimer; + OsTimerPtr repeatKeyTimer; + OsTimerPtr krgTimer; +} XkbSrvInfoRec, *XkbSrvInfoPtr; + +#define XkbSLI_IsDefault (1L<<0) +#define XkbSLI_HasOwnState (1L<<1) + +typedef struct _XkbSrvLedInfo { + CARD16 flags; + CARD16 class; + CARD16 id; + union { + KbdFeedbackPtr kf; + LedFeedbackPtr lf; + } fb; + + CARD32 physIndicators; + CARD32 autoState; + CARD32 explicitState; + CARD32 effectiveState; + + CARD32 mapsPresent; + CARD32 namesPresent; + XkbIndicatorMapPtr maps; + Atom * names; + + CARD32 usesBase; + CARD32 usesLatched; + CARD32 usesLocked; + CARD32 usesEffective; + CARD32 usesCompat; + CARD32 usesControls; + + CARD32 usedComponents; +} XkbSrvLedInfoRec, *XkbSrvLedInfoPtr; + +/* + * Settings for xkbClientFlags field (used by DIX) + * These flags _must_ not overlap with XkbPCF_* + */ +#define _XkbClientInitialized (1<<15) + +#define _XkbWantsDetectableAutoRepeat(c)\ + ((c)->xkbClientFlags&XkbPCF_DetectableAutoRepeatMask) + +/* + * Settings for flags field + */ +#define _XkbStateNotifyInProgress (1<<0) + +typedef struct +{ + ProcessInputProc processInputProc; + ProcessInputProc realInputProc; + DeviceUnwrapProc unwrapProc; +} xkbDeviceInfoRec, *xkbDeviceInfoPtr; + +#define WRAP_PROCESS_INPUT_PROC(device, oldprocs, proc, unwrapproc) \ + device->public.processInputProc = proc; \ + oldprocs->processInputProc = \ + oldprocs->realInputProc = device->public.realInputProc; \ + device->public.realInputProc = proc; \ + oldprocs->unwrapProc = device->unwrapProc; \ + device->unwrapProc = unwrapproc; + +#define COND_WRAP_PROCESS_INPUT_PROC(device, oldprocs, proc, unwrapproc) \ + if (device->public.processInputProc == device->public.realInputProc)\ + device->public.processInputProc = proc; \ + oldprocs->processInputProc = \ + oldprocs->realInputProc = device->public.realInputProc; \ + device->public.realInputProc = proc; \ + oldprocs->unwrapProc = device->unwrapProc; \ + device->unwrapProc = unwrapproc; + +#define UNWRAP_PROCESS_INPUT_PROC(device, oldprocs) \ + device->public.processInputProc = oldprocs->processInputProc; \ + device->public.realInputProc = oldprocs->realInputProc; \ + device->unwrapProc = oldprocs->unwrapProc; + +#define XKBDEVICEINFO(dev) ((xkbDeviceInfoPtr) (dev)->devPrivates[xkbDevicePrivateIndex].ptr) + +/***====================================================================***/ + + +/***====================================================================***/ + +#define XkbAX_KRGMask (XkbSlowKeysMask|XkbBounceKeysMask) +#define XkbAllFilteredEventsMask \ + (XkbAccessXKeysMask|XkbRepeatKeysMask|XkbMouseKeysAccelMask|XkbAX_KRGMask) + +/***====================================================================***/ + +extern int XkbReqCode; +extern int XkbEventBase; +extern int XkbKeyboardErrorCode; +extern int XkbDisableLockActions; +extern char * XkbBaseDirectory; +extern char * XkbBinDirectory; +extern char * XkbInitialMap; +extern int _XkbClientMajor; +extern int _XkbClientMinor; +extern unsigned int XkbXIUnsupported; + +extern char * XkbModelUsed,*XkbLayoutUsed,*XkbVariantUsed,*XkbOptionsUsed; +extern Bool noXkbExtension; +extern Bool XkbWantRulesProp; + +extern pointer XkbLastRepeatEvent; + +extern CARD32 xkbDebugFlags; +extern CARD32 xkbDebugCtrls; + +#define _XkbAlloc(s) xalloc((s)) +#define _XkbCalloc(n,s) Xcalloc((n)*(s)) +#define _XkbRealloc(o,s) Xrealloc((o),(s)) +#define _XkbTypedAlloc(t) ((t *)xalloc(sizeof(t))) +#define _XkbTypedCalloc(n,t) ((t *)Xcalloc((n)*sizeof(t))) +#define _XkbTypedRealloc(o,n,t) \ + ((o)?(t *)Xrealloc((o),(n)*sizeof(t)):_XkbTypedCalloc(n,t)) +#define _XkbClearElems(a,f,l,t) bzero(&(a)[f],((l)-(f)+1)*sizeof(t)) +#define _XkbFree(p) Xfree(p) + +#define _XkbLibError(c,l,d) \ + { _XkbErrCode= (c); _XkbErrLocation= (l); _XkbErrData= (d); } +#define _XkbErrCode2(a,b) ((XID)((((unsigned int)(a))<<24)|((b)&0xffffff))) +#define _XkbErrCode3(a,b,c) _XkbErrCode2(a,(((unsigned int)(b))<<16)|(c)) +#define _XkbErrCode4(a,b,c,d) _XkbErrCode3(a,b,((((unsigned int)(c))<<8)|(d))) + +extern int DeviceKeyPress,DeviceKeyRelease; +extern int DeviceButtonPress,DeviceButtonRelease; + +#ifdef XINPUT +#define _XkbIsPressEvent(t) (((t)==KeyPress)||((t)==DeviceKeyPress)) +#define _XkbIsReleaseEvent(t) (((t)==KeyRelease)||((t)==DeviceKeyRelease)) +#else +#define _XkbIsPressEvent(t) ((t)==KeyPress) +#define _XkbIsReleaseEvent(t) ((t)==KeyRelease) +#endif + +#define _XkbCoreKeycodeInRange(c,k) (((k)>=(c)->curKeySyms.minKeyCode)&&\ + ((k)<=(c)->curKeySyms.maxKeyCode)) +#define _XkbCoreNumKeys(c) ((c)->curKeySyms.maxKeyCode-\ + (c)->curKeySyms.minKeyCode+1) + +#define XConvertCase(s,l,u) XkbConvertCase(s,l,u) +#undef IsKeypadKey +#define IsKeypadKey(s) XkbKSIsKeypad(s) + +typedef int Status; +typedef pointer XPointer; +typedef struct _XDisplay Display; + +#ifndef True +#define True 1 +#define False 0 +#endif + +#ifndef PATH_MAX +#ifdef MAXPATHLEN +#define PATH_MAX MAXPATHLEN +#else +#define PATH_MAX 1024 +#endif +#endif + +_XFUNCPROTOBEGIN + +extern void XkbUseMsg( + void +); + +extern int XkbProcessArguments( + int /* argc */, + char ** /* argv */, + int /* i */ +); + +extern void XkbSetExtension(DeviceIntPtr device, ProcessInputProc proc); + +extern void XkbFreeCompatMap( + XkbDescPtr /* xkb */, + unsigned int /* which */, + Bool /* freeMap */ +); + +extern void XkbFreeNames( + XkbDescPtr /* xkb */, + unsigned int /* which */, + Bool /* freeMap */ +); + +extern DeviceIntPtr _XkbLookupAnyDevice( + int /* id */, + int * /* why_rtrn */ +); + +extern DeviceIntPtr _XkbLookupKeyboard( + int /* id */, + int * /* why_rtrn */ +); + +extern DeviceIntPtr _XkbLookupBellDevice( + int /* id */, + int * /* why_rtrn */ +); + +extern DeviceIntPtr _XkbLookupLedDevice( + int /* id */, + int * /* why_rtrn */ +); + +extern DeviceIntPtr _XkbLookupButtonDevice( + int /* id */, + int * /* why_rtrn */ +); + +extern XkbDescPtr XkbAllocKeyboard( + void +); + +extern Status XkbAllocClientMap( + XkbDescPtr /* xkb */, + unsigned int /* which */, + unsigned int /* nTypes */ +); + +extern Status XkbAllocServerMap( + XkbDescPtr /* xkb */, + unsigned int /* which */, + unsigned int /* nNewActions */ +); + +extern void XkbFreeClientMap( + XkbDescPtr /* xkb */, + unsigned int /* what */, + Bool /* freeMap */ +); + +extern void XkbFreeServerMap( + XkbDescPtr /* xkb */, + unsigned int /* what */, + Bool /* freeMap */ +); + +extern Status XkbAllocIndicatorMaps( + XkbDescPtr /* xkb */ +); + +extern Status XkbAllocCompatMap( + XkbDescPtr /* xkb */, + unsigned int /* which */, + unsigned int /* nInterpret */ +); + +extern Status XkbAllocNames( + XkbDescPtr /* xkb */, + unsigned int /* which */, + int /* nTotalRG */, + int /* nTotalAliases */ +); + +extern Status XkbAllocControls( + XkbDescPtr /* xkb */, + unsigned int /* which*/ +); + +extern Status XkbCopyKeyType( + XkbKeyTypePtr /* from */, + XkbKeyTypePtr /* into */ +); + +extern Status XkbCopyKeyTypes( + XkbKeyTypePtr /* from */, + XkbKeyTypePtr /* into */, + int /* num_types */ +); + +extern Status XkbResizeKeyType( + XkbDescPtr /* xkb */, + int /* type_ndx */, + int /* map_count */, + Bool /* want_preserve */, + int /* new_num_lvls */ +); + +extern void XkbFreeKeyboard( + XkbDescPtr /* xkb */, + unsigned int /* which */, + Bool /* freeDesc */ +); + +extern void XkbSetActionKeyMods( + XkbDescPtr /* xkb */, + XkbAction * /* act */, + unsigned int /* mods */ +); + +extern Bool XkbCheckActionVMods( + XkbDescPtr /* xkb */, + XkbAction * /* act */, + unsigned int /* changed */ +); + +extern Bool XkbApplyVModChanges( + XkbSrvInfoPtr /* xkbi */, + unsigned int /* changed */, + XkbChangesPtr /* pChanges */, + unsigned int * /* needChecksRtrn */, + XkbEventCausePtr /* cause */ +); + +extern void XkbApplyVModChangesToAllDevices( + DeviceIntPtr /* dev */, + XkbDescPtr /* xkb */, + unsigned int /* changed */, + XkbEventCausePtr /* cause */ +); + +extern unsigned int XkbMaskForVMask( + XkbDescPtr /* xkb */, + unsigned int /* vmask */ +); + +extern Bool XkbVirtualModsToReal( + XkbDescPtr /* xkb */, + unsigned int /* virtua_mask */, + unsigned int * /* mask_rtrn */ +); + +extern unsigned int XkbAdjustGroup( + int /* group */, + XkbControlsPtr /* ctrls */ +); + +extern KeySym *XkbResizeKeySyms( + XkbDescPtr /* xkb */, + int /* key */, + int /* needed */ +); + +extern XkbAction *XkbResizeKeyActions( + XkbDescPtr /* xkb */, + int /* key */, + int /* needed */ +); + +extern void XkbUpdateKeyTypesFromCore( + DeviceIntPtr /* pXDev */, + KeyCode /* first */, + CARD8 /* num */, + XkbChangesPtr /* pChanges */ +); + +extern void XkbUpdateDescActions( + XkbDescPtr /* xkb */, + KeyCode /* first */, + CARD8 /* num */, + XkbChangesPtr /* changes */ +); + +extern void XkbUpdateActions( + DeviceIntPtr /* pXDev */, + KeyCode /* first */, + CARD8 /* num */, + XkbChangesPtr /* pChanges */, + unsigned int * /* needChecksRtrn */, + XkbEventCausePtr /* cause */ +); + +extern void XkbUpdateCoreDescription( + DeviceIntPtr /* keybd */, + Bool /* resize */ +); + +extern void XkbApplyMappingChange( + DeviceIntPtr /* pXDev */, + CARD8 /* request */, + KeyCode /* firstKey */, + CARD8 /* num */, + ClientPtr /* client */ +); + +extern void XkbSetIndicators( + DeviceIntPtr /* pXDev */, + CARD32 /* affect */, + CARD32 /* values */, + XkbEventCausePtr /* cause */ +); + +extern void XkbUpdateIndicators( + DeviceIntPtr /* keybd */, + CARD32 /* changed */, + Bool /* check_edevs */, + XkbChangesPtr /* pChanges */, + XkbEventCausePtr /* cause */ +); + +extern XkbSrvLedInfoPtr XkbAllocSrvLedInfo( + DeviceIntPtr /* dev */, + KbdFeedbackPtr /* kf */, + LedFeedbackPtr /* lf */, + unsigned int /* needed_parts */ +); + +extern XkbSrvLedInfoPtr XkbFindSrvLedInfo( + DeviceIntPtr /* dev */, + unsigned int /* class */, + unsigned int /* id */, + unsigned int /* needed_parts */ +); + +extern void XkbApplyLedNameChanges( + DeviceIntPtr /* dev */, + XkbSrvLedInfoPtr /* sli */, + unsigned int /* changed_names */, + xkbExtensionDeviceNotify * /* ed */, + XkbChangesPtr /* changes */, + XkbEventCausePtr /* cause */ +); + +extern void XkbApplyLedMapChanges( + DeviceIntPtr /* dev */, + XkbSrvLedInfoPtr /* sli */, + unsigned int /* changed_maps */, + xkbExtensionDeviceNotify * /* ed */, + XkbChangesPtr /* changes */, + XkbEventCausePtr /* cause */ +); + +extern void XkbApplyLedStateChanges( + DeviceIntPtr /* dev */, + XkbSrvLedInfoPtr /* sli */, + unsigned int /* changed_leds */, + xkbExtensionDeviceNotify * /* ed */, + XkbChangesPtr /* changes */, + XkbEventCausePtr /* cause */ +); + +extern void XkbUpdateLedAutoState( + DeviceIntPtr /* dev */, + XkbSrvLedInfoPtr /* sli */, + unsigned int /* maps_to_check */, + xkbExtensionDeviceNotify * /* ed */, + XkbChangesPtr /* changes */, + XkbEventCausePtr /* cause */ +); + +extern void XkbFlushLedEvents( + DeviceIntPtr /* dev */, + DeviceIntPtr /* kbd */, + XkbSrvLedInfoPtr /* sli */, + xkbExtensionDeviceNotify * /* ed */, + XkbChangesPtr /* changes */, + XkbEventCausePtr /* cause */ +); + +extern void XkbUpdateAllDeviceIndicators( + XkbChangesPtr /* changes */, + XkbEventCausePtr /* cause */ +); + +extern unsigned int XkbIndicatorsToUpdate( + DeviceIntPtr /* dev */, + unsigned long /* state_changes */, + Bool /* enabled_ctrl_changes */ +); + +extern void XkbComputeDerivedState( + XkbSrvInfoPtr /* xkbi */ +); + +extern void XkbCheckSecondaryEffects( + XkbSrvInfoPtr /* xkbi */, + unsigned int /* which */, + XkbChangesPtr /* changes */, + XkbEventCausePtr /* cause */ +); + +extern void XkbCheckIndicatorMaps( + DeviceIntPtr /* dev */, + XkbSrvLedInfoPtr /* sli */, + unsigned int /* which */ +); + +extern unsigned int XkbStateChangedFlags( + XkbStatePtr /* old */, + XkbStatePtr /* new */ +); + +extern void XkbSendStateNotify( + DeviceIntPtr /* kbd */, + xkbStateNotify * /* pSN */ +); + +extern void XkbSendMapNotify( + DeviceIntPtr /* kbd */, + xkbMapNotify * /* ev */ +); + +extern int XkbComputeControlsNotify( + DeviceIntPtr /* kbd */, + XkbControlsPtr /* old */, + XkbControlsPtr /* new */, + xkbControlsNotify * /* pCN */, + Bool /* forceCtrlProc */ +); + +extern void XkbSendControlsNotify( + DeviceIntPtr /* kbd */, + xkbControlsNotify * /* ev */ +); + +extern void XkbSendCompatMapNotify( + DeviceIntPtr /* kbd */, + xkbCompatMapNotify * /* ev */ +); + +extern void XkbSendIndicatorNotify( + DeviceIntPtr /* kbd */, + int /* xkbType */, + xkbIndicatorNotify * /* ev */ +); + +extern void XkbHandleBell( + BOOL /* force */, + BOOL /* eventOnly */, + DeviceIntPtr /* kbd */, + CARD8 /* percent */, + pointer /* ctrl */, + CARD8 /* class */, + Atom /* name */, + WindowPtr /* pWin */, + ClientPtr /* pClient */ +); + +extern void XkbSendAccessXNotify( + DeviceIntPtr /* kbd */, + xkbAccessXNotify * /* pEv */ +); + +extern void XkbSendNamesNotify( + DeviceIntPtr /* kbd */, + xkbNamesNotify * /* ev */ +); + +extern void XkbSendCompatNotify( + DeviceIntPtr /* kbd */, + xkbCompatMapNotify * /* ev */ +); + +extern void XkbSendActionMessage( + DeviceIntPtr /* kbd */, + xkbActionMessage * /* ev */ +); + +extern void XkbSendExtensionDeviceNotify( + DeviceIntPtr /* kbd */, + ClientPtr /* client */, + xkbExtensionDeviceNotify * /* ev */ +); + +extern void XkbSendNotification( + DeviceIntPtr /* kbd */, + XkbChangesPtr /* pChanges */, + XkbEventCausePtr /* cause */ +); + +extern void XkbProcessKeyboardEvent( + struct _xEvent * /* xE */, + DeviceIntPtr /* keybd */, + int /* count */ +); + +extern void XkbProcessOtherEvent( + struct _xEvent * /* xE */, + DeviceIntPtr /* keybd */, + int /* count */ +); + +extern void XkbHandleActions( + DeviceIntPtr /* dev */, + DeviceIntPtr /* kbd */, + struct _xEvent * /* xE */, + int /* count */ +); + +extern Bool XkbEnableDisableControls( + XkbSrvInfoPtr /* xkbi */, + unsigned long /* change */, + unsigned long /* newValues */, + XkbChangesPtr /* changes */, + XkbEventCausePtr /* cause */ +); + +extern void AccessXInit( + DeviceIntPtr /* dev */ +); + +extern Bool AccessXFilterPressEvent( + register struct _xEvent * /* xE */, + register DeviceIntPtr /* keybd */, + int /* count */ +); + +extern Bool AccessXFilterReleaseEvent( + register struct _xEvent * /* xE */, + register DeviceIntPtr /* keybd */, + int /* count */ +); + +extern void AccessXCancelRepeatKey( + XkbSrvInfoPtr /* xkbi */, + KeyCode /* key */ +); + +extern void AccessXComputeCurveFactor( + XkbSrvInfoPtr /* xkbi */, + XkbControlsPtr /* ctrls */ +); + +extern XkbDeviceLedInfoPtr XkbAddDeviceLedInfo( + XkbDeviceInfoPtr /* devi */, + unsigned int /* ledClass */, + unsigned int /* ledId */ +); + +extern XkbDeviceInfoPtr XkbAllocDeviceInfo( + unsigned int /* deviceSpec */, + unsigned int /* nButtons */, + unsigned int /* szLeds */ +); + +extern void XkbFreeDeviceInfo( + XkbDeviceInfoPtr /* devi */, + unsigned int /* which */, + Bool /* freeDevI */ +); + +extern Status XkbResizeDeviceButtonActions( + XkbDeviceInfoPtr /* devi */, + unsigned int /* newTotal */ +); + +extern XkbInterestPtr XkbFindClientResource( + DevicePtr /* inDev */, + ClientPtr /* client */ +); + +extern XkbInterestPtr XkbAddClientResource( + DevicePtr /* inDev */, + ClientPtr /* client */, + XID /* id */ +); + +extern int XkbRemoveClient( + DevicePtr /* inDev */, + ClientPtr /* client */ +); + +extern int XkbRemoveResourceClient( + DevicePtr /* inDev */, + XID /* id */ +); + +extern int XkbDDXInitDevice( + DeviceIntPtr /* dev */ +); + +extern int XkbDDXAccessXBeep( + DeviceIntPtr /* dev */, + unsigned int /* what */, + unsigned int /* which */ +); + +extern void XkbDDXKeyClick( + DeviceIntPtr /* dev */, + int /* keycode */, + int /* synthetic */ +); + +extern int XkbDDXUsesSoftRepeat( + DeviceIntPtr /* dev */ +); + +extern void XkbDDXKeybdCtrlProc( + DeviceIntPtr /* dev */, + KeybdCtrl * /* ctrl */ +); + +extern void XkbDDXChangeControls( + DeviceIntPtr /* dev */, + XkbControlsPtr /* old */, + XkbControlsPtr /* new */ +); + +extern void XkbDDXUpdateIndicators( + DeviceIntPtr /* keybd */, + CARD32 /* newState */ +); + +extern void XkbDDXUpdateDeviceIndicators( + DeviceIntPtr /* dev */, + XkbSrvLedInfoPtr /* sli */, + CARD32 /* newState */ +); + +extern void XkbDDXFakePointerButton( + int /* event */, + int /* button */ +); + +extern void XkbDDXFakePointerMotion( + unsigned int /* flags */, + int /* x */, + int /* y */ +); + +extern void XkbDDXFakeDeviceButton( + DeviceIntPtr /* dev */, + Bool /* press */, + int /* button */ +); + +extern int XkbDDXTerminateServer( + DeviceIntPtr /* dev */, + KeyCode /* key */, + XkbAction * /* act */ +); + +extern int XkbDDXSwitchScreen( + DeviceIntPtr /* dev */, + KeyCode /* key */, + XkbAction * /* act */ +); + +extern int XkbDDXPrivate( + DeviceIntPtr /* dev */, + KeyCode /* key */, + XkbAction * /* act */ +); + +extern void XkbDisableComputedAutoRepeats( + DeviceIntPtr /* pXDev */, + unsigned int /* key */ +); + +extern void XkbSetRepeatKeys( + DeviceIntPtr /* pXDev */, + int /* key */, + int /* onoff */ +); + +extern int XkbLatchModifiers( + DeviceIntPtr /* pXDev */, + CARD8 /* mask */, + CARD8 /* latches */ +); + +extern int XkbLatchGroup( + DeviceIntPtr /* pXDev */, + int /* group */ +); + +extern void XkbClearAllLatchesAndLocks( + DeviceIntPtr /* dev */, + XkbSrvInfoPtr /* xkbi */, + Bool /* genEv */, + XkbEventCausePtr /* cause */ +); + +extern void XkbSetRulesDflts( + char * /* rulesFile */, + char * /* model */, + char * /* layout */, + char * /* variant */, + char * /* options */ +); + +extern void XkbInitDevice( + DeviceIntPtr /* pXDev */ +); + +extern Bool XkbInitKeyboardDeviceStruct( + DeviceIntPtr /* pXDev */, + XkbComponentNamesPtr /* pNames */, + KeySymsPtr /* pSyms */, + CARD8 /* pMods */[], + BellProcPtr /* bellProc */, + KbdCtrlProcPtr /* ctrlProc */ +); + +extern int SProcXkbDispatch( + ClientPtr /* client */ +); + +extern XkbGeometryPtr XkbLookupNamedGeometry( + DeviceIntPtr /* dev */, + Atom /* name */, + Bool * /* shouldFree */ +); + +extern char * _XkbDupString( + char * /* str */ +); + +extern void XkbConvertCase( + KeySym /* sym */, + KeySym * /* lower */, + KeySym * /* upper */ +); + +extern Status XkbChangeKeycodeRange( + XkbDescPtr /* xkb */, + int /* minKC */, + int /* maxKC */, + XkbChangesPtr /* changes */ +); + +extern int XkbFinishDeviceInit( + DeviceIntPtr /* pXDev */ +); + +extern void XkbFreeSrvLedInfo( + XkbSrvLedInfoPtr /* sli */ +); + +extern void XkbFreeInfo( + XkbSrvInfoPtr /* xkbi */ +); + +extern Status XkbChangeTypesOfKey( + XkbDescPtr /* xkb */, + int /* key */, + int /* nGroups */, + unsigned int /* groups */, + int * /* newTypesIn */, + XkbMapChangesPtr /* changes */ +); + +extern XkbKeyTypePtr XkbAddKeyType( + XkbDescPtr /* xkb */, + Atom /* name */, + int /* map_count */, + Bool /* want_preserve */, + int /* num_lvls */ +); + +extern Status XkbInitCanonicalKeyTypes( + XkbDescPtr /* xkb */, + unsigned int /* which */, + int /* keypadVMod */ +); + +extern int XkbKeyTypesForCoreSymbols( + XkbDescPtr /* xkb */, + int /* map_width */, + KeySym * /* core_syms */, + unsigned int /* protected */, + int * /* types_inout */, + KeySym * /* xkb_syms_rtrn */ +); + +extern Bool XkbApplyCompatMapToKey( + XkbDescPtr /* xkb */, + KeyCode /* key */, + XkbChangesPtr /* changes */ +); + +extern Bool XkbUpdateMapFromCore( + XkbDescPtr /* xkb */, + KeyCode /* first_key */, + int /* num_keys */, + int /* map_width */, + KeySym * /* core_keysyms */, + XkbChangesPtr /* changes */ +); + +extern void XkbFreeControls( + XkbDescPtr /* xkb */, + unsigned int /* which */, + Bool /* freeMap */ +); + +extern void XkbFreeIndicatorMaps( + XkbDescPtr /* xkb */ +); + +extern Bool XkbApplyVirtualModChanges( + XkbDescPtr /* xkb */, + unsigned int /* changed */, + XkbChangesPtr /* changes */ +); + +extern Bool XkbUpdateActionVirtualMods( + XkbDescPtr /* xkb */, + XkbAction * /* act */, + unsigned int /* changed */ +); + +extern void XkbUpdateKeyTypeVirtualMods( + XkbDescPtr /* xkb */, + XkbKeyTypePtr /* type */, + unsigned int /* changed */, + XkbChangesPtr /* changes */ +); + +extern void XkbSendNewKeyboardNotify( + DeviceIntPtr /* kbd */, + xkbNewKeyboardNotify * /* pNKN */ +); + +#ifdef XKBSRV_NEED_FILE_FUNCS + +#include +#include +#include + +#define _XkbListKeymaps 0 +#define _XkbListKeycodes 1 +#define _XkbListTypes 2 +#define _XkbListCompat 3 +#define _XkbListSymbols 4 +#define _XkbListGeometry 5 +#define _XkbListNumComponents 6 + +typedef struct _XkbSrvListInfo { + int szPool; + int nPool; + char * pool; + + int maxRtrn; + int nTotal; + + char * pattern[_XkbListNumComponents]; + int nFound[_XkbListNumComponents]; +} XkbSrvListInfoRec,*XkbSrvListInfoPtr; + +char * +XkbGetRulesDflts( + XkbRF_VarDefsPtr /* defs */ +); + +extern void XkbSetRulesUsed( + XkbRF_VarDefsPtr /* defs */ +); + + +extern Status XkbDDXList( + DeviceIntPtr /* dev */, + XkbSrvListInfoPtr /* listing */, + ClientPtr /* client */ +); + +extern unsigned int XkbDDXLoadKeymapByNames( + DeviceIntPtr /* keybd */, + XkbComponentNamesPtr /* names */, + unsigned int /* want */, + unsigned int /* need */, + XkbFileInfoPtr /* finfoRtrn */, + char * /* keymapNameRtrn */, + int /* keymapNameRtrnLen */ +); + +extern Bool XkbDDXNamesFromRules( + DeviceIntPtr /* keybd */, + char * /* rules */, + XkbRF_VarDefsPtr /* defs */, + XkbComponentNamesPtr /* names */ +); + +extern FILE *XkbDDXOpenConfigFile( + char * /* mapName */, + char * /* fileNameRtrn */, + int /* fileNameRtrnLen */ +); + +extern Bool XkbDDXApplyConfig( + XPointer /* cfg_in */, + XkbSrvInfoPtr /* xkbi */ +); + +extern XPointer XkbDDXPreloadConfig( + char ** /* rulesFileRtrn */, + XkbRF_VarDefsPtr /* defs */, + XkbComponentNamesPtr /* names */, + DeviceIntPtr /* dev */ +); + +extern int _XkbStrCaseCmp( + char * /* str1 */, + char * /* str2 */ +); + +#endif /* XKBSRV_NEED_FILE_FUNCS */ + + +_XFUNCPROTOEND + +#define XkbAtomGetString(d,s) NameForAtom(s) + +#endif /* _XKBSRV_H_ */ + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/XKBstr.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/XKBstr.h new file mode 100644 index 0000000000000000000000000000000000000000..eaefae8220de72a391a05f41980fac34b9194547 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/XKBstr.h @@ -0,0 +1,643 @@ +/************************************************************ +Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc. + +Permission to use, copy, modify, and distribute this +software and its documentation for any purpose and without +fee is hereby granted, provided that the above copyright +notice appear in all copies and that both that copyright +notice and this permission notice appear in supporting +documentation, and that the name of Silicon Graphics not be +used in advertising or publicity pertaining to distribution +of the software without specific prior written permission. +Silicon Graphics makes no representation about the suitability +of this software for any purpose. It is provided "as is" +without any express or implied warranty. + +SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS +SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON +GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL +DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE +OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH +THE USE OR PERFORMANCE OF THIS SOFTWARE. + +********************************************************/ + +#ifndef _XKBSTR_H_ +#define _XKBSTR_H_ + +#include +#include + +#define XkbCharToInt(v) ((v)&0x80?(int)((v)|(~0xff)):(int)((v)&0x7f)) +#define XkbIntTo2Chars(i,h,l) (((h)=((i>>8)&0xff)),((l)=((i)&0xff))) +#define Xkb2CharsToInt(h,l) ((short)(((h)<<8)|(l))) + +/* + * The Xkb structs are full of implicit padding to properly align members. + * We can't clean that up without breaking ABI, so tell clang not to bother + * complaining about it. + */ +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wpadded" +#endif + + /* + * Common data structures and access macros + */ + +typedef struct _XkbStateRec { + unsigned char group; + unsigned char locked_group; + unsigned short base_group; + unsigned short latched_group; + unsigned char mods; + unsigned char base_mods; + unsigned char latched_mods; + unsigned char locked_mods; + unsigned char compat_state; + unsigned char grab_mods; + unsigned char compat_grab_mods; + unsigned char lookup_mods; + unsigned char compat_lookup_mods; + unsigned short ptr_buttons; +} XkbStateRec,*XkbStatePtr; +#define XkbModLocks(s) ((s)->locked_mods) +#define XkbStateMods(s) ((s)->base_mods|(s)->latched_mods|XkbModLocks(s)) +#define XkbGroupLock(s) ((s)->locked_group) +#define XkbStateGroup(s) ((s)->base_group+(s)->latched_group+XkbGroupLock(s)) +#define XkbStateFieldFromRec(s) XkbBuildCoreState((s)->lookup_mods,(s)->group) +#define XkbGrabStateFromRec(s) XkbBuildCoreState((s)->grab_mods,(s)->group) + +typedef struct _XkbMods { + unsigned char mask; /* effective mods */ + unsigned char real_mods; + unsigned short vmods; +} XkbModsRec,*XkbModsPtr; + +typedef struct _XkbKTMapEntry { + Bool active; + unsigned char level; + XkbModsRec mods; +} XkbKTMapEntryRec,*XkbKTMapEntryPtr; + +typedef struct _XkbKeyType { + XkbModsRec mods; + unsigned char num_levels; + unsigned char map_count; + /* map is an array of map_count XkbKTMapEntryRec structs */ + XkbKTMapEntryPtr map; + /* preserve is an array of map_count XkbModsRec structs */ + XkbModsPtr preserve; + Atom name; + /* level_names is an array of num_levels Atoms */ + Atom * level_names; +} XkbKeyTypeRec, *XkbKeyTypePtr; + +#define XkbNumGroups(g) ((g)&0x0f) +#define XkbOutOfRangeGroupInfo(g) ((g)&0xf0) +#define XkbOutOfRangeGroupAction(g) ((g)&0xc0) +#define XkbOutOfRangeGroupNumber(g) (((g)&0x30)>>4) +#define XkbSetGroupInfo(g,w,n) (((w)&0xc0)|(((n)&3)<<4)|((g)&0x0f)) +#define XkbSetNumGroups(g,n) (((g)&0xf0)|((n)&0x0f)) + + /* + * Structures and access macros used primarily by the server + */ + +typedef struct _XkbBehavior { + unsigned char type; + unsigned char data; +} XkbBehavior; + +#define XkbAnyActionDataSize 7 +typedef struct _XkbAnyAction { + unsigned char type; + unsigned char data[XkbAnyActionDataSize]; +} XkbAnyAction; + +typedef struct _XkbModAction { + unsigned char type; + unsigned char flags; + unsigned char mask; + unsigned char real_mods; + unsigned char vmods1; + unsigned char vmods2; +} XkbModAction; +#define XkbModActionVMods(a) \ + ((short)(((a)->vmods1<<8)|((a)->vmods2))) +#define XkbSetModActionVMods(a,v) \ + (((a)->vmods1=(((v)>>8)&0xff)),(a)->vmods2=((v)&0xff)) + +typedef struct _XkbGroupAction { + unsigned char type; + unsigned char flags; + char group_XXX; +} XkbGroupAction; +#define XkbSAGroup(a) (XkbCharToInt((a)->group_XXX)) +#define XkbSASetGroup(a,g) ((a)->group_XXX=(g)) + +typedef struct _XkbISOAction { + unsigned char type; + unsigned char flags; + unsigned char mask; + unsigned char real_mods; + char group_XXX; + unsigned char affect; + unsigned char vmods1; + unsigned char vmods2; +} XkbISOAction; + +typedef struct _XkbPtrAction { + unsigned char type; + unsigned char flags; + unsigned char high_XXX; + unsigned char low_XXX; + unsigned char high_YYY; + unsigned char low_YYY; +} XkbPtrAction; +#define XkbPtrActionX(a) (Xkb2CharsToInt((a)->high_XXX,(a)->low_XXX)) +#define XkbPtrActionY(a) (Xkb2CharsToInt((a)->high_YYY,(a)->low_YYY)) +#define XkbSetPtrActionX(a,x) (XkbIntTo2Chars(x,(a)->high_XXX,(a)->low_XXX)) +#define XkbSetPtrActionY(a,y) (XkbIntTo2Chars(y,(a)->high_YYY,(a)->low_YYY)) + +typedef struct _XkbPtrBtnAction { + unsigned char type; + unsigned char flags; + unsigned char count; + unsigned char button; +} XkbPtrBtnAction; + +typedef struct _XkbPtrDfltAction { + unsigned char type; + unsigned char flags; + unsigned char affect; + char valueXXX; +} XkbPtrDfltAction; +#define XkbSAPtrDfltValue(a) (XkbCharToInt((a)->valueXXX)) +#define XkbSASetPtrDfltValue(a,c) ((a)->valueXXX= ((c)&0xff)) + +typedef struct _XkbSwitchScreenAction { + unsigned char type; + unsigned char flags; + char screenXXX; +} XkbSwitchScreenAction; +#define XkbSAScreen(a) (XkbCharToInt((a)->screenXXX)) +#define XkbSASetScreen(a,s) ((a)->screenXXX= ((s)&0xff)) + +typedef struct _XkbCtrlsAction { + unsigned char type; + unsigned char flags; + unsigned char ctrls3; + unsigned char ctrls2; + unsigned char ctrls1; + unsigned char ctrls0; +} XkbCtrlsAction; +#define XkbActionSetCtrls(a,c) (((a)->ctrls3=(((c)>>24)&0xff)),\ + ((a)->ctrls2=(((c)>>16)&0xff)),\ + ((a)->ctrls1=(((c)>>8)&0xff)),\ + ((a)->ctrls0=((c)&0xff))) +#define XkbActionCtrls(a) ((((unsigned int)(a)->ctrls3)<<24)|\ + (((unsigned int)(a)->ctrls2)<<16)|\ + (((unsigned int)(a)->ctrls1)<<8)|\ + ((unsigned int)((a)->ctrls0))) + +typedef struct _XkbMessageAction { + unsigned char type; + unsigned char flags; + unsigned char message[6]; +} XkbMessageAction; + +typedef struct _XkbRedirectKeyAction { + unsigned char type; + unsigned char new_key; + unsigned char mods_mask; + unsigned char mods; + unsigned char vmods_mask0; + unsigned char vmods_mask1; + unsigned char vmods0; + unsigned char vmods1; +} XkbRedirectKeyAction; + +#define XkbSARedirectVMods(a) ((((unsigned int)(a)->vmods1)<<8)|\ + ((unsigned int)(a)->vmods0)) +#define XkbSARedirectSetVMods(a,m) (((a)->vmods1=(((m)>>8)&0xff)),\ + ((a)->vmods0=((m)&0xff))) +#define XkbSARedirectVModsMask(a) ((((unsigned int)(a)->vmods_mask1)<<8)|\ + ((unsigned int)(a)->vmods_mask0)) +#define XkbSARedirectSetVModsMask(a,m) (((a)->vmods_mask1=(((m)>>8)&0xff)),\ + ((a)->vmods_mask0=((m)&0xff))) + +typedef struct _XkbDeviceBtnAction { + unsigned char type; + unsigned char flags; + unsigned char count; + unsigned char button; + unsigned char device; +} XkbDeviceBtnAction; + +typedef struct _XkbDeviceValuatorAction { + unsigned char type; + unsigned char device; + unsigned char v1_what; + unsigned char v1_ndx; + unsigned char v1_value; + unsigned char v2_what; + unsigned char v2_ndx; + unsigned char v2_value; +} XkbDeviceValuatorAction; + +typedef union _XkbAction { + XkbAnyAction any; + XkbModAction mods; + XkbGroupAction group; + XkbISOAction iso; + XkbPtrAction ptr; + XkbPtrBtnAction btn; + XkbPtrDfltAction dflt; + XkbSwitchScreenAction screen; + XkbCtrlsAction ctrls; + XkbMessageAction msg; + XkbRedirectKeyAction redirect; + XkbDeviceBtnAction devbtn; + XkbDeviceValuatorAction devval; + unsigned char type; +} XkbAction; + +typedef struct _XkbControls { + unsigned char mk_dflt_btn; + unsigned char num_groups; + unsigned char groups_wrap; + XkbModsRec internal; + XkbModsRec ignore_lock; + unsigned int enabled_ctrls; + unsigned short repeat_delay; + unsigned short repeat_interval; + unsigned short slow_keys_delay; + unsigned short debounce_delay; + unsigned short mk_delay; + unsigned short mk_interval; + unsigned short mk_time_to_max; + unsigned short mk_max_speed; + short mk_curve; + unsigned short ax_options; + unsigned short ax_timeout; + unsigned short axt_opts_mask; + unsigned short axt_opts_values; + unsigned int axt_ctrls_mask; + unsigned int axt_ctrls_values; + unsigned char per_key_repeat[XkbPerKeyBitArraySize]; +} XkbControlsRec, *XkbControlsPtr; + +#define XkbAX_AnyFeedback(c) ((c)->enabled_ctrls&XkbAccessXFeedbackMask) +#define XkbAX_NeedOption(c,w) ((c)->ax_options&(w)) +#define XkbAX_NeedFeedback(c,w) (XkbAX_AnyFeedback(c)&&XkbAX_NeedOption(c,w)) + +typedef struct _XkbServerMapRec { + /* acts is an array of XkbActions structs, with size_acts entries + allocated, and num_acts entries used. */ + unsigned short num_acts; + unsigned short size_acts; + XkbAction *acts; + + /* behaviors, key_acts, explicit, & vmodmap are all arrays with + (xkb->max_key_code + 1) entries allocated for each. */ + XkbBehavior *behaviors; + unsigned short *key_acts; +#if defined(__cplusplus) || defined(c_plusplus) + /* explicit is a C++ reserved word */ + unsigned char *c_explicit; +#else + unsigned char *explicit; +#endif + unsigned char vmods[XkbNumVirtualMods]; + unsigned short *vmodmap; +} XkbServerMapRec, *XkbServerMapPtr; + +#define XkbSMKeyActionsPtr(m,k) (&(m)->acts[(m)->key_acts[k]]) + + /* + * Structures and access macros used primarily by clients + */ + +typedef struct _XkbSymMapRec { + unsigned char kt_index[XkbNumKbdGroups]; + unsigned char group_info; + unsigned char width; + unsigned short offset; +} XkbSymMapRec, *XkbSymMapPtr; + +typedef struct _XkbClientMapRec { + /* types is an array of XkbKeyTypeRec structs, with size_types entries + allocated, and num_types entries used. */ + unsigned char size_types; + unsigned char num_types; + XkbKeyTypePtr types; + + /* syms is an array of size_syms KeySyms, in which num_syms are used */ + unsigned short size_syms; + unsigned short num_syms; + KeySym *syms; + /* key_sym_map is an array of (max_key_code + 1) XkbSymMapRec structs */ + XkbSymMapPtr key_sym_map; + + /* modmap is an array of (max_key_code + 1) unsigned chars */ + unsigned char *modmap; +} XkbClientMapRec, *XkbClientMapPtr; + +#define XkbCMKeyGroupInfo(m,k) ((m)->key_sym_map[k].group_info) +#define XkbCMKeyNumGroups(m,k) (XkbNumGroups((m)->key_sym_map[k].group_info)) +#define XkbCMKeyGroupWidth(m,k,g) (XkbCMKeyType(m,k,g)->num_levels) +#define XkbCMKeyGroupsWidth(m,k) ((m)->key_sym_map[k].width) +#define XkbCMKeyTypeIndex(m,k,g) ((m)->key_sym_map[k].kt_index[g&0x3]) +#define XkbCMKeyType(m,k,g) (&(m)->types[XkbCMKeyTypeIndex(m,k,g)]) +#define XkbCMKeyNumSyms(m,k) (XkbCMKeyGroupsWidth(m,k)*XkbCMKeyNumGroups(m,k)) +#define XkbCMKeySymsOffset(m,k) ((m)->key_sym_map[k].offset) +#define XkbCMKeySymsPtr(m,k) (&(m)->syms[XkbCMKeySymsOffset(m,k)]) + + /* + * Compatibility structures and access macros + */ + +typedef struct _XkbSymInterpretRec { + KeySym sym; + unsigned char flags; + unsigned char match; + unsigned char mods; + unsigned char virtual_mod; + XkbAnyAction act; +} XkbSymInterpretRec,*XkbSymInterpretPtr; + +typedef struct _XkbCompatMapRec { + /* sym_interpret is an array of XkbSymInterpretRec structs, + in which size_si are allocated & num_si are used. */ + XkbSymInterpretPtr sym_interpret; + XkbModsRec groups[XkbNumKbdGroups]; + unsigned short num_si; + unsigned short size_si; +} XkbCompatMapRec, *XkbCompatMapPtr; + +typedef struct _XkbIndicatorMapRec { + unsigned char flags; + unsigned char which_groups; + unsigned char groups; + unsigned char which_mods; + XkbModsRec mods; + unsigned int ctrls; +} XkbIndicatorMapRec, *XkbIndicatorMapPtr; + +#define XkbIM_IsAuto(i) ((((i)->flags&XkbIM_NoAutomatic)==0)&&\ + (((i)->which_groups&&(i)->groups)||\ + ((i)->which_mods&&(i)->mods.mask)||\ + ((i)->ctrls))) +#define XkbIM_InUse(i) (((i)->flags)||((i)->which_groups)||\ + ((i)->which_mods)||((i)->ctrls)) + + +typedef struct _XkbIndicatorRec { + unsigned long phys_indicators; + XkbIndicatorMapRec maps[XkbNumIndicators]; +} XkbIndicatorRec,*XkbIndicatorPtr; + +typedef struct _XkbKeyNameRec { + char name[XkbKeyNameLength] _X_NONSTRING; +} XkbKeyNameRec,*XkbKeyNamePtr; + +typedef struct _XkbKeyAliasRec { + char real[XkbKeyNameLength] _X_NONSTRING; + char alias[XkbKeyNameLength] _X_NONSTRING; +} XkbKeyAliasRec,*XkbKeyAliasPtr; + + /* + * Names for everything + */ +typedef struct _XkbNamesRec { + Atom keycodes; + Atom geometry; + Atom symbols; + Atom types; + Atom compat; + Atom vmods[XkbNumVirtualMods]; + Atom indicators[XkbNumIndicators]; + Atom groups[XkbNumKbdGroups]; + /* keys is an array of (xkb->max_key_code + 1) XkbKeyNameRec entries */ + XkbKeyNamePtr keys; + /* key_aliases is an array of num_key_aliases XkbKeyAliasRec entries */ + XkbKeyAliasPtr key_aliases; + /* radio_groups is an array of num_rg Atoms */ + Atom *radio_groups; + Atom phys_symbols; + + /* num_keys seems to be unused in libX11 */ + unsigned char num_keys; + unsigned char num_key_aliases; + unsigned short num_rg; +} XkbNamesRec,*XkbNamesPtr; + +typedef struct _XkbGeometry *XkbGeometryPtr; + /* + * Tie it all together into one big keyboard description + */ +typedef struct _XkbDesc { + struct _XDisplay * dpy; + unsigned short flags; + unsigned short device_spec; + KeyCode min_key_code; + KeyCode max_key_code; + + XkbControlsPtr ctrls; + XkbServerMapPtr server; + XkbClientMapPtr map; + XkbIndicatorPtr indicators; + XkbNamesPtr names; + XkbCompatMapPtr compat; + XkbGeometryPtr geom; +} XkbDescRec, *XkbDescPtr; +#define XkbKeyKeyTypeIndex(d,k,g) (XkbCMKeyTypeIndex((d)->map,k,g)) +#define XkbKeyKeyType(d,k,g) (XkbCMKeyType((d)->map,k,g)) +#define XkbKeyGroupWidth(d,k,g) (XkbCMKeyGroupWidth((d)->map,k,g)) +#define XkbKeyGroupsWidth(d,k) (XkbCMKeyGroupsWidth((d)->map,k)) +#define XkbKeyGroupInfo(d,k) (XkbCMKeyGroupInfo((d)->map,(k))) +#define XkbKeyNumGroups(d,k) (XkbCMKeyNumGroups((d)->map,(k))) +#define XkbKeyNumSyms(d,k) (XkbCMKeyNumSyms((d)->map,(k))) +#define XkbKeySymsPtr(d,k) (XkbCMKeySymsPtr((d)->map,(k))) +#define XkbKeySym(d,k,n) (XkbKeySymsPtr(d,k)[n]) +#define XkbKeySymEntry(d,k,sl,g) \ + (XkbKeySym(d,k,((XkbKeyGroupsWidth(d,k)*(g))+(sl)))) +#define XkbKeyAction(d,k,n) \ + (XkbKeyHasActions(d,k)?&XkbKeyActionsPtr(d,k)[n]:NULL) +#define XkbKeyActionEntry(d,k,sl,g) \ + (XkbKeyHasActions(d,k)?\ + XkbKeyAction(d,k,((XkbKeyGroupsWidth(d,k)*(g))+(sl))):NULL) + +#define XkbKeyHasActions(d,k) ((d)->server->key_acts[k]!=0) +#define XkbKeyNumActions(d,k) (XkbKeyHasActions(d,k)?XkbKeyNumSyms(d,k):1) +#define XkbKeyActionsPtr(d,k) (XkbSMKeyActionsPtr((d)->server,k)) +#define XkbKeycodeInRange(d,k) (((k)>=(d)->min_key_code)&&\ + ((k)<=(d)->max_key_code)) +#define XkbNumKeys(d) ((d)->max_key_code-(d)->min_key_code+1) + + + /* + * The following structures can be used to track changes + * to a keyboard device + */ +typedef struct _XkbMapChanges { + unsigned short changed; + KeyCode min_key_code; + KeyCode max_key_code; + unsigned char first_type; + unsigned char num_types; + KeyCode first_key_sym; + unsigned char num_key_syms; + KeyCode first_key_act; + unsigned char num_key_acts; + KeyCode first_key_behavior; + unsigned char num_key_behaviors; + KeyCode first_key_explicit; + unsigned char num_key_explicit; + KeyCode first_modmap_key; + unsigned char num_modmap_keys; + KeyCode first_vmodmap_key; + unsigned char num_vmodmap_keys; + unsigned char pad; + unsigned short vmods; +} XkbMapChangesRec,*XkbMapChangesPtr; + +typedef struct _XkbControlsChanges { + unsigned int changed_ctrls; + unsigned int enabled_ctrls_changes; + Bool num_groups_changed; +} XkbControlsChangesRec,*XkbControlsChangesPtr; + +typedef struct _XkbIndicatorChanges { + unsigned int state_changes; + unsigned int map_changes; +} XkbIndicatorChangesRec,*XkbIndicatorChangesPtr; + +typedef struct _XkbNameChanges { + unsigned int changed; + unsigned char first_type; + unsigned char num_types; + unsigned char first_lvl; + unsigned char num_lvls; + unsigned char num_aliases; + unsigned char num_rg; + unsigned char first_key; + unsigned char num_keys; + unsigned short changed_vmods; + unsigned long changed_indicators; + unsigned char changed_groups; +} XkbNameChangesRec,*XkbNameChangesPtr; + +typedef struct _XkbCompatChanges { + unsigned char changed_groups; + unsigned short first_si; + unsigned short num_si; +} XkbCompatChangesRec,*XkbCompatChangesPtr; + +typedef struct _XkbChanges { + unsigned short device_spec; + unsigned short state_changes; + XkbMapChangesRec map; + XkbControlsChangesRec ctrls; + XkbIndicatorChangesRec indicators; + XkbNameChangesRec names; + XkbCompatChangesRec compat; +} XkbChangesRec, *XkbChangesPtr; + + /* + * These data structures are used to construct a keymap from + * a set of components or to list components in the server + * database. + */ +typedef struct _XkbComponentNames { + char * keymap; + char * keycodes; + char * types; + char * compat; + char * symbols; + char * geometry; +} XkbComponentNamesRec, *XkbComponentNamesPtr; + +typedef struct _XkbComponentName { + unsigned short flags; + char * name; +} XkbComponentNameRec,*XkbComponentNamePtr; + +typedef struct _XkbComponentList { + int num_keymaps; + int num_keycodes; + int num_types; + int num_compat; + int num_symbols; + int num_geometry; + XkbComponentNamePtr keymaps; + XkbComponentNamePtr keycodes; + XkbComponentNamePtr types; + XkbComponentNamePtr compat; + XkbComponentNamePtr symbols; + XkbComponentNamePtr geometry; +} XkbComponentListRec, *XkbComponentListPtr; + + /* + * The following data structures describe and track changes to a + * non-keyboard extension device + */ +typedef struct _XkbDeviceLedInfo { + unsigned short led_class; + unsigned short led_id; + unsigned int phys_indicators; + unsigned int maps_present; + unsigned int names_present; + unsigned int state; + Atom names[XkbNumIndicators]; + XkbIndicatorMapRec maps[XkbNumIndicators]; +} XkbDeviceLedInfoRec,*XkbDeviceLedInfoPtr; + +typedef struct _XkbDeviceInfo { + char * name; + Atom type; + unsigned short device_spec; + Bool has_own_state; + unsigned short supported; + unsigned short unsupported; + + /* btn_acts is an array of num_btn XkbAction entries */ + unsigned short num_btns; + XkbAction * btn_acts; + + unsigned short sz_leds; + unsigned short num_leds; + unsigned short dflt_kbd_fb; + unsigned short dflt_led_fb; + /* leds is an array of XkbDeviceLedInfoRec in which + sz_leds entries are allocated and num_leds entries are used */ + XkbDeviceLedInfoPtr leds; +} XkbDeviceInfoRec,*XkbDeviceInfoPtr; + +#define XkbXI_DevHasBtnActs(d) (((d)->num_btns>0)&&((d)->btn_acts!=NULL)) +#define XkbXI_LegalDevBtn(d,b) (XkbXI_DevHasBtnActs(d)&&((b)<(d)->num_btns)) +#define XkbXI_DevHasLeds(d) (((d)->num_leds>0)&&((d)->leds!=NULL)) + +typedef struct _XkbDeviceLedChanges { + unsigned short led_class; + unsigned short led_id; + unsigned int defined; /* names or maps changed */ + struct _XkbDeviceLedChanges *next; +} XkbDeviceLedChangesRec,*XkbDeviceLedChangesPtr; + +typedef struct _XkbDeviceChanges { + unsigned int changed; + unsigned short first_btn; + unsigned short num_btns; + XkbDeviceLedChangesRec leds; +} XkbDeviceChangesRec,*XkbDeviceChangesPtr; + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + +#endif /* _XKBSTR_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/XResproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/XResproto.h new file mode 100644 index 0000000000000000000000000000000000000000..74cc87672438d0becdc73cf7e2d67517351bc333 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/XResproto.h @@ -0,0 +1,227 @@ +/* + Copyright (c) 2002 XFree86 Inc +*/ + +#ifndef _XRESPROTO_H +#define _XRESPROTO_H + +#define XRES_MAJOR_VERSION 1 +#define XRES_MINOR_VERSION 2 + +#define XRES_NAME "X-Resource" + +/* v1.0 */ +#define X_XResQueryVersion 0 +#define X_XResQueryClients 1 +#define X_XResQueryClientResources 2 +#define X_XResQueryClientPixmapBytes 3 + +/* Version 1.1 has been accidentally released from the version */ +/* control and while it doesn't have differences to version 1.0, the */ +/* next version is labeled 1.2 in order to remove the risk of confusion. */ + +/* v1.2 */ +#define X_XResQueryClientIds 4 +#define X_XResQueryResourceBytes 5 + +typedef struct { + CARD32 resource_base; + CARD32 resource_mask; +} xXResClient; +#define sz_xXResClient 8 + +typedef struct { + CARD32 resource_type; + CARD32 count; +} xXResType; +#define sz_xXResType 8 + +/* XResQueryVersion */ + +typedef struct _XResQueryVersion { + CARD8 reqType; + CARD8 XResReqType; + CARD16 length; + CARD8 client_major; + CARD8 client_minor; + CARD16 unused; +} xXResQueryVersionReq; +#define sz_xXResQueryVersionReq 8 + +typedef struct { + CARD8 type; + CARD8 pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD16 server_major; + CARD16 server_minor; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xXResQueryVersionReply; +#define sz_xXResQueryVersionReply 32 + +/* XResQueryClients */ + +typedef struct _XResQueryClients { + CARD8 reqType; + CARD8 XResReqType; + CARD16 length; +} xXResQueryClientsReq; +#define sz_xXResQueryClientsReq 4 + +typedef struct { + CARD8 type; + CARD8 pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 num_clients; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xXResQueryClientsReply; +#define sz_xXResQueryClientsReply 32 + +/* XResQueryClientResources */ + +typedef struct _XResQueryClientResources { + CARD8 reqType; + CARD8 XResReqType; + CARD16 length; + CARD32 xid; +} xXResQueryClientResourcesReq; +#define sz_xXResQueryClientResourcesReq 8 + +typedef struct { + CARD8 type; + CARD8 pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 num_types; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xXResQueryClientResourcesReply; +#define sz_xXResQueryClientResourcesReply 32 + +/* XResQueryClientPixmapBytes */ + +typedef struct _XResQueryClientPixmapBytes { + CARD8 reqType; + CARD8 XResReqType; + CARD16 length; + CARD32 xid; +} xXResQueryClientPixmapBytesReq; +#define sz_xXResQueryClientPixmapBytesReq 8 + +typedef struct { + CARD8 type; + CARD8 pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 bytes; + CARD32 bytes_overflow; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xXResQueryClientPixmapBytesReply; +#define sz_xXResQueryClientPixmapBytesReply 32 + +/* v1.2 XResQueryClientIds */ + +#define X_XResClientXIDMask 0x01 +#define X_XResLocalClientPIDMask 0x02 + +typedef struct _XResClientIdSpec { + CARD32 client; + CARD32 mask; +} xXResClientIdSpec; +#define sz_xXResClientIdSpec 8 + +typedef struct _XResClientIdValue { + xXResClientIdSpec spec; + CARD32 length; + // followed by length CARD32s +} xXResClientIdValue; +#define sz_xResClientIdValue (sz_xXResClientIdSpec + 4) + +typedef struct _XResQueryClientIds { + CARD8 reqType; + CARD8 XResReqType; + CARD16 length; + CARD32 numSpecs; + // followed by numSpecs times XResClientIdSpec +} xXResQueryClientIdsReq; +#define sz_xXResQueryClientIdsReq 8 + +typedef struct { + CARD8 type; + CARD8 pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 numIds; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; + // followed by numIds times XResClientIdValue +} xXResQueryClientIdsReply; +#define sz_xXResQueryClientIdsReply 32 + +/* v1.2 XResQueryResourceBytes */ + +typedef struct _XResResourceIdSpec { + CARD32 resource; + CARD32 type; +} xXResResourceIdSpec; +#define sz_xXResResourceIdSpec 8 + +typedef struct _XResQueryResourceBytes { + CARD8 reqType; + CARD8 XResReqType; + CARD16 length; + CARD32 client; + CARD32 numSpecs; + // followed by numSpecs times XResResourceIdSpec +} xXResQueryResourceBytesReq; +#define sz_xXResQueryResourceBytesReq 12 + +typedef struct _XResResourceSizeSpec { + xXResResourceIdSpec spec; + CARD32 bytes; + CARD32 refCount; + CARD32 useCount; +} xXResResourceSizeSpec; +#define sz_xXResResourceSizeSpec (sz_xXResResourceIdSpec + 12) + +typedef struct _XResResourceSizeValue { + xXResResourceSizeSpec size; + CARD32 numCrossReferences; + // followed by numCrossReferences times XResResourceSizeSpec +} xXResResourceSizeValue; +#define sz_xXResResourceSizeValue (sz_xXResResourceSizeSpec + 4) + +typedef struct { + CARD8 type; + CARD8 pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 numSizes; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; + // followed by numSizes times XResResourceSizeValue +} xXResQueryResourceBytesReply; +#define sz_xXResQueryResourceBytesReply 32 + +#endif /* _XRESPROTO_H */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/Xv.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/Xv.h new file mode 100644 index 0000000000000000000000000000000000000000..f662df6aeb7e4522e3a743680e40a7285440302a --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/Xv.h @@ -0,0 +1,128 @@ +/*********************************************************** +Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts, +and the Massachusetts Institute of Technology, Cambridge, Massachusetts. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the names of Digital or MIT not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + +******************************************************************/ + +#ifndef XV_H +#define XV_H +/* +** File: +** +** Xv.h --- Xv shared library and server header file +** +** Author: +** +** David Carver (Digital Workstation Engineering/Project Athena) +** +** Revisions: +** +** 05.15.91 Carver +** - version 2.0 upgrade +** +** 01.24.91 Carver +** - version 1.4 upgrade +** +*/ + +#include + +#define XvName "XVideo" +#define XvVersion 2 +#define XvRevision 2 + +/* Symbols */ + +typedef XID XvPortID; +typedef XID XvEncodingID; + +#define XvNone 0 + +#define XvInput 0 +#define XvOutput 1 + +#define XvInputMask (1< +#include + +#define XvMCName "XVideo-MotionCompensation" +#define XvMCNumEvents 0 +#define XvMCNumErrors 3 +#define XvMCVersion 1 +#define XvMCRevision 1 + +#define XvMCBadContext 0 +#define XvMCBadSurface 1 +#define XvMCBadSubpicture 2 + +/* Chroma formats */ +#define XVMC_CHROMA_FORMAT_420 0x00000001 +#define XVMC_CHROMA_FORMAT_422 0x00000002 +#define XVMC_CHROMA_FORMAT_444 0x00000003 + +/* XvMCSurfaceInfo Flags */ +#define XVMC_OVERLAID_SURFACE 0x00000001 +#define XVMC_BACKEND_SUBPICTURE 0x00000002 +#define XVMC_SUBPICTURE_INDEPENDENT_SCALING 0x00000004 +#define XVMC_INTRA_UNSIGNED 0x00000008 + +/* Motion Compensation types */ +#define XVMC_MOCOMP 0x00000000 +#define XVMC_IDCT 0x00010000 + +#define XVMC_MPEG_1 0x00000001 +#define XVMC_MPEG_2 0x00000002 +#define XVMC_H263 0x00000003 +#define XVMC_MPEG_4 0x00000004 + +#define XVMC_MB_TYPE_MOTION_FORWARD 0x02 +#define XVMC_MB_TYPE_MOTION_BACKWARD 0x04 +#define XVMC_MB_TYPE_PATTERN 0x08 +#define XVMC_MB_TYPE_INTRA 0x10 + +#define XVMC_PREDICTION_FIELD 0x01 +#define XVMC_PREDICTION_FRAME 0x02 +#define XVMC_PREDICTION_DUAL_PRIME 0x03 +#define XVMC_PREDICTION_16x8 0x02 +#define XVMC_PREDICTION_4MV 0x04 + +#define XVMC_SELECT_FIRST_FORWARD 0x01 +#define XVMC_SELECT_FIRST_BACKWARD 0x02 +#define XVMC_SELECT_SECOND_FORWARD 0x04 +#define XVMC_SELECT_SECOND_BACKWARD 0x08 + +#define XVMC_DCT_TYPE_FRAME 0x00 +#define XVMC_DCT_TYPE_FIELD 0x01 + +#define XVMC_TOP_FIELD 0x00000001 +#define XVMC_BOTTOM_FIELD 0x00000002 +#define XVMC_FRAME_PICTURE (XVMC_TOP_FIELD | XVMC_BOTTOM_FIELD) + +#define XVMC_SECOND_FIELD 0x00000004 + +#define XVMC_DIRECT 0x00000001 + +#define XVMC_RENDERING 0x00000001 +#define XVMC_DISPLAYING 0x00000002 + + +typedef struct { + int surface_type_id; + int chroma_format; + unsigned short max_width; + unsigned short max_height; + unsigned short subpicture_max_width; + unsigned short subpicture_max_height; + int mc_type; + int flags; +} XvMCSurfaceInfo; + +typedef struct { + XID context_id; + int surface_type_id; + unsigned short width; + unsigned short height; + XvPortID port; + int flags; + void * privData; /* private to the library */ +} XvMCContext; + +typedef struct { + XID surface_id; + XID context_id; + int surface_type_id; + unsigned short width; + unsigned short height; + void *privData; /* private to the library */ +} XvMCSurface; + +typedef struct { + XID subpicture_id; + XID context_id; + int xvimage_id; + unsigned short width; + unsigned short height; + int num_palette_entries; + int entry_bytes; + char component_order[4]; + void *privData; /* private to the library */ +} XvMCSubpicture; + +typedef struct { + unsigned int num_blocks; + XID context_id; + void *privData; + short *blocks; +} XvMCBlockArray; + +typedef struct { + unsigned short x; + unsigned short y; + unsigned char macroblock_type; + unsigned char motion_type; + unsigned char motion_vertical_field_select; + unsigned char dct_type; + short PMV[2][2][2]; + unsigned int index; + unsigned short coded_block_pattern; + unsigned short pad0; +} XvMCMacroBlock; + + +typedef struct { + unsigned int num_blocks; + XID context_id; + void *privData; + XvMCMacroBlock *macro_blocks; +} XvMCMacroBlockArray; + +#endif diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/XvMCproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/XvMCproto.h new file mode 100644 index 0000000000000000000000000000000000000000..d3b017114d5e61064d3a5af1cebb9cb3a21f9bd2 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/XvMCproto.h @@ -0,0 +1,226 @@ +#ifndef _XVMCPROTO_H_ +#define _XVMCPROTO_H_ + +#define xvmc_QueryVersion 0 +#define xvmc_ListSurfaceTypes 1 +#define xvmc_CreateContext 2 +#define xvmc_DestroyContext 3 +#define xvmc_CreateSurface 4 +#define xvmc_DestroySurface 5 +#define xvmc_CreateSubpicture 6 +#define xvmc_DestroySubpicture 7 +#define xvmc_ListSubpictureTypes 8 +#define xvmc_GetDRInfo 9 +#define xvmc_LastRequest xvmc_GetDRInfo + +#define xvmcNumRequest (xvmc_LastRequest + 1) + + +typedef struct { + CARD32 surface_type_id; + CARD16 chroma_format; + CARD16 pad0; + CARD16 max_width; + CARD16 max_height; + CARD16 subpicture_max_width; + CARD16 subpicture_max_height; + CARD32 mc_type; + CARD32 flags; +} xvmcSurfaceInfo; +#define sz_xvmcSurfaceInfo 24 + +typedef struct { + CARD8 reqType; + CARD8 xvmcReqType; + CARD16 length; +} xvmcQueryVersionReq; +#define sz_xvmcQueryVersionReq 4 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE padb1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 major; + CARD32 minor; + CARD32 padl4; + CARD32 padl5; + CARD32 padl6; + CARD32 padl7; +} xvmcQueryVersionReply; +#define sz_xvmcQueryVersionReply 32 + +typedef struct { + CARD8 reqType; + CARD8 xvmcReqType; + CARD16 length; + CARD32 port; +} xvmcListSurfaceTypesReq; +#define sz_xvmcListSurfaceTypesReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE padb1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 num; + CARD32 padl3; + CARD32 padl4; + CARD32 padl5; + CARD32 padl6; + CARD32 padl7; +} xvmcListSurfaceTypesReply; +#define sz_xvmcListSurfaceTypesReply 32 + +typedef struct { + CARD8 reqType; + CARD8 xvmcReqType; + CARD16 length; + CARD32 context_id; + CARD32 port; + CARD32 surface_type_id; + CARD16 width; + CARD16 height; + CARD32 flags; +} xvmcCreateContextReq; +#define sz_xvmcCreateContextReq 24 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE padb1; + CARD16 sequenceNumber; + CARD32 length; + CARD16 width_actual; + CARD16 height_actual; + CARD32 flags_return; + CARD32 padl4; + CARD32 padl5; + CARD32 padl6; + CARD32 padl7; +} xvmcCreateContextReply; +#define sz_xvmcCreateContextReply 32 + +typedef struct { + CARD8 reqType; + CARD8 xvmcReqType; + CARD16 length; + CARD32 context_id; +} xvmcDestroyContextReq; +#define sz_xvmcDestroyContextReq 8 + +typedef struct { + CARD8 reqType; + CARD8 xvmcReqType; + CARD16 length; + CARD32 surface_id; + CARD32 context_id; +} xvmcCreateSurfaceReq; +#define sz_xvmcCreateSurfaceReq 12 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE padb1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 padl2; + CARD32 padl3; + CARD32 padl4; + CARD32 padl5; + CARD32 padl6; + CARD32 padl7; +} xvmcCreateSurfaceReply; +#define sz_xvmcCreateSurfaceReply 32 + +typedef struct { + CARD8 reqType; + CARD8 xvmcReqType; + CARD16 length; + CARD32 surface_id; +} xvmcDestroySurfaceReq; +#define sz_xvmcDestroySurfaceReq 8 + + +typedef struct { + CARD8 reqType; + CARD8 xvmcReqType; + CARD16 length; + CARD32 subpicture_id; + CARD32 context_id; + CARD32 xvimage_id; + CARD16 width; + CARD16 height; +} xvmcCreateSubpictureReq; +#define sz_xvmcCreateSubpictureReq 20 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE padb1; + CARD16 sequenceNumber; + CARD32 length; + CARD16 width_actual; + CARD16 height_actual; + CARD16 num_palette_entries; + CARD16 entry_bytes; + CARD8 component_order[4]; + CARD32 padl5; + CARD32 padl6; + CARD32 padl7; +} xvmcCreateSubpictureReply; +#define sz_xvmcCreateSubpictureReply 32 + +typedef struct { + CARD8 reqType; + CARD8 xvmcReqType; + CARD16 length; + CARD32 subpicture_id; +} xvmcDestroySubpictureReq; +#define sz_xvmcDestroySubpictureReq 8 + +typedef struct { + CARD8 reqType; + CARD8 xvmcReqType; + CARD16 length; + CARD32 port; + CARD32 surface_type_id; +} xvmcListSubpictureTypesReq; +#define sz_xvmcListSubpictureTypesReq 12 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE padb1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 num; + CARD32 padl2; + CARD32 padl3; + CARD32 padl4; + CARD32 padl5; + CARD32 padl6; +} xvmcListSubpictureTypesReply; +#define sz_xvmcListSubpictureTypesReply 32 + +typedef struct { + CARD8 reqType; + CARD8 xvmcReqType; + CARD16 length; + CARD32 port; + CARD32 shmKey; + CARD32 magic; +} xvmcGetDRInfoReq; +#define sz_xvmcGetDRInfoReq 16 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE padb1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 major; + CARD32 minor; + CARD32 patchLevel; + CARD32 nameLen; + CARD32 busIDLen; + CARD32 isLocal; +} xvmcGetDRInfoReply; +#define sz_xvmcGetDRInfoReply 32 + +#endif diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/Xvproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/Xvproto.h new file mode 100644 index 0000000000000000000000000000000000000000..6e7ea08fed761d2ca948cf77e376651f910b60dd --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/Xvproto.h @@ -0,0 +1,603 @@ +/*********************************************************** +Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts, +and the Massachusetts Institute of Technology, Cambridge, Massachusetts. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the names of Digital or MIT not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + +******************************************************************/ + +#ifndef XVPROTO_H +#define XVPROTO_H +/* +** File: +** +** Xvproto.h --- Xv protocol header file +** +** Author: +** +** David Carver (Digital Workstation Engineering/Project Athena) +** +** Revisions: +** +** 11.06.91 Carver +** - changed SetPortControl to SetPortAttribute +** - changed GetPortControl to GetPortAttribute +** - changed QueryBestSize +** +** 15.05.91 Carver +** - version 2.0 upgrade +** +** 24.01.91 Carver +** - version 1.4 upgrade +** +*/ + +#include + +/* Symbols: These are undefined at the end of this file to restore the + values they have in Xv.h */ + +#define XvPortID CARD32 +#define XvEncodingID CARD32 +#define ShmSeg CARD32 +#define VisualID CARD32 +#define Drawable CARD32 +#define GContext CARD32 +#define Time CARD32 +#define Atom CARD32 + +/* Structures */ + +typedef struct { + INT32 numerator; + INT32 denominator; +} xvRational; +#define sz_xvRational 8 + +typedef struct { + XvPortID base_id; + CARD16 name_size; + CARD16 num_ports; + CARD16 num_formats; + CARD8 type; + CARD8 pad; +} xvAdaptorInfo; +#define sz_xvAdaptorInfo 12 + +typedef struct { + XvEncodingID encoding; + CARD16 name_size; + CARD16 width, height; + CARD16 pad; + xvRational rate; +} xvEncodingInfo; +#define sz_xvEncodingInfo (12 + sz_xvRational) + +typedef struct { + VisualID visual; + CARD8 depth; + CARD8 pad1; + CARD16 pad2; +} xvFormat; +#define sz_xvFormat 8 + +typedef struct { + CARD32 flags; + INT32 min; + INT32 max; + CARD32 size; +} xvAttributeInfo; +#define sz_xvAttributeInfo 16 + +typedef struct { + CARD32 id; + CARD8 type; + CARD8 byte_order; + CARD16 pad1; + CARD8 guid[16]; + CARD8 bpp; + CARD8 num_planes; + CARD16 pad2; + CARD8 depth; + CARD8 pad3; + CARD16 pad4; + CARD32 red_mask; + CARD32 green_mask; + CARD32 blue_mask; + CARD8 format; + CARD8 pad5; + CARD16 pad6; + CARD32 y_sample_bits; + CARD32 u_sample_bits; + CARD32 v_sample_bits; + CARD32 horz_y_period; + CARD32 horz_u_period; + CARD32 horz_v_period; + CARD32 vert_y_period; + CARD32 vert_u_period; + CARD32 vert_v_period; + CARD8 comp_order[32]; + CARD8 scanline_order; + CARD8 pad7; + CARD16 pad8; + CARD32 pad9; + CARD32 pad10; +} xvImageFormatInfo; +#define sz_xvImageFormatInfo 128 + + +/* Requests */ + +#define xv_QueryExtension 0 +#define xv_QueryAdaptors 1 +#define xv_QueryEncodings 2 +#define xv_GrabPort 3 +#define xv_UngrabPort 4 +#define xv_PutVideo 5 +#define xv_PutStill 6 +#define xv_GetVideo 7 +#define xv_GetStill 8 +#define xv_StopVideo 9 +#define xv_SelectVideoNotify 10 +#define xv_SelectPortNotify 11 +#define xv_QueryBestSize 12 +#define xv_SetPortAttribute 13 +#define xv_GetPortAttribute 14 +#define xv_QueryPortAttributes 15 +#define xv_ListImageFormats 16 +#define xv_QueryImageAttributes 17 +#define xv_PutImage 18 +#define xv_ShmPutImage 19 +#define xv_LastRequest xv_ShmPutImage + +#define xvNumRequests (xv_LastRequest + 1) + +typedef struct { + CARD8 reqType; + CARD8 xvReqType; + CARD16 length; +} xvQueryExtensionReq; +#define sz_xvQueryExtensionReq 4 + +typedef struct { + CARD8 reqType; + CARD8 xvReqType; + CARD16 length; + CARD32 window; +} xvQueryAdaptorsReq; +#define sz_xvQueryAdaptorsReq 8 + +typedef struct { + CARD8 reqType; + CARD8 xvReqType; + CARD16 length; + CARD32 port; +} xvQueryEncodingsReq; +#define sz_xvQueryEncodingsReq 8 + +typedef struct { + CARD8 reqType; + CARD8 xvReqType; + CARD16 length; + XvPortID port; + Drawable drawable; + GContext gc; + INT16 vid_x; + INT16 vid_y; + CARD16 vid_w; + CARD16 vid_h; + INT16 drw_x; + INT16 drw_y; + CARD16 drw_w; + CARD16 drw_h; +} xvPutVideoReq; +#define sz_xvPutVideoReq 32 + +typedef struct { + CARD8 reqType; + CARD8 xvReqType; + CARD16 length; + XvPortID port; + Drawable drawable; + GContext gc; + INT16 vid_x; + INT16 vid_y; + CARD16 vid_w; + CARD16 vid_h; + INT16 drw_x; + INT16 drw_y; + CARD16 drw_w; + CARD16 drw_h; +} xvPutStillReq; +#define sz_xvPutStillReq 32 + +typedef struct { + CARD8 reqType; + CARD8 xvReqType; + CARD16 length; + XvPortID port; + Drawable drawable; + GContext gc; + INT16 vid_x; + INT16 vid_y; + CARD16 vid_w; + CARD16 vid_h; + INT16 drw_x; + INT16 drw_y; + CARD16 drw_w; + CARD16 drw_h; +} xvGetVideoReq; +#define sz_xvGetVideoReq 32 + +typedef struct { + CARD8 reqType; + CARD8 xvReqType; + CARD16 length; + XvPortID port; + Drawable drawable; + GContext gc; + INT16 vid_x; + INT16 vid_y; + CARD16 vid_w; + CARD16 vid_h; + INT16 drw_x; + INT16 drw_y; + CARD16 drw_w; + CARD16 drw_h; +} xvGetStillReq; +#define sz_xvGetStillReq 32 + +typedef struct { + CARD8 reqType; + CARD8 xvReqType; + CARD16 length; + XvPortID port; + Time time; +} xvGrabPortReq; +#define sz_xvGrabPortReq 12 + +typedef struct { + CARD8 reqType; + CARD8 xvReqType; + CARD16 length; + XvPortID port; + Time time; +} xvUngrabPortReq; +#define sz_xvUngrabPortReq 12 + +typedef struct { + CARD8 reqType; + CARD8 xvReqType; + CARD16 length; + Drawable drawable; + BOOL onoff; + CARD8 pad1; + CARD16 pad2; +} xvSelectVideoNotifyReq; +#define sz_xvSelectVideoNotifyReq 12 + +typedef struct { + CARD8 reqType; + CARD8 xvReqType; + CARD16 length; + XvPortID port; + BOOL onoff; + CARD8 pad1; + CARD16 pad2; +} xvSelectPortNotifyReq; +#define sz_xvSelectPortNotifyReq 12 + +typedef struct { + CARD8 reqType; + CARD8 xvReqType; + CARD16 length; + XvPortID port; + Drawable drawable; +} xvStopVideoReq; +#define sz_xvStopVideoReq 12 + +typedef struct { + CARD8 reqType; + CARD8 xvReqType; + CARD16 length; + XvPortID port; + Atom attribute; + INT32 value; +} xvSetPortAttributeReq; +#define sz_xvSetPortAttributeReq 16 + +typedef struct { + CARD8 reqType; + CARD8 xvReqType; + CARD16 length; + XvPortID port; + Atom attribute; +} xvGetPortAttributeReq; +#define sz_xvGetPortAttributeReq 12 + +typedef struct { + CARD8 reqType; + CARD8 xvReqType; + CARD16 length; + XvPortID port; + CARD16 vid_w; + CARD16 vid_h; + CARD16 drw_w; + CARD16 drw_h; + CARD8 motion; + CARD8 pad1; + CARD16 pad2; +} xvQueryBestSizeReq; +#define sz_xvQueryBestSizeReq 20 + +typedef struct { + CARD8 reqType; + CARD8 xvReqType; + CARD16 length; + XvPortID port; +} xvQueryPortAttributesReq; +#define sz_xvQueryPortAttributesReq 8 + +typedef struct { + CARD8 reqType; + CARD8 xvReqType; + CARD16 length; + XvPortID port; + Drawable drawable; + GContext gc; + CARD32 id; + INT16 src_x; + INT16 src_y; + CARD16 src_w; + CARD16 src_h; + INT16 drw_x; + INT16 drw_y; + CARD16 drw_w; + CARD16 drw_h; + CARD16 width; + CARD16 height; +} xvPutImageReq; +#define sz_xvPutImageReq 40 + +typedef struct { + CARD8 reqType; + CARD8 xvReqType; + CARD16 length; + XvPortID port; + Drawable drawable; + GContext gc; + ShmSeg shmseg; + CARD32 id; + CARD32 offset; + INT16 src_x; + INT16 src_y; + CARD16 src_w; + CARD16 src_h; + INT16 drw_x; + INT16 drw_y; + CARD16 drw_w; + CARD16 drw_h; + CARD16 width; + CARD16 height; + CARD8 send_event; + CARD8 pad1; + CARD16 pad2; +} xvShmPutImageReq; +#define sz_xvShmPutImageReq 52 + +typedef struct { + CARD8 reqType; + CARD8 xvReqType; + CARD16 length; + XvPortID port; +} xvListImageFormatsReq; +#define sz_xvListImageFormatsReq 8 + +typedef struct { + CARD8 reqType; + CARD8 xvReqType; + CARD16 length; + CARD32 port; + CARD32 id; + CARD16 width; + CARD16 height; +} xvQueryImageAttributesReq; +#define sz_xvQueryImageAttributesReq 16 + + +/* Replies */ + +typedef struct _QueryExtensionReply { + BYTE type; /* X_Reply */ + CARD8 padb1; + CARD16 sequenceNumber; + CARD32 length; + CARD16 version; + CARD16 revision; + CARD32 padl4; + CARD32 padl5; + CARD32 padl6; + CARD32 padl7; + CARD32 padl8; +} xvQueryExtensionReply; +#define sz_xvQueryExtensionReply 32 + +typedef struct _QueryAdaptorsReply { + BYTE type; /* X_Reply */ + CARD8 padb1; + CARD16 sequenceNumber; + CARD32 length; + CARD16 num_adaptors; + CARD16 pads3; + CARD32 padl4; + CARD32 padl5; + CARD32 padl6; + CARD32 padl7; + CARD32 padl8; +} xvQueryAdaptorsReply; +#define sz_xvQueryAdaptorsReply 32 + +typedef struct _QueryEncodingsReply { + BYTE type; /* X_Reply */ + CARD8 padb1; + CARD16 sequenceNumber; + CARD32 length; + CARD16 num_encodings; + CARD16 padl3; + CARD32 padl4; + CARD32 padl5; + CARD32 padl6; + CARD32 padl7; + CARD32 padl8; +} xvQueryEncodingsReply; +#define sz_xvQueryEncodingsReply 32 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE result; + CARD16 sequenceNumber; + CARD32 length; /* 0 */ + CARD32 padl3; + CARD32 padl4; + CARD32 padl5; + CARD32 padl6; + CARD32 padl7; + CARD32 padl8; +} xvGrabPortReply; +#define sz_xvGrabPortReply 32 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE padb1; + CARD16 sequenceNumber; + CARD32 length; /* 0 */ + INT32 value; + CARD32 padl4; + CARD32 padl5; + CARD32 padl6; + CARD32 padl7; + CARD32 padl8; +} xvGetPortAttributeReply; +#define sz_xvGetPortAttributeReply 32 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE padb1; + CARD16 sequenceNumber; + CARD32 length; /* 0 */ + CARD16 actual_width; + CARD16 actual_height; + CARD32 padl4; + CARD32 padl5; + CARD32 padl6; + CARD32 padl7; + CARD32 padl8; +} xvQueryBestSizeReply; +#define sz_xvQueryBestSizeReply 32 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE padb1; + CARD16 sequenceNumber; + CARD32 length; /* 0 */ + CARD32 num_attributes; + CARD32 text_size; + CARD32 padl5; + CARD32 padl6; + CARD32 padl7; + CARD32 padl8; +} xvQueryPortAttributesReply; +#define sz_xvQueryPortAttributesReply 32 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE padb1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 num_formats; + CARD32 padl4; + CARD32 padl5; + CARD32 padl6; + CARD32 padl7; + CARD32 padl8; +} xvListImageFormatsReply; +#define sz_xvListImageFormatsReply 32 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE padb1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 num_planes; + CARD32 data_size; + CARD16 width; + CARD16 height; + CARD32 padl6; + CARD32 padl7; + CARD32 padl8; +} xvQueryImageAttributesReply; +#define sz_xvQueryImageAttributesReply 32 + +/* DEFINE EVENT STRUCTURE */ + +typedef struct { + union { + struct { + BYTE type; + BYTE detail; + CARD16 sequenceNumber; + } u; + struct { + BYTE type; + BYTE reason; + CARD16 sequenceNumber; + Time time; + Drawable drawable; + XvPortID port; + CARD32 padl5; + CARD32 padl6; + CARD32 padl7; + CARD32 padl8; + } videoNotify; + struct { + BYTE type; + BYTE padb1; + CARD16 sequenceNumber; + Time time; + XvPortID port; + Atom attribute; + INT32 value; + CARD32 padl6; + CARD32 padl7; + CARD32 padl8; + } portNotify; + } u; +} xvEvent; + +#undef XvPortID +#undef XvEncodingID +#undef ShmSeg +#undef VisualID +#undef Drawable +#undef GContext +#undef Time +#undef Atom + +#endif /* XVPROTO_H */ + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/ag.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/ag.h new file mode 100644 index 0000000000000000000000000000000000000000..be5883a3e6635eb820306e91f296532299edb1e3 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/ag.h @@ -0,0 +1,52 @@ +/* +Copyright 1996, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. +*/ + +#ifndef _AG_H_ +#define _AG_H_ + +#define XAGNAME "XC-APPGROUP" + +#define XAG_MAJOR_VERSION 1 /* current version numbers */ +#define XAG_MINOR_VERSION 0 + +#define XagWindowTypeX11 0 +#define XagWindowTypeMacintosh 1 +#define XagWindowTypeWin32 2 +#define XagWindowTypeWin16 3 + +#define XagBadAppGroup 0 +#define XagNumberErrors (XagBadAppGroup + 1) + +#define XagNsingleScreen 7 +#define XagNdefaultRoot 1 +#define XagNrootVisual 2 +#define XagNdefaultColormap 3 +#define XagNblackPixel 4 +#define XagNwhitePixel 5 +#define XagNappGroupLeader 6 + +#endif /* _AG_H_ */ + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/agproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/agproto.h new file mode 100644 index 0000000000000000000000000000000000000000..803099d740aef38f527b73bf60a02834f32893dd --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/agproto.h @@ -0,0 +1,178 @@ +/* +Copyright 1996, 1998, 2001 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. +*/ + +#ifndef _AGPROTO_H_ /* { */ +#define _AGPROTO_H_ + +#include + +#define X_XagQueryVersion 0 +#define X_XagCreate 1 +#define X_XagDestroy 2 +#define X_XagGetAttr 3 +#define X_XagQuery 4 +#define X_XagCreateAssoc 5 +#define X_XagDestroyAssoc 6 + +#define XAppGroup CARD32 + +/* +* Redefine some basic types used by structures defined herein. This allows +* both the library and server to view communicated data as 32-bit entities, +* thus preventing problems on 64-bit architectures where libXext sees this +* data as 64 bits and the server sees it as 32 bits. +*/ + +#define Colormap CARD32 +#define VisualID CARD32 +#define Window CARD32 + +typedef struct _XagQueryVersion { + CARD8 reqType; /* always XagReqCode */ + CARD8 xagReqType; /* always X_XagQueryVersion */ + CARD16 length; + CARD16 client_major_version; + CARD16 client_minor_version; +} xXagQueryVersionReq; +#define sz_xXagQueryVersionReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + BOOL pad1; + CARD16 sequence_number; + CARD32 length; + CARD16 server_major_version; + CARD16 server_minor_version; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xXagQueryVersionReply; +#define sz_xXagQueryVersionReply 32 + +/* Set AppGroup Attributes masks */ +#define XagSingleScreenMask 1 << 0 +#define XagDefaultRootMask 1 << XagNdefaultRoot +#define XagRootVisualMask 1 << XagNrootVisual +#define XagDefaultColormapMask 1 << XagNdefaultColormap +#define XagBlackPixelMask 1 << XagNblackPixel +#define XagWhitePixelMask 1 << XagNwhitePixel +#define XagAppGroupLeaderMask 1 << XagNappGroupLeader + +typedef struct _XagCreate { + CARD8 reqType; /* always XagReqCode */ + CARD8 xagReqType; /* always X_XagCreate */ + CARD16 length; + XAppGroup app_group; + CARD32 attrib_mask; /* LISTofVALUE follows */ +} xXagCreateReq; +#define sz_xXagCreateReq 12 + +typedef struct _XagDestroy { + CARD8 reqType; /* always XagReqCode */ + CARD8 xagReqType; /* always X_XagDestroy */ + CARD16 length; + XAppGroup app_group; +} xXagDestroyReq; +#define sz_xXagDestroyReq 8 + +typedef struct _XagGetAttr { + CARD8 reqType; /* always XagReqCode */ + CARD8 xagReqType; /* always X_XagGetAttr */ + CARD16 length; + XAppGroup app_group; +} xXagGetAttrReq; +#define sz_xXagGetAttrReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + BOOL pad1; + CARD16 sequence_number; + CARD32 length; + Window default_root; + VisualID root_visual; + Colormap default_colormap; + CARD32 black_pixel; + CARD32 white_pixel; + BOOL single_screen; + BOOL app_group_leader; + CARD16 pad2; +} xXagGetAttrReply; +#define sz_xXagGetAttrReply 32 + +typedef struct _XagQuery { + CARD8 reqType; /* always XagReqCode */ + CARD8 xagReqType; /* always X_XagQuery */ + CARD16 length; + CARD32 resource; +} xXagQueryReq; +#define sz_xXagQueryReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + BOOL pad1; + CARD16 sequence_number; + CARD32 length; + XAppGroup app_group; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xXagQueryReply; +#define sz_xXagQueryReply 32 + +typedef struct _XagCreateAssoc { + CARD8 reqType; /* always XagReqCode */ + CARD8 xagReqType; /* always X_XagCreateAssoc */ + CARD16 length; + Window window; + CARD16 window_type; + CARD16 system_window_len; /* LISTofCARD8 follows */ +} xXagCreateAssocReq; +#define sz_xXagCreateAssocReq 12 + +typedef struct _XagDestroyAssoc { + CARD8 reqType; /* always XagReqCode */ + CARD8 xagReqType; /* always X_XagDestroyAssoc */ + CARD16 length; + Window window; +} xXagDestroyAssocReq; +#define sz_xXagDestroyAssocReq 8 + +#undef XAppGroup +/* + * Cancel the previous redefinition of the basic types, thus restoring their + * X.h definitions. + */ + +#undef Window +#undef Colormap +#undef VisualID + +#endif /* } _AGPROTO_H_ */ + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/applewmconst.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/applewmconst.h new file mode 100644 index 0000000000000000000000000000000000000000..4877c34715e98b260c0f2a264f2e3a71f283b624 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/applewmconst.h @@ -0,0 +1,84 @@ +/************************************************************************** + +Copyright (c) 2002 Apple Computer, Inc. +All Rights Reserved. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sub license, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice (including the +next paragraph) shall be included in all copies or substantial portions +of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. +IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +**************************************************************************/ + +#ifndef _APPLEWMCONST_H_ +#define _APPLEWMCONST_H_ + +/* Events */ +#define AppleWMControllerNotify 0 +#define AppleWMActivationNotify 1 +#define AppleWMPasteboardNotify 2 +#define AppleWMNumberEvents 3 + +#define AppleWMControllerNotifyMask (1L << 0) +#define AppleWMActivationNotifyMask (1L << 1) +#define AppleWMPasteboardNotifyMask (1L << 2) + +/* "Kinds" of ControllerNotify events */ +#define AppleWMMinimizeWindow 0 +#define AppleWMZoomWindow 1 +#define AppleWMCloseWindow 2 +#define AppleWMBringAllToFront 3 +#define AppleWMHideWindow 4 +#define AppleWMHideAll 5 +#define AppleWMShowAll 6 +#define AppleWMWindowMenuItem 9 +#define AppleWMWindowMenuNotify 10 +#define AppleWMNextWindow 11 +#define AppleWMPreviousWindow 12 + +/* "Kinds" of ActivationNotify events */ +#define AppleWMIsActive 0 +#define AppleWMIsInactive 1 +#define AppleWMReloadPreferences 2 + +/* "Kinds" of PasteboardNotify events */ +#define AppleWMCopyToPasteboard 0 + +/* Errors */ +#define AppleWMClientNotLocal 0 +#define AppleWMOperationNotSupported 1 +#define AppleWMNumberErrors (AppleWMOperationNotSupported + 1) + +/* Window level ids */ +#define AppleWMWindowLevelNormal 0 +#define AppleWMWindowLevelFloating 1 +#define AppleWMWindowLevelTornOff 2 +#define AppleWMWindowLevelDock 3 +#define AppleWMWindowLevelDesktop 4 +#define AppleWMNumWindowLevels 5 + +/* Possible value for frame_rect argument to XAppleWMFrameGetRect() */ +/* Use xp_frame_rect_enum from */ + +/* Window frame classes */ +/* Use xp_frame_class_enum from */ + +/* Window frame attributes */ +/* Use xp_frame_attr_enum from */ + +#endif /* _APPLEWMCONST_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/applewmproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/applewmproto.h new file mode 100644 index 0000000000000000000000000000000000000000..91417361e233d94747ed07fc24e0bb971435f8e3 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/applewmproto.h @@ -0,0 +1,293 @@ +/************************************************************************** + +Copyright (c) 2002 Apple Computer, Inc. +All Rights Reserved. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sub license, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice (including the +next paragraph) shall be included in all copies or substantial portions +of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. +IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +**************************************************************************/ + +#ifndef _APPLEWMPROTO_H_ +#define _APPLEWMPROTO_H_ + +#include +#include +#include + +#define APPLEWMNAME "Apple-WM" + +#define APPLE_WM_MAJOR_VERSION 1 /* current version numbers */ +#define APPLE_WM_MINOR_VERSION 3 +#define APPLE_WM_PATCH_VERSION 0 + +#define X_AppleWMQueryVersion 0 +#define X_AppleWMFrameGetRect 1 +#define X_AppleWMFrameHitTest 2 +#define X_AppleWMFrameDraw 3 +#define X_AppleWMDisableUpdate 4 +#define X_AppleWMReenableUpdate 5 +#define X_AppleWMSelectInput 6 +#define X_AppleWMSetWindowMenuCheck 7 +#define X_AppleWMSetFrontProcess 8 +#define X_AppleWMSetWindowLevel 9 +#define X_AppleWMSetCanQuit 10 +#define X_AppleWMSetWindowMenu 11 +#define X_AppleWMSendPSN 12 +#define X_AppleWMAttachTransient 13 + +/* For the purpose of the structure definitions in this file, +we must redefine the following types in terms of Xmd.h's types, which may +include bit fields. All of these are #undef'd at the end of this file, +restoring the definitions in X.h. */ + +#define Window CARD32 +#define Drawable CARD32 +#define Font CARD32 +#define Pixmap CARD32 +#define Cursor CARD32 +#define Colormap CARD32 +#define GContext CARD32 +#define Atom CARD32 +#define VisualID CARD32 +#define Time CARD32 +#define KeyCode CARD8 +#define KeySym CARD32 + +typedef struct _AppleWMQueryVersion { + CARD8 reqType; /* always WMReqCode */ + CARD8 wmReqType; /* always X_AppleWMQueryVersion */ + CARD16 length; +} xAppleWMQueryVersionReq; +#define sz_xAppleWMQueryVersionReq 4 + +typedef struct { + BYTE type; /* X_Reply */ + BOOL pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD16 majorVersion; /* major version of WM protocol */ + CARD16 minorVersion; /* minor version of WM protocol */ + CARD32 patchVersion; /* patch version of WM protocol */ + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xAppleWMQueryVersionReply; +#define sz_xAppleWMQueryVersionReply 32 + +typedef struct _AppleWMDisableUpdate { + CARD8 reqType; /* always WMReqCode */ + CARD8 wmReqType; /* always X_AppleWMDisableUpdate */ + CARD16 length; + CARD32 screen; +} xAppleWMDisableUpdateReq; +#define sz_xAppleWMDisableUpdateReq 8 + +typedef struct _AppleWMReenableUpdate { + CARD8 reqType; /* always WMReqCode */ + CARD8 wmReqType; /* always X_AppleWMReenableUpdate */ + CARD16 length; + CARD32 screen; +} xAppleWMReenableUpdateReq; +#define sz_xAppleWMReenableUpdateReq 8 + +typedef struct _AppleWMSelectInput { + CARD8 reqType; /* always WMReqCode */ + CARD8 wmReqType; /* always X_AppleWMSelectInput */ + CARD16 length; + CARD32 mask; +} xAppleWMSelectInputReq; +#define sz_xAppleWMSelectInputReq 8 + +typedef struct _AppleWMNotify { + BYTE type; /* always eventBase + event type */ + BYTE kind; + CARD16 sequenceNumber; + Time time; /* time of change */ + CARD16 pad1; + CARD32 arg; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xAppleWMNotifyEvent; +#define sz_xAppleWMNotifyEvent 32 + +typedef struct _AppleWMSetWindowMenu { + CARD8 reqType; /* always WMReqCode */ + CARD8 wmReqType; /* always X_AppleWMSetWindowMenu */ + CARD16 length; + CARD16 nitems; + CARD16 pad1; +} xAppleWMSetWindowMenuReq; +#define sz_xAppleWMSetWindowMenuReq 8 + +typedef struct _AppleWMSetWindowMenuCheck { + CARD8 reqType; /* always WMReqCode */ + CARD8 wmReqType; /* always X_AppleWMSetWindowMenuCheck */ + CARD16 length; + CARD32 index; +} xAppleWMSetWindowMenuCheckReq; +#define sz_xAppleWMSetWindowMenuCheckReq 8 + +typedef struct _AppleWMSetFrontProcess { + CARD8 reqType; /* always WMReqCode */ + CARD8 wmReqType; /* always X_AppleWMSetFrontProcess */ + CARD16 length; +} xAppleWMSetFrontProcessReq; +#define sz_xAppleWMSetFrontProcessReq 4 + +typedef struct _AppleWMSetWindowLevel { + CARD8 reqType; /* always WMReqCode */ + CARD8 wmReqType; /* always X_AppleWMSetWindowLevel */ + CARD16 length; + CARD32 window; + CARD32 level; +} xAppleWMSetWindowLevelReq; +#define sz_xAppleWMSetWindowLevelReq 12 + +typedef struct _AppleWMSendPSN { + CARD8 reqType; /* always WMReqCode */ + CARD8 wmReqType; /* always X_AppleWMSendPSN */ + CARD16 length; + CARD32 psn_hi; + CARD32 psn_lo; +} xAppleWMSendPSNReq; +#define sz_xAppleWMSendPSNReq 12 + +typedef struct _AppleWMAttachTransient { + CARD8 reqType; /* always WMReqCode */ + CARD8 wmReqType; /* always X_AppleWMAttachTransient */ + CARD16 length; + CARD32 child; + CARD32 parent; +} xAppleWMAttachTransientReq; +#define sz_xAppleWMAttachTransientReq 12 + +typedef struct _AppleWMSetCanQuit { + CARD8 reqType; /* always WMReqCode */ + CARD8 wmReqType; /* always X_AppleWMSetCanQuit */ + CARD16 length; + CARD32 state; +} xAppleWMSetCanQuitReq; +#define sz_xAppleWMSetCanQuitReq 8 + +typedef struct _AppleWMFrameGetRect { + CARD8 reqType; /* always WMReqCode */ + CARD8 wmReqType; /* always X_AppleWMFrameGetRect */ + CARD16 length; + CARD16 frame_class; + CARD16 frame_rect; + CARD16 ix; + CARD16 iy; + CARD16 iw; + CARD16 ih; + CARD16 ox; + CARD16 oy; + CARD16 ow; + CARD16 oh; +} xAppleWMFrameGetRectReq; +#define sz_xAppleWMFrameGetRectReq 24 + +typedef struct { + BYTE type; /* X_Reply */ + BOOL pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD16 x; + CARD16 y; + CARD16 w; + CARD16 h; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xAppleWMFrameGetRectReply; +#define sz_xAppleWMFrameGetRectReply 32 + +typedef struct _AppleWMFrameHitTest { + CARD8 reqType; /* always WMReqCode */ + CARD8 wmReqType; /* always X_AppleWMFrameHitTest */ + CARD16 length; + CARD16 frame_class; + CARD16 pad1; + CARD16 px; + CARD16 py; + CARD16 ix; + CARD16 iy; + CARD16 iw; + CARD16 ih; + CARD16 ox; + CARD16 oy; + CARD16 ow; + CARD16 oh; +} xAppleWMFrameHitTestReq; +#define sz_xAppleWMFrameHitTestReq 28 + +typedef struct { + BYTE type; /* X_Reply */ + BOOL pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 ret; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xAppleWMFrameHitTestReply; +#define sz_xAppleWMFrameHitTestReply 32 + +typedef struct _AppleWMFrameDraw { + CARD8 reqType; /* always WMReqCode */ + CARD8 wmReqType; /* always X_AppleWMFrameDraw */ + CARD16 length; + CARD32 screen; + CARD32 window; + CARD16 frame_class; + CARD16 frame_attr; + CARD16 ix; + CARD16 iy; + CARD16 iw; + CARD16 ih; + CARD16 ox; + CARD16 oy; + CARD16 ow; + CARD16 oh; + CARD32 title_length; +} xAppleWMFrameDrawReq; +#define sz_xAppleWMFrameDrawReq 36 + +/* restore these definitions back to the typedefs in X.h */ +#undef Window +#undef Drawable +#undef Font +#undef Pixmap +#undef Cursor +#undef Colormap +#undef GContext +#undef Atom +#undef VisualID +#undef Time +#undef KeyCode +#undef KeySym + +#endif /* _APPLEWMPROTO_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/bigreqsproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/bigreqsproto.h new file mode 100644 index 0000000000000000000000000000000000000000..df96a766fd145ebd1c546c78f4942ec5b87c7289 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/bigreqsproto.h @@ -0,0 +1,67 @@ +/* + +Copyright 1992, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +*/ + +#ifndef _BIGREQSPROTO_H_ +#define _BIGREQSPROTO_H_ + +#define X_BigReqEnable 0 + +#define XBigReqNumberEvents 0 + +#define XBigReqNumberErrors 0 + +#define XBigReqExtensionName "BIG-REQUESTS" + +typedef struct { + CARD8 reqType; /* always XBigReqCode */ + CARD8 brReqType; /* always X_BigReqEnable */ + CARD16 length; +} xBigReqEnableReq; +#define sz_xBigReqEnableReq 4 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 pad0; + CARD16 sequenceNumber; + CARD32 length; + CARD32 max_request_size; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xBigReqEnableReply; +#define sz_xBigReqEnableReply 32 + + +typedef struct { + CARD8 reqType; + CARD8 data; + CARD16 zero; + CARD32 length; +} xBigReq; + +#endif /* _BIGREQSPROTO_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/bigreqstr.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/bigreqstr.h new file mode 100644 index 0000000000000000000000000000000000000000..0a023dbf1c4044af188c6921cd883a9bedd579eb --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/bigreqstr.h @@ -0,0 +1,3 @@ +#warning "bigreqstr.h is obsolete and may be removed in the future." +#warning "include for the protocol defines." +#include diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/composite.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/composite.h new file mode 100644 index 0000000000000000000000000000000000000000..e942700ee4cf7b9e71ff93e7bf1c8611c3fab035 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/composite.h @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2006, Oracle and/or its affiliates. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ +/* + * Copyright © 2003 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _COMPOSITE_H_ +#define _COMPOSITE_H_ + +#include + +#define COMPOSITE_NAME "Composite" +#define COMPOSITE_MAJOR 0 +#define COMPOSITE_MINOR 4 + +#define CompositeRedirectAutomatic 0 +#define CompositeRedirectManual 1 + +#define X_CompositeQueryVersion 0 +#define X_CompositeRedirectWindow 1 +#define X_CompositeRedirectSubwindows 2 +#define X_CompositeUnredirectWindow 3 +#define X_CompositeUnredirectSubwindows 4 +#define X_CompositeCreateRegionFromBorderClip 5 +#define X_CompositeNameWindowPixmap 6 +#define X_CompositeGetOverlayWindow 7 +#define X_CompositeReleaseOverlayWindow 8 + +#define CompositeNumberRequests (X_CompositeReleaseOverlayWindow + 1) + +#define CompositeNumberEvents 0 + +#endif /* _COMPOSITE_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/compositeproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/compositeproto.h new file mode 100644 index 0000000000000000000000000000000000000000..5a9ca6f3b60bcc1a2a7a92a494774f3771d0eac3 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/compositeproto.h @@ -0,0 +1,192 @@ +/* + * Copyright (c) 2006, Oracle and/or its affiliates. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ +/* + * Copyright © 2003 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _COMPOSITEPROTO_H_ +#define _COMPOSITEPROTO_H_ + +#include +#include + +#define Window CARD32 +#define Region CARD32 +#define Pixmap CARD32 + +/* + * requests and replies + */ +typedef struct { + CARD8 reqType; + CARD8 compositeReqType; + CARD16 length; + CARD32 majorVersion; + CARD32 minorVersion; +} xCompositeQueryVersionReq; + +#define sz_xCompositeQueryVersionReq 12 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 majorVersion; + CARD32 minorVersion; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xCompositeQueryVersionReply; + +#define sz_xCompositeQueryVersionReply 32 + +typedef struct { + CARD8 reqType; + CARD8 compositeReqType; + CARD16 length; + Window window; + CARD8 update; + CARD8 pad1; + CARD16 pad2; +} xCompositeRedirectWindowReq; + +#define sz_xCompositeRedirectWindowReq 12 + +typedef struct { + CARD8 reqType; + CARD8 compositeReqType; + CARD16 length; + Window window; + CARD8 update; + CARD8 pad1; + CARD16 pad2; +} xCompositeRedirectSubwindowsReq; + +#define sz_xCompositeRedirectSubwindowsReq 12 + +typedef struct { + CARD8 reqType; + CARD8 compositeReqType; + CARD16 length; + Window window; + CARD8 update; + CARD8 pad1; + CARD16 pad2; +} xCompositeUnredirectWindowReq; + +#define sz_xCompositeUnredirectWindowReq 12 + +typedef struct { + CARD8 reqType; + CARD8 compositeReqType; + CARD16 length; + Window window; + CARD8 update; + CARD8 pad1; + CARD16 pad2; +} xCompositeUnredirectSubwindowsReq; + +#define sz_xCompositeUnredirectSubwindowsReq 12 + +typedef struct { + CARD8 reqType; + CARD8 compositeReqType; + CARD16 length; + Region region; + Window window; +} xCompositeCreateRegionFromBorderClipReq; + +#define sz_xCompositeCreateRegionFromBorderClipReq 12 + +/* Version 0.2 additions */ + +typedef struct { + CARD8 reqType; + CARD8 compositeReqType; + CARD16 length; + Window window; + Pixmap pixmap; +} xCompositeNameWindowPixmapReq; + +#define sz_xCompositeNameWindowPixmapReq 12 + +/* Version 0.3 additions */ + +typedef struct { + CARD8 reqType; + CARD8 compositeReqType; + CARD16 length; + Window window; +} xCompositeGetOverlayWindowReq; + +#define sz_xCompositeGetOverlayWindowReq sizeof(xCompositeGetOverlayWindowReq) + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber; + CARD32 length; + Window overlayWin; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xCompositeGetOverlayWindowReply; + +#define sz_xCompositeGetOverlayWindowReply sizeof(xCompositeGetOverlayWindowReply) + +typedef struct { + CARD8 reqType; + CARD8 compositeReqType; + CARD16 length; + Window window; +} xCompositeReleaseOverlayWindowReq; + +#define sz_xCompositeReleaseOverlayWindowReq sizeof(xCompositeReleaseOverlayWindowReq) + +#undef Window +#undef Region +#undef Pixmap + +#endif /* _COMPOSITEPROTO_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/cup.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/cup.h new file mode 100644 index 0000000000000000000000000000000000000000..cbbc34bf8e9f7d1225b7bbb4fa11d163cf599725 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/cup.h @@ -0,0 +1,38 @@ +/* + +Copyright 1987, 1988, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +*/ + +#ifndef _CUP_H_ +#define _CUP_H_ + +#define XCUPNAME "TOG-CUP" + +#define XCUP_MAJOR_VERSION 1 /* current version numbers */ +#define XCUP_MINOR_VERSION 0 + +#define XcupNumberErrors 0 + +#endif /* _CUP_H_ */ + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/cupproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/cupproto.h new file mode 100644 index 0000000000000000000000000000000000000000..a0c3d16e8a3a2193c1cada7219ebfd73c1aa6ca4 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/cupproto.h @@ -0,0 +1,105 @@ +/* + +Copyright 1987, 1988, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +*/ + +#ifndef _XCUPPROTO_H_ /* { */ +#define _XCUPPROTO_H_ + +#include + +#define X_XcupQueryVersion 0 +#define X_XcupGetReservedColormapEntries 1 +#define X_XcupStoreColors 2 + +typedef struct _XcupQueryVersion { + CARD8 reqType; /* always XcupReqCode */ + CARD8 xcupReqType; /* always X_XcupQueryVersion */ + CARD16 length; + CARD16 client_major_version; + CARD16 client_minor_version; +} xXcupQueryVersionReq; +#define sz_xXcupQueryVersionReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + BOOL pad1; + CARD16 sequence_number; + CARD32 length; + CARD16 server_major_version; + CARD16 server_minor_version; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xXcupQueryVersionReply; +#define sz_xXcupQueryVersionReply 32 + +typedef struct _XcupGetReservedColormapEntries { + CARD8 reqType; /* always XcupReqCode */ + CARD8 xcupReqType; /* always X_XcupGetReservedColormapEntries */ + CARD16 length; + CARD32 screen; +} xXcupGetReservedColormapEntriesReq; +#define sz_xXcupGetReservedColormapEntriesReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + BOOL pad1; + CARD16 sequence_number; + CARD32 length; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; + CARD32 pad7; +} xXcupGetReservedColormapEntriesReply; +#define sz_xXcupGetReservedColormapEntriesReply 32 + +typedef struct _XcupStoreColors { + CARD8 reqType; /* always XcupReqCode */ + CARD8 xcupReqType; /* always X_XcupStoreColors */ + CARD16 length; + CARD32 cmap; +} xXcupStoreColorsReq; +#define sz_xXcupStoreColorsReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + BOOL pad1; + CARD16 sequence_number; + CARD32 length; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; + CARD32 pad7; +} xXcupStoreColorsReply; +#define sz_xXcupStoreColorsReply 32 + +#endif /* } _XCUPPROTO_H_ */ + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/damageproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/damageproto.h new file mode 100644 index 0000000000000000000000000000000000000000..bff6c180ef0498db5e409fb09e1fb82fcc5b77a8 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/damageproto.h @@ -0,0 +1,158 @@ +/* + * Copyright © 2003 Keith Packard + * Copyright © 2007 Eric Anholt + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _DAMAGEPROTO_H_ +#define _DAMAGEPROTO_H_ + +#include +#include +#include + +#define Window CARD32 +#define Drawable CARD32 +#define Font CARD32 +#define Pixmap CARD32 +#define Cursor CARD32 +#define Colormap CARD32 +#define GContext CARD32 +#define Atom CARD32 +#define VisualID CARD32 +#define Time CARD32 +#define KeyCode CARD8 +#define KeySym CARD32 +#define Picture CARD32 +#define Region CARD32 +#define Damage CARD32 + +/************** Version 0 ******************/ + +typedef struct { + CARD8 reqType; + CARD8 damageReqType; + CARD16 length; +} xDamageReq; + +/* + * requests and replies + */ + +typedef struct { + CARD8 reqType; + CARD8 damageReqType; + CARD16 length; + CARD32 majorVersion; + CARD32 minorVersion; +} xDamageQueryVersionReq; + +#define sz_xDamageQueryVersionReq 12 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 majorVersion; + CARD32 minorVersion; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xDamageQueryVersionReply; + +#define sz_xDamageQueryVersionReply 32 + +typedef struct { + CARD8 reqType; + CARD8 damageReqType; + CARD16 length; + Damage damage; + Drawable drawable; + CARD8 level; + CARD8 pad1; + CARD16 pad2; +} xDamageCreateReq; + +#define sz_xDamageCreateReq 16 + +typedef struct { + CARD8 reqType; + CARD8 damageReqType; + CARD16 length; + Damage damage; +} xDamageDestroyReq; + +#define sz_xDamageDestroyReq 8 + +typedef struct { + CARD8 reqType; + CARD8 damageReqType; + CARD16 length; + Damage damage; + Region repair; + Region parts; +} xDamageSubtractReq; + +#define sz_xDamageSubtractReq 16 + +typedef struct { + CARD8 reqType; + CARD8 damageReqType; + CARD16 length; + Drawable drawable; + Region region; +} xDamageAddReq; + +#define sz_xDamageAddReq 12 + +/* Events */ + +#define DamageNotifyMore 0x80 + +typedef struct { + CARD8 type; + CARD8 level; + CARD16 sequenceNumber; + Drawable drawable; + Damage damage; + Time timestamp; + xRectangle area; + xRectangle geometry; +} xDamageNotifyEvent; + +#undef Damage +#undef Region +#undef Picture +#undef Window +#undef Drawable +#undef Font +#undef Pixmap +#undef Cursor +#undef Colormap +#undef GContext +#undef Atom +#undef VisualID +#undef Time +#undef KeyCode +#undef KeySym + +#endif /* _DAMAGEPROTO_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/damagewire.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/damagewire.h new file mode 100644 index 0000000000000000000000000000000000000000..d90a0dd7c490dbe52693ebbffb1afa5c1abfaea3 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/damagewire.h @@ -0,0 +1,56 @@ +/* + * Copyright © 2003 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _DAMAGEWIRE_H_ +#define _DAMAGEWIRE_H_ + +#define DAMAGE_NAME "DAMAGE" +#define DAMAGE_MAJOR 1 +#define DAMAGE_MINOR 1 + +/************* Version 1 ****************/ + +/* Constants */ +#define XDamageReportRawRectangles 0 +#define XDamageReportDeltaRectangles 1 +#define XDamageReportBoundingBox 2 +#define XDamageReportNonEmpty 3 + +/* Requests */ +#define X_DamageQueryVersion 0 +#define X_DamageCreate 1 +#define X_DamageDestroy 2 +#define X_DamageSubtract 3 +#define X_DamageAdd 4 + +#define XDamageNumberRequests (X_DamageAdd + 1) + +/* Events */ +#define XDamageNotify 0 + +#define XDamageNumberEvents (XDamageNotify + 1) + +/* Errors */ +#define BadDamage 0 +#define XDamageNumberErrors (BadDamage + 1) + +#endif /* _DAMAGEWIRE_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/dbe.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/dbe.h new file mode 100644 index 0000000000000000000000000000000000000000..7968552d3206caedb7ffd9b477ab97afae25f582 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/dbe.h @@ -0,0 +1,57 @@ +/****************************************************************************** + * + * Copyright (c) 1994, 1995 Hewlett-Packard Company + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR + * THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of the Hewlett-Packard + * Company shall not be used in advertising or otherwise to promote the + * sale, use or other dealings in this Software without prior written + * authorization from the Hewlett-Packard Company. + * + * Header file for Xlib-related DBE + * + *****************************************************************************/ + +#ifndef DBE_H +#define DBE_H + +/* Values for swap_action field of XdbeSwapInfo structure */ +#define XdbeUndefined 0 +#define XdbeBackground 1 +#define XdbeUntouched 2 +#define XdbeCopied 3 + +/* Errors */ +#define XdbeBadBuffer 0 + +#define DBE_PROTOCOL_NAME "DOUBLE-BUFFER" + +/* Current version numbers */ +#define DBE_MAJOR_VERSION 1 +#define DBE_MINOR_VERSION 0 + +/* Used when adding extension; also used in Xdbe macros */ +#define DbeNumberEvents 0 +#define DbeBadBuffer 0 +#define DbeNumberErrors (DbeBadBuffer + 1) + +#endif /* DBE_H */ + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/dbeproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/dbeproto.h new file mode 100644 index 0000000000000000000000000000000000000000..d6f7123885aad157f19ea6236481ad59c7a0c7c6 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/dbeproto.h @@ -0,0 +1,224 @@ +/****************************************************************************** + * + * Copyright (c) 1994, 1995 Hewlett-Packard Company + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR + * THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the name of the Hewlett-Packard + * Company shall not be used in advertising or otherwise to promote the + * sale, use or other dealings in this Software without prior written + * authorization from the Hewlett-Packard Company. + * + * Header file for Xlib-related DBE + * + *****************************************************************************/ + +#ifndef DBE_PROTO_H +#define DBE_PROTO_H + +#include + +/* Request values used in (S)ProcDbeDispatch() */ +#define X_DbeGetVersion 0 +#define X_DbeAllocateBackBufferName 1 +#define X_DbeDeallocateBackBufferName 2 +#define X_DbeSwapBuffers 3 +#define X_DbeBeginIdiom 4 +#define X_DbeEndIdiom 5 +#define X_DbeGetVisualInfo 6 +#define X_DbeGetBackBufferAttributes 7 + +typedef CARD8 xDbeSwapAction; +typedef CARD32 xDbeBackBuffer; + +/* TYPEDEFS */ + +/* Protocol data types */ + +typedef struct +{ + CARD32 window; /* window */ + xDbeSwapAction swapAction; /* swap action */ + CARD8 pad1; /* unused */ + CARD16 pad2; + +} xDbeSwapInfo; + +typedef struct +{ + CARD32 visualID; /* associated visual */ + CARD8 depth; /* depth of visual */ + CARD8 perfLevel; /* performance level hint */ + CARD16 pad1; + +} xDbeVisInfo; +#define sz_xDbeVisInfo 8 + +typedef struct +{ + CARD32 n; /* number of visual info items in list */ + +} xDbeScreenVisInfo; /* followed by n xDbeVisInfo items */ + +typedef struct +{ + CARD32 window; /* window */ + +} xDbeBufferAttributes; + + +/* Requests and replies */ + +typedef struct +{ + CARD8 reqType; /* major-opcode: always codes->major_opcode */ + CARD8 dbeReqType; /* minor-opcode: always X_DbeGetVersion (0) */ + CARD16 length; /* request length: (2) */ + CARD8 majorVersion; /* client-major-version */ + CARD8 minorVersion; /* client-minor-version */ + CARD16 unused; /* unused */ + +} xDbeGetVersionReq; +#define sz_xDbeGetVersionReq 8 + +typedef struct +{ + BYTE type; /* Reply: X_Reply (1) */ + CARD8 unused; /* unused */ + CARD16 sequenceNumber; /* sequence number */ + CARD32 length; /* reply length: (0) */ + CARD8 majorVersion; /* server-major-version */ + CARD8 minorVersion; /* server-minor-version */ + CARD16 pad1; /* unused */ + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; + +} xDbeGetVersionReply; +#define sz_xDbeGetVersionReply 32 + +typedef struct +{ + CARD8 reqType; /* major-opcode: codes->major_opcode */ + CARD8 dbeReqType; /* X_DbeAllocateBackBufferName (1) */ + CARD16 length; /* request length: (4) */ + CARD32 window; /* window */ + xDbeBackBuffer buffer; /* back buffer name */ + xDbeSwapAction swapAction; /* swap action hint */ + CARD8 pad1; /* unused */ + CARD16 pad2; + +} xDbeAllocateBackBufferNameReq; +#define sz_xDbeAllocateBackBufferNameReq 16 + +typedef struct +{ + CARD8 reqType; /* major-opcode: codes->major_opcode */ + CARD8 dbeReqType; /* X_DbeDeallocateBackBufferName (2) */ + CARD16 length; /* request length: (2) */ + xDbeBackBuffer buffer; /* back buffer name */ + +} xDbeDeallocateBackBufferNameReq; +#define sz_xDbeDeallocateBackBufferNameReq 8 + +typedef struct +{ + CARD8 reqType; /* major-opcode: always codes->major_opcode */ + CARD8 dbeReqType; /* minor-opcode: always X_DbeSwapBuffers (3) */ + CARD16 length; /* request length: (2+2n) */ + CARD32 n; /* n, number of window/swap action pairs */ + +} xDbeSwapBuffersReq; /* followed by n window/swap action pairs */ +#define sz_xDbeSwapBuffersReq 8 + +typedef struct +{ + CARD8 reqType; /* major-opcode: always codes->major_opcode */ + CARD8 dbeReqType; /* minor-opcode: always X_DbeBeginIdom (4) */ + CARD16 length; /* request length: (1) */ + +} xDbeBeginIdiomReq; +#define sz_xDbeBeginIdiomReq 4 + +typedef struct +{ + CARD8 reqType; /* major-opcode: always codes->major_opcode */ + CARD8 dbeReqType; /* minor-opcode: always X_DbeEndIdom (5) */ + CARD16 length; /* request length: (1) */ + +} xDbeEndIdiomReq; +#define sz_xDbeEndIdiomReq 4 + +typedef struct +{ + CARD8 reqType; /* always codes->major_opcode */ + CARD8 dbeReqType; /* always X_DbeGetVisualInfo (6) */ + CARD16 length; /* request length: (2+n) */ + CARD32 n; /* n, number of drawables in list */ + +} xDbeGetVisualInfoReq; /* followed by n drawables */ +#define sz_xDbeGetVisualInfoReq 8 + +typedef struct +{ + BYTE type; /* Reply: X_Reply (1) */ + CARD8 unused; /* unused */ + CARD16 sequenceNumber; /* sequence number */ + CARD32 length; /* reply length */ + CARD32 m; /* m, number of visual infos in list */ + CARD32 pad1; /* unused */ + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + +} xDbeGetVisualInfoReply; /* followed by m visual infos */ +#define sz_xDbeGetVisualInfoReply 32 + +typedef struct +{ + CARD8 reqType; /* always codes->major_opcode */ + CARD8 dbeReqType; /* X_DbeGetBackBufferAttributes (7) */ + CARD16 length; /* request length: (2) */ + xDbeBackBuffer buffer; /* back buffer name */ + +} xDbeGetBackBufferAttributesReq; +#define sz_xDbeGetBackBufferAttributesReq 8 + +typedef struct +{ + BYTE type; /* Reply: X_Reply (1) */ + CARD8 unused; /* unused */ + CARD16 sequenceNumber; /* sequence number */ + CARD32 length; /* reply length: (0) */ + CARD32 attributes; /* attributes */ + CARD32 pad1; /* unused */ + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + +} xDbeGetBackBufferAttributesReply; +#define sz_xDbeGetBackBufferAttributesReply 32 + +#endif /* DBE_PROTO_H */ + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/dmx.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/dmx.h new file mode 100644 index 0000000000000000000000000000000000000000..8cbd4d3672f0e527867063236857da5d587845b9 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/dmx.h @@ -0,0 +1,68 @@ +/* + * Copyright 2002-2004 Red Hat Inc., Durham, North Carolina. + * + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation on the rights to use, copy, modify, merge, + * publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice (including the + * next paragraph) shall be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON-INFRINGEMENT. IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +/* + * Authors: + * Rickard E. (Rik) Faith + * + */ + +/** \file + * This file describes the interface to the client-side libdmx.a + * library. All DMX-aware client-side applications should include this + * file. */ + +#ifndef _DMX_H_ +#define _DMX_H_ + +/* These values must be larger than LastExtensionError. + The values in dmxext.h and dmxproto.h *MUST* match. */ +#define DmxBadXinerama 1001 +#define DmxBadValue 1002 +#define DmxBadReply 1003 + +#define DMXScreenWindowWidth (1L<<0) +#define DMXScreenWindowHeight (1L<<1) +#define DMXScreenWindowXoffset (1L<<2) +#define DMXScreenWindowYoffset (1L<<3) +#define DMXRootWindowWidth (1L<<4) +#define DMXRootWindowHeight (1L<<5) +#define DMXRootWindowXoffset (1L<<6) +#define DMXRootWindowYoffset (1L<<7) +#define DMXRootWindowXorigin (1L<<8) +#define DMXRootWindowYorigin (1L<<9) + +#define DMXDesktopWidth (1L<<0) +#define DMXDesktopHeight (1L<<1) +#define DMXDesktopShiftX (1L<<2) +#define DMXDesktopShiftY (1L<<3) + +#define DMXInputType (1L<<0) +#define DMXInputPhysicalScreen (1L<<1) +#define DMXInputSendsCore (1L<<2) + +#endif diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/dmxproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/dmxproto.h new file mode 100644 index 0000000000000000000000000000000000000000..c8bc862867848dd4d54d3ec5158f47c67ee3ddbb --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/dmxproto.h @@ -0,0 +1,445 @@ +/* + * Copyright 2002-2004 Red Hat Inc., Durham, North Carolina. + * + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation on the rights to use, copy, modify, merge, + * publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice (including the + * next paragraph) shall be included in all copies or substantial + * portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NON-INFRINGEMENT. IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +/* + * Authors: + * Rickard E. (Rik) Faith + * + */ + +/** \file + * This file describes the structures necessary to implement the wire + * protocol for the DMX protocol extension. It should be included only + * in files that implement the client-side (or server-side) part of the + * protocol (i.e., client-side applications should \b not include this + * file). */ + +#ifndef _DMXSTR_H_ +#define _DMXSTR_H_ + +#define DMX_EXTENSION_NAME "DMX" +#define DMX_EXTENSION_MAJOR 2 +#define DMX_EXTENSION_MINOR 2 +#define DMX_EXTENSION_PATCH 20040604 + +/* These values must be larger than LastExtensionError. + The values in dmxext.h and dmxproto.h *MUST* match. */ +#define DMX_BAD_XINERAMA 1001 +#define DMX_BAD_VALUE 1002 + +#define X_DMXQueryVersion 0 +#define X_DMXGetScreenCount 1 +#define X_DMXGetScreenInformationDEPRECATED 2 +#define X_DMXGetWindowAttributes 3 +#define X_DMXGetInputCount 4 +#define X_DMXGetInputAttributes 5 +#define X_DMXForceWindowCreationDEPRECATED 6 +#define X_DMXReconfigureScreenDEPRECATED 7 +#define X_DMXSync 8 +#define X_DMXForceWindowCreation 9 +#define X_DMXGetScreenAttributes 10 +#define X_DMXChangeScreensAttributes 11 +#define X_DMXAddScreen 12 +#define X_DMXRemoveScreen 13 +#define X_DMXGetDesktopAttributes 14 +#define X_DMXChangeDesktopAttributes 15 +#define X_DMXAddInput 16 +#define X_DMXRemoveInput 17 + +/** Wire-level description of DMXQueryVersion protocol request. */ +typedef struct { + CARD8 reqType; /* dmxcode */ + CARD8 dmxReqType; /* X_DMXQueryVersion */ + CARD16 length; +} xDMXQueryVersionReq; +#define sz_xDMXQueryVersionReq 4 + +/** Wire-level description of DMXQueryVersion protocol reply. */ +typedef struct { + BYTE type; /* X_Reply */ + CARD8 ununsed; + CARD16 sequenceNumber; + CARD32 length; + CARD32 majorVersion; + CARD32 minorVersion; + CARD32 patchVersion; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; +} xDMXQueryVersionReply; +#define sz_xDMXQueryVersionReply 32 + +/** Wire-level description of DMXSync protocol request. */ +typedef struct { + CARD8 reqType; /* DMXCode */ + CARD8 dmxReqType; /* X_DMXSync */ + CARD16 length; +} xDMXSyncReq; +#define sz_xDMXSyncReq 4 + +/** Wire-level description of DMXSync protocol reply. */ +typedef struct { + BYTE type; /* X_Reply */ + CARD8 unused; + CARD16 sequenceNumber; + CARD32 length; + CARD32 status; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xDMXSyncReply; +#define sz_xDMXSyncReply 32 + +/** Wire-level description of DMXForceWindowCreation protocol request. */ +typedef struct { + CARD8 reqType; /* DMXCode */ + CARD8 dmxReqType; /* X_DMXForceWindowCreation */ + CARD16 length; + CARD32 window; +} xDMXForceWindowCreationReq; +#define sz_xDMXForceWindowCreationReq 8 + +/** Wire-level description of DMXForceWindowCreation protocol reply. */ +typedef struct { + BYTE type; /* X_Reply */ + CARD8 unused; + CARD16 sequenceNumber; + CARD32 length; + CARD32 status; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xDMXForceWindowCreationReply; +#define sz_xDMXForceWindowCreationReply 32 + +/** Wire-level description of DMXGetScreenCount protocol request. */ +typedef struct { + CARD8 reqType; /* DMXCode */ + CARD8 dmxReqType; /* X_DMXGetScreenCount */ + CARD16 length; +} xDMXGetScreenCountReq; +#define sz_xDMXGetScreenCountReq 4 + +/** Wire-level description of DMXGetScreenCount protocol reply. */ +typedef struct { + BYTE type; /* X_Reply */ + CARD8 unused; + CARD16 sequenceNumber; + CARD32 length; + CARD32 screenCount; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xDMXGetScreenCountReply; +#define sz_xDMXGetScreenCountReply 32 + +/** Wire-level description of DMXGetScreenAttributes protocol request. */ +typedef struct { + CARD8 reqType; /* DMXCode */ + CARD8 dmxReqType; /* X_DMXGetScreenAttributes */ + CARD16 length; + CARD32 physicalScreen; +} xDMXGetScreenAttributesReq; +#define sz_xDMXGetScreenAttributesReq 8 + +/** Wire-level description of DMXGetScreenAttributes protocol reply. */ +typedef struct { + BYTE type; /* X_Reply */ + CARD8 unused; + CARD16 sequenceNumber; + CARD32 length; + CARD32 displayNameLength; + CARD32 logicalScreen; + + CARD16 screenWindowWidth; + CARD16 screenWindowHeight; + INT16 screenWindowXoffset; + INT16 screenWindowYoffset; + + CARD16 rootWindowWidth; + CARD16 rootWindowHeight; + INT16 rootWindowXoffset; + INT16 rootWindowYoffset; + INT16 rootWindowXorigin; + INT16 rootWindowYorigin; +} xDMXGetScreenAttributesReply; +#define sz_xDMXGetScreenAttributesReply 36 + +/** Wire-level description of DMXChangeScreensAttributes protocol request. */ +typedef struct { + CARD8 reqType; /* DMXCode */ + CARD8 dmxReqType; /* X_DMXChangeScreensAttributes */ + CARD16 length; + CARD32 screenCount; + CARD32 maskCount; +} xDMXChangeScreensAttributesReq; +#define sz_xDMXChangeScreensAttributesReq 12 + +/** Wire-level description of DMXChangeScreensAttributes protocol reply. */ +typedef struct { + BYTE type; /* X_Reply */ + CARD8 unused; + CARD16 sequenceNumber; + CARD32 length; + CARD32 status; + CARD32 errorScreen; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; +} xDMXChangeScreensAttributesReply; +#define sz_xDMXChangeScreensAttributesReply 32 + +/** Wire-level description of DMXAddScreen protocol request. */ +typedef struct { + CARD8 reqType; /* DMXCode */ + CARD8 dmxReqType; /* X_DMXAddScreen */ + CARD16 length; + CARD32 displayNameLength; + CARD32 physicalScreen; + CARD32 valueMask; +} xDMXAddScreenReq; +#define sz_xDMXAddScreenReq 16 + +/** Wire-level description of DMXAddScreen protocol reply. */ +typedef struct { + BYTE type; /* X_Reply */ + CARD8 unused; + CARD16 sequenceNumber; + CARD32 length; + CARD32 status; + CARD32 physicalScreen; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; +} xDMXAddScreenReply; +#define sz_xDMXAddScreenReply 32 + +/** Wire-level description of DMXRemoveScreen protocol request. */ +typedef struct { + CARD8 reqType; /* DMXCode */ + CARD8 dmxReqType; /* X_DMXRemoveScreen */ + CARD16 length; + CARD32 physicalScreen; +} xDMXRemoveScreenReq; +#define sz_xDMXRemoveScreenReq 8 + +/** Wire-level description of DMXRemoveScreen protocol reply. */ +typedef struct { + BYTE type; /* X_Reply */ + CARD8 unused; + CARD16 sequenceNumber; + CARD32 length; + CARD32 status; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xDMXRemoveScreenReply; +#define sz_xDMXRemoveScreenReply 32 + +/** Wire-level description of DMXGetWindowAttributes protocol request. */ +typedef struct { + CARD8 reqType; /* DMXCode */ + CARD8 dmxReqType; /* X_DMXGetWindowAttributes */ + CARD16 length; + CARD32 window; +} xDMXGetWindowAttributesReq; +#define sz_xDMXGetWindowAttributesReq 8 + +/** Wire-level description of DMXGetWindowAttributes protocol reply. */ +typedef struct { + BYTE type; /* X_Reply */ + CARD8 unused; + CARD16 sequenceNumber; + CARD32 length; + CARD32 screenCount; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xDMXGetWindowAttributesReply; +#define sz_xDMXGetWindowAttributesReply 32 + +/** Wire-level description of DMXGetDesktopAttributes protocol request. */ +typedef struct { + CARD8 reqType; /* DMXCode */ + CARD8 dmxReqType; /* X_DMXGetDesktopAttributes */ + CARD16 length; +} xDMXGetDesktopAttributesReq; +#define sz_xDMXGetDesktopAttributesReq 4 + +/** Wire-level description of DMXGetDesktopAttributes protocol reply. */ +typedef struct { + BYTE type; /* X_Reply */ + CARD8 unused; + CARD16 sequenceNumber; + CARD32 length; + INT16 width; + INT16 height; + INT16 shiftX; + INT16 shiftY; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; +} xDMXGetDesktopAttributesReply; +#define sz_xDMXGetDesktopAttributesReply 32 + +/** Wire-level description of DMXChangeDesktopAttributes protocol request. */ +typedef struct { + CARD8 reqType; /* DMXCode */ + CARD8 dmxReqType; /* X_DMXChangeDesktopAttributes */ + CARD16 length; + CARD32 valueMask; +} xDMXChangeDesktopAttributesReq; +#define sz_xDMXChangeDesktopAttributesReq 8 + +/** Wire-level description of DMXChangeDesktopAttributes protocol reply. */ +typedef struct { + BYTE type; /* X_Reply */ + CARD8 unused; + CARD16 sequenceNumber; + CARD32 length; + CARD32 status; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xDMXChangeDesktopAttributesReply; +#define sz_xDMXChangeDesktopAttributesReply 32 + +/** Wire-level description of DMXGetInputCount protocol request. */ +typedef struct { + CARD8 reqType; /* DMXCode */ + CARD8 dmxReqType; /* X_DMXGetInputCount */ + CARD16 length; +} xDMXGetInputCountReq; +#define sz_xDMXGetInputCountReq 4 + +/** Wire-level description of DMXGetInputCount protocol reply. */ +typedef struct { + BYTE type; /* X_Reply */ + CARD8 unused; + CARD16 sequenceNumber; + CARD32 length; + CARD32 inputCount; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xDMXGetInputCountReply; +#define sz_xDMXGetInputCountReply 32 + +/** Wire-level description of DMXGetInputAttributes protocol request. */ +typedef struct { + CARD8 reqType; /* DMXCode */ + CARD8 dmxReqType; /* X_DMXGetInputAttributes */ + CARD16 length; + CARD32 deviceId; +} xDMXGetInputAttributesReq; +#define sz_xDMXGetInputAttributesReq 8 + +/** Wire-level description of DMXGetInputAttributes protocol reply. */ +typedef struct { + BYTE type; /* X_Reply */ + CARD8 unused; + CARD16 sequenceNumber; + CARD32 length; + CARD32 inputType; + CARD32 physicalScreen; + CARD32 physicalId; + CARD32 nameLength; + BOOL isCore; + BOOL sendsCore; + BOOL detached; + CARD8 pad0; + CARD32 pad1; +} xDMXGetInputAttributesReply; +#define sz_xDMXGetInputAttributesReply 32 + +/** Wire-level description of DMXAddInput protocol request. */ +typedef struct { + CARD8 reqType; /* DMXCode */ + CARD8 dmxReqType; /* X_DMXAddInput */ + CARD16 length; + CARD32 displayNameLength; + CARD32 valueMask; +} xDMXAddInputReq; +#define sz_xDMXAddInputReq 12 + +/** Wire-level description of DMXAddInput protocol reply. */ +typedef struct { + BYTE type; /* X_Reply */ + CARD8 unused; + CARD16 sequenceNumber; + CARD32 length; + CARD32 status; + CARD32 physicalId; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; +} xDMXAddInputReply; +#define sz_xDMXAddInputReply 32 + +/** Wire-level description of DMXRemoveInput protocol request. */ +typedef struct { + CARD8 reqType; /* DMXCode */ + CARD8 dmxReqType; /* X_DMXRemoveInput */ + CARD16 length; + CARD32 physicalId; +} xDMXRemoveInputReq; +#define sz_xDMXRemoveInputReq 8 + +/** Wire-level description of DMXRemoveInput protocol reply. */ +typedef struct { + BYTE type; + CARD8 unused; + CARD16 sequenceNumber; + CARD32 length; + CARD32 status; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xDMXRemoveInputReply; +#define sz_xDMXRemoveInputReply 32 + +#endif diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/dpmsconst.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/dpmsconst.h new file mode 100644 index 0000000000000000000000000000000000000000..f46d2d9d6ea66e3ece0b6fe0c5c2194fb2f9d0f1 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/dpmsconst.h @@ -0,0 +1,46 @@ +/***************************************************************** + +Copyright (c) 1996 Digital Equipment Corporation, Maynard, Massachusetts. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +DIGITAL EQUIPMENT CORPORATION BE LIABLE FOR ANY CLAIM, DAMAGES, INCLUDING, +BUT NOT LIMITED TO CONSEQUENTIAL OR INCIDENTAL DAMAGES, OR OTHER LIABILITY, +WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR +IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of Digital Equipment Corporation +shall not be used in advertising or otherwise to promote the sale, use or other +dealings in this Software without prior written authorization from Digital +Equipment Corporation. + +******************************************************************/ + +#ifndef _DPMSCONST_H +#define _DPMSCONST_H 1 + +#define DPMSMajorVersion 1 +#define DPMSMinorVersion 2 + +#define DPMSExtensionName "DPMS" + +#define DPMSModeOn 0 +#define DPMSModeStandby 1 +#define DPMSModeSuspend 2 +#define DPMSModeOff 3 + +#define DPMSInfoNotifyMask (1L << 0) +#define DPMSInfoNotify 0 + +#endif /* !_DPMSCONST_H */ + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/dpmsproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/dpmsproto.h new file mode 100644 index 0000000000000000000000000000000000000000..6b7e4191489716b47f398cfca5e64577282e8be4 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/dpmsproto.h @@ -0,0 +1,201 @@ +/***************************************************************** + +Copyright (c) 1996 Digital Equipment Corporation, Maynard, Massachusetts. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +DIGITAL EQUIPMENT CORPORATION BE LIABLE FOR ANY CLAIM, DAMAGES, INCLUDING, +BUT NOT LIMITED TO CONSEQUENTIAL OR INCIDENTAL DAMAGES, OR OTHER LIABILITY, +WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR +IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of Digital Equipment Corporation +shall not be used in advertising or otherwise to promote the sale, use or other +dealings in this Software without prior written authorization from Digital +Equipment Corporation. + +******************************************************************/ + +#ifndef _DPMSPROTO_H_ +#define _DPMSPROTO_H_ + +#include + +#define X_DPMSGetVersion 0 +#define X_DPMSCapable 1 +#define X_DPMSGetTimeouts 2 +#define X_DPMSSetTimeouts 3 +#define X_DPMSEnable 4 +#define X_DPMSDisable 5 +#define X_DPMSForceLevel 6 +#define X_DPMSInfo 7 +#define X_DPMSSelectInput 8 + +#define DPMSNumberEvents 0 + +#define DPMSNumberErrors 0 + + +typedef struct { + CARD8 reqType; /* always DPMSCode */ + CARD8 dpmsReqType; /* always X_DPMSGetVersion */ + CARD16 length; + CARD16 majorVersion; + CARD16 minorVersion; +} xDPMSGetVersionReq; +#define sz_xDPMSGetVersionReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 pad0; + CARD16 sequenceNumber; + CARD32 length; + CARD16 majorVersion; + CARD16 minorVersion; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xDPMSGetVersionReply; +#define sz_xDPMSGetVersionReply 32 + +typedef struct { + CARD8 reqType; /* always DPMSCode */ + CARD8 dpmsReqType; /* always X_DPMSCapable */ + CARD16 length; +} xDPMSCapableReq; +#define sz_xDPMSCapableReq 4 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 pad0; + CARD16 sequenceNumber; + CARD32 length; + BOOL capable; + CARD8 pad1; + CARD16 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; + CARD32 pad7; +} xDPMSCapableReply; +#define sz_xDPMSCapableReply 32 + +typedef struct { + CARD8 reqType; /* always DPMSCode */ + CARD8 dpmsReqType; /* always X_DPMSGetTimeouts */ + CARD16 length; +} xDPMSGetTimeoutsReq; +#define sz_xDPMSGetTimeoutsReq 4 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 pad0; + CARD16 sequenceNumber; + CARD32 length; + CARD16 standby; + CARD16 suspend; + CARD16 off; + CARD16 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xDPMSGetTimeoutsReply; +#define sz_xDPMSGetTimeoutsReply 32 + +typedef struct { + CARD8 reqType; /* always DPMSCode */ + CARD8 dpmsReqType; /* always X_DPMSSetTimeouts */ + CARD16 length; + CARD16 standby; + CARD16 suspend; + CARD16 off; + CARD16 pad0; +} xDPMSSetTimeoutsReq; +#define sz_xDPMSSetTimeoutsReq 12 + +typedef struct { + CARD8 reqType; /* always DPMSCode */ + CARD8 dpmsReqType; /* always X_DPMSEnable */ + CARD16 length; +} xDPMSEnableReq; +#define sz_xDPMSEnableReq 4 + +typedef struct { + CARD8 reqType; /* always DPMSCode */ + CARD8 dpmsReqType; /* always X_DPMSDisable */ + CARD16 length; +} xDPMSDisableReq; +#define sz_xDPMSDisableReq 4 + +typedef struct { + CARD8 reqType; /* always DPMSCode */ + CARD8 dpmsReqType; /* always X_DPMSForceLevel */ + CARD16 length; + CARD16 level; /* power level requested */ + CARD16 pad0; +} xDPMSForceLevelReq; +#define sz_xDPMSForceLevelReq 8 + +typedef struct { + CARD8 reqType; /* always DPMSCode */ + CARD8 dpmsReqType; /* always X_DPMSInfo */ + CARD16 length; +} xDPMSInfoReq; +#define sz_xDPMSInfoReq 4 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 pad0; + CARD16 sequenceNumber; + CARD32 length; + CARD16 power_level; + BOOL state; + CARD8 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xDPMSInfoReply; +#define sz_xDPMSInfoReply 32 + +typedef struct { + CARD8 reqType; /* always DPMSCode */ + CARD8 dpmsReqType; /* always X_DPMSSelectInput */ + CARD16 length B16; + CARD32 eventMask B32; +} xDPMSSelectInputReq; +#define sz_xDPMSSelectInputReq 8 + +typedef struct { + CARD8 type; + CARD8 extension; + CARD16 sequenceNumber B16; + CARD32 length; + CARD16 evtype B16; + CARD16 pad0 B16; + Time timestamp B32; + CARD16 power_level B16; + BOOL state; + CARD8 pad1; + CARD32 pad2 B32; + CARD32 pad3 B32; + CARD32 pad4 B32; +} xDPMSInfoNotifyEvent; +#define sz_xDPMSInfoNotifyEvent 32 + +#endif /* _DPMSPROTO_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/dri2proto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/dri2proto.h new file mode 100644 index 0000000000000000000000000000000000000000..c1775fddf09c58369d8fb0a74a4f540e48000259 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/dri2proto.h @@ -0,0 +1,357 @@ +/* + * Copyright © 2008 Red Hat, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Soft- + * ware"), to deal in the Software without restriction, including without + * limitation the rights to use, copy, modify, merge, publish, distribute, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, provided that the above copyright + * notice(s) and this permission notice appear in all copies of the Soft- + * ware and that both the above copyright notice(s) and this permission + * notice appear in supporting documentation. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL- + * ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY + * RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN + * THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSE- + * QUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFOR- + * MANCE OF THIS SOFTWARE. + * + * Except as contained in this notice, the name of a copyright holder shall + * not be used in advertising or otherwise to promote the sale, use or + * other dealings in this Software without prior written authorization of + * the copyright holder. + * + * Authors: + * Kristian Høgsberg (krh@redhat.com) + */ + +#ifndef _DRI2_PROTO_H_ +#define _DRI2_PROTO_H_ + +#define DRI2_NAME "DRI2" +#define DRI2_MAJOR 1 +#define DRI2_MINOR 4 + +#define DRI2NumberErrors 0 +#define DRI2NumberEvents 2 +#define DRI2NumberRequests 14 + +#define X_DRI2QueryVersion 0 +#define X_DRI2Connect 1 +#define X_DRI2Authenticate 2 +#define X_DRI2CreateDrawable 3 +#define X_DRI2DestroyDrawable 4 +#define X_DRI2GetBuffers 5 +#define X_DRI2CopyRegion 6 +#define X_DRI2GetBuffersWithFormat 7 +#define X_DRI2SwapBuffers 8 +#define X_DRI2GetMSC 9 +#define X_DRI2WaitMSC 10 +#define X_DRI2WaitSBC 11 +#define X_DRI2SwapInterval 12 +#define X_DRI2GetParam 13 + +/* + * Events + */ +#define DRI2_BufferSwapComplete 0 +#define DRI2_InvalidateBuffers 1 + +typedef struct { + CARD32 attachment; + CARD32 name; + CARD32 pitch; + CARD32 cpp; + CARD32 flags; +} xDRI2Buffer; + +typedef struct { + CARD8 reqType; + CARD8 dri2ReqType; + CARD16 length; + CARD32 majorVersion; + CARD32 minorVersion; +} xDRI2QueryVersionReq; +#define sz_xDRI2QueryVersionReq 12 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 majorVersion; + CARD32 minorVersion; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xDRI2QueryVersionReply; +#define sz_xDRI2QueryVersionReply 32 + +typedef struct { + CARD8 reqType; + CARD8 dri2ReqType; + CARD16 length; + CARD32 window; + CARD32 driverType; +} xDRI2ConnectReq; +#define sz_xDRI2ConnectReq 12 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 driverNameLength; + CARD32 deviceNameLength; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xDRI2ConnectReply; +#define sz_xDRI2ConnectReply 32 + +typedef struct { + CARD8 reqType; + CARD8 dri2ReqType; + CARD16 length; + CARD32 window; + CARD32 magic; +} xDRI2AuthenticateReq; +#define sz_xDRI2AuthenticateReq 12 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 authenticated; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xDRI2AuthenticateReply; +#define sz_xDRI2AuthenticateReply 32 + +typedef struct { + CARD8 reqType; + CARD8 dri2ReqType; + CARD16 length; + CARD32 drawable; +} xDRI2CreateDrawableReq; +#define sz_xDRI2CreateDrawableReq 8 + +typedef struct { + CARD8 reqType; + CARD8 dri2ReqType; + CARD16 length; + CARD32 drawable; +} xDRI2DestroyDrawableReq; +#define sz_xDRI2DestroyDrawableReq 8 + +typedef struct { + CARD8 reqType; + CARD8 dri2ReqType; + CARD16 length; + CARD32 drawable; + CARD32 count; +} xDRI2GetBuffersReq; +#define sz_xDRI2GetBuffersReq 12 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 width; + CARD32 height; + CARD32 count; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xDRI2GetBuffersReply; +#define sz_xDRI2GetBuffersReply 32 + +typedef struct { + CARD8 reqType; + CARD8 dri2ReqType; + CARD16 length; + CARD32 drawable; + CARD32 region; + CARD32 dest; + CARD32 src; +} xDRI2CopyRegionReq; +#define sz_xDRI2CopyRegionReq 20 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; + CARD32 pad7; +} xDRI2CopyRegionReply; +#define sz_xDRI2CopyRegionReply 32 + +typedef struct { + CARD8 reqType; + CARD8 dri2ReqType; + CARD16 length; + CARD32 drawable; + CARD32 target_msc_hi; + CARD32 target_msc_lo; + CARD32 divisor_hi; + CARD32 divisor_lo; + CARD32 remainder_hi; + CARD32 remainder_lo; +} xDRI2SwapBuffersReq; +#define sz_xDRI2SwapBuffersReq 32 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 swap_hi; + CARD32 swap_lo; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xDRI2SwapBuffersReply; +#define sz_xDRI2SwapBuffersReply 32 + +typedef struct { + CARD8 reqType; + CARD8 dri2ReqType; + CARD16 length; + CARD32 drawable; +} xDRI2GetMSCReq; +#define sz_xDRI2GetMSCReq 8 + +typedef struct { + CARD8 reqType; + CARD8 dri2ReqType; + CARD16 length; + CARD32 drawable; + CARD32 target_msc_hi; + CARD32 target_msc_lo; + CARD32 divisor_hi; + CARD32 divisor_lo; + CARD32 remainder_hi; + CARD32 remainder_lo; +} xDRI2WaitMSCReq; +#define sz_xDRI2WaitMSCReq 32 + +typedef struct { + CARD8 reqType; + CARD8 dri2ReqType; + CARD16 length; + CARD32 drawable; + CARD32 target_sbc_hi; + CARD32 target_sbc_lo; +} xDRI2WaitSBCReq; +#define sz_xDRI2WaitSBCReq 16 + +typedef struct { + CARD8 type; + CARD8 pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 ust_hi; + CARD32 ust_lo; + CARD32 msc_hi; + CARD32 msc_lo; + CARD32 sbc_hi; + CARD32 sbc_lo; +} xDRI2MSCReply; +#define sz_xDRI2MSCReply 32 + +typedef struct { + CARD8 reqType; + CARD8 dri2ReqType; + CARD16 length; + CARD32 drawable; + CARD32 interval; +} xDRI2SwapIntervalReq; +#define sz_xDRI2SwapIntervalReq 12 + +typedef struct { + CARD8 type; + CARD8 pad; + CARD16 sequenceNumber; + CARD16 event_type; + CARD16 pad2; + CARD32 drawable; + CARD32 ust_hi; + CARD32 ust_lo; + CARD32 msc_hi; + CARD32 msc_lo; + CARD32 sbc_hi; + CARD32 sbc_lo; +} xDRI2BufferSwapComplete; +#define sz_xDRI2BufferSwapComplete 32 + +typedef struct { + CARD8 type; + CARD8 pad; + CARD16 sequenceNumber; + CARD16 event_type; + CARD16 pad2; + CARD32 drawable; + CARD32 ust_hi; + CARD32 ust_lo; + CARD32 msc_hi; + CARD32 msc_lo; + CARD32 sbc; +} xDRI2BufferSwapComplete2; +#define sz_xDRI2BufferSwapComplete2 32 + +typedef struct { + CARD8 type; + CARD8 pad; + CARD16 sequenceNumber; + CARD32 drawable; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xDRI2InvalidateBuffers; +#define sz_xDRI2InvalidateBuffers 32 + +typedef struct { + CARD8 reqType; + CARD8 dri2ReqType; + CARD16 length; + CARD32 drawable; + CARD32 param; +} xDRI2GetParamReq; +#define sz_xDRI2GetParamReq 12 + +typedef struct { + BYTE type; /*X_Reply*/ + BOOL is_param_recognized; + CARD16 sequenceNumber; + CARD32 length; + CARD32 value_hi; + CARD32 value_lo; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xDRI2GetParamReply; +#define sz_xDRI2GetParamReply 32 + +#endif diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/dri2tokens.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/dri2tokens.h new file mode 100644 index 0000000000000000000000000000000000000000..bdca8665165a8b94039cce5155618571f931b7bc --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/dri2tokens.h @@ -0,0 +1,61 @@ +/* + * Copyright © 2008 Red Hat, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Soft- + * ware"), to deal in the Software without restriction, including without + * limitation the rights to use, copy, modify, merge, publish, distribute, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, provided that the above copyright + * notice(s) and this permission notice appear in all copies of the Soft- + * ware and that both the above copyright notice(s) and this permission + * notice appear in supporting documentation. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL- + * ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY + * RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN + * THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSE- + * QUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFOR- + * MANCE OF THIS SOFTWARE. + * + * Except as contained in this notice, the name of a copyright holder shall + * not be used in advertising or otherwise to promote the sale, use or + * other dealings in this Software without prior written authorization of + * the copyright holder. + * + * Authors: + * Kristian Høgsberg (krh@redhat.com) + */ + +#ifndef _DRI2_TOKENS_H_ +#define _DRI2_TOKENS_H_ + +#define DRI2BufferFrontLeft 0 +#define DRI2BufferBackLeft 1 +#define DRI2BufferFrontRight 2 +#define DRI2BufferBackRight 3 +#define DRI2BufferDepth 4 +#define DRI2BufferStencil 5 +#define DRI2BufferAccum 6 +#define DRI2BufferFakeFrontLeft 7 +#define DRI2BufferFakeFrontRight 8 +#define DRI2BufferDepthStencil 9 +#define DRI2BufferHiz 10 + +/* keep bits 16 and above for prime IDs */ +#define DRI2DriverPrimeMask 7 /* 0 - 7 - allows for 6 devices*/ +#define DRI2DriverPrimeShift 16 +#define DRI2DriverPrimeId(x) (((x) >> DRI2DriverPrimeShift) & (DRI2DriverPrimeMask)) + +#define DRI2DriverDRI 0 +#define DRI2DriverVDPAU 1 + +/* Event sub-types for the swap complete event */ +#define DRI2_EXCHANGE_COMPLETE 0x1 +#define DRI2_BLIT_COMPLETE 0x2 +#define DRI2_FLIP_COMPLETE 0x3 + +#endif diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/dri3proto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/dri3proto.h new file mode 100644 index 0000000000000000000000000000000000000000..a1fbed55c8151c85c3adb3c0fd2864395045dced --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/dri3proto.h @@ -0,0 +1,288 @@ +/* + * Copyright © 2013 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that copyright + * notice and this permission notice appear in supporting documentation, and + * that the name of the copyright holders not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. The copyright holders make no representations + * about the suitability of this software for any purpose. It is provided "as + * is" without express or implied warranty. + * + * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE + * OF THIS SOFTWARE. + */ + +#ifndef _DRI3_PROTO_H_ +#define _DRI3_PROTO_H_ + +#define DRI3_NAME "DRI3" +#define DRI3_MAJOR 1 +#define DRI3_MINOR 4 + +#define DRI3NumberErrors 0 +#define DRI3NumberEvents 0 + +#define X_DRI3QueryVersion 0 +#define X_DRI3Open 1 +#define X_DRI3PixmapFromBuffer 2 +#define X_DRI3BufferFromPixmap 3 +#define X_DRI3FenceFromFD 4 +#define X_DRI3FDFromFence 5 + +/* v1.2 */ +#define xDRI3GetSupportedModifiers 6 +#define xDRI3PixmapFromBuffers 7 +#define xDRI3BuffersFromPixmap 8 + +/* v1.3 */ +#define xDRI3SetDRMDeviceInUse 9 + +/* v1.4 */ +#define xDRI3ImportSyncobj 10 +#define xDRI3FreeSyncobj 11 + +#define DRI3NumberRequests 12 + +#define DRI3Syncobj CARD32 + +typedef struct { + CARD8 reqType; + CARD8 dri3ReqType; + CARD16 length; + CARD32 majorVersion; + CARD32 minorVersion; +} xDRI3QueryVersionReq; +#define sz_xDRI3QueryVersionReq 12 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 majorVersion; + CARD32 minorVersion; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xDRI3QueryVersionReply; +#define sz_xDRI3QueryVersionReply 32 + +typedef struct { + CARD8 reqType; + CARD8 dri3ReqType; + CARD16 length; + CARD32 drawable; + CARD32 provider; +} xDRI3OpenReq; +#define sz_xDRI3OpenReq 12 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 nfd; + CARD16 sequenceNumber; + CARD32 length; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; + CARD32 pad7; +} xDRI3OpenReply; +#define sz_xDRI3OpenReply 32 + +typedef struct { + CARD8 reqType; + CARD8 dri3ReqType; + CARD16 length; + CARD32 pixmap; + CARD32 drawable; + CARD32 size; + CARD16 width; + CARD16 height; + CARD16 stride; + CARD8 depth; + CARD8 bpp; +} xDRI3PixmapFromBufferReq; + +#define sz_xDRI3PixmapFromBufferReq 24 + +typedef struct { + CARD8 reqType; + CARD8 dri3ReqType; + CARD16 length; + CARD32 pixmap; +} xDRI3BufferFromPixmapReq; +#define sz_xDRI3BufferFromPixmapReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 nfd; /* Number of file descriptors returned (1) */ + CARD16 sequenceNumber; + CARD32 length; + CARD32 size; + CARD16 width; + CARD16 height; + CARD16 stride; + CARD8 depth; + CARD8 bpp; + CARD32 pad20; + CARD32 pad24; + CARD32 pad28; +} xDRI3BufferFromPixmapReply; +#define sz_xDRI3BufferFromPixmapReply 32 + +typedef struct { + CARD8 reqType; + CARD8 dri3ReqType; + CARD16 length; + CARD32 drawable; + CARD32 fence; + BOOL initially_triggered; + CARD8 pad13; + CARD16 pad14; +} xDRI3FenceFromFDReq; + +#define sz_xDRI3FenceFromFDReq 16 + +typedef struct { + CARD8 reqType; + CARD8 dri3ReqType; + CARD16 length; + CARD32 drawable; + CARD32 fence; +} xDRI3FDFromFenceReq; + +#define sz_xDRI3FDFromFenceReq 12 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 nfd; /* Number of file descriptors returned (1) */ + CARD16 sequenceNumber; + CARD32 length; + CARD32 pad08; + CARD32 pad12; + CARD32 pad16; + CARD32 pad20; + CARD32 pad24; + CARD32 pad28; +} xDRI3FDFromFenceReply; + +#define sz_xDRI3FDFromFenceReply 32 + +/* v1.2 */ + +typedef struct { + CARD8 reqType; + CARD8 dri3ReqType; + CARD16 length; + CARD32 window; + CARD8 depth; + CARD8 bpp; + CARD16 pad10; +} xDRI3GetSupportedModifiersReq; +#define sz_xDRI3GetSupportedModifiersReq 12 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 numWindowModifiers; + CARD32 numScreenModifiers; + CARD32 pad16; + CARD32 pad20; + CARD32 pad24; + CARD32 pad28; +} xDRI3GetSupportedModifiersReply; +#define sz_xDRI3GetSupportedModifiersReply 32 + +typedef struct { + CARD8 reqType; + CARD8 dri3ReqType; + CARD16 length; + CARD32 pixmap; + CARD32 window; + CARD8 num_buffers; /* Number of file descriptors passed */ + CARD8 pad13; + CARD16 pad14; + CARD16 width; + CARD16 height; + CARD32 stride0; + CARD32 offset0; + CARD32 stride1; + CARD32 offset1; + CARD32 stride2; + CARD32 offset2; + CARD32 stride3; + CARD32 offset3; + CARD8 depth; + CARD8 bpp; + CARD16 pad54; + CARD64 modifier; +} xDRI3PixmapFromBuffersReq; +#define sz_xDRI3PixmapFromBuffersReq 64 + +typedef struct { + CARD8 reqType; + CARD8 dri3ReqType; + CARD16 length; + CARD32 pixmap; +} xDRI3BuffersFromPixmapReq; +#define sz_xDRI3BuffersFromPixmapReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 nfd; /* Number of file descriptors returned */ + CARD16 sequenceNumber; + CARD32 length; + CARD16 width; + CARD16 height; + CARD32 pad12; + CARD64 modifier; + CARD8 depth; + CARD8 bpp; + CARD16 pad26; + CARD32 pad28; +} xDRI3BuffersFromPixmapReply; +#define sz_xDRI3BuffersFromPixmapReply 32 + +/* v1.3 */ + +typedef struct { + CARD8 reqType; + CARD8 dri3ReqType; + CARD16 length; + CARD32 window; + CARD32 drmMajor; + CARD32 drmMinor; +} xDRI3SetDRMDeviceInUseReq; +#define sz_xDRI3SetDRMDeviceInUseReq 16 + +/* v1.4 */ +typedef struct { + CARD8 reqType; + CARD8 dri3ReqType; + CARD16 length; + DRI3Syncobj syncobj; + CARD32 drawable; +} xDRI3ImportSyncobjReq; +#define sz_xDRI3ImportSyncobjReq 12 + +typedef struct { + CARD8 reqType; + CARD8 dri3ReqType; + CARD16 length; + DRI3Syncobj syncobj; +} xDRI3FreeSyncobjReq; +#define sz_xDRI3FreeSyncobjReq 8 + +#endif diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/ge.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/ge.h new file mode 100644 index 0000000000000000000000000000000000000000..aca1d8a241c5ec0951cfbdbc9734a4905d09c523 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/ge.h @@ -0,0 +1,60 @@ +/* + * Copyright © 2007-2008 Peter Hutterer + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Authors: Peter Hutterer, University of South Australia, NICTA + * + */ + +#ifndef _GE_H_ +#define _GE_H_ + +#define GE_NAME "Generic Event Extension" +#define GE_MAJOR 1 +#define GE_MINOR 0 + +/********************************************************* + * + * Requests + * + */ + +#define X_GEQueryVersion 0 + +#define GENumberRequests (X_GEQueryVersion + 1) + +/********************************************************* + * + * Events + * + */ + +#define GENumberEvents 0 + +/********************************************************* + * + * Errors + * + */ + +#define GENumberErrors 0 + +#endif /* _GE_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/geproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/geproto.h new file mode 100644 index 0000000000000000000000000000000000000000..7b34be21d1a9e62df4b00d5e1c6ae3045046a741 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/geproto.h @@ -0,0 +1,85 @@ +/* + * Copyright © 2007-2008 Peter Hutterer + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Authors: Peter Hutterer, University of South Australia, NICTA + * + */ + +#ifndef _GEPROTO_H_ +#define _GEPROTO_H_ + +#include +#include +#include + + +/********************************************************* + * + * Protocol request constants + * + */ + +#define X_GEGetExtensionVersion 1 + +/********************************************************* + * + * XGE protocol requests/replies + * + */ + +/* generic request */ +typedef struct { + CARD8 reqType; + CARD8 ReqType; + CARD16 length; +} xGEReq; + + +/* QueryVersion */ +typedef struct { + CARD8 reqType; /* input extension major code */ + CARD8 ReqType; /* always X_GEQueryVersion */ + CARD16 length; + CARD16 majorVersion; + CARD16 minorVersion; +} xGEQueryVersionReq; + +#define sz_xGEQueryVersionReq 8 + +typedef struct { + CARD8 repType; /* X_Reply */ + CARD8 RepType; /* always X_GEQueryVersion */ + CARD16 sequenceNumber; + CARD32 length; + CARD16 majorVersion; + CARD16 minorVersion; + CARD32 pad00; + CARD32 pad01; + CARD32 pad02; + CARD32 pad03; + CARD32 pad04; +} xGEQueryVersionReply; + +#define sz_xGEQueryVersionReply 32 + +#endif /* _GEPROTO_H_ */ + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/lbx.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/lbx.h new file mode 100644 index 0000000000000000000000000000000000000000..ecd24ff1fa5127aec70687fd44f1a6b789cdea9d --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/lbx.h @@ -0,0 +1,73 @@ +/* + * Copyright 1992 Network Computing Devices + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of NCD. not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. NCD. makes no representations about the + * suitability of this software for any purpose. It is provided "as is" + * without express or implied warranty. + * + * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. + * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +#ifndef _LBX_H_ +#define _LBX_H_ + +#define LBXNAME "LBX" + +#define LBX_MAJOR_VERSION 1 +#define LBX_MINOR_VERSION 0 + +#define LbxNumberReqs 44 +#define LbxEvent 0 +#define LbxQuickMotionDeltaEvent 1 +#define LbxNumberEvents 2 + +/* This is always the master client */ +#define LbxMasterClientIndex 0 + +/* LbxEvent lbxType sub-fields */ +#define LbxSwitchEvent 0 +#define LbxCloseEvent 1 +#define LbxDeltaEvent 2 +#define LbxInvalidateTagEvent 3 +#define LbxSendTagDataEvent 4 +#define LbxListenToOne 5 +#define LbxListenToAll 6 +#define LbxMotionDeltaEvent 7 +#define LbxReleaseCmapEvent 8 +#define LbxFreeCellsEvent 9 + +/* + * Lbx image compression methods + * + * No compression is always assigned the value of 0. + * + * The rest of the compression method opcodes are assigned dynamically + * at option negotiation time. + */ + +#define LbxImageCompressNone 0 + + +#define BadLbxClient 0 +#define LbxNumberErrors (BadLbxClient + 1) + +/* tagged data types */ +#define LbxTagTypeModmap 1 +#define LbxTagTypeKeymap 2 +#define LbxTagTypeProperty 3 +#define LbxTagTypeFont 4 +#define LbxTagTypeConnInfo 5 + +#endif diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/lbxproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/lbxproto.h new file mode 100644 index 0000000000000000000000000000000000000000..8e858aa7c903088ab1ff394cac4095d8462222e0 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/lbxproto.h @@ -0,0 +1,975 @@ +/* + * Copyright 1992 Network Computing Devices + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of NCD. not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. NCD. makes no representations about the + * suitability of this software for any purpose. It is provided "as is" + * without express or implied warranty. + * + * NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. + * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +#ifndef _LBXPROTO_H_ +#define _LBXPROTO_H_ + +#include +/* + * NOTE: any changes or additions to the opcodes needs to be reflected + * in the lbxCacheable array in Xserver/lbx/lbxmain.c + */ + +#define X_LbxQueryVersion 0 +#define X_LbxStartProxy 1 +#define X_LbxStopProxy 2 +#define X_LbxSwitch 3 +#define X_LbxNewClient 4 +#define X_LbxCloseClient 5 +#define X_LbxModifySequence 6 +#define X_LbxAllowMotion 7 +#define X_LbxIncrementPixel 8 +#define X_LbxDelta 9 +#define X_LbxGetModifierMapping 10 +#define X_LbxInvalidateTag 12 +#define X_LbxPolyPoint 13 +#define X_LbxPolyLine 14 +#define X_LbxPolySegment 15 +#define X_LbxPolyRectangle 16 +#define X_LbxPolyArc 17 +#define X_LbxFillPoly 18 +#define X_LbxPolyFillRectangle 19 +#define X_LbxPolyFillArc 20 +#define X_LbxGetKeyboardMapping 21 +#define X_LbxQueryFont 22 +#define X_LbxChangeProperty 23 +#define X_LbxGetProperty 24 +#define X_LbxTagData 25 + +#define X_LbxCopyArea 26 +#define X_LbxCopyPlane 27 +#define X_LbxPolyText8 28 +#define X_LbxPolyText16 29 +#define X_LbxImageText8 30 +#define X_LbxImageText16 31 + +#define X_LbxQueryExtension 32 +#define X_LbxPutImage 33 +#define X_LbxGetImage 34 + +#define X_LbxBeginLargeRequest 35 +#define X_LbxLargeRequestData 36 +#define X_LbxEndLargeRequest 37 + +#define X_LbxInternAtoms 38 +#define X_LbxGetWinAttrAndGeom 39 + +#define X_LbxGrabCmap 40 +#define X_LbxReleaseCmap 41 +#define X_LbxAllocColor 42 + +#define X_LbxSync 43 + +/* + * Redefine some basic types used by structures defined herein. This removes + * any possibility on 64-bit architectures of one entity viewing communicated + * data as 32-bit quantities and another entity viewing the same data as 64-bit + * quantities. + */ +#define XID CARD32 +#define Atom CARD32 +#define Colormap CARD32 +#define Drawable CARD32 +#define VisualID CARD32 +#define Window CARD32 + +typedef struct { + BOOL success; /* TRUE */ + BOOL changeType; + CARD16 majorVersion, + minorVersion; + CARD16 length; /* 1/4 additional bytes in setup info */ + CARD32 tag; +} xLbxConnSetupPrefix; + +typedef struct _LbxQueryVersion { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxQueryVersion */ + CARD16 length; +} xLbxQueryVersionReq; +#define sz_xLbxQueryVersionReq 4 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 unused; + CARD16 sequenceNumber; + CARD32 length; + CARD16 majorVersion; /* major version of LBX protocol */ + CARD16 minorVersion; /* minor version of LBX protocol */ + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xLbxQueryVersionReply; +#define sz_xLbxQueryVersionReply 32 + +typedef struct _LbxStartProxy { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxStartProxy */ + CARD16 length; +} xLbxStartProxyReq; +#define sz_xLbxStartProxyReq 4 + +typedef struct _LbxStopProxy { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxStopProxy */ + CARD16 length; +} xLbxStopProxyReq; +#define sz_xLbxStopProxyReq 4 + +typedef struct _LbxSwitch { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxSwitch */ + CARD16 length; + CARD32 client; /* new client */ +} xLbxSwitchReq; +#define sz_xLbxSwitchReq 8 + +typedef struct _LbxNewClient { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxNewClient */ + CARD16 length; + CARD32 client; /* new client */ +} xLbxNewClientReq; +#define sz_xLbxNewClientReq 8 + +typedef struct _LbxCloseClient { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxCloseClient */ + CARD16 length; + CARD32 client; /* new client */ +} xLbxCloseClientReq; +#define sz_xLbxCloseClientReq 8 + +typedef struct _LbxModifySequence { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxModifySequence */ + CARD16 length; + CARD32 adjust; +} xLbxModifySequenceReq; +#define sz_xLbxModifySequenceReq 8 + +typedef struct _LbxAllowMotion { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxAllowMotion */ + CARD16 length; + CARD32 num; +} xLbxAllowMotionReq; +#define sz_xLbxAllowMotionReq 8 + +typedef struct { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxGrabCmap */ + CARD16 length; + Colormap cmap; +} xLbxGrabCmapReq; +#define sz_xLbxGrabCmapReq 8 + +#define LBX_SMART_GRAB 0x80 +#define LBX_AUTO_RELEASE 0x40 +#define LBX_3CHANNELS 0x20 +#define LBX_2BYTE_PIXELS 0x10 +#define LBX_RGB_BITS_MASK 0x0f + +#define LBX_LIST_END 0 +#define LBX_PIXEL_PRIVATE 1 +#define LBX_PIXEL_SHARED 2 +#define LBX_PIXEL_RANGE_PRIVATE 3 +#define LBX_PIXEL_RANGE_SHARED 4 +#define LBX_NEXT_CHANNEL 5 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 flags; + CARD16 sequenceNumber; + CARD32 length; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xLbxGrabCmapReply; +#define sz_xLbxGrabCmapReply 32 +#define sz_xLbxGrabCmapReplyHdr 8 + + +typedef struct { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxReleaseCmap */ + CARD16 length; + Colormap cmap; +} xLbxReleaseCmapReq; +#define sz_xLbxReleaseCmapReq 8 + +typedef struct { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxAllocColor */ + CARD16 length; + Colormap cmap; + CARD32 pixel; + CARD16 red, green, blue; + CARD16 pad; +} xLbxAllocColorReq; +#define sz_xLbxAllocColorReq 20 + +typedef struct _LbxIncrementPixel { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxIncrementPixel */ + CARD16 length; + CARD32 cmap; + CARD32 pixel; +} xLbxIncrementPixelReq; +#define sz_xLbxIncrementPixelReq 12 + +typedef struct _LbxDelta { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxDelta */ + CARD16 length; + CARD8 diffs; /* number of diffs */ + CARD8 cindex; /* cache index */ + /* list of diffs follows */ +} xLbxDeltaReq; +#define sz_xLbxDeltaReq 6 + +typedef struct _LbxGetModifierMapping { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxGetModifierMapping */ + CARD16 length; +} xLbxGetModifierMappingReq; +#define sz_xLbxGetModifierMappingReq 4 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 keyspermod; + CARD16 sequenceNumber; + CARD32 length; + CARD32 tag; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xLbxGetModifierMappingReply; +#define sz_xLbxGetModifierMappingReply 32 + +typedef struct _LbxGetKeyboardMapping { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxGetKeyboardMapping */ + CARD16 length; + KeyCode firstKeyCode; + CARD8 count; + CARD16 pad1; +} xLbxGetKeyboardMappingReq; +#define sz_xLbxGetKeyboardMappingReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 keysperkeycode; + CARD16 sequenceNumber; + CARD32 length; + CARD32 tag; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xLbxGetKeyboardMappingReply; +#define sz_xLbxGetKeyboardMappingReply 32 + +typedef struct _LbxQueryFont { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxQueryFont */ + CARD16 length; + CARD32 fid; +} xLbxQueryFontReq; +#define sz_xLbxQueryFontReq 8 + +typedef struct _LbxInternAtoms { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxInternAtoms */ + CARD16 length; + CARD16 num; +} xLbxInternAtomsReq; +#define sz_xLbxInternAtomsReq 6 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 unused; + CARD16 sequenceNumber; + CARD32 length; + CARD32 atomsStart; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xLbxInternAtomsReply; +#define sz_xLbxInternAtomsReply 32 +#define sz_xLbxInternAtomsReplyHdr 8 + + +typedef struct _LbxGetWinAttrAndGeom { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxGetWinAttrAndGeom */ + CARD16 length; + CARD32 id; /* window id */ +} xLbxGetWinAttrAndGeomReq; +#define sz_xLbxGetWinAttrAndGeomReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 backingStore; + CARD16 sequenceNumber; + CARD32 length; /* NOT 0; this is an extra-large reply */ + VisualID visualID; +#if defined(__cplusplus) || defined(c_plusplus) + CARD16 c_class; +#else + CARD16 class; +#endif + CARD8 bitGravity; + CARD8 winGravity; + CARD32 backingBitPlanes; + CARD32 backingPixel; + BOOL saveUnder; + BOOL mapInstalled; + CARD8 mapState; + BOOL override; + Colormap colormap; + CARD32 allEventMasks; + CARD32 yourEventMask; + CARD16 doNotPropagateMask; + CARD16 pad1; + Window root; + INT16 x, y; + CARD16 width, height; + CARD16 borderWidth; + CARD8 depth; + CARD8 pad2; +} xLbxGetWinAttrAndGeomReply; +#define sz_xLbxGetWinAttrAndGeomReply 60 + + +typedef struct { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxSync */ + CARD16 length; +} xLbxSyncReq; +#define sz_xLbxSyncReq 4 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 pad0; + CARD16 sequenceNumber; + CARD32 length; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xLbxSyncReply; +#define sz_xLbxSyncReply 32 + + +/* an LBX squished charinfo packs the data in a CARD32 as follows */ +#define LBX_WIDTH_SHIFT 26 +#define LBX_LEFT_SHIFT 20 +#define LBX_RIGHT_SHIFT 13 +#define LBX_ASCENT_SHIFT 7 +#define LBX_DESCENT_SHIFT 0 + +#define LBX_WIDTH_BITS 6 +#define LBX_LEFT_BITS 6 +#define LBX_RIGHT_BITS 7 +#define LBX_ASCENT_BITS 6 +#define LBX_DESCENT_BITS 7 + +#define LBX_WIDTH_MASK 0xfc000000 +#define LBX_LEFT_MASK 0x03f00000 +#define LBX_RIGHT_MASK 0x000fe000 +#define LBX_ASCENT_MASK 0x00001f80 +#define LBX_DESCENT_MASK 0x0000007f + +#define LBX_MASK_BITS(val, n) ((unsigned int) ((val) & ((1 << (n)) - 1))) + +typedef struct { + CARD32 metrics; +} xLbxCharInfo; + +/* note that this is identical to xQueryFontReply except for missing + * first 2 words + */ +typedef struct { + xCharInfo minBounds; +/* XXX do we need to leave this gunk? */ +#ifndef WORD64 + CARD32 walign1; +#endif + xCharInfo maxBounds; +#ifndef WORD64 + CARD32 walign2; +#endif + CARD16 minCharOrByte2, maxCharOrByte2; + CARD16 defaultChar; + CARD16 nFontProps; /* followed by this many xFontProp structures */ + CARD8 drawDirection; + CARD8 minByte1, maxByte1; + BOOL allCharsExist; + INT16 fontAscent, fontDescent; + CARD32 nCharInfos; /* followed by this many xLbxCharInfo structures */ +} xLbxFontInfo; + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 compression; + CARD16 sequenceNumber; + CARD32 length; + CARD32 tag; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + /* X_QueryFont sticks much of the data in the base reply packet, + * but we hope that it won't be needed, (and it won't fit in 32 bytes + * with the tag anyways) + * + * if any additional data is needed, its sent in a xLbxFontInfo + */ +} xLbxQueryFontReply; +#define sz_xLbxQueryFontReply 32 + +typedef struct _LbxChangeProperty { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxChangeProperty */ + CARD16 length; + Window window; + Atom property; + Atom type; + CARD8 format; + CARD8 mode; + BYTE pad[2]; + CARD32 nUnits; +} xLbxChangePropertyReq; +#define sz_xLbxChangePropertyReq 24 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 pad; + CARD16 sequenceNumber; + CARD32 length; + CARD32 tag; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xLbxChangePropertyReply; +#define sz_xLbxChangePropertyReply 32 + +typedef struct _LbxGetProperty { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxGetProperty */ + CARD16 length; + Window window; + Atom property; + Atom type; + CARD8 delete; + BYTE pad[3]; + CARD32 longOffset; + CARD32 longLength; +} xLbxGetPropertyReq; +#define sz_xLbxGetPropertyReq 28 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 format; + CARD16 sequenceNumber; + CARD32 length; + Atom propertyType; + CARD32 bytesAfter; + CARD32 nItems; + CARD32 tag; + CARD32 pad1; + CARD32 pad2; +} xLbxGetPropertyReply; +#define sz_xLbxGetPropertyReply 32 + +typedef struct _LbxTagData { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxTagData */ + CARD16 length; + XID tag; + CARD32 real_length; + /* data */ +} xLbxTagDataReq; +#define sz_xLbxTagDataReq 12 + +typedef struct _LbxInvalidateTag { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxInvalidateTag */ + CARD16 length; + CARD32 tag; +} xLbxInvalidateTagReq; +#define sz_xLbxInvalidateTagReq 8 + +typedef struct _LbxPutImage { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxPutImage */ + CARD16 length; + CARD8 compressionMethod; + CARD8 cacheEnts; + CARD8 bitPacked; + /* rest is variable */ +} xLbxPutImageReq; +#define sz_xLbxPutImageReq 7 + +typedef struct { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxGetImage */ + CARD16 length; + Drawable drawable; + INT16 x, y; + CARD16 width, height; + CARD32 planeMask; + CARD8 format; + CARD8 pad1; + CARD16 pad2; +} xLbxGetImageReq; + +#define sz_xLbxGetImageReq 24 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 depth; + CARD16 sequenceNumber; + CARD32 lbxLength; + CARD32 xLength; + VisualID visual; + CARD8 compressionMethod; + CARD8 pad1; + CARD16 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xLbxGetImageReply; + +#define sz_xLbxGetImageReply 32 + +/* Following used for LbxPolyPoint, LbxPolyLine, LbxPolySegment, + LbxPolyRectangle, LbxPolyArc, LbxPolyFillRectangle and LbxPolyFillArc */ + +#define GFX_CACHE_SIZE 15 + +#define GFXdCacheEnt(e) ((e) & 0xf) +#define GFXgCacheEnt(e) (((e) >> 4) & 0xf) +#define GFXCacheEnts(d,g) (((d) & 0xf) | (((g) & 0xf) << 4)) + +#define GFXCacheNone 0xf + +typedef struct _LbxPolyPoint { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; + CARD16 length; + CARD8 cacheEnts; + CARD8 padBytes; +} xLbxPolyPointReq; + +#define sz_xLbxPolyPointReq 6 + +typedef xLbxPolyPointReq xLbxPolyLineReq; +typedef xLbxPolyPointReq xLbxPolySegmentReq; +typedef xLbxPolyPointReq xLbxPolyRectangleReq; +typedef xLbxPolyPointReq xLbxPolyArcReq; +typedef xLbxPolyPointReq xLbxPolyFillRectangleReq; +typedef xLbxPolyPointReq xLbxPolyFillArcReq; + +#define sz_xLbxPolyLineReq sz_xLbxPolyPointReq +#define sz_xLbxPolySegmentReq sz_xLbxPolyPointReq +#define sz_xLbxPolyRectangleReq sz_xLbxPolyPointReq +#define sz_xLbxPolyArcReq sz_xLbxPolyPointReq +#define sz_xLbxPolyFillRectangleReq sz_xLbxPolyPointReq +#define sz_xLbxPolyFillArc sz_xLbxPolyPointReq + +typedef struct _LbxFillPoly { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; + CARD16 length; + CARD8 cacheEnts; + BYTE shape; + CARD8 padBytes; +} xLbxFillPolyReq; +#define sz_xLbxFillPolyReq 7 + +typedef struct _LbxCopyArea { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; + CARD16 length; + CARD8 srcCache; /* source drawable */ + CARD8 cacheEnts; /* dest drawable and gc */ + /* followed by encoded src x, src y, dst x, dst y, width, height */ +} xLbxCopyAreaReq; + +#define sz_xLbxCopyAreaReq 6 + +typedef struct _LbxCopyPlane { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; + CARD16 length; + CARD32 bitPlane; + CARD8 srcCache; /* source drawable */ + CARD8 cacheEnts; /* dest drawable and gc */ + /* followed by encoded src x, src y, dst x, dst y, width, height */ +} xLbxCopyPlaneReq; + +#define sz_xLbxCopyPlaneReq 10 + +typedef struct _LbxPolyText { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; + CARD16 length; + CARD8 cacheEnts; + /* followed by encoded src x, src y coordinates and text elts */ +} xLbxPolyTextReq; + +#define sz_xLbxPolyTextReq 5 + +typedef xLbxPolyTextReq xLbxPolyText8Req; +typedef xLbxPolyTextReq xLbxPolyText16Req; + +#define sz_xLbxPolyTextReq 5 +#define sz_xLbxPolyText8Req 5 +#define sz_xLbxPolyText16Req 5 + +typedef struct _LbxImageText { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; + CARD16 length; + CARD8 cacheEnts; + CARD8 nChars; + /* followed by encoded src x, src y coordinates and string */ +} xLbxImageTextReq; + +typedef xLbxImageTextReq xLbxImageText8Req; +typedef xLbxImageTextReq xLbxImageText16Req; + +#define sz_xLbxImageTextReq 6 +#define sz_xLbxImageText8Req 6 +#define sz_xLbxImageText16Req 6 + +typedef struct { + CARD8 offset; + CARD8 diff; +} xLbxDiffItem; +#define sz_xLbxDiffItem 2 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 nOpts; + CARD16 sequenceNumber; + CARD32 length; + CARD32 optDataStart; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xLbxStartReply; +#define sz_xLbxStartReply 32 +#define sz_xLbxStartReplyHdr 8 + +typedef struct _LbxQueryExtension { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxQueryExtension */ + CARD16 length; + CARD32 nbytes; +} xLbxQueryExtensionReq; +#define sz_xLbxQueryExtensionReq 8 + +typedef struct _LbxQueryExtensionReply { + BYTE type; /* X_Reply */ + CARD8 numReqs; + CARD16 sequenceNumber; + CARD32 length; + BOOL present; + CARD8 major_opcode; + CARD8 first_event; + CARD8 first_error; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + + /* reply & event generating requests */ +} xLbxQueryExtensionReply; +#define sz_xLbxQueryExtensionReply 32 + + +typedef struct _LbxBeginLargeRequest { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxBeginLargeRequest */ + CARD16 length; + CARD32 largeReqLength; +} xLbxBeginLargeRequestReq; +#define sz_BeginLargeRequestReq 8 + +typedef struct _LbxLargeRequestData { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxLargeRequestData */ + CARD16 length; + /* followed by LISTofCARD8 data */ +} xLbxLargeRequestDataReq; +#define sz_LargeRequestDataReq 4 + +typedef struct _LbxEndLargeRequest { + CARD8 reqType; /* always LbxReqCode */ + CARD8 lbxReqType; /* always X_LbxEndLargeRequest */ + CARD16 length; +} xLbxEndLargeRequestReq; +#define sz_EndLargeRequestReq 4 + + + +typedef struct _LbxSwitchEvent { + BYTE type; /* always eventBase + LbxEvent */ + BYTE lbxType; /* LbxSwitchEvent */ + CARD16 pad; + CARD32 client; +} xLbxSwitchEvent; +#define sz_xLbxSwitchEvent 8 + +typedef struct _LbxCloseEvent { + BYTE type; /* always eventBase + LbxEvent */ + BYTE lbxType; /* LbxCloseEvent */ + CARD16 sequenceNumber; + CARD32 client; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xLbxCloseEvent; +#define sz_xLbxCloseEvent 32 + +typedef struct _LbxInvalidateTagEvent { + BYTE type; /* always eventBase + LbxEvent */ + BYTE lbxType; /* LbxInvalidateTagEvent */ + CARD16 sequenceNumber; + CARD32 tag; + CARD32 tagType; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xLbxInvalidateTagEvent; +#define sz_xLbxInvalidateTagEvent 32 + +typedef struct _LbxSendTagDataEvent { + BYTE type; /* always eventBase + LbxEvent */ + BYTE lbxType; /* LbxSendTagDataEvent */ + CARD16 sequenceNumber; + CARD32 tag; + CARD32 tagType; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xLbxSendTagDataEvent; +#define sz_xLbxSendTagDataEvent 32 + +typedef struct _LbxListenToOneEvent { + BYTE type; /* always eventBase + LbxEvent */ + BYTE lbxType; /* LbxListenToOneEvent */ + CARD16 sequenceNumber; + CARD32 client; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xLbxListenToOneEvent; +#define sz_xLbxListenToOneEvent 32 + +typedef struct _LbxListenToAllEvent { + BYTE type; /* always eventBase + LbxEvent */ + BYTE lbxType; /* LbxListenToAllEvent */ + CARD16 sequenceNumber; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; + CARD32 pad7; +} xLbxListenToAllEvent; +#define sz_xLbxListenToOneEvent 32 + +typedef struct _LbxReleaseCmapEvent { + BYTE type; /* always eventBase + LbxEvent */ + BYTE lbxType; /* LbxReleaseCmapEvent */ + CARD16 sequenceNumber; + Colormap colormap; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xLbxReleaseCmapEvent; +#define sz_xLbxReleaseCmapEvent 32 + + +typedef struct _LbxFreeCellsEvent { + BYTE type; /* always eventBase + LbxEvent */ + BYTE lbxType; /* LbxFreeCellsEvent */ + CARD16 sequenceNumber; + Colormap colormap; + CARD32 pixelStart; + CARD32 pixelEnd; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xLbxFreeCellsEvent; +#define sz_xLbxFreeCellsEvent 32 + + +/* + * squished X event sizes. If these change, be sure to update lbxquish.c + * and unsquish.c appropriately + * + * lbxsz_* is the padded squished length + * lbxupsz_* is the unpadded squished length + */ + +#define lbxsz_KeyButtonEvent 32 +#define lbxupsz_KeyButtonEvent 31 + +#define lbxsz_EnterLeaveEvent 32 +#define lbxupsz_EnterLeaveEvent 32 + +#define lbxsz_FocusEvent 12 +#define lbxupsz_FocusEvent 9 + +#define lbxsz_KeymapEvent 32 +#define lbxupsz_KeymapEvent 32 + +#define lbxsz_ExposeEvent 20 +#define lbxupsz_ExposeEvent 18 + +#define lbxsz_GfxExposeEvent 24 +#define lbxupsz_GfxExposeEvent 21 + +#define lbxsz_NoExposeEvent 12 +#define lbxupsz_NoExposeEvent 11 + +#define lbxsz_VisibilityEvent 12 +#define lbxupsz_VisibilityEvent 9 + +#define lbxsz_CreateNotifyEvent 24 +#define lbxupsz_CreateNotifyEvent 23 + +#define lbxsz_DestroyNotifyEvent 12 +#define lbxupsz_DestroyNotifyEvent 12 + +#define lbxsz_UnmapNotifyEvent 16 +#define lbxupsz_UnmapNotifyEvent 13 + +#define lbxsz_MapNotifyEvent 16 +#define lbxupsz_MapNotifyEvent 13 + +#define lbxsz_MapRequestEvent 12 +#define lbxupsz_MapRequestEvent 12 + +#define lbxsz_ReparentEvent 24 +#define lbxupsz_ReparentEvent 21 + +#define lbxsz_ConfigureNotifyEvent 28 +#define lbxupsz_ConfigureNotifyEvent 27 + +#define lbxsz_ConfigureRequestEvent 28 +#define lbxupsz_ConfigureRequestEvent 28 + +#define lbxsz_GravityEvent 16 +#define lbxupsz_GravityEvent 16 + +#define lbxsz_ResizeRequestEvent 12 +#define lbxupsz_ResizeRequestEvent 12 + +#define lbxsz_CirculateEvent 20 +#define lbxupsz_CirculateEvent 17 + +#define lbxsz_PropertyEvent 20 +#define lbxupsz_PropertyEvent 17 + +#define lbxsz_SelectionClearEvent 16 +#define lbxupsz_SelectionClearEvent 16 + +#define lbxsz_SelectionRequestEvent 28 +#define lbxupsz_SelectionRequestEvent 28 + +#define lbxsz_SelectionNotifyEvent 24 +#define lbxupsz_SelectionNotifyEvent 24 + +#define lbxsz_ColormapEvent 16 +#define lbxupsz_ColormapEvent 14 + +#define lbxsz_MappingNotifyEvent 8 +#define lbxupsz_MappingNotifyEvent 7 + +#define lbxsz_ClientMessageEvent 32 +#define lbxupsz_ClientMessageEvent 32 + +#define lbxsz_UnknownEvent 32 + +#ifdef DEBUG + +#define DBG_SWITCH 0x00000001 +#define DBG_CLOSE 0x00000002 +#define DBG_IO 0x00000004 +#define DBG_READ_REQ 0x00000008 +#define DBG_LEN 0x00000010 +#define DBG_BLOCK 0x00000020 +#define DBG_CLIENT 0x00000040 +#define DBG_DELTA 0x00000080 +#endif +/* + * Cancel the previous redefinition of the basic types, thus restoring their + * X.h definitions. + */ + +#undef XID +#undef Atom +#undef Colormap +#undef Drawable +#undef VisualID +#undef Window + +#endif /* _LBXPROTO_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/mitmiscconst.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/mitmiscconst.h new file mode 100644 index 0000000000000000000000000000000000000000..adc5f94200bc3c5f71de5b00e43a31478ffe144d --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/mitmiscconst.h @@ -0,0 +1,38 @@ +/************************************************************ + +Copyright 1989, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +********************************************************/ + +/* RANDOM CRUFT! THIS HAS NO OFFICIAL X CONSORTIUM OR X PROJECT TEAM BLESSING */ + + +#ifndef _MITMISCCONST_H_ +#define _MITMISCCONST_H_ + +#define MITMiscNumberEvents 0 +#define MITMiscNumberErrors 0 + +#define MITMISCNAME "MIT-SUNDRY-NONSTANDARD" + +#endif diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/mitmiscproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/mitmiscproto.h new file mode 100644 index 0000000000000000000000000000000000000000..d42e4fce300d1c21e4af6e11c5efa5b5c6cd4e18 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/mitmiscproto.h @@ -0,0 +1,68 @@ +/************************************************************ + +Copyright 1989, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +********************************************************/ + +/* RANDOM CRUFT! THIS HAS NO OFFICIAL X CONSORTIUM OR X PROJECT TEAM BLESSING */ + +#ifndef _MITMISCPROTO_H_ +#define _MITMISCPROTO_H_ + +#include + +#define X_MITSetBugMode 0 +#define X_MITGetBugMode 1 + +typedef struct _SetBugMode { + CARD8 reqType; /* always MITReqCode */ + CARD8 mitReqType; /* always X_MITSetBugMode */ + CARD16 length; + BOOL onOff; + BYTE pad0; + CARD16 pad1; +} xMITSetBugModeReq; +#define sz_xMITSetBugModeReq 8 + +typedef struct _GetBugMode { + CARD8 reqType; /* always MITReqCode */ + CARD8 mitReqType; /* always X_MITGetBugMode */ + CARD16 length; +} xMITGetBugModeReq; +#define sz_xMITGetBugModeReq 4 + +typedef struct { + BYTE type; /* X_Reply */ + BOOL onOff; + CARD16 sequenceNumber; + CARD32 length; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xMITGetBugModeReply; +#define sz_xMITGetBugModeReply 32 + +#endif /* _MITMISCPROTO_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/multibufconst.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/multibufconst.h new file mode 100644 index 0000000000000000000000000000000000000000..2d1238c31fd8cde7633ded6690aec9c1c50c04a4 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/multibufconst.h @@ -0,0 +1,83 @@ +/* +Copyright 1989, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + */ + +#ifndef _MULTIBUFCONST_H_ +#define _MULTIBUFCONST_H_ + +#define MULTIBUFFER_PROTOCOL_NAME "Multi-Buffering" + +#define MULTIBUFFER_MAJOR_VERSION 1 /* current version numbers */ +#define MULTIBUFFER_MINOR_VERSION 1 /* has ClearImageBufferArea */ + +/* + * update_action field + */ +#define MultibufferUpdateActionUndefined 0 +#define MultibufferUpdateActionBackground 1 +#define MultibufferUpdateActionUntouched 2 +#define MultibufferUpdateActionCopied 3 + +/* + * update_hint field + */ +#define MultibufferUpdateHintFrequent 0 +#define MultibufferUpdateHintIntermittent 1 +#define MultibufferUpdateHintStatic 2 + +/* + * valuemask fields + */ +#define MultibufferWindowUpdateHint (1L << 0) +#define MultibufferBufferEventMask (1L << 0) + +/* + * mono vs. stereo and left vs. right + */ +#define MultibufferModeMono 0 +#define MultibufferModeStereo 1 +#define MultibufferSideMono 0 +#define MultibufferSideLeft 1 +#define MultibufferSideRight 2 + +/* + * clobber state + */ +#define MultibufferUnclobbered 0 +#define MultibufferPartiallyClobbered 1 +#define MultibufferFullyClobbered 2 + +/* + * event stuff + */ +#define MultibufferClobberNotifyMask 0x02000000 +#define MultibufferUpdateNotifyMask 0x04000000 + +#define MultibufferClobberNotify 0 +#define MultibufferUpdateNotify 1 +#define MultibufferNumberEvents (MultibufferUpdateNotify + 1) + +#define MultibufferBadBuffer 0 +#define MultibufferNumberErrors (MultibufferBadBuffer + 1) + +#endif /* _MULTIBUFCONST_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/multibufproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/multibufproto.h new file mode 100644 index 0000000000000000000000000000000000000000..19a640102ea163bc408ec0fc33c4b78bb71203b3 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/multibufproto.h @@ -0,0 +1,295 @@ +/* +Copyright 1989, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + */ + +#ifndef _MULTIBUFPROTO_H_ +#define _MULTIBUFPROTO_H_ + +#include + +/* + * Protocol requests constants and alignment values + */ + +#define Window CARD32 +#define Drawable CARD32 +#define VisualID CARD32 +#define Multibuffer CARD32 + +#define X_MbufGetBufferVersion 0 +#define X_MbufCreateImageBuffers 1 +#define X_MbufDestroyImageBuffers 2 +#define X_MbufDisplayImageBuffers 3 +#define X_MbufSetMBufferAttributes 4 +#define X_MbufGetMBufferAttributes 5 +#define X_MbufSetBufferAttributes 6 +#define X_MbufGetBufferAttributes 7 +#define X_MbufGetBufferInfo 8 +#define X_MbufCreateStereoWindow 9 +#define X_MbufClearImageBufferArea 10 + + +typedef struct xMbufBufferInfo { + CARD32 visualID; /* associated visual */ + CARD16 maxBuffers; /* maximum supported buffers */ + CARD8 depth; /* depth of visual (redundant) */ + CARD8 unused; +} xMbufBufferInfo; +#define sz_xMbufBufferInfo 8 + +typedef struct { + BYTE type; + BYTE unused; + CARD16 sequenceNumber; + CARD32 buffer; /* affected buffer */ + BYTE state; /* current status */ + CARD8 unused1; + CARD16 unused2; + CARD32 unused3; + CARD32 unused4; + CARD32 unused5; + CARD32 unused6; + CARD32 unused7; +} xMbufClobberNotifyEvent; + +typedef struct { + BYTE type; + BYTE unused; + CARD16 sequenceNumber; + CARD32 buffer; /* affected buffer */ + CARD32 timeStamp; /* update time */ + CARD32 unused1; + CARD32 unused2; + CARD32 unused3; + CARD32 unused4; + CARD32 unused5; + CARD32 unused6; +} xMbufUpdateNotifyEvent; + +typedef struct { + CARD8 reqType; /* always codes->major_opcode */ + CARD8 mbufReqType; /* always X_MbufGetBufferVersion */ + CARD16 length; +} xMbufGetBufferVersionReq; +#define sz_xMbufGetBufferVersionReq 4 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 unused; /* not used */ + CARD16 sequenceNumber; + CARD32 length; + CARD8 majorVersion; /* major version of Multi-Buffering protocol */ + CARD8 minorVersion; /* minor version of Multi-Buffering protocol */ + CARD16 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xMbufGetBufferVersionReply; +#define sz_xMbufGetBufferVersionReply 32 + +typedef struct { + CARD8 reqType; /* always codes->major_opcode */ + CARD8 mbufReqType; /* always X_MbufCreateImageBuffers */ + CARD16 length; + CARD32 window; /* associated window */ + CARD8 updateAction; /* action at update */ + CARD8 updateHint; /* hint as to frequency of updates */ + CARD16 unused; +} xMbufCreateImageBuffersReq; /* followed by buffer ids */ +#define sz_xMbufCreateImageBuffersReq 12 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 unused; /* not used */ + CARD16 sequenceNumber; + CARD32 length; + CARD16 numberBuffer; /* number successfully allocated */ + CARD16 unused1; + CARD32 unused2; + CARD32 unused3; + CARD32 unused4; + CARD32 unused5; + CARD32 unused6; +} xMbufCreateImageBuffersReply; +#define sz_xMbufCreateImageBuffersReply 32 + +typedef struct { + CARD8 reqType; /* always codes->major_opcode */ + CARD8 mbufReqType; /* always X_MbufDestroyImageBuffers */ + CARD16 length; + CARD32 window; /* associated window */ +} xMbufDestroyImageBuffersReq; +#define sz_xMbufDestroyImageBuffersReq 8 + +typedef struct { + CARD8 reqType; /* always codes->major_opcode */ + CARD8 mbufReqType; /* always X_MbufDisplayImageBuffers */ + CARD16 length; + CARD16 minDelay; /* minimum time between last update and now */ + CARD16 maxDelay; /* maximum time between last update and now */ +} xMbufDisplayImageBuffersReq; /* followed by list of buffers */ +#define sz_xMbufDisplayImageBuffersReq 8 + +typedef struct { + CARD8 reqType; /* always codes->major_opcode */ + CARD8 mbufReqType; /* always X_MbufSetMBufferAttributes */ + CARD16 length; + CARD32 window; /* associated window */ + CARD32 valueMask; /* modified entries */ +} xMbufSetMBufferAttributesReq; /* followed by values */ +#define sz_xMbufSetMBufferAttributesReq 12 + +typedef struct { + CARD8 reqType; /* always codes->major_opcode */ + CARD8 mbufReqType; /* always X_MbufGetMBufferAttributes */ + CARD16 length; + CARD32 window; /* associated window */ +} xMbufGetMBufferAttributesReq; +#define sz_xMbufGetMBufferAttributesReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 unused; /* not used */ + CARD16 sequenceNumber; + CARD32 length; + CARD16 displayedBuffer; /* currently visible buffer */ + CARD8 updateAction; + CARD8 updateHint; + CARD8 windowMode; + CARD8 unused0; + CARD16 unused1; + CARD32 unused2; + CARD32 unused3; + CARD32 unused4; + CARD32 unused5; +} xMbufGetMBufferAttributesReply; +#define sz_xMbufGetMBufferAttributesReply 32 + +typedef struct { + CARD8 reqType; /* always codes->major_opcode */ + CARD8 mbufReqType; /* always X_MbufSetBufferAttributes */ + CARD16 length; + CARD32 buffer; + CARD32 valueMask; +} xMbufSetBufferAttributesReq; /* followed by values */ +#define sz_xMbufSetBufferAttributesReq 12 + +typedef struct { + CARD8 reqType; /* always codes->major_opcode */ + CARD8 mbufReqType; /* always X_MbufGetBufferAttributes */ + CARD16 length; + CARD32 buffer; +} xMbufGetBufferAttributesReq; +#define sz_xMbufGetBufferAttributesReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 unused; /* not used */ + CARD16 sequenceNumber; + CARD32 length; + CARD32 window; + CARD32 eventMask; + CARD16 bufferIndex; + CARD8 side; + CARD8 unused0; + CARD32 unused1; + CARD32 unused2; + CARD32 unused3; +} xMbufGetBufferAttributesReply; +#define sz_xMbufGetBufferAttributesReply 32 + +typedef struct { + CARD8 reqType; /* always codes->major_opcode */ + CARD8 mbufReqType; /* always X_MbufGetBufferInfo */ + CARD16 length; + Drawable drawable; +} xMbufGetBufferInfoReq; +#define sz_xMbufGetBufferInfoReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 unused; /* not used */ + CARD16 sequenceNumber; + CARD32 length; + CARD16 normalInfo; + CARD16 stereoInfo; + CARD32 unused1; + CARD32 unused2; + CARD32 unused3; + CARD32 unused4; + CARD32 unused5; +} xMbufGetBufferInfoReply; /* followed by buffer infos */ +#define sz_xMbufGetBufferInfoReply 32 + + +typedef struct { + CARD8 reqType; /* always codes->major_opcode */ + CARD8 mbufReqType; /* always X_MbufCreateStereoWindow */ + CARD16 length; + CARD8 unused0; + CARD8 unused1; + CARD8 unused2; + CARD8 depth; + Window wid; + Window parent; + Multibuffer left; /* associated buffers */ + Multibuffer right; + INT16 x; + INT16 y; + CARD16 width; + CARD16 height; + CARD16 borderWidth; +#if defined(__cplusplus) || defined(c_plusplus) + CARD16 c_class; +#else + CARD16 class; +#endif + VisualID visual; + CARD32 mask; +} xMbufCreateStereoWindowReq; /* followed by value list */ +#define sz_xMbufCreateStereoWindowReq 44 + +typedef struct { + CARD8 reqType; /* always codes->major_opcode */ + CARD8 mbufReqType; /* always X_MbufClearImageBufferArea */ + CARD16 length; + Multibuffer buffer; + INT16 x; + INT16 y; + CARD16 width; + CARD16 height; + CARD8 unused0; + CARD8 unused1; + CARD8 unused2; + BOOL exposures; +} xMbufClearImageBufferAreaReq; +#define sz_xMbufClearImageBufferAreaReq 20 + +#undef Window +#undef Drawable +#undef VisualID +#undef Multibuffer + +#endif /* _MULTIBUFPROTO_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/panoramiXproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/panoramiXproto.h new file mode 100644 index 0000000000000000000000000000000000000000..5de1cf05313647e9bb361427ddf970ac92f33e93 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/panoramiXproto.h @@ -0,0 +1,193 @@ +/***************************************************************** +Copyright (c) 1991, 1997 Digital Equipment Corporation, Maynard, Massachusetts. +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +DIGITAL EQUIPMENT CORPORATION BE LIABLE FOR ANY CLAIM, DAMAGES, INCLUDING, +BUT NOT LIMITED TO CONSEQUENTIAL OR INCIDENTAL DAMAGES, OR OTHER LIABILITY, +WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR +IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of Digital Equipment Corporation +shall not be used in advertising or otherwise to promote the sale, use or other +dealings in this Software without prior written authorization from Digital +Equipment Corporation. +******************************************************************/ + +/* THIS IS NOT AN X PROJECT TEAM SPECIFICATION */ + +#ifndef _PANORAMIXPROTO_H_ +#define _PANORAMIXPROTO_H_ + +#define PANORAMIX_MAJOR_VERSION 1 /* current version number */ +#define PANORAMIX_MINOR_VERSION 1 + +#define PANORAMIX_PROTOCOL_NAME "XINERAMA" + +#define X_PanoramiXQueryVersion 0 +#define X_PanoramiXGetState 1 +#define X_PanoramiXGetScreenCount 2 +#define X_PanoramiXGetScreenSize 3 + +#define X_XineramaIsActive 4 +#define X_XineramaQueryScreens 5 + +typedef struct _PanoramiXQueryVersion { + CARD8 reqType; /* always PanoramiXReqCode */ + CARD8 panoramiXReqType; /* always X_PanoramiXQueryVersion */ + CARD16 length; + CARD8 clientMajor; + CARD8 clientMinor; + CARD16 unused; +} xPanoramiXQueryVersionReq; + +#define sz_xPanoramiXQueryVersionReq 8 + +typedef struct { + CARD8 type; /* must be X_Reply */ + CARD8 pad1; /* unused */ + CARD16 sequenceNumber; /* last sequence number */ + CARD32 length; /* 0 */ + CARD16 majorVersion; + CARD16 minorVersion; + CARD32 pad2; /* unused */ + CARD32 pad3; /* unused */ + CARD32 pad4; /* unused */ + CARD32 pad5; /* unused */ + CARD32 pad6; /* unused */ +} xPanoramiXQueryVersionReply; + +#define sz_xPanoramiXQueryVersionReply 32 + + +typedef struct _PanoramiXGetState { + CARD8 reqType; /* always PanoramiXReqCode */ + CARD8 panoramiXReqType; /* always X_PanoramiXGetState */ + CARD16 length; + CARD32 window; +} xPanoramiXGetStateReq; +#define sz_xPanoramiXGetStateReq 8 + +typedef struct { + BYTE type; + BYTE state; + CARD16 sequenceNumber; + CARD32 length; + CARD32 window; + CARD32 pad1; /* unused */ + CARD32 pad2; /* unused */ + CARD32 pad3; /* unused */ + CARD32 pad4; /* unused */ + CARD32 pad5; /* unused */ +} xPanoramiXGetStateReply; + +#define sz_panoramiXGetStateReply 32 + +typedef struct _PanoramiXGetScreenCount { + CARD8 reqType; /* always PanoramiXReqCode */ + CARD8 panoramiXReqType; /* always X_PanoramiXGetScreenCount */ + CARD16 length; + CARD32 window; +} xPanoramiXGetScreenCountReq; +#define sz_xPanoramiXGetScreenCountReq 8 + +typedef struct { + BYTE type; + BYTE ScreenCount; + CARD16 sequenceNumber; + CARD32 length; + CARD32 window; + CARD32 pad1; /* unused */ + CARD32 pad2; /* unused */ + CARD32 pad3; /* unused */ + CARD32 pad4; /* unused */ + CARD32 pad5; /* unused */ +} xPanoramiXGetScreenCountReply; +#define sz_panoramiXGetScreenCountReply 32 + +typedef struct _PanoramiXGetScreenSize { + CARD8 reqType; /* always PanoramiXReqCode */ + CARD8 panoramiXReqType; /* always X_PanoramiXGetState */ + CARD16 length; + CARD32 window; + CARD32 screen; +} xPanoramiXGetScreenSizeReq; +#define sz_xPanoramiXGetScreenSizeReq 12 + +typedef struct { + BYTE type; + CARD8 pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 width; + CARD32 height; + CARD32 window; + CARD32 screen; + CARD32 pad2; /* unused */ + CARD32 pad3; /* unused */ +} xPanoramiXGetScreenSizeReply; +#define sz_panoramiXGetScreenSizeReply 32 + +/************ Alternate protocol ******************/ + +typedef struct { + CARD8 reqType; + CARD8 panoramiXReqType; + CARD16 length; +} xXineramaIsActiveReq; +#define sz_xXineramaIsActiveReq 4 + +typedef struct { + BYTE type; + CARD8 pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 state; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xXineramaIsActiveReply; +#define sz_XineramaIsActiveReply 32 + + +typedef struct { + CARD8 reqType; + CARD8 panoramiXReqType; + CARD16 length; +} xXineramaQueryScreensReq; +#define sz_xXineramaQueryScreensReq 4 + +typedef struct { + BYTE type; + CARD8 pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 number; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xXineramaQueryScreensReply; +#define sz_XineramaQueryScreensReply 32 + +typedef struct { + INT16 x_org; + INT16 y_org; + CARD16 width; + CARD16 height; +} xXineramaScreenInfo; +#define sz_XineramaScreenInfo 8 + +#endif diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/presentproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/presentproto.h new file mode 100644 index 0000000000000000000000000000000000000000..ea8086312a03ca91e1775c3d7e2119ca84768924 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/presentproto.h @@ -0,0 +1,280 @@ +/* + * Copyright © 2013 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that copyright + * notice and this permission notice appear in supporting documentation, and + * that the name of the copyright holders not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. The copyright holders make no representations + * about the suitability of this software for any purpose. It is provided "as + * is" without express or implied warranty. + * + * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE + * OF THIS SOFTWARE. + */ + +#ifndef _PRESENT_PROTO_H_ +#define _PRESENT_PROTO_H_ + +#include +#include + +#define Window CARD32 +#define Pixmap CARD32 +#define Region CARD32 +#define XSyncFence CARD32 +#define EventID CARD32 + +typedef struct { + Window window; + CARD32 serial; +} xPresentNotify; +#define sz_xPresentNotify 8 + +typedef struct { + CARD8 reqType; + CARD8 presentReqType; + CARD16 length; + CARD32 majorVersion; + CARD32 minorVersion; +} xPresentQueryVersionReq; +#define sz_xPresentQueryVersionReq 12 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 majorVersion; + CARD32 minorVersion; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xPresentQueryVersionReply; +#define sz_xPresentQueryVersionReply 32 + +typedef struct { + CARD8 reqType; + CARD8 presentReqType; + CARD16 length; + Window window; + + Pixmap pixmap; + CARD32 serial; + + Region valid; + Region update; + + INT16 x_off; + INT16 y_off; + CARD32 target_crtc; + + XSyncFence wait_fence; + XSyncFence idle_fence; + + CARD32 options; + CARD32 pad1; + + CARD64 target_msc; + CARD64 divisor; + CARD64 remainder; + /* followed by a LISTofPRESENTNOTIFY */ +} xPresentPixmapReq; +#define sz_xPresentPixmapReq 72 + +typedef struct { + CARD8 reqType; + CARD8 presentReqType; + CARD16 length; + Window window; + + CARD32 serial; + CARD32 pad0; + + CARD64 target_msc; + CARD64 divisor; + CARD64 remainder; +} xPresentNotifyMSCReq; +#define sz_xPresentNotifyMSCReq 40 + +typedef struct { + CARD8 reqType; + CARD8 presentReqType; + CARD16 length; + CARD32 eid; + CARD32 window; + CARD32 eventMask; +} xPresentSelectInputReq; +#define sz_xPresentSelectInputReq 16 + +typedef struct { + CARD8 reqType; + CARD8 presentReqType; + CARD16 length; + CARD32 target; +} xPresentQueryCapabilitiesReq; +#define sz_xPresentQueryCapabilitiesReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 capabilities; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; + CARD32 pad7; +} xPresentQueryCapabilitiesReply; +#define sz_xPresentQueryCapabilitiesReply 32 + +typedef struct { + CARD8 reqType; + CARD8 presentReqType; + CARD16 length; + Window window; + + Pixmap pixmap; + CARD32 serial; + + Region valid; + Region update; + + INT16 x_off; + INT16 y_off; + CARD32 target_crtc; + + DRI3Syncobj acquire_syncobj; + DRI3Syncobj release_syncobj; + CARD64 acquire_point; + CARD64 release_point; + + CARD32 options; + CARD32 pad1; + + CARD64 target_msc; + CARD64 divisor; + CARD64 remainder; + /* followed by a LISTofPRESENTNOTIFY */ +} xPresentPixmapSyncedReq; +#define sz_xPresentPixmapSyncedReq 88 + +/* + * Events + * + * All Present events are X Generic Events + */ + +typedef struct { + CARD8 type; + CARD8 extension; + CARD16 sequenceNumber; + CARD32 length; + CARD16 evtype; + CARD16 pad2; + CARD32 eid; + CARD32 window; + INT16 x; + INT16 y; + CARD16 width; + CARD16 height; + INT16 off_x; + INT16 off_y; + + CARD16 pixmap_width; + CARD16 pixmap_height; + CARD32 pixmap_flags; +} xPresentConfigureNotify; +#define sz_xPresentConfigureNotify 40 + +typedef struct { + CARD8 type; + CARD8 extension; + CARD16 sequenceNumber; + CARD32 length; + CARD16 evtype; + CARD8 kind; + CARD8 mode; + CARD32 eid; + Window window; + CARD32 serial; + CARD64 ust; + + CARD64 msc; +} xPresentCompleteNotify; +#define sz_xPresentCompleteNotify 40 + +typedef struct { + CARD8 type; + CARD8 extension; + CARD16 sequenceNumber; + CARD32 length; + CARD16 evtype; + CARD16 pad2; + CARD32 eid; + Window window; + CARD32 serial; + Pixmap pixmap; + CARD32 idle_fence; +} xPresentIdleNotify; +#define sz_xPresentIdleNotify 32 + +#if PRESENT_FUTURE_VERSION +typedef struct { + CARD8 type; + CARD8 extension; + CARD16 sequenceNumber; + CARD32 length; + CARD16 evtype; + CARD8 update_window; + CARD8 pad1; + CARD32 eid; + Window event_window; + Window window; + Pixmap pixmap; + CARD32 serial; + + /* 32-byte boundary */ + + Region valid_region; + Region update_region; + + xRectangle valid_rect; + + xRectangle update_rect; + + INT16 x_off; + INT16 y_off; + CARD32 target_crtc; + + XSyncFence wait_fence; + XSyncFence idle_fence; + + CARD32 options; + CARD32 pad2; + + CARD64 target_msc; + CARD64 divisor; + CARD64 remainder; + +} xPresentRedirectNotify; + +#define sz_xPresentRedirectNotify 104 +#endif + +#undef Window +#undef Pixmap +#undef Region +#undef XSyncFence +#undef EventID + +#endif diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/presenttokens.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/presenttokens.h new file mode 100644 index 0000000000000000000000000000000000000000..8004625a655583f79abdeedd1019b851d7375cab --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/presenttokens.h @@ -0,0 +1,115 @@ +/* + * Copyright © 2013 Keith Packard + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that copyright + * notice and this permission notice appear in supporting documentation, and + * that the name of the copyright holders not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. The copyright holders make no representations + * about the suitability of this software for any purpose. It is provided "as + * is" without express or implied warranty. + * + * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE + * OF THIS SOFTWARE. + */ + +#ifndef _PRESENT_TOKENS_H_ +#define _PRESENT_TOKENS_H_ + +#define PRESENT_NAME "Present" +#define PRESENT_MAJOR 1 +#define PRESENT_MINOR 4 + +#define PresentNumberErrors 0 +#define PresentNumberEvents 0 + +/* Requests */ +#define X_PresentQueryVersion 0 +#define X_PresentPixmap 1 +#define X_PresentNotifyMSC 2 +#define X_PresentSelectInput 3 +#define X_PresentQueryCapabilities 4 +#define X_PresentPixmapSynced 5 + +#define PresentNumberRequests 6 + +/* Present operation options */ +#define PresentOptionNone 0 +#define PresentOptionAsync (1 << 0) +#define PresentOptionCopy (1 << 1) +#define PresentOptionUST (1 << 2) +#define PresentOptionSuboptimal (1 << 3) +#define PresentOptionAsyncMayTear (1 << 4) + +#define PresentAllOptions (PresentOptionAsync | \ + PresentOptionCopy | \ + PresentOptionUST | \ + PresentOptionSuboptimal | \ + PresentOptionAsyncMayTear) + +#define PresentAllAsyncOptions (PresentOptionAsync | PresentOptionAsyncMayTear) + +/* Present capabilities */ + +#define PresentCapabilityNone 0 +#define PresentCapabilityAsync 1 +#define PresentCapabilityFence 2 +#define PresentCapabilityUST 4 +#define PresentCapabilityAsyncMayTear 8 +#define PresentCapabilitySyncobj 16 + +#define PresentAllCapabilities (PresentCapabilityAsync | \ + PresentCapabilityFence | \ + PresentCapabilityUST | \ + PresentCapabilityAsyncMayTear | \ + PresentCapabilitySyncobj) + +#define PresentAllAsyncCapabilities (PresentCapabilityAsync | PresentCapabilityAsyncMayTear) + +/* Events */ +#define PresentConfigureNotify 0 +#define PresentCompleteNotify 1 +#define PresentIdleNotify 2 +#if PRESENT_FUTURE_VERSION +#define PresentRedirectNotify 3 +#endif + +/* Event Masks */ +#define PresentConfigureNotifyMask 1 +#define PresentCompleteNotifyMask 2 +#define PresentIdleNotifyMask 4 +#if PRESENT_FUTURE_VERSION +#define PresentRedirectNotifyMask 8 +#endif + +#if PRESENT_FUTURE_VERSION +#define PRESENT_REDIRECT_NOTIFY_MASK PresentRedirectNotifyMask +#else +#define PRESENT_REDIRECT_NOTIFY_MASK 0 +#endif + +#define PresentAllEvents (PresentConfigureNotifyMask | \ + PresentCompleteNotifyMask | \ + PresentIdleNotifyMask | \ + PRESENT_REDIRECT_NOTIFY_MASK) + +/* Complete Kinds */ + +#define PresentCompleteKindPixmap 0 +#define PresentCompleteKindNotifyMSC 1 + +/* Complete Modes */ + +#define PresentCompleteModeCopy 0 +#define PresentCompleteModeFlip 1 +#define PresentCompleteModeSkip 2 +#define PresentCompleteModeSuboptimalCopy 3 + +#endif diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/randr.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/randr.h new file mode 100644 index 0000000000000000000000000000000000000000..e7caab1725670b7b0152454d496fd300b1cd7820 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/randr.h @@ -0,0 +1,208 @@ +/* + * Copyright © 2000 Compaq Computer Corporation + * Copyright © 2002 Hewlett Packard Company + * Copyright © 2006 Intel Corporation + * Copyright © 2008 Red Hat, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that copyright + * notice and this permission notice appear in supporting documentation, and + * that the name of the copyright holders not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. The copyright holders make no representations + * about the suitability of this software for any purpose. It is provided "as + * is" without express or implied warranty. + * + * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE + * OF THIS SOFTWARE. + * + * Author: Jim Gettys, HP Labs, Hewlett-Packard, Inc. + * Keith Packard, Intel Corporation + */ + +#ifndef _RANDR_H_ +#define _RANDR_H_ + +typedef unsigned short Rotation; +typedef unsigned short SizeID; +typedef unsigned short SubpixelOrder; +typedef unsigned short Connection; +typedef unsigned short XRandrRotation; +typedef unsigned short XRandrSizeID; +typedef unsigned short XRandrSubpixelOrder; +typedef unsigned long XRandrModeFlags; + +#define RANDR_NAME "RANDR" +#define RANDR_MAJOR 1 +#define RANDR_MINOR 6 + +#define RRNumberErrors 5 +#define RRNumberEvents 2 +#define RRNumberRequests 47 + +#define X_RRQueryVersion 0 +/* we skip 1 to make old clients fail pretty immediately */ +#define X_RROldGetScreenInfo 1 +#define X_RR1_0SetScreenConfig 2 +/* V1.0 apps share the same set screen config request id */ +#define X_RRSetScreenConfig 2 +#define X_RROldScreenChangeSelectInput 3 +/* 3 used to be ScreenChangeSelectInput; deprecated */ +#define X_RRSelectInput 4 +#define X_RRGetScreenInfo 5 + +/* V1.2 additions */ +#define X_RRGetScreenSizeRange 6 +#define X_RRSetScreenSize 7 +#define X_RRGetScreenResources 8 +#define X_RRGetOutputInfo 9 +#define X_RRListOutputProperties 10 +#define X_RRQueryOutputProperty 11 +#define X_RRConfigureOutputProperty 12 +#define X_RRChangeOutputProperty 13 +#define X_RRDeleteOutputProperty 14 +#define X_RRGetOutputProperty 15 +#define X_RRCreateMode 16 +#define X_RRDestroyMode 17 +#define X_RRAddOutputMode 18 +#define X_RRDeleteOutputMode 19 +#define X_RRGetCrtcInfo 20 +#define X_RRSetCrtcConfig 21 +#define X_RRGetCrtcGammaSize 22 +#define X_RRGetCrtcGamma 23 +#define X_RRSetCrtcGamma 24 + +/* V1.3 additions */ +#define X_RRGetScreenResourcesCurrent 25 +#define X_RRSetCrtcTransform 26 +#define X_RRGetCrtcTransform 27 +#define X_RRGetPanning 28 +#define X_RRSetPanning 29 +#define X_RRSetOutputPrimary 30 +#define X_RRGetOutputPrimary 31 + +#define RRTransformUnit (1L << 0) +#define RRTransformScaleUp (1L << 1) +#define RRTransformScaleDown (1L << 2) +#define RRTransformProjective (1L << 3) + +/* v1.4 */ +#define X_RRGetProviders 32 +#define X_RRGetProviderInfo 33 +#define X_RRSetProviderOffloadSink 34 +#define X_RRSetProviderOutputSource 35 +#define X_RRListProviderProperties 36 +#define X_RRQueryProviderProperty 37 +#define X_RRConfigureProviderProperty 38 +#define X_RRChangeProviderProperty 39 +#define X_RRDeleteProviderProperty 40 +#define X_RRGetProviderProperty 41 + +/* v1.5 */ +#define X_RRGetMonitors 42 +#define X_RRSetMonitor 43 +#define X_RRDeleteMonitor 44 + +/* v1.6 */ +#define X_RRCreateLease 45 +#define X_RRFreeLease 46 + +/* Event selection bits */ +#define RRScreenChangeNotifyMask (1L << 0) +/* V1.2 additions */ +#define RRCrtcChangeNotifyMask (1L << 1) +#define RROutputChangeNotifyMask (1L << 2) +#define RROutputPropertyNotifyMask (1L << 3) +/* V1.4 additions */ +#define RRProviderChangeNotifyMask (1L << 4) +#define RRProviderPropertyNotifyMask (1L << 5) +#define RRResourceChangeNotifyMask (1L << 6) +/* V1.6 additions */ +#define RRLeaseNotifyMask (1L << 7) + +/* Event codes */ +#define RRScreenChangeNotify 0 +/* V1.2 additions */ +#define RRNotify 1 +/* RRNotify Subcodes */ +#define RRNotify_CrtcChange 0 +#define RRNotify_OutputChange 1 +#define RRNotify_OutputProperty 2 +#define RRNotify_ProviderChange 3 +#define RRNotify_ProviderProperty 4 +#define RRNotify_ResourceChange 5 +/* V1.6 additions */ +#define RRNotify_Lease 6 +/* used in the rotation field; rotation and reflection in 0.1 proto. */ +#define RR_Rotate_0 1 +#define RR_Rotate_90 2 +#define RR_Rotate_180 4 +#define RR_Rotate_270 8 + +/* new in 1.0 protocol, to allow reflection of screen */ + +#define RR_Reflect_X 16 +#define RR_Reflect_Y 32 + +#define RRSetConfigSuccess 0 +#define RRSetConfigInvalidConfigTime 1 +#define RRSetConfigInvalidTime 2 +#define RRSetConfigFailed 3 + +/* new in 1.2 protocol */ + +#define RR_HSyncPositive 0x00000001 +#define RR_HSyncNegative 0x00000002 +#define RR_VSyncPositive 0x00000004 +#define RR_VSyncNegative 0x00000008 +#define RR_Interlace 0x00000010 +#define RR_DoubleScan 0x00000020 +#define RR_CSync 0x00000040 +#define RR_CSyncPositive 0x00000080 +#define RR_CSyncNegative 0x00000100 +#define RR_HSkewPresent 0x00000200 +#define RR_BCast 0x00000400 +#define RR_PixelMultiplex 0x00000800 +#define RR_DoubleClock 0x00001000 +#define RR_ClockDivideBy2 0x00002000 + +#define RR_Connected 0 +#define RR_Disconnected 1 +#define RR_UnknownConnection 2 + +#define BadRROutput 0 +#define BadRRCrtc 1 +#define BadRRMode 2 +#define BadRRProvider 3 +#define BadRRLease 4 + +/* Conventional RandR output properties */ + +#define RR_PROPERTY_BACKLIGHT "Backlight" +#define RR_PROPERTY_RANDR_EDID "EDID" +#define RR_PROPERTY_SIGNAL_FORMAT "SignalFormat" +#define RR_PROPERTY_SIGNAL_PROPERTIES "SignalProperties" +#define RR_PROPERTY_CONNECTOR_TYPE "ConnectorType" +#define RR_PROPERTY_CONNECTOR_NUMBER "ConnectorNumber" +#define RR_PROPERTY_COMPATIBILITY_LIST "CompatibilityList" +#define RR_PROPERTY_CLONE_LIST "CloneList" +#define RR_PROPERTY_BORDER "Border" +#define RR_PROPERTY_BORDER_DIMENSIONS "BorderDimensions" +#define RR_PROPERTY_GUID "GUID" +#define RR_PROPERTY_RANDR_TILE "TILE" +#define RR_PROPERTY_NON_DESKTOP "non-desktop" + +/* roles this device can carry out */ +#define RR_Capability_None 0 +#define RR_Capability_SourceOutput 1 +#define RR_Capability_SinkOutput 2 +#define RR_Capability_SourceOffload 4 +#define RR_Capability_SinkOffload 8 + +#endif /* _RANDR_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/randrproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/randrproto.h new file mode 100644 index 0000000000000000000000000000000000000000..624c2544c99da9614c620dc93309122ebc2e9a30 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/randrproto.h @@ -0,0 +1,1152 @@ +/* + * Copyright © 2000 Compaq Computer Corporation + * Copyright © 2002 Hewlett-Packard Company + * Copyright © 2006 Intel Corporation + * Copyright © 2008 Red Hat, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that copyright + * notice and this permission notice appear in supporting documentation, and + * that the name of the copyright holders not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. The copyright holders make no representations + * about the suitability of this software for any purpose. It is provided "as + * is" without express or implied warranty. + * + * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE + * OF THIS SOFTWARE. + * + * Author: Jim Gettys, Hewlett-Packard Company, Inc. + * Keith Packard, Intel Corporation + */ + +/* note that RANDR 1.0 is incompatible with version 0.0, or 0.1 */ +/* V1.0 removes depth switching from the protocol */ +#ifndef _XRANDRP_H_ +#define _XRANDRP_H_ + +#include +#include + +#define Window CARD32 +#define Drawable CARD32 +#define Font CARD32 +#define Pixmap CARD32 +#define Cursor CARD32 +#define Colormap CARD32 +#define GContext CARD32 +#define Atom CARD32 +#define Time CARD32 +#define KeyCode CARD8 +#define KeySym CARD32 +#define RROutput CARD32 +#define RRMode CARD32 +#define RRCrtc CARD32 +#define RRProvider CARD32 +#define RRModeFlags CARD32 +#define RRLease CARD32 + +#define Rotation CARD16 +#define SizeID CARD16 +#define SubpixelOrder CARD16 + +/* + * data structures + */ + +typedef struct { + CARD16 widthInPixels; + CARD16 heightInPixels; + CARD16 widthInMillimeters; + CARD16 heightInMillimeters; +} xScreenSizes; +#define sz_xScreenSizes 8 + +/* + * requests and replies + */ + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + CARD32 majorVersion; + CARD32 minorVersion; +} xRRQueryVersionReq; +#define sz_xRRQueryVersionReq 12 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 majorVersion; + CARD32 minorVersion; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xRRQueryVersionReply; +#define sz_xRRQueryVersionReply 32 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + Window window; +} xRRGetScreenInfoReq; +#define sz_xRRGetScreenInfoReq 8 + +/* + * the xRRScreenInfoReply structure is followed by: + * + * the size information + */ + + +typedef struct { + BYTE type; /* X_Reply */ + BYTE setOfRotations; + CARD16 sequenceNumber; + CARD32 length; + Window root; + Time timestamp; + Time configTimestamp; + CARD16 nSizes; + SizeID sizeID; + Rotation rotation; + CARD16 rate; + CARD16 nrateEnts; + CARD16 pad; +} xRRGetScreenInfoReply; +#define sz_xRRGetScreenInfoReply 32 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + Drawable drawable; + Time timestamp; + Time configTimestamp; + SizeID sizeID; + Rotation rotation; +} xRR1_0SetScreenConfigReq; +#define sz_xRR1_0SetScreenConfigReq 20 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + Drawable drawable; + Time timestamp; + Time configTimestamp; + SizeID sizeID; + Rotation rotation; + CARD16 rate; + CARD16 pad; +} xRRSetScreenConfigReq; +#define sz_xRRSetScreenConfigReq 24 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 status; + CARD16 sequenceNumber; + CARD32 length; + Time newTimestamp; + Time newConfigTimestamp; + Window root; + CARD16 subpixelOrder; + CARD16 pad4; + CARD32 pad5; + CARD32 pad6; +} xRRSetScreenConfigReply; +#define sz_xRRSetScreenConfigReply 32 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + Window window; + CARD16 enable; + CARD16 pad2; +} xRRSelectInputReq; +#define sz_xRRSelectInputReq 12 + +/* + * Additions for version 1.2 + */ + +typedef struct _xRRModeInfo { + RRMode id; + CARD16 width; + CARD16 height; + CARD32 dotClock; + CARD16 hSyncStart; + CARD16 hSyncEnd; + CARD16 hTotal; + CARD16 hSkew; + CARD16 vSyncStart; + CARD16 vSyncEnd; + CARD16 vTotal; + CARD16 nameLength; + RRModeFlags modeFlags; +} xRRModeInfo; +#define sz_xRRModeInfo 32 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + Window window; +} xRRGetScreenSizeRangeReq; +#define sz_xRRGetScreenSizeRangeReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 pad; + CARD16 sequenceNumber; + CARD32 length; + CARD16 minWidth; + CARD16 minHeight; + CARD16 maxWidth; + CARD16 maxHeight; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; +} xRRGetScreenSizeRangeReply; +#define sz_xRRGetScreenSizeRangeReply 32 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + Window window; + CARD16 width; + CARD16 height; + CARD32 widthInMillimeters; + CARD32 heightInMillimeters; +} xRRSetScreenSizeReq; +#define sz_xRRSetScreenSizeReq 20 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + Window window; +} xRRGetScreenResourcesReq; +#define sz_xRRGetScreenResourcesReq 8 + +typedef struct { + BYTE type; + CARD8 pad; + CARD16 sequenceNumber; + CARD32 length; + Time timestamp; + Time configTimestamp; + CARD16 nCrtcs; + CARD16 nOutputs; + CARD16 nModes; + CARD16 nbytesNames; + CARD32 pad1; + CARD32 pad2; +} xRRGetScreenResourcesReply; +#define sz_xRRGetScreenResourcesReply 32 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RROutput output; + Time configTimestamp; +} xRRGetOutputInfoReq; +#define sz_xRRGetOutputInfoReq 12 + +typedef struct { + BYTE type; + CARD8 status; + CARD16 sequenceNumber; + CARD32 length; + Time timestamp; + RRCrtc crtc; + CARD32 mmWidth; + CARD32 mmHeight; + CARD8 connection; + CARD8 subpixelOrder; + CARD16 nCrtcs; + CARD16 nModes; + CARD16 nPreferred; + CARD16 nClones; + CARD16 nameLength; +} xRRGetOutputInfoReply; +#define sz_xRRGetOutputInfoReply 36 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RROutput output; +} xRRListOutputPropertiesReq; +#define sz_xRRListOutputPropertiesReq 8 + +typedef struct { + BYTE type; + CARD8 pad0; + CARD16 sequenceNumber; + CARD32 length; + CARD16 nAtoms; + CARD16 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xRRListOutputPropertiesReply; +#define sz_xRRListOutputPropertiesReply 32 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RROutput output; + Atom property; +} xRRQueryOutputPropertyReq; +#define sz_xRRQueryOutputPropertyReq 12 + +typedef struct { + BYTE type; + BYTE pad0; + CARD16 sequenceNumber; + CARD32 length; + BOOL pending; + BOOL range; + BOOL immutable; + BYTE pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xRRQueryOutputPropertyReply; +#define sz_xRRQueryOutputPropertyReply 32 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RROutput output; + Atom property; + BOOL pending; + BOOL range; + CARD16 pad; +} xRRConfigureOutputPropertyReq; +#define sz_xRRConfigureOutputPropertyReq 16 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RROutput output; + Atom property; + Atom type; + CARD8 format; + CARD8 mode; + CARD16 pad; + CARD32 nUnits; +} xRRChangeOutputPropertyReq; +#define sz_xRRChangeOutputPropertyReq 24 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RROutput output; + Atom property; +} xRRDeleteOutputPropertyReq; +#define sz_xRRDeleteOutputPropertyReq 12 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RROutput output; + Atom property; + Atom type; + CARD32 longOffset; + CARD32 longLength; +#ifdef __cplusplus + BOOL _delete; +#else + BOOL delete; +#endif + BOOL pending; + CARD16 pad1; +} xRRGetOutputPropertyReq; +#define sz_xRRGetOutputPropertyReq 28 + +typedef struct { + BYTE type; + CARD8 format; + CARD16 sequenceNumber; + CARD32 length; + Atom propertyType; + CARD32 bytesAfter; + CARD32 nItems; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; +} xRRGetOutputPropertyReply; +#define sz_xRRGetOutputPropertyReply 32 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + Window window; + xRRModeInfo modeInfo; +} xRRCreateModeReq; +#define sz_xRRCreateModeReq 40 + +typedef struct { + BYTE type; + CARD8 pad0; + CARD16 sequenceNumber; + CARD32 length; + RRMode mode; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xRRCreateModeReply; +#define sz_xRRCreateModeReply 32 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RRMode mode; +} xRRDestroyModeReq; +#define sz_xRRDestroyModeReq 8 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RROutput output; + RRMode mode; +} xRRAddOutputModeReq; +#define sz_xRRAddOutputModeReq 12 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RROutput output; + RRMode mode; +} xRRDeleteOutputModeReq; +#define sz_xRRDeleteOutputModeReq 12 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RRCrtc crtc; + Time configTimestamp; +} xRRGetCrtcInfoReq; +#define sz_xRRGetCrtcInfoReq 12 + +typedef struct { + BYTE type; + CARD8 status; + CARD16 sequenceNumber; + CARD32 length; + Time timestamp; + INT16 x; + INT16 y; + CARD16 width; + CARD16 height; + RRMode mode; + Rotation rotation; + Rotation rotations; + CARD16 nOutput; + CARD16 nPossibleOutput; +} xRRGetCrtcInfoReply; +#define sz_xRRGetCrtcInfoReply 32 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RRCrtc crtc; + Time timestamp; + Time configTimestamp; + INT16 x; + INT16 y; + RRMode mode; + Rotation rotation; + CARD16 pad; +} xRRSetCrtcConfigReq; +#define sz_xRRSetCrtcConfigReq 28 + +typedef struct { + BYTE type; + CARD8 status; + CARD16 sequenceNumber; + CARD32 length; + Time newTimestamp; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xRRSetCrtcConfigReply; +#define sz_xRRSetCrtcConfigReply 32 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RRCrtc crtc; +} xRRGetCrtcGammaSizeReq; +#define sz_xRRGetCrtcGammaSizeReq 8 + +typedef struct { + BYTE type; + CARD8 status; + CARD16 sequenceNumber; + CARD32 length; + CARD16 size; + CARD16 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xRRGetCrtcGammaSizeReply; +#define sz_xRRGetCrtcGammaSizeReply 32 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RRCrtc crtc; +} xRRGetCrtcGammaReq; +#define sz_xRRGetCrtcGammaReq 8 + +typedef struct { + BYTE type; + CARD8 status; + CARD16 sequenceNumber; + CARD32 length; + CARD16 size; + CARD16 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xRRGetCrtcGammaReply; +#define sz_xRRGetCrtcGammaReply 32 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RRCrtc crtc; + CARD16 size; + CARD16 pad1; +} xRRSetCrtcGammaReq; +#define sz_xRRSetCrtcGammaReq 12 + +/* + * Additions for V1.3 + */ + +typedef xRRGetScreenResourcesReq xRRGetScreenResourcesCurrentReq; + +#define sz_xRRGetScreenResourcesCurrentReq sz_xRRGetScreenResourcesReq + +typedef xRRGetScreenResourcesReply xRRGetScreenResourcesCurrentReply; +#define sz_xRRGetScreenResourcesCurrentReply sz_xRRGetScreenResourcesReply + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RRCrtc crtc; + xRenderTransform transform; + CARD16 nbytesFilter; /* number of bytes in filter name */ + CARD16 pad; +} xRRSetCrtcTransformReq; + +#define sz_xRRSetCrtcTransformReq 48 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RRCrtc crtc; +} xRRGetCrtcTransformReq; + +#define sz_xRRGetCrtcTransformReq 8 + +typedef struct { + BYTE type; + CARD8 status; + CARD16 sequenceNumber; + CARD32 length; + xRenderTransform pendingTransform; + BYTE hasTransforms; + CARD8 pad0; + CARD16 pad1; + xRenderTransform currentTransform; + CARD32 pad2; + CARD16 pendingNbytesFilter; /* number of bytes in filter name */ + CARD16 pendingNparamsFilter; /* number of filter params */ + CARD16 currentNbytesFilter; /* number of bytes in filter name */ + CARD16 currentNparamsFilter; /* number of filter params */ +} xRRGetCrtcTransformReply; + +#define sz_xRRGetCrtcTransformReply 96 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + Window window; + RROutput output; +} xRRSetOutputPrimaryReq; +#define sz_xRRSetOutputPrimaryReq 12 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + Window window; +} xRRGetOutputPrimaryReq; +#define sz_xRRGetOutputPrimaryReq 8 + +typedef struct { + BYTE type; + CARD8 pad; + CARD16 sequenceNumber; + CARD32 length; + RROutput output; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xRRGetOutputPrimaryReply; +#define sz_xRRGetOutputPrimaryReply 32 + +/* + * Additions for V1.4 + */ + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + Window window; +} xRRGetProvidersReq; +#define sz_xRRGetProvidersReq 8 + +typedef struct { + BYTE type; + CARD8 pad; + CARD16 sequenceNumber; + CARD32 length; + Time timestamp; + CARD16 nProviders; + CARD16 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xRRGetProvidersReply; +#define sz_xRRGetProvidersReply 32 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RRProvider provider; + Time configTimestamp; +} xRRGetProviderInfoReq; +#define sz_xRRGetProviderInfoReq 12 + +typedef struct { + BYTE type; + CARD8 status; + CARD16 sequenceNumber; + CARD32 length; + Time timestamp; + CARD32 capabilities; + CARD16 nCrtcs; + CARD16 nOutputs; + CARD16 nAssociatedProviders; + CARD16 nameLength; + CARD32 pad1; + CARD32 pad2; +} xRRGetProviderInfoReply; +#define sz_xRRGetProviderInfoReply 32 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RRProvider provider; + RRProvider source_provider; + Time configTimestamp; +} xRRSetProviderOutputSourceReq; +#define sz_xRRSetProviderOutputSourceReq 16 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RRProvider provider; + RRProvider sink_provider; + Time configTimestamp; +} xRRSetProviderOffloadSinkReq; +#define sz_xRRSetProviderOffloadSinkReq 16 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RRProvider provider; +} xRRListProviderPropertiesReq; +#define sz_xRRListProviderPropertiesReq 8 + +typedef struct { + BYTE type; + CARD8 pad0; + CARD16 sequenceNumber; + CARD32 length; + CARD16 nAtoms; + CARD16 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xRRListProviderPropertiesReply; +#define sz_xRRListProviderPropertiesReply 32 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RRProvider provider; + Atom property; +} xRRQueryProviderPropertyReq; +#define sz_xRRQueryProviderPropertyReq 12 + +typedef struct { + BYTE type; + BYTE pad0; + CARD16 sequenceNumber; + CARD32 length; + BOOL pending; + BOOL range; + BOOL immutable; + BYTE pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xRRQueryProviderPropertyReply; +#define sz_xRRQueryProviderPropertyReply 32 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RRProvider provider; + Atom property; + BOOL pending; + BOOL range; + CARD16 pad; +} xRRConfigureProviderPropertyReq; +#define sz_xRRConfigureProviderPropertyReq 16 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RRProvider provider; + Atom property; + Atom type; + CARD8 format; + CARD8 mode; + CARD16 pad; + CARD32 nUnits; +} xRRChangeProviderPropertyReq; +#define sz_xRRChangeProviderPropertyReq 24 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RRProvider provider; + Atom property; +} xRRDeleteProviderPropertyReq; +#define sz_xRRDeleteProviderPropertyReq 12 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RRProvider provider; + Atom property; + Atom type; + CARD32 longOffset; + CARD32 longLength; +#ifdef __cplusplus + BOOL _delete; +#else + BOOL delete; +#endif + BOOL pending; + CARD16 pad1; +} xRRGetProviderPropertyReq; +#define sz_xRRGetProviderPropertyReq 28 + +typedef struct { + BYTE type; + CARD8 format; + CARD16 sequenceNumber; + CARD32 length; + Atom propertyType; + CARD32 bytesAfter; + CARD32 nItems; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; +} xRRGetProviderPropertyReply; +#define sz_xRRGetProviderPropertyReply 32 + +/* + * Additions for V1.6 + */ + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + Window window; + RRLease lid; + CARD16 nCrtcs; + CARD16 nOutputs; +} xRRCreateLeaseReq; +#define sz_xRRCreateLeaseReq 16 + +typedef struct { + BYTE type; + CARD8 nfd; + CARD16 sequenceNumber; + CARD32 length; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; + CARD32 pad7; +} xRRCreateLeaseReply; +#define sz_xRRCreateLeaseReply 32 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RRLease lid; + BYTE terminate; + CARD8 pad1; + CARD16 pad2; +} xRRFreeLeaseReq; +#define sz_xRRFreeLeaseReq 12 + +/* + * event + */ +typedef struct { + CARD8 type; /* always evBase + ScreenChangeNotify */ + CARD8 rotation; /* new rotation */ + CARD16 sequenceNumber; + Time timestamp; /* time screen was changed */ + Time configTimestamp; /* time config data was changed */ + Window root; /* root window */ + Window window; /* window requesting notification */ + SizeID sizeID; /* new size ID */ + CARD16 subpixelOrder; /* subpixel order */ + CARD16 widthInPixels; /* new size */ + CARD16 heightInPixels; + CARD16 widthInMillimeters; + CARD16 heightInMillimeters; +} xRRScreenChangeNotifyEvent; +#define sz_xRRScreenChangeNotifyEvent 32 + +typedef struct { + CARD8 type; /* always evBase + RRNotify */ + CARD8 subCode; /* RRNotify_CrtcChange */ + CARD16 sequenceNumber; + Time timestamp; /* time crtc was changed */ + Window window; /* window requesting notification */ + RRCrtc crtc; /* affected CRTC */ + RRMode mode; /* current mode */ + CARD16 rotation; /* rotation and reflection */ + CARD16 pad1; /* unused */ + INT16 x; /* new location */ + INT16 y; + CARD16 width; /* new size */ + CARD16 height; +} xRRCrtcChangeNotifyEvent; +#define sz_xRRCrtcChangeNotifyEvent 32 + +typedef struct { + CARD8 type; /* always evBase + RRNotify */ + CARD8 subCode; /* RRNotify_OutputChange */ + CARD16 sequenceNumber; + Time timestamp; /* time output was changed */ + Time configTimestamp; /* time config was changed */ + Window window; /* window requesting notification */ + RROutput output; /* affected output */ + RRCrtc crtc; /* current crtc */ + RRMode mode; /* current mode */ + CARD16 rotation; /* rotation and reflection */ + CARD8 connection; /* connection status */ + CARD8 subpixelOrder; /* subpixel order */ +} xRROutputChangeNotifyEvent; +#define sz_xRROutputChangeNotifyEvent 32 + +typedef struct { + CARD8 type; /* always evBase + RRNotify */ + CARD8 subCode; /* RRNotify_OutputProperty */ + CARD16 sequenceNumber; + Window window; /* window requesting notification */ + RROutput output; /* affected output */ + Atom atom; /* property name */ + Time timestamp; /* time crtc was changed */ + CARD8 state; /* NewValue or Deleted */ + CARD8 pad1; + CARD16 pad2; + CARD32 pad3; + CARD32 pad4; +} xRROutputPropertyNotifyEvent; +#define sz_xRROutputPropertyNotifyEvent 32 + +typedef struct { + CARD8 type; /* always evBase + RRNotify */ + CARD8 subCode; /* RRNotify_ProviderChange */ + CARD16 sequenceNumber; + Time timestamp; /* time provider was changed */ + Window window; /* window requesting notification */ + RRProvider provider; /* affected provider */ + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xRRProviderChangeNotifyEvent; +#define sz_xRRProviderChangeNotifyEvent 32 + +typedef struct { + CARD8 type; /* always evBase + RRNotify */ + CARD8 subCode; /* RRNotify_ProviderProperty */ + CARD16 sequenceNumber; + Window window; /* window requesting notification */ + RRProvider provider; /* affected provider */ + Atom atom; /* property name */ + Time timestamp; /* time provider was changed */ + CARD8 state; /* NewValue or Deleted */ + CARD8 pad1; + CARD16 pad2; + CARD32 pad3; + CARD32 pad4; +} xRRProviderPropertyNotifyEvent; +#define sz_xRRProviderPropertyNotifyEvent 32 + +typedef struct { + CARD8 type; /* always evBase + RRNotify */ + CARD8 subCode; /* RRNotify_ResourceChange */ + CARD16 sequenceNumber; + Time timestamp; /* time resource was changed */ + Window window; /* window requesting notification */ + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xRRResourceChangeNotifyEvent; +#define sz_xRRResourceChangeNotifyEvent 32 + +typedef struct { + CARD8 type; /* always evBase + RRNotify */ + CARD8 subCode; /* RRNotify_Lease */ + CARD16 sequenceNumber; + Time timestamp; /* time resource was changed */ + Window window; /* window requesting notification */ + RRLease lease; + CARD8 created; /* created/deleted */ + CARD8 pad0; + CARD16 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xRRLeaseNotifyEvent; +#define sz_xRRLeaseNotifyEvent 32 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RRCrtc crtc; +} xRRGetPanningReq; +#define sz_xRRGetPanningReq 8 + +typedef struct { + BYTE type; + CARD8 status; + CARD16 sequenceNumber; + CARD32 length; + Time timestamp; + CARD16 left; + CARD16 top; + CARD16 width; + CARD16 height; + CARD16 track_left; + CARD16 track_top; + CARD16 track_width; + CARD16 track_height; + INT16 border_left; + INT16 border_top; + INT16 border_right; + INT16 border_bottom; +} xRRGetPanningReply; +#define sz_xRRGetPanningReply 36 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + RRCrtc crtc; + Time timestamp; + CARD16 left; + CARD16 top; + CARD16 width; + CARD16 height; + CARD16 track_left; + CARD16 track_top; + CARD16 track_width; + CARD16 track_height; + INT16 border_left; + INT16 border_top; + INT16 border_right; + INT16 border_bottom; +} xRRSetPanningReq; +#define sz_xRRSetPanningReq 36 + +typedef struct { + BYTE type; + CARD8 status; + CARD16 sequenceNumber; + CARD32 length; + Time newTimestamp; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xRRSetPanningReply; +#define sz_xRRSetPanningReply 32 + +typedef struct { + Atom name; + BOOL primary; + BOOL automatic; + CARD16 noutput; + INT16 x; + INT16 y; + CARD16 width; + CARD16 height; + CARD32 widthInMillimeters; + CARD32 heightInMillimeters; +} xRRMonitorInfo; +#define sz_xRRMonitorInfo 24 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + Window window; + BOOL get_active; + CARD8 pad; + CARD16 pad2; +} xRRGetMonitorsReq; +#define sz_xRRGetMonitorsReq 12 + +typedef struct { + BYTE type; + CARD8 status; + CARD16 sequenceNumber; + CARD32 length; + Time timestamp; + CARD32 nmonitors; + CARD32 noutputs; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; +} xRRGetMonitorsReply; +#define sz_xRRGetMonitorsReply 32 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + Window window; + xRRMonitorInfo monitor; +} xRRSetMonitorReq; +#define sz_xRRSetMonitorReq 32 + +typedef struct { + CARD8 reqType; + CARD8 randrReqType; + CARD16 length; + Window window; + Atom name; +} xRRDeleteMonitorReq; +#define sz_xRRDeleteMonitorReq 12 + +#undef RRLease +#undef RRModeFlags +#undef RRCrtc +#undef RRMode +#undef RROutput +#undef RRMode +#undef RRCrtc +#undef RRProvider +#undef Drawable +#undef Window +#undef Font +#undef Pixmap +#undef Cursor +#undef Colormap +#undef GContext +#undef Atom +#undef Time +#undef KeyCode +#undef KeySym +#undef Rotation +#undef SizeID +#undef SubpixelOrder + +#endif /* _XRANDRP_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/recordconst.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/recordconst.h new file mode 100644 index 0000000000000000000000000000000000000000..ecdd81be5c6bebf3267af9909d4c880c2d9da0b1 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/recordconst.h @@ -0,0 +1,54 @@ +/*************************************************************************** + * Copyright 1995 Network Computing Devices + * + * Permission to use, copy, modify, distribute, and sell this software and + * its documentation for any purpose is hereby granted without fee, provided + * that the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Network Computing Devices + * not be used in advertising or publicity pertaining to distribution + * of the software without specific, written prior permission. + * + * NETWORK COMPUTING DEVICES DISCLAIMs ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES BE LIABLE + * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + **************************************************************************/ + +#ifndef _RECORDCONST_H_ +#define _RECORDCONST_H_ + +#define RECORD_NAME "RECORD" +#define RECORD_MAJOR_VERSION 1 +#define RECORD_MINOR_VERSION 13 +#define RECORD_LOWEST_MAJOR_VERSION 1 +#define RECORD_LOWEST_MINOR_VERSION 12 + +#define XRecordBadContext 0 /* Not a valid RC */ + +#define RecordNumErrors (XRecordBadContext + 1) +#define RecordNumEvents 0L + +/* + * Constants for arguments of various requests + */ +#define XRecordFromServerTime 0x01 +#define XRecordFromClientTime 0x02 +#define XRecordFromClientSequence 0x04 + +#define XRecordCurrentClients 1 +#define XRecordFutureClients 2 +#define XRecordAllClients 3 + +#define XRecordFromServer 0 +#define XRecordFromClient 1 +#define XRecordClientStarted 2 +#define XRecordClientDied 3 +#define XRecordStartOfData 4 +#define XRecordEndOfData 5 + + +#endif /* _RECORD_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/recordproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/recordproto.h new file mode 100644 index 0000000000000000000000000000000000000000..d2016eb08cf0d0d1c4aa59be0ebb9b18c0abcfee --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/recordproto.h @@ -0,0 +1,306 @@ +/*************************************************************************** + * Copyright 1995 Network Computing Devices + * + * Permission to use, copy, modify, distribute, and sell this software and + * its documentation for any purpose is hereby granted without fee, provided + * that the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Network Computing Devices + * not be used in advertising or publicity pertaining to distribution + * of the software without specific, written prior permission. + * + * NETWORK COMPUTING DEVICES DISCLAIMs ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES BE LIABLE + * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + **************************************************************************/ + +#ifndef _RECORDPROTO_H_ +#define _RECORDPROTO_H_ + +#include + +/* only difference between 1.12 and 1.13 is byte order of device events, + which the library doesn't deal with. */ + +/********************************************************* + * + * Protocol request constants + * + */ +#define X_RecordQueryVersion 0 /* First request from client */ +#define X_RecordCreateContext 1 /* Create client RC */ +#define X_RecordRegisterClients 2 /* Add to client RC */ +#define X_RecordUnregisterClients 3 /* Delete from client RC */ +#define X_RecordGetContext 4 /* Query client RC */ +#define X_RecordEnableContext 5 /* Enable interception and reporting */ +#define X_RecordDisableContext 6 /* Disable interception and reporting */ +#define X_RecordFreeContext 7 /* Free client RC */ + +#define sz_XRecordRange 32 +#define sz_XRecordClientInfo 12 +#define sz_XRecordState 16 +#define sz_XRecordDatum 32 + + +#define XRecordGlobaldef +#define XRecordGlobalref extern + +#define RecordMaxEvent (128L-1L) +#define RecordMinDeviceEvent (2L) +#define RecordMaxDeviceEvent (6L) +#define RecordMaxError (256L-1L) +#define RecordMaxCoreRequest (128L-1L) +#define RecordMaxExtRequest (256L-1L) +#define RecordMinExtRequest (129L-1L) + +#define RECORD_RC CARD32 +#define RECORD_XIDBASE CARD32 +#define RECORD_CLIENTSPEC CARD32 +#define RECORD_ELEMENT_HEADER CARD8 + +typedef RECORD_CLIENTSPEC RecordClientSpec, *RecordClientSpecPtr; + +typedef struct +{ + CARD8 first; + CARD8 last; +} RECORD_RANGE8; + +typedef struct +{ + CARD16 first; + CARD16 last; +} RECORD_RANGE16; + +typedef struct +{ + RECORD_RANGE8 majorCode; + RECORD_RANGE16 minorCode; +} RECORD_EXTRANGE; + +typedef struct +{ + RECORD_RANGE8 coreRequests; + RECORD_RANGE8 coreReplies; + RECORD_EXTRANGE extRequests; + RECORD_EXTRANGE extReplies; + RECORD_RANGE8 deliveredEvents; + RECORD_RANGE8 deviceEvents; + RECORD_RANGE8 errors; + BOOL clientStarted; + BOOL clientDied; +} RECORDRANGE; +#define sz_RECORDRANGE 24 + +/* typedef RECORDRANGE xRecordRange, *xRecordRangePtr; +#define sz_xRecordRange 24 */ + +/* Cannot have structures within structures going over the wire */ +typedef struct +{ + CARD8 coreRequestsFirst; + CARD8 coreRequestsLast; + CARD8 coreRepliesFirst; + CARD8 coreRepliesLast; + CARD8 extRequestsMajorFirst; + CARD8 extRequestsMajorLast; + CARD16 extRequestsMinorFirst; + CARD16 extRequestsMinorLast; + CARD8 extRepliesMajorFirst; + CARD8 extRepliesMajorLast; + CARD16 extRepliesMinorFirst; + CARD16 extRepliesMinorLast; + CARD8 deliveredEventsFirst; + CARD8 deliveredEventsLast; + CARD8 deviceEventsFirst; + CARD8 deviceEventsLast; + CARD8 errorsFirst; + CARD8 errorsLast; + BOOL clientStarted; + BOOL clientDied; +} xRecordRange; +#define sz_xRecordRange 24 + +typedef struct +{ + RECORD_CLIENTSPEC clientResource; + CARD32 nRanges; +/* LISTofRECORDRANGE */ +} RECORD_CLIENT_INFO; + +typedef RECORD_CLIENT_INFO xRecordClientInfo; + +/* + * Initialize + */ +typedef struct { + CARD8 reqType; + CARD8 recordReqType; + CARD16 length; + CARD16 majorVersion; + CARD16 minorVersion; +} xRecordQueryVersionReq; +#define sz_xRecordQueryVersionReq 8 + +typedef struct +{ + CARD8 type; + CARD8 pad0; + CARD16 sequenceNumber; + CARD32 length; + CARD16 majorVersion; + CARD16 minorVersion; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + } xRecordQueryVersionReply; +#define sz_xRecordQueryVersionReply 32 + +/* + * Create RC + */ +typedef struct +{ + CARD8 reqType; + CARD8 recordReqType; + CARD16 length; + RECORD_RC context; + RECORD_ELEMENT_HEADER elementHeader; + CARD8 pad; + CARD16 pad0; + CARD32 nClients; + CARD32 nRanges; +/* LISTofRECORD_CLIENTSPEC */ +/* LISTofRECORDRANGE */ +} xRecordCreateContextReq; +#define sz_xRecordCreateContextReq 20 + +/* + * Add to RC + */ +typedef struct +{ + CARD8 reqType; + CARD8 recordReqType; + CARD16 length; + RECORD_RC context; + RECORD_ELEMENT_HEADER elementHeader; + CARD8 pad; + CARD16 pad0; + CARD32 nClients; + CARD32 nRanges; +/* LISTofRECORD_CLIENTSPEC */ +/* LISTofRECORDRANGE */ +} xRecordRegisterClientsReq; +#define sz_xRecordRegisterClientsReq 20 + +/* + * Delete from RC + */ +typedef struct +{ + CARD8 reqType; + CARD8 recordReqType; + CARD16 length; + RECORD_RC context; + CARD32 nClients; +/* LISTofRECORD_CLIENTSPEC */ +} xRecordUnregisterClientsReq; +#define sz_xRecordUnregisterClientsReq 12 + +/* + * Query RC + */ +typedef struct +{ + CARD8 reqType; + CARD8 recordReqType; + CARD16 length; + RECORD_RC context; +} xRecordGetContextReq; +#define sz_xRecordGetContextReq 8 + +typedef struct +{ + CARD8 type; + BOOL enabled; + CARD16 sequenceNumber; + CARD32 length; + RECORD_ELEMENT_HEADER elementHeader; + CARD8 pad; + CARD16 pad0; + CARD32 nClients; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +/* LISTofCLIENT_INFO */ /* intercepted-clients */ +} xRecordGetContextReply; +#define sz_xRecordGetContextReply 32 + +/* + * Enable data interception + */ +typedef struct +{ + CARD8 reqType; + CARD8 recordReqType; + CARD16 length; + RECORD_RC context; +} xRecordEnableContextReq; +#define sz_xRecordEnableContextReq 8 + +typedef struct +{ + CARD8 type; + CARD8 category; + CARD16 sequenceNumber; + CARD32 length; + RECORD_ELEMENT_HEADER elementHeader; + BOOL clientSwapped; + CARD16 pad1; + RECORD_XIDBASE idBase; + CARD32 serverTime; + CARD32 recordedSequenceNumber; + CARD32 pad3; + CARD32 pad4; + /* BYTE data; */ +} xRecordEnableContextReply; +#define sz_xRecordEnableContextReply 32 + +/* + * Disable data interception + */ +typedef struct +{ + CARD8 reqType; + CARD8 recordReqType; + CARD16 length; + RECORD_RC context; +} xRecordDisableContextReq; +#define sz_xRecordDisableContextReq 8 + +/* + * Free RC + */ +typedef struct +{ + CARD8 reqType; + CARD8 recordReqType; + CARD16 length; + RECORD_RC context; +} xRecordFreeContextReq; +#define sz_xRecordFreeContextReq 8 + +#undef RECORD_RC +#undef RECORD_XIDBASE +#undef RECORD_ELEMENT_HEADER +#undef RECORD_CLIENTSPEC + +#endif diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/recordstr.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/recordstr.h new file mode 100644 index 0000000000000000000000000000000000000000..7f269b77e3af4cfbdf7a13163a681e6c69a654e8 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/recordstr.h @@ -0,0 +1,4 @@ +#warning "recordstr.h is obsolete and may be removed in the future." +#warning "include for the library interfaces." +#warning "include for the protocol defines." +#include diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/render.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/render.h new file mode 100644 index 0000000000000000000000000000000000000000..7ecde3f59e72d080ce9d59e97383f7a2dd1c0569 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/render.h @@ -0,0 +1,210 @@ +/* + * Copyright © 2000 SuSE, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of SuSE not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. SuSE makes no representations about the + * suitability of this software for any purpose. It is provided "as is" + * without express or implied warranty. + * + * SuSE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL SuSE + * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Author: Keith Packard, SuSE, Inc. + */ + +#ifndef _RENDER_H_ +#define _RENDER_H_ + +#include + +typedef XID Glyph; +typedef XID GlyphSet; +typedef XID Picture; +typedef XID PictFormat; + +#define RENDER_NAME "RENDER" +#define RENDER_MAJOR 0 +#define RENDER_MINOR 11 + +#define X_RenderQueryVersion 0 +#define X_RenderQueryPictFormats 1 +#define X_RenderQueryPictIndexValues 2 /* 0.7 */ +#define X_RenderQueryDithers 3 +#define X_RenderCreatePicture 4 +#define X_RenderChangePicture 5 +#define X_RenderSetPictureClipRectangles 6 +#define X_RenderFreePicture 7 +#define X_RenderComposite 8 +#define X_RenderScale 9 +#define X_RenderTrapezoids 10 +#define X_RenderTriangles 11 +#define X_RenderTriStrip 12 +#define X_RenderTriFan 13 +#define X_RenderColorTrapezoids 14 +#define X_RenderColorTriangles 15 +/* #define X_RenderTransform 16 */ +#define X_RenderCreateGlyphSet 17 +#define X_RenderReferenceGlyphSet 18 +#define X_RenderFreeGlyphSet 19 +#define X_RenderAddGlyphs 20 +#define X_RenderAddGlyphsFromPicture 21 +#define X_RenderFreeGlyphs 22 +#define X_RenderCompositeGlyphs8 23 +#define X_RenderCompositeGlyphs16 24 +#define X_RenderCompositeGlyphs32 25 +#define X_RenderFillRectangles 26 +/* 0.5 */ +#define X_RenderCreateCursor 27 +/* 0.6 */ +#define X_RenderSetPictureTransform 28 +#define X_RenderQueryFilters 29 +#define X_RenderSetPictureFilter 30 +/* 0.8 */ +#define X_RenderCreateAnimCursor 31 +/* 0.9 */ +#define X_RenderAddTraps 32 +/* 0.10 */ +#define X_RenderCreateSolidFill 33 +#define X_RenderCreateLinearGradient 34 +#define X_RenderCreateRadialGradient 35 +#define X_RenderCreateConicalGradient 36 +#define RenderNumberRequests (X_RenderCreateConicalGradient+1) + +#define BadPictFormat 0 +#define BadPicture 1 +#define BadPictOp 2 +#define BadGlyphSet 3 +#define BadGlyph 4 +#define RenderNumberErrors (BadGlyph+1) + +#define PictTypeIndexed 0 +#define PictTypeDirect 1 + +#define PictOpMinimum 0 +#define PictOpClear 0 +#define PictOpSrc 1 +#define PictOpDst 2 +#define PictOpOver 3 +#define PictOpOverReverse 4 +#define PictOpIn 5 +#define PictOpInReverse 6 +#define PictOpOut 7 +#define PictOpOutReverse 8 +#define PictOpAtop 9 +#define PictOpAtopReverse 10 +#define PictOpXor 11 +#define PictOpAdd 12 +#define PictOpSaturate 13 +#define PictOpMaximum 13 + +/* + * Operators only available in version 0.2 + */ +#define PictOpDisjointMinimum 0x10 +#define PictOpDisjointClear 0x10 +#define PictOpDisjointSrc 0x11 +#define PictOpDisjointDst 0x12 +#define PictOpDisjointOver 0x13 +#define PictOpDisjointOverReverse 0x14 +#define PictOpDisjointIn 0x15 +#define PictOpDisjointInReverse 0x16 +#define PictOpDisjointOut 0x17 +#define PictOpDisjointOutReverse 0x18 +#define PictOpDisjointAtop 0x19 +#define PictOpDisjointAtopReverse 0x1a +#define PictOpDisjointXor 0x1b +#define PictOpDisjointMaximum 0x1b + +#define PictOpConjointMinimum 0x20 +#define PictOpConjointClear 0x20 +#define PictOpConjointSrc 0x21 +#define PictOpConjointDst 0x22 +#define PictOpConjointOver 0x23 +#define PictOpConjointOverReverse 0x24 +#define PictOpConjointIn 0x25 +#define PictOpConjointInReverse 0x26 +#define PictOpConjointOut 0x27 +#define PictOpConjointOutReverse 0x28 +#define PictOpConjointAtop 0x29 +#define PictOpConjointAtopReverse 0x2a +#define PictOpConjointXor 0x2b +#define PictOpConjointMaximum 0x2b + +/* + * Operators only available in version 0.11 + */ +#define PictOpBlendMinimum 0x30 +#define PictOpMultiply 0x30 +#define PictOpScreen 0x31 +#define PictOpOverlay 0x32 +#define PictOpDarken 0x33 +#define PictOpLighten 0x34 +#define PictOpColorDodge 0x35 +#define PictOpColorBurn 0x36 +#define PictOpHardLight 0x37 +#define PictOpSoftLight 0x38 +#define PictOpDifference 0x39 +#define PictOpExclusion 0x3a +#define PictOpHSLHue 0x3b +#define PictOpHSLSaturation 0x3c +#define PictOpHSLColor 0x3d +#define PictOpHSLLuminosity 0x3e +#define PictOpBlendMaximum 0x3e + +#define PolyEdgeSharp 0 +#define PolyEdgeSmooth 1 + +#define PolyModePrecise 0 +#define PolyModeImprecise 1 + +#define CPRepeat (1 << 0) +#define CPAlphaMap (1 << 1) +#define CPAlphaXOrigin (1 << 2) +#define CPAlphaYOrigin (1 << 3) +#define CPClipXOrigin (1 << 4) +#define CPClipYOrigin (1 << 5) +#define CPClipMask (1 << 6) +#define CPGraphicsExposure (1 << 7) +#define CPSubwindowMode (1 << 8) +#define CPPolyEdge (1 << 9) +#define CPPolyMode (1 << 10) +#define CPDither (1 << 11) +#define CPComponentAlpha (1 << 12) +#define CPLastBit 12 + +/* Filters included in 0.6 */ +#define FilterNearest "nearest" +#define FilterBilinear "bilinear" +/* Filters included in 0.10 */ +#define FilterConvolution "convolution" + +#define FilterFast "fast" +#define FilterGood "good" +#define FilterBest "best" + +#define FilterAliasNone -1 + +/* Subpixel orders included in 0.6 */ +#define SubPixelUnknown 0 +#define SubPixelHorizontalRGB 1 +#define SubPixelHorizontalBGR 2 +#define SubPixelVerticalRGB 3 +#define SubPixelVerticalBGR 4 +#define SubPixelNone 5 + +/* Extended repeat attributes included in 0.10 */ +#define RepeatNone 0 +#define RepeatNormal 1 +#define RepeatPad 2 +#define RepeatReflect 3 + +#endif /* _RENDER_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/renderproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/renderproto.h new file mode 100644 index 0000000000000000000000000000000000000000..2cd06af5d2f14e822e76cfda71e0ce94104ab029 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/renderproto.h @@ -0,0 +1,661 @@ +/* + * Copyright © 2000 SuSE, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of SuSE not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. SuSE makes no representations about the + * suitability of this software for any purpose. It is provided "as is" + * without express or implied warranty. + * + * SuSE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL SuSE + * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Author: Keith Packard, SuSE, Inc. + */ + +#ifndef _XRENDERP_H_ +#define _XRENDERP_H_ + +#include +#include + +#define Window CARD32 +#define Drawable CARD32 +#define Font CARD32 +#define Pixmap CARD32 +#define Cursor CARD32 +#define Colormap CARD32 +#define GContext CARD32 +#define Atom CARD32 +#define VisualID CARD32 +#define Time CARD32 +#define KeyCode CARD8 +#define KeySym CARD32 + +#define Picture CARD32 +#define PictFormat CARD32 +#define Fixed INT32 +#define Glyphset CARD32 + +/* + * data structures + */ + +typedef struct { + CARD16 red; + CARD16 redMask; + CARD16 green; + CARD16 greenMask; + CARD16 blue; + CARD16 blueMask; + CARD16 alpha; + CARD16 alphaMask; +} xDirectFormat; + +#define sz_xDirectFormat 16 + +typedef struct { + PictFormat id; + CARD8 type; + CARD8 depth; + CARD16 pad1; + xDirectFormat direct; + Colormap colormap; +} xPictFormInfo; + +#define sz_xPictFormInfo 28 + +typedef struct { + VisualID visual; + PictFormat format; +} xPictVisual; + +#define sz_xPictVisual 8 + +typedef struct { + CARD8 depth; + CARD8 pad1; + CARD16 nPictVisuals; + CARD32 pad2; +} xPictDepth; + +#define sz_xPictDepth 8 + +typedef struct { + CARD32 nDepth; + PictFormat fallback; +} xPictScreen; + +#define sz_xPictScreen 8 + +typedef struct { + CARD32 pixel; + CARD16 red; + CARD16 green; + CARD16 blue; + CARD16 alpha; +} xIndexValue; + +#define sz_xIndexValue 12 + +typedef struct { + CARD16 red; + CARD16 green; + CARD16 blue; + CARD16 alpha; +} xRenderColor; + +#define sz_xRenderColor 8 + +typedef struct { + Fixed x; + Fixed y; +} xPointFixed; + +#define sz_xPointFixed 8 + +typedef struct { + xPointFixed p1; + xPointFixed p2; +} xLineFixed; + +#define sz_xLineFixed 16 + +typedef struct { + xPointFixed p1, p2, p3; +} xTriangle; + +#define sz_xTriangle 24 + +typedef struct { + Fixed top; + Fixed bottom; + xLineFixed left; + xLineFixed right; +} xTrapezoid; + +#define sz_xTrapezoid 40 + +typedef struct { + CARD16 width; + CARD16 height; + INT16 x; + INT16 y; + INT16 xOff; + INT16 yOff; +} xGlyphInfo; + +#define sz_xGlyphInfo 12 + +typedef struct { + CARD8 len; + CARD8 pad1; + CARD16 pad2; + INT16 deltax; + INT16 deltay; +} xGlyphElt; + +#define sz_xGlyphElt 8 + +typedef struct { + Fixed l, r, y; +} xSpanFix; + +#define sz_xSpanFix 12 + +typedef struct { + xSpanFix top, bot; +} xTrap; + +#define sz_xTrap 24 + +/* + * requests and replies + */ +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + CARD32 majorVersion; + CARD32 minorVersion; +} xRenderQueryVersionReq; + +#define sz_xRenderQueryVersionReq 12 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 majorVersion; + CARD32 minorVersion; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xRenderQueryVersionReply; + +#define sz_xRenderQueryVersionReply 32 + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; +} xRenderQueryPictFormatsReq; + +#define sz_xRenderQueryPictFormatsReq 4 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 numFormats; + CARD32 numScreens; + CARD32 numDepths; + CARD32 numVisuals; + CARD32 numSubpixel; /* Version 0.6 */ + CARD32 pad5; +} xRenderQueryPictFormatsReply; + +#define sz_xRenderQueryPictFormatsReply 32 + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + PictFormat format; +} xRenderQueryPictIndexValuesReq; + +#define sz_xRenderQueryPictIndexValuesReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 numIndexValues; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xRenderQueryPictIndexValuesReply; + +#define sz_xRenderQueryPictIndexValuesReply 32 + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + Picture pid; + Drawable drawable; + PictFormat format; + CARD32 mask; +} xRenderCreatePictureReq; + +#define sz_xRenderCreatePictureReq 20 + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + Picture picture; + CARD32 mask; +} xRenderChangePictureReq; + +#define sz_xRenderChangePictureReq 12 + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + Picture picture; + INT16 xOrigin; + INT16 yOrigin; +} xRenderSetPictureClipRectanglesReq; + +#define sz_xRenderSetPictureClipRectanglesReq 12 + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + Picture picture; +} xRenderFreePictureReq; + +#define sz_xRenderFreePictureReq 8 + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + CARD8 op; + CARD8 pad1; + CARD16 pad2; + Picture src; + Picture mask; + Picture dst; + INT16 xSrc; + INT16 ySrc; + INT16 xMask; + INT16 yMask; + INT16 xDst; + INT16 yDst; + CARD16 width; + CARD16 height; +} xRenderCompositeReq; + +#define sz_xRenderCompositeReq 36 + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + Picture src; + Picture dst; + CARD32 colorScale; + CARD32 alphaScale; + INT16 xSrc; + INT16 ySrc; + INT16 xDst; + INT16 yDst; + CARD16 width; + CARD16 height; +} xRenderScaleReq; + +#define sz_xRenderScaleReq 32 + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + CARD8 op; + CARD8 pad1; + CARD16 pad2; + Picture src; + Picture dst; + PictFormat maskFormat; + INT16 xSrc; + INT16 ySrc; +} xRenderTrapezoidsReq; + +#define sz_xRenderTrapezoidsReq 24 + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + CARD8 op; + CARD8 pad1; + CARD16 pad2; + Picture src; + Picture dst; + PictFormat maskFormat; + INT16 xSrc; + INT16 ySrc; +} xRenderTrianglesReq; + +#define sz_xRenderTrianglesReq 24 + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + CARD8 op; + CARD8 pad1; + CARD16 pad2; + Picture src; + Picture dst; + PictFormat maskFormat; + INT16 xSrc; + INT16 ySrc; +} xRenderTriStripReq; + +#define sz_xRenderTriStripReq 24 + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + CARD8 op; + CARD8 pad1; + CARD16 pad2; + Picture src; + Picture dst; + PictFormat maskFormat; + INT16 xSrc; + INT16 ySrc; +} xRenderTriFanReq; + +#define sz_xRenderTriFanReq 24 + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + Glyphset gsid; + PictFormat format; +} xRenderCreateGlyphSetReq; + +#define sz_xRenderCreateGlyphSetReq 12 + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + Glyphset gsid; + Glyphset existing; +} xRenderReferenceGlyphSetReq; + +#define sz_xRenderReferenceGlyphSetReq 24 + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + Glyphset glyphset; +} xRenderFreeGlyphSetReq; + +#define sz_xRenderFreeGlyphSetReq 8 + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + Glyphset glyphset; + CARD32 nglyphs; +} xRenderAddGlyphsReq; + +#define sz_xRenderAddGlyphsReq 12 + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + Glyphset glyphset; +} xRenderFreeGlyphsReq; + +#define sz_xRenderFreeGlyphsReq 8 + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + CARD8 op; + CARD8 pad1; + CARD16 pad2; + Picture src; + Picture dst; + PictFormat maskFormat; + Glyphset glyphset; + INT16 xSrc; + INT16 ySrc; +} xRenderCompositeGlyphsReq, xRenderCompositeGlyphs8Req, +xRenderCompositeGlyphs16Req, xRenderCompositeGlyphs32Req; + +#define sz_xRenderCompositeGlyphs8Req 28 +#define sz_xRenderCompositeGlyphs16Req 28 +#define sz_xRenderCompositeGlyphs32Req 28 + +/* 0.1 and higher */ + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + CARD8 op; + CARD8 pad1; + CARD16 pad2; + Picture dst; + xRenderColor color; +} xRenderFillRectanglesReq; + +#define sz_xRenderFillRectanglesReq 20 + +/* 0.5 and higher */ + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + Cursor cid; + Picture src; + CARD16 x; + CARD16 y; +} xRenderCreateCursorReq; + +#define sz_xRenderCreateCursorReq 16 + +/* 0.6 and higher */ + +/* + * This can't use an array because 32-bit values may be in bitfields + */ +typedef struct { + Fixed matrix11; + Fixed matrix12; + Fixed matrix13; + Fixed matrix21; + Fixed matrix22; + Fixed matrix23; + Fixed matrix31; + Fixed matrix32; + Fixed matrix33; +} xRenderTransform; + +#define sz_xRenderTransform 36 + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + Picture picture; + xRenderTransform transform; +} xRenderSetPictureTransformReq; + +#define sz_xRenderSetPictureTransformReq 44 + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + Drawable drawable; +} xRenderQueryFiltersReq; + +#define sz_xRenderQueryFiltersReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 numAliases; /* LISTofCARD16 */ + CARD32 numFilters; /* LISTofSTRING8 */ + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xRenderQueryFiltersReply; + +#define sz_xRenderQueryFiltersReply 32 + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + Picture picture; + CARD16 nbytes; /* number of bytes in name */ + CARD16 pad; +} xRenderSetPictureFilterReq; + +#define sz_xRenderSetPictureFilterReq 12 + +/* 0.8 and higher */ + +typedef struct { + Cursor cursor; + CARD32 delay; +} xAnimCursorElt; + +#define sz_xAnimCursorElt 8 + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + Cursor cid; +} xRenderCreateAnimCursorReq; + +#define sz_xRenderCreateAnimCursorReq 8 + +/* 0.9 and higher */ + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + Picture picture; + INT16 xOff; + INT16 yOff; +} xRenderAddTrapsReq; + +#define sz_xRenderAddTrapsReq 12 + +/* 0.10 and higher */ + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + Picture pid; + xRenderColor color; +} xRenderCreateSolidFillReq; + +#define sz_xRenderCreateSolidFillReq 16 + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + Picture pid; + xPointFixed p1; + xPointFixed p2; + CARD32 nStops; +} xRenderCreateLinearGradientReq; + +#define sz_xRenderCreateLinearGradientReq 28 + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + Picture pid; + xPointFixed inner; + xPointFixed outer; + Fixed inner_radius; + Fixed outer_radius; + CARD32 nStops; +} xRenderCreateRadialGradientReq; + +#define sz_xRenderCreateRadialGradientReq 36 + +typedef struct { + CARD8 reqType; + CARD8 renderReqType; + CARD16 length; + Picture pid; + xPointFixed center; + Fixed angle; /* in degrees */ + CARD32 nStops; +} xRenderCreateConicalGradientReq; + +#define sz_xRenderCreateConicalGradientReq 24 + +#undef Window +#undef Drawable +#undef Font +#undef Pixmap +#undef Cursor +#undef Colormap +#undef GContext +#undef Atom +#undef VisualID +#undef Time +#undef KeyCode +#undef KeySym + +#undef Picture +#undef PictFormat +#undef Fixed +#undef Glyphset + +#endif /* _XRENDERP_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/saver.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/saver.h new file mode 100644 index 0000000000000000000000000000000000000000..e8da62560163a837bf403595f778ed537e461531 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/saver.h @@ -0,0 +1,52 @@ +/* +Copyright (c) 1992 X Consortium + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of the X Consortium shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from the X Consortium. + * + * Author: Keith Packard, MIT X Consortium + */ + +#ifndef _SAVER_H_ +#define _SAVER_H_ + +#define ScreenSaverName "MIT-SCREEN-SAVER" +#define ScreenSaverPropertyName "_MIT_SCREEN_SAVER_ID" + +#define ScreenSaverNotifyMask 0x00000001 +#define ScreenSaverCycleMask 0x00000002 + +#define ScreenSaverMajorVersion 1 +#define ScreenSaverMinorVersion 1 + +#define ScreenSaverOff 0 +#define ScreenSaverOn 1 +#define ScreenSaverCycle 2 +#define ScreenSaverDisabled 3 + +#define ScreenSaverBlanked 0 +#define ScreenSaverInternal 1 +#define ScreenSaverExternal 2 + +#define ScreenSaverNotify 0 +#define ScreenSaverNumberEvents 1 + +#endif /* _SAVER_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/saverproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/saverproto.h new file mode 100644 index 0000000000000000000000000000000000000000..0b8e34eed05da13396917c4205b80ce828977d8d --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/saverproto.h @@ -0,0 +1,175 @@ +/* +Copyright (c) 1992 X Consortium + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of the X Consortium shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from the X Consortium. + * + * Author: Keith Packard, MIT X Consortium + */ + +#ifndef _SAVERPROTO_H_ +#define _SAVERPROTO_H_ + +#include + +#define Window CARD32 +#define Drawable CARD32 +#define Font CARD32 +#define Pixmap CARD32 +#define Cursor CARD32 +#define Colormap CARD32 +#define GContext CARD32 +#define Atom CARD32 +#define VisualID CARD32 +#define Time CARD32 +#define KeyCode CARD8 +#define KeySym CARD32 + +#define X_ScreenSaverQueryVersion 0 + +typedef struct _ScreenSaverQueryVersion { + CARD8 reqType; /* always ScreenSaverReqCode */ + CARD8 saverReqType; /* always X_ScreenSaverQueryVersion */ + CARD16 length; + CARD8 clientMajor; + CARD8 clientMinor; + CARD16 unused; +} xScreenSaverQueryVersionReq; +#define sz_xScreenSaverQueryVersionReq 8 + +typedef struct { + CARD8 type; /* X_Reply */ + CARD8 unused; /* not used */ + CARD16 sequenceNumber; + CARD32 length; + CARD16 majorVersion; /* major version of protocol */ + CARD16 minorVersion; /* minor version of protocol */ + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xScreenSaverQueryVersionReply; +#define sz_xScreenSaverQueryVersionReply 32 + +#define X_ScreenSaverQueryInfo 1 + +typedef struct _ScreenSaverQueryInfo { + CARD8 reqType; /* always ScreenSaverReqCode */ + CARD8 saverReqType; /* always X_ScreenSaverQueryInfo */ + CARD16 length; + Drawable drawable; +} xScreenSaverQueryInfoReq; +#define sz_xScreenSaverQueryInfoReq 8 + +typedef struct { + CARD8 type; /* X_Reply */ + BYTE state; /* Off, On */ + CARD16 sequenceNumber; + CARD32 length; + Window window; + CARD32 tilOrSince; + CARD32 idle; + CARD32 eventMask; + BYTE kind; /* Blanked, Internal, External */ + CARD8 pad0; + CARD16 pad1; + CARD32 pad2; +} xScreenSaverQueryInfoReply; +#define sz_xScreenSaverQueryInfoReply 32 + +#define X_ScreenSaverSelectInput 2 + +typedef struct _ScreenSaverSelectInput { + CARD8 reqType; /* always ScreenSaverReqCode */ + CARD8 saverReqType; /* always X_ScreenSaverSelectInput */ + CARD16 length; + Drawable drawable; + CARD32 eventMask; +} xScreenSaverSelectInputReq; +#define sz_xScreenSaverSelectInputReq 12 + +#define X_ScreenSaverSetAttributes 3 + +typedef struct _ScreenSaverSetAttributes { + CARD8 reqType; /* always ScreenSaverReqCode */ + CARD8 saverReqType; /* always X_ScreenSaverSetAttributes */ + CARD16 length; + Drawable drawable; + INT16 x, y; + CARD16 width, height, borderWidth; + BYTE c_class; + CARD8 depth; + VisualID visualID; + CARD32 mask; +} xScreenSaverSetAttributesReq; +#define sz_xScreenSaverSetAttributesReq 28 + +#define X_ScreenSaverUnsetAttributes 4 + +typedef struct _ScreenSaverUnsetAttributes { + CARD8 reqType; /* always ScreenSaverReqCode */ + CARD8 saverReqType; /* always X_ScreenSaverUnsetAttributes */ + CARD16 length; + Drawable drawable; +} xScreenSaverUnsetAttributesReq; +#define sz_xScreenSaverUnsetAttributesReq 8 + +#define X_ScreenSaverSuspend 5 + +typedef struct _ScreenSaverSuspend { + CARD8 reqType; + CARD8 saverReqType; + CARD16 length; + CARD32 suspend; /* a boolean, but using the wrong encoding */ +} xScreenSaverSuspendReq; +#define sz_xScreenSaverSuspendReq 8 + +typedef struct _ScreenSaverNotify { + CARD8 type; /* always eventBase + ScreenSaverNotify */ + BYTE state; /* off, on, cycle */ + CARD16 sequenceNumber; + Time timestamp; + Window root; + Window window; /* screen saver window */ + BYTE kind; /* blanked, internal, external */ + BYTE forced; + CARD16 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; +} xScreenSaverNotifyEvent; +#define sz_xScreenSaverNotifyEvent 32 + +#undef Window +#undef Drawable +#undef Font +#undef Pixmap +#undef Cursor +#undef Colormap +#undef GContext +#undef Atom +#undef VisualID +#undef Time +#undef KeyCode +#undef KeySym + +#endif /* _SAVERPROTO_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/secur.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/secur.h new file mode 100644 index 0000000000000000000000000000000000000000..ca27b29e6fe672d913a001b8d6c64bad9aafc20e --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/secur.h @@ -0,0 +1,61 @@ +/* +Copyright 1996, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. +*/ + +#ifndef _SECUR_H +#define _SECUR_H + +#define SECURITY_EXTENSION_NAME "SECURITY" +#define SECURITY_MAJOR_VERSION 1 +#define SECURITY_MINOR_VERSION 0 + +#define XSecurityNumberEvents 1 +#define XSecurityNumberErrors 2 +#define XSecurityBadAuthorization 0 +#define XSecurityBadAuthorizationProtocol 1 + +/* trust levels */ +#define XSecurityClientTrusted 0 +#define XSecurityClientUntrusted 1 + +/* authorization attribute masks */ +#define XSecurityTimeout (1<<0) +#define XSecurityTrustLevel (1<<1) +#define XSecurityGroup (1<<2) +#define XSecurityEventMask (1<<3) +#define XSecurityAllAuthorizationAttributes \ + (XSecurityTimeout | XSecurityTrustLevel | XSecurityGroup | XSecurityEventMask) + +/* event masks */ +#define XSecurityAuthorizationRevokedMask (1<<0) +#define XSecurityAllEventMasks XSecurityAuthorizationRevokedMask + +/* event offsets */ +#define XSecurityAuthorizationRevoked 0 + +#define XSecurityAuthorizationName "XC-QUERY-SECURITY-1" +#define XSecurityAuthorizationNameLen 19 + +#endif /* _SECUR_H */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/securproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/securproto.h new file mode 100644 index 0000000000000000000000000000000000000000..d9e120c9068bc58e882bb801c09c20ab2f59153f --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/securproto.h @@ -0,0 +1,110 @@ +/* +Copyright 1996, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. +*/ + +#ifndef _SECURPROTO_H +#define _SECURPROTO_H + +#include + +#define X_SecurityQueryVersion 0 +#define X_SecurityGenerateAuthorization 1 +#define X_SecurityRevokeAuthorization 2 + +typedef struct { + CARD8 reqType; + CARD8 securityReqType; + CARD16 length; + CARD16 majorVersion; + CARD16 minorVersion; +} xSecurityQueryVersionReq; +#define sz_xSecurityQueryVersionReq 8 + +typedef struct { + CARD8 type; + CARD8 pad0; + CARD16 sequenceNumber; + CARD32 length; + CARD16 majorVersion; + CARD16 minorVersion; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + } xSecurityQueryVersionReply; +#define sz_xSecurityQueryVersionReply 32 + +typedef struct { + CARD8 reqType; + CARD8 securityReqType; + CARD16 length; + CARD16 nbytesAuthProto; + CARD16 nbytesAuthData; + CARD32 valueMask; + /* auth protocol name padded to 4 bytes */ + /* auth protocol data padded to 4 bytes */ + /* list of CARD32 values, if any */ +} xSecurityGenerateAuthorizationReq; +#define sz_xSecurityGenerateAuthorizationReq 12 + +typedef struct { + CARD8 type; + CARD8 pad0; + CARD16 sequenceNumber; + CARD32 length; + CARD32 authId; + CARD16 dataLength; + CARD16 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + } xSecurityGenerateAuthorizationReply; +#define sz_xSecurityGenerateAuthorizationReply 32 + +typedef struct { + CARD8 reqType; + CARD8 securityReqType; + CARD16 length; + CARD32 authId; +} xSecurityRevokeAuthorizationReq; +#define sz_xSecurityRevokeAuthorizationReq 8 + +typedef struct _xSecurityAuthorizationRevokedEvent { + BYTE type; + BYTE detail; + CARD16 sequenceNumber; + CARD32 authId; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xSecurityAuthorizationRevokedEvent; +#define sz_xSecurityAuthorizationRevokedEvent 32 + +#endif /* _SECURPROTO_H */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/shapeconst.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/shapeconst.h new file mode 100644 index 0000000000000000000000000000000000000000..9088956f1b90e79163ef997d731aa1d1d1b4a9b2 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/shapeconst.h @@ -0,0 +1,55 @@ +/************************************************************ + +Copyright 1989, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +********************************************************/ + +#ifndef _SHAPECONST_H_ +#define _SHAPECONST_H_ + +/* + * Protocol requests constants and alignment values + * These would really be in SHAPE's X.h and Xproto.h equivalents + */ + +#define SHAPENAME "SHAPE" + +#define SHAPE_MAJOR_VERSION 1 /* current version numbers */ +#define SHAPE_MINOR_VERSION 1 + +#define ShapeSet 0 +#define ShapeUnion 1 +#define ShapeIntersect 2 +#define ShapeSubtract 3 +#define ShapeInvert 4 + +#define ShapeBounding 0 +#define ShapeClip 1 +#define ShapeInput 2 + +#define ShapeNotifyMask (1L << 0) +#define ShapeNotify 0 + +#define ShapeNumberEvents (ShapeNotify + 1) + +#endif /* _SHAPECONST_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/shapeproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/shapeproto.h new file mode 100644 index 0000000000000000000000000000000000000000..e5c1838a875316b97647a6c7d8f54320fa9de82b --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/shapeproto.h @@ -0,0 +1,237 @@ +/************************************************************ + +Copyright 1989, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +********************************************************/ + +#ifndef _SHAPEPROTO_H_ +#define _SHAPEPROTO_H_ + +#include + +/* + * Protocol requests constants and alignment values + * These would really be in SHAPE's X.h and Xproto.h equivalents + */ + +#define Window CARD32 +#define Time CARD32 + +#define X_ShapeQueryVersion 0 +#define X_ShapeRectangles 1 +#define X_ShapeMask 2 +#define X_ShapeCombine 3 +#define X_ShapeOffset 4 +#define X_ShapeQueryExtents 5 +#define X_ShapeSelectInput 6 +#define X_ShapeInputSelected 7 +#define X_ShapeGetRectangles 8 + +typedef struct _ShapeQueryVersion { + CARD8 reqType; /* always ShapeReqCode */ + CARD8 shapeReqType; /* always X_ShapeQueryVersion */ + CARD16 length; +} xShapeQueryVersionReq; +#define sz_xShapeQueryVersionReq 4 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 unused; /* not used */ + CARD16 sequenceNumber; + CARD32 length; + CARD16 majorVersion; /* major version of SHAPE protocol */ + CARD16 minorVersion; /* minor version of SHAPE protocol */ + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xShapeQueryVersionReply; +#define sz_xShapeQueryVersionReply 32 + +typedef struct _ShapeRectangles { + CARD8 reqType; /* always ShapeReqCode */ + CARD8 shapeReqType; /* always X_ShapeRectangles */ + CARD16 length; + CARD8 op; /* Set, ... */ + CARD8 destKind; /* ShapeBounding or ShapeClip */ + CARD8 ordering; /* UnSorted, YSorted, YXSorted, YXBanded */ + CARD8 pad0; /* not used */ + Window dest; + INT16 xOff; + INT16 yOff; +} xShapeRectanglesReq; /* followed by xRects */ +#define sz_xShapeRectanglesReq 16 + +typedef struct _ShapeMask { + CARD8 reqType; /* always ShapeReqCode */ + CARD8 shapeReqType; /* always X_ShapeMask */ + CARD16 length; + + CARD8 op; /* Set, ... */ + CARD8 destKind; /* ShapeBounding or ShapeClip */ + CARD16 junk; /* not used */ + + Window dest; + INT16 xOff; + INT16 yOff; + CARD32 src; /* 1 bit pixmap */ +} xShapeMaskReq; +#define sz_xShapeMaskReq 20 + +typedef struct _ShapeCombine { + CARD8 reqType; /* always ShapeReqCode */ + CARD8 shapeReqType; /* always X_ShapeCombine */ + CARD16 length; + CARD8 op; /* Set, ... */ + CARD8 destKind; /* ShapeBounding or ShapeClip */ + CARD8 srcKind; /* ShapeBounding or ShapeClip */ + CARD8 junk; /* not used */ + Window dest; + INT16 xOff; + INT16 yOff; + Window src; +} xShapeCombineReq; +#define sz_xShapeCombineReq 20 + +typedef struct _ShapeOffset { + CARD8 reqType; /* always ShapeReqCode */ + CARD8 shapeReqType; /* always X_ShapeOffset */ + CARD16 length; + CARD8 destKind; /* ShapeBounding or ShapeClip */ + CARD8 junk1; /* not used */ + CARD16 junk2; /* not used */ + Window dest; + INT16 xOff; + INT16 yOff; +} xShapeOffsetReq; +#define sz_xShapeOffsetReq 16 + +typedef struct _ShapeQueryExtents { + CARD8 reqType; /* always ShapeReqCode */ + CARD8 shapeReqType; /* always X_ShapeQueryExtents */ + CARD16 length; + Window window; +} xShapeQueryExtentsReq; +#define sz_xShapeQueryExtentsReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 unused; /* not used */ + CARD16 sequenceNumber; + CARD32 length; /* 0 */ + CARD8 boundingShaped; /* window has bounding shape */ + CARD8 clipShaped; /* window has clip shape */ + CARD16 unused1; + INT16 xBoundingShape; /* extents of bounding shape */ + INT16 yBoundingShape; + CARD16 widthBoundingShape; + CARD16 heightBoundingShape; + INT16 xClipShape; /* extents of clip shape */ + INT16 yClipShape; + CARD16 widthClipShape; + CARD16 heightClipShape; + CARD32 pad1; +} xShapeQueryExtentsReply; +#define sz_xShapeQueryExtentsReply 32 + +typedef struct _ShapeSelectInput { + CARD8 reqType; /* always ShapeReqCode */ + CARD8 shapeReqType; /* always X_ShapeSelectInput */ + CARD16 length; + Window window; + BYTE enable; /* xTrue -> send events */ + BYTE pad1; + CARD16 pad2; +} xShapeSelectInputReq; +#define sz_xShapeSelectInputReq 12 + +typedef struct _ShapeNotify { + BYTE type; /* always eventBase + ShapeNotify */ + BYTE kind; /* either ShapeBounding or ShapeClip */ + CARD16 sequenceNumber; + Window window; + INT16 x; + INT16 y; /* extents of new shape */ + CARD16 width; + CARD16 height; + Time time; /* time of change */ + BYTE shaped; /* set when a shape actual exists */ + BYTE pad0; + CARD16 pad1; + CARD32 pad2; + CARD32 pad3; +} xShapeNotifyEvent; +#define sz_xShapeNotifyEvent 32 + +typedef struct _ShapeInputSelected { + CARD8 reqType; /* always ShapeReqCode */ + CARD8 shapeReqType; /* always X_ShapeInputSelected */ + CARD16 length; + Window window; +} xShapeInputSelectedReq; +#define sz_xShapeInputSelectedReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 enabled; /* current status */ + CARD16 sequenceNumber; + CARD32 length; /* 0 */ + CARD32 pad1; /* unused */ + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xShapeInputSelectedReply; +#define sz_xShapeInputSelectedReply 32 + +typedef struct _ShapeGetRectangles { + CARD8 reqType; /* always ShapeReqCode */ + CARD8 shapeReqType; /* always X_ShapeGetRectangles */ + CARD16 length; + Window window; + CARD8 kind; /* ShapeBounding or ShapeClip */ + CARD8 junk1; + CARD16 junk2; +} xShapeGetRectanglesReq; +#define sz_xShapeGetRectanglesReq 12 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 ordering; /* UnSorted, YSorted, YXSorted, YXBanded */ + CARD16 sequenceNumber; + CARD32 length; /* not zero */ + CARD32 nrects; /* number of rectangles */ + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xShapeGetRectanglesReply; /* followed by xRectangles */ +#define sz_xShapeGetRectanglesReply 32 + +#undef Window +#undef Time + +#endif /* _SHAPEPROTO_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/shapestr.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/shapestr.h new file mode 100644 index 0000000000000000000000000000000000000000..20fde1dbe690dfcd6c4151fc760fa7d2881d71e8 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/shapestr.h @@ -0,0 +1,8 @@ +#ifndef _SHAPESTR_H_ +#define _SHAPESTR_H_ + +#warning "shapestr.h is obsolete and may be removed in the future." +#warning "include for the protocol defines." +#include + +#endif /* _SHAPESTR_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/shm.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/shm.h new file mode 100644 index 0000000000000000000000000000000000000000..be49f5e977a3f288ae392d2cf68897e3c6587583 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/shm.h @@ -0,0 +1,44 @@ +/************************************************************ + +Copyright 1989, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +********************************************************/ + +/* THIS IS NOT AN X CONSORTIUM STANDARD OR AN X PROJECT TEAM SPECIFICATION */ + +#ifndef _SHM_H_ +#define _SHM_H_ + +#define SHMNAME "MIT-SHM" + +#define SHM_MAJOR_VERSION 1 /* current version numbers */ +#define SHM_MINOR_VERSION 2 + +#define ShmCompletion 0 +#define ShmNumberEvents (ShmCompletion + 1) + +#define BadShmSeg 0 +#define ShmNumberErrors (BadShmSeg + 1) + + +#endif /* _SHM_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/shmproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/shmproto.h new file mode 100644 index 0000000000000000000000000000000000000000..6e3260615d9bc295f706849a44921824ea30b37c --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/shmproto.h @@ -0,0 +1,229 @@ +/************************************************************ + +Copyright 1989, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +********************************************************/ + +/* THIS IS NOT AN X CONSORTIUM STANDARD OR AN X PROJECT TEAM SPECIFICATION */ + +#ifndef _SHMPROTO_H_ +#define _SHMPROTO_H_ + +#include + +#define ShmSeg CARD32 +#define Drawable CARD32 +#define VisualID CARD32 +#define GContext CARD32 +#define Pixmap CARD32 + +#define X_ShmQueryVersion 0 +#define X_ShmAttach 1 +#define X_ShmDetach 2 +#define X_ShmPutImage 3 +#define X_ShmGetImage 4 +#define X_ShmCreatePixmap 5 +#define X_ShmAttachFd 6 +#define X_ShmCreateSegment 7 + +typedef struct _ShmQueryVersion { + CARD8 reqType; /* always ShmReqCode */ + CARD8 shmReqType; /* always X_ShmQueryVersion */ + CARD16 length; +} xShmQueryVersionReq; +#define sz_xShmQueryVersionReq 4 + +typedef struct { + BYTE type; /* X_Reply */ + BOOL sharedPixmaps; + CARD16 sequenceNumber; + CARD32 length; + CARD16 majorVersion; /* major version of SHM protocol */ + CARD16 minorVersion; /* minor version of SHM protocol */ + CARD16 uid; + CARD16 gid; + CARD8 pixmapFormat; + CARD8 pad0; + CARD16 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xShmQueryVersionReply; +#define sz_xShmQueryVersionReply 32 + +typedef struct _ShmAttach { + CARD8 reqType; /* always ShmReqCode */ + CARD8 shmReqType; /* always X_ShmAttach */ + CARD16 length; + ShmSeg shmseg; + CARD32 shmid; + BOOL readOnly; + BYTE pad0; + CARD16 pad1; +} xShmAttachReq; +#define sz_xShmAttachReq 16 + +typedef struct _ShmDetach { + CARD8 reqType; /* always ShmReqCode */ + CARD8 shmReqType; /* always X_ShmDetach */ + CARD16 length; + ShmSeg shmseg; +} xShmDetachReq; +#define sz_xShmDetachReq 8 + +typedef struct _ShmPutImage { + CARD8 reqType; /* always ShmReqCode */ + CARD8 shmReqType; /* always X_ShmPutImage */ + CARD16 length; + Drawable drawable; + GContext gc; + CARD16 totalWidth; + CARD16 totalHeight; + CARD16 srcX; + CARD16 srcY; + CARD16 srcWidth; + CARD16 srcHeight; + INT16 dstX; + INT16 dstY; + CARD8 depth; + CARD8 format; + CARD8 sendEvent; + CARD8 bpad; + ShmSeg shmseg; + CARD32 offset; +} xShmPutImageReq; +#define sz_xShmPutImageReq 40 + +typedef struct _ShmGetImage { + CARD8 reqType; /* always ShmReqCode */ + CARD8 shmReqType; /* always X_ShmGetImage */ + CARD16 length; + Drawable drawable; + INT16 x; + INT16 y; + CARD16 width; + CARD16 height; + CARD32 planeMask; + CARD8 format; + CARD8 pad0; + CARD8 pad1; + CARD8 pad2; + ShmSeg shmseg; + CARD32 offset; +} xShmGetImageReq; +#define sz_xShmGetImageReq 32 + +typedef struct _ShmGetImageReply { + BYTE type; /* X_Reply */ + CARD8 depth; + CARD16 sequenceNumber; + CARD32 length; + VisualID visual; + CARD32 size; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; +} xShmGetImageReply; +#define sz_xShmGetImageReply 32 + +typedef struct _ShmCreatePixmap { + CARD8 reqType; /* always ShmReqCode */ + CARD8 shmReqType; /* always X_ShmCreatePixmap */ + CARD16 length; + Pixmap pid; + Drawable drawable; + CARD16 width; + CARD16 height; + CARD8 depth; + CARD8 pad0; + CARD8 pad1; + CARD8 pad2; + ShmSeg shmseg; + CARD32 offset; +} xShmCreatePixmapReq; +#define sz_xShmCreatePixmapReq 28 + +typedef struct _ShmCompletion { + BYTE type; /* always eventBase + ShmCompletion */ + BYTE bpad0; + CARD16 sequenceNumber; + Drawable drawable; + CARD16 minorEvent; + BYTE majorEvent; + BYTE bpad1; + ShmSeg shmseg; + CARD32 offset; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; +} xShmCompletionEvent; +#define sz_xShmCompletionEvent 32 + +/* Version 1.2 additions */ +typedef struct _ShmAttachFd { + CARD8 reqType; /* always ShmReqCode */ + CARD8 shmReqType; /* always X_ShmAttachFd */ + CARD16 length; + ShmSeg shmseg; + BOOL readOnly; + BYTE pad0; + CARD16 pad1; +} xShmAttachFdReq; +/* File descriptor is passed with this request */ +#define sz_xShmAttachFdReq 12 + +typedef struct _ShmCreateSegment { + CARD8 reqType; /* always ShmReqCode */ + CARD8 shmReqType; /* always X_ShmAttachFd */ + CARD16 length; + ShmSeg shmseg; + CARD32 size; + BOOL readOnly; + BYTE pad0; + CARD16 pad1; +} xShmCreateSegmentReq; +#define sz_xShmCreateSegmentReq 16 + +typedef struct { + CARD8 type; /* must be X_Reply */ + CARD8 nfd; /* must be 1 */ + CARD16 sequenceNumber; /* last sequence number */ + CARD32 length; /* 0 */ + CARD32 pad2; /* unused */ + CARD32 pad3; /* unused */ + CARD32 pad4; /* unused */ + CARD32 pad5; /* unused */ + CARD32 pad6; /* unused */ + CARD32 pad7; /* unused */ +} xShmCreateSegmentReply; +/* File descriptor is passed with this reply */ +#define sz_xShmCreateSegmentReply 32 + +#undef ShmSeg +#undef Drawable +#undef VisualID +#undef GContext +#undef Pixmap + +#endif /* _SHMPROTO_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/shmstr.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/shmstr.h new file mode 100644 index 0000000000000000000000000000000000000000..78f37596259cacee5ce59ab4704a194be3466a6c --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/shmstr.h @@ -0,0 +1,63 @@ +/************************************************************ + +Copyright 1989, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +********************************************************/ + +/* THIS IS NOT AN X CONSORTIUM STANDARD OR AN X PROJECT TEAM SPECIFICATION */ + +#ifndef _SHMSTR_H_ +#define _SHMSTR_H_ + +#include + +#ifdef _XSHM_SERVER_ +#define XSHM_PUT_IMAGE_ARGS \ + DrawablePtr /* dst */, \ + GCPtr /* pGC */, \ + int /* depth */, \ + unsigned int /* format */, \ + int /* w */, \ + int /* h */, \ + int /* sx */, \ + int /* sy */, \ + int /* sw */, \ + int /* sh */, \ + int /* dx */, \ + int /* dy */, \ + char * /* data */ + +#define XSHM_CREATE_PIXMAP_ARGS \ + ScreenPtr /* pScreen */, \ + int /* width */, \ + int /* height */, \ + int /* depth */, \ + char * /* addr */ + +typedef struct _ShmFuncs { + PixmapPtr (* CreatePixmap)(XSHM_CREATE_PIXMAP_ARGS); + void (* PutImage)(XSHM_PUT_IMAGE_ARGS); +} ShmFuncs, *ShmFuncsPtr; +#endif + +#endif /* _SHMSTR_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/syncconst.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/syncconst.h new file mode 100644 index 0000000000000000000000000000000000000000..0479816e93fe64237cf931a5acc9938a52256473 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/syncconst.h @@ -0,0 +1,181 @@ +/* + +Copyright 1991, 1993, 1994, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +*/ + +/*********************************************************** +Copyright 1991,1993 by Digital Equipment Corporation, Maynard, Massachusetts, +and Olivetti Research Limited, Cambridge, England. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the names of Digital or Olivetti +not be used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL AND OLIVETTI DISCLAIM ALL WARRANTIES WITH REGARD TO THIS +SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS, IN NO EVENT SHALL THEY BE LIABLE FOR ANY SPECIAL, INDIRECT OR +CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF +USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. + +******************************************************************/ + +#ifndef _SYNCCONST_H_ +#define _SYNCCONST_H_ + +#define SYNC_NAME "SYNC" + +#define SYNC_MAJOR_VERSION 3 +#define SYNC_MINOR_VERSION 1 + + +#define XSyncCounterNotify 0 +#define XSyncAlarmNotify 1 +#define XSyncAlarmNotifyMask (1L << XSyncAlarmNotify) + +#define XSyncNumberEvents 2L + +#define XSyncBadCounter 0L +#define XSyncBadAlarm 1L +#define XSyncBadFence 2L +#define XSyncNumberErrors (XSyncBadFence + 1) + +/* + * Flags for Alarm Attributes + */ +#define XSyncCACounter (1L<<0) +#define XSyncCAValueType (1L<<1) +#define XSyncCAValue (1L<<2) +#define XSyncCATestType (1L<<3) +#define XSyncCADelta (1L<<4) +#define XSyncCAEvents (1L<<5) + +/* The _XSync macros below are for library internal use only. They exist + * so that if we have to make a fix, we can change it in this one place + * and have both the macro and function variants inherit the fix. + */ + +#define _XSyncIntToValue(pv, i) ((pv)->hi=((i<0)?~0:0),(pv)->lo=(i)) +#define _XSyncIntsToValue(pv, l, h) ((pv)->lo = (l), (pv)->hi = (h)) +#define _XSyncValueGreaterThan(a, b)\ + ((a).hi>(b).hi || ((a).hi==(b).hi && (a).lo>(b).lo)) +#define _XSyncValueLessThan(a, b)\ + ((a).hi<(b).hi || ((a).hi==(b).hi && (a).lo<(b).lo)) +#define _XSyncValueGreaterOrEqual(a, b)\ + ((a).hi>(b).hi || ((a).hi==(b).hi && (a).lo>=(b).lo)) +#define _XSyncValueLessOrEqual(a, b)\ + ((a).hi<(b).hi || ((a).hi==(b).hi && (a).lo<=(b).lo)) +#define _XSyncValueEqual(a, b) ((a).lo==(b).lo && (a).hi==(b).hi) +#define _XSyncValueIsNegative(v) (((v).hi & 0x80000000) ? 1 : 0) +#define _XSyncValueIsZero(a) ((a).lo==0 && (a).hi==0) +#define _XSyncValueIsPositive(v) (((v).hi & 0x80000000) ? 0 : 1) +#define _XSyncValueLow32(v) ((v).lo) +#define _XSyncValueHigh32(v) ((v).hi) +#define _XSyncValueAdd(presult,a,b,poverflow) {\ + int t = (a).lo;\ + Bool signa = XSyncValueIsNegative(a);\ + Bool signb = XSyncValueIsNegative(b);\ + ((presult)->lo = (a).lo + (b).lo);\ + ((presult)->hi = (a).hi + (b).hi);\ + if (t>(presult)->lo) (presult)->hi++;\ + *poverflow = ((signa == signb) && !(signa == XSyncValueIsNegative(*presult)));\ + } +#define _XSyncValueSubtract(presult,a,b,poverflow) {\ + int t = (a).lo;\ + Bool signa = XSyncValueIsNegative(a);\ + Bool signb = XSyncValueIsNegative(b);\ + ((presult)->lo = (a).lo - (b).lo);\ + ((presult)->hi = (a).hi - (b).hi);\ + if (t<(presult)->lo) (presult)->hi--;\ + *poverflow = ((signa == signb) && !(signa == XSyncValueIsNegative(*presult)));\ + } +#define _XSyncMaxValue(pv) ((pv)->hi = 0x7fffffff, (pv)->lo = 0xffffffff) +#define _XSyncMinValue(pv) ((pv)->hi = 0x80000000, (pv)->lo = 0) + +/* + * These are the publicly usable macros. If you want the function version + * of one of these, just #undef the macro to uncover the function. + * (This is the same convention that the ANSI C library uses.) + */ + +#define XSyncIntToValue(pv, i) _XSyncIntToValue(pv, i) +#define XSyncIntsToValue(pv, l, h) _XSyncIntsToValue(pv, l, h) +#define XSyncValueGreaterThan(a, b) _XSyncValueGreaterThan(a, b) +#define XSyncValueLessThan(a, b) _XSyncValueLessThan(a, b) +#define XSyncValueGreaterOrEqual(a, b) _XSyncValueGreaterOrEqual(a, b) +#define XSyncValueLessOrEqual(a, b) _XSyncValueLessOrEqual(a, b) +#define XSyncValueEqual(a, b) _XSyncValueEqual(a, b) +#define XSyncValueIsNegative(v) _XSyncValueIsNegative(v) +#define XSyncValueIsZero(a) _XSyncValueIsZero(a) +#define XSyncValueIsPositive(v) _XSyncValueIsPositive(v) +#define XSyncValueLow32(v) _XSyncValueLow32(v) +#define XSyncValueHigh32(v) _XSyncValueHigh32(v) +#define XSyncValueAdd(presult,a,b,poverflow) _XSyncValueAdd(presult,a,b,poverflow) +#define XSyncValueSubtract(presult,a,b,poverflow) _XSyncValueSubtract(presult,a,b,poverflow) +#define XSyncMaxValue(pv) _XSyncMaxValue(pv) +#define XSyncMinValue(pv) _XSyncMinValue(pv) + +/* + * Constants for the value_type argument of various requests + */ +typedef enum { + XSyncAbsolute, + XSyncRelative +} XSyncValueType; + +/* + * Alarm Test types + */ +typedef enum { + XSyncPositiveTransition, + XSyncNegativeTransition, + XSyncPositiveComparison, + XSyncNegativeComparison +} XSyncTestType; + +/* + * Alarm state constants + */ +typedef enum { + XSyncAlarmActive, + XSyncAlarmInactive, + XSyncAlarmDestroyed +} XSyncAlarmState; + + +typedef XID XSyncCounter; +typedef XID XSyncAlarm; +typedef XID XSyncFence; +typedef struct _XSyncValue { + int hi; + unsigned int lo; +} XSyncValue; +#endif /* _SYNCCONST_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/syncproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/syncproto.h new file mode 100644 index 0000000000000000000000000000000000000000..0fa1db74afee1a1af721d65180936b73349fcf1b --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/syncproto.h @@ -0,0 +1,474 @@ +/* + +Copyright 1991, 1993, 1994, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +*/ + +/*********************************************************** +Copyright 1991,1993 by Digital Equipment Corporation, Maynard, Massachusetts, +and Olivetti Research Limited, Cambridge, England. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the names of Digital or Olivetti +not be used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL AND OLIVETTI DISCLAIM ALL WARRANTIES WITH REGARD TO THIS +SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS, IN NO EVENT SHALL THEY BE LIABLE FOR ANY SPECIAL, INDIRECT OR +CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF +USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. + +******************************************************************/ + +#ifndef _SYNCPROTO_H_ +#define _SYNCPROTO_H_ + +#include + +#define X_SyncInitialize 0 +#define X_SyncListSystemCounters 1 +#define X_SyncCreateCounter 2 +#define X_SyncSetCounter 3 +#define X_SyncChangeCounter 4 +#define X_SyncQueryCounter 5 +#define X_SyncDestroyCounter 6 +#define X_SyncAwait 7 +#define X_SyncCreateAlarm 8 +#define X_SyncChangeAlarm 9 +#define X_SyncQueryAlarm 10 +#define X_SyncDestroyAlarm 11 +#define X_SyncSetPriority 12 +#define X_SyncGetPriority 13 +#define X_SyncCreateFence 14 +#define X_SyncTriggerFence 15 +#define X_SyncResetFence 16 +#define X_SyncDestroyFence 17 +#define X_SyncQueryFence 18 +#define X_SyncAwaitFence 19 + +/* cover up types from sync.h to make sure they're the right size for + * protocol packaging. These will be undef'ed after all the protocol + * structures are defined. + */ +#define XSyncCounter CARD32 +#define XSyncAlarm CARD32 +#define XSyncFence CARD32 +#define Drawable CARD32 + +/* + * Initialize + */ +typedef struct _xSyncInitialize { + CARD8 reqType; + CARD8 syncReqType; + CARD16 length; + CARD8 majorVersion; + CARD8 minorVersion; + CARD16 pad; +} xSyncInitializeReq; +#define sz_xSyncInitializeReq 8 + +typedef struct { + BYTE type; + CARD8 unused; + CARD16 sequenceNumber; + CARD32 length; + CARD8 majorVersion; + CARD8 minorVersion; + CARD16 pad; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xSyncInitializeReply; +#define sz_xSyncInitializeReply 32 + +/* + * ListSystemCounters + */ +typedef struct _xSyncListSystemCounters +{ + CARD8 reqType; + CARD8 syncReqType; + CARD16 length; +} xSyncListSystemCountersReq; +#define sz_xSyncListSystemCountersReq 4 + +typedef struct { + BYTE type; + CARD8 unused; + CARD16 sequenceNumber; + CARD32 length; + INT32 nCounters; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xSyncListSystemCountersReply; +#define sz_xSyncListSystemCountersReply 32 + +typedef struct { + XSyncCounter counter; + INT32 resolution_hi; + CARD32 resolution_lo; + CARD16 name_length; +} xSyncSystemCounter; +#define sz_xSyncSystemCounter 14 + +/* + * Create Counter + */ +typedef struct _xSyncCreateCounterReq { + CARD8 reqType; + CARD8 syncReqType; + CARD16 length; + XSyncCounter cid; + INT32 initial_value_hi; + CARD32 initial_value_lo; +} xSyncCreateCounterReq; +#define sz_xSyncCreateCounterReq 16 + +/* + * Change Counter + */ +typedef struct _xSyncChangeCounterReq { + CARD8 reqType; + CARD8 syncReqType; + CARD16 length; + XSyncCounter cid; + INT32 value_hi; + CARD32 value_lo; +} xSyncChangeCounterReq; +#define sz_xSyncChangeCounterReq 16 + +/* + * Set Counter + */ +typedef struct _xSyncSetCounterReq { + CARD8 reqType; + CARD8 syncReqType; + CARD16 length; + XSyncCounter cid; + INT32 value_hi; + CARD32 value_lo; +} xSyncSetCounterReq; +#define sz_xSyncSetCounterReq 16 + +/* + * Destroy Counter + */ +typedef struct _xSyncDestroyCounterReq { + CARD8 reqType; + CARD8 syncReqType; + CARD16 length; + XSyncCounter counter; +} xSyncDestroyCounterReq; +#define sz_xSyncDestroyCounterReq 8 + +/* + * Query Counter + */ +typedef struct _xSyncQueryCounterReq { + CARD8 reqType; + CARD8 syncReqType; + CARD16 length; + XSyncCounter counter; +} xSyncQueryCounterReq; +#define sz_xSyncQueryCounterReq 8 + + +typedef struct { + BYTE type; + CARD8 unused; + CARD16 sequenceNumber; + CARD32 length; + INT32 value_hi; + CARD32 value_lo; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; +} xSyncQueryCounterReply; +#define sz_xSyncQueryCounterReply 32 + +/* + * Await + */ +typedef struct _xSyncAwaitReq { + CARD8 reqType; + CARD8 syncReqType; + CARD16 length; +} xSyncAwaitReq; +#define sz_xSyncAwaitReq 4 + +typedef struct _xSyncWaitCondition { + XSyncCounter counter; + CARD32 value_type; + INT32 wait_value_hi; + CARD32 wait_value_lo; + CARD32 test_type; + INT32 event_threshold_hi; + CARD32 event_threshold_lo; +} xSyncWaitCondition; +#define sz_xSyncWaitCondition 28 + +/* + * Create Alarm + */ +typedef struct _xSyncCreateAlarmReq { + CARD8 reqType; + CARD8 syncReqType; + CARD16 length; + XSyncAlarm id; + CARD32 valueMask; +} xSyncCreateAlarmReq; +#define sz_xSyncCreateAlarmReq 12 + +/* + * Destroy Alarm + */ +typedef struct _xSyncDestroyAlarmReq { + CARD8 reqType; + CARD8 syncReqType; + CARD16 length; + XSyncAlarm alarm; +} xSyncDestroyAlarmReq; +#define sz_xSyncDestroyAlarmReq 8 + +/* + * Query Alarm + */ +typedef struct _xSyncQueryAlarmReq { + CARD8 reqType; + CARD8 syncReqType; + CARD16 length; + XSyncAlarm alarm; +} xSyncQueryAlarmReq; +#define sz_xSyncQueryAlarmReq 8 + +typedef struct { + BYTE type; + CARD8 unused; + CARD16 sequenceNumber; + CARD32 length; + XSyncCounter counter; + CARD32 value_type; + INT32 wait_value_hi; + CARD32 wait_value_lo; + CARD32 test_type; + INT32 delta_hi; + CARD32 delta_lo; + BOOL events; + BYTE state; + BYTE pad0; + BYTE pad1; +} xSyncQueryAlarmReply; +#define sz_xSyncQueryAlarmReply 40 + +/* + * Change Alarm + */ +typedef struct _xSyncChangeAlarmReq { + CARD8 reqType; + CARD8 syncReqType; + CARD16 length; + XSyncAlarm alarm; + CARD32 valueMask; +} xSyncChangeAlarmReq; +#define sz_xSyncChangeAlarmReq 12 + +/* + * SetPriority + */ +typedef struct _xSyncSetPriority{ + CARD8 reqType; + CARD8 syncReqType; + CARD16 length; + CARD32 id; + INT32 priority; +} xSyncSetPriorityReq; +#define sz_xSyncSetPriorityReq 12 + +/* + * Get Priority + */ +typedef struct _xSyncGetPriority{ + CARD8 reqType; + CARD8 syncReqType; + CARD16 length; + CARD32 id; /*XXX XID? */ +} xSyncGetPriorityReq; +#define sz_xSyncGetPriorityReq 8 + +typedef struct { + BYTE type; + CARD8 unused; + CARD16 sequenceNumber; + CARD32 length; + INT32 priority; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xSyncGetPriorityReply; +#define sz_xSyncGetPriorityReply 32 + +/* + * Create Fence + */ +typedef struct _xSyncCreateFenceReq { + CARD8 reqType; + CARD8 syncReqType; + CARD16 length; + Drawable d; + XSyncFence fid; + BOOL initially_triggered; + CARD8 pad0; + CARD16 pad1; +} xSyncCreateFenceReq; +#define sz_xSyncCreateFenceReq 16 + +/* + * Put a fence object in the "triggered" state. + */ +typedef struct _xSyncTriggerFenceReq { + CARD8 reqType; + CARD8 syncReqType; + CARD16 length; + XSyncFence fid; +} xSyncTriggerFenceReq; +#define sz_xSyncTriggerFenceReq 8 + +/* + * Put a fence in the "untriggered" state. + */ +typedef struct _xSyncResetFenceReq { + CARD8 reqType; + CARD8 syncReqType; + CARD16 length; + XSyncFence fid; +} xSyncResetFenceReq; +#define sz_xSyncResetFenceReq 8 + +/* + * Destroy a fence object + */ +typedef struct _xSyncDestroyFenceReq { + CARD8 reqType; + CARD8 syncReqType; + CARD16 length; + XSyncFence fid; +} xSyncDestroyFenceReq; +#define sz_xSyncDestroyFenceReq 8 + +/* + * Query a fence object + */ +typedef struct _xSyncQueryFenceReq { + CARD8 reqType; + CARD8 syncReqType; + CARD16 length; + XSyncFence fid; +} xSyncQueryFenceReq; +#define sz_xSyncQueryFenceReq 8 + +/* + * Wait for any of a list of fence sync objects + * to reach the "triggered" state. + */ +typedef struct _xSyncAwaitFenceReq { + CARD8 reqType; + CARD8 syncReqType; + CARD16 length; +} xSyncAwaitFenceReq; +#define sz_xSyncAwaitFenceReq 4 + +typedef struct { + BYTE type; + CARD8 unused; + CARD16 sequenceNumber; + CARD32 length; + BOOL triggered; + BYTE pad0; + CARD16 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xSyncQueryFenceReply; +#define sz_xSyncQueryFenceReply 32 + +/* + * Events + */ + +typedef struct _xSyncCounterNotifyEvent { + BYTE type; + BYTE kind; + CARD16 sequenceNumber; + XSyncCounter counter; + INT32 wait_value_hi; + CARD32 wait_value_lo; + INT32 counter_value_hi; + CARD32 counter_value_lo; + CARD32 time; + CARD16 count; + BOOL destroyed; + BYTE pad0; +} xSyncCounterNotifyEvent; + +typedef struct _xSyncAlarmNotifyEvent { + BYTE type; + BYTE kind; + CARD16 sequenceNumber; + XSyncAlarm alarm; + INT32 counter_value_hi; + CARD32 counter_value_lo; + INT32 alarm_value_hi; + CARD32 alarm_value_lo; + CARD32 time; + CARD8 state; + BYTE pad0; + BYTE pad1; + BYTE pad2; +} xSyncAlarmNotifyEvent; + +#undef XSyncCounter +#undef XSyncAlarm +#undef XSyncFence +#undef Drawable + + +#endif /* _SYNCPROTO_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/syncstr.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/syncstr.h new file mode 100644 index 0000000000000000000000000000000000000000..43cdcba4063b4219cf3ef954f3ef115b75b5d439 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/syncstr.h @@ -0,0 +1,182 @@ +/* + +Copyright 1991, 1993, 1994, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +*/ + +/*********************************************************** +Copyright 1991,1993 by Digital Equipment Corporation, Maynard, Massachusetts, +and Olivetti Research Limited, Cambridge, England. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the names of Digital or Olivetti +not be used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL AND OLIVETTI DISCLAIM ALL WARRANTIES WITH REGARD TO THIS +SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS, IN NO EVENT SHALL THEY BE LIABLE FOR ANY SPECIAL, INDIRECT OR +CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF +USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. + +******************************************************************/ + +#ifndef _SYNCSTR_H_ +#define _SYNCSTR_H_ + +#include + +#ifdef _SYNC_SERVER + +#define CARD64 XSyncValue /* XXX temporary! need real 64 bit values for Alpha */ + +typedef struct _SyncCounter { + ClientPtr client; /* Owning client. 0 for system counters */ + XSyncCounter id; /* resource ID */ + CARD64 value; /* counter value */ + struct _SyncTriggerList *pTriglist; /* list of triggers */ + Bool beingDestroyed; /* in process of going away */ + struct _SysCounterInfo *pSysCounterInfo; /* NULL if not a system counter */ +} SyncCounter; + +/* + * The System Counter interface + */ + +typedef enum { + XSyncCounterNeverChanges, + XSyncCounterNeverIncreases, + XSyncCounterNeverDecreases, + XSyncCounterUnrestricted +} SyncCounterType; + +typedef struct _SysCounterInfo { + char *name; + CARD64 resolution; + CARD64 bracket_greater; + CARD64 bracket_less; + SyncCounterType counterType; /* how can this counter change */ + void (*QueryValue)( + pointer /*pCounter*/, + CARD64 * /*freshvalue*/ +); + void (*BracketValues)( + pointer /*pCounter*/, + CARD64 * /*lessthan*/, + CARD64 * /*greaterthan*/ +); +} SysCounterInfo; + + + +typedef struct _SyncTrigger { + SyncCounter *pCounter; + CARD64 wait_value; /* wait value */ + unsigned int value_type; /* Absolute or Relative */ + unsigned int test_type; /* transition or Comparison type */ + CARD64 test_value; /* trigger event threshold value */ + Bool (*CheckTrigger)( + struct _SyncTrigger * /*pTrigger*/, + CARD64 /*newval*/ + ); + void (*TriggerFired)( + struct _SyncTrigger * /*pTrigger*/ + ); + void (*CounterDestroyed)( + struct _SyncTrigger * /*pTrigger*/ + ); +} SyncTrigger; + +typedef struct _SyncTriggerList { + SyncTrigger *pTrigger; + struct _SyncTriggerList *next; +} SyncTriggerList; + +typedef struct _SyncAlarmClientList { + ClientPtr client; + XID delete_id; + struct _SyncAlarmClientList *next; +} SyncAlarmClientList; + +typedef struct _SyncAlarm { + SyncTrigger trigger; + ClientPtr client; + XSyncAlarm alarm_id; + CARD64 delta; + int events; + int state; + SyncAlarmClientList *pEventClients; +} SyncAlarm; + +typedef struct { + ClientPtr client; + CARD32 delete_id; + int num_waitconditions; +} SyncAwaitHeader; + +typedef struct { + SyncTrigger trigger; + CARD64 event_threshold; + SyncAwaitHeader *pHeader; +} SyncAwait; + +typedef union { + SyncAwaitHeader header; + SyncAwait await; +} SyncAwaitUnion; + + +extern pointer SyncCreateSystemCounter( + char * /* name */, + CARD64 /* initial_value */, + CARD64 /* resolution */, + SyncCounterType /* change characterization */, + void (* /*QueryValue*/ ) ( + pointer /* pCounter */, + CARD64 * /* pValue_return */), /* XXX prototype */ + void (* /*BracketValues*/) ( + pointer /* pCounter */, + CARD64 * /* pbracket_less */, + CARD64 * /* pbracket_greater */) +); + +extern void SyncChangeCounter( + SyncCounter * /* pCounter*/, + CARD64 /* new_value */ +); + +extern void SyncDestroySystemCounter( + pointer pCounter +); +extern void InitServertime(void); + +#endif /* _SYNC_SERVER */ + +#endif /* _SYNCSTR_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xcmiscproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xcmiscproto.h new file mode 100644 index 0000000000000000000000000000000000000000..616cec37072ca9e579e0e96ecbcbdb0502b6258a --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xcmiscproto.h @@ -0,0 +1,110 @@ +/* + +Copyright 1993, 1994, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +*/ + +#ifndef _XCMISCPROTO_H_ +#define _XCMISCPROTO_H_ + +#define X_XCMiscGetVersion 0 +#define X_XCMiscGetXIDRange 1 +#define X_XCMiscGetXIDList 2 + +#define XCMiscNumberEvents 0 + +#define XCMiscNumberErrors 0 + +#define XCMiscMajorVersion 1 +#define XCMiscMinorVersion 1 + +#define XCMiscExtensionName "XC-MISC" + +typedef struct { + CARD8 reqType; /* always XCMiscCode */ + CARD8 miscReqType; /* always X_XCMiscGetVersion */ + CARD16 length; + CARD16 majorVersion; + CARD16 minorVersion; +} xXCMiscGetVersionReq; +#define sz_xXCMiscGetVersionReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 pad0; + CARD16 sequenceNumber; + CARD32 length; + CARD16 majorVersion; + CARD16 minorVersion; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xXCMiscGetVersionReply; +#define sz_xXCMiscGetVersionReply 32 + +typedef struct { + CARD8 reqType; /* always XCMiscCode */ + CARD8 miscReqType; /* always X_XCMiscGetXIDRange */ + CARD16 length; +} xXCMiscGetXIDRangeReq; +#define sz_xXCMiscGetXIDRangeReq 4 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 pad0; + CARD16 sequenceNumber; + CARD32 length; + CARD32 start_id; + CARD32 count; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xXCMiscGetXIDRangeReply; +#define sz_xXCMiscGetXIDRangeReply 32 + +typedef struct { + CARD8 reqType; /* always XCMiscCode */ + CARD8 miscReqType; /* always X_XCMiscGetXIDList */ + CARD16 length; + CARD32 count; /* number of IDs requested */ +} xXCMiscGetXIDListReq; +#define sz_xXCMiscGetXIDListReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 pad0; + CARD16 sequenceNumber; + CARD32 length; + CARD32 count; /* number of IDs requested */ + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xXCMiscGetXIDListReply; +#define sz_xXCMiscGetXIDListReply 32 + +#endif /* _XCMISCPROTO_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xcmiscstr.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xcmiscstr.h new file mode 100644 index 0000000000000000000000000000000000000000..c2b643308cce88d36d2df62fefa831f67d0a4874 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xcmiscstr.h @@ -0,0 +1,3 @@ +#warning "xcmiscstr.h is obsolete and may be removed in the future." +#warning "include for the protocol defines." +#include diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86bigfont.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86bigfont.h new file mode 100644 index 0000000000000000000000000000000000000000..1bf47e92d1d8ba56c5772df032665abcfd03e6fb --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86bigfont.h @@ -0,0 +1,20 @@ +/* + * Declarations for the BIGFONT extension. + * + * Copyright (c) 1999-2000 Bruno Haible + * Copyright (c) 1999-2000 The XFree86 Project, Inc. + */ + +/* THIS IS NOT AN X CONSORTIUM STANDARD */ + +#ifndef _XF86BIGFONT_H_ +#define _XF86BIGFONT_H_ + +#define X_XF86BigfontQueryVersion 0 +#define X_XF86BigfontQueryFont 1 + +#define XF86BigfontNumberEvents 0 + +#define XF86BigfontNumberErrors 0 + +#endif /* _XF86BIGFONT_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86bigfproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86bigfproto.h new file mode 100644 index 0000000000000000000000000000000000000000..a0710dd3ebf368809fc545d709e5aa0eb793e2ce --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86bigfproto.h @@ -0,0 +1,92 @@ +/* + * Declarations of request structures for the BIGFONT extension. + * + * Copyright (c) 1999-2000 Bruno Haible + * Copyright (c) 1999-2000 The XFree86 Project, Inc. + */ + +/* THIS IS NOT AN X CONSORTIUM STANDARD */ + +#ifndef _XF86BIGFPROTO_H_ +#define _XF86BIGFPROTO_H_ + +#include + +#define XF86BIGFONTNAME "XFree86-Bigfont" + +#define XF86BIGFONT_MAJOR_VERSION 1 /* current version numbers */ +#define XF86BIGFONT_MINOR_VERSION 1 + +typedef struct _XF86BigfontQueryVersion { + CARD8 reqType; /* always XF86BigfontReqCode */ + CARD8 xf86bigfontReqType; /* always X_XF86BigfontQueryVersion */ + CARD16 length; +} xXF86BigfontQueryVersionReq; +#define sz_xXF86BigfontQueryVersionReq 4 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 capabilities; + CARD16 sequenceNumber; + CARD32 length; + CARD16 majorVersion; /* major version of XFree86-Bigfont */ + CARD16 minorVersion; /* minor version of XFree86-Bigfont */ + CARD32 uid; + CARD32 gid; + CARD32 signature; + CARD32 pad1; + CARD32 pad2; +} xXF86BigfontQueryVersionReply; +#define sz_xXF86BigfontQueryVersionReply 32 + +/* Bit masks that can be set in the capabilities */ +#define XF86Bigfont_CAP_LocalShm 1 + +typedef struct _XF86BigfontQueryFont { + CARD8 reqType; /* always XF86BigfontReqCode */ + CARD8 xf86bigfontReqType; /* always X_XF86BigfontQueryFont */ + CARD16 length; + CARD32 id; + CARD32 flags; +} xXF86BigfontQueryFontReq; +#define sz_xXF86BigfontQueryFontReq 12 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 pad1; + CARD16 sequenceNumber; + CARD32 length; + xCharInfo minBounds; +#ifndef WORD64 + CARD32 walign1; +#endif + xCharInfo maxBounds; +#ifndef WORD64 + CARD32 walign2; +#endif + CARD16 minCharOrByte2; + CARD16 maxCharOrByte2; + CARD16 defaultChar; + CARD16 nFontProps; + CARD8 drawDirection; + CARD8 minByte1; + CARD8 maxByte1; + BOOL allCharsExist; + INT16 fontAscent; + INT16 fontDescent; + CARD32 nCharInfos; + CARD32 nUniqCharInfos; + CARD32 shmid; + CARD32 shmsegoffset; + /* followed by nFontProps xFontProp structures */ + /* and if nCharInfos > 0 && shmid == -1, + followed by nUniqCharInfos xCharInfo structures + and then by nCharInfos CARD16 indices (each >= 0, < nUniqCharInfos) + and then, if nCharInfos is odd, one more CARD16 for padding. */ +} xXF86BigfontQueryFontReply; +#define sz_xXF86BigfontQueryFontReply 72 + +/* Bit masks that can be set in the flags */ +#define XF86Bigfont_FLAGS_Shm 1 + +#endif /* _XF86BIGFPROTO_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86bigfstr.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86bigfstr.h new file mode 100644 index 0000000000000000000000000000000000000000..cf6735d499b0830c59eee706da7435f7be24f506 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86bigfstr.h @@ -0,0 +1,3 @@ +#warning "xf86bigfstr.h is obsolete and may be removed in the future." +#warning "include for the protocol defines." +#include diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86dga.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86dga.h new file mode 100644 index 0000000000000000000000000000000000000000..7b5d635f923ee27110225186af31d9bf8094d9a9 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86dga.h @@ -0,0 +1,13 @@ +#ifdef _XF86DGA_SERVER_ + +#warning "xf86dga.h is obsolete and may be removed in the future." +#warning "include instead." +#include + +#else + +#warning "xf86dga.h is obsolete and may be removed in the future." +#warning "include instead." +#include + +#endif diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86dga1const.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86dga1const.h new file mode 100644 index 0000000000000000000000000000000000000000..eca06f6af1c9c81f8b085ad2ac05efb95460dab5 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86dga1const.h @@ -0,0 +1,36 @@ +/* + +Copyright (c) 1995 Jon Tombs +Copyright (c) 1995 XFree86 Inc + +*/ + +/************************************************************************ + + THIS IS THE OLD DGA API AND IS OBSOLETE. PLEASE DO NOT USE IT ANYMORE + +************************************************************************/ + +#ifndef _XF86DGA1CONST_H_ +#define _XF86DGA1CONST_H_ + +#define X_XF86DGAQueryVersion 0 +#define X_XF86DGAGetVideoLL 1 +#define X_XF86DGADirectVideo 2 +#define X_XF86DGAGetViewPortSize 3 +#define X_XF86DGASetViewPort 4 +#define X_XF86DGAGetVidPage 5 +#define X_XF86DGASetVidPage 6 +#define X_XF86DGAInstallColormap 7 +#define X_XF86DGAQueryDirectVideo 8 +#define X_XF86DGAViewPortChanged 9 + +#define XF86DGADirectPresent 0x0001 +#define XF86DGADirectGraphics 0x0002 +#define XF86DGADirectMouse 0x0004 +#define XF86DGADirectKeyb 0x0008 +#define XF86DGAHasColormap 0x0100 +#define XF86DGADirectColormap 0x0200 + + +#endif /* _XF86DGA1CONST_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86dga1proto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86dga1proto.h new file mode 100644 index 0000000000000000000000000000000000000000..61d95b3140d1f4ed83a1a9611be67989d72d87e9 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86dga1proto.h @@ -0,0 +1,195 @@ +/* + +Copyright (c) 1995 Jon Tombs +Copyright (c) 1995 XFree86 Inc. + +*/ + +#ifndef _XF86DGAPROTO1_H_ +#define _XF86DGAPROTO1_H_ + +#include + +typedef struct _XF86DGAQueryVersion { + CARD8 reqType; /* always DGAReqCode */ + CARD8 dgaReqType; /* always X_DGAQueryVersion */ + CARD16 length; +} xXF86DGAQueryVersionReq; +#define sz_xXF86DGAQueryVersionReq 4 + +typedef struct { + BYTE type; /* X_Reply */ + BOOL pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD16 majorVersion; /* major version of DGA protocol */ + CARD16 minorVersion; /* minor version of DGA protocol */ + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xXF86DGAQueryVersionReply; +#define sz_xXF86DGAQueryVersionReply 32 + +typedef struct _XF86DGAGetVideoLL { + CARD8 reqType; /* always DGAReqCode */ + CARD8 dgaReqType; /* always X_XF86DGAGetVideoLL */ + CARD16 length; + CARD16 screen; + CARD16 pad; +} xXF86DGAGetVideoLLReq; +#define sz_xXF86DGAGetVideoLLReq 8 + +typedef struct _XF86DGAInstallColormap{ + CARD8 reqType; + CARD8 dgaReqType; + CARD16 length; + CARD16 screen; + CARD16 pad2; + CARD32 id; /* colormap. */ +} xXF86DGAInstallColormapReq; +#define sz_xXF86DGAInstallColormapReq 12 + + +typedef struct { + BYTE type; + BOOL pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 offset; + CARD32 width; + CARD32 bank_size; + CARD32 ram_size; + CARD32 pad4; + CARD32 pad5; +} xXF86DGAGetVideoLLReply; +#define sz_xXF86DGAGetVideoLLReply 32 + +typedef struct _XF86DGADirectVideo { + CARD8 reqType; /* always DGAReqCode */ + CARD8 dgaReqType; /* always X_XF86DGADirectVideo */ + CARD16 length; + CARD16 screen; + CARD16 enable; +} xXF86DGADirectVideoReq; +#define sz_xXF86DGADirectVideoReq 8 + + +typedef struct _XF86DGAGetViewPortSize { + CARD8 reqType; /* always DGAReqCode */ + CARD8 dgaReqType; /* always X_XF86DGAGetViewPort */ + CARD16 length; + CARD16 screen; + CARD16 pad; +} xXF86DGAGetViewPortSizeReq; +#define sz_xXF86DGAGetViewPortSizeReq 8 + +typedef struct { + BYTE type; + BOOL pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 width; + CARD32 height; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xXF86DGAGetViewPortSizeReply; +#define sz_xXF86DGAGetViewPortSizeReply 32 + +typedef struct _XF86DGASetViewPort { + CARD8 reqType; /* always DGAReqCode */ + CARD8 dgaReqType; /* always X_XF86DGASetViewPort */ + CARD16 length; + CARD16 screen; + CARD16 pad; + CARD32 x; + CARD32 y; +} xXF86DGASetViewPortReq; +#define sz_xXF86DGASetViewPortReq 16 + +typedef struct _XF86DGAGetVidPage { + CARD8 reqType; /* always DGAReqCode */ + CARD8 dgaReqType; /* always X_XF86DGAGetVidPage */ + CARD16 length; + CARD16 screen; + CARD16 pad; +} xXF86DGAGetVidPageReq; +#define sz_xXF86DGAGetVidPageReq 8 + +typedef struct { + BYTE type; + BOOL pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 vpage; + CARD32 pad; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xXF86DGAGetVidPageReply; +#define sz_xXF86DGAGetVidPageReply 32 + + +typedef struct _XF86DGASetVidPage { + CARD8 reqType; /* always DGAReqCode */ + CARD8 dgaReqType; /* always X_XF86DGASetVidPage */ + CARD16 length; + CARD16 screen; + CARD16 vpage; +} xXF86DGASetVidPageReq; +#define sz_xXF86DGASetVidPageReq 8 + + +typedef struct _XF86DGAQueryDirectVideo { + CARD8 reqType; /* always DGAReqCode */ + CARD8 dgaReqType; /* always X_DGAQueryVersion */ + CARD16 length; + CARD16 screen; + CARD16 pad; +} xXF86DGAQueryDirectVideoReq; +#define sz_xXF86DGAQueryDirectVideoReq 8 + +typedef struct { + BYTE type; + BOOL pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 flags; + CARD32 pad; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xXF86DGAQueryDirectVideoReply; +#define sz_xXF86DGAQueryDirectVideoReply 32 + + +typedef struct _XF86DGAViewPortChanged { + CARD8 reqType; /* always DGAReqCode */ + CARD8 dgaReqType; /* always X_DGAQueryVersion */ + CARD16 length; + CARD16 screen; + CARD16 n; +} xXF86DGAViewPortChangedReq; +#define sz_xXF86DGAViewPortChangedReq 8 + +typedef struct { + BYTE type; + BOOL pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 result; + CARD32 pad; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xXF86DGAViewPortChangedReply; +#define sz_xXF86DGAViewPortChangedReply 32 + +#endif /* _XF86DGAPROTO1_H_ */ + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86dga1str.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86dga1str.h new file mode 100644 index 0000000000000000000000000000000000000000..d8e73e8cae514b3d12dfc2959187002fce33ce58 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86dga1str.h @@ -0,0 +1,3 @@ +#warning "xf86dga1str.h is obsolete and may be removed in the future." +#warning "include for the protocol defines." +#include diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86dgaconst.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86dgaconst.h new file mode 100644 index 0000000000000000000000000000000000000000..b21e84fd834513427d3a08171199d599bcd00b6e --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86dgaconst.h @@ -0,0 +1,96 @@ +/* + Copyright (c) 1999 XFree86 Inc +*/ + +#ifndef _XF86DGACONST_H_ +#define _XF86DGACONST_H_ + +#include + +#define X_XDGAQueryVersion 0 + +/* 1 through 9 are in xf86dga1.h */ + +/* 10 and 11 are reserved to avoid conflicts with rogue DGA extensions */ + +#define X_XDGAQueryModes 12 +#define X_XDGASetMode 13 +#define X_XDGASetViewport 14 +#define X_XDGAInstallColormap 15 +#define X_XDGASelectInput 16 +#define X_XDGAFillRectangle 17 +#define X_XDGACopyArea 18 +#define X_XDGACopyTransparentArea 19 +#define X_XDGAGetViewportStatus 20 +#define X_XDGASync 21 +#define X_XDGAOpenFramebuffer 22 +#define X_XDGACloseFramebuffer 23 +#define X_XDGASetClientVersion 24 +#define X_XDGAChangePixmapMode 25 +#define X_XDGACreateColormap 26 + + +#define XDGAConcurrentAccess 0x00000001 +#define XDGASolidFillRect 0x00000002 +#define XDGABlitRect 0x00000004 +#define XDGABlitTransRect 0x00000008 +#define XDGAPixmap 0x00000010 + +#define XDGAInterlaced 0x00010000 +#define XDGADoublescan 0x00020000 + +#define XDGAFlipImmediate 0x00000001 +#define XDGAFlipRetrace 0x00000002 + +#define XDGANeedRoot 0x00000001 + +#define XF86DGANumberEvents 7 + +#define XDGAPixmapModeLarge 0 +#define XDGAPixmapModeSmall 1 + +#define XF86DGAClientNotLocal 0 +#define XF86DGANoDirectVideoMode 1 +#define XF86DGAScreenNotActive 2 +#define XF86DGADirectNotActivated 3 +#define XF86DGAOperationNotSupported 4 +#define XF86DGANumberErrors (XF86DGAOperationNotSupported + 1) + + +typedef struct { + int num; /* A unique identifier for the mode (num > 0) */ + char *name; /* name of mode given in the XF86Config */ + float verticalRefresh; + int flags; /* DGA_CONCURRENT_ACCESS, etc... */ + int imageWidth; /* linear accessible portion (pixels) */ + int imageHeight; + int pixmapWidth; /* Xlib accessible portion (pixels) */ + int pixmapHeight; /* both fields ignored if no concurrent access */ + int bytesPerScanline; + int byteOrder; /* MSBFirst, LSBFirst */ + int depth; + int bitsPerPixel; + unsigned long redMask; + unsigned long greenMask; + unsigned long blueMask; + short visualClass; + int viewportWidth; + int viewportHeight; + int xViewportStep; /* viewport position granularity */ + int yViewportStep; + int maxViewportX; /* max viewport origin */ + int maxViewportY; + int viewportFlags; /* types of page flipping possible */ + int reserved1; + int reserved2; +} XDGAMode; + + +typedef struct { + XDGAMode mode; + unsigned char *data; + Pixmap pixmap; +} XDGADevice; + + +#endif /* _XF86DGACONST_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86dgaproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86dgaproto.h new file mode 100644 index 0000000000000000000000000000000000000000..2e8a712e86a907c40f693bb72f7c10aeb64aef75 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86dgaproto.h @@ -0,0 +1,344 @@ +/* + +Copyright (c) 1995 Jon Tombs +Copyright (c) 1995 XFree86 Inc. + +*/ + +#ifndef _XF86DGAPROTO_H_ +#define _XF86DGAPROTO_H_ + +#include +#include + +#define XF86DGANAME "XFree86-DGA" + +#define XDGA_MAJOR_VERSION 2 /* current version numbers */ +#define XDGA_MINOR_VERSION 0 + + +typedef struct _XDGAQueryVersion { + CARD8 reqType; /* always DGAReqCode */ + CARD8 dgaReqType; /* always X_DGAQueryVersion */ + CARD16 length; +} xXDGAQueryVersionReq; +#define sz_xXDGAQueryVersionReq 4 + +typedef struct { + BYTE type; /* X_Reply */ + BOOL pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD16 majorVersion; /* major version of DGA protocol */ + CARD16 minorVersion; /* minor version of DGA protocol */ + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xXDGAQueryVersionReply; +#define sz_xXDGAQueryVersionReply 32 + +typedef struct _XDGAQueryModes { + CARD8 reqType; + CARD8 dgaReqType; + CARD16 length; + CARD32 screen; +} xXDGAQueryModesReq; +#define sz_xXDGAQueryModesReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + BOOL pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 number; /* number of modes available */ + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xXDGAQueryModesReply; +#define sz_xXDGAQueryModesReply 32 + + +typedef struct _XDGASetMode { + CARD8 reqType; + CARD8 dgaReqType; + CARD16 length; + CARD32 screen; + CARD32 mode; /* mode number to init */ + CARD32 pid; /* Pixmap descriptor */ +} xXDGASetModeReq; +#define sz_xXDGASetModeReq 16 + +typedef struct { + BYTE type; /* X_Reply */ + BOOL pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 offset; /* offset into framebuffer map */ + CARD32 flags; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xXDGASetModeReply; +#define sz_xXDGASetModeReply 32 + +typedef struct { + CARD8 byte_order; + CARD8 depth; + CARD16 num; + CARD16 bpp; + CARD16 name_size; + CARD32 vsync_num; + CARD32 vsync_den; + CARD32 flags; + CARD16 image_width; + CARD16 image_height; + CARD16 pixmap_width; + CARD16 pixmap_height; + CARD32 bytes_per_scanline; + CARD32 red_mask; + CARD32 green_mask; + CARD32 blue_mask; + CARD16 visual_class; + CARD16 pad1; + CARD16 viewport_width; + CARD16 viewport_height; + CARD16 viewport_xstep; + CARD16 viewport_ystep; + CARD16 viewport_xmax; + CARD16 viewport_ymax; + CARD32 viewport_flags; + CARD32 reserved1; + CARD32 reserved2; +} xXDGAModeInfo; +#define sz_xXDGAModeInfo 72 + +typedef struct _XDGAOpenFramebuffer { + CARD8 reqType; + CARD8 dgaReqType; + CARD16 length; + CARD32 screen; +} xXDGAOpenFramebufferReq; +#define sz_xXDGAOpenFramebufferReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + BOOL pad1; + CARD16 sequenceNumber; + CARD32 length; /* device name size if there is one */ + CARD32 mem1; /* physical memory */ + CARD32 mem2; /* spillover for _alpha_ */ + CARD32 size; /* size of map in bytes */ + CARD32 offset; /* optional offset into device */ + CARD32 extra; /* extra info associated with the map */ + CARD32 pad2; +} xXDGAOpenFramebufferReply; +#define sz_xXDGAOpenFramebufferReply 32 + + +typedef struct _XDGACloseFramebuffer { + CARD8 reqType; + CARD8 dgaReqType; + CARD16 length; + CARD32 screen; +} xXDGACloseFramebufferReq; +#define sz_xXDGACloseFramebufferReq 8 + + +typedef struct _XDGASetViewport { + CARD8 reqType; + CARD8 dgaReqType; + CARD16 length; + CARD32 screen; + CARD16 x; + CARD16 y; + CARD32 flags; +} xXDGASetViewportReq; +#define sz_xXDGASetViewportReq 16 + + +typedef struct _XDGAInstallColormap { + CARD8 reqType; + CARD8 dgaReqType; + CARD16 length; + CARD32 screen; + CARD32 cmap; +} xXDGAInstallColormapReq; +#define sz_xXDGAInstallColormapReq 12 + +typedef struct _XDGASelectInput { + CARD8 reqType; + CARD8 dgaReqType; + CARD16 length; + CARD32 screen; + CARD32 mask; +} xXDGASelectInputReq; +#define sz_xXDGASelectInputReq 12 + +typedef struct _XDGAFillRectangle { + CARD8 reqType; + CARD8 dgaReqType; + CARD16 length; + CARD32 screen; + CARD16 x; + CARD16 y; + CARD16 width; + CARD16 height; + CARD32 color; +} xXDGAFillRectangleReq; +#define sz_xXDGAFillRectangleReq 20 + + +typedef struct _XDGACopyArea { + CARD8 reqType; + CARD8 dgaReqType; + CARD16 length; + CARD32 screen; + CARD16 srcx; + CARD16 srcy; + CARD16 width; + CARD16 height; + CARD16 dstx; + CARD16 dsty; +} xXDGACopyAreaReq; +#define sz_xXDGACopyAreaReq 20 + +typedef struct _XDGACopyTransparentArea { + CARD8 reqType; + CARD8 dgaReqType; + CARD16 length; + CARD32 screen; + CARD16 srcx; + CARD16 srcy; + CARD16 width; + CARD16 height; + CARD16 dstx; + CARD16 dsty; + CARD32 key; +} xXDGACopyTransparentAreaReq; +#define sz_xXDGACopyTransparentAreaReq 24 + + +typedef struct _XDGAGetViewportStatus { + CARD8 reqType; + CARD8 dgaReqType; + CARD16 length; + CARD32 screen; +} xXDGAGetViewportStatusReq; +#define sz_xXDGAGetViewportStatusReq 8 + +typedef struct { + BYTE type; + BOOL pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 status; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xXDGAGetViewportStatusReply; +#define sz_xXDGAGetViewportStatusReply 32 + +typedef struct _XDGASync { + CARD8 reqType; + CARD8 dgaReqType; + CARD16 length; + CARD32 screen; +} xXDGASyncReq; +#define sz_xXDGASyncReq 8 + +typedef struct { + BYTE type; + BOOL pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; + CARD32 pad7; +} xXDGASyncReply; +#define sz_xXDGASyncReply 32 + +typedef struct _XDGASetClientVersion { + CARD8 reqType; + CARD8 dgaReqType; + CARD16 length; + CARD16 major; + CARD16 minor; +} xXDGASetClientVersionReq; +#define sz_xXDGASetClientVersionReq 8 + + +typedef struct { + CARD8 reqType; + CARD8 dgaReqType; + CARD16 length; + CARD32 screen; + CARD16 x; + CARD16 y; + CARD32 flags; +} xXDGAChangePixmapModeReq; +#define sz_xXDGAChangePixmapModeReq 16 + +typedef struct { + BYTE type; + BOOL pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD16 x; + CARD16 y; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; + CARD32 pad7; +} xXDGAChangePixmapModeReply; +#define sz_xXDGAChangePixmapModeReply 32 + +typedef struct _XDGACreateColormap { + CARD8 reqType; + CARD8 dgaReqType; + CARD16 length; + CARD32 screen; + CARD32 id; + CARD32 mode; + CARD8 alloc; + CARD8 pad1; + CARD16 pad2; +} xXDGACreateColormapReq; +#define sz_xXDGACreateColormapReq 20 + + +typedef struct { + union { + struct { + BYTE type; + BYTE detail; + CARD16 sequenceNumber; + } u; + struct { + CARD32 pad0; + CARD32 time; + INT16 dx; + INT16 dy; + INT16 screen; + CARD16 state; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + } event; + } u; +} dgaEvent; + + +#endif /* _XF86DGAPROTO_H_ */ + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86dgastr.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86dgastr.h new file mode 100644 index 0000000000000000000000000000000000000000..f4809d1a591d4b50016f1fda6d0a6b464e3e3c3d --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86dgastr.h @@ -0,0 +1,3 @@ +#warning "xf86dgastr.h is obsolete and may be removed in the future." +#warning "include for the protocol defines." +#include diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86vm.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86vm.h new file mode 100644 index 0000000000000000000000000000000000000000..a874ab50734033f82a52118a673bc163e1eb515e --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86vm.h @@ -0,0 +1,65 @@ +/* + +Copyright 1995 Kaleb S. KEITHLEY + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL Kaleb S. KEITHLEY BE LIABLE FOR ANY CLAIM, DAMAGES +OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of Kaleb S. KEITHLEY +shall not be used in advertising or otherwise to promote the sale, use +or other dealings in this Software without prior written authorization +from Kaleb S. KEITHLEY + +*/ + +/* THIS IS NOT AN X CONSORTIUM STANDARD OR AN X PROJECT TEAM SPECIFICATION */ + +#ifndef _XF86VM_H_ +#define _XF86VM_H_ + +#include + + +#define CLKFLAG_PROGRAMABLE 1 + +#ifdef XF86VIDMODE_EVENTS +#define XF86VidModeNotify 0 +#define XF86VidModeNumberEvents (XF86VidModeNotify + 1) + +#define XF86VidModeNotifyMask 0x00000001 + +#define XF86VidModeNonEvent 0 +#define XF86VidModeModeChange 1 +#else +#define XF86VidModeNumberEvents 0 +#endif + +#define XF86VidModeBadClock 0 +#define XF86VidModeBadHTimings 1 +#define XF86VidModeBadVTimings 2 +#define XF86VidModeModeUnsuitable 3 +#define XF86VidModeExtensionDisabled 4 +#define XF86VidModeClientNotLocal 5 +#define XF86VidModeZoomLocked 6 +#define XF86VidModeNumberErrors (XF86VidModeZoomLocked + 1) + +#define XF86VM_READ_PERMISSION 1 +#define XF86VM_WRITE_PERMISSION 2 + +#endif diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86vmproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86vmproto.h new file mode 100644 index 0000000000000000000000000000000000000000..73072842481d9587b11cb71b10afed91d6e1211a --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86vmproto.h @@ -0,0 +1,583 @@ +/* + +Copyright 1995 Kaleb S. KEITHLEY + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL Kaleb S. KEITHLEY BE LIABLE FOR ANY CLAIM, DAMAGES +OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of Kaleb S. KEITHLEY +shall not be used in advertising or otherwise to promote the sale, use +or other dealings in this Software without prior written authorization +from Kaleb S. KEITHLEY + +*/ + +/* THIS IS NOT AN X CONSORTIUM STANDARD OR AN X PROJECT TEAM SPECIFICATION */ + +#ifndef _XF86VIDMODEPROTO_H_ +#define _XF86VIDMODEPROTO_H_ + +#include + +#define XF86VIDMODENAME "XFree86-VidModeExtension" + +#define XF86VIDMODE_MAJOR_VERSION 2 /* current version numbers */ +#define XF86VIDMODE_MINOR_VERSION 2 + +#define X_XF86VidModeQueryVersion 0 +#define X_XF86VidModeGetModeLine 1 +#define X_XF86VidModeModModeLine 2 +#define X_XF86VidModeSwitchMode 3 +#define X_XF86VidModeGetMonitor 4 +#define X_XF86VidModeLockModeSwitch 5 +#define X_XF86VidModeGetAllModeLines 6 +#define X_XF86VidModeAddModeLine 7 +#define X_XF86VidModeDeleteModeLine 8 +#define X_XF86VidModeValidateModeLine 9 +#define X_XF86VidModeSwitchToMode 10 +#define X_XF86VidModeGetViewPort 11 +#define X_XF86VidModeSetViewPort 12 +/* new for version 2.x of this extension */ +#define X_XF86VidModeGetDotClocks 13 +#define X_XF86VidModeSetClientVersion 14 +#define X_XF86VidModeSetGamma 15 +#define X_XF86VidModeGetGamma 16 +#define X_XF86VidModeGetGammaRamp 17 +#define X_XF86VidModeSetGammaRamp 18 +#define X_XF86VidModeGetGammaRampSize 19 +#define X_XF86VidModeGetPermissions 20 +/* + * major version 0 == uses parameter-to-wire functions in XFree86 libXxf86vm. + * major version 1 == uses parameter-to-wire functions hard-coded in xvidtune + * client. + * major version 2 == uses new protocol version in XFree86 4.0. + */ + +typedef struct _XF86VidModeQueryVersion { + CARD8 reqType; /* always XF86VidModeReqCode */ + CARD8 xf86vidmodeReqType; /* always X_XF86VidModeQueryVersion */ + CARD16 length; +} xXF86VidModeQueryVersionReq; +#define sz_xXF86VidModeQueryVersionReq 4 + +typedef struct { + BYTE type; /* X_Reply */ + BOOL pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD16 majorVersion; /* major version of XF86VidMode */ + CARD16 minorVersion; /* minor version of XF86VidMode */ + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xXF86VidModeQueryVersionReply; +#define sz_xXF86VidModeQueryVersionReply 32 + +typedef struct _XF86VidModeGetModeLine { + CARD8 reqType; /* always XF86VidModeReqCode */ + CARD8 xf86vidmodeReqType; + CARD16 length; + CARD16 screen; + CARD16 pad; +} xXF86VidModeGetModeLineReq, + xXF86VidModeGetAllModeLinesReq, + xXF86VidModeGetMonitorReq, + xXF86VidModeGetViewPortReq, + xXF86VidModeGetDotClocksReq, + xXF86VidModeGetPermissionsReq; +#define sz_xXF86VidModeGetModeLineReq 8 +#define sz_xXF86VidModeGetAllModeLinesReq 8 +#define sz_xXF86VidModeGetMonitorReq 8 +#define sz_xXF86VidModeGetViewPortReq 8 +#define sz_xXF86VidModeGetDotClocksReq 8 +#define sz_xXF86VidModeGetPermissionsReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + BOOL pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 dotclock; + CARD16 hdisplay; + CARD16 hsyncstart; + CARD16 hsyncend; + CARD16 htotal; + CARD16 hskew; + CARD16 vdisplay; + CARD16 vsyncstart; + CARD16 vsyncend; + CARD16 vtotal; + CARD16 pad2; + CARD32 flags; + CARD32 reserved1; + CARD32 reserved2; + CARD32 reserved3; + CARD32 privsize; +} xXF86VidModeGetModeLineReply; +#define sz_xXF86VidModeGetModeLineReply 52 + +/* 0.x version */ +typedef struct { + BYTE type; /* X_Reply */ + BOOL pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 dotclock; + CARD16 hdisplay; + CARD16 hsyncstart; + CARD16 hsyncend; + CARD16 htotal; + CARD16 vdisplay; + CARD16 vsyncstart; + CARD16 vsyncend; + CARD16 vtotal; + CARD32 flags; + CARD32 privsize; +} xXF86OldVidModeGetModeLineReply; +#define sz_xXF86OldVidModeGetModeLineReply 36 + +typedef struct { + CARD32 dotclock; + CARD16 hdisplay; + CARD16 hsyncstart; + CARD16 hsyncend; + CARD16 htotal; + CARD32 hskew; + CARD16 vdisplay; + CARD16 vsyncstart; + CARD16 vsyncend; + CARD16 vtotal; + CARD16 pad1; + CARD32 flags; + CARD32 reserved1; + CARD32 reserved2; + CARD32 reserved3; + CARD32 privsize; +} xXF86VidModeModeInfo; + +/* 0.x version */ +typedef struct { + CARD32 dotclock; + CARD16 hdisplay; + CARD16 hsyncstart; + CARD16 hsyncend; + CARD16 htotal; + CARD16 vdisplay; + CARD16 vsyncstart; + CARD16 vsyncend; + CARD16 vtotal; + CARD32 flags; + CARD32 privsize; +} xXF86OldVidModeModeInfo; + +typedef struct { + BYTE type; /* X_Reply */ + BOOL pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 modecount; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xXF86VidModeGetAllModeLinesReply; +#define sz_xXF86VidModeGetAllModeLinesReply 32 + +typedef struct _XF86VidModeAddModeLine { + CARD8 reqType; /* always XF86VidModeReqCode */ + CARD8 xf86vidmodeReqType; /* always X_XF86VidModeAddMode */ + CARD16 length; + CARD32 screen; /* could be CARD16 but need the pad */ + CARD32 dotclock; + CARD16 hdisplay; + CARD16 hsyncstart; + CARD16 hsyncend; + CARD16 htotal; + CARD16 hskew; + CARD16 vdisplay; + CARD16 vsyncstart; + CARD16 vsyncend; + CARD16 vtotal; + CARD16 pad1; + CARD32 flags; + CARD32 reserved1; + CARD32 reserved2; + CARD32 reserved3; + CARD32 privsize; + CARD32 after_dotclock; + CARD16 after_hdisplay; + CARD16 after_hsyncstart; + CARD16 after_hsyncend; + CARD16 after_htotal; + CARD16 after_hskew; + CARD16 after_vdisplay; + CARD16 after_vsyncstart; + CARD16 after_vsyncend; + CARD16 after_vtotal; + CARD16 pad2; + CARD32 after_flags; + CARD32 reserved4; + CARD32 reserved5; + CARD32 reserved6; +} xXF86VidModeAddModeLineReq; +#define sz_xXF86VidModeAddModeLineReq 92 + +/* 0.x version */ +typedef struct _XF86OldVidModeAddModeLine { + CARD8 reqType; /* always XF86VidModeReqCode */ + CARD8 xf86vidmodeReqType; /* always X_XF86VidModeAddMode */ + CARD16 length; + CARD32 screen; /* could be CARD16 but need the pad */ + CARD32 dotclock; + CARD16 hdisplay; + CARD16 hsyncstart; + CARD16 hsyncend; + CARD16 htotal; + CARD16 vdisplay; + CARD16 vsyncstart; + CARD16 vsyncend; + CARD16 vtotal; + CARD32 flags; + CARD32 privsize; + CARD32 after_dotclock; + CARD16 after_hdisplay; + CARD16 after_hsyncstart; + CARD16 after_hsyncend; + CARD16 after_htotal; + CARD16 after_vdisplay; + CARD16 after_vsyncstart; + CARD16 after_vsyncend; + CARD16 after_vtotal; + CARD32 after_flags; +} xXF86OldVidModeAddModeLineReq; +#define sz_xXF86OldVidModeAddModeLineReq 60 + +typedef struct _XF86VidModeModModeLine { + CARD8 reqType; /* always XF86VidModeReqCode */ + CARD8 xf86vidmodeReqType; /* always X_XF86VidModeModModeLine */ + CARD16 length; + CARD32 screen; /* could be CARD16 but need the pad */ + CARD16 hdisplay; + CARD16 hsyncstart; + CARD16 hsyncend; + CARD16 htotal; + CARD16 hskew; + CARD16 vdisplay; + CARD16 vsyncstart; + CARD16 vsyncend; + CARD16 vtotal; + CARD16 pad1; + CARD32 flags; + CARD32 reserved1; + CARD32 reserved2; + CARD32 reserved3; + CARD32 privsize; +} xXF86VidModeModModeLineReq; +#define sz_xXF86VidModeModModeLineReq 48 + +/* 0.x version */ +typedef struct _XF86OldVidModeModModeLine { + CARD8 reqType; /* always XF86OldVidModeReqCode */ + CARD8 xf86vidmodeReqType; /* always X_XF86OldVidModeModModeLine */ + CARD16 length; + CARD32 screen; /* could be CARD16 but need the pad */ + CARD16 hdisplay; + CARD16 hsyncstart; + CARD16 hsyncend; + CARD16 htotal; + CARD16 vdisplay; + CARD16 vsyncstart; + CARD16 vsyncend; + CARD16 vtotal; + CARD32 flags; + CARD32 privsize; +} xXF86OldVidModeModModeLineReq; +#define sz_xXF86OldVidModeModModeLineReq 32 + +typedef struct _XF86VidModeValidateModeLine { + CARD8 reqType; /* always XF86VidModeReqCode */ + CARD8 xf86vidmodeReqType; + CARD16 length; + CARD32 screen; /* could be CARD16 but need the pad */ + CARD32 dotclock; + CARD16 hdisplay; + CARD16 hsyncstart; + CARD16 hsyncend; + CARD16 htotal; + CARD16 hskew; + CARD16 vdisplay; + CARD16 vsyncstart; + CARD16 vsyncend; + CARD16 vtotal; + CARD16 pad1; + CARD32 flags; + CARD32 reserved1; + CARD32 reserved2; + CARD32 reserved3; + CARD32 privsize; +} xXF86VidModeDeleteModeLineReq, + xXF86VidModeValidateModeLineReq, + xXF86VidModeSwitchToModeReq; +#define sz_xXF86VidModeDeleteModeLineReq 52 +#define sz_xXF86VidModeValidateModeLineReq 52 +#define sz_xXF86VidModeSwitchToModeReq 52 + +/* 0.x version */ +typedef struct _XF86OldVidModeValidateModeLine { + CARD8 reqType; /* always XF86OldVidModeReqCode */ + CARD8 xf86vidmodeReqType; + CARD16 length; + CARD32 screen; /* could be CARD16 but need the pad */ + CARD32 dotclock; + CARD16 hdisplay; + CARD16 hsyncstart; + CARD16 hsyncend; + CARD16 htotal; + CARD16 vdisplay; + CARD16 vsyncstart; + CARD16 vsyncend; + CARD16 vtotal; + CARD32 flags; + CARD32 privsize; +} xXF86OldVidModeDeleteModeLineReq, + xXF86OldVidModeValidateModeLineReq, + xXF86OldVidModeSwitchToModeReq; +#define sz_xXF86OldVidModeDeleteModeLineReq 36 +#define sz_xXF86OldVidModeValidateModeLineReq 36 +#define sz_xXF86OldVidModeSwitchToModeReq 36 + +typedef struct _XF86VidModeSwitchMode { + CARD8 reqType; /* always XF86VidModeReqCode */ + CARD8 xf86vidmodeReqType; /* always X_XF86VidModeSwitchMode */ + CARD16 length; + CARD16 screen; + CARD16 zoom; +} xXF86VidModeSwitchModeReq; +#define sz_xXF86VidModeSwitchModeReq 8 + +typedef struct _XF86VidModeLockModeSwitch { + CARD8 reqType; /* always XF86VidModeReqCode */ + CARD8 xf86vidmodeReqType; /* always X_XF86VidModeLockModeSwitch */ + CARD16 length; + CARD16 screen; + CARD16 lock; +} xXF86VidModeLockModeSwitchReq; +#define sz_xXF86VidModeLockModeSwitchReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + BOOL pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 status; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xXF86VidModeValidateModeLineReply; +#define sz_xXF86VidModeValidateModeLineReply 32 + +typedef struct { + BYTE type; /* X_Reply */ + BOOL pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD8 vendorLength; + CARD8 modelLength; + CARD8 nhsync; + CARD8 nvsync; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xXF86VidModeGetMonitorReply; +#define sz_xXF86VidModeGetMonitorReply 32 + +typedef struct { + BYTE type; + BOOL pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 x; + CARD32 y; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xXF86VidModeGetViewPortReply; +#define sz_xXF86VidModeGetViewPortReply 32 + +typedef struct _XF86VidModeSetViewPort { + CARD8 reqType; /* always VidModeReqCode */ + CARD8 xf86vidmodeReqType; /* always X_XF86VidModeSetViewPort */ + CARD16 length; + CARD16 screen; + CARD16 pad; + CARD32 x; + CARD32 y; +} xXF86VidModeSetViewPortReq; +#define sz_xXF86VidModeSetViewPortReq 16 + +typedef struct { + BYTE type; + BOOL pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 flags; + CARD32 clocks; + CARD32 maxclocks; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; +} xXF86VidModeGetDotClocksReply; +#define sz_xXF86VidModeGetDotClocksReply 32 + +typedef struct _XF86VidModeSetClientVersion { + CARD8 reqType; /* always XF86VidModeReqCode */ + CARD8 xf86vidmodeReqType; + CARD16 length; + CARD16 major; + CARD16 minor; +} xXF86VidModeSetClientVersionReq; +#define sz_xXF86VidModeSetClientVersionReq 8 + +typedef struct _XF86VidModeGetGamma { + CARD8 reqType; /* always XF86VidModeReqCode */ + CARD8 xf86vidmodeReqType; + CARD16 length; + CARD16 screen; + CARD16 pad; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xXF86VidModeGetGammaReq; +#define sz_xXF86VidModeGetGammaReq 32 + +typedef struct { + BYTE type; + BOOL pad; + CARD16 sequenceNumber; + CARD32 length; + CARD32 red; + CARD32 green; + CARD32 blue; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; +} xXF86VidModeGetGammaReply; +#define sz_xXF86VidModeGetGammaReply 32 + +typedef struct _XF86VidModeSetGamma { + CARD8 reqType; /* always XF86VidModeReqCode */ + CARD8 xf86vidmodeReqType; + CARD16 length; + CARD16 screen; + CARD16 pad; + CARD32 red; + CARD32 green; + CARD32 blue; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; +} xXF86VidModeSetGammaReq; +#define sz_xXF86VidModeSetGammaReq 32 + + +typedef struct _XF86VidModeSetGammaRamp { + CARD8 reqType; /* always XF86VidModeReqCode */ + CARD8 xf86vidmodeReqType; + CARD16 length; + CARD16 screen; + CARD16 size; +} xXF86VidModeSetGammaRampReq; +#define sz_xXF86VidModeSetGammaRampReq 8 + +typedef struct _XF86VidModeGetGammaRamp { + CARD8 reqType; /* always XF86VidModeReqCode */ + CARD8 xf86vidmodeReqType; + CARD16 length; + CARD16 screen; + CARD16 size; +} xXF86VidModeGetGammaRampReq; +#define sz_xXF86VidModeGetGammaRampReq 8 + +typedef struct { + BYTE type; + BOOL pad; + CARD16 sequenceNumber; + CARD32 length; + CARD16 size; + CARD16 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xXF86VidModeGetGammaRampReply; +#define sz_xXF86VidModeGetGammaRampReply 32 + +typedef struct _XF86VidModeGetGammaRampSize { + CARD8 reqType; /* always XF86VidModeReqCode */ + CARD8 xf86vidmodeReqType; + CARD16 length; + CARD16 screen; + CARD16 pad; +} xXF86VidModeGetGammaRampSizeReq; +#define sz_xXF86VidModeGetGammaRampSizeReq 8 + +typedef struct { + BYTE type; + BOOL pad; + CARD16 sequenceNumber; + CARD32 length; + CARD16 size; + CARD16 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xXF86VidModeGetGammaRampSizeReply; +#define sz_xXF86VidModeGetGammaRampSizeReply 32 + +typedef struct { + BYTE type; + BOOL pad; + CARD16 sequenceNumber; + CARD32 length; + CARD32 permissions; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xXF86VidModeGetPermissionsReply; +#define sz_xXF86VidModeGetPermissionsReply 32 + + +#endif /* _XF86VIDMODEPROTO_H_ */ + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86vmstr.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86vmstr.h new file mode 100644 index 0000000000000000000000000000000000000000..f521335b3c4f40ed87d205b8db68ce552c157249 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xf86vmstr.h @@ -0,0 +1,3 @@ +#warning "xf86vmstr.h is obsolete and may be removed in the future." +#warning "include for the protocol defines." +#include diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xfixesproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xfixesproto.h new file mode 100644 index 0000000000000000000000000000000000000000..916535a53102939abf229d99e7e4f1cac91fa78e --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xfixesproto.h @@ -0,0 +1,585 @@ +/* + * Copyright (c) 2006, Oracle and/or its affiliates. + * Copyright 2010 Red Hat, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ +/* + * Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _XFIXESPROTO_H_ +#define _XFIXESPROTO_H_ + +#include +#include +#include + +#define Window CARD32 +#define Drawable CARD32 +#define Font CARD32 +#define Pixmap CARD32 +#define Cursor CARD32 +#define Colormap CARD32 +#define GContext CARD32 +#define Atom CARD32 +#define VisualID CARD32 +#define Time CARD32 +#define KeyCode CARD8 +#define KeySym CARD32 +#define Picture CARD32 + +/*************** Version 1 ******************/ + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; +} xXFixesReq; + +/* + * requests and replies + */ +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + CARD32 majorVersion; + CARD32 minorVersion; +} xXFixesQueryVersionReq; + +#define sz_xXFixesQueryVersionReq 12 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 majorVersion; + CARD32 minorVersion; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xXFixesQueryVersionReply; + +#define sz_xXFixesQueryVersionReply 32 + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + BYTE mode; /* SetModeInsert/SetModeDelete*/ + BYTE target; /* SaveSetNearest/SaveSetRoot*/ + BYTE map; /* SaveSetMap/SaveSetUnmap */ + BYTE pad1; + Window window; +} xXFixesChangeSaveSetReq; + +#define sz_xXFixesChangeSaveSetReq 12 + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + Window window; + Atom selection; + CARD32 eventMask; +} xXFixesSelectSelectionInputReq; + +#define sz_xXFixesSelectSelectionInputReq 16 + +typedef struct { + CARD8 type; + CARD8 subtype; + CARD16 sequenceNumber; + Window window; + Window owner; + Atom selection; + Time timestamp; + Time selectionTimestamp; + CARD32 pad2; + CARD32 pad3; +} xXFixesSelectionNotifyEvent; + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + Window window; + CARD32 eventMask; +} xXFixesSelectCursorInputReq; + +#define sz_xXFixesSelectCursorInputReq 12 + +typedef struct { + CARD8 type; + CARD8 subtype; + CARD16 sequenceNumber; + Window window; + CARD32 cursorSerial; + Time timestamp; + Atom name; /* Version 2 */ + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; +} xXFixesCursorNotifyEvent; + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; +} xXFixesGetCursorImageReq; + +#define sz_xXFixesGetCursorImageReq 4 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber; + CARD32 length; + INT16 x; + INT16 y; + CARD16 width; + CARD16 height; + CARD16 xhot; + CARD16 yhot; + CARD32 cursorSerial; + CARD32 pad2; + CARD32 pad3; +} xXFixesGetCursorImageReply; + +#define sz_xXFixesGetCursorImageReply 32 + +/*************** Version 2 ******************/ + +#define Region CARD32 + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + Region region; + /* LISTofRECTANGLE */ +} xXFixesCreateRegionReq; + +#define sz_xXFixesCreateRegionReq 8 + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + Region region; + Pixmap bitmap; +} xXFixesCreateRegionFromBitmapReq; + +#define sz_xXFixesCreateRegionFromBitmapReq 12 + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + Region region; + Window window; + CARD8 kind; + CARD8 pad1; + CARD16 pad2; +} xXFixesCreateRegionFromWindowReq; + +#define sz_xXFixesCreateRegionFromWindowReq 16 + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + Region region; + GContext gc; +} xXFixesCreateRegionFromGCReq; + +#define sz_xXFixesCreateRegionFromGCReq 12 + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + Region region; + Picture picture; +} xXFixesCreateRegionFromPictureReq; + +#define sz_xXFixesCreateRegionFromPictureReq 12 + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + Region region; +} xXFixesDestroyRegionReq; + +#define sz_xXFixesDestroyRegionReq 8 + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + Region region; + /* LISTofRECTANGLE */ +} xXFixesSetRegionReq; + +#define sz_xXFixesSetRegionReq 8 + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + Region source; + Region destination; +} xXFixesCopyRegionReq; + +#define sz_xXFixesCopyRegionReq 12 + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + Region source1; + Region source2; + Region destination; +} xXFixesCombineRegionReq, + xXFixesUnionRegionReq, + xXFixesIntersectRegionReq, + xXFixesSubtractRegionReq; + +#define sz_xXFixesCombineRegionReq 16 +#define sz_xXFixesUnionRegionReq sz_xXFixesCombineRegionReq +#define sz_xXFixesIntersectRegionReq sz_xXFixesCombineRegionReq +#define sz_xXFixesSubtractRegionReq sz_xXFixesCombineRegionReq + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + Region source; + INT16 x, y; + CARD16 width, height; + Region destination; +} xXFixesInvertRegionReq; + +#define sz_xXFixesInvertRegionReq 20 + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + Region region; + INT16 dx, dy; +} xXFixesTranslateRegionReq; + +#define sz_xXFixesTranslateRegionReq 12 + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + Region source; + Region destination; +} xXFixesRegionExtentsReq; + +#define sz_xXFixesRegionExtentsReq 12 + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + Region region; +} xXFixesFetchRegionReq; + +#define sz_xXFixesFetchRegionReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber; + CARD32 length; + INT16 x, y; + CARD16 width, height; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xXFixesFetchRegionReply; + +#define sz_xXFixesFetchRegionReply 32 + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + GContext gc; + Region region; + INT16 xOrigin, yOrigin; +} xXFixesSetGCClipRegionReq; + +#define sz_xXFixesSetGCClipRegionReq 16 + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + Window dest; + BYTE destKind; + CARD8 pad1; + CARD16 pad2; + INT16 xOff, yOff; + Region region; +} xXFixesSetWindowShapeRegionReq; + +#define sz_xXFixesSetWindowShapeRegionReq 20 + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + Picture picture; + Region region; + INT16 xOrigin, yOrigin; +} xXFixesSetPictureClipRegionReq; + +#define sz_xXFixesSetPictureClipRegionReq 16 + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + Cursor cursor; + CARD16 nbytes; + CARD16 pad; +} xXFixesSetCursorNameReq; + +#define sz_xXFixesSetCursorNameReq 12 + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + Cursor cursor; +} xXFixesGetCursorNameReq; + +#define sz_xXFixesGetCursorNameReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber; + CARD32 length; + Atom atom; + CARD16 nbytes; + CARD16 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xXFixesGetCursorNameReply; + +#define sz_xXFixesGetCursorNameReply 32 + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; +} xXFixesGetCursorImageAndNameReq; + +#define sz_xXFixesGetCursorImageAndNameReq 4 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber; + CARD32 length; + INT16 x; + INT16 y; + CARD16 width; + CARD16 height; + CARD16 xhot; + CARD16 yhot; + CARD32 cursorSerial; + Atom cursorName; + CARD16 nbytes; + CARD16 pad; +} xXFixesGetCursorImageAndNameReply; + +#define sz_xXFixesGetCursorImageAndNameReply 32 + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + Cursor source; + Cursor destination; +} xXFixesChangeCursorReq; + +#define sz_xXFixesChangeCursorReq 12 + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + Cursor source; + CARD16 nbytes; + CARD16 pad; +} xXFixesChangeCursorByNameReq; + +#define sz_xXFixesChangeCursorByNameReq 12 + +/*************** Version 3 ******************/ + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + Region source; + Region destination; + CARD16 left; + CARD16 right; + CARD16 top; + CARD16 bottom; +} xXFixesExpandRegionReq; + +#define sz_xXFixesExpandRegionReq 20 + +/*************** Version 4.0 ******************/ + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + Window window; +} xXFixesHideCursorReq; + +#define sz_xXFixesHideCursorReq sizeof(xXFixesHideCursorReq) + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + Window window; +} xXFixesShowCursorReq; + +#define sz_xXFixesShowCursorReq sizeof(xXFixesShowCursorReq) + +/*************** Version 5.0 ******************/ + +#define Barrier CARD32 + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + Barrier barrier; + Window window; + INT16 x1; + INT16 y1; + INT16 x2; + INT16 y2; + CARD32 directions; + CARD16 pad; + CARD16 num_devices; + /* array of CARD16 devices */ +} xXFixesCreatePointerBarrierReq; + +#define sz_xXFixesCreatePointerBarrierReq 28 + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + Barrier barrier; +} xXFixesDestroyPointerBarrierReq; + +#define sz_xXFixesDestroyPointerBarrierReq 8 + +/*************** Version 6.0 ******************/ + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; + CARD32 disconnect_mode; +} xXFixesSetClientDisconnectModeReq; + +#define sz_xXFixesSetClientDisconnectModeReq 8 + +typedef struct { + CARD8 reqType; + CARD8 xfixesReqType; + CARD16 length; +} xXFixesGetClientDisconnectModeReq; + +#define sz_xXFixesGetClientDisconnectModeReq 4 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 pad0; + CARD16 sequenceNumber; + CARD32 length; + CARD32 disconnect_mode; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xXFixesGetClientDisconnectModeReply; + +#define sz_xXFixesGetClientDisconnectModeReply 32 + +#undef Barrier +#undef Region +#undef Picture +#undef Window +#undef Drawable +#undef Font +#undef Pixmap +#undef Cursor +#undef Colormap +#undef GContext +#undef Atom +#undef VisualID +#undef Time +#undef KeyCode +#undef KeySym + +#endif /* _XFIXESPROTO_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xfixeswire.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xfixeswire.h new file mode 100644 index 0000000000000000000000000000000000000000..83251cf2ecf3334289c83ac80f0a1d857ea83daa --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xfixeswire.h @@ -0,0 +1,154 @@ +/* + * Copyright (c) 2006, Oracle and/or its affiliates. + * Copyright 2010 Red Hat, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ +/* + * Copyright © 2002 Keith Packard, member of The XFree86 Project, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + + +#ifndef _XFIXESWIRE_H_ +#define _XFIXESWIRE_H_ + +#define XFIXES_NAME "XFIXES" +#define XFIXES_MAJOR 6 +#define XFIXES_MINOR 0 + +/*************** Version 1 ******************/ +#define X_XFixesQueryVersion 0 +#define X_XFixesChangeSaveSet 1 +#define X_XFixesSelectSelectionInput 2 +#define X_XFixesSelectCursorInput 3 +#define X_XFixesGetCursorImage 4 +/*************** Version 2 ******************/ +#define X_XFixesCreateRegion 5 +#define X_XFixesCreateRegionFromBitmap 6 +#define X_XFixesCreateRegionFromWindow 7 +#define X_XFixesCreateRegionFromGC 8 +#define X_XFixesCreateRegionFromPicture 9 +#define X_XFixesDestroyRegion 10 +#define X_XFixesSetRegion 11 +#define X_XFixesCopyRegion 12 +#define X_XFixesUnionRegion 13 +#define X_XFixesIntersectRegion 14 +#define X_XFixesSubtractRegion 15 +#define X_XFixesInvertRegion 16 +#define X_XFixesTranslateRegion 17 +#define X_XFixesRegionExtents 18 +#define X_XFixesFetchRegion 19 +#define X_XFixesSetGCClipRegion 20 +#define X_XFixesSetWindowShapeRegion 21 +#define X_XFixesSetPictureClipRegion 22 +#define X_XFixesSetCursorName 23 +#define X_XFixesGetCursorName 24 +#define X_XFixesGetCursorImageAndName 25 +#define X_XFixesChangeCursor 26 +#define X_XFixesChangeCursorByName 27 +/*************** Version 3 ******************/ +#define X_XFixesExpandRegion 28 +/*************** Version 4 ******************/ +#define X_XFixesHideCursor 29 +#define X_XFixesShowCursor 30 +/*************** Version 5 ******************/ +#define X_XFixesCreatePointerBarrier 31 +#define X_XFixesDestroyPointerBarrier 32 +/*************** Version 6 ******************/ +#define X_XFixesSetClientDisconnectMode 33 +#define X_XFixesGetClientDisconnectMode 34 + +#define XFixesNumberRequests (X_XFixesGetClientDisconnectMode+1) + +/* Selection events share one event number */ +#define XFixesSelectionNotify 0 + +/* Within the selection, the 'subtype' field distinguishes */ +#define XFixesSetSelectionOwnerNotify 0 +#define XFixesSelectionWindowDestroyNotify 1 +#define XFixesSelectionClientCloseNotify 2 + +#define XFixesSetSelectionOwnerNotifyMask (1L << 0) +#define XFixesSelectionWindowDestroyNotifyMask (1L << 1) +#define XFixesSelectionClientCloseNotifyMask (1L << 2) + +/* There's only one cursor event so far */ +#define XFixesCursorNotify 1 + +#define XFixesDisplayCursorNotify 0 + +#define XFixesDisplayCursorNotifyMask (1L << 0) + +#define XFixesNumberEvents (2) + +/* errors */ +#define BadRegion 0 +#define BadBarrier 1 +#define XFixesNumberErrors (BadBarrier+1) + +#define SaveSetNearest 0 +#define SaveSetRoot 1 + +#define SaveSetMap 0 +#define SaveSetUnmap 1 + +/*************** Version 2 ******************/ + +#define WindowRegionBounding 0 +#define WindowRegionClip 1 + +/*************** Version 5 ******************/ + +#define BarrierPositiveX (1L << 0) +#define BarrierPositiveY (1L << 1) +#define BarrierNegativeX (1L << 2) +#define BarrierNegativeY (1L << 3) + +/*************** Version 6 ******************/ + +/* The default server behaviour */ +#define XFixesClientDisconnectFlagDefault 0 +/* The server may disconnect this client to shut down */ +#define XFixesClientDisconnectFlagTerminate (1L << 0) + +/*************** Version 6.1 ******************/ + +/* The server must terminate if this client exits */ +#define XFixesClientDisconnectFlagForceTerminate (1L << 1) + +#endif /* _XFIXESWIRE_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xtestconst.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xtestconst.h new file mode 100644 index 0000000000000000000000000000000000000000..e74b9042ec2d25fb54e1458940e7d32536e5cc9f --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xtestconst.h @@ -0,0 +1,41 @@ +/* + +Copyright 1992, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +*/ + +#ifndef _XTEST_CONST_H_ +#define _XTEST_CONST_H_ + +#define XTestNumberEvents 0 + +#define XTestNumberErrors 0 + +#define XTestCurrentCursor ((Cursor)1) + +#define XTestMajorVersion 2 +#define XTestMinorVersion 2 + +#define XTestExtensionName "XTEST" + +#endif diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xtestext1const.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xtestext1const.h new file mode 100644 index 0000000000000000000000000000000000000000..656edc6ba15b68aa2fc92c4d20638d015483b05e --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xtestext1const.h @@ -0,0 +1,160 @@ +/* + * xtestext1.h + * + * X11 Input Synthesis Extension include file + */ + +/* + + +Copyright 1986, 1987, 1988, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + + +Copyright 1986, 1987, 1988 by Hewlett-Packard Corporation + +Permission to use, copy, modify, and distribute this +software and its documentation for any purpose and without +fee is hereby granted, provided that the above copyright +notice appear in all copies and that both that copyright +notice and this permission notice appear in supporting +documentation, and that the name of Hewlett-Packard not be used in +advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +Hewlett-Packard makes no representations about the +suitability of this software for any purpose. It is provided +"as is" without express or implied warranty. + +This software is not subject to any license of the American +Telephone and Telegraph Company or of the Regents of the +University of California. + +*/ + +#ifndef _XTESTEXT1CONST_H +#define _XTESTEXT1CONST_H 1 + +#define XTestMAX_ACTION_LIST_SIZE 64 +#define XTestACTIONS_SIZE 28 + + +/* + * used in the XTestPressButton and XTestPressKey functions + */ +#define XTestPRESS 1 << 0 +#define XTestRELEASE 1 << 1 +#define XTestSTROKE 1 << 2 + +/* + * When doing a key or button stroke, the number of milliseconds + * to delay between the press and the release of a key or button + * in the XTestPressButton and XTestPressKey functions. + */ + +#define XTestSTROKE_DELAY_TIME 10 + +/* + * used in the XTestGetInput function + */ +#define XTestEXCLUSIVE 1 << 0 +#define XTestPACKED_ACTIONS 1 << 1 +#define XTestPACKED_MOTION 1 << 2 + +/* + * used in the XTestFakeInput function + */ +#define XTestFAKE_ACK_NOT_NEEDED 0 +#define XTestFAKE_ACK_REQUEST 1 + +/* + * used in the XTest extension initialization routine + */ +#define XTestEXTENSION_NAME "XTestExtension1" +#define XTestEVENT_COUNT 2 + +/* + * This is the definition for the format of the header byte + * in the input action structures. + */ +#define XTestACTION_TYPE_MASK 0x03 /* bits 0 and 1 */ +#define XTestKEY_STATE_MASK 0x04 /* bit 2 (key action) */ +#define XTestX_SIGN_BIT_MASK 0x04 /* bit 2 (motion action) */ +#define XTestY_SIGN_BIT_MASK 0x08 /* bit 3 (motion action) */ +#define XTestDEVICE_ID_MASK 0xf0 /* bits 4 through 7 */ + +#define XTestMAX_DEVICE_ID 0x0f +#define XTestPackDeviceID(x) (((x) & XTestMAX_DEVICE_ID) << 4) +#define XTestUnpackDeviceID(x) (((x) & XTestDEVICE_ID_MASK) >> 4) + +/* + * These are the possible action types. + */ +#define XTestDELAY_ACTION 0 +#define XTestKEY_ACTION 1 +#define XTestMOTION_ACTION 2 +#define XTestJUMP_ACTION 3 + +/* + * These are the definitions for key/button motion input actions. + */ +#define XTestKEY_UP 0x04 +#define XTestKEY_DOWN 0x00 + +/* + * These are the definitions for pointer relative motion input + * actions. + * + * The sign bits for the x and y relative motions are contained + * in the header byte. The x and y relative motions are packed + * into one byte to make things fit in 32 bits. If the relative + * motion range is larger than +/-15, use the pointer jump action. + */ +#define XTestMOTION_MAX 15 +#define XTestMOTION_MIN -15 + +#define XTestX_NEGATIVE 0x04 +#define XTestY_NEGATIVE 0x08 + +#define XTestX_MOTION_MASK 0x0f +#define XTestY_MOTION_MASK 0xf0 + +#define XTestPackXMotionValue(x) ((x) & XTestX_MOTION_MASK) +#define XTestPackYMotionValue(x) (((x) << 4) & XTestY_MOTION_MASK) + +#define XTestUnpackXMotionValue(x) ((x) & XTestX_MOTION_MASK) +#define XTestUnpackYMotionValue(x) (((x) & XTestY_MOTION_MASK) >> 4) +/* + * These are the definitions for a long delay input action. It is + * used when more than XTestSHORT_DELAY_TIME milliseconds of delay + * (approximately one minute) is needed. + * + * The device ID for a delay is always set to XTestDELAY_DEVICE_ID. + * This guarantees that a header byte with a value of 0 is not + * a valid header, so it can be used as a flag to indicate that + * there are no more input actions in an XTestInputAction event. + */ + +#define XTestSHORT_DELAY_TIME 0xffff +#define XTestDELAY_DEVICE_ID 0x0f + +#endif /* _XTESTEXT1CONST_H */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xtestext1proto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xtestext1proto.h new file mode 100644 index 0000000000000000000000000000000000000000..d14ace12b4e605530197b138838433d8d7a48ef0 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xtestext1proto.h @@ -0,0 +1,221 @@ +/* + * xtestext1.h + * + * X11 Input Synthesis Extension include file + */ + +/* +Copyright 1986, 1987, 1988, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + + +Copyright 1986, 1987, 1988 by Hewlett-Packard Corporation + +Permission to use, copy, modify, and distribute this +software and its documentation for any purpose and without +fee is hereby granted, provided that the above copyright +notice appear in all copies and that both that copyright +notice and this permission notice appear in supporting +documentation, and that the name of Hewlett-Packard not be used in +advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +Hewlett-Packard makes no representations about the +suitability of this software for any purpose. It is provided +"as is" without express or implied warranty. + +This software is not subject to any license of the American +Telephone and Telegraph Company or of the Regents of the +University of California. + +*/ + +#ifndef _XTESTEXT1PROTO_H +#define _XTESTEXT1PROTO_H 1 + +#include + +/* + * the typedefs for CARD8, CARD16, and CARD32 are defined in Xmd.h + */ + +/* + * XTest request type values + * + * used in the XTest extension protocol requests + */ +#define X_TestFakeInput 1 +#define X_TestGetInput 2 +#define X_TestStopInput 3 +#define X_TestReset 4 +#define X_TestQueryInputSize 5 + +/* + * This defines the maximum size of a list of input actions + * to be sent to the server. It should always be a multiple of + * 4 so that the entire xTestFakeInputReq structure size is a + * multiple of 4. + */ + +typedef struct { + CARD8 reqType; /* always XTestReqCode */ + CARD8 XTestReqType; /* always X_TestFakeInput */ + CARD16 length; /* 2 + XTestMAX_ACTION_LIST_SIZE/4 */ + CARD32 ack; + CARD8 action_list[XTestMAX_ACTION_LIST_SIZE]; +} xTestFakeInputReq; +#define sz_xTestFakeInputReq (XTestMAX_ACTION_LIST_SIZE + 8) + +typedef struct { + CARD8 reqType; /* always XTestReqCode */ + CARD8 XTestReqType; /* always X_TestGetInput */ + CARD16 length; /* 2 */ + CARD32 mode; +} xTestGetInputReq; +#define sz_xTestGetInputReq 8 + +typedef struct { + CARD8 reqType; /* always XTestReqCode */ + CARD8 XTestReqType; /* always X_TestStopInput */ + CARD16 length; /* 1 */ +} xTestStopInputReq; +#define sz_xTestStopInputReq 4 + +typedef struct { + CARD8 reqType; /* always XTestReqCode */ + CARD8 XTestReqType; /* always X_TestReset */ + CARD16 length; /* 1 */ +} xTestResetReq; +#define sz_xTestResetReq 4 + +typedef struct { + CARD8 reqType; /* always XTestReqCode */ + CARD8 XTestReqType; /* always X_TestQueryInputSize */ + CARD16 length; /* 1 */ +} xTestQueryInputSizeReq; +#define sz_xTestQueryInputSizeReq 4 + +/* + * This is the definition of the reply for the xTestQueryInputSize + * request. It should remain the same minimum size as other replies + * (32 bytes). + */ +typedef struct { + CARD8 type; /* always X_Reply */ + CARD8 pad1; + CARD16 sequenceNumber; + CARD32 length; /* always 0 */ + CARD32 size_return; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xTestQueryInputSizeReply; + +/* + * This is the definition for the input action wire event structure. + * This event is sent to the client when the server has one or + * more user input actions to report to the client. It must + * remain the same size as all other wire events (32 bytes). + */ +typedef struct { + CARD8 type; /* always XTestInputActionType */ + CARD8 pad00; + CARD16 sequenceNumber; + CARD8 actions[XTestACTIONS_SIZE]; +} xTestInputActionEvent; + +/* + * This is the definition for the xTestFakeAck wire event structure. + * This event is sent to the client when the server has completely + * processed its input action buffer, and is ready for more. + * It must remain the same size as all other wire events (32 bytes). + */ +typedef struct { + CARD8 type; /* always XTestFakeAckType */ + CARD8 pad00; + CARD16 sequenceNumber; + CARD32 pad02; + CARD32 pad03; + CARD32 pad04; + CARD32 pad05; + CARD32 pad06; + CARD32 pad07; + CARD32 pad08; +} xTestFakeAckEvent; + +/* + * These are the definitions for key/button motion input actions. + */ +typedef struct { + CARD8 header; /* which device, key up/down */ + CARD8 keycode; /* which key/button to move */ + CARD16 delay_time; /* how long to delay (in ms) */ +} XTestKeyInfo; + +/* + * This is the definition for pointer jump input actions. + */ +typedef struct { + CARD8 header; /* which pointer */ + CARD8 pad1; /* unused padding byte */ + CARD16 jumpx; /* x coord to jump to */ + CARD16 jumpy; /* y coord to jump to */ + CARD16 delay_time; /* how long to delay (in ms) */ +} XTestJumpInfo; + +/* + * These are the definitions for pointer relative motion input + * actions. + * + * The sign bits for the x and y relative motions are contained + * in the header byte. The x and y relative motions are packed + * into one byte to make things fit in 32 bits. If the relative + * motion range is larger than +/-15, use the pointer jump action. + */ + +typedef struct { + CARD8 header; /* which pointer */ + CARD8 motion_data; /* x,y relative motion */ + CARD16 delay_time; /* how long to delay (in ms) */ +} XTestMotionInfo; + +/* + * These are the definitions for a long delay input action. It is + * used when more than XTestSHORT_DELAY_TIME milliseconds of delay + * (approximately one minute) is needed. + * + * The device ID for a delay is always set to XTestDELAY_DEVICE_ID. + * This guarantees that a header byte with a value of 0 is not + * a valid header, so it can be used as a flag to indicate that + * there are no more input actions in an XTestInputAction event. + */ + +typedef struct { + CARD8 header; /* always XTestDELAY_DEVICE_ID */ + CARD8 pad1; /* unused padding byte */ + CARD16 pad2; /* unused padding word */ + CARD32 delay_time; /* how long to delay (in ms) */ +} XTestDelayInfo; + +#endif /* _XTESTEXT1PROTO_H */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xtestproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xtestproto.h new file mode 100644 index 0000000000000000000000000000000000000000..9595ac1ff8eb61e0faa93acc791571b90f4d7616 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xtestproto.h @@ -0,0 +1,124 @@ +/* + +Copyright 1992, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +*/ + +#ifndef _XTESTPROTO_H_ +#define _XTESTPROTO_H_ + +#include + +#define Window CARD32 +#define Time CARD32 +#define Cursor CARD32 + +#define X_XTestGetVersion 0 +#define X_XTestCompareCursor 1 +#define X_XTestFakeInput 2 +#define X_XTestGrabControl 3 + +typedef struct { + CARD8 reqType; /* always XTestReqCode */ + CARD8 xtReqType; /* always X_XTestGetVersion */ + CARD16 length; + CARD8 majorVersion; + CARD8 pad; + CARD16 minorVersion; +} xXTestGetVersionReq; +#define sz_xXTestGetVersionReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + CARD8 majorVersion; + CARD16 sequenceNumber; + CARD32 length; + CARD16 minorVersion; + CARD16 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xXTestGetVersionReply; +#define sz_xXTestGetVersionReply 32 + +typedef struct { + CARD8 reqType; /* always XTestReqCode */ + CARD8 xtReqType; /* always X_XTestCompareCursor */ + CARD16 length; + Window window; + Cursor cursor; +} xXTestCompareCursorReq; +#define sz_xXTestCompareCursorReq 12 + +typedef struct { + BYTE type; /* X_Reply */ + BOOL same; + CARD16 sequenceNumber; + CARD32 length; + CARD32 pad0; + CARD32 pad1; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; +} xXTestCompareCursorReply; +#define sz_xXTestCompareCursorReply 32 + +/* used only on the client side */ +typedef struct { + CARD8 reqType; /* always XTestReqCode */ + CARD8 xtReqType; /* always X_XTestFakeInput */ + CARD16 length; + BYTE type; + BYTE detail; + CARD16 pad0; + Time time; + Window root; + CARD32 pad1; + CARD32 pad2; + INT16 rootX, rootY; + CARD32 pad3; + CARD16 pad4; + CARD8 pad5; + CARD8 deviceid; +} xXTestFakeInputReq; +#define sz_xXTestFakeInputReq 36 + +typedef struct { + CARD8 reqType; /* always XTestReqCode */ + CARD8 xtReqType; /* always X_XTestGrabControl */ + CARD16 length; + BOOL impervious; + CARD8 pad0; + CARD8 pad1; + CARD8 pad2; +} xXTestGrabControlReq; +#define sz_xXTestGrabControlReq 8 + +#undef Window +#undef Time +#undef Cursor + +#endif /* _XTESTPROTO_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xwaylandproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xwaylandproto.h new file mode 100644 index 0000000000000000000000000000000000000000..49f048d24c821dda62a038555d7bbbb39d856bcb --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/extensions/xwaylandproto.h @@ -0,0 +1,63 @@ +/* + * Copyright © 2022 Red Hat, Inc. + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that copyright + * notice and this permission notice appear in supporting documentation, and + * that the name of the copyright holders not be used in advertising or + * publicity pertaining to distribution of the software without specific, + * written prior permission. The copyright holders make no representations + * about the suitability of this software for any purpose. It is provided "as + * is" without express or implied warranty. + * + * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE + * OF THIS SOFTWARE. + */ + +#ifndef _XWAYLAND_PROTO_H_ +#define _XWAYLAND_PROTO_H_ + +#include + +#define XWAYLAND_EXTENSION_NAME "XWAYLAND" +#define XWAYLAND_EXTENSION_MAJOR 1 +#define XWAYLAND_EXTENSION_MINOR 0 + +/* Request opcodes */ +#define X_XwlQueryVersion 0 + +#define XwlNumberRequests 1 +#define XwlNumberErrors 0 +#define XwlNumberEvents 0 + +typedef struct { + CARD8 reqType; + CARD8 xwlReqType; + CARD16 length; + CARD16 majorVersion; + CARD16 minorVersion; +} xXwlQueryVersionReq; +#define sz_xXwlQueryVersionReq 8 + +typedef struct { + BYTE type; /* X_Reply */ + BYTE pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD16 majorVersion; + CARD16 minorVersion; + CARD32 pad2; + CARD32 pad3; + CARD32 pad4; + CARD32 pad5; + CARD32 pad6; +} xXwlQueryVersionReply; +#define sz_xXwlQueryVersionReply 32 + +#endif diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/fonts/FS.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/fonts/FS.h new file mode 100644 index 0000000000000000000000000000000000000000..fa4ff806a2f6543c0733c6f02137a564c05703a4 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/fonts/FS.h @@ -0,0 +1,129 @@ +/* + * Copyright 1990, 1991 Network Computing Devices; + * Portions Copyright 1987 by Digital Equipment Corporation + * + * Permission to use, copy, modify, distribute, and sell this software and + * its documentation for any purpose is hereby granted without fee, provided + * that the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the names of Network Computing Devices or Digital + * not be used in advertising or publicity pertaining to distribution + * of the software without specific, written prior permission. + * Network Computing Devices and Digital make no representations + * about the suitability of this software for any purpose. It is provided + * "as is" without express or implied warranty. + * + * NETWORK COMPUTING DEVICES AND DIGITAL DISCLAIM ALL WARRANTIES WITH + * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES + * OR DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR + * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS + * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF + * THIS SOFTWARE. + */ + +/* + +Portions Copyright 1987, 1994, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +*/ + +#ifndef _FS_H_ +#define _FS_H_ + +#include +#include + +#define FS_PROTOCOL 2 +#define FS_PROTOCOL_MINOR 0 + +#ifndef X_PROTOCOL +/* protocol families */ +#define FamilyInternet 0 +#define FamilyDECnet 1 +#define FamilyChaos 2 +#define FamilyInternet6 6 + + +typedef unsigned int FSDrawDirection; +#endif + +#ifndef None +#define None 0L +#endif + +#define LeftToRightDrawDirection 0 +#define RightToLeftDrawDirection 1 + +/* font info flags */ +#define FontInfoAllCharsExist (1L << 0) +#define FontInfoInkInside (1L << 1) +#define FontInfoHorizontalOverlap (1L << 2) + +/* auth status flags */ +#define AuthSuccess 0 +#define AuthContinue 1 +#define AuthBusy 2 +#define AuthDenied 3 + +/* property types */ +#define PropTypeString 0 +#define PropTypeUnsigned 1 +#define PropTypeSigned 2 + +#ifndef LSBFirst +/* byte order */ +#define LSBFirst 0 +#define MSBFirst 1 +#endif + +/* event masks */ +#define CatalogueChangeNotifyMask (1L << 0) +#define FontChangeNotifyMask (1L << 1) + +/* errors */ +#define FSSuccess -1 +#define FSBadRequest 0 +#define FSBadFormat 1 +#define FSBadFont 2 +#define FSBadRange 3 +#define FSBadEventMask 4 +#define FSBadAccessContext 5 +#define FSBadIDChoice 6 +#define FSBadName 7 +#define FSBadResolution 8 +#define FSBadAlloc 9 +#define FSBadLength 10 +#define FSBadImplementation 11 + +#define FirstExtensionError 128 +#define LastExtensionError 255 + +/* events */ +#define KeepAlive 0 +#define CatalogueChangeNotify 1 +#define FontChangeNotify 2 +#define FSLASTEvent 3 + +#endif /* _FS_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/fonts/FSproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/fonts/FSproto.h new file mode 100644 index 0000000000000000000000000000000000000000..3cdb8348860036cda0f0541ce898166fc0e3c8b7 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/fonts/FSproto.h @@ -0,0 +1,814 @@ +/* + +Copyright 1990, 1991, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + + * Copyright 1990, 1991 Network Computing Devices; + * Portions Copyright 1987 by Digital Equipment Corporation + * + * Permission to use, copy, modify, distribute, and sell this software and + * its documentation for any purpose is hereby granted without fee, provided + * that the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the names of Network Computing Devices, or Digital + * not be used in advertising or publicity pertaining to distribution + * of the software without specific, written prior permission. + * + * NETWORK COMPUTING DEVICES, AND DIGITAL DISCLAIM ALL WARRANTIES WITH + * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES, + * OR DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR + * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS + * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF + * THIS SOFTWARE. + */ + +#ifndef _FS_PROTO_H_ +#define _FS_PROTO_H_ + +#include + +#define sz_fsPropOffset 20 +#define sz_fsPropInfo 8 +#define sz_fsResolution 6 + +#define sz_fsChar2b 2 +#define sz_fsChar2b_version1 2 +#define sz_fsOffset32 8 +#define sz_fsRange 4 + +#define sz_fsXCharInfo 12 +#define sz_fsXFontInfoHeader 40 + +#define sz_fsConnClientPrefix 8 +#define sz_fsConnSetup 12 +#define sz_fsConnSetupExtra 8 +#define sz_fsConnSetupAccept 12 + +/* request sizes */ +#define sz_fsReq 4 +#define sz_fsListExtensionsReq 4 +#define sz_fsResourceReq 8 + +#define sz_fsNoopReq 4 +#define sz_fsListExtensionReq 4 +#define sz_fsQueryExtensionReq 4 +#define sz_fsListCataloguesReq 12 +#define sz_fsSetCataloguesReq 4 +#define sz_fsGetCataloguesReq 4 +#define sz_fsSetEventMaskReq 8 +#define sz_fsGetEventMaskReq 4 +#define sz_fsCreateACReq 8 +#define sz_fsFreeACReq 8 +#define sz_fsSetAuthorizationReq 8 +#define sz_fsSetResolutionReq 4 +#define sz_fsGetResolutionReq 4 +#define sz_fsListFontsReq 12 +#define sz_fsListFontsWithXInfoReq 12 +#define sz_fsOpenBitmapFontReq 16 +#define sz_fsQueryXInfoReq 8 +#define sz_fsQueryXExtents8Req 12 +#define sz_fsQueryXExtents16Req 12 +#define sz_fsQueryXBitmaps8Req 16 +#define sz_fsQueryXBitmaps16Req 16 +#define sz_fsCloseReq 8 + +/* reply sizes */ +#define sz_fsReply 8 +#define sz_fsGenericReply 8 + +#define sz_fsListExtensionsReply 8 +#define sz_fsQueryExtensionReply 20 +#define sz_fsListCataloguesReply 16 +#define sz_fsGetCataloguesReply 8 +#define sz_fsGetEventMaskReply 12 +#define sz_fsCreateACReply 12 +#define sz_fsGetResolutionReply 8 +#define sz_fsListFontsReply 16 +#define sz_fsListFontsWithXInfoReply (12 + sz_fsXFontInfoHeader) +#define sz_fsOpenBitmapFontReply 16 +#define sz_fsQueryXInfoReply (8 + sz_fsXFontInfoHeader) +#define sz_fsQueryXExtents8Reply 12 +#define sz_fsQueryXExtents16Reply 12 +#define sz_fsQueryXBitmaps8Reply 20 +#define sz_fsQueryXBitmaps16Reply 20 + +#define sz_fsError 16 +#define sz_fsEvent 12 +#define sz_fsKeepAliveEvent 12 + +#define fsTrue 1 +#define fsFalse 0 + +/* temp decls */ +#define Mask CARD32 +#define Font CARD32 +#define AccContext CARD32 + +typedef CARD32 fsTimestamp; + +#ifdef NOTDEF /* in fsmasks.h */ +typedef CARD32 fsBitmapFormat; +typedef CARD32 fsBitmapFormatMask; +#endif + +#define sz_fsBitmapFormat 4 + +typedef struct { + INT16 left, + right; + INT16 width; + INT16 ascent, + descent; + CARD16 attributes; +} fsXCharInfo; + +typedef struct { + CARD8 high; + CARD8 low; +} fsChar2b; + +typedef struct { + CARD8 low; + CARD8 high; +} fsChar2b_version1; + +typedef struct { + CARD8 min_char_high; + CARD8 min_char_low; + CARD8 max_char_high; + CARD8 max_char_low; +} fsRange; + +typedef struct { + CARD32 position; + CARD32 length; +} fsOffset32; + +typedef struct { + fsOffset32 name; + fsOffset32 value; + CARD8 type; + BYTE pad0; + CARD16 pad1; +} fsPropOffset; + +typedef struct { + CARD32 num_offsets; + CARD32 data_len; + /* offsets */ + /* data */ +} fsPropInfo; + +typedef struct { + CARD16 x_resolution; + CARD16 y_resolution; + CARD16 point_size; +} fsResolution; + + +typedef struct { + CARD32 flags; + CARD8 char_range_min_char_high; + CARD8 char_range_min_char_low; + CARD8 char_range_max_char_high; + CARD8 char_range_max_char_low; + + CARD8 draw_direction; + CARD8 pad; + CARD8 default_char_high; + CARD8 default_char_low; + INT16 min_bounds_left; + INT16 min_bounds_right; + + INT16 min_bounds_width; + INT16 min_bounds_ascent; + INT16 min_bounds_descent; + CARD16 min_bounds_attributes; + + INT16 max_bounds_left; + INT16 max_bounds_right; + INT16 max_bounds_width; + INT16 max_bounds_ascent; + + INT16 max_bounds_descent; + CARD16 max_bounds_attributes; + INT16 font_ascent; + INT16 font_descent; + /* propinfo */ +} fsXFontInfoHeader; + + +/* requests */ + +typedef struct { + BYTE byteOrder; + CARD8 num_auths; + CARD16 major_version; + CARD16 minor_version; + CARD16 auth_len; + /* auth data */ +} fsConnClientPrefix; + +typedef struct { + CARD16 status; + CARD16 major_version; + CARD16 minor_version; + CARD8 num_alternates; + CARD8 auth_index; + CARD16 alternate_len; + CARD16 auth_len; + /* alternates */ + /* auth data */ +} fsConnSetup; + +typedef struct { + CARD32 length; + CARD16 status; + CARD16 pad; + /* more auth data */ +} fsConnSetupExtra; + +typedef struct { + CARD32 length; + CARD16 max_request_len; + CARD16 vendor_len; + CARD32 release_number; + /* vendor string */ +} fsConnSetupAccept; + +typedef struct { + CARD8 reqType; + CARD8 data; + CARD16 length; +} fsReq; + +/* + * The fsFakeReq structure is never used in the protocol; it is prepended + * to incoming packets when setting up a connection so we can index + * through InitialVector. To avoid alignment problems, it is padded + * to the size of a word on the largest machine this code runs on. + * Hence no sz_fsFakeReq constant is necessary. + */ +typedef struct { + CARD8 reqType; + CARD8 data; + CARD16 length; + CARD32 pad; /* to fill out to multiple of 64 bits */ +} fsFakeReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length; + Font id; +} fsResourceReq; + +typedef fsReq fsNoopReq; +typedef fsReq fsListExtensionsReq; + +typedef struct { + CARD8 reqType; + BYTE nbytes; + CARD16 length; + /* name */ +} fsQueryExtensionReq; + +typedef struct { + CARD8 reqType; + CARD8 data; + CARD16 length; + CARD32 maxNames; + CARD16 nbytes; + CARD16 pad2; + /* pattern */ +} fsListCataloguesReq; + +typedef struct { + CARD8 reqType; + BYTE num_catalogues; + CARD16 length; + /* catalogues */ +} fsSetCataloguesReq; + +typedef fsReq fsGetCataloguesReq; + +typedef struct { + CARD8 reqType; + CARD8 ext_opcode; + CARD16 length; + Mask event_mask; +} fsSetEventMaskReq; + +typedef struct { + CARD8 reqType; + CARD8 ext_opcode; + CARD16 length; +} fsGetEventMaskReq; + +typedef struct { + CARD8 reqType; + BYTE num_auths; + CARD16 length; + AccContext acid; + /* auth protocols */ +} fsCreateACReq; + +typedef fsResourceReq fsFreeACReq; +typedef fsResourceReq fsSetAuthorizationReq; + +typedef struct { + CARD8 reqType; + BYTE num_resolutions; + CARD16 length; + /* resolutions */ +} fsSetResolutionReq; + +typedef fsReq fsGetResolutionReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length; + CARD32 maxNames; + CARD16 nbytes; + CARD16 pad2; + /* pattern */ +} fsListFontsReq; + +typedef fsListFontsReq fsListFontsWithXInfoReq; + +typedef struct { + CARD8 reqType; + BYTE pad; + CARD16 length; + Font fid; + fsBitmapFormatMask format_mask; + fsBitmapFormat format_hint; + /* pattern */ +} fsOpenBitmapFontReq; + +typedef fsResourceReq fsQueryXInfoReq; + +typedef struct { + CARD8 reqType; + BOOL range; + CARD16 length; + Font fid; + CARD32 num_ranges; + /* list of chars */ +} fsQueryXExtents8Req; + +typedef fsQueryXExtents8Req fsQueryXExtents16Req; + +typedef struct { + CARD8 reqType; + BOOL range; + CARD16 length; + Font fid; + fsBitmapFormat format; + CARD32 num_ranges; + /* list of chars */ +} fsQueryXBitmaps8Req; + +typedef fsQueryXBitmaps8Req fsQueryXBitmaps16Req; + +typedef fsResourceReq fsCloseReq; + + +/* replies */ +typedef struct { + BYTE type; + BYTE data1; + CARD16 sequenceNumber; + CARD32 length; +} fsGenericReply; + +typedef struct { + BYTE type; + CARD8 nExtensions; + CARD16 sequenceNumber; + CARD32 length; + /* extension names */ +} fsListExtensionsReply; + +typedef struct { + BYTE type; + CARD8 present; + CARD16 sequenceNumber; + CARD32 length; + CARD16 major_version; + CARD16 minor_version; + CARD8 major_opcode; + CARD8 first_event; + CARD8 num_events; + CARD8 first_error; + CARD8 num_errors; + CARD8 pad1; + CARD16 pad2; +} fsQueryExtensionReply; + +typedef struct { + BYTE type; + BYTE pad; + CARD16 sequenceNumber; + CARD32 length; + CARD32 num_replies; + CARD32 num_catalogues; + /* catalog names */ +} fsListCataloguesReply; + +typedef struct { + BYTE type; + CARD8 num_catalogues; + CARD16 sequenceNumber; + CARD32 length; + /* catalogue names */ +} fsGetCataloguesReply; + +typedef struct { + BYTE type; + BYTE pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 event_mask; +} fsGetEventMaskReply; + +typedef struct { + BYTE type; + CARD8 auth_index; + CARD16 sequenceNumber; + CARD32 length; + CARD16 status; + CARD16 pad; + /* auth data */ +} fsCreateACReply; + +typedef struct { + CARD32 length; + CARD16 status; + CARD16 pad; + /* auth data */ +} fsCreateACExtraReply; + +typedef struct { + BYTE type; + CARD8 num_resolutions; + CARD16 sequenceNumber; + CARD32 length; + /* resolutions */ +} fsGetResolutionReply; + +typedef struct { + BYTE type; + BYTE pad1; + CARD16 sequenceNumber; + CARD32 length; + CARD32 following; + CARD32 nFonts; + /* font names */ +} fsListFontsReply; + +/* + * this one is messy. the reply itself is variable length (unknown + * number of replies) and the contents of each is variable (unknown + * number of properties) + * + */ + +typedef struct { + BYTE type; + CARD8 nameLength; /* 0 is end-of-reply */ + CARD16 sequenceNumber; + CARD32 length; + CARD32 nReplies; + CARD32 font_header_flags; + CARD8 font_hdr_char_range_min_char_high; + CARD8 font_hdr_char_range_min_char_low; + CARD8 font_hdr_char_range_max_char_high; + CARD8 font_hdr_char_range_max_char_low; + CARD8 font_header_draw_direction; + CARD8 font_header_pad; + CARD8 font_header_default_char_high; + CARD8 font_header_default_char_low; + INT16 font_header_min_bounds_left; + INT16 font_header_min_bounds_right; + INT16 font_header_min_bounds_width; + INT16 font_header_min_bounds_ascent; + INT16 font_header_min_bounds_descent; + CARD16 font_header_min_bounds_attributes; + INT16 font_header_max_bounds_left; + INT16 font_header_max_bounds_right; + INT16 font_header_max_bounds_width; + INT16 font_header_max_bounds_ascent; + INT16 font_header_max_bounds_descent; + CARD16 font_header_max_bounds_attributes; + INT16 font_header_font_ascent; + INT16 font_header_font_descent; + /* propinfo */ + /* name */ +} fsListFontsWithXInfoReply; + +typedef struct { + BYTE type; + CARD8 otherid_valid; + CARD16 sequenceNumber; + CARD32 length; + CARD32 otherid; + BYTE cachable; + BYTE pad1; + CARD16 pad2; +} fsOpenBitmapFontReply; + +typedef struct { + BYTE type; + CARD8 pad0; + CARD16 sequenceNumber; + CARD32 length; + CARD32 font_header_flags; + CARD8 font_hdr_char_range_min_char_high; + CARD8 font_hdr_char_range_min_char_low; + CARD8 font_hdr_char_range_max_char_high; + CARD8 font_hdr_char_range_max_char_low; + CARD8 font_header_draw_direction; + CARD8 font_header_pad; + CARD8 font_header_default_char_high; + CARD8 font_header_default_char_low; + INT16 font_header_min_bounds_left; + INT16 font_header_min_bounds_right; + INT16 font_header_min_bounds_width; + INT16 font_header_min_bounds_ascent; + INT16 font_header_min_bounds_descent; + CARD16 font_header_min_bounds_attributes; + INT16 font_header_max_bounds_left; + INT16 font_header_max_bounds_right; + INT16 font_header_max_bounds_width; + INT16 font_header_max_bounds_ascent; + INT16 font_header_max_bounds_descent; + CARD16 font_header_max_bounds_attributes; + INT16 font_header_font_ascent; + INT16 font_header_font_descent; + /* propinfo */ +} fsQueryXInfoReply; + +typedef struct { + BYTE type; + CARD8 pad0; + CARD16 sequenceNumber; + CARD32 length; + CARD32 num_extents; + /* extents */ +} fsQueryXExtents8Reply; + +typedef fsQueryXExtents8Reply fsQueryXExtents16Reply; + +typedef struct { + BYTE type; + CARD8 pad0; + CARD16 sequenceNumber; + CARD32 length; + CARD32 replies_hint; + CARD32 num_chars; + CARD32 nbytes; + /* offsets */ + /* glyphs */ +} fsQueryXBitmaps8Reply; + +typedef fsQueryXBitmaps8Reply fsQueryXBitmaps16Reply; + +typedef union { + fsGenericReply generic; + fsListExtensionsReply extensions; + fsGetResolutionReply getres; +} fsReply; + +/* errors */ +typedef struct { + BYTE type; + BYTE request; + CARD16 sequenceNumber; + CARD32 length; + fsTimestamp timestamp; + CARD8 major_opcode; + CARD8 minor_opcode; + CARD16 pad; +} fsError; + +typedef struct { + BYTE type; + BYTE request; + CARD16 sequenceNumber; + CARD32 length; + fsTimestamp timestamp; + CARD8 major_opcode; + CARD8 minor_opcode; + CARD16 pad; +} fsRequestError; + +typedef struct { + BYTE type; + BYTE request; + CARD16 sequenceNumber; + CARD32 length; + fsTimestamp timestamp; + CARD8 major_opcode; + CARD8 minor_opcode; + CARD16 pad; + fsBitmapFormat format; +} fsFormatError; + +typedef struct { + BYTE type; + BYTE request; + CARD16 sequenceNumber; + CARD32 length; + fsTimestamp timestamp; + CARD8 major_opcode; + CARD8 minor_opcode; + CARD16 pad; + Font fontid; +} fsFontError; + +typedef struct { + BYTE type; + BYTE request; + CARD16 sequenceNumber; + CARD32 length; + fsTimestamp timestamp; + CARD8 major_opcode; + CARD8 minor_opcode; + CARD16 pad; + fsRange range; +} fsRangeError; + +typedef struct { + BYTE type; + BYTE request; + CARD16 sequenceNumber; + CARD32 length; + fsTimestamp timestamp; + CARD8 major_opcode; + CARD8 minor_opcode; + CARD16 pad; + Mask event_mask; +} fsEventMaskError; + +typedef struct { + BYTE type; + BYTE request; + CARD16 sequenceNumber; + CARD32 length; + fsTimestamp timestamp; + CARD8 major_opcode; + CARD8 minor_opcode; + CARD16 pad; + AccContext acid; +} fsAccessContextError; + +typedef struct { + BYTE type; + BYTE request; + CARD16 sequenceNumber; + CARD32 length; + fsTimestamp timestamp; + CARD8 major_opcode; + CARD8 minor_opcode; + CARD16 pad; + Font fontid; +} fsIDChoiceError; + +typedef struct { + BYTE type; + BYTE request; + CARD16 sequenceNumber; + CARD32 length; + fsTimestamp timestamp; + CARD8 major_opcode; + CARD8 minor_opcode; + CARD16 pad; +} fsNameError; + +typedef struct { + BYTE type; + BYTE request; + CARD16 sequenceNumber; + CARD32 length; + fsTimestamp timestamp; + CARD8 major_opcode; + CARD8 minor_opcode; + fsResolution resolution; +} fsResolutionError; + +typedef struct { + BYTE type; + BYTE request; + CARD16 sequenceNumber; + CARD32 length; + fsTimestamp timestamp; + CARD8 major_opcode; + CARD8 minor_opcode; + CARD16 pad; +} fsAllocError; + +typedef struct { + BYTE type; + BYTE request; + CARD16 sequenceNumber; + CARD32 length; + fsTimestamp timestamp; + CARD8 major_opcode; + CARD8 minor_opcode; + CARD16 pad; + CARD32 bad_length; +} fsLengthError; + +typedef struct { + BYTE type; + BYTE request; + CARD16 sequenceNumber; + CARD32 length; + fsTimestamp timestamp; + CARD8 major_opcode; + CARD8 minor_opcode; + CARD16 pad; +} fsImplementationError; + +/* events */ +typedef struct { + BYTE type; + BYTE event_code; + CARD16 sequenceNumber; + CARD32 length; + fsTimestamp timestamp; +} fsKeepAliveEvent; + +typedef struct { + BYTE type; + BYTE event_code; + CARD16 sequenceNumber; + CARD32 length; + fsTimestamp timestamp; + BOOL added; + BOOL deleted; + CARD16 pad; +} fsCatalogueChangeNotifyEvent; + +typedef fsCatalogueChangeNotifyEvent fsFontChangeNotifyEvent; + +typedef fsCatalogueChangeNotifyEvent fsEvent; + +/* reply codes */ +#define FS_Reply 0 /* normal reply */ +#define FS_Error 1 /* error */ +#define FS_Event 2 + +/* request codes */ +#define FS_Noop 0 +#define FS_ListExtensions 1 +#define FS_QueryExtension 2 +#define FS_ListCatalogues 3 +#define FS_SetCatalogues 4 +#define FS_GetCatalogues 5 +#define FS_SetEventMask 6 +#define FS_GetEventMask 7 +#define FS_CreateAC 8 +#define FS_FreeAC 9 +#define FS_SetAuthorization 10 +#define FS_SetResolution 11 +#define FS_GetResolution 12 +#define FS_ListFonts 13 +#define FS_ListFontsWithXInfo 14 +#define FS_OpenBitmapFont 15 +#define FS_QueryXInfo 16 +#define FS_QueryXExtents8 17 +#define FS_QueryXExtents16 18 +#define FS_QueryXBitmaps8 19 +#define FS_QueryXBitmaps16 20 +#define FS_CloseFont 21 + +/* restore decls */ +#undef Mask +#undef Font +#undef AccContext + +#endif /* _FS_PROTO_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/fonts/font.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/fonts/font.h new file mode 100644 index 0000000000000000000000000000000000000000..b596ba253961a73075ccda9f6f7f34e771538119 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/fonts/font.h @@ -0,0 +1,168 @@ +/*********************************************************** +Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Digital not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + +******************************************************************/ + +#ifndef FONT_H +#define FONT_H + +#include + +#ifndef BitmapFormatByteOrderMask +#include "fsmasks.h" +#endif + +/* data structures */ +#ifndef _XTYPEDEF_FONTPTR +typedef struct _Font *FontPtr; +#define _XTYPEDEF_FONTPTR +#endif + +typedef struct _FontInfo *FontInfoPtr; +typedef struct _FontProp *FontPropPtr; +typedef struct _ExtentInfo *ExtentInfoPtr; +typedef struct _FontPathElement *FontPathElementPtr; + +#ifndef _XTYPEDEF_CHARINFOPTR +typedef struct _CharInfo *CharInfoPtr; +#define _XTYPEDEF_CHARINFOPTR +#endif + +typedef struct _FontNames *FontNamesPtr; +typedef struct _FontResolution *FontResolutionPtr; + +#define NullCharInfo ((CharInfoPtr) 0) +#define NullFont ((FontPtr) 0) +#define NullFontInfo ((FontInfoPtr) 0) + + /* draw direction */ +#define LeftToRight 0 +#define RightToLeft 1 +#define BottomToTop 2 +#define TopToBottom 3 +typedef int DrawDirection; + +#define NO_SUCH_CHAR -1 + + +#define FontAliasType 0x1000 + +#define AllocError 80 +#define StillWorking 81 +#define FontNameAlias 82 +#define BadFontName 83 +#define Suspended 84 +#define Successful 85 +#define BadFontPath 86 +#define BadCharRange 87 +#define BadFontFormat 88 +#define FPEResetFailed 89 /* for when an FPE reset won't work */ + +/* OpenFont flags */ +#define FontLoadInfo 0x0001 +#define FontLoadProps 0x0002 +#define FontLoadMetrics 0x0004 +#define FontLoadBitmaps 0x0008 +#define FontLoadAll 0x000f +#define FontOpenSync 0x0010 +#define FontReopen 0x0020 + +/* Query flags */ +#define LoadAll 0x1 +#define FinishRamge 0x2 +#define EightBitFont 0x4 +#define SixteenBitFont 0x8 + +/* Glyph Caching Modes */ +#define CACHING_OFF 0 +#define CACHE_16_BIT_GLYPHS 1 +#define CACHE_ALL_GLYPHS 2 +#define DEFAULT_GLYPH_CACHING_MODE CACHE_16_BIT_GLYPHS +extern int glyphCachingMode; + +struct _Client; + +extern int StartListFontsWithInfo( + struct _Client * /*client*/, + int /*length*/, + unsigned char * /*pattern*/, + int /*max_names*/ +); + +extern FontNamesPtr MakeFontNamesRecord( + unsigned /* size */ +); + +extern void FreeFontNames( + FontNamesPtr /* pFN*/ +); + +extern int AddFontNamesName( + FontNamesPtr /* names */, + char * /* name */, + int /* length */ +); + +#if 0 /* unused */ +extern int FontToFSError(); +extern FontResolutionPtr GetClientResolution(); +#endif + +typedef struct _FontPatternCache *FontPatternCachePtr; + +extern FontPatternCachePtr MakeFontPatternCache ( + void +); + +extern void FreeFontPatternCache ( + FontPatternCachePtr /* cache */ +); + +extern void EmptyFontPatternCache ( + FontPatternCachePtr /* cache */ +); + +extern void CacheFontPattern ( + FontPatternCachePtr /* cache */, + const char * /* pattern */, + int /* patlen */, + FontPtr /* pFont */ +); +extern _X_EXPORT FontResolutionPtr GetClientResolutions( + int * /* num */ +); + +extern FontPtr FindCachedFontPattern ( + FontPatternCachePtr /* cache */, + const char * /* pattern */, + int /* patlen */ +); + +extern void RemoveCachedFontPattern ( + FontPatternCachePtr /* cache */, + FontPtr /* pFont */ +); + +typedef enum { + Linear8Bit, TwoD8Bit, Linear16Bit, TwoD16Bit +} FontEncoding; + +#endif /* FONT_H */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/fonts/fontproto.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/fonts/fontproto.h new file mode 100644 index 0000000000000000000000000000000000000000..23b8df6020d2691e9050182f61ed24f35d384abe --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/fonts/fontproto.h @@ -0,0 +1,94 @@ +/*********************************************************** + +Copyright (c) 1999 The XFree86 Project Inc. + +All Rights Reserved. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The XFree86 Project +Inc. shall not be used in advertising or otherwise to promote the +sale, use or other dealings in this Software without prior written +authorization from The XFree86 Project Inc.. + +*/ +#ifndef _FONTPROTO_H +#define _FONTPROTO_H + +#include + +/* Externally provided functions required by libXfont */ + +extern _X_EXPORT int RegisterFPEFunctions ( + NameCheckFunc name_func, + InitFpeFunc init_func, + FreeFpeFunc free_func, + ResetFpeFunc reset_func, + OpenFontFunc open_func, + CloseFontFunc close_func, + ListFontsFunc list_func, + StartLfwiFunc start_lfwi_func, + NextLfwiFunc next_lfwi_func, + WakeupFpeFunc wakeup_func, + ClientDiedFunc client_died, + LoadGlyphsFunc load_glyphs, + StartLaFunc start_list_alias_func, + NextLaFunc next_list_alias_func, + SetPathFunc set_path_func); + +extern _X_EXPORT int GetDefaultPointSize ( void ); + +extern _X_EXPORT int init_fs_handlers ( FontPathElementPtr fpe, + BlockHandlerProcPtr block_handler); +extern _X_EXPORT void remove_fs_handlers ( FontPathElementPtr fpe, + BlockHandlerProcPtr block_handler, + Bool all ); + +extern _X_EXPORT int client_auth_generation ( ClientPtr client ); + +#ifndef ___CLIENTSIGNAL_DEFINED___ +#define ___CLIENTSIGNAL_DEFINED___ +extern Bool ClientSignal ( ClientPtr client ); +#endif /* ___CLIENTSIGNAL_DEFINED___ */ + +extern _X_EXPORT void DeleteFontClientID ( Font id ); +extern _X_EXPORT Font GetNewFontClientID ( void ); +extern _X_EXPORT int StoreFontClientFont ( FontPtr pfont, Font id ); +extern _X_EXPORT void FontFileRegisterFpeFunctions ( void ); +extern _X_EXPORT void FontFileCheckRegisterFpeFunctions ( void ); + +extern Bool XpClientIsBitmapClient ( ClientPtr client ); +extern Bool XpClientIsPrintClient( ClientPtr client, FontPathElementPtr fpe ); +extern void PrinterFontRegisterFpeFunctions ( void ); + +extern void fs_register_fpe_functions ( void ); +extern void check_fs_register_fpe_functions ( void ); + +/* util/private.c */ +extern FontPtr CreateFontRec (void); +extern void DestroyFontRec (FontPtr font); +extern Bool _FontSetNewPrivate (FontPtr /* pFont */, + int /* n */, + void * /* ptr */); +extern int AllocateFontPrivateIndex (void); +extern void ResetFontPrivateIndex (void); + +/* Type1/t1funcs.c */ +extern void Type1RegisterFontFileFunctions(void); +extern void CIDRegisterFontFileFunctions(void); + +/* Speedo/spfuncs.c */ +extern void SpeedoRegisterFontFileFunctions(void); + +/* FreeType/ftfuncs.c */ +extern void FreeTypeRegisterFontFileFunctions(void); + +#endif diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/fonts/fontstruct.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/fonts/fontstruct.h new file mode 100644 index 0000000000000000000000000000000000000000..a327ef9dd50399ca10803eb83d17d352e570aa32 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/fonts/fontstruct.h @@ -0,0 +1,297 @@ +/*********************************************************** +Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Digital not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + +******************************************************************/ + +#ifndef FONTSTR_H +#define FONTSTR_H + +#include +#include "font.h" +#include +#include + +/* + * This version of the server font data structure is only for describing + * the in memory data structure. The file structure is not necessarily a + * copy of this. That is up to the compiler and the OS layer font loading + * machinery. + */ + +#define GLYPHPADOPTIONS 4 /* 1, 2, 4, or 8 */ + +typedef struct _FontProp { + long name; + long value; /* assumes ATOM is not larger than INT32 */ +} FontPropRec; + +typedef struct _FontResolution { + unsigned short x_resolution; + unsigned short y_resolution; + unsigned short point_size; +} FontResolutionRec; + +typedef struct _ExtentInfo { + DrawDirection drawDirection; + int fontAscent; + int fontDescent; + int overallAscent; + int overallDescent; + int overallWidth; + int overallLeft; + int overallRight; +} ExtentInfoRec; + +typedef struct _CharInfo { + xCharInfo metrics; /* info preformatted for Queries */ + char *bits; /* pointer to glyph image */ +} CharInfoRec; + +/* + * Font is created at font load time. It is specific to a single encoding. + * e.g. not all of the glyphs in a font may be part of a single encoding. + */ + +typedef struct _FontInfo { + unsigned short firstCol; + unsigned short lastCol; + unsigned short firstRow; + unsigned short lastRow; + unsigned short defaultCh; + unsigned int noOverlap:1; + unsigned int terminalFont:1; + unsigned int constantMetrics:1; + unsigned int constantWidth:1; + unsigned int inkInside:1; + unsigned int inkMetrics:1; + unsigned int allExist:1; + unsigned int drawDirection:2; + unsigned int cachable:1; + unsigned int anamorphic:1; + short maxOverlap; + short pad; + xCharInfo maxbounds; + xCharInfo minbounds; + xCharInfo ink_maxbounds; + xCharInfo ink_minbounds; + short fontAscent; + short fontDescent; + int nprops; + FontPropPtr props; + char *isStringProp; +} FontInfoRec; + +typedef struct _Font { + int refcnt; + FontInfoRec info; + char bit; + char byte; + char glyph; + char scan; + fsBitmapFormat format; + int (*get_glyphs) (FontPtr /* font */, + unsigned long /* count */, + unsigned char * /* chars */, + FontEncoding /* encoding */, + unsigned long * /* count */, + CharInfoPtr * /* glyphs */); + int (*get_metrics) (FontPtr /* font */, + unsigned long /* count */, + unsigned char * /* chars */, + FontEncoding /* encoding */, + unsigned long * /* count */, + xCharInfo ** /* glyphs */); + void (*unload_font) (FontPtr /* font */); + void (*unload_glyphs) (FontPtr /* font */); + FontPathElementPtr fpe; + void *svrPrivate; + void *fontPrivate; + void *fpePrivate; + int maxPrivate; + void **devPrivates; +} FontRec; + +#define FontGetPrivate(pFont,n) ((n) > (pFont)->maxPrivate ? (void *) 0 : \ + (pFont)->devPrivates[n]) + +#define FontSetPrivate(pFont,n,ptr) ((n) > (pFont)->maxPrivate ? \ + _FontSetNewPrivate (pFont, n, ptr) : \ + ((((pFont)->devPrivates[n] = (ptr)) != 0) || TRUE)) + +typedef struct _FontNames { + int nnames; + int size; + int *length; + char **names; +} FontNamesRec; + + +/* External view of font paths */ +typedef struct _FontPathElement { + int name_length; +#if FONT_PATH_ELEMENT_NAME_CONST + const +#endif + char *name; + int type; + int refcount; + void *private; +} FontPathElementRec; + +typedef Bool (*NameCheckFunc) (const char *name); +typedef int (*InitFpeFunc) (FontPathElementPtr fpe); +typedef int (*FreeFpeFunc) (FontPathElementPtr fpe); +typedef int (*ResetFpeFunc) (FontPathElementPtr fpe); +typedef int (*OpenFontFunc) ( void *client, + FontPathElementPtr fpe, + Mask flags, + const char* name, + int namelen, + fsBitmapFormat format, + fsBitmapFormatMask fmask, + XID id, + FontPtr* pFont, + char** aliasName, + FontPtr non_cachable_font); +typedef void (*CloseFontFunc) (FontPathElementPtr fpe, FontPtr pFont); +typedef int (*ListFontsFunc) (void *client, + FontPathElementPtr fpe, + const char* pat, + int len, + int max, + FontNamesPtr names); + +typedef int (*StartLfwiFunc) (void *client, + FontPathElementPtr fpe, + const char* pat, + int len, + int max, + void ** privatep); + +typedef int (*NextLfwiFunc) (void *client, + FontPathElementPtr fpe, + char** name, + int* namelen, + FontInfoPtr* info, + int* numFonts, + void *private); + +typedef int (*WakeupFpeFunc) (FontPathElementPtr fpe, + unsigned long* LastSelectMask); + +typedef void (*ClientDiedFunc) (void *client, + FontPathElementPtr fpe); + +typedef int (*LoadGlyphsFunc) (void *client, + FontPtr pfont, + Bool range_flag, + unsigned int nchars, + int item_size, + unsigned char* data); + +typedef int (*StartLaFunc) (void *client, + FontPathElementPtr fpe, + const char* pat, + int len, + int max, + void ** privatep); + +typedef int (*NextLaFunc) (void *client, + FontPathElementPtr fpe, + char** namep, + int* namelenp, + char** resolvedp, + int* resolvedlenp, + void *private); + +typedef void (*SetPathFunc)(void); + +typedef struct _FPEFunctions { + NameCheckFunc name_check; + InitFpeFunc init_fpe; + ResetFpeFunc reset_fpe; + FreeFpeFunc free_fpe; + OpenFontFunc open_font; + CloseFontFunc close_font; + ListFontsFunc list_fonts; + StartLaFunc start_list_fonts_and_aliases; + NextLaFunc list_next_font_or_alias; + StartLfwiFunc start_list_fonts_with_info; + NextLfwiFunc list_next_font_with_info; + WakeupFpeFunc wakeup_fpe; + ClientDiedFunc client_died; + /* for load_glyphs, range_flag = 0 -> + nchars = # of characters in data + item_size = bytes/char + data = list of characters + range_flag = 1 -> + nchars = # of fsChar2b's in data + item_size is ignored + data = list of fsChar2b's */ + LoadGlyphsFunc load_glyphs; + SetPathFunc set_path_hook; +} FPEFunctionsRec, FPEFunctions; + +/* + * Various macros for computing values based on contents of + * the above structures + */ + +#define GLYPHWIDTHPIXELS(pci) \ + ((pci)->metrics.rightSideBearing - (pci)->metrics.leftSideBearing) + +#define GLYPHHEIGHTPIXELS(pci) \ + ((pci)->metrics.ascent + (pci)->metrics.descent) + +#define GLYPHWIDTHBYTES(pci) (((GLYPHWIDTHPIXELS(pci))+7) >> 3) + +#define GLYPHWIDTHPADDED(bc) (((bc)+7) & ~0x7) + +#define BYTES_PER_ROW(bits, nbytes) \ + ((nbytes) == 1 ? (((bits)+7)>>3) /* pad to 1 byte */ \ + :(nbytes) == 2 ? ((((bits)+15)>>3)&~1) /* pad to 2 bytes */ \ + :(nbytes) == 4 ? ((((bits)+31)>>3)&~3) /* pad to 4 bytes */ \ + :(nbytes) == 8 ? ((((bits)+63)>>3)&~7) /* pad to 8 bytes */ \ + : 0) + +#define BYTES_FOR_GLYPH(ci,pad) (GLYPHHEIGHTPIXELS(ci) * \ + BYTES_PER_ROW(GLYPHWIDTHPIXELS(ci),pad)) +/* + * Macros for computing different bounding boxes for fonts; from + * the font protocol + */ + +#define FONT_MAX_ASCENT(pi) ((pi)->fontAscent > (pi)->ink_maxbounds.ascent ? \ + (pi)->fontAscent : (pi)->ink_maxbounds.ascent) +#define FONT_MAX_DESCENT(pi) ((pi)->fontDescent > (pi)->ink_maxbounds.descent ? \ + (pi)->fontDescent : (pi)->ink_maxbounds.descent) +#define FONT_MAX_HEIGHT(pi) (FONT_MAX_ASCENT(pi) + FONT_MAX_DESCENT(pi)) +#define FONT_MIN_LEFT(pi) ((pi)->ink_minbounds.leftSideBearing < 0 ? \ + (pi)->ink_minbounds.leftSideBearing : 0) +#define FONT_MAX_RIGHT(pi) ((pi)->ink_maxbounds.rightSideBearing > \ + (pi)->ink_maxbounds.characterWidth ? \ + (pi)->ink_maxbounds.rightSideBearing : \ + (pi)->ink_maxbounds.characterWidth) +#define FONT_MAX_WIDTH(pi) (FONT_MAX_RIGHT(pi) - FONT_MIN_LEFT(pi)) + +#include "fontproto.h" + +#endif /* FONTSTR_H */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/fonts/fsmasks.h b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/fonts/fsmasks.h new file mode 100644 index 0000000000000000000000000000000000000000..861790235c4d3a3bb2ae5bd2eee0dbf28f29f881 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/include/X11/fonts/fsmasks.h @@ -0,0 +1,97 @@ +/* + * Copyright 1990, 1991 Network Computing Devices; + * Portions Copyright 1987 by Digital Equipment Corporation + * + * Permission to use, copy, modify, distribute, and sell this software and + * its documentation for any purpose is hereby granted without fee, provided + * that the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the names of Network Computing Devices or Digital + * not be used in advertising or publicity pertaining to distribution + * of the software without specific, written prior permission. + * Network Computing Devices and Digital make no representations + * about the suitability of this software for any purpose. It is provided + * "as is" without express or implied warranty. + * + * NETWORK COMPUTING DEVICES AND DIGITAL DISCLAIM ALL WARRANTIES WITH + * REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES + * OR DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL + * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR + * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS + * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF + * THIS SOFTWARE. + */ + +/* + +Portions Copyright 1987, 1994, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +*/ + + +/* + * masks & values used by the font lib and the font server + */ + +#ifndef _FSMASKS_H_ +#define _FSMASKS_H_ + +#include + +/* font format macros */ +#define BitmapFormatByteOrderMask (1L << 0) +#define BitmapFormatBitOrderMask (1L << 1) +#define BitmapFormatImageRectMask (3L << 2) +#define BitmapFormatScanlinePadMask (3L << 8) +#define BitmapFormatScanlineUnitMask (3L << 12) + +#define BitmapFormatByteOrderLSB (0) +#define BitmapFormatByteOrderMSB (1L << 0) +#define BitmapFormatBitOrderLSB (0) +#define BitmapFormatBitOrderMSB (1L << 1) + +#define BitmapFormatImageRectMin (0L << 2) +#define BitmapFormatImageRectMaxWidth (1L << 2) +#define BitmapFormatImageRectMax (2L << 2) + +#define BitmapFormatScanlinePad8 (0L << 8) +#define BitmapFormatScanlinePad16 (1L << 8) +#define BitmapFormatScanlinePad32 (2L << 8) +#define BitmapFormatScanlinePad64 (3L << 8) + +#define BitmapFormatScanlineUnit8 (0L << 12) +#define BitmapFormatScanlineUnit16 (1L << 12) +#define BitmapFormatScanlineUnit32 (2L << 12) +#define BitmapFormatScanlineUnit64 (3L << 12) + +#define BitmapFormatMaskByte (1L << 0) +#define BitmapFormatMaskBit (1L << 1) +#define BitmapFormatMaskImageRectangle (1L << 2) +#define BitmapFormatMaskScanLinePad (1L << 3) +#define BitmapFormatMaskScanLineUnit (1L << 4) + +typedef CARD32 fsBitmapFormat; +typedef CARD32 fsBitmapFormatMask; + +#endif /* _FSMASKS_H_ */ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/about.json b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/about.json new file mode 100644 index 0000000000000000000000000000000000000000..39b76247fe72cdf692af227fd8a58b9a93a1db63 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/about.json @@ -0,0 +1,130 @@ +{ + "channels": [ + "https://repo.anaconda.com/pkgs/main" + ], + "conda_build_version": "24.1.2", + "conda_version": "24.1.2", + "dev_url": "https://gitlab.freedesktop.org/xorg/proto/xorgproto", + "doc_url": "https://gitlab.freedesktop.org/xorg/proto/xorgproto", + "env_vars": { + "CIO_TEST": "" + }, + "extra": { + "copy_test_source_files": true, + "final": true, + "flow_run_id": "af31ccde-d9c4-4092-88fc-ffbd455029a7", + "recipe-maintainers": [ + "pkgw" + ], + "remote_url": "git@github.com:AnacondaRecipes/xorg-xorgproto-feedstock.git", + "sha": "edf34136111283bca6f43abd1ac347df754626ff" + }, + "home": "https://www.x.org/", + "identifiers": [], + "keywords": [], + "license": "MIT", + "license_family": "MIT", + "license_file": "licenses/", + "root_pkgs": [ + "_libgcc_mutex 0.1 main", + "_openmp_mutex 5.1 1_gnu", + "archspec 0.2.1 pyhd3eb1b0_0", + "boltons 23.0.0 py39h06a4308_0", + "brotli-python 1.0.9 py39h6a678d5_7", + "bzip2 1.0.8 h7b6447c_0", + "c-ares 1.19.1 h5eee18b_0", + "charset-normalizer 2.0.4 pyhd3eb1b0_0", + "conda-content-trust 0.2.0 py39h06a4308_0", + "conda-package-handling 2.2.0 py39h06a4308_0", + "conda-package-streaming 0.9.0 py39h06a4308_0", + "fmt 9.1.0 hdb19cb5_0", + "icu 73.1 h6a678d5_0", + "idna 3.4 py39h06a4308_0", + "jsonpatch 1.32 pyhd3eb1b0_0", + "jsonpointer 2.1 pyhd3eb1b0_0", + "krb5 1.20.1 h143b758_1", + "ld_impl_linux-64 2.38 h1181459_1", + "libarchive 3.6.2 h6ac8c49_2", + "libev 4.33 h7f8727e_1", + "libffi 3.4.4 h6a678d5_0", + "libgcc-ng 11.2.0 h1234567_1", + "libgomp 11.2.0 h1234567_1", + "libnghttp2 1.57.0 h2d74bed_0", + "libsolv 0.7.24 he621ea3_0", + "libssh2 1.10.0 hdbd6064_2", + "libstdcxx-ng 11.2.0 h1234567_1", + "libxml2 2.10.4 hf1b16e4_1", + "lz4-c 1.9.4 h6a678d5_0", + "ncurses 6.4 h6a678d5_0", + "packaging 23.1 py39h06a4308_0", + "pcre2 10.42 hebb0a14_0", + "pluggy 1.0.0 py39h06a4308_1", + "pybind11-abi 4 hd3eb1b0_1", + "pycosat 0.6.6 py39h5eee18b_0", + "pycparser 2.21 pyhd3eb1b0_0", + "pysocks 1.7.1 py39h06a4308_0", + "python 3.9.18 h955ad1f_0", + "readline 8.2 h5eee18b_0", + "reproc 14.2.4 h295c915_1", + "reproc-cpp 14.2.4 h295c915_1", + "ruamel.yaml 0.17.21 py39h5eee18b_0", + "ruamel.yaml.clib 0.2.6 py39h5eee18b_1", + "sqlite 3.41.2 h5eee18b_0", + "tk 8.6.12 h1ccaba5_0", + "tqdm 4.65.0 py39hb070fc8_0", + "wheel 0.41.2 py39h06a4308_0", + "yaml-cpp 0.8.0 h6a678d5_0", + "zlib 1.2.13 h5eee18b_0", + "zstandard 0.19.0 py39h5eee18b_0", + "zstd 1.5.5 hc292b87_0", + "attrs 23.1.0 py39h06a4308_0", + "beautifulsoup4 4.12.2 py39h06a4308_0", + "ca-certificates 2023.12.12 h06a4308_0", + "certifi 2024.2.2 py39h06a4308_0", + "cffi 1.16.0 py39h5eee18b_0", + "chardet 4.0.0 py39h06a4308_1003", + "click 8.1.7 py39h06a4308_0", + "conda 24.1.2 py39h06a4308_0", + "conda-build 24.1.2 py39h06a4308_0", + "conda-index 0.4.0 pyhd3eb1b0_0", + "conda-libmamba-solver 24.1.0 pyhd3eb1b0_0", + "cryptography 42.0.2 py39hdda0065_0", + "distro 1.8.0 py39h06a4308_0", + "filelock 3.13.1 py39h06a4308_0", + "jinja2 3.1.3 py39h06a4308_0", + "jsonschema 4.19.2 py39h06a4308_0", + "jsonschema-specifications 2023.7.1 py39h06a4308_0", + "libcurl 8.5.0 h251f7ec_0", + "libedit 3.1.20230828 h5eee18b_0", + "liblief 0.12.3 h6a678d5_0", + "libmamba 1.5.6 haf1ee3a_0", + "libmambapy 1.5.6 py39h2dafd23_0", + "markupsafe 2.1.3 py39h5eee18b_0", + "menuinst 2.0.2 py39h06a4308_0", + "more-itertools 10.1.0 py39h06a4308_0", + "openssl 3.0.13 h7f8727e_0", + "patch 2.7.6 h7b6447c_1001", + "patchelf 0.17.2 h6a678d5_0", + "pip 23.3.1 py39h06a4308_0", + "pkginfo 1.9.6 py39h06a4308_0", + "platformdirs 3.10.0 py39h06a4308_0", + "psutil 5.9.0 py39h5eee18b_0", + "py-lief 0.12.3 py39h6a678d5_0", + "pyopenssl 24.0.0 py39h06a4308_0", + "python-libarchive-c 2.9 pyhd3eb1b0_1", + "pytz 2023.3.post1 py39h06a4308_0", + "pyyaml 6.0.1 py39h5eee18b_0", + "referencing 0.30.2 py39h06a4308_0", + "requests 2.31.0 py39h06a4308_1", + "rpds-py 0.10.6 py39hb02cf49_0", + "setuptools 68.2.2 py39h06a4308_0", + "soupsieve 2.5 py39h06a4308_0", + "tomli 2.0.1 py39h06a4308_0", + "tzdata 2023d h04d1e81_0", + "urllib3 2.1.0 py39h06a4308_1", + "xz 5.4.5 h5eee18b_0", + "yaml 0.2.5 h7b6447c_0" + ], + "summary": "X.org protocol headers", + "tags": [] +} \ No newline at end of file diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/files b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/files new file mode 100644 index 0000000000000000000000000000000000000000..eec096542fa810cae701f62ddbd7a8edf340e1ca --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/files @@ -0,0 +1,226 @@ +include/GL/glxint.h +include/GL/glxmd.h +include/GL/glxproto.h +include/GL/glxtokens.h +include/GL/internal/glcore.h +include/X11/DECkeysym.h +include/X11/HPkeysym.h +include/X11/Sunkeysym.h +include/X11/X.h +include/X11/XF86keysym.h +include/X11/XWDFile.h +include/X11/Xalloca.h +include/X11/Xarch.h +include/X11/Xatom.h +include/X11/Xdefs.h +include/X11/Xfuncproto.h +include/X11/Xfuncs.h +include/X11/Xmd.h +include/X11/Xos.h +include/X11/Xos_r.h +include/X11/Xosdefs.h +include/X11/Xpoll.h +include/X11/Xproto.h +include/X11/Xprotostr.h +include/X11/Xthreads.h +include/X11/Xw32defs.h +include/X11/Xwindows.h +include/X11/Xwinsock.h +include/X11/ap_keysym.h +include/X11/dri/xf86dri.h +include/X11/dri/xf86driproto.h +include/X11/dri/xf86dristr.h +include/X11/extensions/EVI.h +include/X11/extensions/EVIproto.h +include/X11/extensions/XI.h +include/X11/extensions/XI2.h +include/X11/extensions/XI2proto.h +include/X11/extensions/XIproto.h +include/X11/extensions/XKB.h +include/X11/extensions/XKBproto.h +include/X11/extensions/XKBsrv.h +include/X11/extensions/XKBstr.h +include/X11/extensions/XResproto.h +include/X11/extensions/Xv.h +include/X11/extensions/XvMC.h +include/X11/extensions/XvMCproto.h +include/X11/extensions/Xvproto.h +include/X11/extensions/ag.h +include/X11/extensions/agproto.h +include/X11/extensions/applewmconst.h +include/X11/extensions/applewmproto.h +include/X11/extensions/bigreqsproto.h +include/X11/extensions/bigreqstr.h +include/X11/extensions/composite.h +include/X11/extensions/compositeproto.h +include/X11/extensions/cup.h +include/X11/extensions/cupproto.h +include/X11/extensions/damageproto.h +include/X11/extensions/damagewire.h +include/X11/extensions/dbe.h +include/X11/extensions/dbeproto.h +include/X11/extensions/dmx.h +include/X11/extensions/dmxproto.h +include/X11/extensions/dpmsconst.h +include/X11/extensions/dpmsproto.h +include/X11/extensions/dri2proto.h +include/X11/extensions/dri2tokens.h +include/X11/extensions/dri3proto.h +include/X11/extensions/ge.h +include/X11/extensions/geproto.h +include/X11/extensions/lbx.h +include/X11/extensions/lbxproto.h +include/X11/extensions/mitmiscconst.h +include/X11/extensions/mitmiscproto.h +include/X11/extensions/multibufconst.h +include/X11/extensions/multibufproto.h +include/X11/extensions/panoramiXproto.h +include/X11/extensions/presentproto.h +include/X11/extensions/presenttokens.h +include/X11/extensions/randr.h +include/X11/extensions/randrproto.h +include/X11/extensions/recordconst.h +include/X11/extensions/recordproto.h +include/X11/extensions/recordstr.h +include/X11/extensions/render.h +include/X11/extensions/renderproto.h +include/X11/extensions/saver.h +include/X11/extensions/saverproto.h +include/X11/extensions/secur.h +include/X11/extensions/securproto.h +include/X11/extensions/shapeconst.h +include/X11/extensions/shapeproto.h +include/X11/extensions/shapestr.h +include/X11/extensions/shm.h +include/X11/extensions/shmproto.h +include/X11/extensions/shmstr.h +include/X11/extensions/syncconst.h +include/X11/extensions/syncproto.h +include/X11/extensions/syncstr.h +include/X11/extensions/xcmiscproto.h +include/X11/extensions/xcmiscstr.h +include/X11/extensions/xf86bigfont.h +include/X11/extensions/xf86bigfproto.h +include/X11/extensions/xf86bigfstr.h +include/X11/extensions/xf86dga.h +include/X11/extensions/xf86dga1const.h +include/X11/extensions/xf86dga1proto.h +include/X11/extensions/xf86dga1str.h +include/X11/extensions/xf86dgaconst.h +include/X11/extensions/xf86dgaproto.h +include/X11/extensions/xf86dgastr.h +include/X11/extensions/xf86vm.h +include/X11/extensions/xf86vmproto.h +include/X11/extensions/xf86vmstr.h +include/X11/extensions/xfixesproto.h +include/X11/extensions/xfixeswire.h +include/X11/extensions/xtestconst.h +include/X11/extensions/xtestext1const.h +include/X11/extensions/xtestext1proto.h +include/X11/extensions/xtestproto.h +include/X11/extensions/xwaylandproto.h +include/X11/fonts/FS.h +include/X11/fonts/FSproto.h +include/X11/fonts/font.h +include/X11/fonts/fontproto.h +include/X11/fonts/fontstruct.h +include/X11/fonts/fsmasks.h +include/X11/keysym.h +include/X11/keysymdef.h +share/doc/bigreqsproto/bigreq.xml +share/doc/fontsproto/fsproto.xml +share/doc/kbproto/XKBproto-1.svg +share/doc/kbproto/XKBproto-10.svg +share/doc/kbproto/XKBproto-11.svg +share/doc/kbproto/XKBproto-2.svg +share/doc/kbproto/XKBproto-3.svg +share/doc/kbproto/XKBproto-4.svg +share/doc/kbproto/XKBproto-5.svg +share/doc/kbproto/XKBproto-6.svg +share/doc/kbproto/XKBproto-7.svg +share/doc/kbproto/XKBproto-8.svg +share/doc/kbproto/XKBproto-9.svg +share/doc/kbproto/acknowledgements.xml +share/doc/kbproto/appA.xml +share/doc/kbproto/appB.xml +share/doc/kbproto/appC.xml +share/doc/kbproto/appD.xml +share/doc/kbproto/ch01.xml +share/doc/kbproto/ch02.xml +share/doc/kbproto/ch03.xml +share/doc/kbproto/ch04.xml +share/doc/kbproto/ch05.xml +share/doc/kbproto/ch06.xml +share/doc/kbproto/ch07.xml +share/doc/kbproto/ch08.xml +share/doc/kbproto/ch09.xml +share/doc/kbproto/ch10.xml +share/doc/kbproto/ch11.xml +share/doc/kbproto/ch12.xml +share/doc/kbproto/ch13.xml +share/doc/kbproto/ch14.xml +share/doc/kbproto/ch15.xml +share/doc/kbproto/ch16.xml +share/doc/kbproto/xkbproto.xml +share/doc/recordproto/record.xml +share/doc/scrnsaverproto/saver.xml +share/doc/xcmiscproto/xc-misc.xml +share/doc/xextproto/appendix.xml +share/doc/xextproto/appgrp.xml +share/doc/xextproto/dbe.xml +share/doc/xextproto/dpms.xml +share/doc/xextproto/evi.xml +share/doc/xextproto/geproto.xml +share/doc/xextproto/lbx.xml +share/doc/xextproto/multibuf.xml +share/doc/xextproto/security.xml +share/doc/xextproto/shape.xml +share/doc/xextproto/shm.xml +share/doc/xextproto/sync.xml +share/doc/xextproto/tog-cup.xml +share/doc/xextproto/xtest.xml +share/doc/xorgproto/compositeproto.txt +share/doc/xorgproto/damageproto.txt +share/doc/xorgproto/dri2proto.txt +share/doc/xorgproto/dri3proto.txt +share/doc/xorgproto/fixesproto.txt +share/doc/xorgproto/presentproto.txt +share/doc/xorgproto/randrproto.txt +share/doc/xorgproto/renderproto.txt +share/doc/xorgproto/resproto.txt +share/doc/xorgproto/xv-protocol-v2.txt +share/doc/xorgproto/xwaylandproto.txt +share/doc/xproto/encoding.xml +share/doc/xproto/glossary.xml +share/doc/xproto/keysyms.xml +share/doc/xproto/sect1-9.xml +share/doc/xproto/x11protocol.xml +share/pkgconfig/applewmproto.pc +share/pkgconfig/bigreqsproto.pc +share/pkgconfig/compositeproto.pc +share/pkgconfig/damageproto.pc +share/pkgconfig/dmxproto.pc +share/pkgconfig/dpmsproto.pc +share/pkgconfig/dri2proto.pc +share/pkgconfig/dri3proto.pc +share/pkgconfig/fixesproto.pc +share/pkgconfig/fontsproto.pc +share/pkgconfig/glproto.pc +share/pkgconfig/inputproto.pc +share/pkgconfig/kbproto.pc +share/pkgconfig/presentproto.pc +share/pkgconfig/randrproto.pc +share/pkgconfig/recordproto.pc +share/pkgconfig/renderproto.pc +share/pkgconfig/resourceproto.pc +share/pkgconfig/scrnsaverproto.pc +share/pkgconfig/videoproto.pc +share/pkgconfig/xcmiscproto.pc +share/pkgconfig/xextproto.pc +share/pkgconfig/xf86bigfontproto.pc +share/pkgconfig/xf86dgaproto.pc +share/pkgconfig/xf86driproto.pc +share/pkgconfig/xf86vidmodeproto.pc +share/pkgconfig/xineramaproto.pc +share/pkgconfig/xproto.pc +share/pkgconfig/xwaylandproto.pc diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/git b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/git new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/has_prefix b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/has_prefix new file mode 100644 index 0000000000000000000000000000000000000000..76c36239452447f2a49cd6cc4d9dd95df5be79eb --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/has_prefix @@ -0,0 +1,29 @@ +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/applewmproto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/bigreqsproto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/compositeproto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/damageproto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/dmxproto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/dpmsproto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/dri2proto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/dri3proto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/fixesproto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/fontsproto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/glproto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/inputproto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/kbproto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/presentproto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/randrproto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/recordproto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/renderproto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/resourceproto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/scrnsaverproto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/videoproto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/xcmiscproto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/xextproto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/xf86bigfontproto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/xf86dgaproto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/xf86driproto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/xf86vidmodeproto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/xineramaproto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/xproto.pc +/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl text share/pkgconfig/xwaylandproto.pc diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/hash_input.json b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/hash_input.json new file mode 100644 index 0000000000000000000000000000000000000000..9ef81326568d1e39add297edabaf960ddd01a020 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/hash_input.json @@ -0,0 +1,6 @@ +{ + "channel_targets": "defaults", + "c_compiler": "gcc", + "target_platform": "linux-64", + "c_compiler_version": "11.2.0" +} \ No newline at end of file diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/index.json b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/index.json new file mode 100644 index 0000000000000000000000000000000000000000..fb4f690597e8347203a66532712d94df4a621e93 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/index.json @@ -0,0 +1,46 @@ +{ + "arch": "x86_64", + "build": "h5eee18b_1", + "build_number": 1, + "constrains": [ + "xorg-xextproto <0.0.0a", + "xorg-xproto <0.0.0a", + "xorg-recordproto <0.0.0a", + "xorg-randrproto <0.0.0a", + "xorg-xf86dgaproto <0.0.0a", + "xorg-xf86vidmodeproto <0.0.0a", + "xorg-xcmiscproto <0.0.0a", + "xorg-applewmproto <0.0.0a", + "xorg-damageproto <0.0.0a", + "xorg-xf86driproto <0.0.0a", + "xorg-renderproto <0.0.0a", + "xorg-kbproto <0.0.0a", + "xorg-glproto <0.0.0a", + "xorg-inputproto <0.0.0a", + "xorg-scrnsaverproto <0.0.0a", + "xorg-compositeproto <0.0.0a", + "xorg-videoproto <0.0.0a", + "xorg-xwaylandproto <0.0.0a", + "xorg-dri3proto <0.0.0a", + "xorg-fixesproto <0.0.0a", + "xorg-dri2proto <0.0.0a", + "xorg-resourceproto <0.0.0a", + "xorg-dpmsproto <0.0.0a", + "xorg-xineramaproto <0.0.0a", + "xorg-fontsproto <0.0.0a", + "xorg-dmxproto <0.0.0a", + "xorg-xf86bigfontproto <0.0.0a", + "xorg-presentproto <0.0.0a", + "xorg-bigreqsproto <0.0.0a" + ], + "depends": [ + "libgcc-ng >=11.2.0" + ], + "license": "MIT", + "license_family": "MIT", + "name": "xorg-xorgproto", + "platform": "linux", + "subdir": "linux-64", + "timestamp": 1746046234466, + "version": "2024.1" +} \ No newline at end of file diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-applewmproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-applewmproto new file mode 100644 index 0000000000000000000000000000000000000000..be403fdec7fe5dec8d396199fc3e2135c13191dc --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-applewmproto @@ -0,0 +1,27 @@ +/************************************************************************** + +Copyright (c) 2002-2009 Apple, Inc. +All Rights Reserved. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sub license, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice (including the +next paragraph) shall be included in all copies or substantial portions +of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. +IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +**************************************************************************/ + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-bigreqsproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-bigreqsproto new file mode 100644 index 0000000000000000000000000000000000000000..142f2fab0b46336b9853e485a163ed5b9134bc52 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-bigreqsproto @@ -0,0 +1,21 @@ +Copyright 1992, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-compositeproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-compositeproto new file mode 100644 index 0000000000000000000000000000000000000000..b541db83f8dba561a9a04d2b3c222d097007bcba --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-compositeproto @@ -0,0 +1,41 @@ +Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice (including the next +paragraph) shall be included in all copies or substantial portions of the +Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. + +Copyright © 2003 Keith Packard + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation, and that the name of Keith Packard not be used in +advertising or publicity pertaining to distribution of the software without +specific, written prior permission. Keith Packard makes no +representations about the suitability of this software for any purpose. It +is provided "as is" without express or implied warranty. + +KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO +EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR +CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-damageproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-damageproto new file mode 100644 index 0000000000000000000000000000000000000000..d14c75a80c883fd083c307bf800a379647e25ea8 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-damageproto @@ -0,0 +1,21 @@ +Copyright © 2001,2003 Keith Packard +Copyright © 2007 Eric Anholt + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation, and that the name of Keith Packard not be used in +advertising or publicity pertaining to distribution of the software without +specific, written prior permission. Keith Packard makes no +representations about the suitability of this software for any purpose. It +is provided "as is" without express or implied warranty. + +KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO +EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR +CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-dmxproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-dmxproto new file mode 100644 index 0000000000000000000000000000000000000000..7ea03ea2aea2764b868c6f6fd2e16adf78898123 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-dmxproto @@ -0,0 +1,24 @@ +Copyright 2002-2004 Red Hat Inc., Durham, North Carolina. + +All Rights Reserved. + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation on the rights to use, copy, modify, merge, +publish, distribute, sublicense, and/or sell copies of the Software, +and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice (including the +next paragraph) shall be included in all copies or substantial +portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NON-INFRINGEMENT. IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS +BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-dri2proto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-dri2proto new file mode 100644 index 0000000000000000000000000000000000000000..a99b75ab4928c82dd383c2822d1c0ad303ab83ea --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-dri2proto @@ -0,0 +1,29 @@ +Copyright © 2007 Red Hat, Inc. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Soft- +ware"), to deal in the Software without restriction, including without +limitation the rights to use, copy, modify, merge, publish, distribute, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, provided that the above copyright +notice(s) and this permission notice appear in all copies of the Soft- +ware and that both the above copyright notice(s) and this permission +notice appear in supporting documentation. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL- +ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY +RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN +THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSE- +QUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFOR- +MANCE OF THIS SOFTWARE. + +Except as contained in this notice, the name of a copyright holder shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization of +the copyright holder. + +Authors: + Kristian Høgsberg (krh@redhat.com) diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-dri3proto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-dri3proto new file mode 100644 index 0000000000000000000000000000000000000000..8dcf1d489b5c9dccf284f4810aa9ee19c38a4788 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-dri3proto @@ -0,0 +1,19 @@ +Copyright © 2013 Keith Packard + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that copyright +notice and this permission notice appear in supporting documentation, and +that the name of the copyright holders not be used in advertising or +publicity pertaining to distribution of the software without specific, +written prior permission. The copyright holders make no representations +about the suitability of this software for any purpose. It is provided "as +is" without express or implied warranty. + +THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO +EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR +CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE +OF THIS SOFTWARE. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-evieproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-evieproto new file mode 100644 index 0000000000000000000000000000000000000000..316475fbba6dffceb948b95f2577275a1c5c50da --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-evieproto @@ -0,0 +1,20 @@ +Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice (including the next +paragraph) shall be included in all copies or substantial portions of the +Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-fixesproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-fixesproto new file mode 100644 index 0000000000000000000000000000000000000000..c8114fef98b78857abd00a5e7fdebf541774e440 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-fixesproto @@ -0,0 +1,42 @@ +Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved. +Copyright 2010 Red Hat, Inc. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice (including the next +paragraph) shall be included in all copies or substantial portions of the +Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. + +Copyright © 2001,2003 Keith Packard + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation, and that the name of Keith Packard not be used in +advertising or publicity pertaining to distribution of the software without +specific, written prior permission. Keith Packard makes no +representations about the suitability of this software for any purpose. It +is provided "as is" without express or implied warranty. + +KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO +EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR +CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-fontcacheproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-fontcacheproto new file mode 100644 index 0000000000000000000000000000000000000000..3e473adcaa8ade1acfa9d49fd019a2672c3755b9 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-fontcacheproto @@ -0,0 +1,24 @@ +Copyright (c) 1998-1999 Shunsuke Akiyama . +All rights reserved. +Copyright (c) 1998-1999 X-TrueType Server Project, All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +SUCH DAMAGE. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-fontsproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-fontsproto new file mode 100644 index 0000000000000000000000000000000000000000..eac45aaedc80e8693fa9b5451ca712c5b785d67d --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-fontsproto @@ -0,0 +1,86 @@ +Copyright 1990, 1991 Network Computing Devices; +Portions Copyright 1987 by Digital Equipment Corporation + +Permission to use, copy, modify, distribute, and sell this software and +its documentation for any purpose is hereby granted without fee, provided +that the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation, and that the names of Network Computing Devices or Digital +not be used in advertising or publicity pertaining to distribution +of the software without specific, written prior permission. +Network Computing Devices and Digital make no representations +about the suitability of this software for any purpose. It is provided +"as is" without express or implied warranty. + +NETWORK COMPUTING DEVICES AND DIGITAL DISCLAIM ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES +OR DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL +DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR +PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS +ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF +THIS SOFTWARE. + + +Copyright 1990, 1991, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + + +Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Digital not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + + +Copyright (c) 1999 The XFree86 Project Inc. + +All Rights Reserved. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The XFree86 Project +Inc. shall not be used in advertising or otherwise to promote the +sale, use or other dealings in this Software without prior written +authorization from The XFree86 Project Inc.. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-glproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-glproto new file mode 100644 index 0000000000000000000000000000000000000000..78b6de44f83664a7bb4f306cc74c75a4c769b3b7 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-glproto @@ -0,0 +1,27 @@ +SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) +Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice including the dates of first publication and +either this permission notice or a reference to +http://oss.sgi.com/projects/FreeB/ +shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF +OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +Except as contained in this notice, the name of Silicon Graphics, Inc. +shall not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization from +Silicon Graphics, Inc. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-inputproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-inputproto new file mode 100644 index 0000000000000000000000000000000000000000..f0b75c0d7f3a52cddc252ae01ccaccb7281ba7fa --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-inputproto @@ -0,0 +1,63 @@ +Copyright 1989, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +Copyright 1989 by Hewlett-Packard Company, Palo Alto, California. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Hewlett-Packard not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +HEWLETT-PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +HEWLETT-PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + +Copyright © 2009 Red Hat, Inc. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice (including the next +paragraph) shall be included in all copies or substantial portions of the +Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-kbproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-kbproto new file mode 100644 index 0000000000000000000000000000000000000000..6f12c2f4d7c659aee131ef4837b8838c5ffdce15 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-kbproto @@ -0,0 +1,22 @@ +Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc. + +Permission to use, copy, modify, and distribute this +software and its documentation for any purpose and without +fee is hereby granted, provided that the above copyright +notice appear in all copies and that both that copyright +notice and this permission notice appear in supporting +documentation, and that the name of Silicon Graphics not be +used in advertising or publicity pertaining to distribution +of the software without specific prior written permission. +Silicon Graphics makes no representation about the suitability +of this software for any purpose. It is provided "as is" +without any express or implied warranty. + +SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS +SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON +GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL +DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE +OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH +THE USE OR PERFORMANCE OF THIS SOFTWARE. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-lg3dproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-lg3dproto new file mode 100644 index 0000000000000000000000000000000000000000..03b626225ee59523b915ed2b26e9387ed187a61e --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-lg3dproto @@ -0,0 +1,22 @@ + +Copyright (c) 2004, Sun Microsystems, Inc. + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +SUN MICROSYSTEMS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of Sun Microsystems shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from Sun Microsystems. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-pmproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-pmproto new file mode 100644 index 0000000000000000000000000000000000000000..3ce03b5d446a0044d05002ab92e5340915494bab --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-pmproto @@ -0,0 +1,24 @@ +Copyright 1996, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-presentproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-presentproto new file mode 100644 index 0000000000000000000000000000000000000000..8dcf1d489b5c9dccf284f4810aa9ee19c38a4788 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-presentproto @@ -0,0 +1,19 @@ +Copyright © 2013 Keith Packard + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that copyright +notice and this permission notice appear in supporting documentation, and +that the name of the copyright holders not be used in advertising or +publicity pertaining to distribution of the software without specific, +written prior permission. The copyright holders make no representations +about the suitability of this software for any purpose. It is provided "as +is" without express or implied warranty. + +THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO +EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR +CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE +OF THIS SOFTWARE. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-printproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-printproto new file mode 100644 index 0000000000000000000000000000000000000000..3b590a8f8301851dde69292e2f9b088c3b4d08b3 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-printproto @@ -0,0 +1,29 @@ +(c) Copyright 1996 Hewlett-Packard Company +(c) Copyright 1996 International Business Machines Corp. +(c) Copyright 1996, Oracle and/or its affiliates. All rights reserved. +(c) Copyright 1996 Novell, Inc. +(c) Copyright 1996 Digital Equipment Corp. +(c) Copyright 1996 Fujitsu Limited +(c) Copyright 1996 Hitachi, Ltd. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the names of the copyright holders shall +not be used in advertising or otherwise to promote the sale, use or other +dealings in this Software without prior written authorization from said +copyright holders. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-randrproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-randrproto new file mode 100644 index 0000000000000000000000000000000000000000..4ae7cc03b2d9e5a638147e275126ff6fba524b5a --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-randrproto @@ -0,0 +1,22 @@ +Copyright © 2000 Compaq Computer Corporation +Copyright © 2002 Hewlett-Packard Company +Copyright © 2006 Intel Corporation +Copyright © 2008 Red Hat, Inc. + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that copyright +notice and this permission notice appear in supporting documentation, and +that the name of the copyright holders not be used in advertising or +publicity pertaining to distribution of the software without specific, +written prior permission. The copyright holders make no representations +about the suitability of this software for any purpose. It is provided "as +is" without express or implied warranty. + +THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO +EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR +CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE +OF THIS SOFTWARE. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-recordproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-recordproto new file mode 100644 index 0000000000000000000000000000000000000000..ae257264d252c397da3bae40ae4a37c159a61585 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-recordproto @@ -0,0 +1,17 @@ +Copyright 1995 Network Computing Devices + +Permission to use, copy, modify, distribute, and sell this software and +its documentation for any purpose is hereby granted without fee, provided +that the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation, and that the name of Network Computing Devices +not be used in advertising or publicity pertaining to distribution +of the software without specific, written prior permission. + +NETWORK COMPUTING DEVICES DISCLAIMs ALL WARRANTIES WITH REGARD TO +THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES BE LIABLE +FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN +AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING +OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-renderproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-renderproto new file mode 100644 index 0000000000000000000000000000000000000000..f330a5d70b054047666062d9b8b137839d4a7e90 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-renderproto @@ -0,0 +1,20 @@ +Copyright © 2000 SuSE, Inc. + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation, and that the name of SuSE not be used in advertising or +publicity pertaining to distribution of the software without specific, +written prior permission. SuSE makes no representations about the +suitability of this software for any purpose. It is provided "as is" +without express or implied warranty. + +SuSE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL SuSE +BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION +OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +Author: Keith Packard, SuSE, Inc. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-resourceproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-resourceproto new file mode 100644 index 0000000000000000000000000000000000000000..d878fd6914b87c191752defc2f7a20bf91bb9461 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-resourceproto @@ -0,0 +1,22 @@ +Copyright (c) 2002 XFree86 Inc + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of the XFree86 Project shall not +be used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from the XFree86 Project. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-scrnsaverproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-scrnsaverproto new file mode 100644 index 0000000000000000000000000000000000000000..8d5f08739ae412a0adda486eefae048db2827edd --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-scrnsaverproto @@ -0,0 +1,24 @@ +Copyright (c) 1992 X Consortium + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of the X Consortium shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from the X Consortium. + +Author: Keith Packard, MIT X Consortium diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-trapproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-trapproto new file mode 100644 index 0000000000000000000000000000000000000000..3ebeac698d5cf35dd3ee6d4dbc04c0f133a5be15 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-trapproto @@ -0,0 +1,18 @@ +Copyright 1987, 1988, 1989, 1990, 1994 by Digital Equipment Corporation, +Maynard, MA + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Digital not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-videoproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-videoproto new file mode 100644 index 0000000000000000000000000000000000000000..28dd80b05cf0c1c4165355a467ecb7e89b72584b --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-videoproto @@ -0,0 +1,63 @@ +Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts, +and the Massachusetts Institute of Technology, Cambridge, Massachusetts. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the names of Digital or MIT not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of the XFree86 Project shall not +be used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from the XFree86 Project. + + +Copyright (c) 2004 The Unichrome Project. All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHOR(S) OR COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-windowswmproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-windowswmproto new file mode 100644 index 0000000000000000000000000000000000000000..55a98f73432cff542f852eac33c2a42988328b98 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-windowswmproto @@ -0,0 +1,23 @@ +Copyright (c) 2002 Apple Computer, Inc. +All Rights Reserved. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sub license, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice (including the +next paragraph) shall be included in all copies or substantial portions +of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. +IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-x11proto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-x11proto new file mode 100644 index 0000000000000000000000000000000000000000..03c358212c7172db1440ab74637fc7aa984dbe98 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-x11proto @@ -0,0 +1,108 @@ +Copyright (c) 1991, Oracle and/or its affiliates. All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice (including the next +paragraph) shall be included in all copies or substantial portions of the +Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. + + +Copyright 1985, 1987, 1988, 1990, 1991, 1993-1996, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +The X Window System is a Trademark of The Open Group. + + +Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Digital not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + + +Copyright 1987 by Apollo Computer Inc., Chelmsford, Massachusetts. +Copyright 1989 by Hewlett-Packard Company. + + All Rights Reserved + +Permission to use, duplicate, change, and distribute this software and +its documentation for any purpose and without fee is granted, provided +that the above copyright notice appear in such copy and that this +copyright notice appear in all supporting documentation, and that the +names of Apollo Computer Inc., the Hewlett-Packard Company, or the X +Consortium not be used in advertising or publicity pertaining to +distribution of the software without written prior permission. + +HEWLETT-PACKARD MAKES NO WARRANTY OF ANY KIND WITH REGARD +TO THIS SOFTWARE, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. Hewlett-Packard shall not be liable for errors +contained herein or direct, indirect, special, incidental or +consequential damages in connection with the furnishing, +performance, or use of this material. + + +Copyright (c) 1999 The XFree86 Project Inc. + +All Rights Reserved. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The XFree86 Project +Inc. shall not be used in advertising or otherwise to promote the +sale, use or other dealings in this Software without prior written +authorization from The XFree86 Project Inc. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-xcmiscproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-xcmiscproto new file mode 100644 index 0000000000000000000000000000000000000000..782a1ecc093600e140a74ee072c284da2027803e --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-xcmiscproto @@ -0,0 +1,21 @@ +Copyright 1993, 1994, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-xextproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-xextproto new file mode 100644 index 0000000000000000000000000000000000000000..23135f95a721ae7c9d3f76a92c556f2db6f7aa7f --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-xextproto @@ -0,0 +1,201 @@ +Copyright 1989, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + + +Copyright (c) 1997 by Silicon Graphics Computer Systems, Inc. +Permission to use, copy, modify, and distribute this +software and its documentation for any purpose and without +fee is hereby granted, provided that the above copyright +notice appear in all copies and that both that copyright +notice and this permission notice appear in supporting +documentation, and that the name of Silicon Graphics not be +used in advertising or publicity pertaining to distribution +of the software without specific prior written permission. +Silicon Graphics makes no representation about the suitability +of this software for any purpose. It is provided "as is" +without any express or implied warranty. +SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS +SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON +GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL +DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE +OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH +THE USE OR PERFORMANCE OF THIS SOFTWARE. + + +Copyright 1992 Network Computing Devices + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation, and that the name of NCD. not be used in advertising or +publicity pertaining to distribution of the software without specific, +written prior permission. NCD. makes no representations about the +suitability of this software for any purpose. It is provided "as is" +without express or implied warranty. + +NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. +BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION +OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + + +Copyright (c) 1994, 1995 Hewlett-Packard Company + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR +THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of the Hewlett-Packard +Company shall not be used in advertising or otherwise to promote the +sale, use or other dealings in this Software without prior written +authorization from the Hewlett-Packard Company. + + +Copyright (c) 1996 Digital Equipment Corporation, Maynard, Massachusetts. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +DIGITAL EQUIPMENT CORPORATION BE LIABLE FOR ANY CLAIM, DAMAGES, INCLUDING, +BUT NOT LIMITED TO CONSEQUENTIAL OR INCIDENTAL DAMAGES, OR OTHER LIABILITY, +WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR +IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of Digital Equipment Corporation +shall not be used in advertising or otherwise to promote the sale, use or other +dealings in this Software without prior written authorization from Digital +Equipment Corporation. + + +Copyright 1988, 1989, 1990, 1994 Network Computing Devices, Inc. + +Permission to use, copy, modify, distribute, and sell this software and +its documentation for any purpose is hereby granted without fee, provided +that the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation, and that the name Network Computing Devices, Inc. not be +used in advertising or publicity pertaining to distribution of this +software without specific, written prior permission. + +THIS SOFTWARE IS PROVIDED `AS-IS'. NETWORK COMPUTING DEVICES, INC., +DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING WITHOUT +LIMITATION ALL IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +PARTICULAR PURPOSE, OR NONINFRINGEMENT. IN NO EVENT SHALL NETWORK +COMPUTING DEVICES, INC., BE LIABLE FOR ANY DAMAGES WHATSOEVER, INCLUDING +SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES, INCLUDING LOSS OF USE, +DATA, OR PROFITS, EVEN IF ADVISED OF THE POSSIBILITY THEREOF, AND +REGARDLESS OF WHETHER IN AN ACTION IN CONTRACT, TORT OR NEGLIGENCE, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + + +Copyright 1991,1993 by Digital Equipment Corporation, Maynard, Massachusetts, +and Olivetti Research Limited, Cambridge, England. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the names of Digital or Olivetti +not be used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL AND OLIVETTI DISCLAIM ALL WARRANTIES WITH REGARD TO THIS +SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS, IN NO EVENT SHALL THEY BE LIABLE FOR ANY SPECIAL, INDIRECT OR +CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF +USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. + + +Copyright 1986, 1987, 1988 by Hewlett-Packard Corporation + +Permission to use, copy, modify, and distribute this +software and its documentation for any purpose and without +fee is hereby granted, provided that the above copyright +notice appear in all copies and that both that copyright +notice and this permission notice appear in supporting +documentation, and that the name of Hewlett-Packard not be used in +advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +Hewlett-Packard makes no representations about the +suitability of this software for any purpose. It is provided +"as is" without express or implied warranty. + +This software is not subject to any license of the American +Telephone and Telegraph Company or of the Regents of the +University of California. + + +Copyright © 2007-2008 Peter Hutterer + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice (including the next +paragraph) shall be included in all copies or substantial portions of the +Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-xf86bigfontproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-xf86bigfontproto new file mode 100644 index 0000000000000000000000000000000000000000..9f1e99973997a509b5da95bb08f3092450cc704c --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-xf86bigfontproto @@ -0,0 +1,20 @@ +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of the XFree86 Project shall not +be used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from the XFree86 Project. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-xf86dgaproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-xf86dgaproto new file mode 100644 index 0000000000000000000000000000000000000000..9f1e99973997a509b5da95bb08f3092450cc704c --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-xf86dgaproto @@ -0,0 +1,20 @@ +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of the XFree86 Project shall not +be used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from the XFree86 Project. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-xf86driproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-xf86driproto new file mode 100644 index 0000000000000000000000000000000000000000..26b6878727821440304c9214db1ca3eef4854e3f --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-xf86driproto @@ -0,0 +1,24 @@ +Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas. +Copyright 2000 VA Linux Systems, Inc. +All Rights Reserved. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sub license, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice (including the +next paragraph) shall be included in all copies or substantial portions +of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. +IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-xf86miscproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-xf86miscproto new file mode 100644 index 0000000000000000000000000000000000000000..9f1e99973997a509b5da95bb08f3092450cc704c --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-xf86miscproto @@ -0,0 +1,20 @@ +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of the XFree86 Project shall not +be used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from the XFree86 Project. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-xf86rushproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-xf86rushproto new file mode 100644 index 0000000000000000000000000000000000000000..9f1e99973997a509b5da95bb08f3092450cc704c --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-xf86rushproto @@ -0,0 +1,20 @@ +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of the XFree86 Project shall not +be used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from the XFree86 Project. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-xf86vidmodeproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-xf86vidmodeproto new file mode 100644 index 0000000000000000000000000000000000000000..bc845c03c81cece535b7e9118abd29d5f253e79f --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-xf86vidmodeproto @@ -0,0 +1,25 @@ +Copyright 1995 Kaleb S. KEITHLEY + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL Kaleb S. KEITHLEY BE LIABLE FOR ANY CLAIM, DAMAGES +OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of Kaleb S. KEITHLEY +shall not be used in advertising or otherwise to promote the sale, use +or other dealings in this Software without prior written authorization +from Kaleb S. KEITHLEY diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-xineramaproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-xineramaproto new file mode 100644 index 0000000000000000000000000000000000000000..54284fc88006902b8acdf505baeed5a4f8caa665 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/licenses/licenses/COPYING-xineramaproto @@ -0,0 +1,45 @@ +Copyright 2003 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + + +Copyright (c) 1991, 1997 Digital Equipment Corporation, Maynard, Massachusetts. +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +DIGITAL EQUIPMENT CORPORATION BE LIABLE FOR ANY CLAIM, DAMAGES, INCLUDING, +BUT NOT LIMITED TO CONSEQUENTIAL OR INCIDENTAL DAMAGES, OR OTHER LIABILITY, +WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR +IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of Digital Equipment Corporation +shall not be used in advertising or otherwise to promote the sale, use or other +dealings in this Software without prior written authorization from Digital +Equipment Corporation. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/paths.json b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/paths.json new file mode 100644 index 0000000000000000000000000000000000000000..4086afe7228554037df6c231ac490dca21b0b56a --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/paths.json @@ -0,0 +1,1419 @@ +{ + "paths": [ + { + "_path": "include/GL/glxint.h", + "path_type": "hardlink", + "sha256": "3dcd6b79b13cc985e513e28e3369bc9e068dc4c6367d4b090a1193f35b5f0baa", + "size_in_bytes": 4696 + }, + { + "_path": "include/GL/glxmd.h", + "path_type": "hardlink", + "sha256": "2bb5fe1a31ad2389b33129831c616c3a496b9f85ec3a5afedd6e740aa8d19097", + "size_in_bytes": 2085 + }, + { + "_path": "include/GL/glxproto.h", + "path_type": "hardlink", + "sha256": "89ffdb6a325e33cee77686e44d2c6a13e419af8cf1c417690e907b5dd0a094a4", + "size_in_bytes": 78531 + }, + { + "_path": "include/GL/glxtokens.h", + "path_type": "hardlink", + "sha256": "8c86b8b9d24ea06d7563012c8099971aa9d4e3db37930abede5dddb294c0d8a9", + "size_in_bytes": 11429 + }, + { + "_path": "include/GL/internal/glcore.h", + "path_type": "hardlink", + "sha256": "3b715ad3957914f560a23fa31cfc835676ba65fb4ea62b36f7030cda7a41dbfa", + "size_in_bytes": 6315 + }, + { + "_path": "include/X11/DECkeysym.h", + "path_type": "hardlink", + "sha256": "9610df489e4dc4082ab74b0b5007309fb1ed7286e47634f039272bbf4a99b720", + "size_in_bytes": 2867 + }, + { + "_path": "include/X11/HPkeysym.h", + "path_type": "hardlink", + "sha256": "cd157ef21f5bd6833f4b82937de93504fecc1e368ded3e4a908244817b785ea5", + "size_in_bytes": 7936 + }, + { + "_path": "include/X11/Sunkeysym.h", + "path_type": "hardlink", + "sha256": "eb20cdc24a3fb9d8f43d18e50615ed44fc37006d704a42a4da1d2a7c2cfeb035", + "size_in_bytes": 4413 + }, + { + "_path": "include/X11/X.h", + "path_type": "hardlink", + "sha256": "3f3ce079a71d26784ea298a75a29fb8add6f0f409cf36850bea7d428fdb1a9fb", + "size_in_bytes": 20137 + }, + { + "_path": "include/X11/XF86keysym.h", + "path_type": "hardlink", + "sha256": "d0bbb8c30541e1b85c05af25551d40e82ea9f6166ca367f5330bf9ce760fe97e", + "size_in_bytes": 35330 + }, + { + "_path": "include/X11/XWDFile.h", + "path_type": "hardlink", + "sha256": "8383b2a444394f6748d0c3c770880acedb015357222040bbcb28791b6b309a7f", + "size_in_bytes": 3872 + }, + { + "_path": "include/X11/Xalloca.h", + "path_type": "hardlink", + "sha256": "7fc35f8e17d6e342bd0cf07284e08c0216c66ee45affc8aa935570e142bfdc54", + "size_in_bytes": 4587 + }, + { + "_path": "include/X11/Xarch.h", + "path_type": "hardlink", + "sha256": "e5d6c520a7f79d69e183f96a1450d6f21063c7298662265b93a404dac3981145", + "size_in_bytes": 2951 + }, + { + "_path": "include/X11/Xatom.h", + "path_type": "hardlink", + "sha256": "4da0ace354f86d5ad38fd24b4bcdb2e28e17432e0637c3eb25ecddb444f89486", + "size_in_bytes": 2518 + }, + { + "_path": "include/X11/Xdefs.h", + "path_type": "hardlink", + "sha256": "33aeef747e6b1fac465abca1f2c4d233cef2adbad7271f755ba92fe564bf2207", + "size_in_bytes": 2401 + }, + { + "_path": "include/X11/Xfuncproto.h", + "path_type": "hardlink", + "sha256": "e3459a7b7ea05634666daabd0fb37351c3cb0090df5aa8fea3d4b92281c42c60", + "size_in_bytes": 7420 + }, + { + "_path": "include/X11/Xfuncs.h", + "path_type": "hardlink", + "sha256": "f2d087fb703bcd883bca0f53b2c6896004d9a78cf35e43f4305b7c1f53cc27c7", + "size_in_bytes": 2256 + }, + { + "_path": "include/X11/Xmd.h", + "path_type": "hardlink", + "sha256": "f9a844b749286102b9f5acb8d0ff62fad3a697f9b5d39f1a525ea087865a13be", + "size_in_bytes": 5236 + }, + { + "_path": "include/X11/Xos.h", + "path_type": "hardlink", + "sha256": "c7ecf4e4648478b00d031bc5aca9cc595dd9b5b85653cee1a763536a23e8da3b", + "size_in_bytes": 4386 + }, + { + "_path": "include/X11/Xos_r.h", + "path_type": "hardlink", + "sha256": "43bbccf037dfad389ef742c382725c05235ccae31c3142591b78fe4622de966b", + "size_in_bytes": 33693 + }, + { + "_path": "include/X11/Xosdefs.h", + "path_type": "hardlink", + "sha256": "cab0a2d64c7d75dcc07718bbd07a6046be254cd9150fb810c1134ab551532b5b", + "size_in_bytes": 3115 + }, + { + "_path": "include/X11/Xpoll.h", + "path_type": "hardlink", + "sha256": "b35fd8105ca5fb36a9c7717818e6846c058904831e351ceef872bd0f145febf7", + "size_in_bytes": 7743 + }, + { + "_path": "include/X11/Xproto.h", + "path_type": "hardlink", + "sha256": "ae2c275f8b7bf4705ef993b50a34ce7418fbbc4789bcb841237116b7c0271c82", + "size_in_bytes": 52399 + }, + { + "_path": "include/X11/Xprotostr.h", + "path_type": "hardlink", + "sha256": "f3ea6f07d8f7e740da7dadab37d0ef8f6101658e52efab871460a1abc883c292", + "size_in_bytes": 2743 + }, + { + "_path": "include/X11/Xthreads.h", + "path_type": "hardlink", + "sha256": "1d1f3d598e0066d2e7efe133a8568d34fd670730bc9f1eb8dd9f5094ded4b6a9", + "size_in_bytes": 12395 + }, + { + "_path": "include/X11/Xw32defs.h", + "path_type": "hardlink", + "sha256": "aea48b3eb9f3195863f5286b4c7b790f57651b87bdaac58e159a16cce000a3fc", + "size_in_bytes": 1909 + }, + { + "_path": "include/X11/Xwindows.h", + "path_type": "hardlink", + "sha256": "f325abc2e6e77e3a747bc89c45d5dbb4b8ba6c473793a6aa0bd28dddc64d327b", + "size_in_bytes": 3371 + }, + { + "_path": "include/X11/Xwinsock.h", + "path_type": "hardlink", + "sha256": "8b782cf21f6b1cc1f0b190a73061144c75a1ce5519ffa46302e291d87a83f212", + "size_in_bytes": 2349 + }, + { + "_path": "include/X11/ap_keysym.h", + "path_type": "hardlink", + "sha256": "0959cf896b2aadb430b83a6a28668f6253ccb1533cbb2a594bb08d52a86d2d85", + "size_in_bytes": 2294 + }, + { + "_path": "include/X11/dri/xf86dri.h", + "path_type": "hardlink", + "sha256": "d2e8a5ad7a99f6fcb2afa21b367532ed1bfb6afd765ae443d14c7be63b090141", + "size_in_bytes": 2445 + }, + { + "_path": "include/X11/dri/xf86driproto.h", + "path_type": "hardlink", + "sha256": "847e039fd2b38731fd78b7a7afc96286209ce2b137b756f526a25412e4d58ecf", + "size_in_bytes": 9669 + }, + { + "_path": "include/X11/dri/xf86dristr.h", + "path_type": "hardlink", + "sha256": "57580e9cbcd6ff7d73a086bc53efb861b7e196cb3d636a9f6e4939ae566c2417", + "size_in_bytes": 174 + }, + { + "_path": "include/X11/extensions/EVI.h", + "path_type": "hardlink", + "sha256": "44df84d26993330980047b643ced1ff0fa22ebe7f165b98d33eb0d7e831119a6", + "size_in_bytes": 1563 + }, + { + "_path": "include/X11/extensions/EVIproto.h", + "path_type": "hardlink", + "sha256": "c4840aea1b12c0a0cc0c9bd393c80f5096e69132fe827f0210a0b77c966ce013", + "size_in_bytes": 3006 + }, + { + "_path": "include/X11/extensions/XI.h", + "path_type": "hardlink", + "sha256": "c456e8e0f6a03f7f5bf505d7626791f97856db7edc42fa806876b63356e0e272", + "size_in_bytes": 9823 + }, + { + "_path": "include/X11/extensions/XI2.h", + "path_type": "hardlink", + "sha256": "a9533c6407ebadb3871911abde60a33c8e04fd4fa6ee0d94cb46dba9d897cd46", + "size_in_bytes": 11151 + }, + { + "_path": "include/X11/extensions/XI2proto.h", + "path_type": "hardlink", + "sha256": "b419ceee6265f5e1b31ae4f09ad611c27dfc350be7daee0b16d9eb3fc69b62a5", + "size_in_bytes": 40459 + }, + { + "_path": "include/X11/extensions/XIproto.h", + "path_type": "hardlink", + "sha256": "32852fe9a4dfe74f84fd5573bd3342180dd74a4464e2d99950f4977e7d57eb90", + "size_in_bytes": 41010 + }, + { + "_path": "include/X11/extensions/XKB.h", + "path_type": "hardlink", + "sha256": "fe1ad789175ca423f5ba8a9797853b076d9fe887c93912ec59dd371ea8ab78bd", + "size_in_bytes": 28212 + }, + { + "_path": "include/X11/extensions/XKBproto.h", + "path_type": "hardlink", + "sha256": "8e63ddc0011cff9f473a51c3423febf4788a9563f3f384c826db1186723e5e74", + "size_in_bytes": 29172 + }, + { + "_path": "include/X11/extensions/XKBsrv.h", + "path_type": "hardlink", + "sha256": "3647e1913b8a5611db225b0d2999e293b7b3bc9029c13ab53e5c5ad150e2d19f", + "size_in_bytes": 28018 + }, + { + "_path": "include/X11/extensions/XKBstr.h", + "path_type": "hardlink", + "sha256": "37e7f96d1c6baa97fe7a3fde4c0de4685b886ad2b83aec252218cc757c3da46c", + "size_in_bytes": 19697 + }, + { + "_path": "include/X11/extensions/XResproto.h", + "path_type": "hardlink", + "sha256": "7ebe2398f4eed157e0de1dcce51ebddad81c50b06137b18b5389fb594bee7ab3", + "size_in_bytes": 5168 + }, + { + "_path": "include/X11/extensions/Xv.h", + "path_type": "hardlink", + "sha256": "c7918121196caf28257d441bfd53a8d7a63cf6002f840f991a195d98de72b13c", + "size_in_bytes": 3027 + }, + { + "_path": "include/X11/extensions/XvMC.h", + "path_type": "hardlink", + "sha256": "aa0c708ce394aedb18f72f6382ff7bd08734e25eace1a52f778cec5cf6aa5420", + "size_in_bytes": 3620 + }, + { + "_path": "include/X11/extensions/XvMCproto.h", + "path_type": "hardlink", + "sha256": "15cb788db04696fe14f7c51b030df695d7f6ae72f907477a2b6c38ea3fb85656", + "size_in_bytes": 4473 + }, + { + "_path": "include/X11/extensions/Xvproto.h", + "path_type": "hardlink", + "sha256": "d05fe6fbf2545804911be29b2dbac60065d2c23e7156d962a17c9c58787a478c", + "size_in_bytes": 12109 + }, + { + "_path": "include/X11/extensions/ag.h", + "path_type": "hardlink", + "sha256": "2026eaa8774cce32108f7c785eaa4503c7fddc65451b91de21b299079f077e34", + "size_in_bytes": 1705 + }, + { + "_path": "include/X11/extensions/agproto.h", + "path_type": "hardlink", + "sha256": "ee57f6bbb34865f14733196f4f45de87943564e947925c47af3dbd9b141664f9", + "size_in_bytes": 5005 + }, + { + "_path": "include/X11/extensions/applewmconst.h", + "path_type": "hardlink", + "sha256": "c0f42e2e231bc5e6a2a97dc277e4cc3e3ee2925669050a47005e189bd4fa5754", + "size_in_bytes": 2900 + }, + { + "_path": "include/X11/extensions/applewmproto.h", + "path_type": "hardlink", + "sha256": "c47efc1e4ae60c30dd144fb2dd51b4a18231ea71bf90edd36455851483a77436", + "size_in_bytes": 8098 + }, + { + "_path": "include/X11/extensions/bigreqsproto.h", + "path_type": "hardlink", + "sha256": "161ccbc4c6edb751b4f0c59155e194e719d29a3543e157159c065a9988feccd0", + "size_in_bytes": 1909 + }, + { + "_path": "include/X11/extensions/bigreqstr.h", + "path_type": "hardlink", + "sha256": "a01646c7ce3d2ca4f93a1393cb730c755399966bf74585c7b889b4b67c7be7b5", + "size_in_bytes": 187 + }, + { + "_path": "include/X11/extensions/composite.h", + "path_type": "hardlink", + "sha256": "4ae957edf4cbc648f6c3d79985b5990f1f8b59baea8c0925ce87e824b994efb6", + "size_in_bytes": 3109 + }, + { + "_path": "include/X11/extensions/compositeproto.h", + "path_type": "hardlink", + "sha256": "50d751cd8d8dcf78ed6f8ee795f1701e29d57a4e8db734617d9c0704e4e9a973", + "size_in_bytes": 5441 + }, + { + "_path": "include/X11/extensions/cup.h", + "path_type": "hardlink", + "sha256": "222ea6974547ca941a73ef80f33b87eea6e8f8f2326889ad86774009c50a887d", + "size_in_bytes": 1353 + }, + { + "_path": "include/X11/extensions/cupproto.h", + "path_type": "hardlink", + "sha256": "39a8b0c8012991e73e7296b0144dd2b438696bb333714a555990c67494188c1e", + "size_in_bytes": 3065 + }, + { + "_path": "include/X11/extensions/damageproto.h", + "path_type": "hardlink", + "sha256": "851fbfa9105d39a4cc28f3b357f7a8112ab3e245fc702a69d80f5ad62610bc3c", + "size_in_bytes": 3615 + }, + { + "_path": "include/X11/extensions/damagewire.h", + "path_type": "hardlink", + "sha256": "d25fc9e418c6a90dbf9c6d70df42e027fbabc2ee34412ce93fb68cedeede18b9", + "size_in_bytes": 1893 + }, + { + "_path": "include/X11/extensions/dbe.h", + "path_type": "hardlink", + "sha256": "fccc5aad978437552fefdc8f17cf4634dc6795b202bbc511ae30385f4d975a60", + "size_in_bytes": 2159 + }, + { + "_path": "include/X11/extensions/dbeproto.h", + "path_type": "hardlink", + "sha256": "eea867f4ed3b7c1fb8b092989c835125333f68b628ddfbbfa120cef60a99e502", + "size_in_bytes": 7343 + }, + { + "_path": "include/X11/extensions/dmx.h", + "path_type": "hardlink", + "sha256": "0c7a2b2fad12ce2a2e4cbc5abbb3352bb818c474c9ae2293f3111d277d26a2c5", + "size_in_bytes": 2373 + }, + { + "_path": "include/X11/extensions/dmxproto.h", + "path_type": "hardlink", + "sha256": "d0d98a46a4c6ac933cfaf399187553f220cd85c2ccf90f915efdd31437cfb5ac", + "size_in_bytes": 13343 + }, + { + "_path": "include/X11/extensions/dpmsconst.h", + "path_type": "hardlink", + "sha256": "90e503d50d8bf9a7b4ab4f59557f1aa533c38670f4ea6a6b8f7795b350fc53be", + "size_in_bytes": 1778 + }, + { + "_path": "include/X11/extensions/dpmsproto.h", + "path_type": "hardlink", + "sha256": "e1739aec5af2d719319cfcec31fcfc83bcd5fe6eae344c225a2237ff63fb1d76", + "size_in_bytes": 5288 + }, + { + "_path": "include/X11/extensions/dri2proto.h", + "path_type": "hardlink", + "sha256": "6ea4a4ec24777e9d56b7033aac475a850619704a18493104eb894c1c4e340322", + "size_in_bytes": 8318 + }, + { + "_path": "include/X11/extensions/dri2tokens.h", + "path_type": "hardlink", + "sha256": "8d0522d35d28259bdb099fba9e5351e94f46fee1f0a5fda640aab5037012a37e", + "size_in_bytes": 2468 + }, + { + "_path": "include/X11/extensions/dri3proto.h", + "path_type": "hardlink", + "sha256": "9c30e8b62204677c4eb1c2babeb776fede9a6b35966f5750ef9d6f55f92ce66b", + "size_in_bytes": 6913 + }, + { + "_path": "include/X11/extensions/ge.h", + "path_type": "hardlink", + "sha256": "eebf3ac0a163aa23e2f9e75864639eae276d8d71516840b5b3458cf3414ccfed", + "size_in_bytes": 1782 + }, + { + "_path": "include/X11/extensions/geproto.h", + "path_type": "hardlink", + "sha256": "b831b2d821249670d8ed60a05f9f0dd85caa2c2ef101dbb6989bca5ea7ad02f1", + "size_in_bytes": 2351 + }, + { + "_path": "include/X11/extensions/lbx.h", + "path_type": "hardlink", + "sha256": "92a918d6978fcc31a277c35d977a7fe8160897c592962df84a4023f523e9c06f", + "size_in_bytes": 2236 + }, + { + "_path": "include/X11/extensions/lbxproto.h", + "path_type": "hardlink", + "sha256": "5cb30949b8c2488d13b0fcc80b9e6f276475e54d7c53d92a410a94b24fa781f6", + "size_in_bytes": 24782 + }, + { + "_path": "include/X11/extensions/mitmiscconst.h", + "path_type": "hardlink", + "sha256": "51a1ce94842dbd1d1804787d2b08497c66b0ab0823d8ccad18eab82b0b5031eb", + "size_in_bytes": 1509 + }, + { + "_path": "include/X11/extensions/mitmiscproto.h", + "path_type": "hardlink", + "sha256": "6a96defa0e524702d3a2b82f4e83758ebf1d49b50cab19ab48092ea77c9b41b9", + "size_in_bytes": 2229 + }, + { + "_path": "include/X11/extensions/multibufconst.h", + "path_type": "hardlink", + "sha256": "0673f0f1e98f5a1221d26b6dddce42d774dc54533fdf3f474af1faae97e5d708", + "size_in_bytes": 2575 + }, + { + "_path": "include/X11/extensions/multibufproto.h", + "path_type": "hardlink", + "sha256": "6d7d0af5207799874ba8df995a2d1fe9740bc519d996a3eca78c6ab8b90f28ec", + "size_in_bytes": 8600 + }, + { + "_path": "include/X11/extensions/panoramiXproto.h", + "path_type": "hardlink", + "sha256": "95ddf60b563ca29aa12a213de8b02f030a45266318acdd26ad933955f2482eaf", + "size_in_bytes": 5473 + }, + { + "_path": "include/X11/extensions/presentproto.h", + "path_type": "hardlink", + "sha256": "2a96502bcd195831be9f625275f3c83c3f02ea318721b2f3e9a49fc87e22fd5e", + "size_in_bytes": 6036 + }, + { + "_path": "include/X11/extensions/presenttokens.h", + "path_type": "hardlink", + "sha256": "bf885155fe280d44e9ce8a987f3b9f907f1a5515b98a35e89ebeaa3cd7599ea6", + "size_in_bytes": 4131 + }, + { + "_path": "include/X11/extensions/randr.h", + "path_type": "hardlink", + "sha256": "cf25cc300807b0728ac1880f221f57a6f94c2757cf890eacf5e8c59bac729bf8", + "size_in_bytes": 6909 + }, + { + "_path": "include/X11/extensions/randrproto.h", + "path_type": "hardlink", + "sha256": "1958398c76e9c6a52e6c039749921c36388deb6c3ccd9e9e6f0aa6fc451469f5", + "size_in_bytes": 25751 + }, + { + "_path": "include/X11/extensions/recordconst.h", + "path_type": "hardlink", + "sha256": "a3f004dca681551fa9d1f2941b857b2b6705aab45b62a81c46d4934971fad8af", + "size_in_bytes": 2064 + }, + { + "_path": "include/X11/extensions/recordproto.h", + "path_type": "hardlink", + "sha256": "1572d360f49327192887869a5ca5532a0841b69d45a970c0b7fb73b8f0ed8168", + "size_in_bytes": 7634 + }, + { + "_path": "include/X11/extensions/recordstr.h", + "path_type": "hardlink", + "sha256": "5c503dc572b8ff89c9f7734175db253af35d3b70da7ff3a1592ddd2e095846cb", + "size_in_bytes": 258 + }, + { + "_path": "include/X11/extensions/render.h", + "path_type": "hardlink", + "sha256": "68d86876464cfe3137b980d033d742e73e38f477eeaab8bb3d2830864cc424ca", + "size_in_bytes": 6933 + }, + { + "_path": "include/X11/extensions/renderproto.h", + "path_type": "hardlink", + "sha256": "b69c9a5e0b0a691ded3757d2fc39b84ed8acfda159070b92e7014d9459a4c45a", + "size_in_bytes": 13218 + }, + { + "_path": "include/X11/extensions/saver.h", + "path_type": "hardlink", + "sha256": "9536761cd417a944c7e8bf1c86adf7b49747dfe4fea0d10f7a0d7966e5e69658", + "size_in_bytes": 1900 + }, + { + "_path": "include/X11/extensions/saverproto.h", + "path_type": "hardlink", + "sha256": "0e69e246eb004163c8c5db7bb52697614d1a4fae6d33fe7e8ae9e1cf0e08a27e", + "size_in_bytes": 5132 + }, + { + "_path": "include/X11/extensions/secur.h", + "path_type": "hardlink", + "sha256": "6ea2702a7a3f83bc5c9e9b8250142b2765e80850cd7863d060b2b2a04e33bdc8", + "size_in_bytes": 2141 + }, + { + "_path": "include/X11/extensions/securproto.h", + "path_type": "hardlink", + "sha256": "61eb0a9b69254e116a94344f81fba183262013f0a28d9ccae9c0c14700f0e280", + "size_in_bytes": 3177 + }, + { + "_path": "include/X11/extensions/shapeconst.h", + "path_type": "hardlink", + "sha256": "41e65d51df6976c3a3a2650052043de9080830b9519aa1d8f7fde073d831ffa6", + "size_in_bytes": 1878 + }, + { + "_path": "include/X11/extensions/shapeproto.h", + "path_type": "hardlink", + "sha256": "284ff667072c0e69f78787adc8b103de04ba0cfc0ff47c33e459b93e61dbf884", + "size_in_bytes": 6730 + }, + { + "_path": "include/X11/extensions/shapestr.h", + "path_type": "hardlink", + "sha256": "a2cb83fc43b2d4b4a27571061ab600889e75ca9d8759893bb24c22accd12d45f", + "size_in_bytes": 252 + }, + { + "_path": "include/X11/extensions/shm.h", + "path_type": "hardlink", + "sha256": "7698fc62925c431a769eb71807e3ecfcd2686b1d010fb65c124e55483cc617b4", + "size_in_bytes": 1645 + }, + { + "_path": "include/X11/extensions/shmproto.h", + "path_type": "hardlink", + "sha256": "f4f57a83fb76630c3353436ef45697951b98f44a6a584ab0580b98b1d7d65f5c", + "size_in_bytes": 6045 + }, + { + "_path": "include/X11/extensions/shmstr.h", + "path_type": "hardlink", + "sha256": "574babc1d2c5d10c2d0b96b60266d783cf29941808d17701728dd3015896e159", + "size_in_bytes": 2123 + }, + { + "_path": "include/X11/extensions/syncconst.h", + "path_type": "hardlink", + "sha256": "d1fe4e40fe978867730ec3ae0b799d94868256178fc358232ffed26cf7f22717", + "size_in_bytes": 6748 + }, + { + "_path": "include/X11/extensions/syncproto.h", + "path_type": "hardlink", + "sha256": "e1e5169e4c82cd186ccc55004106cbebf1bc8216a655198849116be227e883f7", + "size_in_bytes": 11001 + }, + { + "_path": "include/X11/extensions/syncstr.h", + "path_type": "hardlink", + "sha256": "e52b25a54eeb192ef452ceece0038b2056a63c06d3158f03b1adec6217653a28", + "size_in_bytes": 5605 + }, + { + "_path": "include/X11/extensions/xcmiscproto.h", + "path_type": "hardlink", + "sha256": "379daae208ad4ce1aca4063bf4a00207b5da74c128ba10437c07ed06f0c94127", + "size_in_bytes": 3057 + }, + { + "_path": "include/X11/extensions/xcmiscstr.h", + "path_type": "hardlink", + "sha256": "57d1c363ab65868094f6d27d81d7e2aeab57f2442abd9bec9003c3025ebaef11", + "size_in_bytes": 185 + }, + { + "_path": "include/X11/extensions/xf86bigfont.h", + "path_type": "hardlink", + "sha256": "cf37ed3052f7eb7063390d3d279cbe2b68cc7d61bc5eec540fdfc502a9abef7e", + "size_in_bytes": 414 + }, + { + "_path": "include/X11/extensions/xf86bigfproto.h", + "path_type": "hardlink", + "sha256": "266b83b83286049f31e9722c3ddc35ba24055b79b2e99583bc13c014a6cb18d8", + "size_in_bytes": 2544 + }, + { + "_path": "include/X11/extensions/xf86bigfstr.h", + "path_type": "hardlink", + "sha256": "2ea0f6a31a4a885728da10660e2192439edf0c6e158248466e7507b716820681", + "size_in_bytes": 191 + }, + { + "_path": "include/X11/extensions/xf86dga.h", + "path_type": "hardlink", + "sha256": "af912f0989ba2a8f6900b34c7b80853a9efbbd57e8e7fc7d52c13c71b90bf487", + "size_in_bytes": 369 + }, + { + "_path": "include/X11/extensions/xf86dga1const.h", + "path_type": "hardlink", + "sha256": "f4fe2d2c79b4a40760b6977b3233aac364f63820446d09cfbe8a289073921ed4", + "size_in_bytes": 931 + }, + { + "_path": "include/X11/extensions/xf86dga1proto.h", + "path_type": "hardlink", + "sha256": "0ba9065e24a625d904817ab5327ad97594ab0ebbed00a210afd7f49de1fc5586", + "size_in_bytes": 4506 + }, + { + "_path": "include/X11/extensions/xf86dga1str.h", + "path_type": "hardlink", + "sha256": "7a43d28c46fde05e8544c31a76fe1b2b7f6e268ba99b91d4d2cd7edf7f412823", + "size_in_bytes": 191 + }, + { + "_path": "include/X11/extensions/xf86dgaconst.h", + "path_type": "hardlink", + "sha256": "9ef9c5908ecc39e1167f8f05351395cf4f9993ade3622b120ae0b06691c38c1e", + "size_in_bytes": 2533 + }, + { + "_path": "include/X11/extensions/xf86dgaproto.h", + "path_type": "hardlink", + "sha256": "a5a9f6dfa25ceba4c16725e4947e7d9477f1fb81c9d8a15d6321fdb9e9f8f1f5", + "size_in_bytes": 7106 + }, + { + "_path": "include/X11/extensions/xf86dgastr.h", + "path_type": "hardlink", + "sha256": "ab0a295adf7cd4291bd3be78114fa20834063144bf966cf09373797ae8a1cbc0", + "size_in_bytes": 188 + }, + { + "_path": "include/X11/extensions/xf86vm.h", + "path_type": "hardlink", + "sha256": "7fc9762fa61735daffb69833b91bd031486aa375cc8eb2a02c3978ad81ccd327", + "size_in_bytes": 2106 + }, + { + "_path": "include/X11/extensions/xf86vmproto.h", + "path_type": "hardlink", + "sha256": "b86a00b97241ddf4b827c298d3165afb63de06d54829d4212fc8192f11b890cc", + "size_in_bytes": 15700 + }, + { + "_path": "include/X11/extensions/xf86vmstr.h", + "path_type": "hardlink", + "sha256": "1c03a84d3f615c57b3b8ebbf028354ea5714c8f305ee51ac6478b406e4aba7bc", + "size_in_bytes": 185 + }, + { + "_path": "include/X11/extensions/xfixesproto.h", + "path_type": "hardlink", + "sha256": "1f49db640e00e73185ee0fbeac337729f8723008dd3bf6c41a891b1ced3b593b", + "size_in_bytes": 13541 + }, + { + "_path": "include/X11/extensions/xfixeswire.h", + "path_type": "hardlink", + "sha256": "83ad3d3fe09e5bfd723f73b3038a0de671f6c0d526a6d95c7dba576df0918a39", + "size_in_bytes": 5924 + }, + { + "_path": "include/X11/extensions/xtestconst.h", + "path_type": "hardlink", + "sha256": "52735cf666baf73492e71c40f9a509156c9e3b4344a63fef39f5889db984d984", + "size_in_bytes": 1392 + }, + { + "_path": "include/X11/extensions/xtestext1const.h", + "path_type": "hardlink", + "sha256": "087021647a7f93be9f780b531e29221a9885d191f878138fcc2cbb6563b08b40", + "size_in_bytes": 5439 + }, + { + "_path": "include/X11/extensions/xtestext1proto.h", + "path_type": "hardlink", + "sha256": "43d9e5e32b532bddc9e0c5fc2ba5c55404f5b35ca14f4e905e008fa61d8d5112", + "size_in_bytes": 7790 + }, + { + "_path": "include/X11/extensions/xtestproto.h", + "path_type": "hardlink", + "sha256": "8fb8a7075f991e292346dd837f5abc243cbe0160a2c16b8f8227151483562059", + "size_in_bytes": 3254 + }, + { + "_path": "include/X11/extensions/xwaylandproto.h", + "path_type": "hardlink", + "sha256": "006374cc83aec12bf77057376d6c691b427c09ca1c361a5fae8da8f794f95627", + "size_in_bytes": 2044 + }, + { + "_path": "include/X11/fonts/FS.h", + "path_type": "hardlink", + "sha256": "a939fe23e62fffb130759d91cdccdaefaa8eb15597b07fd04578bd6d527f8149", + "size_in_bytes": 4076 + }, + { + "_path": "include/X11/fonts/FSproto.h", + "path_type": "hardlink", + "sha256": "5138b931490addeb40fc3876bdfda1f62f7345c2838ce9c46d6f9a0b0e61bc7d", + "size_in_bytes": 19889 + }, + { + "_path": "include/X11/fonts/font.h", + "path_type": "hardlink", + "sha256": "42b2166ad9a03d7bbf29c0e5e6193cdbf83d578ff5fa1b36fa09092d242e35b8", + "size_in_bytes": 4253 + }, + { + "_path": "include/X11/fonts/fontproto.h", + "path_type": "hardlink", + "sha256": "1560309501298e0a4279ba942069349be0f0dadebe25943a1abcec4563dd25cb", + "size_in_bytes": 3450 + }, + { + "_path": "include/X11/fonts/fontstruct.h", + "path_type": "hardlink", + "sha256": "9aa84499496ef26316b84bccfa6d91453f1a466b7ff9163241ec9dbad43137bb", + "size_in_bytes": 9401 + }, + { + "_path": "include/X11/fonts/fsmasks.h", + "path_type": "hardlink", + "sha256": "0db16266f62d0c74f7fa344b99b9c155a3886f6f411f4d410e8ef0f09e2e5abf", + "size_in_bytes": 3992 + }, + { + "_path": "include/X11/keysym.h", + "path_type": "hardlink", + "sha256": "1a6abb208e617e38ee069f8b014518c3c2815f6a4e46e0fb384a7bfff64405c4", + "size_in_bytes": 2769 + }, + { + "_path": "include/X11/keysymdef.h", + "path_type": "hardlink", + "sha256": "4ba0724695c817a08b4ea3a79c5e8a52e0798cc8d5906281b10f89dc6225208d", + "size_in_bytes": 186634 + }, + { + "_path": "share/doc/bigreqsproto/bigreq.xml", + "path_type": "hardlink", + "sha256": "ebfab1f82da0348c76a79a2c083122445e7ebfb2d0d17ca9a88114d74f310a74", + "size_in_bytes": 12598 + }, + { + "_path": "share/doc/fontsproto/fsproto.xml", + "path_type": "hardlink", + "sha256": "4c31347982d0b3ab54151f74a4b0976e55fbed754954b6cea8dc3a472a2c10d6", + "size_in_bytes": 204699 + }, + { + "_path": "share/doc/kbproto/XKBproto-1.svg", + "path_type": "hardlink", + "sha256": "8c56e0c362bf60560acba2855db1d2ad86122a546b5bf8862b796c6f58ee7ef0", + "size_in_bytes": 54498 + }, + { + "_path": "share/doc/kbproto/XKBproto-10.svg", + "path_type": "hardlink", + "sha256": "9814702558544906c941b17fbcc7950d18b653005625132761f692cec44c8f87", + "size_in_bytes": 5150 + }, + { + "_path": "share/doc/kbproto/XKBproto-11.svg", + "path_type": "hardlink", + "sha256": "1924ae667875ef35594503cea2e8e8d5209dccd0409430e0e4e065966b4db645", + "size_in_bytes": 126010 + }, + { + "_path": "share/doc/kbproto/XKBproto-2.svg", + "path_type": "hardlink", + "sha256": "0035a5810429961753227013ff96b71dff1a43bd528e2cb492941c2a080ac0e2", + "size_in_bytes": 23983 + }, + { + "_path": "share/doc/kbproto/XKBproto-3.svg", + "path_type": "hardlink", + "sha256": "620bbad890b74e9cfa09b2653dafb23d149fda6f388f177fa7d91bf0271d7754", + "size_in_bytes": 24187 + }, + { + "_path": "share/doc/kbproto/XKBproto-4.svg", + "path_type": "hardlink", + "sha256": "95faa0041198c0d56a7c51b5f24927f017673d95987ad26cd8e88e9d4775bb7c", + "size_in_bytes": 26760 + }, + { + "_path": "share/doc/kbproto/XKBproto-5.svg", + "path_type": "hardlink", + "sha256": "486f4dac591df63d6d1225ec8058d09701967a529e17f4c0401e330501ee6566", + "size_in_bytes": 27246 + }, + { + "_path": "share/doc/kbproto/XKBproto-6.svg", + "path_type": "hardlink", + "sha256": "d2a7bddab069eb7b79f0ed1d6de714e6c92637a9cde6c4adcdd47dab20675d29", + "size_in_bytes": 36338 + }, + { + "_path": "share/doc/kbproto/XKBproto-7.svg", + "path_type": "hardlink", + "sha256": "bf4ce4e0b3ff900d812c30f44ce05a3769a19c5f1a7f0cd49052e951d689ed37", + "size_in_bytes": 22062 + }, + { + "_path": "share/doc/kbproto/XKBproto-8.svg", + "path_type": "hardlink", + "sha256": "74d841a4fbe533992b8ea287bbb2ce9681f244def02e4d082d8dcfaec2dcc3c4", + "size_in_bytes": 6473 + }, + { + "_path": "share/doc/kbproto/XKBproto-9.svg", + "path_type": "hardlink", + "sha256": "74d841a4fbe533992b8ea287bbb2ce9681f244def02e4d082d8dcfaec2dcc3c4", + "size_in_bytes": 6473 + }, + { + "_path": "share/doc/kbproto/acknowledgements.xml", + "path_type": "hardlink", + "sha256": "98ae3f8d86780793e7df268421b41dca8c9ae34e7fdf042116017b4ab3374629", + "size_in_bytes": 2743 + }, + { + "_path": "share/doc/kbproto/appA.xml", + "path_type": "hardlink", + "sha256": "5be898bfda0888eca723f237b4f985440f767e776594a099f8837abaff70495f", + "size_in_bytes": 22361 + }, + { + "_path": "share/doc/kbproto/appB.xml", + "path_type": "hardlink", + "sha256": "2afa8fe86bfea56bf9bcb10b9901b8e371ed49d93631978febd47022b27ab5c4", + "size_in_bytes": 2981 + }, + { + "_path": "share/doc/kbproto/appC.xml", + "path_type": "hardlink", + "sha256": "11595fa4d6fe1c761885c1b829d92e41dcf822c9f4190ca7a148af7723f16657", + "size_in_bytes": 15839 + }, + { + "_path": "share/doc/kbproto/appD.xml", + "path_type": "hardlink", + "sha256": "0999abc742208e12c35964a350a19e7688a39e922e0086f151910a02162611cf", + "size_in_bytes": 67191 + }, + { + "_path": "share/doc/kbproto/ch01.xml", + "path_type": "hardlink", + "sha256": "2cd0ea42d52841d850255bb0a79c008b505ec576c82d17d8b4e502215eea4ac3", + "size_in_bytes": 3931 + }, + { + "_path": "share/doc/kbproto/ch02.xml", + "path_type": "hardlink", + "sha256": "9bf29ab4964a293bfe2f920671f0652dc65707703fe5d7d34c33ba9b14d2e524", + "size_in_bytes": 14340 + }, + { + "_path": "share/doc/kbproto/ch03.xml", + "path_type": "hardlink", + "sha256": "dd57a4aa691fe23175e6d91378e57a619e38da2c84f9f22dfbf65d6f690f3b5b", + "size_in_bytes": 7401 + }, + { + "_path": "share/doc/kbproto/ch04.xml", + "path_type": "hardlink", + "sha256": "7628751b082ff6639b2bb44fa1a9f47630b2452960883d73e85c3033e3bcbb5a", + "size_in_bytes": 25756 + }, + { + "_path": "share/doc/kbproto/ch05.xml", + "path_type": "hardlink", + "sha256": "d4f90c6f47e9cad1a3c81398d520690842eb5c17fcb83cd5c62a332f6e9d80dc", + "size_in_bytes": 3671 + }, + { + "_path": "share/doc/kbproto/ch06.xml", + "path_type": "hardlink", + "sha256": "424f811b2dd5144bf52e2a3ea49ac81c4a26e45a24e1e45bf87e80632c1e3569", + "size_in_bytes": 44058 + }, + { + "_path": "share/doc/kbproto/ch07.xml", + "path_type": "hardlink", + "sha256": "145e057c0015426a7e90038703c2a011376966b13c64169c14ff93421ee95c63", + "size_in_bytes": 20038 + }, + { + "_path": "share/doc/kbproto/ch08.xml", + "path_type": "hardlink", + "sha256": "591f61ce222747d79d85dabdcb1e6dc2d4827671d21f0946b7b05d7e3266ec17", + "size_in_bytes": 5408 + }, + { + "_path": "share/doc/kbproto/ch09.xml", + "path_type": "hardlink", + "sha256": "5fdbcd3b9489e6c8cd44a2fba3af832628c47f474c640587930bc7eedbf2281a", + "size_in_bytes": 16703 + }, + { + "_path": "share/doc/kbproto/ch10.xml", + "path_type": "hardlink", + "sha256": "a915194d8aad059a28095d92313899bb8da2f82f851a1caef64bc683f1374025", + "size_in_bytes": 5246 + }, + { + "_path": "share/doc/kbproto/ch11.xml", + "path_type": "hardlink", + "sha256": "bdc417b6aa28c8638d63745017254ebe79780112e9a9046a9361d37d0d5c92ba", + "size_in_bytes": 13334 + }, + { + "_path": "share/doc/kbproto/ch12.xml", + "path_type": "hardlink", + "sha256": "ba6f308bcd1ec0bc480c7771dd224c7d6acc45f12b2082f7f2a84aa5ac6afa87", + "size_in_bytes": 33865 + }, + { + "_path": "share/doc/kbproto/ch13.xml", + "path_type": "hardlink", + "sha256": "87938255486545589d49211f633e1550a52e3687344ad0ff5ff1b0346f8f690d", + "size_in_bytes": 13600 + }, + { + "_path": "share/doc/kbproto/ch14.xml", + "path_type": "hardlink", + "sha256": "7e45a92337f54f90f290aeebff2bf74d6940827b418dcab10400a1ca21ba3e11", + "size_in_bytes": 3223 + }, + { + "_path": "share/doc/kbproto/ch15.xml", + "path_type": "hardlink", + "sha256": "23072d2102342305e8a9c59ae53ae2a2964c9cfa90335ae7794d106406913ab1", + "size_in_bytes": 7208 + }, + { + "_path": "share/doc/kbproto/ch16.xml", + "path_type": "hardlink", + "sha256": "12ab5b2fcf92293f8c5ecb9346aa41f1819de824d392638a7245fa7e74e27c27", + "size_in_bytes": 227290 + }, + { + "_path": "share/doc/kbproto/xkbproto.xml", + "path_type": "hardlink", + "sha256": "f957e05d18dce699e6cb7a25b7cb634f588912a22f7491d9450e7dec2cb26d59", + "size_in_bytes": 4043 + }, + { + "_path": "share/doc/recordproto/record.xml", + "path_type": "hardlink", + "sha256": "ec4b7d7e83288bd3e70ad51191379b5bcc130d39ea01bef4662c92fb4b484d38", + "size_in_bytes": 61083 + }, + { + "_path": "share/doc/scrnsaverproto/saver.xml", + "path_type": "hardlink", + "sha256": "f0a3c0ce0317c11170520602a248d6de375e6f83aee7eaac3ad842d36420694d", + "size_in_bytes": 35235 + }, + { + "_path": "share/doc/xcmiscproto/xc-misc.xml", + "path_type": "hardlink", + "sha256": "39a1519655a35272dccda67d298fc4875248e7f450ff68e3bed24eff082ba5a2", + "size_in_bytes": 8388 + }, + { + "_path": "share/doc/xextproto/appendix.xml", + "path_type": "hardlink", + "sha256": "e2f7c382343acb1517096c3daf1f5898f2f28116b044c1813c7641bacce0e3d6", + "size_in_bytes": 2101 + }, + { + "_path": "share/doc/xextproto/appgrp.xml", + "path_type": "hardlink", + "sha256": "5551881f6aa505582f5416231730abff8ee85e0054f08b30613417184440aa79", + "size_in_bytes": 36791 + }, + { + "_path": "share/doc/xextproto/dbe.xml", + "path_type": "hardlink", + "sha256": "a728384893bec337a3715ca8d8645884a2b6794f1d81b0f0a0df7a4dd9359c6b", + "size_in_bytes": 36787 + }, + { + "_path": "share/doc/xextproto/dpms.xml", + "path_type": "hardlink", + "sha256": "2ca52a6ad36c908c44e08fa2274a3687b9a4d8fce8e7dbba31364254e8d4f483", + "size_in_bytes": 21827 + }, + { + "_path": "share/doc/xextproto/evi.xml", + "path_type": "hardlink", + "sha256": "8357419f3d474caf9870f96c9ea769b8b33b133033e0bbde49b23a086addc34d", + "size_in_bytes": 14521 + }, + { + "_path": "share/doc/xextproto/geproto.xml", + "path_type": "hardlink", + "sha256": "586b5187f1ac05f33909ce86da6416cf4a8950e6a072fb4363eab3428f7e2802", + "size_in_bytes": 5135 + }, + { + "_path": "share/doc/xextproto/lbx.xml", + "path_type": "hardlink", + "sha256": "55c3b39c5a47064ba06dbf00cc4c4f26e12f910a1c3e3352d6a7ffb9b3f8c59e", + "size_in_bytes": 162642 + }, + { + "_path": "share/doc/xextproto/multibuf.xml", + "path_type": "hardlink", + "sha256": "ce0b491247e5d21edaee8fe72de27728636a684da6a4698527f502d8523fcb96", + "size_in_bytes": 50811 + }, + { + "_path": "share/doc/xextproto/security.xml", + "path_type": "hardlink", + "sha256": "5471a9592a39905f0f8481c856dacf856ac817b24167e053bd4b4ce3439b13a4", + "size_in_bytes": 46431 + }, + { + "_path": "share/doc/xextproto/shape.xml", + "path_type": "hardlink", + "sha256": "173613c79ad47a4f5c495311448aab834e7a531a8d844d7c188740aca75cdbff", + "size_in_bytes": 37921 + }, + { + "_path": "share/doc/xextproto/shm.xml", + "path_type": "hardlink", + "sha256": "fd17234b3a982841465ea9a157c1e5a5da851cb340f341b4f5065f7ac4616b73", + "size_in_bytes": 17196 + }, + { + "_path": "share/doc/xextproto/sync.xml", + "path_type": "hardlink", + "sha256": "f1511c04912aa0eece9e74d2458e700285d3bc4489ef5b09b195a3603b3b6333", + "size_in_bytes": 48176 + }, + { + "_path": "share/doc/xextproto/tog-cup.xml", + "path_type": "hardlink", + "sha256": "aa0aab3443151f6e56f84aebfc1e1ef969f7ff338dd630b467ddc48ab7283643", + "size_in_bytes": 16996 + }, + { + "_path": "share/doc/xextproto/xtest.xml", + "path_type": "hardlink", + "sha256": "1cd135196cee7b82ade9f119e7bf603b32099bc2a2190375f4416ef470384bf1", + "size_in_bytes": 19672 + }, + { + "_path": "share/doc/xorgproto/compositeproto.txt", + "path_type": "hardlink", + "sha256": "39afb3a7cfa60f1fe86f85c4eef2703aa13d42fb25b05d8046fe64dd000f7110", + "size_in_bytes": 12160 + }, + { + "_path": "share/doc/xorgproto/damageproto.txt", + "path_type": "hardlink", + "sha256": "9d1a89280321badd89891dd6532b3be268d5208e6bd2af8b67621942ad4aad28", + "size_in_bytes": 7585 + }, + { + "_path": "share/doc/xorgproto/dri2proto.txt", + "path_type": "hardlink", + "sha256": "e2a82261c302d1b6bf63ffe94108d2cdc674bf1448e03249604bfe171f2eb3ac", + "size_in_bytes": 23086 + }, + { + "_path": "share/doc/xorgproto/dri3proto.txt", + "path_type": "hardlink", + "sha256": "dab17d9c74666e60c8d8a54b4c1fe4d1d1cf54fa0466f8833cb566307d6f160d", + "size_in_bytes": 21123 + }, + { + "_path": "share/doc/xorgproto/fixesproto.txt", + "path_type": "hardlink", + "sha256": "a122a53d209258ba7677058c55d9129dbd0eaa742661c27dfd4a294835ca3a9a", + "size_in_bytes": 22305 + }, + { + "_path": "share/doc/xorgproto/presentproto.txt", + "path_type": "hardlink", + "sha256": "d564a65604cfe9a48f1366b44267e3c015a0c05a2869798fe77fba04ea6ab682", + "size_in_bytes": 27825 + }, + { + "_path": "share/doc/xorgproto/randrproto.txt", + "path_type": "hardlink", + "sha256": "8fe3039b7c071d091fcc7f5512f0a64da3ed13c0eae3d494bfb14818bd96eec0", + "size_in_bytes": 111306 + }, + { + "_path": "share/doc/xorgproto/renderproto.txt", + "path_type": "hardlink", + "sha256": "130c693a91437674b224372b07400667daeb23a2e0ea2f858d8a22eb9efba7ee", + "size_in_bytes": 37809 + }, + { + "_path": "share/doc/xorgproto/resproto.txt", + "path_type": "hardlink", + "sha256": "e0b6933668423d84de06a41f5f94914bc912bcf29bc285dd1c884cbe742767d5", + "size_in_bytes": 18060 + }, + { + "_path": "share/doc/xorgproto/xv-protocol-v2.txt", + "path_type": "hardlink", + "sha256": "79d5a801985c87fc66fec5c88f82ef2e4a4da936371ceca6f264cd3fddeca711", + "size_in_bytes": 20332 + }, + { + "_path": "share/doc/xorgproto/xwaylandproto.txt", + "path_type": "hardlink", + "sha256": "b86d2645b20844379f70ef1fe366bf7b81d8ac1ee34dc8e3a4252ce7741f1c4b", + "size_in_bytes": 2384 + }, + { + "_path": "share/doc/xproto/encoding.xml", + "path_type": "hardlink", + "sha256": "889733d7e288dbf634c4ee41b99b94b5de20628650e0ee5cb9eb4d8f6c58a644", + "size_in_bytes": 133533 + }, + { + "_path": "share/doc/xproto/glossary.xml", + "path_type": "hardlink", + "sha256": "a0d9084baaaf18da70dcbcba6559c9655c002b1b7570355d315b5da9957b079a", + "size_in_bytes": 49731 + }, + { + "_path": "share/doc/xproto/keysyms.xml", + "path_type": "hardlink", + "sha256": "e31966785fb48e876df8aa9a664489a5729a97c9e129ee8231953f904dff0e3f", + "size_in_bytes": 150187 + }, + { + "_path": "share/doc/xproto/sect1-9.xml", + "path_type": "hardlink", + "sha256": "dcacf8b3f030dd05d05f0c82e8be0529b654890d9d39aa1370d2b27283aa1085", + "size_in_bytes": 467109 + }, + { + "_path": "share/doc/xproto/x11protocol.xml", + "path_type": "hardlink", + "sha256": "cf4a8eab4a752f1e8ffdab6ff5db3485e030c8300660c2892b0d3905dd364ed8", + "size_in_bytes": 2588 + }, + { + "_path": "share/pkgconfig/applewmproto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "a52ea0644f4924fa22deaad0f2010daa930853751adf7fa00e6b42fcdad7c445", + "size_in_bytes": 391 + }, + { + "_path": "share/pkgconfig/bigreqsproto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "736fb810109deb2bd899644b8878a9005d4985b24314d5184c752e5aa77b5738", + "size_in_bytes": 391 + }, + { + "_path": "share/pkgconfig/compositeproto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "36debcfbe90b67a34798547243ccb45eb3165ceee2f08c7ef6d482a389899b4a", + "size_in_bytes": 392 + }, + { + "_path": "share/pkgconfig/damageproto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "e2522a19a9dec1f182b19a90334962d64420722910a03ba849f04813aaa440f7", + "size_in_bytes": 388 + }, + { + "_path": "share/pkgconfig/dmxproto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "0e99d6e008c6e65f8030ec9f5f33716a8c0ae4c723b62d847a3a927d58134dd3", + "size_in_bytes": 383 + }, + { + "_path": "share/pkgconfig/dpmsproto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "61af903921e1f9dbbea7617d3709ad42d3f2aabd57800412bc66958cb4d78dc1", + "size_in_bytes": 382 + }, + { + "_path": "share/pkgconfig/dri2proto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "d8d6730407ca4af901815420fb356de3f2be85eaa728d42928a6bae24410e0f6", + "size_in_bytes": 383 + }, + { + "_path": "share/pkgconfig/dri3proto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "c03c01139089580ce6e16e62dff627412bb77e6260126ba249ecdfeb6990938b", + "size_in_bytes": 383 + }, + { + "_path": "share/pkgconfig/fixesproto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "472b2d118aae57aed513ce298b34bc203ce4c49aa94010a8b3f2bf71c8004d52", + "size_in_bytes": 418 + }, + { + "_path": "share/pkgconfig/fontsproto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "7685900d92970d3b72361d27d2c8ebf44b197cdc39b7216822d2ea9c1853c7cf", + "size_in_bytes": 387 + }, + { + "_path": "share/pkgconfig/glproto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "c6d2cbdd4b330201def78c008e8fc773d8d0469d58e74750b9f0b1b93350f4ca", + "size_in_bytes": 382 + }, + { + "_path": "share/pkgconfig/inputproto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "63d3ab0b7dbbd6a7250dd409e6d3b31b272c1cd972f2c02eba22b395227420d0", + "size_in_bytes": 390 + }, + { + "_path": "share/pkgconfig/kbproto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "529002e869e5c17c2a4e6dcc25e725f83ec971231ae842bb4d07998edd0d2875", + "size_in_bytes": 381 + }, + { + "_path": "share/pkgconfig/presentproto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "ebab0aa08ecad410342bee90a75e7253f91355fccdf5f482055650fdd6c29203", + "size_in_bytes": 389 + }, + { + "_path": "share/pkgconfig/randrproto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "ba57c59ff3fad19ec3a70cc47b469d9914f202a007541083274ed1a39e7b47a7", + "size_in_bytes": 387 + }, + { + "_path": "share/pkgconfig/recordproto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "af25b35da39c50c31564c85c155a8c6be80b120e2e47d0b0da44f11b02fb850e", + "size_in_bytes": 390 + }, + { + "_path": "share/pkgconfig/renderproto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "642868053c1e5ef458518713f2a1a607788b74b73f2fee5a3946c66c402e1e5a", + "size_in_bytes": 389 + }, + { + "_path": "share/pkgconfig/resourceproto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "e9b6561e1d2a362130deec151d7986d1cac7c06d0ba3965b56121a386d63d6aa", + "size_in_bytes": 393 + }, + { + "_path": "share/pkgconfig/scrnsaverproto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "7352e2679d32dce803888b1d0973002c77b5b817bdf524d3c89c3a3ed9c2dff3", + "size_in_bytes": 395 + }, + { + "_path": "share/pkgconfig/videoproto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "6a02934efaef47d41857499e40815fc48edbb6886a0df3600c7e026a1e7039fd", + "size_in_bytes": 386 + }, + { + "_path": "share/pkgconfig/xcmiscproto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "d96a491237f97a2b98668210687443870271449b533d733453dfcf5d12444ebe", + "size_in_bytes": 389 + }, + { + "_path": "share/pkgconfig/xextproto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "cb435bce5fcaeb2e8016237ae83be4aed802abf50f740e0632a1c7f3df2cb553", + "size_in_bytes": 385 + }, + { + "_path": "share/pkgconfig/xf86bigfontproto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "7b88ff24f536c572d79b4f400c7d0bdc3434a1e0a0ffb874079f5532ce30ca6b", + "size_in_bytes": 399 + }, + { + "_path": "share/pkgconfig/xf86dgaproto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "197ca48cf2c117c4a4984b76a5585f5043589b5c9e344ce9e03571ad97289b5c", + "size_in_bytes": 389 + }, + { + "_path": "share/pkgconfig/xf86driproto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "2225bf7998fa1d2d0fb15137e1d3c43bd3840b2cac7673695d3899f9a630db4b", + "size_in_bytes": 399 + }, + { + "_path": "share/pkgconfig/xf86vidmodeproto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "5be0eded010ed7bbc7204daf9a38e9aff1d9d92de0d41fbba6b18d0251e022bf", + "size_in_bytes": 399 + }, + { + "_path": "share/pkgconfig/xineramaproto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "048daf03ee56be99a48fe74686bd1a36c4dc80b2c9029cd477feba065fd4d326", + "size_in_bytes": 393 + }, + { + "_path": "share/pkgconfig/xproto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "050752f0181689bb230da617fc1928dbf09d6ba94f972eb373969750bd6a95a2", + "size_in_bytes": 411 + }, + { + "_path": "share/pkgconfig/xwaylandproto.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl", + "sha256": "9b6bdded4c0fd1b106e623a08c54815d80e0de9fe95ca00845f50d8ab2fa4b12", + "size_in_bytes": 390 + } + ], + "paths_version": 1 +} \ No newline at end of file diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/0001-windows-fds-bits.patch b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/0001-windows-fds-bits.patch new file mode 100644 index 0000000000000000000000000000000000000000..7aa35dc55f85221d5c4d08dc026ec69e654b2dd3 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/0001-windows-fds-bits.patch @@ -0,0 +1,12 @@ +diff --git a/configure.ac b/configure.ac +index 8fb5ad32d7..c8cce85375 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -55,6 +55,7 @@ AC_CHECK_HEADERS([sys/select.h sys/param.h sys/types.h sys/time.h]) + # Avoid determining fds_bits on WIN32 hosts (not including cygwin) + case $host_os in + mingw*) fds_bits_found=true;; ++ msys*) fds_bits_found=true;; + *) fds_bits_found=false;; + esac + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/bld.bat b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/bld.bat new file mode 100644 index 0000000000000000000000000000000000000000..d2d47f89334c4c1d29a7e903e3f6fa8262936428 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/bld.bat @@ -0,0 +1,18 @@ +:: Trailing semicolon in this variable as set by current (2017/01) +:: conda-build breaks us. Manual fix: +set "MSYS2_ARG_CONV_EXCL=/AI;/AL;/OUT;/out" +:: Delegate to the Unixy script. We need to translate the key path variables +:: to be Unix-y rather than Windows-y, though. +set "saved_recipe_dir=%RECIPE_DIR%" +FOR /F "delims=" %%i IN ('cygpath.exe -u -p "%PATH%"') DO set "PATH_OVERRIDE=%%i" +FOR /F "delims=" %%i IN ('cygpath.exe -m "%BUILD_PREFIX%"') DO set "BUILD_PREFIX_M=%%i" +FOR /F "delims=" %%i IN ('cygpath.exe -m "%LIBRARY_PREFIX%"') DO set "LIBRARY_PREFIX_M=%%i" +FOR /F "delims=" %%i IN ('cygpath.exe -u "%LIBRARY_PREFIX%"') DO set "LIBRARY_PREFIX_U=%%i" +FOR /F "delims=" %%i IN ('cygpath.exe -u "%PREFIX%"') DO set "PREFIX=%%i" +FOR /F "delims=" %%i IN ('cygpath.exe -u "%PYTHON%"') DO set "PYTHON=%%i" +FOR /F "delims=" %%i IN ('cygpath.exe -u "%RECIPE_DIR%"') DO set "RECIPE_DIR=%%i" +FOR /F "delims=" %%i IN ('cygpath.exe -u "%SP_DIR%"') DO set "SP_DIR=%%i" +FOR /F "delims=" %%i IN ('cygpath.exe -u "%SRC_DIR%"') DO set "SRC_DIR=%%i" +FOR /F "delims=" %%i IN ('cygpath.exe -u "%STDLIB_DIR%"') DO set "STDLIB_DIR=%%i" +bash -x %saved_recipe_dir%\build.sh +if errorlevel 1 exit 1 diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/build.sh b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/build.sh new file mode 100644 index 0000000000000000000000000000000000000000..6fdcafd4462f01f5ff7ef5343d5036b0ef19b202 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/build.sh @@ -0,0 +1,53 @@ +#! /bin/bash +# Get an updated config.sub and config.guess +cp $BUILD_PREFIX/share/gnuconfig/config.* . + +set -e + +# Adopt a Unix-friendly path if we're on Windows (see bld.bat). +[ -n "$PATH_OVERRIDE" ] && export PATH="$PATH_OVERRIDE" + +# On Windows we want $LIBRARY_PREFIX in both "mixed" (C:/Conda/...) and Unix +# (/c/Conda) forms, but Unix form is often "/" which can cause problems. +if [ -n "$LIBRARY_PREFIX_M" ] ; then + mprefix="$LIBRARY_PREFIX_M" + if [ "$LIBRARY_PREFIX_U" = / ] ; then + uprefix="" + else + uprefix="$LIBRARY_PREFIX_U" + fi +else + mprefix="$PREFIX" + uprefix="$PREFIX" +fi + +# On Windows we need to regenerate the configure scripts. +if [ -n "$CYGWIN_PREFIX" ] ; then + am_version=1.15 # keep sync'ed with meta.yaml + export ACLOCAL=aclocal-$am_version + export AUTOMAKE=automake-$am_version + autoreconf_args=( + --force + --install + -I "$mprefix/share/aclocal" + -I "$BUILD_PREFIX_M/Library/usr/share/aclocal" + ) + autoreconf "${autoreconf_args[@]}" +else + # Get an updated config.sub and config.guess + cp -f $BUILD_PREFIX/share/gnuconfig/config.* . +fi + +export PKG_CONFIG_LIBDIR=$uprefix/lib/pkgconfig:$uprefix/share/pkgconfig +configure_args=( + --prefix=$mprefix + --disable-dependency-tracking + --disable-silent-rules +) +./configure "${configure_args[@]}" +make -j$CPU_COUNT +make install + +if [[ "${CONDA_BUILD_CROSS_COMPILATION:-}" != "1" || "${CROSSCOMPILING_EMULATOR}" != "" ]]; then + make check +fi diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/conda_build_config.yaml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/conda_build_config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f23223bce74a3e324c2efa8c6a3119d5ce25c4ce --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/conda_build_config.yaml @@ -0,0 +1,107 @@ +VERBOSE_AT: V=1 +VERBOSE_CM: VERBOSE=1 +blas_impl: mkl +boost: '1.82' +boost_cpp: '1.82' +bzip2: '1.0' +c_compiler: gcc +c_compiler_version: 11.2.0 +cairo: '1.16' +cgo_compiler: go-cgo +cgo_compiler_version: '1.21' +channel_targets: defaults +clang_variant: clang +cpu_optimization_target: nocona +cran_mirror: https://cran.r-project.org +cuda_compiler: cuda-nvcc +cuda_compiler_version: '12.4' +cxx_compiler: gxx +cxx_compiler_version: 11.2.0 +cyrus_sasl: 2.1.28 +dbus: '1' +expat: '2' +extend_keys: +- pin_run_as_build +- extend_keys +- ignore_build_only_deps +- ignore_version +fontconfig: '2.14' +fortran_compiler: gfortran +fortran_compiler_version: 11.2.0 +freetype: '2.10' +g2clib: '1.6' +geos: 3.10.6 +giflib: '5' +glib: '2' +gmp: '6.3' +gnu: 2.12.2 +go_compiler: go-nocgo +go_compiler_version: '1.21' +gst_plugins_base: '1.24' +gstreamer: '1.24' +harfbuzz: '10' +hdf4: '4.2' +hdf5: 1.14.5 +hdfeos2: '2.20' +hdfeos5: '5.1' +icu: '73' +ignore_build_only_deps: +- python +- numpy +jpeg: '9' +libabseil: '20250127.0' +libcurl: 8.1.1 +libdap4: '3.19' +libffi: '3.4' +libgd: 2.3.3 +libgdal: 3.6.2 +libgrpc: 1.71.0 +libgsasl: '1.10' +libkml: '1.3' +libnetcdf: '4.8' +libpng: '1.6' +libprotobuf: 5.29.3 +libtiff: '4.7' +libwebp: 1.3.2 +libxml2: '2.13' +libxslt: '1.1' +llvm_variant: llvm +lua: '5' +lzo: '2' +mkl: 2023.* +mpfr: '4' +numpy: '2.0' +openblas: 0.3.21 +openjpeg: '2.3' +openssl: '3.0' +perl: '5.38' +pin_run_as_build: + python: + max_pin: x.x + min_pin: x.x + r-base: + max_pin: x.x + min_pin: x.x + libboost: + max_pin: x.x.x +pixman: '0.40' +proj: 9.3.1 +proj4: 5.2.0 +python: '3.10' +python_impl: cpython +python_implementation: cpython +r_base: 4.3.1 +r_implementation: r-base +r_version: 4.3.1 +readline: '8.1' +rust_compiler: rust +rust_compiler_version: 1.82.0 +sqlite: '3' +target_platform: linux-64 +tk: '8.6' +xz: '5' +zip_keys: +- - python + - numpy +zlib: '1.2' +zstd: 1.5.2 diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-applewmproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-applewmproto new file mode 100644 index 0000000000000000000000000000000000000000..be403fdec7fe5dec8d396199fc3e2135c13191dc --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-applewmproto @@ -0,0 +1,27 @@ +/************************************************************************** + +Copyright (c) 2002-2009 Apple, Inc. +All Rights Reserved. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sub license, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice (including the +next paragraph) shall be included in all copies or substantial portions +of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. +IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +**************************************************************************/ + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-bigreqsproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-bigreqsproto new file mode 100644 index 0000000000000000000000000000000000000000..142f2fab0b46336b9853e485a163ed5b9134bc52 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-bigreqsproto @@ -0,0 +1,21 @@ +Copyright 1992, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-compositeproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-compositeproto new file mode 100644 index 0000000000000000000000000000000000000000..b541db83f8dba561a9a04d2b3c222d097007bcba --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-compositeproto @@ -0,0 +1,41 @@ +Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice (including the next +paragraph) shall be included in all copies or substantial portions of the +Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. + +Copyright © 2003 Keith Packard + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation, and that the name of Keith Packard not be used in +advertising or publicity pertaining to distribution of the software without +specific, written prior permission. Keith Packard makes no +representations about the suitability of this software for any purpose. It +is provided "as is" without express or implied warranty. + +KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO +EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR +CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-damageproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-damageproto new file mode 100644 index 0000000000000000000000000000000000000000..d14c75a80c883fd083c307bf800a379647e25ea8 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-damageproto @@ -0,0 +1,21 @@ +Copyright © 2001,2003 Keith Packard +Copyright © 2007 Eric Anholt + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation, and that the name of Keith Packard not be used in +advertising or publicity pertaining to distribution of the software without +specific, written prior permission. Keith Packard makes no +representations about the suitability of this software for any purpose. It +is provided "as is" without express or implied warranty. + +KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO +EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR +CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-dmxproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-dmxproto new file mode 100644 index 0000000000000000000000000000000000000000..7ea03ea2aea2764b868c6f6fd2e16adf78898123 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-dmxproto @@ -0,0 +1,24 @@ +Copyright 2002-2004 Red Hat Inc., Durham, North Carolina. + +All Rights Reserved. + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation on the rights to use, copy, modify, merge, +publish, distribute, sublicense, and/or sell copies of the Software, +and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice (including the +next paragraph) shall be included in all copies or substantial +portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NON-INFRINGEMENT. IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS +BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-dri2proto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-dri2proto new file mode 100644 index 0000000000000000000000000000000000000000..a99b75ab4928c82dd383c2822d1c0ad303ab83ea --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-dri2proto @@ -0,0 +1,29 @@ +Copyright © 2007 Red Hat, Inc. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Soft- +ware"), to deal in the Software without restriction, including without +limitation the rights to use, copy, modify, merge, publish, distribute, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, provided that the above copyright +notice(s) and this permission notice appear in all copies of the Soft- +ware and that both the above copyright notice(s) and this permission +notice appear in supporting documentation. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL- +ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY +RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN +THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSE- +QUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFOR- +MANCE OF THIS SOFTWARE. + +Except as contained in this notice, the name of a copyright holder shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization of +the copyright holder. + +Authors: + Kristian Høgsberg (krh@redhat.com) diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-dri3proto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-dri3proto new file mode 100644 index 0000000000000000000000000000000000000000..8dcf1d489b5c9dccf284f4810aa9ee19c38a4788 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-dri3proto @@ -0,0 +1,19 @@ +Copyright © 2013 Keith Packard + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that copyright +notice and this permission notice appear in supporting documentation, and +that the name of the copyright holders not be used in advertising or +publicity pertaining to distribution of the software without specific, +written prior permission. The copyright holders make no representations +about the suitability of this software for any purpose. It is provided "as +is" without express or implied warranty. + +THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO +EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR +CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE +OF THIS SOFTWARE. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-evieproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-evieproto new file mode 100644 index 0000000000000000000000000000000000000000..316475fbba6dffceb948b95f2577275a1c5c50da --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-evieproto @@ -0,0 +1,20 @@ +Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice (including the next +paragraph) shall be included in all copies or substantial portions of the +Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-fixesproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-fixesproto new file mode 100644 index 0000000000000000000000000000000000000000..c8114fef98b78857abd00a5e7fdebf541774e440 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-fixesproto @@ -0,0 +1,42 @@ +Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved. +Copyright 2010 Red Hat, Inc. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice (including the next +paragraph) shall be included in all copies or substantial portions of the +Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. + +Copyright © 2001,2003 Keith Packard + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation, and that the name of Keith Packard not be used in +advertising or publicity pertaining to distribution of the software without +specific, written prior permission. Keith Packard makes no +representations about the suitability of this software for any purpose. It +is provided "as is" without express or implied warranty. + +KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO +EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR +CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-fontcacheproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-fontcacheproto new file mode 100644 index 0000000000000000000000000000000000000000..3e473adcaa8ade1acfa9d49fd019a2672c3755b9 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-fontcacheproto @@ -0,0 +1,24 @@ +Copyright (c) 1998-1999 Shunsuke Akiyama . +All rights reserved. +Copyright (c) 1998-1999 X-TrueType Server Project, All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +SUCH DAMAGE. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-fontsproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-fontsproto new file mode 100644 index 0000000000000000000000000000000000000000..eac45aaedc80e8693fa9b5451ca712c5b785d67d --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-fontsproto @@ -0,0 +1,86 @@ +Copyright 1990, 1991 Network Computing Devices; +Portions Copyright 1987 by Digital Equipment Corporation + +Permission to use, copy, modify, distribute, and sell this software and +its documentation for any purpose is hereby granted without fee, provided +that the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation, and that the names of Network Computing Devices or Digital +not be used in advertising or publicity pertaining to distribution +of the software without specific, written prior permission. +Network Computing Devices and Digital make no representations +about the suitability of this software for any purpose. It is provided +"as is" without express or implied warranty. + +NETWORK COMPUTING DEVICES AND DIGITAL DISCLAIM ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES +OR DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL +DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR +PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS +ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF +THIS SOFTWARE. + + +Copyright 1990, 1991, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + + +Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Digital not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + + +Copyright (c) 1999 The XFree86 Project Inc. + +All Rights Reserved. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The XFree86 Project +Inc. shall not be used in advertising or otherwise to promote the +sale, use or other dealings in this Software without prior written +authorization from The XFree86 Project Inc.. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-glproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-glproto new file mode 100644 index 0000000000000000000000000000000000000000..78b6de44f83664a7bb4f306cc74c75a4c769b3b7 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-glproto @@ -0,0 +1,27 @@ +SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008) +Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice including the dates of first publication and +either this permission notice or a reference to +http://oss.sgi.com/projects/FreeB/ +shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF +OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +Except as contained in this notice, the name of Silicon Graphics, Inc. +shall not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization from +Silicon Graphics, Inc. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-inputproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-inputproto new file mode 100644 index 0000000000000000000000000000000000000000..f0b75c0d7f3a52cddc252ae01ccaccb7281ba7fa --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-inputproto @@ -0,0 +1,63 @@ +Copyright 1989, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +Copyright 1989 by Hewlett-Packard Company, Palo Alto, California. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Hewlett-Packard not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +HEWLETT-PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +HEWLETT-PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + +Copyright © 2009 Red Hat, Inc. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice (including the next +paragraph) shall be included in all copies or substantial portions of the +Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-kbproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-kbproto new file mode 100644 index 0000000000000000000000000000000000000000..6f12c2f4d7c659aee131ef4837b8838c5ffdce15 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-kbproto @@ -0,0 +1,22 @@ +Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc. + +Permission to use, copy, modify, and distribute this +software and its documentation for any purpose and without +fee is hereby granted, provided that the above copyright +notice appear in all copies and that both that copyright +notice and this permission notice appear in supporting +documentation, and that the name of Silicon Graphics not be +used in advertising or publicity pertaining to distribution +of the software without specific prior written permission. +Silicon Graphics makes no representation about the suitability +of this software for any purpose. It is provided "as is" +without any express or implied warranty. + +SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS +SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON +GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL +DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE +OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH +THE USE OR PERFORMANCE OF THIS SOFTWARE. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-lg3dproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-lg3dproto new file mode 100644 index 0000000000000000000000000000000000000000..03b626225ee59523b915ed2b26e9387ed187a61e --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-lg3dproto @@ -0,0 +1,22 @@ + +Copyright (c) 2004, Sun Microsystems, Inc. + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +SUN MICROSYSTEMS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of Sun Microsystems shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from Sun Microsystems. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-pmproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-pmproto new file mode 100644 index 0000000000000000000000000000000000000000..3ce03b5d446a0044d05002ab92e5340915494bab --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-pmproto @@ -0,0 +1,24 @@ +Copyright 1996, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-presentproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-presentproto new file mode 100644 index 0000000000000000000000000000000000000000..8dcf1d489b5c9dccf284f4810aa9ee19c38a4788 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-presentproto @@ -0,0 +1,19 @@ +Copyright © 2013 Keith Packard + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that copyright +notice and this permission notice appear in supporting documentation, and +that the name of the copyright holders not be used in advertising or +publicity pertaining to distribution of the software without specific, +written prior permission. The copyright holders make no representations +about the suitability of this software for any purpose. It is provided "as +is" without express or implied warranty. + +THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO +EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR +CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE +OF THIS SOFTWARE. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-printproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-printproto new file mode 100644 index 0000000000000000000000000000000000000000..3b590a8f8301851dde69292e2f9b088c3b4d08b3 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-printproto @@ -0,0 +1,29 @@ +(c) Copyright 1996 Hewlett-Packard Company +(c) Copyright 1996 International Business Machines Corp. +(c) Copyright 1996, Oracle and/or its affiliates. All rights reserved. +(c) Copyright 1996 Novell, Inc. +(c) Copyright 1996 Digital Equipment Corp. +(c) Copyright 1996 Fujitsu Limited +(c) Copyright 1996 Hitachi, Ltd. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the names of the copyright holders shall +not be used in advertising or otherwise to promote the sale, use or other +dealings in this Software without prior written authorization from said +copyright holders. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-randrproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-randrproto new file mode 100644 index 0000000000000000000000000000000000000000..4ae7cc03b2d9e5a638147e275126ff6fba524b5a --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-randrproto @@ -0,0 +1,22 @@ +Copyright © 2000 Compaq Computer Corporation +Copyright © 2002 Hewlett-Packard Company +Copyright © 2006 Intel Corporation +Copyright © 2008 Red Hat, Inc. + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that copyright +notice and this permission notice appear in supporting documentation, and +that the name of the copyright holders not be used in advertising or +publicity pertaining to distribution of the software without specific, +written prior permission. The copyright holders make no representations +about the suitability of this software for any purpose. It is provided "as +is" without express or implied warranty. + +THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO +EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR +CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE +OF THIS SOFTWARE. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-recordproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-recordproto new file mode 100644 index 0000000000000000000000000000000000000000..ae257264d252c397da3bae40ae4a37c159a61585 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-recordproto @@ -0,0 +1,17 @@ +Copyright 1995 Network Computing Devices + +Permission to use, copy, modify, distribute, and sell this software and +its documentation for any purpose is hereby granted without fee, provided +that the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation, and that the name of Network Computing Devices +not be used in advertising or publicity pertaining to distribution +of the software without specific, written prior permission. + +NETWORK COMPUTING DEVICES DISCLAIMs ALL WARRANTIES WITH REGARD TO +THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS, IN NO EVENT SHALL NETWORK COMPUTING DEVICES BE LIABLE +FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN +AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING +OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-renderproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-renderproto new file mode 100644 index 0000000000000000000000000000000000000000..f330a5d70b054047666062d9b8b137839d4a7e90 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-renderproto @@ -0,0 +1,20 @@ +Copyright © 2000 SuSE, Inc. + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation, and that the name of SuSE not be used in advertising or +publicity pertaining to distribution of the software without specific, +written prior permission. SuSE makes no representations about the +suitability of this software for any purpose. It is provided "as is" +without express or implied warranty. + +SuSE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL SuSE +BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION +OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +Author: Keith Packard, SuSE, Inc. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-resourceproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-resourceproto new file mode 100644 index 0000000000000000000000000000000000000000..d878fd6914b87c191752defc2f7a20bf91bb9461 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-resourceproto @@ -0,0 +1,22 @@ +Copyright (c) 2002 XFree86 Inc + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of the XFree86 Project shall not +be used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from the XFree86 Project. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-scrnsaverproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-scrnsaverproto new file mode 100644 index 0000000000000000000000000000000000000000..8d5f08739ae412a0adda486eefae048db2827edd --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-scrnsaverproto @@ -0,0 +1,24 @@ +Copyright (c) 1992 X Consortium + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of the X Consortium shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from the X Consortium. + +Author: Keith Packard, MIT X Consortium diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-trapproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-trapproto new file mode 100644 index 0000000000000000000000000000000000000000..3ebeac698d5cf35dd3ee6d4dbc04c0f133a5be15 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-trapproto @@ -0,0 +1,18 @@ +Copyright 1987, 1988, 1989, 1990, 1994 by Digital Equipment Corporation, +Maynard, MA + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Digital not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-videoproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-videoproto new file mode 100644 index 0000000000000000000000000000000000000000..28dd80b05cf0c1c4165355a467ecb7e89b72584b --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-videoproto @@ -0,0 +1,63 @@ +Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts, +and the Massachusetts Institute of Technology, Cambridge, Massachusetts. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the names of Digital or MIT not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of the XFree86 Project shall not +be used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from the XFree86 Project. + + +Copyright (c) 2004 The Unichrome Project. All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHOR(S) OR COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-windowswmproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-windowswmproto new file mode 100644 index 0000000000000000000000000000000000000000..55a98f73432cff542f852eac33c2a42988328b98 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-windowswmproto @@ -0,0 +1,23 @@ +Copyright (c) 2002 Apple Computer, Inc. +All Rights Reserved. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sub license, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice (including the +next paragraph) shall be included in all copies or substantial portions +of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. +IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-x11proto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-x11proto new file mode 100644 index 0000000000000000000000000000000000000000..03c358212c7172db1440ab74637fc7aa984dbe98 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-x11proto @@ -0,0 +1,108 @@ +Copyright (c) 1991, Oracle and/or its affiliates. All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice (including the next +paragraph) shall be included in all copies or substantial portions of the +Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. + + +Copyright 1985, 1987, 1988, 1990, 1991, 1993-1996, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +The X Window System is a Trademark of The Open Group. + + +Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Digital not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + + +Copyright 1987 by Apollo Computer Inc., Chelmsford, Massachusetts. +Copyright 1989 by Hewlett-Packard Company. + + All Rights Reserved + +Permission to use, duplicate, change, and distribute this software and +its documentation for any purpose and without fee is granted, provided +that the above copyright notice appear in such copy and that this +copyright notice appear in all supporting documentation, and that the +names of Apollo Computer Inc., the Hewlett-Packard Company, or the X +Consortium not be used in advertising or publicity pertaining to +distribution of the software without written prior permission. + +HEWLETT-PACKARD MAKES NO WARRANTY OF ANY KIND WITH REGARD +TO THIS SOFTWARE, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. Hewlett-Packard shall not be liable for errors +contained herein or direct, indirect, special, incidental or +consequential damages in connection with the furnishing, +performance, or use of this material. + + +Copyright (c) 1999 The XFree86 Project Inc. + +All Rights Reserved. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The XFree86 Project +Inc. shall not be used in advertising or otherwise to promote the +sale, use or other dealings in this Software without prior written +authorization from The XFree86 Project Inc. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-xcmiscproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-xcmiscproto new file mode 100644 index 0000000000000000000000000000000000000000..782a1ecc093600e140a74ee072c284da2027803e --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-xcmiscproto @@ -0,0 +1,21 @@ +Copyright 1993, 1994, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-xextproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-xextproto new file mode 100644 index 0000000000000000000000000000000000000000..23135f95a721ae7c9d3f76a92c556f2db6f7aa7f --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-xextproto @@ -0,0 +1,201 @@ +Copyright 1989, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + + +Copyright (c) 1997 by Silicon Graphics Computer Systems, Inc. +Permission to use, copy, modify, and distribute this +software and its documentation for any purpose and without +fee is hereby granted, provided that the above copyright +notice appear in all copies and that both that copyright +notice and this permission notice appear in supporting +documentation, and that the name of Silicon Graphics not be +used in advertising or publicity pertaining to distribution +of the software without specific prior written permission. +Silicon Graphics makes no representation about the suitability +of this software for any purpose. It is provided "as is" +without any express or implied warranty. +SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS +SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON +GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL +DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE +OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH +THE USE OR PERFORMANCE OF THIS SOFTWARE. + + +Copyright 1992 Network Computing Devices + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation, and that the name of NCD. not be used in advertising or +publicity pertaining to distribution of the software without specific, +written prior permission. NCD. makes no representations about the +suitability of this software for any purpose. It is provided "as is" +without express or implied warranty. + +NCD. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NCD. +BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION +OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + + +Copyright (c) 1994, 1995 Hewlett-Packard Company + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL HEWLETT-PACKARD COMPANY BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR +THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of the Hewlett-Packard +Company shall not be used in advertising or otherwise to promote the +sale, use or other dealings in this Software without prior written +authorization from the Hewlett-Packard Company. + + +Copyright (c) 1996 Digital Equipment Corporation, Maynard, Massachusetts. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +DIGITAL EQUIPMENT CORPORATION BE LIABLE FOR ANY CLAIM, DAMAGES, INCLUDING, +BUT NOT LIMITED TO CONSEQUENTIAL OR INCIDENTAL DAMAGES, OR OTHER LIABILITY, +WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR +IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of Digital Equipment Corporation +shall not be used in advertising or otherwise to promote the sale, use or other +dealings in this Software without prior written authorization from Digital +Equipment Corporation. + + +Copyright 1988, 1989, 1990, 1994 Network Computing Devices, Inc. + +Permission to use, copy, modify, distribute, and sell this software and +its documentation for any purpose is hereby granted without fee, provided +that the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation, and that the name Network Computing Devices, Inc. not be +used in advertising or publicity pertaining to distribution of this +software without specific, written prior permission. + +THIS SOFTWARE IS PROVIDED `AS-IS'. NETWORK COMPUTING DEVICES, INC., +DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING WITHOUT +LIMITATION ALL IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +PARTICULAR PURPOSE, OR NONINFRINGEMENT. IN NO EVENT SHALL NETWORK +COMPUTING DEVICES, INC., BE LIABLE FOR ANY DAMAGES WHATSOEVER, INCLUDING +SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES, INCLUDING LOSS OF USE, +DATA, OR PROFITS, EVEN IF ADVISED OF THE POSSIBILITY THEREOF, AND +REGARDLESS OF WHETHER IN AN ACTION IN CONTRACT, TORT OR NEGLIGENCE, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + + +Copyright 1991,1993 by Digital Equipment Corporation, Maynard, Massachusetts, +and Olivetti Research Limited, Cambridge, England. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the names of Digital or Olivetti +not be used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL AND OLIVETTI DISCLAIM ALL WARRANTIES WITH REGARD TO THIS +SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS, IN NO EVENT SHALL THEY BE LIABLE FOR ANY SPECIAL, INDIRECT OR +CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF +USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. + + +Copyright 1986, 1987, 1988 by Hewlett-Packard Corporation + +Permission to use, copy, modify, and distribute this +software and its documentation for any purpose and without +fee is hereby granted, provided that the above copyright +notice appear in all copies and that both that copyright +notice and this permission notice appear in supporting +documentation, and that the name of Hewlett-Packard not be used in +advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +Hewlett-Packard makes no representations about the +suitability of this software for any purpose. It is provided +"as is" without express or implied warranty. + +This software is not subject to any license of the American +Telephone and Telegraph Company or of the Regents of the +University of California. + + +Copyright © 2007-2008 Peter Hutterer + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice (including the next +paragraph) shall be included in all copies or substantial portions of the +Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-xf86bigfontproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-xf86bigfontproto new file mode 100644 index 0000000000000000000000000000000000000000..9f1e99973997a509b5da95bb08f3092450cc704c --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-xf86bigfontproto @@ -0,0 +1,20 @@ +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of the XFree86 Project shall not +be used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from the XFree86 Project. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-xf86dgaproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-xf86dgaproto new file mode 100644 index 0000000000000000000000000000000000000000..9f1e99973997a509b5da95bb08f3092450cc704c --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-xf86dgaproto @@ -0,0 +1,20 @@ +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of the XFree86 Project shall not +be used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from the XFree86 Project. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-xf86driproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-xf86driproto new file mode 100644 index 0000000000000000000000000000000000000000..26b6878727821440304c9214db1ca3eef4854e3f --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-xf86driproto @@ -0,0 +1,24 @@ +Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas. +Copyright 2000 VA Linux Systems, Inc. +All Rights Reserved. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sub license, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice (including the +next paragraph) shall be included in all copies or substantial portions +of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. +IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-xf86miscproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-xf86miscproto new file mode 100644 index 0000000000000000000000000000000000000000..9f1e99973997a509b5da95bb08f3092450cc704c --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-xf86miscproto @@ -0,0 +1,20 @@ +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of the XFree86 Project shall not +be used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from the XFree86 Project. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-xf86rushproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-xf86rushproto new file mode 100644 index 0000000000000000000000000000000000000000..9f1e99973997a509b5da95bb08f3092450cc704c --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-xf86rushproto @@ -0,0 +1,20 @@ +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of the XFree86 Project shall not +be used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from the XFree86 Project. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-xf86vidmodeproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-xf86vidmodeproto new file mode 100644 index 0000000000000000000000000000000000000000..bc845c03c81cece535b7e9118abd29d5f253e79f --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-xf86vidmodeproto @@ -0,0 +1,25 @@ +Copyright 1995 Kaleb S. KEITHLEY + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL Kaleb S. KEITHLEY BE LIABLE FOR ANY CLAIM, DAMAGES +OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of Kaleb S. KEITHLEY +shall not be used in advertising or otherwise to promote the sale, use +or other dealings in this Software without prior written authorization +from Kaleb S. KEITHLEY diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-xineramaproto b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-xineramaproto new file mode 100644 index 0000000000000000000000000000000000000000..54284fc88006902b8acdf505baeed5a4f8caa665 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/licenses/COPYING-xineramaproto @@ -0,0 +1,45 @@ +Copyright 2003 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + + +Copyright (c) 1991, 1997 Digital Equipment Corporation, Maynard, Massachusetts. +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software. + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +DIGITAL EQUIPMENT CORPORATION BE LIABLE FOR ANY CLAIM, DAMAGES, INCLUDING, +BUT NOT LIMITED TO CONSEQUENTIAL OR INCIDENTAL DAMAGES, OR OTHER LIABILITY, +WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR +IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of Digital Equipment Corporation +shall not be used in advertising or otherwise to promote the sale, use or other +dealings in this Software without prior written authorization from Digital +Equipment Corporation. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/meta.yaml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/meta.yaml new file mode 100644 index 0000000000000000000000000000000000000000..8f39294d6e740619dd7cc8d58b78a91d34d3344e --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/meta.yaml @@ -0,0 +1,93 @@ +# This file created by conda-build 24.1.2 +# meta.yaml template originally from: +# /feedstock/recipe, last modified Wed Apr 30 20:50:02 2025 +# ------------------------------------------------ + +package: + name: xorg-xorgproto + version: '2024.1' +source: + patches: null + sha256: 372225fd40815b8423547f5d890c5debc72e88b91088fbfb13158c20495ccb59 + url: https://www.x.org/releases/individual/proto/xorgproto-2024.1.tar.xz +build: + number: '1' + run_exports: + - xorg-xorgproto >=2024.1,<2025.0a0 + string: h5eee18b_1 +requirements: + build: + - _libgcc_mutex 0.1 main + - _openmp_mutex 5.1 1_gnu + - _sysroot_linux-64_curr_repodata_hack 3 haa98f57_10 + - binutils_impl_linux-64 2.40 h5293946_0 + - binutils_linux-64 2.40.0 hc2dff05_2 + - gcc_impl_linux-64 11.2.0 h1234567_1 + - gcc_linux-64 11.2.0 h5c386dc_2 + - gnuconfig 2021.05.24 hd3eb1b0_0 + - kernel-headers_linux-64 3.10.0 h57e8cba_10 + - ld_impl_linux-64 2.40 h12ee557_0 + - libgcc-devel_linux-64 11.2.0 h1234567_1 + - libgcc-ng 11.2.0 h1234567_1 + - libgomp 11.2.0 h1234567_1 + - libstdcxx-ng 11.2.0 h1234567_1 + - make 4.2.1 h1bed415_1 + - pkg-config 0.29.2 h1bed415_8 + - sysroot_linux-64 2.17 h57e8cba_10 + host: + - _libgcc_mutex 0.1 main + - _openmp_mutex 5.1 1_gnu + - libgcc-ng 11.2.0 h1234567_1 + - libgomp 11.2.0 h1234567_1 + - xorg-util-macros 1.19.0 h27cfd23_2 + run: + - libgcc-ng >=11.2.0 + run_constrained: + - xorg-applewmproto <0.0.0a + - xorg-bigreqsproto <0.0.0a + - xorg-compositeproto <0.0.0a + - xorg-damageproto <0.0.0a + - xorg-dmxproto <0.0.0a + - xorg-dpmsproto <0.0.0a + - xorg-dri2proto <0.0.0a + - xorg-dri3proto <0.0.0a + - xorg-fixesproto <0.0.0a + - xorg-fontsproto <0.0.0a + - xorg-glproto <0.0.0a + - xorg-inputproto <0.0.0a + - xorg-kbproto <0.0.0a + - xorg-presentproto <0.0.0a + - xorg-randrproto <0.0.0a + - xorg-recordproto <0.0.0a + - xorg-renderproto <0.0.0a + - xorg-resourceproto <0.0.0a + - xorg-scrnsaverproto <0.0.0a + - xorg-videoproto <0.0.0a + - xorg-xcmiscproto <0.0.0a + - xorg-xextproto <0.0.0a + - xorg-xf86bigfontproto <0.0.0a + - xorg-xf86dgaproto <0.0.0a + - xorg-xf86driproto <0.0.0a + - xorg-xf86vidmodeproto <0.0.0a + - xorg-xineramaproto <0.0.0a + - xorg-xproto <0.0.0a + - xorg-xwaylandproto <0.0.0a +test: + commands: + - test -e $PREFIX/include/X11/extensions/damageproto.h +about: + dev_url: https://gitlab.freedesktop.org/xorg/proto/xorgproto + doc_url: https://gitlab.freedesktop.org/xorg/proto/xorgproto + home: https://www.x.org/ + license: MIT + license_family: MIT + license_file: licenses/ + summary: X.org protocol headers +extra: + copy_test_source_files: true + final: true + flow_run_id: af31ccde-d9c4-4092-88fc-ffbd455029a7 + recipe-maintainers: + - pkgw + remote_url: git@github.com:AnacondaRecipes/xorg-xorgproto-feedstock.git + sha: edf34136111283bca6f43abd1ac347df754626ff diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/meta.yaml.template b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/meta.yaml.template new file mode 100644 index 0000000000000000000000000000000000000000..b862967581799e06c41b9d93d3c2724e11cea8c3 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/recipe/meta.yaml.template @@ -0,0 +1,85 @@ +{% set xorg_name = "xorgproto" %} +{% set xorg_category = "proto" %} +{% set name = "xorg-" ~ xorg_name %} +{% set version = "2024.1" %} +{% set sha256 = "372225fd40815b8423547f5d890c5debc72e88b91088fbfb13158c20495ccb59" %} +{% set am_version = "1.15" %} # keep synchronized with build.sh + +package: + name: {{ name|lower }} + version: {{ version }} + +source: + url: https://www.x.org/releases/individual/{{ xorg_category }}/{{ xorg_name }}-{{ version }}.tar.xz + sha256: {{ sha256 }} + patches: + - 0001-windows-fds-bits.patch # [win] + +build: + number: 1 + run_exports: + - {{ pin_subpackage('xorg-xorgproto') }} + +requirements: + build: + - m2-autoconf # [win] + - m2-automake{{ am_version }} # [win] + - m2-libtool # [win] + - pkg-config # [unix] + - m2-pkg-config # [win] + - gnuconfig # [unix] + - m2-base # [win] + - make # [unix] + - m2-make # [win] + - gnuconfig # [unix] + - {{ compiler('c') }} # [unix] + - {{ compiler('m2w64_c') }} # [win] + host: + - xorg-util-macros + run_constrained: + - xorg-applewmproto <0.0.0a + - xorg-bigreqsproto <0.0.0a + - xorg-compositeproto <0.0.0a + - xorg-damageproto <0.0.0a + - xorg-dmxproto <0.0.0a + - xorg-dpmsproto <0.0.0a + - xorg-dri2proto <0.0.0a + - xorg-dri3proto <0.0.0a + - xorg-fixesproto <0.0.0a + - xorg-fontsproto <0.0.0a + - xorg-glproto <0.0.0a + - xorg-inputproto <0.0.0a + - xorg-kbproto <0.0.0a + - xorg-presentproto <0.0.0a + - xorg-randrproto <0.0.0a + - xorg-recordproto <0.0.0a + - xorg-renderproto <0.0.0a + - xorg-resourceproto <0.0.0a + - xorg-scrnsaverproto <0.0.0a + - xorg-videoproto <0.0.0a + - xorg-xcmiscproto <0.0.0a + - xorg-xextproto <0.0.0a + - xorg-xf86bigfontproto <0.0.0a + - xorg-xf86dgaproto <0.0.0a + - xorg-xf86driproto <0.0.0a + - xorg-xf86vidmodeproto <0.0.0a + - xorg-xineramaproto <0.0.0a + - xorg-xproto <0.0.0a + - xorg-xwaylandproto <0.0.0a + +test: + commands: + - test -e $PREFIX/include/X11/extensions/damageproto.h # [not win] + +about: + home: https://www.x.org/ + dev_url: https://gitlab.freedesktop.org/xorg/proto/xorgproto + doc_url: https://gitlab.freedesktop.org/xorg/proto/xorgproto + license: MIT + license_family: MIT + license_file: licenses/ + summary: X.org protocol headers + +extra: + recipe-maintainers: + - pkgw diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/repodata_record.json b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/repodata_record.json new file mode 100644 index 0000000000000000000000000000000000000000..80020f6326e69fbe0fc2bc7e3bace06c891babf6 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/repodata_record.json @@ -0,0 +1,52 @@ +{ + "arch": "x86_64", + "build": "h5eee18b_1", + "build_number": 1, + "channel": "https://repo.anaconda.com/pkgs/main/linux-64/", + "constrains": [ + "xorg-xextproto <0.0.0a", + "xorg-xproto <0.0.0a", + "xorg-recordproto <0.0.0a", + "xorg-randrproto <0.0.0a", + "xorg-xf86dgaproto <0.0.0a", + "xorg-xf86vidmodeproto <0.0.0a", + "xorg-xcmiscproto <0.0.0a", + "xorg-applewmproto <0.0.0a", + "xorg-damageproto <0.0.0a", + "xorg-xf86driproto <0.0.0a", + "xorg-renderproto <0.0.0a", + "xorg-kbproto <0.0.0a", + "xorg-glproto <0.0.0a", + "xorg-inputproto <0.0.0a", + "xorg-scrnsaverproto <0.0.0a", + "xorg-compositeproto <0.0.0a", + "xorg-videoproto <0.0.0a", + "xorg-xwaylandproto <0.0.0a", + "xorg-dri3proto <0.0.0a", + "xorg-fixesproto <0.0.0a", + "xorg-dri2proto <0.0.0a", + "xorg-resourceproto <0.0.0a", + "xorg-dpmsproto <0.0.0a", + "xorg-xineramaproto <0.0.0a", + "xorg-fontsproto <0.0.0a", + "xorg-dmxproto <0.0.0a", + "xorg-xf86bigfontproto <0.0.0a", + "xorg-presentproto <0.0.0a", + "xorg-bigreqsproto <0.0.0a" + ], + "depends": [ + "libgcc-ng >=11.2.0" + ], + "fn": "xorg-xorgproto-2024.1-h5eee18b_1.conda", + "license": "MIT", + "license_family": "MIT", + "md5": "412a0d97a7a51d23326e57226189da92", + "name": "xorg-xorgproto", + "platform": "linux", + "sha256": "aa6d3ab9be5b43d3e8ac0c7e23f2a83c3959f8f30ec758e2fcae91f87a9b23b4", + "size": 594175, + "subdir": "linux-64", + "timestamp": 1746046234000, + "url": "https://repo.anaconda.com/pkgs/main/linux-64/xorg-xorgproto-2024.1-h5eee18b_1.conda", + "version": "2024.1" +} \ No newline at end of file diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/run_exports.json b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/run_exports.json new file mode 100644 index 0000000000000000000000000000000000000000..949267073d85ea8c0f0dc8a628eaa5712d809a1e --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/run_exports.json @@ -0,0 +1 @@ +{"weak": ["xorg-xorgproto >=2024.1,<2025.0a0"]} \ No newline at end of file diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/test/run_test.sh b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/test/run_test.sh new file mode 100644 index 0000000000000000000000000000000000000000..54b06e65f59ea6bdf2631ab12ed56611dd7bd5f1 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/info/test/run_test.sh @@ -0,0 +1,8 @@ + + +set -ex + + + +test -e $PREFIX/include/X11/extensions/damageproto.h +exit 0 diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/bigreqsproto/bigreq.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/bigreqsproto/bigreq.xml new file mode 100644 index 0000000000000000000000000000000000000000..1d1d84d0045c6149d5953cc1aa38b47bedd9d796 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/bigreqsproto/bigreq.xml @@ -0,0 +1,332 @@ + + %defs; +]> + + + + + + Big Requests Extension + X Consortium Standard + X Version 11, Release &fullrelvers; + Version 2.0 + + + BobScheifler + X Consortium + + + 19931994X Consortium + + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of the X Consortium shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from the X Consortium. + +X Window System is a trademark of The Open Group. + + + + + +Overview + +This extension enables the use of protocol requests that exceed 262140 bytes in length. + +The core protocol restricts the maximum length of a protocol request to 262140 bytes, in that it uses a 16-bit length field specifying the number of 4-byte units in the request. This is a problem in the core protocol when joining large numbers of lines (PolyLine) or arcs (PolyArc), since these requests cannot be broken up into smaller requests without disturbing the rendering of the join points. It is also much more of a problem for protocol extensions, such as the PEX extension for 3D graphics and the XIE extension for imaging, that need to send long data lists in output commands. + +This extension defines a mechanism for extending the length field beyond 16 bits. If the normal 16-bit length field of the protocol request is zero, then an additional 32-bit field containing the actual length (in 4-byte units) is inserted into the request, immediately following the 16-bit length field. + +For example, a normal PolyLine encoding is: + + + + + + + + + + + PolyLine + + + + + 1 + 65 + + opcode + + + 1 + + + coordinate-mode + + + + 0 + Origin + + + + + 1 + Previous + + + + 2 + 3+n + + + + + 4 + DRAWABLE + + drawable + + + 4 + GCONTEXT + + gc + + + 4n + LISTofPOINT + + points + + + + + +An extended-length PolyLine encoding is: + + + + + + + + + + + PolyLine + + + + + 1 + 65 + + opcode + + + 1 + + + coordinate-mode + + + + 0 + Origin + + + + + 1 + Previous + + + + 2 + 0 + + extended length flag + + + 4 + 4+n + + request length + + + 4 + DRAWABLE + + drawable + + + 4 + GCONTEXT + + gc + + + 4n + LISTofPOINT + + points + + + + + +Extended-length protocol encodings, once enabled, can be used on all protocol requests, including all extensions. + + + +Requests + +BigReqEnable + + => + +maximum-request-length: CARD32 + +This request enables extended-length protocol requests for the requesting client. It also returns the maximum length of a request, in 4-byte units, that can be used in extended-length protocol requests. This value will always be greater than the maximum-request-length returned in the connection setup information. + + + +Events and Errors + +No new events or errors are defined by this extension. + + + +Encoding + +Please refer to the X11 Protocol Encoding document as this document uses conventions established there. + +The name of this extension is “BIG-REQUESTS”. + + + + + + + + + + BigReqEnable + + + + + 1 + Card8 + opcode + + + 1 + 0 + bigreq opcode + + + 2 + 1 + request length + + + + + + + + + + => + + + + + 1 + 1 + Reply + + + 1 + + unused + + + 2 + CARD16 + sequence number + + + 4 + 0 + length + + + 4 + CARD32 + maximum-request-length + + + 20 + + unused + + + + + + + + +C language binding + +It is desirable for core Xlib, and other extensions, to use this extension internally when necessary. It is also desirable to make the use of this extension as transparent as possible to the X client. For example, if enabling of the extension were delayed until the first time it was needed, an application that used +XNextRequest +to determine the sequence number of a request would no longer get the correct sequence number. As such, +XOpenDisplay +will determine if the extension is supported by the server and, if it is, enable extended-length encodings. + +The core Xlib functions +XDrawLines, +XDrawArcs, +XFillPolygon, +XChangeProperty, +XSetClipRectangles, and +XSetRegion. +are required to use extended-length encodings when necessary, if supported by the server. Use of extended-length encodings in other core Xlib functions +(XDrawPoints, +XDrawRectangles, +XDrawSegments. +XFillArcs, +XFillRectangles, +XPutImage +is permitted but not required; an Xlib implementation may choose to split the data across multiple smaller requests instead. + +To permit clients to know what the maximum-request-length for extended-length encodings is, the following function is added to Xlib: + + + + long XExtendedMaxRequestSize + Display *display + + + +Returns zero (0) if the specified display does not support this extension, otherwise returns the maximum-request-length (in 4-byte units) supported by the server through the extended-length encoding. + + + +Acknowledgements + +Clive Feather (IXI) originated the extended-length encoding used in this extension proposal. + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/fontsproto/fsproto.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/fontsproto/fsproto.xml new file mode 100644 index 0000000000000000000000000000000000000000..74f24286186e42435a6a0571e687609c4b7c21d0 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/fontsproto/fsproto.xml @@ -0,0 +1,4417 @@ + + %defs; +]> + + + + + + The X Font Service Protocol + X Consortium Standard + X Version 11, Release &fullrelvers; + Version 2.0 + + + JimFulton + Network Computing Devices, Inc. + + + Revised May 2, 1994 + 1991Network Computing Devices, Inc. + + + +Permission to use, copy, modify, distribute, and sell this +documentation for any purpose is hereby granted without fee, +provided that the above copyright notice and this permission +notice appear in all copies. Network Computing Devices, Inc. +makes no representations about the suitability for any purpose +of the information in this document. This documentation is +provided “as is” without express or implied warranty. + + + + +Copyright © 1994 X Consortium + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the “Software”), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + + +THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + +Except as contained in this notice, the name of the X Consortium shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from the X Consortium. + + + + + +Introduction + +The management of fonts in large, heterogeneous environments is one of the +hardest aspects of using the X Window System + +X Window System +is a trademark of The Open Group. + +. Multiple formats and the lack of +a consistent mechanism for exporting font data to all displays on a network +prevent the transparent use of applications across different display platforms. +The X Font Service protocol is designed to address this and other issues, with +specific emphasis on the needs of the core X protocol. Upward-compatible +changes (typically in the form of new requests) are expected as consensus is +reached on new features (particularly outline font support). + + +Currently, most X displays use network file protocols such as +NFS and TFTP to +obtain raw font data which they parse directly. Since a common binary format +for this data doesn't exist, displays must be able to interpret a variety of +formats if they are to be used with different application hosts. This leads to +wasted code and data space and a loss of interoperability as displays are used +in unforeseen environments. + + +By moving the interpretation of font data out of the X server into a separate +service on the network, these problems can be greatly reduced. In addition, +new technologies, such as dynamically generating bitmaps from scaled or outline +fonts, can be provided to all displays transparently. For horizontal text, +caching techniques and increased processor power can potentially make +rasterization more efficient on large, centralized hosts than on individual +displays. + + +Each font server provides sets of fonts that may be listed and queried for +header, property, glyph extents, and bitmap information. This data is +transmitted over the network using a binary format (with variations to support +different bit- and byte-orders) designed to minimize the amount of processing +required by the display. Since the font server, rather than the display, is +responsible for parsing the raw font data, new formats can be used by all +displays by modifying a single font server. + + +From the user's point of view, font servers are simply a new type of name in +the X font path. Network name services allow descriptive names (such as +DEPARTMENT-FONTS or APPLICATION-FONTS) to be translated into proper network +addresses. X displays send requests to and read replies from the font server +rather than reading directly from files. Since the X Font Service protocol is +designed to allow subsets of the font data to be requested, displays may easily +implement a variety of strategies for fine-grained demand-loading of glyphs. + + + + +Architectural Model + + + + +In this document, the words client and +server refer to the consumer and +provider of a font, respectively, unless otherwise indicated. It is important +to note that in this context, the X server is also a font client. + + +The X Font Service protocol does not require any changes to the core X protocol +or to any applications. To the user, font servers are simply additional types +of font path elements. As such, X servers may connect to multiple font +servers, as shown in Figure 2.1. Although the font protocol is geared towards +the X Window System, it may be also used by other consumers of font data (such +as printer drivers). + + +
Connecting to a Font Server + + ┌────────┐ ┌───────────────┐ + │ X1 ├──────────────┤ │ + │ Server │ │ Font Server │ + └────────┘ ┌───────┤ 1 │ + │ └───────────────┘ + ┌────────┐ │ + │ X2 ├──────┘ ┌───────────────┐ + │ Server ├──────────────┤ │ + └────────┘ │ Font Server │ + ┌───────┤ 2 │ +┌─────────┐ │ └───────────────┘ +│ other │ │ +│ clients ├──────┘ +└─────────┘ + +
+ + +Clients communicate with the font server using the request/reply/event model +over any mutually-understood virtual stream connection (such as +TCP/IP, DECnet, + +DECnet is a trademark +of Digital Equipment Corporation. + +etc.). Font servers are responsible for providing data in the bit and byte +orders requested by the client. The set of requests and events provided in the +first version of the X Font Service protocol is limited to supporting the needs +of the bitmap-oriented core X Window System protocol. Extensions are expected +as new needs evolve. + + +A font server reads raw font data from a variety of sources (possibly +including other font servers) and converts it into a common format that is +transmitted to the client using the protocol described in +Section 4. New font +formats are handled by adding new converters to a font server, as shown in +Figure 2.2. + + +
Where Font Data Comes From + + ┌────────────┐ + │ client │ + │ (X server) │ + └─────┬──────┘ + │ + network + │ +┌─────────────────────┴──────────────────────┐ +│ │ +│ font server 1 │ +│ │ +├─────┬─────┬─────┬─────┬────┬─────┬───┬─────┤ +│ bdf │ snf │ pcf │ atm │ f3 │ dwf │ │ │ ... │ +└─────┴─────┴─────┴─────┴────┴─────┴─│─┴─────┘ + │ + network + │ + ┌─────┴────┐ + │ font │ + │ server 2 │ + └──────────┘ + +
+ + +The server may choose to provide named sets of fonts called +catalogues. +Clients may specify which of the sets should be used in listing or opening a +font. + + + +An event mechanism similar to that used in the X protocol is provided for +asynchronous notification of clients by the server. + + + +Clients may provide authorization data for the server to be used in determining +(according to the server's licensing policy) whether or not access should be +granted to particular fonts. This is particularly useful for clients whose +authorization changes over time (such as an X server that can verify the +identity of the user). + + +Implementations that wish to provide additional requests or events may use the +extension mechanism. Adding to the core font service protocol (with the +accompanying change in the major or minor version numbers) is reserved to the X +Consortium. + + + + +Font Server Naming + + + + +Font clients that expose font server names to the user are encouraged to +provide ways of naming font servers symbolically (e.g. DEPARTMENT-FONTS). +However, for environments that lack appropriate name services +transport-specific names are necessary. Since these names do occur in the +protocol, clients and servers should support at least the applicable formats +described below. Formats for additional transports may be registered with the +X Consortium. + + +
+TCP/IP Names + + + + +The following syntax should be used for TCP/IP names: + + + TCP name ::= tcp/ hostname : ipportnumber / cataloguelist + + +where hostname is either symbolic (such as +expo.lcs.mit.edu) or numeric +decimal (such as 18.30.0.212). +The ipportnumber is the port on which the +font server is listening for connections. +The cataloguelist string at +the end is optional and specifies a plus-separated list of catalogues +that may be requested. For example: + + tcp/expo.lcs.mit.edu:8012/available+special + tcp/18.30.0.212:7890 + + +
+ +
+DECnet Names + + + + +The following syntax should be used for DECnet names: + + + DECnet name ::= decnet/ nodename ::font$ objname / cataloguelist + + +where nodename is either symbolic (such as +SRVNOD) or the +numeric decimal form of the DECnet address (such as +44.70). +The objname is normal, case-insensitive DECnet +object name. The cataloguelist string +at the end is +optional and specifies a plus-separated list of catalogues that may be +requested. For example: + + + DECNET/SRVNOD::FONT$DEFAULT/AVAILABLE + decnet/44.70::font$other + + +
+ + + +Protocol + + + + +The protocol described below uses the request/reply/error model and is +specified using the same conventions outlined in +Section 2 +of the core X Window System protocol +: + + + + + +Data type names are spelled in upper case with no word separators, +as in: FONTID + + + + + +Alternate values are capitalized with no word separators, +as in: MaxWidth + + + + + +Structure element declarations are in lower case with hyphens +as word separators, as in: byte-order-msb + + + +Structure element names are referred to in +upper case (e.g. BYTE-ORDER-MSB) when used in +descriptions to set them off from the surrounding +text. When this document is typeset they will be +printed in lower case in a distinct font. + + + + + +Type declarations have the form name: type, +as in: CARD8: 8-bit byte + + + + +Comma-separated lists of alternate values are enclosed in +braces, as in: { Min, MaxWidth, +Max } + + + + +Comma-separated lists of structure elements are enclosed in +brackets, as in: [ byte1: CARD8, +byte2: CARD8 ] + + + + + +A type with a prefix LISTof represents a counted list of +elements of that type, as in: LISTofCARD8 + + +
+Data Types + + + + +The following data types are used in the core X Font Server protocol: + + +
+ <type>ACCESSCONTEXT</type> + ACCESSCONTEXT + + + + + + + + ACCESSCONTEXT:ID + + + + +This value is specified in the CreateAC request as the identifier +to be used when referring to a particular AccessContext resource +within the server. These resources are used by the server to +store client-specified authorization information. This +information may be used by the server to determine whether or not +the client should be granted access to particular font data. + + +In order to preserve the integrity of font licensing being performed by +the font server, care must be taken by a client to properly represent the +identity of the true user of the font. Some font clients will in fact +be servers (for example, X servers) requesting fonts for their own clients. +Other font clients may be doing work on behalf of a number of different +users over time (for example, print spoolers). + + +AccessContexts +must be created (with +CreateAC) +and switched among (with +SetAuthorization) +to represent all of these font users properly. + +
+ +
+ <type>ALTERNATESERVER</type> + ALTERNATESERVER + + + + + + + + ALTERNATESERVER: + [ name: STRING8, +  subset: BOOL ] + + + + + +This structure specifies the NAME, +encoded in ISO 8859-1 according +to Section 3, +of another font server that may be useful as a +substitute for this font server. +The SUBSET field indicates +whether or not the alternate server is likely to only contain a +subset of the fonts available from this font server. This +information is returned during the initial connection setup and +may be used by the client to find a backup server in case of +failure. + +
+ +
+ <type>AUTH</type> + AUTH + + + + + + + + AUTH:[ name:STRING8, +  data:LISTofBYTE ] + + + + + +This structure specifies the name of an authorization protocol and +initial data for that protocol. It is used in the authorization +negotiation in the initial connection setup and in the CreateAC +request. + +
+ +
+ <type>BITMAPFORMAT</type> + BITMAPFORMAT + + + + + + + + BITMAPFORMAT:CARD32 + + + + + + CARD32 containing the following fields defined by the + sets of values given further below + + + + + + + + + [ +  byte-order-msb: 1 bit, +  bit-order-msb: 1 bit, +  image-rect: 2 bits{ Min, + MaxWidth, + Max }, +  zero-pad: 4 bits, +  scanline-pad: 2 bits{ ScanlinePad8, + ScanlinePad16, + ScanlinePad32, + ScanlinePad64 }, +  zero-pad: 2 bits, +  scanline-unit: 2 bits{ ScanlineUnit8, + ScanlineUnit16, + ScanlineUnit32, + ScanlineUnit64 }, +  zero-pad: 2 bits, +  zero-pad: 16 bits, + ] + + + + + +This structure specifies how glyph images are transmitted in +response to +QueryXBitmaps8 +and +QueryXBitmaps16 +requests. + + +If the BYTE-ORDER-MSB bit +(1 << 0) is set, the Most Significant +Byte of each scanline unit is returned first. Otherwise, the +Least Significant Byte is returned first. + + +If the BIT-ORDER-MSB bit +(1 << 1) is set, the left-most bit in +each glyph scanline unit is stored in the Most Significant Bit of +each transmitted scanline unit. Otherwise, the left-most bit is +stored in the Least Significant Bit. + + +The IMAGE-RECT field specifies a rectangle of +pixels within the +glyph image. It contains one of the following alternate values: + + + + + + + + ImageRectMin(0 << 2) + ImageRectMaxWidth(1 << 2) + ImageRectMax(2 << 2) + + + + + +For a glyph with extents XCHARINFO in a font with header +information XFONTINFO, the IMAGE-RECT +values have the following meanings: + + + ImageRectMin + + ImageRectMin + +This refers to the minimal bounding rectangle +surrounding the inked pixels in the glyph. This is the +most compact representation. The edges of the rectangle +are: + + left: XCHARINFO.LBEARING + right: XCHARINFO.RBEARING + top: XCHARINFO.ASCENT + bottom: XCHARINFO.DESCENT + + + + + + ImageRectMaxWidth + + ImageRectMaxWidth + +This refers to the scanlines between the +glyph's ascent and descent, padded on the left to the minimum +left-bearing (or 0, whichever is less) and on the right to +the maximum right-bearing (or logical-width, whichever is +greater). All glyph images share a common horizontal +origin. This is a combination of ImageRectMax in the +horizontal direction and ImageRectMin in the vertical +direction. The edges of the rectangle are: + + +left: min (XFONTINFO.MIN-BOUNDS.LBEARING, 0) +right: max (XFONTINFO.MAX-BOUNDS.RBEARING, + XFONTINFO.MAX-BOUNDS.WIDTH) +top: XCHARINFO.ASCENT +bottom: XCHARINFO.DESCENT + + + + + + ImageRectMax + + ImageRectMax + +This refers to all scanlines, from the maximum +ascent (or the font ascent, whichever is greater) to the +maximum descent (or the font descent, whichever is greater), +padded to the same horizontal extents as MaxWidth. +All glyph images have the same sized bitmap and share a +common origin. This is the least compact representation, +but may be the easiest or most efficient (particularly for +character cell fonts) for some clients to use. The edges of +the rectangle are: + + +left: min (XFONTINFO.MIN-BOUNDS.LBEARING, 0) +right: max (XFONTINFO.MAX-BOUNDS.RBEARING, + XFONTINFO.MAX-BOUNDS.WIDTH) +top: max (XFONTINFO.FONT-ASCENT, + XFONTINFO.MAX-BOUNDS.ASCENT) +bottom: max (XFONTINFO.FONT-DESCENT, + XFONTINFO.MAX-BOUNDS.DESCENT) + + + + + + + +The SCANLINE-PAD field specifies the number of +bits (8, 16, 32, +or 64) to which each glyph scanline is padded before transmitting. +It contains one of the following alternate values: + + + + + + + ScanlinePad8(0 << 8) + ScanlinePad16(1 << 8) + ScanlinePad32(2 << 8) + ScanlinePad64(3 << 8) + + + + + +The SCANLINE-UNIT field specifies the number of +bits (8, 16, 32, or 64) that should be treated as a unit for swapping. +This value must be less than or equal to the number of bits specified by the +SCANLINE-PAD. It contains one of the following +alternate values: + + + + + + + + ScanlineUnit8(0 << 12) + ScanlineUnit16(1 << 12) + ScanlineUnit32(2 << 12) + ScanlineUnit64(3 << 12) + + + + + +BITMAPFORMATs are byte-swapped as CARD32s. +All unspecified bits must be zero. + + +Use of an invalid BITMAPFORMAT causes a +Format error to be returned. + +
+ +
+ <type>BITMAPFORMATMASK</type> + BITMAPFORMATMASK + + + + + + + + BITMAPFORMATMASK: CARD32 mask + + + + +This is a mask of bits representing the fields in a BITMAPFORMAT: + + + + + + + ByteOrderMask(1 << 0) + BitOrderMask(1 << 1) + ImageRectMask(1 << 2) + ScanlinePadMask(1 << 3) + ScanlineUnitMask(1 << 4) + + + + + +Unspecified bits are required to be zero or else a +Format error is returned. + +
+ +
+ <type>BOOL</type> + BOOL + + + + + + + + BOOL: CARD8 + + + + +This is a boolean value containing one of the following alternate +values: + + + + + + + False0 + True1 + + + + +
+ +
+ <type>BYTE</type> + BYTE + + + + + + + + BYTE: 8-bit value + + + + + +This is an unsigned byte of data whose encoding +is determined by the context in which it is used. + + +
+ +
+ <type>CARD8</type>, <type>CARD16</type>, <type>CARD32</type> + CARD8 + CARD16 + CARD32 + + + + + + + + CARD8: 8-bit unsigned integer + CARD16: 16-bit unsigned integer + CARD32: 32-bit unsigned integer + + + + + +These are unsigned numbers. The latter two are byte-swapped when +the server and client have different byte orders. + + +
+ +
+ <type>CHAR2B</type> + CHAR2B + + + + + + + + CHAR2B:[ byte1, byte2:CARD8 ] + + + + +This structure specifies an individual character code within +either a 2-dimensional matrix (using BYTE1 +and BYTE2 as the row and column indices, +respectively) or a vector (using BYTE1 and +BYTE2 as most- and least-significant bytes, +respectively). This data type is treated as a pair of 8-bit values and +is never byte-swapped. Therefore, the client should always transmit +BYTE1 first. + + +
+ +
+ <type>EVENTMASK</type> + EVENTMASK + + + + + + + + EVENTMASK: CARD32 mask + + + + + +This is a mask of bits indicating which of an extension's (or the +core's) maskable events the client would like to receive. Each +bit indicates one or more events, and a bit value of one indicates +interest in a corresponding set of events. The following bits are +defined for event masks specified for the core protocol (i.e. an +EXTENSION-OPCODE of zero in +SetEventMask +and +GetEventMask +requests): + + + + + + + + CatalogueListChangeMask(1 << 0) + FontListChangeMask(1 << 1) + + + + + + +If +CatalogueListChangeMask +is set, client is interested in +receiving +CatalogueListNotify +events. If +FontListChangeMask +is set, the client is interested in +receiving +FontListNotify +events. + + +Extensions that provide additional events may define their own +event masks. These event masks have their own scope and may use +the same bit values as the core or other extensions. + + +All unused bits must be set to zero. In +SetEventMask +requests, if +any bits are set that are not defined for the extension (or core) +for which this EVENTMASK is intended (according to the +EXTENSION-OPCODE given in the +SetEventMask +request), an +EventMask +error is generated. + + +This value is swapped as a CARD32. + + +
+ +
+ <type>FONTID</type> + FONTID + + + + + + + + FONTID: ID + + + + + +This is specified by the client in the request +OpenBitmapFont +as the identifier to be used when referring to a particular open +font. + + +
+ +
+ <type>ID</type> + ID + + + + + + + + ID: CARD32 + + + + + +This is a 32-bit value in which the top 3 bits must be clear, and +at least 1 other bit must be set (yielding a range of 1 through +229-1). +It is specified by the client to represent objects in +the server. Identifiers are scoped according to their type are +private to the client; thus, the same identifier may be used for +both a FONTID and an ACCESSCONTEXT +as well as by multiple clients. + + +An ID of zero is referred to as None. + +
+ +
+ <type>INT8</type>, <type>INT16</type>, <type>INT32</type> + INT8 + INT16 + INT32 + + + + + + + + INT8: 8-bit signed integer + INT16: 16-bit signed integer + INT32: 32-bit signed integer + + + + + +These are signed numbers. The latter two are byte-swapped when +the client and server have different byte orders. + +
+ +
+ <type>OFFSET32</type> + OFFSET32 + + + + + + + + OFFSET32: + [ position:CARD32, +  length:CARD32 ] + + + + +This structure indicates a position and length within a block of +data. + +
+ +
+ <type>PROPINFO</type> + PROPINFO + + + + + + + + PROPINFO: + [ offsets:LISTofPROPOFFSET, +  data:LISTofBYTE ] + + + + + +This structure describes the list of properties provided by a +font. Strings for all of the properties names and values are +stored within the data block and are located using a table of +offsets and lengths. + + +This structure is padded to 32-bit alignment. + + +
+ +
+ <type>PROPOFFSET</type> + PROPOFFSET + + + + + + + + PROPOFFSET: + [ name:OFFSET32, +  value:OFFSET32, +  type:CARD8, +  zero-pad3:BYTE, BYTE, BYTE ] + + + + + +This structure specifies the position, length, and type of +of data for a property. + + +The NAME field specifies the position and length +(which must be +greater than zero) of the property name relative to the beginning +of the PROPINFO.DATA block for this font. +The interpretation of +the position and length of the VALUE field is +determined by the TYPE field, which contains +one of the following alternate values: + + + + + + + + String0 + Unsigned1 + Signed2 + + + +which have the following meanings: + + + String + + String + +This property contains a counted string of bytes. The +data is stored in the PROPINFO.DATA +block beginning at +relative byte VALUE.POSITION (beginning with zero), extending +for VALUE.LENGTH (at least zero) bytes. + + + + + Unsigned + + Unsigned + +This property contains a unsigned, 32-bit number stored +as a CARD32 in VALUE.POSITION (VALUE.LENGTH is zero). + + + + + Signed + + Signed + +This property contains a signed, 32-bit number stored as +an INT32 in VALUE.POSITION (VALUE.LENGTH is zero). + + + + +This structure is zero-padded to 32-bit alignment. + + +
+ +
+ <type>RANGE</type> + RANGE + + + + + + + + RANGE: + [ min-char, max-char:CHAR2B ] + + + + + +This structure specifies a range of character codes. A single +character is represented by MIN-CHAR equals +MAX-CHAR. If the linear interpretation of +MAX-CHAR is less than that of +MIN-CHAR, or if +MIN-CHAR is less than the font's +XFONTINFO.CHAR-RANGE.MIN-CHAR, or if +MAX-CHAR is greater than the +font's XFONTINFO.CHAR-RANGE.MAX-CHAR, +the range is invalid. + + +
+ +
+ <type>RESOLUTION</type> + RESOLUTION + + + + + + + + RESOLUTION: + [ x-resolution:CARD16, +  y-resolution:CARD16, +  decipoint-size:CARD16 ] + + + + + +This structure specifies resolution and point size to be used in +resolving partially-specified scaled font names. The +X-RESOLUTION and +Y-RESOLUTION are measured in +pixels-per-inch and must be greater than zero. +The DECIPOINT-SIZE is the preferred font +size, measured in tenths of a point, and must be greater than zero. + + +
+ +
+ <type>STRING8</type> + STRING8 + + + + + + + + STRING8: LISTofCARD8 + + + + + +This is a counted list of 1-byte character codes, typically +encoded in ISO 8859-1. A character code +c is equivalent to a +CHAR2B structure whose BYTE1 +is zero and whose BYTE2 is +c. + + +
+ +
+ <type>TIMESTAMP</type> + TIMESTAMP + + + + + + + + TIMESTAMP: CARD32 + + + + + +This is the number of milliseconds that have passed since a +server-dependent origin. It is provided in errors and events and is +permitted to wrap. + +
+ +
+ <type>XCHARINFO</type> + XCHARINFO + + + + + + + + XCHARINFO: + [ lbearing, rbearing:INT16, +  width:INT16, +  ascent, descent:INT16, +  attributes:CARD16 ] + + + + + +This structure specifies the ink extents and horizontal escapement +(also known as the set- or logical width) of an individual +character. The first five values represent directed distances in +a coordinate system whose origin is aligned with the lower-left +edge of the left-most pixel of the glyph baseline (i.e. the +baseline falls between two pixels as shown in Figure 3-1 of the +Bitmap Distribution Format 2.1 Consortium standard +). + + +The LBEARING field specifies the +directed distance measured to the +right from the origin to the left edge of the left-most inked +pixel in the glyph. + + +The RBEARING field specifies the +directed distance (measured to +the right) from the origin to the right edge of the right-most +inked pixel in the glyph. + + +The WIDTH field specifies the +directed distance (measured to the +right) from the origin to the position where the next character +should appear (called the escapement point). This +distance includes any whitespace used for intercharacter padding and is +also referred to as the logical width or +horizontal escapement. +horizontal escapement + + +The ASCENT field specifies the +directed distance (measured up) +from the baseline to the top edge of the top-most inked pixel +in the glyph. + + +The DESCENT field specifies the +directed distance (measured +down) from the baseline to the bottom edge of the bottom-most +inked pixel. + + +The ATTRIBUTES field specifies +glyph-specific information that +is passed through the application. If this value is not being +used, it should be zero. + + +The ink bounding box of a glyph is defined to be the smallest +rectangle that encloses all of the inked pixels. This box has +a width of +RBEARING − LBEARING +pixels and a height of +ASCENT + DESCENT pixels. + +
+ +
+ <type>XFONTINFO</type> + XFONTINFO + + + + + + + + XFONTINFO: + [ flags:CARD32, +  drawing-direction:{ LeftToRight, RightToLeft } +  char-range:RANGE, +  default-char:CHAR2B, +  min-bounds:XCHARINFO, +  max-bounds:XCHARINFO, +  font-ascent:INT16, +  font-descent:INT16, +  properties:PROPINFO ] + + + + +This structure specifies attributes related to the font as a +whole. + + +The FLAGS field is a bit mask containing zero +or more of the following boolean values (unspecified bits must be zero): + + + + + + + + AllCharactersExist(1 << 0) + InkInside(1 << 1) + HorizontalOverlap(1 << 2) + + + + +which have the following meanings: + + + AllCharactersExist + + AllCharactersExist + +If this bit is set, all of the characters in the range given by +CHAR-RANGE have glyphs encoded in +the font. If this bit is clear, some of the characters +may not have encoded glyphs. + + + + + InkInside + + InkInside + +If this bit is set, the inked pixels of each glyph +fall within the rectangle described by the font's ascent, +descent, origin, and the glyph's escapement point. If +this bit is clear, there may be glyphs whose ink extends +outside this rectangle. + + + + + HorizontalOverlap + + HorizontalOverlap + +If this bit is set, the two ink bounding +boxes (smallest rectangle enclosing the inked pixels) of +some pairs of glyphs in the font may overlap when displayed +side-by-side (i.e. the second character is imaged at the +escapement point of the first) on a common baseline. If +this bit is clear, there are no pairs of glyphs whose ink +bounding boxes overlap. + + + + + + + LeftToRight + RightToLeft +The DRAWING-DIRECTION field contains a hint +indicating whether most of the character metrics have a positive (or +LeftToRight) logical width or a +negative (RightToLeft) logical width. It +contains the following alternate values: + + + + + + + LeftToRight0 + RightToLeft1 + + + + + +The CHAR-RANGE.MIN-CHAR +and CHAR-RANGE.MAX-CHAR fields specify the +first and last character codes that have glyphs encoded in this font. +All fonts must have at least one encoded glyph (in which case the +MIN-CHAR and MAX-CHAR +are equal), but are not required to have glyphs +encoded at all positions between the first and last characters. + + +The DEFAULT-CHAR field specifies +the character code of the glyph +that the client should substitute for unencoded characters. Requests +for extents or bitmaps for an unencoded character generate zero-filled +metrics and a zero-length glyph bitmap, respectively. + + +The MIN-BOUNDS and +MAX-BOUNDS fields contain the minimum and maximum +values of each of the extents field of all encoded characters in the +font (i.e. non-existent characters are ignored). + + +The FONT-ASCENT and +FONT-DESCENT fields specify the font designer's +logical height of the font, above and below the baseline, +respectively. The sum of the two values is often used as the +vertical line spacing of the font. Individual glyphs are permitted +to have ascents and descents that are greater than these values. + + +The PROPERTIES field contains the +property data associated with this font. + + +This structure is padded to 32-bit alignment. + +
+
+ +
+Requests + + + + +This section describes the requests that may be sent by the client and the +replies or errors that are generated in response. Versions of the protocol +with the same major version are required to be upward-compatible. + + +Every request on a given connection is implicitly assigned a sequence number, +starting with 1, that is used in replies, error, and events. Servers are +required to generate replies and errors in the order in which the corresponding +requests are received. Servers are permitted to add or remove fonts to the +list visible to the client between any two requests, but requests must be +processed atomically. Each request packet is at least 4 bytes long and +contains the following fields: + + + + + + + + major-opcode:CARD8 + minor-opcode:CARD8 + length:CARD16 + + + + + + +The MAJOR-OPCODE specifies which core request or +extension package this packet represents. If the +MAJOR-OPCODE corresponds to a core request, the +MINOR-OPCODE contains 8 bits of request-specific data. +Otherwise, the MINOR-OPCODE specifies which extension +request this packet represents. The LENGTH field +specifies the number of 4-byte units contained within the packet +and must be at least one. If this field contains a value greater than one it +is followed by (LENGTH - 1) * 4 bytes +of request-specific data. Unless +otherwise specified, unused bytes are not required to be zero. + + +If a request packet contains too little or too much data, the server returns +a Length error. +If the server runs out of internal +resources (such as memory) while processing a request, it returns an +Alloc error. +If a server is deficient (and therefore non-compliant) and is unable to +process a request, it may return an +Implementation error. +If a client uses an extension request without previously having issued a +QueryExtension +request for that extension, the server responds with a +Request +error. If the server encounters a request with an unknown +MAJOR-OPCODE or MINOR-OPCODE, +it responds with a +Request +error. +At most one error is generated per request. If more than one error condition +is encountered in processing a requests, the choice of which error is returned +is server-dependent. + + +Core requests have MAJOR-OPCODE values between 0 and +127, inclusive. Extension requests have MAJOR-OPCODE +values between 128 and 255, inclusive, that are assigned by by the server. +All MINOR-OPCODE values in extension requests are +between 0 and 255, inclusive. + + +Each reply is at least 8 bytes long and contains the following fields: + + + + + + + + type:CARD8value of 0 + data-or-unused:CARD8 + sequence-number:CARD16 + length:CARD32 + + + + + +The TYPE field has a value of zero. +The DATA-OR-UNUSED field may be used to +encode one byte of reply-specific data (see +Section 5.2 on request encoding). +The least-significant 16 bits of the sequence number of the request that +generated the reply are stored in the SEQUENCE-NUMBER +field. The LENGTH field specifies the number of +4-byte units in this reply packet, including the fields described above, +and must be at least two. If LENGTH is greater +than two, the fields described above are followed by +(LENGTH - 2) * 4 bytes of additional data. + + +Requests that have replies are described using the following syntax: +
+ RequestName + + + + + + + arg1:type1 + arg2:type2 + ... + argN:typeN + ▶ + result1:type1 + result2:type2 + ... + resultM:typeM + Errors:kind1, kind2 ..., kindK + + + + Description +
+ + +If a request does not generate a reply, the ▶ and result lines are +omitted. If a request may generate multiple replies, the ▶ is replaced by +a ▶+. In the authorization data exchanges in the initial connection setup +and the CreateAC request, ◀ indicates data sent by the client in response +to data sent by the server. + + +The protocol begins with the establishment of a connection over a +mutually-understood virtual stream: + + +
+ open connection + open connection + + + + + + + byte-order:BYTE + client-major-protocol-version:CARD16 + client-minor-protocol-version:CARD16 + authorization-protocols:LISTofAUTH + + + + +The initial byte of the connection specifies the +BYTE-ORDER in +which subsequent 16-bit and 32-bit numeric values are to be +transmitted. The octal value 102 +(ASCII uppercase B) +indicates that the most-significant byte is to be transmitted +first; the octal value 154 +(ASCII lowercase l) +indicates that the least-significant byte is to be transmitted first. +If any other value is encountered the server closes the +connection without any response. + + +The CLIENT-MAJOR-PROTOCOL-VERSION and +CLIENT-MINOR-PROTOCOL-VERSION specify +which version of the +font service protocol the client would like to use. If the +client can support multiple versions, the highest version +should be given. This version of the protocol has a +major version of 2 and a minor version of 0. + + +The AUTHORIZATION-PROTOCOLS +contains a list of protocol names and +optional initial data for which the client can provide +information. The server may use this to determine which +protocol to use or as part of the initial exchange of +authorization data. + + + + + + + + ▶ + status:{ Success, Continue, + Busy, Denied } + server-major-protocol-version:CARD16 + server-minor-protocol-version:CARD16 + alternate-servers-hint:LISTofALTERNATESERVER + authorization-index:CARD8 + authorization-data:LISTofBYTE + + + + +The SERVER-MAJOR-PROTOCOL-VERSION and +SERVER-MINOR-PROTOCOL-VERSION specify +the version of the font +service protocol that the server expects from the client. If +the server supports the version specified by the client, this +version number should be returned. If the client has +requested a higher version than is supported by the server, +the server's highest version should be returned. Otherwise, +if the client has requested a lower version than is supported +by the server, the server's lowest version should be returned. +It is the client's responsibility to decide whether or not it +can match this version of the protocol. + + +The ALTERNATE-SERVERS-HINT +is a list of other font servers +that may have related sets of fonts (determined by means +outside this protocol, typically by the system administrator). +Clients may choose to contact these font servers if the +connection is rejected or lost. + + +The STATUS field indicates whether the server accepted, +rejected, or would like more information about the connection. +It has one of the following alternate values: + + + + + + + Success0 + Continue1 + Busy2 + Denied3 + + + + + +If STATUS is Denied, +the server has rejected the client's authorization information. +If STATUS is Busy, the server has +simply decided that it cannot provide fonts to this client at +this time (it may be able to at a later time). In both cases, +AUTHORIZATION-INDEX is set to zero, +no authorization-data is +returned, and the server closes the connection after sending +the data described so far. + + +Otherwise the AUTHORIZATION-INDEX is set to the index +(beginning with 1) into the AUTHORIZATION-PROTOCOLS +list of the protocol that the server will use for this connection. If +the server does not want to use any of the given protocols, +this value is set to zero. The AUTHORIZATION-DATA +field is used to send back authorization protocol-dependent data to the +client (such as a challenge, authentication of the server, +etc.). + + +If STATUS is Success, +the following section of protocol is omitted. Otherwise, if +STATUS is Continue, +the server expects +more authorization data from the client (i.e. the connection +setup is not finished, so no requests or events may be sent): + + + + + + + ◀ + more-authorization-data:STRING8 + ▶ + status:{ Success, Continue, Busy, Denied } + more-authorization-data:LISTofBYTE + + + + + +The values in STATUS have the same meanings as described +above. This section of protocol is repeated until the server +either accepts (sets STATUS to +Success) or rejects (sets STATUS +to Denied or Busy) the connection. + + +Once the connection has been accepted and STATUS +is Success, +an implicit AccessContext is created for the authorization +data and the protocol continues with the following data sent +from the server: + + + + + + + ▶ + remaining-length:CARD32 + maximum-request-length:CARD16 + release-number:CARD32 + vendor:STRING8 + + + + + +The REMAINING-LENGTH specifies the length in 4-byte +units of the remaining data to be transmitted to the client. The +MAXIMUM-REQUEST-LENGTH specifies the largest request +size in 4-byte units that is accepted by the server and must have a +value of at least 4096. Requests with a length field larger +than this value are ignored and a +Length +error is returned. +The VENDOR string specifies the name of the +manufacturer of the font server. The +RELEASE-NUMBER specifies the particular +release of the server in a manufacturer-dependent manner. + +
+
+<para> +After the connection is established and the setup information has been +exchanged, the client may issue any of requests described below: +</para> +</section> +<section id="Requests:NoOp"> + <title><function>NoOp</function> + NoOp + + + + + + + Errors:Alloc + + + + +This request does nothing. It is typically used in response +to a +KeepAlive +event. + +
+ +
+ <function>ListExtensions</function> + ListExtensions + + + + + + + ▶ + names:LISTofSTRING8 + Errors:Alloc + + + + + +This request returns the names of the extension packages +that are supported by the server. Extension names are +case-sensitive and are encoded in ISO 8859-1. + + +
+ +
+ <function>QueryExtension</function> + QueryExtension + + + + + + + + name:STRING8 + ▶ + present:BOOL + major-version:CARD16 + minor-version:CARD16 + major-opcode:CARD8 + first-event:CARD8 + number-events:CARD8 + first-error:CARD8 + number-errors:CARD8 + Errors:Alloc + + + + +This request determines whether or not the extension package specified by +NAME (encoded in ISO 8859-1) is +supported by the server and that there is sufficient number of major opcode, +event, and error codes available. If so, then PRESENT +is set to True, MAJOR-VERSION +and MINOR-VERSION are set to the +respective major and minor version numbers of the protocol +that the server would prefer; MAJOR-OPCODE is set to +the value to use in extension requests; FIRST-EVENT +is set to the value of the first extension-specific event code or zero if the +extension does not have any events; NUMBER-EVENTS is +set to the number of new events that the event defines; +FIRST-ERROR +is set to the value of the first extension-specific error code +or zero if the extension does not define any new errors; and +NUMBER-ERRORS is set to the number of +new errors the extension defines. + + +Otherwise, PRESENT is set to +False and the remaining fields are +set to zero. + + +The server is free to return different values to different +clients. Therefore, clients must use this request before +issuing any of the requests in the named extension package or +using the +SetEventMask request to express interest in any of +this extension's events. Otherwise, a +Request +error is returned. + +
+ +
+ <function>ListCatalogues</function> + ListCatalogues + + + + + + + + pattern:STRING8 + max-names:CARD32 + ▶+ + replies-following-hint:CARD32 + names:LISTofSTRING8 + Errors:Alloc + + + + +This request returns a list of at most MAX-NAMES names +of collections (called catalogues) of fonts that match +the specified PATTERN. In the pattern (which is encoded +in ISO 8859-1), the +? character (octal 77) +matches any single character; the +* character (octal 52) +matches any series of zero or more characters; and alphabetic +characters match either upper- or lowercase. The +returned NAMES are encoded in +ISO 8859-1 and may contain +mixed character cases. + + +If PATTERN is of zero length or +MAX-NAMES is equal to zero, +one reply containing a zero-length list of names is returned. +This may be used to synchronize the client with the server. + + +Servers are free to add or remove catalogues to the set returned by +ListCatalogues +between any two requests. This request is not +cumulative; repeated uses are processed in isolation and do +result in an iteration through the list. + + +To reduce the amount of buffering needed by the server, the +list of names may be split across several reply packets, so +long as the names arrive in the same order that they would +have appeared had they been in a single packet. The +REPLIES-FOLLOWING-HINT field in all but the last reply +contains a positive value that specifies the number of +replies that are likely, but not required, to follow. In the +last reply, which may contain zero or more names, this field +is set to zero. + +
+ +
+ <function>SetCatalogues</function> + SetCatalogues + + + + + + + names:LISTofSTRING8 + Errors:Alloc, +Name + + + + +This request sets the list of catalogues whose fonts should be +visible to the client. The union of the fonts provided by +each of the named catalogues forms the set of fonts whose +names match patterns in +ListFonts, +ListFontsWithXInfo, +and +OpenBitmapFont +requests. The catalogue names are +case-insensitive and are encoded in ISO 8859-1. A zero-length +list resets the client's catalogue list to the +server-dependent default. + + +If any of the catalogue names are invalid, a +Name +error is returned and the request is ignored. + +
+ +
+ <function>GetCatalogues</function> + GetCatalogues + + + + + + + ▶ + names:LISTofSTRING8 + Errors:Alloc + + + + +This request returns the current list of catalogue names +(encoded in ISO 8859-1) associated with the client. These +catalogues determine the set of fonts that are visible +to +ListFonts, +ListFontsWithXInfo, +and +OpenBitmapFont. +A zero-length list indicates the server's default set of +fonts. Catalogue names are case-insensitive and may be +returned in mixed case. + +
+ +
+ <function>SetEventMask</function> + SetEventMask + + + + + + + extension-opcode:CARD8 + event-mask:EVENTMASK + Errors:EventMask, +Request + + + + +This request specifies the set of maskable events that the +extension indicated by EXTENSION-OPCODE +(or zero for the core) +should generate for the client. Event masks are limited in +scope to the extension (or core) for which they are defined, +so expressing interest in events from one or more extensions +requires multiple uses of this request. + + +The default event mask if +SetEventMask +has not been called +is zero, indicating no interest in any maskable events. +Some events are not maskable and cannot be blocked. + + +If EXTENSION-OPCODE is not a valid extension +opcode previously returned by +QueryExtension +or zero, a +Request +error is +returned. If EVENT-MASK contains any bits that do not +correspond to valid events for the specified extension (or +core), an +EventMask +error is returned and the request is +ignored. + +
+ +
+ <function>GetEventMask</function> + GetEventMask + + + + + + + extension-opcode:CARD8 + ▶ + event-mask:EVENTMASK + Errors:Request + + + + +This request returns the set of maskable core events the +extension indicated by EXTENSION-OPCODE +(or the core if zero) +should generate for the client. Non-maskable events are +always sent to the client. + + +If EXTENSION-OPCODE is not a valid extension opcode +previously returned by +QueryExtension +or zero, a +Request +error is returned. + +
+ +
+ <function>CreateAC</function> + CreateAC + + + + + + + ac:ACCESSCONTEXT + authorization-protocols:LISTofAUTH + ▶ + status:{ Success, Continue, Denied } + authorization-index:CARD8 + authorization-data:LISTofBYTE + Errors:IDChoice + + + + +This request creates a new +AccessContext +object within the +server containing the specified authorization data. When +this +AccessContext +is selected by the client using the +SetAuthorization +request, the data may be used by the server +to determine whether or not the client should be granted +access to particular font information. + + +If STATUS is Denied, the server +rejects the client's authorization information and does not associate +AC with any valid AccessContext. +In this case, AUTHORIZATION-INDEX is set +to zero, and zero bytes of AUTHORIZATION-DATA +is returned. + + +Otherwise, AUTHORIZATION-INDEX is set to the index +(beginning with 1) into the AUTHORIZATION-PROTOCOLS +list of the protocol +that the server will use for this connection. If the server +does not want to use any of the given protocols, this value is +set to zero. The AUTHORIZATION-DATA field is used +to send back authorization protocol-dependent data to the client (such +as a challenge, authentication of the server, etc.). + + +If STATUS is Continue, +the client is expected to continue +the request by sending the following protocol and receiving +the indicated response from the server. This continues +until STATUS is set to either +Success or Denied. + + + + + + + + ◀ + more-authorization-data:STRING8 + ▶ + status:{ Success, Continue, Denied } + more-authorization-data:LISTofBYTE + + + + +Once the connection has been accepted and STATUS +is Success, the request is complete. + + +If AC is not in the range +[1..229-1] or is already associated +with an access context, an IDChoice error is returned. + +
+ +
+ <function>FreeAC</function> + FreeAC + + + + + + + ac:ACCESSCONTEXT + Errors:AccessContext, +Alloc + + + + +This request indicates that the specified AC should +no longer be associated with a valid access context. +If AC is also the current +AccessContext +(as set by the +SetAuthorization +request), an implicit +SetAuthorization +of None is done to +restore the +AccessContext +established for the initial +connection setup. Operations on fonts that were opened under +AC are not affected. The client may reuse the +value of AC in a subsequent +CreateAC +request. + + +If AC isn't associated with any valid authorization +previously created by +CreateAC, an +AccessContext +error is returned. + +
+ +
+ <function>SetAuthorization</function> + SetAuthorization + + + + + + + ac:ACCESSCONTEXT + Errors:AccessContext + + + + +This request sets the +AccessContext +to be used for subsequent +requests (except for +QueryXInfo, +QueryXExtents8, +QueryXExtents16, +QueryXBitmaps8, +QueryXBitmaps16 +and +CloseFont +which are done under the +AccessContext +of the +corresponding +OpenBitmapFont +). +An AC of None restores the +AccessContext +established for the initial connection setup. + + +If AC is neither None +nor a value associated with a valid AccessContext +previously created by +CreateAC, +an +AccessContext +error is returned. + +
+ +
+ <function>SetResolution</function> + SetResolution + + + + + + + resolutions:LISTofRESOLUTION + Errors:Resolution, +Alloc + + + + +This request provides a hint as to the resolution and +preferred point size of the drawing surfaces for which the +client will be requesting fonts. The server may use this +information to set the RESOLUTION_X and RESOLUTION_Y fields +of scalable XLFD font names, to order sets of names based on +their resolutions, and to choose the server-dependent +instance that is used when a partially-specified scalable +fontname is opened. + + +If a zero-length list of RESOLUTIONs is given, the +server-dependent default value is restored. Otherwise, if +elements of all of the specified RESOLUTIONs are non-zero, the +default resolutions for this client are changed. + + +If a RESOLUTION entry contains a zero, +a Resolution error is +returned and the default resolutions are not changed. + +
+ +
+ <function>GetResolution</function> + GetResolution + + + + + + + ▶ + resolutions:LISTofRESOLUTION + Errors:Alloc + + + + +This request returns the current list of default resolutions. +If a client has not performed a +SetResolution, +a server-dependent default value is returned. + +
+ +
+ <function>ListFonts</function> + ListFonts + + + + + + + pattern:STRING8 + max-names:CARD32 + ▶+ + replies-following-hint:CARD32 + names:LISTofSTRING8 + Errors:Alloc + + + + +This request returns a list of at most MAX-NAMES +font names that match the specified PATTERN, +according to matching rules +of the X Logical +Font Description Conventions +. +In the pattern (which is encoded in ISO 8859-1) the +? character (octal 77) +matches any single character; the +* character (octal 52) +matches any series of zero or more characters; and +alphabetic characters match either upper- or lowercase. The +returned NAMES are encoded in +ISO 8859-1 and may contain mixed +character cases. Font names are not required to be in XLFD +format. + + +If PATTERN is of zero length or +MAX-NAMES is equal to zero, +one reply containing a zero-length list of names is returned. +This may be used to synchronize the client with the server. + + +Servers are free to add or remove fonts to the set returned by +ListFonts +between any two requests. This request is not +cumulative; repeated uses are processed in isolation and do +result in an iteration through the list. + + +To reduce the amount of buffering needed by the server, the +list of names may be split across several reply packets, so +long as the names arrive in the same order that they would +have appeared had they been in a single packet. The +REPLIES-FOLLOWING-HINT field in all but the last reply +contains a positive value that specifies the number of +replies that are likely, but not required, to follow. In the +last reply, which may contain zero or more names, this field +is set to zero. + +
+ +
+ <function>ListFontsWithXInfo</function> + ListFontsWithXInfo + + + + + + + pattern:STRING8 + pattern:STRING8 + pattern:STRING8 + max-names:CARD32 + ▶+ + replies-following-hint:CARD32 + info:XFONTINFO + name:STRING8 + Errors:Alloc + + + + +This request is similar to +ListFonts +except that a separate +reply containing the name, header, and property data is +generated for each matching font name. Following these +replies, if any, a final reply containing a zero-length +NAME and no INFO is sent. + + +The REPLIES-FOLLOWING-HINT field in all but the +last reply contains a positive value that specifies the number of replies +that are likely, but not required, to follow. In the last +reply, this field is set to zero. + + +If PATTERN is of zero length or if +MAX-NAMES is equal to zero, only the final reply +containing a zero-length NAME and no +INFO is returned. This may be used to synchronize the +client with the server. + +
+ +
+ <function>OpenBitmapFont</function> + OpenBitmapFont + + + + + + + fontid:FONTID + pattern:STRING8 + format-mask:BITMAPFORMATMASK + format-hint:BITMAPFORMAT + ▶ + otherid:FONTID or None + otherid-valid:BOOL + cachable:BOOL + Errors: +IDChoice, +Name, +Format, +AccessContext, +Alloc + + + + +This request looks for a server-dependent choice of the +font names that match the specified PATTERN +according to the rules described for +ListFonts. +If no matches are found, a +Name +error is returned. Otherwise, the server attempts to +open the font associated with the chosen name. + + +Permission to access the font is determined by the server +according the licensing policy used for this font. The server +may use the client's current +AccessContext +(as set by the most +recent +SetAuthorization +request or the original connection +setup) to determine any client-specific sets of permissions. +After the font has been opened, the client is allowed to +specify a new +AccessContext +with +SetAuthorization +or release +the +AccessContext +using +FreeAC +. Subsequent +QueryXInfo, +QueryXExtents8, +QueryXExtents16, +QueryXBitmaps8, +QueryXBitmaps16 +and +CloseFont +requests on this FONTID are +performed according to permissions granted at the time of the +OpenBitmapFont +request. + + +If the server is willing and able to detect that the client +has already opened the font successfully (possibly under a +different name), the OTHERID field +may be set to one of the +identifiers previously used to open the font. The +OTHERID-VALID field indicates whether or not +OTHERID is still associated with an open font: +if it is True, the client may use +OTHERID as an alternative to +FONTID. Otherwise, if +OTHERID-VALID is False, +OTHERID is no longer +open but has not been reused by a subsequent +OpenBitmapFont +request. + + +If OTHERID is set to None, +then OTHERID-VALID should be set +to False. + + +The FORMAT-MASK indicates which fields in +FORMAT-HINT +the client is likely to use in subsequent +GetXBitmaps8 +and +GetXBitmaps16 +requests. Servers may wish to use +this information to precompute certain values. + + +If CACHABLE is set to True, +the client may cache the font +(so that redundant opens of the same font may be avoided) +and use it with all +AccessContexts +during the life of the +client without violating the font's licensing policy. This +flag is typically set whenever a font is unlicensed or is +licensed on a per-display basis. If CACHABLE +is False, the +client should reopen the font for each +AccessContext. + + +The server is permitted to add to or remove from the set of +fonts returned by +ListFonts +between any two requests, though +mechanisms outside the protocol. Therefore, it is possible +for this request (which is atomic) to return a different font +than would result from separate a +ListFonts +followed by an +OpenBitmapFont +with a non-wildcarded font name. + + +If FONTID is not in the range +[1..229-1] or if it is already +associated with an open font, an +IDChoice +error is returned. +If no font is available that matches the specified +PATTERN, a +Name +error is returned. If the font is present but the client +is not permitted access, an +AccessContext +error is returned. +If FORMAT-MASK has any unspecified bits set or if any +of the fields in FORMAT-HINT indicated by +FORMAT-MASK are invalid, a +Format +error is returned. + +
+ +
+ <function>QueryXInfo</function> + QueryXInfo + + + + + + + fontid:FONTID + ▶ + info:XFONTINFO + Errors:Font, +Alloc + + + + +This request returns the font header and property information +for the open font associated with FONTID. + + +If FONTID is not associated with any open fonts, a +Font +error +is returned. + +
+ +
+ <function>QueryXExtents8</function> + QueryXExtents8 + + + + + + + fontid:FONTID + range:BOOL + chars:STRING8 + ▶ + extents:LISTofXCHARINFO + Errors:Font, +Range, +Alloc + + + + +This request is equivalent to +QueryXExtents16 +except that it +uses 1-byte character codes. + +
+ +
+ <function>QueryXExtents16</function> + QueryXExtents16 + + + + + + + fontid:FONTID + range:BOOL + chars:LISTofCHAR2B + ▶ + extents:LISTofXCHARINFO + Errors:Font, +Range, +Alloc + + + + +This request returns a list of glyph extents from the open +font associated with FONTID for the series of characters +specified by RANGE and CHARS. + + +If RANGE is True, +each succeeding pair of elements in CHARS is +treated as a range of characters for which extents should be +returned. If CHARS contains an odd number of elements, +the font's XFONTINFO.CHAR-RANGE.MAX-CHAR +is implicitly appended to +the list. If CHARS contains no elements, the list is +implicitly replaced with the font's +XFONTINFO.CHAR-RANGE. If +any of the resulting character ranges are invalid, a +Range +error is returned. Otherwise, the character ranges are +concatenated in the order given by CHARS to produce +a set of character codes for which extents are returned. + + +If RANGE is False, +then CHARS specifies the set of character +codes for which extents are returned. If CHARS is of +zero length, then a zero-length list of extents is returned. + + +The extents for each character code in the resulting set (which +may contain duplicates) are returned in the order in +which the character codes appear in the set. +At least one metric for each character shall be non-zero +unless the character is not encoded in the font, in which case +all-zero metrics are returned. +A blank, zero-width character can be encoded +with non-zero but equal left and right bearings. + + +If FONTID is not associated with any open fonts, a +Font +error is +returned. If RANGE is True +and CHARS contains any invalid ranges, a +Range +error is returned. + +
+ +
+ <function>QueryXBitmaps8</function> + QueryXBitmaps8 + + + + + + + fontid:FONTID + range:BOOL + chars:STRING8 + format:BITMAPFORMAT + ▶+ + replies-following-hint:CARD32 + offsets:LISTofOFFSET32 + bitmaps:LISTofBYTE + Errors:Font, +Range, +Format, +Alloc + + + + +This request is equivalent to +QueryXBitmaps16 +except that it +uses 1-byte character codes. + +
+ +
+ <function>QueryXBitmaps16</function> + QueryXBitmaps16 + + + + + + + fontid:FONTID + range:BOOL + chars:LISTofCHAR2B + format:BITMAPFORMAT + ▶+ + replies-following-hint:CARD32 + offsets:LISTofOFFSET32 + bitmaps:LISTofBYTE + Errors:Font, + Range, + Format, + Alloc + + + + +This request returns a list of glyph bitmaps from the open font associated +with FONTID for the series of characters +specified by RANGE and CHARS. + + +If RANGE is True, each succeeding +pair of elements in CHARS is +treated as a range of characters for which bitmaps should be +returned. If CHARS contains an odd number of elements, +the font's XFONTINFO.CHAR-RANGE.MAX-CHAR +is implicitly appended to +the list. If CHARS contains no elements, the list is +implicitly replaced with the font's +XFONTINFO.CHAR-RANGE. If +any of the resulting character ranges are invalid, a Range +error is returned. Otherwise, the character ranges are +concatenated in the order given by CHARS to produce +a set of character codes for which bitmaps are returned. + + +If RANGE is False, +then CHARS specifies the set of character +codes for which bitmaps are returned. If CHARS +is of zero length, then a single reply containing a zero-length list of +offsets and bitmaps is returned. + + +If any of the resulting character ranges are invalid, a +Range +error is returned. Otherwise, the resulting character ranges +are concatenated in the order given by CHARS +to produce a set of character codes for which bitmaps are returned. + + +The server is free to return the glyph bitmaps in multiple +replies to reduce the amount of buffering that is necessary. +In this situation, the set of characters obtained above is +partitioned into an implementation-dependent number of +ordered, non-overlapping subsets containing runs of one or +more consecutive characters. The global ordering of +characters must be maintained such that concatenating the +subsets in order that they were produced yields the original +set. A reply is generated for each subset, in the order that +it was produced. + + +For each character in a subset, an image of that character's +glyph is described by a rectangle of bits corresponding to the +pixels specified by FORMAT.IMAGE-RECT. Within the image, set +and clear bits represent inked and non-inked pixels, +respectively. + + +Each scanline of a glyph image, from top to bottom, is zero-padded +on the right to a multiple of the number of bits specified by +FORMAT.SCANLINE-PAD. The scanline is then divided from left +to right into a sequence of FORMAT.SCANLINE-UNIT bits. The +bits of each unit are then arranged such that the left-most +pixel is stored in the most- or least-significant bit, +according to FORMAT.BIT-ORDER-MSB. The bytes of each unit are +then arranged such that the most- or least-significant byte, +according to FORMAT.BYTE-ORDER-MSB, is transmitted first. +Finally, the units are arranged such that the left-most is +transmitted first and the right-most is transmitted last. + + +The individual images within a subset are then concatenated in +a server-dependent order to form the BITMAPS data +of the reply. If a glyph image is duplicated within a reply, the +server is free to return fewer (but at least one) copies of +the image. If a character is not encoded within the font, a +zero-length bitmap is substituted for this character. Each +glyph image must begin at a bit position that is a multiple of +the FORMAT.SCANLINE-UNIT. + + +The OFFSETS array in a reply contains one entry +for each character in the subset being returned, in the order that the +characters appear in the subset. Each entry specifies the +starting location in bytes and size in bytes of the +corresponding glyph image in the BITMAPS data of that +reply (i.e. an offset may not refer to data in another reply). + + +The REPLIES-FOLLOWING-HINT field in all but the +last reply contains a positive value that specifies the number of replies +that are likely, but not required, to follow. In the last +reply, which may contain data for zero or more characters, +this field is set to zero. + + +If FONTID is not associated with any open fonts, +a Font +error is returned. If RANGE is +True and CHARS contains any +invalid ranges, a +Range error +is returned. If FORMAT is invalid, a +Format error +is returned. + +
+ +
+ <function>CloseFont</function> + CloseFont + + + + + + + fontid:FONTID + Errors:Font, Alloc + + + + +This request indicates that the specified FONTID +should no longer be associated with an open font. The server is free to +release any client-specific storage or licenses allocated for +the font. The client may reuse the value of FONTID +in a subsequent +OpenBitmapFont +request. + + +If FONTID is not associated with any open fonts, a +Font +error is returned. + +
+ +
+ close connection + close connection + + +When a connection is closed, a +CloseFont +is done on all fonts +that are open on the connection. In addition, the server is +free to release any storage or licenses allocated on behalf of +the client that made the connection. + +
+
+ +
+Errors + + + + +All errors are at least 16 bytes long and contain the following fields: + + + + + + + + + type:CARD8value of 1 + error-code:CARD8 + sequence-number:CARD16 + length:CARD32 + timestamp:TIMESTAMP + major-opcode:CARD8 + minor-opcode:CARD8 + data-or-unused:CARD16 + + + + +The TYPE field has a value of one. The ERROR-CODE field specifies which error +occurred. Core errors codes are in the range 0 through 127, extension error +codes are in the range 128 through 255. The SEQUENCE-NUMBER field contains the +least significant 16 bits of the sequence number of the request that caused the +error. The LENGTH field specifies the length of the error packet in 4-byte +units and must have a value of at least 4. The TIMESTAMP specifies the server +time when the error occurred. The MAJOR-OPCODE and MINOR-OPCODE (zero for core +requests) fields specify the type of request that generated the error. The +DATA-OR-UNUSED field may be used for 16 bits of error-specific information. If +LENGTH is greater than four, these fields are followed by (LENGTH - 4) * 4 +bytes of extra data. + + +The following errors are defined for the core protocol: + + +
+ <errorname>Request</errorname> + Error CodesRequest + + + + + + + + data-or-unused:CARD16unused + + + + +This error is generated by any request that has an unknown +combination of major and minor request numbers, or by any +extension request that is issued before a +QueryExtension +of that extension. + +
+ +
+ <errorname>Format</errorname> + Error CodesFormat + + + + + + + + data-or-unused:CARD16unused + format:BITMAPFORMATbad format value + + + + +This error is generated by the use of an invalid BITMAPFORMAT +in the +OpenBitmapFont, +QueryXBitmaps8, and +QueryXBitmaps16 +requests. +The value that caused the error is included as extra data. + +
+ +
+ <errorname>Font</errorname> + Error CodesFont + + + + + + + + data-or-unused:CARD16unused + fontid:FONTIDbad font identifier + + + + +This error is generated by an invalid FONTID in the +QueryXInfo, +QueryXExtents8, +QueryXExtents16, +QueryXBitmaps8, +QueryXBitmaps16 +and +CloseFont +requests. The value that caused +the error is included as extra data. + +
+ +
+ <errorname>Range</errorname> + Error CodesRange + + + + + + + + data-or-unused:CARD16unused + range:RANGEbad range + + + + +This error is generated by an invalid RANGE in the +QueryXExtents8, +QueryXExtents16, +QueryXBitmaps8 +and +QueryXBitmaps16 +requests. The +value that caused the error is included as extra data. + +
+ +
+ <errorname>EventMask</errorname> + Error CodesEventMask + + + + + + + + data-or-unused:CARD16unused + event-mask:EVENTMASKbad event mask + + + + +This error is generated by an invalid EVENTMASK in the +SetEventMask +request. The value that caused the error is +included as extra data. + +
+ +
+ <errorname>AccessContext</errorname> + Error CodesAccessContext + + + + + + + + data-or-unused:CARD16unused + ac:ACCESSCONTEXTunaccepted AccessContext + + + + +This error is generated by an invalid ACCESSCONTEXT in the +FreeAC +or +SetAuthorization +request or by an +OpenBitmapFont +request performed without sufficient authorization. In the +first two cases, the ACCESSCONTEXT of the errant request is +returned as extra data. In the third case, the current +ACCESSCONTEXT is returned as extra data. + +
+ +
+ <errorname>IDChoice</errorname> + Error CodesIDChoice + + + + + + + + data-or-unused:CARD16unused + id:IDbad identifier + + + + +This error is generated by an invalid or already associated +ACCESSCONTEXT identifier in a +CreateAC +request or FONTID identifier +in an +OpenBitmapFont +request. The value that caused the error +is included as extra data. + +
+ +
+ <errorname>Name</errorname> + Error CodesName + + + + + + + + data-or-unused:CARD16unused + + + + +This error is generated by a font name pattern that matches +no fonts in an +OpenBitmapFont +request or no catalogue names in a +SetCatalogues +request. + +
+ +
+ <errorname>Resolution</errorname> + Error CodesResolution + + + + + + + + data-or-unused:CARD16X value of errant resolution + y-resolution:CARD16Y value of errant resolution + point-size:CARD16point size of errant resolution + + + + +This error is generated in response to an invalid RESOLUTION +structure in a +SetResolution +request. The value that caused the +error is included in the DATA-OR-UNUSED field and as extra data. + +
+ +
+ <errorname>Alloc</errorname> + Error CodesAlloc + + + + + + + + data-or-unused:CARD16unused + + + + +This error is generated by any request for which the server +lacks sufficient resources (especially memory). + +
+ +
+ <errorname>Length</errorname> + Error CodesLength + + + + + + + + data-or-unused:CARD16unused + length:CARD32bad length value + + + + +This error is generated by any request that has a length field +greater than (MAXIMUM-REQUEST-LENGTH * 4) bytes. The value that +caused the error is included as extra data. + +
+ +
+ <errorname>Implementation</errorname> + Error CodesImplementation + + + + + + + + data-or-unused:CARD16unused + + + + +This error may be generated in response to any request that +the server is unable to process because it is deficient. Use +of this error is highly discouraged and indicates lack of +conformance to the protocol. + +
+
+ Extensions + +Additional errors may be defined by extensions. + +
+
+ +
+Events + + + + +Events may be generated in response to requests or at the server's discretion +after the initial connection setup information has been exchanged. Each event +is at least 12 bytes long and contains the following fields: + + + + + + + + type:CARD8value of 2 + event-code:CARD8 + sequence-number:CARD16 + length:CARD32 + timestamp:TIMESTAMP + + + + + +The TYPE field contains the value 2. The EVENT-CODE field specifies the number +of the event and is in the range 0-127 for core events or the range 128-255 for +extensions. The SEQUENCE-NUMBER field specifies the least significant 16 bits +of the sequence number of the last request to have been processed by the +server. The LENGTH field specifies the number of 4-byte units in this event +packet and must always have a value of at least 3. The TIMESTAMP field +specifies the server time when the event occurred. If LENGTH is greater than +three, these fields are followed by (LENGTH - 3) * 4 bytes of additional data. + + +Events are described using the following syntax: +
+ EventName + + + + + + + arg1:type1 + ... + argN:typeN + + + + Description +
+ + +If an event does not provide any extra arguments, the +arg1...argN +lines are omitted from the description. + + +The core X Font Service protocol defines the following events: + + +
+ <function>KeepAlive</function> + KeepAlive + +This unsolicited, nonmaskable event may be sent by the +server to verify that the connection has not been broken +(for transports that do not provide this information). +Clients should acknowledge receipt of this request +by sending any request (such as +NoOp +). + +
+ +
+ <function>CatalogueListNotify</function> + CatalogueListNotify + + + + + + + added:BOOL + deleted:BOOL + + + + +This event is sent to clients that have included +CatalogueListChangeMask +in their core event mask +whenever the list of catalogues that are available has +changed. The ADDED field is True if new catalogues have +been added to the server, otherwise it is False. The +DELETED field is True if any existing catalogues have +been removed from the server, otherwise it is False. + +
+ +
+ <function>FontListNotify</function> + FontListNotify + + + + + + + added:BOOL + deleted:BOOL + + + + +This event is sent to clients that have included +FontListChangeMask +in their event mask whenever the +list of fonts that are provided by the currently selected +catalogues has changed. The ADDED field is True if new +fonts have been added to any of the catalogues currently +used by the client, otherwise it is False. The DELETED +field is True if any existing fonts have been removed +from any of catalogues used by the client, otherwise it +is False. + +
+
+ Extensions + +Additional events may be defined by extensions. + +
+
+ + + +Protocol Encoding + + + + +Numbers that are prefixed with #x +are in hexadecimal (base 16). All other +numbers are in decimal. Requests, replies, errors, events, and compound types +are described using the syntax: + + + + + Name + count contents name + ... + count contents name + + + + +where COUNT is the number of bytes in the data stream occupied by this +field, CONTENTS is the name of the type as given in +Section 4 or the value if +this field contains a constant, and NAME is a description of this field. + + +Objects containing counted lists use a lowercase single-letter variable (whose +scope is limited to the request, reply, event, or error in which it is found) +to represent the number of objects in the list. These variables, and any +expressions in which they are used, should be treated as unsigned integers. +Multiple copies of an object are indicated by CONTENTS prefix +LISTof. + + +Unused bytes (whose value is undefined) will have a blank CONTENTS field and a +NAME field of unused. Zeroed bytes (whose value must be zero) +will have a blank CONTENTS field and a NAME field of zero. +The expression pad(e) refers to the number of bytes +needed to round a value e up to the closed +multiple of four: + + + + + pad(e) = (4 - (e mod 4)) mod 4 + + +
+Data Types + + + + +ACCESSCONTEXT +4 CARD32 access context + + with at least one of the following bits set: + + #x1fffffff + + but none of the following bits set: + + #xe0000000 zero + + +ALTERNATESERVER +1 BOOL subset +1 n length of name +n STRING8 name +p unused, p=pad(n+2) + +AUTH +2 n length of name +2 d length of data +n STRING8 name +p unused, p=pad(n) +d STRING8 data +q unused, q=pad(d) + + +BITMAPFORMAT +4 CARD32 value, union of the following bits: + + #x00000001 ByteOrderMSB + #x00000002 BitOrderMSB + #x00000000 ImageRectMin + #x00000004 ImageRectMaxWidth + #x00000008 ImageRectMax + #x00000000 ScanlinePad8 + #x00000100 ScanlinePad16 + #x00000200 ScanlinePad32 + #x00000300 ScanlinePad64 + #x00000000 ScanlineUnit8 + #x00001000 ScanlineUnit16 + #x00002000 ScanlineUnit32 + #x00003000 ScanlineUnit64 + + except for the following bits which must be zero: + + #xffffccf0 zero + + and the following of which at most one bit may be set: + + #x0000000c at most one bit can be set + + +BITMAPFORMATMASK +4 CARD32 value, mask of the following bits: + + #x00000001 ByteOrderMask + #x00000002 BitOrderMask + #x00000004 ImageRectMask + #x00000008 ScanlinePadMask + #x00000010 ScanlineUnitMask + + except for the following bits which must be zero: + + #xffffffe0 zero + +BOOL +1 BOOL boolean, one of the following values: + 0 False + 1 True + +BYTE +1 BYTE unsigned byte of data + +CARD8 +1 CARD8 8-bit unsigned integer + +CARD16 +2 CARD16 16-bit unsigned integer + +CARD32 +4 CARD32 32-bit unsigned integer + +CHAR2B +1 CARD8 byte1 +1 CARD8 byte2 + +EVENTMASK +4 CARD32 event mask + + for core events, this is union of the following bits: + + #00000001 CatalogueListChangeMask + #00000002 FontListChangeMask + + but none of the following bits set: + + #fffffffc + + extensions define their own sets of bits + +FONTID +4 CARD32 font identifier + + with at least one of the following bits set: + + #x1fffffff + + but none of the following bits set: + + #xe0000000 zero + +INT8 +1 INT8 8-bit signed integer + +INT16 +2 INT16 16-bit signed integer + +INT32 +4 INT32 32-bit signed integer + +OFFSET32 +4 CARD32 position (or integer value) +4 CARD32 length + +PROPINFO +4 n number of PROPOFFSET components +4 m number of bytes of property data +20*n PROPOFFSET property offsets into data block +m LISTofBYTE property data block + +PROPOFFSET +8 OFFSET32 name in data block +8 OFFSET32 value in data block +1 CARD8 type, one of the following values: + 0 String + 1 Unsigned + 2 Signed + 3 zero + +RANGE +2 CHAR2B minimum character code +2 CHAR2B maximum character code + +RESOLUTION +2 CARD16 x resolution in pixels per inch +2 CARD16 y resolution in pixels per inch +2 CARD16 point size in decipoints + +STRNAME +1 n length of name +n STRING8 name + +STRING8 +n LISTofBYTE array of 8-bit character values + +TIMESTAMP +4 CARD32 milliseconds since server time origin + +XCHARINFO +2 INT16 left bearing +2 INT16 right bearing +2 INT16 width +2 INT16 ascent +2 INT16 descent +2 CARD16 attributes + +XFONTINFO +4 CARD32 flags, union of the following bits: + + #x00000001 AllCharactersExist + #x00000002 InkInside + #x00000004 HorizontalOverlap + + but none of the following bits set: + + #xfffffff8 zero + +4 RANGE range of characters in font +1 CARD8 drawing direction + 0 LeftToRight + 1 RightToLeft +1 unused +2 CHAR2B default character +12 XCHARINFO minimum bounds +12 XCHARINFO maximum bounds +2 INT16 font ascent +2 INT16 font descent +n PROPINFO property data + +
+ +
+Requests +open connection + +1 BYTE byteorder, one of the values: + #x42 MostSignificant Byte first + #x6c LeastSignificant Byte first +1 CARD8 numberof auth in auth-data +2 2 client-major-protocol-version +2 0 client-minor-protocol-version +2 a/4 lengthof auth-data +a LISTofAUTH auth-data +▶ +2 CARD16 status + 0 Success + 1 Continue + 2 Busy + 3 Denied +2 2 major version +2 0 version +1 CARD8 numberof alternate-servers-hint +1 CARD8 authorization-index +2 a/4 lengthof alternate-servers-hint +2 (d+q)/4 lengthof authorization-data +a LISTofALTERNATESERVER alternate-servers-hint +d LISTofBYTE authorization-data +q unused, q=pad(d) + + + +If STATUS is Busy or Denied, the protocol stops and the connection is +closed. If STATUS is Continue, the client is expected to respond with +additional data, to which the server responds with +a new status value and more data. This dialog continues until the status +is set to Success, or until the server sets STATUS to Busy or Denied +and closes the connection: + + + +◀ +4 1+(d+q)/4 length +d LISTofBYTE more-authorization-data +q unused, q=pad(d) +▶ +4 2+(d+q)/4 length +2 CARD16 status + 0 Success + 1 Continue + 2 Busy + 3 Denied +2 unused +d LISTofBYTE more-authorization-data +q unused, q=pad(d) + + +When STATUS is Success, the protocol resumes with the following +sent by the server: + + + +4 3+(v+w)/4 length of rest of data +2 CARD16 maximum-request-length +2 v length of vendor string +4 CARD32 release-number +v STRING8 vendor-string +w unused, w=pad(v) + + +Once the connection has been established, the client may send the +following requests: + + + +NoOp +1 0 major-opcode +1 unused +2 1 length + +ListExtensions +1 1 major-opcode +1 unused +2 1 length +▶ +1 0 type reply +1 CARD8 numberof names +2 CARD16 sequence-number +4 2+(n+p)/4 length +n LISTofSTRNAME names +p unused, p=pad(n) + +QueryExtension +1 2 major-opcode +1 n length of name +2 1+(n+p)/4 length +n STRING8 name +p unused, p=pad(n) +▶ +1 0 type reply +1 BOOL present +2 CARD16 sequence-number +4 5 length +2 CARD16 major-version +2 CARD16 minor-version +1 CARD8 major-opcode +1 CARD8 first-event +1 CARD8 number-events +1 CARD8 first-error +1 CARD8 number-errors +3 unused + +ListCatalogues +1 3 major-opcode +1 unused +2 3+(n+p)/4 length +4 CARD32 max-names +2 n length of pattern +2 unused +n STRING8 pattern +p unused, p=pad(n) +▶+ +1 0 type reply +1 unused +2 CARD16 sequence-number +4 4+(n+p)/4 length +4 CARD32 replies-following-hint +4 CARD32 numberof catalogue-names +n LISTofSTRNAME catalogue-names +p unused, p=pad(n) + +SetCatalogues +1 4 major-opcode +1 CARD8 numberof catalogue-names +2 1+(n+p)/4 length +n LISTofSTRNAME catalogue-names +p unused, p=pad(n) + +GetCatalogues +1 5 major-opcode +1 unused +2 1 length +▶ +1 0 type reply +1 CARD8 numberof catalogue-names +2 CARD16 sequence-number +4 2+(n+p)/4 length +n LISTofSTRNAME catalogue-names +p unused, p=pad(n) + +SetEventMask +1 6 major-opcode +1 CARD8 extension-opcode +2 2 length +4 EVENTMASK event-mask + +GetEventMask +1 7 major-opcode +1 CARD8 extension-opcode +2 1 length +▶ +1 0 type reply +1 unused +2 CARD16 sequence-number +4 3 length +4 EVENTMASK event-mask + +CreateAC +1 8 major-opcode +1 CARD8 numberof authorization-protocols +2 2+a/4 length +4 ACCESSCONTEXT ac +a LISTofAUTH authorization-protocols +▶ +1 0 type reply +1 CARD8 authorization-index +2 CARD16 sequence-number +4 3+(d+q)/4 length +2 CARD16 status + 0 Success + 1 Continue + 2 Busy + 3 Denied +2 unused +d LISTofBYTE authorization-data +q unused, q=pad(d) + + + +If STATUS is Continue, the client is expected to respond with additional +data, to which the server +responds with a new status value and more data. This dialog continues +until the status is set to +Success, Busy, or Denied at which point the request is finished. + + + +◀ +4 1+(d+q)/4 length +d LISTofBYTE more-authorization-data +q unused, q=pad(d) +▶ +4 2+(d+q)/4 length +2 CARD16 status + 0 Success + 1 Continue + 2 Busy + 3 Denied +2 unused +d LISTofBYTE authorization-data +q unused, q=pad(d) + +FreeAC +1 9 major-opcode +1 unused +2 2 length +4 ACCESSCONTEXT ac + +SetAuthorization +1 10 major-opcode +1 unused +2 2 length +4 ACCESSCONTEXT ac + +SetResolution +1 11 major-opcode +1 n number of resolutions +2 1+(6*n+p)/4 length +6*n LISTofRESOLUTION resolutions +p p=pad(6*n) + +GetResolution +1 12 major-opcode +1 unused +2 1 length +▶ +1 0 type reply +1 n number of resolutions +2 CARD16 sequence-number +4 2+(6*n+p)/4 length +6*n LISTofRESOLUTION resolutions +p p=pad(6*n) + +ListFonts +1 13 major-opcode +1 unused +2 3+(n+p)/4 length +4 CARD32 max-names +2 n length of pattern +2 unused +n STRING8 pattern +p unused, p=pad(n) +▶+ +1 0 type reply +1 unused +2 CARD16 sequence-number +4 4+(n+p)/4 length +4 CARD32 replies-following-hint +4 CARD32 numberof font-names +n LISTofSTRNAME font-names +p unused, p=pad(n) + +ListFontsWithXInfo +1 14 major-opcode +1 unused +2 3+(n+p)/4 length +4 CARD32 max-names +2 n length of pattern +2 unused +n STRING8 pattern +p unused, p=pad(n) +▶+ (except for last in series) +1 0 type reply +1 n length of name +2 CARD16 sequence-number +4 3+(n+p+f)/4 length +4 CARD32 replies-hint +f XFONTINFO fontinfo +n STRING8 name +p unused, p=pad(n) +▶ (last in series) +1 0 type reply +1 0 last-reply indicator +2 CARD16 sequence-number +4 2 reply length + +OpenBitmapFont +1 15 major-opcode +1 unused +2 4+(n+p)/4 length +4 FONTID fontid +4 BITMAPFORMATMASK format-mask +4 BITMAPFORMAT format +n STRNAME pattern +p unused, p=pad(n) +▶ +1 0 type reply +1 BOOL otherid-valid +2 CARD16 sequence-number +4 4 length +4 FONTID otherid +1 BOOL cachable +3 unused + +QueryXInfo +1 16 major-opcode +1 unused +2 2 length +4 FONTID fontid +▶ +1 0 type reply +1 unused +2 CARD16 sequence-number +4 2+f/4 length +f XFONTINFO fontinfo +p unused, p=pad(f) + +QueryXExtents8 +1 17 major-opcode +1 BOOL range +2 3+(n+p)/4 length +4 FONTID fontid +4 n number chars entries +n STRING8 chars +p unused, p=pad(n) +▶ +1 0 type reply +1 unused +2 CARD16 sequence-number +4 3+3*n length +4 n number of extents +12*n LISTofXCHARINFO extents + +QueryXExtents16 +1 18 major-opcode +1 BOOL range +2 3+(2*n+p)/4 length +4 FONTID fontid +4 n number chars entries +2*n LISTofCHAR2B chars +p unused, p=pad(2*n) +▶ +1 0 type reply +1 unused +2 CARD16 sequence-number +4 3+3*n length +4 n number of extents +12*n LISTofXCHARINFO extents + +QueryXBitmaps8 +1 19 major-opcode +1 BOOL range +2 4+(n+p)/4 length +4 FONTID fontid +4 BITMAPFORMAT format +4 n number of chars entries +n STRING8 chars +p unused, p=pad(n) +▶+ +1 0 type reply +1 unused +2 CARD16 sequence-number +4 5+2*n+(m+p)/4 length +4 CARD32 replies-following-hint +4 n number of offsets +4 m number of bytes of glyph images +8*n LISTofOFFSET32 offsets +m LISTofBYTE glyphimages +p unused, p=pad(m) + +QueryXBitmaps16 +1 20 major-opcode +1 BOOL range +2 4+(2*n+p)/4 length +4 FONTID fontid +4 BITMAPFORMAT format +4 n number of chars entries +2*n LISTofCHAR2B chars +p unused, p=pad(2*n) +▶ +1 0 type reply +1 unused +2 CARD16 sequence-number +4 5+2*n+(m+p)/4 length +4 CARD32 replies-following-hint +4 n number of offsets +4 m number of bytes of glyph images +8*n LISTofOFFSET32 offsets +m LISTofBYTE glyphimages +p unused, p=pad(m) + +CloseFont +1 21 major-opcode +1 unused +2 2 length +4 FONTID fontid + +
+ +
+Errors + + +Request +1 1 type error +1 0 Request +2 CARD16 sequence-number +4 4 length +4 TIMESTAMP timestamp +1 CARD8 major-opcode +1 CARD8 minor-opcode +2 unused + +Format +1 1 type error +1 1 Format +2 CARD16 sequence-number +4 5 length +4 TIMESTAMP timestamp +1 CARD8 major-opcode +1 CARD8 minor-opcode +2 unused +4 BITMAPFORMAT bad-format + +Font +1 1 type error +1 2 Font +2 CARD16 sequence-number +4 5 length +4 TIMESTAMP timestamp +1 CARD8 major-opcode +1 CARD8 minor-opcode +2 unused +4 FONTID bad-fontid + +Range +1 1 type error +1 3 Range +2 CARD16 sequence-number +4 5 length +4 TIMESTAMP timestamp +1 CARD8 major-opcode +1 CARD8 minor-opcode +2 unused +4 RANGE bad-range + +EventMask +1 1 type error +1 4 EventMask +2 CARD16 sequence-number +4 5 length +4 TIMESTAMP timestamp +1 CARD8 major-opcode +1 CARD8 minor-opcode +2 unused +4 EVENTMASK event-mask + +AccessContext +1 1 type error +1 5 AccessContext +2 CARD16 sequence-number +4 5 length +4 TIMESTAMP timestamp +1 CARD8 major-opcode +1 CARD8 minor-opcode +2 unused +4 ACCESSCONTEXT access context + +IDChoice +1 1 type error +1 6 IDChoice +2 CARD16 sequence-number +4 5 length +4 TIMESTAMP timestamp +1 CARD8 major-opcode +1 CARD8 minor-opcode +2 unused +4 FONTID bad-fontid + +Name +1 1 type error +1 7 Name +2 CARD16 sequence-number +4 4 length +4 TIMESTAMP timestamp +1 CARD8 major-opcode +1 CARD8 minor-opcode +2 unused + +Resolution +1 1 type error +1 8 Resolution +2 CARD16 sequence-number +4 5 length +4 TIMESTAMP timestamp +1 CARD8 major-opcode +1 CARD8 minor-opcode +6 RESOLUTION resolution + +Alloc +1 1 type error +1 9 Alloc +2 CARD16 sequence-number +4 4 length +4 TIMESTAMP timestamp +1 CARD8 major-opcode +1 CARD8 minor-opcode +2 unused + +Length +1 1 type error +1 10 Length +2 CARD16 sequence-number +4 5 length +4 TIMESTAMP timestamp +1 CARD8 major-opcode +1 CARD8 minor-opcode +2 unused +4 CARD32 bad-length + +Implementation +1 1 type error +1 11 Implementation +2 CARD16 sequence-number +4 4 length +4 TIMESTAMP timestamp +1 CARD8 major-opcode +1 CARD8 minor-opcode +2 unused + + +
+ +
+Events + +KeepAlive +1 2 type event +1 0 event KeepAlive +2 CARD16 sequence-number +4 3 length +4 TIMESTAMP timestamp + +CatalogueListNotify +1 2 type event +1 1 event CatalogueListNotify +2 CARD16 sequence-number +4 4 length +4 TIMESTAMP timestamp +1 BOOL added +1 BOOL deleted +2 unused + +FontListNotify +1 2 type event +1 2 event FontListNotify +2 CARD16 sequence-number +4 4 length +4 TIMESTAMP timestamp +1 BOOL added +1 BOOL deleted +2 unused + + +
+ + + +Acknowledgements + + + + +This document represents the culmination of several years of debate and +experiments done under the auspices of the +MIT X Consortium font working group. +Although this was a group effort, the author remains responsible for any errors +or omissions. The protocol presented here was primarily designed by +JimFulton, +KeithPackard, +and +BobScheifler. +Special thanks goes to +NedBatchelder, +JimFlowers, +and +AxelDeininger +for their invigorating comments +which never failed to make this a better document. +StephenGildea +edited version 2 of this document. Finally, +DavidLemke +deserves great credit for designing and coding the sample implementation. + + + + +References + +All of the following documents are X Consortium standards available from +the X Consortium. + + + 1 + <olink targetdoc='x11protocol' targetptr='x11protocol'>X Window System Protocol Version 11</olink> + Robert W.Scheifler + + + + 2 + Adobe Systems + Bitmap Distribution Format 2.1 + + + + 3 + X Consortium + <olink targetdoc='xlfd' targetptr='xlfd'>X Logical Font + Description Conventions, Version 1.5</olink> + + + + + +Suggested Licensing Policies + +The authorization data passed by the client in the initial connection +setup information may be used by the font server to implement restrictions +on which fonts may be accessed. Furthermore, the font server is free to +refuse new connections at any time. + + +Configuration or management of the license restrictions is outside the scope of +the font service protocol and is done in a server-dependent manner. Possible +policies might include, but are not limited to, combinations of the following: + + + + + No restrictions + + +anyone may access any fonts. The server neither refuses any connections +nor generates AccessContext errors on any +fonts. For environments without specially-licensed fonts, this is +sufficient. + + + + + Per-machine + + +only those clients connecting from a known set of +machines are permitted access. The server could get the address +of the connection and look in a list of allowed machines. + + + + + Per-user + + +only a known set of users may access the fonts. The +server can use the authorization data (such as a Kerberos ticket +or a Secure RPC credential) to verify the identity of the user +and then look in a list of allowed users. + + + + + Simultaneous Use + + +only a certain number of clients may use a given font at any one time. +Additional clients would receive AccessContext +errors if they attempt to open the font. This is only effective if +the initial clients keep the font open for the entire time that it +is being used (even if all of the data has been transmitted and is +being cached). + + + + + Postage Meter + + +a particular font may only be accessed a limited +number of times before its license must be renewed. Each time +the font is opened, the server decrements a counter. When the +counter reaches zero, all further attempts to open the font +return an AccessContext error. + + + + + + + +It should be noted that chaining of font servers (obtaining font data from +other font servers) may conflict with certain license policies. + + + + +Implementation Suggestions + +Font server implementations will probably wish to use techniques such as the +following to avoid limits on the number of simultaneous connections: + + + + +The initial connection information returned by the font +server contains the names of other font servers that +may be used as substitutes. A font server may refuse to +accept a connection, indicating that the client should +try one of the alternatives instead. + + + + +On operating systems that support processing forking, font +servers might choose to fork so that the child can continue +processing the existing connections and the parent can accept +new connections. Such implementations are encouraged to use +shared memory so that in-memory font databases can be shared. + + + + +On operating systems that support passing stream file descriptors +between processes, cooperating font servers could collect +connections in a single process when there are few connections +and spread them among several processes as the load increases. + + + + +If a font client is unable to connect to a server (as opposed +to having the connection terminated), it should retry for an +implementation-dependent length of time (see Xlib's +handling of ECONNREFUSED in XConnDis.c). + + + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-1.svg b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-1.svg new file mode 100644 index 0000000000000000000000000000000000000000..1f8ba5b75902388d6ac1afe32ee3f27ebd5ff8b7 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-1.svg @@ -0,0 +1,1177 @@ + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-10.svg b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-10.svg new file mode 100644 index 0000000000000000000000000000000000000000..76600793e391515b9a1657e4b5b38c9b99bf185f --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-10.svg @@ -0,0 +1,142 @@ + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-11.svg b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-11.svg new file mode 100644 index 0000000000000000000000000000000000000000..fa334dea183012ccf3f9b530d5eaf402fb413087 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-11.svg @@ -0,0 +1,2730 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + <ESC> + <FK01> + <FK02> + <FK03> + <FK04> + <FK05> + <FK06> + <FK07> + <FK08> + + + + + <AE12> + + + <TAB> + + + <CAPS> + + + <LFSH> + + + <AE01> + + + <AD01> + + + <AC01> + + + <AB01> + + + <TLDE> + + + <AE02> + + + <AD02> + + + <AC02> + + + <AB02> + + + <INS> + + + <AE03> + + + <AD03> + + + <AC03> + + + <AB03> + + + <LEFT> + + + <AE04> + + + <AD04> + + + <AC04> + + + <AB04> + + + <RGHT> + + + <AE05> + + + <AD05> + + + <AC05> + + + <AB05> + + + + + + + + + + + + <FK09> + <FK10> + <FK11> + <FK12> + <PRSC> + <SCLK> + <PAUS> + <FK16> + <FK17> + + + + + + + + <AE06> + + + <AD06> + + + <AC06> + + + <AB06> + + + <NMLK> + <AE07> + + + <KP7> + <AD07> + + + <KP4> + <AC07> + + + <KP1> + <AB07> + + + <UP> + + + <KPEQ> + <AE08> + + + <KP8> + <AD08> + + + <KP5> + <AC08> + + + <KP2> + <AB08> + + + <DOWN> + + + <KPSL> + <AE09> + + + <KP9> + <AD09> + + + <KP6> + <AC09> + + + <KP3> + <AB09> + + + <AD11> + + + <KPMU> + <AE10> + + + <KPSU> + <AD10> + + + <KPAD> + <AC10> + + + <KPEN> + <AB10> + + + <AD12> + <KPEN> + <AE11> + + + <BKSL> + + + <AC11> + + + <RTSH> + + + + + + + + + <RALT> + + + + + + + <PGUP> + + + + + + + <PGDN> + + + + + + <RCTL> + + + + + <RTRN> + + + + + + <KP0> + <SPCE> + + + + + + + + <LALT> + + + + + <HOME> + + + + + <END> + + + + + <LCTL> + + + + + <DELE> + + + + + <BKSP> + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-2.svg b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-2.svg new file mode 100644 index 0000000000000000000000000000000000000000..495be15370218fb53cd5a056dd5f9df4ba8722c0 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-2.svg @@ -0,0 +1,544 @@ + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-3.svg b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-3.svg new file mode 100644 index 0000000000000000000000000000000000000000..30744c590315ce9e7785c4df773f5c5b772c5a25 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-3.svg @@ -0,0 +1,461 @@ + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-4.svg b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-4.svg new file mode 100644 index 0000000000000000000000000000000000000000..f5578d33229d22809b5c20329bf88afd8958b5f3 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-4.svg @@ -0,0 +1,463 @@ + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-5.svg b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-5.svg new file mode 100644 index 0000000000000000000000000000000000000000..0deeacc189a5c20229ee1aa2cfbc4d7695085d66 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-5.svg @@ -0,0 +1,468 @@ + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-6.svg b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-6.svg new file mode 100644 index 0000000000000000000000000000000000000000..a274f2b07d9c2e95f1f335562f80f4d0681633ef --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-6.svg @@ -0,0 +1,558 @@ + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + + + Core Symbols + + + + + + + A + a + + + + L1 + L2 + L1 + L2 + G1 + G2 + + + + Xkb Symbols + + + + + + + A + a + + + L1 + L2 + G1 + G2 + + + Symbols + a + G1L1 = + A + G1L2 = + + + + G2L1 = + + + + G2L2 = + + + + + Physical Key + Shift Level + Group + + + + + + + a + A + + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-7.svg b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-7.svg new file mode 100644 index 0000000000000000000000000000000000000000..82b80a6505a33adf672b9a2575b508213fe4a4b5 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-7.svg @@ -0,0 +1,474 @@ + + + + + + + + + + image/svg+xml + + + + + + + + + + + + + + Key: + Keycode: + 13 + + NumLock + 15 + + Enter + 12 + + 1 + End + 9 + + è + ö + 8 + + Q + q + @ + 10 + + A + a + + + + æ + 11 + + ? + \ + ? + ϐ + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-8.svg b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-8.svg new file mode 100644 index 0000000000000000000000000000000000000000..8baa3e36ab2105821a130ce9f4cdeff2661ec2c0 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-8.svg @@ -0,0 +1,138 @@ + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-9.svg b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-9.svg new file mode 100644 index 0000000000000000000000000000000000000000..8baa3e36ab2105821a130ce9f4cdeff2661ec2c0 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/XKBproto-9.svg @@ -0,0 +1,138 @@ + + + + + + image/svg+xml + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/acknowledgements.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/acknowledgements.xml new file mode 100644 index 0000000000000000000000000000000000000000..95b9521e0d3d85699a44988fac94e4db2908a99e --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/acknowledgements.xml @@ -0,0 +1,41 @@ + +Acknowledgments + + +I am grateful for all of the comments and suggestions I have received over the years. I could not possibly list everyone who has helped, but a few people have gone well above and beyond the call of duty and simply must be listed here. + + + +My managers here at SGI, Tom Paquin (now at Netscape) and Gianni Mariani were wonderful. Rather than insisting on some relatively quick, specialized proprietary solution to the keyboard problems we were having, both Tom and Gianni understood the importance of solving them in a general way and for the community as a whole. That was a difficult position to take and it was even harder to maintain when the scope of the project expanded beyond anything we imagined was possible. Gianni and Tom were unflagging in their support and their desire to “do the right thing” despite the schedule and budget pressure that intervened from time to time. + + + +Will Walker, at Digital Equipment Corporation, has been a longtime supporter of XKB. His help and input was essential to ensure that the extension as a whole fits and works together well. His focus was AccessX but the entire extension has benefited from his input and hard work. Without his unflagging good cheer and willingness to lend a hand, XKB would not be where it is today. + + + +Matt Landau, at the X Consortium, stood behind XKB during some tough spots in the release and standardization process. Without Matt’s support, XKB would likely not be a standard for a long time to come. When it became clear that we had too much to do for the amount of time we had remaining, Matt did a fantastic job of finding people to help finish the work needed for standardization. + + + +One of those people was George Sachs, at Hewlett-Packard, who jumped in to help out. His help was essential in getting the extension into this release. Another was Donna Converse, who helped figure out how to explain all of this stuff to someone who hadn’t had their head buried in it for years. + + + +Amber Benson and Gary Aitken were simply phenomenal. They jumped into a huge and complicated project with good cheer and unbelievable energy. They were “up to speed” and contributing within days. I stand in awe of the amount that they managed to achieve in such a short time. Thanks to Gary and Amber, the XKB library specification is a work of art and a thousand times easier to use and more useful than it would otherwise be. + + + +I truly cannot express my gratitude to all of you, without whom this would not have been possible. + + + +Erik Fortune + + +Silicon Graphics, Inc. + + +5 February 1996 + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/appA.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/appA.xml new file mode 100644 index 0000000000000000000000000000000000000000..fd26bac22106bfa4f1cabd77168f3f58d8649883 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/appA.xml @@ -0,0 +1,916 @@ + +Default Symbol Transformations + + +Interpreting the Control Modifier + + +If the +Control + modifier is not consumed by the symbol lookup process, routines that determine +the symbol and string that correspond to an event should convert the symbol to +a string as defined in the table below. Only the string to be returned is +affected by the +Control + modifier; the symbol is not changed. + + + + +This table lists the decimal value of the standard control characters that +correspond to some keysyms for ASCII characters. Control characters for symbols +not listed in this table are application-specific. + + + + + + + + + + + + + + + + Keysyms + Value + Keysyms + Value + Keysyms + Value + Keysyms + Value + + + + + atsign + 0 + h, H + 8 + p, P + 16 + x, X + 24 + + + a, A + 1 + i, I + 9 + q, Q + 17 + y, Y + 25 + + + b, B + 2 + j, J + 10 + r, R + 18 + z, Z + 26 + + + c, C + 3 + k, K + 11 + s, S + 19 + left_bracket + 27 + + + d, D + 4 + l, L + 12 + t, T + 20 + backslash + 28 + + + e, E + 5 + m, M + 13 + u, U + 21 + right_bracket + 29 + + + f, F + 6 + n, N + 14 + v, V + 22 + asciicircum + 30 + + + g, G + 8 + o, O + 15 + w, W + 23 + underbar + 31 + + + + + + + +Interpreting the Lock Modifier + + +If the +Lock + modifier is not consumed by the symbol lookup process, routines that determine +the symbol and string that correspond to an event should capitalize the result. +Unlike the transformation for +Control +, the capitalization transformation changes both the symbol and the string +returned by the event. + + + +Locale-Sensitive Capitalization + + +If +Lock + is set in an event and not consumed, applications should capitalize the string +and symbols that result from an event according to the capitalization rules in +effect for the system on which the application is running, taking the current +state of the user environment (e.g. locale) into account. + + + + + +Locale-Insensitive Capitalization + + +XKB recommends but does not require locale-sensitive capitalization. In cases +where the locale is unknown or where locale-sensitive capitalization is +prohibitively expensive, applications can capitalize according to the rules +defined in this extension. + + + + +The following tables list all of the keysyms for which XKB defines +capitalization behavior. Any keysyms not explicitly listed in these tables are +not capitalized by XKB when locale-insensitive capitalization is in effect and +are not automatically assigned the +ALPHABETIC + type as described in the Alphabetic Key Type. + + + + +Capitalization Rules for Latin-1 Keysyms + + +This table lists the Latin-11 keysyms for which XKB defines upper and lower +case: + + + + + + + + + + + + + + + + Lower Case + Upper Case + Lower Case + Upper Case + Lower Case + Upper Case + Lower Case + Upper Case + + + + + a + A + o + O + acircumflex + Acircumflex + eth + ETH + + + b + B + p + P + adiaeresis + Adiaeresis + ntilde + Ntilde + + + c + C + q + Q + atilde + Atilde + ograve + Ograve + + + d + D + r + R + aring + Aring + oacute + Oacute + + + e + E + s + S + ae + AE + ocircumflex + Ocircumflex + + + f + F + t + T + ccedilla + Ccedilla + otilde + Otilde + + + g + G + u + U + egrave + Egrave + odiaeresis + Odiaeresis + + + h + H + v + V + eacute + Eacute + oslash + Ooblique + + + i + I + w + W + ecircumflex + Ecircumflex + ugrave + Ugrave + + + j + J + x + X + ediaeresis + Ediaeresis + uacute + Uacute + + + k + K + y + Y + igrave + Igrave + ucircumflex + Ucircumflex + + + l + L + z + Z + iacute + Iacute + udiaeresis + Udiaeresis + + + m + M + agrave + Agrave + icircumflex + Icircumflex + yacute + Yacute + + + n + N + aacute + Aacute + idiaeresis + Idiaeresis + thorn + THORN + + + + + + + +Capitalization Rules for Latin-2 Keysyms + + +This table lists the Latin-2 keysyms for which XKB defines upper and lower case: + + + + + + + + + + + + + + Lower Case + Upper Case + Lower Case + Upper Case + Lower Case + Upper Case + + + + + aogonek + Aogonek + zabovedot + Zabovedot + dstroke + Dstroke + + + lstroke + Lstroke + racute + Racute + nacute + Nacute + + + lcaron + Lcaron + abreve + Abreve + ncaron + Ncaron + + + sacute + Sacute + lacute + Lacute + odoubleacute + Odoubleacute + + + scaron + Scaron + cacute + Cacute + rcaron + Rcaron + + + scedilla + Scedilla + ccaron + Ccaron + uabovering + Uabovering + + + tcaron + Tcaron + eogonek + Eogonek + udoubleacute + Udoubleacute + + + zacute + Zacute + ecaron + Ecaron + tcedilla + Tcedilla + + + zcaron + Zcaron + dcaron + Dcaron + + + + + + + + + +Capitalization Rules for Latin-3 Keysyms + + +This table lists the Latin-3 keysyms for which XKB defines upper and lower case: + + + + + + + + + + + + + + Lower Case + Upper Case + Lower Case + Upper Case + Lower Case + Upper Case + + + + + hstroke + Hstroke + jcircumflex + Jcircumflex + gcircumflex + Gcircumflex + + + hcircumflex + Hcircumflex + cabovedot + Cabovedot + ubreve + Ubreve + + + idotless + Iabovedot + ccircumflex + Ccircumflex + scircumflex + Scircumflex + + + gbreve + Gbreve + gabovedot + Gabovedot + + + + + + + + + +Capitalization Rules for Latin-4 Keysyms + + +This table lists the Latin-4 keysyms for which XKB defines upper and lower case: + + + + + + + + + + + + + + Lower Case + Upper Case + Lower Case + Upper Case + Lower Case + Upper Case + + + + + rcedilla + Rcedilla + eng + ENG + omacron + Omacron + + + itilde + Itilde + amacron + Amacron + kcedilla + Kcedilla + + + lcedilla + Lcedilla + iogonek + Iogonek + uogonek + Uogonek + + + emacron + Emacron + eabovedot + eabovedot + utilde + Utilde + + + gcedilla + Gcedilla + imacron + Imacron + umacron + Umacron + + + tslash + Tslash + ncedilla + Ncedilla + + + + + + + + + +Capitalization Rules for Cyrillic Keysyms + + +This table lists the Cyrillic keysyms for which XKB defines upper and lower +case: + + + + + + + + + + + + Lower Case + Upper Case + Lower Case + Upper Case + + + + + Serbian_dje + Serbian_DJE + Cyrillic_i + Cyrillic_I + + + Macedonia_gje + Macedonia_GJE + Cyrillic_shorti + Cyrillic_SHORTI + + + Cyrillic_io + Cyrillic_IO + Cyrillic_ka + Cyrillic_KA + + + Ukrainian_ie + Ukrainian_IE + Cyrillic_el + Cyrillic_EL + + + Macedonia_dse + Macedonia_DSE + Cyrillic_em + Cyrillic_EM + + + Ukrainian_i + Ukrainian_I + Cyrillic_en + Cyrillic_EN + + + Ukrainian_yi + Ukrainian_YI + Cyrillic_o + Cyrillic_O + + + Cyrillic_je + Cyrillic_JE + Cyrillic_pe + Cyrillic_PE + + + Cyrillic_lje + Cyrillic_LJE + Cyrillic_ya + Cyrillic_YA + + + Cyrillic_nje + Cyrillic_NJE + Cyrillic_er + Cyrillic_ER + + + Serbian_tshe + Serbian_TSHE + Cyrillic_es + Cyrillic_ES + + + Macedonia_kje + Macedonia_KJE + Cyrillic_te + Cyrillic_TE + + + Byelorussian_shortu + Byelorussian_SHORTU + Cyrillic_u + Cyrillic_U + + + Cyrillic_dzhe + Cyrillic_DZHE + Cyrillic_zhe + Cyrillic_ZHE + + + Cyrillic_yu + Cyrillic_YU + Cyrillic_ve + Cyrillic_VE + + + Cyrillic_a + Cyrillic_A + Cyrillic_softsign + Cyrillic_SOFTSIGN + + + Cyrillic_be + Cyrillic_BE + Cyrillic_yeru + Cyrillic_YERU + + + Cyrillic_tse + Cyrillic_TSE + Cyrillic_ze + Cyrillic_ZE + + + Cyrillic_de + Cyrillic_DE + Cyrillic_sha + Cyrillic_SHA + + + Cyrillic_ie + Cyrillic_IE + Cyrillic_e + Cyrillic_E + + + Cyrillic_ef + Cyrillic_EF + Cyrillic_shcha + Cyrillic_SHCHA + + + Cyrillic_ghe + Cyrillic_GHE + Cyrillic_che + Cyrillic_CHE + + + Cyrillic_ha + Cyrillic_HA + Cyrillic_hardsign + Cyrillic_HARDSIGN + + + + + + + +Capitalization Rules for Greek Keysyms + + +This table lists the Greek keysyms for which XKB defines upper and lower case: + + + + + + + + + + + + Lower Case + Upper Case + Lower Case + Upper Case + + + + + Greek_omegaaccent + Greek_OMEGAACCENT + Greek_iota + Greek_IOTA + + + Greek_alphaaccent + Greek_ALPHAACCENT + Greek_kappa + Greek_KAPPA + + + Greek_epsilonaccent + Greek_EPSILONACCENT + Greek_lamda + Greek_LAMDA + + + Greek_etaaccent + Greek_ETAACCENT + Greek_lambda + Greek_LAMBDA + + + Greek_iotaaccent + Greek_IOTAACCENT + Greek_mu + Greek_MU + + + Greek_iotadieresis + Greek_IOTADIERESIS + Greek_nu + Greek_NU + + + Greek_omicronaccent + Greek_OMICRONACCENT + Greek_xi + Greek_XI + + + Greek_upsilonaccent + Greek_UPSILONACCENT + Greek_omicron + Greek_OMICRON + + + Greek_upsilondieresis + Greek_UPSILONDIERESIS + Greek_pi + Greek_PI + + + Greek_alpha + Greek_ALPHA + Greek_rho + Greek_RHO + + + Greek_beta + Greek_BETA + Greek_sigma + Greek_SIGMA + + + Greek_gamma + Greek_GAMMA + Greek_tau + Greek_TAU + + + Greek_delta + Greek_DELTA + Greek_upsilon + Greek_UPSILON + + + Greek_epsilon + Greek_EPSILON + Greek_phi + Greek_PHI + + + Greek_zeta + Greek_ZETA + Greek_chi + Greek_CHI + + + Greek_eta + Greek_ETA + Greek_psi + Greek_PSI + + + Greek_theta + Greek_THETA + Greek_omega + Greek_OMEGA + + + + + + + +Capitalization Rules for Other Keysyms + + +XKB defines no capitalization rules for symbols in any other set of keysyms +provided by the consortium. Applications are free to apply additional rules for +private keysyms or for other keysyms not covered by XKB. + + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/appB.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/appB.xml new file mode 100644 index 0000000000000000000000000000000000000000..85137cff4372b9eb9b4e274fcb5faafefd7f1e9e --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/appB.xml @@ -0,0 +1,129 @@ + +Canonical Key Types + + +Canonical Key Types + +The ONE_LEVEL Key Type + + +The +ONE_LEVEL + key type describes groups that have only one symbol. The default +ONE_LEVEL + type has no map entries and does not pay attention to any modifiers. + + + + +The TWO_LEVEL Key Type + + +The +TWO_LEVEL + key type describes groups that have two symbols but are neither alphabetic nor +numeric keypad keys. The default +TWO_LEVEL + type uses only the +Shift + modifier. It returns level two if +Shift + is set, level one if it is not. + + + + + +The ALPHABETIC Key Type + + +The +ALPHABETIC + key type describes groups that consist of two symbols — the lowercase form +of a symbol followed by the uppercase form of the same symbol. The default + +ALPHABETIC + type implements locale-sensitive "shift cancels caps lock" behavior using both +the +Shift + and +Lock + modifiers as follows: + + + + + If +Shift + and +Lock + are both set, the default +ALPHABETIC + type yields level one. + + + + If +Shift + alone is set, it yields level two. + + + + If +Lock + alone is set, it yields level one but preserves the +Lock + modifier. + + + + If neither +Shift + nor +Lock + are set, it yields level one. + + + + + + +The KEYPAD Key Type + + +The +KEYPAD + key type describes that consist of two symbols, at least one of which is a +numeric keypad symbol. The default +KEYPAD + type implements "shift cancels numeric lock" behavior using the +Shift + modifier and the real modifier bound to the virtual modifier named "NumLock" +(the "NumLock" modifier) as follows: + + + + + If +Shift + and the "NumLock" modifier are both set, the default +KEYPAD +type yields level one. + + + + If either +Shift + or the "NumLock" modifier alone are set, it yields level two. + + + + If neither +Shift + nor the "NumLock" modifier are set, it yields level one. + + + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/appC.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/appC.xml new file mode 100644 index 0000000000000000000000000000000000000000..6e47caea95e07c3efdd5d1461d68f0d302402b6d --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/appC.xml @@ -0,0 +1,715 @@ + +New KeySyms + + +New KeySyms + +KeySyms Used by the ISO9995 Standard + + + + + + + + + + Byte 3 + Byte 4 + Character + Name + + + + + 254 + 1 + + ISO LOCK + + + 254 + 2 + + ISO LATCHING LEVEL TWO SHIFT + + + 254 + 3 + + ISO LEVEL THREE SHIFT + + + 254 + 4 + + ISO LATCHING LEVEL THREE SHIFT + + + 254 + 5 + + ISO LEVEL THREE SHIFT LOCK + + + 254 + 6 + + ISO LATCHING GROUP SHIFT + + + 254 + 7 + + ISO GROUP SHIFT LOCK + + + 254 + 8 + + ISO NEXT GROUP + + + 254 + 9 + + ISO LOCK NEXT GROUP + + + 254 + 10 + + ISO PREVIOUS GROUP + + + 254 + 11 + + ISO LOCK PREVIOUS GROUP + + + 254 + 12 + + ISO FIRST GROUP + + + 254 + 13 + + ISO LOCK FIRST GROUP + + + 254 + 14 + + ISO LAST GROUP + + + 254 + 15 + + ISO LOCK LAST GROUP + + + 254 + 32 + + LEFT TAB + + + 254 + 33 + + MOVE LINE UP + + + 254 + 34 + + MOVE LINE DOWN + + + 254 + 35 + + PARTIAL LINE UP + + + 254 + 36 + + PARTIAL LINE DOWN + + + 254 + 37 + + PARTIAL SPACE LEFT + + + 254 + 38 + + PARTIAL SPACE RIGHT + + + 254 + 39 + + SET MARGIN LEFT + + + 254 + 40 + + SET MARGIN RIGHT + + + 254 + 41 + + RELEASE MARGIN LEFT + + + 254 + 42 + + RELEASE MARGIN RIGHT + + + 254 + 43 + + RELEASE MARGIN LEFT AND RIGHT + + + 254 + 44 + + FAST CURSOR LEFT + + + 254 + 45 + + FAST CURSOR RIGHT + + + 254 + 46 + + FAST CURSOR UP + + + 254 + 47 + + FAST CURSOR DOWN + + + 254 + 48 + + CONTINUOUS UNDERLINE + + + 254 + 49 + + DISCONTINUOUS UNDERLINE + + + 254 + 50 + + EMPHASIZE + + + 254 + 51 + + CENTER OBJECT + + + 254 + 52 + + ISO_ENTER + + + + + + + +KeySyms Used to Control The Core Pointer + + + + + + + + + + Byte 3 + Byte 4 + Character + Name + + + + + 254 + 224 + + POINTER LEFT + + + 254 + 225 + + POINTER RIGHT + + + 254 + 226 + + POINTER UP + + + 254 + 227 + + POINTER DOWN + + + 254 + 228 + + POINTER UP AND LEFT + + + 254 + 229 + + POINTER UP AND RIGHT + + + 254 + 230 + + POINTER DOWN AND LEFT + + + 254 + 231 + + POINTER DOWN AND RIGHT + + + 254 + 232 + + DEFAULT POINTER BUTTON + + + 254 + 233 + + POINTER BUTTON ONE + + + 254 + 234 + + POINTER BUTTON TWO + + + 254 + 235 + + POINTER BUTTON THREE + + + 254 + 236 + + POINTER BUTTON FOUR + + + 254 + 237 + + POINTER BUTTON FIVE + + + 254 + 238 + + DEFAULT POINTER BUTTON DOUBLE CLICK + + + 254 + 239 + + POINTER BUTTON ONE DOUBLE CLICK + + + 254 + 240 + + POINTER BUTTON TWO DOUBLE CLICK + + + 254 + 241 + + POINTER BUTTON THREE DOUBLE CLICK + + + 254 + 242 + + POINTER BUTTON FOUR DOUBLE CLICK + + + 254 + 243 + + POINTER BUTTON FIVE DOUBLE CLICK + + + 254 + 244 + + DRAG DEFAULT POINTER BUTTON + + + 254 + 245 + + DRAG POINTER BUTTON ONE + + + 254 + 246 + + DRAG POINTER BUTTON TWO + + + 254 + 247 + + DRAG POINTER BUTTON THREE + + + 254 + 248 + + DRAG POINTER BUTTON FOUR + + + 254 + 249 + + ENABLE POINTER FROM KEYBOARD + + + 254 + 250 + + ENABLE KEYBOARD POINTER ACCEL + + + 254 + 251 + + SET DEFAULT POINTER BUTTON NEXT + + + 254 + 252 + + SET DEFAULT POINTER BUTTON PREVIOUS + + + 254 + 253 + + DRAG POINTER BUTTON FIVE + + + + + + + +KeySyms Used to Change Keyboard Controls + + + + + + + + + + Byte 3 + Byte 4 + Character + Name + + + + + 254 + 112 + + ENABLE ACCESSX KEYS + + + 254 + 113 + + ENABLE ACCESSX FEEDBACK + + + 254 + 114 + + TOGGLE REPEAT KEYS + + + 254 + 115 + + TOGGLE SLOW KEYS + + + 254 + 116 + + ENABLE BOUNCE KEYS + + + 254 + 117 + + ENABLE STICKY KEYS + + + 254 + 118 + + ENABLE MOUSE KEYS + + + 254 + 119 + + ENABLE MOUSE KEYS ACCELERATION + + + 254 + 120 + + ENABLE OVERLAY1 + + + 254 + 121 + + ENABLE OVERLAY2 + + + 254 + 122 + + ENABLE AUDIBLE BELL + + + + + + + +KeySyms Used To Control The Server + + + + + + + + + + Byte + Byte + Character + Name + + + + + 254 + 208 + + FIRST SCREEN + + + 254 + 209 + + PREVIOUS SCREEN + + + 254 + 210 + + NEXT SCREEN + + + 254 + 211 + + LAST SCREEN + + + 254 + 212 + + TERMINATE SERVER + + + + + + + +KeySyms for Non-Spacing Diacritical Keys + + + + + + + + + + Byte + Byte + Character + Name + + + + + 254 + 80 + + DEAD GRAVE ACCENT + + + 254 + 81 + + DEAD ACUTE ACCENT + + + 254 + 82 + + DEAD CIRCUMFLEX + + + 254 + 83 + + DEAD TILDE + + + 254 + 84 + + DEAD MACRON + + + 254 + 85 + + DEAD BREVE + + + 254 + 86 + + DEAD DOT ABOVE + + + 254 + 87 + + DEAD DIAERESIS + + + 254 + 88 + + DEAD RING ABOVE + + + 254 + 89 + + DEAD DOUBLE ACUTE ACCENT + + + 254 + 90 + + DEAD CARON + + + 254 + 91 + + DEAD CEDILLA + + + 254 + 92 + + DEAD OGONEK + + + 254 + 93 + + DEAD IOTA + + + 254 + 94 + + DEAD VOICED SOUND + + + 254 + 95 + + DEAD SEMI VOICED SOUND + + + 254 + 96 + + DEAD DOT BELOW + + + + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/appD.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/appD.xml new file mode 100644 index 0000000000000000000000000000000000000000..147373b23e4e968c4602698cc72cf3893344a065 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/appD.xml @@ -0,0 +1,2096 @@ + +Protocol Encoding + + +Syntactic Conventions + + +This document uses the same syntactic conventions as the encoding of the core X +protocol, with the following additions: + + + +A LISTofITEMs contains zero or more items of variable type and size. The encode +form for a LISTofITEMs is: + + + +v LISTofITEMs NAME + + TYPE MASK-EXPRESSION + value1 corresponding field(s) + ... + valuen corresponding field(s) + + + +The MASK-EXPRESSION is an expression using C-style boolean operators and fields +of the request which specifies the bitmask used to determine whether or not a +member of the LISTofITEMs is present. If present, TYPE specifies the +interpretation of the resulting bitmask and the values are listed using the +symbolic names of the members of the set. If TYPE is blank, the values are +numeric constants. + + + + +It is possible for a single bit in the MASK-EXPRESSION to control more than one +ITEM — if the bit is set, all listed ITEMs are present. It is also possible +for multiple bits in the MASK-EXPRESSION to control a single ITEM — if any of +the bits associated with an ITEM are set, it is present in the LISTofITEMs. + + + + +The size of a LISTofITEMS is derived from the items that are present in the +list, so it is always given as a variable in the request description, and the +request is followed by a section of the form: + + + +ITEMs +encode-form +... +encode-form + + + +listing an encode-form for each ITEM. The NAME in each encode-form keys to the +fields listed as corresponding to each bit in the MASK-EXPRESSION. Items are +not necessarily the same size, and the size specified in the encoding form is +the size that the item occupies if it is present. + + + + +Some types are of variable size. The encode-form for a list of items of a +single type but variable size is: + + + +S0+..Ss LISTofTYPE name + + + +Which indicates that the list has +s + elements of variable size and that the size of the list is the sum of the +sizes of all of the elements that make up the list. The notation Sn refers to +the size of the +n +th element of the list and the notation S* refers to the size of the list as a +whole. + + + + +The definition of a type of variable size includes an expression which +specifies the size. The size is specified as a constant plus a variable +expression; the constant specifies the size of the fields that are always +present and the variables which make up the variable expression are defined in +the constant portion of the structure. For example, the following definition +specifies a counted string with a two-byte length field preceding the string: + + + + +TYPE 2+n+p +2 n length +n STRING8 string +p unused,p=pad(n) + + + +Some fields are optional. The size of an optional field has the form: +"[ +expr +]" where expr specifies the size of the field if it is present. An explanation +of the conditions under which the field is present follows the name in the +encode form: + + + +1 BOOL more +3 unused +[4] CARD32 optData, if more==TRUE + + + +This portion of the structure is four bytes long if more is FALSE or eight +bytes long if more is TRUE. This notation can also be used in size expressions; +for example, the size of the previous structure is written as "4+[4]" bytes. + + + + + +Common Types + +SETofKB_EVENTTYPE + #x0001 XkbNewKeyboardNotify + #x0002 XkbMapNotify + #x0004 XkbStateNotify + #x0008 XkbControlsNotify + #x0010 XkbIndicatorStateNotify + #x0020 XkbIndicatorMapNotify + #x0040 XkbNamesNotify + #x0080 XkbCompatMapNotify + #x0100 XkbBellNotify + #x0200 XkbActionMessage + #x0400 XkbAccessXNotify + #x0800 XkbExtensionDeviceNotify + + +SETofKB_NKNDETAIL + #x01 XkbNKN_Keycodes + #x02 XkbNKN_Geometry + #x04 XkbNKN_DeviceID + + +SETofKB_AXNDETAIL + #x01 XkbAXN_SKPress + #x02 XkbAXN_SKAccept + #x04 XkbAXN_SKReject + #x08 XkbAXN_SKRelease + #x10 XkbAXN_BKAccept + #x20 XkbAXN_BKReject + #x40 XkbAXN_AXKWarning + + +SETofKB_MAPPART + #x0001 XkbKeyTypes + #x0002 XkbKeySyms + #x0004 XkbModifierMap + #x0008 XkbExplicitComponents + #x0010 XkbKeyActions + #x0020 XkbKeyBehaviors + #x0040 XkbVirtualMods + #x0080 XkbVirtualModMap + + +SETofKB_STATEPART + #x0001 XkbModifierState + #x0002 XkbModifierBase + #x0004 XkbModifierLatch + #x0008 XkbModifierLock + #x0010 XkbGroupState + #x0020 XkbGroupBase + #x0040 XkbGroupLatch + #x0080 XkbGroupLock + #x0100 XkbCompatState + #x0200 XkbGrabMods + #x0400 XkbCompatGrabMods + #x0800 XkbLookupMods + #x1000 XkbCompatLookupMods + #x2000 XkbPointerButtons + + +SETofKB_BOOLCTRL + #x00000001 XkbRepeatKeys + #x00000002 XkbSlowKeys + #x00000004 XkbBounceKeys + #x00000008 XkbStickyKeys + #x00000010 XkbMouseKeys + #x00000020 XkbMouseKeysAccel + #x00000040 XkbAccessXKeys + #x00000080 XkbAccessXTimeoutMask + #x00000100 XkbAccessXFeedbackMask + #x00000200 XkbAudibleBellMask + #x00000400 XkbOverlay1Mask + #x00000800 XkbOverlay2Mask + #x00001000 XkbIgnoreGroupLockMask + + +SETofKB_CONTROL + Encodings are the same as for SETofKB_BOOLCTRL, with the addition of: + #x080000000 XkbGroupsWrap + #x100000000 XkbInternalMods + #x200000000 XkbIgnoreLockMods + #x400000000 XkbPerKeyRepeat + #x800000000 XkbControlsEnabled + + +SETofKB_AXFBOPT + #x0001 XkbAX_SKPressFB + #x0002 XkbAX_SKAcceptFB + #x0004 XkbAX_FeatureFB + #x0008 XkbAX_SlowWarnFB + #x0010 XkbAX_IndicatorFB + #x0020 XkbAX_StickyKeysFB + #x0100 XkbAX_SKReleaseFB + #x0200 XkbAX_SKRejectFB + #x0400 XkbAX_BKRejectFB + #x0800 XkbAX_DumbBell + + +SETofKB_AXSKOPT + #x0040 XkbAX_TwoKeys + #x0080 XkbAX_LatchToLock + + +SETofKB_AXOPTION + Encoding same as the bitwise union of : + SETofKB_AXFBOPT + SETofKB_AXSKOPT + + +KB_DEVICESPEC + 0..255 input extension device id + #x100 XkbUseCoreKbd + #x200 XkbUseCorePtr + + +KB_LEDCLASSRESULT + 0 KbdFeedbackClass + 4 LedFeedbackClass + + +KB_LEDCLASSSPEC + Encoding same as KB_LEDCLASSRESULT, with the addition of: + #x0300 XkbDfltXIClass + #x0500 XkbAllXIClasses + + +KB_BELLCLASSRESULT + 0 KbdFeedbackClass + 5 BellFeedbackClass + + +KB_BELLCLASSSPEC + Encoding same as KB_BELLCLASSRESULT, with the addition of: + #x0300 XkbDfltXIClass + + +KB_IDSPEC + 0..255 input extension feedback id + #x0400 XkbDfltXIId + + +KB_IDRESULT + Encoding same as KB_IDSPEC, with the addition of: + #xff00 XkbXINone + + +KB_MULTIIDSPEC + encodings same as KB_IDSPEC, with the addition of: + #x0500 XkbAllXIIds + + +KB_GROUP + 0 XkbGroup1 + 1 XkbGroup2 + 2 XkbGroup3 + 3 XkbGroup4 + + +KB_GROUPS + Encoding same as KB_GROUP, with the addition of: + 254 XkbAnyGroup + 255 XkbAllGroups + + +SETofKB_GROUP + #x01 XkbGroup1 + #x02 XkbGroup2 + #x04 XkbGroup3 + #x08 XkbGroup4 + + +SETofKB_GROUPS + Encoding same as SETofKB_GROUP, with the addition of: + #x80 XkbAnyGroup + + +KB_GROUPSWRAP + #x00 XkbWrapIntoRange + #x40 XkbClampIntoRange + #x80 XkbRedirectIntoRange + + +SETofKB_VMODSHIGH + #x80 virtual modifier 15 + #x40 virtual modifier 14 + #x20 virtual modifier 13 + #x10 virtual modifier 12 + #x08 virtual modifier 11 + #x04 virtual modifier 10 + #x02 virtual modifier 9 + #x01 virtual modifier 8 + + +SETofKB_VMODSLOW + #x80 virtual modifier 7 + #x40 virtual modifier 6 + #x20 virtual modifier 5 + #x10 virtual modifier 4 + #x08 virtual modifier 3 + #x04 virtual modifier 2 + #x02 virtual modifier 1 + #x01 virtual modifier 0 + + +SETofKB_VMOD + #x8000 virtual modifier 15 + #x4000 virtual modifier 14 + #x2000 virtual modifier 13 + #x1000 virtual modifier 12 + #x0800 virtual modifier 11 + #x0400 virtual modifier 10 + #x0200 virtual modifier 9 + #x0100 virtual modifier 8 + #x0080 virtual modifier 7 + #x0040 virtual modifier 6 + #x0020 virtual modifier 5 + #x0010 virtual modifier 4 + #x0008 virtual modifier 3 + #x0004 virtual modifier 2 + #x0002 virtual modifier 1 + #x0001 virtual modifier 0 + + +SETofKB_EXPLICIT + #x80 XkbExplicitVModMap + #x40 XkbExplicitBehavior + #x20 XkbExplicitAutoRepeat + #x10 XkbExplicitInterpret + #x08 XkbExplicitKeyType4 + #x04 XkbExplicitKeyType3 + #x02 XkbExplicitKeyType2 + #x01 XkbExplicitKeyType1 + + +KB_SYMINTERPMATCH + #x80 XkbSI_LevelOneOnly + #x7f operation, one of the following: + 0 XkbSI_NoneOf + 1 XkbSI_AnyOfOrNone + 2 XkbSI_AnyOf + 3 XkbSI_AllOf + 4 XkbSI_Exactly + + +SETofKB_IMFLAG + #x80 XkbIM_NoExplicit + #x40 XkbIM_NoAutomatic + #x20 XkbIM_LEDDrivesKB + + +SETofKB_IMMODSWHICH + #x10 XkbIM_UseCompat + #x08 XkbIM_UseEffective + #x04 XkbIM_UseLocked + #x02 XkbIM_UseLatched + #x01 XkbIM_UseBase + + +SETofKB_IMGROUPSWHICH + #x10 XkbIM_UseCompat + #x08 XkbIM_UseEffective + #x04 XkbIM_UseLocked + #x02 XkbIM_UseLatched + #x01 XkbIM_UseBase + + +KB_INDICATORMAP +1 SETofKB_IMFLAGS flags +1 SETofKB_IMGROUPSWHICH whichGroups +1 SETofKB_GROUP groups +1 SETofKB_IMMODSWHICH whichMods +1 SETofKEYMASK mods +1 SETofKEYMASK realMods +2 SETofKB_VMOD vmods +4 SETofKB_BOOLCTRL ctrls + + +SETofKB_CMDETAIL + #x01 XkbSymInterp + #x02 XkbGroupCompat + + +SETofKB_NAMEDETAIL + #x0001 XkbKeycodesName + #x0002 XkbGeometryName + #x0004 XkbSymbolsName + #x0008 XkbPhysSymbolsName + #x0010 XkbTypesName + #x0020 XkbCompatName + #x0040 XkbKeyTypeNames + #x0080 XkbKTLevelNames + #x0100 XkbIndicatorNames + #x0200 XkbKeyNames + #x0400 XkbKeyAliases + #x0800 XkbVirtualModNames + #x1000 XkbGroupNames + #x2000 XkbRGNames + + +SETofKB_GBNDETAIL + #x01 XkbGBN_Types + #x02 XkbGBN_CompatMap + #x04 XkbGBN_ClientSymbols + #x08 XkbGBN_ServerSymbols + #x10 XkbGBN_IndicatorMaps + #x20 XkbGBN_KeyNames + #x40 XkbGBN_Geometry + #x80 XkbGBN_OtherNames + + +SETofKB_XIEXTDEVFEATURE + #x02 XkbXI_ButtonActions + #x04 XkbXI_IndicatorNames + #x08 XkbXI_IndicatorMaps + #x10 XkbXI_IndicatorState + + +SETofKB_XIFEATURE + Encoding same as SETofKB_XIEXTDEVFEATURE, with the addition of: + #x01 XkbXI_Keyboards + + +SETofKB_XIDETAIL + Encoding same as SETofKB_XIFEATURE, with the addition of: + #x8000 XkbXI_UnsupportedFeature + + +SETofKB_PERCLIENTFLAG + #x01 XkbDetectableAutorepeat + #x02 XkbGrabsUseXKBState + #x04 XkbAutoResetControls + #x08 XkbLookupStateWhenGrabbed + #x10 XkbSendEventUsesXKBState + + +KB_MODDEF +1 SETofKEYMASK mask +1 SETofKEYMASK realMods +2 SETofVMOD vmods + + +KB_COUNTED_STRING8 +1 l length +l STRING8 string + + +KB_COUNTED_STRING16 +2 l length +l STRING8 string + + +KB_COUNTED_STRING16 +p unused,p=pad(2+l) + + + + +Errors + +1 0 Error +2 ?? code +2 CARD16 sequence +4 CARD32 error value + most significant 8 bits of error value have the meaning: + 0xff XkbErrBadDevice + 0xfe XkbErrBadClass + 0xfd XkbErrBadId + the least significant 8 bits of the error value contain the device id, +class, or feedback + id which failed. +2 CARD16 minor opcode +1 CARD8 major opcode +21 unused + + + + +Key Actions + +1 0 type +7 unused + + +1 1 type +1 BITMASK flags + #x01 XkbSA_ClearLocks + #x02 XkbSA_LatchToLock + #x04 XkbSA_UseModMapMods +1 SETofKEYMASK mask +1 SETofKEYMASK real modifiers +1 SETofKB_VMODSHIGH virtual modifiers high +1 SETofKB_VMODSLOW virtual modifiers low +2 unused + + +1 2 type +1 BITMASK flags + #x01 XkbSA_ClearLocks + #x02 XkbSA_LatchToLock + #x04 XkbSA_UseModMapMods +1 SETofKEYMASK mask +1 SETofKEYMASK real modifiers +1 SETofKB_VMODSHIGH virtual modifiers high +1 SETofKB_VMODSLOW virtual modifiers low +2 unused + + +1 3 type +1 BITMASK flags + #x01 XkbSA_LockNoLock + #x02 XkbSA_LockNoUnlock + #x04 XkbSA_UseModMapMods +1 SETofKEYMASK mask +1 SETofKEYMASK real modifiers +1 SETofKB_VMODSHIGH virtual modifiers high +1 SETofKB_VMODSLOW virtual modifiers low +2 unused + + +1 4 type +1 BITMASK flags + #x01 XkbSA_ClearLocks + #x02 XkbSA_LatchToLock + #x04 XkbSA_GroupAbsolute +1 INT8 group +5 unused + + +1 5 type +1 BITMASK flags + #x01 XkbSA_ClearLocks + #x02 XkbSA_LatchToLock + #x04 XkbSA_GroupAbsolute +1 INT8 group +5 unused + + +1 6 type +1 BITMASK flags + #x01 XkbSA_LockNoLock + #x02 XkbSA_LockNoUnlock + #x04 XkbSA_GroupAbsolute +1 INT8 group +5 unused + + +1 7 type +1 BITMASK flags + #x01 XkbSA_NoAcceleration + #x02 XkbSA_MoveAbsoluteX + #x04 XkbSA_MoveAbsoluteY +1 INT8 x high +1 CARD8 x low +1 INT8 y high +1 CARD8 y low +2 unused + + +1 8 type +1 BITMASK flags +1 CARD8 count +1 CARD8 button +4 unused + + +1 9 type +1 BITMASK flags +1 unused +1 CARD8 button +4 unused + + +1 10 type +1 BITMASK flags + #x04 XkbSA_DfltBtnAbsolute +1 BITMASK affect + #x01 XkbSA_AffectDfltBtn +1 INT8 value +4 unused + + +1 11 type +1 BITMASK flags + #x01 XkbSA_LockNoLock + #x02 XkbSA_LockNoUnlock + #x04 XkbSA_UseModMapMods (if SA_ISODfltIsGroup is 0) + #x04 XkbSA_GroupAbsolute (if SA_ISODfltIsGroup is 1) + #x80 XkbSA_ISODfltIsGroup +1 SETofKEYMASK mask +1 SETofKEYMASK real modifiers +1 INT8 group +1 BITMASK affect + #x08 XkbSA_ISONoAffectCtrls + #x10 XkbSA_ISONoAffectPtr + #x20 XkbSA_ISONoAffectGroup + #x40 XkbSA_ISONoAffectMods +1 SETofKB_VMODSHIGH virtual modifiers high +1 SETofKB_VMODSLOW virtual modifiers low + + +1 12 type +7 unused + + +1 13 type +1 BITMASK flags + #x01 XkbSA_SwitchApplication + #x04 XkbSA_SwitchAbsolute +1 INT8 new screen +5 unused (must be 0) + + +1 14 type +3 unused (must be 0) +1 BITMASK boolean controls high + #x01 XkbAccessXFeedbackMask + #x02 XkbAudibleBellMask + #x04 XkbOverlay1Mask + #x08 XkbOverlay2Mask + #x10 XkbIgnoreGroupLockMask +1 BITMASK boolean controls low + #x01 XkbRepeatKeys + #x02 XkbSlowKeys + #x04 XkbBounceKeys + #x08 XkbStickyKeys + #x10 XkbMouseKeys + #x20 XkbMouseKeysAccel + #x40 XkbAccessXKeys + #x80 XkbAccessXTimeoutMask +2 unused (must be 0) + + +1 15 type +3 unused (must be 0) +1 BITMASK boolean controls high + #x01 XkbAccessXFeedbackMask + #x02 XkbAudibleBellMask + #x04 XkbOverlay1Mask + #x08 XkbOverlay2Mask + #x10 XkbIgnoreGroupLockMask +1 BITMASK boolean controls low + #x01 XkbRepeatKeys + #x02 XkbSlowKeys + #x04 XkbBounceKeys + #x08 XkbStickyKeys + #x10 XkbMouseKeys + #x20 XkbMouseKeysAccel + #x40 XkbAccessXKeys + #x80 XkbAccessXTimeoutMask + + +1 16 type +2 unused (must be 0) + + +1 16 type +1 BITMASK flags + #x01 XkbSA_MessageOnPress + #x02 XkbSA_MessageOnRelease + #x04 XkbSA_MessageGenKeyEvent +6 STRING message + + +1 17 type +1 KEYCODE new key +1 SETofKEYMASK mask +1 SETofKEYMASK real modifiers +1 SETofKB_VMODSHIGH virtual modifiers mask high +1 SETofKB_VMODSLOW virtual modifiers mask low +1 SETofKB_VMODSHIGH virtual modifiers high +1 SETofKB_VMODSLOW virtual modifiers low + + +1 18 type +1 0 flags +1 CARD8 count +1 CARD8 button +1 CARD8 device +3 unused (must be 0) + + +1 19 type +1 BITMASK flags + #x01 XkbSA_LockNoLock + #x02 XkbSA_LockNoUnlock +1 unused +1 CARD8 button +1 CARD8 device + + +1 20 type +1 CARD8 device +1 KB_SA_VALWHAT valuator 1 what + #x00 XkbSA_IgnoreVal + #x01 XkbSA_SetValMin + #x02 XkbSA_SetValCenter + #x03 XkbSA_SetValMax + #x04 XkbSA_SetValRelative + #x05 XkbSA_SetValAbsolute +1 CARD8 valuator 1 index +1 CARD8 valuator 1 value +1 KB_SA_VALWHAT valuator 2 what + Encodings as for "valuator 1 what" above +1 CARD8 valuator 2 index +1 CARD8 valuator 2 value + + + + +Key Behaviors + +1 #x00 type +1 unused + + +1 #x01 type +1 unused + + +1 #x02 type +1 0..31 group + + +1 #x03 type +1 KEYCODE key + + +1 #x04 type +1 CARD8 key + + +1 #x81 type +1 unused + + +1 #x82 type +1 0..31 group + + +1 #x83 type +1 KEYCODE key + + +1 #x84 type +1 KEYCODE key + + + + +Requests + +1 ?? opcode +1 0 xkb-opcode +2 2 request-length +2 CARD16 wantedMajor +2 CARD16 wantedMinor + + +1 1 Reply +1 BOOL supported +2 CARD16 sequence number +4 0 reply length +2 1 serverMajor +2 0 serverMinor +20 unused + + + +1 ?? opcode +1 1 xkb-opcode +2 4+(V+p)/4 request-length +2 KB_DEVICESPEC deviceSpec +2 SETofKB_EVENTTYPE affectWhich +2 SETofKB_EVENTTYPE clear +2 SETofKB_EVENTTYPE selectAll +2 SETofKB_MAPDETAILS affectMap +2 SETofKB_MAPDETAILS map +V LISTofITEMs details + SETofKB_EVENTTYPE +(affectWhich&(~clear)&(~selectAll)) + XkbNewKeyboardNotify affectNewKeyboard, newKeyboardDetails + XkbStateNotify affectState, stateDetails + XkbControlsNotify affectCtrls, ctrlDetails + XkbIndicatorStateNotify affectIndicatorState, indicatorStateDetails + XkbIndicatorMapNotify affectIndicatorMap, indicatorMapDetails + XkbNamesNotify affectNames, namesDetails + XkbCompatMapNotify affectCompat, compatDetails + XkbBellNotify affectBell, bellDetails + XkbActionMessage affectMsgDetails, msgDetails + XkbExtensionDeviceNotify affectExtDev, extdevDetails + + +ITEMs +p unused, p=pad(V) + + +ITEMs +2 SETofKB_NKNDETAIL affectNewKeyboard +2 SETofKB_NKNDETAIL newKeyboardDetails +2 SETofKB_STATEPART affectState +2 SETofKB_STATEPART stateDetails +4 SETofKB_CONTROL affectCtrls +4 SETofKB_CONTROL ctrlDetails +4 SETofKB_INDICATOR affectIndicatorState +4 SETofKB_INDICATOR indicatorStateDetails +4 SETofKB_INDICATOR affectIndicatorMaps +4 SETofKB_INDICATOR indicatorMapDetails +2 SETofKB_NAME_DETAIL affectNames +2 SETofKB_NAME_DETAIL namesDetails +1 SETofKB_CMDETAIL affectCompat +1 SETofKB_CMDETAIL compatDetails +1 SETofKB_BELLDETAIL affectBell +1 SETofKB_BELLDETAIL bellDetails +1 SETofKB_MSGDETAIL affectMsgDetails +1 SETofKB_MSGDETAIL msgDetails +2 SETofKB_AXNDETAIL affectAccessX +2 SETofKB_AXNDETAIL accessXDetails +2 SETofKB_XIDETAIL affectExtDev +2 SETofKB_XIDETAIL extdevDetails + + + +1 ?? opcode +1 3 xkb-opcode +2 7 request-length +2 KB_DEVICESPEC deviceSpec +2 KB_BELLCLASSSPEC bellClass +2 KB_IDSPEC bellID +1 INT8 percent +1 BOOL forceSound +1 BOOL eventOnly +1 unused +2 INT16 pitch +2 INT16 duration +2 unused +4 ATOM name +4 WINDOW window + + +1 ?? opcode +1 4 xkb-opcode +2 2 request-length +2 KB_DEVICESPEC deviceSpec +2 unused + + +1 1 Reply +1 CARD8 deviceID +2 CARD16 sequence number +4 0 length +1 SETofKEYMASK mods +1 SETofKEYMASK baseMods +1 SETofKEYMASK latchedMods +1 SETofKEYMASK lockedMods +1 KP_GROUP group +1 KP_GROUP lockedGroup +2 INT16 baseGroup +2 INT16 latchedGroup +1 SETofKEYMASK compatState +1 SETofKEYMASK grabMods +1 SETofKEYMASK compatGrabMods +1 SETofKEYMASK lookupMods +1 SETofKEYMASK compatLookupMods +1 unused +2 SETofBUTMASK ptrBtnState +6 unused + + + +1 ?? opcode +1 5 xkb-opcode +2 4 request-length +2 KB_DEVICESPEC deviceSpec +1 SETofKEYMASK affectModLocks +1 SETofKEYMASK modLocks +1 BOOL lockGroup +1 KB_GROUP groupLock +1 SETofKEYMASK affectModLatches +1 SETofKEYMASK modLatches +1 unused +1 BOOL latchGroup +2 INT16 groupLatch + + +1 ?? opcode +1 6 xkb-opcode +2 2 request-length +2 KB_DEVICESPEC deviceSpec +2 unused + + +1 1 Reply +1 CARD8 deviceID +2 CARD16 sequence number +4 15 length +1 CARD8 mouseKeysDfltBtn +1 CARD8 numGroups +1 CARD8 groupsWrap +1 SETofKEYMASK internalMods.mask +1 SETofKEYMASK ignoreLockMods.mask +1 SETofKEYMASK internalMods.realMods +1 SETofKEYMASK ignoreLockMods.realMods +1 unused +2 SETofKB_VMOD internalMods.vmods +2 SETofKB_VMOD ignoreLockMods.vmods +2 CARD16 repeatDelay +2 CARD16 repeatInterval +2 CARD16 slowKeysDelay +2 CARD16 debounceDelay +2 CARD16 mouseKeysDelay +2 CARD16 mouseKeysInterval +2 CARD16 mouseKeysTimeToMax +2 CARD16 mouseKeysMaxSpeed +2 INT16 mouseKeysCurve +2 SETofKB_AXOPTION accessXOptions +2 CARD16 accessXTimeout +2 SETofKB_AXOPTION accessXTimeoutOptionsMask +2 SETofKB_AXOPTION accessXTimeoutOptionValues +2 unused +4 SETofKB_BOOLCTRL accessXTimeoutMask +4 SETofKB_BOOLCTRL accessXTimeoutValues +4 SETofKB_BOOLCTRL enabledControls +32 LISTofCARD8 perKeyRepeat + + + +1 ?? opcode +1 7 xkb-opcode +2 25 request-length +2 KB_DEVICESPEC deviceSpec +1 SETofKEYMASK affectInternalRealMods +1 SETofKEYMASK internalRealMods +1 SETofKEYMASK affectIgnoreLockRealMods +1 SETofKEYMASK ignoreLockRealMods +2 SETofKB_VMOD affectInternalVirtualMods +2 SETofKB_VMOD internalVirtualMods +2 SETofKB_VMOD affectIgnoreLockVirtualMods +2 SETofKB_VMOD ignoreLockVirtualMods +1 CARD8 mouseKeysDfltBtn +1 CARD8 groupsWrap +2 SETofKB_AXOPTION accessXOptions +2 unused +4 SETofKB_BOOLCTRL affectEnabledControls +4 SETofKB_BOOLCTRL enabledControls +4 SETofKB_CONTROL changeControls +2 CARD16 repeatDelay +2 CARD16 repeatInterval +2 CARD16 slowKeysDelay +2 CARD16 debounceDelay +2 CARD16 mouseKeysDelay +2 CARD16 mouseKeysInterval +2 CARD16 mouseKeysTimeToMax +2 CARD16 mouseKeysMaxSpeed +2 INT16 mouseKeysCurve +2 CARD16 accessXTimeout +4 SETofKB_BOOLCTRL accessXTimeoutMask +4 SETofKB_BOOLCTRL accessXTimeoutValues +2 SETofKB_AXOPTION accessXTimeoutOptionsMask +2 SETofKB_AXOPTION accessXTimeoutOptionsValues +32 LISTofCARD8 perKeyRepeat + + +1 CARD8 opcode +1 8 xkb-opcode +2 7 request-length +2 KB_DEVICESPEC deviceSpec +2 SETofKB_MAPPART full +2 SETofKB_MAPPART partial +1 CARD8 firstType +1 CARD8 nTypes +1 KEYCODE firstKeySym +1 CARD8 nKeySyms +1 KEYCODE firstKeyAction +1 CARD8 nKeyActions +1 KEYCODE firstKeyBehavior +1 CARD8 nKeyBehaviors +2 SETofKB_VMOD virtualMods +1 KEYCODE firstKeyExplicit +1 CARD8 nKeyExplicit +1 KEYCODE firstModMapKey +1 CARD8 nModMapKeys +1 KEYCODE firstVModMapKey +1 CARD8 nVModMapKeys +2 unused + + +1 1 Reply +1 CARD8 deviceID +2 CARD16 sequence number +4 2+(I/4) length +2 unused +1 KEYCODE minKeyCode +1 KEYCODE maxKeyCode +2 SETofKB_MAPPART present +1 CARD8 firstType +1 t nTypes +1 CARD8 totalTypes +1 KEYCODE firstKeySym +2 S totalSyms +1 s nKeySyms +1 KEYCODE firstKeyAction +2 A totalActions +1 a nKeyActions +1 KEYCODE firstKeyBehavior +1 b nKeyBehaviors +1 B totalKeyBehaviors +1 KEYCODE firstKeyExplicit +1 e nKeyExplicit +1 E totalKeyExplicit +1 KEYCODE firstModMapKey +1 m nModMapKeys +1 M totalModMapKeys +1 KEYCODE firstVModMapKey +1 0 nVModMapKeys +1 V totalVModMapKeys +1 unused +2 SETofKB_VMOD virtualMods (has v bits set to 1) +I LISTofITEMs map + SETofKB_MAPPART (present) + XkbKeyTypes typesRtrn + XkbKeySyms symsRtrn + XkbKeyActions actsRtrn.count, actsRtrn.acts + XkbKeyBehaviors behaviorsRtrn + XkbVirtualMods vmodsRtrn + XkbExplicitComponents explicitRtrn + XkbModifierMap modmapRtrn + XkbVirtualModMap vmodMapRtrn + + +ITEMs +T1+..Tt LISTofKB_KEYTYPE typesRtrn +8s+4S LISTofKB_KEYSYMMAP symsRtrn +a LISTofCARD8 actsRtrn.count +p unused,p=pad(a) +8A LISTofKB_ACTION actsRtrn.acts +4B LISTofKB_SETBEHAVIOR behaviorsRtrn +v LISTofSETofKEYMASK vmodsRtrn +p unused, p=pad(v) +2E LISTofKB_SETEXPLICIT explicitRtrn +p unused,p=pad(2E) +2M LISTofKB_KEYMODMAP modmapRtrn +p unused, p=pad(2M) +4V LISTofKB_KEYVMODMAP vmodMapRtrn + + +KB_KEYTYPE 8+8m+[4m] +1 SETofKEYMASK mods.mask +1 SETofKEYMASK mods.mods +2 SETofKB_VMOD mods.vmods +1 CARD8 numLevels +1 m nMapEntries +1 BOOL hasPreserve +1 unused +8m LISTofKB_KTMAPENTRY map +[4m] LISTofKB_MODDEF preserve + + +KB_KTMAPENTRY +1 BOOL active +1 SETofKEYMASK mods.mask +1 CARD8 level +1 SETofKEYMASK mods.mods +2 SETofKB_VMOD mods.vmods +2 unused + + +KB_KEYSYMMAP 8+4n +4 LISTofCARD8 ktIndex +1 CARD8 groupInfo +1 CARD8 width +2 n nSyms +4n LISTofKEYSYM syms + + +KB_SETBEHAVIOR +1 KEYCODE keycode +2 KB_BEHAVIOR behavior +1 unused + + +KB_SETEXPLICIT +1 KEYCODE keycode +1 SETofKB_EXPLICIT explicit + + +KB_KEYMODMAP +1 KEYCODE keycode +1 SETofKB_KEYMASK mods + + +KB_KEYVMODMAP +1 KEYCODE keycode +1 unused +2 SETofKB_VMOD vmods + + + +1 CARD8 opcode +1 9 xkb-opcode +2 9+(I/4) request-length +2 KB_DEVICESPEC deviceSpec +2 SETofKB_MAPPART present +2 SETofKB_SETMAPFLAGS flags + #0001 SetMapResizeTypes + #0002 SetMapRecomputeActions +1 KEYCODE minKeyCode +1 KEYCODE maxKeyCode +1 CARD8 firstType +1 t nTypes +1 KEYCODE firstKeySym +1 s nKeySyms +2 S totalSyms +1 KEYCODE firstKeyAction +1 a nKeyActions +2 A totalActions +1 KEYCODE firstKeyBehavior +1 b nKeyBehaviors +1 B totalKeyBehaviors +1 KEYCODE firstKeyExplicit +1 e nKeyExplicit +1 E totalKeyExplicit +1 KEYCODE firstModMapKey +1 m nModMapKeys +1 M totalModMapKeys +1 KEYCODE firstVModMapKey +1 v nVModMapKeys +1 V totalVModMapKeys +2 SETofKB_VMOD virtualMods (has n bits set to 1) +I LISTofITEMs values + SETofKB_MAPPART (present) + XkbKeyTypes types + XkbKeySymbols syms + XkbKeyActions actions.count,actions.actions + XkbKeyBehaviors behaviors + XkbVirtualMods vmods + XkbExplicitComponents explicit + XkbModifierMap modmap + XkbVirtualModMap vmodmap + + +ITEMs +T0+..Tt LISTofKB_SETKEYTYPE types +8s+4S LISTofKB_KEYSYMMAP syms +a LISTofCARD8 actions.count +p unused,p=pad(a) +8A LISTofKB_ACTION actions.actions +4B LISTofKB_SETBEHAVIOR behaviors +v LISTofSETofKEYMASK vmods +p unused, p=pad(v) +2E LISTofKB_SETEXPLICIT explicit +p unused,p=pad(2E) +2M LISTofKB_KEYMODMAP modmap +P unused, p=pad(2M) +4V LISTofKB_KEYVMODMAP vmodmap + + +KB_SETKEYTYPE 8+4m+[4m] +1 SETofKEYMASK mask +1 SETofKEYMASK realMods +2 SETofKB_VMOD virtualMods +1 CARD8 numLevels +1 m nMapEntries +1 BOOL preserve +1 unused +4m LISTofKB_KTSETMAPENTRY entries +[4m] LISTofKB_MODDEF preserveEntries (if preserve==TRUE) + + +KB_KTSETMAPENTRY +1 CARD8 level +1 SETofKEYMASK realMods +2 SETofKB_VMOD virtualMods + + + +1 ?? opcode +1 10 xkb-opcode +2 3 request-length +2 KB_DEVICESPEC deviceSpec +1 SETofKB_GROUP groups +1 BOOL getAllSI +2 CARD16 firstSI +2 CARD16 nSI + + +1 1 Reply +1 CARD8 deviceID +2 CARD16 sequence number +4 (16n+4g)/4 length +1 SETofKB_GROUP groupsRtrn (has g bits set to 1) +1 unused +2 CARD16 firstSIRtrn +2 n nSIRtrn +2 CARD16 nTotalSI +16 unused +16n LISTofKB_SYMINTERPRET siRtrn +4g LISTofKB_MODDEF groupRtrn + + + +1 ?? opcode +1 11 xkb-opcode +2 4+(16n+4g) request-length +2 KB_DEVICESPEC deviceSpec +1 unused +1 BOOL recomputeActions +1 BOOL truncateSI +1 SETofKB_GROUP groups (has g bits set to 1) +2 CARD16 firstSI +2 n nSI +2 unused +16n LISTofKB_SYMINTERPRET si +4g LISTofKB_MODDEF groupMaps + + +1 ?? opcode +1 12 xkb-opcode +2 2 request-length +2 KB_DEVICESPEC deviceSpec + + +ITEMs +2 unused + + +1 1 Reply +1 CARD8 deviceID +2 CARD16 sequence number +4 0 length +4 SETofKB_INDICATOR state +20 unused + + + +1 ?? opcode +1 13 xkb-opcode +2 3 request-length +2 KB_DEVICESPEC deviceSpec +2 unused +4 SETofKB_INDICATOR which + + +1 1 Reply +1 CARD8 deviceID +2 CARD16 sequence number +4 12n/4 length +4 SETofKB_INDICATOR which (has n bits set to 1) +4 SETofKB_INDICATOR realIndicators +1 n nIndicators +15 unused +12n LISTofKB_INDICATORMAP maps + + + +1 ?? opcode +1 14 xkb-opcode +2 3+3n request-length +2 KB_DEVICESPEC deviceSpec +2 unused +4 SETofKB_INDICATOR which (has n bits set to 1) +12n LISTofKB_INDICATORMAP maps + + +1 CARD8 opcode +1 15 xkb-opcode +2 4 request-length +2 KB_DEVICESPEC deviceSpec +2 KB_LEDCLASSSPEC ledClass +2 KB_IDSPEC ledID +2 unused +4 ATOM indicator + + +1 1 Reply +1 CARD8 deviceID +2 CARD16 sequence number +4 0 length +4 ATOM indicator +1 BOOL found +1 BOOL on +1 BOOL realIndicator +1 KB_INDICATOR ndx +1 SETofKB_IMFLAGS map.flags +1 SETofKB_IMGROUPSWHICH map.whichGroups +1 SETofKB_GROUPS map.groups +1 SETofKB_IMMODSWHICH map.whichMods +1 SETofKEYMASK map.mods +1 SETofKEYMASK map.realMods +2 SETofKB_VMOD map.vmods +4 SETofKB_BOOLCTRL map.ctrls +1 BOOL supported +3 unused + + + +1 ?? opcode +1 16 xkb-opcode +2 8 request-length +2 KB_DEVICESPEC deviceSpec +2 KB_LEDCLASSSPEC ledClass +2 KB_IDSPEC ledID +2 unused +4 ATOM indicator +1 BOOL setState +1 BOOL on +1 BOOL setMap +1 BOOL createMap +1 unused +1 SETofKB_IMFLAGS map.flags +1 SETofKB_IMGROUPSWHICH map.whichGroups +1 SETofKB_GROUP map.groups +1 SETofKB_IMMODSWHICH map.whichMods +1 SETofKEYMASK map.realMods +2 SETofKB_VMOD map.vmods +4 SETofKB_BOOLCTRL map.ctrls + + +1 CARD8 opcode +1 17 xkb-opcode +2 3 request-length +2 KB_DEVICESPEC deviceSpec +2 unused +4 SETofKB_NAMEDETAIL which + + +1 1 Reply +1 CARD8 deviceID +2 CARD16 sequence number +4 V/4 length +4 SETofKB_NAMEDETAIL which +1 KEYCODE minKeyCode +1 KEYCODE maxKeyCode +1 t nTypes +1 SETofKB_GROUP groupNames (has g bits set to 1) +2 SETofKB_VMOD virtualMods (has v bits set to 1) +1 KEYCODE firstKey +1 k nKeys +4 SETofKB_INDICATOR indicators (has i bits set to 1) +1 r nRadioGroups +1 a nKeyAliases +2 l nKTLevels +4 unused +V LISTofITEMs valueList + SETofKB_NAMEDETAIL (which) + XkbKeycodesName keycodesName + XkbGeometryName geometryName + XkbSymbolsName symbolsName + XkbPhySymbolsName physSymbolsName + XkbTypesName typesName + XkbCompatName compatName + XkbKeyTypeNames typeNames + XkbKTLevelNames nLevelsPerType, ktLevelNames + XkbIndicatorNames indicatorNames + XkbVirtualModNames virtualModNames + XkbGroupNames groupNames + XkbKeyNames keyNames + XkbKeyAliases keyAliases + XkbRGNames radioGroupNames + + +ITEMs +4 ATOM keycodesName +4 ATOM geometryName +4 ATOM symbolsName +4 ATOM physSymbolsName +4 ATOM typesName +4 ATOM compatName +4t LISTofATOM typeNames +l LISTofCARD8 nLevelsPerType, sum of all elements=L +p unused, p=pad(l) +4L LISTofATOM ktLevelNames +4i LISTofATOM indicatorNames +4v LISTofATOM virtualModNames +4g LISTofATOM groupNames +4k LISTofKB_KEYNAME keyNames +8a LISTofKB_KEYALIAS keyAliases +4r LISTofATOM radioGroupNames + + + +1 CARD8 opcode +1 18 xkb-opcode +2 7+(V/4) request-length +2 KB_DEVICESPEC deviceSpec +2 SETofKB_VMOD virtualMods +4 SETofKB_NAMEDETAIL which +1 CARD8 firstType +1 t nTypes +1 CARD8 firstKTLevel +1 l nKTLevels +4 SETofKB_INDICATOR indicators (has i bits set to 1) +1 SETofKB_GROUP groupNames (has g bits set to 1) +1 r nRadioGroups +1 KEYCODE firstKey +1 k nKeys +1 a nKeyAliases +1 unused +2 L totalKTLevelNames +V LISTofITEMs values + SETofKB_NAMEDETAIL (which) + XkbKeycodesName keycodesName + XkbGeometryName geometryName + XkbSymbolsName symbolsName + XkbPhySymbolsName physSymbolsName + XkbTypesName typesName + XkbCompatName compatName + XkbKeyTypeNames typeNames + XkbKTLevelNames nLevelsPerType, ktLevelNames + XkbIndicatorNames indicatorNames + XkbVirtualModNames virtualModNames + XkbGroupNames groupNames + XkbKeyNames keyNames + XkbKeyAliases keyAliases + XkbRGNames radioGroupNames + + +ITEMs +4 ATOM keycodesName +4 ATOM geometryName +4 ATOM symbolsName +4 ATOM physSymbolsName +4 ATOM typesName +4 ATOM compatName +4t LISTofATOM typeNames +l LISTofCARD8 nLevelsPerType +p unused, p=pad(l) +4L LISTofATOM ktLevelNames +4i LISTofATOM indicatorNames +4v LISTofATOM virtualModNames +4g LISTofATOM groupNames +4k LISTofKB_KEYNAME keyNames +8a LISTofKB_KEYALIAS keyAliases +4r LISTofATOM radioGroupNames + + + +1 CARD8 opcode +1 19 xkb-opcode +2 3 request-length +2 KB_DEVICESPEC deviceSpec +2 unused +4 ATOM name + + +1 1 Reply +1 CARD8 deviceID +2 CARD16 sequence number +4 (f+8p+C*+H*+S*+D*+A*)/4 length +4 ATOM name +1 BOOL found +1 unused +2 CARD16 widthMM +2 CARD16 heightMM +2 p nProperties +2 c nColors +2 h nShapes +2 s nSections +2 d nDoodads +2 a nKeyAliases +1 CARD8 baseColorNdx +1 CARD8 labelColorNdx +f KB_COUNTED_STRING16 labelFont +8p LISTofKB_PROPERTY properties +C0+..Cc LISTofKB_COUNTED_STRING16 colors +H0+..Hh LISTofKB_SHAPE shapes +S0+..Ss LISTofKB_SECTION sections +D0+..Dd LISTofKB_DOODAD doodads +A0+..Aa LISTofKB_KEYALIAS keyAliases + + +KB_PROPERTY 4+n+v +2 n nameLength +n STRING8 name +2 v valueLength +v STRING8 value + + +KB_SHAPE 8+O* +4 ATOM name +1 o nOutlines +1 CARD8 primaryNdx +1 CARD8 approxNdx +1 unused +O0+..Oo LISTofKB_OUTLINE outlines + + +KB_OUTLINE 4+4p +1 p nPoints +1 CARD8 cornerRadius +2 unused +4p LISTofKB_POINT points + + +KB_POINT +2 INT16 x +2 INT16 y + + +KB_SECTION 20+R*+D*+O* +4 ATOM name +2 INT16 top +2 INT16 left +2 CARD16 width +2 CARD16 height +2 INT16 angle +1 CARD8 priority +1 r nRows +1 d nDoodads +1 o nOverlays +2 unused +R0+..Rr LISTofKB_ROW rows +D0+..Dd LISTofKB_DOODAD doodads +O0+..Oo LISTofKB_OVERLAY overlays + + +KB_ROW 8+8k +2 INT16 top +2 INT16 left +1 k nKeys +1 BOOL vertical +2 unused +8k LISTofKB_KEY keys + + +KB_KEY +4 STRING8 name +2 INT16 gap +1 CARD8 shapeNdx +1 CARD8 colorNdx + + +KB_OVERLAY 8+R* +4 ATOM name +1 r nRows +3 unused +R0+..Rr LISTofKB_OVERLAYROW rows + + +KB_OVERLAYROW 4+8k +1 CARD8 rowUnder +1 k nKeys +2 unused +8k LISTofKB_OVERLAYKEY keys + + +KB_OVERLAYKEY +4 STRING8 over +4 STRING8 under + + +KB_SHAPEDOODAD +4 ATOM name +1 CARD8 type + + +KB_SHAPEDOODAD + #1 XkbOutlineDoodad + #2 XkbSolidDoodad +1 CARD8 priority +2 INT16 top +2 INT16 left +2 INT16 angle +1 CARD8 colorNdx +1 CARD8 shapeNdx +6 unused + + +KB_TEXTDOODAD 20+t+f +4 ATOM name +1 CARD8 type + #3 XkbTextDoodad +1 CARD8 priority +2 INT16 top +2 INT16 left +2 INT16 angle +2 CARD16 width +2 CARD16 height +1 CARD8 colorNdx +3 unused +t KB_COUNTED_STRING16 text +f KB_COUNTED_STRING16 font + + +KB_INDICATORDOODAD +4 ATOM name +1 CARD8 type + #4 XkbIndicatorDoodad +1 CARD8 priority +2 INT16 top +2 INT16 left +2 INT16 angle +1 CARD8 shapeNdx +1 CARD8 onColorNdx +1 CARD8 offColorNdx +5 unused + + +KB_LOGODOODAD 20+n +4 ATOM name +1 CARD8 type + #5 XkbLogoDoodad +1 CARD8 priority +2 INT16 top +2 INT16 left +2 INT16 angle +1 CARD8 colorNdx +1 CARD8 shapeNdx +6 unused +n KB_COUNTED_STRING16 logoName + + +KB_DOODAD: + KB_SHAPEDOODAD, or KB_TEXTDOODAD, or + KB_INDICATORDOODAD, or KB_LOGODOODAD + + + +1 CARD8 opcode +1 20 xkb-opcode +2 7+(f+8p+C*+H*+S*+D*+A*)/4 request-length +2 KB_DEVICESPEC deviceSpec +1 h nShapes +1 s nSections +4 ATOM name +2 CARD16 widthMM +2 CARD16 heightMM +2 p nProperties +2 c nColors +2 d nDoodads +2 a nKeyAliases +1 CARD8 baseColorNdx +1 CARD8 labelColorNdx +2 unused +f KB_COUNTED_STRING16 labelFont +8p LISTofKB_PROPERTY properties +C0+..Cc LISTofKB_COUNTED_STRING16 colors +H0+..Hh LISTofKB_SHAPE shapes +S0+..Ss LISTofKB_SECTION sections +D0+..Dd LISTofKB_DOODAD doodads +A0+..Aa LISTofKB_KEYALIAS keyAliases + + +1 CARD8 opcode +1 21 xkb-opcode +2 7 request-length +2 KB_DEVICESPEC deviceSpec +2 unused +4 SETofKB_PERCLIENTFLAG change +4 SETofKB_PERCLIENTFLAG value +4 SETofKB_BOOLCTRL ctrlsToChange +4 SETofKB_BOOLCTRL autoCtrls +4 SETofKB_BOOLCTRL autoCtrlValues + + +1 1 Reply +1 CARD8 deviceID +2 CARD16 sequence number +4 0 length +4 SETofKB_PERCLIENTFLAG supported +4 SETofKB_PERCLIENTFLAG value +4 SETofKB_BOOLCTRL autoCtrls +4 SETofKB_BOOLCTRL autoCtrlValues +8 unused + + + +1 CARD8 opcode +1 22 xkb-opcode +2 2+(6+m+k+t+c+s+g+p)/4 request-length +2 KB_DEVICESPEC deviceSpec +2 CARD16 maxNames +1 m keymapsSpecLen +m STRING keymapsSpec +1 k keycodesSpecLen +k STRING keycodesSpec +1 t typesSpecLen +t STRING typesSpec +1 c compatMapSpecLen +c STRING compatMapSpec +1 s symbolsSpecLen +s STRING symbolsSpec +1 g geometrySpecLen +g STRING geometrySpec +p unused,p=pad(6+m+k+t+c+s+g) + + +1 1 Reply +1 CARD8 deviceID +2 CARD16 sequence number +4 (M*+K*+T*+C*+S*+G*+p)/4 length +2 m nKeymaps +2 k nKeycodes +2 t nTypes +2 c nCompatMaps +2 s nSymbols +2 g nGeometries +2 CARD16 extra +10 unused +M0+..Mm LISTofKB_LISTING keymaps +K0+..Kk LISTofKB_LISTING keycodes +T0+..Tt LISTofKB_LISTING types +C0+..Cc LISTofKB_LISTING compatMaps +S0+..Ss LISTofKB_LISTING symbols +G0+..Gg LISTofKB_LISTING geometries +p unused,p=pad(M*+K*+T*+C*+S*+G*) + + +KB_LISTING 4+n+p +2 CARD16 flags +2 n length +n STRING8 string +p unused,p=pad(n) to a 2-byte boundary + + + +1 CARD8 opcode +1 23 xkb-opcode +2 3+(6+m+k+t+c+s+g+p)/4 request-length +2 KB_DEVICESPEC deviceSpec +2 SETofKB_GBNDETAILMASK need +2 SETofKB_GBNDETAILMASK want +1 BOOL load +1 unused +1 m keymapsSpecLen +m STRING8 keymapsSpec +1 k keycodesSpecLen +k STRING8 keycodesSpec +1 t typesSpecLen +t STRING8 typesSpec +1 c compatMapSpecLen +c STRING8 compatMapSpec +1 s symbolsSpecLen +s STRING8 symbolsSpec +1 g geometrySpecLen +g STRING8 geometrySpec +p unused,p=pad(6+m+k+t+c+s+g) + + +1 1 Reply +1 CARD8 deviceID +2 CARD16 sequence number +4 V/4 length +1 KEYCODE minKeyCode +1 KEYCODE maxKeyCode +1 BOOL loaded +1 BOOL newKeyboard +2 SETofKB_GBNDETAILMASK found +2 SETofKB_GBNDETAILMASK reported +16 unused +V LISTofITEMs replies + SETofKB_GBNDETAILMASK (reported) + XkbGBN_Types map + XkbGBN_CompatMap compat + XkbGBN_ClientSymbols map + XkbGBN_ServerSymbols map + XkbGBN_IndicatorMap indicators + XkbGBN_KeyNames names + XkbGBN_OtherNames names + XkbGBN_Geometry geometry + + +ITEMs +M XkbGetMap reply map +C XkbGetCompatMap reply compat +I XkbGetIndicatorMap reply indicators +N XkbGetNames reply names +G XkbGetGeometry reply geometry + + + +1 CARD8 opcode +1 24 xkb-opcode +2 4 request-length +2 KB_DEVICESPEC deviceSpec +2 SETofKB_DEVFEATURE wanted +1 BOOL allButtons +1 CARD8 firstButton +1 CARD8 nButtons +1 unused +2 KB_LEDCLASSSPEC ledClass +2 KB_IDSPEC ledID + + +1 1 Reply +1 CARD8 deviceID +2 CARD16 sequence number +4 (2+n+p+8b+L*)/4 length +2 SETofKB_DEVFEATURE present +2 SETofKB_FEATURE supported +2 SETofKB_FEATURE unsupported +2 l nDeviceLedFBs +1 CARD8 firstBtnWanted +1 CARD8 nBtnsWanted +1 CARD8 firstBtnRtrn +1 b nBtnsRtrn +1 CARD8 totalBtns +1 BOOL hasOwnState +2 SETofKB_IDRESULT dfltKbdFB +2 SETofKB_IDRESULT dfltLedFB +2 unused +4 ATOM devType +2 n nameLen +n STRING8 name +p unused,p=pad(2+n) +8b LISTofKB_ACTION btnActions +L0+..Ll LISTofKB_DEVICELEDINFO leds + + +KB_DEVICELEDINFO 20+4n+12m +2 KB_LEDCLASSSPEC ledClass +2 KB_IDSPEC ledID +4 SETofKB_INDICATOR namesPresent (has n bits set to 1) +4 SETofKB_INDICATOR mapsPresent (has m bits set to 1) +4 SETofKB_INDICATOR physIndicators +4 SETofKB_INDICATOR state +4n LISTofATOM names +12m LISTofKB_INDICATORMAP maps + + + +1 ?? opcode +1 25 xkb-opcode +2 3+(8b+L*)/4 request-length +2 KB_DEVICESPEC deviceSpec +1 CARD8 firstBtn +1 b nBtns +2 SETofKB_DEVFEATURE change +2 l nDeviceLedFBs +8b LISTofKB_ACTION btnActions +L0+..Ll LISTofKB_DEVICELEDINFO leds + Encoding of KB_DEVICELEDINFO is as for XkbGetDeviceInfo + + +1 ?? opcode +1 101 xkb-opcode +2 6+(n+p)/4 request-length +2 n msgLength +2 unused +4 CARD32 affectFlags +4 CARD32 flags +4 CARD32 affectCtrls +4 CARD32 ctrls +n STRING8 message +p unused, p=pad(n) + + +1 1 Reply +1 unused +2 CARD16 sequence number +4 0 length +4 CARD32 currentFlags +4 CARD32 currentCtrls +4 CARD32 supportedFlags +4 CARD32 supportedCtrls +8 unused + + + + + +Events + +1 ?? code +1 0 xkb code +2 CARD16 sequence number +4 TIMESTAMP time +1 CARD8 deviceID +1 CARD8 oldDeviceID +1 KEYCODE minKeyCode +1 KEYCODE maxKeyCode +1 KEYCODE oldMinKeyCode +1 KEYCODE oldMaxKeyCode +1 CARD8 requestMajor +1 CARD8 requestMinor +2 SETofKB_NKNDETAIL changed +14 unused + + +1 ?? code +1 1 xkb code +2 CARD16 sequence number +4 TIMESTAMP time +1 CARD8 deviceID +1 SETofBUTMASK ptrBtnActions +2 SETofKB_MAPPART changed +1 KEYCODE minKeyCode +1 KEYCODE maxKeyCode +1 CARD8 firstType +1 CARD8 nTypes +1 KEYCODE firstKeySym +1 CARD8 nKeySyms +1 KEYCODE firstKeyAct +1 CARD8 nKeyActs +1 KEYCODE firstKeyBehavior +1 CARD8 nKeyBehavior +1 KEYCODE firstKeyExplicit +1 CARD8 nKeyExplicit +1 KEYCODE firstModMapKey +1 CARD8 nModMapKeys +1 KEYCODE firstVModMapKey +1 CARD8 nVModMapKeys +2 SETofKB_VMOD virtualMods +2 unused + + +1 ?? code +1 2 xkb code +2 CARD16 sequence number +4 TIMESTAMP time +1 CARD8 deviceID +1 SETofKEYMASK mods +1 SETofKEYMASK baseMods +1 SETofKEYMASK latchedMods +1 SETofKEYMASK lockedMods +1 KB_GROUP group +2 INT16 baseGroup +2 INT16 latchedGroup +1 KB_GROUP lockedGroup +1 SETofKEYMASK compatState +1 SETofKEYMASK grabMods +1 SETofKEYMASK compatGrabMods +1 SETofKEYMASK lookupMods +1 SETofKEYMASK compatLookupMods +2 SETofBUTMASK ptrBtnState +2 SETofKB_STATEPART changed +1 KEYCODE keycode +1 CARD8 eventType +1 CARD8 requestMajor +1 CARD8 requestMinor + + +1 ?? code +1 3 xkb code +2 CARD16 sequence number +4 TIMESTAMP time +1 CARD8 deviceID +1 CARD8 numGroups +2 unused +4 SETofKB_CONTROL changedControls +4 SETofKB_BOOLCTRL enabledControls +4 SETofKB_BOOLCTRL enabledControlChanges +1 KEYCODE keycode +1 CARD8 eventType +1 CARD8 requestMajor +1 CARD8 requestMinor +4 unused + + +1 ?? code +1 4 xkb code +2 CARD16 sequence number +4 TIMESTAMP time +1 CARD8 deviceID +3 unused +4 SETofKB_INDICATOR state +4 SETofKB_INDICATOR stateChanged +12 unused + + +1 ?? code +1 5 xkb code +2 CARD16 sequence number +4 TIMESTAMP time +1 CARD8 deviceID +3 unused +4 SETofKB_INDICATOR state +4 SETofKB_INDICATOR mapChanged +12 unused + + +1 ?? code +1 6 xkb code +2 CARD16 sequence number +4 TIMESTAMP time +1 CARD8 deviceID +1 unused +2 SETofKB_NAMEDETAIL changed +1 CARD8 firstType +1 CARD8 nTypes +1 CARD8 firstLevelName +1 CARD8 nLevelNames +1 unused +1 CARD8 nRadioGroups +1 CARD8 nKeyAliases +1 SETofKB_GROUP changedGroupNames +2 SETofKB_VMOD changedVirtualMods +1 KEYCODE firstKey +1 CARD8 nKeys +4 SETofKB_INDICATOR changedIndicators +4 unused + + +1 ?? code +1 7 xkb code +2 CARD16 sequence number +4 TIMESTAMP time +1 CARD8 deviceID +1 SETofKB_GROUP changedGroups +2 CARD16 firstSI +2 CARD16 nSI +2 CARD16 nTotalSI +16 unused + + +1 ?? code +1 8 xkb code +2 CARD16 sequence number +4 TIMESTAMP time +1 CARD8 deviceID +1 KB_BELLCLASSRESULT bellClass +1 CARD8 bellID +1 CARD8 percent +2 CARD16 pitch +2 CARD16 duration +4 ATOM name +4 WINDOW window +1 BOOL eventOnly +7 unused + + +1 ?? code +1 9 xkb code +2 CARD16 sequence number +4 TIMESTAMP time +1 CARD8 deviceID +1 KEYCODE keycode +1 BOOL press +1 BOOL keyEventFollows +1 SETofKEYMASK mods +1 KB_GROUP group +8 STRING8 message +10 unused + + +1 ?? code +1 10 xkb code +2 CARD16 sequence number +4 TIMESTAMP time +1 CARD8 deviceID +1 KEYCODE keycode +2 SETofKB_AXNDETAIL detail +2 CARD16 slowKeysDelay +2 CARD16 debounceDelay + + +1 ?? code +16 unused + + +1 ?? code +1 11 xkb code +2 CARD16 sequence number +4 TIMESTAMP time +1 CARD8 deviceID +1 unused +2 SETofKB_XIDETAIL reason +2 KB_LEDCLASSRESULT ledClass +2 CARD8 ledID +4 SETofKB_INDICATOR ledsDefined +4 SETofKB_INDICATOR ledState +1 CARD8 firstButton +1 CARD8 nButtons +2 SETofKB_XIFEATURE supported +2 SETofKB_XIFEATURE unsupported +2 unused + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch01.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch01.xml new file mode 100644 index 0000000000000000000000000000000000000000..27dcc8830350086bd2a3f4fbba8d5bb2d2b79fc0 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch01.xml @@ -0,0 +1,101 @@ + +Overview + +This extension provides a number of new capabilities and controls for +text keyboards. + + + +The core X protocol specifies the ways that the +Shift +, +Control + and +Lock + modifiers and the modifiers bound to the +Mode_switch + or +Num_Lock + keysyms interact to generate keysyms and characters. The core protocol also +allows users to specify that a key affects one or more modifiers. This behavior +is simple and fairly flexible, but it has a number of limitations that make it +difficult or impossible to properly support many common varieties of keyboard +behavior. The limitations of core protocol support for keyboards include: + + + + + Use of a single, uniform, four-symbol mapping for all keyboard keys +makes it difficult to properly support keyboard overlays, PC-style break keys +or keyboards that comply with ISO9995 or a host of other national and +international standards. + + + + Use of a modifier to specify a second keyboard group has side-effects +that wreak havoc with client grabs and X toolkit translations and limit us to +two keyboard groups. + + + + Poorly specified locking key behavior requires X servers to look for a +few "magic" keysyms to determine which keys should lock when pressed. This +leads to incompatibilities between X servers with no way for clients to detect +implementation differences. + + + + Poorly specified capitalization and control behavior requires +modifications to X library source code to support new character sets or locales +and can lead to incompatibilities between system-wide and X library +capitalization behavior. + + + + Limited interactions between modifiers specified by the core protocol +make many common keyboard behaviors difficult or impossible to implement. For +example, there is no reliable way to indicate whether or not using shift should +"cancel" the lock modifier. + + + + The lack of any explicit descriptions for indicators, most modifiers +and other aspects of the keyboard appearance requires clients that wish to +clearly describe the keyboard to a user to resort to a mishmash of prior +knowledge and heuristics. + + + + + +This extension makes it possible to clearly and explicitly specify most aspects +of keyboard behavior on a per-key basis. It adds the notion of a numeric +keyboard group to the global keyboard state and provides mechanisms to more +closely track the logical and physical state of the keyboard. For keyboard +control clients, this extension provides descriptions and symbolic names for +many aspects of keyboard appearance and behavior. It also includes a number of +keyboard controls designed to make keyboards more accessible to people with +movement impairments. + + + + +The X Keyboard Extension essentially replaces the core protocol definition of a +keyboard. The following sections describe the new capabilities of the extension +and the effect of the extension on core protocol requests, events and errors. + + + +Conventions and Assumptions + +This document uses the syntactic +conventions, common types, and errors defined in sections two through four of +the specification of the X Window System Protocol. This document assumes +familiarity with the fundamental concepts of X, especially those related to the +way that X handles keyboards. Readers who are not familiar with the meaning or +use of keycodes, keysyms or modifiers should consult (at least) the first five +chapters of the protocol specification of the X Window System before +continuing. + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch02.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch02.xml new file mode 100644 index 0000000000000000000000000000000000000000..023429732490a78f255af5f6f9f7785133bdeb88 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch02.xml @@ -0,0 +1,441 @@ + +Keyboard State + +The core protocol description of +keyboard state consists of eight +modifiers +( +Shift +, +Lock +, +Control +, and +Mod1 +- +Mod5 +). A modifier reports the state of one or modifier keys, which are similar to +qualifier keys as defined by the ISO9995 standard: + + + + + Qualifier key + + +A key whose operation +has no immediate effect, but which, for as long as it is held down, modifies +the effect of other keys. A qualifier key may be, for example, a shift key or a +control key. + + + + + + +Whenever a modifier key is physically or logically depressed, the modifier it +controls is set in the keyboard state. The protocol implies that certain +modifier keys lock (i.e. affect modifier state after they have been physically +released) but does not explicitly discuss locking keys or their behavior. The +current modifier state is reported to clients in a number of core protocol +events and can be determined using the +QueryPointer + request. + + + +The XKB extension retains the eight "real" modifiers defined by the core +protocol but extends the core protocol notion of +keyboard state + to include up to four +keysym groups +, as defined by the ISO9995 standard: + + + + + + Group: + + +A logical state of a keyboard providing +access to a collection of characters. A group usually contains a set of +characters which logically belong together and which may be arranged on several +shift levels within that group. + + + + + + +For example, keyboard group can be used to select between multiple alphabets on +a single keyboard, or to access less-commonly used symbols within a character +set. + + + +Locking and Latching Modifiers and Groups + +With the core protocol, there is no way to +tell whether a modifier is set due to a lock or because the user is actually +holding down a key; this can make for a clumsy user-interface as locked +modifiers or group state interfere with accelerators and translations. + + +XKB adds explicit support for locking +and latching modifiers and groups. Locked modifiers or groups apply to all +future key events until they are explicitly changed. Latched modifiers or +groups apply only to the next key event that does not change keyboard state. + + + + +Fundamental Components of XKB Keyboard State + +The fundamental components of XKB keyboard state include: + + + + + The locked modifiers and group + + + The latched modifiers and group + + + The base modifiers and group (for which keys are physically or +logically down) + + + + The effective modifiers and group (the cumulative effect of the base, +locked and latched modifier and group states). + + + + State of the core pointer buttons. + + + + +The latched and locked state of modifiers and groups can be changed in response +to keyboard activity or under application control using the +XkbLatchLockState + request. The base modifier, base group +and pointer button states always reflect the logical state of the keyboard and +pointer and change +only + in response to keyboard or pointer activity. + + + +Computing Effective Modifier and Group + +The effective modifiers and group +report the cumulative effects of the base, latched and locked modifiers and +group respectively, and cannot be directly changed. Note that the effective +modifiers and effective group are computed differently. + + + +The effective modifiers are simply the bitwise union of the base, latched and +locked modifiers. + + + + +The effective group is the arithmetic sum of the base, latched and locked +groups. The locked and effective keyboard group must fall in the range + +Group1 +- +Group4 +, so they are adjusted into range as specified by the global +GroupsWrap +control as follows: + + + + + +If the +RedirectIntoRange + flag is set, the four least significant +bits of the groups wrap control specify the index of a group to which all +illegal groups correspond. If the specified group is also out of range, all +illegal groups map to +Group1. + + + + +If the +ClampIntoRange + flag is set, out-of-range groups +correspond to the nearest legal group. Effective groups larger than the highest +supported group are mapped to the highest supported group; effective groups +less than +Group1 + are mapped to +Group1 +. For example, a key with two groups of symbols uses +Group2 + type and symbols if the global effective group is either +Group3 + or +Group4. + + + + +If neither flag is set, group is +wrapped into range using integer modulus. For example, a key with two groups of +symbols for which groups wrap uses +Group1 + symbols if the global effective group is +Group3 + or +Group2 + symbols if the global effective group is +Group4. + + + + + +The base and latched keyboard groups are unrestricted eight-bit integer values +and are not affected by the +GroupsWrap + control. + + + + + +Computing A State Field from an XKB State + +Many events report the keyboard state +in a single +state + field. Using XKB, a state field combines modifiers, group and the pointer +button state into a single sixteen bit value as follows: + + + + + Bits 0 through 7 (the least significant eight bits) of the effective +state comprise a mask of type KEYMASK which reports the state modifiers. + + + + Bits 8 through 12 comprise a mask of type BUTMASK which reports pointer +button state. + + + + Bits 13 and 14 are interpreted as a two-bit unsigned numeric value and +report the state keyboard group. + + + + Bit 15 (the most significant bit) is reserved and must be zero. + + + + + +It is possible to assemble a state field from any of the components of the XKB +keyboard state. For example, the effective keyboard state would be assembled as +described above using the effective keyboard group, the effective keyboard +modifiers and the pointer button state. + + + + + + +Derived Components of XKB Keyboard State + +In addition to the fundamental state +components, XKB keeps track of and reports a number of state components which +are derived from the fundamental components but stored and reported separately +to make it easier to track changes in the keyboard state. These derived +components are updated automatically whenever any of the fundamental components +change but cannot be changed directly. + + + +The first pair of derived state components control the way that passive grabs +are activated and the way that modifiers are reported in core protocol events +that report state. The server uses the +ServerInternalModifiers +, +IgnoreLocksModifiers + and +IgnoreGroupLock + controls, described in Server +Internal Modifiers and Ignore Locks Behavior, to derive these two +states as follows: + + + + + The lookup state is the state used to determine the symbols associated +with a key event and consists of the effective state minus any server internal +modifiers. + + + + The grab state is the state used to decide whether a particular event +triggers a passive grab and consists of the lookup state minus any members of +the ignore locks modifiers that are not either latched or logically depressed. +If the ignore group locks control is set, the grab state does not include the +effects of any locked groups. + + + + + +Server Internal Modifiers and Ignore Locks Behavior + +The core protocol does not provide any +way to exclude certain modifiers from client events, so there is no way to set +up a modifier which affects only the server. + + + +The modifiers specified in the mask of the +InternalMods + control are not reported in any core +protocol events, are not used to determine grabs and are not used to calculate +compatibility state for XKB-unaware clients. Server internal modifiers affect +only the action applied when a key is pressed. + + + + +The core protocol does not provide any way to exclude certain modifiers from +grab calculations, so locking modifiers often have unanticipated and +unfortunate side-effects. XKB provides another mask which can help avoid some +of these problems. + + + + +The locked state of the modifiers specified in mask of the +IgnoreLockMods + control is not reported in most core +protocol events and is not used to activate grabs. The only core events which +include the locked state of the modifiers in the ignore locks mask are key +press and release events that do not activate a passive grab and which do not +occur while a grab is active. If the +IgnoreGroupLock + control is set, the locked state of the +keyboard group is not considered when activating passive grabs. + + + + +Without XKB, the passive grab set by a translation (e.g. +Alt<KeyPress>space +) does not trigger if any modifiers other than those specified by the +translation are set, with the result that many user interface components do not +react when either Num Lock or when the secondary keyboard group are active. The +ignore locks mask and the ignore group locks control make it possible to avoid +this behavior without exhaustively grabbing every possible modifier combination. + + + + + + +Compatibility Components of Keyboard State + +The core protocol interpretation of +keyboard modifiers does not include direct support for multiple groups, so XKB +reports the effective keyboard group to XKB-aware clients using some of the +reserved bits in the state field of some core protocol events, as described in +Computing A State Field from an +XKB State. + + + +This modified state field would not be interpreted correctly by XKB-unaware +clients, so XKB provides a +group compatibility mapping +(see Group Compatibility Map) which +remaps the keyboard group into a core modifier mask that has similar effects, +when possible. XKB maintains three compatibility state components that are used +to make non-XKB clients work as well as possible: + + + + + +The +compatibility state + corresponds to the effective modifier +and effective group state. + + + + +The +compatibility lookup state + is the core-protocol equivalent of the +lookup state. + + + + +The +compatibility grab state + is the nearest core-protocol equivalent +of the grab state. + + + + + +Compatibility states are essentially the corresponding XKB state, but with +keyboard group possibly encoded as one or more modifiers; Group Compatibility Map describes +the group compatibility map, which specifies the modifier(s) that correspond to +each keyboard group. + + + + +The compatibility state reported to XKB-unaware + clients for any given core protocol event +is computed from the modifier state that XKB-capable clients would see for that +same event. For example, if the ignore group locks control is set and group 2 +is locked, the modifier bound to +Mode_switch + is not reported in any event except (Device)KeyPress and (Device)KeyRelease +events that do not trigger a passive grab. + + + + +Referring to clients as "XKB-capable + is somewhat misleading in this context. +The sample implementation of XKB invisibly extends the X library to use the +keyboard extension if it is present. This means that most clients can take +advantage of all of XKB without modification, but it also means that the XKB +state can be reported to clients that have not explicitly requested the +keyboard extension. Clients that +directly + interpret the state field of core protocol events or that interpret the keymap +directly may be affected by some of the XKB differences; clients that use +library or toolkit routines to interpret keyboard events automatically use all +of the XKB features. + + + + +XKB-aware clients can query the keyboard state at any time or request immediate +notification of a change to any of the fundamental or derived components of the +keyboard state. + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch03.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch03.xml new file mode 100644 index 0000000000000000000000000000000000000000..d71f353783cabb8c03d13aaec1c8944282d0dc16 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch03.xml @@ -0,0 +1,220 @@ + +Virtual Modifiers + +The core protocol specifies that +certain keysyms, when bound to modifiers, affect the rules of keycode to keysym +interpretation for all keys; for example, when +Num_Lock + is bound to some modifier, that modifier is used to choose shifted or +unshifted state for the numeric keypad keys. The core protocol does not provide +a convenient way to determine the mapping of modifier bits, in particular + +Mod1 + through +Mod5 +, to keysyms such as +Num_Lock + and +Mode_switch +. Clients must retrieve and search the modifier map to determine the keycodes +bound to each modifier, and then retrieve and search the keyboard mapping to +determine the keysyms bound to the keycodes. They must repeat this process for +all modifiers whenever any part of the modifier mapping is changed. + + + +XKB provides a set of sixteen named virtual modifiers, each of which can be +bound to any set of the eight "real" modifiers ( +Shift +, +Lock +, +Control + and +Mod1 +- +Mod5 + as reported in the keyboard state). This makes it easier for applications and +keyboard layout designers to specify to the function a modifier key or data +structure should fulfill without having to worry about which modifier is bound +to a particular keysym. + + + + +The use of a single, server-driven mechanism for reporting changes to all data +structures makes it easier for clients to stay synchronized. For example, the +core protocol specifies a special interpretation for the modifier bound to the + +Num_Lock + key. Whenever any keys or modifiers are rebound, every application has to +check the keyboard mapping to make sure that the binding for +Num_Lock + has not changed. If +Num_Lock + is remapped when XKB is in use, the keyboard description is automatically +updated to reflect the new binding, and clients are notified immediately and +explicitly if there is a change they need to consider. + + + + +The separation of function from physical modifier bindings also makes it easier +to specify more clearly the intent of a binding. X servers do not all assign +modifiers the same way — for example, +Num_Lock + might be bound to +Mod2 + for one vendor and to +Mod4 + for another. This makes it cumbersome to automatically remap the keyboard to a +desired configuration without some kind of prior knowledge about the keyboard +layout and bindings. With XKB, applications simply use virtual modifiers to +specify the behavior they want, without regard for the actual physical bindings +in effect. + + + + +XKB puts most aspects of the keyboard under user or program control, so it is +even more important to clearly and uniformly refer to modifiers by function. + + + +Modifier Definitions + +Use an +XKB modifier definition + to specify the modifiers affected by any XKB control or data structure. An XKB +modifier definition consists of a set of real modifiers, a set of virtual +modifiers, and an effective mask. The mask is derived from the real and virtual +modifiers and cannot be explicitly changed — it contains all of the real +modifiers specified in the definition +plus + any real modifiers that are bound to the virtual modifiers specified in the +definition. For example, this modifier definition specifies the numeric lock +modifier if the +Num_Lock + keysym is not bound to any real modifier: + + +{ real_mods= None, virtual_mods= NumLock, mask= None } + + + +If we assign +Mod2 + to the +Num_Lock + key, the definition changes to: + + + +{ real_mods= None, virtual_mods= NumLock, mask= Mod2 } + + + +Using this kind of modifier definition makes it easy to specify the desired +behavior in such a way that XKB can automatically update all of the data +structures that make up a keymap to reflect user or application specified +changes in any one aspect of the keymap. + + + + +The use of modifier definitions also makes it possible to unambiguously specify +the reason that a modifier is of interest. On a system for which the +Alt + and +Meta + keysyms are bound to the same modifier, the following definitions behave +identically: + + + +{ real_mods= None, virtual_mods= Alt, mask= Mod1 } +{ real_mods= None, virtual_mods= Meta, mask= Mod1 } + + + +If we rebind one of the modifiers, the modifier definitions automatically +reflect the change: + + + +{ real_mods= None, virtual_mods= Alt, mask= Mod1 } +{ real_mods= None, virtual_mods= Meta, mask= Mod4 } + + + +Without the level of indirection provided by virtual modifier maps and modifier +definitions, we would have no way to tell which of the two definitions is +concerned with +Alt + and which is concerned with +Meta. + + + + +Inactive Modifier Definitions + +Some XKB structures ignore modifier +definitions in which the virtual modifiers are unbound. Consider this +example: + + +if ( state matches { Shift } ) Do OneThing; +if ( state matches { Shift+NumLock } ) Do Another; + + + +If the +NumLock + virtual modifier is not bound to any real modifiers, these effective masks for +these two cases are identical (i.e. they contain only +Shift +). When it is essential to distinguish between +OneThing + and Another, XKB considers only those modifier definitions for which all +virtual modifiers are bound. + + + + + +Virtual Modifier Mapping + +XKB maintains a +virtual modifier mapping +, which lists the virtual modifiers associated with each key. The real +modifiers bound to a virtual modifier always include all of the modifiers bound +to any of the keys that specify that virtual modifier in their virtual modifier +mapping. + + + +For example, if +Mod3 + is bound to the +Num_Lock + key by the core protocol modifier mapping, and the +NumLock + virtual modifier is bound to they +Num_Lock + key by the virtual modifier mapping, +Mod3 + is added to the set of modifiers associated with the +NumLock + virtual modifier. + + + + +The virtual modifier mapping is normally updated automatically whenever actions +are assigned to keys (see Changing +the Keyboard Mapping Using the Core Protocol for details) and few +applications should need to change the virtual modifier mapping explicitly. + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch04.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch04.xml new file mode 100644 index 0000000000000000000000000000000000000000..d35e2b4b3a18256ba7f335c04617af5dbc2d8d45 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch04.xml @@ -0,0 +1,865 @@ + +Global Keyboard Controls + + +The X Keyboard Extension supports a number of +global key controls +, which affect the way that XKB handles the keyboard as a whole. Many of these +controls make the keyboard more accessible to the physically impaired and are +based on the AccessDOS package +AccessDOS provides access to the DOS operating system for people with physical +impairments and was developed by the Trace R&D Center at the University of +Wisconsin. For more information on AccessDOS, contact the Trace R&D Center, +Waisman Center and Department of Industrial Engineering, University of +Wisconsin-Madison WI 53705-2280. Phone: 608-262-6966. e-mail: +info@trace.wisc.edu.. + + + +The RepeatKeys Control + + +The core protocol only allows control over whether or not the entire keyboard +or individual keys should autorepeat when held down. The +RepeatKeys + control extends this capability by adding control over the delay until a key +begins to repeat and the rate at which it repeats. +RepeatKeys + is also coupled with the core autorepeat control; changes to one are always +reflected in the other. + + + + +The +RepeatKeys + control has two parameters. The +autorepeat delay + specifies the delay between the initial press of an autorepeating key and the +first generated repeat event in milliseconds. The +autorepeat interval + specifies the delay between all subsequent generated repeat events in +milliseconds. + + + + +The PerKeyRepeat Control + + +When +RepeatKeys + are active, the +PerKeyRepeat + control specifies whether or not individual keys should autorepeat when held +down. XKB provides the +PerKeyRepeat + for convenience only, and it always parallels the +auto-repeats + field of the core protocol +GetKeyboardControl + request — changes to one are always reflected in the other. + + + + + +Detectable Autorepeat + + +The X server usually generates both press and release events whenever an +autorepeating key is held down. If an XKB-aware client enables the +DetectableAutorepeat + per-client option for a keyboard, the server sends that client a key release +event only when the key is +physically + released. For example, holding down a key to generate three characters without +detectable autorepeat yields: + + + +Press -> Release -> Press -> Release -> Press -> Release + + + +If detectable autorepeat is enabled, the client instead receives: + + + +Press-> Press -> Press -> Release + + + +Note that only clients that request detectable autorepeat are affected; other +clients continue to receive both press and release events for autorepeating +keys. Also note that support for detectable autorepeat is optional; servers are +not required to support detectable autorepeat, but they must correctly report +whether or not it is supported. + + + + +Querying and Changing Per-Client +Flags describes the +XkbPerClientFlags + request, which reports or changes values for all of the per-client flags, and +which lists the per-client flags that are supported. + + + + + + +The SlowKeys Control + + +Some users often bump keys accidentally while moving their hand or typing stick +toward the key they want. Usually, the keys that are bumped accidentally are +hit only for a very short period of time. The +SlowKeys + control helps filter these accidental bumps by telling the server to wait a +specified period, called the +SlowKeys acceptance delay +, before delivering key events. If the key is released before this period +elapses, no key events are generated. The user can then bump any number of keys +on their way to the one they want without generating unwanted characters. Once +they have reached the key they want, they can then hold it long enough for + +SlowKeys + to accept it. + + + + +The +SlowKeys + control has one parameter; the +slow keys delay + specifies the length of time, in milliseconds, that a key must be held down +before it is accepted. + + + + +When +SlowKeys + are active, the X Keyboard Extension reports the initial press, acceptance, +rejection or release of any key to interested clients using +AccessXNotify + events. The +AccessXNotify + event is described in more detail in Events. + + + + +The BounceKeys Control + + +Some people with physical impairments accidentally "bounce" on a key when they +press it. That is, they press it once, then accidentally press it again +immediately. The +BounceKeys + control temporarily disables a key after it has been pressed, effectively +"debouncing" the keyboard. + + + + +The +BounceKeys + has a single parameter. The +BounceKeys delay + specifies the period of time, in milliseconds, that the key is disabled after +it is pressed. + + + + +When +BounceKeys + are active, the server reports the acceptance or rejection of any key to +interested clients by sending an +AccessXNotify + event. The +AccessXNotify + event is described in more detail in Events. + + + + +The StickyKeys Control + + +Some people find it difficult or impossible to press two keys at once. The + +StickyKeys + control makes it easier for them to type by changing the behavior of the +modifier keys. When +StickyKeys + are enabled, a modifier is latched when the user presses it just once, so the +user can first press a modifier, release it, then press another key. For +example, to get an exclamation point (!) on a PC-style keyboard, the user can +press the +Shift + key, release it, then press the +1 + key. + + + + +By default, +StickyKeys + also allows users to lock modifier keys without requiring special locking +keys. The user can press a modifier twice in a row to lock it, and then unlock +it by pressing it one more time. + + + + +Modifiers are automatically unlatched when the user presses a non-modifier key. +For instance, to enter the sequence +Shift ++ +Ctrl ++ +Z + the user could press and release the +Shift + key to latch the +Shift + modifier, then press and release the +Ctrl + key to latch the +Control + modifier — the +Ctrl + key is a modifier key, so pressing it does not unlatch the +Shift + modifier, but leaves both the +Shift + and +Control + modifiers latched, instead. When the user presses the +Z + key, it will be as though the user pressed +Shift ++ +Ctrl ++ +Z + simultaneously. The +Z + key is not a modifier key, so the +Shift + and +Control + modifiers are unlatched after the event is generated. + + + + +A locked a modifier remains in effect until the user unlocks it. For example, +to enter the sequence ("XKB") on a PC-style keyboard with a typical US/ASCII +layout, the user could press and release the +Shift + key twice to lock the +Shift + modifier. Then, when the user presses the +9 +, +‘ +, +x +, +k +, +b +, +‘ +, and +0 + keys in sequence, it will generate ("XKB"). To unlock the +Shift + modifier, the user can press and release the +Shift + key. + + + + +Two option flags modify the behavior of the +StickyKeys + control: + + + + + If the +XkbAX_TwoKeys + flag is set, XKB automatically turns +StickyKeys + off if the user presses two or more keys at once. This serves to automatically +disable StickyKeys when a user who does not require sticky keys is using the +keyboard. + + + + The +XkbAX_LatchToLock + controls the locking behavior of +StickyKeys +; the +StickyKeys + control only locks modifiers as described above if the +XkbAX_LatchToLock + flag is set. + + + + + + +The MouseKeys Control + + +The +MouseKeys + control lets a user control all the mouse functions from the keyboard. When + +MouseKeys + are enabled, all keys with +MouseKeys + actions bound to them generate core pointer events instead of normal key press +and release events. + + + + +The +MouseKeys + control has a single parameter, the +mouse keys default button +, which specifies the core pointer button to be used by mouse keys actions that +do not explicitly specify a button. + + + + + +The MouseKeysAccel Control + + +If the +MouseKeysAccel + control is enabled, the effect of a pointer motion action changes as a key is +held down. The +mouse keys delay + specifies the amount of time between the initial key press and the first +repeated motion event. The +mouse keys interval + specifies the amount of time between repeated mouse keys events. The +steps to maximum acceleration + field specifies the total number of events before the key is travelling at +maximum speed. The +maximum acceleration + field specifies the maximum acceleration. The +curve + parameter controls the ramp used to reach maximum acceleration. + + + + +When +MouseKeys + are active and a +SA_MovePtr + key action (see Key +Actions) is activated, a pointer motion event is generated immediately. +If +MouseKeysAccel + is enabled and if acceleration is enabled for the key in question, a second +event is generated after +mouse keys delay +milliseconds, and additional events are generated every +mouse keys interval + milliseconds for as long as the key is held down. + + + + +Relative Pointer Motion + + +If the +SA_MovePtr + action specifies relative motion, events are generated as follows: The initial +event always moves the cursor the distance specified in the action; after + +steps to maximum acceleration + events have been generated, all subsequent events move the pointer the +distance specified in the action times the +maximum acceleration. + Events after the first but before maximum acceleration has been achieved are +accelerated according to the formula: + + + + + + + + + + +Where +action_delta + is the offset specified by the mouse keys action, +max_accel +and +steps_to_max + are parameters to the +MouseKeysAccel + ctrl, and the curveFactor is computed using the +MouseKeysAccel + +curve + parameter as follows: + + + + + + + + + +With the result that a +curve + of +0 + causes the distance moved to increase linearly from +action_delta + to + + + + +, and the minimum legal +curve + of - +1000 + causes all events after the first move at +max_accel +. A negative +curve + causes an initial sharp increase in acceleration which tapers off, while a +positive curve yields a slower initial increase in acceleration followed by a +sharp increase as the number of pointer events generated by the action +approaches +steps_to_max +. + + + + + +Absolute Pointer Motion + + +If an +SA_MovePtr + action specifies an absolute position for one of the coordinates but still +allows acceleration, all repeated events contain any absolute coordinates +specified in the action. + + + + + + +The AccessXKeys Control + + +If +AccessXKeys + is enabled many controls can also be turned on or off from the keyboard by +entering the following standard key sequences: + + + + + Holding down a shift key by itself for eight seconds toggles the + +SlowKeys + control. + + + + Pressing and releasing a shift key five times in a row without any +intervening key events and with less than 30 seconds delay between consecutive +presses toggles the state of the +StickyKeys + control. + + + + Simultaneously operating two or more modifier keys deactivates the + +StickyKeys + control. + + + + + +Some of these key sequences optionally generate audible feedback of the change +in state, as described in The +AccessXFeedback Control, or cause +XkbAccessXNotify + events as described in Events. + + + + + +The AccessXTimeout Control + + +In environments where computers are shared, features such as +SlowKeys + present a problem: if +SlowKeys + is on, the keyboard can appear to be unresponsive because keys have no effect +unless they are held for a certain period of time. To help address this +problem, XKB provides an +AccessXTimeout + control to automatically change the value of any global controls or AccessX +options if the keyboard is idle for a specified period of time. + + + + +The AccessXTimeout control has a number of parameters which affect the duration +of the timeout and the features changed when the timeout expires. + + + + +The +AccessX Timeout + field specifies the number of seconds the keyboard must be idle before the +global controls and AccessX options are modified. The +AccessX Options Mask + field specifies which values in the +AccessX Options + field are to be changed, and the +AccessX Options Values + field specifies the new values for those options. The +AccessX Controls Mask + field specifies which controls are to be changed in the global set of + +enabled controls +, and the +AccessX Controls Values + field specifies the new values for those controls. + + + + + +The AccessXFeedback Control + + +If +AccessXFeedback + is enabled, special beep-codes indicate changes in keyboard controls (or some +key events when +SlowKeys + or +StickyKeys + are active). Many beep codes sound as multiple tones, but XKB reports a single + +XkbBellNotify + event for the entire sequence of tones. + + + + +All feedback tones are governed by the +AudibleBell + control. Individual feedback tones can be explicitly enabled or disabled using +the +accessX options mask + or set to deactivate after an idle period using the +accessX timeout options mask +. XKB defines the following feedback tones: + + + + + + + + + + + + Feedback Name + Bell Name + Default Sound + Indicates + + + + + FeatureFB + AX_FeatureOn + rising tone + Keyboard control enabled + + + + AX_FeatureOff + falling tone + Keyboard control disabled + + + + AX_FeatureChange + two tones + Several controls changed state + + + IndicatorFB + AX_IndicatorOn + high tone + Indicator Lit + + + + AX_IndicatorOff + low tone + Indicator Extinguished + + + + AX_IndicatorChange + two high tones + Several indicators changed state + + + SlowWarnFB + AX_SlowKeysWarning + three high tones + Shift key held for four seconds + + + SKPressFB + AX_SlowKeyPress + single tone + Key press while +SlowKeys + are on + + + SKReleaseFB + AX_SlowKeyRelease + single tone + Key release while +SlowKeys + are on + + + SKAcceptFB + AX_SlowKeyAccept + single tone + Key event accepted by +SlowKeys + + + + SKRejectFB + AX_SlowKeyReject + low tone + Key event rejected by +SlowKeys + + + + StickyKeysFB + AX_StickyLatch + low tone then high tone + Modifier latched by +StickyKeys + + + + + AX_StickyLock + high tone + Modifier locked by +StickyKeys + + + + + AX_StickyUnlock + low tone + Modifier unlocked by +StickyKeys + + + + BKRejectFB + AX_BounceKeysReject + low tone + Key event rejected by +BounceKeys + + + + + + + +Implementations that cannot generate continuous tones may generate multiple +beeps instead of falling and rising tones; for example, they can generate a +high-pitched beep followed by a low-pitched beep instead of a continuous +falling tone. + + + + +If the physical keyboard bell is not very capable, attempts to simulate a +continuous tone with multiple bells can sound horrible. Set the +DumbBellFB + AccessX option to inform the server that the keyboard bell is not very capable +and that XKB should use only simple bell combinations. Keyboard capabilities +vary wildly, so the sounds generated for the individual bells when the + +DumbBellFB + option is set are implementation specific. + + + + + +The Overlay1 and Overlay2 Controls + + +A keyboard overlay allows some subset of the keyboard to report alternate +keycodes when the overlay is enabled. For example a keyboard overlay can be +used to simulate a numeric or editing keypad on keyboard that does not actually +have one by generating alternate of keycodes for some keys when the overlay is +enabled. This technique is very common on portable computers and embedded +systems with small keyboards. + + + + +XKB includes direct support for two keyboard overlays, using the +Overlay1 + and +Overlay2 + controls. When +Overlay1 + is enabled, all of the keys that are members of the first keyboard overlay +generate an alternate keycode. When +Overlay2 + is enabled, all of the keys that are members of the second keyboard overlay +generate an alternate keycode. + + + + +To specify the overlay to which a key belongs and the alternate keycode it +should generate when that overlay is enabled, assign it either the +KB_Overlay1 + or +KB_Overlay2 + key behaviors, as described in +Key Behavior. + + + + + +"Boolean" Controls and The EnabledControls Control + + +All of the controls described above, along with the +AudibleBell + control (described in Disabling +Server Generated Bells) and the +IgnoreGroupLock + control (described in Server +Internal Modifiers and Ignore Locks Behavior) comprise the +boolean controls +. In addition to any parameters listed in the descriptions of the individual +controls, the boolean controls can be individually enabled or disabled by +changing the value of the +EnabledControls + control. + + + + +The following +non-boolean + controls are always active and cannot be changed using the +EnabledControls + control or specified in any context that accepts only boolean controls: + +GroupsWrap + (Computing Effective Modifier and +Group), +EnabledControls +, +InternalMods + (Server Internal Modifiers and +Ignore Locks Behavior), and +IgnoreLockMods + (Server Internal Modifiers and +Ignore Locks Behavior) and +PerKeyRepeat + (The RepeatKeys Control) + + + + + +Automatic Reset of Boolean Controls + + +The +auto-reset controls + are a per-client value which consist of two masks that can contain any of the +boolean controls (see "Boolean" +Controls and The EnabledControls Control). Whenever the client exits +for any reason, any boolean controls specified in the +auto-reset mask + are set to the corresponding value from the +auto-reset values + mask. This makes it possible for clients to "clean up after themselves" +automatically, even if abnormally terminated. + + + + +For example, a client that replace the keyboard bell with some other audible +cue might want to turn off the +AudibleBell + control (Disabling Server +Generated Bells) to prevent the server from also generating a sound and +thus avoid cacophony. If the client were to exit without resetting the + +AudibleBell +control, the user would be left without any feedback at all. Setting +AudibleBell + in both the auto-reset mask and auto-reset values guarantees that the audible +bell will be turned back on when the client exits. + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch05.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch05.xml new file mode 100644 index 0000000000000000000000000000000000000000..5669a39eac50dfc9d28e1cf0e620a03d795a3ddd --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch05.xml @@ -0,0 +1,86 @@ + + +Key Event Processing Overview + + +There are three steps to processing each key event in the X server, and at +least three in the client. This section describes each of these steps briefly; +the following sections describe each step in more detail. + + + + + First, the server applies global keyboard controls to determine whether +the key event should be processed immediately, deferred, or ignored. For +example, the +SlowKeys + control can cause a key event to be deferred until the slow keys delay has +elapsed while the +RepeatKeys + control can cause multiple X events from a single physical key press if the +key is held down for an extended period. The global keyboard controls affect +all of the keys on the keyboard and are described in +Global Keyboard Controls. + + + + Next, the server applies per-key behavior. Per key-behavior can be used +to simulate or indicate some special kinds of key behavior. For example, +keyboard overlays, in which a key generates an alternate keycode under certain +circumstances, can be implemented using per-key behavior. Every key has a +single behavior, so the effect of key behavior does not depend on keyboard +modifier or group state, though it might depend on global keyboard controls. +Per-key behaviors are described in detail in +Key Behavior. + + + + Finally, the server applies key actions. Logically, every keysym on the +keyboard has some action associated with it. The key action tells the server +what to do when an event which yields the corresponding keysym is generated. +Key actions might change or suppress the event, generate some other event, or +change some aspect of the server. Key actions are described in Key Actions. + + + + + +If the global controls, per-key behavior and key action combine to cause a key +event, the client which receives the event processes it in several steps. + + + + + First the client extracts the effective keyboard group and a set of +modifiers from the state field of the event. See Computing A State Field from an XKB +State for details. + + + + Using the modifiers and effective keyboard group, the client selects a +symbol from the list of keysyms bound to the key. Determining the KeySym Associated with a +Key Event discusses symbol selection. + + + + If necessary, the client transforms the symbol and resulting string +using any modifiers that are "left over" from the process of looking up a +symbol. For example, if the +Lock + modifier is left over, the resulting keysym is capitalized according to the +capitalization rules specified by the system. See + +Transforming the KeySym Associated with a +Key Event for a more detailed discussion of the transformations defined +by XKB. + + + + Finally, the client uses the keysym and remaining modifiers in an +application-specific way. For example, applications based on the X toolkit +might apply translations based on the symbol and modifiers reported by the +first three steps. + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch06.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch06.xml new file mode 100644 index 0000000000000000000000000000000000000000..ec6a5f29be774fde717d812fa3ab31c3cb6d8c71 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch06.xml @@ -0,0 +1,1767 @@ + +Key Event Processing in the Server + + +This section describes the steps involved in processing a key event within the +server when XKB is present. Key events can be generated due to keyboard +activity and passed to XKB by the DDX layer, or they can be synthesized by +another extension, such as XTEST. + + + +Applying Global Controls + + +When the X Keyboard Extension receives a key event, it first checks the global +key controls to decide whether to process the event immediately or at all. The +global key controls which might affect the event, in descending order of +priority, are: + + + + + If a key is pressed while the +BounceKeys + control is enabled, the extension generates the event only if the key is +active. When a key is released, the server deactivates the key and starts a + +bounce keys timer + with an interval specified by the debounce delay. + + +If the bounce keys timer expires or if some other key is pressed before the +timer expires, the server reactivates the corresponding key and deactivates the +timer. Neither expiration nor deactivation of a bounce keys timer causes an +event. + + + If the +SlowKeys + control is enabled, the extension sets a +slow keys timer + with an interval specified by the slow keys delay, but does not process the +key event immediately. The corresponding key release deactivates this timer. + + +If the slow keys timer expires, the server generates a key press for the +corresponding key, sends an +XkbAccessXNotify + and deactivates the timer. + + + + The extension processes key press events normally whether or not the + +RepeatKeys + control is active, but if +RepeatKeys + are enabled and per-key autorepeat is enabled for the event key, the extension +processes key press events normally, but it also initiates an +autorepeat timer + with an interval specified by the autorepeat delay. The corresponding key +release deactivates the timer. + + +If the autorepeat timer expires, the server generates a key release and a key +press for the corresponding key and reschedules the timer according to the +autorepeat interval. + + + + + +Key events are processed by each global control in turn: if the +BounceKeys + control accepts a key event, +SlowKeys + considers it. Once +SlowKeys + allows or synthesizes an event, the +RepeatKeys + control acts on it. + + + + + +Key Behavior + + +Once an event is accepted by all of the controls or generated by a timer, the +server checks the per-key behavior of the corresponding key. This extension +currently defines the following key behaviors: + + + + + + + + + + Behavior + Effect + + + + + +KB_Default + + Press and release events are processed normally. + + + +KB_Lock + + If a key is logically up (i.e. the corresponding bit of the core key +map is cleared) when it is pressed, the key press is processed normally and the +corresponding release is ignored. If the key is logically down when pressed, +the key press is ignored but the corresponding release is processed normally. + + + + + + +KB_RadioGroup + + + + flags: CARD8 + + + index: CARD8 + + + If another member of the radio group specified by +index + is logically down when a key is pressed, the server synthesizes a key release +for the member that is logically down and then processes the new key press +event normally. + +If the key itself is logically down when pressed, the key press event is +ignored, but the processing of the corresponding key release depends on the +value of the +RGAllowNone + bit in +flags +. If it is set, the key release is processed normally; otherwise the key +release is also ignored. + + +All other key release events are ignored. + + + + + + +KB_Overlay1 + + + + key: KEYCODE + + + If the +Overlay1 + control is enabled, events from this key are reported as if they came from the +key specified in +key +. Otherwise, press and release events are processed normally. + + + + + +KB_Overlay2 + + + + key: KEYCODE + + + If the +Overlay2 + control is enabled, events from this key are reported as if they came from the +key specified in +key +. Otherwise, press and release events are processed normally. + + + + + + +The X server uses key behavior to determine whether to process or filter out +any given key event; key behavior is independent of keyboard modifier or group +state (each key has exactly one behavior. + + + +Key behaviors can be used to simulate any of these types of keys or to indicate +an unmodifiable physical, electrical or software driver characteristic of a +key. An optional +permanent + flag can modify any of the supported behaviors and indicates that behavior +describes an unalterable physical, electrical or software aspect of the +keyboard. Permanent behaviors cannot be changed or set by the +XkbSetMap + request. The +permanent + flag indicates a characteristic of the underlying system that XKB cannot +affect, so XKB treats all permanent behaviors as if they were +KB_Default + and does not filter key events described in the table above. + + + + + +Key Actions + + +Once the server has applied the global controls and per-key behavior and has +decided to process a key event, it applies +key actions + to determine the effects of the key on the internal state of the server. A key +action consists of an operator and some optional data. XKB supports actions +which: + + + + + change base, latched or locked modifiers or group + + + + move the core pointer or simulate core pointer button events + + + + change most aspects of keyboard behavior + + + + terminate or suspend the server + + + + send a message to interested clients + + + + simulate events on other keys + + + + + +Each key has an optional list of actions. If present, this list parallels the +list of symbols associated with the key (i.e. it has one action per symbol +associated with the key). For key press events, the server looks up the action +to be applied from this list using the key symbol mapping associated with the +event key, just as a client looks up symbols as described in Determining the KeySym Associated with a +Key Event; if the event key does not have any actions, the server uses +the +SA_NoAction + event for that key regardless of modifier or group state. + + + + +Key actions have essentially two halves; the effects on the server when the key +is pressed and the effects when the key is released. The action applied for a +key press event determines the further actions, if any, that are applied to the +corresponding release event or to events that occur while the key is held down. +Clients can change the actions associated with a key while the key is down +without changing the action applied next time the key is released; subsequent +press-release pairs will use the newly bound key action. + + + + +Most actions directly change the state of the keyboard or server; some actions +also modify other actions that occur simultaneously with them. Two actions +occur simultaneously if the keys which invoke the actions are both logically +down at the same time, regardless of the order in which they are pressed or +delay between the activation of one and the other. + + + + +Most actions which affect keyboard modifier state accept a modifier definition +(see Virtual Modifiers) +named +mods + and a boolean flag name +useModMap + among their arguments. These two fields combine to specify the modifiers +affected by the action as follows: If +useModMap + is +True +, the action sets any modifiers bound by the modifier mapping to the key that +initiated the action; otherwise, the action sets the modifiers specified by + +mods +. For brevity in the text of the following definitions, we refer to this +combination of +useModMap + and +mods + as the "action modifiers." + + + + +The X Keyboard Extension supports the following actions: + + + + + + + + + + Action + Effect + + + + + SA_NoAction + + + + +No direct effect, though SA_NoAction + events may change the effect of other server actions (see below). + + + + + + + + + SA_SetMods + + + mods: MOD_DEF + + + useModMap: BOOL + + + clearLocks: BOOL + + + + + + +Key press adds any action modifiers to the keyboard’s base modifiers. + + + + Key release clears any action modifiers in the keyboard’s base +modifiers, provided that no other key which affects the same modifiers is +logically down. + + + + If no keys were operated simultaneously with this key and +clearLocks + is set, release unlocks any action modifiers. + + + + + + + + + +SA_LatchMods + + + + mods: MOD_DEF + + + useModMap: BOOL + + + clearLocks: BOOL + + + latchToLock: BOOL + + + + + + Key press and release events have the same effect as for +SA_SetMods +; if no keys were operated simultaneously with the latching modifier key, key +release events have the following additional effects: + + + + Modifiers that were unlocked due to +clearLocks + have no further effect. + + + + If +latchToLock + is set, key release locks and then unlatches any remaining action modifiers +that are already latched. + + + + Finally, key release latches any action modifiers that were not used by +the +clearLocks + or +latchToLock + flags. + + + + + + + + + +SA_LockMods + + + + mods: MOD_DEF + + + useModMap: BOOL + + + noLock: BOOL + + + noUnlock: BOOL + + + + + + Key press sets the base and possibly the locked state of any action +modifiers. If +noLock + is +True +, only the base state is changed. + + + + For key release events, clears any action modifiers in the keyboard’s +base modifiers, provided that no other key which affects the same modifiers is +down. If +noUnlock + is +False + and any of the action modifiers were locked before the corresponding key press +occurred, key release unlocks them. + + + + + + + + + +SA_SetGroup + + + + group: INT8 + + + groupAbsolute: BOOL + + + clearLocks: BOOL + + + + + + If +groupAbsolute + is set, key press events change the base keyboard group to +group +; otherwise, they add +group + to the base keyboard group. In either case, the resulting effective keyboard +group is brought back into range depending on the value of the +GroupsWrap + control for the keyboard. + + + + If an +SA_ISOLock + key is pressed while this key is held down, key release has no effect, +otherwise it cancels the effects of the press. + + + + If no keys were operated simultaneously with this key and +clearLocks + is set, key release also sets the locked keyboard group to +Group1 +. + + + + + + + + + +SA_LatchGroup + + + + group: INT8 + + + groupAbsolute: BOOL + + + clearLocks: BOOL + + + latchToLock: BOOL + + + + + + Key press and release events have the same effect as an +SA_SetGroup + action; if no keys were operated simultaneously with the latching group key +and the +clearLocks + flag was not set or had no effect, key release has the following additional +effects: + + + + If +latchToLock + is set and the latched keyboard group is non-zero, the key release adds the +delta applied by the corresponding key press to the locked keyboard group and +subtracts it from the latched keyboard group. The locked and effective keyboard +group are brought back into range according to the value of the global + +GroupsWrap + control for the keyboard. + + + + Otherwise, key release adds the key press delta to the latched keyboard +group. + + + + + + + + + +SA_LockGroup + + + + group: INT8 + + + groupAbsolute: BOOL + + + + + + If +groupAbsolute + is set, key press sets the locked keyboard group to +group +. Otherwise, key press adds +group + to the locked keyboard group. In either case, the resulting locked and +effective group is brought back into range depending on the value of the + +GroupsWrap + control for the keyboard. + + + + Key release has no effect. + + + + + + + + + +SA_MovePtr + + + + x, y: INT16 + + + noAccel: BOOL + + + absoluteX: BOOL + + + absoluteY: BOOL + + + + + + If +MouseKeys + are not enabled, this action behaves like +SA_NoAction +, otherwise this action cancels any pending repeat key timers for this key and +has the following additional effects. + + + + Key press generates a core pointer +MotionNotify + event instead of the usual +KeyPress +. If +absoluteX + is +True +, +x + specifies the new pointer X coordinate, otherwise +x + is added to the current pointer X coordinate; +absoluteY + and +y + specify the new Y coordinate in the same way. + + + + If +noAccel + is +False +, and the +MouseKeysAccel + keyboard control is enabled, key press also initiates the mouse keys timer for +this key; every time this timer expires, the cursor moves again. The distance +the cursor moves in these subsequent events is determined by the mouse keys +acceleration as described in The +MouseKeysAccel Control. + + + + Key release disables the mouse keys timer (if it was initiated by the +corresponding key press) but has no other effect and is ignored (does not +generate an event of any type). + + + + + + + + + +SA_PtrBtn + + + + button: CARD8 + + + count: CARD8 + + + useDfltBtn: BOOL + + + + + + If +MouseKeys + are not enabled, this action behaves like +SA_NoAction +. + + + + If +useDfltBtn + is set, the event is generated for the current default core button. Otherwise, +the event is generated for the button specified by +button +. + + + + If the mouse button specified for this action is logically down, the +key press and corresponding release are ignored and have no effect. + + + + Otherwise, key press causes one or more core pointer button events +instead of the usual key press. If +count + is +0 +, key press generates a single +ButtonPress + event; if +count + is greater than +0 +, key press generates +count + pairs of +ButtonPress + and +ButtonRelease + events. + + + + If +count + is +0 +, key release generates a core pointer +ButtonRelease + which matches the event generated by the corresponding key press; if count is +non-zero, key release does not cause a +ButtonRelease + event. Key release never causes a key release event. + + + + + + + + + +SA_LockPtrBtn + + + + button: BUTTON + + + noLock: BOOL + + + noUnlock: BOOL + + + useDfltBtn: BOOL + + + + + + If +MouseKeys + are not enabled, this action behaves like +SA_NoAction +. + + + + Otherwise, if the button specified by +useDfltBtn + and +button + is not locked, key press causes a +ButtonPress + instead of a key press and locks the button. If the button is already locked +or if +noLock + is +True +, key press is ignored and has no effect. + + + + If the corresponding key press was ignored, and if +noUnlock + is +False +, key release generates a +ButtonRelease + event instead of a key release event and unlocks the specified button. If the +corresponding key press locked a button, key release is ignored and has no +effect. + + + + + + + + + +SA_SetPtrDflt + + + + affect: CARD8 + + + value: CARD8 + + + dfltBtnAbs: BOOL + + + + + + If +MouseKeys + are not enabled, this action behaves like +SA_NoAction +. + + + + Otherwise, both key press and key release are ignored, but key press +changes the pointer value specified by +affect +to +value +, as follows: + + + + If +which + is +SA_AffectDfltBtn +, +value + and +dfltBtnAbs + specify the default pointer button used by the various pointer actions as +follow: If +dfltBtnAbs +is True, value specifies the button to be used, otherwise, +value + specifies the amount to be added to the current default button. In either +case, illegal button choices are wrapped back into range. + + + + + + + + + +SA_ISOLock + + + + dfltIsGroup: +False + + + + mods: MOD_DEF + + + useModMap: BOOL + + + noLock: BOOL + + + noUnlock: BOOL + + + noAffectMods: BOOL + + + noAffectGrp: BOOL + + + noAffectPtr: BOOL + + + noAffectCtrls: BOOL + + +or + + + dfltIsGroup: +True + + + + group: INT8 + + + groupAbsolute: BOOL + + + noAffectMods: BOOL + + + noAffectGrp: BOOL + + + noAffectPtr: BOOL + + + noAffectCtrls: BOOL + + + + + + If +dfltIsGroup + is +True +, key press sets the base group specified by +groupAbsolute + and +group +. Otherwise, key press sets the action modifiers in the keyboard’s base +modifiers. + + + + Key release clears the base modifiers or group that were set by the key +press; it may have additional effects if no other appropriate actions occur +simultaneously with the +SA_ISOLock + operation. + + + + If +noAffectMods + is +False +, any +SA_SetMods + or +SA_LatchMods + actions that occur simultaneously with the +ISOLock + action are treated as +SA_LockMods + instead. + + + + If +noAffectGrp + is +False +, any +SA_SetGroup + or +SA_LatchGroup + actions that occur simultaneously with this action are treated as +SA_LockGroup + actions instead. + + + + If +noAffectPtr + is +False +, +SA_PtrBtn + actions that occur simultaneously with the +SA_ISOLock + action are treated as +SA_LockPtrBtn + actions instead. + + + + If +noAffectCtrls + is +False +, any +SA_SetControls + actions that occur simultaneously with the +SA_ISOLock + action are treated as +SA_LockControls + actions instead. + + + + If no other actions were transformed by the +SA_ISOLock + action, key release locks the group or modifiers specified by the action +arguments. + + + + + + + +SA_TerminateServer + + + + + Key press terminates the server. Key release is ignored. + + + + This action is optional; servers are free to ignore it. If ignored, it +behaves like +SA_NoAction +. + + + + + + + + + +SA_SwitchScreen + + + + num: INT8 + + + switchApp: BOOL + + + screenAbs: BOOL + + + + + + If the server supports this action and multiple screens or displays +(either virtual or real), this action changes to the active screen indicated by + +num + and +screenAbs +. If +screenAbs + is +True +, num specifies the index of the new screen; otherwise, num specifies an offset +from the current screen to the new screen. + + + + If +switchApp + is +False +, it should switch to another screen on the same server. Otherwise it should +switch to another X server or application which shares the same physical +display. + + + + This action is optional; servers are free to ignore the action or any +of its flags if they do not support the requested behavior. If the action is +ignored, it behaves like +SA_NoAction +, otherwise neither key press nor release generate an event. + + + + + + + + SA_SetControls + controls: KB_BOOLCTRLMASK + + + + + +Key press enables any boolean controls that are specified in +controls + and not already enabled at the time of the key press. Key release disables any +controls that were enabled by the corresponding key press. This action can +cause +XkbControlsNotify + events. + + + + + + + + SA_LockControls + + controls: KB_BOOLCTRLMASK + + + noLock: BOOL + + + noUnlock: BOOL + + + + + + If +noLock + is +False +, key press locks and enables any controls that are specified in +controls + and not already locked at the time of the key press. + + +If +noUnlock + is +False +, key release unlocks and disables any controls that are specified in +controls + and were not enabled at the time of the corresponding key press. + + + + + + + + + +SA_ActionMessage +: + pressMsg: BOOL + + + releaseMsg: BOOL + + + genEvent: BOOL + + + message: STRING + + + + + + if +pressMsg + is +True +, key press generates an +XkbActionMessage + event which reports the keycode, event type and the contents of +message +. + + + + If +releaseMsg + is +True +, key release generates an +XkbActionMessage + event which reports the keycode, event type and contents of +message +. + + + + If +genEvent + is +True +, both press and release generate key press and key release events, regardless +of whether they also cause an +XkbActionMessage +. + + + + + + + + + +SA_RedirectKey + + + + newKey: KEYCODE + + + modsMask: KEYMASK + + + mods: KEYMASK + + + vmodsMask: CARD16 + + + vmods: CARD16 + + + + + + Key press causes a key press event for the key specified by +newKey + instead of for the actual key. The state reported in this event reports of the +current effective modifiers changed as follow: Any real modifiers specified in + +modsMask + are set to corresponding values from +mods +. Any real modifiers bound to the virtual modifiers specified in +vmodsMask + are either set or cleared, depending on the corresponding value in +vmods +. If the real and virtual modifier definitions specify conflicting values for a +single modifier, the real modifier definition has priority. + + + + Key release causes a key release event for the key specified by + +newKey +; the state field for this event consists of the effective keyboard modifiers +at the time of the release, changed as described above. + + + + The +SA_RedirectKey + action normally redirects to another key on the same device as the key or +button which caused the event, unless that device does not belong to the input +extension KEYCLASS, in which case this action causes an event on the core +keyboard device. + + + + + + + + + +SA_DeviceBtn + + + + count: CARD8 + + + button: BUTTON + + + device: CARD8 + + + + + + The +device + field specifies the ID of an extension device; the +button + field specifies the index of a button on that device. If the button specified +by this action is logically down, the key press and corresponding release are +ignored and have no effect. If the device or button specified by this action +are illegal, this action behaves like +SA_NoAction +. + + + + Otherwise, key press causes one or more input extension device button +events instead of the usual key press event. If +count + is +0 +, key press generates a single +DeviceButtonPress + event; if +count + is greater than +0 +, key press generates +count + pairs of +DeviceButtonPress + and +DeviceButtonRelease + events. + + + + If +count + is +0 +, key release generates an input extension +DeviceButtonRelease + which matches the event generated by the corresponding key press; if count is +non-zero, key release does not cause a +DeviceButtonRelease + event. Key release never causes a key release event. + + + + + + + + + +SA_LockDeviceBtn + + + + button: BUTTON + + + device: CARD8 + + + noLock: BOOL + + + noUnlock: BOOL + + + + + + The +device + field specifies the ID of an extension device; the +button + field specifies the index of a button on that device. If the device or button +specified by this action are illegal, it behaves like +SA_NoAction +. + + + + Otherwise, if the specified button is not locked and if +noLock + is +False +, key press causes an input extension +DeviceButtonPress + event instead of a key press event and locks the button. If the button is +already locked or if +noLock + is +True +, key press is ignored and has no effect. + + + + If the corresponding key press was ignored, and if +noUnlock + is +False +, key release generates an input extension +DeviceButtonRelease + event instead of a core protocol or input extension key release event and +unlocks the specified button. If the corresponding key press locked a button, +key release is ignored and has no effect. + + + + + + + + + +SA_DeviceValuator + + + + +device +: CARD8 + + + +val1What +: SA_DVOP + + + +val1 +: CARD8 + + + +val1Value +: INT8 + + + +val1Scale +: 0...7 + + + +val2What +: BOOL + + + +val2 +: CARD8 + + + +val2Value +: INT8 + + + +val2Scale +: 0...7 + + + + + + The +device + field specifies the ID of an extension device; +val1 + and +val2 + specify valuators on that device. If +device + is illegal or if neither +val1 + nor +val2 + specifies a legal valuator, this action behaves like +SA_NoAction +. + + + + If +valn + specifies a legal valuator and +valnWhat + is not +SA_IgnoreVal +, the specified value is adjusted as specified by +valnWhat +: + + + + If +valnWhat + is +SA_SetValMin +, +valn + is set to its minimum legal value. + + + + If +valnWhat + is +SA_SetValCenter +, +valn + is centered (to (max-min)/2). + + + + If +valnWhat + is +SA_SetValMax +, +valn + is set to its maximum legal value. + + + + if +valnWhat + is +SA_SetValRelative +, + + + + + is added to +valn +. + + + + if +valnWhat + is +SA_SetValAbsolute +, +valn + is set to + + + + +. + + + + Illegal values for +SA_SetValRelative + or +SA_SetValAbsolute + are clamped into range. + + + + + + + + + + +If +StickyKeys + are enabled, all +SA_SetMods + and +SA_SetGroup + actions act like +SA_LatchMods + and +SA_LatchGroup + respectively. If the +LatchToLock + AccessX option is set, either action behaves as if both the +SA_ClearLocks + and +SA_LatchToLock + flags are set. + + + + +Actions which cause an event from another key or from a button on another +device immediately generate the specified event. These actions do not consider +the behavior or actions (if any) that are bound to the key or button to which +the event is redirected. + + + + +Core events generated by server actions contain the keyboard state that was in +effect at the time the key event occurred; the reported state does not reflect +any changes in state that occur as a result of the actions bound to the key +event that caused them. + + + + +Events sent to clients that have not issued an +XkbUseExtension + request contain a compatibility state in place of the actual XKB keyboard +state. See Effects of XKB on Core +Protocol Events for a description of this compatibility mapping. + + + + + +Delivering a Key or Button Event to a Client + + +The window and client that receive core protocol and input extension key or +button events are determined using the focus policy, window hierarchy and +passive grabs as specified by the core protocol and the input extension, with +the following changes: + + + + + A passive grab triggers if the modifier state specified in the grab +matches the grab compatibility state (described in Compatibility Components of Keyboard +State). Clients can choose to use the XKB grab state instead by setting +the +GrabsUseXKBState + per-client flag. This flag affects all passive grabs that are requested by the +client which sets it but does not affect passive grabs that are set by any +other client. + + + + The state field of events which trigger a passive grab reports the XKB +or compatibility grab state in effect at the time the grab is triggered; the +state field of the corresponding release event reports the corresponding grab +state in effect when the key or button is released. + + + + If the +LookupStateWhenGrabbed + per-client flag is set, all key or button events that occur while a keyboard +or pointer grab is active contain the XKB or compatibility lookup state, +depending on the value of the +GrabsUseXKBState + per-client flag. If +LookupStateWhenGrabbed + is not set, they include the XKB or compatibility grab state, instead. + + + + Otherwise, the state field of events that do not trigger a passive grab +report is derived from the XKB effective modifiers and group, as described in +Computing A State Field from an +XKB State. + + + + If a key release event is the result of an autorepeating key that is +being held down, and the client to which the event is reported has requested +detectable autorepeat (see +Detectable Autorepeat), the event is not delivered to the client. + + + + + +The following section explains the intent of the XKB interactions with core +protocol grabs and the reason that the per-client flags are needed. + + + + +XKB Interactions With Core Protocol Grabs + + +XKB provides the separate lookup and grab states to help work around some +difficulties with the way the core protocol specifies passive grabs. +Unfortunately, many clients work around those problems differently, and the way +that XKB handles grabs and reports keyboard state can sometimes interact with +those client workarounds in unexpected and unpleasant ways. + + + + +To provide more reasonable behavior for clients that are aware of XKB without +causing problems for clients that are unaware of XKB, this extension provides +two per-client flags that specify the way that XKB and the core protocol should +interact. + + + + + The largest problems arise from the fact that an XKB state field +encodes an explicit keyboard group in bits 13-14 (as described in Computing A State Field from an XKB +State), while pre-XKB clients use one of the eight keyboard modifiers +to select an alternate keyboard group. To make existing clients behave +reasonably, XKB normally uses the compatibility grab state instead of the XKB +grab state to determine whether or not a passive grab is triggered. XKB-aware +clients can set the +GrabsUseXKBState + per-client flag to indicate that they are specifying passive grabs using an +XKB state. + + + + Some toolkits start an active grab when a passive grab is triggered, in +order to have more control over the conditions under which the grab is +terminated. Unfortunately, the fact that XKB reports a different state in +events that trigger or terminate grabs means that this grab simulation can fail +to terminate the grab under some conditions. To work around this problem, XKB +normally reports the grab state in all events whenever a grab is active. +Clients which do not use active grabs like this can set the +LookupStateWhenGrabbed + per-client flag in order to receive the same state component whether or not a +grab is active. + + +The +GrabsUseXKBState + per-client flag also applies to the state of events sent while a grab is +active. If it is set, events during a grab contain the XKB lookup or grab +state; by default, events during a grab contain the compatibility lookup or +grab state. + + + + +The state used to trigger a passive grab is controlled by the setting of the + +GrabsUseXKBState + per-client flag at the time the grab is registered. Changing this flag does +not affect existing passive grabs. + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch07.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch07.xml new file mode 100644 index 0000000000000000000000000000000000000000..b5ffc6850c396c5fa6efcafb87ae1987531f56d5 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch07.xml @@ -0,0 +1,688 @@ + +Key Event Processing in the Client + + +The XKB +client map + for a keyboard is the collection of information a client needs to interpret +key events that come from that keyboard. It contains a global list of +key types +, described in Key Types, +and an array of +key symbol map +s, each of which describes the symbols bound to one particular key and the +rules to be used to interpret those symbols. + + + +Notation and Terminology + + +XKB associates a two-dimensional array of symbols with each key. Symbols are +addressed by keyboard group (see +Keyboard State) and shift level, where level is defined as in the +ISO9995 standard: + + + + + Level + + +One of several states (normally 2 or 3) which govern which graphic +character is produced when a graphic key is actuated. In certain cases the +level may also affect function keys. + + + + + + +Note that shift level is derived from the modifier state, but not necessarily +in the same way for all keys. For example, the +Shift + modifier selects shift level 2 on most keys, but for keypad keys the modifier +bound to +Num_Lock + (i.e. the +NumLock + virtual modifier) also selects shift level 2.gray symbols on a key + + + +We use the notation G +n +L +n + to specify the position of a symbol on a key or in memory: + + + + + + + + + +The gray characters indicate symbols that are implied or expected but are not +actually engraved on the key. + + +Unfortunately, the "natural" orientation of symbols on a key and +the natural orientation in memory are reversed from one another, so keyboard +group refers to a column on the key and a row in memory. There’s no real help +for it, but we try to minimize confusion by using "group" and "level" (or +"shift level") to refer to symbols regardless of context. + + + +Determining the KeySym Associated with a Key Event + + +To look up the symbol associated with an XKB key event, we need to know the +group and shift level that correspond to the event. + + + + +Group is reported in bits 13-14 of the state field of the key event, as +described in Computing A State +Field from an XKB State. The keyboard group reported in the event might +be out-of-range for any particular key because the number of groups can vary +from key to key. The XKB description of each key contains a +group info + field which is interpreted identically to the global groups wrap control (see +Computing Effective Modifier and +Group) and which specifies the interpretation of groups that are +out-of-range for that key. + + + + +Once we have determined the group to be used for the event, we have to +determine the shift level. The description of a key includes a +key type + for each group of symbols bound to the key. Given the modifiers from the key +event, this key type yields a shift level and a set of "leftover" modifiers, as +described in Key Types +below. + + + + +Finally, we can use the effective group and the shift level returned by the +type of that group to look up a symbol in a two-dimensional array of symbols +associated with the key. + + + + +Key Types + + +Each entry of a key type’s +map + field specifies the shift level that corresponds to some XKB modifier +definition; any combination of modifiers that is not explicitly listed +somewhere in the map yields shift level one. Map entries which specify unbound +virtual modifiers (see Inactive +Modifier Definitions) are not considered; each entry contains an +automatically-updated +active + field which indicates whether or not it should be used. + + + + +Each key type includes a few fields that are derived from the contents of the +map and which report some commonly used values so they don’t have to be +constantly recalculated. The +numLevels + field contains the highest shift level reported by any of its map entries; XKB +uses +numLevels + to insure that the array of symbols bound to a key is large enough (the number +of levels reported by a key type is also referred to as its width). The + +modifiers + field reports all real modifiers considered by any of the map entries for the +type. Both +modifiers + + +and +numLevels + are updated automatically by XKB and neither can be changed explicitly. + + + + +Any modifiers specified in +modifiers + are normally +consumed + (see Transforming the KeySym +Associated with a Key Event), which means that they are not considered +during any of the later stages of event processing. For those rare occasions +that a modifier +should + be considered despite having been used to look up a symbol, key types include +an optional +preserve + field. If a +preserve + list is present, each entry corresponds to one of the key type’s map entries +and lists the modifiers that should +not + be consumed if the matching map entry is used to determine shift level. + + + + +For example, the following key type implements caps lock as defined by the core +protocol (using the second symbol bound to the key): + + + +type "ALPHABETIC" { + modifiers = Shift+Lock; + map[Shift]= Level2; + map[Lock]= Level2; + map[Shift+Lock]= Level2; +}; + + + +The problem with this kind of definition is that we could assign completely +unrelated symbols to the two shift levels, and "Caps Lock" would choose the +second symbol. Another definition for alphabetic keys uses system routines to +capitalize the keysym: + + + +type "ALPHABETIC" { + modifiers= Shift; + map[Shift]= Level2; +}; + + + +When caps lock is applied using this definition, we take the symbol from shift +level one and capitalize it using system-specific capitalization rules. If +shift and caps lock are both set, we take the symbol from shift level two and +try to capitalize it, which usually has no effect. + + + + +The following key type implements shift-cancels-caps lock behavior for +alphabetic keys: + + + +type "ALPHABETIC" { + modifiers = Shift+Lock; + map[Shift] = Level2; + preserve[Lock]= Lock; +}; + + + +Consider the four possible states that can affect alphabetic keys: no +modifiers, shift alone, caps lock alone or shift and caps lock together. The +map contains no explicit entry for +None + (no modifiers), so if no modifiers are set, any group with this type returns +the first keysym. The map entry for +Shift + reports +Level2 +, so any group with this type returns the second symbol when +Shift + is set. There is no map entry for +Lock + alone, but the type specifies that the +Lock + modifier should be preserved in this case, so +Lock + alone returns the first symbol in the group but first applies the +capitalization transformation, yielding the capital form of the symbol. In the +final case, there is no map entry for +Shift+Lock +, so it returns the first symbol in the group; there is no preserve entry, so +the +Lock + modifier is consumed and the symbol is not capitalized. + + + + + +Key Symbol Map + + +The +key symbol map + for a key contains all of the information that a client needs to process +events generated by that key. Each key symbol mapping reports: + + + + + The number of groups of symbols bound to the key ( +numGroups +). + + + + The treatment of out-of-range groups ( +groupInfo +). + + + + The index of the key type to for each +possible + group ( +kt_index[MaxKbdGroups] +). + + + + The width of the widest type associated with the key ( +groupsWidth +). + + + + The two-dimensional (numGroups +× + groupsWidth) array of symbols bound to the key. + + + + + +It is legal for a key to have zero groups, in which case it also has zero +symbols and all events from that key yield +NoSymbol +. The array of key types is of fixed width and is large enough to hold key +types for the maximum legal number of groups ( +MaxKbdGroups +, currently four); if a key has fewer than +MaxKbdGroups + groups, the extra key types are reported but ignored. The +groupsWidth + field cannot be explicitly changed; it is updated automatically whenever the +symbols or set of types bound to a key are changed. + + + + +If, when looking up a symbol, the effective keyboard group is out-of-range for +the key, the +groupInfo + field of the key symbol map specifies the rules for determining the +corresponding legal group as follows: + + + + + If the +RedirectIntoRange + flag is set, the two least significant bits of +groupInfo + specify the index of a group to which all illegal groups correspond. If the +specified group is also out of range, all illegal groups map to +Group1 +. + + + + If +ClampIntoRange + flag is set, out-of-range groups correspond to the nearest legal group. +Effective groups larger than the highest supported group are mapped to the +highest supported group; effective groups less than +Group1 + are mapped to +Group1 +. For example, a key with two groups of symbols uses +Group2 + type and symbols if the global effective group is either +Group3 + or +Group4 +. + + + + If neither flag is set, group is wrapped into range using integer +modulus. For example, a key with two groups of symbols for which groups wrap +uses +Group1 + symbols if the global effective group is +Group3 + or +Group2 + symbols if the global effective group is +Group4 +. + + + + + +The client map contains an array of key symbol mappings, with one entry for +each key between the minimum and maximum legal keycodes, inclusive. All +keycodes which fall in that range have key symbol mappings, whether or not any +key actually yields that code. + + + + + + +Transforming the KeySym Associated with a Key Event + + +Any modifiers that were not used to look up the keysym, or which were +explicitly preserved, might indicate further transformations to be performed on +the keysym or the character string that is derived from it. For example, If the + +Lock + modifier is set, the symbol and corresponding string should be capitalized +according to the locale-sensitive capitalization rules specified by the system. +If the +Control + modifier is set, the keysym is not affected, but the corresponding character +should be converted to a control character as described in Default Symbol Transformations. + + + + +This extension specifies the transformations to be applied when the +Control + or +Lock + modifiers are active but were not used to determine the keysym to be used: + + + + + + + + + + Modifier + Transformation + + + + + +Control + + Report the control character associated with the symbol. This +extension defines the control characters associated with the ASCII alphabetic +characters (both upper and lower case) and for a small set of punctuation +characters (see +Default Symbol Transformations). +Applications are +free to associate control characters with any symbols that are not specified by +this extension. + + + +Lock + + Capitalize the symbol either according to capitalization rules +appropriate to the application locale or using the capitalization rules defined +by this extension (see Default Symbol Transformations). + + + + + + +Interpretation of other modifiers is application dependent. + + +This definition of capitalization is fundamentally different from +the core protocol’s, which uses the lock modifier to select from the symbols +bound to the key. Consider key 9 in the +client map example; +the core protocol provides no way to generate the capital form +of either symbol bound to this key. XKB specifies that we first look up the +symbol and then capitalize, so XKB yields the capital form of the two symbols +when caps lock is active. + + +XKB specifies the behavior of +Lock + and +Control +, but interpretation of other modifiers is left to the application. + + + + + +Client Map Example + + +Consider a simple, if unlikely, keyboard with the following keys (gray +characters indicate symbols that are implied or expected but are not actually +engraved on the key): + + + + + + + + + +The core protocol represents this keyboard as a simple array with one row per +key and four columns (the widest key, key 10, determines the width of the +entire array). + + + + + + + + + + + + + Key + G1L1 + G1L2 + G2L1 + G2L2 + + + + + 8 + Q + NoSymbol + at + NoSymbol + + + 9 + odiaeresis + egrave + NoSymbol + NoSymbol + + + 10 + A + NoSymbol + Æ + NoSymbol + + + 11 + ssharp + question + backslash + questiondown + + + 12 + KP_End + KP_1 + NoSymbol + NoSymbol + + + 13 + Num_Lock + NoSymbol + NoSymbol + NoSymbol + + + 14 + NoSymbol + NoSymbol + NoSymbol + NoSymbol + + + 15 + Return + NoSymbol + NoSymbol + NoSymbol + + + + + + +The row to be used for a given key event is determined by keycode; the column +to be used is determined by the symbols bound to the key, the state of the + +Shift + and +Lock + Modifiers and the state of the modifiers bound to the +Num_Lock + and +Mode_switch + keys as specified by the core protocol. + + + + +The XKB description of this keyboard consists of six key symbol maps, each of +which specifies the types and symbols associated with each keyboard group for +one key: + + + + + + + + + + + + Key + Group: Type + L1 + L2 + + + + + 8 + G1: ALPHABETIC + q + Q + + + G2: ONE_LEVEL + @ + NoSymbol + + + 9 + G1: TWO_LEVEL + odiaeresis + egrave + + + 10 + G1: ALPHABETIC + a + A + + + G2: ALPHABETIC + ae + AE + + + 11 + G1: TWO_LEVEL + ssharp + question + + + G2: ONE_LEVEL + backslash + questiondown + + + 12 + G1: KEYPAD + KP_End + KP_1 + + + 13 + G1: ONE_LEVEL + Num_Lock + + + + 14 + No Groups + + + + + 15 + G1: ONE_LEVEL + Return + + + + + + + +The keycode reported in a key event determines the row to be used for that +event; the effective keyboard group determines the list of symbols and key type +to be used. The key type determines which symbol is chosen from the list. + + + + +Determining the KeySym Associated +with a Key Event details the procedure to map from a key event to a +symbol and/or a string. + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch08.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch08.xml new file mode 100644 index 0000000000000000000000000000000000000000..08524a8b10c731bad20fd2a1657df2ea937ab225 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch08.xml @@ -0,0 +1,157 @@ + +Symbolic Names + + +The core protocol does not provide any information to clients other than that +actually used to interpret events. This makes it difficult to write a client +which presents the keyboard to a user in an easy-to-understand way. Such +applications have to examine the vendor string and keycodes to determine the +type of keyboard connected to the server and have to examine keysyms and +modifier mappings to determine the effects of most modifiers (the +Shift +, +Lock + and +Control + modifiers are defined by the core protocol but no semantics are implied for +any other modifiers). + + + + +This extension provides such applications with symbolic names for most +components of the keyboard extension and a description of the physical layout +of the keyboard. + + + + +The +keycodes + name describes the range and meaning of the keycodes returned by the keyboard +in question; the +keyboard + +geometry +name describes the physical location, size and shape of the various keys on the +keyboard. As an example to distinguish between these two names, consider +function keys on PC-compatible keyboards. Function keys are sometimes above the +main keyboard and sometimes to the left of the main keyboard, but the same +keycode is used for the key that is logically +F1 + regardless of physical position. Thus, all PC-compatible keyboards might share +a keycodes name but different geometry names. + + +The keycodes name is intended to be a very general description of +the keycodes returned by a keyboard; A single keycodes name might cover +keyboards with differing numbers of keys provided that the keys that all keys +have the same semantics when present. For example, 101 and 102 key PC keyboards +might use the same name. Applications can use the keyboard geometry to +determine which subset of the named keyboard type is in use. + + +The +symbols + name identifies the symbols bound to the keys. The symbols name is a human or +application-readable description of the intended locale or usage of the +keyboard with these symbols. The +physical symbols + name describes the symbols actually engraved on the keyboard, which might be +different than the symbols currently being used. + + + + +The +types + name provides some information about the set of key types that can be +associated with the keyboard keys. The +compat + name provides some information about the rules used to bind actions to keys +changed using core protocol requests. + + + + +The +compat +, +types +, +keycodes +, +symbols + and +geometry + names typically correspond to the keyboard components from which the current +keyboard description was assembled. These components are stored individually in +the server’s database of keyboard components, described in + +The Server Database of Keyboard +Components, and can be combined to assemble a complete keyboard +description. + + + + +Each key has a four-byte symbolic name. The key name links keys with similar +functions or in similar positions on keyboards that report different scan +codes. +Key aliases + allow the keyboard layout designer to assign multiple names to a single key, +to make it easier to refer to keys using either their position +or + their "function." + + + + +For example, consider the common keyboard customizations: + + + + + Set the "key to the left of the letter a" to be a control key. + + + + Change the "caps lock" key, wherever it might be, to a control key. + + + + + +If we specify key names by position, the first customization is simple but the +second is impossible; if we specify key names by function, the second +customization is simple but the first is impossible. Using key aliases, we can +specify both function and position for "troublesome" keys, and both +customizations are straightforward. + + + + +Key aliases can be specified both in the symbolic names component and in the +keyboard geometry (see Keyboard +Geometry). Both sets of aliases are always valid, but key alias +definitions in the keyboard geometry have priority; if both symbolic names and +geometry include aliases, applications should consider the definitions from the +geometry before considering the definitions from the symbolic names section. + + + + +XKB provides symbolic names for each of the four keyboard groups, sixteen +virtual modifiers, thirty-two keyboard indicators, and up to +MaxRadioGroups + (32) radio groups. + + + + +XKB allows keyboard layout designers or editors to assign names to each key +type and to each of the levels in a key type. For example, the second position +on an alphabetic key might be called the "Caps" level while the second position +on a numeric keypad key might be called the "Num Lock" level. + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch09.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch09.xml new file mode 100644 index 0000000000000000000000000000000000000000..d5f587b75e97bea6d3a5dd76224fd73777e4eb75 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch09.xml @@ -0,0 +1,605 @@ + +Keyboard Indicators + + +Although the core X protocol supports thirty-two LEDs on a keyboard, it does +not provide any way to link the state of the LEDs and the logical state of the +keyboard. For example, most keyboards have a "Caps Lock" LED, but X does not +provide any standard way to make the LED automatically follow the logical state +of the modifier bound to the +Caps Lock + key. + + + + +The core protocol also gives no way to determine which bits in the +led_mask + field of the keyboard state map to the particular LEDs on the keyboard. For +example, X does not provide a method for a client to determine which bit to set +in the +led_mask + to turn on the "Scroll Lock" LED, or even if the keyboard has a "Scroll Lock" +LED. + + + + +Most X servers implement some kind of automatic behavior for one or more of the +keyboard LEDs, but the details of that automatic behavior are +implementation-specific and can be difficult or impossible to control. + + + + +XKB provides indicator names and programmable indicators to help solve these +problems. Using XKB, clients can determine the names of the various indicators, +determine and control the way that the individual indicators should be updated +to reflect keyboard changes, and determine which of the 32 keyboard indicators +reported by the protocol are actually present on the keyboard. Clients may also +request immediate notification of changes to the state of any subset of the +keyboard indicators, which makes it straightforward to provide an on-screen +"virtual" LED panel. + + + +Global Information About Indicators + + +XKB provides only two pieces of information about the indicators as a group. + + + + +The +physical indicators + mask reports which of the 32 logical keyboard indicators supported by the core +protocol and XKB corresponds to some actual indicator on the keyboard itself. +Because the physical indicators mask describes a physical characteristic of the +keyboard, it cannot be directly changed under program control. It is possible, +however, for the set of physical indicators to be change if a new keyboard is +attached or if a completely new keyboard description is loaded by the +XkbGetKeyboardByName + request (see Using the Server’s +Database of Keyboard Components). + + + + +The +indicator state + mask reports the current state of the 32 logical keyboard indicators. This +field and the core protocol indicator state (as reported by the +led-mask + field of the core protocol +GetKeyboardControl + request) are always identical. + + + + + +Per-Indicator Information + + +Each of the thirty-two keyboard indicators has a symbolic name, of type ATOM. +The +XkbGetNames + request reports the symbolic names for all keyboard components, including the +indicators. Use the +XkbSetNames + request to change symbolic names. Both requests are described in Querying and Changing Symbolic +Names. + + + + +Indicator Maps + + +XKB also provides an +indicator map + for each of the thirty-two keyboard indicators; an indicator map specifies: + + + + + The conditions under which the keyboard modifier state affects the +indicator. + + + + The conditions under which the keyboard group state affects the +indicator. + + + + The conditions under which the state of the boolean controls affects +the indicator. + + + + The effect (if any) of attempts to explicitly change the state of the +indicator using the core protocol +SetKeyboardControl + request. + + + + + +If +IM_NoAutomatic + is set in the +flags + field of an indicator map, that indicator never changes in response to changes +in keyboard state or controls, regardless of the values for the other fields of +the indicator map. If +IM_NoAutomatic + is not set in +flags +, the other fields of the indicator map specify the automatic changes to the +indicator in response to changes in the keyboard state or controls. + + + + +The +which_groups + and the +groups + fields of an indicator map determine how the keyboard group state affects the +corresponding indicator. The +which_groups + field controls the interpretation of +groups + and may contain any one of the following values: + + + + + + + + + + Value + Interpretation of the Groups Field + + + + + +IM_UseNone + + The +groups + field and the current keyboard group state are ignored. + + + +IM_UseBase + + If +groups + is non-zero, the indicator is lit whenever the base keyboard group is +non-zero. If +groups + is zero, the indicator is lit whenever the base keyboard group is zero. + + + +IM_UseLatched + + If +groups + is non-zero, the indicator is lit whenever the latched keyboard group is +non-zero. If +groups + is zero, the indicator is lit whenever the latched keyboard group is +zero. + + + +IM_UseLocked + + The +groups + field is interpreted as a mask. The indicator is lit when the current locked +keyboard group matches one of the bits that are set in +groups +. + + + +IM_UseEffective + + The +groups + field is interpreted as a mask. The indicator is lit when the current +effective keyboard group matches one of the bits that are set in +groups +. + + + + + + +The +which_mods + and +mods + fields of an indicator map determine how the state of the keyboard modifiers +affect the corresponding indicator. The +mods + field is an XKB modifier definition, as described in Modifier Definitions, which can +specify both real and virtual modifiers. The mods field takes effect even if +some or all of the virtual indicators specified in +mods + are unbound. + + + + +The +which_mods + field can specify one or more components of the XKB keyboard state. The +corresponding indicator is lit whenever any of the real modifiers specified in +the +mask + field of the +mods + modifier definition are also set in any of the current keyboard state +components specified by the +which_mods +. The +which_mods + field may have any combination of the following values: + + + + + + + + + + Value + Keyboard State Component To Be Considered + + + + + +IM_UseBase + + Base modifier state + + + +IM_UseLatched + + Latched modifier state + + + +IM_UseLocked + + Locked modifier state + + + +IM_UseEffective + + Effective modifier state + + + +IM_UseCompat + + Modifier compatibility state + + + + + + +The +controls + field specifies a subset of the boolean keyboard controls (see "Boolean" Controls and The +EnabledControls Control). The indicator is lit whenever any of the +boolean controls specified in +controls + are enabled. + + + + +An indicator is lit whenever any of the conditions specified by its indicator +map are met, unless overridden by the +IM_NoAutomatic + flag (described above) or an explicit indicator change (described below). + + + + +Effects of Explicit Changes on Indicators + + +If the +IM_NoExplicit + flag is set in an indicator map, attempts to change the state of the indicator +are ignored. + + + + +If both +IM_NoExplicit + and +IM_NoAutomatic + are both absent from an indicator map, requests to change the state of the +indicator are honored but might be immediately superseded by automatic changes +to the indicator state which reflect changes to keyboard state or controls. + + + + +If the +IM_LEDDrivesKB + flag is set and the +IM_NoExplicit + flag is not, the keyboard state and controls are changed to reflect the other +fields of the indicator map, as described in the remainder of this section. +Attempts to explicitly change the value of an indicator for which +IM_LEDDrivesKB + is absent or for which +IM_NoExplicit + is present do not affect keyboard state or controls. + + + + +The effect on group state of changing an explicit indicator which drives the +keyboard is determined by the value of +which_groups + and +groups +, as follows: + + + + + + + + + + + which_groups + New State + Effect on Keyboard Group State + + + + + +IM_UseNone +, or +IM_UseBase + + On or Off + No Effect + + + +IM_UseLatched + + On + The +groups + field is treated as a group mask. The keyboard group latch is changed to the +lowest numbered group specified in +groups +; if +groups + is empty, the keyboard group latch is changed to zero. + + + IM_UseLatched + Off + The +groups + field is treated as a group mask. If the indicator is explicitly extinguished, +keyboard group latch is changed to the lowest numbered group not specified in + +groups +; if +groups + is zero, the keyboard group latch is set to the index of the highest legal +keyboard group. + + + +IM_UseLocked +, or +IM_UseEffective + + On + If the +groups + mask is empty, group is not changed, otherwise the locked keyboard group is +changed to the lowest numbered group specified in +groups +. + + + +IM_UseLocked +, or +IM_UseEffective + + Off + Locked keyboard group is changed to the lowest numbered group that +is not specified in the +groups + mask, or to +Group1 + if the +groups + mask contains all keyboard groups. + + + + + + +The effect on the keyboard modifiers of changing an explicit indicator which +drives the keyboard is determined by the values that are set in of +which_mods + and +mods +, as follows: + + + + + + + + + + + Set in which_mods + New State + Effect on Keyboard Modifiers + + + + + +IM_UseBase + + On or Off + No Effect + + + +IM_UseLatched + + On + Any modifiers specified in the +mask + field of +mods + are added to the latched modifiers. + + + +IM_UseLatched + + Off + Any modifiers specified in the +mask + field of +mods + are removed from the latched modifiers. + + + +IM_UseLocked +, +IM_UseCompat +, or +IM_UseEffective + + On + Any modifiers specified in the +mask + field of +mods + are added to the locked modifiers. + + + +IM_UseLocked + + Off + Any modifiers specified in the +mask + field of +mods + are removed from the locked modifiers. + + + +IM_UseCompat +, or +IM_UseEffective + + Off + Any modifiers specified in the +mask + field of +mods + are removed from both the locked and latched modifiers. + + + + + + +Lighting an explicit indicator which drives the keyboard also enables all of +the boolean controls specified in the +controls + field of its indicator map. Explicitly extinguishing such an indicator +disables all of the boolean controls specified in +controls +. + + + + +The effects of changing an indicator which drives the keyboard are cumulative; +it is possible for a single change to affect keyboard group, modifiers and +controls simultaneously. + + + + +If an indicator for which both the +IM_LEDDrivesKB + and +IM_NoAutomatic + flags are specified is changed, the keyboard changes specified above are +applied and the indicator is changed to reflect the state that was explicitly +requested. The indicator will remain in the new state until it is explicitly +changed again. + + + + +If the +IM_NoAutomatic + flag is not set for an indicator which drives the keyboard, the changes +specified above are applied and the state of the indicator is set to the values +specified by the indicator map. Note that it is possible in this case for the +indicator to end up in a different state than the one that was explicitly +requested. For example, an indicator with +which_mods + of +IM_UseBase + and +mods + of +Shift + is not extinguished if one of the +Shift + keys is physically depressed when the request to extinguish the indicator is +processed. + + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch10.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch10.xml new file mode 100644 index 0000000000000000000000000000000000000000..74362b0a3f6b565ac039c21a250591617143a453 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch10.xml @@ -0,0 +1,174 @@ + +Keyboard Bells + + +The core protocol provides requests to control the pitch, volume and duration +of the keyboard bell and a request to explicitly sound the bell. + + + + +The X Keyboard Extension allows clients to disable the audible bell, attach a +symbolic name to a bell request or receive an event when the keyboard bell is +rung. + + + +Client Notification of Bells + + +Clients can ask to receive +XkbBellNotify + event when a bell is requested by a client or generated by the server. Bells +can be sounded due to core protocol +Bell + requests, X Input Extension +DeviceBell + requests, X Keyboard Extension +XkbBell + requests or for reasons internal to the server such as the XKB +AccessXFeedback + control. + + + + +Bell events caused by the +XkbBell + request or by the +AccessXFeedback + control include an optional window and symbolic name for the bell. If present, +the window makes it possible to provide some kind of visual indication of which +window caused the sound. The symbolic name can report some information about +the reason the bell was generated and makes it possible to generate a distinct +sound for each type of bell. + + + + + +Disabling Server Generated Bells + + +The global +AudibleBell + boolean control for a keyboard indicates whether bells sent to that device +should normally cause the server to generate a sound. Applications which +provide "sound effects" for the various named bells will typically disable the +server generation of bells to avoid burying the user in sounds. + + + + +When the +AudibleBell + control is active, all bells caused by core protocol +Bell + and X Input Extension +DeviceBell + requests cause the server to generate a sound, as do all bells generated by +the XKB +AccessXFeedback + control. Bells requested via the X +kbBell + request normally cause a server-generated sound, but clients can ask the +server not to sound the default keyboard bell. + + + + +When the +AudibleBell + control is disabled, the server generates a sound only for bells that are +generated using the +XkbBell + request and which specify forced delivery of the bell. + + + + + +Generating Named Bells + + +The +XkbBell + request allows clients to specify a symbolic name which is reported in the +bell events they cause. Bells generated by the +AccessXFeedback + control of this extension also include a symbolic name, but all kinds of +feedback cause a single event even if they sound multiple tones. + + + + +The X server is permitted to use symbolic bell names (when present) to generate +sounds other than simple tones, but it is not required to do so. + + + + +Aside from those used by the XKB +AccessXFeedback + control (see The AccessXFeedback +Control), this extension does not specify bell names or their +interpretation. + + + + + +Generating Optional Named Bells + + +Under some circumstances, some kind of quiet audio feedback is useful, but a +normal keyboard bell is not. For example, a quiet "launch effect" can be +helpful to let the user know that an application has been started, but a loud +bell would simply be annoying. + + + + +To simplify generation of these kinds of effects, the +XkbBell + request allows clients to specify "event only" bells. The X server never +generates a normal keyboard bell for "event only" bells, regardless of the +setting of the global +AudibleBell + control. + + + + +If the X server generates different sounds depending bell name, it is permitted +to generate a sound even for "event only" bells. This field is intended simply +to weed out "normal" keyboard bells. + + + + + +Forcing a Server Generated Bell + + +Occasionally, it is useful to force the server to generate a sound. For +example, a client could "filter" server bells, generating sound effects for +some but sounding the normal server bell for others. Such a client needs a way +to tell the server that the requested bell should be generated regardless of +the setting of the +AudibleBell + control. + + + + +To simplify this process, clients which call the +XkbBell + request can specify that a bell is forced. A forced bell always causes a +server generated sound and never causes a +XkbBellNotify + event. Because forced bells do not cause bell notify events, they have no +associated symbolic name or event window. + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch11.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch11.xml new file mode 100644 index 0000000000000000000000000000000000000000..39361a47c31c6af350571576e99e673f2f7fb81f --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch11.xml @@ -0,0 +1,413 @@ + + +Keyboard Geometry + + +The XKB description of a keyboard includes an optional keyboard geometry which +describes the physical appearance of the keyboard. Keyboard geometry describes +the shape, location and color of all keyboard keys or other visible keyboard +components such as indicators. The information contained in a keyboard geometry +is sufficient to allow a client program to draw an accurate two-dimensional +image of the keyboard. + + + + +The components of the keyboard geometry include the following: + + + + + A +symbolic name + to help users identify the keyboard. + + + + The +width + and +height + of the keyboard, in + + + +. For non-rectangular keyboards, the width and height describe the smallest +bounding-box that encloses the outline of the keyboard. + + + + A list of up to +MaxColors + ( +32 +) +color names +. A color name is a string whose interpretation is not specified by XKB. Other +geometry components refer to colors using their indices in this list. + + + + The + base color + of the keyboard is the predominant color on the keyboard and is used as the +default color for any components whose color is not explicitly specified. + + + + The +label color + is the color used to draw the labels on most of the keyboard keys. + + + + The +label font + is a string which describes the font used to draw labels on most keys; XKB +does not specify a format or name space for font names. + + + + A list of +geometry properties +. A geometry property associates an arbitrary string with an equally arbitrary +name. Geometry properties can be used to provide hints to programs that display +images of keyboards, but they are not interpreted by XKB. No other geometry +structures refer to geometry properties. + + + + A list of +key aliases +, as described in Symbolic +Names. + + + + A list of +shapes +; other keyboard components refer to shapes by their index in this list. A +shape consists of a name and one or more closed-polygons called +outlines +. Shapes and outlines are described in detail in Shapes and Outlines. + + + + + +Unless otherwise specified, geometry measurements are in + + + + + units. The origin (0,0) is in the top left corner of the keyboard image. Some +geometry components can be drawn rotated; all such objects rotate about their +origin in + + + + + increments. + + + + +All geometry components include a +priority +, which indicates the order in which overlapping objects should be drawn. +Objects are drawn in order from highest priority ( +0 +) to lowest ( +255 +). + + + + +The description of the actual appearance of the keyboard is subdivided into +named +sections + of related keys and +doodads +. A a +doodad + describes some visible aspect of the keyboard that is not a key. A section is +a collection of keys and doodads that are physically close together and +logically related. + + + +Shapes and Outlines + + +An outline is a list of one or more points which describes a single +closed-polygon, as follows: + + + + + A list with a single point describes a rectangle with one corner at the +origin of the shape ( +0 +, +0 +) and the opposite corner at the specified point. + + + + A list of two points describes a rectangle with one corner at the +position specified by the first point and the opposite corner at the position +specified by the second point. + + + + A list of three or more points describes an arbitrary polygon. If +necessary, the polygon is automatically closed by connecting the last point in +the list with the first. + + + + A non-zero value for the +cornerRadius + field specifies that the corners of the polygon should be drawn as circles +with the specified radius. + + + + + +All points in an outline are specified relative to the origin of the enclosing +shape. Points in an outline may have negative values for the X and Y coordinate. + + + + +One outline (usually the first) is the primary outline; a keyboard display +application can generate a simpler but still accurate keyboard image by +displaying only the primary outlines for each shape. Non-rectangular keys must +include a rectangular +approximation + as one of the outlines associated with the shape; the approximation is not +normally displayed but can be used by very simple keyboard display applications +to generate a recognizable but degraded image of the keyboard. + + + + + +Sections + + +Each section has its own coordinate system — if a section is rotated, the +coordinates of any components within the section are interpreted relative to +the edges that were on the top and left before rotation. The components that +make up a section include: + + + + + A list of +rows +. A row is a list of horizontally or vertically adjacent keys. Horizontal rows +parallel the (pre-rotation) top of the section and vertical rows parallel the +(pre-rotation) left of the section. All keys in a horizontal row share a common +top coordinate; all keys in a vertical row share a left coordinate. + + +A key description consists of a key +name +, a +shape +, a key +color +, and a +gap +. The key +name + should correspond to one of the keys named in the keyboard names description, +the +shape + specifies the appearance of the key, and the key +color + specifies the color of the key (not the label on the key). Keys are normally +drawn immediately adjacent to one another from left-to-right (or top-to-bottom) +within a row. The +gap + field specifies the distance between a key and its predecessor. + + + + An optional list of doodads; any type of doodad can be enclosed within +a section. Position and angle of rotation are relative to the origin and angle +of rotation of the sections that contain them. Priority is relative to the +other components of the section, not to the keyboard as a whole. + + + + An optional list of +overlay keys +. Each overlay key definition indicates a key that can yield multiple scan +codes and consists of a field named +under +, which specifies the primary name of the key and a field named +over +, which specifies the name for the key when the overlay keycode is selected. +The key specified in +under + must be a member of the section that contains the overlay key definition, +while the key specified in over must not. + + + + + + +Doodads + + +Doodads can be global to the keyboard or part of a section. Doodads have +symbolic names of arbitrary length. The only doodad name whose interpretation +is specified by XKB is "Edges", which describes the outline of the entire +keyboard, if present. + + + + +All doodads report their origin in fields named +left + and +top +. XKB supports five kinds of doodads: + + + + + An +indicator doodad + describes one of the physical keyboard indicators. Indicator doodads specify +the shape of the indicator, the indicator color when it is lit ( +on_color +) and the indicator color when it is dark ( +off_color +). + + + + An +outline doodad + describes some aspect of the keyboard to be drawn as one or more hollow, +closed polygons. Outline doodads specify the shape, color, and angle of +rotation about the doodad origin at which they should be drawn. + + + + A +solid doodad + describes some aspect of the keyboard to be drawn as one or more filled +polygons. Solid doodads specify the shape, color and angle of rotation about +the doodad origin at which they should be drawn. + + + + A +text doodad + describes a text label somewhere on the keyboard. Text doodads specify the +label string, the font and color to use when drawing the label, and the angle +of rotation of the doodad about its origin. + + + + A +logo doodad + is a catch-all, which describes some other visible element of the keyboard. A +logo doodad is essentially an outline doodad with an additional symbolic name +that describes the element to be drawn. + + +If a keyboard display program recognizes the symbolic name, it can draw +something appropriate within the bounding region of the shape specified in the +doodad. If the symbolic name does not describe a recognizable image, it should +draw an outline using the specified shape, outline, and angle of rotation. + + +The XKB extension does not specify the interpretation of logo names. + + + + + + +Keyboard Geometry Example + + +Consider the following example keyboard: + + + + + + + + + + +This keyboard has six sections: The left and right function sections (at the +very top) each have one horizontal row with eight keys. The left and right +alphanumeric sections (the large sections in the middle) each have six vertical +rows, with four or five keys in each row. The left and right editing sections +each have three vertical rows with one to three keys per row; the left editing +section is rotated 20° clockwise about its origin while the right editing +section is rotated 20° counterclockwise. + + + + +This keyboard has four global doodads: Three small, round indicators and a +rectangular logo. The program which generated this image did not recognize the +logo, so it displays an outline with an appropriate shape in its place. + + + + +This keyboard has seven shapes: All of the keys in the two function sections +use the "FKEY" shape. Most of the keys in the alphanumeric sections, as well as +four of the keys in each of the editing sections use the "NORM" shape. The keys +in the first column of the left alphanumeric section and the last column of the +right alphanumeric section all use the "WIDE" shape. Two keys in each of the +editing sections use the "TALL" shape. The "LED" shape describes the three +small, round indicators between the function and alphabetic sections. The +"LOGO" shape describes the keyboard logo, and the "EDGE" shape describes the +outline of the keyboard as a whole. + + + + +The keyboard itself is white, as are all of the keys except for the eight keys +that make up the home row, which use the "grey20" color. It isn’t really +visible in this picture, but the three indicators have an "on" color of "green" +and are "green30" when they are turned off. The keys in the alphanumeric and +editing sections all have a (vertical) gap of 0.5mm; the keys in the two +function sections have a (horizontal) gap of 3mm. + + + + +Many of the keys in the right alphanumeric section, and the rightmost key in +the right editing section are drawn with two names in this image. Those are +overlay keys; the bottom key name is the normal name while the overlay name is +printed at the top. For example, the right editing section has a single overlay +key entry, which specifies an +under + name of +<SPCE> + and an +over + name of +<KP0> +, which indicates that the key in question is usually the shift key, but can +behave like the +0 + key on the numeric keypad when an overlay is active. + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch12.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch12.xml new file mode 100644 index 0000000000000000000000000000000000000000..efc6d6a2ca63725247d43161eea3e8f6b42cd5c1 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch12.xml @@ -0,0 +1,1024 @@ + + +Interactions Between XKB and the Core Protocol + + +In addition to providing a number of new requests, XKB replaces or extends +existing core protocol requests and events. Some aspects of the this extension, +such as the ability to lock any key or modifier, are visible even to clients +that are unaware of the XKB extension. Other capabilities, such as control of +keysym selection on a per-key basis, are available only to XKB-aware clients. + + + + +Though they do not have access to some advanced extension capabilities, the XKB +extension includes compatibility mechanisms to ensure that non-XKB clients +behave as expected and operate at least as well with an XKB-capable server as +they do today. + + + + +There are a few significant areas in which XKB state and mapping differences +might be visible to XKB-unaware clients: + + + + + The core protocol uses a modifier to choose between two keyboard +groups, while this extension provides explicit support for multiple groups. + + + + The order of the symbols associated with any given key by XKB might not +match the ordering demanded by the core protocol. + + + + + +To minimize problems that might result from these differences, XKB includes +ways to specify the correspondence between core protocol and XKB modifiers and +symbols. + + + + +This section describes the differences between the core X protocol’s notion +of a keyboard mapping and XKB and explains the ways they can interact. + + + +Group Compatibility Map + + +As described in Keyboard +State, the current keyboard group is reported to XKB-aware clients in +bits 13-14 of the state field of many core protocol events. XKB-unaware clients +cannot interpret those bits, but they might use a keyboard modifier to +implement support for a single keyboard group. To ensure that pre-XKB clients +continue to work when XKB is present, XKB makes it possible to map an XKB state +field, which includes both keyboard group and modifier state into a pre-XKB +state field which contains only modifiers. + + + + +A keyboard description includes one +group compatibility map + per keyboard group (four in all). Each such map is a modifier definition (i.e. +specifies both real and virtual modifiers) which specifies the modifiers to be +set in the compatibility states when the corresponding keyboard group is +active. Here are a few examples to illustrate the application of the group +compatibility map: + + + + + + + + + + + + + + Group + GroupCompat Map + Effective Modifiers + State for XKB Clients + Compatibility Modifiers + State for non-XKB Clients + + + + + 1 + Group1=None + Shift + x00xxxxx00000001 + Shift + xxxxxxxx00000001 + + + 2 + Group2=Mod3 + None + x01xxxxx00000000 + Mod3 + xxxxxxxx00100000 + + + 3 + Group3=Mod2 + Shift + x10xxxxx00000001 + Shift+Mod2 + xxxxxxxx00010001 + + + 4 + Group4=None + Control + x11xxxxx00000100 + Control + xxxxxxxx00000100 + + + + + + +Note that non-XKB clients (i.e. clients that are linked with a version of the X +library that does not support XKB) cannot detect the fact that +Group4 + is active in this example because the group compatibility map for +Group4 + does not specify any modifiers. + + + + +Setting a Passive Grab for an XKB State + + +The fact that the +state + field of an event might look different when XKB is present can cause problems +with passive grabs. Existing clients specify the modifiers they wish to grab +using the rules defined by the core protocol, which use a normal modifier to +indicate keyboard group. If we used an XKB state field, the high bits of the +state field would be non-zero whenever the keyboard was in any group other than + +Group1 +, and none of the passive grabs set by clients could ever be triggered. + + + + +To avoid this behavior, the X server normally uses the compatibility grab state +to decide whether or not to activate a passive grab, even for XKB-aware +clients. The group compatibility map attempts to encode the keyboard group in +one or more modifiers of the compatibility state, so existing clients continue +to work exactly the way they do today. By default, there is no way to directly +specify a keyboard group in a +Grabbed + or +GrabButton + request, but groups can be specified indirectly by correctly adjusting the +group compatibility map. + + + + +Clients that wish to specify an XKB keyboard state, including a separate +keyboard group, can set the +GrabsUseXKBState + per-client flag which indicates that all subsequent key and button grabs from +the requesting clients are specified using an XKB state. + + + + +Whether the XKB or core state should be used to trigger a grab is determined by +the setting of the +GrabsUseXKBState + flag for the requesting client at the time the key or button is grabbed. There +is no way to change the state to be used for a grab that is already registered +or for grabs that are set by some other client. + + + + + + +Changing the Keyboard Mapping Using the Core Protocol + + +An XKB keyboard description includes a lot of information that is not present +in the core protocol description of a keyboard. Whenever a client remaps the +keyboard using core protocol requests, XKB examines the map to determine likely +default values for the components that cannot be specified using the core +protocol. + + + + +Some aspects of this automatic mapping are configurable, and make it fairly +easy to take advantage of many XKB features using existing tools like +xmodmap +, but much of the process of mapping a core keyboard description into an XKB +description is designed to preserve compatible behavior for pre-XKB clients and +cannot be redefined by the user. Clients or users that want behavior that +cannot be described using this mapping should use XKB functions directly. + + + + +Explicit Keyboard Mapping Components + + +This automatic remapping might accidentally replace definitions that were +explicitly requested by an application, so the XKB keyboard description defines +a set of +explicit components + for each key; any components that are listed in the explicit components for a +key are not changed by the automatic keyboard mapping. The explicit components +field for a key can contain any combination of the following values: + + + + + + + + + + Bit in Explicit Mask + Protects Against + + + + + ExplicitKeyType1 + Automatic determination of the key type associated with +Group1 + (see Assigning Types To Groups of +Symbols for a Key) + + + ExplicitKeyType2 + Automatic determination of the key type associated with +Group2 +(see Assigning Types To Groups of +Symbols for a Key) + + + ExplicitKeyType3 + Automatic determination of the key type associated with +Group3 +(see Assigning Types To Groups of +Symbols for a Key). + + + ExplicitKeyType4 + Automatic determination of the key type associated with +Group4 +(see Assigning Types To Groups of +Symbols for a Key). + + + ExplicitInterpret + Application of any of the fields of a symbol interpretation to the +key in question (see Assigning +Actions To Keys). + + + ExplicitAutoRepeat + Automatic determination of autorepeat status for the key, as +specified in a symbol interpretation (see Assigning Actions To +Keys). + + + ExplicitBehavior + Automatic assignment of the +KB_Lock + behavior to the key, if the +LockingKey + flag is set in a symbol interpretation (see Assigning Actions To +Keys). + + + ExplicitVModMap + Automatic determination of the virtual modifier map for the key +based on the actions assigned to the key and the symbol interpretations which +match the key (see Assigning +Actions To Keys). + + + + + + + +Assigning Symbols To Groups + + +The first step in applying the changes specified by a core protocol +ChangeKeyboardMapping + request to the XKB description of a keyboard is to determine the number of +groups that are defined for the key and the width of each group. The XKB +extension does not change key types in response to core protocol +SetModifierMapping + requests, but it does choose key actions as described in Assigning Actions To Keys. + + + + +Determining the number of symbols required for each group is straightforward. +If the key type for some group is not protected by the corresponding +ExplicitKeyType + component, that group has two symbols. If any of the explicit components for +the key include +ExplicitKeyType3 + or +ExplicitKeyType4 +, the width of the key type currently assigned to that group determines the +number of symbols required for the group in the core protocol keyboard +description. The explicit type components for +Group1 + and +Group2 + behave similarly, but for compatibility reasons the first two groups must have +at least two symbols in the core protocol symbol mapping. Even if an explicit +type assigned to either of the first two keyboard groups has fewer than two +symbols, XKB requires two symbols for it in the core keyboard description. + + + + +If the core protocol request contains fewer symbols than XKB needs, XKB adds +trailing +NoSymbol + keysyms to the request to pad it to the required length. If the core protocol +request includes more symbols than it needs, XKB truncates the list of keysyms +to the appropriate length. + + + + +Finally, XKB divides the symbols from the (possibly padded or truncated) list +of symbols specified by the core protocol request among the four keyboard +groups. In most cases, the symbols for each group are taken from the core +protocol definition in sequence (i.e. the first pair of symbols is assigned to + +Group1 +, the second pair of symbols is assigned to +Group2 +, and so forth). If either +Group1 + or +Group2 + has an explicitly defined key type with a width other than two, it gets a +little more complicated. + + + + +Assigning Symbols to Groups One and Two with Explicitly Defined Key Types + + +The server assigns the first four symbols from the expanded or truncated map to +the symbol positions G1L1 , G1L2, +G2L1 and G2L2, respectively. If the key +type assigned to Group1 reports more than two shift levels, +the fifth and following symbols contain +the extra keysyms for +Group2 +. If the key type assigned to +Group2 + reports more than two shift levels, the extra symbols follow the symbols (if +any) for +Group1 + in the core protocol list of symbols. Symbols for +Group3 + and +Group4 + are contiguous and follow the extra symbols, if any, for +Group1 + and +Group2 +. + + + + +For example, consider a key with a key type that returns three shift levels +bound to each group. The symbols bound to the core protocol are assigned in +sequence to the symbol positions: + + + +G1L1, G1L2, G2L1, G2L2, G1L3, G2L3, G3L1, G3L2, G3L3, G4L1, G4L2, and G4L3 + + + +For a key with a width one key type on group one, a width two key type on group +two and a width three key type on group three, the symbols bound to the key by +the core protocol are assigned to the following key positions: + + + +G1L1, (G1L2), G2L1, G2L2, G3L1, G3L2, G3L3 + + + +Note that the second and fourth symbols (positions +G1L2 and G2L2 +) can never be generated if the key type associated with the group yields only +one symbol. XKB accepts and ignores them in order to maintain compatibility +with the core protocol. + + + + + + +Assigning Types To Groups of Symbols for a Key + + +Once the symbols specified by +ChangeKeyboardMapping + have been assigned to the four keyboard groups for a key, the X server assigns +a key type to each group on the key from a canonical list of key types. The +first four key types in any keyboard map are reserved for these standard key +types: + + + + + + + + + + Key Type Name + Standard Definition + + + + + +ONE_LEVEL + + Describes keys that have exactly one symbol per group. Most special +or function keys (such as +Return +) are +ONE_LEVEL + keys. Any combination of modifiers yields level +0 +. Index +0 + in any key symbol map specifies key type +ONE_LEVEL +. + + + +TWO_LEVEL + + Describes non-keypad and non-alphabetic keys that have exactly two +symbols per group. By default, the +TWO_LEVEL + type yields column +1 + if the Shift modifier is set, column +0 + otherwise. Index +1 + in any key symbol map specifies key type +TWO_LEVEL +. + + + +ALPHABETIC + + Describes alphabetic keys that have exactly two symbols per group. +The default definition of the +ALPHABETIC + type provides shift-cancels-caps behavior as described in Key Types. Index +2 + in any key symbol map specifies key type +ALPHABETIC +. + + + +KEYPAD + + Describes numeric keypad keys with two symbols per group. Yields +column +1 + if either of the +Shift + modifier or the real modifier bound to the virtual modifier named +NumLock + are set. Yields column +0 + if neither or both modifiers are set. Index +3 + in any key symbol map specifies key type +KEYPAD +. + + + + + + +Users or applications may change these key types to get different default +behavior (to make shift cancel caps lock, for example) but they must always +have the specified number of symbols per group. + + + + +Before assigning key types to groups, the X server expands any alphanumeric +symbol definitions as follows: + + + + +If the second symbol of either group is +NoSymbol + and the first symbol of that group is an alphabetic keysym for which both +lowercase and uppercase forms are defined, the X server treats the key as if +the first element of the group were the lowercase form of the symbol and the +second element were the uppercase form of the symbol. For the purposes of this +expansion, XKB ignores the locale and uses the capitalization rules defined in +Default Symbol Transformations. + + + + +For each keyboard group that does not have an explicit type definition, XKB +chooses a key type from the canonical key types. If the second symbol assigned +to a group is +NoSymbol + (after alphabetic expansion), the server assigns key type +ONE_LEVEL +. If the group contains the lowercase and uppercase forms of a single glyph +(after alphanumeric expansion), the server assigns key type +ALPHABETIC +. If either of the symbols in a group is a numeric keypad keysym ( +KP_* +), the server assigns key type +KEYPAD +. Otherwise, it assigns key type +TWO_LEVEL +. + + + + +Finally, XKB determines the number of groups of symbols that are actually +defined for the key. Trailing empty groups (i.e. groups that have +NoSymbol + in all symbol positions) are ignored. + + + + +There are two last special cases for compatibility with the core protocol: If, +after trailing empty groups are excluded, all of the groups of symbols bound to +the key have identical type and symbol bindings, XKB assigns only one group to +the key. If +Group2 + is empty and either of +Group3 + or +Group4 + are not, and if neither +Group1 + nor +Group2 + have explicit key types, XKB copies the symbols and key type from +Group1 + into +Group2 +. + + + + + +Assigning Actions To Keys + + +Once symbols have been divided into groups and key types chosen for the keys +affected by a +ChangeKeyboardMapping + request, XKB examines the symbols and modifier mapping for each changed key +and assigns server actions where appropriate. XKB also automatically assigns +server actions to changed keys if the client issues a core protocol +SetModifierMapping + request, and does so optionally in response to +XkbSetMap + and +XkbSetCompatMap + requests. + + + + +The compatibility map includes a list of +symbol interpretations +, which XKB compares to each symbol associated with any changed keys in turn, +unless the +ExplicitInterp + component is set for a key. Setting the +ExplicitInterp + component prevents the application of symbol interpretations to that key. + + + + +If the modifiers and keysym specified in a symbol interpretation match the +modifier mapping and a symbol bound to a changed key that is not protected by + +ExplicitInterp +, the server applies the symbol interpretation to the symbol position. The +server considers all symbol interpretations which specify an explicit keysym +before considering any that do not. The server uses the first interpretation +which matches the given combination of keysym and modifier mapping; other +matching interpretations are ignored. + + + + +XKB uses four of the fields of a symbol interpretation to decide if it matches +one of the symbols bound to some changed key: + + + + + The +symbol + field is a keysym which matches if it has the value +NoSymbol + or is identical to the symbol in question. + + + + The modifiers specified in the +mods + field are compared to the modifiers affected by the key in question as +indicated by +match +. + + + + The +match + field can specify any of the comparisons: +NoneOf +, +AnyOfOrNone +, +AnyOf +, +AllOf + or +Exactly +. + + + + The +levelOneOnly + setting, indicates that the interpretation in question should only use the +modifiers bound to this key by the modifier mapping if the symbol that matches +in level one of its group. Otherwise, if the symbol being considered is not in +shift level one of its group, the server behaves as if the modifier map for the +key were empty. Note that it is still possible for such an interpretation to +apply to a symbol in a shift level other than one if it matches a key without +modifiers; the +levelOneOnly + flag only controls the way that matches are determined and that the key +modifiers are applied when an interpretation does match. + + + + + +Applying a symbol interpretation can affect several aspects of the XKB +definition of the key symbol mapping to which it is applied: + + + + + The +action + specified in the symbol interpretation is bound to the symbol position; any +key event which yields that symbol will also activate the new action. + + + + If the matching symbol is in position G1L1, the autorepeat behavior of +the key is set from the +autorepeat + field of the symbol interpretation. The +ExplicitAutoRepeat + component protects the autorepeat status of a key from symbol interpretation +initiated changes. + + + + If the symbol interpretation specifies an associated virtual modifier, +that virtual modifier is added to the virtual modifier map for the key. The + +ExplicitVModMap + component guards the virtual modifier map for a key from automatic changes. If +the +levelOneOnly + flag is set for the interpretation, and the symbol in question is not in +position G1L1, the virtual modifier map is not updated. + + + + If the matching symbol is in position G1L1, and the +locking key + field is set in the symbol interpretation, the behavior of the key is changed +to +KB_Lock + (see Key Behavior). The + +ExplicitBehavior + component prevents this change. + + + + + +If no interpretations match a given symbol or key, the server uses: +SA_NoAction +, autorepeat enabled, non-locking key. with no virtual modifiers. + + + + +If all of the actions computed for a key are +SA_NoAction +, the server assigns an length zero list of actions to the key. + + + + +If the core protocol modifier mapping is changed, the server regenerates +actions for the affected keys. The +XkbSetMap + and +XkbSetCompatMap + requests can also cause actions for some or all keyboard keys to be recomputed. + + + + + +Updating Everything Else + + +Changes to the symbols or modifier mapping can affect the bindings of virtual +modifiers. If any virtual modifiers change, XKB updates all of its data +structures to reflect the change. Applying virtual modifier changes to the +keyboard mapping night result in changes to types, the group compatibility map, +indicator maps, internal modifiers or ignore locks modifiers. + + + + + + +Effects of XKB on Core Protocol Events + + +After applying server actions which modify the base, latched or locked modifier +or group state of the keyboard, the X server recomputes the effective group and +state. Several components of the keyboard state are reported to XKB-aware +clients depending on context (see +Keyboard State for a detailed description of each of the keyboard state +components): + + + + + The effective modifier state is reported in +XkbStateNotify + events and in response to +XkbGetState + requests. + + + + The symbol lookup state is reported to XKB-aware clients in the state +field of core protocol and input extension key press and release events that do +not activate passive grabs. Unless the +LookupStateWhenGrabbed + per-client flag is set, the lookup state is only reported in these events when +no grabs are active. + + + + The grab state is reported to XKB-aware clients in the state field of +all core protocol events that report keyboard state, except +KeyPress + and +KeyRelease + events that do not activate passive grabs. + + + + The effective group is the sum of the base, latched and locked keyboard +groups. An out of range effective group is wrapped or truncated into range +according to the setting of the +groupsWrap + flag for the keyboard. + + + + + +The server reports compatibility states to any clients that have not issued a +successful +XkbUseExtension + request. The server computes the compatibility symbol lookup state and the +compatibility effective grab state by applying the compatibility modifier map +to the corresponding computed XKB states. + + + + +The compatibility symbol lookup state is reported to non-XKB clients whenever +an XKB-aware client would receive the XKB lookup state. The compatibility grab +state is reported to XKB-unaware clients whenever an XKB client would receive +the XKB grab state. + + + + +If the +GrabsUseXKBState + per-client option is not set, even XKB-aware clients receive the compatibility +grab state in events that trigger or terminate passive grabs. If this flag is +not set, XKB clients also receive the compatibility grab or lookup state +whenever any keyboard grab is active. + + + + +If the +LookupStateWhenGrabbed + per-client option is set, clients receive either the XKB or compatibility +lookup state when the keyboard is grabbed, otherwise they receive either the +XKB or compatibility grab state. All non-XKB clients receive the compatibility +form of the appropriate state component; the form that is sent to an XKB-aware +client depends on the setting of the +GrabsUseXKBState + option for that client. + + + + + +Effect of XKB on Core Protocol Requests + + +Whenever a client updates the keyboard mapping using a core protocol request, +the server saves the requested core protocol keyboard mapping and reports it to +any clients that issue +GetKeyboardMapping + or +GetModifierMapping + requests. Whenever a client updates the keyboard mapping using XKB requests, +the server discards the affected portion of the stored core keyboard +description and regenerates it based on the XKB description of the keyboard. + + + + +The symbols associated with the XKB keyboard description appear in the order: + + + +G1L1 G1L2 G2L1 G2L2 G1L3-n G2L3-n G3L* G4L* + + + +If the type associated with +Group1 + is width one, the second symbol is +NoSymbol +; if the type associated with +Group2 + is width one, the fourth symbol is +NoSymbol +. + + + + +If a key has only one group but the keyboard has several, the symbols for + +Group1 + are repeated for each group. For example, given a keyboard with three groups +and a key with one group that contains the symbols { +a A + }, the core protocol description would contain the six symbols: { +a + +A + +a + +A + +a + +A + }. As a slightly more complicated example, an XKB key which had a single width +three group with the symbols { +a + +b + +c + } would show up in the generated core protocol keyboard description with the +symbols { +a + +b + +a + +b + +c + +c + +a + +b + +c + } for a keyboard with three groups. + + + + +The generated modifier mapping for a key contains all of the modifiers affected +by all of the actions associated with the key plus all of the modifiers +associated with any virtual modifiers bound to the key by the virtual modifier +mapping. If any of the actions associated with a key affect any component of +the keyboard group, any modifiers specified in any entry of the group +compatibility map (see Group +Compatibility Map) are reported in the modifier mask. The +SA_ISOLock + action can theoretically affect any modifier, but the modifier map of an + +SA_ISOLock + key contains only the modifiers or group state that it sets by default. + + + + +The server notifies interested clients of keyboard map changes in one of two +ways. It sends +XkbMapNotify + to clients that have explicitly selected them and core protocol +MappingNotify + events to clients that have not. Once a client requests +XkbMapNotify + events, the server stops sending it +MappingNotify + events to inform it of keyboard changes. + + + + + +Sending Events to Clients + + +XKB normally assumes that events sent to clients using the core protocol + +SendEvent + request contain a core protocol state, if applicable. If the client which will +receive the event is not XKB-capable, XKB attempts to convert the core state to +an XKB state as follows: if any of the modifiers bound to +Group2 + in the group compatibility map are set in the event state, XKB clears them in +the resulting event but sets the effective group in the event state to + +Group2 +. + + + + +If the +PCF_SendEventUsesXKBState + per-client flag is set at the time of the SendEvent request, XKB instead +assumes that the event reported in the event is an XKB state. If the receiving +client is not XKB-aware, the extension converts the XKB state (which contains +the effective state in bits 13-14) to a core state by applying the group +compatibility map just as it would for actual key events. + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch13.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch13.xml new file mode 100644 index 0000000000000000000000000000000000000000..25fa96dd95a8a223bcaa929d655808765bee9b8e --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch13.xml @@ -0,0 +1,442 @@ + +The Server Database of Keyboard Components + + +The X server maintains a database of keyboard components and common keyboard +mappings. This database contains five kinds of components; when combined, these +five components provide a complete description of a keyboard and its behavior. + + + + +The X Keyboard Extension provides requests to list the contents of this +database, to assemble and complete keyboard descriptions by merging the current +keyboard description with the contents of this database, or to replace the +current keyboard description with a complete keyboard description assembled as +described below. + + + +Component Names + + +Component and keymap names have the form " +class +( +member +)" where +class + describes a subset of the available components for a particular type and the +optional +member + identifies a specific component from that subset. For example, the name +"atlantis(acme)" might specify the symbols used for the atlantis national +keyboard layout by the vendor "acme." Each class has an optional +default + member — references which specify a class but not a member refer to the +default member of the class, if one exists. + + + + +The +class + and +member + names are both specified using characters from the Latin-1 character set. XKB +implementations must accept all alphanumeric characters, minus (‘-’) and +underscore (‘_’) in class or member names, and must not accept parentheses, +plus, vertical bar, percent sign, asterisk, question mark or white space. The +use of other characters is implementation-dependent. + + + + + +Partial Components and Combining Multiple Components + + +Some of the elements in the server database contain describe only a piece of +the corresponding keyboard component. These +partial + components should be combined with other components of the same type to be +useful. + + + + +For example, a partial symbols map might describe the differences between a +common ASCII keyboard and some national layout. Such a partial map is not +useful on its own because it does not include those symbols that are the same +on both the ASCII and national layouts (such as function keys). On the other +hand, this partial map can configure +any + ASCII keyboard to use a national layout. + + + + +Two components can be combined in two ways: + + + + + If the second component +overrides + the first, any definitions that are present in both components are taken from +the second. + + + + If the second component +augments + the first, any definitions that are present in both components are taken from +the first. + + + + + +Applications can use a +component expression + to combine multiple components of some time into a complete description of +some aspect of the keyboard. A component expression is a string which lists the +components to be combined separated by operators which specify the rules for +combining them. A complete description is assembled from the listed components, +left to right, as follows: + + + + + If the new elements are being merged with an existing map, the special +component name ‘%’ refers to the unmodified value of the map. + + + + The ‘+’ operator specifies that the next specified component should +override the current assembled definition. + + + + The ‘|’ operator specifies that the next specified component should +augment the currently assembled definition. + + + + If the new elements are being merged with an existing map and the +component expression begins with an operator, a leading ‘%’ is implied. + + + + If any unknown or illegal characters appear anywhere in the string, the +entire expression is invalid and is ignored. + + + + + +For example, the component expression "+de" specifies that the default element +of the "de" map should be applied to the current keyboard mapping, overriding +any existing definitions. + + + + +A slightly more involved example: the expression +"acme(ascii)+de(basic)|iso9995-3" constructs a German (de) mapping for the +ASCII keyboard supplied by the "acme" vendor. The new definition begins with +the symbols for the default ASCII keyboard for Acme, overrides them with any +keys that are defined for the default German keyboard layout and then applies +the definitions from the iso9995-3 to any undefined keys or groups of keys +(part three of the iso9995 standard defines a common set of bindings for the +secondary group, but allows national layouts to override those definitions +where necessary). + + + + + +Component Hints + + +Each component has a set of flags that provide some additional hints about that +component. XKB provides these hints for clients that present the keyboard +database to users and specifies their interpretation only loosely. Clients can +use these hints to constrain the list of components or to control the way that +components are presented to the user. + + + + +Hints for a component are reported with its name. The least significant byte of +the hints field has the same meaning for all five types of keyboard components, +and can contain any combination of the following values: + + + + + + + + + + Flag + Meaning + + + + + +LC_Hidden + + Indicates a component that should not normally be presented to the +user. + + + +LC_Default + + Indicates a component that is the default member of its +class. + + + +LC_Partial + + Indicates a partial component. + + + + + + +The interpretation of the most significant byte of the hints field is dependent +on the type of component. The hints defined for each kind of component are +listed in the section below that describes that kind of component. + + + + + +Keyboard Components + + +The five types of components stored in the server database of keyboard +components correspond to the +symbols +, +geometry +, +keycodes +, +compat + and +types + symbolic names associated with a keyboard. + + + + +The Keycodes Component + + +The +keycodes + component of a keyboard mapping specifies the range and interpretation of the +raw keycodes reported by the device. It sets the +keycodes + symbolic name, the minimum and maximum legal keycodes for the keyboard, and +the symbolic name for each key. The keycodes component might also contain +aliases for some keys, symbolic names for some indicators, and a description of +which indicators are physically present. + + + + +The special keycodes component named "computed" indicates that XKB should +assign unused keycodes to any unknown keys referenced by name by any of the +other components. The computed keycodes component is useful primarily when +browsing keymaps because it makes it possible to use the symbols and geometry +components without having to find a set of keycodes that includes keycode +definitions for all of the keys listed in the two components. + + + + +XKB defines no hints that are specific to the keycodes component. + + + + +The Types Component + + +The +types + component of a keyboard mapping specifies the key types that can be associated +with the various keyboard keys. It affects the +types + symbolic name and the list of types associated with the keyboard (see +Key Types). The types component +of a keyboard mapping can also optionally contain real modifier bindings and +symbolic names for one or more virtual modifiers. + + + + +The special types component named "canonical" always contains the types and +definitions listed in Canonical Key Types of this document. + + + + +XKB defines no hints that are specific to the types component. + + + + + +The Compatibility Map Component + + +The +compatibility map + component of a keyboard mapping primarily specifies the rules used to assign +actions to keysyms. It affects the +compat + symbolic name, the symbol compatibility map and the group compatibility map. +The compat component might also specify maps for some indicators and the real +modifier bindings and symbolic names of some virtual modifiers. + + + + +XKB defines no hints that are specific to the compatibility map component. + + + + + +The Symbols Component + + +The +symbols + component of a keyboard mapping specifies primarily the symbols bound to each +keyboard key. It affects the +symbols + symbolic name, a key symbol mapping for each key, they keyboard modifier +mapping, and the symbolic names for the keyboard symbol groups. Optionally, the + +symbols + component can contain explicit actions and behaviors for some keys, or the +real modifier bindings and symbolic names for some virtual modifiers. + + + + +XKB defines the following additional hints for the symbols component: + + + + + + + + + + Flag + Meaning + + + + + +LC_AlphanumericKeys + + Indicates a symbol component that contains bindings primarily for an +alphanumeric section of the keyboard. + + + +LC_ModifierKeys + + Indicates a symbol component that contains bindings primarily for +modifier keys. + + + +LC_KeypadKeys + + Indicates a symbol component that contains bindings primarily for +numeric keypad keys. + + + LC_FunctionKeys + Indicates a symbol component that contains bindings primarily for +function keys. + + + LC_AlternateGroup + Indicates a symbol component that contains bindings for an alternate +keyboard group. + + + + + + +These hints only apply to partial symbols components; full symbols components +are assumed to specify all of the pieces listed above. + + +The alphanumeric, modifier, keypad or function keys hints should +describe the primary intent of the component designer and should not simply an +exhaustive list of the kinds of keys that are affected. For example, national +keyboard layouts affect primarily alphanumeric keys, but many affect a few +modifier keys too; such mappings should set only +LC_AlphanumericKeys + hint. In general, symbol components should set only one of those four flags +(though +LC_AlternateGroup + may be combined with any of the other flags). + + + +The Geometry Component + + +The +geometry + component of a keyboard mapping specifies primarily the geometry of the +keyboard. It contains the geometry symbolic name and the keyboard geometry +description. The geometry component might also contain aliases for some keys or +symbolic names for some indicators and might affect the set of indicators that +are physically present. Key aliases defined in the geometry component of a +keyboard mapping override those defined in the keycodes component. + + + + +XKB defines no hints that are specific to the geometry component. + + + + + + +Complete Keymaps + + +The X server also reports a set of fully specified keymaps. The keymaps +specified in this list are usually assembled from the components stored in the +rest of the database and typically represent the most commonly used keymaps for +a particular system. + + + + +XKB defines no hints that are specific to complete keymaps. + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch14.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch14.xml new file mode 100644 index 0000000000000000000000000000000000000000..6a2f45a0bf24cd517277c2997c8317b013647f08 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch14.xml @@ -0,0 +1,94 @@ + +Replacing the Keyboard "On-the-Fly" + + +XKB supports the +XkbNewKeyboardNotify + event, which reports a change in keyboard geometry or the range of supported +keycodes. The server can generate an +XkbNewKeyboardNotify + event when it detects a new keyboard, or in response to an +XkbGetKeyboardByName + request (see Using the Server’s +Database of Keyboard Components) which loads a new keyboard description. + + + + +When a client opens a connection to the X server, the server reports the +minimum and maximum keycodes. If the range of supported keycodes is changed, +XKB keeps track of the minimum and maximum keycodes that were reported to each +client and filters out any events that fall outside of that range. Note that +these events are simply ignored; they are not delivered to some other client. + + + + +When the server sends an +XkbNewKeyboardNotify + event to a client to inform it of the new keycode range, XKB resets the stored +range of legal keycodes to the keycode range reported in the event. Non-XKB +clients and XKB-aware clients that do not request +XkbNewKeyboardNotify + events never receive events from keys that fall outside of the legal range +that XKB maintains for that client. + + + + +When a client requests +XkbNewKeyboardNotify + events, the server compares the range of keycodes for the current keyboard to +the range of keycodes that are valid for the client. If they are not the same, +the server immediately sends that client an +XkbNewKeyboardNotify + event. Even if the "new" keyboard is not new to the server, it is new to this +particular client. + + + + +In addition to filtering out-of-range key events, XKB: + + + + + Adjusts core protocol +MappingNotify + events to refer only to keys that match the stored legal range. + + + + Reports keyboard mappings for keys that match the stored legal range to +clients that issue a core protocol +GetKeyboardMapping + request. + + + + Reports modifier mappings only for keys that match the stored legal +range to clients that issue a core protocol +GetModifierMapping + request. + + + + Restricts the core protocol +ChangeKeyboardMapping + and +SetModifierMapping + requests to keys that fall inside the stored legal range. + + + + + +In short, XKB does everything possible to hide the fact that the range of legal +keycodes has changed from clients non-XKB clients, which cannot be expected to +deal with it. The corresponding XKB events and requests do +not + pay attention to the legal keycode range in the same way because XKB makes it +possible for clients to track changes to the keycode range for a device and +respond to them. + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch15.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch15.xml new file mode 100644 index 0000000000000000000000000000000000000000..d3e47d0f75742dc6de6a0c47e578345391e488cc --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch15.xml @@ -0,0 +1,233 @@ + +Interactions Between XKB and the X Input Extension + + +All XKB interactions with the input extension are optional; implementors are +free to restrict the effects of the X Keyboard Extension to the core keyboard +device. The +XkbGetExtensionDeviceInfo + request reports whether or not an XKB implementation supports a particular +capability for input extension devices. + + + + +XKB recognizes the following interactions with the X Input Extension: + + + + + + + + + + Name + Capability + + + + + XI_Keyboards + If set, applications can use all XKB requests and events with +extension keyboards. + + + XI_ButtonActions + If set, clients can assign key actions to buttons, even on input +extension devices that are not keyboards. + + + XI_IndicatorNames + If set, clients can assign names to indicators on non-keyboard +extension devices. + + + XI_IndicatorMaps + If set, clients can assign indicator maps to indicators on +non-keyboard extension devices. + + + XI_IndicatorState + If set, clients can change the state of device indicators using the + +XkbSetExtensionDeviceInfo + request. + + + + + + +Attempts to use an XKB feature with an extension device fail with a +Keyboard + error if the server does not support the +XkbXI_Keyboards + optional feature. If a capability particular capability other than +XkbXI_Keyboards + is not supported, attempts to use it fail silently. The replies for most +requests that can use one of the other optional features include a field to +report whether or not the request was successful, but such requests do not +cause an error condition. + + + + +Clients can also request an +XkbExtensionDeviceNotify + event. This event notifies interested clients of changes to any of the +supported XKB features for extension devices, or if a request from the client +that is receiving the event attempted to use an unsupported feature. + + + +Using XKB Functions with Input Extension Keyboards + + +All XKB requests and events include a device identifier which can refer to an +input extension +KeyClass + device, if the implementation allows XKB to control extension devices. If the +implementation does not support XKB manipulation of extension devices, the +device identifier is ignored but it must be either +0 + or +UseCoreKbd +. + + + + +Implementations which do not support the use of XKB functions with extension +keyboards must not set the +XkbXI_Keyboards + flag. Attempts to use XKB features on an extension keyboard with an +implementation that does not support this feature yield a +Keyboard + error. + + + + + +Pointer and Device Button Actions + + +The XKB extension optionally allows clients to assign any key action (see +Key Actions) to core +pointer or input extension device buttons. This makes it possible to control +the keyboard or generate keyboard key events from extension devices or from the +core pointer. + + + + +XKB implementations are required to support actions for the buttons of the core +pointer device, but support for actions on extension devices is optional. +Implementations which do not support button actions for extension devices must +not set the +XkbXI_ButtonActions + flag. + + + + +Attempts to query or assign button actions with an implementation that does not +support this feature report failure in the request reply and might cause the +server to send an +XkbExtensionDeviceNotify + event to the client which issued the request that failed. Such requests never +cause an error condition. + + + + + +Indicator Maps for Extension Devices + + +The XKB extension allows applications to assign indicator maps to the +indicators of non-keyboard extension devices. If supported, maps can be +assigned to all extension device indicators, whether they are part of a +keyboard feedback or part of an indicator feedback. + + + + +Implementations which do not support indicator maps for extension devices must +not set the +XkbXI_IndicatorMaps + flag. + + + + +Attempts to query or assign indicator maps with an implementation that does not +support this feature report failure in the request reply and might cause the +server to send an +XkbExtensionDeviceNotify + event to the client which issued the request that failed. Such requests never +cause an error condition. + + + + +If this feature is supported, the maps for the default indicators on the core +keyboard device are visible both as extension indicators and as the core +indicators. Changes made with +XkbSetDeviceInfo + are visible via +XkbGetIndicatorMap + and changes made with +XkbSetIndicatorMap + are visible via +XkbGetDeviceInfo +. + + + + + +Indicator Names for Extension Devices + + +The XKB extension allows applications to assign symbolic names to the +indicators of non-keyboard extension devices. If supported, symbolic names can +be assigned to all extension device indicators, whether they are part of a +keyboard feedback or part of an indicator feedback. + + + + +Implementations which do not support indicator maps for extension devices must +not set the +XkbXI_IndicatorMaps + flag. + + + + +Attempts to query or assign indicator names with an implementation that does +not support this feature report failure in the request reply and might cause +the server to send an +XkbExtensionDeviceNotify + event to the client which issued the request that failed. Such requests never +cause an error condition. + + + + +If this feature is supported, the names for the default indicators on the core +keyboard device are visible both as extension indicators and as the core +indicators. Changes made with +XkbSetDeviceInfo + are visible via +XkbGetNames + and changes made with +XkbSetNames + are visible via +XkbGetDeviceInfo +. + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch16.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch16.xml new file mode 100644 index 0000000000000000000000000000000000000000..6044843c46cebdd1f39461c9aaf31246d28df60a --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/ch16.xml @@ -0,0 +1,9427 @@ + + +XKB Protocol Requests + + +This document uses the syntactic conventions and common types defined by the +specification of the core X protocol with a number of additions, which are +detailed below. + + + +Errors + + +If a client attempts to use any other XKB request except +XkbUseExtension + before the extension is properly initialized, XKB reports an +Access + error and ignores the request. XKB is properly initialized once +XkbUseExtension + reports that the client has asked for a supported or compatible version of the +extension. + + + + +Keyboard Errors + + +In addition to all of the errors defined by the core protocol, the X Keyboard +Extension defines a single error, +Keyboard +, which indicates that some request specified an illegal device identifier or +an extension device that is not a member of an appropriate. Unless otherwise +noted, any request with an argument of type KB_DEVICESPEC can cause +Keyboard + errors if an illegal or inappropriate device is specified. + + + + +When the extension reports a Keyboard error, the most significant byte of the + +resource_id + is a further refinement of the error cause, as defined in the table below. The +least significant byte contains the device, class, or feedback id as indicated: + + + + + + + + + + + + high-order byte + value + meaning + low-order byte + + + + + XkbErr_BadDevice + 0xff + device not found + device id + + + XkbErr_BadClass + 0xfe + device found, but is the wrong class + class id + + + XkbErr_BadId + 0xfd + device found, class ok, but device does not have a feedback with the +indicated id + feedback id + + + + + + + +Side-Effects of Errors + + +With the exception of +Alloc + or +Implementation + errors, which might result in an inconsistent internal state, no XKB request +that reports an error condition has any effect. Unless otherwise stated, +requests which update some aspect of the keyboard description will not apply +only part of a request — if part of a request fails, the whole thing is +ignored. + + + + + + +Common Types + + +The following types are used in the request and event definitions in subsequent +sections: + + + + + + + + + + Name + Value + + + + + LISTofITEMs + The type LISTofITEMs is special. It is similar to the +LISTofVALUE defined by the core protocol, but the elements of a LISTofITEMs are +not necessarily all the same size. The use of a BITMASK to indicate which +members are present is optional for a LISTofITEMs — it is possible for the +set of elements to be derived from one or more fields of the request. + + + KB_DEVICESPEC + 8 bit unsigned integer, +UseCoreKbd, or UseCorePtr + + + + KB_LEDCLASSSPEC + { +KbdFeedbackClass +, +LedFeedbackClass +, +DfltXIClass +, +AllXIClasses +, +XINone + } + + + KB_BELLCLASSSPEC + { +KbdFeedbackClass +, +BellFeedbackClass +, +DfltXIClass +, +AllXIClasses + } + + + KB_IDSPEC + 8 bit unsigned integer or +DfltXIId + + + + KB_VMODMASK + CARD16, each bit corresponds to a virtual modifier + + + KB_GROUPMASK + { +Group1 +, +Group2 +, +Group3 +, +Group4 + } + + + KB_GROUPSWRAP + { +WrapIntoRange +, +ClampIntoRange +, +RedirectIntoRange + } + + + KB_GROUPINFO + { groupsWrap: KB_GROUPSWRAP +redirectGroup: 1…4, +numGroups: 1…4 } + + + KB_NKNDETAILSMASK + { +NKN_Keycodes +, NKN_Geometry, +NKN_DeviceID + } + + + KB_STATEMASK + KEYBUTMASK or KB_GROUPMASK + + + KB_STATEPARTMASK + { +ModifierState +, +ModifierBase +, +ModifierLatch +, +ModifierLock +, +GroupState +, +GroupBase +, +GroupLatch +, +GroupLock +, +CompatState +, +GrabMods +, +CompatGrabMods +, +LookupMods +, +CompatLookupMods +, +PointerButtons + } + + + KB_BOOLCTRLMASK + { +RepeatKeys +, +SlowKeys +, +BounceKeys +, +StickyKeys +, +MouseKeys +, +MouseKeysAccel +, +AccessXKeys +, +AccessXTimeout +, +AccessXFeedback +, +AudibleBell +, +Overlay1 +, +Overlay2 +, +IgnoreGroupLock + } + + + KB_CONTROLSMASK + { +GroupsWrap, InternalMods +, +IgnoreLockMods +, +PerKeyRepeat +, +ControlsEnabled + } or KB_BOOLCTRLMASK + + + KB_MAPPARTMASK + { +KeyTypes +, +KeySyms +, +ModifierMap +, +ExplicitComponents +, +KeyActions +, +KeyBehaviors +, +VirtualMods +, +VirtualModMap +} + + + KB_CMDETAILMASK + { +SymInterp +, +GroupCompat + } + + + KB_NAMEDETAILMASK + { +KeycodesName +, +GeometryName +, +SymbolsName +, + +PhysSymbolsName +, +TypesName +, +CompatName +, +KeyTypeNames +, +KTLevelNames +, +IndicatorNames +, +KeyNames +, +KeyAliases +, +VirtualModNames +, +GroupNames +, +RGNames +} + + + KB_AXNDETAILMASK + { +AXN_SKPress +, +AXN_SKAccept +, +AXN_SKReject +, +AXN_SKRelease, AXN_BKAccept, AXN_BKReject, AXN_AXKWarning +} + + + KB_AXSKOPTSMASK + { +AX_TwoKeys +, +AX_LatchToLock + } + + + KB_AXFBOPTSMASK + { +AX_SKPressFB +, +AX_SKAcceptFB +, +AX_FeatureFB +, +AX_SlowWarnFB +, +AX_IndicatorFB +, +AX_StickyKeysFB +, +AX_SKReleaseFB +, + AX_SKRejectFB +, +AX_BKRejectFB +, +AX_DumbBellFB + } + + + KB_AXOPTIONSMASK + KB_AXFBOPTSMASK or KB_AXSKOPTSMASK + + + KB_GBNDETAILMASK + { +GBN_Types +, +GBN_CompatMap +, +GBN_ClientSymbols +, +GBN_ServerSymbols +, +GBN_IndicatorMap +, +GBN_KeyNames +, +GBN_Geometry +, +GBN_OtherNames + } + + + KB_BELLDETAILMASK + { +XkbAllBellNotifyEvents + } + + + KB_MSGDETAILMASK + { +XkbAllActionMessages + } + + + KB_EVENTTYPE + { +XkbNewKeyboardNotify +, +XkbMapNotify +, +XkbStateNotify +, +XkbControlsNotify +, +XkbIndicatorStateNotify +, +XkbIndicatorMapNotify +, +XkbNamesNotify +, +XkbCompatMapNotify +, +XkbBellNotify +, +XkbActionMessage +, +XkbAccessXNotify +, +XkbExtensionDeviceNotify + } + + + KB_ACTION + [ type: CARD8 +data: LISTofCARD8 ] + + + KB_BEHAVIOR + [ type: CARD8, data: CARD 8 ] + + + KB_MODDEF + [ mask: KEYMASK, +mods: KEYMASK, +vmods: KB_VMODMASK ] + + + KB_KTMAPENTRY + [ active: BOOL, +level: CARD8, +mods: KB_MODDEF ] + + + KB_KTSETMAPENTRY + [ level: CARD8, +mods: KB_MODDEF ] + + + KB_KEYTYPE + [ mods: KB_MODDEF, +numLevels: CARD8, +map: LISTofKB_KTMAPENTRY, +preserve: LISTofKB_MODDEF ] + + + KB_SETKEYTYPE + [ realMods: KEYMASK, +vmods: CARD16, +numLevels: CARD8, +map: LISTofKB_KTSETMAPENTRY, +preserve: LISTofKB_MODDEF ] + + + KB_KEYSYMMAP + [ ktIndex: LISTofCARD8, width: CARD8 + numGroups: 0…4, + groupsWrap: KB_GROUPSWRAP, + redirectGroup: 0…3, + syms: LISTofKEYSYM ] + + + KB_KEYVMODMAP + [ key: KEYCODE, vmods: CARD16 ] + + + KB_KEYMODMAP + [ key: KEYCODE, mods: KEYMASK ] + + + KB_EXPLICITMASK + { +ExplicitKeyType1 +, +ExplicitKeyType2 +, +ExplicitKeyType3 +, +ExplicitKeyType4 +, +ExplicitInterpret +, +ExplicitAutoRepeat +, +ExplicitBehavior +, +ExplicitVModMap + } + + + KB_INDICATORMASK + CARD32, each bit corresponds to an indicator + + + KB_IMFLAGS + { +IM_NoExplicit +, +IM_NoAutomatic +, +IM_LEDDrivesKB + } + + + KB_IMMODSWHICH + { +IM_UseNone +, +IM_UseBase +, +IM_UseLatched +, +IM_UseLocked +, +IM_UseEffective +, +IM_UseCompat + } + + + KB_IMGROUPSWHICH + { +IM_UseNone +, +IM_UseBase +, +IM_UseLatched +, +IM_UseLocked +, +IM_UseEffective + } + + + KB_INDICATORMAP + [ flags: CARD8, +mods: KB_MODDEF, +whichMods: +groups: KB_GROUPMASK, +whichGroups: +ctrls: KB_BOOLCTRLMASK ] + + + KB_SYMINTERPMATCH + { +SI_NoneOf +, +SI_AnyOfOrNone +, +SI_AnyOf +, +SI_AllOf +, +SI_Exactly + } + + + KB_SYMINTERP + [ sym: KEYSYM, + mods; KEYMASK, + levelOneOnly: BOOL, + match: KB_SYMINTERPMATCH, + virtualMod: CARD8, + autoRepeat: BOOL, + lockingKey: BOOL ] + + + KB_PCFMASK + { +PCF_DetectableAutorepeat +, +PCF_GrabsUseXkbState +, +PCF_AutoResetControls +, +PCF_LookupStateWhenGrabbed +, +PCF_SendEventUsesXKBState + } + + + KB_LCFLAGSMASK + { +LC_Hidden +, +LC_Default +, +LC_Partial + } + + + KB_LCSYMFLAGSMASK + { +LC_AlphanumericKeys +, +LC_ModifierKeys +, +LC_KeypadKeys +, +LC_FunctionKeys +, +LC_AlternateGroup + } + + + + + + +These types are used by the +XkbGetGeometry + and +XkbSetGeometry + requests: + + + + + + + + + + Name + Value + + + + + KB_PROPERTY + [ name, value: STRING8 ] + + + KB_POINT + [ x, y: CARD16 ] + + + KB_OUTLINE + [ cornerRadius: CARD8, points: LISTofKB_POINT ] + + + KB_SHAPE + [ name: ATOM, outlines: LISTofKB_OUTLINE + primaryNdx, approxNdx: CARD8 ] + + + KB_KEYNAME + [ name: LISTofCHAR ] + + + KB_KEYALIAS + [ real: LISTofCHAR, alias: LISTofCHAR ] + + + KB_KEY + [ name: KB_KEYNAME, gap: INT16, + shapeNdx, colorNdx: CARD8 ] + + + KB_ROW + [ top, left: INT16, vertical: BOOL, keys LISTofKB_KEY ] + + + KB_OVERLAYKEY + [ over, under: KB_KEYNAME ] + + + KB_OVERLAYROW + [ rowUnder: CARD8, keys: LISTofKB_OVERLAYKEY ] + + + KB_OVERLAY + [ sectionUnder: CARD8, +rows: LISTofKB_OVERLAYROW ] + + + KB_SHAPEDOODAD + [ name: ATOM, priority: CARD8, top, left: INT16, + type: { SolidDoodad, OutlineDoodad }, + angle: INT16, width, height: CARD16 + colorNdx, shapeNdx: CARD8 ] + + + KB_TEXTDOODAD + [ name: ATOM, priority: CARD8, top, left: INT16, + angle: INT16, width, height: CARD16, + colorNdx: CARD8, text: STRING8, font: STRING8 ] + + + KB_INDICATORDOODAD + [ name: ATOM, priority: CARD8, top, left: INT16, +angle: INT16, +shapeNdx, onColorNdx, offColorNdx: CARD8 ] + + + KB_LOGODOODAD + [ name: ATOM, priority: CARD8, top, left: INT16, + angle: INT16, colorNdx, shapeNdx: CARD8, + logoName: STRING8 ] + + + KB_DOODAD + KB_SHAPEDOODAD, or KB_TEXTDOODAD, or KB_INDICATORDOODAD, or +KB_LOGODOODAD + + + KB_SECTION + [ name: ATOM, + top, left, angle: INT16, + width, height: CARD16, + priority: CARD8, + rows: LISTofKB_ROW, + doodads: LISTofKB_DOODAD, + overlays: LISTofKB_OVERLAY ] + + + + + + +These types are used by +XkbGetDeviceInfo + and +XkbSetDeviceInfo +: + + + + + + + + + + Name + Value + + + + + KB_XIDEVFEATUREMASK + { +XI_ButtonActions +, +XI_IndicatorNames +, +XI_IndicatorMaps +, +XI_IndicatorState + } + + + KB_XIFEATUREMASK + { KB_XIDEVFEATURES or +XI_Keyboards + + + + KB_XIDETAILMASK + { KB_XIFEATURES or +XI_UnsupportedFeature + +} + + + + KB_DEVICELEDINFO + [ ledClass: KB_LEDCLASSSPEC, +ledID: KB_IDSPEC, +physIndicators: CARD32, +state: CARD32, +names: LISTofATOM, +maps: LISTofKB_INDICATORMAP ] + + + + + + + +Requests + + +This section lists all of the requests supported by the X Keyboard Extension, +separated into categories of related requests. + + + + +Initializing the X Keyboard Extension + + + + + + + + + XkbUseExtension + + + + + wantedMajor, wantedMinor: CARD16 + + + +supported: BOOL + + + + +serverMajor, serverMinor: CARD16 + + + + + + +This request enables XKB extension capabilities for the client that issues the +request; the +wantedMajor + and +wantedMinor + fields specify the extension version in use by the requesting client. The + +supported + field is +True + if the server supports a compatible version, +False + otherwise. The +serverMajor + and +serverMinor + fields return the actual version supported by the server. + + + + +Until a client explicitly and successfully requests the XKB extension, an XKB +capable server reports compatibility state in all core protocol events and +requests. Once a client asks for XKB extension semantics by issuing this +request, the server reports the extended XKB keyboard state in some core +protocol events and requests, as described in the overview section of this +specification. + + + + +Clients should issue an +XkbUseExtension + request before using any other extension requests. + + + + + +Selecting Events + + + + + + + + + XkbSelectEvents + + + + + deviceSpec: KB_DEVICESPEC + + + +affectWhich, clear, selectAll: KB_EVENTTYPE + + + +affectMap, map: KB_MAPPARTMASK + + + +details: LISTofITEMs + + + + Errors: +Keyboard +, +Match +, +Value + + + + + + + + +This request updates the event masks of the keyboard indicated by +deviceSpec + for this client. If +deviceSpec + specifies an illegal device, a +Keyboard + error results. + + + + +The +affectMap + and +map + fields specify changes to the event details mask for the +XkbMapNotify + event. If any map components are set in +map + but not in +affectMap +, a +Match + error results. Otherwise, any map components that are set in +affectMap + are set or cleared in the map notify details mask, depending on the value of +the corresponding field in +map +. + + + + +The +affectWhich +, +clear +, and +selectAll + fields specify changes to any other event details masks. If any event types +are set in both +clear + and +selectAll +, a +Match + error results; if any event types are specified in either +clear + or +selectAll + but not in +affectWhich +, a +Match + error results. Otherwise, the detail masks for any event types specified in +the +affectWhich + field of this request are changed as follows: + + + + + If the event type is also set in +clear +, the detail mask for the corresponding event is set to +0 + or +False +, as appropriate. + + + + If the event type is also set in +selectAll +, the detail mask for the corresponding event is set to include all legal +detail values for that type. + + + + If the event type is not set in either +clear + or +selectAll +, the corresponding element of +details + lists a set of explicit changes to the details mask for the event, as +described below. + + + + + +Each entry of the +details + list specifies changes to the event details mask for a single type of event, +and consists of an +affects + mask and a +values + mask. All details that are specified in +affects + are set to the corresponding value from +values +; if any details are listed in +values + but not in +affects +, a +Match + error results. + + + + +The details list contains entries only for those event types, if any, that are +listed in the +affectWhich + mask and not in either +clear + or +selectAll +. When present, the items of the +details + list appear in the following order: + + + + + + + + + + + Event Type + Legal Details + Type + + + + + +XkbNewKeyboardNotify + + +KB_NKNDETAILSMASK + + +CARD16 + + + + +XkbStateNotify + + +KB_STATEPARTMASK + + +CARD16 + + + + +XkbControlsNotify + + +KB_CONTROLMASK + + +CARD32 + + + + +XkbIndicatorMapNotify + + +KB_INDICATORMASK + + +CARD32 + + + + +XkbIndicatorStateNotify + + +KB_INDICATORMASK + + +CARD32 + + + + +XkbNamesNotify + + +KB_NAMEDETAILMASK + + +CARD16 + + + + +XkbCompatMapNotify + + +KB_CMDETAILMASK + + +CARD8 + + + + +XkbBellNotify + + +KB_BELLDETAILMASK + + +CARD8 + + + + +XkbActionMessage + + +KB_MSGDETAILMASK + + +CARD8 + + + + +XkbAccessXNotify + + +KB_AXNDETAILMASK + + +CARD16 + + + + +XkbExtensionDeviceNotify + + +KB_XIDETAILMASK + + +CARD16 + + + + + + + +Detail masks for event types that are not specified in +affectWhich + are not changed. + + + + +If any components are specified in a client’s event masks, the X server sends +the client an appropriate event whenever any of those components change state. +Unless explicitly modified, all event detail masks are empty. Events describes all XKB events +and the conditions under which the server generates them. + + + + + +Generating Named Keyboard Bells + + + + + + + + + XkbBell + + + + + deviceSpec: KB_DEVICESPEC + + + +bellClass: KB_BELLCLASSSPEC + + + +bellID: KB_IDSPEC + + + +percent: INT8 + + + +forceSound: BOOL + + + +eventOnly: BOOL + + + +pitch, duration: INT16 + + + +name: ATOM + + + +window: WINDOW + + + + Errors: +Keyboard +, +Value +, +Match + + + + + + + + +This request generates audible bells and/or +XkbBellNotify + events for the bell specified by the +bellClass + and +bellID + on the device specified by +deviceSpec + at the specified +pitch +, +duration + and volume ( +percent +). If deviceSpec specifies a device that does not have a bell or keyboard +feedback, a +Keyboard + error results. + + + + +If both +forceSound + and +eventOnly + are set, this request yields a +Match + error. Otherwise, if +forceSound + is +True +, this request always generates a sound and never generates an event; if + +eventOnly + is +True +, it causes an event but no sound. If neither +forceSound + nor +eventOnly + are +True +, this request always generates an event; if the keyboard’s global +AudibleBell + control is enabled, it also generates a sound. + + + + +Any bell event generated by this request contains all of the information about +the bell that was requested, including the symbolic name specified by +name + and the event window specified by window. The +name + and +window + are not directly interpreted by XKB, but they must have the value +None + or specify a legal Atom or Window, respectively. +XkbBellNotify + events generated in response to core protocol or X input extension bell +requests always report +None + as their +name +. + + + + +The +bellClass +, +bellID +, and +percent + fields are interpreted as for the X input extension +DeviceBell + request. If +pitch + and +duration + are zero, the server uses the corresponding values for that bell from the core +protocol or input extension, otherwise +pitch + and +duration + are interpreted as for the core protocol +ChangeKeyboardControl + request; if they do not include legal values, a +Value + error results. The +window + field must specify a legal Window or have the value +None +, or a +Value + error results. The name field must specify a legal Atom or have the value + +None +, or an +Atom + error results. If an error occurs, this request has no other effect (i.e. does +not cause a sound or generate an event). + + + + +The +pitch +, +volume +, and +duration + are suggested values for the bell, but XKB does not require the server to +honor them. + + + + + +Querying and Changing Keyboard State + + + + + + + + + XkbGetState + + + + + deviceSpec: KB_DEVICESPEC + + + + +deviceID: CARD8 + + + + +mods, baseMods, latchedMods, lockedMods: KEYMASK + + + + +group, lockedGroup: KB_GROUP + + + + +baseGroup, latchedGroup: INT16 + + + + +compatState: KEYMASK + + + + +grabMods, compatGrabMods: KB_GROUP + + + + +lookupMods, compatLookupMods: KEYMASK + + + + +ptrBtnState: BUTMASK + + + Errors: +Keyboard + + + + + + + + +This request returns a detailed description of the current state of the +keyboard specified by +deviceSpec +. + + + + +The +deviceID + return value contains the input extension identifier for the specified device, +or +0 + if the server does not support the input extension. + + + + +The +baseMods + return value reports the modifiers that are set because one or more modifier +keys are logically down. The +latchedMods + and +lockedMods + return values report the modifiers that are latched or locked respectively. +The +mods + return value reports the effective modifier mask which results from the +current combination of base, latched and locked modifiers. + + + + +The +baseGroup + return value reports the group state selected by group shift keys that are +logically down. The +latchedGroup + and +lockedGroup + return values detail the effects of latching or locking group shift keys and + +XkbLatchLockState + requests. The +group + return value reports the effective keyboard group which results from the +current combination of base, latched and locked group values. + + + + +The +lookupMods + return value reports the lookup modifiers, which consist of the current +effective modifiers minus any server internal modifiers. The +grabMods + return value reports the grab modifiers, which consist of the lookup modifiers +minus any members of the ignore locks mask that are not either latched or +logically depressed. Keyboard +State describes the lookup modifiers and grab modifiers in more detail. + + + + +The +ptrBtnState + return value reports the current logical state of up to five buttons on the +core pointer device. + + + + +The +compatState + return value reports the compatibility state that corresponds to the effective +keyboard group and modifier state. The +compatLookupMods + and +compatGrabMods + return values report the core protocol compatibility states that correspond to +the XKB lookup and grab state. All of the compatibility states are computed by +applying the group compatibility mapping to the corresponding XKB modifier and +group states, as described in +Group Compatibility Map. + + + + + + + + + + + XkbLatchLockState + + + + + deviceSpec: KB_DEVICESPEC + + + +affectModLocks, modLocks: KEYMASK + + + +lockGroup: BOOL + + + +groupLock: KB_GROUP + + + +affectModLatches,modLatches: KEYMASK + + + +latchGroup: BOOL + + + +groupLatch: INT16 + + + + Errors: +Keyboard +, +Value + + + + + + + + +This request locks or latches keyboard modifiers and group state for the device +specified by +deviceSpec +. If +deviceSpec + specifies an illegal or non-keyboard device, a +Keyboard + error occurs. + + + + +The locked state of any modifier specified in the +affectModLocks + mask is set to the corresponding value from +modLocks +. If +lockGroup + is +True +, the locked keyboard group is set to the group specified by +groupLock +. If any modifiers are set in +modLocks + but not +affectModLocks +, a +Match + error occurs. + + + + +The latched state of any modifier specified in the +affectModLatches + mask is set to the corresponding value from +modLatches +. If +latchGroup + is +True +, the latched keyboard group is set to the group specified by +groupLatch +. if any modifiers are set in +modLatches + but not in +affectModLatches +, a +Match + error occurs. + + + + +If the locked group exceeds the maximum number of groups permitted for the +specified keyboard, it is wrapped or truncated back into range as specified by +the global +GroupsWrap + + +control. No error results from an out-of-range group specification. + + + + +After changing the locked and latched modifiers and groups as specified, the X +server recalculates the effective and compatibility keyboard state and +generates +XkbStateNotify + events as appropriate if any state components have changed. Changing the +keyboard state might also turn indicators on or off which can cause +XkbIndicatorStateNotify + events as well. + + + + +If any errors occur, this request has no effect. + + + + + +Querying and Changing Keyboard Controls + + + + + + + + + XkbGetControls + + + + + deviceSpec: KB_DEVICESPEC + + + + +deviceID: CARD8 + + + + +mouseKeysDfltBtn: CARD8 + + + + +numGroups: CARD8 + + + + +groupsWrap: KB_GROUPINFO + + + + +internalMods,ignoreLockMods: KB_MODDEF + + + + +repeatDelay,repeatInterval: CARD16 + + + + +slowKeysDelay, debounceDelay: CARD16 + + + + +mouseKeysDelay, mouseKeysInterval: CARD16 + + + + +mouseKeysTimeToMax, mouseKeysMaxSpeed: CARD16 + + + + +mouseKeysCurve: INT16 + + + + +accessXOptions: KB_AXOPTIONMASK + + + + +accessXTimeout: CARD16 + + + + +accessXTimeoutOptionsMask, accessXTimeoutOptionValues: CARD16 + + + + +accessXTimeoutMask,accessXTimeoutValues: CARD32 + + + + +enabledControls: KB_BOOLCTRLMASK + + + + +perKeyRepeat: LISTofCARD8 + + + + Errors: +Keyboard + + + + + + + + +This request returns the current values and status of all controls for the +keyboard specified by +deviceSpec +. If +deviceSpec + specifies an illegal device a +Keyboard + error results. On return, the +deviceID + specifies the identifier of the requested device or zero if the server does +not support the input extension. + + + + +The +numGroups + return value reports the current number of groups, and +groupsWrap + reports the treatment of out-of-range groups, as described in Key Symbol Map. The +internalMods + and +ignoreLockMods + return values report the current values of the server internal and ignore +locks modifiers as described in +Keyboard State. Both are modifier definitions ( +Modifier Definitions) which +report the real modifiers, virtual modifiers, and the resulting combination of +real modifiers that are bound to the corresponding control. + + + + +The +repeatDelay +, +repeatInterval +, +slowKeysDelay + and +debounceDelay + fields report the current values of the for the autorepeat delay, autorepeat +interval, slow keys delay and bounce keys timeout, respectively. The +mouseKeysDelay +, +mouseKeysInterval +, +mouseKeysTimeToMax + and +mouseKeysMaxSpeed + and +mouseKeysCurve + return values report the current acceleration applied to mouse keys, as +described in The MouseKeysAccel +Control. All times are reported in milliseconds. + + + + +The +mouseKeysDfltBtn + return value reports the current default pointer button for which events are +synthesized by the mouse keys server actions. + + + + +The +accessXOptions + return value reports the current settings of the various AccessX options flags +which govern the behavior of the +StickyKeys + control and of AccessX feedback. + + + + +The +accessXTimeout + return value reports the length of time, in seconds, that the keyboard must +remain idle before AccessX controls are automatically changed; an +accessXTimeout + of +0 + indicates that AccessX controls are not automatically changed. The +accessXTimeoutMask + specifies the boolean controls to be changed if the AccessX timeout expires; +the +accessXTimeoutValues + field specifies new values for all of the controls in the timeout mask. The + +accessXTimeoutOptionsMask + field specifies the AccessX options to be changed when the AccessX timeout +expires; the +accessXTimeoutOptionValues + return value reports the values to which they will be set. + + + + +The +enabledControls + return value reports the current state of all of the global boolean controls. + + + + +The +perKeyRepeat + array consists of one bit per key and reports the current autorepeat behavior +of each keyboard key; if a bit is set in +perKeyRepeat +, the corresponding key repeats if it is held down while global keyboard +autorepeat is enabled. This array parallels the core protocol and input +extension keyboard controls, if the autorepeat behavior of a key is changed via +the core protocol or input extension, those changes are automatically reflected +in the +perKeyRepeat + array. + + + + + + + + + + + XkbSetControls + + + + + deviceSpec: KB_DEVICESPEC + + + +affectInternalRealMods, internalRealMods: KEYMASK + + + +affectInternalVirtualMods,internalVirtualMods: KB_VMODMASK + + + +affectIgnoreLockRealMods,ignoreLockRealMods: KB_MODMASK + + + +affectIgnoreLockVirtualMods,ignoreLockVirtualMods: KB_VMODMASK + + + +mouseKeysDfltBtn: CARD8 + + + +groupsWrap: KB_GROUPINFO + + + +accessXOptions: CARD16 + + + +affectEnabledControls: KB_BOOLCTRLMASK + + + +enabledControls: KB_BOOLCTRLMASK + + + +changeControls: KB_CONTROLMASK + + + +repeatDelay,repeatInterval: CARD16 + + + +slowKeysDelay, debounceDelay: CARD16 + + + +mouseKeysDelay, mouseKeysInterval: CARD16 + + + +mouseKeysTimeToMax, mouseKeysMaxSpeed: CARD16 + + + +mouseKeysCurve: INT16 + + + +accessXTimeout: CARD16 + + + +accessXTimeoutMask, accessXTimeoutValues: KB_BOOLCTRLMASK + + + +accessXTimeoutOptionsMask,accessXTimeoutOptionsValues: CARD16 + + + +perKeyRepeat: LISTofCARD8 + + + + Errors: + Keyboard +, +Value + + + + + + + + +This request sets the keyboard controls indicated in +changeControls + for the keyboard specified by +deviceSpec +. Each bit that is set in +changeControls + indicates that one or more of the other request fields should be applied, as +follows: + + + + + + + + + + Bit in changeControls + Field(s) to be Applied + + + + + +XkbRepeatKeysMask + + +repeatDelay +, +repeatInterval + + + + +XkbSlowKeysMask + + +slowKeysDelay + + + + +XkbStickyKeysMask + + +accessXOptions + (only the +XkbAX_TwoKeys + + +and the +XkbAX_LatchToLock + options are affected) + + + +XkbBounceKeysMask + + +debounceDelay + + + + +XkbMouseKeysMask + + +mouseKeysDfltBtn + + + + +XkbMouseKeysAccelMask + + +mouseKeysDelay +, +mouseKeysInterval +, +mouseKeysCurve +, +mouseKeysTimeToMax +, +mouseKeysMaxSpeed + + + + +XkbAccessXKeysMask + + +accessXOptions (all options) + + + + +XkbAccessXTimeoutMask + + +accessXTimeout +, +accessXTimeoutMask +, +accessXTimeoutValues +, +accessXTimeoutOptionsMask +, +accessXTimeoutOptionsValues + + + + XkbAccessXFeedbackMask + +accessXOptions + (all options except those affected by the +XkbStickyKeysMask + bit) + + + +XkbGroupsWrapMask + + +groupsWrap + + + + +XkbInternalModsMask + + +affectInternalRealMods +, +internalRealMods +, +affectInternalVirtualMods +, +internalVirtualMods + + + + +XkbIgnoreLockModsMask + + +affectIgnoreLockRealMods +, +ignoreLockRealMods +, +affectIgnoreLockVirtualMods +, +ignoreLockVirtualMods + + + + +XkbPerKeyRepeatMask + + +perKeyRepeat + + + + +XkbControlsEnabledMask + + +affectEnabledControls +, +enabledControls + + + + + + + +If any other bits are set in +changeControls +, a +Value + error results. If any of the bits listed above are not set in +changeControls +, the corresponding fields must have the value +0 +, or a +Match + error results. + + + + +If applied, +repeatDelay + and +repeatInterval + change the autorepeat characteristics of the keyboard, as described in +The RepeatKeys Control. If +specified, +repeatDelay + and +repeatInterval + must both be non-zero or a +Value + error results. + + + + +If applied, the +slowKeysDelay + field specifies a new delay for the +SlowKeys + control, as defined in The +SlowKeys Control. If specified, +slowKeysDelay + must be non-zero, or a +Value + error results. + + + + +If applied, the +debounceDelay + field specifies a new delay for the +BounceKeys + control, as described in The +BounceKeys Control. If present, the +debounceDelay + must be non-zero or a +Value + error results. + + + + +If applied, the +mouseKeysDfltBtn + field specifies the core pointer button for which events are generated +whenever a +SA_PtrBtn + or +SA_LockPtrBtn + key action is activated. If present, +mouseKeysDfltBtn + must specify a legal button for the core pointer device, or a +Value + error results. Key +Actions describes the +SA_PtrBtn + and +SA_LockPtrBtn + actions in more detail. + + + + +If applied, the +mouseKeysDelay +, +mouseKeysInterval +, +mouseKeysTimeToMax +, +mouseKeysMaxSpeed + and +mouseKeysCurve + fields change the rate at which the pointer moves when a key which generates a + +SA_MovePtr + action is held down. The +MouseKeysAccel Control describes these +MouseKeysAccel + parameters in more detail. If defined, the +mouseKeysDelay +, +mouseKeysInterval +, +mouseKeysTimeToMax + and +mouseKeysMaxSpeed + values must all be greater than zero, or a +Value + error results. The +mouseKeysCurve + value must be greater than +-1000 + or a +Value + error results. + + + + +If applied, the +accessXOptions + field sets the AccessX options, which are described in detail in +The AccessXKeys Control. If +either one of +XkbStickyKeysMask + and +XkbAccessXFeedbackMask + are set in +changeControls + and +XkbAccessXKeysMask + is not, only a subset of the AccessX options are changed, as described in the +table above; if both are set or if the +AccessXKeys + bit is set in +changeControls +, all of the AccessX options are updated. Any bit in +accessXOptions + whose interpretation is undefined must be zero, or a +Value + error results. + + + + +If applied, the +accessXTimeout +, +accessXTimeoutMask +, +accessXTimeoutValues +, +accessXTimeoutOptionsMask + and +accessXTimeoutOptionsValues + fields change the behavior of the AccessX Timeout control, as described in +The AccessXTimeout +Control. The +accessXTimeout + must be greater than zero, or a +Value + error results. The +accessXTimeoutMask + or +accessXTimeoutValues + fields must specify only legal boolean controls, or a +Value + error results. The +accessXTimeoutOptionsMask + and +accessXTimeoutOptionsValues + fields must contain only legal AccessX options or a +Value + error results. If any bits are set in either values field but not in the +corresponding mask, a +Match + error results. + + + + +If present, the +groupsWrap + field specifies the treatment of out-of-range keyboard groups, as described in +Key Symbol Map. If the + +groupsWrap + field does not specify a legal treatment for out-of-range groups, a +Value + error results. + + + + +If present, the +affectInternalRealMods + field specifies the set of real modifiers to be changed in the internal +modifier definition and the +internalRealMods + field specifies new values for those modifiers. The +affectInternalVirtualMods + and +internalVirtualMods + fields update the virtual modifier component of the modifier definition that +describes the internal modifiers in the same way. If any bits are set in either +values field but not in the corresponding mask field, a +Match + error results. + + + + +If present, the +affectIgnoreLockRealMods + field specifies the set of real modifiers to be changed in the ignore locks +modifier definition and the +ignoreLockRealMods + field specifies new values for those modifiers. The +affectIgnoreLockVirtualMods + and +ignoreLockVirtualMods + fields update the virtual modifier component of the ignore locks modifier +definition in the same way. If any bits are set in either values field but not +in the corresponding mask field, a +Match + error results. + + + + +If present, the +perKeyRepeat + array specifies the repeat behavior of the individual keyboard keys. The +corresponding core protocol or input extension per-key autorepeat information +is updated to reflect any changes specified in +perKeyRepeat +. If the bits that correspond to any out-of-range keys are set in +perKeyRepeat +, a +Value + error results. + + + + +If present, the +affectEnabledControls + and +enabledControls + field enable and disable global boolean controls. Any controls set in both +fields are enabled; any controls that are set in +affectEnabledControls + but not in +enabledControls + are disabled. Controls that are not set in either field are not affected. If +any controls are specified in +enabledControls + but not in +affectEnabledControls +, a +Match + error results. If either field contains anything except boolean controls, a + +Value + error results. + + + + + +Querying and Changing the Keyboard Mapping + + + + + + + + + XkbGetMap + + + + + deviceSpec: KB_DEVICESPEC + + + +full, partial: KB_MAPPARTMASK + + + +firstType, nTypes: CARD8 + + + +firstKeySym, firstKeyAction: KEYCODE + + + +nKeySyms, nKeyActions: CARD8 + + + +firstKeyBehavior,firstKeyExplicit: KEYCODE + + + +nKeyBehaviors,nKeyExplicit: CARD8 + + + +firstModMapKey,firstVModMapKey: KEYCODE + + + +nModMapKeys, nVModMapKeys: CARD8 + + + +virtualMods: KB_VMODMASK + + + + +deviceID: CARD8 + + + + +minKeyCode, maxKeyCode: KEYCODE + + + + +present: KB_MAPPARTMASK + + + + +firstType, nTypes, nTotalTypes: CARD8 + + + + +firstKeySym, firstKeyAction: KEYCODE + + + + +nKeySyms, nKeyActions: CARD8 + + + + +totalSyms, totalActions: CARD16 + + + + +firstKeyBehavior, firstKeyExplicit: KEYCODE + + + + +nKeyBehaviors, nKeyExplicit: CARD8 + + + + +totalKeyBehaviors, totalKeyExplicit: CARD8 + + + + +firstModMapKey, firstVModMapKey: KEYCODE + + + + +nModMapKeys, nVModMapKeys: CARD8 + + + + +totalModMapKeys, totalVModMapKeys: CARD8 + + + + +virtualMods: KB_VMODMASK + + + + +typesRtrn: LISTofKB_KEYTYPE + + + + +symsRtrn: LISTofKB_KEYSYMMAP + + + + +actsRtrn: { count: LISTofCARD8, acts: LISTofKB_ACTION } + + + + +behaviorsRtrn: LISTofKB_SETBEHAVIOR + + + + +vmodsRtrn: LISTofSETofKEYMASK + + + + +explicitRtrn: LISTofKB_SETEXPLICIT + + + + +modmapRtrn: LISTofKB_KEYMODMAP + + + + +vmodMapRtrn: LISTofKB_KEYVMODMAP + + + + +Errors: +Keyboard +, +Value +, +Match +, +Alloc + + + + + + + +This request returns the indicated components of the server and client maps of +the keyboard specified by +deviceSpec +. The +full + mask specifies the map components to be returned in full; the +partial + mask specifies the components for which some subset of the legal elements are +to be returned. The server returns a +Match + error if any component is specified in both +full + and +partial +, or a +Value + error if any undefined bits are set in either +full + or +partial +. + + + + +Each bit in the +partial + mask controls the interpretation of one or more of the other request fields, +as follows: + + + + + + + + + + + Bit in the Partial Mask + Type + Corresponding Field(s) + + + + + +XkbKeyTypesMask + + key types + +firstType +, +nTypes + + + + +XkbKeySymsMask + + keycodes + +firstKeySym +, +nKeySyms + + + + +XkbKeyActionsMask + + keycodes + +firstKeyAction +, +nKeyActions + + + + +XkbKeyBehaviorsMask + + keycodes + +firstKeyBehavior +, +nKeyBehaviors + + + + +XkbExplicitComponentsMask + + keycodes + +firstKeyExplicit +, +nKeyExplicit + + + + +XkbModifierMapMask + + keycodes + +firstModMapKey +, +nModMapKeys + + + + +XkbVirtualModMapMask + + keycodes + +firstVModMapKey +, +nVModMapKeys + + + + +XkbVirtualModsMask + + virtual modifiers + +virtualMods + + + + + + + +If any of these keyboard map components are specified in +partial +, the corresponding values must specify a valid subset of the requested +components or this request reports a +Value + error. If a keyboard map component is not specified in +partial +, the corresponding fields must contain zeroes, or a +Match + error results. + + + + +If any error is generated, the request aborts and does not report any values. + + + + +On successful return, the +deviceID + field reports the X input extension device ID of the keyboard for which +information is being returned, or +0 + if the server does not support the X input extension. The +minKeyCode + and +maxKeyCode + return values report the minimum and maximum keycodes that are legal for the +keyboard in question. + + + + +The +present + return value lists all of the keyboard map components contained in the reply. +The bits in +present + affect the interpretation of the other return values as follows: + + + + +If +XkbKeyTypesMask + is set in +present +: + + + + + +firstType + and +nTypes + specify the types reported in the reply. + + + + +nTotalTypes + reports the total number of types defined for the keyboard + + + + +typesRtrn + has +nTypes + elements of type KB_KEYTYPE which describe consecutive key types starting from + +firstType +. + + + + + +If +XkbKeySymsMask + is set in +present +: + + + + + +firstKeySym + and +nKeySyms + specify the subset of the keyboard keys for which symbols will be reported. + + + + +totalSyms + reports the total number of keysyms bound to the keys returned in this reply. + + + + +symsRtrn + has +nKeySyms + elements of type KB_KEYSYMMAP, which describe the symbols bound to consecutive +keys starting from +firstKeySym +. + + + + + +If +XkbKeyActionsMask + is set in +present +: + + + + + +firstKeyAction + and +nKeyActions + specify the subset of the keys for which actions are reported. + + + + +totalActions + reports the total number of actions bound to the returned keys. + + + + The +count +field of the +actsRtrn + return value has +nKeyActions + entries of type CARD8, which specify the number of actions bound to +consecutive keys starting from +firstKeyAction +. The +acts + field of +actsRtrn + has +totalActions + elements of type KB_ACTION and specifies the actions bound to the keys. + + + + + +If +XkbKeyBehaviorsMask + is set in +present +: + + + + + The +firstKeyBehavior + and +nKeyBehaviors + return values report the range of keyboard keys for which behaviors will be +reported. + + + + The +totalKeyBehaviors + return value reports the number of keys in the range to be reported that have +non-default values. + + + + The +behaviorsRtrn + value has +totalKeyBehaviors + entries of type KB_BEHAVIOR. Each entry specifies a key in the range for which +behaviors are being reported and the behavior associated with that key. Any +keys in that range that do not have an entry in +behaviorsRtrn + have the default behavior, +KB_Default +. + + + + + +If +XkbExplicitComponentsMask + is set in +present +: + + + + + The +firstKeyExplicit + and +nKeyExplicit + return values report the range of keyboard keys for which the set of explicit +components is to be returned. + + + + The +totalKeyExplicit + return value reports the number of keys in the range specified by +firstKeyExplicit + and +nKeyExplicit + that have one or more explicit components. + + + + The +explicitRtrn + return value has +totalKeyExplicit + entries of type KB_KEYEXPLICIT. Each entry specifies the a key in the range +for which explicit components are being reported and the explicit components +that are bound to it. Any keys in that range that do not have an entry in + +explicitRtrn + have no explicit components. + + + + + +If +XkbModifierMapMask + is set in +present +: + + + + + The +firstModMapKey + and +nModMapKeys + return values report the range of keyboard keys for which the modifier map is +to be reported. + + + + The +totalModMapKeys + return value reports the number of keys in the range specified by +firstModMapKey + and +nModMapKeys + that are bound with to one or more modifiers. + + + + The +modmapRtrn + return value has +totalModMapKeys + entries of type KB_KEYMODMAP. Each entry specifies the a key in the range for +which the modifier map is being reported and the set of modifiers that are +bound to that key. Any keys in that range that do not have an entry in + +modmapRtrn + are not associated with any modifiers by the modifier mapping. + + + + + +If +XkbVirtualModMapMask + is set in +present +: + + + + + The +firstVModMapKey + and +nVModMapKeys + return values report the range of keyboard keys for which the virtual modifier +map is to be reported. + + + + The +totalVModMapKeys + return value reports the number of keys in the range specified by +firstVModMapKey + and +nVModMapKeys + that are bound with to or more virtual modifiers. + + + + The +vmodmapRtrn + return value has +totalVModMapKeys + entries of type KB_KEYVMODMAP. Each entry specifies the a key in the range for +which the virtual modifier map is being reported and the set of virtual +modifiers that are bound to that key. Any keys in that range that do not have +an entry in +vmodmapRtrn + are not associated with any virtual modifiers, + + + + + +If +XkbVirtualModsMask + is set in +present +: + + + + + The +virtualMods + return value is a mask with one bit per virtual modifier which specifies the +virtual modifiers for which a set of corresponding real modifiers is to be +returned. + + + + The +vmodsRtrn + return value is a list with one entry of type KEYBUTMASK for each virtual +modifier that is specified in +virtualMods +. The entries in +vmodsRtrn + contain the real modifier bindings for the specified virtual modifiers, +beginning with the lowest-numbered virtual modifier that is present in + +virtualMods + and proceeding to the highest. + + + + + +If any of these bits are not set in +present +, the corresponding numeric fields all have the value zero, and the +corresponding lists are all of length zero. + + + + + + + + + + + XkbSetMap + + + + + deviceSpec: KB_DEVICESPEC + + + +flags: { +SetMapResizeTypes, SetMapRecomputeActions +} + + + +present: KB_MAPPARTMASK + + + +minKeyCode, maxKeyCode: KEYCODE + + + +firstType, nTypes: CARD8 + + + +firstKeySym, firstKeyAction: KEYCODE + + + +nKeySyms, nKeyActions: CARD8 + + + +totalSyms, totalActions: CARD16 + + + +firstKeyBehavior, firstKeyExplicit: KEYCODE + + + +nKeyBehaviors, nKeyExplicit: CARD8 + + + +totalKeyBehaviors, totalKeyExplicit: CARD8 + + + +firstModMapKey, firstVModMapKey: KEYCODE + + + +nModMapKeys, nVModMapKeys: CARD8 + + + +totalModMapKeys, totalVModMapKeys: CARD8 + + + +virtualMods: VMODMASK + + + +types: LISTofKB_KEYTYPE + + + +syms: LISTofKB_KEYSYMMAP + + + +actions: { count: LISTofCARD8, actions: LISTofKB_ACTION } + + + +behaviors: LISTofKB_BEHAVIOR + + + +vmods: LISTofKEYMASK + + + +explicit: LISTofKB_EXPLICIT + + + +modmap: LISTofKB_KEYMODMAP + + + +vmodmap: LISTofKB_KEYVMODMAP + + + + Errors: +Keyboard +, +Value +, +Match +, +Alloc + + + + + + + + +This request changes the indicated parts of the keyboard specified by +deviceSpec +. With XKB, the effect of a key release is independent of the keyboard mapping +at the time of the release, so this request can be processed regardless of the +logical state of the modifier keys at the time of the request. + + + + +The +present + field specifies the keyboard map components contained to be changed. The bits +in +present + affect the interpretation of the other fields as follows: + + + + +If +XkbKeyTypesMask + is set in +present +, +firstType + and +nTypes + specify a subset of the key types bound to the keyboard to be changed or +created. The index of the first key type to be changed must be less than or +equal to the unmodified length of the list of key types or a +Value + error results. + + + + +If +XkbKeyTypesMask + is set in +present + and +SetMapResizeTypes + is set in +flags +, the server resizes the list of key types bound to the keyboard so that the +last key type specified by this request is the last element in the list. If the +list of key types is shrunk, any existing key definitions that use key types +that eliminated are automatically assigned key types from the list of canonical +key types as described in +Assigning Types To Groups of Symbols for a Key. The list of key types +bound to a keyboard must always include the four canonical types and cannot +have more than +XkbMaxTypesPerKey + (32) types; any attempt to reduce the number of types bound to a keyboard +below four or above +XkbMaxTypesPerKey + causes a +Value + error. Symbolic names for newly created key types or levels within a key type +are initialized to +None +. + + + + +If +XkbKeyTypesMask + is set in +present +, the types list has +nTypes + entries of type KB_KEYTYPE.Each key type specified in +types + must be valid or a +Value + error results. To be valid a key type definition must meet the following +criteria: + + + + + The +numLevels + for the type must be greater than zero. + + + + If the key type is +ONE_LEVEL + (i.e. index zero in the list of key types), +numLevels + must be one. + + + + If the key type is +TWO_LEVEL + or +KEYPAD +, or +ALPHABETIC + (i.e. index one, two, or three in the lest of key types) group width must be +two. + + + + + +Each key type in types must also be internally consistent, or a Match error +results. To be internally consistent, a key type definition must meet the +following criteria: + + + + + Each map entry must specify a resulting level that is legal for the +type. + + + + Any real or virtual modifiers specified in any of the map entries must +also be specified in the +mods + for the type. + + + + + +If +XkbKeySymsMask + is set in +present +, +firstKeySym + and +nKeySyms + specify a subset of the keyboard keys to which new symbols are to be assigned +and +totalSyms + specifies the total number of symbols to be assigned to those keys. If any of +the keys specified by +firstKeySym + and +nKeySyms + are not legal, a +Match + error results. The +syms + list has +nKeySyms + elements of type KB_KEYSYMMAP. Each key in the resulting key symbol map must +be valid and internally consistent or a +Value + error results. To be valid and internally consistent, a key symbol map must +meet the following criteria: + + + + + The key type indices must specify legal result key types. + + + + The number of groups specified by +groupInfo + must be in the range +0…4 +. + + + + The +width + of the key symbol map must be equal to +numLevels + of the widest key type bound to the key. + + + + The number of symbols, +nSyms +, must equal the number of groups times +width +. + + + + + +If +XkbKeyActionsMask + is set in +present +, +firstKeyAction + and +nKeyActions + specify a subset of the keyboard keys to which new actions are to be assigned +and +totalActions + specifies the total number of actions to be assigned to those keys. If any of +the keys specified by +firstKeyAction + and +nKeyActions + are not legal, a +Match + error results. The +count + field of the +actions + return value has +nKeyActions + elements of type CARD8; each element of +count + specifies the number of actions bound to the corresponding key. The +actions + list in the +actions + field has +totalActions + elements of type KB_ACTION. These actions are assigned to each target key in +turn, as specified by +count +. The list of actions assigned to each key must either be empty or have exactly +as many actions as the key has symbols, or a +Match + error results. + + + + +If +XkbKeyBehaviorsMask + is set in +present +, +firstKeyBehavior + and +nKeyBehaviors + specify a subset of the keyboard keys to which new behaviors are to be +assigned, and +totalKeyBehaviors + specifies the total number of keys in that range to be assigned non-default +behavior. If any of the keys specified by +firstKeyBehavior + and +nKeyBehaviors + are not legal, a +Match + error results. The +behaviors + list has +totalKeyBehaviors + elements of type KB_BEHAVIOR; each entry of +behaviors + specifies a key in the specified range and a new behavior for that key; any +key that falls in the range specified by +firstBehavior + and +nBehaviors + for which no behavior is specified in +behaviors + is assigned the default behavior, +KB_Default +. The new behaviors must be legal, or a +Value + error results. To be legal, the behavior specified in the +XkbSetMap + request must: + + + + + Specify a key in the range indicated by +firstKeyBehavior + and +nKeyBehaviors +. + + + + Not specify the +permanent + flag; permanent behaviors cannot be set or changed using the +XkbSetMap + request. + + + + If present, the +KB_Overlay1 + and +KB_Overlay2 + behaviors must specify a keycode for the overlay key that is valid for the +current keyboard. + + + + If present, the +KB_RadioGroup + behavior must specify a legal index (0…31) for the radio group to which the +key belongs. + + + + + +Key behaviors that are not recognized by the server are accepted but ignored. +Attempts to replace a "permanent" behavior are silently ignored; the behavior +is not replaced, but not error is generated and any other components specified +in the +XkbSetMap + request are updated, as appropriate. + + + + +If +XkbVirtualModsMask + is set in +present +, +virtualMods + is a mask which specifies the virtual modifiers to be rebound. The +vmods + list specifies the real modifiers that are bound to each of the virtual +modifiers specified in +virtualMods +, starting from the lowest numbered virtual modifier and progressing upward. +Any virtual modifier that is not specified in +virtualMods + has no corresponding entry in +vmods +, so the +vmods + list has one entry for each bit that is set in +virtualMods +. + + + + +If +XkbExplicitComponentsMask + is set in +present +, +firstKeyExplicit + and +nKeyExplicit + specify a subset of the keyboard keys to which new explicit components are to +be assigned, and +totalKeyExplicit + specifies the total number of keys in that range that have at least one +explicit component. The +explicit + list has +totalKeyExplicit + elements of type KB_KEYEXPLICIT; each entry of +explicit + specifies a key in the specified range and a new set of explicit components +for that key. Any key that falls in the range specified by +firstKeyExplicit + and +nKeyExplicit + that is not assigned some value in +explicit + has no explicit components. + + + + +If +XkbModifierMapMask + is set in +present +, +firstModMapKey + and +nModMapKeys + specify a subset of the keyboard keys for which new modifier mappings are to +be assigned, and +totalModMapKeys + specifies the total number of keys in that range to which at least one +modifier is bound. The +modmap + list has +totalModMapKeys + elements of type KB_KEYMODMAP; each entry of +modmap + specifies a key in the specified range and a new set of modifiers to be +associated with that key. Any key that falls in the range specified by + +firstModMapKey + and +nModMapKeys + that is not assigned some value in +modmap + has no associated modifiers. + + + + +If the modifier map is changed by the +XkbSetMap + request, any changes are also reflected in the core protocol modifier mapping. +Changes to the core protocol modifier mapping are reported to XKB-unaware +clients via +MappingNotify + events and can be retrieved with the core protocol +GetModifierMapping + request. + + + + +If +XkbVirtualModMapMask + is set in +present +, +firstVModMapKey + and +nVModMapKeys + specify a subset of the keyboard keys for which new modifier mappings are to +be assigned, and +totalVModMapKeys + specifies the total number of keys in that range to which at least one virtual +modifier is bound. The +vmodmap + list has +totalVModMapKeys + elements of type KB_KEYVMODMAP; each entry of +vmodmap + specifies a key in the specified range and a new set of virtual modifiers to +be associated with that key. Any key that falls in the range specified by + +firstVModMapKey + and +nVModMapKeys + that is not assigned some value in +vmodmap + has no associated virtual modifiers. + + + + +If the resulting keyboard map is legal, the server updates the keyboard map. +Changes to some keyboard components have indirect effects on others: + + + + +If the +XkbSetMapRecomputeActions + bit is set in +flags +, the actions associated with any keys for which symbol or modifier bindings +were changed by this request are recomputed as described in +Assigning Actions To Keys. Note +that actions are recomputed +after +any actions specified in this request are bound to keys, so the actions +specified in this request might be clobbered by the automatic assignment of +actions to keys. + + + + +If the group width of an existing key type is changed, the list of symbols +associated with any keys of the changed type might be resized accordingly. If +the list increases in size, any unspecified new symbols are initialized to + +NoSymbol +. + + + + +If the list of actions associated with a key is not empty, changing the key +type of the key resizes the list. Unspecified new actions are calculated by +applying any keyboard symbol interpretations to the corresponding symbols. + + + + +The number of groups global to the keyboard is always equal to the largest +number of groups specified by any of the key symbol maps. Changing the number +of groups in one or more key symbol maps may change the number of groups global +to the keyboard. + + + + +Assigning key behavior +KB_RadioGroup + to a key adds that key as a member of the specified radio group. Changing a +key with the existing behavior +KB_RadioGroup + removes that key from the group. Changing the elements of a radio group can +cause synthetic key press or key release events if the key to be added or +removed is logically down at the time of the change. + + + + +Changing a key with behavior +KB_Lock + causes a synthetic key release event if the key is logically but not +physically down at the time of the change. + + + + +This request sends an +XkbMapNotify + event which reflects both explicit and indirect map changes to any interested +clients. If any symbolic names are changed, it sends a +XkbNamesNotify + reflecting the changes to any interested clients. XKB-unaware clients are +notified of keyboard changes via core protocol +MappingNotify + events. + + + + +Key press and key release events caused by changing key behavior may cause +additional +XkbStateNotify + or +XkbIndicatorStateNotify + events. + + + + + +Querying and Changing the Compatibility Map + + + + + + + + + XkbGetCompatMap + + + + + deviceSpec: KB_DEVICESPEC + + + +groups: KB_GROUPMASK + + + +getAllSI: BOOL + + + +firstSI, nSI: CARD16 + + + + +deviceID: CARD8 + + + + +groupsRtrn: KB_GROUPMASK + + + + +firstSIRtrn, nSIRtrn, nTotalSI: CARD16 + + + + +siRtrn: LISTofKB_SYMINTERP + + + + +groupRtrn: LISTofKB_MODDEF + + + Errors: +Keyboard +, +Match +, +Alloc + + + + + + + + +This request returns the listed compatibility map components for the keyboard +specified by +deviceSpec +. If +deviceSpec + does not specify a valid keyboard device, a +Keyboard + Error results. On return, +deviceID + reports the input extension identifier of the keyboard device or +0 + if the server does not support the input extension. + + + + +If +getAllSI + is +False +, +firstSI + and +nSI + specify a subset of the symbol interpretations to be returned; if used, + +nSI + must be greater than +0 + and all of the elements specified by +firstSI + and +nSI + must be defined or a +Value + error results. If +getAllSyms + is +True +, the server ignores +firstSym + and +nSyms + and returns all of the symbol interpretations defined for the keyboard. + + + + +The +groups + mask specifies the groups for which compatibility maps are to be returned. + + + + +The +nTotalSI + return value reports the total number of symbol interpretations defined for +the keyboard. On successful return, the +siRtrn + return list contains the definitions for +nSIRtrn + symbol interpretations beginning at +firstSIRtrn +. + + + + +The +groupRtrn + return values report the entries in the group compatibility map for any groups +specified in the +groupsRtrn + return value. + + + + + + + + + + + XkbSetCompatMap + + + + + deviceSpec: KB_DEVICESPEC + + + +recomputeActions: BOOL + + + +truncateSI: BOOL + + + +groups: KB_GROUPMASK + + + +firstSI, nSI: CARD16 + + + +si: LISTofKB_SYMINTERPRET + + + +groupMaps: LISTofKB_MODDEF + + + + Errors: +Keyboard +, +Match +, +Value +, +Alloc + + + + + + + + +This request changes a specified subset of the compatibility map of the +keyboard indicated by +deviceSpec +. If +deviceSpec + specifies an invalid device, a +Keyboard + error results and nothing is changed. + + + + +The +firstSI + and +nSI + fields specify a subset of the keyboard symbol interpretations to be changed. +The +si + list specifies new values for each of the interpretations in that range. + + + + +The first symbol interpretation to be changed, +firstSI +, must be less than or equal to the unchanged length of the list of symbol +interpretations, or a +Value + error results. If the resulting list would be larger than the unchanged list, +it server list of symbol interpretations is automatically increased in size. +Otherwise, if +truncateSyms + is +True +, the server deletes any symbol interpretations after the last element changed +by this request, and reduces the length of the list accordingly. + + + + +The +groupMaps + fields contain new definitions for a subset of the group compatibility map; + +groups + specifies the group compatibility map entries to be updated from +groupMaps +. + + + + + All changed compatibility maps and symbol interpretations must either ignore +group state or specify a legal range of groups, or a +Value + error results. + + + + +If the +recomputeActions + field is +True +, the server regenerates recalculates the actions bound to all keyboard keys by +applying the new symbol interpretations to the entire key symbol map, as +described in Assigning Actions To +Keys. + + + + + +Querying and Changing Indicators + + + + + + + + + XkbGetIndicatorState + + + + + deviceSpec: KB_DEVICESPEC + + + +deviceID: CARD8 +state: KB_INDICATORMASK + + + + Errors: +Keyboard + + + + + + + + +This request reports the current state of the indicators for the keyboard +specified by +deviceSpec +. If +deviceSpec + does not specify a valid keyboard, a +Keyboard + error results. + + + + +On successful return, the +deviceID + field reports the input extension identifier of the keyboard or +0 + if the server does not support the input extension. The +state + return value reports the state of each of the thirty-two indicators on the +specified keyboard. The least-significant bit corresponds to indicator 0, the +most significant bit to indicator 31; if a bit is set, the corresponding +indicator is lit. + + + + + + + + + + + XkbGetIndicatorMap + + + + + deviceSpec: KB_DEVICESPEC + + + +which: KB_INDICATORMASK + + + + +deviceID: CARD8 + + + + +which: KB_INDICATORMASK + + + + +realIndicators: KB_INDICATORMASK + + + + +nIndicators: CARD8 + + + + +maps: LISTofKB_INDICATORMAP + + + Errors: +Keyboard +, +Value + + + + + + + +This request returns a subset of the maps for the indicators on the keyboard +specified by +deviceSpec +. If +deviceSpec + does not specify a valid keyboard device, a +Keyboard + error results. + + + + +The +which + field specifies the subset to be returned; a set bit in the which field +indicates that the map for the corresponding indicator should be returned. + + + + +On successful return, the +deviceID + field reports the input extension identifier of the keyboard or +0 + if the server does not support the input extension. Any indicators specified +in +realIndicators + are actually present on the keyboard; the rest are virtual indicators. Virtual +indicators do not directly cause any visible or audible effect when they change +state, but they do cause +XkbIndicatorStateNotify + events. + + + + +The +maps + return value reports the requested indicator maps. Indicator maps are +described in Indicator Maps + + + + + + + + + + + XkbSetIndicatorMap + + + + + deviceSpec: KB_DEVICESPEC + + + +which: KB_INDICATORMASK + + + +maps: LISTofKB_INDICATORMAP + + + + Errors: +Keyboard +, +Value + + + + + + + + +This request changes a subset of the maps on the keyboard specified by + +deviceSpec +. If +deviceSpec + does not specify a valid keyboard device, a +Keyboard + error results. + + + + +The +which + field specifies the subset to be changed; the +maps + field contains the new definitions. + + + + +If successful, the new indicator maps are applied immediately. If any +indicators change state as a result of the new maps, the server generates + +XkbIndicatorStateNotify + events as appropriate. + + + + + + + + + + + XkbGetNamedIndicator + + + + + deviceSpec: KB_DEVICESPEC + + + +ledClass: KB_LEDCLASSSPEC + + + +ledID: KB_IDSPEC + + + +indicator: ATOM + + + + +deviceID: CARD8 + + + + +supported: BOOL + + + + +indicator: ATOM + + + + +found: BOOL + + + + +on: BOOL + + + + +realIndicator: BOOL + + + + +ndx: CARD8 + + + + +map: KB_INDICATORMAP + + + + Errors: +Keyboard +, +Atom +, +Value + + + + + + + + +This request returns information about the indicator specified by +ledClass +, +ledID +, and +indicator + on the keyboard specified by +deviceSpec +. The +indicator + field specifies the name of the indicator for which information is to be +returned. + + + + +If +deviceSpec + does not specify a device with indicators, a +Keyboard + error results. If +ledClass + does not have the value +DfltXIClass +, +LedFeedbackClass +, or +KbdFeedbackClass +, a +Value + error results. If +ledID + does not have the value +DfltXIId + or specify the identifier of a feedback of the class specified by +ledClass + on the device specified by +deviceSpec +, a +Match + error results. If +indicator + is not a valid ATOM other than +None +, an +Atom + error results. + + + + +This request is always supported with default class and identifier on the core +keyboard device. If the request specifies a device other than the core keyboard +device or a feedback class and identifier other than the defaults, and the +server does not support indicator names or indicator maps for extension +devices, the +supported + return value is +False + and the values of the other fields in the reply are undefined. If the client +which issued the unsupported request has also selected to do so, it will also +receive an +XkbExtensionDeviceNotify + event which reports the attempt to use an unsupported feature, in this case +one or both of +XkbXI_IndicatorMaps + or +XkbXI_IndicatorNames +. + + + + +Otherwise, +supported + is +True + and the +deviceID + field reports the input extension identifier of the keyboard or +0 + if the server does not support the input extension. The +indicator + return value reports the name for which information was requested and the + +found + return value is +True + if an indicator with the specified name was found on the device. + + + + +If a matching indicator was found: + + + + + The +on + return value reports the state of the indicator at the time of the request. + + + + The +realIndicator + return value is +True + if the requested indicator is actually present on the keyboard or +False + if it is virtual. + + + + The +ndx + return value reports the index of the indicator in the requested feedback. + + + + The +map + return value reports the indicator map used by to automatically change the +state of the specified indicator in response to changes in keyboard state or +controls. + + + + + +If no matching indicator is found, the +found + return value is +False +, and the +on +, +realIndicator +, +ndx +, and +map + return values are undefined. + + + + + + + + + + + XkbSetNamedIndicator + + + + + deviceSpec: KB_DEVICESPEC + + + +ledClass: KB_LEDCLASSSPEC + + + +ledID: KB_IDSPEC + + + +indicator: ATOM + + + +setState: BOOL + + + +on: BOOL + + + +setMap: BOOL + + + +createMap: BOOL + + + +map: KB_SETINDICATORMAP + + + + Errors: +Keyboard +, +Atom +, +Access + + + + + + + + +This request changes various aspects of the indicator specified by +ledClass +, +ledID +, and +indicator + on the keyboard specified by +deviceSpec +. The +indicator + argument specifies the name of the indicator to be updated. + + + + +If +deviceSpec + does not specify a device with indicators, a +Keyboard + error results. If +ledClass + does not have the value +DfltXIClass +, +LedFeedbackClass +, or +KbdFeedbackClass +, a +Value + error results. If +ledID + does not have the value +DfltXIId + or specify the identifier of a feedback of the class specified by +ledClass + on the device specified by +deviceSpec +, a +Match + error results. If +indicator + is not a valid ATOM other than +None +, an +Atom + error results. + + + + +This request is always supported with default class and identifier on the core +keyboard device. If the request specifies a device other than the core keyboard +device or a feedback class and identifier other than the defaults, and the +server does not support indicator names or indicator maps for extension +devices, the +supported + return value is +False + and the values of the other fields in the reply are undefined. If the client +which issued the unsupported request has also selected to do so, it will also +receive an +XkbExtensionDeviceNotify + event which reports the attempt to use an unsupported feature, in this case +one or both of +XkbXI_IndicatorMaps + and +XkbXI_IndicatorNames +. + + + + +Otherwise, +supported + is +True + and the +deviceID + field reports the input extension identifier of the keyboard or +0 + if the server does not support the input extension. The +indicator + return value reports the name for which information was requested and the + +found + return value is +True + if an indicator with the specified name was found on the device. + + + + +If no indicator with the specified name is found on the specified device, and +the +createMap + field is +True +, XKB assigns the specified name to the lowest-numbered indicator that has no +name (i.e. whose name is +None +) and applies the rest of the fields in the request to the newly named +indicator. If no unnamed indicators remain, this request reports no error and +has no effect. + + + + +If no matching indicator is found or new indicator assigned this request +reports no error and has no effect. Otherwise, it updates the indicator as +follows: + + + + +If +setMap +is +True +, XKB changes the map for the indicator (see Indicator Maps) to reflect the +values specified in +map +. + + + + +If +setState + is +True +, XKB attempts to explicitly change the state of the indicator to the state +specified in +on +. The effects of an attempt to explicitly change the state of an indicator +depend on the values in the map for that indicator and are not guaranteed to +succeed. + + + + +If this request affects both indicator map and state, it updates the indicator +map before attempting to change its state, so the success of the explicit +change depends on the indicator map values specified in the request. + + + + +If this request changes the indicator map, it applies the new map immediately +to determine the appropriate state for the indicator given the new indicator +map and the current state of the keyboard. + + + + + +Querying and Changing Symbolic Names + + + + + + + + + XkbGetNames + + + + + deviceSpec: KB_DEVICESPEC + + + +which: KB_NAMEDETAILMASK + + + +deviceID: CARD8 +which: KB_NAMESMASK +minKeyCode, maxKeyCode: KEYCODE +nTypes: CARD8 +nKTLevels: CARD16 +groupNames: KB_GROUPMASK +virtualMods: KB_VMODMASK +firstKey: KEYCODE +nKeys: CARD8 +indicators: KB_INDICATORMASK +nRadioGroups, nKeyAliases: CARD8 +present: KB_NAMEDETAILMASK +valueList: LISTofITEMs + + + + Errors: +Keyboard +, +Value + + + + + + + + +This request returns the symbolic names for various components of the keyboard +mapping for the device specified by +deviceSpec +. The +which + field specifies the keyboard components for which names are to be returned. If + +deviceSpec + does not specify a valid keyboard device, a +Keyboard + error results. If any undefined bits in +which + are non-zero, a +Value + error results. + + + + +The +deviceID + return value contains the X Input Extension device identifier of the specified +device or +0 + if the server does not support the input extension. The +present + and +valueList + return values specify the components for which names are being reported. If a +component is specified in +present +, the corresponding element is present in the +valueList +, otherwise that component has length +0 +. The components of the +valueList + appear in the following order, when present:. + + + + + + + + + + + Component + Size + Type + + + + + +XkbKeycodesName + + 1 + ATOM + + + +XkbGeometryName + + 1 + ATOM + + + +XkbSymbolsName + + 1 + ATOM + + + +XkbPhysSymbolsName + + 1 + ATOM + + + +XkbTypesName + + 1 + ATOM + + + +XkbCompatName + + 1 + ATOM + + + +XkbKeyTypeNames + + +nTypes + + LISTofATOM + + + +XkbKTLevelNames + + +nTypes +, + +nKTLevels + + { count: LISTofCARD8, + names: LISTofATOM } + + + +XkbIndicatorNames + + One per bit set in +indicators + + LISTofATOM + + + +XkbVirtualModNames + + One per bit set in +virtualMods + + LISTofATOM + + + +XkbGroupNames + + One per bit set in +groupNames + + LISTofATOM + + + +XkbKeyNames + + +nKeys + + LISTofKB_KEYNAME + + + +XkbKeyAliases + + +nKeyAliases + + LISTofKB_KEYALIAS + + + +XkbRGNames + + +nRadioGroups + + LISTofATOM + + + + + + +If type names are reported, the +nTypes + return value reports the number of types defined for the keyboard, and the +list of key type names in +valueList + has +nTypes + elements. + + + + +If key type level names are reported, the list of key type level names in the + +valueList + has two parts: The +count + array has +nTypes + elements, each of which reports the number of level names reported for the +corresponding key type. The +names + array has +nKTLevels + atoms and reports the names of each type sequentially. The +nKTLevels + return value is always equal to the sum of all of the elements of the + +count + array. + + + + +If indicator names are reported, the +indicators + mask specifies the indicators for which names are defined; any indicators not +specified in +indicators + have the name +None +. The list of indicator names in +valueList + contains the names of the listed indicators, beginning with the +lowest-numbered indicator for which a name is defined and proceeding to the +highest. + + + + +If virtual modifier names are reported, the +virtualMods + mask specifies the virtual modifiers for which names are defined; any virtual +modifiers not specified in +virtualMods + have the name +None +. The list of virtual modifier names in +valueList + contains the names of the listed virtual modifiers, beginning with the +lowest-numbered virtual modifier for which a name is defined and proceeding to +the highest. + + + + +If group names are reported, the +groupNames + mask specifies the groups for which names are defined; any groups not +specified in +groupNames + have the name +None +. The list of group names in +valueList + contains the names of the listed groups, beginning with the lowest-numbered +group for which a name is defined and proceeding to the highest. + + + + +If key names are reported, the +firstKey + and +nKeys + return values specify a range of keys which includes all keys for which names +are defined; any key that does not fall in the range specified by +firstKey + and +nKeys + has the name +NullKeyName +. The list of key names in the +valueList + has +nKeys + entries and specifies the names of the keys beginning at +firstKey +. + + + + +If key aliases are reported, the +nKeyAliases + return value specifies the total number of key aliases defined for the +keyboard. The list of key aliases in +valueList + has +nKeyAliases + entries, each of which reports an alias and the real name of the key to which +it corresponds. + + + + +If radio group names are reported, the +nRadioGroups + return value specifies the number of radio groups on the keyboard for which +names are defined. The list of radio group names in +valueList + reports the names of each group and has +nRadioGroups + entries. + + + + + + + + + + + XkbSetNames + + + + + deviceSpec: KB_DEVICESPEC + + + which: KB_NAMEDETAILMASK + + + +virtualMods: KB_VMODMASK + + + +firstType, nTypes: CARD8 + + + +firstKTLevel, nKTLevels: CARD8 + + + +totalKTLevelNames: CARD16 + + + +indicators: KB_INDICATORMASK + + + +groupNames: KB_GROUPMASK + + + +nRadioGroups: CARD8 + + + +firstKey: KEYCODE + + + +nKeys, nKeyAliases: CARD8 + + + +valueList: LISTofITEMs + + + + Errors: +Keyboard +, +Atom +, +Value +, +Match +, +Alloc + + + + + + + + +This request changes the symbolic names for the requested components of the +keyboard specified by +deviceSpec +. The +which + field specifies the components for which one or more names are to be updated. +If +deviceSpec + does not specify a valid keyboard device, a +Keyboard + error results. If any undefined bits in +which + are non-zero, a +Value + error results. If any error (other than +Alloc + or +Implementation +) occurs, this request returns without modifying any names. + + + + +The +which + and +valueList + fields specify the components to be changed; the type of each +valueList + entry, the order in which components appear in the +valueList + when specified, and the correspondence between components in +which + and the entries in the +valueList + are as specified for the +XkbGetNames + request. + + + + +If keycodes, geometry, symbols, physical symbols, types or compatibility map +names are to be changed, the corresponding entries in the +valueList + must have the value +None + or specify a valid ATOM, else an +Atom + error occurs. + + + + +If key type names are to be changed, the +firstType + and +nTypes + fields specify a range of types for which new names are supplied, and the list +of key type names in +valueList + has +nTypes + elements. Names for types that fall outside of the range specified by + +firstType + and +nTypes + are not affected. If this request specifies names for types that are not +present on the keyboard, a +Match + error results. All of the type names in the +valueList + must be valid ATOMs or have the value +None +, or an +Atom + error results. + + + + +The names of the first four keyboard types are specified by the XKB extension +and cannot be changed; including any of the canonical types in this request +causes an +Access + error, as does trying to assign the name reserved for a canonical type to one +of the other key types. + + + + +If key type level names are to be changed, the +firstKTLevel + and +nKTLevels + fields specify a range of key types for which new level names are supplied, +and the list of key type level names in the +valueList + has two parts: The +count + array has +nKTLevels + elements, each of which specifies the number of levels for which names are +supplied on the corresponding key type; any levels for which no names are +specified are assigned the name +None +. The +names + array has +totalKTLevels + atoms and specifies the names of each type sequentially. The +totalKTLevels + field must always equal the sum of all of the elements of the +count + array. Level names for types that fall outside of the specified range are not +affected. If this request specifies level names for types that are not present +on the keyboard, or if it specifies more names for a type than the type has +levels, a +Match + error results. All specified type level names must be +None + or a valid ATOM or an +Atom + error results. + + + + +If indicator names are to be changed, the +indicators + mask specifies the indicators for which new names are specified; the names for +indicators not specified in +indicators + are not affected. The list of indicator names in +valueList + contains the new names for the listed indicators, beginning with the +lowest-numbered indicator for which a name is defined and proceeding to the +highest. All specified indicator names must be a valid ATOM or +None +, or an +Atom + error results. + + + + +If virtual modifier names are to be changed, the +virtualMods + mask specifies the virtual modifiers for which new names are specified; names +for any virtual modifiers not specified in +virtualMods + are not affected. The list of virtual modifier names in +valueList + contains the new names for the specified virtual modifiers, beginning with the +lowest-numbered virtual modifier for which a name is defined and proceeding to +the highest. All virtual modifier names must be valid ATOMs or +None +, or an +Atom + error results. + + + + +If group names are to be changed, the +groupNames + mask specifies the groups for which new names are specified; the name of any +group not specified in +groupNames + is not changed. The list of group names in +valueList + contains the new names for the listed groups, beginning with the +lowest-numbered group for which a name is defined and proceeding to the +highest. All specified group names must be a valid ATOM or +None +, or an +Atom + error results. + + + + +If key names are to be changed, the +firstKey + and +nKeys + fields specify a range of keys for which new names are defined; the name of +any key that does not fall in the range specified by +firstKey + and +nKeys + is not changed. The list of key names in the +valueList + has +nKeys + entries and specifies the names of the keys beginning at +firstKey +. + + + + +If key aliases are to be changed, the +nKeyAliases + field specifies the length of a new list of key aliases for the keyboard. The +list of key aliases can only be replaced in its entirety; it cannot be +replaced. The list of key aliases in +valueList + has +nKeyAliases + entries, each of which reports an alias and the real name of the key to which +it corresponds. + + + + +XKB does not check key names or aliases for consistency and validity, so +applications should take care not to assign duplicate names or aliases + + + + +If radio group names are to be changed, the +nRadioGroups + field specifies the length of a new list of radio group names for the +keyboard. There is no way to edit the list of radio group names; it can only be +replaced in its entirety. The list of radio group names in +valueList + reports the names of each group and has +nRadioGroups + entries. If the list of radio group names specifies names for more radio +groups than XKB allows (32), a +Match + error results. All specified radio group names must be valid ATOMs or have the +value +None +, or an +Atom + error results. + + + + + +Querying and Changing Keyboard Geometry + + + + + + + + + XkbGetGeometry + + + + + deviceSpec: KB_DEVICESPEC + + + + +name: ATOM + + + +deviceID: CARD8 + + + + +name: ATOM + + + + +found: BOOL + + + + +widthMM, heightMM: CARD16 + + + + +baseColorNdx, labelColorNdx: CARD8 + + + + +properties: LISTofKB_PROPERTY + + + + +colors: LISTofSTRING8 + + + + +shapes: LISTofKB_SHAPE + + + + +sections: LISTofKB_SECTION + + + + +doodads: LISTofKB_DOODAD + + + + +keyAliases: LISTofKB_KEYALIAS + + + Errors: +Keyboard + + + + + + + +This request returns a description of the physical layout of a keyboard. If the + +name + field has the value +None +, or if name is identical to the name of the geometry for the keyboard +specified by +deviceSpec +, this request returns the geometry of the keyboard specified by +deviceSpec +; otherwise, if +name + is a valid atom other than +None +, the server returns the keyboard geometry description with that name in the +server database of keyboard components (see The Server Database of Keyboard +Components) if one exists. If +deviceSpec + does not specify a valid keyboard device, a +Keyboard + error results. If +name + has a value other than +None + or a valid ATOM, an +Atom + error results. + + + + +On successful return, the +deviceID + field reports the X Input extension identifier of the keyboard device +specified in the request, or +0 + if the server does not support the input extension. + + + + +The +found + return value reports whether the requested geometry was available. If + +found + is +False +, no matching geometry was found and the remaining fields in the request reply +are undefined; if +found + is +True +, the remaining fields of the reply describe the requested keyboard geometry. +The interpretation of the components that make up a keyboard geometry is +described in detail in Keyboard +Geometry + + + + + + + + + + + XkbSetGeometry + + + + + deviceSpec: KB_DEVICESPEC + + + +name: ATOM + + + +widthMM, heightMM, CARD16 + + + +baseColorNdx, labelColorNdx: CARD8 + + + +shapes: LISTofKB_SHAPE + + + +sections: LISTofKB_SECTION + + + +properties: LISTofKB_PROPERTY + + + +colors: LISTofSTRING8 + + + +doodads: LISTofKB_DOODAD + + + +keyAliases: LISTofKB_KEYALIAS + + + + Errors: +Keyboard +, +Atom +, +Value + + + + + + + + +This request changes the reported description of the geometry for the keyboard +specified by +deviceSpec +. If deviceSpec does not specify a valid keyboard device, a +Keyboard + error results. + + + + +The +name + field specifies the name of the new keyboard geometry and must be a valid ATOM +or an +Atom + error results. The new geometry is not added to the server database of +keyboard components, but it can be retrieved using the +XkbGetGeometry + request for as long as it is bound to the keyboard. The keyboard geometry +symbolic name is also updated from the name field, and an +XkbNamesNotify + event is generated, if necessary. + + + + +The list of +colors + must include at least two definitions, or a +Value + error results. All color definitions in the geometry must specify a legal +color (i.e. must specify a valid index for one of the entries of the +colors + list) or a +Match + error results. The +baseColorNdx + and the +labelColorNdx + must be different or a +Match + error results. + + + + +The list of +shapes + must include at least one shape definition, or a +Value + error results. If any two shapes have the same name, a +Match + error result. All doodads and keys which specify shape must specify a valid +index for one of the elements of the +shapes + list, or a +Match + error results. + + + + +All section, shape and doodad names must be valid ATOMs or an +Atom + error results; the constant +None + is not permitted for any of these components. + + + + +All doodads must be of a known type; XKB does not support "private" doodad +types. + + + + +If, after rotation, any keys or doodads fall outside of the bounding box for a +section, the bounding box is automatically adjusted to the minimum size which +encloses all of its components. + + + + +If, after adjustment and rotation, the bounding box of any section or doodad +extends below zero on either the X or Y axes, the entire geometry is translated +so that the minimum extent along either axis is zero. + + + + +If, after rotation and translation, any keyboard components fall outside of the +rectangle specified by +widthMM + and +heightMM +, the keyboard dimensions are automatically resized to the minimum bounding box +that surrounds all components. Otherwise, the width and height of the keyboard +are left as specified. + + + + +The +under + field of any overlay key definitions must specify a key that is in the section +that contains the overlay key, or a +Match + error results. This request does not check the value of the +over + field of an overlay key definition, so applications must be careful to avoid +conflicts with actual keys. + + + + +This request does not verify that key names or aliases are unique. It also does +not verify that all key names specified in the geometry are bound to some +keycode or that all keys that are named in the keyboard definition are also +available in the geometry. Applications should make sure that keyboard geometry +has no internal conflicts and is consistent with the other components of the +keyboard definition, but XKB does not check for or guarantee it. + + + + + +Querying and Changing Per-Client Flags + + + + + + + + + XkbPerClientFlags + + + + + deviceSpec: KB_DEVICESPEC + + + +change: KB_PCFMASK + + + +value: KB_PCFMASK + + + +ctrlsToChange: KB_BOOLCTRLMASK + + + +autoCtrls: KB_BOOLCTRLMASK + + + +autoCtrlValues: KB_BOOLCTRLMASK + + + +deviceID: CARD8 +supported: KB_PCFMASK +value: KB_PCFMASK +autoCtrls: KB_BOOLCTRLMASK +autoCtrlValues: KB_BOOLCTRLMASK +where: KB_PCFMASK: + + + + Errors: +Keyboard +, +Value +, +Match +, +Alloc + + + + + + + + +Changes the client specific flags for the keyboard specified by +deviceSpec +. Reports a +Keyboard + error if +deviceSpec + does not specify a valid keyboard device. + + + + +Any flags specified in +change + are set to the corresponding values in +value +, provided that the server supports the requested control. Legal +per-client-flags are: + + + + + + + + + + Flag… + Described in… + + + + + +XkbPCF_DetectableAutorepeat + + Detectable +Autorepeat + + + +XkbPCF_GrabsUseXKBStateMask + + Setting a Passive Grab +for an XKB State + + + +XkbPCF_AutoResetControlsMask + + Automatic Reset of +Boolean Controls + + + +XkbPCF_LookupStateWhenGrabbed + + Effects of XKB on Core +Protocol Events + + + +XkbPCF_SendEventUsesXKBState + + Sending Events to +Clients + + + + + + +If +PCF_AutoResetControls + is set in both +change + and +value +, the client’s mask of controls to be changed is updated from +ctrlsToChange +, +autoCtrls +, and +autoCtrlValues +. Any controls specified in +ctrlsToChange + are modified in the auto-reset controls mask for the client; the corresponding +bits from the +autoCtrls + field are copied into the auto-reset controls mask and the corresponding bits +from +autoCtrlValues + are copied into the auto-reset controls state values. If any controls are +specified in +autoCtrlValues + but not in +autoCtrls +, a +Match + error results. If any controls are specified in +autoCtrls + but not in +ctrlsToChange +, a +Match + error results. + + + + +If +PCF_AutoResetControls + is set in +change + but not in +value +, the client’s mask of controls to be changed is reset to all zeroes (i.e. +the client does not change any controls when it exits). + + + + +This request reports a +Match + error if a bit is set in any of the value masks but not in the control mask +that governs it or a +Value + error if any undefined bits are set in any of the masks. + + + + +On successful return, the +deviceID + field reports the X Input extension identifier of the keyboard, or +0 + if the server does not support the X Input Extension. + + + + +The +supported + return value reports the set of per-client flags that are supported by the +server; in this version of XKB, only the +XkbPCF_DetectableAutorepeat + per-client flag is optional; all other per-client flags must be supported. + + + + +The +value + return value reports the current settings of all per-client flags for the +specified keyboard. The +autoCtrls + return value reports the current set of controls to be reset when the client +exits, while the +autoCtrlValues + return value reports the state to which they should be set. + + + + + +Using the Server’s Database of Keyboard Components + + + + + + + + + XkbListComponents + + + + + deviceSpec: KB_DEVICESPEC + + + +maxNames: CARD16 + + + +keymapsSpec: STRING8 + + + +keycodesSpec: STRING8 + + + +typesSpec: STRING8 + + + +compatMapSpec: STRING8 + + + +symbolsSpec: STRING8 + + + +geometrySpec: STRING8 + + + + +deviceID: CARD8 + + + + +extra: CARD16 + + + + +keymaps,keycodes,types,compatMaps: LISTofKB_COMPONENTNAME + + + + +symbols, geometries: LISTofKB_COMPONENTNAME + + + Where: + + + KB_COMPONENTNAME { hints: CARD8, name: +STRING8 } + + + Errors: +Keyboard +, +Alloc + + + + + + + +This request returns one or more lists of keyboard components that are +available from the X server database of keyboard components for the device +specified by +deviceSpec +. The X server is allowed, but not required or expected, to maintain separate +databases for each keyboard device. A +Keyboard + error results if +deviceSpec + does not specify a valid keyboard device. + + + + +The +maxNames + field specifies the maximum number of component names to be reported, in +total, by this request. + + + + +The +keymapsSpec +, +keycodesSpec +, +typesSpec +, +compatMapSpec +, +symbolsSpec + and +geometrySpec + request fields specify a pattern to be matched against the names of all +components of the corresponding type in the server database of keyboard +components. + + + + +Each pattern uses the ISO Latin-1 encoding and should contain only parentheses, +the wildcard characters "?" and "*" or characters that are permitted in a +component class or member name (see Component Names). Illegal +characters in a pattern are simply ignored; no error results if a pattern +contains illegal characters. + + + + +Comparison is case-sensitive and, in a pattern, the "?" wildcard character +matches any single character except parentheses while the "*" character matches +any number of characters except parentheses. If an implementation accepts +characters other than those required by XKB, whether or not those characters +match either wildcard is also implementation dependent. An empty pattern does +not match any component names. + + + + +On successful return, the +deviceID + return value reports the X Input Extension device identifier of the specified +device, or +0 + if the server does not support the X input extension. The +extra + return value reports the number of matching component names that could not be +returned due to the setting of the +maxNames + field in the request. + + + + +The +keymaps +, +keycodes +, +types +, +compatMaps +, +symbols + and +geometries + return the hints (see Component +Hints) and names of any components from the server database that match +the corresponding pattern. + + + + +The Server Database of Keyboard +Components describes the X server database of keyboard components in +more detail. + + + + + + + + + + + XkbGetKbdByName + + + + + deviceSpec: KB_DEVICESPEC + + + +need, want: KB_GBNDETAILMASK + + + +load: BOOL + + + +keymapsSpec: STRING8 + + + +keycodesSpec, typesSpec: STRING8 + + + +compatMapSpec, symbolsSpec: STRING8 + + + +geometrySpec: STRING8 + + + + +deviceID: CARD8 + + + + +minKeyCode, maxKeyCode: KEYCODE + + + + +loaded, newKeyboard: BOOL + + + + +found, reported: KB_GBNDETAILMASK + + + + +map: optional +XkbGetMap + reply + + + + +compat: optional +XkbGetCompatMap + reply + + + + +indicators: optional +XkbGetIndicatorMap + reply + + + + +names: optional +XkbGetNames + reply + + + + +geometry: optional +XkbGetGeometry + reply + + + + Errors: +Keyboard +, +Access +, +Alloc + + + + + + + + +Assembles and returns a keymap from the current mapping and specified elements +from the server database of keymap components for the keyboard specified by + +deviceSpec +, and optionally replaces the current keyboard mapping with the newly generated +description. If +deviceSpec + does not specify a valid keyboard device, a +Keyboard + error results. + + + + +The +keymapsSpec +, +keycodesSpec +, +typesSpec +, +compatMapSpec +, +symbolsSpec + and +geometrySpec + component expressions (see +Partial Components and Combining Multiple Components) specify the +database components to be used to assemble the keyboard description. + + + + +The +want + field lists the pieces of the keyboard description that the client wants to +have reported for the newly constructed keymap. The +need + field lists all of the pieces that must be reported. If any of the pieces in + +need + cannot be loaded from the specified names, no description of the keyboard is +returned. + + + + +The +want + and +need + fields can include any combinations of these +XkbGetMapByName + (GBN) components: + + + + + + + + + + + XkbGetMapByName Keyboard Component… + Database Component… + Components of Keyboard Description + + + + + +XkbGBN_Types + + types + key types + + + +XkbGBN_CompatMap + + compat + symbol interpretations, group compatibility map + + + +XkbGBN_ClientSymbols + + symbols, types, keycodes + key types, key symbol mappings, modifier mapping + + + +XkbGBN_ServerSymbols + + symbols, types, keycodes + key behaviors, key actions, key explicit components, virtual +modifiers, virtual modifier mapping + + + +XkbGBN_IndicatorMap + + compat + indicator maps, indicator names + + + +XkbGBN_KeyNames + + keycodes + key names, key aliases + + + +XkbGBN_Geometry + + geometry + keyboard geometry + + + +XkbGBN_OtherNames + + all + key types, symbol interpretations, indicator maps, names, +geometry + + + + + + +If either field contains a GBN component that depends on some database +component for which the request does not supply an expression, XKB +automatically substitutes the special pattern "%" which copies the +corresponding component from the current keyboard description, as described in +Partial Components and Combining +Multiple Components. + + + + +The +load + flag asks the server to replace the current keyboard description for +deviceSpec + with the newly constructed keyboard description. If +load + is +True +, the request must include component expressions for all of the database +components; if any are missing, XKB substitutes "%" as described above. + + + + +If all necessary components are both specified and found, the new keyboard +description is loaded. If the new keyboard description has a different geometry +or keycode range than the previous keyboard description, XKB sends +XkbNewKeyboardNotify + events to all interested clients. See +Replacing the Keyboard +"On-the-Fly" for more information about the effects of replacing the +keyboard description on the fly. + + + + +If the range of keycodes changes, clients that have requested +XkbNewKeyboardNotify + events are not sent any other change notification events by this request. +Clients that do not request +XkbNewKeyboardNotify + events are sent other XKB change notification events (e.g. +XkbMapNotify +, +XkbNamesNotify +) as necessary to alert them to as many of the keyboard changes as possible. + + + + +If no error occurs, the request reply reports the GBN components that were +found and sends a description of any of the resulting keyboard that includes +and of the components that were requested. + + + + +The +deviceID + return value reports the X Input extension device identifier of the keyboard +that was used, or +0 + if the server does not support the X input extension. + + + + +The +minKeyCode + and +maxKeyCode + return values report the legal range of keycodes for the keyboard description +that was created. If the resulting keyboard description does not include at +least one of the key names, client symbols or server symbols components, + +minKeyCode + and +maxKeyCode + are both +0 +. + + + + +The +loaded + return value reports whether or not the existing keyboard definition was +replaced with the newly created one. If +loaded + is +True +, the +newKeyboard + return value reports whether or not the new map changed the geometry or range +of keycodes and caused +XkbNewKeyboardNotify + events for clients that have requested them. + + + + +The +found + return value reports the GBN components that were present in the keymap that +was constructed by this request. The +reported + return value lists the subset of those components for which descriptions +follow. if any of the components specified in the +need + field of the request were not found, +reported + is empty, otherwise it contains the intersection of the +found + return value with the union of the +need + and +want + request fields. + + + + +If any of +GBN_Types +, +GBN_ClientSymbols + or +GBN_ServerSymbols + are set in +reported +, the +map + return value has the same format as the reply to an +XkbGetMap + request and reports the corresponding pieces of the newly constructed keyboard +description. + + + + +If +GBN_CompatMap + is set in +reported +, the +compat + return value has the same format as the reply to an +XkbGetCompatMap + request and reports the symbol interpretations and group compatibility map for +the newly constructed keyboard description. + + + + +If +GBN_IndicatorMap + is set in +reported +, the +indicators + return value has the same format as the reply to an +XkbGetIndicatorMap + request and reports the physical indicators and indicator maps for the newly +constructed keyboard description. + + + + +If +GBN_KeyNames + or +GBN_OtherNames + are set in +reported +, the +names + return value has the same format as the reply to an +XkbGetNames + reply and reports the corresponding set of symbolic names for the newly +constructed keyboard description. + + + + +If +GBN_Geometry + is set in +reported +, the +geometry + return value has the same format as the reply to an +XkbGetGeometryMap + request and reports the keyboard geometry for the newly constructed keyboard +description. + + + + + +Querying and Changing Input Extension Devices + + + + + + + + + XkbGetDeviceInfo + + + + + deviceSpec: KB_DEVICESPEC + + + +wanted: KB_XIDEVFEATUREMASK + + + +ledClass: KB_LEDCLASSSPEC + + + +ledID: KB_IDSPEC + + + +allButtons: BOOL + + + +firstButton, nButtons: CARD8 + + + + +deviceID: CARD8 + + + + +present: KB_XIDEVFEATUREMASK + + + + +supported: KB_XIFEATUREMASK + + + + +unsupported: KB_XIFEATUREMASK + + + + +firstBtnWanted: CARD8 + + + + +nBtnsWanted: CARD8 + + + + +firstBtnRtrn: CARD8 + + + + +nBtnsRtrn: CARD8 + + + + +totalBtns: CARD8 + + + + +hasOwnState: BOOL + + + + +dfltKbdFB, dfltLedFB: KB_IDSPEC + + + + +devType: ATOM + + + + +name: STRING + + + + +btnActions: LISTofKB_ACTION + + + + +leds: LISTofKB_DEVICELEDINFO + + + + Errors: +Device +, +Match +, +Access +, +Alloc + + + + + + + + +Reports a subset of the XKB-supplied information about the input device +specified by +deviceSpec +. Unlike most XKB requests, the device specified for +XkbGetDeviceInfo + need not be a keyboard device. Nonetheless, a +Keyboard + error results if +deviceSpec + does not specify a valid core or input extension device. + + + + +The +wanted + field specifies the types of information to be returned, and controls the +interpretation of the other request fields. + + + + +If the server does not support assignment of XKB actions to extension device +buttons, the +allButtons +, +firstButton + and +nButtons + fields are ignored. + + + + +Otherwise, if the +XkbXI_ButtonActions + flag is set in +wanted +, the +allButtons +, +firstButton + and +nButtons + fields specify the device buttons for which actions should be returned. +Setting +allButtons + to +True + requests actions for all device buttons; if +allButtons + is +False +, +firstButton + and +nButtons + specify a range of buttons for which actions are requested. If the device has +no buttons or if +firstButton + and +nButtons + specify illegal buttons, a +Match + error results. If +allButtons + is +True +, +firstButton + and +nButtons + are ignored. + + + + +If the server does not support XKB access to any aspect of the indicators on +extension devices, or if the +wanted + field does not include any of the indicator flags, the +ledClass + and +ledID + fields are ignored. Otherwise, +ledClass + and +ledID + specify one or more feedback(s) for which indicator information is requested. +If +ledClass + or +ledID + have illegal values, a +Value + error results. If they have legal values but do not specify a keyboard or +indicator class feedback for the device in question, a +Match + error results. + + + + +The +ledClass + field can specify either +KbdFeedbackClass +, +LedFeedbackClass +, +XkbDfltXIClass +, or +XkbAllXIClasses +. If at least one keyboard feedback is defined for the specified device, + +XkbDfltXIClass + is equivalent to +KbdFeedbackClass +, otherwise it is equivalent to +LedFeedbackClass +. If +XkbAllXIClasses + is specified, this request returns information about both indicator and +keyboard class feedbacks which match the requested identifier, as described +below. + + + + +The +ledID + field can specify any valid input extension feedback identifier, +XkbDfltXIId +, or +XkbAllXIIds +. The default keyboard feedback is the one that is affected by core protocol +requests; the default led feedback is implementation-specific. If +XkbAllXIIds + is specified, this request returns indicator information about all feedbacks +of the class(es) specified by +ledClass +. + + + + +If no error results, the +deviceID + return value reports the input extension device identifier of the device for +which values are being returned. The +supported + return value reports the set of optional XKB extension device features that +are supported by this implementation (see + +Interactions Between XKB and the X Input +Extension) for the specified device, and the unsupported return value +reports any +unsupported + features. + + + + +If +hasOwnState + is +True +, the device is also a keyboard, and any indicator maps bound to the device use +the current state and control settings for this device to control automatic +changes. If +hasOwnState + is +False +, the state and control settings of the core keyboard device control automatic +indicator changes. + + + + +The +name + field reports the X Input Extension name for the device. The +devType + field reports the X Input Extension device type. Both fields are provided +merely for convenience and are not interpreted by XKB. + + + + +The +present + return value reports the kinds of device information being returned, and +controls the interpretation of the remaining fields. The +present + field consists of the +wanted + field from the original request minus the flags for any unsupported features. + + + + +If +XkbXI_ButtonActions + is set in +present +, the +totalBtns + return value reports the total number of buttons present on the device, + +firstBtnWanted + and +nBtnsWanted + specify the range of buttons for which actions were requested, and the + +firstBtnRtrn + and +nBtnsRtrn +values specify the range of buttons for which actions are reported. The + +actionsRtrn + list has +nButtonsRtrn + entries which contain the actions bound to the specified buttons on the +device. Any buttons for which actions were requested but not returned have the +action +NoAction() +. + + + + +If any indicator information is reported, the leds list contains one element +for each requested feedback. For example, if +ledClass + is +XkbAllXIClasses + and +ledID + is +XkbAllXIIds +, +leds + describes all of the indicators on the device and has one element for each +keyboard or led class feedback defined for the device. If any information at +all is reported about a feedback, the set of physical indicators is also +reported in the +physIndicators + field of the corresponding element of +leds +. + + + + +If the server supports assignment of indicator maps to extension device +indicators, and if the +XkbXI_IndicatorMaps + flag is set in +wanted +, each member of +leds + reports any indicators on the corresponding feedback to which names have been +assigned. Any indicators for which no map is reported have the default map, +which allows explicit changes and does not request any automatic changes. + + + + +If the server supports assignment of indicator names to extension device +indicators, and the +XkbXI_IndicatorNames + flag is set in +wanted +, each member of +leds + reports any indicators on the corresponding feedback to which names have been +assigned. Any indicators for which no name is reported have the name +None +. + + + + +If the server supports XKB access to the state of extension device indicators, +and the +XkbXI_IndicatorState + flag is set in wanted, each member of leds reports the state of the indicators +on the corresponding feedback. + + + + +If any unsupported features are requested, and the requesting client has +selected for them, the server sends the client an +XkbExtensionDeviceNotify + event which indicates that an unsupported feature was requested. This event is +only generated if the client which issued the unsupported request has selected +for it and, if generated, is not sent to any other clients. + + + + + + + + + + + XkbSetDeviceInfo + + + + + deviceSpec: KB_DEVICESPEC + + + +change: KB_XIDEVFEATUREMASK + + + +firstBtn, nBtns: CARD8 + + + +btnActions:LISTofKB_ACTION + + + +leds: LISTofKB_DEVICELEDINFO + + + + Errors: +Device +, +Match +, +Access +, +Alloc + + + + + + + + +Changes a subset of the XKB-supplied information about the input device +specified by +deviceSpec +. Unlike most XKB requests, the device specified for +XkbGetDeviceInfo + need not be a keyboard device. Nonetheless, a +Keyboard + error results if +deviceSpec + does not specify a valid core or input extension device + + + + +The +change + field specifies the features for which new values are supplied, and controls +the interpretation of the other request fields. + + + + +If the server does not support assignment of XKB actions to extension device +buttons, the +firstButton + and +nButtons + fields are ignored. + + + + +Otherwise, if the +XkbXI_ButtonActions + flag is set in +change +, the +firstBtn + and +nBtns + fields specify a range of buttons for which actions are specified in this +request. If the device has no buttons or if +firstBtn + and +nBtns + specify illegal buttons, a +Match + error results. + + + + +Each element of the +leds + list describes the changes for a single keyboard or led feedback. If the + +ledClass + field of any element of +leds + contains any value other than +KbdFeedbackClass +, +LedFeedbackClass + or +XkbDfltXIClass +, a +Value + error results. If the +ledId + field of any element of leds contains any value other than a valid input +extension feedback identifier or +XkbDfltXIId +, a +Value + error results. If both fields are valid, but the device has no matching +feedback, a +Match + error results. + + + + +The fields of each element of +leds + are interpreted as follows: + + + + + If +XkbXI_IndicatorMaps + is set in +change + and the server supports XKB assignment of indicator maps to the corresponding +feedback, the maps for all indicators on the corresponding feedback are taken +from +leds +. If the server does not support this feature, any maps specified in +leds + are ignored. + + + + If +XkbXI_IndicatorNames + is set in +change +, and the server supports XKB assignment of names to indicators for the +corresponding feedback, the names for all indicators on the corresponding +feedback are taken from +leds +. If the server does not support this feature, any names specified in +leds + are ignored. Regardless of whether they are used, any names be a valid Atom or + +None +, or an +Atom + error results. + + + + If +XkbXI_IndicatorState + is set in change, and the server supports XKB changes to extension device +indicator state, the server attempts to change the indicators on the +corresponding feedback as specified by +leds +. Any indicator maps bound to the feedback are applied, so state changes might +be blocked or have side-effects. + + + + + +If any unsupported features are requested, and the requesting client has +selected for them, the server sends the client an +XkbExtensionDeviceNotify + event which indicates that an unsupported feature was requested. This event is +only generated if the client which issued the unsupported request has selected +for it and, if generated, is not sent to any other clients. + + + + + +Debugging the X Keyboard Extension + + + + + + + + + XkbSetDebuggingFlags + + + + + affectFlags, flags: CARD32 + + + +affectCtrls, ctrls: CARD32 + + + +message: STRING + + + + +currentFlags, supportedFlags: CARD32 + + + + +currentCtrls, supportedCtrls: CARD32 + + + + + + + +This request sets up various internal XKB debugging flags and controls. It is +intended for developer use and may be disabled in production servers. If +disabled, +XkbSetDebuggingFlags + has no effect but returns +Success +. + + + + +The +affectFlags + field specifies the debugging flags to be changed, the +flags + field specifies new values for the changed flags. The interpretation of the +debugging flags is implementation-specific, but flags are intended to control +debugging output and should not otherwise affect the operation of the server. + + + + +The +affectCtrls + field specifies the debugging controls to be changed, the +ctrls + field specifies new values for the changed controls. The interpretation of the +debugging controls is implementation-specific, but debugging controls are +allowed to affect the behavior of the server. + + + + +The +message + field provides a message that the X server can print in any logging or +debugging files before changing the flags. The server must accept this field +but it is not required to actually display it anywhere. + + + + +The X Test Suite makes some assumptions about the implementation of locking +modifier keys that do not apply when XKB is present. The +XkbDF_DisableLocks + debugging control provides a simple workaround to these test suite problems by +simply disabling all locking keys. If +XkbDF_DisableLocks + is enabled, the +SA_LockMods + and +SA_LockGroup + actions behave like +SA_SetMods + and +SA_LockMods +, respectively. If it is disabled, +SA_LockMods + and +SA_LockGroup + actions behave normally. + + + + +Implementations are free to ignore the +XkbDF_DisableLocks + debugging control or to define others. + + + + +The +currentFlags + return value reports the current setting for the debugging flags, if +applicable. The +currentCtrls + return value reports the setting for the debugging controls, if applicable. +The +supportedFlags + and +supportedCtrls + fields report the flags and controls that are recognized by the +implementation. Attempts to change unsupported fields or controls are silently +ignored. + + + + +If the +XkbSetDebuggingFlags + request contains more data than expected, the server ignores the extra data, +but no error results. If the request has less data than expected, a +Length + error results. + + + + +If the +XkbSetDebuggingFlags + reply contains more data than expected, the client just ignores any +uninterpreted data without reporting an error. If the reply has less data than +expected, a +Length + error results. + + + + + + +Events + + +All XKB events report the time at which they occurred in a field named + +time + and the device on which they occurred in a field named +deviceID +. XKB uses a single X event code for all events and uses a common field to +distinguish XKB event type. + + + + +Tracking Keyboard Replacement + + + + + + + + + XkbNewKeyboardNotify + + + + + time: TIMESTAMP + + + +deviceID: CARD8 + + + +changed: KB_NKNDETAILMASK + + + +minKeyCode, maxKeyCode: KEYCODE + + + +oldDeviceID: CARD8 + + + +oldMinKeyCode, oldMaxKeyCode: KEYCODE + + + +requestMajor, requestMinor: CARD8 + + + + + + + +An +XkbNewKeyboardNotify + event reports that a new core keyboard has been installed. New keyboard notify +events can be generated: + + + + + When the X server detects that the keyboard was changed. + + + + When a client installs a new extension device as the core keyboard +using the X Input Extension +ChangeKeyboardDevice + request. + + + + When a client issues an +XkbGetMapByName + request which changes the keycodes range or geometry. + + + + + +The +changed + field of the event reports the aspects of the keyboard that have changed, and +can contain any combination of the event details for this event: + + + + + + + + + + Bit in Changed + Meaning + + + + + NKN_Keycodes + The new keyboard has a different minimum or maximum keycode. + + + NKN_Geometry + The new keyboard has a different keyboard geometry. + + + NKN_DeviceID + The new keyboard has a new X Input Extension device +identifier + + + + + + +The server sends an +XkbNewKeyboardNotify + event to a client only if at least one of the bits that is set in the + +changed + field of the event is also set in the appropriate event details mask for the +client. + + + + +The +minKeyCode + and +maxKeyCode + fields report the minimum and maximum keycodes that can be returned by the new +keyboard. The +oldMinKeyCode + and +oldMaxKeyCode + fields report the minimum and maximum values that could be returned before the +change. This event always reports all four values, but the old and new values +are the same unless +NKN_Keycodes + is set in +changed +. + + + + +Once a client receives a new keyboard notify event which reports a new keycode +range, the X server reports events from all keys in the new range to that +client. Clients that do not request or receive new keyboard notify events +receive events only from keys that fall in the last range for legal keys +reported to that client. See +Replacing the Keyboard "On-the-Fly" for a more detailed explanation. + + + + +If +NKN_Keycodes + is set in +changed +, the +XkbNewKeyboardNotify + event subsumes all other change notification events (e.g. +XkbMapNotify +, +XkbNamesNotify +) that would otherwise result from the keyboard change. Clients who receive an + +XkbNewKeyboardNotify + event should assume that all other aspects of the keyboard mapping have +changed and regenerate the entire local copy of the keyboard description. + + + + +The +deviceID + field reports the X Input Extension device identifier of the new keyboard +device; +oldDeviceID + reports the device identifier before the change. This event always includes +both values, but they are the same unless +NKN_DeviceID + is set in +changed +. If the server does not support the X Input Extension, both fields have the +value +0 +. + + + + +The +requestMajor + and +requestMinor + fields report the major and minor opcode of the request that caused the +keyboard change. If the keyboard change was not caused by some client request, +both fields have the value +0 +. + + + + + +Tracking Keyboard Mapping Changes + + + + + + + + + XkbMapNotify + + + + + time: TIMESTAMP + + + +deviceID: CARD8 + + + +ptrBtnActions: CARD8 + + + +changed: KB_MAPPARTMASK + + + +minKeyCode, maxKeyCode: KEYCODE + + + +firstType, nTypes: CARD8 + + + +firstKeySym, firstKeyAction: KEYCODE + + + +nKeySyms, nKeyActions: CARD8 + + + +firstKeyBehavior, firstKeyExplicit: KEYCODE + + + +nKeyBehaviors, nKeyExplicit: CARD8 + + + +virtualMods: KB_VMODMASK + + + +firstModMapKey, firstVModMapKey: KEYCODE + + + +nModMapKeys, nVModMapKeys: CARD8 + + + + + + + +An +XkbMapNotify + event reports that some aspect of XKB map for a keyboard has changed. Map +notify events can be generated whenever some aspect of the keyboard map is +changed by an XKB or core protocol request. + + + + +The +deviceID + field reports the keyboard for which some map component has changed and the + +changed + field reports the components with new values, and can contain any of the +values that are legal for the +full + and +partial + fields of the +XkbGetMap + request. The server sends an +XkbMapNotify + event to a client only if at least one of the bits that is set in the + +changed + field of the event is also set in the appropriate event details mask for the +client. + + + + +The +minKeyCode + and +maxKeyCode + fields report the range of keycodes that are legal on the keyboard for which +the change is being reported. + + + + +If +XkbKeyTypesMask + is set in +changed +, the +firstType + and +nTypes + fields report a range of key types that includes all changed types. Otherwise, +both fields are +0 +. + + + + +If +XkbKeySymsMask + is set in +changed +, the +firstKeySym + and +nKeySyms + fields report a range of keycodes that includes all keys with new symbols. +Otherwise, both fields are +0 +. + + + + +If +XkbKeyActionsMask + is set in +changed +, the +firstKeyAction + and +nKeyActions + fields report a range of keycodes that includes all keys with new actions. +Otherwise, both fields are +0 +. + + + + +If +XkbKeyBehaviorsMask + is set in +changed +, the +firstKeyBehavior +and +nKeyBehaviors + fields report a range of keycodes that includes all keys with new key +behavior. Otherwise, both fields are +0 +. + + + + +If +XkbVirtualModsMask + is set in +changed +, +virtualMods + contains all virtual modifiers to which a new set of real modifiers is bound. +Otherwise, +virtualMods + is +0 +. + + + + +If +XkbExplicitComponentsMask + is set in +changed +, the +firstKeyExplicit + and +nKeyExplicit + fields report a range of keycodes that includes all keys with changed explicit +components. Otherwise, both fields are +0 +. + + + + +If +XkbModifierMapMask + is set in +changed +, the +firstModMapKey + and +nModMapKeys + fields report a range of keycodes that includes all keys with changed modifier +bindings. Otherwise, both fields are +0 +. + + + + +If +XkbVirtualModMapMask + is set in +changed +, the +firstVModMapKey + and +nVModMapKeys + fields report a range of keycodes that includes all keys with changed virtual +modifier mappings. Otherwise, both fields are +0 +. + + + + + +Tracking Keyboard State Changes + + + + + + + + + XkbStateNotify + + + + + time: TIMESTAMP + + + +deviceID: CARD8 + + + +mods, baseMods, latchedMods, lockedMods: KEYMASK + + + +group, lockedGroup: CARD8 + + + +baseGroup, latchedGroup: INT16 + + + +compatState: KEYMASK + + + +grabMods, compatGrabMods: KEYMASK + + + +lookupMods, compatLookupMods: KEYMASK + + + +ptrBtnState: BUTMASK + + + +changed: KB_STATEPARTMASK + + + +keycode: KEYCODE + + + +eventType: CARD8 + + + +requestMajor, requestMinor: CARD8 + + + + + + + +An XkbStateNotify +event reports that some component of the XKB state (see +Keyboard State) has changed. +State notify events are usually caused by key or pointer activity, but they can +also result from explicit state changes requested by the +XkbLatchLockState + request or by other extensions. + + + + +The +deviceID + field reports the keyboard on which some state component changed. The + +changed + field reports the XKB state components (see +Keyboard State) that have changed +and contain any combination of: + + + + + + + + + + + Bit in changed + Event field + Changed component + + + + + +ModifierState + + +mods + + The effective modifiers + + + +ModifierBase + + +baseMods + + The base modifiers + + + +ModifierLatch + + +latchedMods + + The latched modifiers + + + +ModifierLock + + +lockedMods + + The locked modifiers + + + +GroupState + + +group + + The effective keyboard group + + + +GroupBase + + +baseGroup + + The base keyboard group + + + +GroupLatch + + +latchedGroup + + The latched keyboard group + + + +GroupLock + + +lockedGroup + + The locked keyboard group + + + +PointerButtons + + +ptrBtnState + + The state of the core pointer buttons + + + +GrabMods + + +grabMods + + The XKB state used to compute grabs + + + +LookupMods + + +lookupMods + + The XKB state used to look up symbols + + + +CompatState + + +compatState + + Default state for non-XKB clients + + + +CompatGrabMods + + +compatGrabMods + + The core state used to compute grabs + + + +CompatLookupMods + + +compatLookupMods + + The core state used to look up symbols + + + + + + +The server sends an +XkbStateNotify + event to a client only if at least one of the bits that is set in the + +changed + field of the event is also set in the appropriate event details mask for the +client. + + + + +A state notify event reports current values for all state components, even +those with unchanged values. + + + + +The +keycode + field reports the key or button which caused the change in state while the + +eventType + field reports the exact type of event (e.g. +KeyPress +). If the change in state was not caused by key or button activity, both fields +have the value +0 +. + + + + +The +requestMajor + and +requestMinor + fields report the major and minor opcodes of the request that caused the +change in state and have the value +0 + if it was resulted from key or button activity. + + + + + +Tracking Keyboard Control Changes + + + + + + + + + XkbControlsNotify + + + + + time: TIMESTAMP + + + +deviceID: CARD8 + + + +numGroups: CARD8 + + + +changedControls: KB_CONTROLMASK + + + +enabledControls,enabledControlChanges: KB_BOOLCTRLMASK + + + +keycode: KEYCODE + + + +eventType: CARD8 + + + +requestMajor: CARD8 + + + +requestMinor: CARD8 + + + + + + + +An +XkbControlsNotify + event reports a change in one or more of the global keyboard controls (see +Global Keyboard Controls) +or in the internal modifiers or ignore locks masks (see + +Server Internal Modifiers and Ignore +Locks Behavior). Controls notify events are usually caused by and + +XkbSetControls + request, but they can also be caused by keyboard activity or certain core +protocol and input extension requests. + + + + +The +deviceID + field reports the keyboard for which some control has changed, and the + +changed + field reports the controls that have new values. + + + + +The +changed + field can contain any of the values that are permitted for the +changeControls + field of the +XkbSetControls + request. The server sends an +XkbControlsNotify + event to a client only if at least one of the bits that is set in the + +changed + field of the event is also set in the appropriate event details mask for the +client. + + + + +The +numGroups + field reports the total number of groups defined for the keyboard, whether or +not the number of groups has changed. + + + + +The +enabledControls + field reports the current status of all of the boolean controls, whether or +not any boolean controls changed state. If +EnabledControls + is set in +changed +, the +enabledControlChanges + field reports the boolean controls that were enabled or disabled; if a control +is specified in +enabledControlChanges +, the value that is reported for that control in +enabledControls + represents a change in state. + + + + +The +keycode + field reports the key or button which caused the change in state while the + +eventType + field reports the exact type of event (e.g. +KeyPress +). If the change in state was not caused by key or button activity, both fields +have the value +0 +. + + + + +The +requestMajor + and +requestMinor + fields report the major and minor opcodes of the request that caused the +change in state and have the value +0 + if it was resulted from key or button activity. + + + + + +Tracking Keyboard Indicator State Changes + + + + + + + + + XkbIndicatorStateNotify + + + + + time: TIMESTAMP + + + +deviceID: CARD8 + + + +stateChanged, state: KB_INDICATORMASK + + + + + + + +An +XkbIndicatorStateNotify + event indicates that one or more of the indicators on a keyboard have changed +state. Indicator state notify events can be caused by: + + + + + Automatic update to reflect changes in keyboard state (keyboard +activity, +XkbLatchLockState + requests). + + + + Automatic update to reflect changes in keyboard controls ( +XkbSetControls +, keyboard activity, certain core protocol and input extension requests). + + + + Explicit attempts to change indicator state (core protocol and input +extension requests, +XkbSetNamedIndicator + requests). + + + + Changes to indicator maps ( +XkbSetIndicatorMap + and +XkbSetNamedIndicator + requests). + + + + + +The +deviceID + field reports the keyboard for which some indicator has changed, and the + +state + field reports the new state for all indicators on the specified keyboard. The + +stateChanged + field specifies which of the values in +state + represent a new state for the corresponding indicator. The server sends an + +XkbIndicatorStateNotify + event to a client only if at least one of the bits that is set in the + +stateChanged + field of the event is also set in the appropriate event details mask for the +client. + + + + + +Tracking Keyboard Indicator Map Changes + + + + + + + + + XkbIndicatorMapNotify + + + + + time: TIMESTAMP + + + +deviceID: CARD8 + + + +state: KB_INDICATORMASK + + + +mapChanged: KB_INDICATORMASK + + + + + + + +An +XkbIndicatorMapNotify + event indicates that the maps for one or more keyboard indicators have been +changed. Indicator map notify events can be caused by +XkbSetIndicatorMap + and +XkbSetNamedIndicator + requests. + + + + +The +deviceID + field reports the keyboard for which some indicator map has changed, and the + +mapChanged + field reports the indicators with changed maps. The server sends an +XkbIndicatorMapNotify + event to a client only if at least one of the bits that is set in the + +mapChanged + field of the event is also set in the appropriate event details mask for the +client. + + + + +The +state + field reports the current state of all indicators on the specified keyboard. + + + + + +Tracking Keyboard Name Changes + + + + + + + + + XkbNamesNotify + + + + + time: TIMESTAMP + + + +deviceID: CARD8 + + + +changed: KB_NAMEDETAILMASK + + + +firstType, nTypes: CARD8 + + + +firstLevelName, nLevelNames: CARD8 + + + +firstKey: KEYCODE + + + +nKeys, nKeyAliases, nRadioGroups: CARD8 + + + +changedGroupNames: KB_GROUPMASK + + + +changedVirtualMods: KB_VMODMASK + + + +changedIndicators: KB_INDICATORMASK + + + + + + + +An +XkbNamesNotify + event reports a change to one or more of the symbolic names associated with a +keyboard. Symbolic names can change when: + + + + + Some client explicitly changes them using +XkbSetNames +. + + + + The list of key types or radio groups is resized + + + + The group width of some key type is changed + + + + + +The +deviceID + field reports the keyboard on which names were changed. The +changed + mask lists the components for which some names have changed and can have any +combination of the values permitted for the +which + field of the +XkbGetNames + request. The server sends an +XkbNamesNotify + event to a client only if at least one of the bits that is set in the + +changed + field of the event is also set in the appropriate event details mask for the +client. + + + + +If +KeyTypeNames + is set in +changed +, the +firstType + and +nTypes + fields report a range of types that includes all types with changed names. +Otherwise, both fields are +0 +. + + + + +If +KTLevelNames + is set in +changed +, the +firstLevelName + and +nLevelNames + fields report a range of types that includes all types with changed level +names. Otherwise, both fields are +0 +. + + + + +If +IndicatorNames + is set in +changed +, the +changedIndicators + field reports the indicators with changed names. Otherwise, +changedIndicators + is +0 +. + + + + +If +VirtualModNames + is set in +changed +, the +changedVirtualMods + field reports the virtual modifiers with changed names. Otherwise, +changedVirtualMods + is +0 +. + + + + +If +GroupNames + is set in +changed +, the +changedGroupNames + field reports the groups with changed names. Otherwise, +changedGroupNames + is +0 +. + + + + +If +KeyNames + is set in +changed +, the +firstKey + and +nKeys + fields report a range of keycodes that includes all keys with changed names. +Otherwise, both fields are +0 +. + + + + +The +nKeyAliases + field reports the total number of key aliases associated with the keyboard, +regardless of whether +KeyAliases + is set in +changed +. + + + + +The +nRadioGroups + field reports the total number of radio group names associated with the +keyboard, regardless of whether +RGNames + is set in +changed +. + + + + + +Tracking Compatibility Map Changes + + + + + + + + + XkbCompatMapNotify + + + + + time: TIMESTAMP + + + +deviceID: CARD8 + + + +changedGroups: KB_GROUPMASK + + + +firstSI, nSI: CARD16 + + + +nTotalSI: CARD16 + + + + + + + +An +XkbCompatMapNotify + event indicates that some component of the compatibility map for a keyboard +has been changed. Compatibility map notify events can be caused by +XkbSetCompatMap + and +XkbGetMapByName + requests. + + + + +The +deviceID + field reports the keyboard for which the compatibility map has changed; if the +server does not support the X input extension, +deviceID + is +0 +. + + + + +The +changedGroups + field reports the keyboard groups, if any, with a changed entry in the group +compatibility map. The +firstSI + and +nSI + fields specify a range of symbol interpretations in the symbol compatibility +map that includes all changed symbol interpretations; if the symbol +compatibility map is unchanged, both fields are +0 +. The +nTotalSI + field always reports the total number of symbol interpretations present in the +symbol compatibility map, regardless of whether any symbol interpretations have +been changed. + + + + +The server sends an +XkbCompatMapNotify + event to a client only if at least one of the following conditions is met: + + + + + The +nSI + field of the event is non-zero, and the +XkbSymInterpMask + bit is set in the appropriate event details mask for the client. + + + + The +changedGroups + field of the event contains at least one group, and the +XkbGroupCompatMask + bit is set in the appropriate event details mask for the client. + + + + + + +Tracking Application Bell Requests + + + + + + + + + XkbBellNotify + + + + + time: TIMESTAMP + + + +deviceID: CARD8 + + + +bellClass: { KbdFeedbackClass, BellFeedbackClass } + + + +bellID: CARD8 + + + +percent: CARD8 + + + +pitch: CARD16 + + + +duration: CARD16 + + + +eventOnly: BOOL + + + +name: ATOM + + + +window: WINDOW + + + + + + + +An +XkbBellNotify + event indicates that some client has requested a keyboard bell. Bell notify +events are usually caused by +Bell +, +DeviceBell +, or +XkbBell + requests, but they can also be generated by the server (e.g. if the +AccessXFeedback + control is active). + + + + +The server sends an +XkbBellNotify + event to a client if the appropriate event details field for the client has +the value +True +. + + + + +The +deviceID + field specifies the device for which a bell was requested, while the +bellClass + and +bellID + fields specify the input extension class and identifier of the feedback for +which the bell was requested. If the reporting server does not support the +input extension, all three fields have the value 0. + + + + +The +percent +, +pitch + and +duration + fields report the volume, tone and duration requested for the bell as +specified by the +XkbBell + request. Bell notify events caused by core protocol or input extension +requests use the pitch and duration specified in the corresponding bell or +keyboard feedback control. + + + + +If the bell was caused by an +XkbBell + request or by the X server, +name + reports an optional symbolic name for the bell and the +window + field optionally reports the window for which the bell was generated. +Otherwise, both fields have the value +None +. + + + + +If the +eventOnly + field is +True +, the server did not generate a sound in response to the request, otherwise the +server issues the beep before sending the event. The eventOnly field can be + +True + if the +AudibleBell + control is disabled or if a client explicitly requests +eventOnly + when it issues an +XkbBell + request. + + + + + +Tracking Messages Generated by Key Actions + + + + + + + + + XkbActionMessage + + + + + time: TIMESTAMP + + + +deviceID: CARD8 + + + +keycode: KEYCODE + + + +press: BOOL + + + +mods: KEYMASK + + + +group: KB_GROUP + + + +keyEventFollows: BOOL + + + +message: LISTofCARD8 + + + + + + + +An +XkbActionMessage + event is generated when the user operates a key to which an +SA_ActionMessage + message is bound under the appropriate state and group. The server sends an + +XkbActionMessage + event to a client if the appropriate event details field for the client has +the value +True +. + + + + +The +deviceID + field specifies the keyboard device that contains the key which activated the +event. The +keycode + field specifies the key whose operation caused the message and press is + +True + if the message was caused by the user pressing the key. The +mods + and +group + fields report the effective keyboard modifiers and group in effect at the time +the key was pressed or released. + + + + +If +keyEventFollows + is +True +, the server will also send a key press or release event, as appropriate, for +the key that generated the message. If it is +False +, the key causes only a message. Note that the key event is delivered normally +with respect to passive grabs, keyboard focus, and cursor position, so that + +keyEventFollows + does not guarantee that any particular client which receives the +XkbActionMessage + notify event will also receive a key press or release event. + + + + +The +message + field is +NULL +-terminated string of up to +ActionMessageLength + ( +6 +) bytes, which reports the contents of the +message + field in the action that caused the message notify event. + + + + + +Tracking Changes to AccessX State and Keys + + + + + + + + + XkbAccessXNotify + + + + + time: TIMESTAMP + + + +deviceID: CARD8 + + + +detail: KB_AXNDETAILMASK + + + +keycode: KEYCODE + + + +slowKeysDelay: CARD16 + + + +debounceDelay: CARD16 + + + + + + + +An +XkbAccessXNotify + event reports on some kinds of keyboard activity when any of the +SlowKeys +, +BounceKeys + or +AccessXKeys + controls are active. Compatibility map notify events can only be caused by +keyboard activity. + + + + +The +deviceID + and +keycode + fields specify the keyboard and key for which the event occurred. The + +detail + field describes the event that occurred and has one of the following values: + + + + + + + + + + + Detail + Control + Meaning + + + + + +AXN_SKPress + + +SlowKeys + + Key pressed + + + +AXN_SKAccept + + +SlowKeys + + +K +ey held until it was accepted. + + + +AXN_SKReject + + +SlowKeys + + Key released before it was accepted. + + + +AXN_SKRelease + + +SlowKeys + + Key released after it was accepted. + + + +AXN_BKAccept + + +BounceKeys + + Key pressed while it was active. + + + +AXN_BKReject + + +BounceKeys + + Key pressed while it was still disabled. + + + +AXN_AXKWarning + + +AccessXKeys + + Shift key held down for four seconds + + + + + + +Each subclass of the AccessX notify event is generated only when the control +specified in the table above is enabled. The server sends an +XkbAccessXNotify + event to a client only if the bit which corresponds to the value of the + +detail + field for the event is set in the appropriate event details mask for the +client. + + + + +Regardless of the value of +detail +, the +slowKeysDelay + and +debounceDelay + fields always reports the current slow keys acceptance delay (see +The SlowKeys Control) and +debounce delay (see The BounceKeys +Control) for the specified keyboard. + + + + + +Tracking Changes To Extension Devices + + + + + + + + + XkbExtensionDeviceNotify + + + + + time: TIMESTAMP + + + +deviceID: CARD16 + + + +ledClass: { KbdFeedbackClass, LedFeedbackClass } + + + +ledID: CARD16 + + + +reason: KB_XIDETAILMASK + + + +supported: KB_XIFEATUREMASK + + + +unsupported: KB_XIFEATUREMASK + + + +ledsDefined: KB_INDICATORMASK + + + +ledState: KB_INDICATORMASK + + + +firstButton, nButtons: CARD8 + + + + + + + +An +XkbExtensionDeviceNotify + event reports: + + + + + A change to some part of the XKB information for an extension device. + + + + An attempt to use an XKB extension device feature that is not supported +for the specified device by the current implementation. + + + + + +The +deviceID + field specifies the X Input Extension device identifier of some device on +which an XKB feature was requested, or +XkbUseCorePtr + if the request affected the core pointer device. The +reason + field explains why the event was generated in response to the request, and can +contain any combination of +XkbXI_UnsupportedFeature + and the values permitted for the change field of the +XkbSetDeviceInfo + request. + + + + +If +XkbXI_ButtonActions + is set in +reason +, this event reports a successful change to the XKB actions bound to one or +more buttons on the core pointer or an extension device. The +firstButton + and +nButtons + fields report a range of device buttons that include all of the buttons for +which actions were changed. + + + + +If any combination of +XkbXI_IndicatorNames +, +XkbXI_IndicatorMaps +, or +XkbXI_IndicatorState + is set in either +reason + or +unsupported +, the +ledClass + and +ledID + fields specify the X Input Extension feedback class and identifier of the +feedback for which the change is reported. If this event reports any changes to +an indicator feedback, the +ledsDefined + field reports all indicators on that feedback for which either a name or a +indicator map are defined, and +ledState + reports the current state of all of the indicators on the specified feedback. + + + + +If +XkbXI_IndicatorNames + is set in +reason +, this event reports a successful change to the symbolic names bound to one or +more extension device indicators by XKB. If +XkbXI_IndicatorMaps + is set in +reason +, this event reports a successful change to the indicator maps bound to one or +more extension device indicators by XKB. If +XkbXI_IndicatorState + is set in reason, this event reports that one or more indicators in the +specified device and feedback have changed state. + + + + +If +XkbXI_UnsupportedFeature + is set in reason, this event reports an unsuccessful attempt to use some XKB +extension device feature that is not supported by the XKB implementation in the +server for the specified device. The +unsupported + mask reports the requested features that are not available on the specified +device. See Interactions Between +XKB and the X Input Extension for more information about possible XKB +interactions with the X Input Extension. + + + + +The server sends an +XkbExtensionDeviceNotify + event to a client only if at least one of the bits that is set in the + +reason + field of the event is also set in the appropriate event details mask for the +client. + + + + +Events that report a successful change to some extension device feature are +reported to all clients that have expressed interest in the event; events that +report an attempt to use an unsupported feature are reported only to the client +which issued the request. Events which report a partial success are reported to +all interested clients, but only the client that issued the request is informed +of the attempt to use unsupported features. + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/xkbproto.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/xkbproto.xml new file mode 100644 index 0000000000000000000000000000000000000000..20f98d57e77273375d4aceb47a2fbacf03d95001 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/kbproto/xkbproto.xml @@ -0,0 +1,70 @@ + + %defs; +]> + + + + + The X Keyboard Extension: Protocol Specification + X Consortium Standard + + Erik + Fortune + Silicon Graphics, Inc + + X Version 11, Release &fullrelvers; + Version 1.0 + 19951996 + X Consortium Inc. + Silicon Graphics Inc. + Hewlett-Packard Company + Digital Equipment Corporation + + + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + + +THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + +Except as contained in this notice, the names of the X Consortium, Silicon Graphics Inc., Hewlett-Packard Company, and Digital Equipment Corporation shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/recordproto/record.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/recordproto/record.xml new file mode 100644 index 0000000000000000000000000000000000000000..6b158957e48219bb78461f52a94e739aa73d1e1d --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/recordproto/record.xml @@ -0,0 +1,1904 @@ + + %defs; +]> + + + + + + + Record Extension Protocol Specification + X Consortium Standard + + + MarthaZimet + Network Computing Devices, Inc. + + + StephenGildea + X Consortium + + + X Version 11, Release &fullrelvers; + 1994Network Computing Devices, Inc. + + + + +Permission to use, copy, modify, distribute, and sell this +documentation for any purpose is hereby granted without fee, +provided that the above copyright notice and this permission +notice appear in all copies. Network Computing Devices, Inc. +makes no representations about the suitability for any purpose +of the information in this document. This documentation is +provided “as is” without express or implied warranty. + + + + +Copyright © 1994, 1995 X Consortium + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + + + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + + + +THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + + + +Except as contained in this notice, the name of the X Consortium and +shall not be used in advertising or otherwise to promote the sale, use +or other dealings in this Software without prior written authorization +from the X Consortium. + +X Window System is a trademark of The Open Group. + + + + +Introduction + +Several proposals have been written over the past few years that address some +of the issues surrounding the recording and playback of user actions +in the X Window System +X Window System is a trademark of The Open Group. + +: + + + + + +Some Proposals for a Minimal X11 Testing Extension, +Kieron Drake, UniSoft Ltd., April 1991 + + + + +X11 Input Synthesis Extension Proposal, Larry Woestman, +Hewlett Packard, November 1991 + + + + +XTrap Architecture, Dick Annicchiario, et al, Digital Equipment Corporation, +July 1991 + + + + +XTest Extension Recording Specification, Yochanan Slonim, +Mercury Interactive, December 1992 + + + + + +This document both unifies and extends the previous diverse approaches +to generate a proposal for an X extension that provides support for +the recording of all core X protocol and arbitrary extension protocol. +Input synthesis, or playback, has already been implemented in the +XTest extension, an X Consortium standard. Therefore, this extension +is limited to recording. + + + +In order to provide both record and playback functionality, a +hypothetical record application could use this extension to capture +both user actions and their consequences. For example, a button press +(a user action) may cause a window to be mapped and a corresponding +MapNotify +event to be sent (a consequence). This information could be +stored for later use by a playback application. + + + +The playback application could use the recorded actions as input for +the XTest extension's +XTestFakeInput +operation to synthesize the +appropriate input events. The "consequence" or synchronization +information is then used as a synchronization point during playback. +That is, the playback application does not generate specific +synthesized events until their matching synchronization condition +occurs. When the condition occurs the processing of synthesized +events continues. Determination that the condition has occurred may be +made by capturing the consequences of the synthesized events and +comparing them to the previously recorded synchronization information. +For example, if a button press was followed by a +MapNotify +event on a +particular window in the recorded data, the playback application might +synthesize the button press then wait for the +MapNotify +event on the +appropriate window before proceeding with subsequent synthesized +input. + + + +Because +it is impossible to predict what synchronization information will be +required by a particular application, the extension provides +facilities to record any subset of core X protocol and arbitrary +extension protocol. +As such, this extension does not enforce a specific +synchronization methodology; any method based on information in the X +protocol stream (e.g., watching for window mapping/unmapping, cursor +changes, drawing of certain text strings, etc.) can capture the +information it needs using RECORD facilities. + + + +Acknowledgements + +The document represents the culmination of two years of debate and +experiments done under the auspices of the X Consortium xtest working +group. Although this was a group effort, the author remains +responsible for any errors or omissions. +Two years ago, Robert Chesler of Absol-puter, Kieron Drake of UniSoft +Ltd., Marc Evans of Synergytics and Ken Miller of Digital shared the +vision of a standard extension for recording and were all instrumental +in the early protocol development. During the last two years, Bob +Scheifler of the X Consortium and Jim Fulton of NCD continuously +provided input to the protocol design, as well as encouragement to the +author. In the last few months, Stephen Gildea and Dave Wiggins, +both X Consortium staff, have spent considerable time fine tuning the +protocol design and reviewing the protocol specifications. Most +recently, Amnon Cohen of Mercury Interactive has assisted in +clarification of the recorded event policy, and Kent Siefkes of +Performance Awareness has assisted in clarification of the timestamp +policy. + + + + +Goals + + + +To provide a standard for recording, +whereby both device events and synchronization information in the +form of device event consequences are recorded. + + + + +To record contextual information used in synchronized playback +without prior knowledge of the application +that +is being recorded. + + + + +To provide the ability to record arbitrary X protocol extensions. + + + + + + + +Requirements + +The extension should function as follows: + + + + + +It should +not be dependent on other clients or extensions for its operation. + + + + +It should +not significantly impact performance. + + + + +It should +support the recording of all device input (core devices and XInput devices). + + + + +It should +be extendible. + + + + +It should +support the recording of synchronization information for user events. + + + + + + + +Design + +This section gives an overview of the RECORD extension and discusses +its overall operation and data types. + + + +Overview + +The mechanism used by this extension for recording is to intercept +core X protocol and arbitrary X extension protocol entirely within the X server +itself. When the extension has been requested to intercept specific +protocol by one or more clients, the protocol data are formatted and +returned to the recording clients. + + + +The extension provides a mechanism for capturing all events, including +input device events that go to no clients, that is analogous to a client +expressing "interest" in all events in all windows, including the root +window. Event filtering in the extension provides a mechanism for feeding +device events to recording clients; it does not provide a mechanism for +in-place, synchronous event substitution, modification, or withholding. +In addition, the +extension does not provide data compression before intercepted protocol +is returned to the recording clients. + + +Data Delivery + + + + + +Because +events are limited in size to +32 bytes, using events to return intercepted protocol data to recording +clients is prohibitive in terms of performance. Therefore, intercepted +protocol data are returned to recording clients through multiple replies +to the extension request to begin protocol interception and reporting. +This utilization is consistent with +ListFontsWithInfo , +for example, where a +single request has multiple replies. + + + +Individual requests, replies, events or errors intercepted by the extension +on behalf of recording clients cannot be split across reply packets. In order +to reduce overhead, multiple intercepted requests, replies, events and errors +might be collected +into a single reply. +Nevertheless, all data are returned to the client in a timely manner. + + + +Record Context + + + + + +The extension adds a record context resource (RC) +to the set of resources managed by the server. All the +extension operations take an RC as an argument. Although the protocol +permits sharing of RCs between clients, it is expected that clients will +use their own RCs. The attributes used in extension operations are stored +in the RCs, and these attributes include the protocol and clients to +intercept. + + + +The terms "register" and "unregister" are used to describe the +relationship between clients to intercept and the RC. To register +a client with an RC means the client is added to the list +of clients to intercept; to unregister a client means the client +is deleted from the list of clients to intercept. When the +server is requested to register or unregister clients from an RC, +it is required to do so immediately. That is, it is not permissible for +the server to wait until recording is enabled to register clients +or recording is disabled to unregister clients. + + + + +Record Client Connections + + + + + +The typical communication model for a recording client is to open +two connections to the server and use one for RC control and +the other for reading protocol data. + + + +The "control" connection can execute requests to obtain information about +the supported protocol version, create and destroy RCs, specify protocol +types to intercept and clients to be recorded, query the current state +of an RC, and to stop interception and reporting of protocol data. The +"data" connection can execute a request to +enable interception +and reporting of specified protocol for a particular RC. When the +"enable" request is issued, intercepted protocol is sent back on the +same connection, generally in more than one reply packet. Until the last +reply to the "enable" request is sent by the server, signifying that +the request execution is complete, no other requests will be executed by +the server on that connection. That is, the connection that data are being +reported on cannot issue the "disable" request until the last reply +to the "enable" request is sent by the server. Therefore, unless a +recording client never has the need to disable the interception and reporting +of protocol data, two client connections are necessary. + + + +Events + + + + + +The terms "delivered events" and "device events" are used +to describe the two event classes recording clients may +select for interception. These event classes are handled differently +by the extension. Delivered events are core X events or X extension events +the server actually delivers to one or more clients. Device events are +events generated by core X devices or extension input devices that the +server may or may not deliver to any clients. When device events +are selected for interception by a recording client, the extension +guarantees each device event is recorded and will be forwarded +to the recording client in the same order it is generated by the +device. + + + +The recording of selected device events is not affected +by server grabs. Delivered events, on the other hand, can be affected +by server grabs. +If a recording client selects both +a device event and delivered events that result from that device +event, the delivered events are recorded after the device event. +In the absence of grabs, the delivered events for a +device event precede later device events. + + + +Requests that have side effects on +devices, such as +WarpPointer +and +GrabPointer +with a confine-to window, +will cause RECORD to record an associated device event. +The XTEST extension request +XTestFakeInput +causes a device event to be recorded; the +device events are recorded in the same order that the +XTestFakeInput +requests are received by the server. + + + +If a key autorepeats, multiple +KeyPress +and +KeyRelease +device events are reported. + + + + +Timing + + + + +Requests are recorded just before +they are executed; the time associated with a request is the server +time when it is recorded. + + + + + +Types + +The following new types are used in the request definitions that appear +in section 3. + + +RC: CARD32 + + +The +"RC" +type is a resource identifier for a server record context. + + + + + + + + + + + RANGE8: + [first, last: + CARD8] + + + RANGE16: + [first, last: + CARD16] + + + EXTRANGE: + [major: + RANGE8 + + + + minor: + RANGE16] + + + + + + + + + + + + + + RECORDRANGE: + [core-requests: + RANGE8 + + + + core-replies: + RANGE8 + + + + ext-requests: + EXTRANGE + + + + ext-replies: + EXTRANGE + + + + delivered-events: + RANGE8 + + + + device-events: + RANGE8 + + + + errors: + RANGE8 + + + + client-started: + BOOL + + + + client-died: + BOOL] + + + + + + +The +"RECORDRANGE" +structure contains the protocol values to intercept. Typically, +this structure is sent by recording clients over the control connection +when creating or modifying an RC. + + + + + + + +Specifies core X protocol requests with an opcode field between first +and last inclusive. If first is equal to 0 and last is equal to 0, no +core requests are specified by this RECORDRANGE. If first is greater +than last, a +"Value" +error results. + + + + + + +Specifies replies resulting from core X protocol requests with an opcode +field between first and last inclusive. If first is equal to 0 and last +is equal to 0, no core replies are specified by this RECORDRANGE. If +first is greater than last, a +"Value" +error results. + + + + + + +Specifies extension protocol requests with a major opcode field between +major.first and major.last and a minor opcode field between minor.first +and minor.last inclusive. +If major.first and major.last are equal to 0, no +extension protocol requests are specified by this RECORDRANGE. If +major.first or major.last is less than 128 and greater than 0, +if major.first is greater than major.last, +or if minor.first +is greater than minor.last, a +"Value" +error results. + + + + + + +Specifies replies resulting from extension protocol requests with a +major opcode field between major.first and major.last and +a minor opcode field between minor.first and minor.last +inclusive. If major.first and major.last are equal to 0, +no extension protocol replies are specified by this RECORDRANGE. If +major.first or major.last is less than 128 and greater +than 0, +if major.first is greater than major.last, +or if minor.first is greater than minor.last, a +"Value" +error results. + + + + + + +This is used for both core X protocol events and arbitrary extension +events. Specifies events that are delivered to at least one client +that have a code field between first and last +inclusive. If first is equal to 0 and last is equal to 0, +no events are specified by this RECORDRANGE. +Otherwise, if first is less than 2 +or last is less than 2, or if +first is greater than last, a +"Value" +error results. + + + + + + +This is used for both core X device events and X extension device +events that may or may not be delivered to a client. +Specifies device events that have a code field between first and +last inclusive. If first is equal to 0 and last +is equal to 0, no device events are specified by this RECORDRANGE. +Otherwise, +if first is less than 2 or last is less +than 2, or if first is greater than last, a +"Value" +error results. + + + + +Because +the generated device event may or may not be associated with a +client, unlike other RECORDRANGE components, which select protocol for a +specific client, selecting for device events in any RECORDRANGE in an RC +causes the recording client to receive one instance for each device event +generated that is in the range specified. + + + + + + +This is used for both core X protocol errors and arbitrary extension +errors. Specifies errors that have a code field between first and +last inclusive. If first is equal to 0 and last is equal to 0, no +errors are specified by this RECORDRANGE. If first is greater +than last, a +"Value" +error results. + + + + + + +Specifies the connection setup reply. +If +False , +the connection setup reply is not specified by +this RECORDRANGE. + + + + + + +Specifies notification when a client disconnects. +If +False , +notification when a client disconnects is not specified by +this RECORDRANGE. + + + + + + + + + + + + + ELEMENT_HEADER: + [from-server-time: + BOOL + + + + from-client-time: + BOOL + + + + from-client-sequence: + BOOL] + + + + + + +The +ELEMENT_HEADER +structure specifies additional data that precedes each protocol +element in the data field of a +RecordEnableContext +reply. + + + + + +If from-server-time is +True , +each intercepted protocol element +with category +FromServer +is preceded by the server time when the protocol was recorded. + + + + +If from-client-time is +True , +each intercepted protocol element +with category +FromClient +is preceded by the server time when the protocol was recorded. + + + + +If from-client-sequence is +True , +each intercepted protocol +element with category +FromClient +or +ClientDied +is preceded by the +32-bit sequence number of the recorded client's most recent request +processed by the server at that time. +For +FromClient , +this will be one less than the sequence number of the +following request. +For +ClientDied , +the sequence number will be the only data, because no +protocol is recorded. + + + + + +Note that a reply containing device events is treated the same as +other replies with category +FromServer +for purposes of these flags. +Protocol with category +FromServer +is never preceded by a sequence +number because almost all such protocol has a sequence number in it anyway. + + + + +If both a server time and a sequence number have been requested for a +reply, each protocol request is +preceded first by the time and second by the sequence number. + + +XIDBASE: CARD32 + + + +The XIDBASE type is used to identify a particular client. Valid +values are any existing resource identifier +of any connected client, +in which case the client +that created the resource is specified, or the resource identifier +base sent to the target client from the server in the connection setup +reply. A value of 0 (zero) is valid when the XIDBASE is associated +with device events that may not have been delivered to a client. + + + +CLIENTSPEC: XIDBASE or {CurrentClients, +FutureClients, AllClients} + + + +The CLIENTSPEC type defines the set of clients the RC attributes are +associated with. This type is used by recording clients when creating +an RC or when changing RC attributes. XIDBASE specifies that the RC +attributes apply to a single client only. +CurrentClients +specifies +that the RC attributes apply to current client connections; +FutureClients +specifies future client connections; +AllClients +specifies all client connections, which includes current and future. + + + +The numeric values for +CurrentClients , +FutureClients +and +AllClients +are +defined such that there will be no intersection with valid XIDBASEs. + + + + +When the context is enabled, the data connection is unregistered if it +was registered. +If the context is enabled, +CurrentClients +and +AllClients +silently exclude the recording data connection. +It is an error to explicitly register the data connection. + + + + + + + + + + + CLIENT_INFO: + [client-resource: + CLIENTSPEC + + + + intercepted-protocol: + LISTofRECORDRANGE] + + + + + + +This structure specifies an intercepted client and the protocol to be +intercepted for the client. The client-resource field is a +resource base that identifies the intercepted client. The +intercepted-protocol field specifies the protocol to intercept +for the client-resource. + + + + +Errors + +RecordContext + + + + + + + +This error is returned if the value for an RC argument +in a request does not name a defined record context. + + + + + + + +Protocol Requests + + + + + +RecordQueryVersion + + + + + +major-version, +minor-version: CARD16 + + + + +-> + + + + +major-version, +minor-version: CARD16 + + + + + +This request specifies the RECORD extension protocol version the client +would like to use. When the specified protocol version is supported +by the extension, the protocol version the server expects from the +client is returned. Clients must use this request before other RECORD +extension requests. + + + +This request also determines whether or not the RECORD extension protocol +version specified by the client is supported by the extension. If the +extension supports the version specified by the client, this version number +should be returned. If the client has requested a higher version than is +supported by the server, the server's highest version should be returned. +Otherwise, if the client has requested a lower version than is supported +by the server, the server's lowest version should be returned. This document +defines major version one (1), +minor version thirteen (13). + + + +RecordCreateContext + + + + + + + + + +context: RC + + + + +element-header: ELEMENT_HEADER + + + + +client-specifiers: LISTofCLIENTSPEC + + + + +ranges: LISTofRECORDRANGE + + + + +Errors: +Match , +Value , +IDChoice , +Alloc + + + + + + + +This request creates a new +record context +within the server and assigns the identifier context to +it. After the context is created, this request registers the +set of clients in client-specifiers with the context and +specifies the protocol to intercept for those clients. +The recorded protocol elements will be preceded by data as specified +by element-header. +Typically, +this request is used by a recording client over the control +connection. Multiple RC +objects can exist simultaneously, containing overlapping sets of +protocol and clients to intercept. + + + +If any of the values in +element-header or +ranges is invalid, a +"Value" +error results. Duplicate items in the list of client-specifiers are +ignored. If any item in the client-specifiers list is not a valid +CLIENTSPEC, a +"Match" +error results. Otherwise, each item in the client-specifiers list is +processed as follows: + + + + + +If the item is an XIDBASE identifying a particular client, the +specified client is registered with the context and the protocol +to intercept for the client is then set to ranges. + + + + +If the item is +CurrentClients , +all existing clients are registered with the +context at this time. +The protocol to intercept for all clients registered +with the context is then set to ranges. + + + + +If the item is +FutureClients , +all clients that connect to the server +after this request executes will be automatically registered with the +context. The protocol to intercept for such clients will be set to +ranges in the context. + + + + +If the item is +AllClients , +the effect is as if the actions described +for +FutureClients +are performed, followed by the actions for +CurrentClients . + + + + + +The +"Alloc" +error results when the server is unable to allocate the necessary +resources. + + + +RecordRegisterClients + + + + + + + + + +context: RC + + + + +element-header: ELEMENT_HEADER + + + + +client-specifiers: LISTofCLIENTSPEC + + + + +ranges: LISTofRECORDRANGE + + + + +Errors: +Match , +Value , +RecordContext , +Alloc + + + + + + + +This request registers the set of clients in client-specifiers with +the given context and specifies the protocol to intercept for those +clients. +The header preceding each recorded protocol element is set as specified +by element-header. +These flags affect the entire +context; their effect is not limited to the clients registered by +this request. +Typically, this request is used by a recording client over +the control connection. + + + +If context does not name a valid RC, a +"RecordContext" +error results. If any of the values in +element-header or ranges is invalid, a +"Value" +error results. Duplicate items in the list of client-specifiers are +ignored. If any item in the list of client-specifiers is not a +valid CLIENTSPEC, a +"Match" +error results. +If the context is enabled and the XID of the enabling connection +is specified, a +"Match" +error results. +Otherwise, each item in the client-specifiers list is +processed as follows: + + + + + +If the item is an XIDBASE identifying a particular client, the +specified client is registered with the context if it is not already +registered. The protocol to intercept for the client is then set to +ranges. + + + + +If the item is +CurrentClients , +all existing clients that are not +already registered with the specified context, +except the enabling connection if the context is enabled, +are registered at this +time. The protocol to intercept for all clients registered with the +context is then set to ranges. + + + + +If the item is +FutureClients , +all clients that connect to the server +after this request executes will be automatically registered with the +context. The protocol to intercept for such clients will be set to +ranges in the context. +The set of clients that are registered with the +context and their corresponding sets +of protocol to intercept are left intact. + + + + +If the item is +AllClients , +the effect is as if the actions described +for +FutureClients +are performed, followed by the actions for +CurrentClients . + + + + +The +"Alloc" +error results when the server is unable to allocate the necessary +resources. + + + +RecordUnregisterClients + + + + + + + + + +context: RC + + + + +client-specifiers: LISTofCLIENTSPEC + + + + +Errors: +Match , +RecordContext + + + + + + + + +This request removes the set of clients in client-specifiers from the +given context's set of registered clients. Typically, this request is +used by a recording client over the control connection. + + + +If context does not name a valid RC, a +"RecordContext" +error results. Duplicate items in the list of client-specifiers are +ignored. If any item in the list is not a valid CLIENTSPEC, a +"Match" +error results. Otherwise, each item in the client-specifiers list is +processed as follows: + + + + + +If the item is an XIDBASE identifying a particular client, and the +specified client is currently registered with the context, it is +unregistered, and the set of protocol to intercept for the client is +deleted from the context. If the specified client is not registered +with the context, the item has no effect. + + + + +If the item is +CurrentClients , +all clients currently registered with +the context are unregistered from it, and their corresponding sets of +protocol to intercept are deleted from the context. + + + + +If the item is +FutureClients , +clients that connect to the server after +this request executes will not automatically be registered with the +context. The set of clients that are registered with this context +and their corresponding sets of protocol that will be +intercepted are left intact. + + + + +If the item is +AllClients , +the effect is as if the actions described +for +FutureClients +are performed, followed by the actions for +CurrentClients . + + + + + +A client is unregistered automatically when it disconnects. + + + +RecordGetContext + + + + + + + + + +context: RC + + + + +-> + + + + +enabled: BOOL + + + + +element-header: ELEMENT_HEADER + + + + +intercepted-clients: LISTofCLIENT_INFO + + + + +Errors: + + + + +RecordContext + + + + + + + +This request queries the current state of the specified context +and is typically used by a recording client over the control connection. +The enabled field +specifies the state of data transfer between the extension and the +recording client, and is either enabled +( True ) +or disabled +( False ). +The initial state is disabled. +When enabled, all core X protocol and +extension protocol received from (requests) or sent to (replies, +errors, events) a particular client, and requested to be intercepted +by the recording client, is reported to the recording client over the +data connection. +The element-header specifies the header that precedes each +recorded protocol element. +The +intercepted-clients field specifies the list of clients currently +being recorded and the protocol associated with each client. +If future clients will be automatically registered with the context, +one of the returned CLIENT_INFO structures has a client-resource value +of FutureClients and an intercepted-protocol giving the protocol to +intercept for future clients. +Protocol ranges may be decomposed, coalesced, or otherwise modified +by the server from how they were specified by the client. +All CLIENTSPECs registered with the server are returned, even if the +RECORDRANGE(s) associated with them specify no protocol to record. + + + +When the context argument is not valid, a +RecordContext +error results. + + + +RecordEnableContext + + + + + + + + +context: RC + + + + +->+ + + + + +category: +{FromServer, FromClient, +ClientStarted, ClientDied, +StartOfData, +EndOfData} + + + + + +element-header: ELEMENT_HEADER + + + + +client-swapped: BOOL + + + + +id-base: XIDBASE + + + + +server-time: TIMESTAMP + + + + +recorded-sequence-number: CARD32 + + + + +data: LISTofBYTE + + + + +Errors: +Match, +RecordContext + + + + + + + +This request enables data transfer between the recording client +and the extension and returns the protocol data the recording client +has previously expressed interest in. Typically, this request is +executed by the recording client over the data connection. + + + +If the client is registered on the context, it is unregistered +before any recording begins. + + + +Once the server receives this request, it begins intercepting +and reporting to the recording client all core and extension protocol +received from or sent to clients registered with the RC that the +recording client has expressed interest in. All intercepted protocol data +is returned in the byte-order of the recorded client. Therefore, +recording clients are responsible for all byte swapping, if required. +More than one recording client cannot enable data transfer on the +same RC at the same time. Multiple intercepted requests, replies, +events and errors might be packaged into a single reply before +being returned to the recording clients. + + + +The +category field determines the possible +types of the data. +When a context is enabled, the server will immediately send a reply of +category +StartOfData +to notify the client that recording is enabled. +A category of +FromClient +means the data are from the client +(requests); +FromServer +means data are from the server (replies, +errors, events, or device events). +For a new client, the category is +ClientStarted +and the data are the connection setup reply. +When +the recorded client connection is closed, category is +set to the value +ClientDied +and no protocol is included in this reply. +When the disable request is made over the control connection, +a final reply is sent over the data connection with category +EndOfData +and no protocol. + + + +The element-header field returns the value currently set for the +context, which tells what header information precedes each recorded +protocol element in this reply. + + + +The client-swapped field is +True +if the byte order of +the protocol being recorded +is swapped +relative to the recording client; +otherwise, client-swapped is +False . +The recorded protocol +is in the byte order of the client being +recorded; device events are in the byte order of the +recording client. +For replies of category +StartOfData +and +EndOfData +the +client-swapped bit is set +according +to the byte order of the server relative to the recording client. +The id-base field is the resource identifier base +sent to the client from the server in the +connection setup reply, and hence, identifies the client being +recorded. The id-base field is 0 (zero) when the protocol +data being +returned are device events. +The server-time field is set to the time of the +server when the first protocol element in this reply was intercepted. +The server-time +of reply N+1 is greater than or equal to the server-time of reply N, +and is greater than or equal to the time of the last protocol +element in reply N. + + + +The recorded-sequence-number field is set to the sequence number +of the recorded client's most recent request processed by the server. + + + +The data field +contains the raw protocol data being returned to the recording client. +If requested by the element-header of this record context, each +protocol element may be preceded by a 32-bit timestamp and/or +a 32-bit sequence number. +If present, both the timestamp and sequence number are always in the +byte order of the recording client. + + + +For the core X events +KeyPress , +KeyRelease , +ButtonPress , +and +ButtonRelease , +the fields of a device event that contain +valid information are time and detail. +For the core X event +MotionNotify , +the fields of a device event that contain +valid information are time, root, +root-x and root-y. +The time field refers to the time the event was generated by the +device. + + + +For the extension input device events +DeviceKeyPress , +DeviceKeyRelease , +DeviceButtonPress , +and +DeviceButtonRelease , +the fields of a device event that contain valid information are +device, time and detail. +For +DeviceMotionNotify , +the valid device event fields are +device and time. +For the extension input device events +ProximityIn +and +ProximityOut , +the fields of a device event that contain valid +information are device and time. +For the extension input device event +DeviceValuator , +the fields of a device event that contain valid information are +device, +num_valuators, first_valuator, and valuators. +The time field refers to the time the event was generated by the +device. + + + +The error +"Match" +is returned when data transfer is already enabled. +When the context argument is not valid, a +RecordContext +error results. + + + +RecordDisableContext + + + + + + + + + +context: RC + + + + +Errors: +RecordContext + + + + + + + +This request is typically executed by the recording client over the +control connection. This request directs the extension to immediately +send any complete protocol elements currently buffered, +to send a final reply with category +EndOfData , +and to discontinue +data transfer between the extension and the recording client. +Protocol reporting is disabled +on the data connection that is currently enabled for the given +context. Once the extension completes +processing this request, no additional recorded protocol will +be reported to the recording client. If a data connection is not +currently enabled when this request is executed, then this request has +no affect on the state of data transfer. +An RC is disabled automatically when the connection to the enabling +client is closed down. + + + +When the context argument is not valid, a +RecordContext +error results. + + + +RecordFreeContext + + + + + +context RC + + + + + +Errors: +RecordContext + + + + + +This request deletes the association between the resource ID and the +RC and destroys the RC. +If a client has enabled data transfer on this context, the actions +described in +RecordDisableContext +are performed before the context +is freed. + + + +An RC is destroyed automatically when the connection to the creating client +is closed down and the close-down mode is DestroyAll. When the +context argument is not valid, a +RecordContext +error results. + + + + +Encoding + +Please refer to the X11 Protocol Encoding document as this document uses +conventions established there. + + + +The name of this extension is "RECORD". + + + +Types + +RC: CARD32 + + + +RANGE8 + 1 CARD8 first + 1 CARD8 last + + + +RANGE16 + 2 CARD16 first + 2 CARD16 last + + + +EXTRANGE + 2 RANGE8 major + 4 RANGE16 minor + + + +RECORDRANGE + 2 RANGE8 core-requests + 2 RANGE8 core-replies + 6 EXTRANGE ext-requests + 6 EXTRANGE ext-replies + 2 RANGE8 delivered-events + 2 RANGE8 device-events + 2 RANGE8 errors + 1 BOOL client-started + 1 BOOL client-died + + + +ELEMENT_HEADER + 1 CARD8 + 0x01 from-server-time + 0x02 from-client-time + 0x04 from-client-sequence + + + +XIDBASE: CARD32 + + + +CLIENTSPEC + 4 XIDBASE client-id-base + 1 CurrentClients + 2 FutureClients + 3 AllClients + + + +CLIENT_INFO + 4 CLIENTSPEC client-resource + 4 CARD32 n, number of record ranges in + intercepted-protocol + 24n LISTofRECORDRANGE intercepted-protocol + + + + +Errors + + +RecordContext + 1 0 Error + 1 CARD8 extension's base error code + 0 + 2 CARD16 sequence number + 4 CARD32 invalid record context + 24 unused + + + + +Requests + + +RecordQueryVersion + 1 CARD8 major opcode + 1 0 minor opcode + 2 2 request length + 2 CARD16 major version + 2 CARD16 minor version + => + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 2 CARD16 major version + 2 CARD16 minor version + 20 unused + + + +RecordCreateContext + 1 CARD8 major opcode + 1 1 minor opcode + 2 5+m+6n request length + 4 RC context + 1 ELEMENT_HEADER element-header + 3 unused + 4 CARD32 m, number of client-specifiers + 4 CARD32 n, number of ranges + 4m LISTofCLIENTSPEC client-specifiers + 24n LISTofRECORDRANGE ranges + + + +RecordRegisterClients + 1 CARD8 major opcode + 1 2 minor opcode + 2 5+m+6n request length + 4 RC context + 1 ELEMENT_HEADER element-header + 3 unused + 4 CARD32 m, number of client-specifiers + 4 CARD32 n, number of ranges + 4m LISTofCLIENTSPEC client-specifiers + 24n LISTofRECORDRANGE ranges + + + +RecordUnregisterClients + 1 CARD8 major opcode + 1 3 minor opcode + 2 3+m request length + 4 RC context + 4 CARD32 m, number of client-specifiers + 4m LISTofCLIENTSPEC client-specifiers + + + +RecordGetContext + 1 CARD8 major opcode + 1 4 minor opcode + 2 2 request length + 4 RC context + => + 1 1 Reply + 1 BOOL enabled + 2 CARD16 sequence number + 4 j reply length + 1 ELEMENT_HEADER element-header + 3 unused + 4 CARD32 n, number of intercepted-clients + 16 unused + 4j LISTofCLIENT_INFO intercepted-clients + + + +RecordEnableContext + 1 CARD8 major opcode + 1 5 minor opcode + 2 2 request length + 4 RC context + =>+ + 1 1 Reply + 1 category + 0 FromServer + 1 FromClient + 2 ClientStarted + 3 ClientDied + 4 StartOfData + 5 EndOfData + 2 CARD16 sequence number + 4 n reply length + 1 ELEMENT_HEADER element-header + 1 BOOL client-swapped + 2 unused + 4 XIDBASE id-base + 4 TIMESTAMP server-time + 4 CARD32 recorded-sequence-number + 8 unused + 4n BYTE data + + + +RecordDisableContext + 1 CARD8 major opcode + 1 6 minor opcode + 2 2 request length + 4 RC context + + + +RecordFreeContext + 1 CARD8 major opcode + 1 7 minor opcode + 2 2 request length + 4 RC context + + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/scrnsaverproto/saver.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/scrnsaverproto/saver.xml new file mode 100644 index 0000000000000000000000000000000000000000..b19f0f91cf8ee4f5fa5d77dd2d0f1b369e9d9fdf --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/scrnsaverproto/saver.xml @@ -0,0 +1,943 @@ + + %defs; +]> + + + + + X11 Screen Saver Extension + MIT X Consortium Proposed Standard + X Version 11, Release &fullrelvers; + Version 1.0 + + + JimFulton + Network Computing Devices, Inc + + + KeithPackard + +X Consortium, Laboratory for Computer Science, Massachusetts Institute of Technology + + + + + 1992 + Massachusetts Institute of Technology + Network Computing Devices, Inc + + + + + +Permission to use, copy, modify, and distribute this documentation for any +purpose and without fee is hereby granted, provided that the above copyright +notice and this permission notice appear in all copies. MIT and +Network Computing Devices, Inc. make no +representations about the suitability for any purpose of the information in +this document. This documentation is provided "as is" without express or +implied warranty. + + + + + + +Introduction + +The X Window System provides support for changing the image on a display screen +after a user-settable period of inactivity to avoid burning the cathode ray +tube phosphors. However, no interfaces are provided for the user to control +the image that is drawn. This extension allows an external "screen saver" +client to detect when the alternate image is to be displayed and to provide the +graphics. + + +Current X server implementations typically provide at least one form of +"screen saver" image. Historically, this has been a copy of the X logo +drawn against the root background pattern. However, many users have asked +for the mechanism to allow them to write screen saver programs that provide +capabilities similar to those provided by other window systems. In +particular, such users often wish to be able to display corporate logos, +instructions on how to reactivate the screen, and automatic screen-locking +utilities. This extension provides a means for writing such clients. + + + + +Assumptions + +This extension exports the notion of a special screen saver window that is +mapped above all other windows on a display. This window has the +override-redirect attribute set so that it is not subject to manipulation by +the window manager. Furthermore, the X identifier for the window is never +returned by QueryTree requests on the root window, so it is typically +not visible to other clients. + + + + +Overview + +The core +SetScreenSaver +request can be used to set the length of time without +activity on any input devices after which the screen saver should "activate" +and alter the image on the screen. This image periodically "cycles" to +reduce +the length of time that any particular pixel is illuminated. Finally, the +screen saver is "deactivated" in response to activity on any of the input +devices +or particular X requests. + + + +Screen saving is typically done by disabling video output to the display tube +or by drawing a changing pattern onto the display. If the server chooses the +latter approach, a window with a special identifier is created and mapped at +the top of the stacking order where it remains until the screen saver +deactivates. At this time, the window is unmapped and is not accessible to any +client requests. + + +The server's default mechanism is referred to as the internal screen +saver. An external +screen saver client requires a means of determining the window +id for the screen saver window and setting the attributes (e.g. size, +location, visual, colormap) to be used when the window is mapped. These +requirements form the basis of this extension. + + + + +Issues + +This extension raises several interesting issues. First is the question of +what should be done if some other client has the server grabbed when the screen +saver is supposed to activate? This commonly occurs with window managers that +automatically ask the user to position a window when it is first mapped by +grabbing the server and drawing XORed lines on the root window. + + +Second, a screen saver program must control the actual RGB values sent to the +display tube to ensure that the values change periodically to avoid phosphor +burn in. Thus, the client must have a known colormap installed whenever the +screen saver window is displayed. To prevent screen flashing, the visual type +of the screen saver window should also be controllable. + + +Third, some implementations may wish to destroy the screen saver window when +it is not mapped so that it need not be avoided during event delivery. Thus, +screen saver clients may find that the requests that reference the screen +saver window may fail when the window is not displayed. + + + + +Protocol + +The Screen Saver extension is as follows: + + + +Types + +In addition to the common types described in the core protocol, the following +type is used in the request and event definitions in subsequent sections. + + + + + + + + + + Name + Value + + + + + SCREENSAVEREVENT + ScreenSaverNotify, + ScreenSaverCycle + + + + + + + +Errors + +The Screen Saver extension adds no errors beyond the core protocol. + + + + +Requests + +The Screen Saver extension adds the following requests: + + + +ScreenSaverQueryVersion + client-major-version: CARD8 + client-minor-version: CARD8 +-> + server-major-version: CARD8 + server-minor-version: CARD8 + + + +This request allows the client and server to determine which version of +the protocol should be used. The client sends the version that it +prefers; if the server understands that +version, it returns the same values and interprets subsequent requests +for this extension according to the specified version. Otherwise, +the server returns the closest version of the protocol that it can +support and interprets subsequent requests according to that version. +This document describes major version 1, minor version 0; the major +and minor revision numbers should only be incremented in response to +incompatible and compatible changes, respectively. + + + +ScreenSaverQueryInfo +drawable DRAWABLE + +saver-window: WINDOW +state: {Disabled, Off, On} +kind: {Blanked, Internal, External} +til-or-since: CARD32 +idle: CARD32 +event-mask: SETofSCREENSAVEREVENT + +Errors: Drawable + + + +This request returns information about the state of the screen +saver on the screen associated with drawable. The saver-window +is the XID that is associated with the screen saver window. This +window is not guaranteed to exist +except when external screen saver is active. Although it is a +child of the root, this window is not returned by +QueryTree +requests on the root. Whenever this window is mapped, it is always above +any of its siblings in the stacking order. XXX - TranslateCoords? + + +The state field specifies whether or not the screen saver is currently +active and how the til-or-since value should be interpreted: + + + + + + + + + + Off + +The screen is not currently being saved; +til-or-since +specifies the number of milliseconds until the screen saver is expected to +activate. + + + + On + +The screen is currently being saved; +til-or-since specifies +the number of milliseconds since the screen saver activated. + + + + Disabled + +The screen saver is currently disabled; +til-or-since is zero. + + + + + + + +The kind field specifies the mechanism that either is currently being +used or would have been were the screen being saved: + + + + + + + + + + Blanked + The video signal to the display monitor was disabled. + + + Internal + A server-dependent, built-in screen saver image was displayed; either no + client had set the screen saver window attributes or a different client + had the server grabbed when the screen saver activated. + + + External + The screen saver window was mapped with attributes set by a + client using the ScreenSaverSetAttributes request. + + + + + + +The idle field specifies the number of milliseconds since the last +input was received from the user on any of the input devices. + + + +The event-mask field specifies which, if any, screen saver +events this client has requested using ScreenSaverSelectInput. + + + +If drawable is not a valid drawable identifier, a Drawable +error is returned and the request is ignored. + + + +ScreenSaverSelectInput +drawable: DRAWABLE +event-mask: SETofSCREENSAVEREVENT + + + +Errors: +Drawable, +Match + + + +This request specifies which Screen Saver extension events on the screen +associated with drawable should be generated for this client. If +no bits are set in event-mask, then no events will be generated. +Otherwise, any combination of the following bits may be set: + + + + + + + + + + ScreenSaverNotify + +If this bit is set, ScreenSaverNotify events are generated whenever +the screen saver is activated or deactivated. + + + + ScreenSaverCycle + +If this bit is set, ScreenSaverNotify events are generated whenever +the screen saver cycle interval passes. + + + + + + + +If drawable is not a valid drawable identifier, a Drawable +error is returned. If any undefined bits are set in event-mask, +a Value error is returned. If an error is returned, +the request is ignored. + + + +ScreenSaverSetAttributes + + +drawable: DRAWABLE +class: +{InputOutput, InputOnly, CopyFromParent} +depth: CARD8 +visual: VISUALID or CopyFromParent +x, y: INT16 +width, height, border-width: CARD16 +value-mask: BITMASK +value-list: LISTofVALUE + +Access, Window, Pixmap, Colormap, Cursor, Match, Value, Alloc + + + +This request sets the attributes that this client would like to see +used in creating the screen saver window on the screen associated +with drawable. If another client currently has the attributes set, +an Access error is generated and the request is ignored. + + + +Otherwise, the specified window attributes are checked as if +they were used in a core CreateWindow request whose +parent is the root. The override-redirect field is ignored as +it is implicitly set to True. If the window attributes result in an +error according to the rules for CreateWindow, the request is ignored. + + +Otherwise, the attributes are stored and will take effect on the next +activation that occurs when the server is not grabbed by another client. +Any resources specified for the +background-pixmap or cursor attributes may be +freed immediately. The server is free to copy the background-pixmap +or cursor resources or to use them in place; therefore, the effect of +changing the contents of those resources is undefined. If the +specified colormap no longer exists when the screen saver activates, +the parent's colormap is used instead. If no errors are generated by this +request, any previous +screen saver window attributes set by this client are released. + + +When the screen saver next activates and the server is not grabbed by +another client, the screen saver window is +created, if necessary, and set to the specified attributes and events +are generated as usual. The colormap +associated with the screen saver window is +installed. Finally, the screen saver window is mapped. + + +The window remains mapped and at the top of the stacking order +until the screen saver is deactivated in response to activity on +any of the user input devices, a ForceScreenSaver request with +a value of Reset, or any request that would cause the window to be +unmapped. + + +If the screen saver activates while the server is grabbed by another +client, the internal saver mechanism is used. The ForceScreenSaver +request may be used with a value of Active to +deactivate the internal saver and activate the external saver. + + +If the screen saver client's connection to the server is broken +while the screen saver is activated and the client's close down mode has not +been RetainPermanent or RetainTemporary, the current screen saver +is deactivated and the internal screen saver is immediately activated. + + +When the screen saver deactivates, the screen saver window's colormap +is uninstalled and the window is unmapped (except as described below). +The screen saver XID is disassociated +with the window and the server may, but is not required to, +destroy the window along with any children. + + +When the screen saver is being deactivated and then immediately +reactivated (such as when switching screen savers), the server +may leave the screen saver window mapped (typically to avoid +generating exposures). + + + +ScreenSaverUnsetAttributes + + + +drawble: DRAWABLE + +Errors: Drawable + + + +This request notifies the server that this client no longer +wishes to control the screen saver window. Any screen saver +attributes set by this client and any descendents of the screen +saver window created by this client should be released +immediately if the screen saver is not active, else upon +deactivation. + + +This request is ignored if the client has not previously set the screen saver +window attributes. + + + + +Events + +The Screen Saver extension adds one event: + + +ScreenSaverNotify + + + +root: WINDOW +window: WINDOW +state: {Off, On, Cycle} +kind: { Blanked, Internal , External } +forced: BOOL +time: TIMESTAMP + + +This event is delivered to clients that have requested +ScreenSaverNotify events using the ScreenSaverSelectInput request +whenever the screen saver activates or deactivates. + + +The root field specifies root window of the screen for +which the event was generated. The window field specifies +the value that is returned by ScreenSaverQueryInfo as +the identifier for the screen saver window. This window is not +required to exist if the external screen saver is not active. + + +The state field specifies the cause of the event: + + + + + + + + + + Off + +The screen saver deactivated; this event is sent if the client has set the +ScreenSaverNotify bit in its event mask. + + + + On + +The screen saver activated. This event is sent if the client has set the +ScreenSaverNotify bit in its event mask. + + + + Cycle + +The cycle interval passed and the client is expected to change the image on +the screen. This event is sent if the client has set the +ScreenSaverCycle bit in its event mask. + + + + + + + +If state is set to +On or +Off +then forced indicates whether or not +activation or deactivation was caused by a core +ForceScreenSaver +request; otherwise, forced is set to False. + + + +The kind field specifies mechanism that was used to save the screen +when the screen saver was activated, as described in +ScreenSaverQueryInfo. + + + +The time field indicates the server time +when the event was generated. + + + + + +Encoding + +Please refer to the X11 Protocol Encoding document as this document uses +conventions established there. + + +The name of this extension is "SCREEN-SAVER". + + + +Common Types + +SETofSCREENSAVEREVENT + #x00000001 ScreenSaverNotifyMask + #x00000002 ScreenSaverCycleMask + + + + +Requests + +ScreenSaverQueryVersion +1 CARD8 screen saver opcode +1 0 minor opcode +2 2 request length +1 CARD8 client major version +1 CARD8 client minor version +2 unused +-> +1 1 Reply +1 unused +2 CARD16 sequence number +4 0 reply length +1 CARD8 server major version +1 CARD8 server minor version +22 unused + +ScreenSaverQueryInfo +1 CARD8 screen saver opcode +1 1 minor opcode +2 2 request length +4 DRAWABLE drawable associated with screen +-> +1 1 Reply +1 CARD8 state + 0 Off + 1 On + 3 Disabled +2 CARD16 sequence number +4 0 reply length +4 WINDOW saver window +4 CARD32 milliseconds until saver or since saver +4 CARD32 milliseconds since last user device input +4 SETofSCREENSAVEREVENT event mask +1 CARD8 kind + 0 Blanked + 1 Internal + 2 External +10 unused + +ScreenSaverSelectInput +1 CARD8 screen saver opcode +1 2 minor opcode +2 3 request length +4 DRAWABLE drawable associated with screen +4 SETofSCREENSAVEREVENT event mask + +ScreenSaverSetAttributes +1 CARD8 screen saver opcode +1 3 minor opcode +2 6+n request length +4 DRAWABLE drawable associated with screen +2 INT16 x +2 INT16 y +2 CARD16 width +2 CARD16 height +2 CARD16 border-width +1 class + 0 CopyFromParent + 1 InputOutput + 2 InputOnly +1 CARD8 depth +4 VISUALID visual + 0 CopyFromParent +4 BITMASK value-mask (has n bits set to 1) + encodings are the same as for core CreateWindow +4n LISTofVALUE value-list + encodings are the same as for core CreateWindow + +ScreenSaverUnsetAttributes +1 CARD8 screen saver opcode +1 4 minor opcode +2 3 request length +4 DRAWABLE drawable associated with screen + + + + +Events + + +ScreenSaverNotify +1 CARD8 code assigned by core +1 CARD8 state + 0 Off + 1 On + 2 Cycle +2 CARD16 sequence number +4 TIMESTAMP time +4 WINDOW root +4 WINDOW screen saver window +1 CARD8 kind + 0 Blanked + 1 Internal + 2 External +1 BOOL forced +14 unused + + + + + +Inter-Client Communications Conventions + +Screen saver clients should create at least one resource value whose +identifier can be stored in a property named +_SCREEN_SAVER_ID +on the root of each screen it is managing. +This property should have one 32-bit value corresponding to the resource +identifier; the type of the property should indicate the type of the +resource and should be one of the following: +WINDOW, +PIXMAP, +CURSOR, +FONT, or +COLORMAP. + + + + +C language binding + + +The C binding for this extension simply provide access to the protocol; they +add no semantics beyond what is described above. + + + +The include file for this extension is +<X11/extensions/scrnsaver.h>. + + + + + + Bool XScreenSaverQueryExtension + Display *display + int *event_base + int *error_base + + + + +This routine returns +True +if the specified display supports the +SCREEN-SAVER extension; otherwise it returns +False. +If the extension is supported, the event number for +ScreenSaverNotify +events is returned in the value pointed to by +event_base. Since +no additional errors are defined by this extension, the results +of error_base are not defined. + + + + + Status XScreenSaverQueryVersion + Display *display + int *major + int *minor + + + + +If the specified display supports the +extension, the version numbers of the protocol +expected by the server are returned in +major and +minor and +a non-zero value is returned. Otherwise, the arguments are not +set and 0 is returned. + + +XScreenSaverInfo * +XScreenSaverAllocInfo() + + +This routine allocates and returns an +XScreenSaverInfo structure +for use in calls to . +All fields in the +structure are initialized to zero. If insufficient memory is available, +NULL is returned. The results of this routine can be released +using XFree. + + + + + Status XScreenSaverQueryInfo + Display *display + Drawable drawable + XScreenSaverInfo *saver_info + + + + +If the specified display supports the extension, +information about the current state of the +screen server is returned in saver_info and a non-zero value is +returned. The XScreenSaverInfo structure is +defined as follows: + + + +typedef struct { + Window window; /* screen saver window */ + int state; /* ScreenSaver{Off,On,Disabled} */ + int kind; /* ScreenSaver{Blanked,Internal,External} */ + unsigned long til_or_since; /* milliseconds */ + unsigned long idle; /* milliseconds */ + unsigned long event_mask; /* events */ +} XScreenSaverInfo; + + + +See the ScreenSaverQueryInfo request for a +description of the fields. If the extension is not supported, +saver_info is not changed and 0 +is returned. + + + + + void XScreenSaverSelectInput + Display *display + Drawable drawable + unsigned long event_mask + + + + +If the specified display supports the extension, +this routine asks that events related to +the screen saver be generated for this client. +The format of the events generated is: + + + +typedef struct { + int type; /* of event */ + unsigned long serial; /* # of last request processed by server */ + Bool send_event; /* true if this came from a SendEvent request */ + Display *display; /* Display the event was read from */ + Window window; /* screen saver window */ + Window root; /* root window of event screen */ + int state; /* ScreenSaver{Off,On,Cycle} */ + int kind; /* ScreenSaver{Blanked,Internal,External} */ + Bool forced; /* extents of new region */ + Time time; /* event timestamp */ +} XScreenSaverNotifyEvent; + + + +See the definition of the +ScreenSaverSelectInput request for descriptions +of the allowed event masks. + + + + + void XScreenSaverSetAttributes + Display *dpy + Drawable drawable + int x + int y + unsigned int width + unsigned int height + unsigned int border_width + int depth + unsigned int class + Visual *visual + unsigned long valuemask + XSetWindowAttributes *attributes + + + + +If the specified display supports the +extension, this routine sets the attributes to be used +the next time the external screen saver is activated. See the definition +of the ScreenSaverSetAttributes request for a +description of each of the arguments. + + + + + void XScreenSaverUnsetAttributes + Display *display + Drawable drawable + + + + +If the specified display supports the +extension, this routine instructs the server to discard +any previous screen saver window attributes set by this client. + + + + + Status XScreenSaverRegister + Display *display + int screen + XID xid + Atom type + + + + +This routine stores the given XID in the +_SCREEN_SAVER_ID property (of the given +type) on the root window of the specified +screen. It returns zero if an error +is encountered and the property is not changed, otherwise it returns +non-zero. + + + + + Status XScreenSaverUnregister + Display *display + int screen + + + + +This routine removes any _SCREEN_SAVER_ID from the +root window of the specified screen. +It returns zero if an error is encountered and the property is changed, +otherwise it returns non-zero. + + + + + Status XScreenSaverGetRegistered + Display *display + int screen + XID *xid + ATOM *type + + + + + +This routine returns the +XID and +type stored in the +_SCREEN_SAVER_ID property on the +root window of the specified screen. +It returns zero if an error +is encountered or if the property does not exist or is not of the correct +format; otherwise it returns non-zero. + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xcmiscproto/xc-misc.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xcmiscproto/xc-misc.xml new file mode 100644 index 0000000000000000000000000000000000000000..f2dfec2b8f4b0dfbd57467410f0949a865d60c5d --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xcmiscproto/xc-misc.xml @@ -0,0 +1,201 @@ + + %defs; +]> + + + + + + XC-MISC Extension + X Consortium Standard + + + BobScheifler + X Consortium + + + DavidP.Wiggins + X Consortium + + + X Version 11, Release &fullrelvers; + Version 1.1 + 1994X Consortium + + + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of the X Consortium shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from the X Consortium. + +X Window System is a trademark of The Open Group. + + + + + +Overview + +When an X client connects to an X server, it receives a fixed range of +resource IDs to use to identify the client's resources inside the X +server. Xlib hands these out sequentially as needed. When it +overruns the end of the range, an IDChoice protocol error results. +Long running clients, or clients that use resource IDs at a rapid +rate, may encounter this circumstance. When it happens, there are +usually many resource IDs available, but Xlib doesn't know about them. + +One approach to solving this problem would be to have Xlib notice when +a resource is freed and recycle its ID for future use. This strategy +runs into difficulties because sometimes freeing one resource causes +others to be freed (for example, when a window is destroyed, so are +its children). To do a complete job, Xlib would have to maintain a +large amount of state that currently resides only in the server (the +entire window tree in the above example). Even if a less +comprehensive strategy was adopted, such as recycling only those IDs +that Xlib can identify without maintaining additional state, the +additional bookkeeping at resource creation and destruction time +would likely introduce unacceptable overhead. + +To avoid the problems listed above, the server's complete knowledge of +all resource IDs in use by a client is leveraged. This extension +provides two ways for Xlib to query the server for available resource +IDs. Xlib can use these extension requests behind the scenes when it has +exhausted its current pool of resource IDs. + + + +Requests + + +XCMiscGetVersion + + + client_major_version: CARD16 + client_minor_version: CARD16 + + => + + client_major_version: CARD16 + client_minor_version: CARD16 + + +If supplied, the client_major_version and +client_minor_version indicate what version of +the protocol the client wants the server to implement. The server version +numbers returned indicate the protocol this extension actually supports. This +might not equal the version sent by the client. An implementation can +(but need not) support more than one version simultaneously. The +server_major_version and the server_minor_version are a +mechanism to support future revisions of the XC-MISC protocol +which may be necessary. In general, the major version would increment +for incompatible changes, and the minor version would increment for +small, upward-compatible changes. Servers that support the protocol +defined in this document will return a +server_major_version of one (1), and a +server_minor_version of one (1). + +XCMiscGetXIDRange + + => + + start_id: XID + count: CARD32 + + +This request returns a range of available resource IDs for the client +issuing the request. start_id is the first +ID in the range. count is the number of IDs +in the range. The returned range may or may not be the largest possible +range. + +XCMiscGetXIDList + + + count: CARD32 + + => + + ids: LISTofXID + + +This request returns the a list of individual resource IDs in +ids. +count is the number of resource IDs requested. +The number returned may be smaller than the number requested. + + + +Events and Errors + +No new events or errors are defined by this extension. + + + +Encoding + +Please refer to the X11 Protocol Encoding document as this document uses +conventions established there. + +The name of this extension is “XC-MISC”. + + +XCMiscGetVersion + 1 CARD8 opcode + 1 0 XC-MISC opcode + 2 2 request length + 2 CARD16 client_major_version + 2 CARD16 client_minor_version + + => + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 length + 2 CARD16 server_major_version + 2 CARD16 server_minor_version + 20 unused + + + +XCMiscGetXIDRange + 1 CARD8 opcode + 1 1 XC-MISC opcode + 2 1 request length + + => + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 length + 4 XID start_id + 4 CARD32 count + 16 unused + + + + +XCMiscGetXIDList + 1 CARD8 opcode + 1 2 XC-MISC opcode + 2 2 request length + 4 CARD32 count + + => + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 CARD32 length + 4 CARD32 number of XIDs in ids + 20 unused + 4n LISTofXID ids + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/appendix.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/appendix.xml new file mode 100644 index 0000000000000000000000000000000000000000..b6c0f1de3205533ce8368ed9a05dc6be72f0e090 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/appendix.xml @@ -0,0 +1,61 @@ + + + +System Window Encodings + + +The AppGroupCreateAssoc request has the following possible variations: + + + +AppGroupCreateAssoc (X11) + 1 CARD8 opcode + 1 6 XC-APPGROUP opcode + 2 n length + 4 WINDOW window + 2 0 window_type + 2 4 system_window_len + 4 WINDOW Window + + + +AppGroupCreateAssoc (Macintosh) + 1 CARD8 opcode + 1 6 XC-APPGROUP opcode + 2 n length + 4 WINDOW window + 2 1 window_type + 2 12 system_window_len + 4 CARD32 WindowPtr + 2 INT16 Rect.top + 2 INT16 Rect.left + 2 INT16 Rect.bottom + 2 INT16 Rect.right + + + +AppGroupCreateAssoc (Win32) + 1 CARD8 opcode + 1 6 XC-APPGROUP opcode + 2 n length + 4 WINDOW window + 2 2 window_type + 2 4 system_window_len + 4 CARD32 HWND + + + +AppGroupCreateAssoc (Win16) + 1 CARD8 opcode + 1 6 XC-APPGROUP opcode + 2 n length + 4 WINDOW window + 2 3 window_type + 2 4 system_window_len + 2 CARD16 HWND offset + 2 CARD16 HWND segment + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/appgrp.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/appgrp.xml new file mode 100644 index 0000000000000000000000000000000000000000..5e27a63fcde8f0f6782525588ae642f6de447782 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/appgrp.xml @@ -0,0 +1,1041 @@ + + %defs; +]> + +
+ + + Application Group Extension to the X Protocol + X Consortium Standard + + + Kaleb + S. + KEITHLEY + X Consortium, Inc + kaleb@x.org + + + X Version 11, Release &fullrelvers; + Version 1.0 + 1996X Consortium, Inc. + + + + +All Rights Reserved. + + + +THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT +OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE +OR THE USE OF OR OTHER DEALINGS IN THE SOFTWARE. + + +Except as contained in this notice, the name of the X Consortium shall not be used in advertising +or otherwise to promote the sale, use or other dealings in this Software without prior written +authorization from the X Consortium. + +X Window System is a trademark of The OpenGroup. + + +27 September 1996 + + + +The Application Group Extension to the X protocol is intended to provide a framework to allow +more than one program to manage X applications on the desktop. The initial use of this extension +will be to insert or embed the windows of X programs into the windows of another program, such +as a web browser. This extension is not intended to address larger embedding issues that, for +example, OpenDoc does, such as shared menu bars, etc. + + + + + +Purpose and Goals + + +The Application Group Extension to the X protocol is intended to provide +a framework to allow more than one program to manage X applications on +the desktop. The initial use of this extension will be to insert or embed +the windows of X programs into the windows of another program, such as a +web browser. This extension is not intended to address larger embedding +issues that, for example, OpenDoc does, such as shared menu bars, etc. +Using X programs on the World Wide Web allows for greater control of the +presentation and takes advantage of the existing body of X programs rather +than re-implement them in another language. In addition it allows the +embedding of non-X programs into web browsers by using third party products +like Wabi, MAE, and WinCenter. + +Wabi is a trademark of Sun Microsystems, Inc. MAE is a trademark of Apple +Computer, Inc. WinCenter is a trademark of Network Computing Devices, Inc. + + + + + + +Overview of the protocol. + + +This extension introduces the concept of an Application Group. An Application Group is a set of one or more applications that are primarily managed by a special application known as the Application Group Leader, which, for example, might be a web browser. The primary purpose of Application Groups is to provide a means of sharing the Substructure-Redirect attribute of the root window between the window manager and one or more Application Group Leaders. + + + +To join an Application Group an application must present the proper authorization during the connection setup. Authorizations are generated by the X server at the request of an Application Group Leader, and are then stored for the application to use to establish its connection to the X server. To generate an authorization the Application Group Leader sends a request to the server naming the Application Group to which the authorization will be bound, and any applications that connect using that authorization will automatically become part of the associated Application Group. The protocol to generate an authorization is defined in the Security Extension specification. + + + +As a member of an Application Group, when an application creates and maps a window as a child of the root window, the MapRequest and ConfigureRequest events are delivered to the Application Group Leader instead of the window manager. The Application Group Leader may then reparent the window into its own window hierarchy; or reissue the map request, in which case the window comes under the control of the window manager. + + + + +Requests + + +AppGroupQueryVersion + + + + + + + + client_major_version: CARD16 + + + client_minor_version: CARD16 + + + => + + + server_major_version: CARD16 + + + server_minor_version: CARD16 + + + + + + +If supplied, the client_major_version and client_minor_version indicate what version of the protocol the application wants the server to implement. The server version numbers returned indicate the version of the protocol the X server actually supports. This may not match the versions requested by the application. An implementation may (but need not) support more than one version simultaneously. The server_major_version and server_minor_version numbers are a mechanism to support any future revisions of the Application Group extension protocol which may be necessary. In general, the major version would increment for incompatible changes, and the minor version would increment for small, upward-compatible changes. X servers that support the protocol defined in this document will return a server_major_version of 1 and a server_minor_version of 0. + + + +AppGroupCreate + + + + + + + + app_group: APPGROUP + + + value_mask: BITMASK + + + value_list: LISTofVALUE + + + + + + +This request creates an Application Group using app_group as the Application Group ID. + + + + +  + + + + +The value_mask and value_list specify attributes of the Application Group that are to be explicitly initialized. The attributes, their types, and the default values are: + + + + + + + + + + + Attribute + Type + Default + + + app_group_leader + Bool + True + + + single_screen + Bool + True + + + default_root + Window + None + + + root_visual + VisualID + None + + + default_colormap + Colormap + None + + + black_pixel + Pixel + 0 + + + white_pixel + Pixel + 0 + + + + + + +If the single_screen attribute is True then the number of video screens returned to a program in the Application Group in the connection setup message is one, irrespective of how many video screens the server actually has. If a server supports both video and print screens, then all print screens will always be returned. If single_screen is specified as True then the connection setup message will contain only the information about the video screen which has default_root as its root window, plus any print screens. + + + +The intent is to allow an embedding manager to ensure that it will be able to reparent any top-level windows that Application Group members create. By hiding the fact that there are other screens it can be reasonably assured that applications will only create top-level windows on the same screen that it itself appears on. An embedding manager should take care not to supply an invalid display, e.g. :0.1, to a program that will be in an Application Group where the single_screen attribute is True. + + + +If single_screen is set to True default_root specifies which screen will be returned as screen zero in the connection setup message for applications in the Application Group. If set to None, then the real screen zero is used, otherwise the screen which has default_root as its root window will be used. + + + + +If single_screen is set to True the root_visual and default_colormap attributes may be used to over-ride the default values that are returned in the connection setup information returned to new programs in the Application Group. If None is specified for root_visual or default_colormap then the normal default values for the screen (possibly specified by default_root) are used, otherwise the specified values are used. If root_visual and/or default_colormap are specified they must be valid, i.e. root_visual must be a visual type available on the screen, and the colormap, if specified, must be a valid colormap for the visual that is used. + + + +IF single_screen is set to True and default_colormap is not specified as None, the black_pixel and white_pixel attributes must be specified, and they will over-ride the default values that are returned in the connection setup returned to new programs in the Application Group. If default_colormap is specified as None and black_pixel and/or white_pixel are specified, they will be ignored. + + + +The app_group_leader attribute is used to identify the Application Group Leader program for the app_group. By specifying True the server will identify the program making the request as the Application Group Leader for the application group. The Application Group Leader receives MapRequest and ConfigureRequest events from the server when an attempt is made to map or configure top-level windows of a program in an Application Group, instead of being sent to a window manager that has selected SubstructureRedirect events on the root window. The parent window field in these events will contain the Application Group ID. + + +AppGroupDestroy + +app_group: APPGROUP + + + +This request destroys the app_group. If the app_group_leader attribute for the app_group is True, then any applications in the Application Group that are still connected will be killed as if a KillClient request had been received for that application. + + + +If the application that created a non-embedded Application Group exits, and therefore any Authorizations to be cancelled, and any applications that attempt to open new connections to the X server using one of those Authorizations will be unable to do so. + + +AppGroupGetAttr + + + + + + + + + >app_group: APPGROUP + + + => + + + LISTofVALUE + + + + + + +This request returns the application group attributes for app_group. + + +AppGroupQuery + + + + + + + + resource: XID + + + => + + + app_group: APPGROUP + + + + + + +This request returns the Application Group ID of the application that created resource or None if that application is not associated with any Application Group. The resource value may be the resource base of the application. + + +AppGroupCreateAssociation + + + + + + + + window: WINDOW + + + window_type: CARD32 + + + system_window: LISTofCARD8 + + + + + + +This request associates window with system_window. The window_type indicates the native window system of the application making the request. For non-X window_types both the embedding manager and the server must be executing on the same host. When system_window is Microsoft Windows or OS/2 Presentation Manager, the system_window is an HWND; when the native window system is Macintosh, the system_window is a WindowPtr and a Rect. The window may be used for any X request that takes a Window. + + +AppGroupDestroyAssociation + + + + + + + + window: WINDOW + + + + + + +This request destroys the association created with AppGroupCreateAssociation. The window is destroyed. The system_window that was specified in the AppGroupCreateAssociation request is not affected. + + + + + +Changes to Existing Requests + + +MapWindow + + +If the override-redirect attribute of the window is False and if the window is a child of a root window and if the window belongs to an application that is in an application group and if some other application is the application group leader for that group, then a MapRequest event is generated and the window remains unmapped. Otherwise, the core protocol semantics apply. + + + + +ConfigureWindow + + +If the override-redirect attribute of the window is False and if the window is a child of a root window and if the window belongs to an application that is in an application group and if some other application is the application group leader for that group, then a ConfigureRequest event is generated and the window remains unchanged. Otherwise, the core protocol semantics apply. + + + + +CreateWindow + + +When a program in an Application Group creates a window that is a child of a root window and specifies CopyFromParent for the Visual, if the single_screen attribute is True and the root_visual attribute is set to something other than None, then the window will be created using the Application Group’s root_visual, otherwise core protocol semantics apply. + + + +When a program in an Application Group creates a window that is a child of a root window and specifies CopyFromParent for the Colormap, if the single_screen attribute is True, the default_colormap attribute is set to something other than None, and the window’s Visual is the same as the Application Group’s root_visual attribute, then the window will be created using the Application Group’s default_colormap, otherwise core protocol semantics apply. + + + + + +ChangeWindowAttributes + + +When a program in an Application Group changes the attributes of a window that is a child of a root window and specifies CopyFromParent for the Colormap, if the single_screen attribute is True, the default_colormap attribute is set to something other than None, and the window’s Visual is the same as the Application Group’s root_visual attribute, then the window will be created using the Application Group’s default_colormap, otherwise core protocol semantics apply. + + + + + + + +Changes to Existing Events + + +When the top-level window of an application that is a member of an Application Group is the target of a MapWindow or ConfigureWindow request, if there is an Application Group Leader then MapRequest and ConfigureRequest events are automatically delivered to it, otherwise the core protocol semantics apply, i.e. they are delivered to the client, if any, that has SubstructureRedirect set in its root-window event mask, e.g. the window manager. + + + +The Application Group Leader must not select SubstructuRedirect events on a root window as doing so would result in a core protocol error; only one client is permitted to do so, and that is usually the window manager. + + + + +MapRequest + + +When a MapWindow request is received for a window whose override-redirect attribute is set to False and whose parent is the root window and the window belongs to an application that is in an application group and there is an application group leader for the group, then this event is delivered to the Application Group Leader with the parent field in the event set to the AppGroup ID. Otherwise the core protocol semantics apply. + + + + +ConfigureRequest + + +When a ConfigureWindow request is received for a window whose override-redirect attribute is set to False and whose parent is the root window and the window belongs to an application that is in an application group and there is an application group leader for the group, then this event is delivered to the Application Group Leader with the parent field in the event set to the AppGroup ID. Otherwise the core protocol semantics apply. + + + + + + +Errors + + +AppGroupQueryVersion + + +There are no errors for AppGroupQueryVersion. + + + + + +AppGroupCreate + + +A Window error is returned if default_root is specified and is not a valid root window.. + + + +A Color error is returned default_colormap is specified but default_colormap is not a valid colormap for the screen of default_root. + + + +A Match error is returned if root_visual and default_colormap are both specified, but + + + +default_colormap’s visual is not root_visual. + + + +A Match error is returned if root_visual does not exist for the screen of the default_root. + + + + + +AppGroupDestroy + + +An AppGroup error is returned if app_group is not a valid Application Group. + + + +An Access error is returned if an untrusted application attempts to destroy an Application Group created by a trusted application. + + + + + +AppGroupGetAttr + + +An AppGroup error is returned if app_group is not a valid Application Group. + + + +An Access error is returned if an untrusted application attempts to get the attributes of an Application Group created by a trusted application. + + + + + +AppGroupQuery + + +An Access error is returned if an untrusted application attempts to query the Application Group of a trusted application. + + + + + +AppGroupCreateAssociation + + +A Match error is returned if the X server does not support the window_type. + + + +An Access error may be returned if the X server only supports the window_type on the local host and the program making the request is on a non-local host. + + + +A Window error may be returned for system-specific errors related to system_window, e.g. system_window does not represent a valid native window. + + + + + +AppGroupDestroyAssociation + + +A Window error is returned if window was not specified in a previous AppGroupCreateAssociation request. + + + + + + +Encoding + + +Please refer to the X11 Protocol encoding document as this document uses conventions established there. + + + + +The name of this extension is XC-APPGROUP + + + + +AppGroupQueryVersion + 1 CARD8 opcode + 1 0 XC-APPGROUP opcode + 2 3 length + 2 CARD16 client_major_version + 2 CARD16 client_minor_version +=> + 1 1 Reply + 1 unused + 2 CARD16 sequence_number + 4 0 length + 2 CARD16 server_major_version + 2 CARD16 server_minor_version + 20 unused + + + + +AppGroupCreate + 1 CARD8 opcode + 1 1 XC-APPGROUP opcode + 2 8+n length + 4 XID app_group + 4 BITMASK attrib_mask + #x00000001 app_group_leader + #x00000002 single_screen + #0x0000004 default_root + #x00000008 root_visual + #x00000010 default_colormap + #x00000020 black_pixel + #x00000040 white_pixel + n LISTofVALUE value-list +VALUEs + 4 BOOL app_group_leader + 4 BOOL single_screen + 4 WINDOW default_root + 4 VISUALID root_visual + 4 COLORMAP default_colormap + 4 CARD32 black_pixel + 4 CARD32 white_pixel + + + + +AppGroupDestroy + 1 CARD8 opcode + 1 2 XC-APPGROUP opcode + 2 2 length + 4 XID app_group + + + +AAppGroupGetAttr + 1 CARD8 opcode + 1 4 XC-APPGROUP opcode + 2 2 length + 4 XID app_group +=> + 1 1 Reply + 1 unused + 2 CARD16 sequence_number + 4 0 length + 4 WINDOW default_root + 4 VISUALID root_visual + 4 COLORMAP default_colormap + 4 CARD32 black_pixel + 4 CARD32 whte_pixel + 1 BOOL single_screen + 1 BOOL app_group_leader + 2 unused + + + + +AppGroupQuery + 1 CARD8 opcode + 1 5 XC-APPGROUP opcode + 2 2 length + 4 XID resource +=> + 1 1 Reply + 1 unused + 2 CARD16 sequence_number + 4 0 length + 4 XID app_group + 20 unused + + + +AppGroupCreateAssoc + 1 CARD8 opcode + 1 6 XC-APPGROUP opcode + 2 n length + 4 WINDOW window + 2 CARD16 window_type + #0 X11 + #1 Macintosh + #2 Win32, OS/2 PM 2.x + #3 Win16, OS/2 PM 1.x + 2 n system_window_len + n LISTofCARD8 system_window + + + + +AppGroupDestroyAssoc + 1 CARD8 opcode + 1 7 XC-APPGROUP opcode + 2 2 length + 4 WINDOW window + + + + + +Library API + + + + + + + + +Status XagQueryVersion ( xkb, keycode) /* macro */ + + + + +Display dpy; + + + + +int * major_version_return; + + + + +int * minor_version_return; + + + + + + + +XagQueryVersion sets major_version_return and minor_version_return to the major and minor Application Group protocol version supported by the server. If the Xag library is compatible with the version returned by the server it returns non-zero. If dpy does not support the Application Group extension, or if the server and library protocol versions are incompatible, or if there was an error during communication with the server, it returns zero. No other Xag functions may be called before this function. If a program violates this rule, the effects of all subsequent Xag calls that it makes are undefined. + + + +An embedding manager in, e.g. a Personal Computer Web Browser, will need to open a connection to the Personal Computer X server by calling XOpenDisplay() before using the Application Group extension. + + + +An embedding manager such as a web browser that intends to embed programs in an Application Group should create the Application Group with XagCreateEmbeddedApplicationGroup. + + + + + + + + + + +Status XagCreateEmbeddedApplicationGroup( + + + + + Display* dpy, + + + + + VisualID root_visual, + + + + + Colormap default_colormap, + + + + + unsigned long black_pixel, + + + + + unsigned long white_pixel, + + + + + XAppGroup* app_group_return); + + + + + + + + +XagCreateEmbeddedApplicationGroup creates an Application Group for an embedding manager with the attributes specified. It also sets the default_root attribute to DefaultRoot(dpy, DefaultsScreen(dpy)) and the single_screen and app_group_leader attributes to True. It returns the Application Group ID in app_group_return. + + + +You can create an Application Group without intending to do embedding. One reason for doing this is to give a group of clients their own font-path. + + + +A special font-path can be created by creating an Application Group, getting an Authorization using XSecurityGenerateAuthorization, and then running ‘xset fp+ <new font path>’ as a member of the Application Group. Font-path elements added in this way will be "private" to the Application Group. + + + + + + + + + +Status XagCreateNonembeddedApplicationGroup( + + + + + Display* dpy, + + + + + XAppGroup* app_group_return); + + + + + + + +An Application Group created with XagCreateNonembeddedApplicationGroup will have the default_root, root_visual, and default_colormap attributes all set to None; the single_screen and app_group_leader attributes are set to False, and the black_pixel and white_pixel attributes are not used since the default_colormap attribute is None. + + + +To destroy an Application Group use XagDestroyApplicationGroup. + + + + + + + + + +Status XagDestroyApplicationGroup( + + + + + Display* dpy, + + + + + XAppGroup app_group); + + + + + + + +The Application Group specified by app_group is destroyed. If the Application Group was created using XagCreateEmbeddingApplicationGroup, i.e. and therefore the app_group_leader attribute is True, all programs that are members of the Application Group are killed as if a KillClient request had been issued. + + + + +To retrieve the attributes of an Application Group use XagGetApplicationGroupAttributes. + + + + + + + + + + +Status XagGetApplicationGroupAttributes( + + + + + Display* dpy, + + + + + XAppGroup app_group, + + + + + ...); + + + + + + + + + +XagGetApplicationGroupAttributes is a varargs function that retrieves the Application Group’s attributes specified in the vararg parameter list. + + + +The attributes that may be specified are: XagNappGroupLeader, XagNsingleScreen, XagNdefaultRoot, XagNrootVisual, XagNdefaultColormap, XagNblackPixel, and XagNwhitePixel; which correspond to app_group_leader, single_screen, default_root, root_visual, default_colormap, black_pixel, and white_pixel respectively. See AppGroupCreate in Section 3 for a description of each attribute. + + + +The types for each of the parameters are pointers to the following: + + + + single_screen Bool + default_root Window + root_visual VisualID + default_colormap Colormap + black_pixel unsigned long + white_pixel unsigned long + app_group_leader Bool + + + +Example: + ... + Boolean app_group_leader, single_screen; + Window default_root; + VisualID root_visual; + Colormap default_colormap; + Pixel black_pixel, white_pixel; + ... + status = XagGetApplicationGroupAttributes(dpy, app_group, + XagNappGroupLeader, &app_group_leader, + XagNsingleScreen, &single_screen, + XagNdefault_root, &default_root, + XagNrootVisual, &root_visual, + XagNdefaultColormap, &default_colormap, + XagNblackPixel, &black_pixel, + XagNwhitePixel, &white_pixel, + NULL); + ... + + + + +To determine which Application Group a resource (such as a window) belongs to, use XagQueryApplicationGroup. + + + + + + + + + +Status XagQueryApplicationGroup( + + + + + Display* dpy, + + + + + XID resource, + + + + + XAppGroup* app_group_return); + + + + + + + + +The Application Group is returned in app_group_return, if the resource is not in any Application Group then app_group_return will be set to None. + + + +To associate an X Window ID with a system-specific window ID, such as a HWND or a WindowPtr, use XagCreateAssociation. + + + + + + + + + +Status XagCreateAssociation( + + + + + Display* dpy, + + + + + Window* window_return, + + + + + void* system_window); + + + + + + + + +The window_ret may be used as the target for a ReparentWindow request. + + + +Because XReparentWindow is not constrained in the same way that Win32’s SetParent and the Macintosh are, there is no reason to call XagCreateAssociation in an X-based embedding manager. As such if XagCreateAssociation is called in a native X program, the window_return will be the same as the system_window, and the implementation may even elect to not generate any protocol. + + +To create an association on the Macintosh: + + + struct { + WindowPtr win; + Rect rect; + } system_window; + system_window.win = win_ptr; + system_window.rect.top = system_window.rect.left = 20; + system_window.rect.bottom = 180; + system_window.rect.right = 380; + + + + status = XagCreateAssociation (dpy, &window, (void*)&system_window); + + + +To create an association using a Win16, Win32, or OS/2 PM: + + + + HWND system_window; + status = XagCreateAssociation (dpy, &window, (void*)&system_window); + + + +To destroy the association created with XagCreateAssociation use XagDestroyAssociation. + + + + + + + + + + +Status XagDestroyAssociation( + + + + + Display* dpy, + + + + + Window window); + + + + + + + +After calling XagDestroyAssociation the window may no longer be used to +reparent windows with XReparentWindow. + + + +Like XagCreateAssociation, if the native window system is X11 the implementation may elect to not generate any protocol as a result of this function call in order to avoid unintentionally destroying the the system_window that was specified in the prior XagCreateAssociation call. + + + +
diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/dbe.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/dbe.xml new file mode 100644 index 0000000000000000000000000000000000000000..f0b345c3a0099c3f72c3dccdd0ecfb1cdf613fe6 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/dbe.xml @@ -0,0 +1,1069 @@ + + %defs; +]> + + + + + + + + Double Buffer Extension Protocol + X Consortium Standard + + + IanElliott + Hewlett-Packard Company + + + DavidP.Wiggins + X Consortium + + + 1989199219931994 + X Consortium, Inc. + + 1989Digital Equipment Corporation + 1992Intergraph Corporation + 1993Silicon Graphics, Inc. + 1994Hewlett-Packard Company + X Version 11, Release &fullrelvers; + Version 1.0 + + + +Permission to use, copy, modify, and distribute this documentation for any +purpose and without fee is hereby granted, provided that the above copyright +notice and this permission notice appear in all copies. Digital Equipment +Corporation, Intergraph Corporation, Silicon Graphics, Hewlett-Packard, and +the X Consortium make no representations about the suitability for any purpose +of the information in this document. This documentation is provided “as is” +without express or implied warranty. + + + + + +Introduction +The Double Buffer Extension (DBE) provides a standard way to utilize +double-buffering within the framework of the X Window System. Double-buffering +uses two buffers, called front and back, which hold images. The front buffer +is visible to the user; the back buffer is not. Successive frames of an +animation are rendered into the back buffer while the previously rendered +frame is displayed in the front buffer. When a new frame is ready, the back +and front buffers swap roles, making the new frame visible. Ideally, this +exchange appears to happen instantaneously to the user and with no visual +artifacts. Thus, only completely rendered images are presented to the user, +and they remain visible during the entire time it takes to render a new frame. +The result is a flicker-free animation. + + + + +Goals +This extension should enable clients to: + + + + + Allocate and deallocate double-buffering for a window. + + + +Draw to and read from the front and back buffers associated with a window. + + + + Swap the front and back buffers associated with a window. + + + +Specify a wide range of actions to be taken when a window is swapped. +This includes explicit, simple swap actions (defined below), and more +complex actions (for example, clearing ancillary buffers) that can be put +together within explicit "begin" and "end" requests (defined below). + + + + +Request that the front and back buffers associated with multiple +double-buffered windows be swapped simultaneously. + + + + + +In addition, the extension should: + + + + + +Allow multiple clients to use double-buffering on the same window. + + + +Support a range of implementation methods that can capitalize on existing +hardware features. + + + + Add no new event types. + + + +Be reasonably easy to integrate with a variety of direct graphics hardware +access (DGHA) architectures. + + + + + + + +Concepts + + +Normal windows are created using the core CreateWindow +request, which allocates a set of window attributes and, for InputOutput +windows, a front buffer, into which an image can be drawn. The contents of +this buffer will be displayed when the window is visible. + + +This extension enables applications to use double-buffering with a window. +This involves creating a second buffer, called a back buffer, and associating +one or more back buffer names (XIDs) with the window for use when referring to +(that is, drawing to or reading from) the window's back buffer. The back +buffer name is a DRAWABLE of type BACKBUFFER. + + + +DBE provides a relative double-buffering model. One XID, the window, always +refers to the front buffer. One or more other XIDs, the back buffer names, +always refer to the back buffer. After a buffer swap, the window continues to +refer to the (new) front buffer, and the back buffer name continues to refer +to the (new) back buffer. Thus, applications and toolkits that want to just +render to the back buffer always use the back buffer name for all drawing +requests to the window. Portions of an application that want to render to +the front buffer always use the window XID for all drawing requests to the +window. + + + +Multiple clients and toolkits can all use double-buffering on the same +window. DBE does not provide a request for querying whether a window has +double-buffering support, and if so, what the back buffer name is. Given +the asynchronous nature of the X Window System, this would cause race +conditions. Instead, DBE allows multiple back buffer names to exist for +the same window; they all refer to the same physical back buffer. The first +time a back buffer name is allocated for a window, the window becomes +double-buffered and the back buffer name is associated with the window. +Subsequently, the window already is a double-buffered window, and nothing +about the window changes when a new back buffer name is allocated, except +that the new back buffer name is associated with the window. The window +remains double-buffered until either the window is destroyed or until all of +the back buffer names for the window are deallocated. + + + +In general, both the front and back buffers are treated the same. In +particular, here are some important characteristics: + + + + + +Only one buffer per window can be visible at a time (the front buffer). + + + + +Both buffers associated with a window have the same visual type, depth, +width, height, and shape as the window. + + + + +Both buffers associated with a window are "visible" (or "obscured") in +the same way. When an Expose event is generated for a window, both +buffers should be considered to be damaged in the exposed area. Damage +that occurs to either buffer will result in an Expose event on the window. +When a double-buffered window is exposed, both buffers are tiled with the +window background, exactly as stated by the core protocol. Even though +the back buffer is not visible, terms such as obscure apply to the back +buffer as well as to the front buffer. + + + + +It is acceptable at any time to pass a BACKBUFFER in any +request, notably any core or extension drawing request, that expects +a DRAWABLE. This enables an application to draw directly into +BACKBUFFERs in the same fashion as it would draw into any other +DRAWABLE. + + + + +It is an error (Window) to pass a BACKBUFFER in a core request that +expects a Window. + + + + +A BACKBUFFER will never be sent by core X in a reply, event, or error +where a Window is specified. + + + + +If core X11 backing-store and save-under applies to a double-buffered +window, it applies to both buffers equally. + + + + +If the core ClearArea request is executed on a +double-buffered window, the same area in both the front and back buffers +is cleared. + + + + +The effect of passing a window to a request that accepts a DRAWABLE is +unchanged by this extension. The window and front buffer are synonymous with +each other. This includes obeying the GetImage semantics +and the subwindow-mode semantics if a core graphics context is involved. +Regardless of whether the window was explicitly passed in a +GetImage request, or implicitly referenced (that is, +one of the windo's ancestors was passed in the request), the front (that is, +visible) buffer is always referenced. Thus, DBE-naive screen dump clients will +always get the front buffer. GetImage on a back buffer +returns undefined image contents for any obscured regions of the back buffer +that fall within the image. + + + +Drawing to a back buffer always uses the clip region that would be used to +draw to the front buffer with a GC subwindow-mode of +ClipByChildren. If an +ancestor of a double-buffered window is drawn to with a core GC having a +subwindow-mode of IncludeInferiors, the effect on the +double-buffered window's back buffer depends on the depth of the +double-buffered window and the ancestor. If the depths are the same, the +contents of the back buffer of the double-buffered window are not changed. +If the depths are different, the contents of the back buffer of the +double-buffered window are undefined for the pixels that the +IncludeInferiors drawing touched. + + + +DBE adds no new events. DBE does not extend the semantics of any existing +events with the exception of adding a new DRAWABLE type called BACKBUFFER. If +events, replies, or errors that contain a DRAWABLE (for example, +GraphicsExpose) are generated in response to a request, +the DRAWABLE returned will be the one specified in the request. + + + +DBE advertises which visuals support double-buffering. + + + +DBE does not include any timing or synchronization facilities. +Applications that need such facilities (for example, to maintain a constant +frame rate) should investigate the Synchronization Extension, an X +Consortium standard. + + + +Window Management Operations + + +The basic philosophy of DBE is that both buffers are treated the same by core +X window management operations. + + + +When the core DestroyWindow is executed on a +double-buffered window, both buffers associated with the window are +destroyed, and all back buffer names associated with the window are freed. + + + +If the core ConfigureWindow request changes the size of +a window, both buffers assume the new size. If the windo's size increases, +the effect on the buffers depends on whether the implementation honors bit +gravity for buffers. If bit gravity is implemented, then the contents of +both buffers are moved in accordance with the windo's bit gravity (see the +core ConfigureWindow request), and the remaining areas +are tiled with the window background. If bit gravity is not implemented, then +the entire unobscured region of both buffers is tiled with the window +background. In either case, Expose events are generated +for the region that is tiled with the window background. + + + +If the core GetGeometry request is executed on a +BACKBUFFER, the returned x, y, and border-width will be zero. + + + +If the Shape extension ShapeRectangles, +ShapeMask, +ShapeCombine, or +ShapeOffset +request is executed on a double-buffered window, both buffers are reshaped +to match the new window shape. The region difference is the following: + + + + D = newshape - oldshape + + + +It is tiled with the window background in both buffers, and +Expose events are generated for D. + + + + + +Complex Swap Actions + +DBE has no explicit knowledge of ancillary buffers (for example, depth +buffers or alpha buffers), and only has a limited set of defined swap +actions. Some applications may need a richer set of swap actions than DBE +provides. Some DBE implementations have knowledge of ancillary buffers, +and/or can provide a rich set of swap actions. Instead of continually +extending DBE to increase its set of swap actions, DBE provides a flexible +"idiom" mechanism. If an application's needs are served by the defined swap +actions, it should use them; otherwise, it should use the following method +of expressing a complex swap action as an idiom. Following this policy will +ensure the best possible performance across a wide variety of implementations. + + + +As suggested by the term "idiom," a complex swap action should be expressed +as a group/series of requests. Taken together, this group of requests may be +combined into an atomic operation by the implementation, in order to maximize +performance. The set of idioms actually recognized for optimization is +implementation dependent. To help with idiom expression and interpretation, +an idiom must be surrounded by two protocol requests: +DBEBeginIdiom and +DBEEndIdiom. Unless this begin-end pair +surrounds the idiom, it may not be recognized by a given implementation, and +performance will suffer. + + + +For example, if an application wants to swap buffers for two windows, and +use core X to clear only certain planes of the back buffers, the application +would issue the following protocol requests as a group, and in the following +order: + + + + + DBEBeginIdiom request. + + + +DBESwapBuffers request with XIDs for two windows, each of which uses +a swap action of Untouched. + + + + +Core X PolyFillRectangle request to the back buffer of one window. + + + + +Core X PolyFillRectangle request to the back buffer of the other window. + + + + DBEEndIdiom request. + + + + +The DBEBeginIdiom and DBEEndIdiom +requests do not perform any actions themselves. They are treated as markers +by implementations that can combine certain groups/series of requests as +idioms, and are ignored by other implementations or for nonrecognized +groups/series of requests. If these requests are sent out of order, or are +mismatched, no errors are sent, and the requests are executed as usual, +though performance may suffer. + + + +An idiom need not include a DBESwapBuffers request. For +example, if a swap action of Copied is desired, but only some of the planes +should be copied, a core X +CopyArea request may be used instead of +DBESwapBuffers. +If DBESwapBuffers is included in an idiom, it should +immediately follow the DBEBeginIdiom request. Also, when +the DBESwapBuffers is included in an idiom, that +request's swap action will still be valid, and if the swap action might +overlap with another request, then the final result of the idiom must be as if +the separate requests were executed serially. For example, if the specified +swap action is Untouched, and if a PolyFillRectangle +using a client clip rectangle is done to the windo's back buffer after the +DBESwapBuffers request, then the contents of the new +back buffer (after the idiom) will be the same as if the idiom was not +recognized by the implementation. + + + +It is highly recommended that Application Programming Interface (API) +providers define, and application developers use, "convenience" functions +that allow client applications to call one procedure that encapsulates +common idioms. These functions will generate the +DBEBeginIdiom request, the idiom requests, and +DBEEndIdiom request. Usage of these functions will +ensure best possible performance across a wide variety of implementations. + + + + + + +Requests +The DBE defines the following requests. + + +DBEGetVersion + +This request returns the major and minor version numbers of this extension. + + +DBEGetVersion + + + + + + + + client-major-version + CARD8 + + + client-minor-version + CARD8 + + + => + + + + server-major-version + CARD8 + + + server-minor-version + CARD8 + + + + + + +The client-major-version and client-minor-version numbers indicate what +version of the protocol the client wants the server to implement. The +server-major-version and the server-minor-version numbers returned indicate +the protocol this extension actually supports. This might not equal the +version sent by the client. An implementation can (but need not) support +more than one version simultaneously. The server-major-version and +server-minor-version allow the creation of future revisions of the DBE +protocol that may be necessary. In general, the major version +would increment for incompatible changes, and the minor version would increment +for small, upward-compatible changes. Servers that support the protocol +defined in this document will return a server-major-version of one (1), and a +server-minor-version of zero (0). + + + +The DBE client must issue a DBEGetVersion request before any other double +buffering request in order to negotiate a compatible protocol version; +otherwise, the client will get undefined behavior (DBE may or may not work). + + + + + +DBEGetVisualInfo + +This request returns information about which visuals support double buffering. + + +DBEGetVisualInfo + + + + + + + + + screen-specifiers + LISTofDRAWABLE + + + => + + + + visinfo + LISTofSCREENVISINFO + + + + +where: + + + + + + + + + SCREENVISINFO + LISTofVISINFO + + + VISINFO + [ visual: VISUALID + + + + depth: CARD8 + + + + perflevel: CARD8 ] + + + + + +Errors: Drawable + + +All of the values passed in screen-specifiers must be valid DRAWABLEs (or a +Drawable error results). For each drawable in +screen-specifiers, the reply will contain a list of VISINFO structures for +visuals that support double-buffering on the screen on which the drawable +resides. The visual member specifies the VISUALID. The depth member specifies +the depth in bits for the visual. The perflevel is a performance hint. The +only operation defined on a perflevel is comparison to a perflevel of another +visual on the same screen. The visual having the higher perflevel is likely +to have better double-buffer graphics performance than the visual having the +lower perflevel. Nothing can be deduced from any of the following: the +magnitude of the difference of two perflevels, a perflevel value in isolation, +or comparing perflevels from different servers. + + + +If the list of screen-specifiers is empty, information for all screens is +returned, starting with screen zero. + + + + + +DBEAllocateBackBufferName + + +This request allocates a drawable ID used to refer to the back buffer of a +window. + + +DBEAllocateBackBufferName + + + + + + + + + window + WINDOW + + + back-buffer-name + BACKBUFFER + + + swap-action-hint + SWAPACTION + + + + + + +Errors: Alloc, Value, IDChoice, Match, Window + + + +If the window is not already a double-buffered window, the window becomes +double-buffered, and the back-buffer-name is associated with the window. The +swap-action-hint tells the server which swap action is most likely to be +used with the window in subsequent DBESwapBuffers +requests. The swap-action-hint must have one of the values specified for type +SWAPACTION (or a Value error results). See the description of the +DBESwapBuffers request for a complete discussion of +swap actions and the SWAPACTION type. + + + +If the window already is a double-buffered window, nothing about the window +changes, except that an additional back-buffer-name is associated with the +window. The window remains double-buffered until either the window is +destroyed, or until all of the back buffer names for the window are +deallocated. + + + +The window passed into the request must be a valid WINDOW (or a Window error +results). The window passed into the request must be an InputOutput window (or +a Match error results). The visual of the window must be in the list returned +by DBEGetVisualInfo (or a Match error results). The +back-buffer-name must be in the range assigned to the client, and must not +already be in use (or an IDChoice error results). If the server cannot +allocate all resources associated with turning on double-buffering for the +window, an Alloc error results, the windo's double-buffer status (whether it +is already double-buffered or not) remains unchanged, and the +back-buffer-name is freed. + + + + +DBEDeallocateBackBufferName + +This request frees a drawable ID that was obtained by +DBEAllocateBackBufferName. + + +DBEDeallocateBackBufferName + + + + + + + + + back-buffer-name + BACKBUFFER + + + + + +Errors: Buffer + + +The back-buffer-name passed in the request is freed and no longer associated +with the window. If this is the last back-buffer-name associated with the +window, then the back buffer is no longer accessible to clients, and all +double-buffering resources associated with the window may be freed. The +window's current front buffer remains the front buffer. + + + +The back-buffer-name must be a valid BACKBUFFER associated with a window (or +a Buffer error results). + + + + +DBESwapBuffers + +This request swaps the buffers for all windows listed, applying the +appropriate swap action for each window. + + +DBESwapBuffers + + + + + + + + + windows + LISTofSWAPINFO + + + + +where: + + + + + + + + SWAPINFO + [ window: WINDOW + + + + swap-action: SWAPACTION ] + + + SWAPACTION + { Undefined, Background, Untouched, Copied } + + + + + +Errors: Match, Window, Value + + +Each window passed into the request must be a valid WINDOW (or a +Window error results). Each window passed into the +request must be a double-buffered window (or a Match +error results). Each window passed into the request must only be listed +once (or a Match error results). Each swap-action in +the list must have one of the values specified for type SWAPACTION (or a +Value error results). If an error results, none of +the valid double-buffered windows will have their buffers swapped. + + + +The swap-action determines what will happen to the new back buffer of the +window it is paired with in the list in addition to making the old back +buffer become visible. The defined actions are as follows: + + + + + Undefined + +The contents of the new back buffer become undefined. This may be the +most efficient action since it allows the implementation to discard the +contents of the buffer if it needs to. + + + + Background + +The unobscured region of the new back buffer will be tiled with the window +background. The background action allows devices to use a fast clear +capability during a swap. + + + + Untouched + +The unobscured region of the new back buffer will be unmodified by the swap. + + + + Copied + +The unobscured region of the new back buffer will be the contents of the +old back buffer. + + + + + +If DBESwapBuffers is included in a "swap and clear" +type of idiom, it must immediately follow the +DBEBeginIdiom request. + + + + +DBEBeginIdiom + +This request informs the server that a complex swap will immediately follow +this request. + + +DBEBeginIdiom + + +As previously discussed, a complex swap action is a group/series of +requests that, taken together, may be combined into an atomic operation by +the implementation. The sole function of this request is to serve as a +"marker" that the server can use to aid in idiom processing. The server is +free to implement this request as a no-op. + + + + +DBEEndIdiom + + + +This request informs the server that a complex swap has concluded. + + +DBEEndIdiom + + +The sole function of this request is to serve as a "marker" that the server +can use to aid in idiom processing. The server is free to implement this +request as a no-op. + + + + + +DBEGetBackBufferAttributes + +This request returns information about a back buffer. + +DBEGetBackBufferAttributes + + + + + + + + + back-buffer-name + BACKBUFFER + + + => + + + + attributes + BUFFER_ATTRIBUTES + + + + + +where: + +BUFFER_ATTRIBUTES: [ window: WINDOW ] + + +If back-buffer-name is a valid BACKBUFFER, the window field of the +attributes in the reply will be the window which has the back buffer that +back-buffer-name refers to. If back-buffer-name is not a valid BACKBUFFER, +the window field of the attributes in the reply will be None. + + + + + + +Encoding + +Please refer to the X11 Protocol Encoding document as this section uses +syntactic conventions and data types established there. + + +The name of this extension is "DOUBLE-BUFFER". + + +Type +The following new types are used by the extension. + + +BACKBUFFER: XID +SWAPACTION + +#x00 Undefined +#x01 Background +#x02 Untouched +#x03 Copied + + +SWAPINFO + +4 WINDOW window +1 SWAPACTION swap action +3 unused + + +VISINFO + +4 VISUALID visual +1 CARD8 depth +1 CARD8 perflevel +2 unused + + +SCREENVISINFO + +4 CARD32 n, number in list +8n LISTofVISINFO n VISINFOs + + +BUFFER_ATTRIBUTES + +4 WINDOW window + + + + +Error +Buffer + +1 0 error +1 error base + 0 code +2 CARD16 sequence number +4 CARD32 bad buffer +2 CARD16 minor-opcode +1 CARD8 major-opcode +21 unused + + + + +Request + +DBEGetVersion + +1 CARD8 major-opcode +1 0 minor-opcode +2 2 request length +1 CARD8 client-major-version +1 CARD8 client-minor-version +2 unused +=> +1 unused +2 CARD16 sequence number +4 0 reply length +1 CARD8 server-major-version +1 CARD8 server-minor-version +22 unused + + +DBEAllocateBackBufferName + +1 CARD8 major-opcode +1 1 minor-opcode +2 4 request length +4 WINDOW window +4 BACKBUFFER back buffer name +1 SWAPACTION swap action hint +3 unused + + +DBEDeallocateBackBufferName + +1 CARD8 major-opcode +1 2 minor-opcode +2 2 request length +4 BACKBUFFER back buffer name + + + +DBESwapBuffers + +1 CARD8 major-opcode +1 3 minor-opcode +2 2+2n request length +4 CARD32 n, number of window/swap action pairs in list +8n LISTofSWAPINFO window/swap action pairs + + + +DBEBeginIdiom + +1 CARD8 major-opcode +1 4 minor-opcode +2 1 request length + + +DBEEndIdiom + +1 CARD8 major-opcode +1 5 minor-opcode +2 1 request length + + +DBEGetVisualInfo + +1 CARD8 major-opcode +1 6 minor-opcode +2 2+n request length +4 CARD32 n, number of screen specifiers in list +4n LISTofDRAWABLE n screen specifiers +=> +1 1 Reply +1 unused +2 CARD16 sequence number +4 CARD32 j, reply length +4 CARD32 m, number of SCREENVISINFOs in list +20 unused +4j LISTofSCREENVISINFO m SCREENVISINFOs + + +DBEGetBackBufferAttributes + +1 CARD8 major-opcode +1 7 minor-opcode +2 2 request length +4 BACKBUFFER back-buffer-name +=> +1 unused +2 CARD16 sequence number +4 0 reply length +4 BUFFER_ATTRIBUTES attributes +20 unused + + + + + + +Acknowledgements + +We wish to thank the following individuals who have contributed their time +and talent toward shaping the DBE specification: + +T. Alex Chen, IBM; Peter Daifuku, Silicon Graphics, Inc.; +Ian Elliott, Hewlett-Packard Company; Stephen Gildea, X Consortium, Inc.; +Jim Graham, Sun; Larry Hare, AGE Logic; Jay Hersh, X Consortium, Inc.; +Daryl Huff, Sun; Deron Dann Johnson, Sun; Louis Khouw, Sun; +Mark Kilgard, Silicon Graphics, Inc.; Rob +Lembree, Digital Equipment Corporation; Alan Ricker, Metheus; Michael +Rosenblum, Digital Equipment Corporation; Bob Scheifler, X Consortium, Inc.; +Larry Seiler, Digital Equipment Corporation; Jeanne Sparlin Smith, IBM; +Jeff Stevenson, Hewlett-Packard Company; Walter Strand, Metheus; Ken +Tidwell, Hewlett-Packard Company; and David P. Wiggins, X Consortium, Inc. + + + +Mark provided the impetus to start the DBE project. Ian wrote the first +draft of the specification. David served as architect. + + + + +References + +Jeffrey Friedberg, Larry Seiler, and Jeff Vroom, "Multi-buffering Extension +Specification Version 3.3." + +Tim Glauert, Dave Carver, Jim Gettys, and David P. Wiggins, +"X Synchronization Extension Version 3.0." + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/dpms.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/dpms.xml new file mode 100644 index 0000000000000000000000000000000000000000..7edfe5c2595c247f61029ae3bc2493bcef474cfd --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/dpms.xml @@ -0,0 +1,663 @@ + + %defs; +]> + + + + + X Display Power Management Signaling (DPMS) Extension Protocol Specification + X Project Team Standard + + + Rob Lembree + Digital Equipment Corporation + lembree@zk3.dec.com + + + X Version 11, Release &fullrelvers; + Version 1.0 + 1996Digital Equipment Corporation + + + +Permission to use, copy, modify, distribute, and sell this +documentation for any purpose is hereby granted without fee, +provided that the above copyright notice and this permission +notice appear in all copies. Digital Equipment Corporation +makes no representations about the suitability for any purpose +of the information in this document. This documentation is +provided “as is” without express or implied warranty. + + + + + + +Overview + +This extension provides X Protocol control over the VESA Display +Power Management Signaling (DPMS) characteristics of video boards +under control of the X Window System. + +X Window System is a trademark of The Open Group. + + + + + + + +Traditionally, the X Window System has provided for both blanking and +non-blanking screen savers. Timeouts associated with these built-in +screen saver mechanisms are limited to idle (dwell) time, and a change +timeout that specifies the change interval for non-blanking screen savers. + + + +The United States' Environmental Protection Agency (EPA) Energy Star program +requires that monitors power down after some idle time by default. +While it is possible to simply overload the existing screen saver timeouts, +this solution leaves the non-privileged user little to no control over +the DPMS characteristics of his or her system. For example, disabling +DPMS would require some unintended side effect in the core screen saver, +such as disabling the changing of a non-blanking screen saver. Providing +clients with this control requires an extension to the core X Window System +Protocol, and this extension seeks to fill this gap. + + + +The design goal of the DPMS extension is to be a logical extension to +the traditional screen saver. The protocol and sample implementation is +designed to use the same date types and time units as the screen saver. +The sample implementation works independently from the screen saver so that +policy as it pertains to the interaction between screen saver and DPMS can +be deferred to the user or screen saver application. The extension has +been tested with and shown to work correctly with both the internal blanking +and non-blanking screen savers, as well as with screen saver extension +clients. + + +The DPMS extension is designed to be simple, yet export sufficient +VESA DPMS information to enable full function clients to be written. +Included is the ability to sense DPMS capability, set and get DPMS timeouts, +enable and disable individual DPMS modes, enable and disable DPMS (without +destroying timeout values), and sense current DPMS on/off state and +power level. + + +There are four power levels specified by the Video Electronics Standards +Association (VESA) Display Power Management Signaling (DPMS) standard. +These are: + + + +DPMS Extension Power Levels + 0 DPMSModeOn In use + 1 DPMSModeStandby Blanked, low power + 2 DPMSModeSuspend Blanked, lower power + 3 DPMSModeOff Shut off, awaiting activity + + + +It is logical to assume that successive DPMS modes be chronologically +at the same time or later than one another, and the protocol is designed +to enforce this rule. + + + +Note however that a conscious decision is made to decouple the timeouts +associated with screen saver from the DPMS timeouts. While it might be +considered logical to require that the first non-zero DPMS timeout be +greater than or equal to the screen saver timeout, this is intentionally +omitted, leaving this policy decision to the user or the screen saver +application. In the case of a laptop where power may be scarce, the +importance of power savings should supersede the screen saver. If the +laptop user plugs the unit in and power is no longer a scarce commodity, +it may be decided to make DPMS less aggressive, or disable it completely. + + + + +Requests + +DPMSGetVersion + + + + + + + + + +client_major_version: CARD16 + + + + +client_minor_version: CARD16 + + + + => + + + +server_major_version: CARD16 + + + + +server_minor_version: CARD16 + + + + + + + +If supplied, the client_major_version and +client_minor_version indicate what version +of the protocol the +client wants the server to implement. The server version numbers +returned indicate the protocol this extension actually supports. This +might not equal the version sent by the client. An implementation can +(but need not) support more than one version simultaneously. The +server_major_version and the +server_minor_version are a +mechanism to support future revisions of the Display Power Management +Signaling protocol which may be necessary. In general, the major version +would increment for incompatible changes, and the minor version would +increment for small, upward-compatible changes. Servers that support the +protocol defined in this document will return a +server_major_version +of one (1), and a server_minor_version +of two (2). + + + +DPMSCapable + + + + + + + + + => + + + +capable: BOOL + + + + + + + +This request is used to determine whether or not the currently running +server's devices are capable of DPMS operations. The truth value of this +request is implementation defined, but is generally based on the capabilities +of the graphic card and monitor combination. Also, the return value in the +case of heterogeneous multi-head servers is implementation defined. + + + +DPMSGetTimeouts + + + + + + + + + => + + + +standby_timeout: CARD16 + + + + +suspend_timeout: CARD16 + + + + +off_timeout: CARD16 + + + + + + + +This request returns the current values of the DPMS timeout values. All +values are in units of seconds. + + + +standby_timeout is the amount of time +of inactivity before standby +mode is invoked. The actual effects of this mode are implementation defined, +but in the case of DPMS compliant hardware, it is implemented by shutting off +the horizontal sync signal, and pulsing the vertical sync signal. Standby +mode provides the quickest monitor recovery time. Note also that many +monitors implement this mode identically to suspend mode. A value of +zero indicates that this mode is disabled. + + + +suspend_timeout is the amount of time +of inactivity before the second +level of power savings is invoked. Suspend mode's physical and electrical +characteristics are implementation defined, but in DPMS compliant hardware, +results in the pulsing of the horizontal sync signal, and shutting off of +the vertical sync signal. Suspend mode recovery is considered to be slower +than standby mode, but faster than off mode, however this is monitor +dependent. As noted above, many monitors implement this mode identically to +standby mode. A value of zero indicates that this mode is disabled. + + + +off_timeout is the amount of time of +inactivity before the third and +final level of power savings is invoked. Off mode's physical and electrical +characteristics are implementation defined, but in DPMS compliant hardware, +is implemented by shutting off both horizontal and vertical sync signals, +resulting in the power-down of the monitor. Recovery time is implementation +dependent, but frequently is similar to the power-up time of the monitor. A +value of zero indicates that this mode is disabled. + + + +DPMSSetTimeouts + + + + + + + + + +standby_timeout: CARD16 + + + + +suspend_timeout: CARD16 + + + + +off_timeout: CARD16 + + + + => + + + + + + + +All values are in units of seconds. +standby_timeout is the amount of +time of inactivity before standby mode will be invoked. This is the +lightest level of power savings, and the monitor is generally immediately +ready upon detection of user activity. This is most often implemented by +shutting off the horizontal sync signal to the monitor. +A value of zero disables this mode. + + + +The suspend_timeout specifies the amount +of time of inactivity +before the screen is placed into suspend mode. Suspend mode is the +middle level of power savings, resulting in a slightly longer recovery +upon detection of activity. Suspend mode is most often implemented by +pulsing the horizontal sync signal, and removing the vertical sync +signal. A value of zero disables this mode. + + + +The off_timeout specifies the amount of +time of inactivity before +the monitor is shut off. Off mode is the deepest level of power management, +resulting in the greatest power savings and the longest recovery time. +Off mode is most often implemented by removing both the horizontal and +vertical signals. A value of zero disables this mode. + + +The values of successive power levels must be greater than or equal +to the value of the previous (non-zero) level. A BadValue error is generated +if an illegal combination is detected. + + +DPMSEnable + + +=> + + + +This request enables the DPMS characteristics of the server, using the +server's currently stored timeouts. If DPMS is already enabled, no change is +effected. + + + +DPMSDisable + + +=> + + + +This request disables the DPMS characteristics of the server. It does +not affect the core or extension screen savers. If DPMS is already +disabled, no change is effected. This request is provided so that DPMS +may be disabled without damaging the server's stored timeout values. + + + +DPMSForceLevel + + + + + + + + + +power_level: CARD16 + + + + => + + + + + + +This request forces a specific DPMS level on the server. If DPMS is +disabled, a BadMatch error is generated. If an erroneous power level +is specified, a BadValue error is returned, and the error value contains +the bad value. If the power level specified is already in effect, no +changes occur. Power Level must be one of DPMSModeOn, DPMSModeStandby, +DPMSModeSuspend or DPMSModeOff. + + + +DPMSInfo + + + + + + + + + => + + + +power_level: CARD16 + + + + +state: BOOL + + + + + + + +This request returns information about the current DPMS state of the +display. state is one of DPMSEnabled +or DPMSDisabled. +If state is DPMSEnabled, +power_level is returned as one +of DPMSModeOn, DPMSModeStandby, DPMSModeSuspend or DPMSModeOff, otherwise +it is undefined. + + + +DPMSSelectInput + + + + + + + + + +event_mask: CARD32 + + + + => + + + + + + +This request specifies whether DPMS extension events should be generated for this client. +If DPMSInfoNotifyMask is set in event-mask, then DPMSInfoNotifyEvent +events will be generated whenever the current DPMS on/off state or power level changes. +If no bits are set, then no events will be generated. + + + + + + +Events + +The DPMS extension adds one event: + + +DPMSInfoNotifyEvent + + + + + + + + + +timestamp: TIMESTAMP + + + + +power_level: CARD16 + + + + +state: BOOL + + + + + + + +This event is delivered to clients that have requested +DPMSInfoNotifyMask events using the DPMSSelectInput request +whenever the current DPMS on/off state or power level changes. +state is one of DPMSEnabled or DPMSDisabled. +If state is DPMSEnabled, +power_level is one +of DPMSModeOn, DPMSModeStandby, DPMSModeSuspend or DPMSModeOff, otherwise +it is undefined. + + + + + +Encoding + +Please refer to the X11 Protocol Encoding document as this document uses +conventions established there. + + + +The name of this extension is "DPMS". + + + +DPMSGetVersion + 1 CARD8 opcode + 1 0 DPMS opcode + 2 2 request length + 2 CARD16 client_major_version + 2 CARD16 client_minor_version +=> + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 length + 2 CARD16 server_major_version + 2 CARD16 server_minor_version + 20 unused + + + +DPMSCapable + 1 CARD8 opcode + 1 1 DPMS opcode + 2 1 request length +=> + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 length + 1 BOOL capable + 23 unused + + + +DPMSGetTimeouts + 1 CARD8 opcode + 1 2 DPMS opcode + 2 1 request length +=> + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 length + 2 CARD16 standby_timeout + 2 CARD16 suspend_timeout + 2 CARD16 off_timeout + 18 unused + + + +DPMSSetTimeouts + 1 CARD8 opcode + 1 3 DPMS opcode + 2 3 request length + 2 CARD16 standby_timeout + 2 CARD16 suspend_timeout + 2 CARD16 off_timeout + 2 unused +=> + + + +DPMSEnable + 1 CARD8 opcode + 1 4 DPMS opcode + 2 1 request length + => + + + +DPMSDisable + 1 CARD8 opcode + 1 5 DPMS opcode + 2 1 request length + => + + + +DPMSForceLevel + 1 CARD8 opcode + 1 6 DPMS opcode + 2 2 request length + 2 power_level + 0 DPMSModeOn + 1 DPMSModeStandby + 2 DPMSModeSuspend + 3 DPMSModeOff + 2 unused +=> + + + +DPMSInfo + 1 CARD8 opcode + 1 7 DPMS opcode + 2 1 request length +=> + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 length + 2 power_level + 0 DPMSModeOn + 1 DPMSModeStandby + 2 DPMSModeSuspend + 3 DPMSModeOff + 1 BOOL state + 21 unused + + + + +DPMSSelectInput + 1 CARD8 opcode + 1 8 DPMS opcode + 2 2 request length + 4 event mask + 0 no events + 1 DPMSInfoNotifyMask + + + +DPMSInfoNotifyEvent + 1 GenericEvent type + 1 CARD8 DPMS extension offset + 2 CARD16 sequence number + 4 0 length + 2 DPMSInfoNotify evtype + 2 unused + 4 TIMESTAMP timestamp + 2 power_level + 0 DPMSModeOn + 1 DPMSModeStandby + 2 DPMSModeSuspend + 3 DPMSModeOff + 1 BOOL state + 13 unused + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/evi.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/evi.xml new file mode 100644 index 0000000000000000000000000000000000000000..e47feb1d08de986a3a01f099a1e277f9566062e3 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/evi.xml @@ -0,0 +1,519 @@ + + %defs; +]> + + + + + + Extended Visual Information Extension + X Project Team Standard + + + PeterDaifuku + Silicon Graphics, Inc. + + + X Version 11, Release &fullrelvers; + Version 1.0 + 1986-1997The Open Group + + + + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this +software and associated documentation files (the Software), to use the +Software without restriction, including, without limitation, the rights to +copy, modify, merge, publish, distribute and sublicense the Software, +to make, have made, license and distribute derivative works thereof, and +to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + + + +The above copyright notice and the following permission notice shall be +included in all copies of the Software: + + + +THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE WARRANTIES +OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON- +INFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER USEABILITIY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF, OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OF OTHER DEALINGS IN +THE SOFTWARE. + + + +Except as contained in this notice, the name of The Open Group shall not +be used in advertising or otherwise to promote the use or other dealings +in this Software without prior written authorization from The Open Group. + + + +X Window System is a trademark of The Open Group. + + + + + + +Introduction + +EVI (Extended Visual Information extension) allows a client to determine +information about core X visuals beyond what the core protocol provides. + + + + +Goals + +As the X Window System has evolved, it has become clear that the information +returned by the core X protocol regarding Visuals is often insufficient for a +client to determine which is the most appropriate visual for its needs. This +extension allows clients to query the X server for additional visual +information, specifically as regards colormaps and framebuffer levels. + + + +This extension is meant to address the needs of pure X clients only. It is +specifically and purposefully not designed to address the needs of X +extensions. Extensions that have an impact on visual information should provide +their own mechanisms for delivering that information. For example, the Double +Buffering Extension (DBE) provides its own mechanism for determining which +visuals support double-buffering. + + + + +Requests + +GetVersion + + + + + + + + + +client_major_version: CARD8 + + + + +client_minor_version: CARD8 + + + + +=> + + + + +server_major_version: CARD8 + + + + +server_minor_version: CARD8 + + + + + + + + + +If supplied, the client_major_version and client_minor_version indicate +what version of the protocol the client wants the server to implement. +The server version numbers returned indicate the protocol this extension +actually supports. This might not equal the version sent by the client. +An implementation can (but need not) support more than one version +simultaneously. The server_major_version and the server_minor_version +are a mechanism to support future revisions of the EVI protocol that +may be necessary. In general, the major version would increment for +incompatible changes, and the minor version would increment for small +upward-compatible changes. Servers that support the protocol defined in +this document will return a server_major_version of one (1), and a +server_minor_version of zero (0). + + + + GetVisualInfo + + + + + + + + + +visual_list: LISTofVISUALID + + + + +=> + + + + +per_visual_info: LISTofVISUALINFO + + + + + + + +where: + + + + + + + + + +VISUALINFO: [core_visual_id: VISUALID + + + + +screen: CARD8 + + + + +level: INT8 + + + + +transparency_type: CARD8 + + + + +unused: CARD8 + + + + +transparency_value: CARD32 + + + + +min_hw_colormaps: CARD8 + + + + +max_hw_colormaps: CARD8 + + + + +num_colormap_conflicts: CARD16 + + + + +colormap_conflicts: LISTofVISUALID] + + + + + + + + + +level is 0 for normal planes, > 0 for overlays, < 0 for underlays. + + + + +transparency_type is 0 for none, 1 for transparent pixel, 2 for +transparent mask. + + + + +transparency_value: value to get transparent pixel if transparency +supported. + + + + +min_hw_colormaps: minimum number of hardware colormaps backing up the +visual. + + + + +max_hw_colormaps: maximum number of hardware colormaps backing up the +visual. + + + (architectures with static colormap allocation/reallocation would have min += max) + + + + +num_colormap_conflicts: number of elements in colormap_conflicts. + + + + +colormap_conflicts: list of visuals that may conflict with this one. For +example, if a 12-bit colormap is overloaded to support 8-bit visuals, the +8-bit visuals would conflict with the 12-bit visuals. + + + + + + +Events and Errors + +No new events or errors are defined by this extension. + + + + +Changes to existing protocol. + +None. + + + + +Encoding + +The name of this extension is "Extended-Visual-Information". + + + +The conventions used here are the same as those for the core X11 +Protocol Encoding. + + + +GetVersion + 1 CARD8 opcode + 1 0 EVI opcode + 2 2 request length + 2 CARD16 client_major_version + 2 CARD16 client_minor_version +=> + 1 1 reply + 1 unused + 2 CARD16 sequence number + 4 0 length + 2 CARD16 server_major_version + 2 CARD16 server_minor_version + 20 unused + + + +GetVisualInfo + 1 CARD8 opcode + 1 1 EVI opcode + 2 2+n request length + 4 CARD32 n_visual + 4n CARD32 visual_ids +=> + 1 1 reply + 1 unused + 2 CARD16 sequence number + 4 n length + 4 CARD32 n_info + 4 CARD32 n_conflicts + 16 unused + 16n LISTofVISUALINFO items + + + +VISUALINFO + 4 VisualID core_visual_id + 1 INT8 screen + 1 INT8 level + 1 CARD8 transparency_type + 1 CARD8 unused + 4 CARD32 transparency_value + 1 CARD8 min_hw_colormaps + 1 CARD8 max_hw_colormaps + 2 CARD16 num_colormap_conflicts + + + + +C Language Binding + + +The C functions provide direct access to the protocol and add no additional +semantics. For complete details on the effects of these functions, refer +to the appropriate protocol request, which can be derived by deleting Xevi +at the start of the function. All functions that have return type Status +will return nonzero for success and zero for failure. + + + +The include file for this extension is: +< X11/extensions/XEVI.h>. + + + + + Bool XeviQueryVersion + Display *display + int *major_version_return + int *minor_version_return + + + + + + + display + + + +Specifies the connection to the X server. + + + + + + major_version_return + + + +Returns the major version supported by the server. + + + + + + minor_version_return + + + +Returns the minor version supported by the server. + + + + + + +XeviQueryVersion sets major_version_return and minor_version_return to +the major and minor EVI protocol version supported by the server. If +the EVI library is compatible with the version returned by the server, +it returns nonzero. If dpy does not support the EVI extension, or if +there was an error during communication with the server, or if the server +and library protocol versions are incompatible, it returns zero. No other +Xevi functions may be called before this function. If a client violates +this rule, the effects of all subsequent Xevi calls that it makes are +undefined. + + + +To get the extended information for any subset of visuals use +XeviGetVisualInfo. + + + + + int XeviGetVisualInfo + Display *display + VisualID *visual + int n_visual + ExtendedVisualInfo **evi_return + int *n_info_return + + + + + + + display + + + +Specifies the connection to the X server. + + + + + + visual + + + +If NULL, then information for all visuals of all +screens is returned. Otherwise, a pointer to a list of visuals for which +extended visual information is desired. + + + + + + n_visual + + + +If 0, then information for all visuals of all screens is returned. Otherwise, +the number of elements in the array visual. + + + + + + evi_return + + + +Returns a pointer to a list of ExtendedVisualInfo. When done, the client +should free the list using XFree. + + + + + + n_info_return + + + +Returns the number of elements in the list of +ExtendedVisualInfo. + + + + + + +XeviGetVisualInfo returns a list of ExtendedVisualInfo structures that describe +visual information beyond that supported by the core protocol. This includes +layer information relevant for systems supporting overlays and/or underlay +planes, and information that allows applications better to determine the level +of hardware support for multiple colormaps. XeviGetVisualInfo returns Success +if successful, or an X error otherwise. + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/geproto.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/geproto.xml new file mode 100644 index 0000000000000000000000000000000000000000..4cca9acf8f388c968911a72b06a7cb1e89f2cda5 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/geproto.xml @@ -0,0 +1,126 @@ + + %defs; +]> + + + X Generic Event Extension + + Peter + Hutterer + peter.hutterer@who-t.net + + X Version 11, Release &fullrelvers; + Version 1.0 + 2007Peter Hutterer + + + + Permission is hereby granted, free of charge, to any person obtaining a + copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation + the rights to use, copy, modify, merge, publish, distribute, sublicense, + and/or sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + + + The above copyright notice and this permission notice (including the next + paragraph) shall be included in all copies or substantial portions of the + Software. + + + + THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. + + + + + + + Introduction + + X was designed to provide 64 event opcodes for all extensions. These + events are limited to 32 bytes. + + The Generic Event Extension provides a template event for extensions + to re-use a single event opcode. GE only provide headers and the most + basic functionality, leaving the extensions to interpret the events in + their specific context. + + GenericEvents may be longer than 32 bytes. If so, the number of 4 + byte units following the initial 32 bytes must be specified in the length + field of the event. + + + + Extension Initialization + + The name of this extension is "Generic Event Extension" + + GEQueryVersion + client-major-version: CARD16 + client-minor-version: CARD16 +==> + major-version: CARD16 + minor-version: CARD16 + + The client sends the highest supported version to the server and the + server sends the highest version it supports, but no higher than the + requested version. Major versions changes can introduce incompatibilities + in existing functionality, minor version changes introduce only backward + compatible changes. It is the clients responsibility to ensure that the + server supports a version which is compatible with its + expectations. + + As of version 1.0, no other requests are provided by this extension. + + + + + Events + + GE defines a single event, to be used by all extensions. The event's + structure is similar to a reply. This is a core protocol event, ID 35, and + is not itself an extension event. + + GenericEvent + type: BYTE always GenericEvent (35) + extension: CARD8 extension offset + sequenceNumber: CARD16 low 16 bits of request seq. number + length: CARD32 length + evtype: CARD16 event type + + The field 'extension' is to be set to the major opcode of the + extension. The 'evtype' field is the actual opcode of the event. The + length field specifies the number of 4-byte blocks after the initial 32 + bytes. If length is 0, the event is 32 bytes long. + + + + Notes + + Although the wire event is of arbitrary length, the actual size of + an XEvent is restricted to sizeof(XEvent) [96 bytes, see Xlib.h]. If an + extension converts a wire event to an XEvent > 96 bytes, it will + overwrite the space allocated for the event. See struct _XSQEvent in + Xlibint.h for details. + + Extensions need to malloc additional data and fill the XEvent + structure with pointers to the malloc'd data. The client then needs to + free the data, only the XEvent structure will be released by Xlib. + + The server must not send GenericEvents longer than 32 bytes until it + has verified that the client is able to interpret these events. If a long + event is sent to a client unable to process GenericEvents, future + interpretation of replies and events by this client will fail. + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/lbx.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/lbx.xml new file mode 100644 index 0000000000000000000000000000000000000000..87060b74755dad5a189368934cca9cad8ea9f3b5 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/lbx.xml @@ -0,0 +1,6346 @@ + + %defs; +]> + +
+ + + Low Bandwidth X Extension + X Consortium Standard + + + Donna + Converse + + + Jim + Fulton + + + David + Lemke + + + Ralph + Mor + + + Keith + Packard + + + Ray + Tice + + + Dale + Tonogai + + + X Version 11, Release &fullrelvers; + Version 1.0 + 1996X Consortium + + + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated +documentation files (the "Software"), to deal in the Software without +restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, and +sell copies of the Software, +and to permit persons to whom the Software is furnished to do so, subject to +the following conditions: + + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions +of the Software. + + +THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE X +CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + +Except as contained in this notice, the name of the X Consortium shall not be +used in advertising or otherwise +to promote the sale, use or other dealings in this Software without prior +written authorization from the +X Consortium. + +X Window System is a trademark of The OpenGroup. + + + + +Introduction + + +Low Bandwidth X (LBX) is a network-transparent protocol for running X Window +System applications over transport channels whose bandwidth and latency are +significantly worse than that used in local area networks. It combines a +variety of caching and reencoding techniques to reduce the volume of data that +must be sent over the wire. It can be used with existing clients by placing a +proxy between the clients and server, so that the low bandwidth/high latency +communication occurs between the proxy and server. + + + + +This extension was designed and implemented by Jim Fulton, David Lemke, Keith +Packard, and Dale Tonogai, all of Network Computing Devices (NCD). Chris Kent +Kantarjiev (Xerox PARC) participated in early design discussions. Ralph Mor (X +Consortium) designed and implemented additional sections. Donna Converse (X +Consortium) authored the protocol description and encoding from design notes +and the implementation. Ray Tice (X Consortium) resolved the open issues in the +design and specification. Bob Scheifler (X Consortium) helped out in many areas. + + + + +The extension name is "LBX". + + + + + +Description + + +The design center for LBX is to use a proxy as an intermediary between the +client and server. The proxy reencodes and compresses requests, events, replies +and errors, as well as the resulting data stream. Additionally, the proxy can +cache information from the server to provide low-latency replies to clients. +This reply generation by the proxy is known as short-circuiting. A proxy can +handle multiple clients for a given server, but does not prevent clients from +connecting directly to the server. The design allows the proxy to multiplex +multiple clients into a single data stream to the server. + + + + +Much of LBX is implemented as an extension. The compression and reencoding +changes can be isolated to the transport and dispatch portions of the server, +while short-circuiting requires minor changes to the server’s colormap and +property code. + + + + +LBX employs several different compression and short-circuiting methods. Use of +these methods is negotiable, and in some cases, the algorithm used by a given +method is negotiable as well. LBX also provides for negotiation of extensions +to LBX. + + + + +Data Flow + + +The LBX data stream goes through a number of layers: + + + + + +Client requests + + +Read by LBX and potential byte-swapping + + +Request-specific compression + + +Potential byte swapping + + +Multiplexing of client request streams + + +Delta replacement + + +Stream compression + + + + +Transport + + + + + +Stream decompression + + +Delta substitution + + +Demultiplexing of client request streams + + +Potential byte swapping + + +Reencoding + + +Request processing + + + + +The reverse process occurs with X server replies, events, and errors. + + + + + +Tags + + +Tags are used to support caching of large data items that are expected to be +queried multiple times. Such things as the keyboard map and font metrics are +often requested by multiple clients. Rather than send the data each time, the +first time the data is sent it includes a tag. The proxy saves this data, so +that subsequent requests can send only the tag to refer to that same data. The +different types of tags are used for connection information, keyboard maps, +modifier maps, fonts information and properties. + + + + +Tag usage is negotiated as a boolean in the +LbxStartProxy + message. The proxy controls how many tags are stored in the proxy. The server +may wish to observe the proxy’s InvalidateTag behavior to limit how many tags +are cached at any one time. Tagged data is not shared across types of tags, but +the number space used for the tag ids is. The tag ids are generated by the +server. + + + + +The X server keeps track of what tags are known to the proxy. The proxy can +invalidate a tag if no tag bearing replies of that type are pending. The proxy +sends an +LbxInvalidateTag + message to release the tagged data. The proxy must not invalidate connection +tags unless instructed to do so by the server. + + + + +If the server wishes to discard tagged data, it must either have received an + +LbxInvalidateTag + request from the proxy or send an +LbxInvalidateTag + event to the proxy for that tag. + + + + +Tag Substitution in Requests + + +Many substitution requests have a tag field, followed by fields marked +optional. For these requests, if the optional fields are present, the +data in them is stored in the indicated tag, unless the tag is 0. If +the optional fields are absent, the tag field indicates the tag that +contains the data for the "optional" fields. + + + + + +Property Tags + + +Property data makes special use of tags. A common use of properties is for +inter-client communication. If both clients use the proxy, it is wasteful to +send the data to the server and then back, when the server may never need it. + +LbxChangeProperty + request does the same work as the core +ChangeProperty + request, but it does not send the data. The reply to this request contains a +tag id corresponding to the data. If the property information is used locally, +the server responds to +LbxGetProperty + with the tag, and the property data need never be sent to the server. If the +server does require the data, it can issue an +LbxQueryTag + message. The proxy can also send the data on at any time if it judges it +appropriate (i.e., when the wire goes idle). Since the proxy owns the property +data, it must not invalidate the tag before sending the data back to the server +via an +LbxTagData + request. + + + + + + +Short-circuiting + + +Short-circuiting is used to handle constant data. This includes atoms, color +name/RGB mappings, and +AllocColor + calls. Atoms and color name/RGB mappings stay constant for the life of the +server. +AllocColor + + +replies are constant for each colormap. Short-circuiting replaces round-trip +requests with one-way requests, and can sometimes use one in place of many. + + + + +Atoms are used heavily for ICCCM communication. Once the proxy knows the string +to atom mapping, it has no need to send subsequent requests for this atom to +the server. + + + + +Colorname/RGB mappings are constant, so once the proxy sees the response from + +LookupColor +, it need not forward any subsequent requests. + + + + +Clients often use the same color cells, so once a read-only color allocation +has occurred, the proxy knows what RGB values should be returned to the client. +The proxy doesn't need to forward any +AllocColor + requests it can resolve, but it must tell the server to modify the color +cell's reference count. +LbxIncrementPixel + is used to support this. + + + + +For all three classes of short-circuiting, the proxy must still tell the server +a request has occurred, so that the request sequence numbers stay in sync. This +is done with +LbxModifySequence +. + + + + +Sequence numbers cause the major complication with short-circuiting. X +guarantees that any replies, events or errors generated by a previous request +will be sent before those of a later request. This means that any requests that +can be handled by the proxy must have their reply sent after any previous +events or errors. + + + + +If a proxy’s applications do not require strict adherence to the X protocol +ordering of errors or events, a proxy might provide further optimization by +avoiding the overhead of maintaining this ordering, however, the resulting +protocol is not strictly X11 compliant. + + + + + +Graphics Re-encoding + + +The LBX proxy attempts to reencode PolyPoint, +PolyLine, PolySegment, +PolyRectangle, PolyArc, +FillPoly, PolyFillRectangle, +PolyFillArc, CopyArea, +CopyPlane, PolyText8, +PolyText16, ImageText8, +and ImageText16 requests. If the request can be +reencoded, it may be replaced by an equivalent LBX form of the request. +The requests are reencoded by attempting to reduce 2-byte coordinate, +length, width and angle fields to 1 byte. Where applicable, the +coordinate mode is also converted to Previous + to improve the compressibility of the resulting data. In image requests, +the image data may also be compressed. + + + + +Motion events + + +To prevent clogging the wire with MotionNotify + events, the server and proxy work together to control the number +of events on the wire. This is done with the +LbxAllowMotion + request. The request adds an amount to an allowed motion count in +the server, which is kept on a per-proxy basis. Every motion notify +event sent to the proxy decrements the allowed motion counter. If +the allowed motion count is less than or equal to zero, motion +events not required by the X protocol definition are not sent to the +proxy. The allowed motion counter has a minimum value of -2^31. + + + + +Event Squishing + + +In the core protocol, all events are padded as needed to be 32 bytes long. The +LBX extension reduces traffic by removing padding at the end of events, and +implying the event length from its type. This is known as squishing. + + + + +Master Client + + +When the initial X connection between the proxy and the server is converted to +LBX mode, the proxy itself becomes the master client. New client requests and +some tag messages are sent in the context of the master client. + + + + + +Multiplexing of Clients + + +The LBX proxy multiplexes the data streams of all its clients into one stream, +and then splits them apart again when they are received. The +LbxSwitch + message is used to tell each end which client is using the wire at the time. + + + + +The server should process delta requests in the order that they appear on the +LBX connection. If the server does not maintain the interclient request order +for requests sent by the proxy, it must still obey the semantics implied by the +interclient request order so that the delta cache functions correctly. + + + + +The server can affect the multiplexing of clients by the proxy using the + +LbxListenToOne + and +LbxListenToAll + messages. This is useful during grabs, since the master connection can not be +blocked during grabs like other clients. The proxy is responsible for tracking +server grabs issued by its clients so that the proxy can multiplex the client +streams in an order executable by the server. + + + + +Replies must be ordered in the multiplexed data stream from the server to the +proxy such that the reply carrying tagged data precedes replies that refer to +that tagged data. + + + + + +Swapping + + +Swapping is handled as with any X extension, with one caveat. Since a proxy can +be supporting clients with different byte orders, and they all share the same +wire, the length fields of all messages between the server and proxy are +expressed in the proxy byte order. This prevents any problems with length +computation that may occur when clients are switched. + + + + + +Delta cache + + +LBX takes advantage of the fact that an X message may be very similar to one +that has been previously sent. For example, a +KeyPress + event may differ from a previous +KeyPress + event in just a few bytes. By sending just the bytes that differ (or +"deltas"), the number of bytes sent over the wire can be substantially reduced. +Delta compaction is used on requests being sent by the proxy as well as on +replies and events being sent by the server. + + + + +The server and the proxy each keep per-proxy request and response caches. The +response cache contains events, errors and replies. All messages are saved in +the appropriate delta cache if they are of an appropriate type and more than 8 +bytes long but fit within the delta cache. The number of entries in the delta +cache and the maximum saved message size are negotiated in the +LbxStartProxy + request. + + + + +The LBX requests that are never stored in the request delta cache are the + +LbxQueryVersion +, +LbxStartProxy +, +LbxSwitch +, +LbxNewClient +, +LbxAllowMotion +, +LbxDelta +, +LbxQueryExtension +, +LbxPutImage +, +LbxGetImage +, +LbxBeginLargeRequest +, +LbxLargeRequestData +, +LbxEndLargeRequest + and +LbxInternAtoms + requests. The responses that are never stored in the response cache are + +LbxSwitchEvent + and +LbxDeltaResponse +. The message carried by a +delta +message is also cached, if it meets the other requirements. Messages after the + +LbxStartProxy + request are cached starting at index 0, and incrementing the index, modulo the +number of entries, thereafter. The request and response caches are +independently indexed. + + + + +If the current message is cachable and the same length as a message in the +corresponding delta cache, a delta message may be substituted in place of the +original message in the protocol stream. + + + + + +Stream Compression + + +Before being passed down to the transport layer messages can be passed through +a general purpose data compressor. The choice of compression algorithm is +negotiated with See LbxStartProxy. The proxy +and server are not required to support any specific stream compressor. As an +example, however, the X Consortium implementation of a ZLIB based compressor is +described below. + + + +The XC-ZLIB compressor is presented with a simple byte stream - the X and LBX +message boundaries are not apparent. The data is broken up into fixed sized +blocks. Each block is compressed using zlib 1.0 (by Gailly & Adler), then a +two byte header is prepended, and then the entire packet is transmitted. The +header has the following information: + + + out[0] = (length & 0xfff) >> 8 | ((compflag) ? 0x80 : 0); + out[1] = length & 0xff; + + + + +Authentication Protocols + + +The current version of LBX does not support multipass authentication protocols +for clients of the proxy. These authentication protocols return an +Authenticate + message in response to a connection setup request, and require additional +authentication data from the client after the +LbxNewClient + request, and before the reply to +LbxNewClient +. One example of such a protocol is XC-QUERY-SECURITY-1. + + + + + + +C Library Interfaces + + +The C Library routines for LBX are in the Xext library. The prototypes are +located in a file named "XLbx.h". + + + + +Application Library Interfaces + + +In a proxy environment, applications do not need to call these routines to take +advantage of LBX. Clients can, however, obtain information about the LBX +extension to the server using this interface. Use of this routine may be +altered when connected through a proxy, as described in See C Library Interfaces. + + + + +XLbxQueryVersion + + +To determine the version of LBX supported by the X server, call +XLbxQueryVersion +. + + + + +Bool XLbxQueryVersion + Display * display + int * major_version_return + int * minor_version_return + + + + + + display + Specifies the connection to the X server. + + + major_version_return + Returns the extension major version number. + + + minor_version_return + Returns the extension minor version number. + + + + +The +XLbxQueryVersion + function determines if the LBX extension is present. If the extension is not +present, +XLbxQueryVersion + returns +False +; otherwise, it returns +True +. If the extension is present, +XLbxQueryVersion + returns the major and minor version numbers of the extension as supported by +the X server. + + + + + + +Proxy Library Interfaces + + +The following interfaces are intended for use by the proxy. + + + +XLbxQueryExtension + + +To determine the dynamically assigned codes for the extension, use the Xlib +function +XQueryExtension + or the LBX function +XLbxQueryExtension +. + + + + +Bool XLbxQueryExtension + Display * display + int * major_opcode_return + int * first_event_return + int * first_error_return + + + + + + display + Specifies the connection to the X server. + + + major_opcode_return + Returns the major opcode. + + + first_event_return + Returns the first event code. + + + first_error_return + Returns the first error code. + + + + +The +XLbxQueryExtension + function determines if the LBX extension is present. If the extension is not +present, +XLbxQueryExtension + returns +False +; otherwise, it returns +True +. If the extension is present, +XLbxQueryExtension + returns the major opcode for the extension to major_opcode_return, the base +event type code to first_event_return, and the base error code to +first_error_return; otherwise, the return values are undefined. + + + + + +XLbxGetEventBase + +To determine the base event type code, use the Xlib function +XQueryExtension + or the LBX function +XLbxGetEventBase. + + + + + +int XLbxGetEventBase + Display * display + + + + + + display + Specifies the connection to the X server. + + + + +The XLbxGetEventBase +function returns the base event type code if the extension is +present; otherwise, it returns -1. + + + + + + + + +Protocol + + +Syntactic Conventions and Common Types + + +Please refer to the X Window System Protocol specification, +as this document uses the syntactic conventions established +there and references types defined there. + + + + +The following additional types are defined by this extension: + + + +DIFFITEM +1 CARD8 offset +1 CARD8 diff + + + +LBXANGLE: CARD8 or 2 BYTE + where (in order of precedence): + (0 <= in <= A(95)) && !(in % A(5)) out = 0x5a + (in / +A(5)) + A(105) <= in <= A(360) && !(in % A(15)) out = 0x67 + +(in / A(15)) + -A(100) <= in <= -A(5) && !(in % A(5)) out = 0xa6 + +(in / A(5)) + -A(360) < in <= -A(105) && !(in % A(15)) out = 0x98 + +(in / A(15)) + -A(360) < in <= A(360) out[0] = in >> 8; out[1] = in + + + +LBXARC: + [x, y: LBXINT16, + width, height: LBXCARD16, + angle1, angle2: LBXANGLE] + + + +Within a list of arcs, after the first arc, x and y are +relative to the corresponding fields of the prior arc. + + + +LBXCARD16: CARD8 or 2 BYTE + where: + 0x0000 <= in < 0x00F0 CARD8 + 0x00F0 <= in < 0x10F0 out[0] = 0xF0 | ((in - 0xF0) >> +8) + out[1] = in - 0xF0 + + + +LBXGCANDDRAWENT +[ gc-cache-index, drawable-cache-index: CARD4 ] + + + +LBXGCANDDRAWUPDATE + drawable: DRAWABLE /* present only if +drawable-cache-index + == 0 */ +gc: GC] /* present only if gc-cache-index == 0 */ + + + +LBXGCANDDRAWABLE + cache-entries: LBXGCANDDRAWENT + updates: LBXGCANDDRAWUPDATE + + + +LBXINT16: INT8 or 2 BYTE + where: + 0xF790 <= in < 0xFF90 out[0] = 0x80 | (((in + 0x70) >> +8) & 0x0F) + out[1] = in + 0x70 + 0xFF90 <= in < 0x0080 CARD8 + 0x0080 <= in < 0x0880 out[0] = 0x80 | (((in - 0x80) >> +8) & 0x0F) + out[1] = in - 0x80 + + + +LBXPINT16: CARD8 or 2 BYTE /* for +usually positive numbers */ + where: + 0xFE00 <= in < 0x0000 out[0] = 0xF0 | (((in + 0x1000) +>> 8) & 0x0F) + out[1] = in + 0x1000 + 0x0000 <= in < 0x00F0 CARD8 + 0x00F0 <= in < 0x0EF0 out[0] = 0xF0 | ((in - 0xF0) >>8) + out[1] = in - 0xF0 + + + +LBXPOINT: [x, y: LBXINT16] + Within a list of points, after the first rectangle, x and y are +relative to the corresponding fields of the prior point. + + + +LBXRECTANGLE: + [x, y: LBXINT16, + width, height: LBXCARD16] + + + +Within a list of rectangles, after the first rectangle, x and +y are relative to the corresponding fields of the prior rectangle. + + + +MASK: CARD8 + + + + + +Errors + + +As with the X11 protocol, when a request terminates with an error, +the request has no side effects (that is, there is no partial execution). + + + + +There is one error, +LbxClient +. This error indicates that the client field of an LBX request was invalid, or +that the proxy’s connection was in an invalid state for a start or stop proxy +request. + + + + + +Requests + + +There is one request that is expected to be used only by the client: +LbxQueryVersion + + + + +There is one request that is expected to be used by the client or the proxy: + +LbxQueryExtension +. + + + + +The following requests are expected to be used only by the proxy, and are +instigated by the proxy: +LbxStartProxy +, +LbxStopProxy +, +LbxNewClient +, +LbxSwitch +, +LbxCloseClient +, +LbxModifySequence +, +LbxAllowMotion +, +LbxInvalidateTag +, +LbxTagData + and +LbxQueryTag +. + + + + +All other requests are sent by the proxy to the LBX server and are instigated +by reception of an X request from the client. They replace the X request. + + + + +Requests Initiated by the Proxy or by the Client + + + + + + + + LbxQueryVersion + + + + + =>; + + + majorVersion: CARD16 + + + minorVersion: CARD16 + + + + + + +This request returns the major and minor version numbers of the LBX protocol. + + + + +The encoding of this request is on See +LbxQueryVersion. + + + + + + +Requests Initiated or Substituted by the Proxy + + + + + + + + LbxQueryExtension + + + + + +nbytes +: CARD32 + + + +name +: STRING8 + + + => + + + num-requests: CARD8 + + + present: BOOL + + + major-opcode: CARD8 + + + first-event: CARD8 + + + first-error: CARD8 + + + reply-mask: LISTofMASK /* optional */ + + + event-mask:LISTofMASK /* optional */ + + + Errors: +Alloc + + + + + + + +This request is identical to the +QueryExtension + request, with an additional field, and two optional additional fields. When +the client issues an +QueryExtension + request, the proxy will substitute an +LbxQueryExtension + request. + + + + +This request determines if the named extension is present. If so, the major +opcode for the extension is returned, if it has one. Otherwise, zero is +returned. Any minor opcode and the request formats are specific to the +extension. If the extension involves additional event types, the base event +type code is returned. Otherwise, zero is returned. The format of events is +specific to the extension. If the extension involves additional error codes, +the base error code is returned. Otherwise, zero is returned. The format of +additional data in the errors is specific to the extension. + + + + +In addition, the number of requests defined by the named extension is returned. +If the number of requests is nonzero, and if the information is available, +reply-mask and event-mask will be included in the reply. The reply-mask +represents a bit-wise one-to-one correspondence with the extension requests. +The least significant bit corresponds to the first request, and the next bit +corresponds to the next request, and so on. Each element in the list contains +eight meaningful bits, except for the last element, which contains eight or +fewer meaningful bits. Unused bits are not guaranteed to be zero. The bit +corresponding to a request is set if the request could generate a reply, +otherwise it is zero. In the same way, the event-mask represents a bit-wise +one-to-one correspondence with the extension requests. A bit is set if the +corresponding request could result in the generation of one or more extension +or X11 events. If reply-mask is present in the reply, event-mask will also be +present. + + + + +The encoding of this request is on See +LbxQueryExtension. + + + + + + +Control Requests Initiated by the Proxy + + + + + + + + LbxStartProxy + + + + + +options +: LISTofOPTION + + + => + + + choices: LISTofCHOICE + + + Errors: +LbxClient +, +Alloc + + + + where: + + + OPTION [optcode: CARD8, + + + len: OPTLEN, + + + option: (See See StartProxy Options) ] + + + CHOICE [optcode: CARD8, + + + len: OPTLEN, + + + choice: (See See StartProxy Options) ] + + + + + + + + + StartProxy Options + + + + + + + + + optcode + option + choice + default + + + + + delta-proxy + DELTAOPT + DELTACHOICE + entries=16, maxlen=64 + + + delta-server + DELTAOPT + DELTACHOICE + entries=16, maxlen=64 + + + stream-comp + LISTofNAMEDOPT + INDEXEDCHOICE + No Compression + + + bitmap-comp + LISTofSTRING8 + LISTofINDEXEDOPT + No Compression + + + pixmap-comp + LISTofPIXMAPMETHOD + LISTofPIXMAPCHOICE + No Compression + + + use-squish + BOOL + BOOL + True + + + use-tags + BOOL + BOOL + True + + + colormap + LISTofSTRING8 + INDEXEDCHOICE + No Colormap Grabbing + + + extension + NAMEDOPT + INDEXEDCHOICE + Extension Disabled + + + +
+ + + + + + + +   + + + DELTAOPT [minN, maxN, prefN: CARD8 + + + minMaxMsgLen, maxMaxMsgLen, prefMaxMsgLen: +CARD8] + + + DELTACHOICE [entries, maxlen: +CARD8] + + + INDEXEDCHOICE [index: CARD8, + + + data: LISTofBYTE] + + + INDEXEDOPT [index, opcode: CARD8] + + + NAMEDOPT [name: STRING8, + + + detail: LISTofBYTE] + + + OPTLEN 1 or 3 CARD8 + + + where: + + + (0 < in <= 0xFF): out = +in + + + (0 <= in<= 0xFFFF): out[0] = +0; out[1] = in >> 8; out[2] = in& 0xFF; + + + PIXMAPMETHOD [name: STRING8, + + + format-mask: BITMASK, + + + depths: LISTofCARD8] + + + PIXMAPCHOICE [index, opcode: CARD8, + + + format-mask: BITMASK, + + + depths: LISTofCARD8] + + + + + + + + + +This request negotiates LBX protocol options, and switches the proxy-server +connection from X11 protocol to LBX protocol. + + + + +The proxy gives the preferred protocol options in the request. The server +chooses from the given options and informs the proxy which to use. The options +may be listed in any order, and the proxy may choose which options to +negotiate. If an option is not successfully negotiated, the default is used. + + + + +The server delta cache and proxy delta caches can be configured for number of +entries, and the length of entries. (See See Delta +cache for details.) The delta caches are configured using the +delta-server + and +delta-proxy + options. To configure a cache, the proxy sends the minimum, maximum and +preferred values for the number of cache entries, ( +minN, maxN, prefN +), and the length of the cache entries, ( +minMaxMsgLen, maxMaxMsgLen, prefMaxMsgLen +). The server’s reply fields, +entries + and +maxlen +, contains the values to use. These values must be within the ranges specified +by the proxy. The server may also specify an +entries + value of 0 to disable delta caching. The cache entry lengths are specified in +units of 4 bytes. + + + + +The stream compression algorithm is selected using the +stream-comp +option. (Stream compression is described in See +Stream Compression.) Each algorithm has a name that follows the naming +conventions in See Algorithm Naming. To +negotiate using the stream-comp option, the proxy lists its available +compressors. For each candidate algorithm, the proxy sends the name in the + +name + field, and uses the +detail + field to send any additional data specific to each compression algorithm. The +reply contains a 0-based index into the list of algorithms to indicate which +algorithm to use, followed by data specific to that algorithm. + + + + +Bitmap compression is negotiated using the +bitmap-comp + option. The proxy sends a list of names of available algorithms, and the +server reply lists the algorithms to use. For each bitmap algorithm in the +reply, a 0-based index into the list of algorithms indicates the algorithm, and +the +opcode + field gives the value for use in requests. The algorithm names follow the +conventions in See Algorithm Naming. + + + + +Pixmap compression is negotiated using the +pixmap-comp + option. The proxy sends a list of available algorithms. For each algorithm, +the list includes, the name, a bitmask of supported formats, and a list of +depths that the format supports. The server reply lists the algorithms to use. +For each pixmap algorithm in the reply, the reply contains a 0-based index into +the list of proxy algorithms, the opcode to use in requests when referring to +this algorithm, a mask of valid formats, and a list of valid depths. Algorithm +names follow the conventions in See Algorithm +Naming. + + + + +Squishing is negotiated using the use-squish option. If the proxy desires +squishing, it sends a true value. The reply from the server indicates whether +to do squishing, and will indicate squishing only if +use-squish + is set to true in the request. + + + + +Tag caching, described in See Tags, is +negotiated using the use-tag option. If the proxy desires tag caching, it sends +a true value. The reply from the server indicates whether to do tag caching, +and will demand caching only if +use-tag + is set to true in the request. + + + + +The colormap option is used to negotiate what color matching algorithm will be +used by the proxy when the proxy uses the +LbxAllocColor + request to allocate pixels in a grabbed colormap. To negotiate using the +colormap option, the proxy lists the names of available colormap algorithms. +The choice in the reply contains a 0-based index into the list of algorithms to +indicate which algorithm to use, followed by data specific to that algorithm. +If no colormap algorithm is successfully negotiated, then the +LbxAllocColor +, +LbxGrabCmap +, and +LbxReleaseCmap + requests will not be used. + + + + +The extension option is used to control extensions to LBX. These extensions +may, for example, enable other types of compression. To negotiate an extension, +the name of the extension is sent, followed by any data specific to that +extension. The extension name follows the conventions in See Algorithm Naming. The extension option may +occur multiple times in the start proxy message, since multiple extensions can +be negotiated. The reply to an extension option contains the zero-based index +of the extension option, as counted in the +LbxStartProxy + message. This index is followed by extension-specific information. The server +does not respond to extensions it does not recognize. + + + + +An +LbxClient + error is returned when a client which is already communicating through an LBX +proxy to the X server sends a +LbxStartProxy + request. + + + + +The encoding for this request is on See +LbxStartProxy. + + + + + + + + + + LbxStopProxy + + + + + Errors: +LbxClient + + + + + + + +This request terminates the connection between the proxy and X server, and +terminates any clients connected through the proxy. + + + + +The encoding for this request is on See +LbxStopProxy. + + + + +An +LbxClient + error is returned if the requesting client is not an LBX proxy. + + + + + + + + + + LbxNewClient + + + + + +byte-order +: CARD8 + + + +client-id +: CARD32 + + + +protocol-major-version +: CARD16 + + + +protocol-minor-version: + CARD16 + + + +authorization-protocol-name +: STRING8 + + + +authorization-protocol-data +: STRING8 + + + => + + + Core X reply (if connection is rejected) + + +   + + + OR + + +   + + + success: BOOL + + + change-type: {NoDeltas, NormalClientDeltas, +AppGroupDeltas} + + + protocol-major-version: CARD16 + + + protocol-minor-version: CARD16 + + + tag-id: CARD32 + + + length: CARD16 + + + connection-data: CONINFO or CONDIF or +CONDIFROOT + + +   + + + where: + + + CONINFO: (the "additional data" +portion of the core connection reply for successes) + + + CONDIF: [resource-id-base: CARD32, + + + root-input-masks: LISTofSETofEVENT] + + + CONDIFROOT: [resource-id-base: +CARD32, + + + root: WINDOW + + + root-visual: VISUALID + + + default-colormap: COLORMAP + + + white-pixel, black-pixel: CARD32 + + + root-input-masks: LISTofSETofEVENT] + + + + + + +Errors: LbxClient, Alloc + + + + +This request, which is sent by the proxy over the control connection, creates a +new virtual connection to the server. + + + + +Much of the information in the +LbxNewClient + request and reply is identical to the connection setup and reply information +in the core X protocol. + + + + +For the +LbxNewClient + request, the field unique to LBX is client-id. For the +LbxNewClient + reply, +tag-id + and +change-type + are fields unique to LBX, and the contents of connection-data may be different +in LBX from the core X protocol (see below). + + + + +The proxy assigns each virtual connection a unique identifier using the + +client-id + field in the +LbxNewClient + request. This client-id is used in the LBX protocol to specify the current +client (see the +LbxSwitch + request and the +LbxSwitchEvent +). client-id 0 is reserved for the proxy control connection. An +LbxClient + error will result if the +LbxNewClient + request contains a client-id of 0 or an already in use client-id. + + + + +If the server rejects this new virtual connection, the server sends a core X +connection failure reply to the proxy. The current version of LBX does not +support the return of an +Authenticate + reply. + + + + +If the +change-type + field is set to +NoDeltas +, then +connection-data + is sent using the CONINFO structure, which is identical to the additional data +of the core connection reply. If the +tag-id + is non-zero, then the connection-data is stored by the proxy using this tag +value. Tagged connection data must be stored by the proxy, and can not be +invalidated by the proxy until an +LbxInvalidateTag + event is received for that tag. + + + + +When the +change-type + field is not set to +NoDeltas +, then connection data is sent as changes against connection information +previously sent to the proxy. The +tag-id + field, if non-zero, has the tag of the previously sent data to apply the +changes to. A zero tag-id indicates that the changes are with respect to the +connection information sent when the proxy connected to the server. + + + + +If the +change-type + field is set to +NormalClientDeltas +, then +connection-data + is sent using the CONDIF structure. The values in the CONDIF structure are +substituted for the identically named fields of the connection information for +the new connection. + + + + +If the +change-type + field is set to +AppGroupDeltas +, then +connection-data + is sent using the CONDIFROOT structure. The +root +, +root-visual +, and +default-colormap + fields, when nonzero, are substituted for the corresponding fields in the +reference connection information. The +white-pixel + and +black-pixel + fields are substituted only when the +default-colormap + field of the reply is non-zero. When +default-colormap + field of the reply is zero, so are +white-pixel + and +black-pixel +. The first entry in the +root-input-masks + field is the current-input-mask for the default root window. The remaining +entries in +root-input-masks + are input masks for non-video screens, as defined by the X Print Extension. +The number of non-video screens is one less than the number of entries in + +root-input-masks +. These screens are at the end of screen list in the reference connection +information. + + + + +The encoding for this request is on See The +description of this request is on page 13.. + + + + + + + + + + LbxCloseClient + + + + + +client +: CARD32 + + + + Errors: +LbxClient + + + + + + + +This requests the server to close down the connection represented by the +specified proxy’s client identifier. If the specified client wasn’t +previously registered with the server by a +LbxNewClient + request, the server will send the +LbxClient + error. + + + + +The encoding for this request is on See The +description of this request is on page 12.. + + + + + + + + + + LbxSwitch + + + + + +client +: CARD32 + + + + Errors: +LbxClient + + + + + + + +This request causes the X server to treat subsequent requests as being from a +connection to the X server represented by the specified client identifier. + + + + +If the client making the request is not the proxy, or if the client identifier +sent in the request was not previously sent in a +LbxNewClient + request, an +LbxClient + error is returned. + + + + +The encoding for this request is on See +LbxSwitch. + + + + + + + + + + LbxSync + + + + + => + + + + + + +The sync request causes the server to send a reply when all requests before the +sync request have been processed. + + + + +The encoding for this client is on See +LbxSync. + + + + + + + + + + LbxModifySequence + + + + + +adjust +: CARD32 + + + + Errors: None + + + + + + +This request advances the sequence number of the virtual client connection by +the specified amount. The proxy sends the +LbxModifySequence + request to the server when it replies to a client request without forwarding +the client request on to the X server. + + + + +The encoding for this client is on See The +description of this request is on page 13.. + + + + + + + + + + LbxAllowMotion + + + + + +num +: CARD32 + + + + Errors: None + + + + + + +This request controls the delivery of optional motion notify events, as +described in See Motion events. The num +field specifies an increase in the allowed number of motion notify events sent. + + + + +The encoding for this request is on See The +description of this request is on page 14.. + + + + + + + + + + LbxInvalidateTag + + + + + +tag +: CARD32 + + + + + + +The LBX proxy sends this notification to the X server when it refuses to store +tagged data, or when it releases tagged data which was previously stored and +which was not invalidated by a notification from the X server. + + + + +The encoding for this request is on See +LbxInvalidateTag. + + + + + + + + + + LbxTagData + + + + + +tag +: CARD32 + + + +real-length +: CARD32 + + + +data +: LISTofBYTE + + + + + + +This request specifies the data associated with a previously assigned tag. It +is sent in two circumstances: in response to receiving a +SendTagDataEvent +, and spontaneously, when the proxy must rely on the server to store data which +was not previously received from the server. The data is carried in the byte +order and structure as would have originally been sent in the core protocol +request. + + + + +The encoding for this request is on See +LbxTagData. + + + + + + + + + + LbxGrabCmap + + + + + +cmap +: Colormap + + + => + + + + +smart-grab +: BOOL + + + +large-pixel: +BOOL /* optional */ + + + +auto-release: +BOOL /* optional */ + + + +three-channels +: BOOL /* optional */ + + + +bits-per-rgb: +CARD4 /* optional */ + + + +cells +: LISTofCHAN /* optional */ + + +   + + + where: + + + CHAN: LISTofLBXPIXEL + + + LBXPIXEL: PIXELPRIVATE or PIXELPRIVATERANGE +or + + + PIXELALLOC or PIXELALLOCRANGE + + + PIXEL: CARD8 or CARD16 + + + PIXELPRIVATE: [ pixel: PIXEL ] + + + PIXELPRIVATERANGE: [ first-pixel, +last-pixel: PIXEL] + + + PIXELALLOC: [ pixel: PIXEL, + + + color: COLORSINGLE or COLORTRIPLE] + + + PIXELALLOCRANGE: [ first-pixel, +last-pixel: PIXEL, + + + colors: LISTofCOLORSINGLE or +LISTofCOLORTRIPLE] + + + COLORSINGLE: [ value: CARD8 or CARD16 +] + + + COLORTRIPLE: [ r, g, b: +COLORSINGLE] + + + + Errors: +Colormap + + + + + + + +This request asks the server for control of allocating new colormap cells in +the specified colormap. The server grants control by replying to this request. +If no changes have occurred since the last time this proxy grabbed this +colormap, then the +smart-grab + field of the reply is set to true, and the optional fields are not sent. +Otherwise, the current contents of the colormap are placed in the reply, as +described later in this section. + + + + +Once the proxy has received the reply, it can use the +LbxAllocColor + request to allocate new colormap cells without the performance penalty of +round trips. The proxy is still permitted to use the normal colormap and + +LbxIncrementPixel + requests while the colormap is grabbed. The grab is valid across all virtual +connections of the proxy. + + + + +The +LbxGrabCmap + request is limited to colormaps for the visual types negotiated as part of the +colormap algorithm negotiation in the start proxy request at connection setup. + + + + +The server and other proxies may not allocate new colormap cells in the +colormap while the colormap is grabbed by this proxy. If the server or another +proxy needs to allocate new colormap cells, the server sends a Lbx +ReleaseCmap + event to the proxy holding the grab, which then issues an +LbxReleaseCmap + request. + + + + +The server and other proxies may free colormap cells in a colormap grabbed by a +proxy. The server will send an +LbxFreeCells + event to the proxy that currently has the colormap grabbed when the cell +reference count reaches 0. + + + + +If the colormap is a of a static visual type, such as +StaticGray +, +StaticColor +, +GrayScale +, or +TrueColor +, then the proxy’s grab is immediately released by the server, and the proxy +must use +LbxIncrementPixel + requests in place of +LbxAllocColor + requests for this colormap. + + + + +If the cmap field does not refer to a valid colormap or the colormap is already +grabbed by this proxy then a +Colormap + error is generated. + + + + +The reply describes the contents of the colormap via several arguments and a +descriptive list containing one or three channels, with each channel describing +allocations in the colormap. + + + + +The +large-pixel + argument, if True, specifies that PIXEL indices will be listed as CARD16 +quantities instead of CARD8. The + auto-release + field, if True, indicates that this colormap is of a static visual type and +the proxy’s grab is immediately released by the server. + + + + +If +three-channels + is False, a single channel is enclosed and color values are described using +COLORTRIPLE, which has fields for red, green and blue. A single channel is used +when the visual type is not +DirectColor + or +TrueColor +. + + + + +If +three-channels + is True, separate red, green and blue channel lists are enclosed, for +describing a +DirectColor + or +TrueColor + colormap. Color values for entries in each channel are sent using COLORSINGLE +and the corresponding PIXEL value refers to the RGB subfield of the current +channel, as defined by the corresponding red-mask, green-mask and blue-mask of +the visual. + + + + +The +bits-per-rgb + value is one less than the bits-per-rgb-value field of the visual that the +colormap belongs to. If the value is 7 or less, then COLORSINGLE values in the +descriptive list are sent using CARD8 fields. Otherwise these values are sent +using CARD16 fields. + + + + +The list describing current colormap allocations contains entries of the +following types: + + + + +An LBXPIXELPRIVATE entry indicates that the pixel in the +pixel +field is unavailable for allocation. + + + + +An LBXPIXELPRIVATERANGE entry indicates that a contiguous range of pixels are +unavailable for allocation. The range is +first-pixel + to +last-pixel +, and includes +last-pixel +. + + + + +An LBXPIXELALLOC entry indicates that the pixel in the +pixel +field is allocated as a read-only pixel. The +color + field carries the color information of the pixel. + + + + +An LBXPIXELALLOCRANGE entry indicates that a contiguous range of pixels are +allocated as read-only. The range starts +first-pixel + to +last-pixel +, and includes +last-pixel +. These fields are followed by a list of COLORSINGLE or COLORTRIPLE, depending +on the value of +three-channels +. + + + + +A NEXTCHANNEL entry indicates that the next channel of the colormap will be +described. + + + + +A LISTEND entry indicates the end of the colormap description. + + + + +All pixels not described in the reply are unallocated. + + + + +The encoding for this request is on See +LbxGrabCmap. + + + + + + + + + + + LbxReleaseCmap + + + + + +cmap +: Colormap + + + + + + +This request releases the specified grabbed colormap. If the +cmap + field does not refer to a colormap, a +BadColormap + error is produced. + + + + +The proxy must remember the state of the colormap when the +LbxReleaseCmap + request is issued if this proxy may at some future time issue another + +LbxGrabCmap + request on this colormap before the state of the colormap changes. + + + + +The encoding for this request is on See +LbxReleaseCmap. + + + + + + + + + + LbxInternAtoms + + + + + +count +: CARD16 + + + +names: LISTofSTRING8 + + + + => + + + + +atoms +: LISTofATOM + + + + Errors: +Alloc + + + + + + + +This request allows the proxy to intern a group of atoms in a single round +trip. The server will create any atoms that do not exist. + + + + +The encoding for this request is on See +LbxInternAtoms. + + + + + + +Substitution Requests + + + + + + + + LbxAllocColor + + + + + +cmap +: Colormap + + + +pixel +: CARD32 + + + +red +, +green +, +blue +: CARD16 + + + + + + +This request is sent by a proxy that has given colormap grabbed to allocate a +new read-only cell in the colormap. The proxy may substitute this request for +the core +AllocColor + and +AllocNamedColor + requests. + + + + +The +pixel + field identifies the colormap cell to allocate. The +red +, +green +, and +blue + fields are the hardware specific color values of the corresponding fields of +the core +AllocColor + request. The mapping to hardware specific colormap values by the proxy is +performed using the color algorithm negotiated by +LbxStartProxy +. + + + + +For colormaps of static visual types, the +LbxIncrementPixel + request is used instead of LBX +AllocColor +. + + + + +If the +cmap + field does not identify a grabbed colormap then a +BadAccess + error is produced. If the +pixel + field refers to a read-write entry, or the pixel field refers to a pixel +outside of the range of this colormap, a +BadAlloc + error is produced. + + + + +The encoding for this request is on See +LbxAllocColor. + + + + + + + + + + LbxIncrementPixel + + + + + +cmap +: COLORMAP + + + +pixel +: CARD32 + + + + Errors: None + + + + + + +This request replaces the +AllocColor + request for read-only pixels currently allocated for the current client. If +the visual type of the colormap is of a static type, this request may be used +on currently unallocated pixels. The colormap is not required to be grabbed to +use this request. + + + + +The encoding for this request is on See The +description of this request is on page 14.. + + + + + + + + + + LbxDelta + + + + + +count +: CARD8 + + + +cache-index +: CARD8 + + + +diffs +: LISTofDIFFITEM + + + + + + +This request contains a minimal amount of information relative to a similar +prior request. The information is in the form of a difference comparison to a +prior request. The prior request is specified by an index to a cache, +independently maintained by both the proxy and the server. + + + + +The encoding for this request is on See The +description of this request is on page 18.. + + + + + + + + + + LbxGetModifierMapping + + + + + => + + + + +keyspermod +: CARD8 + + + +tag +: CARD32 + + + +keycodes +: LISTofKEYCODE /* optional */ + + + + + + +This request is identical to the core +GetModifierMapping + request, with the addition of a tag being returned in the reply. See See Tag Substitution in Requests for a description +of the +tag + field and optional fields. + + + + +The encoding for this request is on See +LbxGetModifierMapping. + + + + + + + + + + LbxGetKeyboardMapping + + + + + +firstKeyCode +: KEYCODE + + + +count +: CARD8 + + + => + + + + +keysperkeycode +: CARD8 + + + +tag +: CARD32 + + + +keysyms +: LISTofKEYSYM /* optional */ + + + + Errors: +Value + + + + + + + +This request is identical to the X +GetKeyboardMapping + protocol request, with the addition that a tag is returned in the reply. See +See Tag Substitution in Requests for a +description of the +tag + field and optional fields. + + + + +The encoding for this request is on See +LbxGetKeyboardMapping. + + + + + + + + + + + LbxGetWinAttrAndGeom + + + + + +window +: WINDOW + + + => + + + + visual: VISUALID + + + class: {InputOutput, InputOnly} + + + bit-gravity: BITGRAVITY + + + win-gravity: WINGRAVITY + + + backing-store: {NotUseful, WhenMapped, +Always} + + + backing-planes: CARD32 + + + backing-pixel: CARD32 + + + save-under: BOOL + + + colormap: COLORMAP or None + + + map-is-installed: BOOL + + + map-state: {Unmapped, Unviewable, +Viewable} + + + all-event-masks, your-event-mask: +SETofEVENT + + + do-not-propagate-mask: SETofDEVICEEVENT + + + override-redirect: BOOL + + + root: WINDOW + + + depth: CARD8 + + + x, y: INT16 + + + width, height, border-width: CARD16 + + + + Errors: +Window + + + + + + + + +GetWindowAttributes + and +GetGeometry + are frequently used together in the X protocol. +LbxGetWinAttrAndGeom + allows the proxy to request the same information in one round trip. + + + + +The encoding for this request is on See +LbxGetWinAttrAndGeom. + + + + + + + + + + + LbxQueryFont + + + + + +font +: FONTABLE + + + => + + + compression: BOOL + + + tag: CARD32 + + + font-info: FONTINFO /* optional +*/ + + + char-infos: LISTofCHARINFO or LISTofLBXCHARINFO + /* optional */ + + + where: + + + LBXCHARINFO: [left-side-bearing: +INT6 + + + right-side-bearing: INT7 + + + character-width: INT6 + + + ascent: INT6 + + + descent: INT7] + + + + Errors: +Font,Alloc + + + + + + + +This request is used to replace the core +QueryFont + request and has identical semantics. + + + + +See See Tag Substitution in Requests for a +description of the +tag + field and optional fields. + + + + +The +compression + field is True if the +char-infos + field is represented using LBXCHARINFO. + + + + +The per-character information will be encoded in an LBXCHARINFO when, for every +character, the character-width, left-side-bearing, and ascent can each be +represented in not more than 6 bits, and the right-side-bearing and descent can +each be represented in not more than 7 bits, and the attributes field is +identical the attributes field of the max_bounds of the +font_info + field of the font. + + + + +The encoding for this request is on See +LbxQueryFont. + + + + + + + + + + + LbxChangeProperty + + + + + +window +: WINDOW + + + +property +: ATOM + + + +type +: ATOM + + + +format +: {0,8,16,32} + + + +mode +: {Replace, Prepend, Append} + + + +nUnits +: CARD32 + + + => + + + tag: CARD32 + + + + + + +This request is sent to the server when the client sends an X +ChangeProperty +request through the proxy. The size of the data is sent with this request, but +not the property data itself. The server reply contains a tag identifier for +the data, which is stored in the proxy. The proxy must not discard this data +before it is sent to the server, or invalidated by the server. This means that +before issuing an +LbxStopProxy + request, or exiting, the proxy must send Lbx +TagData + requests for these items. If the server loses the connection before the +information is sent back, the server should revert the property value to its +last known value, if possible. + + + + +If the +mode + field is +Prepend + or +Append +, the tag refers only to the prepended or appended data. + + + + +If the tag in the reply is zero, then the change was ignored by the server, as +defined in the security extension. The proxy should dump the associated data, +since the server will never ask for it. + + + + +The encoding for this request is on See +LbxChangeProperty. + + + + + + + + + + LbxGetProperty + + + + + +window +: WINDOW + + + +property +: ATOM + + + +type +: ATOM or AnyPropertyType + + + +long-offset +: CARD32 + + + +long-length +: CARD32 + + + +delete +: CARD8 + + + => + + + + type: ATOM or None + + + format: {0, 8, 16, 32} + + + bytes-after: CARD32 + + + nItems: CARD32 + + + tag: CARD32 + + + value: LISTofINT8 or LISTofINT16 or +LISTofINT32 + + + + + + +This request may be used by the proxy as a substitution for a core +GetProperty + request. It allows tags to be used for property data that is unlikely to +change often in value, but is likely to be fetched by multiple clients. + + + + +The +LbxGetProperty + request has the same arguments as the core +GetProperty + request. The reply for +LbxGetProperty + has all of the fields from the core +GetProperty + reply, but has the additional fields of +nItems + and +tag +. + + + + +In order to utilize tags in +LbxGetProperty + for a specific property, the server must first send the complete property data +to the proxy and associate this data with a tag. More precisely, the server +sends an +LbxGetProperty + reply with a new +tag +, +nItems + set to the number of items in the property, the size of the property data in +the reply length field, and the complete property data in value. The proxy +stores the property data in its tag cache and associates it with the specified +tag. + + + + +In response to future +LbxGetProperty + requests for the same property, if the server thinks that the proxy has the +actual property data in its tag cache, it may choose to send an +LbxGetProperty + reply without the actual property data. In this case, the reply would include +a non-zero +tag +, a zero reply length, and no data for value. + + + + +If the server chooses not to generate a tagged reply to +LbxGetProperty +, or for some reason is unable to do so, it would send a reply with a +tag + of zero, the size of the property data in the reply length field, and the +complete property data in value. + + + + +The encoding for this request is on See +LbxGetProperty. + + + + + + + + + + LbxPolyPoint + + + + + +gc-and-drawable: +LBXGCANDDRAWABLE + + + +points +: LISTofLBXPOINT + + + + Errors: +Alloc + and those given for the corresponding X request. + + + + + + +This request replaces the +PolyPoint + request. Not all +PolyPoint + requests can be represented as +LbxPolyPoint + requests. + + + + +The proxy will convert the representation of the points to be relative to the +previous point, as described by previous coordinate mode in the X protocol. + + + + +The encoding for this request is on See +LbxPolyPoint. + + + + + + + + + + LbxPolyLine + + + + + +gc-and-drawable: +LBXGCANDDRAWABLE + + + +points +: LISTofLBXPOINT + + + + Errors: +Alloc + and those given for the corresponding X request. + + + + + + +This request replaces the +PolyLine + request. Not all +PolyLine + requests can be represented as +LbxPolyline + requests. + + + + +The proxy will convert the representation of the points to be relative to the +previous point, as described by previous coordinate mode in the X protocol. + + + + +The encoding for this request is on See The +description of this request is on page 21.. + + + + + + + + + + LbxPolySegment + + + + + +gc-and-drawable: +LBXGCANDDRAWABLE + + + +segments +: LISTofLBXSEGMENT + + +   + + + where: + + + LBXSEGEMENT; [x1, y1, x2, y2: LBXINT16] + + + + Errors: +Alloc + and those given for the corresponding X request. + + + + + + +This request replaces the +PolySegment + request. Not all +PolySegment + requests can be represented as +LbxPolySegment + requests. + + + + +For segments other than the first segment of the request, [x1, y1] is +relative to [x1, y1] of the previous segment. For all segments, [x2, y2] is +relative to that segment’s [x1, y1]. + + + + +The encoding for this request is on See +LbxPolySegment. + + + + + + + + + + LbxPolyRectangle + + + + + +gc-and-drawable: +LBXGCANDDRAWABLE + + + +rectangles +: LISTofLBXRECTANGLE + + + + Errors: +Alloc + and those given for the corresponding X request. + + + + + + +This request replaces the +PolyRectangle + request. Not all +PolyRectangle + requests can be represented as +LbxPolyRectangle + requests. + + + + +The encoding for this request is on See The +description of this request is on page 22.. + + + + + + + + + + LbxPolyArc + + + + + +gc-and-drawable: +LBXGCANDDRAWABLE + + + +arcs +: LISTofLBXARC + + + + Errors: +Alloc + and those given for the corresponding X request. + + + + + + +This request replaces the +PolyArc + request. Not all +PolyArc + requests can be represented as +LbxPolyArc + requests. + + + + +The encoding for this request is on See +LbxPolyArc. + + + + + + + + + + LbxPolyFillRectangle + + + + + +gc-and-drawable: +LBXGCANDDRAWABLE + + + +rectangles +: LISTofLBXRECTANGLE + + + + Errors: +Alloc + and those given for the corresponding X request. + + + + + + +This request replaces the +PolyFillRectangle + request. Not all +PolyFillRectangle + requests can be represented as +LbxPolyFillRectangle + requests. + + + + +The encoding for this request is on See +LbxPolyFillRectangle. + + + + + + + + + + LbxPolyFillArc + + + + + +gc-and-drawable: +LBXGCANDDRAWABLE + + + +arcs +: LISTofLBXARC + + + + Errors: +Alloc + and those given for the corresponding X request. + + + + + + +This request replaces the +PolyFillArc + request. Not all +PolyFillArc + requests can be represented as +LbxPolyFillArc + requests. + + + + +The encoding for this request is on See The +description of this request is on page 22.. + + + + + + + + + + LbxFillPoly + + + + + +gc-and-drawable: +LBXGCANDDRAWABLE + + + +shape +: BYTE + + + +points +: LISTofLBXPOINT + + + + Errors: +Alloc + and those given for the corresponding X request. + + + + + + +This request replaces the +FillPoly + request. Not all +FillPoly + requests can be represented as +LbxFillPoly + requests. + + + + +The proxy will convert the representation of the points to be relative to the +previous point, as described by previous coordinate mode in the X protocol. + + + + +The encoding for this request is on See +LbxFillPoly. + + + + + + + + + + LbxCopyArea + + + + + +srcCache +: CARD8 /* source drawable */ + + + +gc-and-drawable: +LBXGCANDDRAWABLE + + + +src-Drawable +: CARD32 + + + +src-x +: LBXPINT16 + + + +src-y +: LBXPINT16 + + + +width +: LBXCARD16 + + + +height +: LBXCARD16 + + + +dst-x +: LBXPINT16 + + + +dst-y +: LBXPINT16 + + + + Errors: Those given for the corresponding X +request. + + + + + + +This request replaces the +CopyArea + request for requests within its encoding range. + + + + +The encoding for this request is on See +LbxCopyArea. + + + + + + + + + + LbxCopyPlane + + + + + +bit-plane +: CARD32 + + + +src-cache +: CARD8 /* cache reference for source drawable */ + + + +gc-and-drawable: +LBXGCANDDRAWABLE + + + +src-drawable +: CARD32 + + + +src-x +: LBXPINT16 + + + +src-y +: LBXPINT16 + + + +width +: LBXCARD16 + + + +height +: LBXCARD16 + + + +dst-x +: LBXPINT16 + + + +dst-y +: LBXPINT16 + + + + Errors: Those given for the corresponding X +request. + + + + + + +This request replaces the +CopyPlane + request for requests within its coding range. + + + + +The encoding for this request is on See +LbxCopyPlane. + + + + + + + + + + LbxPolyText8 + + + + + +gc-and-drawable: +LBXGCANDDRAWABLE + + + +x +: LBXPINT16 + + + +y +: LBXPINT16 + + + +items +: LISTofTEXTITEM8 + + + + Errors: +Alloc +, and those given for the corresponding X request. + + + + + + +This request replaces the +PolyText8 + request for requests within its encoding range. + + + + +The encoding for this request is on See The +description of this request is on page 23.. + + + + + + + + + + LbxPolyText16 + + + + + +gc-and-drawable: +LBXGCANDDRAWABLE + + + +x: + LBXPINT16 + + + +y +: LBXPINT16 + + + +items +: LISTofTEXTITEM16 + + + + Errors: +Alloc +, and those given for the corresponding X request. + + + + + + +This request replaces the +PolyText16 + request for requests within its encoding range. + + + + +The encoding for this request is on See The +description of this request is on page 24.. + + + + + + + + + + LbxImageText8 + + + + + +gc-and-drawable: +LBXGCANDDRAWABLE + + + +nChars +: CARD8 + + + +x +: LBXPINT16 + + + +y +: LBXPINT16 + + + +string +: STRING8 + + + + Errors: +Alloc +, and those given for the corresponding X request. + + + + + + +This request replaces the +ImageText8 + request for requests within its encoding range. + + + + +The encoding for this request is on See The +description of this request is on page 24.. + + + + + + + + + + LbxImageText16 + + + + + +nChars +: CARD8 + + + +gc-and-drawable: +LBXGCANDDRAWABLE + + + x: LBXPINT16 + + + +y +: LBXPINT16 + + + +string +: STRING16 + + + + Errors: +Alloc +, and those given for the corresponding X request. + + + + + + +This request replaces the +ImageText16 + request for requests within its encoding range. + + + + +The encoding for this request is on See The +description of this request is on page 24.. + + + + + + + + + + LbxPutImage + + + + + +compression-method +: CARD8 + + + +format +: { +Bitmap +, +XYPixmap +, +ZPixmap +} /* packed */ + + + +gc-and-drawable: +LBXGCANDDRAWABLE + + + +width +, +height +: LBXCARD16 + + + +dst-x +, +dst-y +: LBXPINT16 + + + +depth +: CARD8 /* packed */ + + + +left-pad +: CARD8 /* packed */ + + + +pad-bytes +: CARD8 /* packed */ + + + +data +:LISTofBYTE + + + + Errors: +Alloc +, +Value + + + + + + + +When the request can be usefully compressed, this request replaces the + +PutImage + request. The +compression-method + parameter contains the opcode of a compression method returned in the + +LbxStartProxy + reply. The +pad-bytes + parameter gives the number of unused pad bytes that follow the compressed +image data. All other parameters are as in the X request. If the specified +compression method is not recognized, the server returns a +Value + error. + + + + +The encoding for this request is on See +LbxPutImage. + + + + + + + + + + LbxGetImage + + + + + +drawable +: DRAWABLE + + + +x +, +y +: INT16 + + + +width +, +height +: CARD16 + + + +plane-mask +: CARD32 + + + +format +: {XYPixmap, ZPixmap} + + + => + + + depth: CARD8 + + + x-length: CARD32 + + + visual: VISUALID or None + + + compression-method: CARD8 + + + data: LISTofBYTE + + + + Errors: +Alloc,Match,Value + + + + + + + +This request can replace the +GetImage + request. The same semantics apply, with the following exceptions. + + + + +The +compression-method + field contains the opcode of the compression method used in the reply. The +compression opcodes are supplied in the +LbxStartProxy + reply. The +x-length +field + +contains the length of the uncompressed version of the reply in 4 byte units. + + + + +A +Value + error is returned if the format is not recognized by the X server. A +Match + error is returned under the same circumstances as described by the +GetImage + request. + + + + +The encoding for this request is on See +LbxGetImage. + + + + + + + + + + + LbxBeginLargeRequest + + + + + +large-request-length +: CARD32 + + + + Errors: +Alloc + + + + + + + +This request, along with the Lbx +LargeRequestData + and Lbx +EndLargeRequest + requests, is used to transport a large request in pieces. The smaller size of +the resulting requests allows smoother multiplexing of clients on a single low +bandwidth connection to the server. The resulting finer-grained multiplexing +improves responsiveness for the other clients. + + + + +After a +LbxBeginLargeRequest + request is sent, multiple +LbxLargeRequestData + requests are sent to transport all of the data in the large request, and +finally an +LbxEndLargeRequest + request is sent. The large-request-length field expresses the total length of +the transported large request, expressed as the number of bytes in the +transported request divided by four. + + + + +The encoding for this request is on See The +description of this request is on page 25.. + + + + + + + + + + LbxLargeRequestData + + + + + +data +: LISTofBYTE + + + + Errors: +Alloc + + + + + + + +This request is used to carry the segments of a larger request, as described in +the definition of +LbxBeginLargeRequest +. The data must be carried in order, starting with the request header, and each +segment must be multiples of 4 bytes long. If the +LbxLargeRequestData + is not preceded by a corresponding +LbxBeginLargeRequest +, a +BadAlloc + error is generated. + + + + +The encoding for this request is on See The +description of this request is on page 26.. + + + + + + + + + + LbxEndLargeRequest + + + + + Errors: +Length, Alloc + + + + + + + +As described in the definition of +LbxBeginLargeRequest +, +LbxEndLargeRequest + is used to signal the end of a series of +LargeRequestData + requests. If the total length of the data transported by the +LbxLargeRequestData + requests does not match the large-request-length field of the preceding + +LbxBeginLargeRequest + request, then a +Length + error occurs. If the +LbxEndLargeRequest + is not preceded by a corresponding +LbxBeginLargeRequest +, a +BadAlloc + error is generated. The request is executed in order for that client as if it +were the request after the request preceding +LbxEndLargeRequest +. + + + + +The encoding for this request is on See +LbxEndLargeRequest. + + + + + + + +Events + + + + + + + + LbxSwitchEvent + + + + + +client +: CARD32 + + + + + + +Notify the proxy that the subsequent replies, events, and errors are relative +to the specified client. + + + + +The encoding for this event is on See +LbxSwitchEvent. + + + + + + + + + + LbxCloseEvent + + + + + +client +: CARD32 + + + + + + +Notify the proxy that the specified client's connection to the server is closed. + + + + +The encoding for this event is on See The +description of this event is on page 27.. + + + + + + + + + + LbxInvalidateTagEvent + + + + + +tag +: CARD32 + + + +tag-type +: {Modmap, Keymap, Property, Font, ConnInfo} + + + + + + +This message informs the proxy that the tag and the server data referenced by +the tag are obsolete, and should be discarded. The tag type may be one of the +following values: +LbxTagTypeModmap +, +LbxTagTypeKeymap +, +LbxTagTypeProperty +, +LbxTagTypeFont +, +LbxTagTypeConnInfo +. + + + + +The encoding for this event is on See +LbxInvalidateTagEvent. + + + + + + + + + + LbxSendTagDataEvent + + + + + +tag +: CARD32 + + + +tag-type +: {Property} + + + + + + +The server sends this event to the proxy to request a copy of tagged data which +is being stored by the proxy. The request contains a tag which was previously +assigned to the data by the server. The proxy should respond to +SendTagData + by sending a +TagData + request to the server. The tag type may be one of the following values: + +LbxTagTypeProperty +. + + + + +The encoding for this event is on See +LbxSendTagDataEvent. + + + + + + + + + + LbxListenToOne + + + + + +client +: CARD32 or +0xffffffff + + + + + + + +When the server is grabbed, +ListenToOne + is sent to the proxy. As an X client, the proxy itself is unaffected by grabs, +in order that it may respond to requests for data from the X server. + + + + +When the client grabbing the server is managed through the proxy, the proxy +will permit messages from itself and the grabbing client to be sent immediately +to the server, and may buffer requests from other clients of the proxy. The +client is identified in the event. + + + + +When the client grabbing the server is not managed through the proxy, the +client field in the event will be +0xffffffff +. The proxy will communicate with the server, and it may buffer requests from +other clients. The proxy will continue to handle new connections while the +server is grabbed. + + + + +The server will send +ListenToAll + to the proxy when the server is ungrabbed. There is no time-out for this +interval in the protocol. + + + + +The encoding for this event is on See The +description of this event is on page 27.. + + + + + + + + + + LbxListenToAll + + + + + + +Notify the proxy that the server has been ungrabbed, and that the proxy may now +send all buffered client requests on to the server. + + + + +The encoding for this event is on See The +description of this event is on page 27.. + + + + + + + + + + LbxQuickMotionDeltaEvent + + + + + +deltaTime +: CARD8 + + + +deltaX +: INT8 + + + +deltaY +: INT8 + + + + + + +This event is used as a replacement for the +MotionNotify + event when possible. The fields are used as deltas to the most recent + +MotionNotify + event encoded as a +MotionNotify + event, +LbxQuickMotionDeltaEvent +, or +LbxMotionDeltaEvent +. Not every +MotionNotify + event can be encoded as a +LbxQuickMotionDeltaEvent +. + + + + +The encoding for this event is on See +LbxQuickMotionDeltaEvent. + + + + + + + + + + LbxMotionDeltaEvent + + + + + +deltaX +: INT8 + + + +deltaY +: INT8 + + + +deltaTime +: CARD16 + + + +deltaSequence +: CARD16 + + + + + + +This event is used as a replacement for the +MotionNotify + event when possible. The fields are used as deltas to the most recent + +MotionNotify + event encoded as a +MotionNotify + event, +LbxQuickMotionDeltaEvent +, or +LbxMotionDeltaEvent +. Not every +MotionNotify + event can be encoded as +a LbxMotionDeltaEvent +. + + + + +The encoding for this event is on See +LbxMotionDeltaEvent. + + + + + + + + + + LbxReleaseCmapEvent + + + + + +colormap +: Colormap + + + + + + +This event notifies the proxy that it must release the grab on this colormap +via the ReleaseCmap request. See +LbxReleaseCmap + + + + +The encoding for this event is on See +LbxReleaseCmapEvent. + + + + + + + + + + LbxFreeCellsEvent + + + + + +colormap +: Colormap + + + +pixelStart, pixelEnd +: CARD32 + + + + + + +The +LbxFreeCells + event is sent to a proxy that has a colormap grabbed to notify the proxy that +the reference count of the described cells were decremented to zero by the +server or another proxy. The reference count includes those by this proxy. The +proxy must update its copy of the colormap state accordingly if the colormap is +still grabbed, or if the proxy may in the future grab the colormap using +smart-grab mode. See LbxGrabCmap + + + + +The pixelStart and pixelEnd fields of the event denote a continuous range of +cells that were freed. + + + + +The encoding for this event is on See +LbxFreeCellsEvent. + + + + +Responses + + +Responses are messages from the server to the proxy that not, strictly +speaking, events, replies or errors. + + + + + + + + + LbxDeltaResponse + + + + + +count +: CARD8 + + + +cache-index +: CARD8 + + + +diffs +: LISTofDIFFITEM + + + + + + +This response carries an event, reply, or error that has been encoded relative +to a message in the response delta cache. The +cache-index + field is the index into the cache. Each entry in +diffs + provides a byte offset and replacement value to use in reconstructing the +response. + + + + +The encoding for this event is on See +LbxDeltaResponse. + + + + + + +Algorithm Naming + + +To avoid potential clashes between different but similar algorithms for stream, +bitmap, and pixmap compression, the following naming scheme will be adhered to: + + + + +Each algorithm has a unique name, which is a STRING8, of the following form: + + + + + <organization>-<some-descriptive-name> + + + + +The organization field above is the organization name as registered in section +1 of the X Registry (the registry is provided as a free service by the X +Consortium.) This prevents conflicts among different vendor’s extensions. + + + + +As an example, the X Consortium defines a zlib-based stream compression +algorithm called XC-ZLIB. + + + + + +Encoding + + +The syntax and types used in the encoding are taken from the X protocol +encoding. Where LBX defines new types, they are defined earlier in this +document. + + + + +As in the X protocol, in various cases, the number of bytes occupied by a +component will be specified by a lowercase single-letter variable name instead +of a specific numeric value, and often some other component will have its value +specified as a simple numeric expression involving these variables. Components +specified with such expressions are always interpreted as unsigned integers. +The scope of such variables is always just the enclosing request, reply, error, +event, or compound type structure. + + + + +For unused bytes, the encode-form is: + + + +N unused + + + +If the number of unused bytes is variable, the encode-form typically is: + + + +p unused, p=pad(E) + + + +where E is some expression, and pad(E) is the number of bytes needed to round E +up to a multiple of four. + + + + +pad(E) = (4 - (E mod 4)) mod 4 + + + + +In many of the encodings, the length depends on many variable length fields. +The variable L is used to indicate the number of padded 4 byte units needed to +carry the request. Similarly, the variable Lpad indicates the number of bytes +needed to pad the request to a 4 byte boundary. + + + +For counted lists there is a common encoding of NLISTofFOO: + + + +NLISTofFOO +1 m num items +m LISTofFOO items + + + +For cached GC and Drawables: + + + +LBXGCANDDRAWUPDATE +4 or 0 DRAWBLE optional drawable +4 or 0 GC optional GC + + + + + +LBXGCANDDRAWABLE +8 LBXGCANDDRAWENT cache-entries +8 unused +m LBXGCANDDRAWUPDATE optional GC and Drawable + + + + +Errors + + +LbxClient +1 0 Error +1 CARD8 error-base + 0 +2 CARD16 sequence number +4 unused +2 CARD16 lbx opcode +1 CARD8 major opcode +21 unused + + + + +Requests + + +LbxQueryVersion +1 CARD8 opcode +1 0 lbx opcode +2 1 request length +=> +1 1 Reply +1 unused +2 CARD16 sequence number +4 0 reply length +2 CARD16 major version +2 CARD16 minor version +20 unused + + + +The description of this request is on See +LbxQueryVersion. + + + + +LbxStartProxy +1 CARD8 opcode +1 1 lbx opcode +2 L request length +n NLISTofOPTION-REQUEST options +p unused, p=pad(n) + +OPTION-REQUEST +1 OPTCODE option-code +m OPTLEN option-request-byte-length, (b=m+a+1) +a DELTAOPT or option + NLISTofNAMEDOPT or + NLISTofSTR or + NLISTofPIXMAPMETHOD or + BOOL + + + +The encoding of the option field depends on the option-code. +See See StartProxy Options. + + + +1 OPTCODE option-code +0 LbxOptionDeltaProxy +1 LbxOptionDeltaServer +2 LbxOptionStreamCompression +3 LbxOptionBitmapCompression +4 LbxOptionPixmapCompression +5 LbxOptionMessageCompression /* also known as squishing */ +6 LbxOptionUseTags +7 LbxOptionColormapAllocation +255 LbxOptionExtension + + + +OPTLEN has two possible encodings, depending on the size of the value carried: + + + +OPTLEN +1 CARD8 b (0 < b <= 255) + +OPTLEN +1 0 long length header +1 c length0, c = b >> 8 +1 d length1, d= b & #xff + +DELTAOPT +1 CARD8 min-cache-size +1 CARD8 max-cache-size +1 CARD8 preferred-cache-size +1 CARD8 min-message-length +1 CARD8 max-message-length (in 4-byte units) +1 CARD8 preferred-message-length + +NAMEDOPT +f STR type-name +1 g+1 option-data-length +g LISTofBYTE option-data (option specific) + +PIXMAPMETHOD +h STR name +1 BITMASK format mask +1 j depth count +j LISTofCARD8 depths + +=> +=> + +1 1 Reply +1 CARD8 count + +0xff options in request cannot be decoded +2 CARD16 sequence number +4 (a+p-32)/4 reply length +a LISTofCHOICE options-reply +p unused, if (n<24) p=24-n else p=pad(n) + +CHOICE +1 CARD8 request-option-index +b OPTLEN reply-option-byte-length +c DELTACHOICE or choice + INDEXEDCHOICE or + NLISTofINDEXEDOPT or + NLISTofPIXMAPCHOICE or + BOOL or + INDEXEDCHOICE + + + +The encoding of the choice field depends on the option-code. See See StartProxy Options. + + + +DELTACHOICE +1 CARD8 preferred cache size +1 CARD8 preferred message length in 4-byte units + +INDEXEDCHOICE +1 CARD8 index +d LISTofBYTE data + +PIXMAPCHOICE +1 CARD8 index +1 CARD8 opcode +1 BITMASK format mask +e NLISTofCARD8 depths + + + +The description of this request is on See +LbxStartProxy. + + + + +LbxStopProxy +1 CARD8 opcode +1 2 lbx opcode +2 1 request length + + + +The description of this request is on See +LbxStopProxy. + + + + +LbxSwitch +1 CARD8 opcode +1 3 lbx opcode +2 2 request length +4 CARD32 client + + + +The description of this request is on +See LbxSwitch. + + + + +LbxNewClient +1 CARD8 opcode +1 4 lbx opcode +2 L request length +4 CARD32 client +The remaining bytes of the request are the core connection setup. +=> +If the connection is rejected, a core connection reply is sent. Otherwise the +reply has the form: +1 BOOL success +1 change type + 0 no-deltas + 1 normal-client-deltas + 2 app-group-deltas +2 CARD16 major version +2 CARD16 minor version +2 1 + a length +4 CARD32 tag id + + + +The remaining bytes depend on the value of change-type and length. + + + +For no-deltas, the remaining bytes are the "additional data" +bytes of the core reply. (a = length of core reply, in 4 byte quantities). + + + +For normal-client-deltas, the additional bytes have the form, with a length (a += 1 +b): + + + +4 CARD32 resource id base +4b LISTofSETofEVENT root input masks + + + +For app-group-deltas, the additional bytes have the following form, with a +length of (a = 1 + 4c): + + + +4 CARD32 resource id base +4 WINDOW root id base +4 VISUALID visual +4 COLORMAP colormap +4 CARD32 white pixel +4 CARD32 black pixel +4c LISTofSETofEVENT root input masks + + + +The description of this request is on +See LbxNewClient. + + + + +LbxCloseClient +1 CARD8 opcode +1 5 lbx opcode +2 2 request length +4 CARD32 client + + + +The description of this request is on +See LbxCloseClient. + + + + +LbxModifySequence +1 CARD8 opcode +1 6 lbx opcode +2 2 request length +4 CARD32 offset to sequence number + + + +The description of this request is on See +LbxModifySequence. + + + + +LbxAllowMotion +1 CARD8 opcode +1 7 lbx opcode +2 2 request length +4 CARD32 number of MotionNotify events + + + +The description of this request is on See +LbxAllowMotion. + + + + +LbxIncrementPixel +1 CARD8 opcode +1 8 lbx opcode +2 3 request length +4 COLORMAP colormap +4 CARD32 pixel + + + +The description of this request is on See +LbxIncrementPixel. + + + + +LbxDelta +1 CARD8 opcode +1 9 lbx opcode +2 1+(2n +p+2)/4 request length +1 n count of diffs +1 CARD8 cache index +2n LISTofDIFFITEM offsets and differences +p unused, p=pad(2n + 2) + + + +The description of this request is on See +LbxDelta. + + + + +LbxGetModifierMapping +1 CARD8 opcode +1 10 lbx opcode +2 1 request length +=> +1 1 Reply +1 n keycodes-per-modifier +2 CARD16 sequence number +4 2n reply length +4 CARD32 tag +20 unused +8n LISTofKEYCODE keycodes + + + +The description of this request is on See +LbxGetModifierMapping. + + + + +LbxInvalidateTag +1 CARD8 opcode +1 12 lbx opcode +2 2 request length +4 CARD32 tag + + + +The description of this request is on See +LbxInvalidateTag. + + + + +LbxPolyPoint +1 CARD8 opcode +1 13 lbx opcode +2 1+(m+n+p)/4 request length +m LBXGCANDDRAWABLE cache entries +n LISTofLBXPOINT points (n is data-dependent) +p 0 unused, p=Lpad + + + +The description of this request is on See +LbxPolyPoint. + + + + +LbxPolyLine +1 CARD8 opcode +1 14 lbx opcode +2 1+(m+n+p)/4 request length +m LBXGCANDDRAWABLE cache entries +n LISTofLBXPOINT points (n is data-dependent) +p 0 unused, p=Lpad + + + +The description of this request is on See +LbxPolyLine. + + + + +LbxPolySegment +1 CARD8 opcode +1 15 lbx opcode +2 1+(m+n+p)/4 request length +m LBXGCANDDRAWABLE cache entries +n LISTofLBXSEGMENT segments (n is data-dependent) +p 0 unused, p=Lpad + + + +The description of this request is on See +LbxPolySegment. + + + + +LbxPolyRectangle +1 CARD8 opcode +1 16 lbx opcode +2 1+(m+n+p)/4 request length +m LBXGCANDDRAWABLE cache entries +n LISTofLBXRECTANGLE rectangles (n is data-dependent) +p 0 unused, p=pad(m+n) + + + +The description of this request is on See +LbxPolyRectangle. + + + + +LbxPolyArc +1 CARD8 opcode +1 17 lbx opcode +2 1+(m+n+p)/4 request length +m LBXGCANDDRAWABLE cache entries +n LISTofLBXARCS arcs (n is data-dependent) +p 0 unused, p=Lpad + + + +The description of this request is on See +LbxPolyArc. + + + + +LbxFillPoly +1 CARD8 opcode +1 18 lbx opcode +2 1+(3+m+n+p)/4 request length +1 LBXGCANDDRAWENT cache entries +1 shape +0 Complex +1 Nonconvex +2 Convex +1 p pad byte count +m LBXGCANDDRAWUPDATE optional gc and drawable +n LISTofLBXPOINT points (n is data-dependent) +p 0 unused, p=Lpad + + + +The description of this request is on See +LbxFillPoly. + + + + +LbxPolyFillRectangle +1 CARD8 opcode +1 19 lbx opcode +2 1+(m+n+p)/4 request length +m LBXGCANDDRAWABLE cache entries +n LISTofLBXRECTANGLE rectangles (n is data-dependent) +p 0 unused, p=Lpad + + + +The description of this request is on See +LbxPolyFillRectangle. + + + + +LbxPolyFillArc +1 CARD8 opcode +1 20 lbx opcode +2 1+(m+n+p)/4 request length +m LBXGCANDDRAWABLE cache entries +n LISTofLBXARC arcs (n is data-dependent) +p 0 unused, p=Lpad + + + +The description of this request is on See +LbxPolyFillArc. + + + + +LbxGetKeyboardMapping +1 CARD8 opcode +1 21 lbx opcode +2 2 request length +1 KEYCODE first keycode +1 m count +2 unused +=> +1 1 Reply +1 n keysyms-per-keycode +2 CARD16 sequence number +4 nm reply length (m = count field from the request) +4 CARD32 tag +20 unused +4nm LISTofKEYSYM keysyms + + + +The description of this request is on See +LbxGetKeyboardMapping. + + + + +LbxQueryFont +1 CARD8 opcode +1 22 lbx opcode +2 2 request length +4 FONTABLE font +=> +1 1 Reply +1 BOOL compression +2 CARD16 sequence number +4 L reply length +4 CARD32 tag +20 unused +All of the following is conditional: +12 CHARINFO min-bounds +4 unused +12 CHARINFO max-bounds +4 unused +2 CARD16 min-char-or-byte2 +2 CARD16 max-char-or-byte2 +2 CARD16 default-char +2 n number of FONTPROPs in properties +1 draw-direction +0 LeftToRight +1 RightToLeft +1 CARD8 min-byte1 +1 CARD8 max-byte1 +1 BOOL all-chars-exist +2 INT16 font-ascent +2 INT16 font-descent +4 m number of elements in char-infos +8n LISTofFONTPROP properties +and either +12m LISTofCHARINFO char-infos +or +m LISTofLBXCHARINFO char-infos + + + +The description of this request is on See +LbxQueryFont. + + + + +LbxChangeProperty +1 CARD8 opcode +1 23 lbx opcode +2 6 request length +4 WINDOW window +4 ATOM property +4 ATOM type +1 CARD8 format +1 mode +0 Replace +1 Preprend +2 Append +2 unused +4 CARD32 length of data in format units + (= n for format = 8) + (= n/2 for format = 16) + (= n/4 for format = 32) +=> +1 1 Reply +1 unused +2 CARD16 sequence number +4 0 reply length +4 CARD32 tag +20 unused + + + +The description of this request is on See +LbxChangeProperty. + + + + +LbxGetProperty +1 CARD8 opcode +1 24 lbx opcode +2 7 request length +4 WINDOW window +4 ATOM property +4 ATOM type +0 AnyPropertyType +1 CARD8 delete +3 unused +4 CARD32 long-offset +4 CARD32 long-length +=> +1 1 Reply +1 CARD8 format +2 CARD16 sequence number +4 CARD32 reply length +4 ATOM type +0 None +4 CARD32 bytes-after +4 CARD32 length of value in format units + (= 0 for format = 0) + (= n for format = 8) + (= n/2 for format = 16) + (= n/4 for format = 32) +4 CARD32 tag +8 unused + + + +The description of this request is on See +LbxGetProperty. + + + + +LbxTagData +1 CARD8 opcode +1 25 lbx opcode +2 3+(n+p)/4 request length +4 CARD32 tag +4 CARD32 length of data in bytes +n LISTofBYTE data +p unused, p=pad(n) + + + +The description of this request is on See +LbxTagData. + + + + +LbxCopyArea +1 CARD8 opcode +1 26 lbx opcode +2 L request length +1 CARD8 source drawable cache entry +1 LBXGCANDDRAWENT cache entries +4 or 0 DRAWABLE optional source drawable +b LBXGCANDDRAWUPDATE optional gc and dest drawable +c LBXPINT16 src-x +d LBXPINT16 src-y +e LBXPINT16 dst-x +f LBXPINT16 dst-y +g LBXCARD16 width +h LBXCARD16 height +p unused, p=Lpad + + + +The description of this request is on See +LbxCopyArea. + + + + +LbxCopyPlane +1 CARD8 opcode +1 27 lbx opcode +2 L request length +4 CARD32 bit plane +1 CARD8 source drawable cache entry +1 LBXGCANDDRAWENT cache entries +4 or 0 DRAWABLE optional source drawable +b LBXGCANDDRAWUPDATE optional gc and dest drawable +c LBXPINT16 src-x +d LBXPINT16 src-y +e LBXPINT16 dst-x +f LBXPINT16 dst-y +g LBXCARD16 width +h LBXCARD16 height +p unused, p=Lpad + + + +The description of this request is on See +LbxCopyPlane. + + + + +LbxPolyText8 +1 CARD8 opcode +1 28 lbx opcode +2 L request length +1 LBXGCANDDRAWENT cache entries +a LBXGCANDDRAWUPDATE optional gc and drawable +b LBXPINT16 x +c LBXPINT16 y +n LISTofTEXTITEM8 items +p unused, p=Lpad + + + +The description of this request is on See +LbxPolyText8. + + + + +LbxPolyText16 +1 CARD8 opcode +1 29 lbx opcode +2 L request length +1 LBXGCANDDRAWENT cache entries +a LBXGCANDDRAWUPDATE optional gc and drawable +b LBXPINT16 x +c LBXPINT16 y +2n LISTofTEXTITEM16 items +p unused, p=Lpad + + + +The description of this request is on See +LbxPolyText16. + + + + +LbxImageText8 +1 CARD8 opcode +1 30 lbx opcode +2 L request length +1 LBXGCANDDRAWENT cache entries +a LBXGCANDDRAWUPDATE optional gc and drawable +b LBXPINT16 x +c LBXPINT16 y +n STRING8 string +p unused, p=Lpad + + + +The description of this request is on See +LbxImageText8. + + + + +LbxImageText16 +1 CARD8 opcode +1 31 lbx opcode +2 L request length +1 LBXGCANDDRAWENT cache entries +a LBXGCANDDRAWUPDATE optional gc and drawable +b LBXPINT16 x +c LBXPINT16 y +2n STRING16 string +p unused, p=Lpad + + + +The description of this request is on See +LbxImageText16. + + + + +LbxQueryExtension +1 CARD8 opcode +1 32 lbx opcode +2 2+(n+p)/4 request length +4 n length of extension name +n STRING8 extension name +p unused, p=pad(n) +=> +1 1 Reply +1 n number of requests in the extension +2 CARD16 sequence number +4 0 or 2*(m + p) reply length, m = (n+7)/8 +1 BOOL present +1 CARD8 major opcode +1 CARD8 first event +1 CARD8 first error +20 unused +m LISTofMASK optional reply-mask +p unused, p=pad(m) +m LISTofMASK optional event-mask +p unused, p=pad(m) + + + +The description of this request is on See +LbxQueryExtension. + + + + +LbxPutImage +1 CARD8 opcode +1 33 lbx opcode +2 L request length +1 CARD8 compression method +1 LBXGCANDDRAWENT cache entries +a PIPACKED bit-packed +b LBXGCANDDRAWUPDATE optional gc and drawable +c LBXCARD16 width +d LBXCARD16 height +e LBXPINT16 x +f LBXPINT16 y +n LISTofBYTE compressed image data +p unused, p=Lpad + + + +If there is no left padding and the depth is less than or equal to nine, +PIPPACKED is encoded as follows: + + + +PIPACKED +1 #x80 | (format << 5) | ((depth -1) << 2) + + + +Otherwise PIPACKED is defined as: + + + +PIPACKED +1 (depth -1) << 2) +1 (format << 5) | left-pad + + + +The description of this request is on See +LbxPutImage. + + + + +LbxGetImage +1 CARD8 opcode +1 34 lbx opcode +2 6 request length +4 DRAWABLE drawable +2 INT16 x +2 INT16 y +2 CARD16 width +2 CARD16 height +4 CARD32 plane mask +1 CARD8 format +3 unused +=> +1 1 Reply +1 CARD8 depth +2 CARD16 sequence number +4 (n+p)/4 reply length +4 (m+p)/4 X reply length; if uncompressed, m=n +4 VISUALID visual +0 None +1 compression method +15 unused +n LISTofBYTE data +p unused, p=pad(n) + + + +The description of this request is on See +LbxGetImage. + + + + +LbxBeginLargeRequest +1 CARD8 opcode +1 35 lbx opcode +2 2 request length +4 CARD32 large request length + + + +The description of this request is on See +LbxBeginLargeRequest. + + + + +LbxLargeRequestData +1 CARD8 opcode +1 36 lbx opcode +2 1+n request length +4n LISTofBYTE data + + + +The description of this request is on See +LbxLargeRequestData. + + + + +LbxEndLargeRequest +1 CARD8 opcode +1 37 lbx opcode +2 1 request length + + + +The description of this request is on See +LbxEndLargeRequest. + + + + +LbxInternAtoms +1 CARD8 opcode +1 38 lbx opcode +2 1+(2+m+n+p)/4 request length +2 m num-atoms +n LISTofLONGSTR names +p pad p=Lpad +=> +1 1 Reply +1 unused +2 CARD16 sequence number +4 a reply length, a = MAX(m - 6, 0) +4*m LISTofATOM atoms +p pad p = MAX(0, 4*(6 - m)) +  +LONGSTR +2 c string length +c STRING8 string + + + +The description of this request is on See +LbxInternAtoms. + + + + +LbxGetWinAttrAndGeom +1 CARD8 opcode +1 39 lbx opcode +2 2 request length +4 CARD32 window id +=> +1 1 Reply +1 backing store +0 NotUseful +1 WhenMapped +2 Always +2 CARD16 sequence number +4 7 reply length +4 VISUALID visual id +2 class +1 InputOutput +2 InputOnly +1 BITGRAVITY bit gravity +1 WINGRAVITY window gravity +4 CARD32 backing bit planes +4 CARD32 backing pixel +1 BOOL save under +1 BOOL map installed +1 map state +0 Unmapped +1 Unviewable +2 Viewable +1 BOOL override +4 COLORMAP colormap +4 SETofEVENT all events mask +4 SETofEVENT your event mask +2 SETofDEVICEEVENT do not propagate mask +2 unused +4 WINDOW root +2 INT16 x +2 INT16 y +2 CARD16 width +2 CARD16 height +2 CARD16 border width +1 CARD8 depth +1 unused + + + +The description of this request is on See +LbxGetWinAttrAndGeom. + + + + +LbxGrabCmap +1 CARD8 opcode +1 40 lbx opcode +2 2 request length +4 COLORMAP colormap +=> + + + +If smart-grab is true, the reply is as follows: + + + +1 1 Reply +1 #x80 flags +2 CARD16 sequence number +4 0 reply length +24 unused + +If smart-grab is false, the reply is as follows: + +1 1 Reply +1 flags (set of) + #x40 auto-release + #x20 three-channels + #x10 two-byte-pixels +lower four bits specifies bits-per-pixel +2 CARD16 sequence number +4 L reply length +m CHAN or CHANNELS cells (CHAN if !three-channels) +p 0 pad(m) + +CHANNELS +a CHAN red +1 5 next channel +b CHAN green +1 5 next channel +c CHAN blue +1 0 list end + +CHAN +d LISTofLBXPIXEL + +LBXPIXEL +e PIXELPRIVATE or + PIXELPRIVATERANGE or + PIXELALLOC or + PIXELALLOCRANGE + +PIXELPRIVATE +1 1 pixel-private +f PIXEL pixel + +PIXEL +f CARD8 or CARD16 (CARD8 if !two-byte-pixels) + +PIXELPRIVATERANGE +1 2 pixel-private-range +f PIXEL fist-pixel +f PIXEL last-pixel + +PIXELALLOC +1 3 pixel-private +f PIXEL pixel +g COLORSINGLE or COLORTRIPLE color (COLORSINGLE if +three-channels) + +COLORSINGLE +h CARD8 or CARD16 value (CARD8 if bits-per-rgb =< 7) + +COLORTRIPLE +h COLORSINGLE red +h COLORSINGLE green +h COLORSINGLE blue + +PIXELALLOCRANGE +1 4 pixel-private +f PIXEL first-pixel +f PIXEL last-pixel +j LISTofCOLORSINGLE or color (COLORSINGLE if three-channels) + LISTofCOLORTRIPLE + + + +The description of this request is on See +LbxGrabCmap. + + + + +LbxReleaseCmap +1 CARD8 opcode +1 41 lbx opcode +2 2 request length +4 COLORMAP cmap + + + +The description of this request is on See +LbxReleaseCmap. + + + + +LbxAllocColor +1 CARD8 opcode +1 42 lbx opcode +2 5 request length +4 COLORMAP colormap +4 CARD32 pixel +2 CARD16 red +2 CARD16 green +2 CARD16 blue +2 unused + + + +The description of this request is on See +LbxAllocColor. + + + + +LbxSync +1 CARD8 opcode +1 43 lbx opcode +2 1 request length +=> +1 1 Reply +1 n unused +2 CARD16 sequence number +4 0 reply length +24 unused + + + +The description of this request is on See +LbxSync. + + + + + + +Events + + +LbxSwitchEvent +1 base + 0 code +1 0 lbx type +2 CARD16 sequence number +4 CARD32 client +24 unused + + + +The description of this event is on See +LbxSwitchEvent. + + + + +LbxCloseEvent +1 base + 0 code +1 1 lbx type +2 CARD16 sequence number +4 CARD32 client +24 unused + + + +The description of this event is on See +LbxCloseEvent. + + + + +LbxInvalidateTagEvent +1 base + 0 code +1 3 lbx type +2 CARD16 sequence number +4 CARD32 tag +4 tag-type +1 LbxTagTypeModmap +2 LbxTagTypeKeymap +3 LbxTagTypeProperty +4 LbxTagTypeFont +5 LbxTagTypeConnInfo +20 unused + + + +The description of this event is on See +LbxInvalidateTagEvent. + + + + +LbxSendTagDataEvent +1 base + 0 code +1 4 lbx type +2 CARD16 sequence number +4 CARD32 tag +4 tag-type +3 LbxTagTypeProperty +20 unused + + + +The description of this event is on See +LbxSendTagDataEvent. + + + + +LbxListenToOne +1 base + 0 code +1 5 lbx type +2 CARD16 sequence number +4 CARD32 client +#xFFFFFFFF +a client not managed by the proxy +24 unused + + + +The description of this event is on See +LbxListenToOne. + + + + +LbxListenToAll +1 base + 0 code +1 6 lbx type +2 CARD16 sequence number +28 unused + + + +The description of this event is on See +LbxListenToAll. + + + + +LbxQuickMotionDeltaEvent +1 base + 1 code +1 CARD8 delta-time +1 INT8 delta-x +1 INT8 delta-y + + + +This event is not padded to 32 bytes. + + + + +The description of this event is on See +LbxQuickMotionDeltaEvent. + + + + +LbxMotionDeltaEvent +1 base + 0 code +1 7 lbx type +1 INT8 delta-x +1 INT8 delta-y +2 CARD16 delta-time +2 CARD16 delta-sequence + + + +This event is not padded to 32 bytes. + + + + +The description of this event is on See +LbxMotionDeltaEvent. + + + + +LbxReleaseCmapEvent +1 base + 0 code +1 8 lbx type +2 CARD16 sequence number +4 COLORMAP colormap +24 unused + + + +The description of this event is on See +LbxReleaseCmapEvent. + + + + +LbxFreeCellsEvent +1 base + 0 code +1 9 lbx type +2 CARD16 sequence number +4 COLORMAP colormap +4 PIXEL pixel start +4 PIXEL pixel end +16 unused + + + +The description of this event is on See +LbxFreeCellsEvent. + + + + + +Re-encoding of X Events + + +The X protocol requires all X events to be 32 bytes. The LBX server reduces the +number of bytes sent between the server and the proxy for some X events by not +appending unused pad bytes to the event data. The offsets of X event data are +unchanged. The proxy will pad the events to 32 bytes before passing them on to +the client. + + + + +LBX reencodes X event representations into the following sizes, if squishing is +enabled: + + + +KeyOrButton 32 +EnterOrLeave 32 +Keymap 32 +Expose 20 +GraphicsExposure 24 +NoExposure 12 +VisibilityNotify 12 +CreateNotify 24 +DestroyNotify 12 +UnmapNotify 16 +MapNotify 16 +MapRequest 12 +Reparent 24 +ConfigureNotify 28 +ConfigureRequest 28 +GravityNotify 16 +ResizeRequest 12 +Circulate 20 +Property Notify 20 +SelectionClear 20 +SelectionRequest 28 +SelectionNotify 24 +Colormap Notify 16 +MappingNotify 8 +ClientMessage 32 +Unknown 32 + + + + +Responses + + +LbxDeltaResponse +1 event_base + 0 event code +1 2 lbx type +2 1+(2+2n+p)/4 request length +1 n count of diffs +1 CARD8 cache index +2n LISTofDIFFITEM offsets and differences +p unused, p=pad(2n) + + + +The description of this response is on See +LbxDeltaResponse. + + + + +
diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/multibuf.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/multibuf.xml new file mode 100644 index 0000000000000000000000000000000000000000..9e2b0659472bd2d399efd85522bb2600cad21f64 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/multibuf.xml @@ -0,0 +1,1628 @@ + + %defs; +]> + + + + + + + Extending X for Double-Buffering, Multi-Buffering, and Stereo + + + JeffreyFriedberg + + + LarrySeiler + + + JeffVroom + + + 1989Digital Equipment Corporation + X Version 11, Release &fullrelvers; + Version 3.3 + + + +Permission to use, copy, modify, and distribute this documentation for any +purpose and without fee is hereby granted, provided that the above copyright +notice and this permission notice appear in all copies. +Digital Equipment Corporation makes no representations +about the suitability for any purpose of the information in +this document. This documentation is provided "as is" +without express or implied warranty. This document +is subject to change. + + + + +Copyright © 1989, 1994 X Consortium + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the ``Software''), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + + +THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + +Except as contained in this notice, the name of the X Consortium shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from the X Consortium. + +X Window System is a trademark of The OpenGroup. + + + + +Warning + +The Multi-Buffering extension described here +was a draft standard of the X Consortium prior to Release 6.1. It has been +superseded by the Double Buffer +Extension (DBE). DBE is an X Consortium Standard as of Release 6.1. + + + + +Introduction + + +Several proposals have been written that address some of the +issues surrounding the support of double-buffered, multi-buffered, +and stereo windows in the X Window System: + + + + + +Extending X for Double-Buffering, +Jeffrey Friedberg, Larry Seiler, Randi Rost. + + + + +(Proposal for) Double-Buffering Extensions, +Jeff Vroom. + + + + +An Extension to X.11 for Displays with Multiple Buffers, +David S.H. Rosenthal. + + + + +A Multiple Buffering/Stereo Proposal, +Mark Patrick. + + + + + +The authors of this proposal have tried to unify the above documents +to yield a proposal that incorporates support for double-buffering, +multi-buffering, and stereo in a way that is acceptable to all concerned. + + + + +Goals + + +Clients should be able to: + + + + + +Associate multiple buffers with a window. + + + + +Paint in any buffer associated with a window. + + + + +Display any buffer associated with a window. + + + + +Display a series of buffers in a window in rapid succession +to achieve a smooth animation. + + + + +Request simultaneous display of different buffers in different windows. + + + + + +In addition, the extension should: + + + + + +Allow existing X applications to run unchanged. + + + + +Support a range of implementation methods that can capitalize on +existing hardware features. + + + + + + + +Image Buffers + + +Normal windows are created using the standard +CreateWindow request: + + + +CreateWindow + parent : WINDOW + w_id : WINDOW + depth : CARD8 + visual : VISUALID or CopyFromParent + x, y : INT16 + width, height : INT16 + border_width : INT16 + value_mask : BITMASK + value_list : LISTofVALUE + + + +This request allocates a set of window attributes and +a buffer into which an image can be drawn. +The contents of this image buffer will +be displayed when the window is mapped to the screen. + + + +To support double-buffering and multi-buffering, +we introduce the notion that additional image buffers can +be created and bound together to form groups. +The following rules will apply: + + + + + +All image buffers in a group will have the same +visual type, depth, and geometry (ie: width and height). + + + + +Only one image buffer per group can be displayed +at a time. + + + + +Draw operations can occur to any image buffer at +any time. + + + + +Window management requests (MapWindow, DestroyWindow, +ConfigureWindow, etc...) +affect all image buffers associated with a window. + + + + +Appropriate resize and exposure events will be generated +for every image buffer that is affected by a window +management operation. + + + + + +By allowing draw operations to occur on any image buffer at any time, +a client could, on a multi-threaded multi-processor server, +simultaneously build up images for display. +To support this, each buffer must have its own resource ID. +Since buffers are different than windows and pixmaps +(buffers are not hierarchical and pixmaps cannot be displayed) +a new resource, Buffer, is introduced. +Furthermore, a Buffer is also a Drawable, thus +draw operations may also be performed on buffers simply +by passing a buffer ID to the existing pixmap/window +interface. + + + +To allow existing X applications to work unchanged, we assume +a window ID passed in a draw request, for a multi-buffered +window, will be an alias for the ID of the currently +displayed image buffer. Any draw requests (eq: GetImage) on +the window will be relative to the displayed image buffer. + + + +In window management requests, only a window ID will be +accepted. Requests like QueryTree, will continue to +return only window ID's. Most events will return +just the window ID. Some new events, described in a subsequent +section, will return a buffer ID. + + + +When a window has backing store the contents of the window +are saved off-screen. Likewise, when the contents of an image +buffer of a multi-buffer window is saved off-screen, it is +said to have backing store. This applies to all image buffers, +whether or not they are selected for display. + + + +In some multi-buffer implementations, undisplayed buffers might be +implemented using pixmaps. Since the contents of pixmaps exist +off-screen and are not affected by occlusion, these image buffers +in effect have backing store. + + + +On the other hand, both the displayed and undisplayed image buffers +might be implemented using a subset of the on-screen pixels. +In this case, unless the contents of an image buffer are saved +off-screen, these image buffers in effect do not have backing store. + + + +Output to any image buffer of an unmapped multi-buffered window +that does not have backing store is discarded. Output to any +image buffer of a mapped multi-buffer window will be performed; +however, portions of an image buffer may be occluded or clipped. + + + +When an unmapped multi-buffered window becomes mapped, the contents +of any image buffer buffer that did not have backing store is +tiled with the background and zero or more exposure events are +generated. If no background is defined for the window, then +the screen contents are not altered and the contents of any +undisplayed image buffers are undefined. If backing store was +maintained for an image buffer, then no exposure events are generated. + + + + +New Requests + + +The new request, CreateImageBuffers, creates a group of +image buffers and associates them with a normal X window: + + + +CreateImageBuffers + w_id : WINDOW + buffers : LISTofBUFFER + update_action : {Undefined,Background,Untouched,Copied} + update_hint : {Frequent,Intermittent,Static} + => + number_buffers : CARD16 + + (Errors: Window, IDChoice, Value) + + + +One image buffer will be associated with each ID passed in +buffers. +The first buffer of the list is referred to as buffer[0], the next +buffer[1], and so on. Each buffer will have the same visual type +and geometry as the window. +Buffer[0] will refer to the image buffer already associated +with the window ID and its contents will not be modified. +The displayed image buffer attribute is set to buffer[0]. + + + +Image buffers for the remaining ID's (buffer[1],...) are allocated. +If the window is mapped, or if these image buffers have backing +store, their contents will be tiled with the window background +(if no background is defined, the buffer contents are undefined), +and zero or more expose events will be generated for each of these +buffers. The contents of an image buffer is undefined when +the window is unmapped and the buffer does not have backing store. + + + +If the window already has a group of image buffers +associated with it (ie: from a previous CreateImageBuffers request) +the actions described for DestroyImageBuffers are performed first +(this will delete the association of the previous buffer ID's and +their buffers as well as de-allocate all buffers except for the +one already associated with the window ID). + + + +To allow a server implementation to efficiently allocate the +buffers, the total number of buffers required and +the update action (how they will behave during an update) +is specified "up front" in the request. +If the server cannot allocate all the buffers requested, the +total number of buffers actually allocated will be returned. +No Alloc errors will be generated \- buffer[0] can +always be associated with the existing displayed image buffer. + + + +For example, an application that wants to animate a short movie +loop may request 64 image buffers. The server may only be able to +support 16 image buffers of this type, size, and depth. +The application can then decide 16 buffers is sufficient and may +truncate the movie loop, or it may decide it really needs +64 and will free the buffers and complain to the user. + + + +One might be tempted to provide a request that inquires whether +n +buffers of a particular type, size, and depth +could be allocated. +But if the query is decoupled from the actual allocation, +another client could sneak in and take the buffers before the +original client has allocated them. + + + +While any buffer of a group can be selected for display, +some applications may display buffers in a predictable order +(ie: the movie loop application). The +list order +(buffer[0], buffer[1], ...) will be used as a hint by the +server as to which buffer will be displayed next. +A client displaying buffers in this order may see a +performance improvement. + + + +update_action indicates what should happen to a previously +displayed buffer when a different buffer becomes displayed. +Possible actions are: + + + + + Undefined + + +The contents of the buffer that was +last displayed will become undefined after the update. This +is the most efficient action since it allows the implementation +to trash the contents of the buffer if it needs to. + + + + + Background + + +The contents of the buffer that was +last displayed will be set to the background of the window after the update. +The background action allows devices to use a fast clear +capability during an update. + + + + + Untouched + + +The contents of the buffer that was +last displayed will be untouched after the update. Used +primarily when cycling through images that have already +been drawn. + + + + + Copied + + +The contents of the buffer that was +last displayed will become the same as those that are being +displayed after the update. This is useful when incrementally +adding to an image. + + + + + + + + +update_hint indicates how often the client will +request a different buffer to be displayed. +This hint will allow smart server implementations to choose the +most efficient means to support a multi-buffered window based +on the current need of the application (dumb implementations +may choose to ignore this hint). Possible hints are: + + + + + Frequent + + +An animation or movie loop is +being attempted and the fastest, most efficient means for +multi-buffering should be employed. + + + + + Intermittent + + +The displayed image will be +changed every so often. This is common for images that are +displayed at a rate slower than a second. For example, a +clock that is updated only once a minute. + + + + + Static + + +The displayed image buffer will +not be changed any time soon. Typically set by an application +whenever there is a pause in the animation. + + + + + + +To display an image buffer the following request can be used: + + + +DisplayImageBuffers + buffers : LISTofBUFFER + min_delay : CARD16 + max_delay : CARD16 + + (Errors: Buffer, Match) + + + +The image buffers listed will become displayed as simultaneously +as possible and the update action, bound at +CreateImageBuffers +time, will be performed. + + + +A list of buffers is specified to +allow the server to efficiently change the display of more than one +window at a time (ie: when a global screen swap method is used). +Attempting to simultaneously display +multiple image buffers from the same window is an error +(Match) since it violates the rule that only one +image buffer per group can be displayed at a time. + + + +If a specified buffer is already displayed, +any delays and update action will still be +performed for that buffer. In this instance, +only the update action of Background +(and possibly +Undefined) will have any affect on the +contents of the displayed buffer. These semantics allow +an animation application to successfully execute +even when there is only a single buffer available +for a window. + + + +When a DisplayImageBuffers request is made to an unmapped +multi-buffered window, the effect of the update action depends +on whether the image buffers involved have backing store. +When the target of the update action is an image buffer that +does not have backing store, output is discarded. When the +target image buffer does have backing store, the update is performed; +however, when the source of the update is an image buffer does not +have backing store (as in the case of update action +Copied), the +contents of target image buffer will become undefined. + + + +min_delay and +max_delay put a bound on how long the +server should wait before processing the display request. +For each of the windows to be updated by this request, at least +min_delay milli-seconds should elapse since +the last +time any of the windows were updated; conversely, no window +should have to wait more than max_delay +milli-seconds before being updated. + + + +min_delay allows an application to +slow down an animation or movie loop so that +it appears +synchronized at a rate the server can support given the current load. +For example, a min_delay of 100 indicates the +server should +wait at least 1/10 of a second since the last time any of the +windows were updated. A min_delay of zero +indicates no waiting is necessary. + + + +max_delay can be thought of as an additional +delay beyond min_delay the server is allowed +to wait +to facilitate such things as efficient update of multiple windows. +If max_delay would require an update before +min_delay +is satisfied, then the server should process the display request as +soon as the min_delay requirement is met. A +typical value for max_delay is zero. + + + +To implement the above functionality, the time since the last +update by a DisplayImageBuffers request for each +multi-buffered +window needs to be saved as state by the server. +The server may delay execution of the DisplayImageBuffers +request until the appropriate time (e.g. by requeuing the +request after computing the timeout); +however, the entire request must be processed in one operation. +Request execution indivisibility must be maintained. When +a server is implemented with internal concurrency, the +extension must adhere to the same concurrency semantics +as those defined for the core protocol. + + + +To explicitly clear a rectangular area of an image buffer to +the window background, the following request can be used: + + + +ClearImageBufferArea + buffer : BUFFER + x, y : INT16 + w, h : CARD16 + exposures : BOOL + + (Errors: Buffer, Value) + + + +Like the X ClearArea request, +x and y +are relative to +the window's origin and specify the upper-left corner of the rectangle. +If width is zero, it is replaced with the +current window width +minus x. If +height is zero it is replaced with the current +window height minus y. If the window has a +defined background tile, the rectangle is tiled with a plane mask of all ones, +a function of Copy, and a subwindow-mode of +ClipByChildren. +If the window has background None, the +contents of the buffer +are not changed. In either case, if +exposures is true, then one or +more exposure events are generated for regions of the rectangle that are +either visible or are being retained in backing store. + + + + +The group of image buffers allocated by a +CreateImageBuffers +request can be destroyed with the following request: + + + +DestroyImageBuffers + w_id : WINDOW + + (Error: Window) + + + +The association between the buffer ID's and their corresponding +image buffers are deleted. Any image buffers not selected for +display are de-allocated. If the window is not multi-buffered, +the request is ignored. + + + + + +Attributes + + +The following attributes will be associated with each window that +is multi-buffered: + + + + displayed_buffer : CARD16 + update_action : {Undefined,Background,Untouched,Copied} + update_hint : {Frequent,Intermittent,Static} + window_mode : {Mono,Stereo} + buffers : LISTofBUFFER + + + +displayed_buffer is set to the +index of the currently +displayed image buffer (for stereo windows, this will be +the index of the left buffer \- the index of the right buffer +is simply index+1). +window_mode indicates whether this window is +Mono or Stereo. +The ID for each buffer associated with the window is recorded +in the buffers list. +The above attributes can be queried with the following request: + + + +GetMultiBufferAttributes + w_id : WINDOW + => + displayed_buffer : CARD16 + update_action : {Undefined,Background,Untouched,Copied} + update_hint : {Frequent,Intermittent,Static} + window_mode : {Mono,Stereo} + buffers : LISTofBUFFER + + (Errors: Window, Access, Value) + + + +If the window is not multi-buffered, a Access error +will be generated. +The only multi-buffer attribute that can be explicitly set +is update_hint. Rather than have a specific +request to set this attribute, a generic set request is provided to +allow for future expansion: + + + +SetMultiBufferAttributes + w_id : WINDOW + value_mask : BITMASK + value_list : LISTofVALUE + + (Errors: Window, Match, Value) + + + +If the window is not multi-buffered, a Match error +will be generated. +The following attributes are maintained for each buffer of a +multi-buffered window: + + + + window : WINDOW + event_mask : SETofEVENT + index : CARD16 + side : {Mono,Left,Right} + + + +window indicates the window this buffer is +associated with. +event_mask specifies which events, relevant to +buffers, will be sent back to the client via the associated buffer ID +(initially no events are selected). +index is the list position (0, 1, ...) of the +buffer. +side indicates whether this buffer is +associated with +the left side or right side of a stereo window. +For non-stereo windows, this attribute will be set to +Mono. +These attributes can be queried with the following request: + + + +GetBufferAttributes + buffer : BUFFER + => + window : WINDOW + event_mask : SETofEVENT + index : CARD16 + side : {Mono,Left,Right} + + (Errors: Buffer, Value) + + + +The only buffer attribute that can be explicitly set +is event_mask. +The only events that are valid are +Expose and the new +ClobberNotify and UpdateNotify +event (see Events section below). +A Value error will be generated if an event not +selectable for a buffer is specified in an event mask. +Rather than have a specific request +to set this attribute, a generic set request is provided to +allow for future expansion: + + + +SetBufferAttributes + buffer : BUFFER + value_mask : BITMASK + value_list : LISTofVALUE + + (Errors: Buffer, Value) + + + +Clients may want to query the server about basic multi-buffer +and stereo capability on a per screen basis. The following request +returns a large list of information +that would most likely be read once by Xlib for each screen, and used as a +data base for other Xlib queries: + + + +GetBufferInfo + root : WINDOW + => + info : LISTofSCREEN_INFO + + + +Where SCREEN_INFO and +BUFFER_INFO are defined as: + + + + SCREEN_INFO : [ normal_info : LISTofBUFFER_INFO, + stereo_info : LISTofBUFFER_INFO ] + + BUFFER_INFO : [ visual : VISUALID, + max_buffers : CARD16, + depth : CARD8 ] + + + +Information regarding multi-buffering of normal (mono) windows +is returned in the normal_info list. +The stereo_info +list contains information about stereo windows. +If the stereo_info list is empty, stereo +windows are +not supported on the screen. If +max_buffers is zero, +the maximum number of buffers for the depth and visual is +a function of the size of the created window and current +memory limitations. + + + +The following request returns the major and minor version numbers +of this extension: + + + +GetBufferVersion + => + major_number : CARD8 + minor_number : CARD8 + + + +The version numbers are an escape hatch in case future revisions of +the protocol are necessary. In general, the major version would +increment for incompatible changes, and the minor version would +increment for small upward compatible changes. Barring changes, the +major version will be 1, and the minor version will be 1. + + + + +Events + + +All events normally generated for single-buffered +windows are also generated for multi-buffered windows. +Most of these events (ie: ConfigureNotify) will +only be generated for the window and not for each buffer. +These events will return a window ID. + + + +Expose events will be generated for both the window +and any buffer affected. When this event is generated for +a buffer, the same event structure will be used +but a buffer ID is returned instead of a window ID. +Clients, when processing these events, will know whether an +ID returned in an event structure is for a window or a buffer +by comparing the returned ID to the ones returned when the +window and buffer were created. + + + +GraphicsExposure and +NoExposure are generated +using whatever ID is specified in the graphics operation. +If a window ID is specified, the event will contain the +window ID. If a buffer ID is specified, the event will +contain the buffer ID. + + +In some implementations, moving a window +over a multi-buffered window may cause one or more of its buffers +to get overwritten or become unwritable. To allow a +client drawing into one of these buffers the opportunity +to stop drawing until some portion of the buffer is +writable, the following event is added: + + + +ClobberNotify + buffer : BUFFER + state : {Unclobbered,PartiallyClobbered,FullyClobbered} + + + +The ClobberNotify event is reported to clients selecting +ClobberNotify on a buffer. When a buffer +that was fully +or partially clobbered becomes unclobbered, an event with +Unclobbered +is generated. When a buffer that was unclobbered becomes +partially clobbered, an event with +PartiallyClobbered +is generated. When a buffer that was unclobbered or +partially clobbered becomes fully clobbered, an event with +FullyClobbered is generated. + + + +ClobberNotify events on a given buffer are +generated before any Expose events on that buffer, +but it is not required that all ClobberNotify +events on all buffers be generated before all +Expose events on all buffers. + + + +The ordering of ClobberNotify events with respect +to VisibilityNotify events is not constrained. + + + +If multiple buffers were used as an image FIFO between an image +server and the X display server, then the FIFO manager would like +to know when a buffer that was previously displayed, has been +undisplayed and updated, as the side effect of a +DisplayImageBuffers +request. This allows the FIFO manager to load up a future frame as +soon as a buffer becomes available. To support this, +the following event is added: + + + +UpdateNotify + buffer : BUFFER + + + +The UpdateNotify event is reported to clients selecting +UpdateNotify on a buffer. Whenever a buffer +becomes updated +(e.g. its update action is performed as part of a +DisplayImageBuffers +request), an UpdateNotify event is generated. + + + + +Errors + + +The following error type has been added to support +this extension: + + + +Buffer + +A value for a BUFFER argument does not name a defined BUFFER. + + + + +Double-Buffering Normal Windows + + +The following pseudo-code fragment illustrates how to create and display +a double-buffered image: + + + +/* + * Create a normal window + */ +CreateWindow( W, ... ) + +/* + * Create two image buffers. Assume after display, buffer + * contents become "undefined". Assume we will "frequently" + * update the display. Abort if we don't get two buffers, + */ +n = CreateImageBuffers( W, [B0,B1], Undefined, Frequent ) +if (n != 2) <abort> + +/* + * Map window to the screen + */ +MapWindow( W ) + +/* + * Draw images using alternate buffers, display every + * 1/10 of a second. Note we draw B1 first so it will + * "pop" on the screen + */ +while animating +{ + <draw picture using B1> + DisplayImageBuffers( [B1], 100, 0 ) + + <draw picture using B0> + DisplayImageBuffers( [B0], 100, 0 ) +} + +/* + * Strip image buffers and leave window with + * contents of last displayed image buffer. + */ +DestroyImageBuffers( W ) + + + + + +Multi-Buffering Normal Windows + + +Multi-buffered images are also supported by these requests. +The following pseudo-code fragment illustrates how to create a +a multi-buffered image and cycle through the images to +simulate a movie loop: + + + +/* + * Create a normal window + */ +CreateWindow( W, ... ) + +/* + * Create 'N' image buffers. Assume after display, buffer + * contents are "untouched". Assume we will "frequently" + * update the display. Abort if we don't get all the buffers. + */ +n = CreateImageBuffers( W, [B0,B1,...,B(N-1)], Untouched, Frequent ) +if (n != N) <abort> + +/* + * Map window to screen + */ +MapWindow( W ) + +/* + * Draw each frame of movie one per buffer + */ +foreach frame + <draw frame using B(i)> + +/* + * Cycle through frames, one frame every 1/10 of a second. + */ +while animating +{ + foreach frame + DisplayImageBuffers( [B(i)], 100, 0 ) +} + + + + + +Stereo Windows + +How stereo windows are supported on a server +is implementation +dependent. A server may contain specialized hardware that allows +left and right images to be toggled at field or frame rates. The +stereo affect may only be perceived with the aid of special +viewing glasses. The display of a +stereo picture should +be independent of how often the contents of the picture are +updated by an application. Double and +multi-buffering +of images should be possible regardless of whether the image +is displayed normally or in stereo. + + + +To achieve this goal, a simple extension to normal windows +is suggested. Stereo windows are just like normal windows +except the displayed image is made up of a left image +buffer and a right image buffer. To create a stereo window, +a client makes the following request: + + + +CreateStereoWindow + parent : WINDOW + w_id : WINDOW + left, right : BUFFER + depth : CARD8 + visual : VISUALID or CopyFromParent + x, y : INT16 + width, height : INT16 + border_width : INT16 + value_mask : BITMASK + value_list : LISTofVALUE + + (Errors: Alloc, Color, Cursor, Match, + Pixmap, Value, Window) + + + +This request, modeled after the CreateWindow request, +adds just two new parameters: left and +right. +For stereo, it is essential that one can distinguish whether +a draw operation is to occur on the left image or right image. +While an internal mode could have been added to achieve this, +using two buffer ID's allows clients to simultaneously build up +the left and right components of a stereo image. These +ID's always refer to (are an alias for) the left and right +image buffers that are currently displayed. + + + +Like normal windows, the window ID is used whenever a window +management operation is to be performed. Window queries would +also return this window ID (eg: QueryTree) as would most +events. Like the window ID, the left and right buffer ID's +each have their own event mask. They can be set and queried +using the Set/GetBufferAttributes requests. + + + +Using the window ID of a stereo window in a draw request +(eg: GetImage) results in pixels that are +undefined. +Possible semantics are that both left and right images get +drawn, or just a single side is operated on (existing applications +will have to be re-written to explicitly use the left and right +buffer ID's in order to successfully create, fetch, and store +stereo images). + + + +Having an explicit CreateStereoWindow request is helpful +in that a server implementation will know from the onset whether +a stereo window is desired and can return appropriate status +to the client if it cannot support this functionality. + + + +Some hardware may support separate stereo and non-stereo modes, +perhaps with different vertical resolutions. For example, the +vertical resolution in stereo mode may be half that of non-stereo +mode. Selecting one mode or the other must be done through some +means outside of this extension (eg: by providing a separate +screen for each hardware display mode). The screen attributes +(ie: x/y resolution) for a screen that supports normal windows, +may differ from a screen that supports stereo windows; +however, all windows, regardless of type, displayed on the +same screen must have the same screen attributes +(ie: pixel aspect ratio). + + + +If a screen that supports stereo windows also supports +normal windows, then the images presented to the left and +right eyes for normal windows should be the same +(ie: have no stereo offset). + + + + + +Single-Buffered Stereo Windows + + +The following shows how to create and display a single-buffered +stereo image: + + +/* + * Create the stereo window, map it the screen, + * and draw the left and right images + */ +CreateStereoWindow( W, L, R, ... ) + +MapWindow( W ) + +<draw picture using L,R> + + + + +Double-Buffering Stereo Windows + + +Additional image buffers may be added to a stereo window +to allow double or multi-buffering of stereo images. +Simply use the the CreateImageBuffers request. +Even numbered buffers (0,2,...) will be left buffers. +Odd numbered buffers (1,3,...) will be right buffers. +Displayable stereo images are formed by consecutive +left/right pairs of image buffers. For example, +(buffer[0],buffer[1]) form the first displayable +stereo image; (buffer[2],buffer[3]) the next; +and so on. + + + +The CreateImageBuffers request will only create +pairs of left and right image buffers for stereo windows. +By always pairing left and right image +buffers together, implementations might be able to +perform some type of optimization. If an odd number +of buffers is specified, a Value error is generated. +All the rules mentioned at the start of this proposal +still apply to the image buffers supported by a stereo window. + + + +To display a image buffer pair of a multi-buffered stereo image, +either the left buffer ID or right buffer ID may be specified in a +DisplayImageBuffers request, but not both. + + + +To double-buffer a stereo window: + + + +/* + * Create stereo window and map it to the screen + */ +CreateStereoWindow( W, L, R, ... ) + +/* + * Create two pairs of image buffers. Assume after display, + * buffer contents become "undefined". Assume we will "frequently" + * update the display. Abort if we did get all the buffers. + */ +n = CreateImageBuffers( W, [L0,R0,L1,R1], Undefined, Frequently ) +if (n != 4) <abort> + +/* + * Map window to the screen + */ +MapWindow( W ) + +/* + * Draw images using alternate buffers, + * display every 1/10 of a second. + */ +while animating +{ + <draw picture using L1,R1> + DisplayImageBuffers( [L1], 100, 0 ) + + <draw picture using L0,R0> + DisplayImageBuffers( [L0], 100, 0 ) +} + + + + + +Multi-Buffering Stereo Windows + + +To cycle through N stereo images: + + + +/* + * Create stereo window + */ +CreateStereoWindow( W, L, R, ... ) + +/* + * Create N pairs of image buffers. Assume after display, + * buffer contents are "untouched". Assume we will "frequently" + * update the display. Abort if we don't get all the buffers. + */ +n = CreateImageBuffers( W, [L0,R0,...,L(N-1),R(N-1)], Untouched, Frequently ) +if (n != N*2) <abort> + +/* + * Map window to screen + */ +MapWindow( W ) + +/* + * Draw the left and right halves of each image + */ +foreach stereo image + <draw picture using L(i),R(i)> + +/* + * Cycle through images every 1/10 of a second + */ +while animating +{ + foreach stereo image + DisplayImageBuffers( [L(i)], 100, 0 ) +} + + + + +Protocol Encoding + + +The official name of this extension is "Multi-Buffering". +When this string passed to QueryExtension the +information returned should be interpreted as follows: + + + + + major-opcode + + +Specifies the major opcode of this extension. +The first byte of each extension request should +specify this value. + + + + + first-event + + +Specifies the code that will be returned when +ClobberNotify events are generated. + + + + + first-error + + +Specifies the code that will be returned when +Buffer errors are generated. + + + + + + +The following sections describe the protocol +encoding for this extension. + + + + + +TYPES + + +BUFFER_INFO + +4 VISUALID visual +2 CARD16 max-buffers +1 CARD8 depth +1 unused + + + +SETofBUFFER_EVENT + + #x00008000 Exposure + #x02000000 ClobberNotify + #x04000000 UpdateNotify + + + + + +EVENTS + + +ClobberNotify +1 see first-event code +1 unused +2 CARD16 sequence number +4 BUFFER buffer +1 state + 0 Unclobbered + 1 PartiallyClobbered + 2 FullyClobbered +23 unused + + + +UpdateNotify +1 first-event+1 code +1 unused +2 CARD16 sequence number +4 BUFFER buffer +24 unused + + + + +ERRORS + + +Buffer +1 0 Error +1 see first-error code +2 CARD16 sequence number +4 CARD32 bad resource id +2 CARD16 minor-opcode +1 CARD8 major-opcode +21 unused + + + + + +REQUESTS + + +GetBufferVersion +1 see major-opcode major-opcode +1 0 minor-opcode +2 1 request length +-> +1 1 Reply +1 unused +2 CARD16 sequencenumber +4 0 reply length +1 CARD8 majorversion number +1 CARD8 minorversion number +22 unused + + +CreateImageBuffers + +1 see major-opcode major-opcode +1 1 minor-opcode +2 3+n requestlength +4 WINDOW wid +1 update-action + 0 Undefined + 1 Background + 2 Untouched + 3 Copied +1 update-hint + 0 Frequent + 1 Intermittent + 2 Static +2 unused +4n LISTofBUFFER buffer-list +-> +1 1 Reply +1 unused +2 CARD16 sequencenumber +4 0 reply length +2 CARD16 number-buffers +22 unused + + +DestroyImageBuffers + +1 see major-opcode major-opcode +1 2 minor-opcode +2 2 request length +4 WINDOW wid + + +DisplayImageBuffers + + +1 see major-opcode major-opcode +2 2+n requestlength +2 CARD16 min-delay +2 CARD16 max-delay +4n LISTofBUFFER buffer-list + + +SetMultiBufferAttributes + +1 see major-opcode major-opcode +1 4 minor-opcode +2 3+n requestlength +4 WINDOW wid +4 BITMASK value-mask (has n bits set to 1) + #x00000001 update-hint +4n LISTofVALUE value-list +VALUEs +1 update-hint + 0 Frequent + 1 Intermittent + 2 Static + + +GetMultiBufferAttributes + +1 see major-opcode major-opcode +1 5 minor-opcode +2 2 request length +4 WINDOW wid +® +1 1 Reply +1 unused +2 CARD16 sequencenumber +4 n reply length +2 CARD16 displayed-buffer +1 update-action + 0 Undefined + 1 Background + 2 Untouched + 3 Copied +1 update-hint + 0 Frequent + 1 Intermittent + 2 Static +1 window-mode + 0 Mono + 1 Stereo +19 unused +4n LISTofBUFFER buffer list + + +SetBufferAttributes + +1 see major-opcode major-opcode +1 6 minor-opcode +2 3+n requestlength +4 BUFFER buffer +4 BITMASK value-mask (has n bits set to 1) + #x00000001 event-mask +4n LISTofVALUE value-list +VALUEs +4 SETofBUFFER_EVENT event-mask + +GetBufferAttributes + +1 see major-opcode major-opcode +1 7 minor-opcode +2 2 request length +4 BUFFER buffer +-> +1 1 Reply +1 unused +2 CARD16 sequencenumber +4 0 reply length +4 WINDOW wid +4 SETofBUFFER_EVENT event-mask +2 CARD16 index + 1 side + 0 Mono + 1 Left + 2 Right +13 unused + +GetBufferInfo + +1 see major-opcode major-opcode +1 8 minor-opcode +2 2 request length +4 WINDOW root +® +1 1 Reply +1 unused +2 CARD16 sequencenumber +4 2(n+m) replylength +2 n number BUFFER_INFO in normal-info +2 m number BUFFER_INFO in stereo-info +20 unused +8n LISTofBUFFER_INFO normal-info +8m LISTofBUFFER_INFO stereo-info + +CreateStereoWindow + +1 see major-opcode major-opcode +1 9 minor-opcode +2 11+n requestlength +3 unused +1 CARD8 depth +4 WINDOW wid +4 WINDOW parent +4 BUFFER left +4 BUFFER right +2 INT16 x +2 INT16 y +2 CARD16 width +2 CARD16 height +2 CARD16 border-width +2 class + 0 CopyFromParent + 1 InputOutput + 2 InputOnly +4 VISUALID visual + 0 CopyFromParent +4 BITMASK value-mask (has n bits set to 1) + encodings are the same + as for CreateWindow +4n LISTofVALUE value-list + encodings are the same + as for CreateWindow + + +ClearImageBufferArea + +1 see major-opcode major-opcode +1 10 minor-opcode +2 5 request length +4 WINDOW buffer +2 INT16 x +2 INT16 y +2 CARD16 width +2 CARD16 height +3 unused +1 BOOL exposures + + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/security.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/security.xml new file mode 100644 index 0000000000000000000000000000000000000000..35f3395e4e20fea4f9a3d4445e128b8bab522f04 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/security.xml @@ -0,0 +1,1467 @@ + + %defs; +]> + + + + + + Security Extension Specification + X Consortium Standard + + + DavidP.Wiggins + X Consortium + + + X Version 11, Release &fullrelvers; + Version 7.1 + 1996X Consortium + + + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the “Software”), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + + +THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + +Except as contained in this notice, the name of the X Consortium shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from the X Consortium. + +X Window System is a trademark of The OpenGroup. + + +November 15, 1996 + + + + +Introduction + + +The Security extension contains new protocol needed to provide enhanced X +server security. The Security extension should not be exposed to untrusted +clients (defined below). + + + + + +Requests + + +SecurityQueryVersion + +This request returns the major and minor version numbers of this extension. + + +SecurityQueryVersion + + + + + + + + + + client-major-version + + + CARD16 + + + + + client-minor-version + + + CARD16 + + + + + => + + + + + server-major-version + + + CARD16 + + + + + server-minor-version + + + CARD16 + + + + + + + +The client-major-version and client-minor-version numbers indicate what +version of the protocol the client wants the server to implement. The +server-major-version and the server-minor-version numbers returned +indicate the protocol this extension actually supports. This might not +equal the version sent by the client. An implementation can (but need not) +support more than one version simultaneously. The server-major-version +and server-minor-version allow the creation of future revisions of the +Security protocol that may be necessary. In general, the major version +would increment for incompatible changes, and the minor version would +increment for small, upward-compatible changes. Servers that support +the protocol defined in this document will return a server-major-version +of one (1), and a server-minor-version of zero (0). + + + +Clients using the Security extension must issue a SecurityQueryVersion +request before any other Security request in order to negotiate a compatible +protocol version; otherwise, the client will get undefined behavior +(Security may or may not work). + + + + +SecurityGenerateAuthorization + + +This request causes the server to create and return a new authorization with +specific characteristics. Clients can subsequently connect using the new +authorization and will inherit some of the characteristics of the +authorization. + + + +SecurityGenerateAuthorization + + + + + + + + + + authorization-protocol-name + + + STRING8 + + + + + authorization-protocol-data + + + STRING8 + + + + + value-mask + + + BITMASK + + + + + value-list + + + LISTofVALUE + + + + + => + + + + + + + authorization-id + + + AUTHID + + + + + authorization-data-return + + + STRING8 + + + + + + + +Errors: AuthorizationProtocol, Value, Alloc + + + +authorization-protocol-name is the name of the authorization method for +which the server should generate a new authorization that subsequent +clients can use to connect to the server. If the authorization-protocol-name +is not one that the server supports, or if authorization-protocol-data +does not make sense for the given authorization-protocol-name, an +AuthorizationProtocol error results. + + + +authorization-protocol-data is authorization-method specific data that can +be used in some way to generate the authorization. + + + +In this version of the extension, the only authorization method +required to be supported is "MIT-MAGIC-COOKIE-1" with any amount +of authorization-protocol-data (including none). The server may use the +authorization-protocol-data as an additional source of randomness used +to generate the authorization. Other authorization methods can supply +their own interpretation of authorization-protocol-data. + + + +The value-mask and value-list specify attributes of the authorization +that are to be explicitly initialized. The possible values are: + + + + + + + + + + + Attribute + Type + Default + + + + + + timeout + + + CARD32 + + + 60 + + + + + group + + + XID or None + + + None + + + + + trust-level + + + {SecurityClientTrusted, + + + + + + + + SecurityClientUntrusted} + + + SecurityClientUntrusted + + + + + event-mask + + + SecurityAuthorizationRevoked, + + + + + + + + or None + + + None + + + + + + + +timeout is the timeout period in seconds for this authorization. A +timeout value of zero means this authorization will never expire. For +non-zero timeout values, when timeout seconds have elapsed since the +last time that the authorization entered the state of having no +connections authorized by it, and if no new connections used the +authorization during that time, the authorization is automatically purged. +(Note that when an authorization is created, it enters the state of having no +connections authorized by it.) Subsequent connection attempts using that +authorization will fail. This is to facilitate "fire and forget" launching of +applications. + + + +group is an application group ID as defined by the Application Group +extension, or None. Any other values will cause a Value error. When a +group is destroyed, all authorizations specifying that group are revoked +as described under the SecurityRevokeAuthorization request. The Application +Group extension attaches additional semantics to the group. + + + +trust-level tells whether clients using the authorization are trusted or +untrusted. If trust-level is not one of the constants SecurityClientTrusted +or SecurityClientUntrusted, a Value error results. + + + +event-mask defines which events the client is interested in for this +authorization. When the authorization expires or is revoked if event-mask +contains SecurityAuthorizationRevoked a SecurityAuthorizationRevoked event +is reported to the client. + + + +The SecurityAuthorizationRevoked event contains the following field: + + + + + + + + + + Field + Type + + + + + + authorization-id + + + AUTHID + + + + + + + +where authorization-id is the identification of the authorization that was +revoked. + + +If an invalid value-mask is specified, a Value error occurs. + + + +The returned authorization-id is a non-zero value that uniquely identifies +this authorization for use in other requests. The value space for type +AUTHID is not required to be disjoint from values spaces of other core +X types, e.g. resource ids, atoms, visual ids, and keysyms. Thus, a given +numeric value might be both a valid AUTHID and a valid atom, for example. + + + +authorization-data-return is the data that a client should use in some +authorization-method-specific way to make a connection with this +authorization. For "MIT-MAGIC-COOKIE-1," authorization-data-return should +be sent as the authorization-protocol-data in the connection setup message. +It is not required that other authorization methods use +authorization-data-return this way. + + + + + +SecurityRevokeAuthorization + + +This request deletes an authorization created by SecurityGenerateAuthorization. + + + +SecurityRevokeAuthorization + + + + + + + + + + + authorization-id + + + AUTHID + + + + + + + +Errors: Authorization + + + +If authorization-id does not name a valid authorization, an Authorization +error occurs. Otherwise, this request kills all clients currently connected +using the authorization specified by authorization-id. The authorization is +deleted from the server's database, so future attempts by clients to connect +with this authorization will fail. + + + + + + +Changes to Core Requests + + +A server supporting this extension modifies the handling of some core +requests in the following ways. + + +Resource ID Usage + + +If an untrusted client makes a request that specifies a resource ID that is +not owned by another untrusted client, a protocol error is sent to the +requesting client indicating that the specified resource does not exist. +The following exceptions apply. An untrusted client can: + + + + + +use the QueryTree, GetGeometry, and TranslateCoordinates requests +without restriction. + + + + +use colormap IDs that are returned in the default-colormap field of its +connection setup information in any colormap requests. + + + + specify a root window as: + + + +the drawable field of CreatePixmap, CreateGC, and QueryBestSize. + + + + the parent field of CreateWindow. + + + +the window field of CreateColormap, ListProperties, and GetWindowAttributes. + + + + the grab-window or confine-to fields of GrabPointer. + + + + the grab-window field of UngrabButton. + + + +the destination of SendEvent, but only if all of the following are true. +(These conditions cover all the events that the ICCCM specifies with +a root window destination.) + + + + The propagate field of SendEvent is False. + + + +The event-mask field of SendEvent is ColormapChange, +StructureNotify, or the logical OR of SubstructureRedirect with +SubstructureNotify. + + + + +The event type being sent is UnmapNotify, ConfigureRequest, or +ClientMessage. + + + + + + +the window field of ChangeWindowAttributes, but only if the value-mask +contains only event-mask and the corresponding value is StructureNotify, +PropertyChange, or the logical OR of both. + + + + + + + + +ISSUE: are root window exceptions needed for these? WarpPointer, ReparentWindow +(parent), CirculateWindow, QueryPointer (emacs does this), GetMotionEvents. + + + + + +Extension Security + + +This extension introduces the notion of secure and insecure extensions. A +secure extension is believed to be safe to use by untrusted clients; that +is, there are no significant security concerns known that an untrusted +client could use to destroy, modify, or steal data of trusted clients. This +belief may be founded on a careful analysis of the extension protocol, +its implementation, and measures taken to "harden" the extension to close +security weaknesses. All extensions not considered secure are called +insecure. The implementation details of how an extension is identified as +secure or insecure are beyond the scope of this specification. + + + +ListExtensions will only return names of secure +extensions to untrusted clients. + + + +If an untrusted client uses QueryExtension on an +insecure extension that the server supports, the reply will have the +present field set to False and the major-opcode field set to zero to +indicate that the extension is not supported. + + + +If an untrusted client successfully guesses the major opcode of an +insecure extension, attempts by it to execute requests with that major +opcode will fail with a Request error. + + + + + +Keyboard Security + + + +The protocol interpretation changes in this section are intended to prevent +untrusted applications from stealing keyboard input that was meant for +trusted clients and to prevent them from interfering with the use of the +keyboard. + + + +The behavior of some keyboard-related requests and events is modified when +the client is untrusted depending on certain server state at the time of +request execution or event generation. Specifically, if a hypothetical +keyboard event were generated given the current input focus, pointer +position, keyboard grab state, and window event selections, and if that +keyboard event would not be delivered to any untrusted client, the +following changes apply: + + + + + +The bit vector representing the up/down state of the keys returned by +QueryKeymap and +KeymapNotify is all zeroes. + + + + GrabKeyboard returns a status of AlreadyGrabbed. + + + +SetInputFocus does nothing. Note that this means the +Globally Active +Input and WM_TAKE_FOCUS mechanisms specified in the ICCCM will +not work with untrusted clients. + + + + +Passive grabs established by GrabKey that would otherwise have activated +do not activate. + + + + + +If an untrusted client attempts to use any of the following requests, the +only effect is that the client receives an Access error: SetModifierMapping, +ChangeKeyboardMapping, ChangeKeyboardControl. + + + +If an InputOnly window owned by an untrusted client has a parent owned by a +trusted client, all attempts to map the window will be ignored. This includes +mapping attempts resulting from MapWindow, MapSubwindows, ReparentWindow, +and save-set processing. + + +However, if the parent of an InputOnly window owned by an untrusted client +is the root window, attempts to map that window will be performed as +expected. This is in line with the root window exceptions above. + + + + +Image Security + + +It should be impossible for an untrusted client to retrieve the image +contents of a trusted window unless a trusted client takes action to allow +this. We introduce the following defenses in support of this requirement. + + + +The restrictions on resource ID usage listed above prevent untrusted clients +from using GetImage directly on windows not belonging to trusted clients. + + + +If an untrusted client tries to set the background-pixmap attribute of an +untrusted window to None, the server will instead use a server-dependent +background which must be different than None. + + + +The X protocol description of GetImage states that the +returned contents of regions of a window obscured by noninferior windows are +undefined if the window has no backing store. Some implementations return the +contents of the obscuring windows in these regions. When an untrusted client +uses GetImage, this behavior is forbidden; the server must +fill the obscured regions in the returned image with a server-dependent pattern. + + + +If an untrusted window has trusted inferiors, their contents are vulnerable +to theft via GetImage on the untrusted parent, as well +as being vulnerable to destruction via drawing with subwindow-mode +IncludeInferiors on the untrusted parent. An untrusted window having trusted +inferiors can only occur at the request of a trusted client. It is expected +to be an unusual configuration. + + + + + +Property Security + + +Unlike the other security provisions described in this document, security for +property access is not amenable to a fixed policy because properties are +used for inter-client communication in diverse ways and may contain data of +varying degrees of sensitivity. Therefore, we only list the possible +restrictions the server may decide to impose on use of properties on trusted +windows by untrusted clients. How the server chooses which restrictions from +this list to apply to a particular property access is implementation dependent + +In the X Consortium server implementation, property access is controlled by +a configuration file; see the -sp option in the Xserver(1) manual page. + . + + +The X Protocol property requests are +ChangeProperty, +GetProperty, +DeleteProperty, +RotateProperties, and +ListProperties. For these requests, the server can +allow the request to execute normally (as if it had been issued by a +trusted client), ignore the request completely (as if it were a NoOperation), +or ignore the request except to send an Atom error to the client. Ignoring +a ListProperties request means replying that +the window has no properties. ListProperties may also +reply with a subset of the existing properties if the server is doing +property hiding; see below. An ignored GetProperty +request may reply that the property does not exist, or that it exists but +contains no data. + + + +The server may decide to hide certain properties on certain windows from +untrusted clients + +The X Consortium server implementation does not currently provide a way to +hide properties. + . +If a property is to be hidden, it must be done consistently to avoid +confusing clients. This means that for untrusted clients: + + + + + +That property should not be returned by +ListProperties. + + + + +PropertyNotify events should not be sent for that +property. + + + +GetProperty on that property should reply that the +property does not exist (the return type is None, the format and +bytes-after are zero, and the value is empty). + + + + + +For a property that the server is protecting but not hiding, consistency +must also be maintained: + + + + + +That property should be returned by ListProperties. + + + + +PropertyNotify events should be sent for that property. + + + + +GetProperty on that property should reply that the +property exists (if it really does) but the value is empty +(return type and format are their real values, and the "length of value" +field in the reply is zero). + + + + + + + +Miscellaneous Security + + +If an untrusted client attempts to use +ChangeHosts, +ListHosts, or +SetAccessControl, +the only effect is that the client receives an Access error. + + + +If an untrusted client attempts to use ConvertSelection +on a selection with a trusted selection owner window, the server generates +a SelectionNotify event to the requestor with property None. + + + + + +New Authorization Method + + +This extension includes a new authorization method named +"XC-QUERY-SECURITY-1". Its purpose is to allow an external agent such as +the X firewall proxy to probe an X server to determine whether that server +meets certain security criteria without requiring the agent to have its +own authorization for that server. The agent may use the returned information +to make a decision. For example, the X firewall proxy may choose not to +forward client connections to servers that do not meet the criteria. + + + +To use this authorization method, the client (or proxy) sends +"XC-QUERY-SECURITY-1" as the authorization-protocol-name in the initial +connection setup message. The authorization-protocol-data may be empty or +may contain additional security criteria described below. If the success +field of the server's reply is Authenticate, the server supports the +security extension, and the server meets all specified additional security +criteria. In this case, the client should resend the initial connection +setup message substituting the authorization protocol name and data +that should be used to authorize the connection. If the success field of the +server's reply is anything other than Authenticate, either the server does not +support the security extension, does not meet (or cannot determine if it +meets) all of the additional security criteria, or chooses for internal reasons +not to answer with Authenticate. In this case, the client should close the +connection. + + + +If the authorization-protocol-data sent with "XC-QUERY-SECURITY-1" is not +empty, it specifies additional security criteria for the server to check, as +follows. + + + +authorization-protocol-data + + + + + + + + + + + policy-mask + + + BITMASK + + + + + policies + + + LISTofSECURITYPOLICY + + + + + + + +The policy-mask field is any logical-OR combination of the constants +Extensions and SitePolicies. For each bit set in policy-mask, there is a +SECURITYPOLICY element in policies. The nth element in policies corresponds +to the nth 1-bit in policy-mask, counting upward from bit 0. + + +SECURITYPOLICY + + + + + + + + + + policy-type + + + {Disallow, Permit} + + + + + names + + + LISTofSTR + + + + + + + +For a SECURITYPOLICY corresponding to policy-mask Extensions, if +policy-type is Disallow the server is required to consider as insecure +all extensions given in names. No policy is specified for extensions +not listed in names. If policy-type is Permit the server may consider +only those extensions given in names to be secure; all other extensions +must be treated as insecure. If these constraints are not met, the server +should not return Authenticate in the success field of the reply. +Servers can but need not dynamically configure themselves in response +to an Extensions SECURITYPOLICY; a conforming server might simply compare +the policy with a compiled-in table of extensions and their security status. + + + +For a SECURITYPOLICY corresponding to policy-mask SitePolicies, policy-type +Disallow means the server must not have been configured with any of the site +policies given in names. Policy-type Permit means the server must have +been configured with at least one of the site policies given in names. If +these constraints are not met, the server should not return Authenticate in +the success field of the reply. + + + +SitePolicies provide a way to express new forms of security-relevant +information that could not be anticipated at the time of this writing. +For example, suppose the server is found to have a critical security defect. +When a fix is developed, a site policy string could be associated with the +fix. Servers with the fix would advertise that site policy, and the X +firewall proxy would specify that site policy in a SECURITYPOLICY with +policy-type Permit. + + + + + +Encoding + + +Please refer to the X11 Protocol Encoding document as this section +uses syntactic conventions and data types established there. + + + +The name of this extension is "SECURITY". + + + +Types + +AUTHID: CARD32 + + + + +Request Encoding + + +SecurityQueryVersion + + +1 CARD8 major-opcode +1 0 minor-opcode +2 2 request length +2 CARD16 client-major-version +2 CARD16 client-minor-version +=> +1 1 Reply +1 unused +2 CARD16 sequence number +4 0 reply length +2 CARD16 server-major-version +2 CARD16 server-minor-version +20 unused + + + +SecurityRevokeAuthorization + + + +1 CARD8 major-opcode +1 2 minor-opcode +2 2 request length +4 AUTHID authorization-id + + + +SecurityGenerateAuthorization + + + +1 CARD8 major-opcode +1 1 minor-opcode +2 3 + (m+n+3)/4 + s request length +2 CARD16 m, number of bytes in authorization protocol name +2 CARD16 n, number of bytes in authorization data +m STRING8 authorization protocol name +n STRING8 authorization protocol data +p unused, p=pad(m+n) +4 BITMASK value-mask (has s bits set to 1) + #x00000001 timeout + #x00000002 trust-level + #x00000004 group + #x00000008 event-mask +4s LISTofVALUE value-list + + + +VALUES + + +4 CARD32 timeout +4 trust-level + 0 SecurityClientTrusted + 1 SecurityClientUntrusted +4 XID group +0 None +4 CARD32 event-mask + #x00000001 SecurityAuthorizationRevoked +=> +1 1 Reply +1 unused +2 CARD16 sequence number +4 (q+3)/4 reply length +4 AUTHID authorization-id +2 CARD16 data-length +18 unused +q STRING8 authorization-data-return +r unused, r=pad(q) + + + + + +Event Encoding + +SecurityAuthorizationRevoked + + + +1 0+extension event base code +1 unused +2 CARD16 sequence number +4 AUTHID authorization id +24 unused + + + + + +Authorization Method Encoding + + +For authorization-protocol-name "XC-QUERY-SECURITY-1", the +authorization-protocol-data is interpreted as follows: + + + +authorization-protocol-data + + +1 BITMASK policy-mask + #x00000001 Extensions + #x00000002 SitePolicies +m LISTofSECURITYPOLICY policies + + + +SECURITYPOLICY + + + +1 policy-type + 0 Permit + 1 Disallow +1 CARD8 number of STRs in names +n LISTofSTR names + + + +LISTofSTR has the same encoding as in the X protocol: each STR is a single +byte length, followed by that many characters, and there is no padding or +termination between STRs. + + + + + +C Language Binding + + +The header for this extension is <X11/extensions/security.h>. All +identifier names provided by this header begin with XSecurity. + + + +All functions that have return type Status will return nonzero for +success and zero for failure. + + + + + Status XSecurityQueryExtension + Display *dpy + int *major_version_return + int *minor_version_return + + + + + sets major_version_return and +minor_version_return to the major and minor Security protocol version +supported by the server. If the Security library is compatible with the +version returned by the server, it returns nonzero. If dpy does not support +the Security extension, or if there was an error during communication with +the server, or if the server and library protocol versions are incompatible, +it returns zero. No other XSecurity functions may be called before this +function. If a client violates this rule, the effects of all subsequent +XSecurity calls that it makes are undefined. + + + + + Xauth *XSecurityAllocXauth + void + + + +In order to provide for future evolution, Xauth structures are used to +pass and return authorization data, and the library provides ways to +allocate and deallocate them. + + + + must be used to allocate the +Xauth structure that is passed to +. + + + +For the purposes of the Security extension, the Xauth structure has +the following fields: + + + + + + + + + + + Type + Field name + Description + + + + + + unsigned short + + + name_length + + + number of bytes in name + + + + + char * + + + name + + + authorization protocol name + + + + + unsigned short + + + data_length + + + number of bytes in data + + + + + char * + + + data + + + authorization protocol data + + + + + + +The Xauth structure returned by this function is initialized as follows: +name_length and data_length are zero, and name and data are NULL. + + + + + void XSecurityFreeXauth + Xauth *auth + + + + + must be used to free Xauth +structures allocated by + or returned by +. It is the +caller's responsibility to fill in the name and data fields of Xauth structures +allocated with , so this function +will not attempt to free them. In contrast, all storage associated with +Xauth structures returned from + will be freed by this +function, including the name and data fields. + + + + + + Bool XSecurityRevokeAuthorization + Display *dpy + XSecurityAuthorization auth_id + + + + + deletes the authorization +specified by auth_id, which must be a value returned in the auth_id_return +parameter of . All +clients that connected with that authorization are be killed. Subsequently, +clients that attempt to connect using that authorization will be refused. + + + + + + Xauth *XSecurityGenerateAuthorization + Display *dpy + Xauth *auth_in + unsigned long valuemask + XSecurityAutorizationAttributes *attributes + XSecurityAutorization *auth_id_return + + + + + creates a new +authorization with the specified attributes. The auth_in argument must be +allocated by . The +name and name_length fields of auth_in should be initialized to the +authorization protocol name and its length in characters respectively. +If there is authorization data, the data and data_length fields of +auth_in should be initialized to the data and its length in characters +respectively. The library does not assume that name and data are +null-terminated strings. The auth_in argument must be freed with +. + + + +The XSecurityAuthorizationAttributes structure has the following fields: + + + + + + + + + + + Type + Field name + Mask + + + + + + unsigned int + + + trust_level + + + XSecurityTrustLevel + + + + + unsigned int + + + timeout + + + XSecurityTimeout + + + + + XID + + + group + + + XSecurityGroup + + + + + long + + + event_mask + + + XSecurityEventMask + + + + + + + +These correspond to the trust-level, timeout, group, and event-mask +described in the SecurityGenerateAuthorization protocol request. The +caller can fill in values for any subset of these attributes. The valuemask +argument must be the bitwise OR of the symbols listed in the Mask column +for all supplied attributes. The event_mask attribute can be None, +XSecurityAuthorizationRevokedMask, or XSecurityAllEventMasks. In this +revision of the protocol specification XSecurityAllEventMasks is equivalent +to XSecurityAuthorizationRevokedMask. If the caller does not need to +specify any attributes, the attributes argument can be NULL, and the +valuemask argument must be zero. + + +If the function fails, NULL is returned and auth_id_return is filled in +with zero. Otherwise, a pointer to an Xauth structure is returned. The name +and name_length fields of the returned Xauth structure will be copies of the +name that was passed in, and the data and data_length fields will be set to +the authorization data returned by the server. The caller should not assume +that name and data are null-terminated strings. If no authorization data was +returned by the server, the data and data_length fields will be set to NULL +and zero respectively. The returned Xauth structure must be freed with +; the caller should not use any other +means free the structure or any of its components. The auth_id_return +argument will be filled in with the non-zero authorization id of the created +authorization. + + + +The XSecurityAuthorizationRevokedEvent structure has the following fields: + + + + + + + + + + + Type + Field name + Description + + + + + + int + + + type + + + event base + XSecurityAuthorizationRevoked + + + + + unsigned long + + + serial + + + # of last request processed by server + + + + + Bool + + + send_event + + + true if this came from SendEvent + + + + + Display* + + + display + + + Display the event was read from + + + + + XSecurityAuthorization + + + auth_id + + + revoked authorization id + + + + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/shape.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/shape.xml new file mode 100644 index 0000000000000000000000000000000000000000..16751ffdbc8898e6d11f47c1741b5371f38b2107 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/shape.xml @@ -0,0 +1,1244 @@ + + %defs; +]> + + + + + + + X Nonrectangular Window Shape Extension Protocol + X.Org Standard + + + KeithPackard + MIT X Consortium + Intel Corporation + + + HidekiHiura + SunSoft, Inc. + + + X Version 11, Release &fullrelvers; + Version 1.1 + 19892004The Open Group + 2006Keith Packard + + + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + + +THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + +Except as contained in this notice, the name of the copyright holders +shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from the +copyright holders. + + + + + +Overview + + +This extension provides arbitrary window and border shapes within the X11 +protocol. + + + +The restriction of rectangular windows within the X protocol is a significant +limitation in the implementation of many styles of user interface. For +example, many transient windows would like to display a "drop shadow'' to +give the illusion of 3 dimensions. As another example, some user interface +style guides call for buttons with rounded corners; the full simulation of a +nonrectangular shape, particularly with respect to event distribution and +cursor shape, is not possible within the core X protocol. As a final +example, round clocks and nonrectangular icons are desirable visual addition +to the desktop. + + + +This extension provides mechanisms for changing both the visible and interactive shape of a +window to arbitrary, possibly disjoint, nonrectangular forms. The intent +of the extension is to supplement the existing semantics, not replace them. +In particular, it is desirable for clients that are unaware of the +extension to still be able to cope reasonably with shaped windows. For +example, window managers should still be able to negotiate screen +real estate in rectangular pieces. Toward this end, any shape specified for +a window is clipped by the bounding rectangle for the window as specified by +the window's geometry in the core protocol. An expected convention would be +that client programs expand their shape to fill the area offered by the +window manager. + + + + +Description + +Each window (even with no shapes specified) is defined by three regions: the +bounding region, the clip +region and the input region. The +bounding region is the area of the +parent window that the window will occupy (including border). The clip region +is the subset of the bounding region that is available for subwindows and +graphics. The area between the bounding region and the clip region is defined +to be the border of the window. The input region is the subset of the +bounding region that can "contain" the pointer. + + + +A nonshaped window will have a bounding region that is a rectangle +spanning the window, including its border; the clip region will be a rectangle +filling the inside dimensions (not including the border); the input +region will match the bounding region. In this document, +these areas are referred to as the +default bounding region, the +default clip region and the +default input region. For a window with inside +size of width by +height and border width +bwidth, the default bounding, clip +and input regions are the rectangles (relative to the window origin): + + + +bounding.x = -bwidth +bounding.y = -bwidth +bounding.width = width + 2 * bwidth +bounding.height = height + 2 * bwidth + +clip.x = 0 +clip.y = 0 +clip.width = width +clip.height = height + +input.x = -bwidth +input.y = -bwidth +input.width = width + 2 * bwidth +input.height = height + 2 * bwidth + + + +This extension allows a client to modify any combination of the bounding, +clip or input regions by specifying new regions that combine with the default +regions. These new regions are called the +client bounding region, +the client clip region and the +client input region. They are specified +relative to the origin of +the window and are always defined by offsets relative to the window origin +(that is, region adjustments are not required when the window is moved). +Three mechanisms for specifying regions are provided: a list of rectangles, +a bitmap, and an existing bounding or clip region from a window. This is +modeled on the specification of regions in graphics contexts in the core +protocol and allows a variety of different uses of the extension. + + + +When using an existing window shape as an operand in specifying a new shape, +the client region is used, unless none has been set, in which case the +default region is used instead. + + + +The effective bounding region of a window +is defined to be the intersection of +the client bounding region with the default bounding region. Any portion of +the client bounding region that is not included in the default bounding +region will not be included in the effective bounding region on the screen. +This means that window managers (or other geometry managers) used to dealing +with rectangular client windows will be able to constrain the client to a +rectangular area of the screen. + + + +Construction of the effective bounding region is dynamic; the client bounding +region is not mutated to obtain the effective bounding region. If a client +bounding region is specified that extends beyond the current default bounding +region, and the window is later enlarged, the effective bounding region will +be enlarged to include more of the client bounding region. + + + +The effective clip region of a window is defined to be the intersection of the +client clip region with both the default clip region and the client bounding +region. Any portion of the client clip region that is not included in both +the default clip region and the client bounding region will not be included in +the effective clip region on the screen. + + + +Construction of the effective clip region is dynamic; the client clip region is +not mutated to obtain the effective clip region. If a client clip region is +specified that extends beyond the current default clip region and the +window or its bounding region is later enlarged, the effective clip region will +be enlarged to include more of the client clip region if it is included in +the effective bounding region. + + + +The border of a window is defined to be the difference between the effective +bounding region and the effective clip region. If this region is empty, no +border is displayed. If this region is nonempty, the border is filled +using the border-tile or border-pixel of the window as specified in the core +protocol. Note that a window with a nonzero border width will never be able +to draw beyond the default clip region of the window. Also note that a zero +border width does not prevent a window from having a border, since the clip +shape can still be made smaller than the bounding shape. + + + +All output to the window and visible regions of any subwindows will be +clipped to the effective clip region. The server must not retain window +contents beyond the effective bounding region with backing store. The window's +origin (for graphics operations, background tiling, and subwindow placement) +is not affected by the existence of a bounding region or clip region. + + + +The effective input region of a window is +defined to be the intersection of the +client input region with both the default input region and the client bounding +region. Any portion of the client input region that is not included in both +the default input region and the client bounding region will not be included in +the effective input region on the screen. + + + +Construction of the effective input region is dynamic; the client input region is +not mutated to obtain the effective input region. If a client input region is +specified that extends beyond the current default input region and the +window or its bounding region is later enlarged, the effective input region will +be enlarged to include more of the client input region if it is included in +the effective bounding region. + + + +Areas that are inside the default bounding region but outside the effective +bounding region are not part of the window; these areas of the screen will +be occupied by other windows. Input events that occur within the default +bounding region but outside the effective bounding region will be delivered as +if the window was not occluding the event position. Events that occur in +a nonrectangular border of a window will be delivered to that window, just +as for events that occur in a normal rectangular border. + + + +An +InputOnly +window can have its bounding or input region set, but it is a +Match +error to attempt to set a clip region on an +InputOnly +window or to specify its clip region as a source to a request +in this extension. + + + +The server must accept changes to the clip and input regions of a root window, but +the server is permitted to ignore requested changes to the bounding region +of a root window. If the server accepts bounding region changes, the contents +of the screen outside the bounding region are implementation dependent. + + + + +Types + + +The following types are used in the request and event definitions in +subsequent sections. + + + +SHAPE_KIND: +{ Bounding, +Clip, +Input } + + + +SHAPE_OP: +{ Set, +Union, +Intersect, +Subtract, +Invert } + + + +Set +indicates that the region specified as an explicit source in the request is +stored unaltered as the new destination client region. +Union +indicates that the source and destination regions are unioned together to +produce the new destination client region. +Intersect +indicates that the source and destination regions are intersected together to +produce the new destination client region. +Subtract +indicates that the source region is subtracted from the destination region to +produce the new destination region. +Invert +indicates that the destination region is subtracted from the source region to +produce the new destination region. + + + + +Requests + +ShapeQueryVersion + + + + => + + + +majorVersion: CARD16 + + +minorVersion: CARD16 + + + +This request can be used to ensure that the server version of the SHAPE +extension is usable by the client. This document defines major version one +(1), minor version one (1). + + + +ShapeRectangles + + + + + + + + + dest: WINDOW + + + destKind: SHAPE_KIND + + + op: SHAPE_OP + + + xOff, yOff: INT16 + + + rectangles: LISTofRECTANGLES + + + ordering: +{ UnSorted, +YSorted, +YXSorted, +YXBanded } + + + + +Errors: +Window, +Length, +Match, +Value + + + + + + + +This request specifies an array of rectangles, relative to the origin of the +window plus the specified offset (xOff and yOff) that together +define a region. This region is combined (as specified by the operator +op) with the existing client region (specified by destKind) of the +destination window, and the result is stored as the specified client region of +the destination window. Note that the list of rectangles can be empty, +specifying an empty region; this is not the same as passing +None to +ShapeMask, + + + +If known by the client, +ordering relations on the rectangles can be specified with the ordering +argument. +This may provide faster operation by the server. +The meanings of the ordering values are the same as in the core protocol +SetClipRectangles +request. +If an incorrect ordering is specified, +the server may generate a +Match +error, but it is not required to do so. +If no error is generated, +the graphics results are undefined. +Except for +UnSorted , +the rectangles should be nonintersecting, or the resulting region will +be undefined. +UnSorted +means that the rectangles are in arbitrary order. +YSorted +means that the rectangles are nondecreasing in their Y origin. +YXSorted +additionally constrains +YSorted +order in that all rectangles with an equal Y origin are +nondecreasing in their X origin. +YXBanded +additionally constrains +YXSorted +by requiring that, for every possible Y scanline, +all rectangles that include that scanline have identical Y origins and Y +extents. + + + +ShapeMask + + + + + + + + + +dest: WINDOW +destKind: SHAPE_KIND +op: SHAPE_OP +xOff, yOff: INT16 +source: PIXMAP or +None + + + + +Errors: +Window, +Pixmap, +Match, +Value + + + + + + + +The source in this request is a 1-bit deep pixmap, or +None . +If source is +None , +the specified client region is removed from the window, causing the effective +region to revert to the default region. The +ShapeNotify +event generated by this request and subsequent +ShapeQueryExtents +will report that a client shape has not been specified. +If a valid pixmap is specified, it is converted +to a region, with bits set to one included in the region and bits set to +zero excluded, and an offset from the window origin as specified by +xOff and yOff. The resulting region is then combined (as +specified by the operator op) with the existing client region +(indicated by destKind) of the destination window, and the result is +stored as the specified client region of the destination window. The source +pixmap and destination window must have been created on the same screen, +or else a +Match +error results. + + + +ShapeCombine + + + + + + + + + +dest: WINDOW + + + + +destKind: SHAPE_KIND + + + + +op: SHAPE_OP + + + + +xOff, yOff: INT16 + + + + +source: WINDOW + + + + +sourceKind: SHAPE_KIND + + + + +Errors: +Window, +Match, +Value + + + + + + + +The client region, indicated by sourceKind, of the source window is +offset from the window origin by xOff and yOff and combined with +the client region, indicated by destKind, of the destination window. +The result is stored as the specified client region of the destination +window. +The source and destination windows must be on the same screen, or else a +Match +error results. + + + +ShapeOffset + + + + + + + + + +dest: WINDOW + + + + +destKind: SHAPE_KIND + + + + +xOff, yOff: INT16 + + + + +Errors: +Window, +Match, +Value + + + + + + + +The client region, indicated by destKind, is moved relative to its +current position by the amounts xOff and yOff. + + + +ShapeQueryExtents + + + + + + + + + +dest: WINDOW + + + + + + + + => + + + + + + + + + +boundingShaped: BOOL + + + + +clipShaped: BOOL + + + + +xBoundingShape: INT16 + + + + +yBoundingShape: INT16 + + + + +widthBoundingShape: CARD16 + + + + +heightBoundingShape: CARD16 + + + + +xClipShape: INT16 + + + + +yClipShape: INT16 + + + + +widthClipShape: CARD16 + + + + +heightClipShape: CARD16 + + + + +Errors: +Window + + + + + + + +The boundingShaped and clipShaped results are +True +if the corresponding client regions have been specified, else they are +False . +The x, y, width, and height values define the extents of the client regions, +when a client region has not been specified, the extents of the +corresponding default region are reported. + + + +ShapeSelectInput + + + + + + + + + +window: WINDOW + + + + +enable: BOOL + + + + +Errors: +Window, +Value + + + + + + + +Specifying enable as +True +causes the server to send the requesting client a +ShapeNotify +event whenever the bounding, clip or input region of the specified window is +altered by any client. +Specifying enable as +False +causes the server to stop sending such events. + + + +ShapeInputSelected + + + + + + + + + +window: WINDOW + + + + +=> +enable: BOOL + + + + +Errors: +Window + + + + + + + +If enable is +True, then +ShapeNotify +events for the window are generated for this client. + + + +ShapeGetRectangles + + + + + + + + + +window: WINDOW + + + + +kind: SHAPE_KIND + + + + + => +rectangles: LISTofRECTANGLE + + + + +ordering: +{ UnSorted, +YSorted, +YXSorted, +YXBanded } + + + + +Errors: +Window, +Match + + + + + + + +A list of rectangles describing the region indicated by kind, and the +ordering of those rectangles, is returned. The meaning of the ordering +values is the same as in the +ShapeRectangles +request. + + + + +Events + +ShapeNotify + + + + + + + + + +window: WINDOW + + + + +kind: SHAPE_KIND + + + + +shaped: BOOL + + + + +x, y: INT16 + + + + +width, +height: CARD16 + + + + +time: TIMESTAMP + + + + + + + +Whenever the client bounding, clip or input shape of a window is modified, a +ShapeNotify +event is sent to each client that has used +ShapeSelectInput +to request it. + + + +Kind indicates which client region (bounding or clip) has been modified; +shaped is +True +when the window has a client shape of type kind, and is +False +when the window no longer has a client shape of this type. +The x, y, width, and height indicate the extents of the +current shape. When shaped is +False +these will indicate the extents of the default region. The timestamp +indicates the server time when the shape was changed. + + + + +Encoding + +Please refer to the X11 Protocol Encoding document as this document uses +conventions established there. + + + +The name of this extension is "SHAPE". + + + +New Types + + +SHAPE_KIND + 0 Bounding + 1 Clip + 2 Input + + + +SHAPE_OP + 0 Set + 1 Union + 2 Intersect + 3 Subtract + 4 Invert + + + + +Requests + +ShapeQueryVersion + 1 CARD8 opcode + 1 0 shape opcode + 2 1 request length + +=> + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 length + 2 CARD16 major version + 2 CARD16 minor version + 20 unused + + + +ShapeRectangles + 1 CARD8 opcode + 1 1 shape opcode + 2 4+2n request length + 1 SHAPE_OP operation + 1 SHAPE_KIND destination kind + 1 ordering + 0 UnSorted + 1 YSorted + 2 YXSorted + 3 YXBanded + 1 unused + 4 WINDOW destination window + 2 INT16 x offset + 2 INT16 y offset + 8n LISTofRECTANGLE rectangles + + + + +ShapeMask + 1 CARD8 opcode + 1 2 shape opcode + 2 5 request length + 1 SHAPE_OP operation + 1 SHAPE_KIND destination kind + 2 unused + 4 WINDOW destination window + 2 INT16 x offset + 2 INT16 y offset + 4 PIXMAP source bitmap + 0 None + + + + +ShapeCombine + 1 CARD8 opcode + 1 3 shape opcode + 2 5 request length + 1 SHAPE_OP operation + 1 SHAPE_KIND destination kind + 1 SHAPE_KIND source kind + 1 unused + 4 WINDOW destination window + 2 INT16 x offset + 2 INT16 y offset + 4 WINDOW source window + + + +ShapeOffset + 1 CARD8 opcode + 1 4 shape opcode + 2 4 request length + 1 SHAPE_KIND destination kind + 3 unused + 4 WINDOW destination window + 2 INT16 x offset + 2 INT16 y offset + + + +ShapeQueryExtents + 1 CARD8 opcode + 1 5 shape opcode + 2 2 request length + 4 WINDOW destination window + + => + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 1 BOOL bounding shaped + 1 BOOL clip shaped + 2 unused + 2 INT16 bounding shape extents x + 2 INT16 bounding shape extents y + 2 CARD16 bounding shape extents width + 2 CARD16 bounding shape extents height + 2 INT16 clip shape extents x + 2 INT16 clip shape extents y + 2 CARD16 clip shape extents width + 2 CARD16 clip shape extents height + 4 unused + + + +ShapeSelectInput + 1 CARD8 opcode + 1 6 shape opcode + 2 3 request length + 4 WINDOW destination window + 1 BOOL enable + 3 unused + + + +ShapeInputSelected + 1 CARD8 opcode + 1 7 shape opcode + 2 2 request length + 4 WINDOW destination window + => + 1 1 Reply + 1 BOOL enabled + 2 CARD16 sequence number + 4 0 reply length + 24 unused + + + +ShapeGetRectangles + 1 CARD8 opcode + 1 8 shape opcode + 2 3 request length + 4 WINDOW window + 1 SHAPE_KIND source kind + 3 unused + => + 1 1 Reply + 1 ordering + 0 UnSorted + 1 YSorted + 2 YXSorted + 3 YXBanded + 2 CARD16 sequence number + 4 2n reply length + 4 CARD32 nrects + 20 unused + 8n LISTofRECTANGLE rectangles + + + + +Events + +ShapeNotify + 1 CARD8 type (0 + extension event base) + 1 SHAPE_KIND shape kind + 2 CARD16 sequence number + 4 WINDOW affected window + 2 INT16 x value of extents + 2 INT16 y value of extents + 2 CARD16 width of extents + 2 CARD16 height of extents + 4 TIMESTAMP server time + 1 BOOL shaped + 11 unused + + + + + +Glossary + + bounding region + + +The area of the parent window that this window will occupy. This area is +divided into two parts: the border and the interior. + + + + + + clip region + + +The interior of the window, as a subset of the bounding region. This +region describes the area that will be painted with the window background +when the window is cleared, will contain all graphics output to the window, +and will clip any subwindows. + + + + + + input region + + +The subset of the bounding region which can ``contain'' the +pointer. + + + + + + default bounding region + + +The rectangular area, as described by the core protocol window size, that +covers the interior of the window and its border. + + + + + + default clip region + + +The rectangular area, as described by the core protocol window size, that +covers the interior of the window and excludes the border. + + + + + + default input region + + +The rectangular area, as described by the core protocol window size, that +covers the interior of the window and its border. + + + + + + client bounding region + + +The region associated with a window that is directly modified via this +extension when specified by + ShapeBounding . +This region is used in conjunction with the default bounding region +to produce the effective bounding region. + + + + + + client clip region + + +The region associated with a window that is directly modified via this +extension when specified by + ShapeClip . +This region is used in conjunction with the default clip region +and the client bounding region to produce the effective clip region. + + + + + + client input region + + +The region associated with a window that is directly modified via this +extension when specified by + ShapeInput . +This region is used in conjunction with the default input region +and the client bounding region to produce the effective input region. + + + + + + effective bounding region + + +The actual shape of the window on the screen, including border and interior +(but excluding the effects of overlapping windows). When a window has a client +bounding region, the effective bounding region is the intersection of the +default bounding region and the client bounding region. Otherwise, the +effective bounding region is the same as the default bounding region. + + + + + + effective clip region + + +The actual shape of the interior of the window on the screen (excluding the +effects of overlapping windows). When a window has a client clip region or +a client bounding region, the effective clip region is the intersection of +the default clip region, the client clip region (if any) and the client +bounding region (if any). Otherwise, the effective clip region is the +same as the default clip region. + + + + + + effective input region + + +The actual shape of the window on the screen (excluding the +effects of overlapping windows) which can ``contain'' the pointer. +When a window has a client input region or +a client bounding region, the effective input region is the intersection of +the default input region, the client input region (if any) and the client +bounding region (if any). Otherwise, the effective input region is the +same as the default input region. + + + + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/shm.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/shm.xml new file mode 100644 index 0000000000000000000000000000000000000000..8e04e7d50fe7efb965daf247ea1c7d4843e0a1ca --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/shm.xml @@ -0,0 +1,476 @@ + + %defs; +]> + + + + + + + MIT-SHM(The MIT Shared Memory Extension) + How the shared memory extension works + + + JonathanCorbet + + National Center for Atmospheric Research + Atmospheric Technology Division + + corbet@ncar.ucar.edu + + + KeithPackard + MIT X Consortium + + + X Version 11, Release &fullrelvers; + Version 1.0 + 1991X Consortium + + + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + + +THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + +Except as contained in this notice, the name of the X Consortium shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from the X Consortium. + +X Window System is a trademark of The OpenGroup. + + + + +This document briefly describes how to use the MIT-SHM shared memory +extension. I have tried to make it accurate, but it would not surprise me +if some errors remained. If you find anything wrong, do let me know and I +will incorporate the corrections. Meanwhile, please take this document "as +is" (eman improvement over what was there before, but certainly not the +definitive word.) + + + + + + +REQUIREMENTS + +The shared memory extension is provided only by some X servers. To find out +if your server supports the extension, use xdpyinfo(1). In particular, to +be able to use this extension, your system must provide the SYSV shared +memory primitives. There is not an mmap-based version of this extension. +To use shared memory on Sun systems, you must have built your kernel with +SYSV shared memory enabled -- which is not the default configuration. +Additionally, the shared memory maximum size will need to be increased on +both Sun and Digital systems; the defaults are far too small for any useful +work. + + + + +WHAT IS PROVIDED + + +The basic capability provided is that of shared memory XImages. This is +essentially a version of the ximage interface where the actual image data +is stored in a shared memory segment, and thus need not be moved through +the Xlib interprocess communication channel. For large images, use of this +facility can result in some real performance increases. + + + +Additionally, some implementations provided shared memory pixmaps. These +are 2 dimensional arrays of pixels in a format specified by the X server, +where the image data is stored in the shared memory segment. Through use of +shared memory pixmaps, it is possible to change the contents of these +pixmaps without using any Xlib routines at all. Shared memory pixmaps can +only be supported when the X server can use regular virtual memory for +pixmap data; if the pixmaps are stored in some magic graphics hardware, your +application will not be able to share them with the server. Xdpyinfo(1) +doesn't print this particular nugget of information. + + + + +HOW TO USE THE SHARED MEMORY EXTENSION + +Code which uses the shared memory extension must include a number of header +files: + + + +#include <X11/Xlib.h> /* of course */ +#include <sys/ipc.h> +#include <sys/shm.h> +#include <X11/extensions/XShm.h> + + + +Of course, if the system you are building on does not support shared +memory, the file XShm.h may not be present. You may want to make +liberal use of #ifdefs. + + + +Any code which uses the shared memory extension should first check to see +that the server provides the extension. You could always be running over +the net, or in some other environment where the extension will not work. +To perform this check, call either + + + + + Status XShmQueryExtension + Display *display + + + + +or + + + + + Status XShmQueryVersion + Display *display + int *major + int *minor + Bool *pixmaps + + + + +Where "display" is, of course, the display on which you are running. If +the shared memory extension may be used, the return value from either +function will be True; otherwise your program should operate using +conventional Xlib calls. When the extension is available, +\fCXShmQueryVersion\fP also returns "major" and "minor" which are the +version numbers of the extension implementation, and "pixmaps" which is +True iff shared memory pixmaps are supported. + + + + +USE OF SHARED MEMORY XIMAGES + +The basic sequence of operations for shared memory XImages is as follows: + + + + + +Create the shared memory XImage structure + + + + +Create a shared memory segment to store the image data + + + + +Inform the server about the shared memory segment + + + + +Use the shared memory XImage, much like a normal one. + + + + + +To create a shared memory XImage, use: + + + + + XImage *XShmCreateImage + Display *display + Visual *visual + unsigned int depth + int format + char *data + XShmSegmentInfo *shminfo + unsigned int width + unsigned int height + + + + +Most of the arguments are the same as for XCreateImage; I will not go +through them here. Note, however, that there are no "offset", "bitmap_pad", +or "bytes_per_line" arguments. These quantities will be defined by the +server itself, and your code needs to abide by them. Unless you have already +allocated the shared memory segment (see below), you should pass in NULL for +the "data" pointer. + + + +There is one additional argument: "shminfo", which is a pointer to a +structure of type XShmSegmentInfo. You must allocate one of these +structures such that it will have a lifetime at least as long as that of +the shared memory XImage. There is no need to initialize this structure +before the call to XShmCreateImage. + + + +The return value, if all goes well, will be an XImage structure, which you +can use for the subsequent steps. + + + +The next step is to create the shared memory segment. This is +best done after the creation of the XImage, since you need to make use of +the information in that XImage to know how much memory to allocate. To +create the segment, you need a call like: + + + + +shminfo.shmid = shmget (IPC_PRIVATE, + image->bytes_per_line * image->height, IPC_CREAT|0777); + + + +(assuming that you have called your shared memory XImage "image"). You +should, of course, follow the Rules and do error checking on all of these +system calls. Also, be sure to use the bytes_per_line field, not the width +you used to create the XImage as they may well be different. + + + +Note that the shared memory ID returned by the system is stored in the +shminfo structure. The server will need that ID to attach itself to the +segment. + + + +Also note that, on many systems for security reasons, the X server +will only accept to attach to the shared memory segment if it's +readable and writeable by "other". On systems where the X server is +able to determine the uid of the X client over a local transport, the +shared memory segment can be readable and writeable only by the uid of +the client. + + + +Next, attach this shared memory segment to your process: + + + +shminfo.shmaddr = image->data = shmat (shminfo.shmid, 0, 0); + + + +The address returned by shmat should be stored in *both* the XImage +structure and the shminfo structure. + + + +To finish filling in the shminfo structure, you need to decide how you want +the server to attach to the shared memory segment, and set the "readOnly" +field as follows. Normally, you would code: + + +shminfo.readOnly = False; + + + +If you set it to True, the server will not be able to write to this +segment, and thus XShmGetImage calls will fail. + + + +Finally, tell the server to attach to your shared memory segment with: + + + +Status XShmAttach (display, shminfo); + + + +If all goes well, you will get a non-zero status back, and your XImage is +ready for use. + + + +To write a shared memory XImage into an X drawable, use XShmPutImage: + + + + + Status XShmPutImage + Display *display + Drawable d + GC gc + XImage *image + int src_x + int src_y + int dest_x + int dest_y + unsigned int width + unsigned int height + bool send_event + + + + +The interface is identical to that of XPutImage, so I will spare my fingers +and not repeat that documentation here. There is one additional parameter, +however, called "send_event". If this parameter is passed as True, the +server will generate a "completion" event when the image write is complete; +thus your program can know when it is safe to begin manipulating the shared +memory segment again. + + + +The completion event has type XShmCompletionEvent, which is defined as the +following: + + + +typedef struct { + int type; /* of event */ + unsigned long serial; /* # of last request processed */ + Bool send_event; /* true if came from a SendEvent request */ + Display *display; /* Display the event was read from */ + Drawable drawable; /* drawable of request */ + int major_code; /* ShmReqCode */ + int minor_code; /* X_ShmPutImage */ + ShmSeg shmseg; /* the ShmSeg used in the request */ + unsigned long offset; /* the offset into ShmSeg used */ +} XShmCompletionEvent; + + + +The event type value that will be used can be determined at run time with a +line of the form: + + + +int CompletionType = XShmGetEventBase (display) + ShmCompletion; + + + +If you modify the shared memory segment before the arrival of the +completion event, the results you see on the screen may be inconsistent. + + + +To read image data into a shared memory XImage, use the following: + + + + + Status XShmGetImage + Display *display + Drawable d + XImage *image + int x + int y + unsigned long plane_mask + + + + +Where "display" is the display of interest, "d" is the source drawable, +"image" is the destination XImage, "x" and "y" are the offsets within +"d", and "plane_mask" defines which planes are to be read. + + + +To destroy a shared memory XImage, you should first instruct the server to +detach from it, then destroy the segment itself, as follows: + + + +XShmDetach (display, shminfo); +XDestroyImage (image); +shmdt (shminfo.shmaddr); +shmctl (shminfo.shmid, IPC_RMID, 0); + + + + + +USE OF SHARED MEMORY PIXMAPS + +Unlike X images, for which any image format is usable, the shared memory +extension supports only a single format (i.e. XYPixmap or ZPixmap) for the +data stored in a shared memory pixmap. This format is independent of the +depth of the image (for 1-bit pixmaps it doesn't really matter what this +format is) and independent of the screen. Use XShmPixmapFormat to get the +format for the server: + + + + + int XShmPixmapFormat + Display *display + + + + +If your application can deal with the server pixmap data format (including +bits-per-pixel et al.), create a shared memory segment and "shminfo" +structure in exactly the same way as is listed above for shared memory +XImages. While it is, not strictly necessary to create an XImage first, +doing so incurs little overhead and will give you an appropriate +bytes_per_line value to use. + + + +Once you have your shminfo structure filled in, simply call: + + + + + Pixmap XShmCreatePixmap + Display *display + Drawable d + char *data + XShmSegmentInfo *shminfo + unsigned int width + unsigned int height + unsigned int depth + + + + +The arguments are all the same as for XCreatePixmap, with two additions: +"data" and "shminfo". The second of the two is the same old shminfo +structure that has been used before. The first is the pointer to the shared +memory segment, and should be the same as the shminfo.shmaddr field. I am +not sure why this is a separate parameter. + + + +If everything works, you will get back a pixmap, which you can manipulate in +all of the usual ways, with the added bonus of being able to tweak its +contents directly through the shared memory segment. Shared memory pixmaps +are destroyed in the usual manner with XFreePixmap, though you should detach +and destroy the shared memory segment itself as shown above. + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/sync.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/sync.xml new file mode 100644 index 0000000000000000000000000000000000000000..afb07838c55ab1d0c76df0aa6b024f6235382941 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/sync.xml @@ -0,0 +1,1274 @@ + + %defs; +]> + + + + + + + + X Synchronization Extension Protocol + X Consortium Standard + + + TimGlauert + + Olivetti Research + MultiWorks + + + + Dave + Carver + + Digital Equipment Corporation + MIT/Project Athena + + + + Jim + Gettys + + Digital Equipment Corporation + Cambridge Research Laboratory + + + + David + P. + Wiggins + X Consortium, Inc. + + + James + Jones + NVIDIA Corporation + + + X Version 11, Release &fullrelvers; + Version 3.1 + 1991 + Olivetti Research Limited, Cambridge England + Digital Equipment Corporation, Maynard, Massachusetts + X Consortium + + 2010NVIDIA Corporation + + + +Permission to use, copy, modify, and distribute this documentation for any +purpose and without fee is hereby granted, provided that the above +copyright notice appear in all copies. Olivetti, Digital, MIT, the +X Consortium, and NVIDIA make no representations about the suitability for +any purpose of the information in this document. This documentation is +provided as is without express or implied warranty. + + + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files +(the "Software"), to deal in the Software without +restriction, including without limitation the rights to use, copy, +modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished +to do so, subject to the following conditions: + + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY +KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO +EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +Except as contained in this notice, the name of the X Consortium shall +not be used in advertising or otherwise to promote the sale, use or other +dealings in this Software without prior written authorization from the X +Consortium. + + + + + +Synchronization Protocol + +The core X protocol makes no guarantees about the relative order of execution +of requests for different clients. This means that any synchronization between +clients must be done at the client level in an operating system-dependent and +network-dependent manner. Even if there was an accepted standard for such +synchronization, the use of a network introduces unpredictable delays between +the synchronization of the clients and the delivery of the resulting requests +to the X server. + + + +The core X protocol also makes no guarantees about the time at which requests +are executed, which means that all clients with real-time constraints must +implement their timing on the host computer. Any such timings are subject to +error introduced by delays within the operating system and network and are +inefficient because of the need for round-trip requests that keep the client +and server synchronized. + + + +The synchronization extension provides primitives that allow synchronization +between clients to take place entirely within the X server. This removes any +error introduced by the network and makes it possible to synchronize clients +on different hosts running different operating systems. This is important for +multimedia applications, where audio, video, and graphics data streams are +being synchronized. The extension also provides internal timers within the +X server to which client requests can be synchronized. This allows simple +animation applications to be implemented without any round-trip requests and +makes best use of buffering within the client, network, and server. + + + +Description + +The mechanism used by this extension for synchronization within the X +server is to block the processing of requests from a client until a +specific synchronization condition occurs. When the condition occurs, the +client is released and processing of requests continues. Multiple clients +may block on the same condition to give inter-client synchronization. +Alternatively, a single client may block on a condition such as an animation +frame marker. + + + +The extension adds Counter, Alarm, +and Fence to the set of resources managed by the +server. A counter has a 64-bit integer value that may be increased or +decreased by client requests or by the server internally. A client can block +by sending an Await request that waits until one of a set of synchronization +conditions, called TRIGGERs, becomes TRUE. Alarms generate events when +counter values go through a specified transition. A fence has two possible +states: triggered and not triggered. Client requests can put the fence in +either of these states. A client can block until one of a set of fences +becomes triggered by sending an AwaitFence request. Fences are bound to a +particular screen at creation time. + + + +The CreateCounter request allows a client to create a +Counter that can be changed by explicit +SetCounter and ChangeCounter +requests. These can be used to implement synchronization between different +clients. + + + +There are some counters, called System Counters, that +are changed by the server internally rather than by client requests. The +effect of any change to a system counter is not visible until the server +has finished processing the current request. In other words, system +counters are apparently updated in the gaps between the execution of +requests rather than during the actual execution of a request. The extension +provides a system counter that advances with the server time as defined by +the core protocol, and it may also provide counters that advance with the +real-world time or that change each time the CRT screen is refreshed. +Other extensions may provide their own extension-specific system counters. + + + +The extension provides an Alarm mechanism that allows +clients to receive an event on a regular basis when a particular counter +is changed. + + + +The CreateFence request allows a client to create a +Fence that can be triggered and reset using +TriggerFence and ResetFence +requests, respectively. CreateFence takes a drawable +argument that implies which screen the fence should be created on. The +TriggerFence request changes the fence's state only +after all previous rendering commands affecting objects owned by the given +fence's screen have completed. Note that while fence objects are bound +to a screen and the simple trigger operation provided by this extension +operates at screen granularity, other extensions may add more fine-grained +trigger operations based on any number of events. The screen binding +merely establishes an upper bound for the scope of fence operations. + + + + +Types + +Please refer to the X11 Protocol specification as this document uses +syntactic conventions established there and references types defined there. + + +The following new types are used by the extension. + + +INT64: 64-bit signed integer +COUNTER: XID +VALUETYPE: {Absolute,Relative}; +TESTTYPE: {PositiveTransition,NegativeTransition, + PositiveComparison,NegativeComparison} +TRIGGER: [ + counter:COUNTER, + value-type:VALUETYPE, + wait-value:INT64, + test-type:TESTTYPE + ] +WAITCONDITION: [ + trigger:TRIGGER, + event-threshold:INT64 + ] +SYSTEMCOUNTER: [ + name:STRING8, + counter:COUNTER, + resolution:INT64 + ] +ALARM: XID +ALARMSTATE: {Active,Inactive,Destroyed} +FENCE: XID + + + +The COUNTER type defines the client-side handle on a server +Counter. The value of a counter is an INT64. + + + +The TRIGGER type defines a test on a counter that is either TRUE or FALSE. The +value of the test is determined by the combination of a test value, the value +of the counter, and the specified test-type. + + + +The test value for a trigger is calculated using the value-type and +wait-value fields when the trigger is initialized. If the value-type field +is not one of the named VALUETYPE constants, the request that initialized the +trigger will return a Value error. If the value-type +field is Absolute, the test value is given by the +wait-value field. If the value-type field is Relative, +the test value is obtained by adding the wait-value field to the value of the +counter. If the resulting test value would lie outside the range for an +INT64, the request that initialized the trigger will return a +Value error. If counter is None +and the value-type is Relative, the request that +initialized the trigger will return a Match error. If +counter is not None and does not name a valid counter, a Counter error is +generated. + + + +If the test-type is PositiveTransition, the trigger is +initialized to FALSE, and it will become TRUE when the counter changes from +a value less than the test value to a value greater than or equal to the +test value. If the test-type is NegativeTransition, +the trigger is initialize to FALSE, and it will become TRUE when the counter +changes from a value greater than the test value to a value less than or +equal to the test value. If the test-type is +PositiveComparison, the trigger is TRUE if the +counter is greater than or equal to the test value and FALSE otherwise. If the +test-type is NegativeComparison, the trigger is TRUE +if the counter is less than or equal to the test value and FALSE otherwise. +If the test-type is not one of the named TESTTYPE constants, the request that +initialized the trigger will return a Value error. A trigger with a counter +value of None and a valid test-type is always TRUE. + + + +The WAITCONDITION type is simply a trigger with an associated event-threshold. +The event threshold is used by the Await request to +decide whether or not to generate an event to the client after the trigger has +become TRUE. By setting the event-threshold to an appropriate value, it is +possible to detect the situation where an Await request +was processed after the TRIGGER became TRUE, which usually indicates that +the server is not processing requests as fast as the client expects. + + + +The SYSTEMCOUNTER type provides the client with information about a +SystemCounter. The name field is the textual name of +the counter that identifies the counter to the client. The counter field +is the client-side handle that should be used in requests that require a +counter. The resolution field gives the approximate step size of the system +counter. This is a hint to the client +that the extension may not be able to resolve two wait conditions with test +values that differ by less than this step size. A microsecond clock, for +example, may advance in steps of 64 microseconds, so a counter based on this +clock would have a resolution of 64. + + + +The only system counter that is guaranteed to be present is called SERVERTIME, +which counts milliseconds from some arbitrary starting point. The least +significant 32 bits of this counter track the value of Time used by the +server in Events and Requests. Other system counters may be provided by +different implementations of the extension. The X Consortium will maintain a +registry of system counter names to avoid collisions in the name space. + + + +An ALARM is the client-side handle on an Alarm resource. + + + +The FENCE type defines the client-side handle on a server +Fence. A fence can only be in one of two states, +represented by a BOOL. If the value is TRUE, the fence is in the triggered +state. Otherwise, the fence is in the not triggered state. + + + + + +Errors + + + + Counter + + +This error is generated if the value for a COUNTER argument in a request +does not name a defined COUNTER. + + + + + Alarm + + +This error is generated if the value for an ALARM argument in a request +does not name a defined ALARM. + + + + + Fence + + +This error is generated if the value for a FENCE argument in a request +does not name a defined FENCE. + + + + + + + +Requests + + + + Initialize + + +version-major,version-minor: CARD8 +=> +version-major,version-minor: CARD8 + + + +This request must be executed before any other requests for this extension. If a +client violates this rule, the results of all SYNC requests that it issues are +undefined. The request takes the version number of the extension that the +client wishes to use and returns the actual version number being implemented +by the extension for this client. The extension may return different +version numbers to a client depending of the version number supplied by +that client. This request should be executed only once for each client +connection. + + +Given two different versions of the SYNC protocol, v1 and v2, v1 is +compatible with v2 if and only if v1.version_major = v2.version_major +and v1.version_minor <= v2.version_minor. Compatible means that the +functionality is fully supported in an identical fashion in the two versions. + + +This document describes major version 3, minor version 1 of the SYNC protocol. + + + + + ListSystemCounters + + +=> +system-counters: LISTofSYSTEMCOUNTER +Errors: Alloc + + +This request returns a list of all the system counters that are available at +the time the request is executed, which includes the system counters +that are maintained by other extensions. The list returned by this +request may change as counters are created and destroyed by other extensions. + + + + + CreateCounter + + +id: COUNTER +initial-value: INT64 +Errors: IDChoice,Alloc + + +This request creates a counter and assigns the specified id to it. The counter +value is initialized to the specified initial-value and there are no clients +waiting on the counter. + + + + + DestroyCounter + + +counter: COUNTER +Errors: Counter,Access + + +This request destroys the given counter and sets the counter fields for all +triggers that specify this counter to None. All clients +waiting on the counter are released and a CounterNotify +event with the destroyed field set to TRUE is sent to each waiting client, +regardless of the event-threshold. All alarms specifying the counter become +Inactive and an AlarmNotify +event with a state field of Inactive is generated. A +counter is destroyed automatically when the connection to the creating client +is closed down if the close-down mode is Destroy. An +Access error is generated if counter is a system +counter. A Counter error is generated if counter does +not name a valid counter. + + + + + QueryCounter + + +counter: COUNTER +=> +value: INT64 +Errors: Counter + + +This request returns the current value of the given counter or a generates +Counter error if counter does not name a valid counter. + + + + + Await + + +wait-list: LISTofWAITCONDITION +Errors: Counter,Alloc,Value + + +When this request is executed, the triggers in the wait-list are initialized +using the wait-value and value-type fields, as described in the definition of +TRIGGER above. The processing of further requests for the client is blocked +until one or more of the triggers becomes TRUE. This may happen immediately, +as a result of the initialization, or at some later time, as a result of +a subsequent SetCounter, +ChangeCounter or +DestroyCounter request. + + +A Value error is generated if wait-list is empty. + + +When the client becomes unblocked, each trigger is checked to determine +whether a CounterNotify event should be generated. +The difference between the counter and the test value is calculated by +subtracting the test value from the value of the counter. If the test-type +is PositiveTransition or +PositiveComparison, a +CounterNotify event is generated if the difference is +at least event-threshold. If the test-type is +NegativeTransition or +NegativeComparison, a +CounterNotify event is generated if the difference +is at most event-threshold. If the difference lies outside the range for an +INT64, an event is not generated. + + +This threshold check is made for each trigger in the list and a +CounterNotify event is generated for every trigger for +which the check succeeds. The check for +CounterNotify events is performed even if one of the +triggers is TRUE when the request is first executed. Note that a +CounterNotify event may be generated for a trigger +that is FALSE if there are multiple triggers in the request. A +CounterNotify event with the destroyed flag set to +TRUE is always generated if the counter for one of the triggers is +destroyed. + + + + + ChangeCounter + + +counter: COUNTER +amount: INT64 +Errors: Counter,Access,Value + + +This request changes the given counter by adding amount to the current +counter value. If the change to this counter satisfies a trigger for which a client +is waiting, that client is unblocked and one or more +CounterNotify events may be generated. If the change to +the counter satisfies the trigger for an alarm, an +AlarmNotify event is generated and the +alarm is updated. An Access error is generated if +counter is a system counter. A Counter error is +generated if counter does not name a valid counter. If the resulting value +for the counter would be outside the range for an INT64, a +Value error is generated and the counter is not changed. + + +It should be noted that all the clients whose triggers are satisfied by this +change are unblocked, so this request cannot be used to implement mutual +exclusion. + + + + + SetCounter + + +counter: COUNTER +value: INT64 +Errors: Counter,Access + + +This request sets the value of the given counter to value. The effect is +equivalent to executing the appropriate ChangeCounter request to change +the counter value to value. An Access error is generated if counter names a +system counter. A Counter error is generated if counter does not name a valid +counter. + + + + + CreateAlarm + + +id: ALARM +values-mask: CARD32 +values-list: LISTofVALUE +left">Errors: IDChoice,Counter,Match,Value,Alloc + + +This request creates an alarm and assigns the identifier id to it. The +values-mask and values-list specify the attributes that are to be explicitly +initialized. The attributes for an Alarm and their defaults are: + + + + + + + + + + + Attribute + Type + Default + + + + + trigger + TRIGGER + counter + None + + + + + value-type + Absolute + + + + + value + 0 + + + + + test-type + PositiveComparison + + + delta + INT64 + 1 + + + events + BOOL + TRUE + + + + + +The trigger is initialized as described in the definition of TRIGGER, with an +error being generated if necessary. + + +If the counter is None, the state of the alarm is set +to Inactive, else it is set to Active. + + +Whenever the trigger becomes TRUE, either as a result of this request or as the +result of a SetCounter, +ChangeCounter, DestroyCounter, or +ChangeAlarm request, an +AlarmNotify event is generated and the alarm is +updated. The alarm is updated by repeatedly adding delta to the value of the +trigger and reinitializing it until it becomes FALSE. If this update would +cause value to fall outside the range for an INT64, or if the counter +value is None, or if the delta is 0 and test-type +is PositiveComparison or +NegativeComparison, no change is made to value and +the alarm state is changed to Inactive before the +event is generated. No further events are generated by an +Inactive alarm until a ChangeAlarm +or DestroyAlarm request is executed. + + +If the test-type is PositiveComparison or +PositiveTransition and delta is less than zero, or +if the test-type is NegativeComparison or +NegativeTransition and delta is greater than zero, +a Match error is generated. + + +The events value enables or disables delivery of +AlarmNotify events +to the requesting client. The alarm keeps a separate event flag for +each client so that other clients may select to receive events from this +alarm. + + +An AlarmNotify event is always generated at some time +after the execution of a CreateAlarm request. This +will happen immediately if the trigger is TRUE, or it will happen later +when the trigger becomes TRUE or the Alarm is destroyed. + + + + + ChangeAlarm + + +id: ALARM +values-mask: CARD32 +values-list: LISTofVALUE +Errors: Alarm,Counter,Value,Match + + +This request changes the parameters of an Alarm. All of the parameters +specified for the CreateAlarm request may be changed +using this request. The trigger is reinitialized and an +AlarmNotify event is generated if appropriate, as +explained in the description of the CreateAlarm request. + + +Changes to the events flag affect the event delivery to the requesting +client only and may be used by a client to select or deselect event delivery +from an alarm created by another client. + + +The order in which attributes are verified and altered is server-dependent. +If an error is generated, a subset of the attributes may have been altered. + + + + + DestroyAlarm + + +alarm: ALARM +Errors: Alarm + + +This request destroys an alarm. An alarm is automatically destroyed when the +creating client is closed down if the close-down mode is +Destroy. When an alarm is destroyed, an +AlarmNotify event is generated with a state value of +Destroyed. + + + + + QueryAlarm + + +alarm: ALARM +=> +trigger: TRIGGER +delta: INT64 +events: ALARMEVENTMASK +state: ALARMSTATE +Errors: Alarm + + This request retrieves the current parameters for an Alarm. + + + + SetPriority + + +client-resource: XID +priority: INT32 +Errors: Match + + +This request changes the scheduling priority of the client that created +client-resource. If client-resource is None, then +the priority for the client making the request is changed. A +Match error is generated if client-resource is not +None and does not name an existing resource in the +server. For any two priority values, A and B, A is higher priority if +and only if A is greater than B. + + +The priority of a client is set to 0 when the initial client connection is + made. + + +The effect of different client priorities depends on the particular +implementation of the extension, and in some cases it may have no effect at +all. However, the intention is that higher priority clients will have +their requests executed before those of lower priority clients. + + +For most animation applications, it is desirable that animation clients be +given priority over nonrealtime clients. This improves the smoothness of the +animation on a loaded server. Because a server is free to implement very strict +priorities, processing requests for the highest priority client to the +exclusion of all others, it is important that a client that may potentially +monopolize the whole server, such as an animation that produces continuous +output as fast as it can with no rate control, is run at low rather than high +priority. + + + + + GetPriority + + +client-resource: XID +=> +priority: INT32 +Errors: Match + + +This request returns the scheduling priority of the client that created +client-resource. If client-resource is None, then the +priority for the client making the request is returned. A +Match error is generated if client-resource is +not None and does not name an existing resource in the +server. + + + + + CreateFence + + +drawable: DRAWABLE +id: FENCE +initially-triggered: BOOL +Errors: IDChoice,Alloc + + +This request creates a fence on the screen associated with drawable and +assigns the specified id to it. The fence is in the triggered state iff +initially-triggered is TRUE. There are no clients waiting on the fence. + + + + + TriggerFence + + +fence: FENCE +Errors: Fence + + +This request puts the given fence in the triggered state after all rendering +from previous requests that affects resources owned by the fence's screen has +completed. This includes requests from other clients if those requests have +been dispatched. This request has no visible effects if the fence was already +in the triggered state. A Fence error is generated if +fence does not name a valid fence. + + +Note that the given fence's state is not necessarily directly modified by this +request. The state change need only be queued to occur after the required +rendering has completed. Clients should take care to not assume the fence will +be in the triggered state in subsequent requests, such as those that operate +on the given fence immediately. AwaitFence should first +be issued if subsequent requests require the fence to be in the triggered +state. + + + + + ResetFence + + +fence: FENCE +Errors: Fence,Match + + +This request immediately puts the given fence in the not triggered state. +A Match error is generated if the fence is not in the +triggered state. A Fence error is generated if fence +does not name a valid fence. + + +See the warnings above regarding TriggerFence's delayed +effect. In particular, a TriggerFence request +immediately followed by a ResetFence request is likely +to result in a Match error. An +AwaitFence request should be issued between the two. + + + + + DestroyFence + + +fence: FENCE +Errors: Fence + + +This request destroys the given fence. All clients waiting on this fence are +released. A fence is destroyed automatically when the connection to the client +that created the fence is closed if the close-down mode is +DestroyAll. A Fence error is +generated if fence does not name a valid fence. + + + + + QueryFence + + +fence: FENCE +=> +triggered: BOOL +Errors: Fence + + +This request returns TRUE if the given fence is triggered, or FALSE if it +is not triggered. A Fence error is generated if +fence does not name a valid fence. + + + + + AwaitFence + + +fence-list: LISTofFENCE +Errors: Fence,Alloc + + +When this request is executed, the processing of further requests for the +client is blocked until one or more of the fences in fence-list reaches the +triggered state. If any of the fences are already in the triggered state, +request processing resumes immediately. A Fence error +is generated if any member of fence-list does not name a valid fence. + + + + + + + +Events + + + + CounterNotify + + +counter: COUNTER +wait-value: INT64 +counter-value: INT64 +time: TIME +count: CARD16 +destroyed: BOOL + + +CounterNotify events may be generated when a client +becomes unblocked after an Await request has been +processed. The wait-value is the value being waited for, and counter-value +is the actual value of the counter at the time the event was generated. +The destroyed flag is TRUE if this request was generated as the result of +the destruction of the counter and FALSE otherwise. The time is the server +time at which the event was generated. + + +When a client is unblocked, all the CounterNotify +events for the Await request are generated contiguously. If count is 0, +there are no more events to follow for this request. If count is n, +there are at least n more events to follow. + + + + + AlarmNotify + + +alarm: ALARM +counter-value: INT64 +alarm-value: INT64 +state: ALARMSTATE +time: TIME + + +An AlarmNotify event is generated when an alarm is +triggered. alarm-value is the test value of the trigger in the alarm when +it was triggered, counter-value is the value of the counter that triggered +the alarm, and time is the server time at which the event was generated. +The state is the new state of the alarm. If state is +Inactive, no more events will be generated by this +alarm until a ChangeAlarm request is executed, the alarm +is destroyed, or the counter for the alarm is destroyed. + + + + + + + + +Encoding + +Please refer to the X11 Protocol Encoding document as this section uses +syntactic conventions established there and references types defined there. + +The name of this extension is "SYNC". + + +Encoding New Types + +The following new types are used by the extension. + + + +ALARM: CARD32 +ALARMSTATE: + 0 Active + 1 Inactive + 2 Destroyed +COUNTER: CARD32 +INT64: 64-bit signed integer +SYSTEMCOUNTER: + 4 COUNTER counter + 8 INT64 resolution + 2 n length of name in bytes + n STRING8 name + p pad,p=pad(n+2) +TESTTYPE: + 0 PositiveTransition + 1 NegativeTransition + 2 PositiveComparison + 3 NegativeComparison +TRIGGER: + 4 COUNTER counter + 4 VALUETYPE wait-type + 8 INT64 wait-value + 4 TESTTYPE test-type VALUETYPE: + 0 Absolute + 1 Relative +WAITCONDITION: + 20 TRIGGER trigger + 8 INT64 event threshold +FENCE: CARD32 + + + +An INT64 is encoded in 8 bytes with the most significant 4 bytes +first followed by the least significant 4 bytes. Within these 4-byte +groups, the byte ordering determined during connection setup is used. + + + + +Encoding Errors + +Counter + 1 0 Error + 1 Base + 0 code + 2 CARD16 sequence number + 4 CARD32 bad counter + 2 CARD16 minor opcode + 1 CARD8 major opcode + 21 unused +Alarm + 1 0 Error + 1 Base + 1 code + 2 CARD16 sequence number + 4 CARD32 bad alarm + 2 CARD16 minor opcode + 1 CARD8 major opcode + 21 unused +Fence + 1 0 Error + 1 Base + 2 code + 2 CARD16 sequence number + 4 CARD32 bad fence + 2 CARD16 minor opcode + 1 CARD8 major opcode + 21 unused + + + + + +Encoding Requests + + +Initialize + 1 CARD8 major opcode + 1 0 minor opcode + 2 2 request length + 1 CARD8 major version + 1 CARD8 minor version + 2 unused +=> + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 1 CARD8 major version + 1 CARD8 minor version + 2 unused + 20 unused + +ListSystemCounters + 1 CARD8 major opcode + 1 1 minor opcode + 2 1 request length +=> + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 4 INT32 list length + 20 unused + 4n list of SYSTEMCOUNTER system counters + +CreateCounter + 1 CARD8 major opcode + 1 2 minor opcode + 2 4 request length + 4 COUNTER id + 8 INT64 initial value + +DestroyCounter + 1 CARD8 major opcode + 1 6 minor opcodeA previous version of this document gave an incorrect minor opcode + 2 2 request length + 4 COUNTER counter +=> + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 8 INT64 counter value + 16 unused + +Await + 1 CARD8 major opcode + 1 7 minor opcodeA previous version of this document gave an incorrect minor opcode. + 2 1 + 7*n request length + 28n LISTofWAITCONDITION wait conditions + +ChangeCounter + 1 CARD8 major opcode + 1 4 minor opcodeA previous version of this document gave an incorrect minor opcode. + 2 4 request length + 4 COUNTER counter + 8 INT64 amount + +SetCounter + 1 CARD8 major opcode + 1 3 minor opcodeA previous version of this document gave an incorrect minor opcode. + 2 4 request length + 4 COUNTER counter + 8 INT64 value + +CreateAlarm + 1 CARD8 major opcode + 1 8 minor opcode + 2 3+n request length + 4 ALARM id + 4 BITMASK values mask + + #x00000001 counter + #x00000002 value-type + #x00000004 value + #x00000008 test-type + #x00000010 delta + #x00000020 events + + 4n LISTofVALUE values + +VALUES + 4 COUNTER counter + 4 VALUETYPE value-type + 8 INT64 value + 4 TESTTYPE test-type + 8 INT64 delta + 4 BOOL events + +ChangeAlarm + 1 CARD8 major opcode + 1 9 minor opcode + 2 3+n request length + 4 ALARM id + 4 BITMASK values mask + encodings as for CreateAlarm + 4n LISTofVALUE values + encodings as for CreateAlarm + +DestroyAlarm + 1 CARD8 major opcode + 1 11 minor opcodeA previous version of this document gave an incorrect minor opcode. + 2 2 request length + 4 ALARM alarm + +QueryAlarm + 1 CARD8 major opcode + 1 10 minor opcodeA previous version of this document gave an incorrect minor opcode. + 2 2 request length + 4 ALARM alarm +=> + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 2 reply length + 20 TRIGGER trigger + 8 INT64 delta + 1 BOOL events + 1 ALARMSTATE state + 2 unused + +SetPriority + 1 CARD8 major opcode + 1 12 minor opcode + 2 3 request length + 4 CARD32 id + 4 INT32 priority + +GetPriority + 1 CARD8 major opcode + 1 13 minor opcode + 2 1 request length + 4 CARD32 id +=> + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 4 INT32 priority + 20 unused + +CreateFence + 1 CARD8 major opcode + 1 14 minor opcode + 2 4 request length + 4 DRAWABLE drawable + 4 FENCE id + 1 BOOL initially triggered + 3 unused + +TriggerFence + 1 CARD8 major opcode + 1 15 minor opcode + 2 2 request length + 4 FENCE id + +ResetFence + 1 CARD8 major opcode + 1 16 minor opcode + 2 2 request length + 4 FENCE id + +DestroyFence + 1 CARD8 major opcode + 1 17 minor opcode + 2 2 request length + 4 FENCE id + +QueryFence + 1 CARD8 major opcode + 1 18 minor opcode + 2 2 request length + 4 FENCE id +=> + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 1 BOOL triggered + 23 unused + +AwaitFence + 1 CARD8 major opcode + 1 19 minor opcode + 2 1 + n request length + 4*n LISTofFENCE wait conditions + + + + + + +Encoding Events + + +CounterNotify + 1 Base + 0 code + 1 0 kind + 2 CARD16 sequence number + 4 COUNTER counter + 8 INT64 wait value + 8 INT64 counter value + 4 TIME timestamp + 2 CARD16 count + 1 BOOL destroyed + 1 unused + +AlarmNotify + 1 Base + 1 code + 1 1 kind + 2 CARD16 sequence number + 4 ALARM alarm + 8 INT64 counter value + 8 INT64 alarm value + 4 TIME timestamp + 1 ALARMSTATE state + 3 unused + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/tog-cup.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/tog-cup.xml new file mode 100644 index 0000000000000000000000000000000000000000..c59e7687ee13e98bb5c0ba8bf61da33c0dacf088 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/tog-cup.xml @@ -0,0 +1,564 @@ + + %defs; +]> + + + + + + Colormap Utilization Policy and Extension + X Project Team Standard + X Version 11, Release &fullrelvers; + Version 1.0 + + + Kaleb + S. + Keithley + The Open Group + + + 1986-1997The Open Group + + + + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this +software and associated documentation files (the Software), to use the +Software +without restriction, including, without limitation, the rights to copy, +modify, merge, +publish, distribute and sublicense the Software, to make, have made, +license and +distribute derivative works thereof, and to permit persons to whom the +Software is +furnished to do so, subject to the following conditions: + + +The above copyright notice and the following permission notice shall be +included in all copies of the Software: + + +THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE WARRANTIES +OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON- +INFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF, OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OF OTHER DEALINGS IN +THE SOFTWARE. + + +Except as contained in this notice, the name of The Open Group shall not be +used in +advertising or otherwise to promote the use or other dealings in this +Software without prior written authorization from The Open Group. + + +X Window System is a trademark of The Open Group. + + + + + + +Overview + +This extension has three purposes: a) to provide mechanism for a special +application (a colormap manager) to discover any special colormap +requirements, e.g. the colormap entries that are nominally reserved for +desktop colors in the MS-Windows environment and initialize the default +colormap so that it can be more easily shared; and b) to encourage colormap +sharing and reduce colormap flashing on low-end 8-bit frame buffers by +providing a policy for sharing; and c) when colormaps aren't shared, +define a behavior in the X server color allocation scheme to reduce +colormap flashing. + + + +To encourage colormap sharing and accommodate special colormap requirements +two new protocols are defined: the first provides a way to query the +server for a list of reserved colormap entries, and the second is a way +to initialize read-only (shareable) colormap entries at specific locations +in a colormap. + + + +To minimize colormap flashing when the root window's default visual is one +of GrayScale, PseudoColor, or DirectColor, and a private colormap for the +default visual is being used, a minor (but compatible) change to the +server implementation of the AllocColor and AllocNamedColor requests is +required. Where the core protocol says nothing about the pixel values +returned, when this extension is in effect, the AllocColor and AllocNamedColor +requests will first look for a matching color in the default colormap, and, +if a match is found and the same cell in the private colormap has not +already been allocated, the color will be allocated in the private colormap +at the same locaton as in the default colormap (instead of in the first +available location.) + + + + +Requests + +QueryVersion + + + + + + + + + +client_major_version: CARD16 + + + + +client_minor_version: CARD16 + + + + +=> + + + + +server_major_version: CARD16 + + + + +server_minor_version: CARD16 + + + + + + + +If supplied, the client_major_version and client_minor_version indicate +what version of the protocol the client wants the server to implement. +The server version numbers returned indicate the protocol this extension +actually supports. This might not equal the version sent by the client. +An implementation can (but need not) support more than one version +simultaneously. The server_major_version and the server_minor_version +are a mechanism to support future revisions of the TOG-CUP protocol that +may be necessary. In general, the major version would increment for +incompatible changes, and the minor version would increment for small +upward-compatible changes. Servers that support the protocol defined in +this document will return a server_major_version of one (1), and a +server_minor_version of zero (0). + + + +GetReservedColormapEntries + + + + + + + + + +screen: CARD32 + + + + +=> + + + + +entries: LISTofCOLORITEM + + + + + + + +This request returns a list of colormap entries (pixels) that are reserved +by the system, e.g. MS-Windows reserved desktop colors. This list will, at a +minimum, contain entries for the BlackPixel and WhitePixel of the specified +screen. The do-red, do-green, and do-blue elements of the COLORITEMs are +unused in this reply. + + + +Rationale: There are colormap entries (pixels) that, e.g., MS-Windows +desktop reserves as desktop colors, that should not be altered. If they +are altered then X programs will cause colormap flashing between X and +MS-Windows applications running/displaying on the same desktop. + + + +StoreColors + + + + + + + + + +cmap: COLORMAP + + + + +items: LISTofCOLORITEM + + + + +=> + + + + +items: LISTofCOLORITEM + + + + + + + +This request changes the colormap entries of the specified pixels. The +colormap entries are allocated as if by an AllocColor request. The do-red, +do-green, and do-blue elements of the COLORITEMs are unused in this request. +A boolean alloc-ok element (a bit) is returned indicating whether the +particular pixel was successfully allocated or not. If successfully +allocated the RGB and pixel are returned. + + + +A Value error is generated if a pixel is not a valid index into cmap. A +BadMatch error is generated if if cmap does not belong to a GrayScale, +PseudoColor, or DirectColor visual. + + + + + +Events and Errors + +No new events or errors are defined by this extension. + + + + +Changes to existing protocol. + +None. + + + + +Encoding + +The name of this extension is "TOG-CUP". + + + +The conventions used here are the same as those for the core X11 +Protocol Encoding. + + + +QueryVersion + 1 CARD8 opcode + 1 0 TOG-CUP opcode + 2 2 request length + 2 CARD16 client_major_version + 2 CARD16 client_minor_version +=> + 1 1 reply + 1 unused + 2 CARD16 sequence number + 4 0 length + 2 CARD16 server_major_version + 2 CARD16 server_minor_number + 20 unused + + + +GetReservedColormapEntries + 1 CARD8 opcode + 1 1 TOG-CUP opcode + 2 2 request length + 4 CARD32 screen +=> + 1 1 reply + 1 unused + 2 CARD16 sequence number + 4 3n length + 24 unused + 12n LISTofCOLORITEM items + + + +StoreColors + 1 CARD8 opcode + 1 2 TOG-CUP opcode + 2 2+3n request length + 4 COLORMAP cmap + 12n LISTofCOLORITEM items +=> + 1 1 reply + 1 unused + 2 CARD16 sequence number + 4 3n length + 24 unused + 12n LISTofCOLORITEM items + + + +(The definition of COLORITEM here is only for the purpose of defining the +additional alloc-ok member in the CUPStoreColors reply.) + + + + COLORITEM + 4 CARD32 pixel + 2 CARD16 red + 2 CARD16 green + 2 CARD16 blue + 1 alloc-ok + #x07 unused + #x08 alloc-ok (1 is True, 0 is False) + #xF0 unused + 1 unused + + + + +C Language Binding + + +The C functions provide direct access to the protocol and add no additional +semantics. For complete details on the effects of these functions, refer +to the appropriate protocol request, which can be derived by deleting XCup +at the start of the function. All functions that have return type Status +will return nonzero for success and zero for failure. + + + +The include file for this extension is +<X11/extensions/Xcup.h>. + + + + + Status XCupQueryVersion + Display* display + int* major_version_return + int* minor_version_return + + + + + + + display + + + +Specifies the connection to the X server. + + + + + + major_version_return + + + +Returns the major version supported by the server. + + + + + + minor_version_return + + + +Returns the minor version supported by the server. + + + + + + + +XCupQueryVersions sets major_version_return and minor_version_return to +the major and minor TOG-CUP protocol version supported by the server. If +the TOG-CUP library is compatible with the version returned by the server, +it returns nonzero. If dpy does not support the TOG-CUP extension, or if +there was an error during communication with the server, or if the server +and library protocol versions are incompatible, it returns zero. No other +XCup functions may be called before this function. If a client violates +this rule, the effects of all subsequent XCup calls that it makes are +undefined. + + + +To get the list of reserved colormap entries, use +XCupGetReservedColormapEntries. + + + + + Status XCupGetReservedColormapEntries + Display* display + int screen + XColor** colors_out + int* ncolors + + + + + + + display + + + +Specifies the connection to the X server. + + + + + + colors_out + + + +Returns the values reserved by the server. + + + + + + ncolors + + + +Returns the number of items in colors_out. + + + + + + +The XCupGetReservedColormapEntries function gets system specific colormap +entries. E.g. the MS-Windows desktop uses N colormap entries at the beginning +(0..N) and end (256-N..255) of the colormap. Use XFree to free colors_out. + + + +To allocate one or more read-only color cells with RGB values, use +XCupStoreColors. + + + + + Status XCupStoreColors + Display* display + Colormap colormap + XColor* colors_in_out + int ncolors + + + + + + + display + + + +Specifies the connection to the X server. + + + + + + colormap + + + +Specifies the colormap. + + + + + + colors_in_out + + + +Specifies and returns the values actually used in the colormap. + + + + + + ncolors + + + +Specifies the number of items in colors_in_out. + + + + + + +The XCupStoreColors function changes the colormap entries of the pixel +values specified in the pixel members of the XColor structures. The colormap +entries are allocated as if an AllocColor had been used instead, i.e. the +colors are read-only (shareable). XCupStoreColors returns the number of +colors that were successfully allocated in the colormap. + + + + + +Using the TOG-CUP extension and Colormap Utilization Policy + +The X server preallocates any hardware or desktop special colors in the +default colormap; e.g. UNIX X servers preallocate Black and White pixels. +PC X servers should also preallocate the MS-Windows desktop colors. (Note +to implementors: in the Sample Implementation special colors are allocated +in the default colormap in cfbCreateDefColormap for dumb memory framebuffers.) + + + +To minimize colormap flash an application which installs its own private +colormap should query the special colors by calling +XCupGetReservedColormapEntries, and can then store those entries (in the +proper location) in its private colormap using XCupStoreColors. + + + +Applications which allocate many colors in a screen's default colormap, e.g. +a color-cube or a gray-ramp, should allocate them with XCupStoreColors. By +using XCupStoreColors the colors will be allocated shareable (read-only) and +any other application which allocates the same color will share that color +cell. + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/xtest.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/xtest.xml new file mode 100644 index 0000000000000000000000000000000000000000..4893b883d0404e6e99916236b13a3e4f03eb062a --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xextproto/xtest.xml @@ -0,0 +1,723 @@ + + %defs; +]> + + + + + XTEST Extension Protocol + X Consortium Standard + + + KieronDrake + UniSoft Ltd. + + + X Version 11, Release &fullrelvers; + Version 2.2 + 1992UniSoft Group Ltd. + 19921994X Consortium + + + +Permission to use, copy, modify, and distribute this documentation for any +purpose and without fee is hereby granted, provided that the above copyright +notice and this permission notice appear in all copies. UniSoft makes no +representations about the suitability for any purpose of the information in +this document. This documentation is provided "as is" without express or +implied warranty. + + + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + + + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + + + +THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + + +Except as contained in this notice, the name of the X Consortium shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from the X Consortium. + + + + + + +Overview + +This extension is a minimal set of client and server extensions +required to completely test the X11 server with no user intervention. + + + +This extension is not intended to support general journaling and +playback of user actions. This is a difficult area [XTrap, 89] as it attempts +to synchronize synthetic user interactions with their effects; it is at the +higher level of dialogue recording/playback rather than at the strictly lexical +level. We are interested only in the latter, simpler, case. A more detailed +discussion and justification of the extension functionality is given in +[Drake, 91]. + + + +We are aiming only to provide a minimum set of facilities that +solve immediate testing and validation problems. The testing extension +itself needs testing, where possible, and so should be as simple as possible. + + + +We have also tried to: + + + + + +Confine the extension to an appropriate high level within the server +to minimize portability problems. In practice this means that the extension +should be at the DIX level or use the DIX/DDX interface, or both. This +has effects, in particular, on the level at which "input synthesis" +can occur. + + + + +Minimize the changes required in the rest of the server. + + + + +Minimize performance penalties on normal server operation. + + + + + + +Description + +The functions provided by this extension fall into two groups: + + + + + Client Operations + + +These routines manipulate otherwise hidden client-side behavior. The +actual implementation will depend on the details of the actual language +binding and what degree of request buffering, GContext caching, and so on, is +provided. +In the C binding, defined in "XTEST Extension Library", routines are +provided to access the internals of two opaque data structures +-- GCs +and +Visuals -- +and to discard any requests pending within the +output buffer of a connection. The exact details can be expected to differ for +other language bindings. + + + + + Server Requests + + +The first of these requests is similar to that provided in most +extensions: it allows a client to specify a major and minor version +number to the server and for the server to respond with major and minor +versions of its own. The remaining two requests allow the following: + + + + + +Access to an otherwise "write-only" server resource: the cursor +associated with a given window + + + + +Perhaps most importantly, limited synthesis of input device events, +almost as if a cooperative user had moved the pointing device +or pressed a key or button. + + + + + + + + + + +Types + +The following types are used in the request and event definitions in +subsequent sections: + + + + + + + + + +FAKE_EVENT_TYPE +{ KeyPress, +KeyRelease, +MotionNotify, +ButtonPress, +ButtonRelease } + + + + + + + FAKE_EVENT + [type: FAKE_EVENT_TYPE, + + + + detail: BYTE, + + + + time: TIME, + + + + root: WINDOW, + + + + rootX, rootY: INT16] + + + + + + +CURSOR { CurrentCursor, None } +or a cursor as defined by the X11 Protocol. + + + + + +Client Operations + + +These are abstract definitions of functionality. They refer to client-side +objects such as "GC" and "VISUAL" that are quoted to +denote their abstract nature. Concrete versions of these functions are +defined only for particular language bindings. In some circumstances +a particular language binding may not implement the relevant abstract +type or may provide it as a transparent, rather than opaque, type, with +the result that the corresponding function does not make sense or is +not required, respectively. + + + +XTestSetGContextOfGC + + + + + + + + +gc: "GC" + + + + +gid: GCONTEXT + + + + + + + +Sets the GCONTEXT within the "GC" gc to have +the value specified by gid. + + + +XTestSetVisualIDOfVisual + + + + + + + + +visual: "VISUAL" + + + + +visualid: VISUALID + + + + + + + +Sets the VISUALID within the "VISUAL" visual to have +the value specified by visualid. + + + +XTestDiscard + + + + + + + + +dpy: "CONNECTION" + + + + +=> + + + + +status: BOOL + + + + + + + +Discards any requests that are present in the request buffer associated with +the "CONNECTION" dpy. +The status returned is +True +if there were one or more requests +in the buffer and +False +otherwise. + + + + +Server Requests + +XTestGetVersion + + + + + + + + +clientMajorVersion: CARD16 + + + + +clientMinorVersion: CARD16 + + + + + => + + + + +serverMajorVersion: CARD16 + + + + +serverMinorVersion: CARD16 + + + + +Errors: Length + + + + + + + + +This request can be used to ensure that the server version of the XTEST +extension is usable by the client. This document defines major version two +(2), minor version one (1). + + + +XTestCompareCursor + + + + + + + + +window: WINDOW + + + + +cursor-id: CURSOR or +CurrentCursor +or +None + + + + +=> + + + + +same: BOOL + + + + +Errors: +Window, +Length, +Cursor + + + + + + + +This request looks up the cursor associated with the window and +compares it with either the null cursor if cursor-id is +None , +or the current cursor (that is, the one being displayed), +or the cursor whose ID is cursor-id, and returns +the result of the comparison in same. + + + +XTestFakeInput + + + + + + + + +events: LISTofFAKE_EVENT + + + + +Errors: +Window, +Length, +Alloc, +Value + + + + + + + +This request simulates the limited set of core protocol +events within the set FAKE_EVENT_TYPE. Only the following event fields, +defined in FAKE_EVENT, are interpreted: + + + + + + type + + + +This must be one of +KeyPress, +KeyRelease, +MotionNotify, +ButtonPress, +or +ButtonRelease, +or else a +Value +error occurs. + + + + + + detail + + + +For key events, this field is interpreted as the physical keycode. +If the keycode is less than min-keycode or greater than max-keycode, +as returned in the connection setup, then a +Value +error occurs. +For button events, this field is interpreted as the physical (or core) button, +meaning it will be mapped to the corresponding logical button according to +the most recent +SetPointerMapping +request. +If the button number is less than one or greater than the number of physical +buttons, then a +Value +error occurs. +For motion events, if this field is +True , +then rootX and rootY +are relative distances from the current pointer location; if this field is +False, +then they are absolute positions. + + + + + + time + + + +This is either +CurrentTime +(meaning no delay) +or the delay in milliseconds that the server should wait before +simulating this event. No other requests from this client will be +processed until this delay, if any, has expired and subsequent processing +of the simulated event has been completed. + + + + + + root + + + +In the case of motion events this field is the ID of the root window on +which the new motion is to take place. If +None +is specified, the root window of the screen the pointer is currently on +is used instead. +If this field is not a valid window, then a +Window +error occurs. + + + + + + rootX & + rootY + + + +In the case of motion events these fields indicate relative distance or +absolute pointer coordinates, according to the setting of detail. +If the specified coordinates are off-screen, the closest on-screen +coordinates will be substituted. + + + + + + +When the simulated event(s) are processed, they cause event propagation, +passive grab activation, and so on, just as if the corresponding input device +action had occurred. However, motion events might not be recorded in the +motion history buffer. + + + +For the currently supported event types, the event list must have length one, +otherwise a +BadLength +error occurs. + + + +XTestGrabControl + + + + + + + + +impervious: BOOL + + + + + + + +If impervious is +True, +then the executing client becomes impervious to server grabs; +that is, it can continue executing requests even if another client +grabs the server. +If impervious is +False, +then the executing client returns to the normal state of being +susceptible to server grabs. + + + + +Encoding + +Please refer to the X11 Protocol Encoding document as this document uses +conventions established there. + + + +The name of this extension is "XTEST". + + + +New Types + +FAKE_EVENT_TYPE + 2 KeyPress + 3 KeyRelease + 4 ButtonPress + 5 ButtonRelease + 6 MotionNotify + + + +NOTE that the above values are defined to be the same as those for +the corresponding core protocol event types. + + + + +Requests + + +XTestGetVersion + 1 CARD8 opcode + 1 0 xtest opcode + 2 2 request length + 1 CARD8 client major version + 1 unused + 2 CARD16 client minor version +=> + 1 1 Reply + 1 CARD8 server major version + 2 CARD16 sequence number + 4 0 reply length + 2 CARD16 server minor version + 22 unused + + + +XTestCompareCursor + 1 CARD8 opcode + 1 1 xtest opcode + 2 3 request length + 4 WINDOW window + 4 CURSOR cursor-id + 0 None + 1 CurrentCursor +=> + 1 1 Reply + 1 BOOL cursors are the same + 2 CARD16 sequence number + 4 0 reply length + 24 unused + + + +XTestFakeInput + 1 CARD8 opcode + 1 2 xtest opcode + 2 1+(1*8) request length + 1 FAKE_EVENT_TYPE fake device event type + 1 BYTE detail: button or keycode + 2 unused + 4 TIME delay (milliseconds) + 0 CurrentTime + 4 WINDOW root window for MotionNotify + 0 None + 8 unused + 2 INT16 x position for MotionNotify + 2 INT16 y position for MotionNotify + 8 unused + + + +XTestGrabControl + 1 CARD8 opcode + 1 3 xtest opcode + 2 2 request length + 1 BOOL impervious + 3 unused + + + + + +References + +Annicchiarico, D., et al., +XTrap: The XTrap Architecture. +Digital Equipment Corporation, July 1991. + + + +Drake, K. J., +Some Proposals for a +Minimum X11 Testing Extension. +UniSoft Ltd., June 1991. + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/compositeproto.txt b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/compositeproto.txt new file mode 100644 index 0000000000000000000000000000000000000000..c1a78780fc2fa12dc9db6e6793eb074722ee90eb --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/compositeproto.txt @@ -0,0 +1,305 @@ + Composite Extension + Version 0.4 + 2007-7-3 + Keith Packard + keithp@keithp.com + Deron Johnson + deron.johnson@sun.com + +1. Introduction + +Many user interface operations would benefit from having pixel contents of +window hierarchies available without respect to sibling and antecedent +clipping. In addition, placing control over the composition of these pixel +contents into a final screen image in an external application will enable +a flexible system for dynamic application content presentation. + +2. Acknowledgements + +This small extension has been brewing for several years, contributors to +both early prototypes and the final design include: + + + Bill Haneman for motivating the ability to magnify occluded windows + with his work on accessibility + + + Carsten Haitzler for Enlightenment, the original eye-candy window + manager which demonstrated that clever hacks are an awfully + close substitute for changes in the underlying system. + + + Jim Gettys for key insights into the relationship between damage + events and per-window pixmap usage + + + Mike Harris and Owen Taylor for figuring out what to call it. + + + Deron Johnson for the Looking Glass implementation and + a prototype of the coordinate transformation mechanism. + + + Ryan Lortie for helping figure out reasonable parent clipping + semantics in the presence of manual redirected children. + +3. Architecture + +The composite extension provides three related mechanisms: + + 1. Per-hierarchy storage. The rendering of an entire hierarchy of windows + is redirected to off-screen storage. The pixels of that hierarchy + are available whenever it is viewable. Storage is automatically + reallocated when the top level window changes size. Contents beyond + the geometry of the top window are not preserved. + + 2. Automatic shadow update. When a hierarchy is rendered off-screen, + the X server provides an automatic mechanism for presenting those + contents within the parent window. The implementation is free to + make this update lag behind actual rendering operations by an + unspecified amount of time. This automatic update mechanism may + be disabled so that the parent window contents can be completely + determined by an external application. + + 3. External parent - child pointer coordinate transformation. + When a hierarchy is under manual compositing, the relationship + of coordinates within the parent to those in the child may + not be known within the X server. This mechanism provides + for redirection of these transformations through a client. + +Per-hierarchy storage may be created for individual windows or for all +children of a window. Manual shadow update may be selected by only a single +application for each window; manual update may also be selected on a +per-window basis or for each child of a window. Detecting when to update +may be done with the Damage extension. + +The off-screen storage includes the window contents, its borders and the +contents of all descendants. + +3.1 NameWindowPixmap + +Version 0.2 of the protocol introduces a mechanism for associating an XID +with the off-screen pixmap used to store these contents. This can be used +to hold onto window contents after the window is unmapped (and hence animate +it's disappearance), and also to access the border of the window, which is +not reachable through the Window ID itself. A new pixmap is created each +time the window is mapped or resized; as these events are nicely signalled +with existing events, no additional notification is needed. The old pixmap +will remain allocated as long as the Pixmap ID is left valid, it is +important that the client use the FreePixmap request when it is done with +the contents and to create a new name for the newly allocated pixmap. + +In automatic update mode, the X server is itself responsible for presenting +the child window contents within the parent. It seems reasonable, then, for +rendering to the parent window to be clipped so as not to interfere with any +child window content. In an environment with a mixture of manual and +automatic updating windows, rendering to the parent in the area nominally +occupied by a manual update window should be able to affect parent pixel +values in those areas, but such rendering should be clipped to automatic +update windows, and presumably to other manual update windows managed by +other applications. In any of these cases, it should be easy to ensure that +rendering has no effect on any non-redirected windows. + +Instead of attempting to define new clipping modes for rendering, the +Composite extension instead defines ClipByChildren rendering to the parent +to exclude regions occupied by redirected windows (either automatic or +manual). The CreateRegionFromBorderClip request can be used along with +IncludeInferiors clipping modes to restrict manual shadow updates to the +apporpriate region of the screen. Bracketing operations with +GrabServer/UngrabServer will permit atomic sequences that can update the +screen without artifact. As all of these operations are asynchronous, +network latency should not adversely affect update latency. + +3.2 Composite Overlay Window + +Version 0.3 of the protocol adds the Composite Overlay Window, which +provides compositing managers with a surface on which to draw without +interference. This window is always above normal windows and is always +below the screen saver window. It is an InputOutput window whose width +and height are the screen dimensions. Its visual is the root visual +and its border width is zero. Attempts to redirect it using the +composite extension are ignored. This window does not appear in the +reply of the QueryTree request. It is also an override redirect window. +These last two features make it invisible to window managers and other X11 +clients. The only way to access the XID of this window is via the +CompositeGetOverlayWindow request. Initially, the Composite Overlay +Window is unmapped. + +CompositeGetOverlayWindow returns the XID of the Composite Overlay +Window. If the window has not yet been mapped, it is mapped by this +request. When all clients who have called this request have terminated +their X11 connections the window is unmapped. + +Composite managers may render directly to the Composite Overlay +Window, or they may reparent other windows to be children of this +window and render to these. Multiple clients may render to the +Composite Overlay Window, create child windows of it, reshape it, and +redefine its input region, but the specific arbitration rules followed +by these clients is not defined by this specification; these policies +should be defined by the clients themselves. + +3.3 Clipping semantics redefined + +Version 0.4 of the protocol changes the semantics of clipping in the +presence of manual redirect children. In version 0.3, a parent was always +clipped to child windows, independent of the kind of redirection going on. +With version 0.4, the parent is no longer clipped to child windows which are +manually redirected. This means the parent can draw in the child region without using +IncludeInferiors mode, and (perhaps more importantly), it will receive +expose events in those regions caused by other actions. This new behaviour +is not selectable. + +4. Errors + +The composite extension does not define any new errors. + +5. Types + + UPDATETYPE { Automatic, Manual } + + CompositeCoordinate + child: Window + x, y: CARD16 + +7. Extension Initialization + +The client must negotiate the version of the extension before executing +extension requests. Otherwise, the server will return BadRequest for any +operations other than QueryVersion. + + QueryVersion + + client-major-version: CARD32 + client-minor-version: CARD32 + + -> + + major-version: CARD32 + minor-version: CARD32 + + The client sends the highest supported version to the server and + the server sends the highest version it supports, but no higher than + the requested version. Major versions changes can introduce + incompatibilities in existing functionality, minor version + changes introduce only backward compatible changes. It is + the client's responsibility to ensure that the server supports + a version which is compatible with its expectations. Servers + are encouraged to support multiple versions of the extension. + +8. Hierarchy Redirection + + RedirectWindow + + window: Window + update: UPDATETYPE + + errors: Window, Access, Match + + The hierarchy starting at 'window' is directed to off-screen + storage. 'update' specifies whether the contents are mirrored to + the parent window automatically or not. Only one client may specify + an update type of Manual, another attempt will result in an + Access error. When all clients enabling redirection terminate, + the redirection will automatically be disabled. + + The root window may not be redirected. Doing so results in a Match + error. + + RedirectSubwindows + + window: Window + update UPDATETYPE + + errors: Window, Access + + Hierarchies starting at all current and future children of window + will be redirected as in RedirectWindow. If update is Manual, + then painting of the window background during window manipulation + and ClearArea requests is inhibited. + + UnredirectWindow: + + window: Window + update: UPDATETYPE + + errors: Window, Value + + Redirection of the specified window will be terminated. If + the specified window was not selected for redirection by the + current client, or if the update type does not match the + current client's previously requested update type, a 'Value' + error results. + + UnredirectSubwindows: + + window: Window + update: UPDATETYPE + + errors: Window, Value + + Redirection of all children of window will be terminated. If + the specified window was not selected for sub-redirection by the + current client, or if the update type does not match the + current client's previously requested update type, a 'Value' + error results. + +9. Clip lists + + CreateRegionFromBorderClip + + region: Region + window: Window + + errors: Window, IDChoice + + This request creates a region containing the "usual" border clip + value; that is the area of the window clipped against siblings and + the parent. This region can be used to restrict rendering to + suitable areas while updating only a single window. The region + is copied at the moment the request is executed; future changes + to the window hierarchy will not be reflected in this region. + +10. Associating a Pixmap ID with the off-screen storage (0.2 and later) + + NameWindowPixmap + + window: Window + pixmap: Pixmap + + errors: Window, Match, IDChoice + + This request makes 'pixmap' a reference to the off-screen storage + for 'window'. This pixmap will remain allocated until freed, even + if 'window' is unmapped, reconfigured or destroyed. However, + 'window' will get a new pixmap allocated each time it is + mapped or resized, so this request will need to be reinvoked for + the client to continue to refer to the storage holding the current + window contents. Generates a 'Match' error if 'window' is not + redirected or is not visible. + +11. Composite Overlay Window (0.3 and later) + + CompositeGetOverlayWindow + + window: Window + + -> + + overlayWin: Window + + This request returns the XID of the Composite Overlay Window for + the screen specified by the argument 'window'. This request + indicates that the client wishes to use the Composite Overlay + Window of this screen. If this Composite Overlay Window has not + yet been mapped, it is mapped by this request. + + The Composite Overlay Window for a particular screen will be + unmapped when all clients who have invoked this request have + also invoked CompositeReleaseOverlayWindow for that screen. Also, + CompositeReleaseOverlayWindow for a screen will be implicitly + called when a client using the Composite Overlay Window on that + screen terminates its X11 connection. + + + CompositeReleaseOverlayWindow + + window: Window + + This request specifies that the client is no longer using the + Composite Overlay Window on the screen specified by the + argument 'window'. A screen's Composite Overlay Window is + unmapped when there are no longer any clients using it. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/damageproto.txt b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/damageproto.txt new file mode 100644 index 0000000000000000000000000000000000000000..cea232252279de50fee1087b027539c562d14883 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/damageproto.txt @@ -0,0 +1,222 @@ + The DAMAGE Extension + Protocol Version 1.1 + Document Revision 1 + 2007-01-08 + + Keith Packard + keithp@keithp.com + + Eric Anholt + eric@anholt.net + Open Source Technology Center + Intel Corporation +1. Introduction + +Monitoring the regions affected by rendering has wide-spread use, from +VNC-like systems scraping the screen to screen magnifying applications +designed to aid users with limited visual acuity. The DAMAGE extension is +designed to make such applications reasonably efficient in the face of +server-client latency. + +2. Acknowledgements + +As usual, the author had significant input from many people, in particular: + + + Havoc Pennington who designed and implemented a Damage extension + last year which was then lost to the mists of time. + + + Bill Haneman whose work on accessibility in the Gnome environment + is legendary. + + + Jim Gettys who found a way to avoid streaming damage rectangles + to the client in many cases. + + + Owen Taylor who suggested that streaming damage rectangles may + be warranted in some cases after all. + +3. Damage Model + +We call changes made to pixel contents of windows and pixmaps 'damage' +throughout this extension. Another notion of 'damage' are drawable regions +which are in need of redisplay to repair the effects of window manipulation +or other data loss. This extension doesn't deal with this second notion at +all; suggestions on a better term which isn't easily conflated with existing +notions are eagerly solicited. + +Damage accumulates as drawing occurs in the drawable. Each drawing operation +'damages' one or more rectangular areas within the drawable. The rectangles +are guaranteed to include the set of pixels modified by each operation, but +may include significantly more than just those pixels. The desire is for +the damage to strike a balance between the number of rectangles reported and +the extraneous area included. A reasonable goal is for each primitive +object drawn (line, string, rectangle) to be represented as a single +rectangle and for the damage area of the operation to be the union of these +rectangles. + +The DAMAGE extension allows applications to either receive the raw +rectangles as a stream of events, or to have them partially processed within +the X server to reduce the amount of data transmitted as well as reduce the +processing latency once the repaint operation has started. + +Damage to a window reflects both drawing within the window itself as well as +drawing within any inferior window that affects pixels seen by +IncludeInferiors rendering operations. To reduce the computational +complexity of this, the DAMAGE extension allows the server to monitor all +rendering operations within the physical target pixel storage that fall +within the bounds of the window. In a system with a single frame buffer +holding all windows, this means that damage will accumulate for all +rendering operations that lie within the visible part of the window. + +The precise reason for this architecture is to enable the Composite +extension which provides multiple pixel storage areas for the screen +contents. + +3.1 Additions in the 1.1 version of the protocol + +Damage is automatically computed by the X Server for X rendering operations, +but direct rendering extensions have allowed clients to perform rendering +outside of the control of the X Server. The 1.1 version of the protocol +added a request to allow direct rendering clients to report damage to a +drawable. Some direct rendering clients, due to architectural limitations, +always perform rendering to the root window, even in when it should be +performed to the backing pixmap in the Composite case. To provide +less-incorrect rendering in this cases, the direct rendering client should +translate its damage region to screen coordinates and report the damage against +the root window rather than the drawable. + +4. Data types + +The "Damage" object holds any accumulated damage region and reflects the +relationship between the drawable selected for damage notification and the +drawable for which damage is tracked. + +5. Errors + +Damage + A value for a DAMAGE argument does not name a defined DAMAGE. + +6. Types + + DAMAGE 32-bit value (top three bits guaranteed to be zero) + + DamageReportLevel { DamageReportRawRectangles, + DamageReportDeltaRectangles, + DamageReportBoundingBox, + DamageReportNonEmpty } + + DamageReportRawRectangles + + Delivers DamageNotify events each time the screen + is modified with rectangular bounds that circumscribe + the damaged area. No attempt to compress out overlapping + rectangles is made. + + DamageReportDeltaRectangles + + Delivers DamageNotify events each time damage occurs + which is not included in the damage region. The + reported rectangles include only the changes to that + area, not the raw damage data. + + DamageReportBoundingBox + + Delivers DamageNotify events each time the bounding + box enclosing the damage region increases in size. + The reported rectangle encloses the entire damage region, + not just the changes to that size. + + DamageReportNonEmpty + + Delivers a single DamageNotify event each time the + damage rectangle changes from empty to non-empty, and + also whenever the result of a DamageSubtract request + results in a non-empty region. + +7. Events + +DamageNotify + + level: DamageReportLevel + drawable: Drawable + damage: DAMAGE + more: Bool + timestamp: Timestamp + area: Rectangle + drawable-geometry: Rectangle + + 'more' indicates whether there are subsequent damage events + being delivered immediately as part of a larger damage region + +8. Extension Initialization + +The client must negotiate the version of the extension before executing +extension requests. Otherwise, the server will return BadRequest for any +operations other than QueryVersion. + +QueryVersion + + client-major-version: CARD32 + client-minor-version: CARD32 + + -> + + major-version: CARD32 + minor-version: CARD32 + + The client sends the highest supported version to the server and + the server sends the highest version it supports, but no higher than + the requested version. Major versions changes can introduce + incompatibilities in existing functionality, minor version + changes introduce only backward compatible changes. It is + the clients responsibility to ensure that the server supports + a version which is compatible with its expectations. Servers + are encouraged to support multiple versions of the extension. + +9. Enable Monitoring + +DamageCreate + + damage: DAMAGE + drawable: Drawable + level: DamageReportLevel + + Creates a damage object to monitor changes to Drawable + +DamageDestroy + damage: DAMAGE + + Destroys damage. + +DamageSubtract + + damage: DAMAGE + repair: Region or None + parts: Region or None + + Synchronously modifies the regions in the following manner: + + If repair is None: + + 1) if parts is not None, parts = damage + 2) damage = + + Otherwise: + + 1) tmp = damage INTERSECT repair + 2) damage = damage - tmp + 3) if parts is not None, parts = tmp + 4) Generate DamageNotify for remaining damage areas + +DamageAdd + + drawable: Drawable + region: Region + + Reports damage of the region within the given drawable. This may be + used by direct rendering clients to report damage that the server would + otherwise be unaware of. The damage region is relative to the origin + of the drawable. + + Damage posted in this way will appear in DamageNotify events as normal, + and also in server internal damage tracking (for shadow framebuffer + updates, pixmap damage, and other uses). diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/dri2proto.txt b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/dri2proto.txt new file mode 100644 index 0000000000000000000000000000000000000000..0e581714b02250ba3f5b9ecac760cc2b60bb0a47 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/dri2proto.txt @@ -0,0 +1,909 @@ + The DRI2 Extension + Version 2.0 + 2008-09-04 + + Kristian Høgsberg + krh@redhat.com + Red Hat, Inc + + +1. Introduction + +The DRI2 extension is designed to associate and access auxiliary +rendering buffers with an X drawable. + +DRI2 is a essentially a helper extension to support implementation of +direct rendering drivers/libraries/technologies. + +The main consumer of this extension will be a direct rendering OpenGL +driver, but the DRI2 extension is not designed to be OpenGL specific. +Direct rendering implementations of OpenVG, Xv, cairo and other +graphics APIs should find the functionality exposed by this extension +helpful and hopefully sufficient. + +Relation to XF86DRI + + +1.1. Acknowledgements + +Kevin E. Martin +Keith Packard +Eric Anholt +Keith Whitwell +Jerome Glisse +Ian Romanick +Michel Dänzer +Jesse Barnes + + + ⚙ ⚙ ⚙ ⚙ ⚙ ⚙ + + +2. DRI2 Concepts + + +2.1. Attachment points + +Stolen from OpenGL FBOs, I guess. + + +2.2. Kernel rendering manager + +This specification assumes a rendering architecture, where an +underlying kernel rendering manager that can provide 32 bit integer +handles to video memory buffers. These handles can be passed between +processes, which, through a direct rendering driver, submit rendering +to the kernel rendering manager, targeting and/or sourcing from these +buffers. This extension provides a means to communicate about such +buffers as associated with an X drawable. + +The details of how the direct rendering driver use the buffer names +and submit the rendering requests is outside the scope of this +specification. However, Appendix B does discuss implementation of +this specification on the Graphics Execution Manager (GEM). + + +2.3. Request ordering + +No ordering between swap buffers and X rendering. X rendering to src +buffers will block if they have a vblank pending. + + +2.4 Authentication model + +The purpose of the DRM authentication scheme is to grant access to the +kernel rendering manager buffers created by the X server if, and only +if, the client has access to the X server. This is achieved in a +three-step protocol: + + 1) The client gets a token from the kernel rendering manager + that uniquely identifies it. The token is a 32 bit integer. + + 2) The client passes the token to the X server in the + DRI2Authenticate request. This request is a round trip to + make sure the X server has received and processed the + authentication before the client starts accessing the DRM. + + 3) The X server authorizes the client by passing the token to + the kernel rendering manager. + +A kernel rendering manager can choose not to implement any +authentication and just allow access to all buffers. + + +2.5 Rendering to the X front buffer + +OpenGL allows the client to render to the front buffer, either by +using a single-buffered configuration or but explicitly setting the +draw buffer to GL_FRONT_LEFT. Not allowed! + +The client must ask for a fake front buffer, render to that and then +use DRI2CopyRegion to copy contents back and forth between the fake +front buffer and the real front buffer. When X and direct rendering +to a front buffer is interleaved, it is the responsibility of the +application to synchronize access using glXWaitGL and glXWaitX. A +DRI2 implementation of direct rendering GLX, should use these entry +points to copy contents back and forth to as necessary to ensure +consistent rendering. + +The client may also use the DRI2SwapBuffers function to request a swap +of the front and back buffers. If the display server supports it, this +operation may be preferred, since it may be easier and/or more performant +for the server to perform a simple buffer swap rather than a blit. + +2.6 Synchronizing rendering + +DRI2 provides several methods for synchronizing drawing with various events. +The protocol for these methods is based on the SGI_video_sync and +OML_sync_control GLX extensions. Using the DRI2WaitMSC request, a client +can wait for a specific frame count or divisor/remainder before continuing +its processing. With the DRI2WaitSBC request, clients can block until a given +swap count is reached (as incremented by DRI2SwapBuffers). Finally, using +DRI2SwapBuffers, clients can limit their frame rate by specifying a swap +interval using the swap interval call (currently only available through GLX) +or by using the OML swap buffers routine. + +2.7 Events + +DRI2 provides an event to indicate when a DRI2SwapBuffers request has +been completed. This can be used to throttle drawing on the client +side and tie into application main loops. + +Another event is generated when the validity of the requested buffers +changes. + + ⚙ ⚙ ⚙ ⚙ ⚙ ⚙ + + +3. Data Types + +The server side region support specified in the Xfixes extension +version 2 is used in the CopyRegion request. + + + ⚙ ⚙ ⚙ ⚙ ⚙ ⚙ + + +4. Errors + +No errors are defined by the DRI2 extension. + + + ⚙ ⚙ ⚙ ⚙ ⚙ ⚙ + +5. Events + +The only events provided by DRI2 are DRI2_BufferSwapComplete +and DRI2InvalidateBuffers. + + + ⚙ ⚙ ⚙ ⚙ ⚙ ⚙ + + +6. Protocol Types + +DRI2DRIVER { DRI2DriverDRI + DRI2DriverVDPAU } + + These values describe the type of driver the client will want + to load. The server sends back the name of the driver to use + for the screen in question. + +DRI2ATTACHMENT { DRI2BufferFrontLeft + DRI2BufferBackLeft + DRI2BufferFrontRight + DRI2BufferBackRight + DRI2BufferDepth + DRI2BufferStencil + DRI2BufferAccum + DRI2BufferFakeFrontLeft + DRI2BufferFakeFrontRight + DRI2BufferDepthStencil + DRI2BufferHiz } + + These values describe various attachment points for DRI2 + buffers. + +DRI2BUFFER { attachment: CARD32 + name: CARD32 + pitch: CARD32 + cpp: CARD32 + flags: CARD32 } + + The DRI2BUFFER describes an auxiliary rendering buffer + associated with an X drawable. 'attachment' describes the + attachment point for the buffer, 'name' is the name of the + underlying kernel buffer, + + +DRI2ATTACH_FORMAT { attachment: CARD32 + format: CARD32 } + + The DRI2ATTACH_FORMAT describes an attachment and the associated + format. 'attachment' describes the attachment point for the buffer, + 'format' describes an opaque, device-dependent format for the buffer. + + ⚙ ⚙ ⚙ ⚙ ⚙ ⚙ + + +7. Extension Initialization + +The name of this extension is "DRI2". + +┌─── + DRI2QueryVersion + client-major-version: CARD32 + client-minor-version: CARD32 + ▶ + major-version: CARD32 + minor-version: CARD32 +└─── + + The client sends the highest supported version to the server + and the server sends the highest version it supports, but no + higher than the requested version. Major versions changes can + introduce incompatibilities in existing functionality, minor + version changes introduce only backward compatible changes. + It is the clients responsibility to ensure that the server + supports a version which is compatible with its expectations. + + Backwards compatible changes included addition of new + requests, but also new value types in the DRI2CopyRegion + request. When new values are introduced, the minor version + will be increased so the client can know which values the X + server understands from the version number. + + + ⚙ ⚙ ⚙ ⚙ ⚙ ⚙ + + +8. Extension Requests + +┌─── + DRI2Connect + window: WINDOW + driverType: DRI2DRIVER + ▶ + driver: STRING + device: STRING +└─── + + Returns the driver name and device file to use for the + specified driver type for the screen associated with 'window'. + + 'type' identifies the type of driver to query for. + + 'driver' is the name of the driver to load. The client is + assumed to know where to look for the drivers and what to do + with it. + + 'device' is the filename of the DRM device file. + + If the client is not local, or the request driver type is + unknown or not available, 'driver' and 'device' will be empty + strings. We are not using an regular X + error here to indicate failure, which will allow the client + fall back to other options more easily. + + ISSUE: We could add the list of supported attachments and the + supported DRI2CopyRegion values here (just the bitmask of all + supported values). + +┌─── + DRI2Authenticate + window: WINDOW + token: CARD32 + ▶ + authenticated: CARD32 +└─── + Errors: Window + + Request that the X server authenticates 'token', allowing the + client to access the DRM buffers created by the X server on + the screen associated with 'window'. + + Authentication shouldn't fail at this point, except if an + invalid token is passed, in which case authenticated is False. + +┌─── + DRI2GetBuffers + drawable: DRAWABLE + attachments: LISTofDRI2ATTACHMENTS + ▶ + width, height: CARD32 + buffers: LISTofDRI2BUFFER +└─── + Errors: Window + + Get buffers for the provided attachment points for the given + drawable. + + If the DDX driver does not support one or more of the + specified attachment points, a Value error is generated, with + the first unsupported attachment point as the error value. + + 'width' and 'height' describes the dimensions of the drawable. + + 'buffers' is a list of DRI2BUFFER for the given DRI2 + attachment points. + +┌─── + DRI2CopyRegion + drawable: DRAWABLE + region: REGION + source: DRI2ATTACHMENT + destination: DRI2ATTACHMENT + ▶ +└─── + Errors: Window, Value + + Schedule a copy from one DRI2 buffer to another. + + The DRICopyRegion request has a reply but it is empty. The + reply is there to let the direct rendering client wait until + the server has seen the request before proceeding with + rendering the next frame. + +┌─── + DRI2SwapBuffers + drawable: DRAWABLE + target_msc: two CARD32s + divisor: two CARD32s + remainder: two CARD32s + ▶ + swap: two CARD32s +└─── + Errors: Window + + Schedule a swap of the front and back buffers with the display + server. + + Returns the swap count value when the swap will actually occur (e.g. + the last queued swap count + (pending swap count * swap interval)). + + This request is only available with protocol version 1.2 or + later. + +┌─── + DRI2GetBuffersWithFormat + drawable: DRAWABLE + attachments: LISTofDRI2ATTACH_FORMAT + ▶ + width, height: CARD32 + buffers: LISTofDRI2BUFFER +└─── + Errors: Window + + Get buffers for the provided attachment points with the specified + formats for the given drawable. + + If the DDX driver does not support one or more of the + specified attachment points or formats, a Value error is generated, + with the first unsupported attachment point as the error value. + + 'width' and 'height' describes the dimensions of the drawable. + + 'buffers' is a list of DRI2BUFFER for the given DRI2 + attachment points. + + This request is only available with protocol version 1.1 or + later. + +┌─── + DRI2GetMSC + drawable: DRAWABLE + ▶ + ust, msc, sbc: CARD64 +└─── + Errors: Window + + Get the current media stamp counter (MSC) and swap buffer count (SBC) + along with the unadjusted system time (UST) when the MSC was last + incremented. + + This request is only available with protocol version 1.2 or + later. + +┌─── + DRI2WaitMSC + drawable: DRAWABLE + target_msc: two CARD32s + divisor: two CARD32s + remainder: two CARD32s + ▶ + ust, msc, sbc: CARD64 +└─── + Errors: Window + + Blocks the client until either the frame count reaches target_msc or, + if the frame count is already greater than target_msc when the request + is received, until the frame count % divisor = remainder. If divisor + is 0, the client will be unblocked if the frame count is greater than + or equal to the target_msc. + + Returns the current media stamp counter (MSC) and swap buffer count + (SBC) along with the unadjusted system time (UST) when the MSC was last + incremented. + + This request is only available with protocol version 1.2 or + later. + +┌─── + DRI2WaitSBC + drawable: DRAWABLE + target_sbc: two CARD32s + ▶ + ust, msc, sbc: CARD64 +└─── + Errors: Window + + Blocks the client until the swap buffer count reaches target_sbc. If + the swap buffer count is already greater than or equal to target_sbc + when the request is received, this request will return immediately. + + If target_sbc is 0, this request will block the client until all + previous DRI2SwapBuffers requests have completed. + + Returns the current media stamp counter (MSC) and swap buffer count + (SBC) along with the unadjusted system time (UST) when the MSC was last + incremented. + + This request is only available with protocol version 1.2 or + later. + +┌─── + DRI2SwapInterval + drawable: DRAWABLE + interval: CARD32 + ▶ +└─── + Errors: Window + + Sets the swap interval for DRAWABLE. This will throttle + DRI2SwapBuffers requests to swap at most once per interval frames, + which is useful useful for limiting the frame rate. + +┌─── + DRI2GetParam + drawable: DRAWABLE + param: CARD32 + ▶ + is_param_recognized: BOOL + value: CARD64 +└─── + Errors: Drawable + + Get the value of a parameter. The parameter's value is looked up on + the screen associated with 'drawable'. + + Parameter names in which the value of the most significant byte is + 0 are reserved for the X server. Currently, no such parameter names + are defined. (When any such names are defined, they will be defined in + this extension specification and its associated headers). + + Parameter names in which the byte's value is 1 are reserved for the + DDX. Such names are private to each driver and shall be defined in the + respective driver's headers. + + Parameter names in which the byte's value is neither 0 nor 1 are + reserved for future use. + + Possible values of 'is_param_recognized' are true (1) and false (0). + If false, then 'value' is undefined. + + This request is only available with protocol version 1.4 or later. + + ⚙ ⚙ ⚙ ⚙ ⚙ ⚙ + +9. Extension Events + +┌─── + DRI2BufferSwapComplete + ▶ + event_type: CARD16 + drawable: CARD32 + ust: CARD64 + msc: CARD64 + sbc: CARD64 +└─── + + This event reports the status of the last DRI2SwapBuffers event to + the client. The event type should be one of DRI2_EXCHANGE_COMPLETE, + indicating a successful buffer exchange, DRI2_BLIT_COMPLETE, indicating + the swap was performed with a blit, and DRI2_FLIP_COMPLETE, indicating + a full page flip was completed. + +┌─── + DRI2InvalidateBuffers + ▶ + drawable: CARD32 +└─── + + This event is generated when the buffers the client had + requested for 'drawable' (with DRI2GetBuffers or + DRI2GetBuffersWithFormat) become inappropriate because they + don't match the drawable dimensions anymore, or a buffer swap + has been performed. + + Note that the server is only required to warn the client once + about this condition, until the client takes care of bringing + them back up-to-date with another GetBuffers request. + + ⚙ ⚙ ⚙ ⚙ ⚙ ⚙ + +10. Extension Versioning + +The DRI2 extension has undergone a number of revisions before + + 1.0: Released, but never used. Relied on a number of + constructs from the XF86DRI extension, such as a + shared memory area (SAREA) to communicate changes in + cliprects and window sizes, and + + 1.99.1: Move the swap buffer functionality into the X server, + introduce SwapBuffer request to copy back buffer + contents to the X drawable. + + 1.99.2: Rethink the SwapBuffer request as an asynchronous + request to copy a region between DRI2 buffers. Drop + CreateDrawable and DestroyDrawable, update Connect to + support different driver types and to send the + authentication group. + + 1.99.3: Drop the bitmask argument intended to indicate + presence of optional arguments for CopyRegion. + + 2.0: Awesomeness! + + 2.1: True excellence. Added DRI2GetBuffersWithFormat to allow + more flexible object creation. + + 2.2: Approaching perfection. Added requests for swapbuffers, + MSC and SBC related requests, and events. + + 2.3: Added the DRI2InvalidateBuffers event. + + 2.6: Enlightenment attained. Added the DRI2BufferHiz attachment. + + 2.7: Added the DRI2GetParam request. + +Compatibility up to 2.0 is not preserved, but was also never released. + + + ⚙ ⚙ ⚙ ⚙ ⚙ ⚙ + + +11. Relationship with other extensions + +As an extension designed to support other extensions, there is +naturally some interactions with other extensions. + + +11.1 GLX + +The GL auxiliary buffers map directly to the DRI2 buffers... eh + + +11.2 DBE + +The DBE back buffer must correspond to the DRI2_BUFFER_FRONT_LEFT +DRI2 buffer for servers that support both DBE and DRI2. + + +11.3 XvMC / Xv + +We might add a DRI2_BUFFER_YUV to do vsynced colorspace conversion +blits. Maybe... not really sure. + + + ⚙ ⚙ ⚙ ⚙ ⚙ ⚙ + + +Appendix A. Protocol Encoding + +Syntactic Conventions + +This document uses the same syntactic conventions as the core X +protocol encoding document. + + +A.1 Common Types + +┌─── + DRI2DRIVER + 0x0 DRI2DriverDRI + 0x1 DRI2DriverVDPAU +└─── + +┌─── + DRI2ATTACHMENT + 0x0 DRI2BufferFrontLeft + 0x1 DRI2BufferBackLeft + 0x2 DRI2BufferFrontRight + 0x3 DRI2BufferBackRight + 0x4 DRI2BufferDepth + 0x5 DRI2BufferStencil + 0x6 DRI2BufferAccum + 0x7 DRI2BufferFakeFrontLeft + 0x8 DRI2BufferFakeFrontRight + 0x9 DRI2BufferDepthStencil + 0xa DRI2BufferHiz +└─── + Used to encode the possible attachment points. The attachment + DRI2BufferDepthStencil is only available with protocol version 1.1 or + later. + +┌─── + DRI2BUFFER + 4 CARD32 attachment + 4 CARD32 name + 4 CARD32 pitch + 4 CARD32 cpp + 4 CARD32 flags +└─── + A DRI2 buffer specifies the attachment, the kernel memory + manager name, the pitch and chars per pixel for a buffer + attached to a given drawable. + +┌─── + DRI2ATTACH_FORMAT + 4 CARD32 attachment + 4 CARD32 format +└─── + Used to describe the attachment and format requested from the server. + This data type is only available with protocol version 1.1 or + later. + +A.2 Protocol Requests + +┌─── + DRI2QueryVersion + 1 CARD8 major opcode + 1 0 DRI2 opcode + 2 3 length + 4 CARD32 major version + 4 CARD32 minor version + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 4 CARD32 major version + 4 CARD32 minor version + 16 unused +└─── + +┌─── + DRI2Connect + 1 CARD8 major opcode + 1 1 DRI2 opcode + 2 3 length + 4 WINDOW window + 4 CARD32 driver type + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 (n+m+p+q)/4 reply length + 4 n driver name length + 4 m device name length + 16 unused + n CARD8 driver name + p unused, p=pad(n) + m CARD8 device name + q unused, q=pad(m) +└─── + +┌─── + DRI2Authenticate + 1 CARD8 major opcode + 1 2 DRI2 opcode + 2 3 length + 4 WINDOW window + 4 CARD32 authentication token + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 4 CARD32 authenticated + 20 unused +└─── + +┌─── + DRI2GetBuffers + 1 CARD8 major opcode + 1 5 DRI2 opcode + 2 3 length + 4 DRAWABLE drawable + 4 n number of attachments + 4n LISTofDRI2ATTACHMENTS attachments + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 4 CARD32 width of drawable + 4 CARD32 height of drawable + 4 CARD32 buffer count + 12 unused + 5n LISTofDRI2BUFFER buffers +└─── + +┌─── + DRI2CopyRegion + 1 CARD8 major opcode + 1 6 DRI2 opcode + 2 3 length + 4 DRAWABLE drawable + 4 REGION region + 4 DRI2ATTACHMENT source + 4 DRI2ATTACHMENT destination + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 24 unused +└─── + +┌─── + DRI2GetBuffersWithFormat + 1 CARD8 major opcode + 1 7 DRI2 opcode + 2 3 length + 4 DRAWABLE drawable + 4 n number of attachments + 8n LISTofDRI2ATTACH_FORMAT attachments and formats + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 4 CARD32 width of drawable + 4 CARD32 height of drawable + 4 CARD32 buffer count + 12 unused + 5n LISTofDRI2BUFFER buffers +└─── + +┌─── + DRI2SwapBuffers + 1 CARD8 major opcode + 1 8 DRI2 opcode + 2 8 length + 4 DRAWABLE drawable + 4 CARD32 target_msc_hi + 4 CARD32 target_msc_lo + 4 CARD32 divisor_hi + 4 CARD32 divisor_lo + 4 CARD32 remainder_hi + 4 CARD32 remainder_lo + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 4 CARD32 swap_hi + 4 CARD32 swap_lo + 20 unused +└─── + +┌─── + DRI2GetMSC + 1 CARD8 major opcode + 1 9 DRI2 opcode + 2 8 length + 4 DRAWABLE drawable + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 4 CARD32 ust_hi + 4 CARD32 ust_lo + 4 CARD32 msc_hi + 4 CARD32 msc_lo + 4 CARD32 sbc_hi + 4 CARD32 sbc_lo +└─── + +┌─── + DRI2WaitMSC + 1 CARD8 major opcode + 1 10 DRI2 opcode + 2 8 length + 4 DRAWABLE drawable + 4 CARD32 target_msc_hi + 4 CARD32 target_msc_lo + 4 CARD32 divisor_hi + 4 CARD32 divisor_lo + 4 CARD32 remainder_hi + 4 CARD32 remainder_lo + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 4 CARD32 ust_hi + 4 CARD32 ust_lo + 4 CARD32 msc_hi + 4 CARD32 msc_lo + 4 CARD32 sbc_hi + 4 CARD32 sbc_lo +└─── + +┌─── + DRI2WaitSBC + 1 CARD8 major opcode + 1 11 DRI2 opcode + 2 8 length + 4 DRAWABLE drawable + 4 CARD32 swap_hi + 4 CARD32 swap_lo + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 4 CARD32 ust_hi + 4 CARD32 ust_lo + 4 CARD32 msc_hi + 4 CARD32 msc_lo + 4 CARD32 sbc_hi + 4 CARD32 sbc_lo +└─── + +┌─── + DRI2SwapInterval + 1 CARD8 major opcode + 1 12 DRI2 opcode + 2 8 length + 4 DRAWABLE drawable + 4 CARD32 interval + ▶ +└─── + +┌─── + DRI2GetParam + 1 CARD8 major opcode + 1 13 DRI2 opcode + 2 8 length + 4 DRAWABLE drawable + 4 CARD32 param + ▶ + 1 1 Reply + 1 BOOL is_param_recognized + 2 CARD16 sequence number + 4 0 reply length + 4 CARD32 value_hi + 4 CARD32 value_lo + 16 unused +└─── + +A.3 Protocol Events + +The DRI2 extension specifies DRI2_BufferSwapComplete and +DRI2_InvalidateBuffers events. + +┌─── + DRI2_BufferSwapComplete + 1 CARD8 type + 1 CARD8 extension + 2 CARD16 sequenceNumber + 2 CARD16 event_type + 4 DRAWABLE drawable + 4 CARD32 ust_hi + 4 CARD32 ust_lo + 4 CARD32 msc_hi + 4 CARD32 msc_lo + 4 CARD32 sbc_hi + 4 CARD32 sbc_lo +└─── + + +┌─── + DRI2_InvalidateBuffers + 1 CARD8 type + 1 CARD8 extension + 2 CARD16 sequenceNumber + 4 DRAWABLE drawable + 4 CARD32 unused + 4 CARD32 unused + 4 CARD32 unused + 4 CARD32 unused + 4 CARD32 unused + 4 CARD32 unused +└─── + +A.4 Protocol Errors + +The DRI2 extension specifies no errors. + + + ⚙ ⚙ ⚙ ⚙ ⚙ ⚙ + + +Appendix B. Implementation on GEM + +Where to begin... diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/dri3proto.txt b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/dri3proto.txt new file mode 100644 index 0000000000000000000000000000000000000000..f1f74c482a1c07fa815b0a0ec10b9796371c668a --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/dri3proto.txt @@ -0,0 +1,762 @@ + The DRI3 Extension + Version 1.4 + 2021-11-30 + + Keith Packard + keithp@keithp.com + Intel Corporation + + Daniel Stone + daniels@collabora.com + Collabora + + +1. Introduction + +The DRI3 extension provides mechanisms to translate between direct +rendered buffers and X pixmaps. When combined with the Present extension, +a complete direct rendering solution for hardware-accelerated devices +such as GPUs is provided. + +The direct rendered buffers are passed across the protocol via +standard POSIX file descriptor passing mechanisms. On Linux, these +buffers are DMA-BUF objects. + +DRI3 also includes a mechanism to translate between Linux Futexes +and X Sync extension Fences. This provides a synchronization mechanism +which can be used to serialize access to shared render buffers. + +1.1. Acknowledgments + +Eric Anholt +Dave Airlie +Kristian Høgsberg +James Jones +Arthur Huillet +Louis-Francis Ratté-Boulianne +Austin Shafer + + ❄ ❄ ❄ ❄ ❄ ❄ ❄ + +2. Data Types + +The DRI3 extension uses the RandR extension Provider data type to +select among multiple GPUs on a single screen and the Sync extension +fence object to provide graphics object synchronization. + + ❄ ❄ ❄ ❄ ❄ ❄ ❄ + +4. Errors + +DRI3 defines no errors. + + ❄ ❄ ❄ ❄ ❄ ❄ ❄ + +5. Events + +DRI3 defines no events. + + ❄ ❄ ❄ ❄ ❄ ❄ ❄ + +6. Protocol Types + +SYNCOBJ { XID } + + ❄ ❄ ❄ ❄ ❄ ❄ ❄ + +7. Extension Initialization + +The name of this extension is "DRI3" + +┌─── + DRI3QueryVersion + client-major-version: CARD32 + client-minor-version: CARD32 + ▶ + major-version: CARD32 + minor-version: CARD32 +└─── + + The client sends the highest supported version to the server + and the server sends the highest version it supports, but no + higher than the requested version. Major versions changes can + introduce incompatibilities in existing functionality, minor + version changes introduce only backward compatible changes. + It is the clients responsibility to ensure that the server + supports a version which is compatible with its expectations. + + Backwards compatible changes included addition of new + requests. + + + ❄ ❄ ❄ ❄ ❄ ❄ ❄ + +8. Extension Requests + +┌─── + DRI3Open + drawable: DRAWABLE + provider: PROVIDER + ▶ + nfd: CARD8 + device: FD +└─── + Errors: Drawable, Value, Match + + This requests that the X server open the direct rendering + device associated with drawable and RandR provider. The + provider must support SourceOutput or SourceOffload. + + The file descriptor for the device is returned in + 'device'. 'nfd' will be set to one (this is strictly a + convenience for XCB which otherwise would need + request-specific information about how many file descriptors + were associated with this reply). + +┌─── + DRI3PixmapFromBuffer + pixmap: PIXMAP + drawable: DRAWABLE + size: CARD32 + width, height, stride: CARD16 + depth, bpp: CARD8 + buffer: FD +└─── + Errors: Alloc, Drawable, IDChoice, Value, Match + + Creates a pixmap for the direct rendering object associated + with 'buffer' and the screen associated with 'drawable'. + Changes to pixmap will be visible in that direct rendered + object and changes to the direct rendered object will be + visible in the pixmap. + + 'size' specifies the total size of the buffer bytes. 'width', + 'height' describe the geometry (in pixels) of the underlying + buffer. 'stride' specifies the number of bytes per scanline in + the buffer. The pixels within the buffer are not required to + be arranged in a simple linear fashion, but 'size' will be at + least 'height' * 'stride'. + + Precisely how any additional information about the buffer is + shared is outside the scope of this extension. + + If buffer cannot be used with the screen associated with + drawable, a Match error is returned. + + If depth or bpp are not supported by the screen, a Value error + is returned. + + For information on synchronization of buffer access between + the client and the X server, please see section 12. + +┌─── + DRI3BufferFromPixmap + pixmap: PIXMAP + ▶ + nfd: CARD8 + size: CARD32 + width, height, stride: CARD16 + depth, bpp: CARD8 + buffer: FD +└─── + Errors: Pixmap, Match + + Pass back a direct rendering object associated with + pixmap. Changes to pixmap will be visible in that + direct rendered object and changes to the direct rendered + object will be visible in the pixmap. + + 'size' specifies the total size of the buffer bytes. 'width', + 'height' describe the geometry (in pixels) of the underlying + buffer. 'stride' specifies the number of bytes per scanline in + the buffer. The pixels within the buffer are not required to + be arranged in a simple linear fashion, but 'size' will be at + least 'height' * 'stride'. + + Precisely how any additional information about the buffer is + shared is outside the scope of this extension. + + If buffer cannot be used with the screen associated with + drawable, a Match error is returned. + + For information on synchronization of buffer access between + the client and the X server, please see section 12. + +┌─── + DRI3FenceFromFD + drawable: DRAWABLE + fence: FENCE + initially-triggered: BOOL + fd: FD +└─── + Errors: IDchoice, Drawable + + Creates a Sync extension Fence that provides the regular Sync + extension semantics along with a file descriptor that provides + a device-specific mechanism to manipulate the fence directly. + Details about the mechanism used with this file descriptor are + outside the scope of the DRI3 extension. + + For information on synchronization of buffer access between + the client and the X server, please see section 12. + +┌─── + DRI3FDFromFence + drawable: DRAWABLE + fence: FENCE + ▶ + fd: FD +└─── + Errors: IDchoice, Drawable, Match + + Given a Sync extension Fence that provides the regular Sync + extension semantics, returns a file descriptor that provides a + device-specific mechanism to manipulate the fence directly. + Details about the mechanism used with this file descriptor are + outside the scope of the DRI3 extension. 'drawable' must be + associated with a direct rendering device that 'fence' can + work with, otherwise a Match error results. + + For information on synchronization of buffer access between + the client and the X server, please see section 12. + +┌─── + DRI3GetSupportedModifiers + window: WINDOW + depth: CARD8 + bpp: CARD8 + ▶ + num_window_modifiers: CARD32 + num_screen_modifiers: CARD32 + window_modifiers: ListOfCARD64 + screen_modifiers: ListOfCARD64 +└─── + Errors: Window, Match + + Return supported DRM FourCC modifiers for the specified + 'window'. + + The first list of 'window_modifiers' contains a set of + modifiers which the server considers optimal for the window's + current configuration. Using these modifiers to allocate, even + if locally suboptimal to the client driver, may result in a + more optimal display pipeline, e.g. by avoiding composition. + + The second list of 'screen_modifiers', is the total set of + modifiers which are acceptable for use on the Screen associated + with 'window'. This set of modifiers will not change over the + lifetime of the client. Using this set of modifiers to allocate + may not result in a globally optimal pipeline, if separate + 'window_modifiers' are available. + + It is expected that a client calling this request will obtain + the modifiers for a particular window, allocate buffers using + the preferred modifier set as described above, create a Pixmap + referring to the storage of those buffers using the + DRI3BuffersFromPixmap request, then make the content visible + in the storage of those buffers visible with a request such as + the Present extension's PresentPixmap. + + The meaning of any modifier is canonically defined in + drm_fourcc.h. + +┌─── + DRI3PixmapFromBuffers + pixmap: PIXMAP + window: WINDOW + num_buffers: CARD8 + width, height: CARD16 + stride0, offset0: CARD32 + stride1, offset1: CARD32 + stride2, offset2: CARD32 + stride3, offset3: CARD32 + depth, bpp: CARD8 + modifier: CARD64 + buffers: ListOfFD +└─── + Errors: Alloc, Window, IDChoice, Value, Match + + Creates a pixmap for the direct rendering object associated + with 'buffers' and the screen associated with 'window'. + Changes to pixmap will be visible in that direct rendered + object and changes to the direct rendered object will be + visible in the pixmap. The pixmap will be available for + presentation to the window. + + In contrast to PixmapFromBuffer, multiple buffers may be + combined to specify a single logical source for pixel + sampling: 'num_buffers' may be set from 1 (single buffer, + akin to PixmapFromBuffer) to 4. This is the number of file + descriptors which will be sent with this request; one per + buffer. + + Modifiers allow explicit specification of non-linear sources, + such as tiled or compressed buffers. The combination of bpp, + depth, and modifier allows unambiguous declaration of the + buffer layout in a manner defined by the DRM tokens. + + If 'modifier' is DRM_FORMAT_MOD_INVALID, the client does + not have information on the buffer layout. In this case, the + buffer may only have a single plane. The driver may make its + own inference through unspecified means to determine the exact + buffer layout, however this is neither required nor defined + by the specification, and is considered an implementation + detail of the particular driver. + + 'width' and 'height' describe the geometry (in pixels) of the + logical pixel-sample source. + + 'strideN' and 'offsetN' define the number of bytes per logical + scanline, and the distance in bytes from the beginning of the + buffer passed for that plane until the start of the sample + source for that plane, respectively for plane N. If the plane + is not used according to the format and modifier specification, + both values for that plane must be zero. + + Precisely how any additional information about the buffer (such + as memory placement) is shared is outside the scope of this + extension. + + If the buffer(s) cannot be used with the screen associated with + 'window', a Match error is returned. + + If the bpp, depth, and modifier combination is not supported by + the screen, a Value error is returned. + + For information on synchronization of buffer access between + the client and the X server, please see section 12. + +┌─── + DRI3BuffersFromPixmap + pixmap: PIXMAP + ▶ + nfd: CARD8 + width, height: CARD16 + depth, bpp: CARD8 + modifier: CARD64 + strides: ListOfCARD32 + offsets: ListOfCARD32 + buffers: ListOfFD +└─── + Errors: Pixmap, Match + + Returns direct rendering objects associated with 'pixmap'. + Changes to 'pixmap' will be visible in the direct rendered + objects and changes to the direct rendered objects will be + visible in 'pixmap' after flushing and synchronization. + + 'width' and 'height' describe the geometry (in pixels) of the + logical pixel-sample source from combining the direct rendering + objects. + + See PixmapFromBuffers for more details on DRM modifiers usage. + + 'nfd' describes the number of buffers returned for the pixmap, + which must be combined together according to 'depth', 'bpp', and + 'modifier'. + + For each buffer, there is an entry in the 'strides', + 'offsets', and 'buffers' list. 'buffer' contains a single file + descriptor referring to the buffer. 'stride' specifies the + number of bytes per logical scanline for this plane, and + 'offset' specifies the distance in bytes from the beginning + of 'buffer' until the start of the sample source for that + plane. + + Precisely how any additional information about the buffer is + shared is outside the scope of this extension. + + If buffers cannot be exported from the the screen associated + with 'pixmap', a Match error is returned. + + For information on synchronization of buffer access between + the client and the X server, please see section 12. + +┌─── + DRI3SetDRMDeviceInUse + window: WINDOW + drmMajor: CARD32 + drmMinor: CARD32 +└─── + Errors: Window + + This request provides a hint to the server about the device + in use by this window. This is used to provide + DRI3GetSupportedModifiers with a hint of what device to + return modifiers for in the window_modifiers return value. + Using this hint allows for device-specific modifiers to + be returned by DRI3GetSupportedModifiers, for example + when an application is renderoffloaded and eligible for + direct scanout. + + This is only a hint, and may or may not be reflected in + the modifier list returned. + + If the window specified was not found, a Window error will + be returned. + + +┌─── + DRI3ImportSyncobj + syncobj: SYNCOBJ + drawable: DRAWABLE + fd: FD +└─── + Errors: IDchoice, Drawable + + Imports the DRM synchronization object bound to the given 'fd'. This + may then be used to enable explicit synchronization with the + server-side direct rendering device associated with 'drawable'. + + The provided syncobj must be a timeline syncobj. + + If 'drawable' is not found, a Drawable error will be returned. + + +┌─── + DRI3FreeSyncobj + syncobj: SYNCOBJ +└─── + Errors: Value + + Indicates that any resources associated with the given 'syncobj' should + be released by the server. The actual release may be deferred until any + pending operations that depend on the object have completed. + + If 'syncobj' is not found, a Value error will be returned. + + ❄ ❄ ❄ ❄ ❄ ❄ ❄ + +9. Extension Events + +DRI3 defines no events. + + ❄ ❄ ❄ ❄ ❄ ❄ ❄ + +10. Extension Versioning + +The DRI3 extension is adapted from the DRI2 extension. + + 1.0: First published version + + 1.1: Cosmetic changes + + 1.2: Add GetSupportedModifiers, + PixmapFromBuffers, and BuffersFromPixmap requests. + + 1.3: Add SetDRMDeviceInUse + + ❄ ❄ ❄ ❄ ❄ ❄ ❄ + + +11. Relationship with other extensions + +As an extension designed to support other extensions, there is +naturally some interactions with other extensions. + +11.1 GLX + +GLX is both an application interface and an X extension. OpenGL +applications using the GLX API will use the GLX extension, DRI3 and +Present when doing direct rendering. + +11.2 Present + +The Present extension provides a way to synchronize the display of pixmap +contents to the screen. When used in conjunction with DRI3, they +provide a complete direct rendering solution for OpenGL or other APIs. + +11.3 DRI2 + +DRI3 provides similar functionality to the DRI2Connect and +DRI2GetBuffersWithFormat requests, however DRI3 uses file descriptors +to refer to the direct rendering device and buffers. + +Present and DRI3 are designed in conjunction to replace DRI2 + +11.2 XvMC / Xv + +It might be nice to be able to reference YUV formatted direct rendered +objects from the X server. + + ❄ ❄ ❄ ❄ ❄ ❄ ❄ + +12. Synchronization + +Synchronization of access to buffers shared between processes is not +currently explicitly controlled by this protocol. + +Without the use of additional extensions not defined by the DRI3 +protocol as of version 1.2, synchronization between multiple +processes and contexts is considered to follow the implicit model. + +In this model, the driver is required to have a global view of +access requests issued by all processes with a reference to the +buffer, and control scheduling of all operations on that buffer, +whether performed by the CPU or auxiliary hardware. + +The driver is responsible for enforcing a strict ordering to protect +against write-after-read or read-after-write hazards, such that any +reads requested by one process or context, are fulfilled before any +writes requested by another process or context, as long as that read +was definitively submitted before the write. + +A similar dependency exists for reads submitted after writes: the +driver must ensure that the write is fully visible and coherent to +the read request. + +As a purely illustrative example, if two processes share a buffer, +where one process reads from a buffer using an OpenGL texture +sampler and submits this work by calling 'glFlush', and the other +process submits work to the driver to write to that buffer, the +driver is responsible for ensuring that the results of the latter +write are not visible to the texture sampler. + +The Sync fences provided by DRI3 control only this submission of +work and ensuing global visibility of the requests, rather than the +completion of the work within any hardware. To further the example +above, a fence used to prevent any writes to the buffer before the +sampler had completed access, the fence would be signaled when +'glFlush' had been called, at which point the request has become +globally visible to the driver's request-scheduling and +synchronization mechanisms. The logical ordering of requests made +by software has been preserved, and the driver then takes care +to ensure that these requests are scheduled such they do not +observe effects from requests made later in time. + +This presents a fully coherent in-order FIFO-like model across +processes, where synchronzation is handled externally to the DRI3 +client with no explicit intervention. + +This restriction also applies for cross-device usage. + + ❄ ❄ ❄ ❄ ❄ ❄ ❄ + +Appendix A. Protocol Encoding + +Syntactic Conventions + +This document uses the same syntactic conventions as the core X +protocol encoding document. + + +A.1 Common Types + +None. + +A.2 Protocol Requests + +┌─── + DRI3QueryVersion + 1 CARD8 major opcode + 1 0 DRI3 opcode + 2 3 length + 4 CARD32 major version + 4 CARD32 minor version + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 4 CARD32 major version + 4 CARD32 minor version + 16 unused +└─── + + +┌─── + DRI3Open + 1 CARD8 major opcode + 1 1 DRI3 opcode + 2 4 length + 4 DRAWABLE drawable + 4 PROVIDER provider + ▶ + 1 1 Reply + 1 1 nfd + 2 CARD16 sequence number + 4 0 reply length + 24 unused + + 0 FD device +└─── + +┌─── + DRI3PixmapFromBuffer + 1 CARD8 major opcode + 1 2 DRI3 opcode + 2 6 length + 4 Pixmap pixmap + 4 Drawable drawable + 4 CARD32 size + 2 CARD16 width + 2 CARD16 height + 2 CARD16 stride + 1 CARD8 depth + 1 CARD8 bpp + + 0 FD buffer +└─── + +┌─── + DRI3BufferFromPixmap + 1 CARD8 major opcode + 1 3 DRI3 opcode + 2 2 length + 4 Pixmap pixmap + ▶ + 1 1 Reply + 1 1 nfd + 2 CARD16 sequence number + 4 0 reply length + 4 CARD32 size + 2 CARD16 width + 2 CARD16 height + 2 CARD16 stride + 1 CARD8 depth + 1 CARD8 bpp + 12 unused + + 0 FD buffer +└─── + +┌─── + DRI3FenceFromFD + 1 CARD8 major opcode + 1 4 DRI3 opcode + 2 4 length + 4 Drawable drawable + 4 Fence fence + 1 BOOL initially triggered + 3 unused + + 0 FD fence fd +└─── + +┌─── + DRI3FDFromFence + 1 CARD8 major opcode + 1 5 DRI3 opcode + 2 3 length + 4 Drawable drawable + 4 Fence fence + ▶ + 1 1 Reply + 1 1 nfd + 2 CARD16 sequence number + 4 0 reply length + 24 unused + + 0 FD fence fd +└─── + +┌─── + DRI3GetSupportedModifiers + 1 CARD8 major opcode + 1 6 DRI3 opcode + 2 3 length + 4 Window window + 1 CARD8 depth + 1 CARD8 bpp + 2 unused + ▶ + 1 1 Reply + 1 0 unused + 2 CARD16 sequence number + 4 CARD32 reply length + 4 CARD32 num_window_modifiers + 4 CARD32 num_screen_modifiers + 16 unused + + 4 ListOfCARD64 window_modifiers[num_window_modifiers] + 4 ListOfCARD64 screen_modifiers[num_screen_modifiers] +└─── + +┌─── + DRI3PixmapFromBuffers + 1 CARD8 major opcode + 1 7 DRI3 opcode + 2 8 length + 4 Pixmap pixmap + 4 Window window + 1 CARD8 num_buffers + 3 unused + 2 CARD16 width + 2 CARD16 height + 4 CARD32 stride0 + 4 CARD32 offset0 + 4 CARD32 stride1 + 4 CARD32 offset1 + 4 CARD32 stride2 + 4 CARD32 offset2 + 4 CARD32 stride3 + 4 CARD32 offset3 + 1 CARD8 depth + 1 CARD8 bpp + 2 unused + 8 CARD64 modifier + + 0 ListOfFD buffers[num_buffers] +└─── + +┌─── + DRI3BuffersFromPixmap + 1 CARD8 major opcode + 1 8 DRI3 opcode + 2 2 length + 4 Pixmap pixmap + ▶ + 1 1 Reply + 1 CARD8 nfd + 2 CARD16 sequence number + 4 CARD32 reply length + 2 CARD16 width + 2 CARD16 height + 4 CARD8 unused + 8 CARD64 modifier + 1 CARD8 depth + 1 CARD8 bpp + 6 unused + + 0 ListOfFD buffer[nfd] + 4 ListOfCARD32 strides[nfd] + 4 ListOfCARD32 offsets[nfd] +└─── + +┌─── + DRI3SetDRMDeviceInUse + 1 CARD8 major opcode + 1 9 DRI3 opcode + 2 4 length + 4 Window window + 4 CARD32 drmMajor + 4 CARD32 drmMinor +└─── + +┌─── + DRI3ImportSyncobj + 1 CARD8 major opcode + 1 11 DRI3 opcode + 2 3 length + 4 SYNCOBJ syncobj + 4 Drawable drawable + 0 FD syncobj fd +└─── + +┌─── + DRI3FreeSyncobj + 1 CARD8 major opcode + 1 12 DRI3 opcode + 2 2 length + 4 SYNCOBJ syncobj +└─── + +A.3 Protocol Events + +The DRI3 extension defines no events. + +A.4 Protocol Errors + +The DRI3 extension defines no errors. + + ❄ ❄ ❄ ❄ ❄ ❄ ❄ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/fixesproto.txt b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/fixesproto.txt new file mode 100644 index 0000000000000000000000000000000000000000..f462606d6fd00408fa4aaa37265ff3ffadad8291 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/fixesproto.txt @@ -0,0 +1,734 @@ + The XFIXES Extension + Version 6.1 + Document Revision 1 + 2010-11-15 + Keith Packard + keithp@keithp.com + +1. Introduction + +X applications have often needed to work around various shortcomings in the +core X window system. This extension is designed to provide the minimal +server-side support necessary to eliminate problems caused by these +workarounds. + +2. Acknowledgements + +This extension is a direct result of requests made by application +developers, in particular, + + + Owen Taylor for describing the issues raised with the XEMBED + mechanisms and SaveSet processing and his initial extension + to handle this issue, and for pointer barriers + + + Bill Haneman for the design for cursor image tracking. + + + Havoc Pennington + + + Fredrik Höglund for cursor names + + + Deron Johnson for cursor visibility + +3. Basic Premise + +Requests in this extension may seem to wander all over the map of X server +capabilities, but they are tied by a simple rule -- resolving issues raised +by application interaction with core protocol mechanisms that cannot be +adequately worked around on the client side of the wire. + +4. Extension initialization + +The client must negotiate the version of the extension before executing +extension requests. Behavior of the server is undefined otherwise. + +QueryVersion + + client-major-version: CARD32 + client-minor-version: CARD32 + + -> + + major-version: CARD32 + minor-version: CARD32 + + The client sends the highest supported version to the server and + the server sends the highest version it supports, but no higher than + the requested version. Major versions changes can introduce + new requests, minor version changes introduce only adjustments to + existing requests or backward compatible changes. It is + the clients responsibility to ensure that the server supports + a version which is compatible with its expectations. + +************* XFIXES VERSION 1 OR BETTER *********** + +5. Save Set processing changes + +Embedding one application within another provides a way of unifying +disparate documents and views within a single framework. From the X +protocol perspective, this appears similar to nested window managers; the +embedding application "manages" the embedded windows much as a window +manager does for top-level windows. To protect the embedded application +from embedding application failure, it is reasonable to use the core SaveSet +mechanism so that embedding application failure causes embedded windows to +be preserved instead of destroyed. + +The core save set mechanism defines the target for each save set member +window as the nearest enclosing window not owned by the terminating client. +For embedding applications, this nearest window is usually the window +manager frame. The problem here is that the window manager will not +generally expect to receive and correctly manage new windows appearing within +that window by the save set mechanism, and will instead destroy the frame +window in response to the client window destruction. This causes the +embedded window to be destroyed. + +An easy fix for this problem is to change the target of the save set member +to a window which won't be affected by the underlying window destruction. +XFIXES chooses the root window as the target. + +Having embedded windows suddenly appear at the top level can confuse users, +so XFIXES also lets the client select whether the window should end up +unmapped after the save set processing instead of unconditionally making +them be mapped. + +5.1 Requests + +ChangeSaveSet + + window: Window + mode: { Insert, Delete } + target: { Nearest, Root } + map: { Map, Unmap } + + ChangeSaveSet is an extension of the core protocol ChangeSaveSet + request. As in that request, mode specifies whether the indicated + window is inserted or deleted from the save-set. Target specifies + whether the window is reparented to the nearest non-client window as + in the core protocol, or reparented to the root window. Map + specifies whether the window is mapped as in the core protocol or + unmapped. + +6. Selection Tracking + +Applications wishing to monitor the contents of current selections must +poll for selection changes. XFIXES improves this by providing an event +delivered whenever the selection ownership changes. + +6.1 Types + + SELECTIONEVENT { SetSelectionOwner, + SelectionWindowDestroy, + SelectionClientClose } + +6.1 Events + +SelectionNotify + + subtype: SELECTIONEVENT + window: Window + owner: Window + selection: Atom + timestamp: Timestamp + selection-timestamp: Timestamp + +6.2 Requests + +SelectSelectionInput + + window: Window + selection: Atom + event-mask: SETofSELECTIONEVENT + + Selects for events to be delivered to window when various causes of + ownership of selection occur. Subtype indicates the cause of the + selection ownership change. Owner is set to the current selection + owner, or None. Timestamp indicates the time the event was + generated while selection-timestamp indicates the timestamp used to + own the selection. + +7. Cursor Image Monitoring + +Mirroring the screen contents is easily done with the core protocol or VNC +addons, except for the current cursor image. There is no way using the core +protocol to discover which cursor image is currently displayed. The +cursor image often contains significant semantic content about the user +interface. XFIXES provides a simple mechanism to discover when the cursor +image changes and to fetch the current cursor image. + +As the current cursor may or may not have any XID associated with it, there +is no stable name available. Instead, XFIXES returns only the image of the +current cursor and provides a way to identify cursor images to avoid +refetching the image each time it changes to a previously seen cursor. + +7.1 Types + CURSOREVENT { DisplayCursor } + +7.2 Events + +CursorNotify + + subtype: CURSOREVENT + window: Window + cursor-serial: CARD32 + timestamp: Timestamp + name: Atom (Version 2 only) + +7.3 Requests + +SelectCursorInput + + window: Window + event-mask: SETofCURSOREVENT + + This request directs cursor change events to the named window. + Events will be delivered irrespective of the screen on which they + occur. Subtype indicates the cause of the cursor image change + (there is only one subtype at present). Cursor-serial is a number + assigned to the cursor image which identifies the image. Cursors + with different serial numbers may have different images. Timestamp + is the time of the cursor change. + + Servers supporting the X Input Extension Version 2.0 or higher only + notify the clients of cursor change events for the ClientPointer, not + of any other master pointer (see Section 4.4. in the XI2 protocol + specification). + +GetCursorImage + + -> + + x: INT16 + y: INT16 + width: CARD16 + height: CARD16 + x-hot: CARD16 + y-hot: CARD16 + cursor-serial: CARD32 + cursor-image: LISTofCARD32 + + GetCursorImage returns the image of the current cursor. X and y are + the current cursor position. Width and height are the size of the + cursor image. X-hot and y-hot mark the hotspot within the cursor + image. Cursor-serial provides the number assigned to this cursor + image, this same serial number will be reported in a CursorNotify + event if this cursor image is redisplayed in the future. + + The cursor image itself is returned as a single image at 32 bits per + pixel with 8 bits of alpha in the most significant 8 bits of the + pixel followed by 8 bits each of red, green and finally 8 bits of + blue in the least significant 8 bits. The color components are + pre-multiplied with the alpha component. + +************* XFIXES VERSION 2 OR BETTER *********** + +8. Region Objects + +The core protocol doesn't expose regions as a primitive object and this +makes many operations more complicated than they really need to be. Adding +region objects simplifies expose handling, the Shape extension and other +operations. These operations are also designed to support a separate +extension, the X Damage Extension. + +8.1 Types + + Region: XID + WINDOW_REGION_KIND: { Bounding, Clip } + +8.2 Errors + + Region The specified region is invalid + +8.3 Requests + +CreateRegion + + region: REGION + rects: LISTofRECTANGLE + + Creates a region initialized to the specified list of rectangles. + The rectangles may be specified in any order, their union becomes + the region. The core protocol allows applications to specify an + order for the rectangles, but it turns out to be just as hard to + verify the rectangles are actually in that order as it is to simply + ignore the ordering information and union them together. Hence, + this request dispenses with the ordering information. + + Errors: IDChoice + +CreateRegionFromBitmap + + region: REGION + bitmap: PIXMAP + + Creates a region initialized to the set of 'one' pixels in bitmap + (which must be depth 1, else Match error). + + Errors: Pixmap, IDChoice, Match + +CreateRegionFromWindow + + window: Window + kind: WINDOW_REGION_KIND + region: Region + + Creates a region initialized to the specified window region. See the + Shape extension for the definition of Bounding and Clip regions. + + Errors: Window, IDChoice, Value + +CreateRegionFromGC + + gc: GContext + region: Region + + Creates a region initialized from the clip list of the specified + GContext. + + Errors: GContext, IDChoice + +CreateRegionFromPicture + + picture: Picture + region: Region + + + Creates a region initialized from the clip list of the specified + Picture. + + Errors: Picture, IDChoice + +DestroyRegion + + region: Region + + Destroys the specified region. + + Errors: Region + +SetRegion + + region: Region + rects: LISTofRECTANGLE + + This replaces the current contents of region with the region formed + by the union of rects. + +CopyRegion + source: Region + destination: Region + + This replaces the contents of destination with the contents of + source. + +UnionRegion +IntersectRegion +SubtractRegion + + source1: Region + source2: Region + destination: Region + + Combines source1 and source2, placing the result in destination. + Destination may be the same as either source1 or source2. + + Errors: Region, Value + +InvertRegion + + source: Region + bounds: RECTANGLE + destination: Region + + The source region is subtracted from the region specified by + bounds. The result is placed in destination, replacing its contents. + + Errors: Region + +TranslateRegion + + region: Region + dx, dy: INT16 + + The region is translated by dx, dy in place. + + Errors: Region + +RegionExtents + + source: Region + destination: Region + + The extents of the source region are placed in the destination + +FetchRegion + + region: Region + -> + extents: RECTANGLE + rectangles: LISTofRECTANGLE + + The region is returned as a list of rectangles in YX-banded order. + + Errors: Region + +SetGCClipRegion + + gc: GCONTEXT + clip-x-origin, clip-y-origin: INT16 + region: Region or None + + This request changes clip-mask in gc to the specified region and + sets the clip origin. Output will be clipped to remain contained + within the region. The clip origin is interpreted relative to the + origin of whatever destination drawable is specified in a graphics + request. The region is interpreted relative to the clip origin. + Future changes to region have no effect on the gc clip-mask. + + Errors: GContext, Region + +SetWindowShapeRegion + + dest: Window + destKind: SHAPE_KIND + xOff, yOff: INT16 + region: Region or None + + This request sets the specified (by destKind) Shape extension region + of the window to region, offset by xOff and yOff. Future changes to + region have no effect on the window shape. + + Errors: Window, Value, Region + +SetPictureClipRegion + + picture: Picture + clip-x-origin, clip-y-origin: INT16 + region: Region or None + + This request changes clip-mask in picture to the specified region + and sets the clip origin. Input and output will be clipped to + remain contained within the region. The clip origin is interpreted + relative to the origin of the drawable associated with picture. The + region is interpreted relative to the clip origin. Future changes + to region have no effect on the picture clip-mask. + + Errors: Picture, Region + +9. Cursor Names + +Attaching names to cursors permits some abstract semantic content to be +associated with specific cursor images. Reflecting those names back to +applications allows that semantic content to be related to the user through +non-visual means. + +9.1 Events + +CursorNotify + + subtype: CURSOREVENT + window: Window + cursor-serial: CARD32 + timestamp: Timestamp + name: Atom or None + + In Version 2 of the XFIXES protocol, this event adds the atom + of any name associated with the current cursor (else None). + +9.2 Requests + +SetCursorName + + cursor: CURSOR + name: LISTofCARD8 + + This request interns name as an atom and sets that atom as the name + of cursor. + + Errors: Cursor + +GetCursorName + + cursor: CURSOR + -> + atom: ATOM or None + name: LISTofCARD8 + + This request returns the name and atom of cursor. If no name is + set, atom is None and name is empty. + + Errors: Cursor + +GetCursorImageAndName + + -> + + x: INT16 + y: INT16 + width: CARD16 + height: CARD16 + x-hot: CARD16 + y-hot: CARD16 + cursor-serial: CARD32 + cursor-atom: ATOM + cursor-image: LISTofCARD32 + cursor-name: LISTofCARD8 + + This is similar to GetCursorImage except for including both + the atom and name of the current cursor. + +ChangeCursor + + source, destination: CURSOR + + This request replaces all references to the destination with a + reference to source. Any existing uses of the destination cursor + object will now show the source cursor image. + +ChangeCursorByName + + src: CURSOR + name: LISTofCARD8 + + This request replaces the contents of all cursors with the specified + name with the src cursor. + +************* XFIXES VERSION 3 OR BETTER *********** + +10. Region Expansion + +This update provides another operation on the region objects defined in +Section 8 of this document. + +10.1 Requests + +ExpandRegion + source: REGION + destination: REGION + left, right, top, bottom: CARD16 + + Creates destination region containing the area specified by + expanding each rectangle in the source region by the specified + number of pixels to the left, right, top and bottom. + +************* XFIXES VERSION 4 OR BETTER *********** + +11. Cursor Visibility + +Composite managers may want to render the cursor themselves instead of +relying on the X server sprite drawing, this provides a way for them to +do so without getting a double cursor image. + +11.1 Requests + +HideCursor + + window: WINDOW + + A client sends this request to indicate that it wants the + cursor image to be hidden (i.e. to not be displayed) when + the sprite is on the same screen as the specified window. + The sprite will be hidden if one or more clients have called + HideCursor and not ShowCursor. + + Note that even though cursor hiding causes the cursor image + to be invisible, CursorNotify events will still be sent + normally, as if the cursor image were visible. + + When a client with outstanding cursor hiding requests + terminates its connection these requests will be deleted. + + Servers supporting the X Input Extension Version 2.0 or higher hide + all visible cursors in response to a HideCursor request. If a master + pointer is created while the cursors are hidden, this master pointer's + cursor will be hidden as well. + +ShowCursor + + window: WINDOW + + A client sends this request to indicate that it wants the + cursor image to be displayed when the sprite is on the same + screen as the specified window. The sprite will be hidden + if one or more clients have called HideCursor and not ShowCursor. + + If the client has made no outstanding HideCursor requests + a BadMatch error is generated. + + Servers supporting the X Input Extension Version 2.0 or higher show + all visible cursors in response to a ShowCursor request. + +************* XFIXES VERSION 5 OR BETTER *********** + +12. Pointer Barriers + +Compositing managers and desktop environments may have UI elements in +particular screen locations such that for a single-headed display they +correspond to easy targets according to Fitt's Law, for example, the top +left corner. For a multi-headed environment these corners should still be +semi-impermeable. Pointer barriers allow the application to define +additional constraint on cursor motion so that these areas behave as +expected even in the face of multiple displays. + +Absolute positioning devices like touchscreens do not obey pointer barriers. +There's no advantage to target acquisition to do so, since on a touchscreen +all points are in some sense equally large, whereas for a relative +positioning device the edges and corners are infinitely large. + +WarpPointer and similar requests do not obey pointer barriers, for +essentially the same reason. + +12.1 Types + + BARRIER: XID + + BarrierDirections + + BarrierPositiveX: 1 << 0 + BarrierPositiveY: 1 << 1 + BarrierNegativeX: 1 << 2 + BarrierNegativeY: 1 << 3 + +12.2 Errors + + Barrier + +12.3 Requests + +CreatePointerBarrier + + barrier: BARRIER + window: Window + x1, y2, x2, y2: INT16 + directions: CARD32 + devices: LISTofDEVICEID + + Creates a pointer barrier along the line specified by the given + coordinates on the screen associated with the given window. The + barrier has no spatial extent; it is simply a line along the left + or top edge of the specified pixels. Barrier coordinates are in + screen space. + + The coordinates must be axis aligned, either x1 == x2, or + y1 == y2, but not both. The varying coordinates may be specified + in any order. For x1 == x2, either y1 > y2 or y1 < y2 is valid. + If the coordinates are not valid BadValue is generated. + + Motion is allowed through the barrier in the directions specified: + setting the BarrierPositiveX bit allows travel through the barrier + in the positive X direction, etc. Nonsensical values (forbidding Y + axis travel through a vertical barrier, for example) and excess set + bits are ignored. + + If the server supports the X Input Extension version 2 or higher, + the devices element names a set of master device to apply the + barrier to. If XIAllDevices or XIAllMasterDevices are given, the + barrier applies to all master devices. If a slave device is named, + BadDevice is generated; this does not apply to slave devices named + implicitly by XIAllDevices. Naming a device multiple times is + legal, and is treated as though it were named only once. If a + device is removed, the barrier continues to apply to the remaining + devices, but will not apply to any future device with the same ID + as the removed device. Nothing special happens when all matching + devices are removed; barriers must be explicitly destroyed. + + Errors: IDChoice, Window, Value, Device + +DestroyPointerBarrier + + barrier: BARRIER + + Destroys the named barrier. + + Errors: Barrier + +************* XFIXES VERSION 6 OR BETTER *********** + +13. Disconnect mode + +The X11 server is capable of terminating itself once all X11 clients are +gone. + +Yet, in a typical user session, there are a number of X11 clients running +continuously (e.g. Xsettings daemon, IBus, etc.). Those always-running +clients will prevent the X11 server from terminating, because the actual +number of X11 clients will never drop to 0. + +Disconnect mode allows the X11 clients themselves to specify that they +should not be accounted for when checking the remaining clients prior +to terminate the X11 server. + +This can be particularly useful for Wayland compositors which are able to +start Xwayland on demand, as this allows Xwayland to terminate automatically +when the relevant X11 clients have quit. + +13.1 Types + + XFixesClientDisconnectFlags + + XFixesClientDisconnectFlagDefault: 0 + XFixesClientDisconnectFlagTerminate: 1 << 0 + XFixesClientDisconnectFlagForceTerminate: 1 << 1 + + XFixesClientDisconnectFlagDefault is the default behavior for + regular clients: the X11 server won't terminate as long as such + clients are still connected and no other clients trigger + termination. + + XFixesClientDisconnectFlagTerminate indicates to the X11 server that + it can ignore the client and terminate itself even though the client + is still connected to the X11 server. + + If XFixesClientDisconnectFlagForceTerminate is set at the time the + client disconnects, the X11 server MUST terminate and/or reset without + delivering further events to clients, even if other clients that have + not set XFixesClientDisconnectFlagTerminate are still connected. + Screen lockers SHOULD use this flag to ensure that the screen does not + unlock if they exit, which would create a security vulnerability. + Programs SHOULD NOT use this flag unless unexpected termination would + create a security vulnerability or other severe problem. + + Because XFixesClientDisconnectFlagForceTerminate allows the client to + cause the server to terminate, it is subject to security checks to + prevent unauthorized use. Servers that support the X Access Control + Extension (XACE) MUST deny attempts to set + XFixesClientDisconnectFlagForceTerminate, unless the client has + DixManageAccess to the server. Servers that support the SECURITY + extension MUST forbid untrusted clients from setting + XFixesClientDisconnectFlagForceTerminate. Servers MAY refuse to allow + clients to set this flag for other reasons. For instance, a server + might only allow the flag to be set by local clients. If the server + refuses to allow the client to set this flag, an Access error results. + + XFixesClientDisconnectFlagForceTerminate is only available in XFixes + versions 6.1 and better. + +13.2 Requests + +SetClientDisconnectMode + + disconnect-mode: CARD32 + + Sets the disconnect mode for the client. + + The disconnect-mode is a bit mask of XFixesClientDisconnectFlags. + + +GetClientDisconnectMode + + Gets the disconnect mode for the client. + + -> + + disconnect-mode: CARD32 + + The disconnect-mode is a bit mask of XFixesClientDisconnectFlags. + + +99. Future compatibility + +This extension is not expected to remain fixed. Future changes will +strive to remain compatible if at all possible. The X server will always +support version 1 of the extension protocol if requested by a client. + +Additions to the protocol will always by marked by minor version number +changes so that applications will be able to detect what requests are +supported. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/presentproto.txt b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/presentproto.txt new file mode 100644 index 0000000000000000000000000000000000000000..56c20d4d58f9d5aef3e9213e36045735ae26a2d3 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/presentproto.txt @@ -0,0 +1,931 @@ + The Present Extension + Version 1.4 + 2023-06-13 + + Keith Packard + keithp@keithp.com + Intel Corporation + +1. Introduction + +The Present extension provides a way for applications to update their +window contents from a pixmap in a well defined fashion, synchronizing +with the display refresh and potentially using a more efficient +mechanism than copying the contents of the source pixmap. + +1.1. Future Present extension versions + +This document includes speculation about future 'redirect' support +within the Present extension. All such information is subject to +change and is provided only as an aid to further Present development. + +1.2. Acknowledgments + +Eric Anholt +Owen Taylor +James Jones +Louis-Francis Ratté-Boulianne + + ❄ ❄ ❄ ❄ ❄ ❄ ❄ + +2. Data Types + +PRESENTEVENTID { XID } + + Defines a unique event delivery target for Present + events. Multiple event IDs can be allocated to provide + multiple distinct event delivery contexts. + +PRESENTNOTIFY { + window: WINDOW + serial: CARD32 + } + + A list of these is passed to PresentPixmap; when the indicated + PresentPixmap completes, PresentCompletNotify events will be + delivered both to the PresentPixmap window/serial parameter as + well as each of the entries in the list of PRESENTNOTIFY parameter. + +PRESENTEVENTTYPE { PresentConfigureNotify, + PresentCompleteNotify, + PresentIdleNotify } + +PRESENTEVENTMASK { PresentConfigureNotifyMask, + PresentCompleteNotifyMask, + PresentIdleNotifyMask } + +PRESENTOPTION { PresentOptionAsync, + PresentOptionCopy, + PresentOptionUST, + PresentOptionSuboptimal, + PresentOptionAsyncMayTear } + +PRESENTCAPABILITY { PresentCapabilityAsync, + PresentCapabilityFence, + PresentCapabilityUST, + PresentCapabilityAsyncMayTear, + PresentCapabilitySyncobj } + +PRESENTCOMPLETEKIND { PresentCompleteKindPixmap, + PresentCompleteKindMSCNotify } + +PRESENTCOMPLETEMODE { PresentCompleteModeCopy, + PresentCompleteModeFlip, + PresentCompleteModeSkip, + PresentCompleteModeSuboptimalCopy } + +The Present extension also uses the Sync extension Fence data type to +provide synchronization for pixmaps. + +2.1. Data Types proposed for a later Present extension version + +PRESENTEVENTTYPE { ... + PresentRedirectNotify } + +PRESENTEVENTMASK { ... + PresentSubredirectNotifyMask } + + ❄ ❄ ❄ ❄ ❄ ❄ ❄ + +3. Errors + +EventID + A value for an EventID argument does not name a defined EventID + + ❄ ❄ ❄ ❄ ❄ ❄ ❄ + +5. Events + +ConfigureNotify events inform clients about window configuration +changes which can affect the allocation of window-related buffers. + +CompleteNotify events inform clients about the completion of a pending +PresentPixmap request. + +IdleNotify events inform clients when pixmaps are available for re-use. + +5.1. Events proposed for a later Present extension version + +RedirectNotify events inform clients about other clients PresentPixmap +requests. + + ❄ ❄ ❄ ❄ ❄ ❄ ❄ + +6. Extension Initialization + +The name of this extension is "Present" + +┌─── + PresentQueryVersion + client-major-version: CARD32 + client-minor-version: CARD32 + ▶ + major-version: CARD32 + minor-version: CARD32 +└─── + + The client sends the highest supported version to the server + and the server sends the highest version it supports, but no + higher than the requested version. Major versions changes can + introduce incompatibilities in existing functionality, minor + version changes introduce only backward compatible changes. + It is the clients responsibility to ensure that the server + supports a version which is compatible with its expectations. + + Backwards compatible changes include addition of new + requests. + + ❄ ❄ ❄ ❄ ❄ ❄ ❄ + +7. Extension Requests + +┌─── + PresentPixmap + window: WINDOW + pixmap: PIXMAP + serial: CARD32 + valid-area: REGION or None + update-area: REGION or None + x-off, y-off: INT16 + target-crtc: CRTC or None + wait-fence: FENCE + idle-fence: FENCE + options: SETofPRESENTOPTION + target-msc: CARD64 + divisor: CARD64 + remainder: CARD64 + notifies: LISTofPRESENTNOTIFY +└─── + Errors: Window, Pixmap, Match + + Provides new content for the specified window, to be made + visible at the specified time (defined by 'target-msc', 'divisor' + and 'remainder'). If the depth of 'pixmap' and 'window' do not + match, a Match error will be generated. + + 'serial' is an arbitrary client-specified value which will + be returned in the associated PresentCompleteNotify event so + that the client can associate the event and request. + + 'valid-area' defines the portion of 'pixmap' which contains + valid window contents, or None if the pixmap contains valid + contents for the whole window. + + 'update-area' defines the subset of the window to be updated, + or None if the whole window is to be updated. + + PresentPixmap may use any region of 'pixmap' which contains + 'update-area' and which is contained by 'valid-area'. In other + words, areas inside 'update-area' will be presented from + 'pixmap', areas outside 'valid-area' will not be presented + from 'pixmap' and areas inside 'valid-area' but outside + 'update-area' may or may not be presented at the discretion of + the X server. + + 'x-off' and 'y-off' define the location in the window where + the 0,0 location of the pixmap will be presented. valid-area + and update-area are relative to the pixmap. + + PresentPixmap will block until 'wait-fence' is triggered. + + When the X server has finished using 'pixmap' for this + operation, it will send a PresentIdleNotify event and arrange + for any 'idle-fence' to be triggered. This may be at any time + following the PresentPixmap request -- the contents may be + immediately copied to another buffer, copied just in time for + the vblank interrupt or the pixmap may be used directly for + display (in which case it will be busy until some future + PresentPixmap operation). + + If 'idle-fence' is not None, then the client guarantees to the + X server that it will wait for that fence to be signalled + before it uses the pixmap again. If 'idle-fence' is None, then + the X server must arrange for the pixmap to be re-usable by + the client as soon as the PresentIdleNotify event has been + received. Note that if PresentCapabilityFence is set for the + associated CRTC, then clients should use fences to improve + overall system performance. If PresentCapabilityFence is not + set, then using fences offers no benefit, but also no cost. + + If 'target-msc' is greater than the current msc for 'window', + the presentation will occur at (or after) the 'target-msc' + field. Otherwise, the presentation will occur after the next + field where msc % 'divisor' == 'remainder'. + + If 'target-crtc' is None, then the X server will choose a + suitable CRTC for synchronization. + + If 'options' contains PresentOptionAsync, and the 'target-msc' + is less than or equal to the current msc for 'window', then + the operation will be performed as soon as possible, not + necessarily waiting for the next vertical blank interval. If + the target-crtc does not support PresentCapabilityAsyncMayTear, + this may result in tearing. + + If the target-crtc supports PresentCapabilityAsyncMayTear, + 'options' contains PresentOptionAsyncMayTear, and the 'target-msc' + is less than or equal to the current msc for 'window', then + the operation will be performed as soon as possible, not + necessarily waiting for the next vertical blank interval, and + possibly resulting in tearing. + + If 'options' contains PresentOptionCopy, then 'pixmap' will be + idle, and 'idle-fence' triggered as soon as the operation occurs. + + If 'options' contains PresentOptionUST, then target-msc, + divisor and remainder will all be interpreted as UST values + instead of MSC values and the frame update will be scheduled + for the specified UST time, If the target-crtc supports + PresentCapabilityUST, then the swap time will be as close to + the target time as the driver can manage. Otherwise, the + server will take the target UST time and convert it to a + suitable target MSC value. + + If 'options' contains PresentOptionSuboptimal, then the + PresentCompleteNotify event can have mode + PresentCompleteModeSuboptimalCopy as the client supports it. + + After the presentation occurs, a PresentCompleteNotify event + with kind PresentCompleteKindPixmap will be generated, both to + 'window' as well as all members of 'notifies'. + + If 'window' is destroyed before the presentation occurs, then + the presentation action will not be completed. + + PresentPixmap holds a reference to 'pixmap' until the + presentation occurs, so 'pixmap' may be immediately freed + after the request executes, even if that is before the + presentation occurs. + + If 'idle-fence' is destroyed before the presentation occurs, + then idle-fence will not be signaled but the presentation will + occur normally. + + If 'wait-fence' is destroyed before it becomes triggered, then + the presentation operation will no longer wait for it and will + occur when the other conditions are satisfied. + +┌─── + PresentNotifyMSC + window: WINDOW + serial: CARD32 + target-msc: CARD64 + divisor: CARD64 + remainder: CARD64 +└─── + Errors: Window + + Delivers a PresentCompleteNotifyEvent with kind + PresentCompleteKindNotifyMSC after the time specified by + 'target-msc', 'divisor' and 'remainder'. + + 'serial' is an arbitrary client-specified value which will be + returned in the event so that the client can associate the + event and request. + + If 'target-msc' is greater than the current msc for 'window', + the event will be delivered at (or after) the 'target-msc' + field. Otherwise, the event delivery will occur after the next + field where msc % 'divisor' == 'remainder'. + + If 'window' is destroyed before the event is delivered, then + the event delivery will not be completed. + +┌─── + PresentSelectInput + event-id: PRESENTEVENTID + window: WINDOW + eventMask: SETofPRESENTEVENT +└─── + Errors: Window, Value, Match, IDchoice, Access + + Selects the set of Present events to be delivered for the + specified window and event context. PresentSelectInput can + create, modify, or delete event contexts. An event context is + associated with a specific window; using an existing event + context with a different window generates a Match error. + + If eventContext specifies an existing event context, then if + eventMask is empty, PresentSelectInput deletes the specified + context, otherwise the specified event context is changed to + select a different set of events. + + If eventContext is an unused XID, then if eventMask is empty + no operation is performed. Otherwise, a new event context is + created selecting the specified events. + +┌─── + PresentQueryCapabilities + target: CRTC or WINDOW + ▶ + capabilities: SETofPRESENTCAPABILITY +└─── + Errors: Window, CRTC + + Returns the supported capabilities for the target CRTC. If + 'target' is a CRTC, then it is used as the target CRTC. If + 'target' is a WINDOW, then the target CRTC is selected by the + X server from among the CRTCs on the screen specified by the window. + + PresentCapabilityAsyncMayTear means that the target device may be + able to flip the scanout buffer mid-frame instead of waiting for + a vertical blank interval. The precise latency between the flip + request and the actual scanout transition is not defined by this + specification, but is intended to be no more than a few + scanlines. + + If PresentCapabilityAsyncMayTear is not supported, + PresentCapabilityAsync means the same as + PresentCapabilityAsyncMayTear described above. + + If PresentCapabilityAsyncMayTear is supported, + PresentCapabilityAsync means that even if there is already a flip + pending in the target device, it may be possible to replace that + flip before the next vertical blank interval. The scanout buffer + does not change mid-frame though, i.e. there is no tearing. + + PresentCapabilityFence means that the target device can take + advantage of SyncFences in the Present operations to improve + GPU throughput. The driver must operate correctly in the + absence of fences, but may have reduced performance. Using + fences for drivers not advertising this capability should have + no performance impact. + + PresentCapabilityUST means that the target device can scanout + the image at an arbitrary UST time value, and is not driven by + a periodic scanout timer. Applications specifying UST times + for PresentPixmap can expect that their image will appear to + the user within a short amount of time from that specified in + the request. The precise accuracy of the scanout time is not + defined by the extension, but is expected to be on the order + of milliseconds or less. + + PresentCapabilitySyncobj means that the target device supports + explicit synchronization using timeline DRM synchronization + objects. See the PresentPixmapSynced request for details. + +┌─── + PresentPixmapSynced + window: WINDOW + pixmap: PIXMAP + serial: CARD32 + valid-area: REGION or None + update-area: REGION or None + x-off, y-off: INT16 + target-crtc: CRTC or None + acquire-syncobj: SYNCOBJ or None + release-syncobj: SYNCOBJ or None + acquire-point: CARD64 + release-point: CARD64 + options: SETofPRESENTOPTION + target-msc: CARD64 + divisor: CARD64 + remainder: CARD64 + notifies: LISTofPRESENTNOTIFY +└─── + Errors: Window, Pixmap, Match, Value + + Identical to the PresentPixmap request, except that instead of the + 'wait-fence' and 'idle-fence' arguments it accepts mandatory + 'acquire-syncobj' and 'release-syncobj' arguments, along with + corresponding acquire and release points, to be used for explicit + timeline-based GPU synchronization. The 'acquire-point' and + 'release-point' are assumed to correspond to timeline points on the + respective DRM syncobjs. + + The contents of the Pixmap will not be accessed by the server until the + 'acquire-point' on the acquire timeline has been signaled by the + client. The fence need not be submitted at the time the + PresentPixmapSynced request is issued. + + Once the 'release-point' on the release timeline has been signaled, the + client may assume that no further GPU or CPU access to the Pixmap by + the server will occur as part of the originating PresentPixmapSynced + request. Note that this is a stronger guarantee than what is provided + by the 'idle-fence' argument of the PresentPixmap request or the + delivery of a PresentIdleNotify event, as those do not necessarily + imply that the Pixmap is idle on the GPU. + + The server may wait for the acquire point and signal the release point + itself, as will typically happen if the request is executed by copying + the Pixmap's contents. Alternatively, it may forward the timelines, + acquire, and release points to an output sink directly, provided that + sink also supports explicit synchronization using DRM syncobjs. + + The server may signal the release point without waiting for the acquire + point if the Pixmap's contents are never accessed while servicing the + request. This may happen, for example, if a request is discarded due to + it being fully occluded by a later request. + + Beware that, if multiple Pixmaps are presented using the same release + timeline, the server makes no guarantees on the order in which the + release points will be signaled. Of particular concern is that, if the + later of the two release points is signaled before the earlier one, it + may appear to the client as though the Pixmap with the earlier release + point has been released before the server has finished its access to + it. Therefore, in general, clients are strongly advised to avoid using + the same release timeline with different Pixmaps. + + If the server does not support PresentCapabilitySyncobj, a Value error + is generated. + + If either 'acquire-syncobj' or 'release-syncobj' are None or do not + refer to previously imported syncobjs, a Value error is generated. + + If 'acquire-point' or 'release-point' is zero, a Value error is + generated. + + If 'acquire-syncobj' is equal to 'release-syncobj' and 'acquire-point' + is greater than or equal to 'release-point', a Value error is + generated. + + +7.1 Requests proposed for a later Present extension version + + These are not part of the standard and represent future plans + for the Present extension. + +┌─── + PresentSelectInput + ... +└─── + ... + + Specifying PresentSubredirectNotify Mask causes PresentPixmap + requests on any child of 'window' from other clients to + generate PresentRedirectNotify events to 'window' instead of + actually performing the operation. However, only one client at + a time can select for PresentRedirect on a window. An attempt + to violate this restriction results in an Access error. + + ❄ ❄ ❄ ❄ ❄ ❄ ❄ + +8. Extension Events + +┌─── + PresentConfigureNotify + type: CARD8 XGE event type (35) + extension: CARD8 Present extension request number + sequence-number: CARD16 + length: CARD32 2 + evtype: CARD16 Present_ConfigureNotify + eventID: PRESENTEVENTID + window: WINDOW + x: INT16 + y: INT16 + width: CARD16 + height: CARD16 + off_x: INT16 + off_y: INT16 + pixmap_width: CARD16 + pixmap_height: CARD16 + pixmap_flags: CARD32 +└─── + + PresentConfigureNotify events are sent when the window + configuration changes if PresentSelectInput has requested + it. PresentConfigureNotify events are XGE events and so do not + have a unique event type. + + 'x' and 'y' are the parent-relative location of 'window'. + +┌─── + PresentCompleteNotify + type: CARD8 XGE event type (35) + extension: CARD8 Present extension request number + sequence-number: CARD16 + length: CARD32 2 + evtype: PRESENTEVENTTYPE PresentCompleteNotify + eventID: PRESENTEVENTID + window: WINDOW + kind: PRESENTCOMPLETEKIND + mode: PRESENTCOMPLETEMODE + serial: CARD32 + ust: CARD64 + msc: CARD64 +└─── + + CompleteNotify events are delivered when a PresentPixmap or + PresentNotifyMSC operation has completed. + + 'kind' is PresentCompleteKindPixmap when generated by a + PresentPixmap operation completion or + PresentCompleteKindNotifyMsc when generated by a + PresentNotifyMSC operation completion. + + 'mode' is PresentCompleteModeCopy when the source pixmap + contents are taken from the pixmap and the pixmap is idle + immediately after the presentation completes. 'mode' is + PresentCompleteModeSuboptimalCopy when the source pixmap + contents are copied but it would be possible to flip the + pixmap if the buffer format/modifier was different (options + given to PresentPixmap must contain PresentOptionSuboptimal). + 'mode' is PresentCompleteModeFlip when the pixmap remains in-use + even after the presentation completes. It will become idle no + later than when the next PresentPixmap operation targeting the + same window by any client completes. If the presentation + operation was skipped because some later operation made it + irrelevant, then 'mode' will be PresentCompleteModeSkip. + + 'serial' is the value provided in the generating PresentPixmap + request. + + 'msc' and 'ust' indicate the frame count and system time when + the presentation actually occurred. + +┌─── + PresentIdleNotify + type: CARD8 XGE event type (35) + extension: CARD8 Present extension request number + sequence-number: CARD16 + length: CARD32 0 + evtype: PRESENTEVENTTYPE PresentIdleNotify + eventID: PRESENTEVENTID + window: WINDOW + serial: CARD32 + pixmap: PIXMAP + idle-fence: FENCE +└─── + + IdleNotify events are delivered when a pixmap used in a + PresentPixmap operation may be re-used by the client. + + 'window' is the window from the PresentPixmap to which this + event is delivered. + + 'serial' is the value provided in the associated PresentPixmap + request. + + 'pixmap' is the pixmap which is ready for re-use. + + 'idle-fence' is the fence which was provided in the + originating PresentPixmap request and is used to synchronize + rendering between the client and the X server's use of the + buffer. If not None, then the client must wait for the fence + to be signaled before using the pixmap. + +8.1. Extension Events proposed for a later Present extension version + +┌─── + PresentRedirectNotify + type: CARD8 XGE event type (35) + extension: CARD8 Present extension request number + sequence-number: CARD16 + length: CARD32 17 + 2 n + evtype: CARD16 Present_RedirectNotify + update-window: BOOL + + eventID: PRESENTEVENTID + event-window: WINDOW + window: WINDOW + pixmap: PIXMAP + serial: CARD32 + + valid-area: REGION + update-area: REGION + valid-rect: RECTANGLE + update-rect: RECTANGLE + x-off, y-off: INT16 + target-crtc: CRTC + wait-fence: FENCE + idle-fence: FENCE + options: SETofPRESENTOPTION + target-msc: CARD64 + divisor: CARD64 + remainder: CARD64 + notifies: LISTofPRESENTNOTIFY +└─── + + RedirectNotify events are delivered when the client has + selected for SubredirectNotify the parent of the target + window. All of the values provided to the PresentPixmap + request are provided. If the client simply passes these + parameters back to the X server, the effect will be as if the + original client executed the request. + + If 'update-window' is TRUE, then there are clients who have + requested composite automatic redirect on the window and who + presumably expect the window buffer to eventually contain + the application provided contents. The compositing manager + should at least occasionally update the window buffer with + suitable contents. The precise update interval is left to the + discretion of the client receiving this event. + + ❄ ❄ ❄ ❄ ❄ ❄ ❄ + +9. Extension Versioning + + 1.0: First published version + + 1.2: Added PresentCompleteModeSuboptimalCopy flag and + PresentOptionSuboptimal option + + ❄ ❄ ❄ ❄ ❄ ❄ ❄ + + +10. Relationship with other extensions + +As an extension designed to support other extensions, there is +naturally some interactions with other extensions. + +10.1 GLX + +GLX is both an application interface and an X extension. OpenGL +applications using the GLX API will use the GLX extension and may use +the Present extension to display application contents. + +10.2 DRI3 + +The DRI3 extension provides a way to share direct rendered pixel data +with the X server as X pixmaps. When used in conjunction with Present, +they provide a complete direct rendering solution for OpenGL or other +APIs. + +10.3 DRI2 + +Present provides similar functionality to the DRI2SwapBuffers and +requests, however Present uses X pixmaps to refer to the new window +contents instead of the DRI2 buffer attachments. + +Present and DRI3 are designed in conjunction to replace DRI2. + +10.4 XvMC / Xv + +It might be nice to be able to use YUV formatted objects as Present +sources. + + ❄ ❄ ❄ ❄ ❄ ❄ ❄ + +Appendix A. Protocol Encoding + +Syntactic Conventions + +This document uses the same syntactic conventions as the core X +protocol encoding document. + + +A.1 Common Types +┌─── + PresentEventType + 0 PresentConfigureNotify + 1 PresentCompleteNotify + 2 PresentIdleNotify +└─── + +┌─── + PresentEventMask + 1 PresentConfigureNotifyMask + 2 PresentCompleteNotifyMask + 4 PresentIdleNotifyMask +└─── + +┌─── + PresentOption + 1 PresentOptionAsync + 2 PresentOptionCopy; + 4 PresentOptionUST + 8 PresentOptionSuboptimal + 16 PresentOptionAsyncMayTear +└─── + +┌─── + PresentCapability + 1 PresentCapabilityAsync + 2 PresentCapabilityFence + 4 PresentCapabilityUST + 8 PresentCapabilityAsyncMayTear +└─── + +┌─── + PresentCompleteKind + 0 PresentCompleteKindPixmap + 1 PresentCompleteKindMSCNotify +└─── + +┌─── + PresentCompleteMode + 0 PresentCompleteModeCopy + 1 PresentCompleteModeFlip + 2 PresentCompleteModeSkip + 3 PresentCompleteModeSuboptimalCopy +└─── + +┌─── + PresentNotify + 4 Window window + 4 CARD32 serial +└─── + +A.1.1 Common Types proposed for a later Present extension version + +┌─── + PresentEventType + ... + 3 PresentRedirectNotify +└─── + +┌─── + PresentEventMask + ... + 8 PresentSubredirectNotifyMask +└─── + +A.2 Protocol Requests + +┌─── + PresentQueryVersion + 1 CARD8 major opcode + 1 0 Present opcode + 2 3 length + 4 CARD32 major version + 4 CARD32 minor version + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 4 CARD32 major version + 4 CARD32 minor version + 16 unused +└─── + +┌─── + PresentPixmap + 1 CARD8 major opcode + 1 1 Present opcode + 2 18+2n length + 4 Window window + 4 Pixmap pixmap + 4 CARD32 serial + 4 Region valid-area + 4 Region update-area + 2 INT16 x-off + 2 INT16 y-off + 4 CRTC target-crtc + 4 SyncFence wait-fence + 4 SyncFence idle-fence + 4 CARD32 options + 4 unused + 8 CARD64 target-msc + 8 CARD64 divisor + 8 CARD64 remainder + 8n LISTofPresentNotify notifies +└─── + +┌─── + PresentNotifyMSC + 1 CARD8 major opcode + 1 2 Present opcode + 2 10 length + 4 Window window + 4 CARD32 serial + 4 unused + 8 CARD64 target-msc + 8 CARD64 divisor + 8 CARD64 remainder +└─── + +┌─── + PresentSelectInput + 1 CARD8 major opcode + 1 3 Present opcode + 2 4 length + 4 EventID event-id + 4 Window window + 4 SETofPRESENTEVENTMASK event-mask +└─── + +┌─── + PresentQueryCapabilities + 1 CARD8 major opcode + 1 4 Present opcode + 2 2 length + 4 CRTC or Window target + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 4 SETofPRESENTCAPABILITY capabilities +└─── + +┌─── + PresentPixmapSynced + 1 CARD8 major opcode + 1 5 Present opcode + 2 22+2n length + 4 Window window + 4 Pixmap pixmap + 4 CARD32 serial + 4 Region valid-area + 4 Region update-area + 2 INT16 x-off + 2 INT16 y-off + 4 CRTC target-crtc + 4 SYNCOBJ acquire-syncobj + 4 SYNCOBJ release-syncobj + 8 CARD64 acquire-point + 8 CARD64 release-point + 4 CARD32 options + 4 unused + 8 CARD64 target-msc + 8 CARD64 divisor + 8 CARD64 remainder + 8n LISTofPresentNotify notifies +└─── + +A.3 Protocol Events + +┌─── + PresentConfigureNotify + 1 35 XGE + 1 CARD8 Present extension opcode + 2 CARD16 sequence number + 4 2 length + 2 0 PresentConfigureNotify + 2 unused + 4 CARD32 event id + 4 Window window + 2 INT16 x + 2 INT16 y + 2 CARD16 width + 2 CARD16 height + 2 INT16 off x + 2 INT16 off y + + 2 CARD16 pixmap width + 2 CARD16 pixmap height + 4 CARD32 pixmap flags +└─── + +┌─── + PresentCompleteNotify + 1 35 XGE + 1 CARD8 Present extension opcode + 2 CARD16 sequence number + 4 2 length + 2 1 PresentCompleteNotify + 1 CARD8 kind + 1 CARD8 mode + 4 CARD32 event id + 4 Window window + 4 CARD32 serial + 8 CARD64 ust + + 8 CARD64 msc +└─── + +┌─── + PresentIdleNotify + 1 35 XGE + 1 CARD8 Present extension opcode + 2 CARD16 sequence number + 4 0 length + 2 2 PresentIdleNotify + 2 unused + 4 CARD32 event id + 4 Window window + 4 CARD32 serial + 4 Pixmap pixmap + 4 SyncFence idle-fence +└─── + +A.3.1 Protocol Events proposed for later Present extension version + +┌─── + PresentRedirectNotify + 1 35 XGE + 1 CARD8 Present extension opcode + 2 CARD16 sequence number + 4 18+2n length + 2 3 PresentRedirectNotify + 1 BOOL update-window + 1 unused + 4 CARD32 event id + 4 Window event-window + 4 Window window + 4 Pixmap pixmap + 4 CARD32 serial + + 4 Region valid-area + 4 Region update-area + 8 Rectangle valid-rect + 8 Rectangle update-rect + 2 INT16 x-off + 2 INT16 y-off + 4 CRTC target-crtc + 4 SyncFence wait-fence + 4 SyncFence idle-fence + 4 CARD32 options + 4 unused + 8 CARD64 target-msc + 8 CARD64 divisor + 8 CARD64 remainder + 8n LISTofPRESENTNOTIFY notifies +└─── + +A.4 Protocol Errors + +The Present extension defines no errors. + + ❄ ❄ ❄ ❄ ❄ ❄ ❄ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/randrproto.txt b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/randrproto.txt new file mode 100644 index 0000000000000000000000000000000000000000..7156e929a5c22a29a51f3172f7e17a83f7940241 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/randrproto.txt @@ -0,0 +1,3435 @@ + The X Resize, Rotate and Reflect Extension + Version 1.6.0 + 2017-04-01 + + Jim Gettys + Jim.Gettys@hp.com + Cambridge Research Laboratory + HP Labs + Hewlett Packard Company + + Keith Packard + keithp@keithp.com + +1. Introduction + +The X Resize, Rotate and Reflect Extension, called RandR for short, +brings the ability to resize, rotate and reflect the root window of a +screen. It is based on the X Resize and Rotate Extension as specified +in the Proceedings of the 2001 Usenix Technical Conference [RANDR]. + +RandR as implemented and integrated into the X server differs in +one substantial fashion from the design discussed in that paper: that +is, RandR 1.0 does not implement the depth switching described in that +document, and the support described for that in the protocol in that +document and in the implementation has been removed from the +protocol described here, as it has been overtaken by events. + +These events include: + ► Modern toolkits (in this case, GTK+ 2.x) have progressed to the point + of implementing migration between screens of arbitrary depths + ► The continued advance of Moore's law has made limited amounts of VRAM + less of an issue, reducing the pressure to implement depth switching + on laptops or desktop systems + ► The continued decline of legacy toolkits whose design would have + required depth switching to support migration + ► The lack of depth switching implementation experience in the + intervening time, due to events beyond our control + +Additionally, the requirement to support depth switching might +complicate other re-engineering of the device independent part of the +X server that is currently being contemplated. + +Rather than further delaying RandR's widespread deployment for a feature +long wanted by the community (resizing of screens, particularly on laptops), +or the deployment of a protocol design that might be flawed due to lack of +implementation experience, we decided to remove depth switching from the +protocol. It may be implemented at a later time if resources and +interests permit as a revision to the protocol described here, which will +remain a stable base for applications. The protocol described here has been +implemented in the main X.org server, and more fully in the hw/kdrive +implementation in the distribution, which fully implements resizing, +rotation and reflection. + +1.2 Introduction to version 1.2 of the extension + +One of the significant limitations found in version 1.1 of the RandR +protocol was the inability to deal with the Xinerama model where multiple +monitors display portions of a common underlying screen. In this environment, +zero or more video outputs are associated with each CRT controller which +defines both a set of video timings and a 'viewport' within the larger +screen. This viewport is independent of the overall size of the screen, and +may be located anywhere within the screen. + +The effect is to decouple the reported size of the screen from the size +presented by each video output, and to permit multiple outputs to present +information for a single screen. + +To extend RandR for this model, we separate out the output, CRTC and screen +configuration information and permit them to be configured separately. For +compatibility with the 1.1 version of the protocol, we make the 1.1 requests +simultaneously affect both the screen and the (presumably sole) CRTC and +output. The set of available outputs are presented with UTF-8 encoded names +and may be connected to CRTCs as permitted by the underlying hardware. CRTC +configuration is now done with full mode information instead of just size +and refresh rate, and these modes have names. These names also use UTF-8 +encoding. New modes may also be added by the user. + +Additional requests and events are provided for this new functionality. + + ┌────────────────────────────────┬──────────┐ + ┏━━━━━━━┳───────────────┐ ╔════════╗ ╔════════╗ + ┃ 1 ┃ │ ║ A ║ ║ B ║ + ┃ ┏━━━╋━━━━━━━━━━━━━━━┫ ║ ║ ║ ║ + ┣━━━╋━━━┛ ┃ ╚════════╝ ╚════════╝ + │ ┃ 2 ┃─────────────────┐ + │ ┃ ┃ ╔═══════════════════╗ + │ ┃ ┃ ║ ║ + │ ┗━━━━━━━━━━━━━━━━━━━┫ ║ C ║ + └───────────────────────┘ ║ ║ + ┌──────┐ ┏━━━━┓ ╔══════╗ ║ ║ + │screen│ ┃CRTC┃ ║output║ ╚═══════════════════╝ + └──────┘ ┗━━━━┛ ╚══════╝ + +In this picture, the screen is covered (incompletely) by two CRTCs. CRTC1 +is connected to two outputs, A and B. CRTC2 is connected to output C. +Outputs A and B will present exactly the same region of the screen using +the same mode line. Output C will present a different (larger) region of +the screen using a different mode line. + +RandR provides information about each available CRTC and output; the +connection between CRTC and output is under application control, although +the hardware will probably impose restrictions on the possible +configurations. The protocol doesn't try to describe these restrictions, +instead it provides a mechanism to find out what combinations are supported. + +1.3 Introduction to version 1.3 of the extension + +Version 1.3 builds on the changes made with version 1.2 and adds some new +capabilities without fundamentally changing the extension again. The +following features are added in this version: + + • Projective Transforms. The implementation work for general rotation + support made it trivial to add full projective transformations. These + can be used to scale the screen up/down as well as perform projector + keystone correct or other effects. + + • Panning. It was removed with RandR 1.2 because the old semantics didn't + fit any longer. With RandR 1.3 panning can be specified per crtc. + +1.4 Introduction to version 1.4 of the extension + +Version 1.4 adds an optional Border property. + + • An optional Border property. This property allows a client to + specify that the viewport of the CRTC is smaller than the active + display region described its mode. This is useful, for example, + for compensating for the overscan behavior of certain + televisions. + +Version 1.4 adds a new object called a provider object. A provider object +represents a GPU or virtual device providing services to the X server. +Providers have a set of abilities and a set of possible roles. + +Provider objects are used to control multi-GPU systems. Provider roles can +be dynamically configured to provide support for: + + 1) Output slaving: plug in a USB device, but have its output rendered + using the main GPU. On some dual-GPU laptops, the second GPU isn't + connected to the LVDS panel, so we need to use the first GPU as an output + slave for the second GPU. + + 2) offload - For dual-GPU laptops, allow direct rendered applications to be run + on the second GPU and display on the first GPU. + + 3) GPU switching - Allow switching between two GPUs as the main screen + renderer. + + 4) multiple GPU rendering - This replaces Xinerama. + +1.5. Introduction to version 1.5 of the extension + +Version 1.5 adds an optional TILE property to outputs. + + • An optional TILE property. + This property is used to denote individual tiles in a tiled monitor + configuration, as exposed via DisplayID v1.3. + +Version 1.5 adds monitors + + • A 'Monitor' is a rectangular subset of the screen which represents + a coherent collection of pixels presented to the user. + + • Each Monitor is associated with a list of outputs (which may be + empty). + + • When clients define monitors, the associated outputs are removed from + existing Monitors. If removing the output causes the list for that + monitor to become empty, that monitor will be deleted. + + • For active CRTCs that have no output associated with any + client-defined Monitor, one server-defined monitor will + automatically be defined of the first Output associated with them. + + • When defining a monitor, setting the geometry to all zeros will + cause that monitor to dynamically track the bounding box of the + active outputs associated with them + +This new object separates the physical configuration of the hardware +from the logical subsets of the screen that applications should +consider as single viewable areas. + +1.5.1. Relationship between Monitors and Xinerama + +Xinerama's information now comes from the Monitors instead of directly +from the CRTCs. The Monitor marked as Primary will be listed first. + +1.5.2. Clarification of Output lifetimes + +With dynamic connectors being a possibility with the introduction of +DisplayPort multistream (MST), a lot of RandR clients can't handle the +XID BadMatch when a RandR output disappears. This is to clarify that +going forward the X server will not remove outputs dynamically, +just mark them as disconnected. + +1.6. Introduction to version 1.6 of the extension + +Version 1.6 adds resource leasing and non desktop output management. + + • A “Lease” is a collection of crtcs and outputs which are made + available to a client for direct access via kernel KMS and DRM + APIs. This is done by passing a suitable file descriptor back to + the client which has access to those resources. While leased, those + resources aren't used by the X server. + + • A “non-desktop” output is a device which should not normally be + considered as part of the desktop environment. Head-mounted + displays and the Apple "Touch Bar" are examples of such + devices. A desktop environment should be able to discover which + outputs are connected to such devices and, by default, not present + normal desktop applications on them. This is done by having + RRGetOutputInfo report such devices as Disconnected while reporting + all other information about the device correctly. + +1.99 Acknowledgments + +Our thanks to the contributors to the design found on the xpert mailing +list, in particular: + +Alan Hourihane for work on the early implementation +Andrew C. Aitchison for help with the XFree86 DDX implementation +Andy Ritger for early questions about how mergefb/Xinerama work with RandR +Carl Worth for editing the specification and Usenix paper +David Dawes for XFree86 DDX integration work +Thomas Winischhofer for the hardware-accelerated SiS rotation implementation +Matthew Tippett and Kevin Martin for splitting outputs and CRTCs to more +fully expose what video hardware can do +Dave Airlie for the 1.4.0 protocol changes and for working through the +implications of MST monitors and encouraging the introduction of the +'Monitor' concept. + + ❧❧❧❧❧❧❧❧❧❧❧ + +2. Screen change model + +Screens may change dynamically, either under control of this extension, or +due to external events. Examples include: monitors being swapped, pressing a +button to switch from internal display to an external monitor on a laptop, +or, eventually, the hotplug of a display card entirely on buses such as +Cardbus or Express Card which permit hot-swap (which will require other work +in addition to this extension). + +Since the screen configuration is dynamic and asynchronous to the client and +may change at any time RandR provides mechanisms to ensure that your clients +view is up to date with the configuration possibilities of the moment and +enforces applications that wish to control the configuration to prove that +their information is up to date before honoring requests to change the +screen configuration (by requiring a timestamp on the request). + +Interested applications are notified whenever the screen configuration +changes, providing the current size of the screen and subpixel order (see +the Render extension [RENDER]), to enable proper rendering of subpixel +decimated client text to continue, along with a time stamp of the +configuration change. A client must refresh its knowledge of the screen +configuration before attempting to change the configuration after a +notification, or the request will fail. + +To avoid multiplicative explosion between orientation, reflection and sizes, +the sizes are only those sizes in the normal (0) rotation. + +Rotation and reflection and how they interact can be confusing. In Randr, +the coordinate system is rotated in a counter-clockwise direction relative +to the normal orientation. Reflection is along the window system coordinate +system, not the physical screen X and Y axis, so that rotation and +reflection do not interact. The other way to consider reflection is to is +specified in the "normal" orientation, before rotation, if you find the +other way confusing. + +We expect that most clients and toolkits will be oblivious to changes to the +screen structure, as they generally use the values in the connections Display +structure directly. By toolkits updating the values on the fly, we believe +pop-up menus and other pop up windows will position themselves correctly in +the face of screen configuration changes (the issue is ensuring that pop-ups +are visible on the reconfigured screen). + + ❧❧❧❧❧❧❧❧❧❧❧ + +3. Data Types + +The subpixel order and transform data types are shared with the Render +extension, and are documented there. + +The only datatype defined in the original extension is the screen size, +defined in the normal (0 degree) orientation. Several more are added +in later revisions. + + ❧❧❧❧❧❧❧❧❧❧❧ + +4. Errors + +Errors are sent using core X error reports. + +Output + A value for an OUTPUT argument does not name a defined OUTPUT. +CRTC + A value for a CRTC argument does not name a defined CRTC. +Mode + A value for a MODE argument does not name a defined MODE. +Provider + A value for a PROVIDER argument does not name a defined PROVIDER. +Lease + A value for a LEASE argument does not name a defined LEASE + + ❧❧❧❧❧❧❧❧❧❧❧ + +5. Protocol Types + +RRCONFIGSTATUS { Success + InvalidConfigTime + InvalidTime + Failed } + + A value of type RRCONFIGSTATUS returned when manipulating the output + configuration or querying information from the server that has some + time-dependency. + + InvalidConfigTime indicates that the supplied configuration + timestamp does not match the current X server configuration + timestamp. Usually this means that the output configuration has + changed since the timestamp was received by the application. + + InvalidTime indicates that the supplied output reconfiguration time + is earlier than the most recent output reconfiguration request. + Generally this indicates that another application has reconfigured + the output using a later timestamp. + + Failed is returned whenever the operation is unsuccessful for some + other reason. This generally indicates that the requested output + configuration is unsupported by the hardware. The goal is to make + these limitations expressed by the protocol, but when that isn't + possible it is correct to return this error value. If, as a + implementer, you find this error code required, please submit the + hardware constraints that exist so that a future version of the + extension can correctly capture the configuration constraints in + your system. + +ROTATION { Rotate_0 + Rotate_90 + Rotate_180 + Rotate_270 + Reflect_X + Reflect_Y } + + These values are used both to indicate a set of allowed rotations + and reflections as well as to indicate a specific rotation and + reflection combination. + +RRSELECTMASK { RRScreenChangeNotifyMask + RRCrtcChangeNotifyMask (New in version 1.2) + RROutputChangeNotifyMask (New in version 1.2) + RROutputPropertyNotifyMask (New in version 1.2) + RRProviderChangeNotifyMask (New in version 1.4) + RRProviderPropertyNotifyMask (New in version 1.4) + RRResourceChangeNotifyMask (New in version 1.4) } + +SIZEID { CARD16 } + +MODE { XID or None } + +CRTC { XID } + +OUTPUT { XID } + +CONNECTION { Connected, Disconnected, UnknownConnection } + + This value provides an indication of whether an output is actually + connected to a monitor or other presentation device. + + +SCREENSIZE [ widthInPixels, heightInPixels: CARD16 + widthInMillimeters, heightInMillimeters: CARD16 ] + +MODEFLAG { HSyncPositive + HSyncNegative + VSyncPositive + VSyncNegative + Interlace + DoubleScan + CSync + CSyncPositive + CSyncNegative + HSkewPresent + BCast + PixelMultiplex + DoubleClock + ClockDivideBy2 } + +MODEINFO [ id: MODE + name: STRING + width, height: CARD16 + dotClock: CARD32 + hSyncStart, hSyncEnd, hTotal, hSkew: CARD16 + vSyncStart, vSyncEnd, vTotal: CARD16 + modeFlags: SETofMODEFLAG ] + +REFRESH [ rates: LISTofCARD16 ] + + ❧❧❧❧❧❧❧❧❧❧❧ + +5.1 Data Types defined by the Render extension + +These data types use the Render extension definitions; they are shown here +only for convenience: + +SUBPIXELORDER { SubPixelUnknown + SubPixelHorizontalRGB + SubPixelHorizontalBGR + SubPixelVerticalRGB + SubPixelVerticalBGR + SubPixelNone } + +FIXED 32-bit value (top 16 are integer portion, bottom 16 are fraction) + +TRANSFORM [ + p11, p12, p13: FIXED + p21, p22, p23: FIXED + p31, p32, p33: FIXED + ] + + ❧❧❧❧❧❧❧❧❧❧❧ + +5.5. Protocol Types added in version 1.4 of the extension + +PROVIDER { XID } + +PROVIDER_CAPS { SourceOutput, SinkOutput, SourceOffload, SinkOffload } + Capabilities for this provider: + SourceOutput: This device can source output buffers. + SinkOutput: This device can sink output buffers. + SourceOffload: This device can source offload buffers. + SinkOffload: This device can sink offload buffers. + + ❧❧❧❧❧❧❧❧❧❧❧ + +5.6. Protocol Types added in version 1.5 of the extension + +MONITORINFO { name: ATOM + primary: BOOL + automatic: BOOL + x: INT16 + y: INT16 + width: CARD16 + height: CARD16 + width-in-millimeters: CARD32 + height-in-millimeters: CARD32 + outputs: LISTofOUTPUT } + + ❧❧❧❧❧❧❧❧❧❧❧ + +5.7. Protocol Types added in version 1.6 of the extension + +LEASE { XID } + + ❧❧❧❧❧❧❧❧❧❧❧ + +6. Extension Initialization + +The name of this extension is "RANDR". + +┌─── + RRQueryVersion + client-major-version: CARD32 + client-minor-version: CARD32 + ▶ + major-version: CARD32 + minor-version: CARD32 +└─── + + The client sends the highest supported version to the server + and the server sends the highest version it supports, but no + higher than the requested version. Major versions changes can + introduce incompatibilities in existing functionality, minor + version changes introduce only backward compatible changes. + It is the clients responsibility to ensure that the server + supports a version which is compatible with its expectations. + + ❧❧❧❧❧❧❧❧❧❧❧ + +7. Extension Requests + +┌─── + RRSelectInput + window: WINDOW + enable: SETofRRSELECTMASK +└─── + Errors: Window, Value + + If 'enable' is RRScreenChangeNotifyMask, RRScreenChangeNotify events + will be sent when the screen configuration changes, either from + this protocol extension, or due to detected external screen + configuration changes. RRScreenChangeNotify may also be sent when + this request executes if the screen configuration has changed since + the client connected, to avoid race conditions. + + New for version 1.2: + + If 'enable' contains RRCrtcChangeNotifyMask, RRCrtcChangeNotify events + will be sent when the configuration for a CRTC associated with the + screen changes, either through this protocol extension or due to + detected external changes. RRCrtcChangeNotify may also be sent when + this request executes if the CRTC configuration has changed since + the client connected, to avoid race conditions. + + If 'enable' contains RROutputChangeNotifyMask, RROutputChangeNotify + events will be sent when the configuration for an output associated with + the screen changes, either through this protocol extension or due to + detected external changes. RROutputChangeNotify may also be sent when + this request executes if the output configuration has changed since the + client connected, to avoid race conditions. + + If 'enable' contains RROutputPropertyNotifyMask, + RROutputPropertyNotify events will be sent when properties change on + this output. + + New for version 1.4: + + If 'enable' contains RRProviderChangeNotifyMask, + RRProviderChangeNotify events will be sent whenever the role for a + provider object has changed. + + If 'enable' contains RRProviderPropertyNotifyMask, + RRProviderPropertyNotify events will be sent when properties change + on a provider object. + + If 'enable' contains RRResourceChangeNotifyMask, + RRResourceChangeNotify events will be sent whenever the set of + available RandR resources associated with the screen has changed. + +┌─── + RRSetScreenConfig + window: WINDOW + timestamp: TIMESTAMP + config-timestamp: TIMESTAMP + size-id: SIZEID + rotation: ROTATION + rate: CARD16 + ▶ + status: RRCONFIGSTATUS + new-timestamp: TIMESTAMP + config-timestamp: TIMESTAMP + root: WINDOW + subpixelOrder: SUBPIXELORDER +└─── + Errors: Value, Match + + If 'timestamp' is less than the time when the configuration was last + successfully set, the request is ignored and InvalidTime returned in + status. + + If 'config-timestamp' is not equal to when the server's screen + configurations last changed, the request is ignored and + InvalidConfigTime returned in status. This could occur if the + screen changed since you last made a RRGetScreenInfo request, + perhaps by a different piece of display hardware being installed. + Rather than allowing an incorrect call to be executed based on stale + data, the server will ignore the request. + + 'rate' contains the desired refresh rate. If it is zero, the server + selects an appropriate rate. + + This request may fail for other indeterminate reasons, in which case + 'status' will be set to Failed and no configuration change will be + made. + + This request sets the screen to the specified size, rate, rotation + and reflection. + + When this request succeeds, 'status' contains Success and the + requested changes to configuration will have been made. + + 'new-time-stamp' contains the time at which this request was + executed. + + 'config-timestamp' contains the time when the possible screen + configurations were last changed. + + 'root' contains the root window for the screen indicated by the + window. + + 'subpixelOrder' contains the resulting subpixel order of the screen + to allow correct subpixel rendering. + + Value errors are generated when 'rotation', 'rate' or 'size-id' + are invalid. + +┌─── + RRGetScreenInfo + window: WINDOW + ▶ + rotations: SETofROTATION + root: WINDOW + timestamp: TIMESTAMP + config-timestamp: TIMESTAMP + size-id: SIZEID + rotation: ROTATION + rate: CARD16 + sizes: LISTofSCREENSIZE + refresh: LISTofREFRESH +└─── + + Errors: Window + + RRGetScreenInfo returns information about the current and available + configurations for the screen associated with 'window'. + + 'rotations' contains the set of rotations and reflections supported + by the screen. + + 'root' is the root window of the screen. + + 'config-timestamp' indicates when the screen configuration + information last changed: requests to set the screen will fail + unless the timestamp indicates that the information the client + is using is up to date, to ensure clients can be well behaved + in the face of race conditions. + + 'timestamp' indicates when the configuration was last set. + + 'size-id' indicates which size is active. + + 'rate' is the current refresh rate. This is zero when the refresh + rate is unknown or on devices for which refresh is not relevant. + + 'sizes' is the list of possible frame buffer sizes (at the normal + orientation). Each size indicates both the linear physical size of + the screen and the pixel size. + + 'refresh' is the list of refresh rates for each size. Each element + of 'sizes' has a corresponding element in 'refresh'. An empty list + indicates no known rates, or a device for which refresh is not + relevant. + + The default size of the screen (the size that would become the + current size when the server resets) is the first size in the + list. + +7.1. Extension Requests added in version 1.2 of the extension + +As introduced above, version 1.2 of the extension splits the screen size +from the crtc and output configuration, permitting the subset of the screen +presented by multiple outputs to be configured. As a separate notion, the +size of the screen itself may be arbitrarily configured within a defined +range. As crtcs and outputs are added and removed from the system, the set +returned by the extension will change so that applications can detect +dynamic changes in the display environment. + +┌─── + RRGetScreenSizeRange + window: WINDOW + ▶ + CARD16 minWidth, minHeight + CARD16 maxWidth, maxHeight +└─── + Errors: Window + + Returns the range of possible screen sizes. The screen may be set to + any size within this range. + +┌─── + RRSetScreenSize + window: WINDOW + width: CARD16 + height: CARD16 + width-in-millimeters: CARD32 + height-in-millimeters: CARD32 +└─── + Errors: Window, Match, Value + + Sets the screen to the specified size. 'width' and 'height' must be + within the range allowed by GetScreenSizeRanges, otherwise a Value + error results. All active monitors must be configured to display a + subset of the specified size, else a Match error results. + + 'width-in-millimeters' and 'height-in-millimeters' can be set to + reflect the physical size of the screen reported both through this + extension and the core protocol. They must be non-zero, or Value + error results. + + If panning is enabled, the width and height of the panning and the + tracking areas are adapted to the new size and clamped afterwards. + Disabled panning axes remain disabled. + Panning borders are disabled if their requirements are no longer met + (see RRSetPanning). + +┌─── + RRGetScreenResources + window: WINDOW + ▶ + timestamp: TIMESTAMP + config-timestamp: TIMESTAMP + crtcs: LISTofCRTC + outputs: LISTofOUTPUT + modes: LISTofMODEINFO +└─── + Errors: Window + + RRGetScreenResources returns the list of outputs and crtcs connected + to the screen associated with 'window'. + + 'timestamp' indicates when the configuration was last set. + + 'config-timestamp' indicates when the configuration information last + changed. Requests to configure the output will fail unless the + timestamp indicates that the information the client is using is up + to date, to ensure clients can be well behaved in the face of race + conditions. + + 'crtcs' contains the list of CRTCs associated with the screen. + + 'outputs' contains the list of outputs associated with the screen. + + 'modes' contains the list of modes associated with the screen + + This request explicitly asks the server to ensure that the + configuration data is up-to-date wrt the hardware. If that requires + polling, this is when such polling would take place. If the + current configuration is all that's required, use + RRGetScreenResourcesCurrent instead. + +┌─── + RRGetOutputInfo + output: OUTPUT + config-timestamp: TIMESTAMP + ▶ + status: RRCONFIGSTATUS + timestamp: TIMESTAMP + crtc: CRTC + + name: STRING + connection: CONNECTION + subpixel-order: SUBPIXELORDER + widthInMillimeters, heightInMillimeters: CARD32 + crtcs: LISTofCRTC + clones: LISTofOUTPUT + modes: LISTofMODE + num-preferred: CARD16 +└─── + Errors: Output + + RRGetOutputInfo returns information about the current and available + configurations 'output'. + + If 'config-timestamp' does not match the current configuration + timestamp (as returned by RRGetScreenResources), 'status' is set to + InvalidConfigTime and the remaining reply data is empty. Otherwise, + 'status' is set to Success. + + 'timestamp' indicates when the configuration was last set. + + 'crtc' is the current source CRTC for video data, or Disabled if the + output is not connected to any CRTC. + + 'name' is a UTF-8 encoded string designed to be presented to the + user to indicate which output this is. E.g. "S-Video" or "DVI". + + 'connection' indicates whether the hardware was able to detect a + device connected to this output. If the hardware cannot determine + whether something is connected, it will set this to + UnknownConnection. + + 'subpixel-order' contains the resulting subpixel order of the + connected device to allow correct subpixel rendering. + + 'widthInMillimeters' and 'heightInMillimeters' report the physical + size of the displayed area. If unknown, or not really fixed (e.g., + for a projector), these values are both zero. + + 'crtcs' is the list of CRTCs that this output may be connected to. + Attempting to connect this output to a different CRTC results in a + Match error. + + 'clones' is the list of outputs which may be simultaneously + connected to the same CRTC along with this output. Attempting to + connect this output with an output not in the 'clones' list + results in a Match error. + + 'modes' is the list of modes supported by this output. Attempting to + connect this output to a CRTC not using one of these modes results + in a Match error. + + The first 'num-preferred' modes in 'modes' are preferred by the + monitor in some way; for fixed-pixel devices, this would generally + indicate which modes match the resolution of the output device. + + Changes in version 1.6 of the protocol: + + When a “non-desktop” device is connected, the 'connection' + field will report Disconnected but the remaining fields will + report information about the connected device. + +┌─── + RRListOutputProperties + output:OUTPUT + ▶ + atoms: LISTofATOM +└─── + Errors: Output + + This request returns the atoms of properties currently defined on + the output. + + Changes in version 1.6 of the protocol: + + When a “non-desktop” device is connected, the property list + will be correct for the device, even though RRGetOutputInfo + reports the device as disconnected. + +┌─── + RRQueryOutputProperty + output: OUTPUT + property: ATOM + ▶ + pending: BOOL + range: BOOL + immutable: BOOL + valid-values: LISTofINT32 +└─── + Errors: Name, Atom, Output + + If the specified property does not exist for the specified output, + then a Name error is returned. + + If 'pending' is TRUE, changes made to property values with + RRChangeOutputProperty will be saved in the pending property value + and be automatically copied to the current value on the next + RRSetCrtcConfig request involving the named output. If 'pending' is + FALSE, changes are copied immediately. + + If 'range' is TRUE, then the valid-values list will contain + precisely two values indicating the minimum and maximum allowed + values. If 'range' is FALSE, then the valid-values list will contain + the list of possible values; attempts to set other values will + result in a Value error. + + If 'immutable' is TRUE, then the property configuration cannot be + changed by clients. Immutable properties are interpreted by the X + server. + + Changes in version 1.6 of the protocol: + + When a “non-desktop” device is connected, the property information + will be correct for the device, even though RRGetOutputInfo + reports the device as disconnected. + +┌─── + RRConfigureOutputProperty + output: OUTPUT + property: ATOM + pending: BOOL + range: BOOL + valid-values: LISTofINT32 +└─── + Errors: Access, Name, Atom, Output + + If the specified property is 'immutable', an Access error is + returned. + + Otherwise, the configuration of the specified property is changed to + the values provided in this request. + + If the specified property does not exist for the specified output, + it is created with an empty value and None type. + +┌─── + RRChangeOutputProperty + output: OUTPUT + property, type: ATOM + format: {8, 16, 32} + mode: { Replace, Prepend, Append } + data: LISTofINT8 or LISTofINT16 or LISTofINT32 +└─── + Errors: Alloc, Atom, Match, Value, Output + + This request alters the value of the property for the specified + output. If the property is marked as a 'pending' property, only the + pending value of the property is changed. Otherwise, changes are + reflected in both the pending and current values of the property. + The type is uninterpreted by the server. The format specifies + whether the data should be viewed as a list of 8-bit, 16-bit, or + 32-bit quantities so that the server can correctly byte-swap as + necessary. + + If the mode is Replace, the previous property value is discarded. + If the mode is Prepend or Append, then the type and format must + match the existing property value (or a Match error results). If + the property is undefined, it is treated as defined with the correct + type and format with zero-length data. + + For Prepend, the data is tacked on to the beginning of the existing + data, and for Append, it is tacked on to the end of the existing data. + + This request generates a OutputPropertyNotify + + The lifetime of a property is not tied to the storing client. + Properties remain until explicitly deleted, until the output is + destroyed, or until server reset (see section 10). + + The maximum size of a property is server-dependent and may vary + dynamically. + +┌─── + RRDeleteOutputProperty + output: OUTPUT + property: ATOM +└─── + Errors: Atom, Output + + This request deletes the property from the specified window if the + property exists and generates a OutputPropertyNotify event unless + the property does not exist. + +┌─── + RRGetOutputProperty + output: OUTPUT + property: ATOM + type: ATOM or AnyPropertyType + long-offset, long-length: CARD32 + delete: BOOL + pending: BOOL + ▶ + type: ATOM or None + format: {0, 8, 16, 32} + bytes-after: CARD32 + value: LISTofINT8 or LISTofINT16 or LISTofINT32 +└─── + Errors: Atom, Value, Output + + If the specified property does not exist for the specified output, + then the return type is None, the format and bytes-after are zero, + and the value is empty. The delete argument is ignored in this + case. + + If the specified property exists but its type does not match the + specified type, then the return type is the actual type of the + property, the format is the actual format of the property (never + zero), the bytes-after is the length of the property in bytes (even + if the format is 16 or 32), and the value is empty. The delete + argument is ignored in this case. + + If the specified property exists and either AnyPropertyType is + specified or the specified type matches the actual type of the + property, then the return type is the actual type of the property, + the format is the actual format of the property (never zero), and + the bytes-after and value are as follows, given: + + N = actual length of the stored property in bytes + (even if the format is 16 or 32) + I = 4 × offset + T = N - I + L = MINIMUM(T, 4 × long-length) + A = N - (I + L) + + If 'pending' is true, and if the property holds a pending value, + then the value returned will be the pending value of the property + rather than the current value. The returned value starts at byte + index I in the property (indexing from 0), and its length in bytes + is L. However, it is a Value error if long-offset is given such + that L is negative. The value of bytes-after is A, giving the + number of trailing unread bytes in the stored property. If delete + is True and the bytes-after is zero, the property is also deleted + from the output, and a RROutputPropertyNotify event is generated. + + Changes in version 1.6 of the protocol: + + When a “non-desktop” device is connected, the property value + will be correct for the device, even though RRGetOutputInfo + reports the device as disconnected. + +┌─── + RRCreateMode + window: WINDOW + modeinfo: MODEINFO + ▶ + mode: MODE +└─── + Errors: Window, Name, Value + + 'modeinfo' provides a new mode for outputs on the screen + associated with 'window'. If the name of 'modeinfo' names an + existing mode, a Name error is returned. If some parameter of the + mode is not valid in some other way, a Value error is returned. + + The returned 'mode' provides the id for the mode. + +┌─── + RRDestroyMode + mode: MODE +└─── + Errors: Mode, Access + + The user-defined 'mode' is destroyed. 'mode' must name a mode + defined with RRCreateMode, else an Match error is returned. If + 'mode' is in use by some CRTC or Output, then an Access error is + returned. + +┌─── + RRAddOutputMode + output: OUTPUT + mode: MODE +└─── + Errors: Output, Mode, Match + + 'output' indicates which output is to be configured. + + 'mode' specifies which mode to add. If 'mode' is not valid for + 'output', then a Match error is generated. + + This request generates OutputChangeNotify events. + +┌─── + RRDeleteOutputMode + output: OUTPUT + mode: MODE +└─── + Errors: Output, Mode + + 'output' indicates which output is to be configured. + + 'mode' specifies which mode to delete. 'mode' must have been added + with RRAddOutputMode, else an Access error is returned. 'mode' must + not be active, else a Match error is returned. + + This request generates OutputChangeNotify events. + +┌─── + RRGetCrtcInfo + crtc: CRTC + config-timestamp: TIMESTAMP + ▶ + status: RRCONFIGSTATUS + timestamp: TIMESTAMP + x, y: INT16 + width, height: CARD16 + mode: MODE + rotation: ROTATION + outputs: LISTofOUTPUT + + rotations: SETofROTATION + possible-outputs: LISTofOUTPUT +└─── + + Errors: Window + + RRGetCrtcInfo returns information about the current and available + configurations for the specified crtc connected to the screen + associated with 'window'. + + If 'config-timestamp' does not match the current configuration + timestamp (as returned by RRGetScreenResources), 'status' is set to + InvalidConfigTime and the remaining reply data is empty. Otherwise, + 'status' is set to Success. + + 'timestamp' indicates when the configuration was last set. + + 'x' and 'y' indicate the position of this CRTC within the screen + region. They will be set to 0 when the CRTC is disabled. + + 'width' and 'height' indicate the size of the area within the screen + presented by this CRTC. This may be different than the size of the + mode due to rotation, the projective transform, and the Border property + described below. They will be set to 0 when the CRTC is disabled. + + 'mode' indicates which mode is active, or None indicating that the + CRTC has been disabled and is not displaying the screen contents. + + 'rotation' indicates the active rotation. It is set to Rotate_0 + when the CRTC is disabled. + + 'outputs' is the list of outputs currently connected to this CRTC + and is empty when the CRTC is disabled. + + 'rotations' contains the set of rotations and reflections supported + by the CRTC. + + 'possible-outputs' lists all of the outputs which may be connected + to this CRTC. + +┌─── + RRSetCrtcConfig + crtc: CRTC + timestamp: TIMESTAMP + config-timestamp: TIMESTAMP + x, y: INT16 + mode: MODE + rotation: ROTATION + outputs: LISTofOUTPUT + ▶ + status: RRCONFIGSTATUS + new-timestamp: TIMESTAMP +└─── + Errors: Value, Match + + If 'timestamp' is less than the time when the configuration was last + successfully set, the request is ignored and InvalidTime returned in + status. + + If 'config-timestamp' is not equal to when the monitor's + configuration last changed, the request is ignored and + InvalidConfigTime returned in status. This could occur if the + monitor changed since you last made a RRGetScreenInfo request, + perhaps by a different monitor being connected to the machine. + Rather than allowing an incorrect call to be executed based on stale + data, the server will ignore the request. + + 'x' and 'y' contain the desired location within the screen for this + monitor's content. 'x' and 'y' must be within the screen size, else + a Value error results. + + 'mode' is either the desired mode or None indicating the CRTC should + be disabled. If 'mode' is not one of these values, a Value + error results. 'mode' must be valid for all of the configured outputs, + else a Match error. + + 'rotation' contains the desired rotation along with which + reflections should be enabled. The rotation and reflection values + must be among those allowed for this monitor, else a Value error + results. + + 'outputs' contains the set of outputs that this CRTC should be + connected to. The set must be among the list of acceptable output + sets for this CRTC or a Match error results. + + If 'mode' is None, then 'outputs' must be empty, else a Match error + results. Conversely, if 'mode' is not None, then 'outputs' must not be + empty, else a Match error results. + + This request may fail for other indeterminate reasons, in which case + 'status' will be set to Failed and no configuration change will be + made. + + This request sets the CRTC to the specified position, mode, rotation + and reflection. The entire area of the CRTC must fit within the + screen size, else a Match error results. As an example, rotating the + screen so that a single CRTC fills the entire screen before and + after may necessitate disabling the CRTC, resizing the screen, + then re-enabling the CRTC at the new configuration to avoid an + invalid intermediate configuration. + + If panning is enabled, the width and height of the panning and the + tracking areas are clamped to the new mode size. + Disabled panning axes remain disabled. + Panning borders are disabled if their requirements are no longer met + (see RRSetPanning). + + When this request succeeds, 'status' contains Success and the + requested changes to configuration will have been made. + + 'new-time-stamp' contains the time at which this request was + executed. + +┌─── + RRGetCrtcGammaSize + crtc: CRTC + ▶ + size: CARD16 +└─── + Errors: Crtc + + This request returns the size of the gamma ramps used by 'crtc'. + +┌─── + RRGetCrtcGamma + crtc: CRTC + ▶ + red: LISTofCARD16 + green: LISTofCARD16 + blue: LISTofCARD16 +└─── + Errors: Crtc + + This request returns the currently set gamma ramps for 'crtc'. All + three lists will be the size returned by the RRGetCrtcGammaSize + request. + +┌─── + RRSetCrtcGamma + crtc: CRTC + red: LISTofCARD16 + green: LISTofCARD16 + blue: LISTofCARD16 +└─── + Errors: Crtc, Match + + This request sets the gamma ramps for 'crtc'. All three lists + must be the size returned by RRGetCrtcGammaSize else a Value error + results. + +7.2. Extension Requests added in version 1.3 of the extension + +┌─── + RRGetScreenResourcesCurrent + window: WINDOW + ▶ + timestamp: TIMESTAMP + config-timestamp: TIMESTAMP + crtcs: LISTofCRTC + outputs: LISTofOUTPUT + modes: LISTofMODEINFO +└─── + Errors: Window + + RRGetScreenResourcesCurrent returns the list of outputs and crtcs + connected to the screen associated with 'window'. + + 'timestamp' indicates when the configuration was last set. + + 'config-timestamp' indicates when the configuration information last + changed. Requests to configure the output will fail unless the + timestamp indicates that the information the client is using is up + to date, to ensure clients can be well behaved in the face of race + conditions. + + 'crtcs' contains the list of CRTCs associated with the screen. + + 'outputs' contains the list of outputs associated with the screen. + + 'modes' contains the list of modes associated with the screen. + + Unlike RRGetScreenResources, this merely returns the current + configuration, and does not poll for hardware changes. + +┌─── + RRSetCrtcTransform + crtc: CRTC + transform: TRANSFORM + filter: STRING8 + values: LISTofFIXED +└─── + Errors: Crtc, Match + + This request provides a mechanism that is more general than the + existing rotation and reflection values for describing the + transformation from frame buffer image to crtc presentation. + 'transform' is a full 2D projective transformation from screen + coordinate space to crtc coordinate space. This transformation is + applied before the rotation and reflection values to compute the + complete transform. + + 'filter' and 'values' specify a Render filter that may be used by the + server when transforming data from frame buffer to crtc. + + This request sets the transform to be used at the next + RRSetCrtcConfig request execution; it does not cause any change to + occur in the current configuration. + + When a non-identity transformation is in use, the rectangle returned + by RRGetCrtcInfo defines the bounding rectangle of the screen that is + projected to the crtc. It is this projected rectangle which must be + within the area of the screen when the mode is set. + +┌─── + RRGetCrtcTransform + crtc: CRTC + ▶ + pending-transform: TRANSFORM + pending-filter: STRING8 + pending-values: LISTofFIXED + current-transform: TRANSFORM + current-filter: STRING8 + current-values: LISTofFIXED +└─── + + This request returns the pending and current transforms for the + specified CRTC. The pending transform will be the same as the current + transform if no new pending transform has been set since the last call + to RRSetCrtcConfig. + +┌─── + RRGetPanning + crtc: CRTC + ▶ + status: RRCONFIGSTATUS + timestamp: TIMESTAMP + left, top, width, height: CARD16 + track_left, track_top, track_width, track_height: CARD16 + border_left, border_top, border_right, border_bottom: INT16 +└─── + + Errors: Crtc + + Version 1.3 adds panning support again. If multiple crtcs are active + the panning behavior can be defined per crtc individually. + RRGetPanning returns information about the currently set panning + configuration for the specified crtc. If the CRTC does not support + panning, all fields (except timestamp) will be 0. + + 'timestamp' indicates when the configuration was last set. + + All other entries are explained for RRSetPanning. + +┌─── + RRSetPanning + crtc: CRTC + timestamp: TIMESTAMP + left, top, width, height: CARD16 + track_left, track_top, track_width, track_height: CARD16 + border_left, border_top, border_right, border_bottom: INT16 + ▶ + status: RRCONFIGSTATUS + new-timestamp: TIMESTAMP +└─── + Errors: Crtc, Match + + This request sets the panning parameters. As soon as panning is + enabled, the CRTC position can change with every pointer move. + RRCrtcChangeNotify events are sent to the clients requesting those. + + If 'timestamp' is less than the time when the configuration was last + successfully set, the request is ignored and InvalidTime returned in + status. + + ┌──┳━━━━━━━━━━━━━━┳─────┬ ─ ─ ─ ─ ─ ┐ + │ ┃ CRTC ┃ │ + │ ┃ ┃ │ │ + │ ┃ X┃→ │ + │ ┃ ┃ │ │ framebuffer + │ ┗━━━━━━━━━━━━━━┛ │ + │ │ │ + │panning area │ + └───────────────────────┴ ─ ─ ─ ─ ─ ┘ + + 'left', 'top', 'width', and 'height' contain the total panning area + for this CRTC. 'width' has to be larger than or equal to the CRTC's + width or 0, and 'left'+'width' must be within the screen size, else a + Match error results. Equivalent restrictions for the height exist. + 'width' or 'height' set to 0 indicate that panning should be disabled + on the according axis. Setting 'width'/'height' to the CRTC's + width/height will disable panning on the X/Y axis as well, but + RRSetScreenSize will silently enable panning if the screen size is + increased. This does not happen if set to 0. + + ┌────────┳━━━━━━━━━━━━━━┳ ─ ─ ─ ─ ─ ┐ + │ ┃ CRTC ┃ + │ ┃ ┃ │ + │ ┃ ┃ + │ ┃ ┃ │ tracking area + │ ┗━━━━━━━━━━━━━━┫ X + │ ↓ │ ↓ │ + │panning area │ + └───────────────────────┴ ─ ─ ─ ─ ─ ┘ + + 'track_left', 'track_top', 'track_width', and 'track_height' contain + the pointer area for which the panning region is updated. For normal + use cases it should enclose the panning area minus borders, and is + typically set to either the panning area minus borders, or to the + total screen size. If set to the total screen size, the CRTC will pan + in the remaining axis even if the pointer is outside the panning area + on a different CRTC, as shown in the figure above. If the pointer is + outside the tracking area, the CRTC will not pan. Zero can be used as + an alias for the total screen size. + + ┌──┳━━━━━━━━━━━━━━┳────────────┐ + │ ┃ CRTC ┃ │ + │ ┃ ┃ │ + │ ┃ ┃→ │ + │ ┃ X←→┃ │ + │ ┃ border_right │ + │ ┗━━━━━━━━━━━━━━┛ │ + │ │ + │panning area │ + └──────────────────────────────┘ + + 'border_left', 'border_top', 'border_right', and 'border_bottom' + define the distances from the CRTC borders that will activate panning + if the pointer hits them. If the borders are 0, the screen will pan + when the pointer hits the CRTC borders (behavior of pre-RandR Xserver + panning). If the borders are positive, the screen will pan when the + pointer gets close to the CRTC borders, if they are negative, the + screen will only pan when the pointer is already way past the CRTC + borders. Negative values might confuse users and disable panning to + the very edges of the screen. Thus they are discouraged. + border_left + border_right has to be lower or equal than the CRTC's + width, else a Match error results. An equivalent restriction for the + height exists. + + Screen size changes update the panning and the tracking areas to the + new size. Both screen size changes and mode changes clamp these areas + to the current CRTC size. In these cases panning borders are disabled + if their requirements are no longer met. + + When this request succeeds, 'status' contains Success and the + requested changes to configuration will have been made. + + 'new-time-stamp' contains the time at which this request was + executed. + +┌─── + RRSetOutputPrimary + window: WINDOW + output: OUTPUT +└─── + Errors: Match, Output, Window + + RRSetOutputPrimary marks 'output' as the primary output for the + screen with the same root window as 'window'. This output's CRTC + will be sorted to the front of the list in Xinerama and RANDR + geometry requests for the benefit of older applications. The + default primary output is None, and None is a legal value to pass + to RRSetOutputPrimary. This request is expected to be used by + desktop environments to mark the screen that should hold the primary + menu bar or panel. + + As this changes the logical layout of the screen, ConfigureNotify + and RRScreenChangeNotify will be generated on the appropriate root + window when the primary output is changed by this call. This request + also generates RROutputChangeNotify events on the outputs that gained + and lost primary status. + + If an output is disconnected asynchronously (eg. due to recabling), + the primary status does not change, but RROutputChangeNotify events + will be generated if the hardware is capable of detecting this; + clients are expected to reconfigure if appropriate. + + If an output is deleted (eg. due to device hotplug), the server will + act as though None was passed to RRSetOutputPrimary, including + generating the appropriate events. + +┌─── + RRGetOutputPrimary + window: WINDOW + ▶ + output: OUTPUT +└─── + Errors: Window + + RRGetOutputPrimary returns the primary output for the screen. + + ❧❧❧❧❧❧❧❧❧❧❧ + +7.4 Extension Requests added in version 1.4 of the extension. + +┌─── + RRGetProviders + window : WINDOW + ▶ + timestamp: TIMESTAMP + providers: LISTofPROVIDER +└─── + Errors: Window + + RRGetProviders returns the list of providers connected to the screen + associated with 'window'. + + 'timestamp' indicates when the configuration was last set. + + 'providers' contains the list of PROVIDERs associated with the + screen. + +┌─── + RRGetProviderInfo + provider: PROVIDER + ▶ + capabilities: PROVIDER_CAPS + name: STRING + crtcs: LISTofCRTC + outputs: LISTofOUTPUT + associated_providers: LISTofPROVIDERS + associated_provider_capability: LISTofPROVIDER_CAPS +└─── + Errors: Provider + + RRGetProviderInfo return information about the specified provider. + The capabilities of the current provider are returned, along with + the list of providers currently associated with this provider and + the capability they are associated with. It also provides the list + of crtcs and outputs that this provider is responsible for. + + 'name' is a UTF-8 encoded string to be presented to the user to + indicate the device or driver supplied name. + +┌─── + RRSetProviderOffloadSink + provider: PROVIDER + sink_provider: PROVIDER + config-timestamp: TIMESTAMP +└─── + Errors: Provider + + RRSetOffloadSink sets the offload sink for this provider to the + specified provider. + +┌─── + RRSetProviderOutputSource + provider: PROVIDER + source_provider: PROVIDER + config-timestamp: TIMESTAMP +└─── + Errors: Provider + + RRSetOutputSource sets the output source for this provider to the + specified provider. + +┌─── + RRListProviderProperties + provider:PROVIDERS + ▶ + atoms: LISTofATOM +└─── + Errors: Provider + + This request returns the atoms of properties currently defined on + the provider. + +┌─── + RRQueryProviderProperty + provider: PROVIDER + property: ATOM + ▶ + pending: BOOL + range: BOOL + immutable: BOOL + valid-values: LISTofINT32 +└─── + Errors: Name, Atom, Provider + + If the specified property does not exist for the specified provider, + then a Name error is returned. + + If 'pending' is TRUE, changes made to property values with + RRChangeProviderProperty will be saved in the pending property value + and be automatically copied to the current value on the next + RRSetCrtcConfig request on a crtc attached to that provider. + If 'pending' is FALSE, changes are copied immediately. + + If 'range' is TRUE, then the valid-values list will contain + precisely two values indicating the minimum and maximum allowed + values. If 'range' is FALSE, then the valid-values list will contain + the list of possible values; attempts to set other values will + result in a Value error. + + If 'immutable' is TRUE, then the property configuration cannot be + changed by clients. Immutable properties are interpreted by the X + server. + +┌─── + RRConfigureProviderProperty + provider: PROVIDER + property: ATOM + pending: BOOL + range: BOOL + valid-values: LISTofINT32 +└─── + Errors: Access, Name, Atom, Provider + + If the specified property is 'immutable', an Access error is + returned. + + Otherwise, the configuration of the specified property is changed to + the values provided in this request. + + If the specified property does not exist for the specified provider, + it is created with an empty value and None type. + +┌─── + RRChangeProviderProperty + provider: PROVIDER + property, type: ATOM + format: {8, 16, 32} + mode: { Replace, Prepend, Append } + data: LISTofINT8 or LISTofINT16 or LISTofINT32 +└─── + Errors: Alloc, Atom, Match, Value, Provider + + This request alters the value of the property for the specified + provider. If the property is marked as a 'pending' property, only the + pending value of the property is changed. Otherwise, changes are + reflected in both the pending and current values of the property. + The type is uninterpreted by the server. The format specifies + whether the data should be viewed as a list of 8-bit, 16-bit, or + 32-bit quantities so that the server can correctly byte-swap as + necessary. + + If the mode is Replace, the previous property value is discarded. + If the mode is Prepend or Append, then the type and format must + match the existing property value (or a Match error results). If + the property is undefined, it is treated as defined with the correct + type and format with zero-length data. + + For Prepend, the data is tacked on to the beginning of the existing + data, and for Append, it is tacked on to the end of the existing data. + + This request generates a ProviderPropertyNotify + + The lifetime of a property is not tied to the storing client. + Properties remain until explicitly deleted, until the provider is + destroyed, or until server reset (see section 10). + + The maximum size of a property is server-dependent and may vary + dynamically. +┌─── + RRDeleteProviderProperty + provider: Provider + property: ATOM +└─── + Errors: Atom, Provider + + This request deletes the property from the specified provider if the + property exists and generates a ProviderPropertyNotify event unless + the property does not exist. + +┌─── + RRGetProviderProperty + provider: PROVIDER + property: ATOM + type: ATOM or AnyPropertyType + long-offset, long-length: CARD32 + delete: BOOL + pending: BOOL + ▶ + type: ATOM or None + format: {0, 8, 16, 32} + bytes-after: CARD32 + value: LISTofINT8 or LISTofINT16 or LISTofINT32 +└─── + Errors: Atom, Value, Provider + + If the specified property does not exist for the specified provider, + then the return type is None, the format and bytes-after are zero, + and the value is empty. The delete argument is ignored in this + case. + + If the specified property exists but its type does not match the + specified type, then the return type is the actual type of the + property, the format is the actual format of the property (never + zero), the bytes-after is the length of the property in bytes (even + if the format is 16 or 32), and the value is empty. The delete + argument is ignored in this case. + + If the specified property exists and either AnyPropertyType is + specified or the specified type matches the actual type of the + property, then the return type is the actual type of the property, + the format is the actual format of the property (never zero), and + the bytes-after and value are as follows, given: + + N = actual length of the stored property in bytes + (even if the format is 16 or 32) + I = 4 × offset + T = N - I + L = MINIMUM(T, 4 × long-length) + A = N - (I + L) + + If 'pending' is true, and if the property holds a pending value, + then the value returned will be the pending value of the property + rather than the current value. The returned value starts at byte + index I in the property (indexing from 0), and its length in bytes + is L. However, it is a Value error if long-offset is given such + that L is negative. The value of bytes-after is A, giving the + number of trailing unread bytes in the stored property. If delete + is True and the bytes-after is zero, the property is also deleted + from the provider, and a RRProviderPropertyNotify event is generated. + + + ❧❧❧❧❧❧❧❧❧❧❧ + +7.5. Extension Requests added in version 1.5 of the extension. + +┌─── + RRGetMonitors + window : WINDOW + get_active : BOOL + ▶ + timestamp: TIMESTAMP + monitors: LISTofMONITORINFO +└─── + Errors: Window + + Returns the list of Monitors for the screen containing + 'window'. If 'get_active' is set it returns only active + monitors (non-0x0 monitors). 'get_active' should always + be set by toolkits, and not by configuration clients. + + 'timestamp' indicates the server time when the list of + monitors last changed. + +┌─── + RRSetMonitor + window : WINDOW + info: MONITORINFO +└─── + Errors: Window, Output, Atom, Value + + Create a new monitor. Any existing Monitor of the same name is deleted. + + 'name' must be a valid atom or an Atom error results. + + 'name' must not match the name of any Output on the screen, or + a Value error results. + + If 'info.outputs' is non-empty, and if x, y, width, height are all + zero, then the Monitor geometry will be dynamically defined to + be the bounding box of the geometry of the active CRTCs + associated with them. + + If 'name' matches an existing Monitor on the screen, the + existing one will be deleted as if RRDeleteMonitor were called. + + If an 'info.output' contains only the automatically generated default + monitor, this is replaced by the new monitor. If the 'info.output' already + contains a user-defined monitor, the new monitor will be added. + This allows to have more than one monitor on an output (e.g. to split an + output into multiple virtual monitors). + + Only one monitor per screen may be primary. If 'info.primary' + is true, then the primary value will be set to false on all + other monitors on the screen. + + RRSetMonitor generates a ConfigureNotify event on the root + window of the screen. + +┌─── + RRDeleteMonitor + window : WINDOW + name: ATOM +└─── + Errors: Window, Atom, Value + + Deletes the named Monitor. + + 'name' must be a valid atom or an Atom error results. + + 'name' must match the name of a Monitor on the screen, or a + Value error results. + + If the last user-defined monitor is removed from an 'info.output', + the automatically generated default monitor will be restored. It is not + possible to delete the automatically generated default monitor. + + RRDeleteMonitor generates a ConfigureNotify event on the root + window of the screen. + + ❧❧❧❧❧❧❧❧❧❧❧ + +7.6. Extension Requests added in version 1.6 of the extension. + +┌─── + RRCreateLease + window : WINDOW + lid: LEASE + crtcs: LISTofCRTC + outputs: LISTofOUTPUT + ▶ + nfd: CARD8 + lease: FD +└─── + Errors: IdChoice, Window, Access, Value, CRTC, Output + + Creates a new Lease called 'lid' for the specified crtcs and + outputs from the screen defined by 'window'. Returns a KMS/DRM + file descriptor which can control the leased objects directly + through the kernel. While leased, all resources will appear to + be 'useless' to clients other than the leasing client as + follows: + + • Crtcs are reported as having no 'possible-outputs' and all + other values reported as if the crtc were disabled. + + • Outputs are reported as having no crtcs they can be + connected to, no clones they can share a crtc with, will + report a connection status of Disconnected, and will show + the current crtc as if it were disabled. + + The lease remains in effect until the file descriptor is + closed, even if the client holding the lease disconnects from + the X server. + + Returns an Access error if any of the named resources are + already leased to another client. + +┌─── + RRFreeLease + lid: LEASE + terminate: BOOL +└─── + Errors: Lease + + Frees the reference to the lease 'lid'. If 'terminate' is + true, then the lease is terminated and all leased resources + returned to the X server. If 'terminate' is false, then the + lease remains in effect, but the X server no longer has a name + for it. + + ❧❧❧❧❧❧❧❧❧❧❧ +8. Extension Events + +Clients MAY select for ConfigureNotify on the root window to be +informed of screen changes. This may be advantageous if all your +client needs to know is the size of the root window, as it avoids +round trips to set up the extension. + +RRScreenChangeNotify is sent if RRSelectInput has requested it +whenever properties of the screen change, which may be due to external +factors, such as re-cabling a monitor, etc. + +┌─── + RRScreenChangeNotify + + rotation: ROTATION; new rotation + sequenceNumber: CARD16 low 16 bits of request seq. number + timestamp: TIMESTAMP time screen was changed + configTimestamp: TIMESTAMP time config data was changed + root: WINDOW root window of screen + window: WINDOW window requesting notification + size-id: SIZEID index of new SCREENSIZE + subpixelOrder: SUBPIXELORDER order of subpixels + widthInPixels: CARD16 width in pixels of the new SCREENSIZE + heightInPixels: CARD16 height in pixels of the new SCREENSIZE + widthInMillimeters: CARD16 width in mm of the new SCREENSIZE + heightInMillimeters: CARD16 height in mm of the new SCREENSIZE +└─── + This event is generated whenever the screen configuration is changed + and sent to requesting clients. 'timestamp' indicates when the + screen configuration was changed. 'configTimestamp' says when the + last time the configuration was changed. 'root' is the root of the + screen the change occurred on, 'window' is window selecting for this + event. 'size-id' contains the index of the current size. + + This event is sent whenever the screen's configuration changes + or if a new screen configuration becomes available that was + not available in the past. In this case (config-timestamp in + the event not being equal to the config-timestamp returned in + the last call to RRGetScreenInfo), the client MUST call + RRGetScreenInfo to update its view of possible screen + configurations to have a correct view of possible screen + organizations. + + Clients which select screen change notification events may be + sent an event immediately if the screen configuration was + changed between when they connected to the X server and + selected for notification. This is to prevent a common race + that might occur on log-in, where many applications start up + just at the time when a display manager or log in script might + be changing the screen size or configuration. + + Note that the sizes in this event reflect the new SCREENSIZE and + thus will appear rotated by the 'rotation' parameter from the sizes + of the screen itself. In other words, when rotation is 90 or 270, + widthInPixels in this event will be the same as the height value + from a ConfigureNotify that reflects the same size change. This + will probably confuse developers. + +8.1 Events added in version 1.2 of the RandR extension + +┌─── + RROutputChangeNotify: + timestamp: TIMESTAMP time screen was reconfigured + config-timestamp: TIMESTAMP time available config data was changed + window: WINDOW window requesting notification + output: OUTPUT output affected by change + crtc: CRTC connected CRTC or None + mode: MODE mode in use on CRTC or None + connection: CONNECTION connection status +└─── + + This event is generated whenever the available output configurations + have changed and is sent to requesting clients. 'timestamp' + indicates when the crtc configuration was changed by a client. + 'config-timestamp' says when the last time the available + configurations changed. 'root' is the root of the screen the change + occurred on, 'window' is window selecting for this event. The + precise change can be detected by examining the new state of the + system. + + Changes in version 1.6 of the protocol: + + When a “non-desktop” device is connected, this event will be + delivered when the connection status of the output changes, + however the 'connection' value will be set to 'Disconnected'. + +┌─── + RROutputPropertyNotify: + window: WINDOW window requesting notification + output: OUTPUT output affected by change + atom: ATOM affected property + time: TIMESTAMP time property was changed + subpixel-order: SUBPIXELORDER order of subpixels + state: { NewValue, Deleted } new property state +└─── + + This event is reported to clients selecting RROutputPropertyChange + on the window and is generated with state NewValue when a property + of the window is changed using RRChangeOutputProperty even when + adding zero-length data and when replacing all or part of a property + with identical data. It is generated with state Deleted when a + property of the window is deleted using either + RRDeleteOutputProperty or RRGetOutputProperty. The timestamp + indicates the server time when the property was changed. + +┌─── + RRCrtcChangeNotify + timestamp: TIMESTAMP time monitor was changed + window: WINDOW window requesting notification + crtc: CRTC CRTC which changed + mode: MODE new mode + rotation: ROTATION; new rotation + x: INT16 x position of CRTC within screen + y: INT16 y position of CRTC within screen + width: CARD16 width of new configuration + height: CARD16 height of new configuration +└─── + This event is generated whenever the CRTC configuration is changed + and sent to requesting clients. 'timestamp' indicates when the + CRTC configuration was changed. 'window' is window selecting for this + event. 'mode' is the new mode, or None if the crtc is disabled. + 'x' and 'y' mark the location in the screen where this CRTC + is reading data. 'width' and 'height' indicate the size of the + CRTC viewport, which is the mode size adjusted by the optional + Border output property described below. 'x', 'y, 'width' and + 'height' are all zero when 'mode' is None. + + This event is sent whenever the monitor's configuration changes + or if a new monitor configuration becomes available that was + not available in the past. In this case, the client MUST call + RRGetCrtcInfo to update its view of possible monitor + configurations to have a correct view of possible monitor + organizations. + + Clients which select monitor change notification events may be + sent an event immediately if the monitor configuration was + changed between when they connected to the X server and + selected for notification. This is to prevent a common race + that might occur on log-in, where many applications start up + just at the time when a display manager or log in script might + be changing the monitor size or configuration. + +8.2 Events added in version 1.4 of the RandR extension + +┌─── + RRProviderChangeNotify: + timestamp: TIMESTAMP time screen was reconfigured + window: WINDOW window requesting notification + provider: PROVIDER provider affected by change +└─── + + This event is generated whenever the role for a provider has changed + and is sent to requesting clients. 'timestamp' indicates when the + provider configuration was changed by a client. 'window' is the + window selecting for this event. The precise change can be detected + by examining the new state of the system. + +┌─── + RRProviderPropertyNotify: + window: WINDOW window requesting notification + provider: PROVIDER provider affected by change + atom: ATOM affected property + time: TIMESTAMP time property was changed + state: { NewValue, Deleted } new property state +└─── + + This event is reported to clients selecting RRProviderPropertyChange + on the window and is generated with state NewValue when a property + of the window is changed using RRChangeProviderProperty even when + adding zero-length data and when replacing all or part of a property + with identical data. It is generated with state Deleted when a + property of the window is deleted using either + RRDeleteProviderProperty or RRGetProviderProperty. The timestamp + indicates the server time when the property was changed. + +┌─── + RRResourceChangeNotify: + window: WINDOW window requesting notification + time: TIMESTAMP time property was changed +└─── + + This event is reported to clients selecting RRResourceChange + on the window and is generated whenever the set of available + RandR resources associated with the screen has changed, either + created or destroyed. Querying the list of available resources + with RRGetScreenResources and RRGetProviders will return the new set. + +8.3 Events added in version 1.6 of the RandR extension + +┌─── + RRLeaseNotify: + timestamp : TIMESTAMP time screen was reconfigured + window : WINDOW window requesting notification + lease : LEASE lease + created : BOOL created/destroyed indicator +└─── + + This event is generated whenever a lease has been created or + destroyed and is sent to requesting clients. 'timestamp' + indicates when the change happened. 'window' is the window + selecting for this event. + + ❧❧❧❧❧❧❧❧❧❧❧ + +9. Properties + +Properties are used for output specific parameters, and for announcing +static or rarely changing data. Announced data is typically +immutable. Properties are also used for evaluating new parameters +before adding them to the RandR protocol. + +The following properties are hereby declared official, and drivers SHOULD +prefix driver specific properties with '_', unless they are planned to be +added to this specification. List values, that are not declared by the table +below, and will remain driver specific or are not planned to be added to this +specification, SHOULD be prefixed with "_" as well in order to avoid name +space or semantics clashes with future extensions of these values. + +Beginning with version 1.3 of the RandR extension, certain properties +are mandatory and MUST be provided by implementations. Earlier +versions of the RandR extension MAY provide these properties as well, +as long as the semantics are not altered. Clients SHOULD fall back +gracefully to lower version functionality, though, if the driver +doesn't handle a mandatory property correctly. + +Changes in version 1.6 of the protocol: + +When a “non-desktop” device is connected, the property information +will be correct for the device, even though RRGetOutputInfo +reports the device as disconnected. The “non-desktop” property will be +set to 1 for such devices and not present on other devices. + +9.1 Known properties + + "Backlight" aka RR_PROPERTY_BACKLIGHT + Type: INTEGER + Format: 32 + Num. items: 1 + Flags: - + Range/List: 0-x (driver specific) + + This property controls the brightness on laptop panels and equivalent + displays with a backlight controller. The driver specific maximum + value MUST turn the backlight to full brightness, 1 SHOULD turn the + backlight to minimum brightness, 0 SHOULD turn the backlight off. + + "CloneList" aka RR_PROPERTY_CLONE_LIST + Type: ATOM + Format: 32 + Num. items: 2*n + Flags: Immutable + Range/List: 0- + + Some combinations of outputs on some cards cannot be served + independently from each other, because they are wired up to the same + encoder outputs. + This property lists all output + signal format pairs that are + driven together with this output, and thus can only be programmed in + clone mode with the same CRTC. + This property MUST be symmetric, but may change with changing signal + format. I.e. if the property for DVI-1/VGA specifies VGA-1/VGA to be + cloned, VGA-1/VGA has to list DVI-1/VGA as well. + Outputs / format pairs listed in this property MUST be included in the + CompatibilityList. + + "CompatibilityList" aka RR_PROPERTY_COMPATIBILITY_LIST + Type: ATOM + Format: 32 + Num items: 2*n + Flags: Immutable + Range/List: 0- + + Some combinations of outputs on some cards cannot be served at all, + because the according encoder is only capable of driving one output at + a time. + This property lists all output + signal format pairs that can be + driven together with this output. NULL atoms specify any output / any + signal format, respectively. + This property MUST be symmetric, but may change with changing signal + format. I.e. if the property for DVI-1/TMDS specifies VGA-1/VGA to be + available, VGA-1/VGA has to list DVI-1/TMDS as well. + + "ConnectorNumber" aka RR_PROPERTY_CONNECTOR_NUMBER + Type: INTEGER + Format: 32 + Num items: 1 + Flags: Immutable, Static + Range/List: 0- + + Outputs that route their signal to the same connector MUST + have the same connector number. Outputs with the same + connector number MUST route their signal to the same + connector, except if it is 0, which indicates unknown + connectivity. 1 is called the primary connector, 2 the + secondary. 3 is typically a TV connector, but that is completely + driver / hardware dependent. + Outputs with the same connector number SHOULD have the same + connector type. Meaning and client behavior for mismatching + connector types is undefined at the moment. + + "ConnectorType" aka RR_PROPERTY_CONNECTOR_TYPE + Type: ATOM + Format: 32 + Num items: 1 + Flags: Immutable, Static + Range/List: unknown VGA DVI DVI‐I DVI‐A DVI‐D HDMI Panel + TV TV-Composite TV-SVideo TV-Component + TV-SCART TV-C4 DisplayPort + + Connector type, as far as known to the driver. + Values with dashes (TV‐Composite) describe more specific versions of + the base values (TV). The former SHOULD be used if the connector is + not capable of producing other signal formats. The later SHOULD be + used if the exact connector is unknown, or the connector is a + multi‐format connector that is not described otherwise. DVI, for + instance, SHOULD be handled like a DVI‐I connector, unless additional + information is available to the user agent. PANEL describes + laptop‐internal (normally LVDS) displays. TV, TV‐SCART, TV‐Component, + and TV‐C4 with signal format VGA are valid combinations and describe + RGB TV signals. + + "EDID" aka RR_PROPERTY_RANDR_EDID + Type: INTEGER + Format: 8 + Num items: n + Flags: Immutable + Range/List: - + + Raw EDID data from the device attached to the according + output. Should include main EDID data and all extension + blocks. Previously known as EdidData. + + “non-desktop” aka RR_PROPERTY_NON_DESKTOP + Type: INTEGER + Format: 32 + Num items: 1 + Flags Immutable + Range/List: 0-1 + + Indicates whether the device attached to this output should not + be considered part of the normal desktop. When set to 0 or not + present, the output should be presented as part of the + desktop. + + When set to 1, the output should not be presented as part of + the desktop. To not present an output as part of the desktop, + the normal desktop environment should not be shown on this + output, nor should desktop applications be positioned on it. + + When set to 1, RRGetOutputInfo will always report connection status + Disconnected, but RROutputChangeNotify events will still be + delivered when the connection status changes and all other + information about the output and connected device will be + reported correctly. + + "SignalFormat" aka RR_PROPERTY_SIGNAL_FORMAT + Type: ATOM + Format: 32 + Num items: 1 + Flags: - + Range/List: unknown VGA TMDS LVDS Composite Composite-PAL + Composite-NTSC Composite-SECAM SVideo + Component DisplayPort + + Signal format / physical protocol format that is used for the + specified output. valid-values lists all possible formats on this + output, which SHOULD be a subset of the list above and MUST be static. + Values with dashes (Composite-PAL) describe more specific versions of + the base values (Composite) and SHOULD be used if known to the driver. + A driver MAY change this property of an output if the underlying + hardware indicates a protocol change (e.g. TV formats). Clients are + allowed to change the signal format in order to select a different + signal format (e.g. Composite etc.) or physical protocol (e.g. VGA or + TMDS on DVI-I). + Laptop panels SHOULD not be detected with this property, but rather by + ConnectorType. + + "SignalProperties" aka RR_PROPERTY_SIGNAL_FORMAT + Type: ATOM + Format: 32 + Num items: n + Flags: - + Range/List: For Composite signals: + NTSC NTSC-M NTSC-J NTSC-N NTSC-4.43 NTSC-film + PAL PAL-B PAL-G PAL-H PAL-H PAL-I PAL-M PAL-D + PAL-N PAL-Nc PAL-L PAL-60 + SECAM SECAM-L SECAM-B SECAM-G SECAM-D SECAM-K + SECAM-H SECAM-K + For TMDS signals: + SingleLink DualLink + For DisplayPort signals: + Lane1 Lane2 Lane4 LowSpeed HiSpeed + + Properties of the signal format that is currently used for the + specified output. valid-values lists all possible properties on this + output, which SHOULD be a subset of the list above. It will change if + SignalFormat changes. Multiple properties are allowed. + Values with dashes (PAL-B) describe more specific versions of the base + values (PAL) and SHOULD be used if known to the driver. A driver MAY + change this property of an output if the underlying hardware indicates + a signal change (e.g. TV formats). Clients are allowed to change the + properties in order to select a different signal subformat. + + "Border" aka RR_PROPERTY_BORDER + Type: CARDINAL + Format: 16 + Num items: 0, 1, 2, or 4 + Flags: Immutable + Range/List: 0- + + This property is a list of integers specifying adjustments for the edges + of the displayed image. How this property is applied depends on the + number of elements in the list: + + 0 = No border is applied + 1 = A border of Border[0] is applied to all four sides of the image. + 2 = A border of Border[0] is applied to the left and right sides of + the image, and a border of Border[1] is applied to the top and + bottom. + 4 = The border dimensions are as follows: + Border[0]: left + Border[1]: top + Border[2]: right + Border[3]: bottom + + Note that how many configuration dimensions are actually supported is + specified by the BorderDimensions property described below. If more than + BorderDimensions values are specified, the extra values are ignored. + + These border dimensions shrink the region of pixels displayed by the + CRTC by the corresponding number of rows or columns, and is applied + after the CRTC transform. For example, a mode with a 1920x1080 active + region, border dimensions of [ 10, 20, 30, 40 ], and a ½x scaling + transform would display a rectangle of 940x510 pixels from the scanout + pixmap scaled to 1880x1020 raster pixels positioned at (10, 20) in + display raster space. + + Raster pixels in the border are black. + + This property is created with pending == TRUE, so changes are not + applied immediately and instead take effect at the next RRSetCrtcConfig. + + If multiple outputs with different border settings are bound to the same + CRTC when the configuration is changed, the behavior is undefined. + + If the length of the property is less than four when the CRTC is + configured, the missing values are assumed to be zero. If the length is + greater than four, the extra values are ignored. + + If the width of the mode is less than or equal to the sum of the left + and right borders, then the left and right border settings are ignored. + Likewise, if the height of the mode is less than or equal to the sum of + the top and bottom borders, the top and bottom borders are ignored. + + "BorderDimensions" aka RR_PROPERTY_BORDER_DIMENSIONS + Type: CARDINAL + Format: 8 + Num items: 1 + Flags: Immutable, Static + Range/List: 0, 1, 2, or 4 + + This property lists how many border adjustment parameters can actually + be used: + + 0 = no borders are supported + 1 = a single border value is applied to all four sides of the image + 2 = left/right and top/bottom borders can be specified independently + 4 = all four borders can be specified independently + + "GUID" aka RR_PROPERTY_GUID + Type: INTEGER + Format: 8 + Num items: 16 + Flags: Immutable + Range/List: - + + Some display devices, such as DisplayPort 1.2 devices, have globally + unique identifiers. When such an identifier is available, this property + contains its raw bytes. + + "TILE" aka RR_PROPERTY_RANDR_TILE + Type: INTEGER + Format: 32 + Num items: 8 + Flags: Immutable + Range/List: - + + Tile monitors have an array of values describing the tiling, + based on DisplayID v1.3 + + The 8 elements are: + 0: group id - The tile group identifier + 1: flags - flags for tile group + 0x1 = single monitor enclosure + 2: number of horizontal tiles in tile group + 3: number of vertical tiles in tile group + 4: horizontal tile location for this tile + 5: vertical tile location for this tile + 6: horizontal tile size for this tile + 7: vertical tile size for this tile + +9.2 Properties introduced with version 1.2 of the RandR extension + +Property Immutable Mandatory since +──────── ───────── ─────────────── +EDID yes n/a + +EDID is provided by the RandR frontend, thus not driver specific. + + +9.3 Properties introduced with version 1.3 of the RandR extension + +Property Immutable Mandatory since +──────── ───────── ─────────────── +CloneList yes not mandatory +CompatibilityList yes not mandatory +ConnectorNumber yes: static not mandatory +ConnectorType yes: static RandR 1.3 +SignalFormat no RandR 1.3 +SignalProperties no not mandatory + +9.4 Properties introduced with version 1.3.1 of the RandR extension + +Property Immutable Mandatory since +──────── ───────── ─────────────── +Backlight no not mandatory + +9.5 Properties introduced with version 1.4.0 of the RandR extension + +Property Immutable Mandatory since +──────── ───────── ─────────────── +Border yes not mandatory +BorderDimensions yes: static not mandatory + +9.6 Properties introduced with version 1.4.1 of the RandR extension + +Property Immutable Mandatory since +──────── ───────── ─────────────── +GUID yes not mandatory + +9.7 Properties introduced with version 1.5 of the RandR extension + +Property Immutable Mandatory since +──────── ───────── ─────────────── +TILE yes not mandatory + +9.8 Properties introduced with version 1.6 of the RandR extension + +Property Immutable Mandatory since +──────── ───────── ─────────────── +non-desktop yes not mandatory + + ❧❧❧❧❧❧❧❧❧❧❧ + +10. Extension Versioning + +The RandR extension was developed in parallel with the implementation +to ensure the feasibility of various portions of the design. As +portions of the extension are implemented, the version number of the +extension has changed to reflect the portions of the standard provided. +This document describes the version 1.4 of the specification, the +partial implementations have version numbers less than that. Here's a +list of what each version provided: + + 0.0: This prototype implemented resize and rotation in the + TinyX server Used approximately the protocol described in + the Usenix paper. Appeared in the TinyX server in + XFree86 4.2, but not in the XFree86 main server. + + 0.1: Added subpixel order, added an event for subpixel order. + This version was never checked in to XFree86 CVS. + + 1.0: Implements resize, rotation, and reflection. Implemented + both in the XFree86 main server (size change only at this + date), and fully (size change, rotation, and reflection) + in XFree86's TinyX server. + + 1.1: Added refresh rates + + 1.2: Separate screens from CRTCs and outputs, switch to full VESA + modes + + 1.3: Added cheap version of RRGetScreenResources. Added CRTC + transformations. Added panning. Added primary outputs. + Added standard properties. + + 1.4: Added provider objects for handling multi-GPU systems. + + 1.5: Added Monitors + + 1.6: Added Leases and non-desktop output information. + +Compatibility between 0.0 and 1.0 was *NOT* preserved, and 0.0 clients +will fail against 1.0 servers. The wire encoding op-codes were +changed for GetScreenInfo to ensure this failure in a relatively +graceful way. Version 1.1 servers and clients are cross compatible with +1.0. Version 1.1 is considered to be stable and we intend upward +compatibility from this point. Version 1.2 offers an extended model of the +system with multiple output support. Version 1.3 adds a cheap version of +GetScreenResources to avoid expensive DDC operations, CRTC transformations, +panning, and the primary output concept. Versions 1.2 through 1.6 are +backward-compatible with 1.1. + + ❧❧❧❧❧❧❧❧❧❧❧ + +11. Relationship with other extensions + +Two other extensions have a direct relationship with this extension. This +section attempts to explain how these three are supposed to work together. + +11.1 XFree86-VidModeExtension + +XFree86-VidModeExtension changes the configuration of a single monitor +attached to the screen without changing the configuration of the screen +itself. It provides the ability to specify new mode lines for the server to +use along with selecting among existing mode lines. As it uses screen +numbers instead of window identifiers, it can be used to affect multiple +monitors in a single-screen Xinerama configuration. However, the association +between screen numbers and root windows in a multi-Screen environment is not +defined by the extension. Version 2.0 of this extension added the ability to +adjust the DAC values in a TrueColor server to modify the brightness curves +of the display. + +All of the utility of this extension is subsumed by RandR version 1.2, RandR +should be used in preference to XFree86-VidModeExtension where both are +present. + +11.2 Xinerama + +Xinerama provides a mechanism for describing the relationship between the +overall screen display and monitors placed within that area. As such, it +provides the query functionality of RandR 1.2 without any of the +configuration functionality. Applications using Xinerama to discover +monitor geometry can continue to do so, with the caveat that they will not be +informed of changes when they occur. However, Xinerama configuration data +will be updated, so applications selecting for RandR notification and +re-querying the configuration with the Xinerama extension will get updated +information. It is probably better to view RandR as a superset of Xinerama +at this point and use it in preference to Xinerama where both are present. + + ❧❧❧❧❧❧❧❧❧❧❧ + +Appendix A. Protocol Encoding + +Syntactic Conventions + +This document uses the same syntactic conventions as the core X +protocol encoding document. + +A.1 Common Types + +┌─── + ROTATION + 0x0001 Rotate_0 + 0x0002 Rotate_90 + 0x0004 Rotate_180 + 0x0008 Rotate_270 + 0x0010 Reflect_X + 0x0020 Reflect_Y +└─── + Used to encode both sets of possible rotations and individual + selected rotations. + +┌─── + RRSELECTMASK + 0x0001 ScreenChangeNotifyMask + 0x0002 CrtcChangeNotifyMask Added in version 1.2 + 0x0004 OutputChangeNotifyMask Added in version 1.2 + 0x0008 OutputPropertyNotifyMask Added in version 1.2 + 0x0010 ProviderChangeNotifyMask Added in version 1.4 + 0x0020 ProviderPropertyNotifyMask Added in version 1.4 + 0x0040 ResourceChangeNotifyMask Added in version 1.4 + 0x0080 LeaseNotifyMask Added in version 1.6 + +└─── + Event select mask for RRSelectInput + +┌─── + RRCONFIGSTATUS + 0x0 Success + 0x1 InvalidConfigTime + 0x2 InvalidTime + 0x3 Failed +└─── + Return status for requests which depend on time. + +┌─── + MODEINFO (32) Added in version 1.2 + 4 CARD32 id + 2 CARD16 width in pixels + 2 CARD16 height in pixels + 4 CARD32 dot clock + 2 CARD16 h sync start + 2 CARD16 h sync end + 2 CARD16 h total + 2 CARD16 h skew + 2 CARD16 v sync start + 2 CARD16 v sync end + 2 CARD16 v total + 2 CARD16 name length + 4 SETofMODEFLAG mode flags +└─── + + An output mode specifies the complete CRTC timings for + a specific mode. The vertical and horizontal synchronization rates + can be computed given the dot clock and the h total/v total + values. If the dot clock is zero, then all of the timing + parameters and flags are not used, and must be zero as this + indicates that the timings are unknown or otherwise unused. + The name itself will be encoded separately in each usage. + +┌─── + MODEFLAG + 0x00000001 HSyncPositive + 0x00000002 HSyncNegative + 0x00000004 VSyncPositive + 0x00000008 VSyncNegative + 0x00000010 Interlace + 0x00000020 DoubleScan + 0x00000040 CSync + 0x00000080 CSyncPositive + 0x00000100 CSyncNegative + 0x00000200 HSkewPresent + 0x00000400 BCast + 0x00000800 PixelMultiplex + 0x00001000 DoubleClock + 0x00002000 ClockDivideBy2 +└─── +┌─── + CONNECTION + 0 Connected + 1 Disconnected + 2 UnknownConnection +└─── + +┌─── + PROVIDER_CAPS Added in version 1.4 + 0x00000001 SourceOutput + 0x00000002 SinkOutput + 0x00000004 SourceOffload + 0x00000008 SinkOffload +└─── + +A.1.1 Common Types added in version 1.5 of the protocol + +┌─── + MONITORINFO (16 + 4*n) + 4 ATOM name + 1 BOOL primary + 1 BOOL automatic + 2 CARD16 noutputs + 2 INT16 x + 2 INT16 y + 2 CARD16 width in pixels + 2 CARD16 height in pixels + 4 CARD32 width in millimeters + 4 CARD32 height in millimeters + 4*n OUTPUT outputs +└─── + +A.2 Protocol Requests + +Opcodes 1 and 3 were used in the 0.0 protocols, and will return +errors if used in version 1.0. + +┌─── + RRQueryVersion + + 1 CARD8 major opcode + 1 0 RandR opcode + 2 3 length + 4 CARD32 major version + 4 CARD32 minor version + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 1 CARD32 major version + 1 CARD32 minor version +└─── +┌─── + RRSetScreenConfig + + 1 CARD8 major opcode + 1 2 RandR opcode + 2 6 length + 4 WINDOW window on screen to be configured + 4 TIMESTAMP timestamp + 4 TIMESTAMP config timestamp + 2 SIZEID size index + 2 ROTATION rotation/reflection + 2 CARD16 refresh rate (1.1 only) + 2 CARD16 pad + ▶ + 1 1 Reply + 1 RRCONFIGSTATUS status + 2 CARD16 sequence number + 4 0 reply length + 4 TIMESTAMP new timestamp + 4 TIMESTAMP new configuration timestamp + 4 WINDOW root + 2 SUBPIXELORDER subpixel order defined in Render + 2 CARD16 pad4 + 4 CARD32 pad5 + 4 CARD32 pad6 +└─── +┌─── + RRSelectInput + + 1 CARD8 major opcode + 1 4 RandR opcode + 2 3 length + 4 WINDOW window + 2 SETofRRSELECTMASK enable + 2 CARD16 pad +└─── +┌─── + RRGetScreenInfo + + 1 CARD8 major opcode + 1 5 RandR opcode + 2 2 length + 4 WINDOW window + ▶ + 1 1 Reply + 1 CARD8 set of Rotations + 2 CARD16 sequence number + 4 0 reply length + 4 WINDOW root window + 4 TIMESTAMP timestamp + 4 TIMESTAMP config timestamp + 2 CARD16 number of SCREENSIZE following + 2 SIZEID current size index + 2 ROTATION current rotation and reflection + 2 CARD16 current rate (added in version 1.1) + 2 CARD16 length of rate info (number of CARD16s) + 2 CARD16 pad + + SCREENSIZE + 2 CARD16 width in pixels + 2 CARD16 height in pixels + 2 CARD16 width in millimeters + 2 CARD16 height in millimeters + + REFRESH + 2 CARD16 number of rates (n) + 2n CARD16 rates +└─── + +A.2.1 Protocol Requests added with version 1.2 + +┌─── + RRGetScreenSizeRange + 1 CARD8 major opcode + 1 6 RandR opcode + 2 2 length + 4 WINDOW window + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 2 CARD16 minWidth + 2 CARD16 minHeight + 2 CARD16 maxWidth + 2 CARD16 maxHeight + 16 unused +└─── +┌─── + RRSetScreenSize + 1 CARD8 major opcode + 1 7 RandR opcode + 2 5 length + 4 WINDOW window + 2 CARD16 width + 2 CARD16 height + 4 CARD32 width in millimeters + 4 CARD32 height in millimeters +└─── +┌─── + RRGetScreenResources + 1 CARD8 major opcode + 1 8 RandR opcode + 2 2 length + 4 WINDOW window + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 c+o+8m+(b+p)/4 reply length + 4 TIMESTAMP timestamp + 4 TIMESTAMP config-timestamp + 2 c number of CRTCs + 2 o number of outputs + 2 m number of modeinfos + 2 b total bytes in mode names + 8 unused + 4c LISTofCRTC crtcs + 4o LISTofOUTPUT outputs + 32m LISTofMODEINFO modeinfos + b STRING8 mode names + p unused, p=pad(b) +└─── +┌─── + RRGetOutputInfo + 1 CARD8 major opcode + 1 9 RandR opcode + 2 3 length + 4 OUTPUT output + 4 TIMESTAMP config-timestamp + ▶ + 1 1 Reply + 1 RRCONFIGSTATUS status + 2 CARD16 sequence number + 4 1+c+m+(n+p)/4 reply length + 4 TIMESTAMP timestamp + 4 CRTC current connected crtc + 4 CARD32 width in millimeters + 4 CARD32 height in millimeters + 1 CONNECTION connection + 1 SUBPIXELORDER subpixel-order + 2 c number of CRTCs + 2 m number of modes + 2 p number of preferred modes + 2 o number of clones + 2 n length of name + 4c LISTofCRTC crtcs + 4m LISTofMODE modes + 4o LISTofOUTPUT clones + n STRING8 name + p unused, p=pad(n) +└─── +┌─── + RRListOutputProperties + 1 CARD8 major opcode + 1 10 RandR opcode + 2 2 length + 4 OUTPUT output + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 n reply length + 2 n number of ATOMs in atoms + 22 unused + 4n LISTofATOM atoms +└─── +┌─── + RRQueryOutputProperty + 1 CARD8 major opcode + 1 11 RandR opcode + 2 3 request length + 4 OUTPUT output + 4 ATOM property + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 n reply length + 1 BOOL pending + 1 BOOL range + 1 BOOL immutable + 21 unused + 4n LISTofINT32 valid values +└─── +┌─── + RRConfigureOutputProperty + 1 CARD8 major opcode + 1 12 RandR opcode + 2 4+n request length + 4 OUTPUT output + 4 ATOM property + 1 BOOL pending + 1 BOOL range + 2 unused + 4n LISTofINT32 valid values +└─── +┌─── + RRChangeOutputProperty + 1 CARD8 major opcode + 1 13 RandR opcode + 2 6+(n+p)/4 request length + 4 OUTPUT output + 4 ATOM property + 4 ATOM type + 1 CARD8 format + 1 mode + 0 Replace + 1 Prepend + 2 Append + 2 unused + 4 CARD32 length of data in format units + (= n for format = 8) + (= n/2 for format = 16) + (= n/4 for format = 32) + n LISTofBYTE data + (n is a multiple of 2 for format = 16) + (n is a multiple of 4 for format = 32) + p unused, p=pad(n) +└─── +┌─── + RRDeleteOutputProperty + 1 CARD8 major opcode + 1 14 RandR opcode + 2 3 request length + 4 OUTPUT output + 4 ATOM property +└─── +┌─── + RRGetOutputProperty + 1 CARD8 major opcode + 1 15 RandR opcode + 2 7 request length + 4 OUTPUT output + 4 ATOM property + 4 ATOM type + 0 AnyPropertyType + 4 CARD32 long-offset + 4 CARD32 long-length + 1 BOOL delete + 1 BOOL pending + 2 unused + ▶ + 1 1 Reply + 1 CARD8 format + 2 CARD16 sequence number + 4 (n+p)/4 reply length + 4 ATOM type + 0 None + 4 CARD32 bytes-after + 4 CARD32 length of value in format units + (= 0 for format = 0) + (= n for format = 8) + (= n/2 for format = 16) + (= n/4 for format = 32) + 12 unused + n LISTofBYTE value + (n is zero for format = 0) + (n is a multiple of 2 for format = 16) + (n is a multiple of 4 for format = 32) + p unused, p=pad(n) +└─── +┌─── + RRCreateMode + 1 CARD8 major opcode + 1 16 RandR opcode + 2 10+(n+p)/4 length + 4 WINDOW window + 32 MODEINFO mode + n STRING8 mode name + p unused, p=pad(n) + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 4 MODE mode + 20 unused +└─── +┌─── + RRDestroyMode + 1 CARD8 major opcode + 1 17 RandR opcode + 2 2 length + 4 MODE mode +└─── +┌─── + RRAddOutputMode + 1 CARD8 major opcode + 1 18 RandR opcode + 2 3 length + 4 OUTPUT output + 4 MODE mode +└─── +┌─── + RRDeleteOutputMode + 1 CARD8 major opcode + 1 19 RandR opcode + 2 3 length + 4 OUTPUT output + 4 MODE mode +└─── +┌─── + RRGetCrtcInfo + 1 CARD8 major opcode + 1 20 RandR opcode + 2 3 length + 4 CRTC crtc + 4 TIMESTAMP config-timestamp + ▶ + 1 1 Reply + 1 RRCONFIGSTATUS status + 2 CARD16 sequence number + 4 o+p reply length + 4 TIMESTAMP timestamp + 2 INT16 x + 2 INT16 y + 2 CARD16 width + 2 CARD16 height + 4 MODE mode + 2 ROTATION current rotation and reflection + 2 ROTATION set of possible rotations + 2 o number of outputs + 2 p number of possible outputs + 4o LISTofOUTPUT outputs + 4p LISTofOUTPUT possible outputs +└─── +┌─── + RRSetCrtcConfig + 1 CARD8 major opcode + 1 21 RandR opcode + 2 7+n length + 4 CRTC crtc + 4 TIMESTAMP timestamp + 4 TIMESTAMP config timestamp + 2 INT16 x + 2 INT16 y + 4 MODE mode + 2 ROTATION rotation/reflection + 2 unused + 4n LISTofOUTPUT outputs + ▶ + 1 1 Reply + 1 RRCONFIGSTATUS status + 2 CARD16 sequence number + 4 0 reply length + 4 TIMESTAMP new timestamp + 20 unused +└─── +┌─── + RRGetCrtcGammaSize + 1 CARD8 major opcode + 1 22 RandR opcode + 2 2 length + 4 CRTC crtc + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 2 CARD16 size + 22 unused +└─── +┌─── + RRGetCrtcGamma + 1 CARD8 major opcode + 1 23 RandR opcode + 2 2 length + 4 CRTC crtc + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 (6n+p)/4 reply length + 2 n size + 20 unused + 2n LISTofCARD16 red + 2n LISTofCARD16 green + 2n LISTofCARD16 blue + p unused, p=pad(6n) +└─── +┌─── + RRSetCrtcGamma + 1 CARD8 major opcode + 1 24 RandR opcode + 2 3+(6n+p)/4 length + 4 CRTC crtc + 2 n size + 2 unused + 2n LISTofCARD16 red + 2n LISTofCARD16 green + 2n LISTofCARD16 blue + p unused, p=pad(6n) +└─── + +A.2.2 Protocol Requests added with version 1.3 + +┌─── + RRGetScreenResourcesCurrent + 1 CARD8 major opcode + 1 25 RandR opcode + 2 2 length + 4 WINDOW window + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 c+o+8m+(b+p)/4 reply length + 4 TIMESTAMP timestamp + 4 TIMESTAMP config-timestamp + 2 c number of CRTCs + 2 o number of outputs + 2 m number of modeinfos + 2 b total bytes in mode names + 8 unused + 4c LISTofCRTC crtcs + 4o LISTofOUTPUT outputs + 32m LISTofMODEINFO modeinfos + b STRING8 mode names + p unused, p=pad(b) +└─── + +┌─── + RRSetCrtcTransform + 1 CARD8 major opcode + 1 26 RandR opcode + 2 12+(n+p)/4+v length + 4 CRTC crtc + 36 TRANSFORM transform + 2 CARD16 filter length + 2 unused + n STRING8 filter name + p unused, p=pad(n) + 4v FIXED filter params +└─── + +┌─── + RRGetCrtcTransform + 1 CARD8 major opcode + 1 27 RandR opcode + 2 2 length + 4 CRTC crtc + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 16+(pn+pnp)/4+(cn+cnp)/4+pf+cf reply length + 36 TRANSFORM pending transform + 1 BOOL has transforms + 3 unused + 36 TRANSFORM current transform + 4 unused + 2 pn pending filter name length + 2 pf pending filter num params + 2 cn current filter name length + 2 cf current filter num params + pn STRING8 pending filter name + pnp unused, pnp=pad(pn) + 4*pf FIXED pending filter params + cn STRING8 current filter name + cnp unused, cnp=pad(cn) + 4*cf FIXED current filter params +└─── + +┌─── + RRGetPanning + 1 CARD8 major opcode + 1 28 RandR opcode + 2 2 length + 4 CRTC crtc + ▶ + 1 1 Reply + 1 RRCONFIGSTATUS status + 2 CARD16 sequence number + 4 1 reply length + 4 TIMESTAMP timestamp + 2 CARD16 left + 2 CARD16 top + 2 CARD16 width + 2 CARD16 height + 2 CARD16 track_left + 2 CARD16 track_top + 2 CARD16 track_width + 2 CARD16 track_height + 2 INT16 border_left + 2 INT16 border_top + 2 INT16 border_right + 2 INT16 border_bottom +└─── +┌─── + RRSetPanning + 1 CARD8 major opcode + 1 29 RandR opcode + 2 9 length + 4 CRTC crtc + 4 TIMESTAMP timestamp + 2 CARD16 left + 2 CARD16 top + 2 CARD16 width + 2 CARD16 height + 2 CARD16 track_left + 2 CARD16 track_top + 2 CARD16 track_width + 2 CARD16 track_height + 2 INT16 border_left + 2 INT16 border_top + 2 INT16 border_right + 2 INT16 border_bottom + ▶ + 1 1 Reply + 1 RRCONFIGSTATUS status + 2 CARD16 sequence number + 4 0 reply length + 4 TIMESTAMP new timestamp + 20 unused +└─── + +┌─── + RRSetOutputPrimary + 1 CARD8 major opcode + 1 30 RandR opcode + 2 3 length + 4 WINDOW window + 4 OUTPUT output +└─── + +┌─── + RRGetOutputPrimary + 1 CARD8 major opcode + 1 31 RandR opcode + 2 2 length + 4 WINDOW window + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 CARD32 length + 4 OUTPUT output + 4 CARD32 pad1 + 4 CARD32 pad2 + 4 CARD32 pad3 + 4 CARD32 pad4 +└─── + +A.2.3 Protocol Requests added with version 1.4 + +┌─── + RRGetProviders + 1 CARD8 major opcode + 1 32 RandR opcode + 2 2 length + 4 WINDOW window + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 p length + 4 TIMESTAMP timestamp + 2 p number of Providers + 18 unused + 4p LISTofPROVIDERS providers +└─── +┌─── + RRGetProviderInfo + 1 CARD8 major opcode + 1 33 RandR opcode + 2 3 length + 4 PROVIDER provider + 4 TIMESTAMP config-timestamp + ▶ + 1 1 Reply + 1 RRCONFIGSTATUS status + 2 CARD16 sequence number + 4 1+c+o+(a*2)+(n+p)/4 reply length + 4 TIMESTAMP timestamp + 4 CARD32 capabilities + 2 c number of crtcs + 2 o number of outputs + 2 a number of associated providers + 2 n length of name + 8 unused + 4c LISTofCRTC crtcs + 4o LISTofOUTPUT outputs + 4a LISTofPROVIDER associated providers + 4a CARD32 associated provider capability + n STRING8 name + p unused, p=pad(n) +└─── +┌─── + RRSetProviderOffloadSink + 1 CARD8 major opcode + 1 34 RandR opcode + 2 4 length + 4 PROVIDER provider + 4 PROVIDER offload sink provider + 4 TIMESTAMP timestamp +└─── +┌─── + RRSetProviderOutputSource + 1 CARD8 major opcode + 1 35 RandR opcode + 2 4 length + 4 PROVIDER provider + 4 PROVIDER output source provider + 4 TIMESTAMP timestamp +└─── +┌─── + RRListProviderProperties + 1 CARD8 major opcode + 1 36 RandR opcode + 2 2 length + 4 PROVIDER provider + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 n reply length + 2 n number of ATOMs in atoms + 22 unused + 4n LISTofATOM atoms +└─── +┌─── + RRQueryProviderProperty + 1 CARD8 major opcode + 1 37 RandR opcode + 2 3 request length + 4 PROVIDER provider + 4 ATOM property + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 n reply length + 1 BOOL pending + 1 BOOL range + 1 BOOL immutable + 21 unused + 4n LISTofINT32 valid values +└─── +┌─── + RRConfigureProviderProperty + 1 CARD8 major opcode + 1 38 RandR opcode + 2 4+n request length + 4 PROVIDER provider + 4 ATOM property + 1 BOOL pending + 1 BOOL range + 2 unused + 4n LISTofINT32 valid values +└─── +┌─── + RRChangeProviderProperty + 1 CARD8 major opcode + 1 39 RandR opcode + 2 6+(n+p)/4 request length + 4 PROVIDER provider + 4 ATOM property + 4 ATOM type + 1 CARD8 format + 1 mode + 0 Replace + 1 Prepend + 2 Append + 2 unused + 4 CARD32 length of data in format units + (= n for format = 8) + (= n/2 for format = 16) + (= n/4 for format = 32) + n LISTofBYTE data + (n is a multiple of 2 for format = 16) + (n is a multiple of 4 for format = 32) + p unused, p=pad(n) +└─── +┌─── + RRDeleteProviderProperty + 1 CARD8 major opcode + 1 40 RandR opcode + 2 3 request length + 4 PROVIDER provider + 4 ATOM property +└─── +┌─── + RRGetProviderProperty + 1 CARD8 major opcode + 1 41 RandR opcode + 2 7 request length + 4 PROVIDER provider + 4 ATOM property + 4 ATOM type + 0 AnyPropertyType + 4 CARD32 long-offset + 4 CARD32 long-length + 1 BOOL delete + 1 BOOL pending + 2 unused + ▶ + 1 1 Reply + 1 CARD8 format + 2 CARD16 sequence number + 4 (n+p)/4 reply length + 4 ATOM type + 0 None + 4 CARD32 bytes-after + 4 CARD32 length of value in format units + (= 0 for format = 0) + (= n for format = 8) + (= n/2 for format = 16) + (= n/4 for format = 32) + 12 unused + n LISTofBYTE value + (n is zero for format = 0) + (n is a multiple of 2 for format = 16) + (n is a multiple of 4 for format = 32) + p unused, p=pad(n) +└─── + +A.2.4 Protocol Requests added with version 1.5 + +┌─── + RRGetMonitors + 1 CARD8 major opcode + 1 42 RandR opcode + 2 2 request length + 4 WINDOW window + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 6*n + o reply length + 4 TIMESTAMP timestamp + 4 n nmonitors + 4 o noutputs + 12 unused + n*24+o*4 LISTofMONITORINFO monitors +└─── +┌─── + RRSetMonitor + 1 CARD8 major opcode + 1 43 RandR opcode + 2 6 + o request length + 4 WINDOW window + 24+o MONITORINFO monitorinfo +└─── +┌─── + RRDeleteMonitor + 1 CARD8 major opcode + 1 44 RandR opcode + 2 3 request length + 4 WINDOW window + 4 ATOM name +└─── + +A.3 Protocol Events + +┌─── + RRScreenChangeNotify + 1 Base + 0 code + 1 ROTATION new rotation and reflection + 2 CARD16 sequence number + 4 TIMESTAMP timestamp + 4 TIMESTAMP configuration timestamp + 4 WINDOW root window + 4 WINDOW request window + 2 SIZEID size ID + 2 SUBPIXELORDER subpixel order defined in Render + 2 CARD16 width in pixels + 2 CARD16 height in pixels + 2 CARD16 width in millimeters + 2 CARD16 height in millimeters +└─── + +A.3.1 Protocol Events added with version 1.2 + +┌─── + RRCrtcChangeNotify + 1 Base + 1 code + 1 0 sub-code + 2 CARD16 sequence number + 4 TIMESTAMP timestamp + 4 WINDOW request window + 4 CRTC crtc affected + 4 MODE mode in use + 2 ROTATION new rotation and reflection + 2 unused + 2 INT16 x + 2 INT16 y + 2 CARD16 width + 2 CARD16 height +└─── +┌─── + RROutputChangeNotify + 1 Base + 1 code + 1 1 sub-code + 2 CARD16 sequence number + 4 TIMESTAMP timestamp + 4 TIMESTAMP configuration timestamp + 4 WINDOW request window + 4 OUTPUT output affected + 4 CRTC crtc in use + 4 MODE mode in use + 2 ROTATION rotation in use + 1 CONNECTION connection status + 1 SUBPIXELORDER subpixel order +└─── +┌─── + RROutputPropertyNotify + 1 Base + 1 code + 1 2 sub-code + 2 CARD16 sequence number + 4 WINDOW window + 4 OUTPUT output + 4 ATOM atom + 4 TIMESTAMP time + 1 state + 0 NewValue + 1 Deleted + 11 unused +└─── + +A.3.2 Protocol Events added with version 1.4 +┌─── + RRProviderChangeNotify + 1 Base + 1 code + 1 3 sub-code + 2 CARD16 sequence number + 4 TIMESTAMP timestamp + 4 WINDOW request window + 4 PROVIDER provider affected + 16 unused +└─── +┌─── + RRProviderPropertyNotify + 1 Base + 1 code + 1 4 sub-code + 2 CARD16 sequence number + 4 WINDOW window + 4 PROVIDER provider + 4 ATOM atom + 4 TIMESTAMP time + 1 state + 0 NewValue + 1 Deleted + 11 unused +└─── +┌─── + RRResourceChangeNotify + 1 Base + 1 code + 1 5 sub-code + 2 CARD16 sequence number + 4 TIMESTAMP time + 4 WINDOW window + 20 unused +└─── +A.4 Protocol Errors + +┌─── + ERRORS + Base + 0 Output + Base + 1 Crtc + Base + 2 Mode + Base + 3 Provider +└─── + +Bibliography + +[RANDR] Gettys, Jim and Keith Packard, "The X Resize and Rotate + Extension - RandR", Proceedings of the 2001 USENIX Annual + Technical Conference, Boston, MA + +[RENDER] + Packard, Keith, "The X Rendering Extension", work in progress, + https://gitlab.freedesktop.org/xorg/proto/xorgproto/raw/master/renderproto.txt diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/renderproto.txt b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/renderproto.txt new file mode 100644 index 0000000000000000000000000000000000000000..b589c85b4d413406ebc01554899382acfa1e62a5 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/renderproto.txt @@ -0,0 +1,1214 @@ + The X Rendering Extension + Version 0.11 + 2009-07-15 + Keith Packard + keithp@keithp.com + +1. Introduction + +The X Rendering Extension (Render) introduces digital image composition as +the foundation of a new rendering model within the X Window System. +Rendering geometric figures is accomplished by client-side tessellation into +either triangles or trapezoids. Text is drawn by loading glyphs into the +server and rendering sets of them. + +2. Acknowledgments + +This extension was the work of many people, in particular: + + + Thomas Porter and Tom Duff for their formal description + of image compositing. + + + Rob Pike and Russ Cox who designed the Plan 9 window system from + which the compositing model was lifted. + + + Juliusz Chroboczek and Raph Levien whose proposal for client-side + glyph management eliminated font handling from the X server. + + + Jon Leech, Brad Grantham and Allen Akin for patiently explaining + how OpenGL works. + + + Carl Worth for providing the sample implementation of + trapezoid rendering and showing how broken the spec was + + + Sam Pottle and Jamey Sharp for helping demonstrate the correctness + of the trapezoid specification. + + + Owen Taylor for helping specify projective transformations + +3. Rendering Model + +Render provides a single rendering operation which can be used in a variety of +ways to generate images: + + dest = (source IN mask) OP dest + +Where 'IN' is the Porter/Duff operator of that name and 'OP' is any of the +list of compositing operators described below, among which can be found all +of the Porter/Duff binary operators. + +To use this operator several additional values are required: + + + The destination rectangle. This is a subset of the destination + within which the rendering is performed. + + + The source location. This identifies the coordinate in the + source aligned with the upper left corner of the + destination rectangle. + + + The mask location. This identifies the coordinate in the + mask aligned with the upper left corner of the + destination rectangle. + + + A clip list. This limits the rendering to the intersection of the + destination rectangle with this clip list. + + + The OP to use + + + Whether the source should be repeated to cover the destination + rectangle, extended with a constant pixel value or extended by + using the nearest available source pixel. + + + Whether the mask should be repeated to cover the destination + rectangle, extended with a constant pixel value or extended by + using the nearest available mask pixel. + + + Whether the mask has a single alpha value for all four channels or + whether each mask channel should affect the associated source/dest + channels. + + + Whether the source should be reshaped with a projective + transformation, and if so, what filter to apply while + resampling the data. + + + Whether the mask should be reshaped with a projective + transformation, and if so, what filter to apply while + resampling the data. + +These parameters are variously attached to the operands or included in each +rendering request. + +4. Data types + +The core protocol rendering system uses a pixel model and applies color only +in the final generation of the video signal. A compositing model operates +on colors, not pixel values so a new datatype is needed to interpret data as +color instead of just bits. + +The "PictFormat" object holds information needed to translate pixel values +into red, green, blue and alpha channels. The server has a list of picture +formats corresponding to the various visuals on the screen. There are two +classes of formats, Indexed and Direct. Indexed PictFormats hold a list of +pixel values and RGBA values while Direct PictFormats hold bit masks for each +of R, G, B and A. + +The "Picture" object contains a Drawable, a PictFormat and some +rendering state. More than one Picture can refer to the same Drawable. + +5. Errors + +Errors are sent using core X error reports. + +PictFormat + A value for a PICTFORMAT argument does not name a defined PICTFORMAT. + +Picture + A value for a PICTURE argument does not name a defined PICTURE. + +PictOp + A value for a PICTOP argument does not name a defined PICTOP. + +GlyphSet + A value for a GLYPHSET argument does not name a defined GLYPHSET. + +Glyph + A value for a GLYPH argument does not name a defined GLYPH in the + glyphset. + +6. Protocol Types + +PICTURE 32-bit value (top three bits guaranteed to be zero) +PICTFORMAT 32-bit value (top three bits guaranteed to be zero) +PICTTYPE { Indexed, Direct } +PICTOP { Clear, Src, Dst, Over, OverReverse, In, InReverse, + Out, OutReverse, Atop, AtopReverse, Xor, Add, Saturate, + DisjointClear, DisjointSrc, DisjointDst, DisjointOver, + DisjointOverReverse, DisjointIn, DisjointInReverse, + DisjointOut, DisjointOutReverse, DisjointAtop, + DisjointAtopReverse, DisjointXor, + ConjointClear, ConjointSrc, ConjointDst, ConjointOver, + ConjointOverReverse, ConjointIn, ConjointInReverse, + ConjointOut, ConjointOutReverse, ConjointAtop, + ConjointAtopReverse, ConjointXor, + Multiply, Screen, Overlay, Darken, Lighten, ColorDodge, + ColorBurn, HardLight, SoftLight, Difference, Exclusion, + HSLHue, HSLSaturation, HSLColor, HSLLuminosity + } +SUBPIXEL { Unknown, HorizontalRGB, HorizontalBGR, + VerticalRGB, VerticalBGR, None + } +COLOR [ + red, green, blue, alpha: CARD16 + ] +CHANNELMASK [ + shift, mask: CARD16 + ] +DIRECTFORMAT [ + red, green, blue, alpha: CHANNELMASK + ] +INDEXVALUE [ + pixel: Pixel; + red, green, blue, alpha: CARD16 + ] +PICTFORMINFO [ + id: PICTFORMAT + type: PICTTYPE + depth: CARD8 + direct: DIRECTFORMAT + colormap: COLORMAP or None + ] + +PICTVISUAL [ + visual: VISUALID or None + format: PICTFORMAT + ] + +PICTDEPTH [ + depth: CARD8 + visuals: LISTofPICTVISUAL + ] + +PICTSCREEN LISTofPICTDEPTH + +FIXED 32-bit value (top 16 are integer portion, bottom 16 are fraction) +TRANSFORM [ + p11, p12, p13: FIXED + p21, p22, p23: FIXED + p31, p32, p33: FIXED + ] +POINTFIX [ + x, y: FIXED + ] +POLYEDGE { Sharp, Smooth } +POLYMODE { Precise, Imprecise } +REPEAT { None, Regular, Pad, Reflect } +COLORPOINT [ + point: POINTFIX + color: COLOR + ] +SPANFIX [ + left, right, y: FIXED + ] +COLORSPANFIX [ + left, right, y: FIXED + left_color: COLOR + right_color: COLOR +QUAD [ + p1, p2, p3, p4: POINTFIX + ] +TRIANGLE [ + p1, p2, p3: POINTFIX + ] +LINEFIX [ + p1, p2: POINTFIX + ] +TRAP [ + top, bottom: SPANFIX + ] +TRAPEZOID [ + top, bottom: FIXED + left, right: LINEFIX + ] +(TRAPEZOID is deprecated) +GLYPHSET 32-bit value (top three bits guaranteed to be zero) +GLYPH 32-bit value +GLYPHINFO [ + width, height: CARD16 + x, y: INT16 + off-x, off-y: INT16 + ] +PICTGLYPH [ + info: GLYPHINFO + x, y: INT16 + ] +GLYPHABLE GLYPHSET or FONTABLE +GLYPHELT8 [ + dx, dy: INT16 + glyphs: LISTofCARD8 + ] +GLYPHITEM8 GLYPHELT8 or GLYPHABLE +GLYPHELT16 [ + dx, dy: INT16 + glyphs: LISTofCARD16 + ] +GLYPHITEM16 GLYPHELT16 or GLYPHABLE +GLYPHELT32 [ + dx, dy: INT16 + glyphs: LISTofCARD32 + ] +GLYPHITEM32 GLYPHELT32 or GLYPHABLE + +ANIMCURSORELT [ + cursor: CURSOR + delay: CARD32 + ] +7. Standard PictFormats + +The server must support a Direct PictFormat with 8 bits each of red, green, +blue and alpha as well as a Direct PictFormat with 8 bits of red, green and +blue and 0 bits of alpha. The server must also support Direct PictFormats +with 1, 4 and 8 bits of alpha and 0 bits of r, g and b. + +Pixel component values lie in the close range [0,1]. These values are +encoded in a varying number of bits. Values are encoded in a straight +forward manner. For a component encoded in m bits, a binary encoding b +is equal to a component value of b/(2^m-1). + +A Direct PictFormat with zero bits of alpha component is declared to have +alpha == 1 everywhere. A Direct PictFormat with zero bits of red, green and +blue is declared to have red, green, blue == 0 everywhere. If any of red, +green or blue components are of zero size, all are of zero size. Direct +PictFormats never have colormaps and are therefore screen independent. + +Indexed PictFormats never have alpha channels and the direct component is all +zeros. Indexed PictFormats always have a colormap in which the specified +colors are allocated read-only and are therefore screen dependent. Drawing +to in Indexed Picture uses only pixel values listed by QueryPictIndexValues. +Reading from an Indexed Picture uses red, green and blue values from the +colormap and alpha values from those listed by QueryPictIndexValues. Pixel +values not present in QueryPictIndexValues are given alpha values of 1. + +8. Compositing Operators + +For each pixel, the four channels of the image are computed with: + + C = Ca * Fa + Cb * Fb + +where C, Ca, Cb are the values of the respective channels and Fa and Fb +come from the following table: + + PictOp Fa Fb + -------------------------------------------------- + Clear 0 0 + Src 1 0 + Dst 0 1 + Over 1 1-Aa + OverReverse 1-Ab 1 + In Ab 0 + InReverse 0 Aa + Out 1-Ab 0 + OutReverse 0 1-Aa + Atop Ab 1-Aa + AtopReverse 1-Ab Aa + Xor 1-Ab 1-Aa + Add 1 1 + Saturate min(1,(1-Ab)/Aa) 1 + DisjointClear 0 0 + DisjointSrc 1 0 + DisjointDst 0 1 + DisjointOver 1 min(1,(1-Aa)/Ab) + DisjointOverReverse min(1,(1-Ab)/Aa) 1 + DisjointIn max(1-(1-Ab)/Aa,0) 0 + DisjointInReverse 0 max(1-(1-Aa)/Ab,0) + DisjointOut min(1,(1-Ab)/Aa) 0 + DisjointOutReverse 0 min(1,(1-Aa)/Ab) + DisjointAtop max(1-(1-Ab)/Aa,0) min(1,(1-Aa)/Ab) + DisjointAtopReverse min(1,(1-Ab)/Aa) max(1-(1-Aa)/Ab,0) + DisjointXor min(1,(1-Ab)/Aa) min(1,(1-Aa)/Ab) + ConjointClear 0 0 + ConjointSrc 1 0 + ConjointDst 0 1 + ConjointOver 1 max(1-Aa/Ab,0) + ConjointOverReverse max(1-Ab/Aa,0) 1 + ConjointIn min(1,Ab/Aa) 0 + ConjointInReverse 0 min(Aa/Ab,1) + ConjointOut max(1-Ab/Aa,0) 0 + ConjointOutReverse 0 max(1-Aa/Ab,0) + ConjointAtop min(1,Ab/Aa) max(1-Aa/Ab,0) + ConjointAtopReverse max(1-Ab/Aa,0) min(1,Aa/Ab) + ConjointXor max(1-Ab/Aa,0) max(1-Aa/Ab,0) + +Saturate and DisjointOverReverse are the same. They match OpenGL +compositing with FUNC_ADD, SRC_ALPHA_SATURATE, ONE, except that Render uses +premultiplied alpha while Open GL uses non-premultiplied alpha. + +The result of any compositing operator is always limited to the range +[0,1] for each component. Components whose value would be greater than 1 +are set to 1. + +For operations involving division, when the divisor is zero, define the +quotient to be positive infinity. The result is always well defined +because the division is surrounded with a max or min operator which will +give a finite result. + +When the mask contains separate alpha values for each channel, the +alpha value resulting from the combination of that value with the source +alpha channel is used in the final image composition. + +9. Source and Mask Transformations + +When fetching pixels from the source or mask pictures, Render provides four +options for pixel values which fall outside the drawable (this includes +pixels within a window geometry obscured by other windows). + + + None. Missing values are replaced with transparent. + + + Pad. Replace missing pixels with the nearest available + pixel. Where multiple pixels are equidistant, select + those with smallest Y and then smallest X coordinates + + + Normal. Select the pixel which would appear were the + drawable tiled to enclose the missing coordinate. If + the tiling doesn't cover the coordinate, use the + selected Constant or Nearest mode. + + * Reflect. Select the pixel which would appear were the + drawable tiled to enclose the missing coordinate in such a + way that tiles in even numbered columns are reflected in the Y + axis, and tiles in even numbered rows are reflected in the X + axis. Tiles that in both an even numbered row and an even + numbered column are reflected in both axes. + +To construct the source and mask operands, the computed pixels values are +transformed through a homogeneous matrix, filtered and then used in the +fundamental rendering operator described above. Each screen provides a list +of supported filter names. There are a few required filters, and several +required filter alias which must map to one of the available filters. + +10. Polygon Rasterization + +Render provides only two kinds of polygons, trapezoids and triangles. To +improve efficiency, several different wire encodings exist for each. + +All trapezoids must be convex. Rendering of concave trapezoids is unspecified +except that the result must obey the clipping rules. + +Composite +Polygons are rasterized by implicit generating an alpha mask and using that +in the general compositing operator along with a supplied source image: + + tmp = Rasterize (polygon) + Composite (op, dst, src, tmp) + +When rasterized with Sharp edges, the mask is computed with a depth of 1 so +that all of the mask values are either 0 or 1. + +When rasterized with Smooth edges, the mask is generated by creating a square +around each pixel coordinate and computing the amount of that square covered +by the polygon. This ignores sampling theory but it provides a precise +definition which is close to the right answer. This value is truncated to +the alpha width in the fallback format before application of the compositing +operator. + +Rasterization +Alpha values are generated by point sampling the coverage of a square +surrounding the center of each pixel by the polygon. + +In Precise poly mode, the sample points are located in a regular grid. When +alpha depth 'e' is even, the regular grid is 2**(e/2) + 1 samples wide and +2**(e/2) -1 samples high. For odd alpha depth 'o', the sample grid is 2**o +- 1 samples wide and 1 sample high. Note that odd alpha depth usually +occurs only at depth 1, so this misshapen sample grid has no ill effects. +The sample grid is centered within the pixel and then each sample point is +rounded down to a point on the sub-pixel coordinate grid. + +In Imprecise mode, the location of the sample points is not specified, but +the implementation must conform to the following constraints: + + + Abutting edges must match precisely. When specifying two polygons + abutting along a common edge, if that edge is specified with the + same coordinates in each polygon then the sum of alpha values for + pixels inside the union of the two polygons must be precisely one. + + + Translationally invariant. The pixelization of the polygon must + be the same when either the polygon or the target drawable + are translated by any whole number of pixels in any direction. + + + Sharp edges are honored. When the polygon is rasterized with Sharp + edges, the implicit alpha mask will contain only 1 or 0 for + each pixel. + + + Order independent. Two identical polygons specified with vertices + in different orders must generate identical results. + +11. Image Filtering + +When computing pixels from source and mask images, a filter may be applied +to the data. This is usually used with a non-identity transformation +matrix, but filtering may be applied with an identity transformation. + +Each filter is given a unique name encoded as an ISO Latin-1 string. +Filters may be configured with a list of fixed point values; the number of +parameters and their interpretation is currently left to conventions passed +outside of the protocol. A set of standard filters are required to be +provided: + + Filter Name Description + + nearest Nearest neighbor filtering + bilinear Linear interpolation in two dimensions + +Additional names may be provided for any filter as aliases. A set of +standard alias names are required to be mapped to a provided filter so that +applications can use the alias names without checking for availability. + + Alias name Intended interpretation + + fast High performance, quality similar to Nearest + good Reasonable performance, quality similar to Bilinear + best Highest quality available, performance may not + be suitable for interactive use + +Aliases must map directly to a non-aliased filter name. + +There is also a set of standard filters which are not required but may be +provided. If they are provided, using the standard name, they must match +the definition specified here. + + Filter Name Description + + convolution MxN convolution filter. The values specified + in SetPictureFilter are M, N and then M * N + filter parameters. M and N must be integers + represented as fixed point numbers. + gaussian Gaussian blur. The value specified is a radius + in pixels (which can be fractional). A standard + Gaussian 2D convolution filter will be applied. + binomial Binomial blur. An approximation of a Gaussian + blur using binomial coefficients + +12. Glyph Rendering + +Glyphs are small alpha masks which can be stored in the X server and +rendered by referring to them by name. A set of glyphs can be rendered in a +single request. Glyphs are positioned by subtracting the x, y elements of +the GLYPHINFO from the requested rendering position. The next glyph +rendering position is set to the current rendering position plus the off-x +and off-y elements. + +Glyphs are stored in GlyphSets and are named within the GlyphSet with +client-specified 32-bit numbers. + +Glyphs can be stored in any PictFormat supported by the server. All glyphs +in a GlyphSet are stored in the same format. + +13. Extension Initialization + +The client must negotiate the version of the extension before executing +extension requests. Behavior of the server is undefined otherwise. + +QueryVersion + + client-major-version: CARD32 + client-minor-version: CARD32 + + -> + + major-version: CARD32 + minor-version: CARD32 + + The client sends the highest supported version to the server and + the server sends the highest version it supports, but no higher than + the requested version. Major versions changes can introduce + incompatibilities in existing functionality, minor version + changes introduce only backward compatible changes. It is + the clients responsibility to ensure that the server supports + a version which is compatible with its expectations. + +QueryPictFormats + + -> + + formats: LISTofPICTFORMINFO + screens: LISTofPICTSCREEN + ndepths: CARD32 + nvisuals: CARD32 + subpixels: LISTofSUBPIXEL + + Errors: + + + The server responds with a list of supported PictFormats and + a list of which PictFormat goes with each visual on each screen. + Every PictFormat must match a supported depth, but not every + PictFormat need have a matching visual. + + The total number of PICTDEPTH and PICTVISUAL objects is this reply + is given in 'ndepths' and 'nvisuals'. + + The relationship between the red, green and blue elements making + up each pixel indexed by screen is returned in subpixels. + This list is not present in servers advertising protocol + versions earlier than 0.6. This list may be shorter than + the number of screens, in which case the remaining screens + are given sub pixel order Unknown. + +QueryPictIndexValues + + format: PICTFORMAT + + -> + + values: LISTofINDEXVALUE + + Errors: + PictFormat, Match + + Returns the mapping from pixel values to RGBA values for the + specified Indexed PictFormat. If 'format' does not refer to + an Indexed PictFormat a Match error is generated. + +QueryFilters + + drawable: DRAWABLE + + -> + + filters: LISTofSTRING8 + aliases: LISTofCARD16 + + This request gets the names of available filters that can be used on the + given drawable. Filters are applied using a SetPictureFilter request. + + 'aliases' contains a value for each filter name which is the index into + 'filters' if this name is an alias. Non-aliased filter have this value + set to 0xFFFF. + +14. Extension Requests + +CreatePicture + + pid: PICTURE + drawable: DRAWABLE + format: PICTFORMAT + value-mask: BITMASK + value-list: LISTofVALUE + + Errors: + Alloc, Drawable, IDChoice, Match, Pixmap, Picture, + PictFormat, Value + + This request creates a Picture object associated with the specified + drawable and assigns the identifier pid to it. Pixel data in the + image are interpreted according to 'format'. It is a Match error + to specify a format with a different depth than the drawable. If + the drawable is a Window then the Red, Green and Blue masks must + match those in the visual for the window else a Match error is + generated. + + The value-mask and value-list specify attributes of the picture that + are to be explicitly initialized. The possible values are: + + repeat: REPEAT + alpha-map: PICTURE or None + alpha-x-origin: INT16 + alpha-y-origin: INT16 + clip-x-origin: INT16 + clip-y-origin: INT16 + clip-mask: PIXMAP or None + graphics-exposures: BOOL + subwindow-mode: { ClipByChildren, IncludeInferiors } + poly-edge: POLYEDGE + poly-mode: POLYMODE + dither: ATOM or None + component-alpha: BOOL + + When used as a source or mask operand, Repeat indicates how the + drawable contents should be extended in both directions. + + The alpha channel of alpha-map is used in place of any alpha channel + contained within the drawable for all rendering operations. The + alpha-mask origin is interpreted relative to the origin of drawable. + Rendering is additionally clipped by the geometry and clip mask of + alpha-map. Exposures to the window do not affect the contents of + alpha-map. Alpha-map must refer to a picture containing a Pixmap, + not a Window (or a Match error results). If the alpha-map picture + itself already has an alpha-map, the result is undefined. + + The clip-mask restricts reads and writes to drawable. Only pixels + where the clip-mask has bits set to 1 are read or written. Pixels + are not accessed outside the area covered by the clip-mask or where + the clip-mask has bits set to 0. The clip-mask affects all graphics + requests, including sources. The clip-mask origin is interpreted + relative to the origin of the picture. If a pixmap is specified as + the clip-mask, it must have depth 1 and have the same root as the + drawable (or a Match error results). If clip-mask is None, then + pixels are always drawn, regardless of the clip origin. The + clip-mask can also be set with the SetPictureClipRectangles request. + Transformations, filters and repeat modes do not affect the clip + mask. + + When a window is used as a destination, the subwindow_mode + determines what happens to pixels obscured by inferior + windows. For ClipByChildren the window is clipped by inferiors + and siblings. For IncludeInferior, the window is clipped by + siblings, but not by inferiors. + + When a window is used as source or mask, the subwindow_mode is + ignored. Pixels that are obscured by other windows, whether + siblings or inferiors, have undefined contents. + + The graphics-exposures flag is ignored. GraphicsExposure events are + never generated by this extension. + + Poly-edge and poly-mode control the rasterization of polygons as + described above. + + Dither is ignored. + + Component-alpha indicates whether each image component is intended as + a separate alpha value when the picture is used as a mask operand. + + The default component values are + + Component Default + ------------------------------- + repeat None + clip-x-origin 0 + clip-y-origin 0 + clip-mask None + subwindow-mode ClipByChildren + poly-edge Smooth + poly-mode Precise + component-alpha False + +ChangePicture + + pid: PICTURE + value-mask: BITMASK + value-list: LISTofVALUE + + Errors: + Picture, Alloc, Pixmap, PictOp, Value + + The value-mask and value-list specify which attributes are to be + changed. The values and restrictions are the same as for + CreatePicture. + +SetPictureClipRectangles + + picture: PICTURE + clip-x-origin: INT16 + clip-y-origin: INT16 + rectangles: LISTofRECTANGLE + + Errors: + Alloc, Picture + + This request changes clip-mask in picture to the specified list of + rectangles and sets the clip origin. Input and output will be + clipped to remain contained within the rectangles. The clip origin + is interpreted relative to the origin of picture after + transformations and repeats have been applied. The rectangle + coordinates are interpreted relative to the clip origin. + + The list of rectangles can be empty, which effectively disables + output. This is the opposite of passing None as the clip-mask in + CreatePicture and ChangePicture. + + Note that output is clipped to the union of all of the rectangles + and that no particular ordering among the rectangles is required. + +SetPictureTransform + + picture: PICTURE + transform: TRANSFORM + + Errors: + Alloc, Value, Picture + + This request changes the projective transformation used to + map coordinates when 'picture' is used as the source or + mask in any compositing operation. The transform + maps from destination pixel geometry back to the source pixel + geometry. + + The matrix must be invertable, else a Value error is generated. + +SetPictureFilter + + picture: PICTURE + filter: STRING8 + values: LISTofFIXED + + Errors: + Value, Match, Picture + + This request sets the current filter used when picture is a source + or mask operand. Filter must be one of the filters supported + for the screen associated with picture, else a Match error + is generated. If the filter accepts additional parameters, + they can be provided in values, incorrect values generate Value + errors, too many values generate Match errors. Too few values + cause the filter to assume default values for the missing + parameters. + + When created, Pictures are set to the Nearest filter. + +FreePicture + + pid: PICTURE + + Errors: + Picture + + This request deletes the association between the resource ID and the + picture. The picture storage will be freed when no other resource + references it. + +Composite + + op: PICTOP + src: PICTURE + mask: PICTURE or None + dst: PICTURE + src-x, src-y: INT16 + mask-x, mask-y: INT16 + dst-x, dst-y: INT16 + width, height: CARD16 + + This request combines the specified rectangle of the transformed + src and mask operands with the specified rectangle of dst using op + as the compositing operator. The coordinates are relative their + respective (transformed) drawable's origin. Rendering is clipped + to the geometry of the dst drawable and then to the dst clip-list. + + Pixels outside the geometry of src or mask needed for this + computation are substituted as described in the Source and Mask + Transformations section above. + + If src, mask and dst are not in the same format, and one of their + formats can hold all without loss of precision, they are converted + to that format. Alternatively, the server will convert each + operand to the fallback format. + + If mask is None, it is replaced by a constant alpha value of 1. + +FillRectangles + + op: PICTOP + dst: PICTURE + color: COLOR + rects: LISTofRECTANGLE + + This request combines color with the destination drawable in the + area specified by rects. Each rectangle is combined separately; + overlapping areas will be rendered multiple times. The effect is + equivalent to compositing with a repeating source picture filled with + the specified color. + +Trapezoids + + op: PICTOP + src: PICTURE + src-x, src-y: INT16 + dst: PICTURE + mask-format: PICTFORMAT or None + traps: LISTofTRAPEZOID + + This request rasterizes the list of trapezoids. + + For each trap, the area between the left and right edges is filled + from the top to the bottom. src-x and src-y register the pattern to + the floor of the top x and y coordinate of the left edge of the + first trapezoid, they are adjusted for subsequent trapezoids so that + the pattern remains globally aligned within the destination. + + When mask-format is not None, trapezoids are rendered in the + following way with the effective mask computed in mask-format: + + tmp = temporary alpha picture (in mask-format) + Combine (Zero, tmp, tmp, None) + for each trapezoid + Combine (Add, tmp, trapezoid, None) + Combine (op, dst, source, tmp) + + When mask-format is None, trapezoids are rendered in the order + specified directly to the destination: + + for each trapezoid + Combine (op, dst, source, trapezoid) + + (The Trapezoids request is deprecated) + +Triangles + + op: PICTOP + src: PICTURE + src-x, src-y: INT16 + dst: PICTURE + mask-format: PICTFORMAT or None + triangles: LISTofTRIANGLE + + This request rasterizes the list of triangles in the order they + occur in the list. + + When mask-format is not None, triangles are rendered in the + following way with the effective mask computed in mask-format: + + tmp = temporary alpha picture (in mask-format) + Combine (Zero, tmp, tmp, None) + for each triangle + Combine (Add, tmp, triangle, None) + Combine (op, dst, source, tmp) + + When mask-format is None, triangles are rendered in the order + specified directly to the destination: + + for each triangle + Combine (op, dst, source, triangle) + +TriStrip + + op: PICTOP + src: PICTURE + src-x, src-y: INT16 + dst: PICTURE + mask-format: PICTFORMAT or None + points: LISTofPOINTFIX + + Triangles are formed by initially using the first three points and + then by eliminating the first point and appending the next point in + the list. If fewer than three points are provided, this request does + nothing. + + When mask-format is not None, triangles are rendered in the + following way with the effective mask computed in mask-format: + + tmp = temporary alpha picture (in mask-format) + Combine (Zero, tmp, tmp, None) + for each triangle + Combine (Add, tmp, triangle, None) + Combine (op, dst, source, tmp) + + When mask-format is None, triangles are rendered in the order + specified directly to the destination: + + for each triangle + Combine (op, dst, source, triangle) + +TriFan + op: PICTOP + src: PICTURE + src-x, src-y: INT16 + dst: PICTURE + mask-format: PICTFORMAT or None + points: LISTofPOINTFIX + + Triangles are formed by initially using the first three points and + then by eliminating the second point and appending the next point + int the list. If fewer than three points are provided, this request + does nothing. + + When mask-format is not None, triangles are rendered in the + following way with the effective mask computed in mask-format: + + tmp = temporary alpha picture (in mask-format) + Combine (Zero, tmp, tmp, None) + for each triangle + Combine (Add, tmp, triangle, None) + Combine (op, dst, source, tmp) + + When mask-format is None, triangles are rendered in the order + specified directly to the destination: + + for each triangle + Combine (op, dst, source, triangle) + +CreateGlyphSet + + gsid: GLYPHSET + format: PICTFORMAT + + Errors: + Alloc, IDChoice, PictFormat, Match + + This request creates a container for glyphs. The glyphset and + all contained glyphs are destroyed when gsid and any other names + for the glyphset are freed. Format must be a Direct format, when + it contains RGB values, the glyphs are composited using + component-alpha True, otherwise they are composited using + component-alpha False. + +ReferenceGlyphSet + + gsid: GLYPHSET + existing: GLYPHSET + + Errors: + Alloc, IDChoice, GlyphSet + + This request creates an additional name for the existing glyphset. + The glyphset will not be freed until all references to it are + destroyed. + +FreeGlyphSet + + glyphset: GLYPHSET + + Errors: + GlyphSet + + This request frees the name for the glyphset. When all names have + been freed, the glyphset and all contained glyphs are freed. + +AddGlyphs + glyphset: GLYPHSET + glyphids: LISTofCARD32 + glyphs: LISTofGLYPHINFO + data: LISTofBYTE + + Errors: + GlyphSet, Alloc + + This request adds glyphs to glyphset. The image for the glyphs + are stored with each glyph in a separate Z-format image padded to a + 32-bit boundary. Existing glyphs with the same names are replaced. + +FreeGlyphs + + glyphset: GLYPHSET + glyphs: LISTofGLYPH + + Errors: + GlyphSet, Match + + This request removes glyphs from glyphset. Each glyph must exist + in glyphset (else a Match error results). + +CompositeGlyphs8 +CompositeGlyphs16 +CompositeGlyphs32 + + op: PICTOP + src: PICTURE + dst: PICTURE + mask-format: PICTFORMAT or None + glyphset: GLYPHABLE + src-x, src-y: INT16 + glyphcmds: LISTofGLYPHITEM8 CompositeGlyphs8 + glyphcmds: LISTofGLYPHITEM16 CompositeGlyphs16 + glyphcmds: LISTofGLYPHITEM32 CompositeGlyphs32 + + Errors: + Picture, PictOp, PictFormat, GlyphSet, Glyph + + The src-x and src-y coordinates are relative to the drawable's + origin and specify the baseline starting position (the initial glyph + origin). Each glyph item is processed in turn. A glyphset item + causes the glyphset to be used for subsequent glyphs. Switching + among glyphsets does not affect the next glyph origin. A glyph + element delta-x and delta-y specify additional changes in the + position along the x and y axes before the string is drawn; the + deltas are always added to the glyph origin. + + All contained GLYPHSETs are always transmitted most significant byte + first. + + If a GlyphSet error is generated for an item, the previous items may + have been drawn. + + When mask-format is not None, glyphs are rendered in the following + way with the effective mask computed in mask-format: + + tmp = temporary alpha picture + Combine (Zero, tmp, tmp, None) + for each glyph + Combine (Add, tmp, glyph, None) + Combine (op, dst, source, tmp) + + When mask-format is None, glyphs are rendered in the order specified + directly to the destination: + + for each glyph + Combine (op, dst, source, glyph) + +CreateCursor + + cid: CURSOR + source: PICTURE + x, y: CARD16 + + Errors: Alloc, IDChoice, Match, Picture + + This request creates a cursor and associates identifier cid with it. + The x and y coordinates define the hotspot relative to the source's + origin and must be a point within the source (or a Match error + results). The resulting picture will nominally be drawn to the + screen with PictOpOver. + + The components of the cursor may be transformed arbitrarily to meet + display limitations. In particular, if the display supports only + two colors cursors without translucency, the cursor will be + transformed so that areas less than .5 alpha will be transparent, + else opaque, and areas darker than 50% gray will be black else white. + + The source picture can be freed immediately if no further explicit + references to it are to be made. + + Subsequent drawing in the source has an undefined effect on the + cursor. The server might or might not make a copy of the picture. + +CreateAnimCursor + cid: CURSOR + cursors: LISTofANIMCURSORELT + + Errors: Alloc, IDChoice, Cursor + + This request creates a cursor and associates identifier cid with it. + When active, the cursor image on the screen will cycle through + 'cursors', showing each cursor in the element for the number of + milliseconds indicated by the 'delay' member of that element. + +AddTraps + picture: PICTURE + off-x, off-y: INT16 + trapezoids: LISTofTRAP + + Errors: Match + + Each trap is PictOpAdd'ed to 'picture'. 'off-x', 'off-y' + are added to each coordinate. + + 'picture' must be an alpha-only picture else a 'Match' error is + returned. + +CreateSolidFill + pid: PICTURE + color: COLOR + + Creates a Source picture that represents a solid fill with + the specified color. + +CreateLinearGradient + pid: PICTURE + p1, p2: POINTFIX + nstops: CARD32 + stops: LISTofFIXED + stop_colors: LISTofCOLOR + + Errors: Alloc, Value + + Creates a source picture representing a linear Gradient. The gradients + bounds are defined by the two end points p1 and p2. + + The gradient has nstops stop points between 0 and 1, each + having a stop color defined in stop_colors. + + The array of stops has to contain values between 0 and 1 (inclusive) and + has to be ordered in increasing size or a Value error is generated. If + p1 == p2 a Value error is generated. + + The colors are non premultiplied. + +CreateRadialGradient + pid: PICTURE + inner_center: POINTFIX + outer_center: POINTFIX + inner_radius: FIXED + outer_radius: FIXED + nstops: CARD32 + stops: LISTofFIXED + stop_colors: LISTofCOLOR + + Errors: Alloc, Value + + Creates a source picture representing a radial Gradient. The + gradients bounds are defined by a center point, a focal point and a + radius around the center. + + The gradient has nstops stop points between 0 and 1, each + having a stop color defined in stop_colors. + + The array of stops has to contain values between 0 and 1 (inclusive) and + has to be ordered in increasing size or a Value error is generated. The inner + circle has to be completely contained inside the outer one or a Value error is + generated. + + The colors are non premultiplied. + +CreateConicalGradient + pid: PICTURE + center: POINTFIX + angle: FIXED + nstops: CARD32 + stops: LISTofFIXED + stop_colors: LISTofCOLOR + + Errors: Alloc, Value + + Creates a source picture representing a conical Gradient. The + gradient is defined by a center point and an angle (in degrees). + + The gradient has nstops stop points between 0 and 1, each + having a stop color defined in stop_colors. + + The array of stops has to contain values between 0 and 1 (inclusive) and + has to be ordered in increasing size or a Value error is generated. + + The colors are non premultiplied. + + +15. Extension Versioning + +The Render extension was developed in parallel with the implementation to +ensure the feasibility of various portions of the design. As portions of +the extension are implemented, the version number of the extension has +changed to reflect the portions of the standard provided. This document +describes the intent for version 1.0 of the specification, the partial +implementations have version numbers less than that. Here's a list of +what each version before 1.0 implemented: + + 0.0: + No disjoint/conjoint operators + No component alpha + Composite + CreateGlyphSet + FreeGlyphSet + AddGlyphs + CompositeGlyphs + + 0.1: + Component alpha + FillRectangles + + 0.2: + Disjoint/Conjoint operators + + 0.3: + FreeGlyphs + + 0.4: + Trapezoids + Triangles + TriStrip + TriFan + + 0.5: + CreateCursor + + 0.6: + SetPictureTransform + QueryFilters + SetPictureFilter + subpixels member of QueryPictFormats + + 0.7: + QueryPictIndexValues + 0.8: + CreateAnimCursor + 0.9: + AddTrapezoids + + 0.10: + CreateSolidFill + CreateLinearGradient + CreateRadialGradient + CreateConicalGradient + + The repeat picture attribute now supports Pad and + Reflect, older versions only supported None and Normal. + + 0.11: + Blend mode operators + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/resproto.txt b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/resproto.txt new file mode 100644 index 0000000000000000000000000000000000000000..8b322ff88c548c6e902be11c375857321a13f64a --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/resproto.txt @@ -0,0 +1,462 @@ + DRAFT FOR REVIEW + The X Resource Extension + Version 1.2 + Rami Ylimäki + rami.ylimaki@vincit.fi + + ❧❧❧❧❧❧❧❧❧❧❧ + +1. Introduction + +The protocol description of X Resource Extension version 1.1 has been +either lost or has never been written. This specification documents +version 1.0 based on reverse engineered library and server +code. Version 1.1 has been accidentally released from the version +control and while it doesn't have differences to version 1.0, this +version is labeled 1.2 in order to remove the risk of confusion. In +addition to the 1.0 description, this document introduces a new 1.2 +version of the extension. + +Version 1.2 is a minor release and therefore the changes are +compatible with the previous version. Main enhancements over version +1.0 are: + +- Client identification is now possible. For example, servers + supporting version 1.2 may report PID of local clients. + +- Size of any resource can be queried from the server. Servers may not + necessarily support size calculation for every resource. However, + clients have now at least the chance to let the server do resource + size estimation for them. + + ❧❧❧❧❧❧❧❧❧❧❧ + +2. Notations used in this document + +Notation for data types and requests follows the guidelines set in +sections 2-4 of X Window System Protocol standard. + + ❧❧❧❧❧❧❧❧❧❧❧ + +3. Interoperability between version 1.1 and 1.2 + +Version 1.2 only introduces two new requests. However, these requests +could be seen as generalized versions of existing requests. Even +though we aren't deprecating any old requests, libraries could +implement some old requests using the new ones. + +The new XResQueryClientIds request could be used instead of +XResQueryClients. + +The new XResQueryResourceBytes request could be used instead of +XResQueryClientPixmapBytes. + +Using the old requests is still acceptable because we don't want to +change the semantics of existing requests between version 1.1 and 1.2. + + ❧❧❧❧❧❧❧❧❧❧❧ + +4. Data types + +4.1 Types in version 1.0 + +CLIENTXIDRANGE [ resource_base: CARD32 + resource_mask: CARD32 ] + +This type is used for reply of XResQueryClients in version 1.1. It +represents the range of resource allocated for a client and can be +also used for client identification. + +resource_base + First resource ID reserved for a client. Used also to identify the + clients themselves. +resource_mask + Mask that can be used to identify a client from some resource + ID. Just zero the bits indicated by this mask from any resource ID + to identify the client that owns the resource. + +CLIENTXID [ client: XID ] + +This type identifies a single client by a resource owned by that +client or by the first resource ID allocated for the client +(resource_base of CLIENTXIDRANGE). Whenever a resource ID is used, it +is masked by resource_mask of CLIENTXIDRANGE to find out the client +that owns the resource. + +CLIENTRESOURCETYPECOUNT [ resource_type: ATOM + count: CARD32 ] + +This type is used for reply of XResQueryClientResources in version +1.1. It represents the number of certain type of resources that are +owned by some client. + +resource_type + Atom specifying the type of a resource. +count + Number of resources of the given type owned by a client. + +4.2 Types in version 1.2 + +4.2.1 Types used by XResQueryClientIds + +CLIENTIDMASK { ClientXid = 0x1, LocalClientPid = 0x2 } + +A bitmask specifying a client identification method. Currently only +the PID of local clients is supported in the form of +LocalClientPid. ClientXid is provided for backward compatibility with +version 1.0 so that the new 1.2 requests (XResQueryClientIds) can be +used in place of the older ones (XResQueryClients). + +CLIENTIDSPEC [ client: CLIENTXID or None + mask: SETofCLIENTIDMASK or None ] + +A data structure for selecting client IDs. + +client + ID of a resource allocated for some client. Only the part + identifying a client is actually used. The resource_base of + CLIENTXIDRANGE can be used if the client doesn't own any + resources. However, any resource ID is accepted because that makes + identifying the owners of existing resources easy. The null + resource None can be used to select all clients. +mask + Collection of identification methods that should be applied on the + client. The special value None can be used to apply all supported + identification methods. + +CLIENTIDVALUE [ spec: CLIENTIDSPEC + length: CARD32 + value: LISTofCARD32 ] + +A data structure specifying a single client ID. + +spec + A unique identifier for a specific ID of some client. Wildcards + such as None and bitmask unions aren't allowed. The data structure + must always identify a single client and single ID type. However, + the client doesn't have to be specified as the resource_base of + CLIENTXIDRANGE and can be any resource owned by the client. +length + Specifies the length of an ID in units of CARD32. The length + depends on the ID type. In version 1.2 the lengths are 0 for + ClientXid and 4 for LocalClientPid. The length of ClientXid is 0 + because that is already stored in the spec field. +value + Actual ID data. In version 1.2 this is missing for ClientXid and + consists of a single CARD32 for LocalClientPid. + +4.2.2 Types used by XResQueryResourceBytes + +To better understand how resources are related to each other, it's +useful to introduce the concepts of main resource and cross +reference. By main resource we just mean a normal resource that has a +valid XID. By cross reference we mean a resource that is used by some +other resource. + +The same resource may have both of these roles depending on the +context. For example, there could be an ordinary pixmap resource. When +we talk about this resource in isolation the term main resource is +used. We call the exact same resource a cross reference when we are +concentrating on some higher level resource, such as window or +graphics context, that is using the lower level resource. Cross +references may also be internal server resources that don't have a +valid XID. + +RESOURCEIDSPEC [ resource: XID or None + type: ATOM or None/AnyPropertyType ] + +A data structure for selecting or identifying resources. The +interpretation of fields changes depending on the context. The +differences in interpretation are described below. + +resource + An XID of a resource. The null resource None can be used to select + all resources matching some type if the data structure is used in + XResQueryResourceBytes request. The null resource None can be used + to mark private server resources if the data structure is used in + a cross reference of XResQueryResourceBytes reply. +type + An atom identifying the resource type. The null atom + None/AnyPropertyType can be used to select all resource types + matching some resource ID if the data structure is used in + XResQueryResourceBytes request. + +RESOURCESIZESPEC [ spec: RESOURCEIDSPEC + bytes: CARD32 + ref_count: CARD32 + use_count: CARD32 ] + +A data structure specifying the size of a single resource. + +spec + Uniquely identifies a single resource. Wildcards such as None and + AnyPropertyType aren't allowed for main resources. In cross + references, None is used to mark internal server resources. +bytes + Number of bytes allocated for the resource. The size of a resource + is never divided by a reference count. This is the number of bytes + released in server when there are no more references left to the + resource. +ref_count + Number of total users of the resource. Typically the reference + count is 1 but for pixmaps and other resources used from different + contexts the count may be larger. +use_count + Number of times the resource is used by some other resource. For + main resources this is typically 1, because a resource doesn't + usually use itself recursively. For cross references this is the + number of times the resource is used and is also 1 usually. + +RESOURCESIZEVALUE [ size: RESOURCESIZESPEC + num_cross_references: CARD32 + cross_references: LISTofRESOURCESIZESPEC ] + +A data structure specifying sizes of cross references to other +resources in addition to the main resource size. + +size + Size of a main resource. +num_cross_references + Number of cross references to other resources from the main + resource. Currently resources can only have pixmaps as cross + references but this can be extended to other types in the + future. For simple resources this field is therefore 0 and the + cross_references list is missing. +cross_references: + Size specifications for cross references. Note that cross + references may contain resources that don't have a valid XID. For + example, a DRI2 drawable might have a cross reference to a private + pixmap that is used internally in the server only. These private + cross references are contained in this list also. This makes it + possible to emulate XResGetClientPixmapBytes with + XResGetResourceBytes. + + ❧❧❧❧❧❧❧❧❧❧❧ + +5. Requests + +5.1 Requests in version 1.0 + +┌─── + XResQueryVersion + client_major: CARD8 + client_minor: CARD8 + ▶ + server_major: CARD16 + server_minor: CARD16 +└─── + +The client sends the highest supported version to the server and the +server sends the highest version it supports, but no higher than the +requested version. Major version changes can introduce +incompatibilities in existing functionality, minor version changes +introduce only backward compatible changes. It is the client's +responsibility to ensure that the server supports a version which is +compatible with its expectations. + +client_major + Major X Resource Extension version supported by client. +client_minor + Minor X Resource Extension version supported by client. +server_major + Highest version supported by server that is compatible with + client. +server_minor + Highest version supported by server that is compatible with + client. + +┌─── + XResQueryClients + ▶ + num_clients: CARD32 + clients: LISTofCLIENTXIDRANGE +└─── + +The request asks X server to return the list of all currently +connected clients. + +num_clients + Number of currently connected clients. +clients + List of XID ranges allocated for the connected clients. + +┌─── + XResQueryClientResources + client: CLIENTXID + ▶ + num_types: CARD32 + types: LISTofCLIENTRESOURCETYPECOUNT + + Errors: Value +└─── + +This request can be used to ask the number of resources owned by a +client. The server will return the counts of each type of resource. + +client + An XID in the resource range of a client. This identifies the + client and not some specific resource. +num_types + Number of different resource types owned by the client. +types + A list of counts for each resource type. + +A value error is generated if invalid resource or client XID is given +in the request. + +┌─── + XResQueryClientPixmapBytes + client: CLIENTXID + ▶ + bytes: CARD32 + bytes_overflow: CARD32 + + Errors: Value +└─── + +This request is used to get the pixmap usage of some client. The +returned number is a sum of memory usage of each pixmap that can be +attributed to the given client. Ideally the server goes through all +pixmaps and divides each pixmap size by the pixmap reference count to +get a pixmap reference size. The reference size is then added to the +returned sum if the client happens to be referencing that pixmap. In +practice some pixmap references may be missed, because it would be too +difficult to keep track of all pixmap references. However, the server +will check the most important client resources that are using pixmaps +and tries to estimate the pixmap usage as well as is possible. In +other words, the server need only make a best-effort attempt to +calculate resource source, so actual resource size may differ from +that reported in practice. + +client + Identifies a client by an ID in its resource ID range. +bytes: + Number of bytes attributed to pixmap references from the client + resources. +bytes_overflow: + Higher order word for the bytes field in case the sum of pixmap + reference sizes doesn't fit in CARD32. + +A value error is generated if invalid resource or client XID is given +in the request. + +5.2 Requests in version 1.2 + +┌─── + XResQueryClientIds + num_specs: CARD32 + client_specs: LISTofCLIENTIDSPEC + ▶ + num_ids: CARD32 + client_ids: LISTofCLIENTIDVALUE + + Errors: Value +└─── + +XResQueryClientIds can be used to identify a given set of clients with +some identification method. The request sends a list of specifiers +that select clients and identification methods to server. The server +then tries to identify the chosen clients using the identification +methods specified for each client. The server returns IDs for those +clients that were successfully identified. It's not an error condition +if some identification method couldn't be applied to a client. If the +server is unable to identify some clients, they simply aren't included +in the returned list. + +The request supports wildcards in the client specifications so that in +the most general case all IDs of all clients can be queried with a +single CLIENTIDSPEC. + +The CLIENTIDSPEC of request and CLIENTIDSPEC of CLIENTIDVALUE in reply +usually match each other. For example, if a request selected a client +by a resource ID owned by the client, then the client is identified by +the same resource ID in the reply. This has been done so that it would +be easy to identify an owner of some resource. + +However, the CLIENTIDSPEC of returned CLIENTIDVALUE never contains any +wildcards. If the request used a wildcard to specify all clients in a +single CLIENTIDSPEC, then the reply has expanded the wildcard and +returns separate CLIENTIDVALUE records for each client. In this case +wildcarded clients are identified by resource_base of CLIENTXIDRANGE. + +The LocalClientPid type of IDs are included in the reply list only if +the client executing the request asked for it and was also a local +client itself. It doesn't make sense for remote clients to ask PIDs of +local clients. + +num_specs + Number of client ID specifications. +client_specs + A list specifying identification methods for clients. Supports + multiple identification methods and clients in a single + specification. See CLIENTIDSPEC for details. +num_ids + Number of IDs that were successfully determined. Can be different + from num_specs or even zero if the server didn't support any + identification methods for the given clients. +client_ids + A list specifying ID information for successfully identified + clients. If wildcards were used in a single CLIENTIDSPEC of + client_specs, then multiple CLIENTIDVALUE records may be returned + for that CLIENTIDSPEC. See CLIENTIDVALUE for details. + +A Value error is returned if the request specifies an invalid client +XID or invalid identification method type. + +┌─── + XResQueryResourceBytes + client: CLIENTXID or None + num_specs: CARD32 + resource_specs: LISTofRESOURCEIDSPEC + ▶ + num_sizes: CARD32 + sizes: LISTofRESOURCESIZEVALUE + + Errors: Atom, Value +└─── + +XResQueryResourceBytes can be used to ask the sizes of resources from +X server. The request sends a list of specifiers that selects +resources for size calculation. The server tries to calculate the +sizes of chosen resources and returns an estimate for a resource only +if the size could be determined. It's not an error condition if a size +couldn't be calculated. In that case the resources simply aren't +included in the returned list. + +The request supports wildcards so that in the most general case sizes +of all resources of all clients can be queried with a single +RESOURCEIDSPEC. However, the reply has all wildcards expanded and +reports a size of a single resource in each RESOURCESIZEVALUE. + +client + An ID of a client can be given to limit the query to resources of + that client. Just like in CLIENTIDSPEC, any resource ID can be + given to identify a client and None can be used if the query + shouldn't be limited to a specific client. Note that in some cases + this field is redundant because resource_specs already fully + determines which resources are selected. If the client ID doesn't + match the owner of any resource in resource_specs, no sizes are + returned and no error is generated. +num_specs + Number of resource specifications. +resource_specs + A list of resource specifications. Each specification can either + uniquely identify a single resource or multiple resources if + wildcarding is used. See RESOURCEIDSPEC for details. +num_sizes + Number of resources whose size could be determined. Can be + different from num_specs or even zero if the server didn't support + size calculation for the given resources. +sizes + A list of resource sizes. Each resource size is linked to a unique + resource. Wildcards are never used in the returned size + records. For example, it's not possible to receive a single + RESOURCESIZEVALUE that would specify the size of all pixmaps if + the sizes of pixmap type resources were asked. Instead, a single + RESOURCESIZEVALUE would be returned for each pixmap in that case. + +An Atom error is returned if the request specifies an invalid resource +type. A Value error is returned if the request specifies an invalid +XID for a client or a resource. + + ❧❧❧❧❧❧❧❧❧❧❧ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/xv-protocol-v2.txt b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/xv-protocol-v2.txt new file mode 100644 index 0000000000000000000000000000000000000000..d863185b7bfb746a2fccb1f1152dbc95169ccefb --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/xv-protocol-v2.txt @@ -0,0 +1,654 @@ + + + + + + + + + + X Video Extension + Protocol Description + + Version 2 + + 25-JUL-91 + + David Carver + + Digital Equipment Corporation + Workstation Engineering/Project Athena + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts, + and the Massachusetts Institute of Technology, Cambridge, Massachusetts. + + All Rights Reserved + + Permission to use, copy, modify, and distribute this software and its + documentation for any purpose and without fee is hereby granted, provided + that the above copyright notice appear in all copies and that both that + copyright notice and this permission notice appear in supporting + documentation, and that the names of Digital or MIT not be used in + advertising or publicity pertaining to distribution of the software + without specific, written prior permission. + + DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING + ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL + DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR + ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER + IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + Preface + ------- + + The following is an outline for an X video extension protocol. It + is preliminary and subject to change. My goal in writing this was + to fix some the shortcomings of existing overly simplistic + extensions while avoiding pitfalls in an overly complex extension. + + Your feedback is desired, and since the major design directions + have been stable for some time, feel free to hammer on the details + of the protocol. + + When you receive a revision of the document, refer to the changes + and issues sections to guide your review and analysis. + + + Acknowledgements + --------------- + + The following people have made major contributions to the design of + the Xv protocol: + + Branko Gerovac (DEC/Corporate Research) + Russ Sasnett (GTE/Project Athena) + Ralph Swick (DEC/Project Athena) + + Many ideas and approaches in Xv were the product of discussions + with several groups, including + + Project Athena's Visual Computing Group + The MIT X Consortium + The MIT Media Lab's Interactive Cinema Group + + + + Changes + ------- + + From version 1.3 to 2.0 + + -- Changed SetPortControl and GetPortControl to GetPortAttribute + and SetPortAttribute. + + -- Changed QueryBestSize + + -- Simplified SelectVideoNotify and SelectPortNotify requests. + + -- Changed the way SetPortControl and GetPortControl works. + + -- Added a QueryExtension request to return the version and + revision information of the extension. + + -- Changed the name of the QueryVideo request to QueryAdaptors; + Removed the list of encodings from QueryVideo and added a + QueryEncodings request. + + -- Added a PortNotify event that notifies interested clients that + a port control has been changed. + + -- Added SelectPortNotify request to select for PortNotify events. + + -- The XvInterruped reason has been replaced by two new reasons: + one for when video is preempted by another video request and + one for when video is terminated because of hard transmission + or reception errors. + + -- Changed the wording of the QueryBestSize request. Added issue + about whether or not returned sizes should maintain the + requested aspect ratio. + + + + Introduction + ------------ + + Video technology is moving very quickly. Standards for processing + high resolution video are currently a hot topic of discussion + internationally, and it will soon be possible to process video + entirely within the digital domain. The Xv extension, however, + does not attempt to address issues of digital video. Its purpose + is to provide a mechanism for support of current and near term + interactive video technology. + + It is somewhat ironic that Xv contains nothing particularly + innovative. It takes a minimalistic approach, and without a doubt + it could have been defined years ago, and with several revisions. + So, the life expectancy of Xv is not long. Nevertheless, it may + undergo further revision and experimentation that will help our + progress towards digital video systems. + + One premise of the Xv extension is that the X server is not alone. + A separate video server is often used to manage other aspects of + video processing, though the partition between what the X server + does and what a video server does is a matter of great debate. + + + Model + ----- + + This extension models video monitor capabilities in the X Window + System. Some advanced monitors support the simultaneous display + of multiple video signals (into separate windows), and that is + represented here through the ability to display video from + multiple video input adaptors into X drawables. + + Some monitors support multiple video encodings (mostly for + internationalization purposes) either through switches or + automatic detection, thus each video adaptor specifies the set of + encodings it supports. + + The requests to display video from an adaptor into a drawable are + modeled after the core PutImage request, though extended to + support scaling and source clipping. + + Video output is also supported and is symmetric with the video + input function, though fewer GC components are used. + + + Mechanism + --------- + + The Xv extension does the following: + + -- lists available video adaptors + -- identifies the number of ports each adaptor supports + -- describes what drawable formats each adaptor supports + -- describes what video encodings each adaptor supports + -- displays video from a port to a drawable + -- captures video from a drawable to a port + -- grabs and ungrabs ports + -- sets and gets port attributes + -- delivers event notification + + + + Adaptors + -------- + + A display may have multiple video input and output adaptors. An + adaptor may support multiple simultaneously active ports, and in + some cases the number of ports has no fixed limit. + + An input port receives encoded video data and converts it to a + stream of data used to update a drawable. An output port samples + data from a drawable and produces a stream of encoded video data. + + The ADAPTORINFO structure is used to describe a video adaptor. + + ADAPTORINFO: + [base-id: PORT + num-ports: CARD16 + type: SETofADAPTORTYPE + formats: LISTofFORMAT + name: STRING] + + ADAPTORTYPE: {Input, Output} + + FORMAT: + [depth: CARD8 + visual: VISUALID] + + The base-id field specifies the XID of the first port of the + adaptor. The `num-ports' field specifies how many ports the + adaptor supports. The ports of the adaptor have XIDs in the range + [base-id..base-id + num-ports - 1] + + The type attribute determines if the adaptor can process video + input, output, or input and output. The if the adaptor can + process input then Input is asserted, if the adaptor can process + output then Output is asserted. + + The drawable depths and visual types supported by the adaptor are + listed in `formats'. Note: that when video is being processed for + pixmaps the visual format is taken to be the visual of the first + pair that matches the depth of the pixmap. + + The name field contains an a vendor specific string that + identifies the adaptor. + + It should be noted that the existence of separate adaptors doesn't + necessarily imply that simultaneous operation is supported. + + + + Errors + ------ + + Port + + A Port error is returned if any request names a PORT that does not + exist. + + + Encoding + + An Encoding error is returned if any request names an ENCODINGID + that does not exist. + + + + + Query Requests + ------------------- + + QueryExtension + ==> + version: CARD16 + revision: CARD16 + + The QueryExtension request returns the extension version and + revision numbers. + + + QueryAdaptors + win: WINDOW + ==> + adaptors: LISTofADAPTORINFO + + The QueryAdaptors request returns the video adaptor information for + the screen of the specified window. + + Errors: {Window} + + + QueryEncodings + port: PORT + ==> + encodings: LISTofENCODINGINFO + + The QueryEncodings request returns the list of encodings supported + by the port adaptor. Use the SetPortAttribute request to set + which encoding a port is to process. The ENCODINGINFO record + describes an encoding: + + ENCODINGINFO: + [encoding: ENCODINGID + name: STRING + width, height: CARD16 + rate: FRACTION] + + The `encoding' field identifies an encoding supported by a port. + Its value is unique for a screen. Width and height specify the + size of the video image and rate specifies the rate at which + fields of image information are encoded. + + An encoding is identified by a string that names the encoding. + Encoding naming conventions need to be established (i.e., + something along the lines of font naming, but simpler) + + FRACTION + [numerator, denominator: INT32] + + The FRACTION structure is used to specify a fractional number. + + Errors: {Port} + + + + Put Video Requests + ------------------ + + PutVideo + port: PORT + drawable: DRAWABLE + gc: GCONTEXT + vid-x, vid-y: INT16 + vid-w, vid-h: CARD16 + drw-x, drw-y: INT16 + drw-w, drw-h: CARD16 + + The PutVideo request writes video into a drawable. The position + and size of the source rectangle is specified by vid-x, vid-y, + vid-w, and vid-h. The position and size of the destination + rectangle is specified by drw-x, drw-y, drw-w, drw-h. + + Video data is clipped to the bounds of the video encoding, scaled + to the requested drawable region size (or the closest size + supported), and clipped to the bounds of the drawable. + + If video is successfully initiated, a VideoNotify event with + detail Started is generated for the drawable. If the port is + already in use, its video is preempted, and if the new drawable is + different than the old, a VideoNotify event with detail Preempted + is generated for the old drawable. If the port is grabbed by + another client, this request is ignored, and a VideoNotify event + with detail Busy is generated for the drawable. If the port is + not receiving a valid video signal or if the video signal is + interrupted while video is active a VideoNotify event with detail + HardError is generated for the drawable. + + GC components: subwindow-mode, clip-x-origin, clip-y-origin, clip-mask. + + Errors: {Match, Value, GContext, Port, Alloc} + + + PutStill + port: PORT + drawable: DRAWABLE + gc: GCONTEXT + vid-x, vid-y: INT16 + vid-w, vid-h: CARD16 + drw-x, drw-y: INT16 + drw-w, drw-h: CARD16 + + The PutStill request writes a single frame of video into a + drawable. The position and size of the source rectangle is + specified by vid-x, vid-y, vid-w, and vid-h. The position and + size of the destination rectangle is specified by drw-x, drw-y, + drw-w, drw-h. + + Video data is clipped to the bounds of the video encoding, scaled + to the requested drawable region size (or the closest size + supported) and clipped to the bounds of the drawable. + + If the port is grabbed by another client, this request is ignored, + and a VideoNotify event with detail Busy is generated for the + drawable. If the port is not receiving a valid video signal a + VideoNotify event with detail HardError is generated for the + drawable. + + GC components: subwindow-mode, clip-x-origin, clip-y-origin, clip-mask. + + Errors: {Match, Value, GContext, Port, Alloc} + + + + Get Video Requests + ------------------ + + GetVideo + port: PORT + drawable: DRAWABLE + gc: GCONTEXT + vid-x, vid-y: INT16 + vid-w, vid-h: CARD16 + drw-x, drw-y: INT16 + drw-w, drw-h: CARD16 + + The GetVideo request outputs video from a drawable. The position + and size of the destination rectangle is specified by vid-x, + vid-y, vid-w, and vid-h. The position and size of the source + rectangle is specified by drw-x, drw-y, drw-w, and drw-h. + + Drawable data is clipped to the bounds of the drawable, scaled to + the requested video region size (or the closest size supported) + and clipped to the bounds of the video encoding. The contents of + any region not updated with drawable data is undefined. + + If video is successfully initiated, a VideoNotify event with + detail Started is generated for the drawable. If the port is + already in use, its video is preempted, and if the new drawable is + different than the old, a VideoNotify event with detail Preempted + is generated for the old drawable. If the port is grabbed by + another client, this request is ignored, and a VideoNotify event + with detail Busy is generated for the drawable. + + GC components: subwindow-mode, clip-x-origin, clip-y-origin, + clip-mask. + + Errors: {Match, Value, GContext, Port, Alloc} + + + GetStill + port: PORT + drawable: DRAWABLE + gc: GCONTEXT + vid-x, vid-y: INT16 + vid-w, vid-h: CARD16 + drw-x, drw-y: INT16 + drw-w, drw-h: CARD16 + + The GetStill request outputs video from a drawable. The position + and size of the destination rectangle is specified by vid-x, + vid-y, vid-w, and vid-h. The position and size of the source + rectangle is specified by drw-x, drw-y, drw-w, and drw-h. + + Drawable data is clipped to the bounds of the drawable, scaled to + the requested video region size (or the closest size supported) + and clipped to the bounds of the video encoding. The contents of + any region not updated with drawable data is undefined. + + If the still is successfully captured a VideoNotify event with + detail Still is generated for the drawable. If the port is + grabbed by another client, this request is ignored, and a + VideoNotify event with detail Busy is generated for the drawable. + + GC components: subwindow-mode, clip-x-origin, clip-y-origin, + clip-mask. + + Errors: {Match, Value, GContext, Port, Alloc} + + + + + Grab Requests + ------------- + + GrabPort + port: PORT + timestamp: {TIMESTAMP, CurrentTime} + ==> + status: {Success, AlreadyGrabbed, InvalidTime} + + The GrabPort request grabs a port. While a port is grabbed, only + video requests from the grabbing client are permitted. + + If timestamp specifies a time older than the current port time, a + status of InvalidTime is returned. If the port is already grabbed + by another client, a status of AlreadyGrabbed is returned. + Otherwise a status of Success is returned. The port time is + updated when the following requests are processed: GrabPort, + UngrabPort, PutVideo, PutStill, GetVideo, GetStill + + If the port is actively processing video for another client, the + video is preempted, and an VideoNotify event with detail Preempted + is generated for its drawable. + + Errors: {Port} + + + UngrabPort + port: PORT + timestamp: {TIMESTAMP, CurrentTime} + + The UngrabPort request ungrabs a port. If timestamp specifies a + time before the last connection request time of this port, the + request is ignored. + + Errors: {Port} + + + + Other Requests + -------------- + + StopVideo + port: PORT + drawable: DRAWABLE + + The StopVideo request stops active video for the specified port + and drawable. If the port isn't processing video, or if it is + processing video in a different drawable, the request is ignored. + When video is stopped a VideoNotify event with detail Stopped is + generated for the associated drawable. + + Errors: {Drawable, Port} + + + SelectVideoNotify + drawable: DRAWABLE + onoff: BOOL + + The SelectVideoNotify request enables or disables VideoNotify + event delivery to the requesting client. VideoNotify events are + generated when video starts and stops. + + Errors: {Drawable} + + + SelectPortNotify + port: PORT + onoff: BOOL + + The SelectPortNotify request enables or disables PortNotify event + delivery to the requesting client. PortNotify events are + generated when port attributes are changed using SetPortAttribute. + + Errors: {Port} + + + QueryBestSize + port: PORT + motion: BOOL + vid-w, vid-h: CARD16 + drw-w, drw-h: CARD16 + ==> + actual-width, actual-height: CARD16 + + The QueryBestSize request returns, for the given source size and + desired destination size, the closest destination size that the + port adaptor supports. The returned size will be equal + or smaller than the requested size if one is supported. If motion + is True then the requested size is intended for use with full + motion video. If motion is False, the requested size is intended + for use with stills only. + + The returned size is also chosen to maintain the requested aspect ratio + if possible. + + Errors: {Port} + + + + SetPortAttribute + port: PORT + attribute: ATOM + value: INT32 + + The SetPortAttribute request sets the value of a port attribute. + The port attribute is identified by the attribute atom. The + following strings are guaranteed to generate valid atoms using the + InternAtom request. + + String Type + ----------------------------------------------------------------- + + "XV_ENCODING" ENCODINGID + "XV_HUE" [-1000..1000] + "XV_SATURATION" [-1000..1000] + "XV_BRIGHTNESS" [-1000..1000] + "XV_CONTRAST" [-1000..1000] + + + If the given attribute doesn't match an attribute supported by the + port adaptor a Match error is generated. The supplied encoding + must be one of the encodings listed for the adaptor, otherwise an + Encoding error is generated. + + If the adaptor doesn't support the exact hue, saturation, + brightness, and contrast levels supplied, the closest levels + supported are assumed. The GetPortAttribute request can be used + to query the resulting levels. + + When a SetPortAttribute request is processed a PortNotify event is + generated for all clients that have requested port change + notification using SelectPortNotify. + + Errors: {Port, Match, Value} + + + GetPortAttribute + port: PORT + attribute: ATOM + ==> + value: INT32 + + + The GetPortAttribute request returns the current value of the + attribute identified by the given atom. If the given atom + doesn't match an attribute supported by the adaptor a Match + error is generated. + + Errors: {Port, Match} + + + + Events + ------ + + VideoNotify + drawable: DRAWABLE + port: PORT + reason: REASON + time: TIMESTAMP + + REASON: {Started, Still, Stopped, Busy, Preempted, HardError} + + A VideoNotify event is generated when video activity is started, + stopped, or unable to proceed in a drawable. + + A Started reason is generated when video starts in a drawable. + + A Stopped reason is generated when video is stopped in a + drawable upon request. + + A Busy reason is generated when a put or get request cannot + proceed because the port is grabbed by another client. + + A Preempted reason is generated when video is stopped by a + conflicting request. + + A HardError reason is generated when the video port cannot + initiate or continue processing a video request because of an + underlying transmission or reception error. + + + PortNotify + port: PORT + attribute: ATOM + value: INT32 + time: TIMESTAMP + + The PortNotify event is generated when a SetPortAttribute request + is processed. The event is delivered to all clients that have + performed a SelectPortNotify request for the port. The event + contains the atom identifying the attribute that changed, and the + new value of that attribute. diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/xwaylandproto.txt b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/xwaylandproto.txt new file mode 100644 index 0000000000000000000000000000000000000000..25fdf87437191dc3df33b4e121ee3355e86afbed --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xorgproto/xwaylandproto.txt @@ -0,0 +1,96 @@ + The XWAYLAND Extension + Version 1.0 + 2022-07-29 + +1. Introduction + +The XWAYLAND extension allows clients to reliably identify whether an X server +is Xwayland. It does not provide any functionality beyond the absolute minimum +to identify as extension. + +Only Xwayland initializes this extension. Thus, if the extension is present, +the X server is Xwayland. Clients should not need the protocol detailed in this +document, a QueryExtension or ListExtensions request is sufficient to check +whether the extension is present. + +The protocol detailed in this document is merely to future-proof this extension +in case actual functionality is added in the future. + + ❄ ❄ ❄ ❄ ❄ ❄ ❄ +2. Version History + +- 1.0, July 2022: QueryVersion request only + + ❄ ❄ ❄ ❄ ❄ ❄ ❄ + +3. Events and Errors + +XWAYLAND defines no events or errrors + + ❄ ❄ ❄ ❄ ❄ ❄ ❄ + +4. Extension initialization + +The name of this extension is "XWAYLAND" + +┌─── + XwlQueryVersion + client-major-version: CARD16 + client-minor-version: CARD16 + ▶ + major-version: CARD16 + minor-version: CARD16 +└─── + + The client sends the highest supported version to the server + and the server replies with the highest version it supports, + but no higher than the requested version. Major versions changes + can introduce incompatibilities in existing functionality, minor + version changes introduce only backward compatible changes. + It is the clients responsibility to ensure that the server + supports a version which is compatible with its expectations. + + Backwards compatible changes include addition of new + requests. + + ❄ ❄ ❄ ❄ ❄ ❄ ❄ + +Appendix A. Protocol Encoding + +Syntactic Conventions + +This document uses the same syntactic conventions as the core X +protocol encoding document. + +A.1 Common Types + +None. + +A.2 Protocol Requests + +┌─── + XwlQueryVersion + 1 CARD8 major opcode + 1 0 XWAYLAND opcode + 2 2 length + 2 CARD16 major version + 2 CARD16 minor version + ▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 2 CARD16 major version + 2 CARD16 minor version + 20 unused +└─── + +A.3 Protocol Events + +The XWAYLAND extension defines no events. + +A.4 Protocol Errors + +The XWAYLAND extension defines no errors. + + ❄ ❄ ❄ ❄ ❄ ❄ ❄ diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xproto/encoding.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xproto/encoding.xml new file mode 100644 index 0000000000000000000000000000000000000000..0c6ef028ec8ce36e2025e5890882af4cac0596bb --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xproto/encoding.xml @@ -0,0 +1,3268 @@ + +Protocol Encoding + + +Syntactic Conventions + + +All numbers are in decimal, +unless prefixed with #x, in which case they are in hexadecimal (base 16). + + + +The general syntax used to describe requests, replies, errors, events, and +compound types is: + + + + NameofThing + encode-form + ... + encode-form + + + +Each encode-form describes a single component. + + +For components described in the protocol as: + + + name: TYPE + + + +the encode-form is: + + + + N TYPE name + + + +N is the number of bytes occupied in the data stream, +and TYPE is the interpretation of those bytes. +For example, + + + + depth: CARD8 + + + +becomes: + + + + 1 CARD8 depth + + + +For components with a static numeric value the encode-form is: + + + + N value name + + + +The value is always interpreted as an N-byte unsigned integer. +For example, +the first two bytes of a +Window +error are always zero (indicating an +error in general) and three (indicating the +Window +error in particular): + + + + 1 0 Error + 1 3 code + + + +For components described in the protocol as: + + + +name: +{ Name1,..., +NameI} + + + +the encode-form is: + + + + N name + value1 Name1 + ... + valueI NameI + + + +The value is always interpreted as an N-byte unsigned integer. +Note that the size of N is sometimes larger than that strictly required +to encode the values. +For example: + + + +class: +{ InputOutput, +InputOnly, +CopyFromParent } + + + +becomes: + + + +2 class + 0 CopyFromParent + 1 InputOutput + 2 InputOnly + + + +For components described in the protocol as: + + + +NAME: TYPE or +Alternative1 ...or +AlternativeI + + + +the encode-form is: + + + +N TYPE NAME + value1 Alternative1 + ... + valueI AlternativeI + + + +The alternative values are guaranteed not to conflict with the encoding +of TYPE. +For example: + + + +destination: WINDOW or +PointerWindow +or +InputFocus + + + +becomes: + + + +4 WINDOW destination + 0 PointerWindow + 1 InputFocus + + + +For components described in the protocol as: + + + + value-mask: BITMASK + + + +the encode-form is: + + + +N BITMASK value-mask + mask1 mask-name1 + ... + maskI mask-nameI + + + +The individual bits in the mask are specified and named, +and N is 2 or 4. +The most-significant bit in a BITMASK is reserved for use in defining +chained (multiword) bitmasks, as extensions augment existing core requests. +The precise interpretation of this bit is not yet defined here, +although a probable mechanism is that a 1-bit indicates that another N bytes +of bitmask follows, with bits within the overall mask still interpreted +from least-significant to most-significant with an N-byte unit, +with N-byte units +interpreted in stream order, and with the overall mask being byte-swapped +in individual N-byte units. + + + +For LISTofVALUE encodings, the request is followed by a section of the form: + + + + VALUEs + encode-form + ... + encode-form + + + +listing an encode-form for each VALUE. +The NAME in each encode-form keys to the corresponding BITMASK bit. +The encoding of a VALUE always occupies four bytes, +but the number of bytes specified in the encoding-form indicates how +many of the least-significant bytes are actually used; +the remaining bytes are unused and their values do not matter. + + + +In various cases, the number of bytes occupied by a component will be +specified +by a lowercase single-letter variable name instead of a specific numeric +value, and often some other component will have its value specified as a +simple numeric expression involving these variables. +Components specified with such expressions are always interpreted +as unsigned integers. +The scope of such variables is always just the enclosing request, reply, +error, event, or compound type structure. +For example: + + + +2 3+n request length +4n LISTofPOINT points + + + +For unused bytes (the values of the bytes are undefined and do no matter), +the encode-form is: + + + + N unused + + + + +If the number of unused bytes is variable, the encode-form typically is: + + + + p unused, p=pad(E) + + + +where E is some expression, + +Padding +and pad(E) is the number of bytes needed to round E up to a multiple of four. + + + + + pad(E) = (4 - (E mod 4)) mod 4 + + + + +Common Types +Typesencoding + + + + LISTofFOO + + +In this document the LISTof notation strictly means some number of repetitions +of the FOO encoding; +the actual length of the list is encoded elsewhere. + + + + + SETofFOO + + +A set is always represented by a bitmask, with a 1-bit indicating presence in +the set. + + + + + + + + + + + +BITMASK: CARD32 + + + + +WINDOW: CARD32 + + + + +PIXMAP: CARD32 + + + + +CURSOR: CARD32 + + + + +FONT: CARD32 + + + + +GCONTEXT: CARD32 + + + + +COLORMAP: CARD32 + + + + +DRAWABLE: CARD32 + + + + +FONTABLE: CARD32 + + + + +ATOM: CARD32 + + + + +VISUALID: CARD32 + + + + +BYTE: 8-bit value + + + + +INT8: 8-bit signed integer + + + + +INT16: 16-bit signed integer + + + + +INT32: 32-bit signed integer + + + + +CARD8: 8-bit unsigned integer + + + + +CARD16: 16-bit unsigned integer + + + + +CARD32: 32-bit unsigned integer + + + + +TIMESTAMP: CARD32 + + + + + + + + +BITGRAVITY + 0 Forget + 1 NorthWest + 2 North + 3 NorthEast + 4 West + 5 Center + 6 East + 7 SouthWest + 8 South + 9 SouthEast + 10 Static + +WINGRAVITY + 0 Unmap + 1 NorthWest + 2 North + 3 NorthEast + 4 West + 5 Center + 6 East + 7 SouthWest + 8 South + 9 SouthEast + 10 Static + +BOOL + 0 False + 1 True + +SETofEVENT + #x00000001 KeyPress + #x00000002 KeyRelease + #x00000004 ButtonPress + #x00000008 ButtonRelease + #x00000010 EnterWindow + #x00000020 LeaveWindow + #x00000040 PointerMotion + #x00000080 PointerMotionHint + #x00000100 Button1Motion + #x00000200 Button2Motion + #x00000400 Button3Motion + #x00000800 Button4Motion + #x00001000 Button5Motion + #x00002000 ButtonMotion + #x00004000 KeymapState + #x00008000 Exposure + #x00010000 VisibilityChange + #x00020000 StructureNotify + #x00040000 ResizeRedirect + #x00080000 SubstructureNotify + #x00100000 SubstructureRedirect + #x00200000 FocusChange + #x00400000 PropertyChange + #x00800000 ColormapChange + #x01000000 OwnerGrabButton + #xFE000000 unused but must be zero + +SETofPOINTEREVENT + encodings are the same as for SETofEVENT, except with + #xFFFF8003 unused but must be zero + +SETofDEVICEEVENT + encodings are the same as for SETofEVENT, except with + #xFFFFC0B0 unused but must be zero + +KEYSYM: CARD32 +KEYCODE: CARD8 +BUTTON: CARD8 + +SETofKEYBUTMASK + #x0001 Shift + #x0002 Lock + #x0004 Control + #x0008 Mod1 + #x0010 Mod2 + #x0020 Mod3 + #x0040 Mod4 + #x0080 Mod5 + #x0100 Button1 + #x0200 Button2 + #x0400 Button3 + #x0800 Button4 + #x1000 Button5 + #xE000 unused but must be zero + +SETofKEYMASK + encodings are the same as for SETofKEYBUTMASK, except with + #xFF00 unused but must be zero +STRING8: LISTofCARD8 +STRING16: LISTofCHAR2B + +CHAR2B + 1 CARD8 byte1 + 1 CARD8 byte2 + +POINT + 2 INT16 x + 2 INT16 y + +RECTANGLE + 2 INT16 x + 2 INT16 y + 2 CARD16 width + 2 CARD16 height + +ARC + 2 INT16 x + 2 INT16 y + 2 CARD16 width + 2 CARD16 height + 2 INT16 angle1 + 2 INT16 angle2 + +HOST + 1 family + 0 Internet + 1 DECnet + 2 Chaos + 5 ServerInterpreted + 6 InternetV6 + 1 unused + 2 n length of address + n LISTofBYTE address + p unused, p=pad(n) + +STR + 1 n length of name in bytes + n STRING8 name + + + + + +Errors +Error reportencoding + + +Request + 1 0 Error + 1 1 code + 2 CARD16 sequence number + 4 unused + 2 CARD16 minor opcode + 1 CARD8 major opcode + 21 unused + +Value + 1 0 Error + 1 2 code + 2 CARD16 sequence number + 4 <32-bits> bad value + 2 CARD16 minor opcode + 1 CARD8 major opcode + 21 unused + +Window + 1 0 Error + 1 3 code + 2 CARD16 sequence number + 4 CARD32 bad resource id + 2 CARD16 minor opcode + 1 CARD8 major opcode + 21 unused + +Pixmap + 1 0 Error + 1 4 code + 2 CARD16 sequence number + 4 CARD32 bad resource id + 2 CARD16 minor opcode + 1 CARD8 major opcode + 21 unused + +Atom + 1 0 Error + 1 5 code + 2 CARD16 sequence number + 4 CARD32 bad atom id + 2 CARD16 minor opcode + 1 CARD8 major opcode + 21 unused + +Cursor + 1 0 Error + 1 6 code + 2 CARD16 sequence number + 4 CARD32 bad resource id + 2 CARD16 minor opcode + 1 CARD8 major opcode + 21 unused + +Font + 1 0 Error + 1 7 code + 2 CARD16 sequence number + 4 CARD32 bad resource id + 2 CARD16 minor opcode + 1 CARD8 major opcode + 21 unused + +Match + 1 0 Error + 1 8 code + 2 CARD16 sequence number + 4 unused + 2 CARD16 minor opcode + 1 CARD8 major opcode + 21 unused + +Drawable + 1 0 Error + 1 9 code + 2 CARD16 sequence number + 4 CARD32 bad resource id + 2 CARD16 minor opcode + 1 CARD8 major opcode + 21 unused + +Access + 1 0 Error + 1 10 code + 2 CARD16 sequence number + 4 unused + 2 CARD16 minor opcode + 1 CARD8 major opcode + 21 unused + +Alloc + 1 0 Error + 1 11 code + 2 CARD16 sequence number + 4 unused + 2 CARD16 minor opcode + 1 CARD8 major opcode + 21 unused + +Colormap + 1 0 Error + 1 12 code + 2 CARD16 sequence number + 4 CARD32 bad resource id + 2 CARD16 minor opcode + 1 CARD8 major opcode + 21 unused + +GContext + 1 0 Error + 1 13 code + 2 CARD16 sequence number + 4 CARD32 bad resource id + 2 CARD16 minor opcode + 1 CARD8 major opcode + 21 unused + +IDChoice + 1 0 Error + 1 14 code + 2 CARD16 sequence number + 4 CARD32 bad resource id + 2 CARD16 minor opcode + 1 CARD8 major opcode + 21 unused + +Name + 1 0 Error + 1 15 code + 2 CARD16 sequence number + 4 unused + 2 CARD16 minor opcode + 1 CARD8 major opcode + 21 unused + +Length + 1 0 Error + 1 16 code + 2 CARD16 sequence number + 4 unused + 2 CARD16 minor opcode + 1 CARD8 major opcode + 21 unused + +Implementation + 1 0 Error + 1 17 code + 2 CARD16 sequence number + 4 unused + 2 CARD16 minor opcode + 1 CARD8 major opcode + 21 unused + + + + +Keyboards + + +KEYCODE values are always greater than 7 (and less than 256). + + + +KEYSYM values with the bit #x10000000 set are reserved as vendor-specific. + + + +The names and encodings of the standard KEYSYM values are contained in +Appendix A, Keysym Encoding. + + + + +Pointers + + +BUTTON values are numbered starting with one. + + + + +Predefined Atoms +Atompredefined + + +PRIMARY 1 WM_NORMAL_HINTS 40 +SECONDARY 2 WM_SIZE_HINTS 41 +ARC 3 WM_ZOOM_HINTS 42 +ATOM 4 MIN_SPACE 43 +BITMAP 5 NORM_SPACE 44 +CARDINAL 6 MAX_SPACE 45 +COLORMAP 7 END_SPACE 46 +CURSOR 8 SUPERSCRIPT_X 47 +CUT_BUFFER0 9 SUPERSCRIPT_Y 48 +CUT_BUFFER1 10 SUBSCRIPT_X 49 +CUT_BUFFER2 11 SUBSCRIPT_Y 50 +CUT_BUFFER3 12 UNDERLINE_POSITION 51 +CUT_BUFFER4 13 UNDERLINE_THICKNESS 52 +CUT_BUFFER5 14 STRIKEOUT_ASCENT 53 +CUT_BUFFER6 15 STRIKEOUT_DESCENT 54 +CUT_BUFFER7 16 ITALIC_ANGLE 55 +DRAWABLE 17 X_HEIGHT 56 +FONT 18 QUAD_WIDTH 57 +INTEGER 19 WEIGHT 58 +PIXMAP 20 POINT_SIZE 59 +POINT 21 RESOLUTION 60 +RECTANGLE 22 COPYRIGHT 61 +RESOURCE_MANAGER 23 NOTICE 62 +RGB_COLOR_MAP 24 FONT_NAME 63 +RGB_BEST_MAP 25 FAMILY_NAME 64 +RGB_BLUE_MAP 26 FULL_NAME 65 +RGB_DEFAULT_MAP 27 CAP_HEIGHT 66 +RGB_GRAY_MAP 28 WM_CLASS 67 +RGB_GREEN_MAP 29 WM_TRANSIENT_FOR 68 +RGB_RED_MAP 30 +STRING 31 +VISUALID 32 +WINDOW 33 +WM_COMMAND 34 +WM_HINTS 35 +WM_CLIENT_MACHINE 36 +WM_ICON_NAME 37 +WM_ICON_SIZE 38 +WM_NAME 39 + + + + +Connection Setup + + +For TCP connections, +displays on a given host are numbered starting from 0, +and the server for display N listens and accepts connections on port 6000 + N. +For DECnet connections, +displays on a given host are numbered starting from 0, +and the server for display N listens and accepts connections on the object +name obtained by concatenating "X$X" with the decimal representation of N, +for example, X$X0 and X$X1. + + + +Information sent by the client at connection setup: + + + + 1 byte-order + #x42 MSB first + #x6C LSB first + 1 unused + 2 CARD16 protocol-major-version + 2 CARD16 protocol-minor-version + 2 n length of authorization-protocol-name + 2 d length of authorization-protocol-data + 2 unused + n STRING8 authorization-protocol-name + p unused, p=pad(n) + d STRING8 authorization-protocol-data + q unused, q=pad(d) + + + +Except where explicitly noted in the protocol, +all 16-bit and 32-bit quantities sent by the client must be transmitted +with the specified byte order, +and all 16-bit and 32-bit quantities returned by the server will be transmitted +with this byte order. + + + +Information received by the client if the connection is refused: + + + + 1 0 Failed + 1 n length of reason in bytes + 2 CARD16 protocol-major-version + 2 CARD16 protocol-minor-version + 2 (n+p)/4 length in 4-byte units of "additional data" + n STRING8 reason + p unused, p=pad(n) + + + +Information received by the client if further authentication is required: + + + + 1 2 Authenticate + 5 unused + 2 (n+p)/4 length in 4-byte units of "additional data" + n STRING8 reason + p unused, p=pad(n) + + + +Information received by the client if the connection is accepted: + + + + 1 1 Success + 1 unused + 2 CARD16 protocol-major-version + 2 CARD16 protocol-minor-version + 2 8+2n+(v+p+m)/4 length in 4-byte units of + "additional data" + 4 CARD32 release-number + 4 CARD32 resource-id-base + 4 CARD32 resource-id-mask + 4 CARD32 motion-buffer-size + 2 v length of vendor + 2 CARD16 maximum-request-length + 1 CARD8 number of SCREENs in roots + 1 n number for FORMATs in + pixmap-formats + 1 image-byte-order + 0 LSBFirst + 1 MSBFirst + 1 bitmap-format-bit-order + 0 LeastSignificant + 1 MostSignificant + 1 CARD8 bitmap-format-scanline-unit + 1 CARD8 bitmap-format-scanline-pad + 1 KEYCODE min-keycode + 1 KEYCODE max-keycode + 4 unused + v STRING8 vendor + p unused, p=pad(v) + 8n LISTofFORMAT pixmap-formats + m LISTofSCREEN roots (m is always a multiple of 4) + + + +FORMAT + 1 CARD8 depth + 1 CARD8 bits-per-pixel + 1 CARD8 scanline-pad + 5 unused + + + +SCREEN + 4 WINDOW root + 4 COLORMAP default-colormap + 4 CARD32 white-pixel + 4 CARD32 black-pixel + 4 SETofEVENT current-input-masks + 2 CARD16 width-in-pixels + 2 CARD16 height-in-pixels + 2 CARD16 width-in-millimeters + 2 CARD16 height-in-millimeters + 2 CARD16 min-installed-maps + 2 CARD16 max-installed-maps + 4 VISUALID root-visual + 1 backing-stores + 0 Never + 1 WhenMapped + 2 Always + 1 BOOL save-unders + 1 CARD8 root-depth + 1 CARD8 number of DEPTHs in allowed-depths + n LISTofDEPTH allowed-depths (n is always a + multiple of 4) + + + +DEPTH + 1 CARD8 depth + 1 unused + 2 n number of VISUALTYPES in visuals + 4 unused + 24n LISTofVISUALTYPE visuals + + + +VISUALTYPE + 4 VISUALID visual-id + 1 class + 0 StaticGray + 1 GrayScale + 2 StaticColor + 3 PseudoColor + 4 TrueColor + 5 DirectColor + 1 CARD8 bits-per-rgb-value + 2 CARD16 colormap-entries + 4 CARD32 red-mask + 4 CARD32 green-mask + 4 CARD32 blue-mask + 4 unused + + + + +Requests +Requestencoding + + +CreateWindow + 1 1 opcode + 1 CARD8 depth + 2 8+n request length + 4 WINDOW wid + 4 WINDOW parent + 2 INT16 x + 2 INT16 y + 2 CARD16 width + 2 CARD16 height + 2 CARD16 border-width + 2 class + 0 CopyFromParent + 1 InputOutput + 2 InputOnly + 4 VISUALID visual + 0 CopyFromParent + 4 BITMASK value-mask (has n bits set to 1) + #x00000001 background-pixmap + #x00000002 background-pixel + #x00000004 border-pixmap + #x00000008 border-pixel + #x00000010 bit-gravity + #x00000020 win-gravity + #x00000040 backing-store + #x00000080 backing-planes + #x00000100 backing-pixel + #x00000200 override-redirect + #x00000400 save-under + #x00000800 event-mask + #x00001000 do-not-propagate-mask + #x00002000 colormap + #x00004000 cursor + 4n LISTofVALUE value-list + + VALUEs + 4 PIXMAP background-pixmap + 0 None + 1 ParentRelative + 4 CARD32 background-pixel + 4 PIXMAP border-pixmap + 0 CopyFromParent + 4 CARD32 border-pixel + 1 BITGRAVITY bit-gravity + 1 WINGRAVITY win-gravity + 1 backing-store + 0 NotUseful + 1 WhenMapped + 2 Always + 4 CARD32 backing-planes + 4 CARD32 backing-pixel + 1 BOOL override-redirect + 1 BOOL save-under + 4 SETofEVENT event-mask + 4 SETofDEVICEEVENT do-not-propagate-mask + 4 COLORMAP colormap + 0 CopyFromParent + 4 CURSOR cursor + 0 None + +ChangeWindowAttributes + 1 2 opcode + 1 unused + 2 3+n request length + 4 WINDOW window + 4 BITMASK value-mask (has n bits set to 1) + encodings are the same as for CreateWindow + 4n LISTofVALUE value-list + encodings are the same as for CreateWindow + +GetWindowAttributes + 1 3 opcode + 1 unused + 2 2 request length + 4 WINDOW window + +▶ + 1 1 Reply + 1 backing-store + 0 NotUseful + 1 WhenMapped + 2 Always + 2 CARD16 sequence number + 4 3 reply length + 4 VISUALID visual + 2 class + 1 InputOutput + 2 InputOnly + 1 BITGRAVITY bit-gravity + 1 WINGRAVITY win-gravity + 4 CARD32 backing-planes + 4 CARD32 backing-pixel + 1 BOOL save-under + 1 BOOL map-is-installed + 1 map-state + 0 Unmapped + 1 Unviewable + 2 Viewable + 1 BOOL override-redirect + 4 COLORMAP colormap + 0 None + 4 SETofEVENT all-event-masks + 4 SETofEVENT your-event-mask + 2 SETofDEVICEEVENT do-not-propagate-mask + 2 unused + +DestroyWindow + 1 4 opcode + 1 unused + 2 2 request length + 4 WINDOW window + +DestroySubwindows + 1 5 opcode + 1 unused + 2 2 request length + 4 WINDOW window + +ChangeSaveSet + 1 6 opcode + 1 mode + 0 Insert + 1 Delete + 2 2 request length + 4 WINDOW window + +ReparentWindow + 1 7 opcode + 1 unused + 2 4 request length + 4 WINDOW window + 4 WINDOW parent + 2 INT16 x + 2 INT16 y + +MapWindow + 1 8 opcode + 1 unused + 2 2 request length + 4 WINDOW window + +MapSubwindows + 1 9 opcode + 1 unused + 2 2 request length + 4 WINDOW window + +UnmapWindow + 1 10 opcode + 1 unused + 2 2 request length + 4 WINDOW window + +UnmapSubwindows + 1 11 opcode + 1 unused + 2 2 request length + 4 WINDOW window + +ConfigureWindow + 1 12 opcode + 1 unused + 2 3+n request length + 4 WINDOW window + 2 BITMASK value-mask (has n bits set to 1) + #x0001 x + #x0002 y + #x0004 width + #x0008 height + #x0010 border-width + #x0020 sibling + #x0040 stack-mode + 2 unused + 4n LISTofVALUE value-list + + VALUEs + 2 INT16 x + 2 INT16 y + 2 CARD16 width + 2 CARD16 height + 2 CARD16 border-width + 4 WINDOW sibling + 1 stack-mode + 0 Above + 1 Below + 2 TopIf + 3 BottomIf + 4 Opposite + +CirculateWindow + 1 13 opcode + 1 direction + 0 RaiseLowest + 1 LowerHighest + 2 2 request length + 4 WINDOW window + +GetGeometry + 1 14 opcode + 1 unused + 2 2 request length + 4 DRAWABLE drawable + +▶ + 1 1 Reply + 1 CARD8 depth + 2 CARD16 sequence number + 4 0 reply length + 4 WINDOW root + 2 INT16 x + 2 INT16 y + 2 CARD16 width + 2 CARD16 height + 2 CARD16 border-width + 10 unused + +QueryTree + 1 15 opcode + 1 unused + 2 2 request length + 4 WINDOW window + +▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 n reply length + 4 WINDOW root + 4 WINDOW parent + 0 None + 2 n number of WINDOWs in children + 14 unused + 4n LISTofWINDOW children + +InternAtom + 1 16 opcode + 1 BOOL only-if-exists + 2 2+(n+p)/4 request length + 2 n length of name + 2 unused + n STRING8 name + p unused, p=pad(n) + +▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 4 ATOM atom + 0 None + 20 unused + +GetAtomName + 1 17 opcode + 1 unused + 2 2 request length + 4 ATOM atom + +▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 (n+p)/4 reply length + 2 n length of name + 22 unused + n STRING8 name + p unused, p=pad(n) + +ChangeProperty + 1 18 opcode + 1 mode + 0 Replace + 1 Prepend + 2 Append + 2 6+(n+p)/4 request length + 4 WINDOW window + 4 ATOM property + 4 ATOM type + 1 CARD8 format + 3 unused + 4 CARD32 length of data in format units + (= n for format = 8) + (= n/2 for format = 16) + (= n/4 for format = 32) + n LISTofBYTE data + (n is a multiple of 2 for format = 16) + (n is a multiple of 4 for format = 32) + p unused, p=pad(n) + + +DeleteProperty + 1 19 opcode + 1 unused + 2 3 request length + 4 WINDOW window + 4 ATOM property + +GetProperty + 1 20 opcode + 1 BOOL delete + 2 6 request length + 4 WINDOW window + 4 ATOM property + 4 ATOM type + 0 AnyPropertyType + 4 CARD32 long-offset + 4 CARD32 long-length + +▶ + 1 1 Reply + 1 CARD8 format + 2 CARD16 sequence number + 4 (n+p)/4 reply length + 4 ATOM type + 0 None + 4 CARD32 bytes-after + 4 CARD32 length of value in format units + (= 0 for format = 0) + (= n for format = 8) + (= n/2 for format = 16) + (= n/4 for format = 32) + 12 unused + n LISTofBYTE value + (n is zero for format = 0) + (n is a multiple of 2 for format = 16) + (n is a multiple of 4 for format = 32) + p unused, p=pad(n) + +ListProperties + 1 21 opcode + 1 unused + 2 2 request length + 4 WINDOW window + +▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 n reply length + 2 n number of ATOMs in atoms + 22 unused + 4n LISTofATOM atoms + +SetSelectionOwner + 1 22 opcode + 1 unused + 2 4 request length + 4 WINDOW owner + 0 None + 4 ATOM selection + 4 TIMESTAMP time + 0 CurrentTime + +GetSelectionOwner + 1 23 opcode + 1 unused + 2 2 request length + 4 ATOM selection + +▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 4 WINDOW owner + 0 None + 20 unused + +ConvertSelection + 1 24 opcode + 1 unused + 2 6 request length + 4 WINDOW requestor + 4 ATOM selection + 4 ATOM target + 4 ATOM property + 0 None + 4 TIMESTAMP time + 0 CurrentTime + +SendEvent + 1 25 opcode + 1 BOOL propagate + 2 11 requestlength + 4 WINDOW destination + 0 PointerWindow + 1 InputFocus + 4 SETofEVENT event-mask + 32 event + standard event format (see the Events section) + +GrabPointer + 1 26 opcode + 1 BOOL owner-events + 2 6 request length + 4 WINDOW grab-window + 2 SETofPOINTEREVENT event-mask + 1 pointer-mode + 0 Synchronous + 1 Asynchronous + 1 keyboard-mode + 0 Synchronous + 1 Asynchronous + 4 WINDOW confine-to + 0 None + 4 CURSOR cursor + 0 None + 4 TIMESTAMP time + 0 CurrentTime + +▶ + 1 1 Reply + 1 status + 0 Success + 1 AlreadyGrabbed + 2 InvalidTime + 3 NotViewable + 4 Frozen + 2 CARD16 sequence number + 4 0 reply length + 24 unused + +UngrabPointer + 1 27 opcode + 1 unused + 2 2 request length + 4 TIMESTAMP time + 0 CurrentTime + +GrabButton + 1 28 opcode + 1 BOOL owner-events + 2 6 request length + 4 WINDOW grab-window + 2 SETofPOINTEREVENT event-mask + 1 pointer-mode + 0 Synchronous + 1 Asynchronous + 1 keyboard-mode + 0 Synchronous + 1 Asynchronous + 4 WINDOW confine-to + 0 None + 4 CURSOR cursor + 0 None + 1 BUTTON button + 0 AnyButton + 1 unused + 2 SETofKEYMASK modifiers + #x8000 AnyModifier + +UngrabButton + 1 29 opcode + 1 BUTTON button + 0 AnyButton + 2 3 request length + 4 WINDOW grab-window + 2 SETofKEYMASK modifiers + #x8000 AnyModifier + 2 unused + +ChangeActivePointerGrab + 1 30 opcode + 1 unused + 2 4 request length + 4 CURSOR cursor + 0 None + 4 TIMESTAMP time + 0 CurrentTime + 2 SETofPOINTEREVENT event-mask + 2 unused + +GrabKeyboard + 1 31 opcode + 1 BOOL owner-events + 2 4 request length + 4 WINDOW grab-window + 4 TIMESTAMP time + 0 CurrentTime + 1 pointer-mode + 0 Synchronous + 1 Asynchronous + 1 keyboard-mode + 0 Synchronous + 1 Asynchronous + 2 unused + +▶ + 1 1 Reply + 1 status + 0 Success + 1 AlreadyGrabbed + 2 InvalidTime + 3 NotViewable + 4 Frozen + 2 CARD16 sequence number + 4 0 reply length + 24 unused + +UngrabKeyboard + 1 32 opcode + 1 unused + 2 2 request length + 4 TIMESTAMP time + 0 CurrentTime + +GrabKey + 1 33 opcode + 1 BOOL owner-events + 2 4 request length + 4 WINDOW grab-window + 2 SETofKEYMASK modifiers + #x8000 AnyModifier + 1 KEYCODE key + 0 AnyKey + 1 pointer-mode + 0 Synchronous + 1 Asynchronous + 1 keyboard-mode + 0 Synchronous + 1 Asynchronous + 3 unused + +UngrabKey + 1 34 opcode + 1 KEYCODE key + 0 AnyKey + 2 3 request length + 4 WINDOW grab-window + 2 SETofKEYMASK modifiers + #x8000 AnyModifier + 2 unused + +AllowEvents + 1 35 opcode + 1 mode + 0 AsyncPointer + 1 SyncPointer + 2 ReplayPointer + 3 AsyncKeyboard + 4 SyncKeyboard + 5 ReplayKeyboard + 6 AsyncBoth + 7 SyncBoth + 2 2 request length + 4 TIMESTAMP time + 0 CurrentTime + +GrabServer + 1 36 opcode + 1 unused + 2 1 request length + +UngrabServer + 1 37 opcode + 1 unused + 2 1 request length + +QueryPointer + 1 38 opcode + 1 unused + 2 2 request length + 4 WINDOW window + +▶ + 1 1 Reply + 1 BOOL same-screen + 2 CARD16 sequence number + 4 0 reply length + 4 WINDOW root + 4 WINDOW child + 0 None + 2 INT16 root-x + 2 INT16 root-y + 2 INT16 win-x + 2 INT16 win-y + 2 SETofKEYBUTMASK mask + 6 unused + +GetMotionEvents + 1 39 opcode + 1 unused + 2 4 request length + 4 WINDOW window + 4 TIMESTAMP start + 0 CurrentTime + 4 TIMESTAMP stop + 0 CurrentTime + +▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 2n reply length + 4 n number of TIMECOORDs in events + 20 unused + 8n LISTofTIMECOORD events + + TIMECOORD + 4 TIMESTAMP time + 2 INT16 x + 2 INT16 y + +TranslateCoordinates + 1 40 opcode + 1 unused + 2 4 request length + 4 WINDOW src-window + 4 WINDOW dst-window + 2 INT16 src-x + 2 INT16 src-y +▶ + 1 1 Reply + 1 BOOL same-screen + 2 CARD16 sequence number + 4 0 reply length + 4 WINDOW child + 0 None + 2 INT16 dst-x + 2 INT16 dst-y + 16 unused + +WarpPointer + 1 41 opcode + 1 unused + 2 6 request length + 4 WINDOW src-window + 0 None + 4 WINDOW dst-window + 0 None + 2 INT16 src-x + 2 INT16 src-y + 2 CARD16 src-width + 2 CARD16 src-height + 2 INT16 dst-x + 2 INT16 dst-y + +SetInputFocus + 1 42 opcode + 1 revert-to + 0 None + 1 PointerRoot + 2 Parent + 2 3 request length + 4 WINDOW focus + 0 None + 1 PointerRoot + 4 TIMESTAMP time + 0 CurrentTime + +GetInputFocus + 1 43 opcode + 1 unused + 2 1 request length + +▶ + 1 1 Reply + 1 revert-to + 0 None + 1 PointerRoot + 2 Parent + 2 CARD16 sequence number + 4 0 reply length + 4 WINDOW focus + 0 None + 1 PointerRoot + 20 unused + +QueryKeymap + 1 44 opcode + 1 unused + 2 1 request length + +▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 2 reply length + 32 LISTofCARD8 keys + +OpenFont + 1 45 opcode + 1 unused + 2 3+(n+p)/4 request length + 4 FONT fid + 2 n length of name + 2 unused + n STRING8 name + p unused, p=pad(n) + +CloseFont + 1 46 opcode + 1 unused + 2 2 request length + 4 FONT font + +QueryFont + 1 47 opcode + 1 unused + 2 2 request length + 4 FONTABLE font + +▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 7+2n+3m reply length + 12 CHARINFO min-bounds + 4 unused + 12 CHARINFO max-bounds + 4 unused + 2 CARD16 min-char-or-byte2 + 2 CARD16 max-char-or-byte2 + 2 CARD16 default-char + 2 n number of FONTPROPs in properties + 1 draw-direction + 0 LeftToRight + 1 RightToLeft + 1 CARD8 min-byte1 + 1 CARD8 max-byte1 + 1 BOOL all-chars-exist + 2 INT16 font-ascent + 2 INT16 font-descent + 4 m number of CHARINFOs in char-infos + 8n LISTofFONTPROP properties + 12m LISTofCHARINFO char-infos + + FONTPROP + 4 ATOM name + 4 <32-bits> value + + CHARINFO + 2 INT16 left-side-bearing + 2 INT16 right-side-bearing + 2 INT16 character-width + 2 INT16 ascent + 2 INT16 descent + 2 CARD16 attributes + +QueryTextExtents + 1 48 opcode + 1 BOOL odd length, True if p = 2 + 2 2+(2n+p)/4 request length + 4 FONTABLE font + 2n STRING16 string + p unused, p=pad(2n) + +▶ + 1 1 Reply + 1 draw-direction + 0 LeftToRight + 1 RightToLeft + 2 CARD16 sequence number + 4 0 reply length + 2 INT16 font-ascent + 2 INT16 font-descent + 2 INT16 overall-ascent + 2 INT16 overall-descent + 4 INT32 overall-width + 4 INT32 overall-left + 4 INT32 overall-right + 4 unused + +ListFonts + 1 49 opcode + 1 unused + 2 2+(n+p)/4 request length + 2 CARD16 max-names + 2 n length of pattern + n STRING8 pattern + p unused, p=pad(n) + +▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 (n+p)/4 reply length + 2 CARD16 number of STRs in names + 22 unused + n LISTofSTR names + p unused, p=pad(n) + +ListFontsWithInfo + 1 50 opcode + 1 unused + 2 2+(n+p)/4 request length + 2 CARD16 max-names + 2 n length of pattern + n STRING8 pattern + p unused, p=pad(n) + +▶ (except for last in series) + 1 1 Reply + 1 n length of name in bytes + 2 CARD16 sequence number + 4 7+2m+(n+p)/4 reply length + 12 CHARINFO min-bounds + 4 unused + 12 CHARINFO max-bounds + 4 unused + 2 CARD16 min-char-or-byte2 + 2 CARD16 max-char-or-byte2 + 2 CARD16 default-char + 2 m number of FONTPROPs in properties + 1 draw-direction + 0 LeftToRight + 1 RightToLeft + 1 CARD8 min-byte1 + 1 CARD8 max-byte1 + 1 BOOL all-chars-exist + 2 INT16 font-ascent + 2 INT16 font-descent + 4 CARD32 replies-hint + 8m LISTofFONTPROP properties + n STRING8 name + p unused, p=pad(n) + + FONTPROP + encodings are the same as for QueryFont + + CHARINFO + encodings are the same as for QueryFont + +▶ (last in series) + 1 1 Reply + 1 0 last-reply indicator + 2 CARD16 sequence number + 4 7 reply length + 52 unused + +SetFontPath + 1 51 opcode + 1 unused + 2 2+(n+p)/4 request length + 2 CARD16 number of STRs in path + 2 unused + n LISTofSTR path + p unused, p=pad(n) + +GetFontPath + 1 52 opcode + 1 unused + 2 1 request list + +▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 (n+p)/4 reply length + 2 CARD16 number of STRs in path + 22 unused + n LISTofSTR path + p unused, p=pad(n) + +CreatePixmap + 1 53 opcode + 1 CARD8 depth + 2 4 request length + 4 PIXMAP pid + 4 DRAWABLE drawable + 2 CARD16 width + 2 CARD16 height + +FreePixmap + 1 54 opcode + 1 unused + 2 2 request length + 4 PIXMAP pixmap + +CreateGC + 1 55 opcode + 1 unused + 2 4+n request length + 4 GCONTEXT cid + 4 DRAWABLE drawable + 4 BITMASK value-mask (has n bits set to 1) + #x00000001 function + #x00000002 plane-mask + #x00000004 foreground + #x00000008 background + #x00000010 line-width + #x00000020 line-style + #x00000040 cap-style + #x00000080 join-style + #x00000100 fill-style + #x00000200 fill-rule + #x00000400 tile + #x00000800 stipple + #x00001000 tile-stipple-x-origin + #x00002000 tile-stipple-y-origin + #x00004000 font + #x00008000 subwindow-mode + #x00010000 graphics-exposures + #x00020000 clip-x-origin + #x00040000 clip-y-origin + #x00080000 clip-mask + #x00100000 dash-offset + #x00200000 dashes + #x00400000 arc-mode + 4n LISTofVALUE value-list + + VALUEs + 1 function + 0 Clear + 1 And + 2 AndReverse + 3 Copy + 4 AndInverted + 5 NoOp + 6 Xor + 7 Or + 8 Nor + 9 Equiv + 10 Invert + 11 OrReverse + 12 CopyInverted + 13 OrInverted + 14 Nand + 15 Set + 4 CARD32 plane-mask + 4 CARD32 foreground + 4 CARD32 background + 2 CARD16 line-width + 1 line-style + 0 Solid + 1 OnOffDash + 2 DoubleDash + 1 cap-style + 0 NotLast + 1 Butt + 2 Round + 3 Projecting + 1 join-style + 0 Miter + 1 Round + 2 Bevel + 1 fill-style + 0 Solid + 1 Tiled + 2 Stippled + 3 OpaqueStippled + 1 fill-rule + 0 EvenOdd + 1 Winding + 4 PIXMAP tile + 4 PIXMAP stipple + 2 INT16 tile-stipple-x-origin + 2 INT16 tile-stipple-y-origin + 4 FONT font + 1 subwindow-mode + 0 ClipByChildren + 1 IncludeInferiors + 1 BOOL graphics-exposures + 2 INT16 clip-x-origin + 2 INT16 clip-y-origin + 4 PIXMAP clip-mask + 0 None + 2 CARD16 dash-offset + 1 CARD8 dashes + 1 arc-mode + 0 Chord + 1 PieSlice + +ChangeGC + 1 56 opcode + 1 unused + 2 3+n request length + 4 GCONTEXT gc + 4 BITMASK value-mask (has n bits set to 1) + encodings are the same as for CreateGC + 4n LISTofVALUE value-list + encodings are the same as for CreateGC + +CopyGC + 1 57 opcode + 1 unused + 2 4 request length + 4 GCONTEXT src-gc + 4 GCONTEXT dst-gc + 4 BITMASK value-mask + encodings are the same as for CreateGC + +SetDashes + 1 58 opcode + 1 unused + 2 3+(n+p)/4 request length + 4 GCONTEXT gc + 2 CARD16 dash-offset + 2 n length of dashes + n LISTofCARD8 dashes + p unused, p=pad(n) + +SetClipRectangles + 1 59 opcode + 1 ordering + 0 UnSorted + 1 YSorted + 2 YXSorted + 3 YXBanded + 2 3+2n request length + 4 GCONTEXT gc + 2 INT16 clip-x-origin + 2 INT16 clip-y-origin + 8n LISTofRECTANGLE rectangles + +FreeGC + 1 60 opcode + 1 unused + 2 2 request length + 4 GCONTEXT gc + +ClearArea + 1 61 opcode + 1 BOOL exposures + 2 4 request length + 4 WINDOW window + 2 INT16 x + 2 INT16 y + 2 CARD16 width + 2 CARD16 height + +CopyArea + 1 62 opcode + 1 unused + 2 7 request length + 4 DRAWABLE src-drawable + 4 DRAWABLE dst-drawable + 4 GCONTEXT gc + 2 INT16 src-x + 2 INT16 src-y + 2 INT16 dst-x + 2 INT16 dst-y + 2 CARD16 width + 2 CARD16 height + +CopyPlane + 1 63 opcode + 1 unused + 2 8 request length + 4 DRAWABLE src-drawable + 4 DRAWABLE dst-drawable + 4 GCONTEXT gc + 2 INT16 src-x + 2 INT16 src-y + 2 INT16 dst-x + 2 INT16 dst-y + 2 CARD16 width + 2 CARD16 height + 4 CARD32 bit-plane + +PolyPoint + 1 64 opcode + 1 coordinate-mode + 0 Origin + 1 Previous + 2 3+n request length + 4 DRAWABLE drawable + 4 GCONTEXT gc + 4n LISTofPOINT points + +PolyLine + 1 65 opcode + 1 coordinate-mode + 0 Origin + 1 Previous + 2 3+n request length + 4 DRAWABLE drawable + 4 GCONTEXT gc + 4n LISTofPOINT points + +PolySegment + 1 66 opcode + 1 unused + 2 3+2n request length + 4 DRAWABLE drawable + 4 GCONTEXT gc + 8n LISTofSEGMENT segments + + SEGMENT + 2 INT16 x1 + 2 INT16 y1 + 2 INT16 x2 + 2 INT16 y2 + +PolyRectangle + 1 67 opcode + 1 unused + 2 3+2n request length + 4 DRAWABLE drawable + 4 GCONTEXT gc + 8n LISTofRECTANGLE rectangles + +PolyArc + 1 68 opcode + 1 unused + 2 3+3n request length + 4 DRAWABLE drawable + 4 GCONTEXT gc + 12n LISTofARC arcs + +FillPoly + 1 69 opcode + 1 unused + 2 4+n request length + 4 DRAWABLE drawable + 4 GCONTEXT gc + 1 shape + 0 Complex + 1 Nonconvex + 2 Convex + 1 coordinate-mode + 0 Origin + 1 Previous + 2 unused + 4n LISTofPOINT points + +PolyFillRectangle + 1 70 opcode + 1 unused + 2 3+2n request length + 4 DRAWABLE drawable + 4 GCONTEXT gc + 8n LISTofRECTANGLE rectangles + +PolyFillArc + 1 71 opcode + 1 unused + 2 3+3n request length + 4 DRAWABLE drawable + 4 GCONTEXT gc + 12n LISTofARC arcs + +PutImage + 1 72 opcode + 1 format + 0 Bitmap + 1 XYPixmap + 2 ZPixmap + 2 6+(n+p)/4 request length + 4 DRAWABLE drawable + 4 GCONTEXT gc + 2 CARD16 width + 2 CARD16 height + 2 INT16 dst-x + 2 INT16 dst-y + 1 CARD8 left-pad + 1 CARD8 depth + 2 unused + n LISTofBYTE data + p unused, p=pad(n) + +GetImage + 1 73 opcode + 1 format + 1 XYPixmap + 2 ZPixmap + 2 5 request length + 4 DRAWABLE drawable + 2 INT16 x + 2 INT16 y + 2 CARD16 width + 2 CARD16 height + 4 CARD32 plane-mask + +▶ + 1 1 Reply + 1 CARD8 depth + 2 CARD16 sequence number + 4 (n+p)/4 reply length + 4 VISUALID visual + 0 None + 20 unused + n LISTofBYTE data + p unused, p=pad(n) + +PolyText8 + 1 74 opcode + 1 unused + 2 4+(n+p)/4 request length + 4 DRAWABLE drawable + 4 GCONTEXT gc + 2 INT16 x + 2 INT16 y + n LISTofTEXTITEM8 items + p unused, p=pad(n) (p is always 0 + or 1) + + TEXTITEM8 + 1 m length of string (cannot be 255) + 1 INT8 delta + m STRING8 string + or + 1 255 font-shift indicator + 1 font byte 3 (most-significant) + 1 font byte 2 + 1 font byte 1 + 1 font byte 0 (least-significant) + +PolyText16 + 1 75 opcode + 1 unused + 2 4+(n+p)/4 request length + 4 DRAWABLE drawable + 4 GCONTEXT gc + 2 INT16 x + 2 INT16 y + n LISTofTEXTITEM16 items + p unused, p=pad(n) (p must be 0 or + 1) + + TEXTITEM16 + 1 m number of CHAR2Bs in string + (cannot be 255) + 1 INT8 delta + 2m STRING16 string + or + 1 255 font-shift indicator + 1 font byte 3 (most-significant) + 1 font byte 2 + 1 font byte 1 + 1 font byte 0 (least-significant) + +ImageText8 + 1 76 opcode + 1 n length of string + 2 4+(n+p)/4 request length + 4 DRAWABLE drawable + 4 GCONTEXT gc + 2 INT16 x + 2 INT16 y + n STRING8 string + p unused, p=pad(n) + +ImageText16 + 1 77 opcode + 1 n number of CHAR2Bs in string + 2 4+(2n+p)/4 request length + 4 DRAWABLE drawable + 4 GCONTEXT gc + 2 INT16 x + 2 INT16 y + 2n STRING16 string + p unused, p=pad(2n) + +CreateColormap + 1 78 opcode + 1 alloc + 0 None + 1 All + 2 4 request length + 4 COLORMAP mid + 4 WINDOW window + 4 VISUALID visual + +FreeColormap + 1 79 opcode + 1 unused + 2 2 request length + 4 COLORMAP cmap + +CopyColormapAndFree + 1 80 opcode + 1 unused + 2 3 request length + 4 COLORMAP mid + 4 COLORMAP src-cmap + +InstallColormap + 1 81 opcode + 1 unused + 2 2 request length + 4 COLORMAP cmap + +UninstallColormap + 1 82 opcode + 1 unused + 2 2 request length + 4 COLORMAP cmap + +ListInstalledColormaps + 1 83 opcode + 1 unused + 2 2 request length + 4 WINDOW window + +▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 n reply length + 2 n number of COLORMAPs in cmaps + 22 unused + 4n LISTofCOLORMAP cmaps + +AllocColor + 1 84 opcode + 1 unused + 2 4 request length + 4 COLORMAP cmap + 2 CARD16 red + 2 CARD16 green + 2 CARD16 blue + 2 unused + +▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 2 CARD16 red + 2 CARD16 green + 2 CARD16 blue + 2 unused + 4 CARD32 pixel + 12 unused + +AllocNamedColor + 1 85 opcode + 1 unused + 2 3+(n+p)/4 request length + 4 COLORMAP cmap + 2 n length of name + 2 unused + n STRING8 name + p unused, p=pad(n) + +▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 4 CARD32 pixel + 2 CARD16 exact-red + 2 CARD16 exact-green + 2 CARD16 exact-blue + 2 CARD16 visual-red + 2 CARD16 visual-green + 2 CARD16 visual-blue + 8 unused + +AllocColorCells + 1 86 opcode + 1 BOOL contiguous + 2 3 request length + 4 COLORMAP cmap + 2 CARD16 colors + 2 CARD16 planes + +▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 n+m reply length + 2 n number of CARD32s in pixels + 2 m number of CARD32s in masks + 20 unused + 4n LISTofCARD32 pixels + 4m LISTofCARD32 masks + +AllocColorPlanes + 1 87 opcode + 1 BOOL contiguous + 2 4 request length + 4 COLORMAP cmap + 2 CARD16 colors + 2 CARD16 reds + 2 CARD16 greens + 2 CARD16 blues + +▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 n reply length + 2 n number of CARD32s in pixels + 2 unused + 4 CARD32 red-mask + 4 CARD32 green-mask + 4 CARD32 blue-mask + 8 unused + 4n LISTofCARD32 pixels + +FreeColors + 1 88 opcode + 1 unused + 2 3+n request length + 4 COLORMAP cmap + 4 CARD32 plane-mask + 4n LISTofCARD32 pixels + +StoreColors + 1 89 opcode + 1 unused + 2 2+3n request length + 4 COLORMAP cmap + 12n LISTofCOLORITEM items + + COLORITEM + 4 CARD32 pixel + 2 CARD16 red + 2 CARD16 green + 2 CARD16 blue + 1 do-red, do-green, do-blue + #x01 do-red (1 is True, 0 is False) + #x02 do-green (1 is True, 0 is False) + #x04 do-blue (1 is True, 0 is False) + #xF8 unused + 1 unused + +StoreNamedColor + 1 90 opcode + 1 do-red, do-green, do-blue + #x01 do-red (1 is True, 0 is False) + #x02 do-green (1 is True, 0 is False) + #x04 do-blue (1 is True, 0 is False) + #xF8 unused + 2 4+(n+p)/4 request length + 4 COLORMAP cmap + 4 CARD32 pixel + 2 n length of name + 2 unused + n STRING8 name + p unused, p=pad(n) + +QueryColors + 1 91 opcode + 1 unused + 2 2+n request length + 4 COLORMAP cmap + 4n LISTofCARD32 pixels + +▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 2n reply length + 2 n number of RGBs in colors + 22 unused + 8n LISTofRGB colors + + RGB + 2 CARD16 red + 2 CARD16 green + 2 CARD16 blue + 2 unused + +LookupColor + 1 92 opcode + 1 unused + 2 3+(n+p)/4 request length + 4 COLORMAP cmap + 2 n length of name + 2 unused + n STRING8 name + p unused, p=pad(n) + +▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 2 CARD16 exact-red + 2 CARD16 exact-green + 2 CARD16 exact-blue + 2 CARD16 visual-red + 2 CARD16 visual-green + 2 CARD16 visual-blue + 12 unused + +CreateCursor + 1 93 opcode + 1 unused + 2 8 request length + 4 CURSOR cid + 4 PIXMAP source + 4 PIXMAP mask + 0 None + 2 CARD16 fore-red + 2 CARD16 fore-green + 2 CARD16 fore-blue + 2 CARD16 back-red + 2 CARD16 back-green + 2 CARD16 back-blue + 2 CARD16 x + 2 CARD16 y + +CreateGlyphCursor + 1 94 opcode + 1 unused + 2 8 request length + 4 CURSOR cid + 4 FONT source-font + 4 FONT mask-font + 0 None + 2 CARD16 source-char + 2 CARD16 mask-char + 2 CARD16 fore-red + 2 CARD16 fore-green + 2 CARD16 fore-blue + 2 CARD16 back-red + 2 CARD16 back-green + 2 CARD16 back-blue + +FreeCursor + 1 95 opcode + 1 unused + 2 2 request length + 4 CURSOR cursor + +RecolorCursor + 1 96 opcode + 1 unused + 2 5 request length + 4 CURSOR cursor + 2 CARD16 fore-red + 2 CARD16 fore-green + 2 CARD16 fore-blue + 2 CARD16 back-red + 2 CARD16 back-green + 2 CARD16 back-blue + +QueryBestSize + 1 97 opcode + 1 class + 0 Cursor + 1 Tile + 2 Stipple + 2 3 request length + 4 DRAWABLE drawable + 2 CARD16 width + 2 CARD16 height + +▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 2 CARD16 width + 2 CARD16 height + 20 unused + +QueryExtension + 1 98 opcode + 1 unused + 2 2+(n+p)/4 request length + 2 n length of name + 2 unused + n STRING8 name + p unused, p=pad(n) + +▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 1 BOOL present + 1 CARD8 major-opcode + 1 CARD8 first-event + 1 CARD8 first-error + 20 unused + +ListExtensions + 1 99 opcode + 1 unused + 2 1 request length + +▶ + 1 1 Reply + 1 CARD8 number of STRs in names + 2 CARD16 sequence number + 4 (n+p)/4 reply length + 24 unused + n LISTofSTR names + p unused, p=pad(n) + +ChangeKeyboardMapping + 1 100 opcode + 1 n keycode-count + 2 2+nm request length + 1 KEYCODE first-keycode + 1 m keysyms-per-keycode + 2 unused + 4nm LISTofKEYSYM keysyms + +GetKeyboardMapping + 1 101 opcode + 1 unused + 2 2 request length + 1 KEYCODE first-keycode + 1 m count + 2 unused + +▶ + 1 1 Reply + 1 n keysyms-per-keycode + 2 CARD16 sequence number + 4 nm reply length (m = count field + from the request) + 24 unused + 4nm LISTofKEYSYM keysyms + +ChangeKeyboardControl + 1 102 opcode + 1 unused + 2 2+n request length + 4 BITMASK value-mask (has n bits set to 1) + #x0001 key-click-percent + #x0002 bell-percent + #x0004 bell-pitch + #x0008 bell-duration + #x0010 led + #x0020 led-mode + #x0040 key + #x0080 auto-repeat-mode + 4n LISTofVALUE value-list + + VALUEs + 1 INT8 key-click-percent + 1 INT8 bell-percent + 2 INT16 bell-pitch + 2 INT16 bell-duration + 1 CARD8 led + 1 led-mode + 0 Off + 1 On + 1 KEYCODE key + 1 auto-repeat-mode + 0 Off + 1 On + 2 Default + +GetKeyboardControl + 1 103 opcode + 1 unused + 2 1 request length + +▶ + 1 1 Reply + 1 global-auto-repeat + 0 Off + 1 On + 2 CARD16 sequence number + 4 5 reply length + 4 CARD32 led-mask + 1 CARD8 key-click-percent + 1 CARD8 bell-percent + 2 CARD16 bell-pitch + 2 CARD16 bell-duration + 2 unused + 32 LISTofCARD8 auto-repeats + +Bell + 1 104 opcode + 1 INT8 percent + 2 1 request length + +ChangePointerControl + 1 105 opcode + 1 unused + 2 3 request length + 2 INT16 acceleration-numerator + 2 INT16 acceleration-denominator + 2 INT16 threshold + 1 BOOL do-acceleration + 1 BOOL do-threshold + +GetPointerControl + 1 106 opcode + 1 unused + 2 1 request length + +▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 2 CARD16 acceleration-numerator + 2 CARD16 acceleration-denominator + 2 CARD16 threshold + 18 unused + +SetScreenSaver + 1 107 opcode + 1 unused + 2 3 request length + 2 INT16 timeout + 2 INT16 interval + 1 prefer-blanking + 0 No + 1 Yes + 2 Default + 1 allow-exposures + 0 No + 1 Yes + 2 Default + 2 unused + +GetScreenSaver + 1 108 opcode + 1 unused + 2 1 request length + +▶ + 1 1 Reply + 1 unused + 2 CARD16 sequence number + 4 0 reply length + 2 CARD16 timeout + 2 CARD16 interval + 1 prefer-blanking + 0 No + 1 Yes + 1 allow-exposures + 0 No + 1 Yes + 18 unused + +ChangeHosts + 1 109 opcode + 1 mode + 0 Insert + 1 Delete + 2 2+(n+p)/4 request length + 1 family + 0 Internet + 1 DECnet + 2 Chaos + 1 unused + 2 n length of address + n LISTofCARD8 address + p unused, p=pad(n) + +ListHosts + 1 110 opcode + 1 unused + 2 1 request length + +▶ + 1 1 Reply + 1 mode + 0 Disabled + 1 Enabled + 2 CARD16 sequence number + 4 n/4 reply length + 2 CARD16 number of HOSTs in hosts + 22 unused + n LISTofHOST hosts (n always a multiple of 4) + +SetAccessControl + 1 111 opcode + 1 mode + 0 Disable + 1 Enable + 2 1 request length + +SetCloseDownMode + 1 112 opcode + 1 mode + 0 Destroy + 1 RetainPermanent + 2 RetainTemporary + 2 1 request length + +KillClient + 1 113 opcode + 1 unused + 2 2 request length + 4 CARD32 resource + 0 AllTemporary + +RotateProperties + 1 114 opcode + 1 unused + 2 3+n request length + 4 WINDOW window + 2 n number of properties + 2 INT16 delta + 4n LISTofATOM properties + +ForceScreenSaver + 1 115 opcode + 1 mode + 0 Reset + 1 Activate + 2 1 request length + +SetPointerMapping + 1 116 opcode + 1 n length of map + 2 1+(n+p)/4 request length + n LISTofCARD8 map + p unused, p=pad(n) + +▶ + 1 1 Reply + 1 status + 0 Success + 1 Busy + 2 CARD16 sequence number + 4 0 reply length + 24 unused + +GetPointerMapping + 1 117 opcode + 1 unused + 2 1 request length + +▶ + 1 1 Reply + 1 n length of map + 2 CARD16 sequence number + 4 (n+p)/4 reply length + 24 unused + n LISTofCARD8 map + p unused, p=pad(n) + +SetModifierMapping + 1 118 opcode + 1 n keycodes-per-modifier + 2 1+2n request length + 8n LISTofKEYCODE keycodes + +▶ + 1 1 Reply + 1 status + 0 Success + 1 Busy + 2 Failed + 2 CARD16 sequence number + 4 0 reply length + 24 unused + +GetModifierMapping + 1 119 opcode + 1 unused + 2 1 request length + +▶ + 1 1 Reply + 1 n keycodes-per-modifier + 2 CARD16 sequence number + 4 2n reply length + 24 unused + 8n LISTofKEYCODE keycodes + +NoOperation + 1 127 opcode + 1 unused + 2 1+n request length + 4n unused + + + + +Events +Eventencoding + + +KeyPress + 1 2 code + 1 KEYCODE detail + 2 CARD16 sequence number + 4 TIMESTAMP time + 4 WINDOW root + 4 WINDOW event + 4 WINDOW child + 0 None + 2 INT16 root-x + 2 INT16 root-y + 2 INT16 event-x + 2 INT16 event-y + 2 SETofKEYBUTMASK state + 1 BOOL same-screen + 1 unused + +KeyRelease + 1 3 code + 1 KEYCODE detail + 2 CARD16 sequence number + 4 TIMESTAMP time + 4 WINDOW root + 4 WINDOW event + 4 WINDOW child + 0 None + 2 INT16 root-x + 2 INT16 root-y + 2 INT16 event-x + 2 INT16 event-y + 2 SETofKEYBUTMASK state + 1 BOOL same-screen + 1 unused + +ButtonPress + 1 4 code + 1 BUTTON detail + 2 CARD16 sequence number + 4 TIMESTAMP time + 4 WINDOW root + 4 WINDOW event + 4 WINDOW child + 0 None + 2 INT16 root-x + 2 INT16 root-y + 2 INT16 event-x + 2 INT16 event-y + 2 SETofKEYBUTMASK state + 1 BOOL same-screen + 1 unused + +ButtonRelease + 1 5 code + 1 BUTTON detail + 2 CARD16 sequence number + 4 TIMESTAMP time + 4 WINDOW root + 4 WINDOW event + 4 WINDOW child + 0 None + 2 INT16 root-x + 2 INT16 root-y + 2 INT16 event-x + 2 INT16 event-y + 2 SETofKEYBUTMASK state + 1 BOOL same-screen + 1 unused + +MotionNotify + 1 6 code + 1 detail + 0 Normal + 1 Hint + 2 CARD16 sequence number + 4 TIMESTAMP time + 4 WINDOW root + 4 WINDOW event + 4 WINDOW child + 0 None + 2 INT16 root-x + 2 INT16 root-y + 2 INT16 event-x + 2 INT16 event-y + 2 SETofKEYBUTMASK state + 1 BOOL same-screen + 1 unused + +EnterNotify + 1 7 code + 1 detail + 0 Ancestor + 1 Virtual + 2 Inferior + 3 Nonlinear + 4 NonlinearVirtual + 2 CARD16 sequence number + 4 TIMESTAMP time + 4 WINDOW root + 4 WINDOW event + 4 WINDOW child + 0 None + 2 INT16 root-x + 2 INT16 root-y + 2 INT16 event-x + 2 INT16 event-y + 2 SETofKEYBUTMASK state + 1 mode + 0 Normal + 1 Grab + 2 Ungrab + 1 same-screen, focus + #x01 focus (1 is True, 0 is False) + #x02 same-screen (1 is True, 0 is False) + #xFC unused + +LeaveNotify + 1 8 code + 1 detail + 0 Ancestor + 1 Virtual + 2 Inferior + 3 Nonlinear + 4 NonlinearVirtual + 2 CARD16 sequence number + 4 TIMESTAMP time + 4 WINDOW root + 4 WINDOW event + 4 WINDOW child + 0 None + 2 INT16 root-x + 2 INT16 root-y + 2 INT16 event-x + 2 INT16 event-y + 2 SETofKEYBUTMASK state + 1 mode + 0 Normal + 1 Grab + 2 Ungrab + 1 same-screen, focus + #x01 focus (1 is True, 0 is False) + #x02 same-screen (1 is True, 0 is False) + #xFC unused + +FocusIn + 1 9 code + 1 detail + 0 Ancestor + 1 Virtual + 2 Inferior + 3 Nonlinear + 4 NonlinearVirtual + 5 Pointer + 6 PointerRoot + 7 None + 2 CARD16 sequence number + 4 WINDOW event + 1 mode + 0 Normal + 1 Grab + 2 Ungrab + 3 WhileGrabbed + 23 unused + +FocusOut + 1 10 code + 1 detail + 0 Ancestor + 1 Virtual + 2 Inferior + 3 Nonlinear + 4 NonlinearVirtual + 5 Pointer + 6 PointerRoot + 7 None + 2 CARD16 sequence number + 4 WINDOW event + 1 mode + 0 Normal + 1 Grab + 2 Ungrab + 3 WhileGrabbed + 23 unused + +KeymapNotify + 1 11 code + 31 LISTofCARD8 keys (byte for keycodes 0-7 is + omitted) + +Expose + 1 12 code + 1 unused + 2 CARD16 sequence number + 4 WINDOW window + 2 CARD16 x + 2 CARD16 y + 2 CARD16 width + 2 CARD16 height + 2 CARD16 count + 14 unused + +GraphicsExposure + 1 13 code + 1 unused + 2 CARD16 sequence number + 4 DRAWABLE drawable + 2 CARD16 x + 2 CARD16 y + 2 CARD16 width + 2 CARD16 height + 2 CARD16 minor-opcode + 2 CARD16 count + 1 CARD8 major-opcode + 11 unused + +NoExposure + 1 14 code + 1 unused + 2 CARD16 sequence number + 4 DRAWABLE drawable + 2 CARD16 minor-opcode + 1 CARD8 major-opcode + 21 unused + +VisibilityNotify + 1 15 code + 1 unused + 2 CARD16 sequence number + 4 WINDOW window + 1 state + 0 Unobscured + 1 PartiallyObscured + 2 FullyObscured + 23 unused + +CreateNotify + 1 16 code + 1 unused + 2 CARD16 sequence number + 4 WINDOW parent + 4 WINDOW window + 2 INT16 x + 2 INT16 y + 2 CARD16 width + 2 CARD16 height + 2 CARD16 border-width + 1 BOOL override-redirect + 9 unused + +DestroyNotify + 1 17 code + 1 unused + 2 CARD16 sequence number + 4 WINDOW event + 4 WINDOW window + 20 unused + +UnmapNotify + 1 18 code + 1 unused + 2 CARD16 sequence number + 4 WINDOW event + 4 WINDOW window + 1 BOOL from-configure + 19 unused + +MapNotify + 1 19 code + 1 unused + 2 CARD16 sequence number + 4 WINDOW event + 4 WINDOW window + 1 BOOL override-redirect + 19 unused + +MapRequest + 1 20 code + 1 unused + 2 CARD16 sequence number + 4 WINDOW parent + 4 WINDOW window + 20 unused + +ReparentNotify + 1 21 code + 1 unused + 2 CARD16 sequence number + 4 WINDOW event + 4 WINDOW window + 4 WINDOW parent + 2 INT16 x + 2 INT16 y + 1 BOOL override-redirect + 11 unused + +ConfigureNotify + 1 22 code + 1 unused + 2 CARD16 sequence number + 4 WINDOW event + 4 WINDOW window + 4 WINDOW above-sibling + 0 None + 2 INT16 x + 2 INT16 y + 2 CARD16 width + 2 CARD16 height + 2 CARD16 border-width + 1 BOOL override-redirect + 5 unused + +ConfigureRequest + 1 23 code + 1 stack-mode + 0 Above + 1 Below + 2 TopIf + 3 BottomIf + 4 Opposite + 2 CARD16 sequence number + 4 WINDOW parent + 4 WINDOW window + 4 WINDOW sibling + 0 None + 2 INT16 x + 2 INT16 y + 2 CARD16 width + 2 CARD16 height + 2 CARD16 border-width + 2 BITMASK value-mask + #x0001 x + #x0002 y + #x0004 width + #x0008 height + #x0010 border-width + #x0020 sibling + #x0040 stack-mode + 4 unused + +GravityNotify + 1 24 code + 1 unused + 2 CARD16 sequence number + 4 WINDOW event + 4 WINDOW window + 2 INT16 x + 2 INT16 y + 16 unused + +ResizeRequest + 1 25 code + 1 unused + 2 CARD16 sequence number + 4 WINDOW window + 2 CARD16 width + 2 CARD16 height + 20 unused + +CirculateNotify + 1 26 code + 1 unused + 2 CARD16 sequence number + 4 WINDOW event + 4 WINDOW window + 4 WINDOW unused + 1 place + 0 Top + 1 Bottom + 15 unused + +CirculateRequest + 1 27 code + 1 unused + 2 CARD16 sequence number + 4 WINDOW parent + 4 WINDOW window + 4 unused + 1 place + 0 Top + 1 Bottom + 15 unused + +PropertyNotify + 1 28 code + 1 unused + 2 CARD16 sequence number + 4 WINDOW window + 4 ATOM atom + 4 TIMESTAMP time + 1 state + 0 NewValue + 1 Deleted + 15 unused + +SelectionClear + 1 29 code + 1 unused + 2 CARD16 sequence number + 4 TIMESTAMP time + 4 WINDOW owner + 4 ATOM selection + 16 unused + +SelectionRequest + 1 30 code + 1 unused + 2 CARD16 sequence number + 4 TIMESTAMP time + 0 CurrentTime + 4 WINDOW owner + 4 WINDOW requestor + 4 ATOM selection + 4 ATOM target + 4 ATOM property + 0 None + 4 unused + +SelectionNotify + 1 31 code + 1 unused + 2 CARD16 sequence number + 4 TIMESTAMP time + 0 CurrentTime + 4 WINDOW requestor + 4 ATOM selection + 4 ATOM target + 4 ATOM property + 0 None + 8 unused + +ColormapNotify + 1 32 code + 1 unused + 2 CARD16 sequence number + 4 WINDOW window + 4 COLORMAP colormap + 0 None + 1 BOOL new + 1 state + 0 Uninstalled + 1 Installed + 18 unused + +ClientMessage + 1 33 code + 1 CARD8 format + 2 CARD16 sequence number + 4 WINDOW window + 4 ATOM type + 20 data + +MappingNotify + 1 34 code + 1 unused + 2 CARD16 sequence number + 1 request + 0 Modifier + 1 Keyboard + 2 Pointer + 1 KEYCODE first-keycode + 1 CARD8 count + 25 unused + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xproto/glossary.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xproto/glossary.xml new file mode 100644 index 0000000000000000000000000000000000000000..eefd327f79c157776d505d0b28bf3092ed8948f6 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xproto/glossary.xml @@ -0,0 +1,1320 @@ + +Glossary + + + + Access control list + Access control list + + +X maintains a list of hosts from which client programs can be run. +By default, +only programs on the local host and hosts specified in an initial list read +by the server can use the display. +Clients on the local host can change this access control list. +Some server implementations can also implement other authorization mechanisms +in addition to or in place of this mechanism. +The action of this mechanism can be conditional based on the authorization +protocol name and data received by the server at connection setup. + + + + + + Active grab + Active grab + + +A grab is active when the pointer or keyboard is actually owned by +the single grabbing client. + + + + + + Ancestors + Ancestors + + +If W is an inferior of A, then A is an ancestor of W. + + + + + + Atom + Atom + + +An atom is a unique ID corresponding to a string name. +Atoms are used to identify properties, types, and selections. + + + + + + Background + Background + + +An +InputOutput +window can have a background, which is defined as a pixmap. +When regions of the window have their contents lost or invalidated, +the server will automatically tile those regions with the background. + + + + + + Backing store + Backing store + + +When a server maintains the contents of a window, +the pixels saved off screen are known as a backing store. + + + + + + Bit gravity + Bitgravity + + +When a window is resized, +the contents of the window are not necessarily discarded. +It is possible to request that the server relocate the previous contents +to some region of the window (though no guarantees are made). +This attraction of window contents for some location of +a window is known as bit gravity. + + + + + + Bit plane + Bitplane + + +When a pixmap or window is thought of as a stack of bitmaps, +each bitmap is called a bit plane or plane. + + + + + + Bitmap + Bitmap + + +A bitmap is a pixmap of depth one. + + + + + + Border + Border + + +An +InputOutput +window can have a border of equal thickness on all four sides of the window. +A pixmap defines the contents of the border, +and the server automatically maintains the contents of the border. +Exposure events are never generated for border regions. + + + + + + Button grabbing + Buttongrabbing + + +Buttons on the pointer may be passively grabbed by a client. +When the button is pressed, +the pointer is then actively grabbed by the client. + + + + + + Byte order + Byte order + + +For image (pixmap/bitmap) data, +the server defines the byte order, +and clients with different native byte ordering must swap bytes as necessary. +For all other parts of the protocol, +the client defines the byte order, +and the server swaps bytes as necessary. + + + + + + Children + Children + Windowchildren + + +The children of a window are its first-level subwindows. + + + + + + Client + Client + + +An application program connects to the window system server by some +interprocess communication path, such as a TCP connection or a +shared memory buffer. +This program is referred to as a client of the window system server. +More precisely, +the client is the communication path itself; +a program with multiple paths open to the server is viewed as +multiple clients by the protocol. +Resource lifetimes are controlled by connection lifetimes, +not by program lifetimes. + + + + + + Clipping region + Clipping region + + +In a graphics context, +a bitmap or list of rectangles can be specified +to restrict output to a particular region of the window. +The image defined by the bitmap or rectangles is called a clipping region. + + + + + + Colormap + Colormap + + +A colormap consists of a set of entries defining color values. +The colormap associated with a window is used to display the contents of +the window; each pixel value indexes the colormap to produce RGB values +that drive the guns of a monitor. +Depending on hardware limitations, +one or more colormaps may be installed at one time, +so that windows associated with those maps display with correct colors. + + + + + + Connection + Connection + + +The interprocess communication path between the server and client +program is known as a connection. +A client program typically (but not necessarily) has one +connection to the server over which requests and events are sent. + + + + + + Containment + Containment + + +A window contains the pointer if the window is viewable and the +hotspot of the cursor is +within a visible region of the window or a +visible region of one of its inferiors. +The border of the window is included as part of the window for containment. +The pointer is in a window if the window contains the pointer +but no inferior contains the pointer. + + + + + + Coordinate system + Coordinate system + + +The coordinate system has the X axis horizontal and the Y axis vertical, +with the origin [0, 0] at the upper left. +Coordinates are integral, +in terms of pixels, +and coincide with pixel centers. +Each window and pixmap has its own coordinate system. +For a window, +the origin is inside the border at the inside upper left. + + + + + + Cursor + Cursor + + +A cursor is the visible shape of the pointer on a screen. +It consists of a hotspot, +a source bitmap, a shape bitmap, and a pair of colors. +The cursor defined for a window controls the visible appearance +when the pointer is in that window. + + + + + + Depth + Depth + + +The depth of a window or pixmap is the number of bits per pixel that it has. +The depth of a graphics context is the depth of the drawables it can be +used in conjunction with for graphics output. + + + + + + Device + Device + + +Keyboards, mice, tablets, track-balls, button boxes, and so on are all +collectively known as input devices. +The core protocol only deals with two devices, +the keyboard and the pointer. + + + + + + DirectColor + DirectColor + + +DirectColor +is a class of colormap in which a pixel value is decomposed into three +separate subfields for indexing. +The first subfield indexes an array to produce red intensity values. +The second subfield indexes a second array to produce blue intensity values. +The third subfield indexes a third array to produce green intensity values. +The RGB values can be changed dynamically. + + + + + + Display + Display + + +A server, together with its screens and input devices, is called a display. + + + + + + Drawable + Drawable + + +Both windows and pixmaps can be used as sources and destinations in +graphics operations. +These windows and pixmaps are collectively known as drawables. +However, an +InputOnly +window cannot be used as a source or destination in a graphics operation. + + + + + + Event + Event + + +Clients are informed of information asynchronously by means of events. +These events can be generated either asynchronously from devices +or as side effects of client requests. +Events are grouped into types. +The server never sends events to a client unless the +client has specifically asked to be informed of that type of event. +However, other clients can force events to be sent to other clients. +Events are typically reported relative to a window. + + + + + + Event mask + Eventmask + + +Events are requested relative to a window. +The set of event types that a client requests relative to a window +is described by using an event mask. + + + + + + Event synchronization + Eventsynchronization + + +There are certain race conditions possible when demultiplexing device +events to clients (in particular deciding where pointer and keyboard +events should be sent when in the middle of window management +operations). +The event synchronization mechanism allows synchronous processing +of device events. + + + + + + Event propagation + Eventpropagation + + +Device-related events propagate from the source window to ancestor +windows until some client has expressed interest in handling that type +of event or until the event is discarded explicitly. + + + + + + Event source + Eventsource + + +The window the pointer is in is the source of a device-related +event. + + + + + + Exposure event + EventExposure + + +Servers do not guarantee to preserve the contents of windows when +windows are obscured or reconfigured. +Exposure events are sent to clients to inform them when contents +of regions of windows have been lost. + + + + + + Extension + Extension + + +Named extensions to the core protocol can be defined to extend the +system. +Extension to output requests, resources, and event types are +all possible and are expected. + + + + + + Focus window + Focus window + + +The focus window is another term for the input focus. + + + + + + Font + Font + + +A font is a matrix of glyphs (typically characters). +The protocol does no translation or interpretation of character sets. +The client simply indicates values used to index the glyph array. +A font contains additional metric information to determine interglyph +and interline spacing. + + + + + + GC, GContext + GCGraphics context + GContextGraphics context + + +GC and gcontext are abbreviations for graphics context. + + + + + + Glyph + Glyph + + +A glyph is an image, typically of a character, in a font. + + + + + + Grab + GrabActive grabPassive grab + + +Keyboard keys, the keyboard, pointer buttons, the pointer, and the +server can be grabbed for exclusive use by a client. +In general, +these facilities are not intended to be used by normal applications +but are intended for various input and window managers to implement +various styles of user interfaces. + + + + + + Graphics context + Graphics context + + +Various information for graphics output is stored in a graphics context +such as foreground pixel, background pixel, line width, +clipping region, +and so on. +A graphics context can only be used with drawables that have the same root +and the same depth as the graphics context. + + + + + + Gravity + Gravity + + +See bit gravity +and window gravity. + + + + + + GrayScale + GrayScale + + +GrayScale +can be viewed as a degenerate case of +PseudoColor, +in which the red, green, and blue values in any given colormap entry are equal, +thus producing shades of gray. +The gray values can be changed dynamically. + + + + + + Hotspot + Hotspot + + +A cursor has an associated hotspot that defines the point in the +cursor corresponding to the coordinates reported for the pointer. + + + + + + Identifier + Identifier + + +An identifier is a unique value associated with a resource that clients use +to name that resource. +The identifier can be used over any connection. + + + + + + Inferiors + Inferiors + + +The inferiors of a window are all of the subwindows nested below it: +the children, the children's children, and so on. + + + + + + Input focus + Input focus + + +The input focus is normally a window defining the scope for +processing of keyboard input. +If a generated keyboard event would normally be reported to this window +or one of its inferiors, +the event is reported normally. +Otherwise, the event is reported with respect to +the focus window. +The input focus also can be set such that all +keyboard events are discarded and such that the focus +window is dynamically taken to be the root window of whatever screen +the pointer is on at each keyboard event. + + + + + + Input manager + Input manager + + +Control over keyboard input is typically provided by an input manager client. + + + + + + InputOnly window + WindowInputOnly + + +An +InputOnly +window is a window that cannot be used for graphics requests. +InputOnly +windows are invisible and can be used to control such things +as cursors, input event generation, and grabbing. +InputOnly +windows cannot have +InputOutput +windows as inferiors. + + + + + + InputOutput window + WindowInputOutput + + +An +InputOutput +window is the normal kind of opaque window, used for both input and output. +InputOutput +windows can have both +InputOutput +and +InputOnly +windows as inferiors. + + + + + + Key grabbing + Keygrabbing + + +Keys on the keyboard can be passively grabbed by a client. +When the key is pressed, +the keyboard is then actively grabbed by the client. + + + + + + Keyboard grabbing + Keyboardgrabbing + + +A client can actively grab control of the keyboard, and key events +will be sent to that client rather than the client the events would +normally have been sent to. + + + + + + Keysym + Keysym + + +An encoding of a symbol on a keycap on a keyboard. + + + + + + Mapped + Mapped window + + +A window is said to be mapped if a map call has been performed on it. +Unmapped windows and their inferiors are never viewable or visible. + + + + + + Modifier keys + Modifier keys + KeymodifierModifier keys + + +Shift, Control, Meta, Super, Hyper, Alt, Compose, Apple, CapsLock, +ShiftLock, and similar keys are called modifier keys. + + + + + + Monochrome + Monochrome + + +Monochrome is a special case of +StaticGray +in which there are only two colormap entries. + + + + + + Obscure + Obscure + + +A window is obscured if some other window obscures it. +Window A obscures window B if both are viewable +InputOutput +windows, A is higher in the global stacking order, +and the rectangle defined by the outside edges of A intersects +the rectangle defined by the outside edges of B. +Note the distinction between obscure and occludes. +Also note that window borders are included in the calculation +and that a window can be obscured and yet still have visible regions. + + + + + + Occlude + Occlude + + +A window is occluded if some other window occludes it. +Window A occludes window B if both are mapped, A is higher in the global +stacking order, and the rectangle defined by the outside edges of A +intersects the rectangle defined by the outside edges of B. +Note the distinction between occludes and obscures. +Also note that window borders are included in the calculation. + + + + + + Padding + Padding + + +Some padding bytes are inserted in the data stream to maintain +alignment of the protocol requests on natural boundaries. +This increases ease of portability to some machine architectures. + + + + + + Parent window + Windowparent + + +If C is a child of P, +then P is the parent of C. + + + + + + Passive grab + Passive grab + + +Grabbing a key or button is a passive grab. +The grab activates when the key or button is actually pressed. + + + + + + Pixel value + Pixel value + + +A pixel is an N-bit value, where N is the number of bit planes used +in a particular window or pixmap (that is, +N is the depth of the window or pixmap). +For a window, +a pixel value indexes a colormap to derive an actual color to be displayed. + + + + + + Pixmap + Pixmap + + +A pixmap is a three-dimensional array of bits. +A pixmap is normally thought of as a two-dimensional array of pixels, +where each pixel can be a value from 0 to (2^N)-1 +and where N is the depth (z axis) of the pixmap. +A pixmap can also be thought of as a stack of N bitmaps. + + + + + + Plane + Plane + + +When a pixmap or window is thought of as a stack of bitmaps, +each bitmap is called a plane or bit plane. + + + + + + Plane mask + Planemask + + +Graphics operations can be restricted to only affect a subset of bit +planes of a destination. +A plane mask is a bit mask describing which planes are to be modified. +The plane mask is stored in a graphics context. + + + + + + Pointer + Pointer + + +The pointer is the pointing device attached to the cursor +and tracked on the screens. + + + + + + Pointer grabbing + Pointergrabbing + + +A client can actively grab control of the pointer. +Then button and motion events will be sent to that client +rather than the client the events would normally have been sent to. + + + + + + Pointing device + Pointing device + + +A pointing device is typically a mouse, tablet, or some other +device with effective dimensional motion. +There is only one visible cursor defined by the core protocol, +and it tracks whatever pointing device is attached as the pointer. + + + + + + Property + Property + + +Windows may have associated properties, +which consist of a name, a type, a data format, and some data. +The protocol places no interpretation on properties. +They are intended as a general-purpose naming mechanism for clients. +For example, clients might use properties to share information such as resize +hints, program names, and icon formats with a window manager. + + + + + + Property list + Property list + + +The property list of a window is the list of properties that have +been defined for the window. + + + + + + PseudoColor + PseudoColor + + +PseudoColor +is a class of colormap in which a pixel value indexes the colormap to +produce independent red, green, and blue values; +that is, the colormap is viewed as an array of triples (RGB values). +The RGB values can be changed dynamically. + + + + + + Redirecting control + Redirecting control + + +Window managers (or client programs) may want to enforce window layout +policy in various ways. +When a client attempts to change the size or position of a window, +the operation may be redirected to a specified client +rather than the operation actually being performed. + + + + + + Reply + Reply + + +Information requested by a client program is sent back to the client +with a reply. +Both events and replies are multiplexed on the same connection. +Most requests do not generate replies, +although some requests generate multiple replies. + + + + + + Request + Request + + +A command to the server is called a request. +It is a single block of data sent over a connection. + + + + + + Resource + Resource + + +Windows, pixmaps, cursors, fonts, graphics contexts, and colormaps are +known as resources. +They all have unique identifiers associated with them for naming purposes. +The lifetime of a resource usually is bounded by the lifetime of the connection +over which the resource was created. + + + + + + RGB values + RGB values + + +Red, green, and blue (RGB) intensity values are used to define color. +These values are always represented as 16-bit unsigned numbers, +with 0 being the minimum intensity and 65535 being the maximum intensity. +The server scales the values to match the display hardware. + + + + + + Root + Root + + +The root of a pixmap, colormap, or graphics context is the same as the root of +whatever drawable was used when the pixmap, colormap, or graphics context was +created. +The root of a window is the root window under which the window was created. + + + + + + Root window + Windowroot + + +Each screen has a root window covering it. +It cannot be reconfigured or unmapped, +but it otherwise acts as a full-fledged window. +A root window has no parent. + + + + + + Save set + Save set + + +The save set of a client is a list of other clients' windows that, +if they are inferiors of one of the client's windows at connection close, +should not be destroyed and that should be remapped if currently unmapped. +Save sets are typically used by window managers to avoid +lost windows if the manager terminates abnormally. + + + + + + Scanline + Scanline + + +A scanline is a list of pixel or bit values viewed as a horizontal +row (all values having the same y coordinate) of an image, with the +values ordered by increasing x coordinate. + + + + + + Scanline order + Scanline order + + +An image represented in scanline order contains scanlines ordered by +increasing y coordinate. + + + + + + Screen + Screen + + +A server can provide several independent screens, +which typically have physically independent monitors. +This would be the expected configuration when there is only a single keyboard +and pointer shared among the screens. + + + + + + Selection + Selection + + +A selection can be thought of as an indirect property with dynamic +type; that is, rather than having the property stored in the server, +it is maintained by some client (the owner). +A selection is global in nature and is thought of as belonging to the user +(although maintained by clients), rather than as being private to a particular +window subhierarchy or a particular set of clients. +When a client asks for the contents of a selection, +it specifies a selection target type. +This target type can be used to control the transmitted representation of the +contents. +For example, +if the selection is the last thing the user clicked on +and that is currently an image, then the target type might specify +whether the contents of the image should be sent in XY format or Z format. +The target type can also be used to control the class of contents transmitted; +for example, asking for the looks (fonts, line +spacing, indentation, and so on) of a paragraph selection rather than the +text of the paragraph. +The target type can also be used for other purposes. +The protocol does not constrain the semantics. + + + + + + Server + Server + + +The server provides the basic windowing mechanism. +It handles connections from clients, +multiplexes graphics requests onto the screens, +and demultiplexes input back to the appropriate clients. + + + + + + Server grabbing + Servergrabbing + + +The server can be grabbed by a single client for exclusive use. +This prevents processing of any requests from other client connections until +the grab is completed. +This is typically only a transient state for +such things as rubber-banding, pop-up menus, or to execute requests +indivisibly. + + + + + + Sibling + Sibling + + +Children of the same parent window are known as sibling windows. + + + + + + Stacking order + Stacking order + + +Sibling windows may stack on top of each other. +Windows above other windows both obscure and occlude those lower windows. +This is similar to paper on a desk. +The relationship between sibling windows is known as the stacking order. + + + + + + StaticColor + StaticColor + + +StaticColor +can be viewed as a degenerate case of +PseudoColor +in which the RGB values are predefined and read-only. + + + + + + StaticGray + StaticGray + + +StaticGray +can be viewed as a degenerate case of +GrayScale +in which the gray values are predefined and read-only. +The values are typically linear or near-linear increasing ramps. + + + + + + Stipple + Stipple + + +A stipple pattern is a bitmap that is used to tile a region that will serve +as an additional clip mask for a fill operation with the foreground +color. + + + + + + String Equivalence + String Equivalence + + +Two ISO Latin-1 STRING8 values are considered equal if they are the same +length and if corresponding bytes are either equal or are equivalent as +follows: decimal values 65 to 90 inclusive (characters A to Z) are +pairwise equivalent to decimal values 97 to 122 inclusive +(characters a to z), decimal values 192 to 214 inclusive +(characters A grave to O diaeresis) are pairwise equivalent to decimal +values 224 to 246 inclusive (characters a grave to o diaeresis), +and decimal values 216 to 222 inclusive (characters O oblique to THORN) +are pairwise equivalent to decimal values 246 to 254 inclusive +(characters o oblique to thorn). + + + + + + Tile + Tile + + +A pixmap can be replicated in two dimensions to tile a region. +The pixmap itself is also known as a tile. + + + + + + Timestamp + Timestamp + CurrentTime + + +A timestamp is a time value, expressed in milliseconds. +It typically is the time since the last +server reset. +Timestamp values wrap around (after about 49.7 days). +The server, given its current time is represented by timestamp T, +always interprets timestamps from clients by treating half of the +timestamp space as being earlier in time than T and half of the +timestamp space as being later in time than T. +One timestamp value (named +CurrentTime) +is never generated by the server. +This value is reserved for use in requests to represent the current +server time. + + + + + + TrueColor + TrueColor + + +TrueColor +can be viewed as a degenerate case of +DirectColor +in which the subfields in the pixel value directly encode +the corresponding RGB values; that is, the colormap has predefined +read-only RGB values. +The values are typically linear or near-linear increasing ramps. + + + + + + Type + Type + + +A type is an arbitrary atom used to identify the interpretation of +property data. +Types are completely uninterpreted by the server +and are solely for the benefit of clients. + + + + + + Viewable + Viewable + + +A window is viewable if it and all of its ancestors are mapped. +This does not imply that any portion of the window is actually visible. +Graphics requests can be performed on a window when it is not viewable, +but output will not be retained unless the server is maintaining +backing store. + + + + + + Visible + Visible + + +A region of a window is visible if someone looking at the screen can +actually see it; +that is, the window is viewable and the region is not occluded by any +other window. + + + + + + Window gravity + Windowgravity + + +When windows are resized, +subwindows may be repositioned automatically relative to some position +in the window. +This attraction of a subwindow to some part of its parent is known +as window gravity. + + + + + + Window manager + Windowmanager + + +Manipulation of windows on the screen and much of the user interface +(policy) is typically provided by a window manager client. + + + + + + XYFormat + XYFormat + + +The data for a pixmap is said to be in XY format if it is organized as +a set of bitmaps representing individual bit planes, with the planes +appearing from most-significant to least-significant in bit order. + + + + + + ZFormat + ZFormat + + +The data for a pixmap is said to be in Z format if it is organized as +a set of pixel values in scanline order. + + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xproto/keysyms.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xproto/keysyms.xml new file mode 100644 index 0000000000000000000000000000000000000000..9999f8d88583d7468bec6f7d7fc2d6b64939191c --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xproto/keysyms.xml @@ -0,0 +1,6050 @@ + +KEYSYM Encoding +TypesKEYSYM +Keysym + + +KEYSYM values are 32-bit integers that encode the symbols on the +keycaps of a keyboard. The three most significant bits are always +zero, which leaves a 29-bit number space. For convenience, KEYSYM +values can be viewed as split into four bytes: + + + + + +Byte 1 is the most significant eight bits (three zero bits and +the most-significant five bits of the 29-bit effective value) + + + + +Byte 2 is the next most-significant eight bits + + + + +Byte 3 is the next most-significant eight bits + + + + +Byte 4 is the least-significant eight bits + + + + + +There are six categories of KEYSYM values. + + + +Special KEYSYMs + +There are two special values: +NoSymbol +and +VoidSymbol. +They are used to indicate the absence of symbols (see +Section 5, Keyboards). + + + + + + + + + + + + + + Byte 1 + Byte 2 + Byte 3 + Byte 4 + Hex. value + Name + + + + + 0 + 0 + 0 + 0 + #x00000000 + NoSymbol + + + 0 + 255 + 255 + 255 + #x00FFFFFF + VoidSymbol + + + + + + + +Latin-1 KEYSYMs + + +The Latin-1 KEYSYMs occupy the range #x0020 to #x007E and #x00A0 to +#00FF and represent the ISO 10646 / Unicode characters U+0020 to +U+007E and U+00A0 to U+00FF, respectively. + + + + +Unicode KEYSYMs +KeysymUnicode + + +These occupy the range #x01000100 to #x0110FFFF and represent the ISO +10646 / Unicode characters U+0100 to U+10FFFF, respectively. The +numeric value of a Unicode KEYSYM is the Unicode position of the +corresponding character plus #x01000000. In the interest of backwards +compatibility, clients should be able to process both the Unicode +KEYSYM and the Legacy KEYSYM for those characters where both exist. + + +Dead keys, which place an accent on the next character entered, shall +be encoded as Function KEYSYMs, and not as the Unicode KEYSYM +corresponding to an equivalent combining character. Where a keycap +indicates a specific function with a graphical symbol that is also +available in Unicode (e.g., an upwards arrow for the cursor up +function), the appropriate Function KEYSYM should be used, and not +the Unicode KEYSYM corresponding to the depicted symbol. + + + +Function KEYSYMs + + +These represent keycap symbols that do not directly represent elements +of a coded character set. Instead, they typically identify a software +function, mode, or operation (e.g., cursor up, caps lock, insert) that +can be activated using a dedicated key. Function KEYSYMs have zero +values for bytes 1 and 2. Byte 3 distinguishes between several 8-bit +sets within which byte 4 identifies the individual function key. + + + + + + + + + + Byte 3 + Byte 4 + + + + + 255 + Keyboard + + + 254 + Keyboard (XKB) Extension + + + 253 + 3270 + + + + + + +Within a national market, keyboards tend to be comparatively standard +with respect to the character keys, but they can differ significantly +on the miscellaneous function keys. Some have function keys left over +from early timesharing days, others were designed for a specific +application, such as text processing, web browsing, or accessing +audiovisual data. The symbols on the keycaps can differ significantly +between manufacturers and national markets, even where they denote the +same software function (e.g., Ctrl in the U.S. versus Strg in Germany) + + + +There are two ways of thinking about how to define KEYSYMs for such a +world: + + + + +The Engraving approach + + + + +The Common approach + + + + + +The Engraving approach is to create a KEYSYM for every unique key +engraving. This is effectively taking the union of all key engravings +on all keyboards. For example, some keyboards label function keys +across the top as F1 through Fn, and others label them as PF1 through +PFn. These would be different keys under the Engraving +approach. Likewise, Lock would differ from Shift Lock, which is +different from the up-arrow symbol that has the effect of changing +lowercase to uppercase. There are lots of other aliases such as Del, +DEL, Delete, Remove, and so forth. The Engraving approach makes it +easy to decide if a new entry should be added to the KEYSYM set: if it +does not exactly match an existing one, then a new one is created. + + + +The Common approach tries to capture all of the keys present on an +interesting number of keyboards, folding likely aliases into the same +KEYSYM. For example, Del, DEL, and Delete are all merged into a single +KEYSYM. Vendors can augment the KEYSYM set (using the vendor-specific +encoding space) to include all of their unique keys that were not +included in the standard set. Each vendor decides which of its keys +map into the standard KEYSYMs, which presumably can be overridden by a +user. It is more difficult to implement this approach, because +judgment is required about when a sufficient set of keyboards +implements an engraving to justify making it a KEYSYM in the standard +set and about which engravings should be merged into a single +KEYSYM. + + + +Although neither scheme is perfect or elegant, the Common approach has +been selected because it makes it easier to write a portable +application. Having the Delete functionality merged into a single +KEYSYM allows an application to implement a deletion function and +expect reasonable bindings on a wide set of workstations. Under the +Common approach, application writers are still free to look for and +interpret vendor-specific KEYSYMs, but because they are in the +extended set, the application developer is more conscious that they +are writing the application in a nonportable fashion. + + + +The Keyboard set is a miscellaneous collection of commonly occurring +keys on keyboards. Within this set, the numeric keypad symbols are +generally duplicates of symbols found on keys on the main part of the +keyboard, but they are distinguished here because they often have a +distinguishable semantics associated with them. + + + + + + + + + + KEYSYM value + Name + Set + + + + + #xFF08 + BACKSPACE, BACK SPACE, BACK CHAR + Keyboard + + + #xFF09 + TAB + Keyboard + + + #xFF0A + LINEFEED, LF + Keyboard + + + #xFF0B + CLEAR + Keyboard + + + #xFF0D + RETURN, ENTER + Keyboard + + + #xFF13 + PAUSE, HOLD + Keyboard + + + #xFF14 + SCROLL LOCK + Keyboard + + + #xFF15 + SYS REQ, SYSTEM REQUEST + Keyboard + + + #xFF1B + ESCAPE + Keyboard + + + #xFF20 + MULTI-KEY CHARACTER PREFACE + Keyboard + + + #xFF21 + KANJI, KANJI CONVERT + Keyboard + + + #xFF22 + MUHENKAN + Keyboard + + + #xFF23 + HENKAN MODE + Keyboard + + + #xFF24 + ROMAJI + Keyboard + + + #xFF25 + HIRAGANA + Keyboard + + + #xFF26 + KATAKANA + Keyboard + + + #xFF27 + HIRAGANA/KATAKANA TOGGLE + Keyboard + + + #xFF28 + ZENKAKU + Keyboard + + + #xFF29 + HANKAKU + Keyboard + + + #xFF2A + ZENKAKU/HANKAKU TOGGLE + Keyboard + + + #xFF2B + TOUROKU + Keyboard + + + #xFF2C + MASSYO + Keyboard + + + #xFF2D + KANA LOCK + Keyboard + + + #xFF2E + KANA SHIFT + Keyboard + + + #xFF2F + EISU SHIFT + Keyboard + + + #xFF30 + EISU TOGGLE + Keyboard + + + #xFF31 + HANGUL START/STOP (TOGGLE) + Keyboard + + + #xFF32 + HANGUL START + Keyboard + + + #xFF33 + HANGUL END, ENGLISH START + Keyboard + + + #xFF34 + START HANGUL/HANJA CONVERSION + Keyboard + + + #xFF35 + HANGUL JAMO MODE + Keyboard + + + #xFF36 + HANGUL ROMAJA MODE + Keyboard + + + #xFF37 + HANGUL CODE INPUT + Keyboard + + + #xFF38 + HANGUL JEONJA MODE + Keyboard + + + #xFF39 + HANGUL BANJA MODE + Keyboard + + + #xFF3A + HANGUL PREHANJA CONVERSION + Keyboard + + + #xFF3B + HANGUL POSTHANJA CONVERSION + Keyboard + + + #xFF3C + HANGUL SINGLE CANDIDATE + Keyboard + + + #xFF3D + HANGUL MULTIPLE CANDIDATE + Keyboard + + + #xFF3E + HANGUL PREVIOUS CANDIDATE + Keyboard + + + #xFF3F + HANGUL SPECIAL SYMBOLS + Keyboard + + + #xFF50 + HOME + Keyboard + + + #xFF51 + LEFT, MOVE LEFT, LEFT ARROW + Keyboard + + + #xFF52 + UP, MOVE UP, UP ARROW + Keyboard + + + #xFF53 + RIGHT, MOVE RIGHT, RIGHT ARROW + Keyboard + + + #xFF54 + DOWN, MOVE DOWN, DOWN ARROW + Keyboard + + + #xFF55 + PRIOR, PREVIOUS, PAGE UP + Keyboard + + + #xFF56 + NEXT, PAGE DOWN + Keyboard + + + #xFF57 + END, EOL + Keyboard + + + #xFF58 + BEGIN, BOL + Keyboard + + + #xFF60 + SELECT, MARK + Keyboard + + + #xFF61 + PRINT + Keyboard + + + #xFF62 + EXECUTE, RUN, DO + Keyboard + + + #xFF63 + INSERT, INSERT HERE + Keyboard + + + #xFF65 + UNDO, OOPS + Keyboard + + + #xFF66 + REDO, AGAIN + Keyboard + + + #xFF67 + MENU + Keyboard + + + #xFF68 + FIND, SEARCH + Keyboard + + + #xFF69 + CANCEL, STOP, ABORT, EXIT + Keyboard + + + #xFF6A + HELP + Keyboard + + + #xFF6B + BREAK + Keyboard + + + #xFF7E + MODE SWITCH, SCRIPT SWITCH, CHARACTER SET SWITCH + Keyboard + + + #xFF7F + NUM LOCK + Keyboard + + + #xFF80 + KEYPAD SPACE + Keyboard + + + #xFF89 + KEYPAD TAB + Keyboard + + + #xFF8D + KEYPAD ENTER + Keyboard + + + #xFF91 + KEYPAD F1, PF1, A + Keyboard + + + #xFF92 + KEYPAD F2, PF2, B + Keyboard + + + #xFF93 + KEYPAD F3, PF3, C + Keyboard + + + #xFF94 + KEYPAD F4, PF4, D + Keyboard + + + #xFF95 + KEYPAD HOME + Keyboard + + + #xFF96 + KEYPAD LEFT + Keyboard + + + #xFF97 + KEYPAD UP + Keyboard + + + #xFF98 + KEYPAD RIGHT + Keyboard + + + #xFF99 + KEYPAD DOWN + Keyboard + + + #xFF9A + KEYPAD PRIOR, PAGE UP + Keyboard + + + #xFF9B + KEYPAD NEXT, PAGE DOWN + Keyboard + + + #xFF9C + KEYPAD END + Keyboard + + + #xFF9D + KEYPAD BEGIN + Keyboard + + + #xFF9E + KEYPAD INSERT + Keyboard + + + #xFF9F + KEYPAD DELETE + Keyboard + + + #xFFAA + KEYPAD MULTIPLICATION SIGN, ASTERISK + Keyboard + + + #xFFAB + KEYPAD PLUS SIGN + Keyboard + + + #xFFAC + KEYPAD SEPARATOR, COMMA + Keyboard + + + #xFFAD + KEYPAD MINUS SIGN, HYPHEN + Keyboard + + + #xFFAE + KEYPAD DECIMAL POINT, FULL STOP + Keyboard + + + #xFFAF + KEYPAD DIVISION SIGN, SOLIDUS + Keyboard + + + #xFFB0 + KEYPAD DIGIT ZERO + Keyboard + + + #xFFB1 + KEYPAD DIGIT ONE + Keyboard + + + #xFFB2 + KEYPAD DIGIT TWO + Keyboard + + + #xFFB3 + KEYPAD DIGIT THREE + Keyboard + + + #xFFB4 + KEYPAD DIGIT FOUR + Keyboard + + + #xFFB5 + KEYPAD DIGIT FIVE + Keyboard + + + #xFFB6 + KEYPAD DIGIT SIX + Keyboard + + + #xFFB7 + KEYPAD DIGIT SEVEN + Keyboard + + + #xFFB8 + KEYPAD DIGIT EIGHT + Keyboard + + + #xFFB9 + KEYPAD DIGIT NINE + Keyboard + + + #xFFBD + KEYPAD EQUALS SIGN + Keyboard + + + #xFFBE + F1 + Keyboard + + + #xFFBF + F2 + Keyboard + + + #xFFC0 + F3 + Keyboard + + + #xFFC1 + F4 + Keyboard + + + #xFFC2 + F5 + Keyboard + + + #xFFC3 + F6 + Keyboard + + + #xFFC4 + F7 + Keyboard + + + #xFFC5 + F8 + Keyboard + + + #xFFC6 + F9 + Keyboard + + + #xFFC7 + F10 + Keyboard + + + #xFFC8 + F11, L1 + Keyboard + + + #xFFC9 + F12, L2 + Keyboard + + + #xFFCA + F13, L3 + Keyboard + + + #xFFCB + F14, L4 + Keyboard + + + #xFFCC + F15, L5 + Keyboard + + + #xFFCD + F16, L6 + Keyboard + + + #xFFCE + F17, L7 + Keyboard + + + #xFFCF + F18, L8 + Keyboard + + + #xFFD0 + F19, L9 + Keyboard + + + #xFFD1 + F20, L10 + Keyboard + + + #xFFD2 + F21, R1 + Keyboard + + + #xFFD3 + F22, R2 + Keyboard + + + #xFFD4 + F23, R3 + Keyboard + + + #xFFD5 + F24, R4 + Keyboard + + + #xFFD6 + F25, R5 + Keyboard + + + #xFFD7 + F26, R6 + Keyboard + + + #xFFD8 + F27, R7 + Keyboard + + + #xFFD9 + F28, R8 + Keyboard + + + #xFFDA + F29, R9 + Keyboard + + + #xFFDB + F30, R10 + Keyboard + + + #xFFDC + F31, R11 + Keyboard + + + #xFFDD + F32, R12 + Keyboard + + + #xFFDE + F33, R13 + Keyboard + + + #xFFDF + F34, R14 + Keyboard + + + #xFFE0 + F35, R15 + Keyboard + + + #xFFE1 + LEFT SHIFT + Keyboard + + + #xFFE2 + RIGHT SHIFT + Keyboard + + + #xFFE3 + LEFT CONTROL + Keyboard + + + #xFFE4 + RIGHT CONTROL + Keyboard + + + #xFFE5 + CAPS LOCK + Keyboard + + + #xFFE6 + SHIFT LOCK + Keyboard + + + #xFFE7 + LEFT META + Keyboard + + + #xFFE8 + RIGHT META + Keyboard + + + #xFFE9 + LEFT ALT + Keyboard + + + #xFFEA + RIGHT ALT + Keyboard + + + #xFFEB + LEFT SUPER + Keyboard + + + #xFFEC + RIGHT SUPER + Keyboard + + + #xFFED + LEFT HYPER + Keyboard + + + #xFFEE + RIGHT HYPER + Keyboard + + + #xFFFF + DELETE, RUBOUT + Keyboard + + + + + + +The Keyboard (XKB) Extension set, which provides among other things +a range of dead keys, is defined in "The X Keyboard Extension: +Protocol Specification", Appendix C. + + + +The 3270 set defines additional keys that are specific to IBM 3270 +terminals. + + + + + + + + + + KEYSYM value + Name + Set + + + + + #xFD01 + 3270 DUPLICATE + 3270 + + + #xFD02 + 3270 FIELDMARK + 3270 + + + #xFD03 + 3270 RIGHT2 + 3270 + + + #xFD04 + 3270 LEFT2 + 3270 + + + #xFD05 + 3270 BACKTAB + 3270 + + + #xFD06 + 3270 ERASEEOF + 3270 + + + #xFD07 + 3270 ERASEINPUT + 3270 + + + #xFD08 + 3270 RESET + 3270 + + + #xFD09 + 3270 QUIT + 3270 + + + #xFD0A + 3270 PA1 + 3270 + + + #xFD0B + 3270 PA2 + 3270 + + + #xFD0C + 3270 PA3 + 3270 + + + #xFD0D + 3270 TEST + 3270 + + + #xFD0E + 3270 ATTN + 3270 + + + #xFD0F + 3270 CURSORBLINK + 3270 + + + #xFD10 + 3270 ALTCURSOR + 3270 + + + #xFD11 + 3270 KEYCLICK + 3270 + + + #xFD12 + 3270 JUMP + 3270 + + + #xFD13 + 3270 IDENT + 3270 + + + #xFD14 + 3270 RULE + 3270 + + + #xFD15 + 3270 COPY + 3270 + + + #xFD16 + 3270 PLAY + 3270 + + + #xFD17 + 3270 SETUP + 3270 + + + #xFD18 + 3270 RECORD + 3270 + + + #xFD19 + 3270 CHANGESCREEN + 3270 + + + #xFD1A + 3270 DELETEWORD + 3270 + + + #xFD1B + 3270 EXSELECT + 3270 + + + #xFD1C + 3270 CURSORSELECT + 3270 + + + #xFD1D + 3270 PRINTSCREEN + 3270 + + + #xFD1E + 3270 ENTER + 3270 + + + + + + + + +Vendor KEYSYMs + + +The KEYSYM number range #x10000000 to #x1FFFFFFF is available for +vendor-specific extensions. Among these, the range #x11000000 to +#x1100FFFF is designated for keypad KEYSYMs. + + + + +Legacy KEYSYMs + + +These date from the time before ISO 10646 / Unicode was +available. They represent characters from a number of different older +8-bit coded character sets and have zero values for bytes 1 and +2. Byte 3 indicates a coded character set and byte 4 is the 8-bit +value of the particular character within that set. + + + + + + + + + + + Byte 3 + Byte 4 + Byte 3 + Byte 4 + + + + + 1 + Latin-2 + 11 + APL + + + 2 + Latin-3 + 12 + Hebrew + + + 3 + Latin-4 + 13 + Thai + + + 4 + Kana + 14 + Korean + + + 5 + Arabic + 15 + Latin-5 + + + 6 + Cyrillic + 16 + Latin-6 + + + 7 + Greek + 17 + Latin-7 + + + 8 + Technical + 18 + Latin-8 + + + 9 + Special + 19 + Latin-9 + + + 10 + Publishing + 32 + Currency + + + + + + +Each character set contains gaps where codes have been removed that +were duplicates with codes in previous character sets (that is, +character sets with lesser byte 3 value). + + + +The Latin, Arabic, Cyrillic, Greek, Hebrew, and Thai sets were taken +from the early drafts of the relevant ISO 8859 parts available at the +time. However, in the case of the Cyrillic and Greek sets, these +turned out differently in the final versions of the ISO standard. The +Technical, Special, and Publishing sets are based on Digital Equipment +Corporation standards, as no equivalent international standards were +available at the time. + + + +The table below lists all standardized Legacy KEYSYMs, along with the +name used in the source document. Where there exists an unambiguous +equivalent in Unicode, as it is the case with all ISO 8859 characters, +it is given in the second column as a cross reference. Where there is +no Unicode number provided, the exact semantics of the KEYSYM may have +been lost and a Unicode KEYSYM should be used instead, if available. + + + +As support of Unicode KEYSYMs increases, some or all of the Legacy +KEYSYMs may be phased out and withdrawn in future versions of this +standard. Most KEYSYMs in the sets Technical, Special, Publishing, APL +and Currency (with the exception of #x20AC) were probably never used +in practice, and were not supported by pre-Unicode fonts. In +particular, the Currency set, which was copied from Unicode, has +already been deprecated by the introduction of the Unicode KEYSYMs. + + + + + + + + + + + KEYSYM value + Unicode value + Name + Set + + + + + #x01A1 + U+0104 + LATIN CAPITAL LETTER A WITH OGONEK + Latin-2 + + + #x01A2 + U+02D8 + BREVE + Latin-2 + + + #x01A3 + U+0141 + LATIN CAPITAL LETTER L WITH STROKE + Latin-2 + + + #x01A5 + U+013D + LATIN CAPITAL LETTER L WITH CARON + Latin-2 + + + #x01A6 + U+015A + LATIN CAPITAL LETTER S WITH ACUTE + Latin-2 + + + #x01A9 + U+0160 + LATIN CAPITAL LETTER S WITH CARON + Latin-2 + + + #x01AA + U+015E + LATIN CAPITAL LETTER S WITH CEDILLA + Latin-2 + + + #x01AB + U+0164 + LATIN CAPITAL LETTER T WITH CARON + Latin-2 + + + #x01AC + U+0179 + LATIN CAPITAL LETTER Z WITH ACUTE + Latin-2 + + + #x01AE + U+017D + LATIN CAPITAL LETTER Z WITH CARON + Latin-2 + + + #x01AF + U+017B + LATIN CAPITAL LETTER Z WITH DOT ABOVE + Latin-2 + + + #x01B1 + U+0105 + LATIN SMALL LETTER A WITH OGONEK + Latin-2 + + + #x01B2 + U+02DB + OGONEK + Latin-2 + + + #x01B3 + U+0142 + LATIN SMALL LETTER L WITH STROKE + Latin-2 + + + #x01B5 + U+013E + LATIN SMALL LETTER L WITH CARON + Latin-2 + + + #x01B6 + U+015B + LATIN SMALL LETTER S WITH ACUTE + Latin-2 + + + #x01B7 + U+02C7 + CARON + Latin-2 + + + #x01B9 + U+0161 + LATIN SMALL LETTER S WITH CARON + Latin-2 + + + #x01BA + U+015F + LATIN SMALL LETTER S WITH CEDILLA + Latin-2 + + + #x01BB + U+0165 + LATIN SMALL LETTER T WITH CARON + Latin-2 + + + #x01BC + U+017A + LATIN SMALL LETTER Z WITH ACUTE + Latin-2 + + + #x01BD + U+02DD + DOUBLE ACUTE ACCENT + Latin-2 + + + #x01BE + U+017E + LATIN SMALL LETTER Z WITH CARON + Latin-2 + + + #x01BF + U+017C + LATIN SMALL LETTER Z WITH DOT ABOVE + Latin-2 + + + #x01C0 + U+0154 + LATIN CAPITAL LETTER R WITH ACUTE + Latin-2 + + + #x01C3 + U+0102 + LATIN CAPITAL LETTER A WITH BREVE + Latin-2 + + + #x01C5 + U+0139 + LATIN CAPITAL LETTER L WITH ACUTE + Latin-2 + + + #x01C6 + U+0106 + LATIN CAPITAL LETTER C WITH ACUTE + Latin-2 + + + #x01C8 + U+010C + LATIN CAPITAL LETTER C WITH CARON + Latin-2 + + + #x01CA + U+0118 + LATIN CAPITAL LETTER E WITH OGONEK + Latin-2 + + + #x01CC + U+011A + LATIN CAPITAL LETTER E WITH CARON + Latin-2 + + + #x01CF + U+010E + LATIN CAPITAL LETTER D WITH CARON + Latin-2 + + + #x01D0 + U+0110 + LATIN CAPITAL LETTER D WITH STROKE + Latin-2 + + + #x01D1 + U+0143 + LATIN CAPITAL LETTER N WITH ACUTE + Latin-2 + + + #x01D2 + U+0147 + LATIN CAPITAL LETTER N WITH CARON + Latin-2 + + + #x01D5 + U+0150 + LATIN CAPITAL LETTER O WITH DOUBLE ACUTE + Latin-2 + + + #x01D8 + U+0158 + LATIN CAPITAL LETTER R WITH CARON + Latin-2 + + + #x01D9 + U+016E + LATIN CAPITAL LETTER U WITH RING ABOVE + Latin-2 + + + #x01DB + U+0170 + LATIN CAPITAL LETTER U WITH DOUBLE ACUTE + Latin-2 + + + #x01DE + U+0162 + LATIN CAPITAL LETTER T WITH CEDILLA + Latin-2 + + + #x01E0 + U+0155 + LATIN SMALL LETTER R WITH ACUTE + Latin-2 + + + #x01E3 + U+0103 + LATIN SMALL LETTER A WITH BREVE + Latin-2 + + + #x01E5 + U+013A + LATIN SMALL LETTER L WITH ACUTE + Latin-2 + + + #x01E6 + U+0107 + LATIN SMALL LETTER C WITH ACUTE + Latin-2 + + + #x01E8 + U+010D + LATIN SMALL LETTER C WITH CARON + Latin-2 + + + #x01EA + U+0119 + LATIN SMALL LETTER E WITH OGONEK + Latin-2 + + + #x01EC + U+011B + LATIN SMALL LETTER E WITH CARON + Latin-2 + + + #x01EF + U+010F + LATIN SMALL LETTER D WITH CARON + Latin-2 + + + #x01F0 + U+0111 + LATIN SMALL LETTER D WITH STROKE + Latin-2 + + + #x01F1 + U+0144 + LATIN SMALL LETTER N WITH ACUTE + Latin-2 + + + #x01F2 + U+0148 + LATIN SMALL LETTER N WITH CARON + Latin-2 + + + #x01F5 + U+0151 + LATIN SMALL LETTER O WITH DOUBLE ACUTE + Latin-2 + + + #x01F8 + U+0159 + LATIN SMALL LETTER R WITH CARON + Latin-2 + + + #x01F9 + U+016F + LATIN SMALL LETTER U WITH RING ABOVE + Latin-2 + + + #x01FB + U+0171 + LATIN SMALL LETTER U WITH DOUBLE ACUTE + Latin-2 + + + #x01FE + U+0163 + LATIN SMALL LETTER T WITH CEDILLA + Latin-2 + + + #x01FF + U+02D9 + DOT ABOVE + Latin-2 + + + #x02A1 + U+0126 + LATIN CAPITAL LETTER H WITH STROKE + Latin-3 + + + #x02A6 + U+0124 + LATIN CAPITAL LETTER H WITH CIRCUMFLEX + Latin-3 + + + #x02A9 + U+0130 + LATIN CAPITAL LETTER I WITH DOT ABOVE + Latin-3 + + + #x02AB + U+011E + LATIN CAPITAL LETTER G WITH BREVE + Latin-3 + + + #x02AC + U+0134 + LATIN CAPITAL LETTER J WITH CIRCUMFLEX + Latin-3 + + + #x02B1 + U+0127 + LATIN SMALL LETTER H WITH STROKE + Latin-3 + + + #x02B6 + U+0125 + LATIN SMALL LETTER H WITH CIRCUMFLEX + Latin-3 + + + #x02B9 + U+0131 + LATIN SMALL LETTER DOTLESS I + Latin-3 + + + #x02BB + U+011F + LATIN SMALL LETTER G WITH BREVE + Latin-3 + + + #x02BC + U+0135 + LATIN SMALL LETTER J WITH CIRCUMFLEX + Latin-3 + + + #x02C5 + U+010A + LATIN CAPITAL LETTER C WITH DOT ABOVE + Latin-3 + + + #x02C6 + U+0108 + LATIN CAPITAL LETTER C WITH CIRCUMFLEX + Latin-3 + + + #x02D5 + U+0120 + LATIN CAPITAL LETTER G WITH DOT ABOVE + Latin-3 + + + #x02D8 + U+011C + LATIN CAPITAL LETTER G WITH CIRCUMFLEX + Latin-3 + + + #x02DD + U+016C + LATIN CAPITAL LETTER U WITH BREVE + Latin-3 + + + #x02DE + U+015C + LATIN CAPITAL LETTER S WITH CIRCUMFLEX + Latin-3 + + + #x02E5 + U+010B + LATIN SMALL LETTER C WITH DOT ABOVE + Latin-3 + + + #x02E6 + U+0109 + LATIN SMALL LETTER C WITH CIRCUMFLEX + Latin-3 + + + #x02F5 + U+0121 + LATIN SMALL LETTER G WITH DOT ABOVE + Latin-3 + + + #x02F8 + U+011D + LATIN SMALL LETTER G WITH CIRCUMFLEX + Latin-3 + + + #x02FD + U+016D + LATIN SMALL LETTER U WITH BREVE + Latin-3 + + + #x02FE + U+015D + LATIN SMALL LETTER S WITH CIRCUMFLEX + Latin-3 + + + #x03A2 + U+0138 + LATIN SMALL LETTER KRA + Latin-4 + + + #x03A3 + U+0156 + LATIN CAPITAL LETTER R WITH CEDILLA + Latin-4 + + + #x03A5 + U+0128 + LATIN CAPITAL LETTER I WITH TILDE + Latin-4 + + + #x03A6 + U+013B + LATIN CAPITAL LETTER L WITH CEDILLA + Latin-4 + + + #x03AA + U+0112 + LATIN CAPITAL LETTER E WITH MACRON + Latin-4 + + + #x03AB + U+0122 + LATIN CAPITAL LETTER G WITH CEDILLA + Latin-4 + + + #x03AC + U+0166 + LATIN CAPITAL LETTER T WITH STROKE + Latin-4 + + + #x03B3 + U+0157 + LATIN SMALL LETTER R WITH CEDILLA + Latin-4 + + + #x03B5 + U+0129 + LATIN SMALL LETTER I WITH TILDE + Latin-4 + + + #x03B6 + U+013C + LATIN SMALL LETTER L WITH CEDILLA + Latin-4 + + + #x03BA + U+0113 + LATIN SMALL LETTER E WITH MACRON + Latin-4 + + + #x03BB + U+0123 + LATIN SMALL LETTER G WITH CEDILLA + Latin-4 + + + #x03BC + U+0167 + LATIN SMALL LETTER T WITH STROKE + Latin-4 + + + #x03BD + U+014A + LATIN CAPITAL LETTER ENG + Latin-4 + + + #x03BF + U+014B + LATIN SMALL LETTER ENG + Latin-4 + + + #x03C0 + U+0100 + LATIN CAPITAL LETTER A WITH MACRON + Latin-4 + + + #x03C7 + U+012E + LATIN CAPITAL LETTER I WITH OGONEK + Latin-4 + + + #x03CC + U+0116 + LATIN CAPITAL LETTER E WITH DOT ABOVE + Latin-4 + + + #x03CF + U+012A + LATIN CAPITAL LETTER I WITH MACRON + Latin-4 + + + #x03D1 + U+0145 + LATIN CAPITAL LETTER N WITH CEDILLA + Latin-4 + + + #x03D2 + U+014C + LATIN CAPITAL LETTER O WITH MACRON + Latin-4 + + + #x03D3 + U+0136 + LATIN CAPITAL LETTER K WITH CEDILLA + Latin-4 + + + #x03D9 + U+0172 + LATIN CAPITAL LETTER U WITH OGONEK + Latin-4 + + + #x03DD + U+0168 + LATIN CAPITAL LETTER U WITH TILDE + Latin-4 + + + #x03DE + U+016A + LATIN CAPITAL LETTER U WITH MACRON + Latin-4 + + + #x03E0 + U+0101 + LATIN SMALL LETTER A WITH MACRON + Latin-4 + + + #x03E7 + U+012F + LATIN SMALL LETTER I WITH OGONEK + Latin-4 + + + #x03EC + U+0117 + LATIN SMALL LETTER E WITH DOT ABOVE + Latin-4 + + + #x03EF + U+012B + LATIN SMALL LETTER I WITH MACRON + Latin-4 + + + #x03F1 + U+0146 + LATIN SMALL LETTER N WITH CEDILLA + Latin-4 + + + #x03F2 + U+014D + LATIN SMALL LETTER O WITH MACRON + Latin-4 + + + #x03F3 + U+0137 + LATIN SMALL LETTER K WITH CEDILLA + Latin-4 + + + #x03F9 + U+0173 + LATIN SMALL LETTER U WITH OGONEK + Latin-4 + + + #x03FD + U+0169 + LATIN SMALL LETTER U WITH TILDE + Latin-4 + + + #x03FE + U+016B + LATIN SMALL LETTER U WITH MACRON + Latin-4 + + + #x047E + U+203E + OVERLINE + Kana + + + #x04A1 + U+3002 + KANA FULL STOP + Kana + + + #x04A2 + U+300C + KANA OPENING BRACKET + Kana + + + #x04A3 + U+300D + KANA CLOSING BRACKET + Kana + + + #x04A4 + U+3001 + KANA COMMA + Kana + + + #x04A5 + U+30FB + KANA CONJUNCTIVE + Kana + + + #x04A6 + U+30F2 + KANA LETTER WO + Kana + + + #x04A7 + U+30A1 + KANA LETTER SMALL A + Kana + + + #x04A8 + U+30A3 + KANA LETTER SMALL I + Kana + + + #x04A9 + U+30A5 + KANA LETTER SMALL U + Kana + + + #x04AA + U+30A7 + KANA LETTER SMALL E + Kana + + + #x04AB + U+30A9 + KANA LETTER SMALL O + Kana + + + #x04AC + U+30E3 + KANA LETTER SMALL YA + Kana + + + #x04AD + U+30E5 + KANA LETTER SMALL YU + Kana + + + #x04AE + U+30E7 + KANA LETTER SMALL YO + Kana + + + #x04AF + U+30C3 + KANA LETTER SMALL TSU + Kana + + + #x04B0 + U+30FC + PROLONGED SOUND SYMBOL + Kana + + + #x04B1 + U+30A2 + KANA LETTER A + Kana + + + #x04B2 + U+30A4 + KANA LETTER I + Kana + + + #x04B3 + U+30A6 + KANA LETTER U + Kana + + + #x04B4 + U+30A8 + KANA LETTER E + Kana + + + #x04B5 + U+30AA + KANA LETTER O + Kana + + + #x04B6 + U+30AB + KANA LETTER KA + Kana + + + #x04B7 + U+30AD + KANA LETTER KI + Kana + + + #x04B8 + U+30AF + KANA LETTER KU + Kana + + + #x04B9 + U+30B1 + KANA LETTER KE + Kana + + + #x04BA + U+30B3 + KANA LETTER KO + Kana + + + #x04BB + U+30B5 + KANA LETTER SA + Kana + + + #x04BC + U+30B7 + KANA LETTER SHI + Kana + + + #x04BD + U+30B9 + KANA LETTER SU + Kana + + + #x04BE + U+30BB + KANA LETTER SE + Kana + + + #x04BF + U+30BD + KANA LETTER SO + Kana + + + #x04C0 + U+30BF + KANA LETTER TA + Kana + + + #x04C1 + U+30C1 + KANA LETTER CHI + Kana + + + #x04C2 + U+30C4 + KANA LETTER TSU + Kana + + + #x04C3 + U+30C6 + KANA LETTER TE + Kana + + + #x04C4 + U+30C8 + KANA LETTER TO + Kana + + + #x04C5 + U+30CA + KANA LETTER NA + Kana + + + #x04C6 + U+30CB + KANA LETTER NI + Kana + + + #x04C7 + U+30CC + KANA LETTER NU + Kana + + + #x04C8 + U+30CD + KANA LETTER NE + Kana + + + #x04C9 + U+30CE + KANA LETTER NO + Kana + + + #x04CA + U+30CF + KANA LETTER HA + Kana + + + #x04CB + U+30D2 + KANA LETTER HI + Kana + + + #x04CC + U+30D5 + KANA LETTER FU + Kana + + + #x04CD + U+30D8 + KANA LETTER HE + Kana + + + #x04CE + U+30DB + KANA LETTER HO + Kana + + + #x04CF + U+30DE + KANA LETTER MA + Kana + + + #x04D0 + U+30DF + KANA LETTER MI + Kana + + + #x04D1 + U+30E0 + KANA LETTER MU + Kana + + + #x04D2 + U+30E1 + KANA LETTER ME + Kana + + + #x04D3 + U+30E2 + KANA LETTER MO + Kana + + + #x04D4 + U+30E4 + KANA LETTER YA + Kana + + + #x04D5 + U+30E6 + KANA LETTER YU + Kana + + + #x04D6 + U+30E8 + KANA LETTER YO + Kana + + + #x04D7 + U+30E9 + KANA LETTER RA + Kana + + + #x04D8 + U+30EA + KANA LETTER RI + Kana + + + #x04D9 + U+30EB + KANA LETTER RU + Kana + + + #x04DA + U+30EC + KANA LETTER RE + Kana + + + #x04DB + U+30ED + KANA LETTER RO + Kana + + + #x04DC + U+30EF + KANA LETTER WA + Kana + + + #x04DD + U+30F3 + KANA LETTER N + Kana + + + #x04DE + U+309B + VOICED SOUND SYMBOL + Kana + + + #x04DF + U+309C + SEMIVOICED SOUND SYMBOL + Kana + + + #x05AC + U+060C + ARABIC COMMA + Arabic + + + #x05BB + U+061B + ARABIC SEMICOLON + Arabic + + + #x05BF + U+061F + ARABIC QUESTION MARK + Arabic + + + #x05C1 + U+0621 + ARABIC LETTER HAMZA + Arabic + + + #x05C2 + U+0622 + ARABIC LETTER ALEF WITH MADDA ABOVE + Arabic + + + #x05C3 + U+0623 + ARABIC LETTER ALEF WITH HAMZA ABOVE + Arabic + + + #x05C4 + U+0624 + ARABIC LETTER WAW WITH HAMZA ABOVE + Arabic + + + #x05C5 + U+0625 + ARABIC LETTER ALEF WITH HAMZA BELOW + Arabic + + + #x05C6 + U+0626 + ARABIC LETTER YEH WITH HAMZA ABOVE + Arabic + + + #x05C7 + U+0627 + ARABIC LETTER ALEF + Arabic + + + #x05C8 + U+0628 + ARABIC LETTER BEH + Arabic + + + #x05C9 + U+0629 + ARABIC LETTER TEH MARBUTA + Arabic + + + #x05CA + U+062A + ARABIC LETTER TEH + Arabic + + + #x05CB + U+062B + ARABIC LETTER THEH + Arabic + + + #x05CC + U+062C + ARABIC LETTER JEEM + Arabic + + + #x05CD + U+062D + ARABIC LETTER HAH + Arabic + + + #x05CE + U+062E + ARABIC LETTER KHAH + Arabic + + + #x05CF + U+062F + ARABIC LETTER DAL + Arabic + + + #x05D0 + U+0630 + ARABIC LETTER THAL + Arabic + + + #x05D1 + U+0631 + ARABIC LETTER REH + Arabic + + + #x05D2 + U+0632 + ARABIC LETTER ZAIN + Arabic + + + #x05D3 + U+0633 + ARABIC LETTER SEEN + Arabic + + + #x05D4 + U+0634 + ARABIC LETTER SHEEN + Arabic + + + #x05D5 + U+0635 + ARABIC LETTER SAD + Arabic + + + #x05D6 + U+0636 + ARABIC LETTER DAD + Arabic + + + #x05D7 + U+0637 + ARABIC LETTER TAH + Arabic + + + #x05D8 + U+0638 + ARABIC LETTER ZAH + Arabic + + + #x05D9 + U+0639 + ARABIC LETTER AIN + Arabic + + + #x05DA + U+063A + ARABIC LETTER GHAIN + Arabic + + + #x05E0 + U+0640 + ARABIC TATWEEL + Arabic + + + #x05E1 + U+0641 + ARABIC LETTER FEH + Arabic + + + #x05E2 + U+0642 + ARABIC LETTER QAF + Arabic + + + #x05E3 + U+0643 + ARABIC LETTER KAF + Arabic + + + #x05E4 + U+0644 + ARABIC LETTER LAM + Arabic + + + #x05E5 + U+0645 + ARABIC LETTER MEEM + Arabic + + + #x05E6 + U+0646 + ARABIC LETTER NOON + Arabic + + + #x05E7 + U+0647 + ARABIC LETTER HEH + Arabic + + + #x05E8 + U+0648 + ARABIC LETTER WAW + Arabic + + + #x05E9 + U+0649 + ARABIC LETTER ALEF MAKSURA + Arabic + + + #x05EA + U+064A + ARABIC LETTER YEH + Arabic + + + #x05EB + U+064B + ARABIC FATHATAN + Arabic + + + #x05EC + U+064C + ARABIC DAMMATAN + Arabic + + + #x05ED + U+064D + ARABIC KASRATAN + Arabic + + + #x05EE + U+064E + ARABIC FATHA + Arabic + + + #x05EF + U+064F + ARABIC DAMMA + Arabic + + + #x05F0 + U+0650 + ARABIC KASRA + Arabic + + + #x05F1 + U+0651 + ARABIC SHADDA + Arabic + + + #x05F2 + U+0652 + ARABIC SUKUN + Arabic + + + #x06A1 + U+0452 + CYRILLIC SMALL LETTER DJE + Cyrillic + + + #x06A2 + U+0453 + CYRILLIC SMALL LETTER GJE + Cyrillic + + + #x06A3 + U+0451 + CYRILLIC SMALL LETTER IO + Cyrillic + + + #x06A4 + U+0454 + CYRILLIC SMALL LETTER UKRAINIAN IE + Cyrillic + + + #x06A5 + U+0455 + CYRILLIC SMALL LETTER DZE + Cyrillic + + + #x06A6 + U+0456 + CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I + Cyrillic + + + #x06A7 + U+0457 + CYRILLIC SMALL LETTER YI + Cyrillic + + + #x06A8 + U+0458 + CYRILLIC SMALL LETTER JE + Cyrillic + + + #x06A9 + U+0459 + CYRILLIC SMALL LETTER LJE + Cyrillic + + + #x06AA + U+045A + CYRILLIC SMALL LETTER NJE + Cyrillic + + + #x06AB + U+045B + CYRILLIC SMALL LETTER TSHE + Cyrillic + + + #x06AC + U+045C + CYRILLIC SMALL LETTER KJE + Cyrillic + + + #x06AD + U+0491 + CYRILLIC SMALL LETTER GHE WITH UPTURN + Cyrillic + + + #x06AE + U+045E + CYRILLIC SMALL LETTER SHORT U + Cyrillic + + + #x06AF + U+045F + CYRILLIC SMALL LETTER DZHE + Cyrillic + + + #x06B0 + U+2116 + NUMERO SIGN + Cyrillic + + + #x06B1 + U+0402 + CYRILLIC CAPITAL LETTER DJE + Cyrillic + + + #x06B2 + U+0403 + CYRILLIC CAPITAL LETTER GJE + Cyrillic + + + #x06B3 + U+0401 + CYRILLIC CAPITAL LETTER IO + Cyrillic + + + #x06B4 + U+0404 + CYRILLIC CAPITAL LETTER UKRAINIAN IE + Cyrillic + + + #x06B5 + U+0405 + CYRILLIC CAPITAL LETTER DZE + Cyrillic + + + #x06B6 + U+0406 + CYRILLIC CAPITAL LETTER BYELORUSSIAN-UKRAINIAN I + Cyrillic + + + #x06B7 + U+0407 + CYRILLIC CAPITAL LETTER YI + Cyrillic + + + #x06B8 + U+0408 + CYRILLIC CAPITAL LETTER JE + Cyrillic + + + #x06B9 + U+0409 + CYRILLIC CAPITAL LETTER LJE + Cyrillic + + + #x06BA + U+040A + CYRILLIC CAPITAL LETTER NJE + Cyrillic + + + #x06BB + U+040B + CYRILLIC CAPITAL LETTER TSHE + Cyrillic + + + #x06BC + U+040C + CYRILLIC CAPITAL LETTER KJE + Cyrillic + + + #x06BD + U+0490 + CYRILLIC CAPITAL LETTER GHE WITH UPTURN + Cyrillic + + + #x06BE + U+040E + CYRILLIC CAPITAL LETTER SHORT U + Cyrillic + + + #x06BF + U+040F + CYRILLIC CAPITAL LETTER DZHE + Cyrillic + + + #x06C0 + U+044E + CYRILLIC SMALL LETTER YU + Cyrillic + + + #x06C1 + U+0430 + CYRILLIC SMALL LETTER A + Cyrillic + + + #x06C2 + U+0431 + CYRILLIC SMALL LETTER BE + Cyrillic + + + #x06C3 + U+0446 + CYRILLIC SMALL LETTER TSE + Cyrillic + + + #x06C4 + U+0434 + CYRILLIC SMALL LETTER DE + Cyrillic + + + #x06C5 + U+0435 + CYRILLIC SMALL LETTER IE + Cyrillic + + + #x06C6 + U+0444 + CYRILLIC SMALL LETTER EF + Cyrillic + + + #x06C7 + U+0433 + CYRILLIC SMALL LETTER GHE + Cyrillic + + + #x06C8 + U+0445 + CYRILLIC SMALL LETTER HA + Cyrillic + + + #x06C9 + U+0438 + CYRILLIC SMALL LETTER I + Cyrillic + + + #x06CA + U+0439 + CYRILLIC SMALL LETTER SHORT I + Cyrillic + + + #x06CB + U+043A + CYRILLIC SMALL LETTER KA + Cyrillic + + + #x06CC + U+043B + CYRILLIC SMALL LETTER EL + Cyrillic + + + #x06CD + U+043C + CYRILLIC SMALL LETTER EM + Cyrillic + + + #x06CE + U+043D + CYRILLIC SMALL LETTER EN + Cyrillic + + + #x06CF + U+043E + CYRILLIC SMALL LETTER O + Cyrillic + + + #x06D0 + U+043F + CYRILLIC SMALL LETTER PE + Cyrillic + + + #x06D1 + U+044F + CYRILLIC SMALL LETTER YA + Cyrillic + + + #x06D2 + U+0440 + CYRILLIC SMALL LETTER ER + Cyrillic + + + #x06D3 + U+0441 + CYRILLIC SMALL LETTER ES + Cyrillic + + + #x06D4 + U+0442 + CYRILLIC SMALL LETTER TE + Cyrillic + + + #x06D5 + U+0443 + CYRILLIC SMALL LETTER U + Cyrillic + + + #x06D6 + U+0436 + CYRILLIC SMALL LETTER ZHE + Cyrillic + + + #x06D7 + U+0432 + CYRILLIC SMALL LETTER VE + Cyrillic + + + #x06D8 + U+044C + CYRILLIC SMALL LETTER SOFT SIGN + Cyrillic + + + #x06D9 + U+044B + CYRILLIC SMALL LETTER YERU + Cyrillic + + + #x06DA + U+0437 + CYRILLIC SMALL LETTER ZE + Cyrillic + + + #x06DB + U+0448 + CYRILLIC SMALL LETTER SHA + Cyrillic + + + #x06DC + U+044D + CYRILLIC SMALL LETTER E + Cyrillic + + + #x06DD + U+0449 + CYRILLIC SMALL LETTER SHCHA + Cyrillic + + + #x06DE + U+0447 + CYRILLIC SMALL LETTER CHE + Cyrillic + + + #x06DF + U+044A + CYRILLIC SMALL LETTER HARD SIGN + Cyrillic + + + #x06E0 + U+042E + CYRILLIC CAPITAL LETTER YU + Cyrillic + + + #x06E1 + U+0410 + CYRILLIC CAPITAL LETTER A + Cyrillic + + + #x06E2 + U+0411 + CYRILLIC CAPITAL LETTER BE + Cyrillic + + + #x06E3 + U+0426 + CYRILLIC CAPITAL LETTER TSE + Cyrillic + + + #x06E4 + U+0414 + CYRILLIC CAPITAL LETTER DE + Cyrillic + + + #x06E5 + U+0415 + CYRILLIC CAPITAL LETTER IE + Cyrillic + + + #x06E6 + U+0424 + CYRILLIC CAPITAL LETTER EF + Cyrillic + + + #x06E7 + U+0413 + CYRILLIC CAPITAL LETTER GHE + Cyrillic + + + #x06E8 + U+0425 + CYRILLIC CAPITAL LETTER HA + Cyrillic + + + #x06E9 + U+0418 + CYRILLIC CAPITAL LETTER I + Cyrillic + + + #x06EA + U+0419 + CYRILLIC CAPITAL LETTER SHORT I + Cyrillic + + + #x06EB + U+041A + CYRILLIC CAPITAL LETTER KA + Cyrillic + + + #x06EC + U+041B + CYRILLIC CAPITAL LETTER EL + Cyrillic + + + #x06ED + U+041C + CYRILLIC CAPITAL LETTER EM + Cyrillic + + + #x06EE + U+041D + CYRILLIC CAPITAL LETTER EN + Cyrillic + + + #x06EF + U+041E + CYRILLIC CAPITAL LETTER O + Cyrillic + + + #x06F0 + U+041F + CYRILLIC CAPITAL LETTER PE + Cyrillic + + + #x06F1 + U+042F + CYRILLIC CAPITAL LETTER YA + Cyrillic + + + #x06F2 + U+0420 + CYRILLIC CAPITAL LETTER ER + Cyrillic + + + #x06F3 + U+0421 + CYRILLIC CAPITAL LETTER ES + Cyrillic + + + #x06F4 + U+0422 + CYRILLIC CAPITAL LETTER TE + Cyrillic + + + #x06F5 + U+0423 + CYRILLIC CAPITAL LETTER U + Cyrillic + + + #x06F6 + U+0416 + CYRILLIC CAPITAL LETTER ZHE + Cyrillic + + + #x06F7 + U+0412 + CYRILLIC CAPITAL LETTER VE + Cyrillic + + + #x06F8 + U+042C + CYRILLIC CAPITAL LETTER SOFT SIGN + Cyrillic + + + #x06F9 + U+042B + CYRILLIC CAPITAL LETTER YERU + Cyrillic + + + #x06FA + U+0417 + CYRILLIC CAPITAL LETTER ZE + Cyrillic + + + #x06FB + U+0428 + CYRILLIC CAPITAL LETTER SHA + Cyrillic + + + #x06FC + U+042D + CYRILLIC CAPITAL LETTER E + Cyrillic + + + #x06FD + U+0429 + CYRILLIC CAPITAL LETTER SHCHA + Cyrillic + + + #x06FE + U+0427 + CYRILLIC CAPITAL LETTER CHE + Cyrillic + + + #x06FF + U+042A + CYRILLIC CAPITAL LETTER HARD SIGN + Cyrillic + + + #x07A1 + U+0386 + GREEK CAPITAL LETTER ALPHA WITH TONOS + Greek + + + #x07A2 + U+0388 + GREEK CAPITAL LETTER EPSILON WITH TONOS + Greek + + + #x07A3 + U+0389 + GREEK CAPITAL LETTER ETA WITH TONOS + Greek + + + #x07A4 + U+038A + GREEK CAPITAL LETTER IOTA WITH TONOS + Greek + + + #x07A5 + U+03AA + GREEK CAPITAL LETTER IOTA WITH DIALYTIKA + Greek + + + #x07A7 + U+038C + GREEK CAPITAL LETTER OMICRON WITH TONOS + Greek + + + #x07A8 + U+038E + GREEK CAPITAL LETTER UPSILON WITH TONOS + Greek + + + #x07A9 + U+03AB + GREEK CAPITAL LETTER UPSILON WITH DIALYTIKA + Greek + + + #x07AB + U+038F + GREEK CAPITAL LETTER OMEGA WITH TONOS + Greek + + + #x07AE + U+0385 + GREEK DIALYTIKA TONOS + Greek + + + #x07AF + U+2015 + HORIZONTAL BAR + Greek + + + #x07B1 + U+03AC + GREEK SMALL LETTER ALPHA WITH TONOS + Greek + + + #x07B2 + U+03AD + GREEK SMALL LETTER EPSILON WITH TONOS + Greek + + + #x07B3 + U+03AE + GREEK SMALL LETTER ETA WITH TONOS + Greek + + + #x07B4 + U+03AF + GREEK SMALL LETTER IOTA WITH TONOS + Greek + + + #x07B5 + U+03CA + GREEK SMALL LETTER IOTA WITH DIALYTIKA + Greek + + + #x07B6 + U+0390 + GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS + Greek + + + #x07B7 + U+03CC + GREEK SMALL LETTER OMICRON WITH TONOS + Greek + + + #x07B8 + U+03CD + GREEK SMALL LETTER UPSILON WITH TONOS + Greek + + + #x07B9 + U+03CB + GREEK SMALL LETTER UPSILON WITH DIALYTIKA + Greek + + + #x07BA + U+03B0 + GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS + Greek + + + #x07BB + U+03CE + GREEK SMALL LETTER OMEGA WITH TONOS + Greek + + + #x07C1 + U+0391 + GREEK CAPITAL LETTER ALPHA + Greek + + + #x07C2 + U+0392 + GREEK CAPITAL LETTER BETA + Greek + + + #x07C3 + U+0393 + GREEK CAPITAL LETTER GAMMA + Greek + + + #x07C4 + U+0394 + GREEK CAPITAL LETTER DELTA + Greek + + + #x07C5 + U+0395 + GREEK CAPITAL LETTER EPSILON + Greek + + + #x07C6 + U+0396 + GREEK CAPITAL LETTER ZETA + Greek + + + #x07C7 + U+0397 + GREEK CAPITAL LETTER ETA + Greek + + + #x07C8 + U+0398 + GREEK CAPITAL LETTER THETA + Greek + + + #x07C9 + U+0399 + GREEK CAPITAL LETTER IOTA + Greek + + + #x07CA + U+039A + GREEK CAPITAL LETTER KAPPA + Greek + + + #x07CB + U+039B + GREEK CAPITAL LETTER LAMDA + Greek + + + #x07CC + U+039C + GREEK CAPITAL LETTER MU + Greek + + + #x07CD + U+039D + GREEK CAPITAL LETTER NU + Greek + + + #x07CE + U+039E + GREEK CAPITAL LETTER XI + Greek + + + #x07CF + U+039F + GREEK CAPITAL LETTER OMICRON + Greek + + + #x07D0 + U+03A0 + GREEK CAPITAL LETTER PI + Greek + + + #x07D1 + U+03A1 + GREEK CAPITAL LETTER RHO + Greek + + + #x07D2 + U+03A3 + GREEK CAPITAL LETTER SIGMA + Greek + + + #x07D4 + U+03A4 + GREEK CAPITAL LETTER TAU + Greek + + + #x07D5 + U+03A5 + GREEK CAPITAL LETTER UPSILON + Greek + + + #x07D6 + U+03A6 + GREEK CAPITAL LETTER PHI + Greek + + + #x07D7 + U+03A7 + GREEK CAPITAL LETTER CHI + Greek + + + #x07D8 + U+03A8 + GREEK CAPITAL LETTER PSI + Greek + + + #x07D9 + U+03A9 + GREEK CAPITAL LETTER OMEGA + Greek + + + #x07E1 + U+03B1 + GREEK SMALL LETTER ALPHA + Greek + + + #x07E2 + U+03B2 + GREEK SMALL LETTER BETA + Greek + + + #x07E3 + U+03B3 + GREEK SMALL LETTER GAMMA + Greek + + + #x07E4 + U+03B4 + GREEK SMALL LETTER DELTA + Greek + + + #x07E5 + U+03B5 + GREEK SMALL LETTER EPSILON + Greek + + + #x07E6 + U+03B6 + GREEK SMALL LETTER ZETA + Greek + + + #x07E7 + U+03B7 + GREEK SMALL LETTER ETA + Greek + + + #x07E8 + U+03B8 + GREEK SMALL LETTER THETA + Greek + + + #x07E9 + U+03B9 + GREEK SMALL LETTER IOTA + Greek + + + #x07EA + U+03BA + GREEK SMALL LETTER KAPPA + Greek + + + #x07EB + U+03BB + GREEK SMALL LETTER LAMDA + Greek + + + #x07EC + U+03BC + GREEK SMALL LETTER MU + Greek + + + #x07ED + U+03BD + GREEK SMALL LETTER NU + Greek + + + #x07EE + U+03BE + GREEK SMALL LETTER XI + Greek + + + #x07EF + U+03BF + GREEK SMALL LETTER OMICRON + Greek + + + #x07F0 + U+03C0 + GREEK SMALL LETTER PI + Greek + + + #x07F1 + U+03C1 + GREEK SMALL LETTER RHO + Greek + + + #x07F2 + U+03C3 + GREEK SMALL LETTER SIGMA + Greek + + + #x07F3 + U+03C2 + GREEK SMALL LETTER FINAL SIGMA + Greek + + + #x07F4 + U+03C4 + GREEK SMALL LETTER TAU + Greek + + + #x07F5 + U+03C5 + GREEK SMALL LETTER UPSILON + Greek + + + #x07F6 + U+03C6 + GREEK SMALL LETTER PHI + Greek + + + #x07F7 + U+03C7 + GREEK SMALL LETTER CHI + Greek + + + #x07F8 + U+03C8 + GREEK SMALL LETTER PSI + Greek + + + #x07F9 + U+03C9 + GREEK SMALL LETTER OMEGA + Greek + + + #x08A1 + U+23B7 + LEFT RADICAL + Technical + + + #x08A2 + - + TOP LEFT RADICAL + Technical + + + #x08A3 + - + HORIZONTAL CONNECTOR + Technical + + + #x08A4 + U+2320 + TOP INTEGRAL + Technical + + + #x08A5 + U+2321 + BOTTOM INTEGRAL + Technical + + + #x08A6 + - + VERTICAL CONNECTOR + Technical + + + #x08A7 + U+23A1 + TOP LEFT SQUARE BRACKET + Technical + + + #x08A8 + U+23A3 + BOTTOM LEFT SQUARE BRACKET + Technical + + + #x08A9 + U+23A4 + TOP RIGHT SQUARE BRACKET + Technical + + + #x08AA + U+23A6 + BOTTOM RIGHT SQUARE BRACKET + Technical + + + #x08AB + U+239B + TOP LEFT PARENTHESIS + Technical + + + #x08AC + U+239D + BOTTOM LEFT PARENTHESIS + Technical + + + #x08AD + U+239E + TOP RIGHT PARENTHESIS + Technical + + + #x08AE + U+23A0 + BOTTOM RIGHT PARENTHESIS + Technical + + + #x08AF + U+23A8 + LEFT MIDDLE CURLY BRACE + Technical + + + #x08B0 + U+23AC + RIGHT MIDDLE CURLY BRACE + Technical + + + #x08B1 + - + TOP LEFT SUMMATION + Technical + + + #x08B2 + - + BOTTOM LEFT SUMMATION + Technical + + + #x08B3 + - + TOP VERTICAL SUMMATION CONNECTOR + Technical + + + #x08B4 + - + BOTTOM VERTICAL SUMMATION CONNECTOR + Technical + + + #x08B5 + - + TOP RIGHT SUMMATION + Technical + + + #x08B6 + - + BOTTOM RIGHT SUMMATION + Technical + + + #x08B7 + - + RIGHT MIDDLE SUMMATION + Technical + + + #x08BC + U+2264 + LESS THAN OR EQUAL SIGN + Technical + + + #x08BD + U+2260 + NOT EQUAL SIGN + Technical + + + #x08BE + U+2265 + GREATER THAN OR EQUAL SIGN + Technical + + + #x08BF + U+222B + INTEGRAL + Technical + + + #x08C0 + U+2234 + THEREFORE + Technical + + + #x08C1 + U+221D + VARIATION, PROPORTIONAL TO + Technical + + + #x08C2 + U+221E + INFINITY + Technical + + + #x08C5 + U+2207 + NABLA, DEL + Technical + + + #x08C8 + U+223C + IS APPROXIMATE TO + Technical + + + #x08C9 + U+2243 + SIMILAR OR EQUAL TO + Technical + + + #x08CD + U+21D4 + IF AND ONLY IF + Technical + + + #x08CE + U+21D2 + IMPLIES + Technical + + + #x08CF + U+2261 + IDENTICAL TO + Technical + + + #x08D6 + U+221A + RADICAL + Technical + + + #x08DA + U+2282 + IS INCLUDED IN + Technical + + + #x08DB + U+2283 + INCLUDES + Technical + + + #x08DC + U+2229 + INTERSECTION + Technical + + + #x08DD + U+222A + UNION + Technical + + + #x08DE + U+2227 + LOGICAL AND + Technical + + + #x08DF + U+2228 + LOGICAL OR + Technical + + + #x08EF + U+2202 + PARTIAL DERIVATIVE + Technical + + + #x08F6 + U+0192 + FUNCTION + Technical + + + #x08FB + U+2190 + LEFT ARROW + Technical + + + #x08FC + U+2191 + UPWARD ARROW + Technical + + + #x08FD + U+2192 + RIGHT ARROW + Technical + + + #x08FE + U+2193 + DOWNWARD ARROW + Technical + + + #x09DF + - + BLANK + Special + + + #x09E0 + U+25C6 + SOLID DIAMOND + Special + + + #x09E1 + U+2592 + CHECKERBOARD + Special + + + #x09E2 + U+2409 + "HT" + Special + + + #x09E3 + U+240C + "FF" + Special + + + #x09E4 + U+240D + "CR" + Special + + + #x09E5 + U+240A + "LF" + Special + + + #x09E8 + U+2424 + "NL" + Special + + + #x09E9 + U+240B + "VT" + Special + + + #x09EA + U+2518 + LOWER-RIGHT CORNER + Special + + + #x09EB + U+2510 + UPPER-RIGHT CORNER + Special + + + #x09EC + U+250C + UPPER-LEFT CORNER + Special + + + #x09ED + U+2514 + LOWER-LEFT CORNER + Special + + + #x09EE + U+253C + CROSSING-LINES + Special + + + #x09EF + U+23BA + HORIZONTAL LINE, SCAN 1 + Special + + + #x09F0 + U+23BB + HORIZONTAL LINE, SCAN 3 + Special + + + #x09F1 + U+2500 + HORIZONTAL LINE, SCAN 5 + Special + + + #x09F2 + U+23BC + HORIZONTAL LINE, SCAN 7 + Special + + + #x09F3 + U+23BD + HORIZONTAL LINE, SCAN 9 + Special + + + #x09F4 + U+251C + LEFT "T" + Special + + + #x09F5 + U+2524 + RIGHT "T" + Special + + + #x09F6 + U+2534 + BOTTOM "T" + Special + + + #x09F7 + U+252C + TOP "T" + Special + + + #x09F8 + U+2502 + VERTICAL BAR + Special + + + #x0AA1 + U+2003 + EM SPACE + Publish + + + #x0AA2 + U+2002 + EN SPACE + Publish + + + #x0AA3 + U+2004 + 3/EM SPACE + Publish + + + #x0AA4 + U+2005 + 4/EM SPACE + Publish + + + #x0AA5 + U+2007 + DIGIT SPACE + Publish + + + #x0AA6 + U+2008 + PUNCTUATION SPACE + Publish + + + #x0AA7 + U+2009 + THIN SPACE + Publish + + + #x0AA8 + U+200A + HAIR SPACE + Publish + + + #x0AA9 + U+2014 + EM DASH + Publish + + + #x0AAA + U+2013 + EN DASH + Publish + + + #x0AAC + - + SIGNIFICANT BLANK SYMBOL + Publish + + + #x0AAE + U+2026 + ELLIPSIS + Publish + + + #x0AAF + U+2025 + DOUBLE BASELINE DOT + Publish + + + #x0AB0 + U+2153 + VULGAR FRACTION ONE THIRD + Publish + + + #x0AB1 + U+2154 + VULGAR FRACTION TWO THIRDS + Publish + + + #x0AB2 + U+2155 + VULGAR FRACTION ONE FIFTH + Publish + + + #x0AB3 + U+2156 + VULGAR FRACTION TWO FIFTHS + Publish + + + #x0AB4 + U+2157 + VULGAR FRACTION THREE FIFTHS + Publish + + + #x0AB5 + U+2158 + VULGAR FRACTION FOUR FIFTHS + Publish + + + #x0AB6 + U+2159 + VULGAR FRACTION ONE SIXTH + Publish + + + #x0AB7 + U+215A + VULGAR FRACTION FIVE SIXTHS + Publish + + + #x0AB8 + U+2105 + CARE OF + Publish + + + #x0ABB + U+2012 + FIGURE DASH + Publish + + + #x0ABC + - + LEFT ANGLE BRACKET + Publish + + + #x0ABD + - + DECIMAL POINT + Publish + + + #x0ABE + - + RIGHT ANGLE BRACKET + Publish + + + #x0ABF + - + MARKER + Publish + + + #x0AC3 + U+215B + VULGAR FRACTION ONE EIGHTH + Publish + + + #x0AC4 + U+215C + VULGAR FRACTION THREE EIGHTHS + Publish + + + #x0AC5 + U+215D + VULGAR FRACTION FIVE EIGHTHS + Publish + + + #x0AC6 + U+215E + VULGAR FRACTION SEVEN EIGHTHS + Publish + + + #x0AC9 + U+2122 + TRADEMARK SIGN + Publish + + + #x0ACA + - + SIGNATURE MARK + Publish + + + #x0ACB + - + TRADEMARK SIGN IN CIRCLE + Publish + + + #x0ACC + - + LEFT OPEN TRIANGLE + Publish + + + #x0ACD + - + RIGHT OPEN TRIANGLE + Publish + + + #x0ACE + - + EM OPEN CIRCLE + Publish + + + #x0ACF + - + EM OPEN RECTANGLE + Publish + + + #x0AD0 + U+2018 + LEFT SINGLE QUOTATION MARK + Publish + + + #x0AD1 + U+2019 + RIGHT SINGLE QUOTATION MARK + Publish + + + #x0AD2 + U+201C + LEFT DOUBLE QUOTATION MARK + Publish + + + #x0AD3 + U+201D + RIGHT DOUBLE QUOTATION MARK + Publish + + + #x0AD4 + U+211E + PRESCRIPTION, TAKE, RECIPE + Publish + + + #x0AD5 + U+2030 + PER MILLE SIGN + Publish + + + #x0AD6 + U+2032 + MINUTES + Publish + + + #x0AD7 + U+2033 + SECONDS + Publish + + + #x0AD9 + U+271D + LATIN CROSS + Publish + + + #x0ADA + - + HEXAGRAM + Publish + + + #x0ADB + - + FILLED RECTANGLE BULLET + Publish + + + #x0ADC + - + FILLED LEFT TRIANGLE BULLET + Publish + + + #x0ADD + - + FILLED RIGHT TRIANGLE BULLET + Publish + + + #x0ADE + - + EM FILLED CIRCLE + Publish + + + #x0ADF + - + EM FILLED RECTANGLE + Publish + + + #x0AE0 + - + EN OPEN CIRCLE BULLET + Publish + + + #x0AE1 + - + EN OPEN SQUARE BULLET + Publish + + + #x0AE2 + - + OPEN RECTANGULAR BULLET + Publish + + + #x0AE3 + - + OPEN TRIANGULAR BULLET UP + Publish + + + #x0AE4 + - + OPEN TRIANGULAR BULLET DOWN + Publish + + + #x0AE5 + - + OPEN STAR + Publish + + + #x0AE6 + - + EN FILLED CIRCLE BULLET + Publish + + + #x0AE7 + - + EN FILLED SQUARE BULLET + Publish + + + #x0AE8 + - + FILLED TRIANGULAR BULLET UP + Publish + + + #x0AE9 + - + FILLED TRIANGULAR BULLET DOWN + Publish + + + #x0AEA + - + LEFT POINTER + Publish + + + #x0AEB + - + RIGHT POINTER + Publish + + + #x0AEC + U+2663 + CLUB + Publish + + + #x0AED + U+2666 + DIAMOND + Publish + + + #x0AEE + U+2665 + HEART + Publish + + + #x0AF0 + U+2720 + MALTESE CROSS + Publish + + + #x0AF1 + U+2020 + DAGGER + Publish + + + #x0AF2 + U+2021 + DOUBLE DAGGER + Publish + + + #x0AF3 + U+2713 + CHECK MARK, TICK + Publish + + + #x0AF4 + U+2717 + BALLOT CROSS + Publish + + + #x0AF5 + U+266F + MUSICAL SHARP + Publish + + + #x0AF6 + U+266D + MUSICAL FLAT + Publish + + + #x0AF7 + U+2642 + MALE SYMBOL + Publish + + + #x0AF8 + U+2640 + FEMALE SYMBOL + Publish + + + #x0AF9 + U+260E + TELEPHONE SYMBOL + Publish + + + #x0AFA + U+2315 + TELEPHONE RECORDER SYMBOL + Publish + + + #x0AFB + U+2117 + PHONOGRAPH COPYRIGHT SIGN + Publish + + + #x0AFC + U+2038 + CARET + Publish + + + #x0AFD + U+201A + SINGLE LOW QUOTATION MARK + Publish + + + #x0AFE + U+201E + DOUBLE LOW QUOTATION MARK + Publish + + + #x0AFF + - + CURSOR + Publish + + + #x0BA3 + - + LEFT CARET + APL + + + #x0BA6 + - + RIGHT CARET + APL + + + #x0BA8 + - + DOWN CARET + APL + + + #x0BA9 + - + UP CARET + APL + + + #x0BC0 + - + OVERBAR + APL + + + #x0BC2 + U+22A5 + DOWN TACK + APL + + + #x0BC3 + - + UP SHOE (CAP) + APL + + + #x0BC4 + U+230A + DOWN STILE + APL + + + #x0BC6 + - + UNDERBAR + APL + + + #x0BCA + U+2218 + JOT + APL + + + #x0BCC + U+2395 + QUAD + APL + + + #x0BCE + U+22A4 + UP TACK + APL + + + #x0BCF + U+25CB + CIRCLE + APL + + + #x0BD3 + U+2308 + UP STILE + APL + + + #x0BD6 + - + DOWN SHOE (CUP) + APL + + + #x0BD8 + - + RIGHT SHOE + APL + + + #x0BDA + - + LEFT SHOE + APL + + + #x0BDC + U+22A2 + LEFT TACK + APL + + + #x0BFC + U+22A3 + RIGHT TACK + APL + + + #x0CDF + U+2017 + DOUBLE LOW LINE + Hebrew + + + #x0CE0 + U+05D0 + HEBREW LETTER ALEF + Hebrew + + + #x0CE1 + U+05D1 + HEBREW LETTER BET + Hebrew + + + #x0CE2 + U+05D2 + HEBREW LETTER GIMEL + Hebrew + + + #x0CE3 + U+05D3 + HEBREW LETTER DALET + Hebrew + + + #x0CE4 + U+05D4 + HEBREW LETTER HE + Hebrew + + + #x0CE5 + U+05D5 + HEBREW LETTER VAV + Hebrew + + + #x0CE6 + U+05D6 + HEBREW LETTER ZAYIN + Hebrew + + + #x0CE7 + U+05D7 + HEBREW LETTER HET + Hebrew + + + #x0CE8 + U+05D8 + HEBREW LETTER TET + Hebrew + + + #x0CE9 + U+05D9 + HEBREW LETTER YOD + Hebrew + + + #x0CEA + U+05DA + HEBREW LETTER FINAL KAF + Hebrew + + + #x0CEB + U+05DB + HEBREW LETTER KAF + Hebrew + + + #x0CEC + U+05DC + HEBREW LETTER LAMED + Hebrew + + + #x0CED + U+05DD + HEBREW LETTER FINAL MEM + Hebrew + + + #x0CEE + U+05DE + HEBREW LETTER MEM + Hebrew + + + #x0CEF + U+05DF + HEBREW LETTER FINAL NUN + Hebrew + + + #x0CF0 + U+05E0 + HEBREW LETTER NUN + Hebrew + + + #x0CF1 + U+05E1 + HEBREW LETTER SAMEKH + Hebrew + + + #x0CF2 + U+05E2 + HEBREW LETTER AYIN + Hebrew + + + #x0CF3 + U+05E3 + HEBREW LETTER FINAL PE + Hebrew + + + #x0CF4 + U+05E4 + HEBREW LETTER PE + Hebrew + + + #x0CF5 + U+05E5 + HEBREW LETTER FINAL TSADI + Hebrew + + + #x0CF6 + U+05E6 + HEBREW LETTER TSADI + Hebrew + + + #x0CF7 + U+05E7 + HEBREW LETTER QOF + Hebrew + + + #x0CF8 + U+05E8 + HEBREW LETTER RESH + Hebrew + + + #x0CF9 + U+05E9 + HEBREW LETTER SHIN + Hebrew + + + #x0CFA + U+05EA + HEBREW LETTER TAV + Hebrew + + + #x0DA1 + U+0E01 + THAI CHARACTER KO KAI + Thai + + + #x0DA2 + U+0E02 + THAI CHARACTER KHO KHAI + Thai + + + #x0DA3 + U+0E03 + THAI CHARACTER KHO KHUAT + Thai + + + #x0DA4 + U+0E04 + THAI CHARACTER KHO KHWAI + Thai + + + #x0DA5 + U+0E05 + THAI CHARACTER KHO KHON + Thai + + + #x0DA6 + U+0E06 + THAI CHARACTER KHO RAKHANG + Thai + + + #x0DA7 + U+0E07 + THAI CHARACTER NGO NGU + Thai + + + #x0DA8 + U+0E08 + THAI CHARACTER CHO CHAN + Thai + + + #x0DA9 + U+0E09 + THAI CHARACTER CHO CHING + Thai + + + #x0DAA + U+0E0A + THAI CHARACTER CHO CHANG + Thai + + + #x0DAB + U+0E0B + THAI CHARACTER SO SO + Thai + + + #x0DAC + U+0E0C + THAI CHARACTER CHO CHOE + Thai + + + #x0DAD + U+0E0D + THAI CHARACTER YO YING + Thai + + + #x0DAE + U+0E0E + THAI CHARACTER DO CHADA + Thai + + + #x0DAF + U+0E0F + THAI CHARACTER TO PATAK + Thai + + + #x0DB0 + U+0E10 + THAI CHARACTER THO THAN + Thai + + + #x0DB1 + U+0E11 + THAI CHARACTER THO NANGMONTHO + Thai + + + #x0DB2 + U+0E12 + THAI CHARACTER THO PHUTHAO + Thai + + + #x0DB3 + U+0E13 + THAI CHARACTER NO NEN + Thai + + + #x0DB4 + U+0E14 + THAI CHARACTER DO DEK + Thai + + + #x0DB5 + U+0E15 + THAI CHARACTER TO TAO + Thai + + + #x0DB6 + U+0E16 + THAI CHARACTER THO THUNG + Thai + + + #x0DB7 + U+0E17 + THAI CHARACTER THO THAHAN + Thai + + + #x0DB8 + U+0E18 + THAI CHARACTER THO THONG + Thai + + + #x0DB9 + U+0E19 + THAI CHARACTER NO NU + Thai + + + #x0DBA + U+0E1A + THAI CHARACTER BO BAIMAI + Thai + + + #x0DBB + U+0E1B + THAI CHARACTER PO PLA + Thai + + + #x0DBC + U+0E1C + THAI CHARACTER PHO PHUNG + Thai + + + #x0DBD + U+0E1D + THAI CHARACTER FO FA + Thai + + + #x0DBE + U+0E1E + THAI CHARACTER PHO PHAN + Thai + + + #x0DBF + U+0E1F + THAI CHARACTER FO FAN + Thai + + + #x0DC0 + U+0E20 + THAI CHARACTER PHO SAMPHAO + Thai + + + #x0DC1 + U+0E21 + THAI CHARACTER MO MA + Thai + + + #x0DC2 + U+0E22 + THAI CHARACTER YO YAK + Thai + + + #x0DC3 + U+0E23 + THAI CHARACTER RO RUA + Thai + + + #x0DC4 + U+0E24 + THAI CHARACTER RU + Thai + + + #x0DC5 + U+0E25 + THAI CHARACTER LO LING + Thai + + + #x0DC6 + U+0E26 + THAI CHARACTER LU + Thai + + + #x0DC7 + U+0E27 + THAI CHARACTER WO WAEN + Thai + + + #x0DC8 + U+0E28 + THAI CHARACTER SO SALA + Thai + + + #x0DC9 + U+0E29 + THAI CHARACTER SO RUSI + Thai + + + #x0DCA + U+0E2A + THAI CHARACTER SO SUA + Thai + + + #x0DCB + U+0E2B + THAI CHARACTER HO HIP + Thai + + + #x0DCC + U+0E2C + THAI CHARACTER LO CHULA + Thai + + + #x0DCD + U+0E2D + THAI CHARACTER O ANG + Thai + + + #x0DCE + U+0E2E + THAI CHARACTER HO NOKHUK + Thai + + + #x0DCF + U+0E2F + THAI CHARACTER PAIYANNOI + Thai + + + #x0DD0 + U+0E30 + THAI CHARACTER SARA A + Thai + + + #x0DD1 + U+0E31 + THAI CHARACTER MAI HAN-AKAT + Thai + + + #x0DD2 + U+0E32 + THAI CHARACTER SARA AA + Thai + + + #x0DD3 + U+0E33 + THAI CHARACTER SARA AM + Thai + + + #x0DD4 + U+0E34 + THAI CHARACTER SARA I + Thai + + + #x0DD5 + U+0E35 + THAI CHARACTER SARA II + Thai + + + #x0DD6 + U+0E36 + THAI CHARACTER SARA UE + Thai + + + #x0DD7 + U+0E37 + THAI CHARACTER SARA UEE + Thai + + + #x0DD8 + U+0E38 + THAI CHARACTER SARA U + Thai + + + #x0DD9 + U+0E39 + THAI CHARACTER SARA UU + Thai + + + #x0DDA + U+0E3A + THAI CHARACTER PHINTHU + Thai + + + #x0DDF + U+0E3F + THAI CURRENCY SYMBOL BAHT + Thai + + + #x0DE0 + U+0E40 + THAI CHARACTER SARA E + Thai + + + #x0DE1 + U+0E41 + THAI CHARACTER SARA AE + Thai + + + #x0DE2 + U+0E42 + THAI CHARACTER SARA O + Thai + + + #x0DE3 + U+0E43 + THAI CHARACTER SARA AI MAIMUAN + Thai + + + #x0DE4 + U+0E44 + THAI CHARACTER SARA AI MAIMALAI + Thai + + + #x0DE5 + U+0E45 + THAI CHARACTER LAKKHANGYAO + Thai + + + #x0DE6 + U+0E46 + THAI CHARACTER MAIYAMOK + Thai + + + #x0DE7 + U+0E47 + THAI CHARACTER MAITAIKHU + Thai + + + #x0DE8 + U+0E48 + THAI CHARACTER MAI EK + Thai + + + #x0DE9 + U+0E49 + THAI CHARACTER MAI THO + Thai + + + #x0DEA + U+0E4A + THAI CHARACTER MAI TRI + Thai + + + #x0DEB + U+0E4B + THAI CHARACTER MAI CHATTAWA + Thai + + + #x0DEC + U+0E4C + THAI CHARACTER THANTHAKHAT + Thai + + + #x0DED + U+0E4D + THAI CHARACTER NIKHAHIT + Thai + + + #x0DF0 + U+0E50 + THAI DIGIT ZERO + Thai + + + #x0DF1 + U+0E51 + THAI DIGIT ONE + Thai + + + #x0DF2 + U+0E52 + THAI DIGIT TWO + Thai + + + #x0DF3 + U+0E53 + THAI DIGIT THREE + Thai + + + #x0DF4 + U+0E54 + THAI DIGIT FOUR + Thai + + + #x0DF5 + U+0E55 + THAI DIGIT FIVE + Thai + + + #x0DF6 + U+0E56 + THAI DIGIT SIX + Thai + + + #x0DF7 + U+0E57 + THAI DIGIT SEVEN + Thai + + + #x0DF8 + U+0E58 + THAI DIGIT EIGHT + Thai + + + #x0DF9 + U+0E59 + THAI DIGIT NINE + Thai + + + #x0EA1 + - + HANGUL KIYEOG + Korean + + + #x0EA2 + - + HANGUL SSANG KIYEOG + Korean + + + #x0EA3 + - + HANGUL KIYEOG SIOS + Korean + + + #x0EA4 + - + HANGUL NIEUN + Korean + + + #x0EA5 + - + HANGUL NIEUN JIEUJ + Korean + + + #x0EA6 + - + HANGUL NIEUN HIEUH + Korean + + + #x0EA7 + - + HANGUL DIKEUD + Korean + + + #x0EA8 + - + HANGUL SSANG DIKEUD + Korean + + + #x0EA9 + - + HANGUL RIEUL + Korean + + + #x0EAA + - + HANGUL RIEUL KIYEOG + Korean + + + #x0EAB + - + HANGUL RIEUL MIEUM + Korean + + + #x0EAC + - + HANGUL RIEUL PIEUB + Korean + + + #x0EAD + - + HANGUL RIEUL SIOS + Korean + + + #x0EAE + - + HANGUL RIEUL TIEUT + Korean + + + #x0EAF + - + HANGUL RIEUL PHIEUF + Korean + + + #x0EB0 + - + HANGUL RIEUL HIEUH + Korean + + + #x0EB1 + - + HANGUL MIEUM + Korean + + + #x0EB2 + - + HANGUL PIEUB + Korean + + + #x0EB3 + - + HANGUL SSANG PIEUB + Korean + + + #x0EB4 + - + HANGUL PIEUB SIOS + Korean + + + #x0EB5 + - + HANGUL SIOS + Korean + + + #x0EB6 + - + HANGUL SSANG SIOS + Korean + + + #x0EB7 + - + HANGUL IEUNG + Korean + + + #x0EB8 + - + HANGUL JIEUJ + Korean + + + #x0EB9 + - + HANGUL SSANG JIEUJ + Korean + + + #x0EBA + - + HANGUL CIEUC + Korean + + + #x0EBB + - + HANGUL KHIEUQ + Korean + + + #x0EBC + - + HANGUL TIEUT + Korean + + + #x0EBD + - + HANGUL PHIEUF + Korean + + + #x0EBE + - + HANGUL HIEUH + Korean + + + #x0EBF + - + HANGUL A + Korean + + + #x0EC0 + - + HANGUL AE + Korean + + + #x0EC1 + - + HANGUL YA + Korean + + + #x0EC2 + - + HANGUL YAE + Korean + + + #x0EC3 + - + HANGUL EO + Korean + + + #x0EC4 + - + HANGUL E + Korean + + + #x0EC5 + - + HANGUL YEO + Korean + + + #x0EC6 + - + HANGUL YE + Korean + + + #x0EC7 + - + HANGUL O + Korean + + + #x0EC8 + - + HANGUL WA + Korean + + + #x0EC9 + - + HANGUL WAE + Korean + + + #x0ECA + - + HANGUL OE + Korean + + + #x0ECB + - + HANGUL YO + Korean + + + #x0ECC + - + HANGUL U + Korean + + + #x0ECD + - + HANGUL WEO + Korean + + + #x0ECE + - + HANGUL WE + Korean + + + #x0ECF + - + HANGUL WI + Korean + + + #x0ED0 + - + HANGUL YU + Korean + + + #x0ED1 + - + HANGUL EU + Korean + + + #x0ED2 + - + HANGUL YI + Korean + + + #x0ED3 + - + HANGUL I + Korean + + + #x0ED4 + - + HANGUL JONG SEONG KIYEOG + Korean + + + #x0ED5 + - + HANGUL JONG SEONG SSANG KIYEOG + Korean + + + #x0ED6 + - + HANGUL JONG SEONG KIYEOG SIOS + Korean + + + #x0ED7 + - + HANGUL JONG SEONG NIEUN + Korean + + + #x0ED8 + - + HANGUL JONG SEONG NIEUN JIEUJ + Korean + + + #x0ED9 + - + HANGUL JONG SEONG NIEUN HIEUH + Korean + + + #x0EDA + - + HANGUL JONG SEONG DIKEUD + Korean + + + #x0EDB + - + HANGUL JONG SEONG RIEUL + Korean + + + #x0EDC + - + HANGUL JONG SEONG RIEUL KIYEOG + Korean + + + #x0EDD + - + HANGUL JONG SEONG RIEUL MIEUM + Korean + + + #x0EDE + - + HANGUL JONG SEONG RIEUL PIEUB + Korean + + + #x0EDF + - + HANGUL JONG SEONG RIEUL SIOS + Korean + + + #x0EE0 + - + HANGUL JONG SEONG RIEUL TIEUT + Korean + + + #x0EE1 + - + HANGUL JONG SEONG RIEUL PHIEUF + Korean + + + #x0EE2 + - + HANGUL JONG SEONG RIEUL HIEUH + Korean + + + #x0EE3 + - + HANGUL JONG SEONG MIEUM + Korean + + + #x0EE4 + - + HANGUL JONG SEONG PIEUB + Korean + + + #x0EE5 + - + HANGUL JONG SEONG PIEUB SIOS + Korean + + + #x0EE6 + - + HANGUL JONG SEONG SIOS + Korean + + + #x0EE7 + - + HANGUL JONG SEONG SSANG SIOS + Korean + + + #x0EE8 + - + HANGUL JONG SEONG IEUNG + Korean + + + #x0EE9 + - + HANGUL JONG SEONG JIEUJ + Korean + + + #x0EEA + - + HANGUL JONG SEONG CIEUC + Korean + + + #x0EEB + - + HANGUL JONG SEONG KHIEUQ + Korean + + + #x0EEC + - + HANGUL JONG SEONG TIEUT + Korean + + + #x0EED + - + HANGUL JONG SEONG PHIEUF + Korean + + + #x0EEE + - + HANGUL JONG SEONG HIEUH + Korean + + + #x0EEF + - + HANGUL RIEUL YEORIN HIEUH + Korean + + + #x0EF0 + - + HANGUL SUNKYEONGEUM MIEUM + Korean + + + #x0EF1 + - + HANGUL SUNKYEONGEUM PIEUB + Korean + + + #x0EF2 + - + HANGUL PAN SIOS + Korean + + + #x0EF3 + - + HANGUL KKOGJI DALRIN IEUNG + Korean + + + #x0EF4 + - + HANGUL SUNKYEONGEUM PHIEUF + Korean + + + #x0EF5 + - + HANGUL YEORIN HIEUH + Korean + + + #x0EF6 + - + HANGUL ARAE A + Korean + + + #x0EF7 + - + HANGUL ARAE AE + Korean + + + #x0EF8 + - + HANGUL JONG SEONG PAN SIOS + Korean + + + #x0EF9 + - + HANGUL JONG SEONG KKOGJI DALRIN IEUNG + Korean + + + #x0EFA + - + HANGUL JONG SEONG YEORIN HIEUH + Korean + + + #x0EFF + - + KOREAN WON + Korean + + + #x13BC + U+0152 + LATIN CAPITAL LIGATURE OE + Latin-9 + + + #x13BD + U+0153 + LATIN SMALL LIGATURE OE + Latin-9 + + + #x13BE + U+0178 + LATIN CAPITAL LETTER Y WITH DIAERESIS + Latin-9 + + + #x20A0 + - + CURRENCY ECU SIGN + Currency + + + #x20A1 + - + CURRENCY COLON SIGN + Currency + + + #x20A2 + - + CURRENCY CRUZEIRO SIGN + Currency + + + #x20A3 + - + CURRENCY FRENCH FRANC SIGN + Currency + + + #x20A4 + - + CURRENCY LIRA SIGN + Currency + + + #x20A5 + - + CURRENCY MILL SIGN + Currency + + + #x20A6 + - + CURRENCY NAIRA SIGN + Currency + + + #x20A7 + - + CURRENCY PESETA SIGN + Currency + + + #x20A8 + - + CURRENCY RUPEE SIGN + Currency + + + #x20A9 + - + CURRENCY WON SIGN + Currency + + + #x20AA + - + CURRENCY NEW SHEQEL SIGN + Currency + + + #x20AB + - + CURRENCY DONG SIGN + Currency + + + #x20AC + U+20AC + CURRENCY EURO SIGN + Currency + + + + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xproto/sect1-9.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xproto/sect1-9.xml new file mode 100644 index 0000000000000000000000000000000000000000..c59def1f85fad481b20735efa71699ac93587bf4 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xproto/sect1-9.xml @@ -0,0 +1,15309 @@ + + +Acknowledgements + +The primary contributors to the X11 protocol are: + + + +Dave Carver (Digital HPW) +Branko Gerovac (Digital HPW) +Jim Gettys (MIT/Project Athena, Digital) +Phil Karlton (Digital WSL) +Scott McGregor (Digital SSG) +Ram Rao (Digital UEG) +David Rosenthal (Sun) +Dave Winchell (Digital UEG) + + + +The implementors of initial server who provided useful +input are: + + + +Susan Angebranndt (Digital) +Raymond Drewry (Digital) +Todd Newman (Digital) + + + +The invited reviewers who provided useful input are: + + + +Andrew Cherenson (Berkeley) +Burns Fisher (Digital) +Dan Garfinkel (HP) +Leo Hourvitz (Next) +Brock Krizan (HP) +David Laidlaw (Stellar) +Dave Mellinger (Interleaf) +Ron Newman (MIT) +John Ousterhout (Berkeley) +Andrew Palay (ITC CMU) +Ralph Swick (MIT) +Craig Taylor (Sun) +Jeffery Vroom (Stellar) + + + +Thanks go to Al Mento of Digital's UEG Documentation Group for +formatting this document. + + + +This document does not attempt to provide the rationale or pragmatics required +to fully understand the protocol or to place it in perspective within a +complete system. + + + +The protocol contains many management mechanisms that are not intended for +normal applications. +Not all mechanisms are needed to build a particular user interface. +It is important to keep in mind that the protocol is intended to +provide mechanism, not policy. + + + +Robert W. Scheifler + + +X Consortium, Inc. + + + + + Protocol Formats + +
+ Request Format + Requestformat + +Every request contains an 8-bit major opcode +Opcodemajor +and a 16-bit length field +Requestlength +expressed in units of four bytes. +Every request consists of four bytes of a header +(containing the major opcode, the length field, and a data byte) +followed by zero or more additional bytes of data. +The length field defines the total length of the request, including the header. +The length field in a request must equal the minimum length required to contain +the request. +If the specified length is smaller or larger than the required length, +an error is generated. +Unused bytes in a request are not required to be zero. +Major opcodes 128 through 255 are reserved for +extensions. +Extension +Extensions are intended to contain multiple requests, +so extension requests typically have an additional +minor opcode encoded +in the second data byte in the request header. +Opcodeminor +However, the placement and interpretation of this minor opcode and of all +other fields in extension requests are not defined by the core protocol. +Every request on a given connection is implicitly assigned a +sequence number, +Sequence number +starting with one, that is used in replies, errors, and events. + +
+ +
+ Reply Format + Replyformat + +Every reply contains a 32-bit length field +expressed in units of four bytes. +Every reply consists of 32 bytes followed by zero or more additional bytes of +data, as specified in the length field. +Unused bytes within a reply are not guaranteed to be zero. +Every reply also contains the least significant 16 bits of the sequence number +of the corresponding request. + +
+ +
+ Error Format + Error reportformat + +Error reports are 32 bytes long. +Every error includes an 8-bit error code. + +Error codes 128 through 255 are reserved for extensions. + +Error Codesextensions +Extensionerror codes +Every error also includes the major and minor opcodes of the failed request +and the least significant 16 bits of the sequence number of the request. +For the following errors (see section 4), +the failing resource ID is also returned: +Colormap, +Cursor, +Drawable, +Font, +GContext, +IDChoice, +Pixmap +and +Window. +For +Atom +errors, the failing atom is returned. +For +Value +errors, the failing value is returned. +Other core errors return no additional data. +Unused bytes within an error are not guaranteed to be zero. + +
+ +
+ Event Format + Eventformat + +Events are 32 bytes long. +Unused bytes within an event are not guaranteed to be zero. +Every event contains an 8-bit type code. +The most significant bit in this code is set if the event was generated from a +SendEvent +request. + +Event codes 64 through 127 are reserved for extensions, although the core +protocol does not define a mechanism for selecting interest in such events. + +Eventextension +Extensionevent +Every core event (with the exception of +KeymapNotify) +also contains the least significant 16 bits of the sequence number of the last +request issued by the client that was (or is currently being) processed by +the server. + +
+ + + +Syntactic Conventions + + + + + +The rest of this document uses the following syntactic conventions. + + + + +The syntax {...} encloses a set of alternatives. + + + + +The syntax [...] encloses a set of structure components. + + + + +In general, TYPEs are in uppercase and +AlternativeValues +are capitalized. + + + + +Requests in section 9 are described +in the following format: + +RequestName + arg1: type1 + ... + argN: typeN + ▶ + result1: type1 + ... + resultM: typeM + + Errors: kind1, ..., kindK + + Description. + + + +If no ▶ is present in the description, +then the request has no reply (it is asynchronous), +although errors may still be reported. +If ▶+ is used, +then one or more replies can be generated for a single request. + + + + +Events in section 11 are described +in the following format: + +EventName + value1: type1 + ... + valueN: typeN + + Description. + + + + + + + +Common Types + + + + + + + + + + Name + Value + + + + + LISTofFOOTypesLISTofFOO + + +A type name of the form LISTofFOO means a counted list of elements of type +FOO. +The size of the length field may vary (it is not necessarily the same +size as a FOO), and in some cases, it may be implicit. +It is fully specified in Appendix B. +Except where explicitly noted, +zero-length lists are legal. + + + + BITMASKTypesBITMASKLISTofVALUETypesLISTofVALUE + + +The types BITMASK and LISTofVALUE are somewhat special. +Various requests contain arguments of the form: + + +value-mask: BITMASK + + +value-list: LISTofVALUE + + +These are used to allow the client to specify a subset of a heterogeneous +collection of optional arguments. +The value-mask specifies which arguments are to be provided; +each such argument is assigned a unique bit position. +The representation of the BITMASK will typically contain more bits than +there are defined arguments. +The unused bits in the value-mask must be zero (or the server generates a +Value +error). +The value-list contains one value for each bit set to 1 in the mask, +from least significant to most significant bit in the mask. +Each value is represented with four bytes, +but the actual value occupies only the least significant bytes as required. +The values of the unused bytes do not matter. + + + + + ORTypesOR + +A type of the form "T1 or ... or Tn" means the union of the indicated types. +A single-element type is given as the element without enclosing braces. + + + + WINDOWTypesWINDOW + 32-bit value (top three bits guaranteed to be zero) + + + PIXMAPTypesPIXMAP + 32-bit value (top three bits guaranteed to be zero) + + + CURSORTypesCURSOR + 32-bit value (top three bits guaranteed to be zero) + + + FONTTypesFONT + 32-bit value (top three bits guaranteed to be zero) + + + GCONTEXTTypesGCONTEXT + 32-bit value (top three bits guaranteed to be zero) + + + COLORMAPTypesCOLORMAP + 32-bit value (top three bits guaranteed to be zero) + + + DRAWABLETypesDRAWABLE + WINDOW or PIXMAP + + + FONTABLETypesFONTABLE + FONT or GCONTEXT + + + ATOMTypesATOM + 32-bit value (top three bits guaranteed to be zero) + + + VISUALIDTypesVISUALID + 32-bit value (top three bits guaranteed to be zero) + + + VALUETypesVALUE + 32-bit quantity (used only in LISTofVALUE) + + + BYTETypesBYTE + 8-bit value + + + INT8TypesINT8 + 8-bit signed integer + + + INT16TypesINT16 + 16-bit signed integer + + + INT32TypesINT32 + 32-bit signed integer + + + CARD8TypesCARD8 + 8-bit unsigned integer + + + CARD16TypesCARD16 + 16-bit unsigned integer + + + CARD32TypesCARD32 + 32-bit unsigned integer + + + TIMESTAMPTypesTIMESTAMP + CARD32 + + + BITGRAVITYTypesBITGRAVITY + +{ Forget, +Static, +NorthWest, +North, +NorthEast, +West, +Center, +East, +SouthWest, +South, +SouthEast } + + + + WINGRAVITYTypesWINGRAVITY + +{ Unmap, +Static, +NorthWest, +North, +NorthEast, +West, +Center, +East, +SouthWest, +South, +SouthEast } + + + + BOOLTypesBOOL + +{ True, +False } + + + + EVENTTypesEVENT + +{ KeyPress, +KeyRelease, +OwnerGrabButton, +ButtonPress, +ButtonRelease, +EnterWindow, +LeaveWindow, +PointerMotion, +PointerMotionHint, +Button1Motion, +Button2Motion, +Button3Motion, +Button4Motion, +Button5Motion, +ButtonMotion, +Exposure, +VisibilityChange, +StructureNotify, +ResizeRedirect, +SubstructureNotify, +SubstructureRedirect, +FocusChange, +PropertyChange, +ColormapChange, +KeymapState } + + + + POINTEREVENTTypesPOINTEREVENT + +{ ButtonPress, +ButtonRelease, +EnterWindow, +LeaveWindow, +PointerMotion, +PointerMotionHint, +Button1Motion, +Button2Motion, +Button3Motion, +Button4Motion, +Button5Motion, +ButtonMotion, +KeymapState } + + + + DEVICEEVENTTypesDEVICEEVENT + +{ KeyPress, +KeyRelease, +ButtonPress, +ButtonRelease, +PointerMotion, +Button1Motion, +Button2Motion, +Button3Motion, +Button4Motion, +Button5Motion, +ButtonMotion } + + + + KEYSYMTypesKEYSYM + 32-bit value (top three bits guaranteed to be zero) + + + KEYCODETypesKEYCODE + CARD8 + + + BUTTONTypesBUTTON + CARD8 + + + KEYMASKTypesKEYMASK + +{ Shift, +Lock, +Control, +Mod1, +Mod2, +Mod3, +Mod4, +Mod5 } + + + + BUTMASKTypesBUTMASK + +{ Button1, +Button2, +Button3, +Button4, +Button5 } + + + + KEYBUTMASKTypesKEYBUTMASK + KEYMASK or BUTMASK + + + STRING8TypesSTRING8 + LISTofCARD8 + + + STRING16TypesSTRING16 + LISTofCHAR2B + + + CHAR2BTypesCHAR2B + [byte1, byte2: CARD8] + + + POINTTypesPOINT + [x, y: INT16] + + + RECTANGLETypesRECTANGLE + +[x, y: INT16, +width, height: CARD16] + + + + ARCTypesARC + +[x, y: INT16, +width, height: CARD16, +angle1, angle2: INT16] + + + + HOSTTypesHOST + + +[family: +{ Internet, +InternetV6, +ServerInterpreted, +DECnet, +Chaos } + +address: LISTofBYTE] + + + + + + + +The [x,y] coordinates of a RECTANGLE specify the upper-left corner. + + + +The primary interpretation of large characters in a STRING16 is that they +are composed of two bytes used to index a two-dimensional matrix, +hence, the use of CHAR2B rather than CARD16. +This corresponds to the JIS/ISO method of indexing 2-byte characters. +It is expected that most large fonts will be defined with 2-byte +matrix indexing. +For large fonts constructed with linear indexing, +a CHAR2B can be interpreted as a 16-bit number by treating byte1 as +the most significant byte. +This means that clients should always transmit such +16-bit character values most significant byte first, as the server will never +byte-swap CHAR2B quantities. + + + +The length, format, and interpretation of a HOST address are specific to the +family (see +ChangeHosts +request). + + + + +Errors + + + + + +In general, when a request terminates with an error, +the request has no side effects (that is, there is no partial execution). +The only requests for which this is not true are +ChangeWindowAttributes, +ChangeGC, +PolyText8, +PolyText16, +FreeColors, +StoreColors +and +ChangeKeyboardControl. + + + +The following error codes result from various requests as follows: + + + + + + + + + Error + Description + + + + + AccessError CodesAccess + +An attempt is made to grab a key/button combination already grabbed by another +client. +An attempt is made to free a colormap entry not allocated by the client +or to free an entry in a colormap that was created with all entries writable. +An attempt is made to store into a read-only or an unallocated colormap entry. +An attempt is made to modify the access control list from other than the local +host (or otherwise authorized client). +An attempt is made to select an event type that only one client can +select at a time when another client has already selected it. + + + + AllocError CodesAlloc + +The server failed to allocate the requested resource. +Note that the explicit listing of +Alloc +errors in request only covers allocation errors at a very coarse level +and is not intended to cover all cases +of a server running out of allocation space in the middle of service. +The semantics when a server runs out of allocation space are left unspecified, +but a server may generate an +Alloc +error on any request for this reason, +and clients should be prepared to receive such errors and handle +or discard them. + + + + AtomError CodesAtom + +A value for an ATOM argument does not name a defined ATOM. + + + + ColormapError CodesColormap + +A value for a COLORMAP argument does not name a defined COLORMAP. + + + + CursorError CodesCursor + +A value for a CURSOR argument does not name a defined CURSOR. + + + + DrawableError CodesDrawable + +A value for a DRAWABLE argument does not name a defined WINDOW +or PIXMAP. + + + + FontError CodesFont + +A value for a FONT argument does not name a defined FONT. +A value for a FONTABLE argument does not name a defined FONT or a +defined GCONTEXT. + + + + GContextError CodesGContext + +A value for a GCONTEXT argument does not name a defined GCONTEXT. + + + + IDChoiceError CodesIDChoice + +The value chosen for a resource identifier either is not included +in the range assigned to the client or is already in use. + + + + ImplementationError CodesImplementation + +The server does not implement some aspect of the request. +A server that generates this error for a core request is deficient. +As such, this error is not listed for any of the requests, +but clients should be prepared to receive such errors +and handle or discard them. + + + + LengthError CodesLength + +The length of a request is shorter or longer than that required +to minimally contain the arguments. +The length of a request exceeds the maximum length accepted by the +server. + + + + MatchError CodesMatch + +An +InputOnly +window is used as a DRAWABLE. +In a graphics request, the GCONTEXT argument does not have the same +root and depth as the destination DRAWABLE argument. +Some argument (or pair of arguments) has the correct type and range, +but it fails to match in some other way required by the request. + + + + NameError CodesName + +A font or color of the specified name does not exist. + + + + PixmapError CodesPixmap + +A value for a PIXMAP argument does not name a defined PIXMAP. + + + + RequestError CodesRequest + +The major or minor opcode does not specify a valid request. + + + + ValueError CodesValue + +Some numeric value falls outside the range of values accepted by the request. +Unless a specific range is specified for an argument, +the full range defined by the argument's type is accepted. +Any argument defined as a set of alternatives typically can generate +this error (due to the encoding). + + + + WindowError CodesWindow + +A value for a WINDOW argument does not name a defined WINDOW. + + + + + + + +The +Atom, +Colormap, +Cursor, +Drawable, +Font, +GContext, +Pixmap +and +Window +errors are also used when the argument type is extended by union with a +set of fixed alternatives, for example, <WINDOW or +PointerRoot +or +None>. + + + + +Keyboards +Keyboard + + + + +A KEYCODE represents a physical (or logical) key. +TypesKEYCODE +Keycode +Keycodes lie in the inclusive range [8,255]. +A keycode value carries no intrinsic information, +although server implementors may attempt to encode geometry information +(for example, matrix) to be interpreted in a server-dependent fashion. +The mapping between keys and keycodes cannot be changed using the +protocol. + + +A KEYSYM is an encoding of a symbol on the cap of a key. +TypesKEYSYM +Keysym +The set of defined KEYSYMs include the character sets Latin-1, Latin-2, +Latin-3, Latin-4, Kana, Arabic, Cyrillic, Greek, Tech, Special, Publish, APL, +Hebrew, Thai, and Korean as well as a set of symbols common on keyboards +(Return, Help, Tab, +and so on). +KEYSYMs with the most significant bit (of the 29 bits) set are reserved +as vendor-specific. + + +A list of KEYSYMs is associated with each KEYCODE. +The list is intended to convey the set of symbols on the corresponding key. +If the list (ignoring trailing +NoSymbol +entries) is a single KEYSYM "K", +then the list is treated as if it were +the list "K NoSymbol +K NoSymbol". +If the list (ignoring trailing NoSymbol entries) +is a pair of KEYSYMs +"K1 K2", then the list is treated as +if it were the list +"K1 K2 K1 K2". +If the list (ignoring trailing +NoSymbol +entries) is +a triple of KEYSYMs "K1 K2 K3", +then the list is treated as if it were the list " +K1 K2 K3 NoSymbol". +When an explicit "void" element is desired in the list, +the value +VoidSymbol +can be used. + + + +The first four elements of the list are split into two groups of KEYSYMs. +Group 1 contains the first and second KEYSYMs, Group 2 contains the third and +fourth KEYSYMs. +Within each group, +if the second element of the group is +NoSymbol, +then the group should be treated as if the second element were the +same as the first element, except when the first element is an alphabetic +KEYSYM "K" for which both lowercase +and uppercase forms are defined. +In that case, the group should be treated as if the first element were the +lowercase form of "K" and the second +element were the uppercase form +of "K". + + + +The standard rules for obtaining a KEYSYM from a +KeyPress +KeyPress +event make use of only the Group 1 and Group 2 KEYSYMs; no interpretation of +other KEYSYMs in the list is defined. The modifier state determines which +group to use. Switching between groups is controlled by the KEYSYM named +MODE SWITCH, by attaching that KEYSYM to some KEYCODE and attaching that +KEYCODE to any one of the modifiers +Mod1 +through +Mod5. +This modifier is +modifiergroup +called the "group modifier". For any KEYCODE, Group 1 is used when the +group modifier is off, and Group 2 is used when the group modifier is on. + + + +The +Lock +modifierLock +modifier is interpreted as CapsLock when the KEYSYM named CAPS +LOCK is attached to some KEYCODE and that KEYCODE is attached to the +Lock +modifier. The +Lock +modifier is interpreted as ShiftLock when the KEYSYM +named SHIFT LOCK is attached to some KEYCODE and that KEYCODE is attached +to the +Lock +modifier. If the +Lock +modifier could be interpreted as both +CapsLock and ShiftLock, the CapsLock interpretation is used. + + + + +The operation of "keypad" keys is controlled by the KEYSYM named NUM LOCK, +by attaching that KEYSYM to some KEYCODE and attaching that KEYCODE to any +one of the modifiers +Mod1 +through +Mod5. +This modifier is called the +modifierNumLock +"numlock modifier". The standard KEYSYMs with the prefix KEYPAD in their +name are called "keypad" KEYSYMs; these are KEYSYMS with numeric value in +the hexadecimal range #xFF80 to #xFFBD inclusive. In addition, +vendor-specific KEYSYMS in the hexadecimal range #x11000000 to #x1100FFFF +are also keypad KEYSYMs. + + + +Within a group, the choice of KEYSYM is determined by applying the first +rule that is satisfied from the following list: + + + + + +The numlock modifier is on and the second KEYSYM is a keypad KEYSYM. In +this case, if the +Shift +modifier is on, or if the +Lock +modifier is on and +is interpreted as ShiftLock, then the first KEYSYM is used; otherwise, the +second KEYSYM is used. + + + + +The +Shift +and +Lock +modifiers are both off. In this case, the first +KEYSYM is used. + + + + +The +Shift +modifier is off, and the +Lock +modifier is on and is +interpreted as CapsLock. In this case, the first KEYSYM is used, but if +that KEYSYM is lowercase alphabetic, then the corresponding uppercase +KEYSYM is used instead. + + + + +The +Shift +modifier is on, and the +Lock +modifier is on and is interpreted +as CapsLock. In this case, the second KEYSYM is used, but if that KEYSYM +is lowercase alphabetic, then the corresponding uppercase KEYSYM is used +instead. + + + + +The +Shift +modifier is on, or the +Lock +modifier is on and is interpreted +as ShiftLock, or both. In this case, the second KEYSYM is used. + + + + + + +The mapping between KEYCODEs and KEYSYMs is not used directly by the server; +it is merely stored for reading and writing by clients. + + + + +Pointers + + + + +Buttons are always numbered starting with one. +Buttonnumber + + + + +Predefined Atoms + + + + + +Atompredefined +Predefined atoms are not strictly necessary and may not be useful in all +environments, but they will eliminate many +InternAtom +requests in most applications. +Note that they are predefined only in the sense of having numeric values, +not in the sense of having required semantics. +The core protocol imposes no semantics on these names, +but semantics are specified in other X Window System standards, +such as the +Inter-Client Communication Conventions Manual +and the X Logical Font Description Conventions. + + + +The following names have predefined atom values. +Note that uppercase and lowercase matter. + + + + ARC + ATOM + BITMAP + CAP_HEIGHT + CARDINAL + COLORMAP + COPYRIGHT + CURSOR + CUT_BUFFER0 + CUT_BUFFER1 + CUT_BUFFER2 + CUT_BUFFER3 + CUT_BUFFER4 + CUT_BUFFER5 + CUT_BUFFER6 + CUT_BUFFER7 + DRAWABLE + END_SPACE + FAMILY_NAME + FONT + FONT_NAME + FULL_NAME + INTEGER + ITALIC_ANGLE + MAX_SPACE + MIN_SPACE + NORM_SPACE + NOTICE + PIXMAP + POINT + POINT_SIZE + PRIMARY + QUAD_WIDTH + RECTANGLE + RESOLUTION + RESOURCE_MANAGER + RGB_BEST_MAP + RGB_BLUE_MAP + RGB_COLOR_MAP + RGB_DEFAULT_MAP + RGB_GRAY_MAP + RGB_GREEN_MAP + RGB_RED_MAP + SECONDARY + STRIKEOUT_ASCENT + STRIKEOUT_DESCENT + STRING + SUBSCRIPT_X + SUBSCRIPT_Y + SUPERSCRIPT_X + SUPERSCRIPT_Y + UNDERLINE_POSITION + UNDERLINE_THICKNESS + VISUALID + WEIGHT + WINDOW + WM_CLASS + WM_CLIENT_MACHINE + WM_COMMAND + WM_HINTS + WM_ICON_NAME + WM_ICON_SIZE + WM_NAME + WM_NORMAL_HINTS + WM_SIZE_HINTS + WM_TRANSIENT_FOR + WM_ZOOM_HINTS + X_HEIGHT + + + + +To avoid conflicts with possible future names for which semantics might be +imposed (either at the protocol level or in terms of higher level user +interface models), +names beginning with an underscore should be used for atoms +that are private to a particular vendor or organization. +To guarantee no conflicts between vendors and organizations, +additional prefixes need to be used. +However, the protocol does not define the mechanism for choosing such prefixes. +For names private to a single application or end user but stored in globally +accessible locations, +it is suggested that two leading underscores be used to avoid conflicts with +other names. + + + + + Connection Setup + Connection + + +For remote clients, +the X protocol can be built on top of any reliable byte stream. + + +
+ Connection Initiation + Connectionopening + + +The client must send an initial byte of data to identify the byte order to be +employed. +Byte order +The value of the byte must be octal 102 or 154. +The value 102 (ASCII uppercase B) means values are transmitted most significant +byte first, and value 154 (ASCII lowercase l) means values are transmitted +least significant byte first. +Except where explicitly noted in the protocol, +all 16-bit and 32-bit quantities sent by the client must be transmitted with +this byte order, +and all 16-bit and 32-bit quantities returned by the server will be transmitted +with this byte order. + + +Following the byte-order byte, +the client sends the following information at connection setup: + +
+ +protocol-major-version: CARD16 + + +protocol-minor-version: CARD16 + + +authorization-protocol-name: STRING8 + + +authorization-protocol-data: STRING8 + +
+ +The version numbers indicate what version of the protocol the client +expects the server to implement. + + +The authorization name indicates what authorization (and authentication) +protocol the client +expects the server to use, and the data is specific to that protocol. +Authorization +Specification of valid authorization mechanisms is not part of the core +X protocol. +A server that does not implement the protocol the client expects +or that only implements the host-based mechanism may simply ignore this +information. +If both name and data strings are empty, +this is to be interpreted as "no explicit authorization." + +
+ +
+ Server Response + + +The client receives the following information at connection setup: + + + + + +success: +{ Failed, +Success, +Authenticate} + + + + + +The client receives the following additional data if the returned success +value is +Failed, +and the connection is not successfully established: + + +
+ +protocol-major-version: CARD16 + + +protocol-minor-version: CARD16 + + +reason: STRING8 + +
+ + +The client receives the following additional data if the returned success +value is +Authenticate, +and further authentication negotiation is required: + + +
+ +reason: STRING8 + +
+ + +The contents of the reason string are specific to the authorization +protocol in use. The semantics of this authentication negotiation are +not constrained, except that the negotiation must eventually terminate +with a reply from the server containing a success value of +Failed +or +Success. + + + +The client receives the following additional data if the returned success +value is +Success, +and the connection is successfully established: + + +
+ +protocol-major-version: CARD16 + + + +protocol-minor-version: CARD16 + + + +vendor: STRING8 + + + +release-number: CARD32 + + + +resource-id-base, resource-id-mask: CARD32 + + + +image-byte-order: +{ LSBFirst, +MSBFirst } + + + +bitmap-scanline-unit: {8, 16, 32} + + + +bitmap-scanline-pad: {8, 16, 32} + + + +bitmap-bit-order: +{ LeastSignificant, +MostSignificant } + + + +pixmap-formats: LISTofFORMAT + + + +roots: LISTofSCREEN + + + +motion-buffer-size: CARD32 + + + +maximum-request-length: CARD16 + + + +min-keycode, max-keycode: KEYCODE + + +where: + +
+ + + + + + + FORMAT: + [depth: CARD8, + + + + +bits-per-pixel: {1, 4, 8, 16, 24, 32} + + + + + +scanline-pad: {8, 16, 32}] + + + + SCREEN: + [root: WINDOW + + + + width-in-pixels, height-in-pixels: CARD16 + + + + width-in-millimeters, height-in-millimeters: CARD16 + + + + allowed-depths: LISTofDEPTH + + + + root-depth: CARD8 + + + + root-visual: VISUALID + + + + default-colormap: COLORMAP + + + + white-pixel, black-pixel: CARD32 + + + + min-installed-maps, max-installed-maps: CARD16 + + + + backing-stores: {Never, WhenMapped, Always} + + + + save-unders: BOOL + + + + current-input-masks: SETofEVENT] + + + DEPTH: + [depth: CARD8 + + + + visuals: LISTofVISUALTYPE] + + + VISUALTYPE: + [visual-id: VISUALID + + + + +class: {StaticGray, StaticColor, TrueColor, GrayScale, +PseudoColor, DirectColor} + + + + + red-mask, green-mask, blue-mask: CARD32 + + + + bits-per-rgb-value: CARD8 + + + + colormap-entries: CARD16] + + + + +
+
+
+ +
+ Server Information + + +The information that is global to the server is: + + + +The protocol version numbers are an escape hatch in case future revisions of +the protocol are necessary. +In general, +the major version would increment for incompatible changes, +and the minor version would increment for small upward compatible changes. +Barring changes, +the major version will be 11, and the minor version will be 0. +The protocol version numbers returned indicate the protocol the server +actually supports. +This might not equal the version sent by the client. +The server can (but need not) refuse connections from clients that offer a +different version than the server supports. +A server can (but need not) support more than one version simultaneously. + + +The vendor string gives some identification of the owner of the server +implementation. +The vendor controls the semantics of the release number. + + +The resource-id-mask contains a single contiguous set of bits (at least 18). +The client allocates resource IDs for types WINDOW, PIXMAP, +CURSOR, FONT, GCONTEXT, and COLORMAP by choosing a value with only +some subset of these bits set and ORing it with resource-id-base. +ResourceID +Only values constructed in this way can be used to name newly created +resources over this connection. +Resource IDs never have the top three bits set. +The client is not restricted to linear or contiguous allocation +of resource IDs. +Once an ID has been freed, +it can be reused. +An ID must be unique with respect to the IDs of all other resources, +not just other resources of the same type. +However, note that the value spaces of resource identifiers, +atoms, visualids, and keysyms are distinguished by context, and +as such, are not required to be disjoint; for example, a given numeric value +might be both a valid window ID, a valid atom, and a valid keysym. + + +Although the server is in general responsible for byte-swapping data to +match the client, +images are always transmitted and received in formats (including byte order) +specified by the server. +The byte order for images is given by image-byte-order and applies to each +scanline unit in XY format (bitmap format) and to each pixel value in Z format. + + +A bitmap is represented in scanline order. +Bitmapformat +Each scanline +is padded to a multiple of bits as given by bitmap-scanline-pad. +The pad bits are of arbitrary value. +The scanline is quantized in multiples of bits as given by bitmap-scanline-unit. +The bitmap-scanline-unit is always less than or equal to the +bitmap-scanline-pad. +Within each unit, +the leftmost bit in the bitmap is either the least significant +or most significant bit in the unit, as given by bitmap-bit-order. +XYFormat +If a pixmap is represented in XY format, +each plane is represented as a bitmap, and the planes appear from +most significant to least significant in bit order with no padding +between planes. + + +Pixmap-formats contains one entry for each +depth value. +Pixmapformat +ZFormat +The entry describes the Z format +used to represent images of that depth. +An entry for a depth is included if any screen supports that depth, +and all screens supporting that depth must support only that Z format for that +depth. +In Z format, +the pixels are in scanline order, left to right within a scanline. +The number of bits used to hold each pixel is given by bits-per-pixel. +Bits-per-pixel may be larger than strictly required by the depth, +in which case the least significant bits are used to hold +the pixmap data, and the values of the unused high-order bits are +undefined. +When the bits-per-pixel is 4, +the order of nibbles in the byte is the same as the image byte-order. +When the bits-per-pixel is 1, +the format is identical for bitmap format. +Each scanline is padded to a multiple of bits as given by scanline-pad. +When bits-per-pixel is 1, +this will be identical to bitmap-scanline-pad. + + +How a pointing device roams the screens is up to the server +implementation and is transparent to the protocol. +No geometry is defined among screens. + + +The server may retain the recent history of pointer motion and do so to a +finer granularity than is reported by +MotionNotify +events. +The +GetMotionEvents +request makes such history available. +The motion-buffer-size gives the approximate maximum number +of elements in the history buffer. + + +Maximum-request-length specifies the maximum length of a request +accepted by the server, in 4-byte units. +Requestlength +That is, length is the maximum value that can appear in the length field of a +request. +Requests larger than this maximum generate a +Length +error, +and the server will read and simply discard the entire request. +Maximum-request-length will always be at least 4096 +(that is, requests of length up to and including 16384 bytes +will be accepted by all servers). + + +TypesKEYCODE +Keycode +Min-keycode and max-keycode specify the smallest and largest keycode +values transmitted by the server. +Min-keycode is never less than 8, +and max-keycode is never greater than 255. +Not all keycodes in this range are required to have corresponding keys. + +
+ +
+ Screen Information + Screen + + +The information that applies per screen is: + + + +The allowed-depths specifies what pixmap and window depths are supported. +Pixmaps are supported for each depth listed, +and windows of that depth are supported if at least one visual type is listed +for the depth. +A pixmap depth of one is always supported and listed, +but windows of depth one might not be supported. +A depth of zero is never listed, +but zero-depth +InputOnly +windows are always supported. + + +Root-depth and root-visual specify the depth and visual type of the +root window. +Width-in-pixels and height-in-pixels specify the size of +the root window (which cannot be changed). +The class of the root window is always +InputOutput. +Width-in-millimeters and height-in-millimeters can be used to determine the +physical size and the aspect ratio. + + +The default-colormap is the one initially associated with the root window. +Clients with minimal color requirements creating windows of +the same depth as the root may want to allocate from this map by +default. + + +Black-pixel and white-pixel can be used in implementing a monochrome +application. +These pixel values are for permanently allocated entries in the +default-colormap. +The actual RGB values may be settable on some screens +and, in any case, may not actually be black and white. +The names are intended to convey the expected relative intensity of the colors. + + +The border of the root window is initially a pixmap filled with the black-pixel. +The initial background of the root window is a pixmap filled with some +unspecified two-color pattern using black-pixel and white-pixel. + + +Min-installed-maps specifies the number of maps that can be guaranteed +to be installed simultaneously (with +InstallColormap), +regardless of the number of entries allocated in each map. +Max-installed-maps specifies the maximum number of maps that might possibly be +installed simultaneously, depending on their allocations. +Multiple static-visual colormaps with identical contents but differing in +resource ID should be considered as a single map for the purposes of this +number. +For the typical case of a single hardware colormap, both values will be 1. + + +Backing store +Backing-stores indicates when the server supports backing stores for +this screen, although it may be storage limited in the number of +windows it can support at once. +If save-unders is +True, +the server can support the save-under mode in +CreateWindow +and +ChangeWindowAttributes, +although again it may be storage limited. + + +The current-input-events is what +GetWindowAttributes +would return for the all-event-masks for the root window. + +
+ +
+ Visual Information + Visualinformation + + +The information that applies per visual-type is: + + + +A given visual type might be listed for more than one depth or for +more than one screen. + + + +Colormaptypes +Pixel value +For +PseudoColor, +a pixel value indexes a colormap to produce independent RGB values; +the RGB values can be changed dynamically. +GrayScale +is treated in the same way as +PseudoColor +except which primary drives the screen is undefined; +thus, the client should always store the +same value for red, green, and blue in colormaps. +For +DirectColor, +a pixel value is decomposed into separate RGB subfields, +and each subfield separately indexes the colormap for the corresponding value. +The RGB values can be changed dynamically. +TrueColor +is treated in the same way as +DirectColor +except the colormap has predefined read-only RGB values. +These values are server-dependent but provide linear or near-linear +increasing ramps in each primary. +StaticColor +is treated in the same way as +PseudoColor +except the colormap has predefined read-only RGB values, +which are server-dependent. +StaticGray +is treated in the same way as +StaticColor +except the red, green, and blue values are equal for any +single pixel value, resulting in shades of gray. +StaticGray +with a two-entry colormap can be thought of as monochrome. + + + +The red-mask, green-mask, and blue-mask are only defined for +DirectColor +and +TrueColor. +Each has one contiguous set of bits set to 1 with no intersections. +Usually each mask has the same number of bits set to 1. + + + +The bits-per-rgb-value specifies the log base 2 of the number of +distinct color intensity values (individually) of red, green, and blue. +This number need not bear any relation to the number of colormap entries. +Actual RGB values are always passed in the protocol within a +16-bit spectrum, with 0 being minimum intensity and 65535 being the +maximum intensity. +On hardware that provides a linear zero-based intensity ramp, +the following relationship exists: + + + + + hw-intensity = protocol-intensity / (65536 / total-hw-intensities) + + + + +Colormap entries are indexed from 0. +The colormap-entries defines the number of available colormap entries in a +newly created colormap. +For +DirectColor +and +TrueColor, +this will usually be 2 to the power of the maximum number of bits set to 1 in +red-mask, green-mask, and blue-mask. + +
+ + + + Requests +
+ CreateWindow + CreateWindow + + + + + + + + +wid, parent: WINDOW + + + + +class: +{ InputOutput, +InputOnly, +CopyFromParent} + + + + +depth: CARD8 + + + + +visual: VISUALID or +CopyFromParent + + + + +x, y: INT16 + + + + +width, height, border-width: CARD16 + + + + +value-mask: BITMASK + + + + +value-list: LISTofVALUE + + + + + + +Errors: +Alloc, +Colormap, +Cursor, +IDChoice, +Match, +Pixmap, +Value, +Window + + + + + + + + + +This request creates an unmapped window and assigns the identifier wid to it. + + +A class of +CopyFromParent +means the class is taken from the parent. +A depth of zero for class +InputOutput +or +CopyFromParent +means the depth is taken from the parent. +A visual of +CopyFromParent +means the visual type is taken from the parent. +For class +InputOutput, +the visual type and depth must be a combination supported for the screen +(or a +Match +error results). +The depth need not be the same as the parent, +but the parent must not be of class +InputOnly +(or a +Match +error results). +For class +InputOnly, +the depth must be zero (or a +Match +error results), and the visual must be one supported for the screen (or a +Match +error results). +However, the parent can have any depth and class. + + +The server essentially acts as if +InputOnly +windows do not exist for the purposes of graphics requests, +exposure processing, and +VisibilityNotify +events. +An +InputOnly +window cannot be used as a drawable (as a source or destination for graphics +requests). +InputOnly +and +InputOutput +windows act identically in other respects-properties, +grabs, input control, and so on. + + +The coordinate system has the X axis horizontal and the Y axis vertical +with the origin [0, 0] at the upper-left corner. +Coordinates are integral, +in terms of pixels, +and coincide with pixel centers. +Each window and pixmap has its own coordinate system. +For a window, +the origin is inside the border at the inside, upper-left corner. + + +The x and y coordinates +for the window are relative to the parent's origin +and specify the position of the upper-left outer corner of the window +(not the origin). +The width and height specify the inside size (not including the border) +and must be nonzero (or a +Value +error results). +The border-width for an +InputOnly +window must be zero (or a +Match +error results). + + +The window is placed on top in the stacking order with respect to siblings. + + +The value-mask and value-list specify attributes of the window that are +to be explicitly initialized. +The possible values are: + + + + + + + + Attribute + Type + + + + + background-pixmap + +PIXMAP or +None +or +ParentRelative + + + + background-pixel + CARD32 + + + border-pixmap + +PIXMAP or +CopyFromParent + + + + border-pixel + CARD32 + + + bit-gravity + BITGRAVITY + + + win-gravity + WINGRAVITY + + + backing-store + +{ NotUseful, +WhenMapped, +Always } + + + + backing-planes + CARD32 + + + backing-pixel + CARD32 + + + save-under + BOOL + + + event-mask + SETofEVENT + + + do-not-propagate-mask + SETofDEVICEEVENT + + + override-redirect + BOOL + + + colormap + +COLORMAP or +CopyFromParent + + + + cursor + +CURSOR or +None + + + + + + + +The default values when attributes are not explicitly initialized +are: + + + + + + + + + Attribute + Default + + + + + background-pixmap + +None + + + + border-pixmap + +CopyFromParent + + + + bit-gravity + +Forget + + + + win-gravity + +NorthWest + + + + backing-store + +NotUseful + + + + backing-planes + all ones + + + backing-pixel + zero + + + save-under + +False + + + + event-mask + {} (empty set) + + + do-not-propagate-mask + {} (empty set) + + + override-redirect + +False + + + + colormap + +CopyFromParent + + + + cursor + +None + + + + + + + +Only the following attributes are defined for +InputOnly +windows: + + + + + +win-gravity + + + + +event-mask + + + + +do-not-propagate-mask + + + + +override-redirect + + + + +cursor + + + + + +It is a +Match +error to specify any other attributes for +InputOnly +windows. + + +Background +If background-pixmap is given, +it overrides the default background-pixmap. +The background pixmap and the window must have the +same root and the same depth (or a +Match +error results). +Any size pixmap can be used, although some sizes may be faster than others. +If background +None +is specified, the window has no defined background. +If background +ParentRelative +is specified, the parent's background is used, +but the window must have the same depth as the parent (or a +Match +error results). +If the parent has background +None, +then the window will also have background +None. +A copy of the parent's background is not made. +The parent's background is reexamined each time the window background is +required. +If background-pixel is given, it overrides the default +background-pixmap and any background-pixmap given explicitly, +and a pixmap of undefined size filled with background-pixel is used for the +background. +Range checking is not performed on the background-pixel value; +it is simply truncated to the appropriate number of bits. +For a +ParentRelative +background, +the background tile origin always aligns with the parent's background tile +origin. +Otherwise, the background tile origin is always the window origin. + + +When no valid contents are available for regions of a window +and the regions are either visible or the server is maintaining backing store, +the server automatically tiles the regions with the window's background +unless the window has a background of +None. +If the background is +None, +the previous screen contents from other windows of the same depth as the window +are simply left in place if the contents come from the parent of the window +or an inferior of the parent; +otherwise, the initial contents of the exposed regions are undefined. +Exposure events are then generated for the regions, even if the background is +None. + + +The border tile origin is always the same as the background tile origin. +If border-pixmap is given, +it overrides the default border-pixmap. +The border pixmap and the window must have the same root +and the same depth (or a +Match +error results). +Any size pixmap can be used, +although some sizes may be faster than others. +If +CopyFromParent +is given, the parent's border pixmap is copied (subsequent changes to +the parent's border attribute do not affect the child), +but the window must have the same depth as the parent (or a +Match +error results). +The pixmap might be copied by sharing the same pixmap object between the +child and parent or by making a complete copy of the pixmap contents. +If border-pixel is given, +it overrides the default border-pixmap and any border-pixmap given explicitly, +and a pixmap of undefined size filled with border-pixel is used for the border. +Range checking is not performed on the border-pixel value; +it is simply truncated to the appropriate number of bits. + + +Output to a window is always clipped to the inside of the window, +so that the border is never affected. + + +The bit-gravity defines which region of the window should be retained +if the window is resized, and win-gravity defines how the window should +be repositioned if the parent is resized (see +ConfigureWindow +request). + + +A backing-store of +WhenMapped +advises the server that maintaining contents of obscured regions +when the window is mapped would be beneficial. +A backing-store of +Always +advises the server that maintaining contents even when the window is +unmapped would be beneficial. +In this case, +the server may generate an exposure event when the window is created. +A value of +NotUseful +advises the server that maintaining contents is unnecessary, +although a server may still choose to maintain contents while the window +is mapped. +Note that if the server maintains contents, +then the server should maintain complete contents +not just the region within the parent boundaries, +even if the window is larger than its parent. +While the server maintains contents, +exposure events will not normally be generated, +but the server may stop maintaining contents at any time. + + +If save-under is +True, +the server is advised that when this window is +mapped, saving the contents of windows it obscures would be beneficial. + + +When the contents of obscured regions of a window are being maintained, +regions obscured by noninferior windows are included in the +destination (and source, when the window is the source) of graphics +requests, but regions obscured by inferior windows are not included. + + +The backing-planes indicates (with bits set to 1) which bit planes +of the window hold dynamic data that must be preserved in backing-stores +and during save-unders. +The backing-pixel specifies what value to use in planes not +covered by backing-planes. +The server is free to save only the specified bit planes in the backing-store +or save-under and regenerate the remaining planes with the specified pixel +value. +Any bits beyond the specified depth of the window in these +values are simply ignored. + + +Eventmask +Eventpropagation +The event-mask defines which events the client is interested in for +this window (or for some event types, inferiors of the window). +The do-not-propagate-mask defines which events should not be propagated to +ancestor windows when no client has the event type selected in this +window. + + +The override-redirect specifies whether map and configure requests on this +window should override a +SubstructureRedirect +on the parent, typically to inform a window manager not to tamper with +the window. + + +The colormap specifies the colormap that best reflects the true +colors of the window. +Servers capable of supporting multiple hardware colormaps may use this +information, and window managers may use it for +InstallColormap +requests. +The colormap must have the same visual type and root as the window (or a +Match +error results). +If +CopyFromParent +is specified, +the parent's colormap is copied (subsequent changes to the parent's +colormap attribute do not affect the child). +However, the window must have the same visual type as the parent (or a +Match +error results), and the parent must not have a colormap of +None +(or a +Match +error results). +For an explanation of +None, +see FreeColormap +request. +The colormap is copied by sharing the colormap object between the child +and the parent, +not by making a complete copy of the colormap contents. + + +If a cursor is specified, +it will be used whenever the pointer is in the window. +If +None +is specified, +the parent's cursor will be used when the pointer is in the window, +and any change in the parent's cursor will cause an immediate change +in the displayed cursor. + + +This request generates a +CreateNotify +event. + + +The background and border pixmaps and the cursor may be freed +immediately if no further explicit references to them are to be made. + + +Subsequent drawing into the background or border pixmap has an +undefined effect on the window state. +The server might or might not make a copy of the pixmap. + + +
+
+ ChangeWindowAttributes + ChangeWindowAttributes + + + + + + + + +window: WINDOW + + + + +value-mask: BITMASK + + + + +value-list: LISTofVALUE + + + + + + +Errors: +Access, +Colormap, +Cursor, +Match, +Pixmap, +Value, +Window + + + + + + + + + +The value-mask and value-list specify which attributes are to be changed. +The values and restrictions are the same as for +CreateWindow. + + +Setting a new background, whether by background-pixmap or +background-pixel, overrides any previous background. +Setting a new border, whether by border-pixel or border-pixmap, +overrides any previous border. + + +Changing the background does not cause the window contents to be changed. +Setting the border or changing the background such that the +border tile origin changes causes the border to be repainted. +Changing the background of a root window to +None +or +ParentRelative +restores the default background pixmap. +Changing the border of a root window to +CopyFromParent +restores the default border pixmap. + + +Changing the win-gravity does not affect the current position of the +window. + + +Changing the backing-store of an obscured window to +WhenMapped +or +Always +or changing the backing-planes, backing-pixel, or save-under of +a mapped window may have no immediate effect. + + +Multiple clients can select input on the same window; +their event-masks are disjoint. +When an event is generated, +it will be reported to all interested clients. +However, only one client at a time can select for +SubstructureRedirect, +only one client at a time can select for +ResizeRedirect, +and only one client at a time can select for +ButtonPress. +An attempt to violate these restrictions results in an +Access +error. + + +There is only one do-not-propagate-mask for a window, not one per +client. + + +Changing the colormap of a window (by defining a new map, not by +changing the contents of the existing map) generates a +ColormapNotify +event. +Changing the colormap of a visible window might have no immediate effect +on the screen (see +InstallColormap +request). + + +Changing the cursor of a root window to +None +restores the default cursor. + + +The order in which attributes are verified and altered is server-dependent. +If an error is generated, +a subset of the attributes may have been altered. + + +
+
+ GetWindowAttributes + GetWindowAttributes + + + + + + + + +window: WINDOW + + + + + + ▶ + + + + + +visual: VISUALID + + + + +class: +{ InputOutput, +InputOnly} + + + + +bit-gravity: BITGRAVITY + + + + +win-gravity: WINGRAVITY + + + + +backing-store: +{ NotUseful, +WhenMapped, +Always} + + + + +backing-planes: CARD32 + + + + +backing-pixel: CARD32 + + + + +save-under: BOOL + + + + +colormap: COLORMAP or +None + + + + +map-is-installed: BOOL + + + + +map-state: +{ Unmapped, +Unviewable, +Viewable} + + + + +all-event-masks, your-event-mask: SETofEVENT + + + + +do-not-propagate-mask: SETofDEVICEEVENT + + + + +override-redirect: BOOL + + + + + + +Errors: +Window + + + + + + + + + +This request returns the current attributes of the window. +A window is +Unviewable +if it is mapped but some ancestor is unmapped. +All-event-masks is the inclusive-OR of all event masks selected on the window +by clients. +Your-event-mask is the event mask selected by the querying client. + + +
+
+ DestroyWindow + DestroyWindow + + + + + + + + +window: WINDOW + + + + + + +Errors: +Window + + + + + + + + + +If the argument window is mapped, +an +UnmapWindow +request is performed automatically. +The window and all inferiors are then destroyed, and a +DestroyNotify +event is generated for each window. +The ordering of the +DestroyNotify +events is such that for any given window, +DestroyNotify +is generated on all inferiors of the window before being generated on +the window itself. +The ordering among siblings and across subhierarchies is not otherwise +constrained. + + +Normal exposure processing on formerly obscured windows is performed. + + +If the window is a root window, +this request has no effect. + + +
+
+ DestroySubwindows + DestroySubwindows + + + + + + + + +window: WINDOW + + + + + + +Errors: +Window + + + + + + + + + +This request performs a +DestroyWindow +request on all children of the window, in bottom-to-top stacking order. + + +
+
+ ChangeSaveSet + ChangeSaveSet + + + + + + + + +window: WINDOW + + + + +mode: +{ Insert, +Delete} + + + + + +Errors: + +Match, +Value, +Window + + + + + + + + + +This request adds or removes the specified window from the client's +save-set. +The window must have been created by some other client (or a +Match +error results). +For further information about the use of the save-set, +see section 10. + + +When windows are destroyed, +the server automatically removes them from the save-set. + + +
+
+ ReparentWindow + ReparentWindow + + + + + + + + +window, parent: WINDOW + + + + +x, y: INT16 + + + + + + +Errors: +Match, +Window + + + + + + + + + +If the window is mapped, +an +UnmapWindow +request is performed automatically first. +The window is then removed from its current position in the hierarchy +and is inserted as a child of the specified parent. +The x and y coordinates are relative to the parent's origin +and specify the new position of the upper-left outer corner of the +window. +The window is placed on top in the stacking order with respect +to siblings. +A +ReparentNotify +event is then generated. +The override-redirect attribute of the window is passed on in this event; +a value of +True +indicates that a window manager should not tamper with this window. +Finally, if the window was originally mapped, a +MapWindow +request is performed automatically. + + +Normal exposure processing on formerly obscured windows is performed. +The server might not generate exposure events for regions from the +initial unmap that are immediately obscured by the final map. + + +A +Match +error is generated if: + +The new parent is not on the same screen as the old parent. + +The new parent is the window itself or an inferior of the window. + +The new parent is +InputOnly, +and the window is not. + +The window has a +ParentRelative +background, and the new parent is not the same depth as the window. + + +
+
+ MapWindow + MapWindow + Mapped window + + + + + + + + +window: WINDOW + + + + + + +Errors: +Window + + + + + + + + + +If the window is already mapped, this request has no effect. + + +If the override-redirect attribute of the window is +False +and some other client has selected +SubstructureRedirect +on the parent, then a +MapRequest +event is generated, but the window remains unmapped. +Otherwise, the window is mapped, +and a +MapNotify +event is generated. + + +If the window is now viewable and its contents have been discarded, +the window is tiled with its background (if no background is defined, +the existing screen contents are not altered), and zero or more exposure +events are generated. +If a backing-store has been maintained while the window was unmapped, +no exposure events are generated. +If a backing-store will now be maintained, +a full-window exposure is always generated. +Otherwise, only visible regions may be reported. +Similar tiling and exposure take place for any newly viewable inferiors. + + +
+
+ MapSubwindows + MapSubwindows + + + + + + + + +window: WINDOW + + + + + + +Errors: +Window + + + + + + + + + +This request performs a +MapWindow +request on all unmapped children of the window, +in top-to-bottom stacking order. + + +
+
+ UnmapWindow + UnmapWindow + + + + + + + + +window: WINDOW + + + + + + +Errors: +Window + + + + + + + + + +If the window is already unmapped, this request has no effect. +Otherwise, the window is unmapped, and an +UnmapNotify +event is generated. +Normal exposure processing on formerly obscured windows is performed. + + +
+
+ UnmapSubwindows + UnmapSubwindows + + + + + + + + +window: WINDOW + + + + + + +Errors: +Window + + + + + + + + + +This request performs an +UnmapWindow +request on all mapped children of the window, +in bottom-to-top stacking order. + + +
+
+ ConfigureWindow + ConfigureWindow + + + + + + + + +window: WINDOW + + + + +value-mask: BITMASK + + + + +value-list: LISTofVALUE + + + + + + +Errors: +Match, +Value, +Window + + + + + + + + + +This request changes the configuration of the window. +The value-mask and value-list specify which values are to be given. +The possible values are: + + + + + + + + + + Attribute + Type + + + + + x + INT16 + + + y + INT16 + + + width + CARD16 + + + height + CARD16 + + + border-width + CARD16 + + + sibling + WINDOW + + + stack-mode + +{ Above, +Below, +TopIf, +BottomIf, +Opposite } + + + + + + + +The x and y coordinates are relative to the parent's origin +and specify the position of the upper-left outer corner of the window. +The width and height specify the inside size, not including the border, and +must be nonzero (or a +Value +error results). +Those values not specified are taken from the existing geometry of the window. +Note that changing just the border-width leaves the outer-left corner +of the window in a fixed position but moves the absolute position of the +window's origin. +It is a +Match +error to attempt to make the border-width of an +InputOnly +window nonzero. + + +If the override-redirect attribute of the window is +False +and some other client has selected +SubstructureRedirect +on the parent, a +ConfigureRequest +event is generated, and no further processing is performed. +Otherwise, the following is performed: + + +If some other client has selected +ResizeRedirect +on the window and the inside width or height of the window is being changed, +a +ResizeRequest +event is generated, +and the current inside width and height are used instead. +Note that the override-redirect attribute of the window has no effect on +ResizeRedirect +and that +SubstructureRedirect +on the parent has precedence over +ResizeRedirect +on the window. + + +Gravity +Bitgravity +Windowgravity +The geometry of the window is changed as specified, +the window is restacked among siblings, and a +ConfigureNotify +event is generated if the state of the window actually changes. +If the inside width or height of the window has actually changed, +then children of the window are affected, +according to their win-gravity. +Exposure processing is performed on formerly obscured windows +(including the window itself and its inferiors if regions of them were +obscured but now are not). +Exposure processing is also performed on any new regions of the window +(as a result of increasing the width or height) +and on any regions where window contents are lost. + + +If the inside width or height of a window is not changed +but the window is moved or its border is changed, +then the contents of the window are not lost but move with the window. +Changing the inside width or height of the window causes its contents to be +moved or lost, depending on the bit-gravity of the window. +It also causes children to be reconfigured, depending on their win-gravity. +For a change of width and height of W and H, +we define the [x, y] pairs as: + + + + + + + + + + Direction + Deltas + + + + + +NorthWest + + [0, 0] + + + +North + + [W/2, 0] + + + +NorthEast + + [W, 0] + + + +West + + [0, H/2] + + + +Center + + [W/2, H/2] + + + +East + + [W, H/2] + + + +SouthWest + + [0, H] + + + +South + + [W/2, H] + + + +SouthEast + + [W, H] + + + + + + +When a window with one of these bit-gravities is resized, +the corresponding pair defines the change in position of each pixel in the +window. +When a window with one of these win-gravities has its parent window resized, +the corresponding pair defines the change in position +of the window within the parent. +This repositioning generates a +GravityNotify +event. +GravityNotify +events are generated after the +ConfigureNotify +event is generated. + + +A gravity of +Static +indicates that the contents or origin should not move relative to the origin +of the root window. +If the change in size of the window is coupled with a change +in position of [X, Y], +then for bit-gravity the change in position of each pixel is [-X, -Y] and for +win-gravity the change in position of a child when its parent is so +resized is [-X, -Y]. +Note that +Static +gravity still only takes effect when the width or height of the +window is changed, not when the window is simply moved. + + +A bit-gravity of +Forget +indicates that the window contents are always discarded after a size change, +even if backing-store or save-under has been requested. +The window is tiled with its background (except, if no background is defined, +the existing screen contents are not altered) +and zero or more exposure events are generated. + + +The contents and borders of inferiors are not affected by their parent's +bit-gravity. +A server is permitted to ignore the specified bit-gravity and use +Forget +instead. + + +A win-gravity of +Unmap +is like +NorthWest, +but the child is also unmapped when the parent is resized, +and an +UnmapNotify +event is generated. +UnmapNotify +events are generated after the +ConfigureNotify +event is generated. + + +If a sibling and a stack-mode are specified, +the window is restacked as follows: + + + + + + + + + + +Above + + +The window is placed just above the sibling. + + + + +Below + + +The window is placed just below the sibling. + + + + +TopIf + + +If the sibling occludes the window, +then the window is placed at the top of the stack. + + + + +BottomIf + + +If the window occludes the sibling, +then the window is placed at the bottom of the stack. + + + + +Opposite + + +If the sibling occludes the window, +then the window is placed at the top of the stack. +Otherwise, if the window occludes the sibling, +then the window is placed at the bottom of the stack. + + + + + + + +If a stack-mode is specified but no sibling is specified, +the window is restacked as follows: + + + + + + + + + + +Above + + +The window is placed at the top of the stack. + + + + +Below + + +The window is placed at the bottom of the stack. + + + + +TopIf + + +If any sibling occludes the window, +then the window is placed at the top of the stack. + + + + +BottomIf + + +If the window occludes any sibling, +then the window is placed at the bottom of the stack. + + + + +Opposite + + +If any sibling occludes the window, +then the window is placed at the top of the stack. +Otherwise, if the window occludes any sibling, +then the window is placed at the bottom of the stack. + + + + + + + +It is a +Match +error if a sibling is specified without a stack-mode +or if the window is not actually a sibling. + + +Note that the computations for +BottomIf, +TopIf, +and +Opposite +are performed with respect to the window's final geometry (as controlled by +the other arguments to the request), not to its initial geometry. + + +Attempts to configure a root window have no effect. + + +
+
+ CirculateWindow + CirculateWindow + + + + + + + + +window: WINDOW + + + + +direction: +{ RaiseLowest, +LowerHighest} + + + + + + +Errors: +Value, +Window + + + + + + + + + +If some other client has selected +SubstructureRedirect +on the window, then a +CirculateRequest +event is generated, and no further processing is performed. +Otherwise, the following is performed, and then a +CirculateNotify +event is generated if the window is actually restacked. + + +For +RaiseLowest, +CirculateWindow +raises the lowest mapped child (if any) that is +occluded by another child to the top of the stack. +For +LowerHighest, +CirculateWindow +lowers the highest mapped child (if any) that occludes another child to +the bottom of the stack. +Exposure processing is performed on formerly obscured windows. + + +
+
+ GetGeometry + GetGeometry + + + + + + + + +drawable: DRAWABLE + + + + + + ▶ + + + + + +root: WINDOW + + + + +depth: CARD8 + + + + +x, y: INT16 + + + + +width, height, border-width: CARD16 + + + + + + +Errors: +Drawable + + + + + + + + + +This request returns the root and current geometry of the drawable. +The depth is the number of bits per pixel for the object. +The x, y, and border-width will always be zero for pixmaps. +For a window, +the x and y coordinates specify the upper-left outer corner of the window +relative to its parent's origin, +and the width and height specify the inside size, not including the border. + + +It is legal to pass an +InputOnly +window as a drawable to this request. + + +
+
+ QueryTree + QueryTree + Children + + + + + + + + +window: WINDOW + + + + + + ▶ + + + + + +root: WINDOW + + + + +parent: WINDOW or +None + + + + +children: LISTofWINDOW + + + + + + +Errors: +Window + + + + + + + + + +This request returns the root, the parent, and the children of the window. +The children are listed in bottom-to-top stacking order. + + +
+
+ InternAtom + InternAtom + Atom + + + + + + + + +name: STRING8 + + + + +only-if-exists: BOOL + + + + + + ▶ + + + + + +atom: ATOM or +None + + + + + + +Errors: +Alloc, +Value + + + + + + + + + +This request returns the atom for the given name. +If only-if-exists is +False, +then the atom is created if it does not exist. +The string should use the ISO Latin-1 encoding. +Uppercase and lowercase matter. + + +The lifetime of an atom is not tied to the interning client. +Atoms remain defined until server reset (see section 10). + + +
+
+ GetAtomName + GetAtomName + + + + + + + + +atom: ATOM + + + + + + ▶ + + + + + +name: STRING8 + + + + + + +Errors: +Atom + + + + + + + + + +This request returns the name for the given atom. + + +
+
+ ChangeProperty + ChangeProperty + Property + + + + + + + + +window: WINDOW + + + + +property, type: ATOM + + + + +format: {8, 16, 32} + + + + +mode: +{ Replace, +Prepend, +Append} + + + + +data: LISTofINT8 or LISTofINT16 or LISTofINT32 + + + + + + +Errors: +Alloc, +Atom, +Match, +Value, +Window + + + + + + + + + +This request alters the property for the specified window. +The type is uninterpreted by the server. +The format specifies whether the data should be viewed as a list of 8-bit, +16-bit, or 32-bit quantities so that the server can correctly byte-swap +as necessary. + + +If the mode is +Replace, +the previous property value is discarded. +If the mode is +Prepend +or +Append, +then the type and format must match the existing property value (or a +Match +error results). +If the property is undefined, +it is treated as defined with the correct type +and format with zero-length data. +For +Prepend, +the data is tacked on to the beginning of the existing data, and for +Append, +it is tacked on to the end of the existing data. + + +This request generates a +PropertyNotify +event on the window. + + +The lifetime of a property is not tied to the storing client. +Properties remain until explicitly deleted, until the window is destroyed, +or until server reset (see section 10). + + +The maximum size of a property is server-dependent and may vary dynamically. + + +
+
+ DeleteProperty + DeleteProperty + + + + + + + + +window: WINDOW + + + + +property: ATOM + + + + + + +Errors: +Atom, +Window + + + + + + + + + +This request deletes the property from the specified window +if the property exists and generates a +PropertyNotify +event on the window unless the property does not exist. + + +
+
+ GetProperty + GetProperty + + + + + + + + +window: WINDOW + + + + +property: ATOM + + + + +type: ATOM or +AnyPropertyType + + + + +long-offset, long-length: CARD32 + + + + +delete: BOOL + + + + + + ▶ + + + + + +type: ATOM or +None + + + + +format: {0, 8, 16, 32} + + + + +bytes-after: CARD32 + + + + +value: LISTofINT8 or LISTofINT16 or LISTofINT32 + + + + + + +Errors: +Atom, +Value, +Window + + + + + + + + + +If the specified property does not exist for the specified window, +then the return type is +None, +the format and bytes-after are zero, +and the value is empty. +The delete argument is ignored in this case. +If the specified property exists but its type does not match the specified type, +then the return type is the actual type of the property, +the format is the actual format of the property (never zero), +the bytes-after is the length of the property in bytes +(even if the format is 16 or 32), +and the value is empty. +The delete argument is ignored in this case. +If the specified property exists and either +AnyPropertyType +is specified or the specified type matches the actual type of the property, +then the return type is the actual type of the property, +the format is the actual format of the property (never zero), +and the bytes-after and value are as follows, given: + + N = actual length of the stored property in bytes + (even if the format is 16 or 32) + I = 4 * long-offset + T = N - I + L = MINIMUM(T, 4 * long-length) + A = N - (I + L) + + + +The returned value starts at byte index I in the property (indexing from 0), +and its length in bytes is L. +However, it is a +Value +error if long-offset is given such that L is negative. +The value of bytes-after is A, +giving the number of trailing unread bytes in the stored +property. +If delete is +True +and the bytes-after is zero, +the property is also deleted from the window, +and a +PropertyNotify +event is generated on the window. + + +
+
+ RotateProperties + RotateProperties + + + + + + + + +window: WINDOW + + + + +delta: INT16 + + + + +properties: LISTofATOM + + + + + + +Errors: +Atom, +Match, +Window + + + + + + + + + +If the property names in the list are viewed as being numbered starting +from zero, and there are N property names in the list, +then the value associated with property name I becomes the value +associated with property name (I + delta) mod N, for all I from zero to N - 1. +The effect is to rotate the states by delta places around the virtual ring +of property names (right for positive delta, left for negative delta). + + +If delta mod N is nonzero, +a +PropertyNotify +event is generated for each property in the order listed. + + +If an atom occurs more than once in the list or no property with that +name is defined for the window, +a +Match +error is generated. +If an +Atom +or +Match +error is generated, no properties are changed. + + +
+
+ ListProperties + ListProperties + + + + + + + + +window: WINDOW + + + + + + ▶ + + + + + +atoms: LISTofATOM + + + + + + +Errors: +Window + + + + + + + + + +This request returns the atoms of properties currently defined on the window. + + +
+
+ SetSelectionOwner + SetSelectionOwner + Selection + + + + + + + + +selection: ATOM + + + + +owner: WINDOW or +None + + + + +time: TIMESTAMP or +CurrentTime + + + + + + +Errors: +Atom, +Window + + + + + + + + + +This request changes the owner, owner window, +and last-change time of the specified selection. +This request has no effect if the specified time is earlier +than the current last-change time of the specified selection or is +later than the current server time. +Otherwise, the last-change time is set to the specified time +with +CurrentTime +replaced by the current server time. +If the owner window is specified as +None, +then the owner of the selection becomes +None +(that is, no owner). +Otherwise, the owner of the selection becomes the client executing the request. +If the new owner (whether a client or +None) +is not the same as the current owner +and the current owner is not +None, +then the current owner is sent a +SelectionClear +event. + + +If the client that is the owner of a selection is later terminated +(that is, its connection is closed) or if the owner window it has +specified in the request is later destroyed, +then the owner of the selection automatically reverts to +None, +but the last-change time is not affected. + + +The selection atom is uninterpreted by the server. +The owner window is returned by the +GetSelectionOwner +request and is reported in +SelectionRequest +and +SelectionClear +events. + + +Selections are global to the server. + + +
+
+ GetSelectionOwner + GetSelectionOwner + + + + + + + + +selection: ATOM + + + + + + ▶ + + + + + +owner: WINDOW or +None + + + + + + +Errors: +Atom + + + + + + + + + +This request returns the current owner window of the specified selection, +if any. +If +None +is returned, then there is no owner for the selection. + + +
+
+ ConvertSelection + ConvertSelection + + + + + + + + +selection, target: ATOM + + + + +property: ATOM or +None + + + + +requestor: WINDOW + + + + +time: TIMESTAMP or +CurrentTime + + + + + + +Errors: +Atom, +Window + + + + + + + + + +If the specified selection has an owner, +the server sends a +SelectionRequest +event to that owner. +If no owner for the specified selection exists, +the server generates a +SelectionNotify +event to the requestor with property +None. +The arguments are passed on unchanged in either of the events. + + +
+
+ SendEvent + SendEvent + Eventsending + + + + + + + + +destination: WINDOW or +PointerWindow +or +InputFocus + + + + +propagate: BOOL + + + + +event-mask: SETofEVENT + + + + +event: <normal-event-format> + + + + + + +Errors: +Value, +Window + + + + + + + + + +If +PointerWindow +is specified, +destination is replaced with the window that the pointer is in. +If +InputFocus +is specified and the focus window contains the pointer, +destination is replaced with the window that the pointer is in. +Otherwise, destination is replaced with the focus window. + + +If the event-mask is the empty set, +then the event is sent to the client that created the destination window. +If that client no longer exists, no event is sent. + + +If propagate is +False, +then the event is sent to every client selecting +on destination any of the event types in event-mask. + + +If propagate is +True +and no clients have selected on destination any +of the event types in event-mask, +then destination is replaced with the +closest ancestor of destination for which some client has selected a +type in event-mask and no intervening window has that type in its +do-not-propagate-mask. +If no such window exists or if the window is an ancestor of the focus window +and +InputFocus +was originally specified as the destination, +then the event is not sent to any clients. +Otherwise, the event is reported to every client selecting on the final +destination any of the types specified in event-mask. + + +The event code must be one of the core events or one of the events +defined by an extension (or a +Value +error results) so that the server can correctly byte-swap the +contents as necessary. +The contents of the event are otherwise unaltered and unchecked +by the server except to force on the most significant bit of the event code +and to set the sequence number in the event correctly. + + +Active grabs are ignored for this request. + + +
+
+ GrabPointer + GrabPointer + Active grabpointer + Pointergrabbing + + + + + + + + +grab-window: WINDOW + + + + +owner-events: BOOL + + + + +event-mask: SETofPOINTEREVENT + + + + +pointer-mode, keyboard-mode: +{ Synchronous, +Asynchronous} + + + + +confine-to: WINDOW or +None + + + + +cursor: CURSOR or +None + + + + +time: TIMESTAMP or +CurrentTime + + + + + + ▶ + + + + + +status: +{ Success, +AlreadyGrabbed, +Frozen, +InvalidTime, +NotViewable} + + + + + + +Errors: +Cursor, +Value, +Window + + + + + + + + + +This request actively grabs control of the pointer. +Further pointer events are only reported to the grabbing client. +The request overrides any active pointer grab by this client. + + +If owner-events is +False, +all generated pointer events are reported with respect to grab-window +and are only reported if selected by event-mask. +If owner-events is +True +and a generated pointer event would normally be reported to this client, +it is reported normally. +Otherwise, the event is reported with respect to the grab-window and is +only reported if selected by event-mask. +For either value of owner-events, +unreported events are simply discarded. + + +If pointer-mode is +Asynchronous, +pointer event processing continues normally. +If the pointer is currently frozen by this client, +then processing of pointer events is resumed. +If pointer-mode is +Synchronous, +the state of the pointer (as seen by means of the protocol) appears to freeze, +and no further pointer events are generated by the server until the +grabbing client issues a releasing +AllowEvents +request or until the pointer grab is released. +Actual pointer changes are not lost while the pointer is frozen. +They are simply queued for later processing. + + +If keyboard-mode is +Asynchronous, +keyboard event processing is unaffected by activation of the grab. +If keyboard-mode is +Synchronous, +the state of the keyboard (as seen by means of the protocol) appears to freeze, +and no further keyboard events are generated by the server until the grabbing +client issues a releasing +AllowEvents +request or until the pointer grab is released. +Actual keyboard changes are not lost while the keyboard is frozen. +They are simply queued for later processing. + + +If a cursor is specified, +then it is displayed regardless of what window the pointer is in. +If no cursor is specified, +then when the pointer is in grab-window or one of its subwindows, +the normal cursor for that window is displayed. +Otherwise, the cursor for grab-window is displayed. + + +If a confine-to window is specified, +then the pointer will be restricted to stay contained in that window. +The confine-to window need have no relationship to the grab-window. +If the pointer is not initially in the confine-to window, +then it is warped automatically to the closest edge +(and enter/leave events are generated normally) just before the grab activates. +If the confine-to window is subsequently reconfigured, +the pointer will be warped automatically as necessary to +keep it contained in the window. + + +This request generates +EnterNotify +and +LeaveNotify +events. + + +The request fails with status +AlreadyGrabbed +if the pointer is actively grabbed by some other client. +The request fails with status +Frozen +if the pointer is frozen by an active grab of another client. +The request fails with status +NotViewable +if grab-window or confine-to window is not viewable +or if the confine-to window lies completely outside the boundaries +of the root window. +The request fails with status +InvalidTime +if the specified time is earlier than the last-pointer-grab time or later than +the current server time. +Otherwise, the last-pointer-grab time is set to the specified time, with +CurrentTime +replaced by the current server time. + + +
+
+ UngrabPointer + UngrabPointer + + + + + + + + +time: TIMESTAMP or +CurrentTime + + + + + + + + + +This request releases the pointer if this client has it actively grabbed (from +either +GrabPointer +or +GrabButton +or from a normal button press) and releases any queued events. +The request has no effect if the specified time is earlier than +the last-pointer-grab time or is later than the current server time. + + +This request generates +EnterNotify +and +LeaveNotify +events. + + +An +UngrabPointer +request is performed automatically if the event window or +confine-to window for an active pointer grab becomes not viewable +or if window reconfiguration causes the confine-to window to lie +completely outside the boundaries of the root window. + + +
+
+ GrabButton + GrabButton + Buttongrabbing + + + + + + + + +modifiers: SETofKEYMASK or +AnyModifier + + + + +button: BUTTON or +AnyButton + + + + +grab-window: WINDOW + + + + +owner-events: BOOL + + + + +event-mask: SETofPOINTEREVENT + + + + +pointer-mode, keyboard-mode: +{ Synchronous, +Asynchronous} + + + + +confine-to: WINDOW or +None + + + + +cursor: CURSOR or +None + + + + + + +Errors: +Access, +Cursor, +Value, +Window + + + + + + + + + +This request establishes a passive grab. +Passive grabpointer +In the future, +the pointer is actively grabbed as described in +GrabPointer, +the last-pointer-grab time is set to the time at which the button was +pressed (as transmitted in the +ButtonPress +event), and the +ButtonPress +event is reported if all of the following conditions are true: + +The pointer is not grabbed and the specified button is logically pressed +when the specified modifier keys are logically down, +and no other buttons or modifier keys are logically down. + +The grab-window contains the pointer. + +The confine-to window (if any) is viewable. + +A passive grab on the same button/key combination does not exist +on any ancestor of grab-window. + + +The interpretation of the remaining arguments is the same as for +GrabPointer. +The active grab is terminated automatically when +the logical state of the pointer has all buttons released, +independent of the logical state of modifier keys. +Note that the logical state of a device (as seen by means of the protocol) +may lag the physical state if device event processing is frozen. + + +This request overrides all previous passive grabs by the same client on +the same button/key combinations on the same window. +A modifier of +AnyModifier +is equivalent to issuing the request for all possible modifier combinations +(including the combination of no modifiers). +It is not required that all specified modifiers have currently assigned +keycodes. +A button of +AnyButton +is equivalent to issuing the request for all possible buttons. +Otherwise, it is not required that the button specified currently be assigned +to a physical button. + + +An +Access +error is generated if some other client has already issued a +GrabButton +request with the same button/key combination on the same window. +When using +AnyModifier +or +AnyButton, +the request fails completely (no grabs are established), and an +Access +error is generated if there is a conflicting grab for any combination. +The request has no effect on an active grab. + + +
+
+ UngrabButton + UngrabButton + + + + + + + + +modifiers: SETofKEYMASK or +AnyModifier + + + + +button: BUTTON or +AnyButton + + + + +grab-window: WINDOW + + + + + + +Errors: +Value, +Window + + + + + + + + + +This request releases the passive button/key combination +on the specified window if it was grabbed by this client. +A modifiers argument of +AnyModifier +is equivalent to issuing the request for all possible modifier +combinations (including the combination of no modifiers). +A button of +AnyButton +is equivalent to issuing the request for all possible buttons. +The request has no effect on an active grab. + + +
+
+ ChangeActivePointerGrab + ChangeActivePointerGrab + Active grabpointer + + + + + + + + +event-mask: SETofPOINTEREVENT + + + + +cursor: CURSOR or +None + + + + +time: TIMESTAMP or +CurrentTime + + + + + + +Errors: +Cursor, +Value + + + + + + + + + +This request changes the specified dynamic parameters if the pointer is +actively grabbed by the client and the specified time is no earlier than the +last-pointer-grab time and no later than the current server time. +The interpretation of event-mask and cursor are the same as in +GrabPointer. +This request has no effect on the parameters of any passive grabs established +with +GrabButton. + + +
+
+ GrabKeyboard + GrabKeyboard + Active grabkeyboard + Keyboardgrabbing + + + + + + + + +grab-window: WINDOW + + + + +owner-events: BOOL + + + + +pointer-mode, keyboard-mode: +{ Synchronous, +Asynchronous} + + + + +time: TIMESTAMP or +CurrentTime + + + + + + ▶ + + + + + +status: +{ Success, +AlreadyGrabbed, +Frozen, +InvalidTime, +NotViewable} + + + + + + +Errors: +Value, +Window + + + + + + + + + +This request actively grabs control of the keyboard. +Further key events are reported only to the grabbing client. +This request overrides any active keyboard grab by this client. + + +If owner-events is +False, +all generated key events are reported with respect to grab-window. +If owner-events is +True +and if a generated key event would normally be reported to this client, +it is reported normally. +Otherwise, the event is reported with respect to the grab-window. +Both +KeyPress +and +KeyRelease +events are always reported, +independent of any event selection made by the client. + + +If keyboard-mode is +Asynchronous, +keyboard event processing continues normally. +If the keyboard is currently frozen by this client, +then processing of keyboard events is resumed. +If keyboard-mode is +Synchronous, +the state of the keyboard (as seen by means of the protocol) appears to freeze. +No further keyboard events are generated by the server until the +grabbing client issues a releasing +AllowEvents +request or until the keyboard grab is released. +Actual keyboard changes are not lost while the keyboard is frozen. +They are simply queued for later processing. + + +If pointer-mode is +Asynchronous, +pointer event processing is unaffected by activation of the grab. +If pointer-mode is +Synchronous, +the state of the pointer (as seen by means of the protocol) appears to freeze. +No further pointer events are generated by the server +until the grabbing client issues a releasing +AllowEvents +request or until the keyboard grab is released. +Actual pointer changes are not lost while the pointer is frozen. +They are simply queued for later processing. + + +This request generates +FocusIn +and +FocusOut +events. + + +The request fails with status +AlreadyGrabbed +if the keyboard is actively grabbed by some other client. +The request fails with status +Frozen +if the keyboard is frozen by an active grab of another client. +The request fails with status +NotViewable +if grab-window is not viewable. +The request fails with status +InvalidTime +if the specified time is earlier than the last-keyboard-grab time +or later than the current server time. +Otherwise, the last-keyboard-grab time is set to the specified time with +CurrentTime +replaced by the current server time. + + +
+
+ UngrabKeyboard + UngrabKeyboard + + + + + + + + +time: TIMESTAMP or +CurrentTime + + + + + + + + + +This request releases the keyboard if this client has it actively grabbed +(as a result of either +GrabKeyboard +or +GrabKey) +and releases any queued events. +The request has no effect if the specified time is earlier than the +last-keyboard-grab time or is later than the current server time. + + +This request generates +FocusIn +and +FocusOut +events. + + +An +UngrabKeyboard +is performed automatically if the event window for an active keyboard grab +becomes not viewable. + + +
+
+ GrabKey + GrabKey + Keygrabbing + + + + + + + + +key: KEYCODE or +AnyKey + + + + +modifiers: SETofKEYMASK or +AnyModifier + + + + +grab-window: WINDOW + + + + +owner-events: BOOL + + + + +pointer-mode, keyboard-mode: +{ Synchronous, +Asynchronous} + + + + + + +Errors: +Access, +Value, +Window + + + + + + + + + +This request establishes a passive grab on the keyboard. +Passive grabkeyboard +In the future, +the keyboard is actively grabbed as described in +GrabKeyboard, +the last-keyboard-grab time is set to the time at which the key was pressed +(as transmitted in the +KeyPress +event), and the +KeyPress +event is reported if all of the following conditions are true: + +The keyboard is not grabbed and the specified key +(which can itself be a modifier key) is logically pressed +when the specified modifier keys are logically down, +and no other modifier keys are logically down. + +Either the grab-window is an ancestor of (or is) the focus window, +or the grab-window is a descendent of the focus window and contains the pointer. + +A passive grab on the same key combination does not exist +on any ancestor of grab-window. + + +The interpretation of the remaining arguments is the same as for +GrabKeyboard. +The active grab is terminated automatically when the logical state +of the keyboard has the specified key released, +independent of the logical state of modifier keys. +Note that the logical state of a device (as seen by means of the protocol) +may lag the physical state if device event processing is frozen. + + +This request overrides all previous passive grabs by the same client +on the same key combinations on the same window. +A modifier of +AnyModifier +is equivalent to issuing the request for all possible modifier combinations +(including the combination of no modifiers). +It is not required that all modifiers specified have +currently assigned keycodes. +A key of +AnyKey +is equivalent to issuing the request for all possible keycodes. +Otherwise, the key must be in the range specified by min-keycode +and max-keycode in the connection setup (or a +Value +error results). + + +An +Access +error is generated if some other client has issued a +GrabKey +with the same key combination on the same window. +When using +AnyModifier +or +AnyKey, +the request fails completely (no grabs are established), +and an +Access +error is generated if there is a conflicting grab for any combination. + + +
+
+ UngrabKey + UngrabKey + + + + + + + + +key: KEYCODE or +AnyKey + + + + +modifiers: SETofKEYMASK or +AnyModifier + + + + +grab-window: WINDOW + + + + + + +Errors: +Value, +Window + + + + + + + + + +This request releases the key combination on the specified window +if it was grabbed by this client. +A modifiers argument of +AnyModifier +is equivalent to issuing the request for all possible modifier combinations +(including the combination of no modifiers). +A key of +AnyKey +is equivalent to issuing the request for all possible keycodes. +This request has no effect on an active grab. + + +
+
+ AllowEvents + AllowEvents + + + + + + + + +mode: +{ AsyncPointer, +SyncPointer, +ReplayPointer, +AsyncKeyboard, + + + + +SyncKeyboard, +ReplayKeyboard, +AsyncBoth, +SyncBoth} + + + + +time: TIMESTAMP or +CurrentTime + + + + + + +Errors: +Value + + + + + + + + + +This request releases some queued events if the client has caused a device to +freeze. +The request has no effect if the specified time is earlier +than the last-grab time of the most recent active grab for the client +or if the specified time is later than the current server time. + + +For +AsyncPointer, +if the pointer is frozen by the client, +pointer event processing continues normally. +If the pointer is frozen twice by the client on behalf of two separate grabs, +AsyncPointer +thaws for both. +AsyncPointer +has no effect if the pointer is not frozen by the client, +but the pointer need not be grabbed by the client. + + +For +SyncPointer, +if the pointer is frozen and actively grabbed by the client, +pointer event processing continues normally until the next +ButtonPress +or +ButtonRelease +event is reported to the client, +at which time the pointer again appears to freeze. +However, if the reported event causes the pointer grab to be released, +then the pointer does not freeze. +SyncPointer +has no effect if the pointer is not frozen by the +client or if the pointer is not grabbed by the client. + + +For +ReplayPointer, +if the pointer is actively grabbed by the client and +is frozen as the result of an event having been sent to the client +(either from the activation of a +GrabButton +or from a previous +AllowEvents +with mode +SyncPointer +but not from a +GrabPointer), +then the pointer grab is released and that event is completely reprocessed, +this time ignoring any passive grabs at or above (towards the root) +the grab-window of the grab just released. +The request has no effect if the pointer is not grabbed by the client +or if the pointer is not frozen as the result of an event. + + +For +AsyncKeyboard, +if the keyboard is frozen by the client, +keyboard event processing continues normally. +If the keyboard is frozen twice by the client on behalf of two separate grabs, +AsyncKeyboard +thaws for both. +AsyncKeyboard +has no effect if the keyboard is not frozen by the client, +but the keyboard need not be grabbed by the client. + + +For +SyncKeyboard, +if the keyboard is frozen and actively grabbed by the client, +keyboard event processing continues normally until the next +KeyPress +or +KeyRelease +event is reported to the client, +at which time the keyboard again appears to freeze. +However, if the reported event causes the keyboard grab to be released, +then the keyboard does not freeze. +SyncKeyboard +has no effect if the keyboard is not frozen by the client or +if the keyboard is not grabbed by the client. + + +For +ReplayKeyboard, +if the keyboard is actively grabbed by the client +and is frozen as the result of an event having been sent to the client +(either from the activation of a +GrabKey +or from a previous +AllowEvents +with mode +SyncKeyboard +but not from a +GrabKeyboard), +then the keyboard grab is released and that event is completely reprocessed, +this time ignoring any passive grabs at or above (towards the root) +the grab-window of the grab just released. +The request has no effect if the keyboard is not grabbed by the client +or if the keyboard is not frozen as the result of an event. + + +For +SyncBoth, +if both pointer and keyboard are frozen by the client, +event processing (for both devices) continues normally until the next +ButtonPress, +ButtonRelease, +KeyPress, +or +KeyRelease +event is reported to the client for a grabbed device +(button event for the pointer, key event for the keyboard), +at which time the devices again appear to freeze. +However, if the reported event causes the grab to be released, +then the devices do not freeze (but if the other device is still +grabbed, then a subsequent event for it will still cause both devices +to freeze). +SyncBoth +has no effect unless both pointer and keyboard are frozen by the client. +If the pointer or keyboard is frozen twice by the client on behalf +of two separate grabs, +SyncBoth +thaws for both (but a subsequent freeze for +SyncBoth +will only freeze each device once). + + +For +AsyncBoth, +if the pointer and the keyboard are frozen by the client, +event processing for both devices continues normally. +If a device is frozen twice by the client on behalf of two separate grabs, +AsyncBoth +thaws for both. +AsyncBoth +has no effect unless both pointer and keyboard are frozen by the client. + + +AsyncPointer, +SyncPointer, +and +ReplayPointer +have no effect on processing of keyboard events. +AsyncKeyboard, +SyncKeyboard, +and +ReplayKeyboard +have no effect on processing of pointer events. + + +It is possible for both a pointer grab and a keyboard grab to be active +simultaneously (by the same or different clients). +When a device is frozen on behalf of either grab, +no event processing is performed for the device. +It is possible for a single device to be frozen because of both grabs. +In this case, the freeze must be released on behalf of both grabs +before events can again be processed. +If a device is frozen twice by a single client, then a single +AllowEvents +releases both. + + +
+
+ GrabServer + GrabServer + Servergrabbing + +This request disables processing of requests and close-downs on all +connections other than the one this request arrived on. + + +
+
+ UngrabServer + UngrabServer + +This request restarts processing of requests and close-downs +on other connections. + + +
+
+ QueryPointer + QueryPointer + + + + + + + + +window: WINDOW + + + + + + ▶ + + + + + +root: WINDOW + + + + +child: WINDOW or +None + + + + +same-screen: BOOL + + + + +root-x, root-y, win-x, win-y: INT16 + + + + +mask: SETofKEYBUTMASK + + + + + + +Errors: +Window + + + + + + + + + +The root window the pointer is logically on and the pointer coordinates +relative to the root's origin are returned. +If same-screen is +False, +then the pointer is not on the same screen as the argument window, +child is +None, +and win-x and win-y are zero. +If same-screen is +True, +then win-x and win-y are the pointer coordinates relative to the +argument window's origin, and child is the child containing the +pointer, if any. +The current logical state of the modifier keys and the buttons +are also returned. +Note that the logical state of a device (as seen by means of the protocol) +may lag the physical state if device event processing is frozen. + + +
+
+ GetMotionEvents + GetMotionEvents + + + + + + + + +start, +stop: TIMESTAMP or +CurrentTime + + + + +window: WINDOW + + + + + + ▶ + + + + + +events: LISTofTIMECOORD + + + + + +where: + + + + +TIMECOORD: [x, y: INT16 + + + + + time: TIMESTAMP] + + + + + + + +Errors: +Window + + + + + + + + + +This request returns all events in the motion history buffer that fall +between the specified start and stop times (inclusive) +and that have coordinates that lie within (including borders) +the specified window at its present placement. +The x and y coordinates are reported relative to the origin of the window. + + +If the start time is later than the stop time or if the start time is +in the future, no events are returned. +If the stop time is in the future, it is equivalent to specifying +CurrentTime. + + +
+
+ TranslateCoordinates + TranslateCoordinates + Coordinate systemtranslating + + + + + + + + +src-window, dst-window: WINDOW + + + + +src-x, src-y: INT16 + + + + + + ▶ + + + + + +same-screen: BOOL + + + + +child: WINDOW or +None + + + + +dst-x, dst-y: INT16 + + + + + + +Errors: +Window + + + + + + + + + +The src-x and src-y coordinates are taken relative to src-window's +origin and are returned as dst-x and dst-y coordinates relative to +dst-window's origin. +If same-screen is +False, +then src-window and dst-window are on different screens, +and dst-x and dst-y are zero. +If the coordinates are contained in a mapped child of dst-window, +then that child is returned. + + +
+
+ WarpPointer + WarpPointer + + + + + + + + +src-window: WINDOW or +None + + + + +dst-window: WINDOW or +None + + + + +src-x, src-y: INT16 + + + + +src-width, src-height: CARD16 + + + + +dst-x, dst-y: INT16 + + + + + + +Errors: +Window + + + + + + + + + +If dst-window is +None, +this request moves the pointer by offsets [dst-x, dst-y] +relative to the current position of the pointer. +If dst-window is a window, +this request moves the pointer to [dst-x, dst-y] relative to dst-window's +origin. +However, if src-window is not +None, +the move only takes place if src-window contains the pointer +and the pointer is contained in the specified rectangle of src-window. + + +The src-x and src-y coordinates are relative to src-window's origin. +If src-height is zero, +it is replaced with the current height of src-window minus src-y. +If src-width is zero, +it is replaced with the current width of src-window minus src-x. + + +This request cannot be used to move the pointer outside the confine-to +window of an active pointer grab. +An attempt will only move the pointer as far as the closest edge +of the confine-to window. + + +This request will generate events just as if the user had instantaneously +moved the pointer. + + +
+
+ SetInputFocus + SetInputFocus + Input focus + + + + + + + + +focus: WINDOW or +PointerRoot +or +None + + + + +revert-to: +{ Parent, +PointerRoot, +None} + + + + +time: TIMESTAMP or +CurrentTime + + + + + + +Errors: +Match, +Value, +Window + + + + + + + + + +This request changes the input focus and the last-focus-change time. +The request has no effect if the specified time is earlier than the current +last-focus-change time or is later than the current server time. +Otherwise, the last-focus-change time is set to the specified time +with +CurrentTime +replaced by the current server time. + + +If +None +is specified as the focus, +all keyboard events are discarded until a new focus window is set. +In this case, the revert-to argument is ignored. + + +If a window is specified as the focus, +it becomes the keyboard's focus window. +If a generated keyboard event would normally be reported to +this window or one of its inferiors, the event is reported normally. +Otherwise, the event is reported with respect to the focus window. + + +If +PointerRoot +is specified as the focus, +the focus window is dynamically taken to be the root window of whatever screen +the pointer is on at each keyboard event. +In this case, +the revert-to argument is ignored. + + +This request generates +FocusIn +and +FocusOut +events. + + +The specified focus window must be viewable at the time of the request (or a +Match +error results). +If the focus window later becomes not viewable, +the new focus window depends on the revert-to argument. +If revert-to is +Parent, +the focus reverts to the parent (or the closest viewable ancestor) +and the new revert-to value is taken to be +None. +If revert-to is +PointerRoot +or +None, +the focus reverts to that value. +When the focus reverts, +FocusIn +and +FocusOut +events are generated, +but the last-focus-change time is not affected. + + +
+
+ GetInputFocus + GetInputFocus + + + + + + + + ▶ + + + + + +focus: WINDOW or +PointerRoot +or +None + + + + +revert-to: +{ Parent, +PointerRoot, +None} + + + + + + + + + +This request returns the current focus state. + + +
+
+ QueryKeymap + QueryKeymap + + + + + + + + ▶ + + + + + +keys: LISTofCARD8 + + + + + + + + + +This request returns a bit vector for the logical state of the keyboard. +Each bit set to 1 indicates that the corresponding key is currently pressed. +The vector is represented as 32 bytes. +Byte N (from 0) contains the bits for keys 8N to 8N + 7 +with the least significant bit in the byte representing key 8N. +Note that the logical state of a device (as seen by means of the protocol) +may lag the physical state if device event processing is frozen. + + +
+
+ OpenFont + OpenFont + Font + + + + + + + + +fid: FONT + + + + +name: STRING8 + + + + + + +Errors: +Alloc, +IDChoice, +Name + + + + + + + + + +This request loads the specified font, if necessary, +and associates identifier fid with it. +The font name should use the ISO Latin-1 encoding, +and uppercase and lowercase do not matter. +When the characters ? and * are used in a font name, a +pattern match is performed and any matching font is used. +In the pattern, +the ? character (octal value 77) will match any single character, +and the * character (octal value 52) will match any number +of characters. +A structured format for font names is specified in the +X.Org standard X Logical Font Description Conventions. + + +Fonts are not associated with a particular screen +and can be stored as a component of any graphics context. + + +
+
+ CloseFont + CloseFont + + + + + + + + +font: FONT + + + + + + +Errors: +Font + + + + + + + + + +This request deletes the association between the resource ID and the font. +The font itself will be freed when no other resource references it. + + +
+
+ QueryFont + QueryFont + + + + + + + + + + + +font: FONTABLE + + + + + + ▶ + + + + + +font-info: FONTINFO + + + + +char-infos: LISTofCHARINFO + + + + + + +where: + + + + +FONTINFO: + + +[draw-direction: +{ LeftToRight, +RightToLeft } + + + + +min-char-or-byte2, max-char-or-byte2: CARD16 + + + + +min-byte1, max-byte1: CARD8 + + + + +all-chars-exist: BOOL + + + + +default-char: CARD16 + + + + +min-bounds: CHARINFO + + + + +max-bounds: CHARINFO + + + + +font-ascent: INT16 + + + + +font-descent: INT16 + + + + +properties: LISTofFONTPROP] + + + + +FONTPROP: + + +[name: ATOM + + + + +value: <32-bit-value>] + + + + +CHARINFO: + + +[left-side-bearing: INT16 + + + + +right-side-bearing: INT16 + + + + +character-width: INT16 + + + + +ascent: INT16 + + + + +descent: INT16 + + + + +attributes: CARD16] + + + + + +Errors: +Font + + + + + + + + + +This request returns logical information about a font. +If a gcontext is given for font, +the currently contained font is used. + + +The draw-direction is just a hint +and indicates whether most char-infos have a positive, +LeftToRight, +or a negative, +RightToLeft, +character-width metric. +The core protocol defines no support for vertical text. + + +If min-byte1 and max-byte1 are both zero, +then min-char-or-byte2 specifies the linear character index corresponding +to the first element of char-infos, +and max-char-or-byte2 specifies the linear character index of the last element. +If either min-byte1 or max-byte1 are nonzero, +then both min-char-or-byte2 and max-char-or-byte2 will be less than 256, +and the 2-byte character index values corresponding to char-infos element N +(counting from 0) are: + + byte1 = N/D + min-byte1 + byte2 = N\\D + min-char-or-byte2 + + + +where: + + D = max-char-or-byte2 - min-char-or-byte2 + 1 + / = integer division + \\ = integer modulus + + + +If char-infos has length zero, +then min-bounds and max-bounds will be identical, +and the effective char-infos is one filled with this char-info, of length: + + L = D * (max-byte1 - min-byte1 + 1) + + + +That is, +all glyphs in the specified linear or matrix range have the same information, +as given by min-bounds (and max-bounds). +If all-chars-exist is +True, +then all characters in char-infos have nonzero bounding boxes. + + +The default-char specifies the character that will be used when an +undefined or nonexistent character is used. +Note that default-char is a CARD16, not CHAR2B. +For a font using 2-byte matrix format, +the default-char has byte1 in the most significant byte +and byte2 in the least significant byte. +If the default-char itself specifies an undefined or nonexistent character, +then no printing is performed for an undefined or nonexistent character. + + +The min-bounds and max-bounds contain the minimum and maximum values of +each individual CHARINFO component over all char-infos (ignoring +nonexistent characters). +The bounding box of the font (that is, the +smallest rectangle enclosing the shape obtained by superimposing all +characters at the same origin [x,y]) has its upper-left coordinate at: + + [x + min-bounds.left-side-bearing, y - max-bounds.ascent] + +with a width of: + + max-bounds.right-side-bearing - min-bounds.left-side-bearing + + + +and a height of: + + max-bounds.ascent + max-bounds.descent + + + +The font-ascent is the logical extent of the font above the baseline +and is used for determining line spacing. +Specific characters may extend beyond this. +The font-descent is the logical extent of the font at or below the baseline +and is used for determining line spacing. +Specific characters may extend beyond this. +If the baseline is at Y-coordinate y, +then the logical extent of the font is inclusive +between the Y-coordinate values (y - font-ascent) and (y + font-descent - 1). + + +A font is not guaranteed to have any properties. +The interpretation of the property value (for example, INT32, CARD32) +must be derived from a priori knowledge of the property. +A basic set of font properties is specified in the X.Org +standard X Logical Font Description Conventions. + + +For a character origin at [x,y], +the bounding box of a character (that is, +the smallest rectangle enclosing the character's shape), described in +terms of CHARINFO components, is a rectangle with its upper-left corner at: + + [x + left-side-bearing, y - ascent] + + + +with a width of: + + right-side-bearing - left-side-bearing + + + +and a height of: + + ascent + descent + + + +and the origin for the next character is defined to be: + + [x + character-width, y] + + + +Note that the baseline is logically viewed as being just below +nondescending characters (when descent is zero, only pixels with +Y-coordinates less than y are drawn) and that the origin is logically +viewed as being coincident with the left edge of a nonkerned character +(when left-side-bearing is zero, no pixels with X-coordinate less than +x are drawn). + + +Note that CHARINFO metric values can be negative. + + +A nonexistent character is represented with all CHARINFO components +zero. + + +The interpretation of the per-character attributes field is +server-dependent. + + +
+
+ QueryTextExtents + QueryTextExtents + + + + + + + + +font: FONTABLE + + + + +string: STRING16 + + + + + + ▶ + + + + + +draw-direction: +{ LeftToRight, +RightToLeft} + + + + +font-ascent: INT16 + + + + +font-descent: INT16 + + + + +overall-ascent: INT16 + + + + +overall-descent: INT16 + + + + +overall-width: INT32 + + + + +overall-left: INT32 + + + + +overall-right: INT32 + + + + + + +Errors: +Font + + + + + + + + + +This request returns the logical extents of the specified string of characters +in the specified font. +If a gcontext is given for font, +the currently contained font is used. +The draw-direction, font-ascent, and font-descent are the same as +described in +QueryFont. +The overall-ascent is the maximum of the ascent metrics of all characters +in the string, and the overall-descent is the maximum of the descent metrics. +The overall-width is the sum of the character-width metrics of all characters +in the string. +For each character in the string, +let W be the sum of the character-width metrics of all characters preceding it +in the string, +let L be the left-side-bearing metric of the character plus W, +and let R be the right-side-bearing metric of the character plus W. +The overall-left is the minimum L of all characters in the string, +and the overall-right is the maximum R. + + +For fonts defined with linear indexing rather than 2-byte matrix indexing, +the server will interpret each CHAR2B as a 16-bit number that +has been transmitted most significant byte first (that is, byte1 of the +CHAR2B is taken as the most significant byte). + + +Characters with all zero metrics are ignored. +If the font has no defined default-char, +then undefined characters in the string are also ignored. + + +
+
+ ListFonts + ListFonts + + + + + + + + +pattern: STRING8 + + + + +max-names: CARD16 + + + + + + ▶ + + + + + +names: LISTofSTRING8 + + + + + + + + + +This request returns a list +of available font names (as controlled by the font search path; see +SetFontPath +request) +that match the pattern. +At most, max-names names will be returned. +The pattern should use the ISO Latin-1 encoding, +and uppercase and lowercase do not matter. +In the pattern, +the ? character (octal value 77) will match any single character, +and the * character (octal value 52) will match any number +of characters. +The returned names are in lowercase. + + +
+
+ ListFontsWithInfo + ListFontsWithInfo + + + + + + + + +pattern: STRING8 + + + + +max-names: CARD16 + + + + + + ▶ + + + + + +name: STRING8 + + + + +info FONTINFO + + + + +replies-hint: CARD32 + + + + + + +where: + + + + + + +FONTINFO: <same type definition as in +QueryFont> + + + + + + + + +This request is similar to +ListFonts, +but it also returns information about each font. +The information returned for each font is identical to what +QueryFont +would return except that the per-character metrics are not returned. +Note that this request can generate multiple replies. +With each reply, +replies-hint may provide an indication of how many more fonts will be returned. +This number is a hint only and may be larger or smaller than +the number of fonts actually returned. +A zero value does not guarantee that no more fonts will be returned. +After the font replies, +a reply with a zero-length name is sent to indicate the end of the reply +sequence. + + +
+
+ SetFontPath + SetFontPath + + + + + + + + +path: LISTofSTRING8 + + + + + + +Errors: +Value + + + + + + + + + +This request defines the search path for font lookup. +There is only one search path per server, not one per client. +The interpretation of the strings is operating-system-dependent, +but the strings are intended to specify directories to be searched in the +order listed. + + +Setting the path to the empty list restores the default path defined +for the server. + + +As a side effect of executing this request, +the server is guaranteed to flush all cached information about fonts +for which there currently are no explicit resource IDs allocated. + + +The meaning of an error from this request is system specific. + + +
+
+ GetFontPath + GetFontPath + + + + + + + + ▶ + + + + + +path: LISTofSTRING8 + + + + + + + + + +This request returns the current search path for fonts. + + +
+
+ CreatePixmap + CreatePixmap + + + + + + + + +pid: PIXMAP + + + + +drawable: DRAWABLE + + + + +depth: CARD8 + + + + +width, height: CARD16 + + + + + + +Errors: +Alloc, +Drawable, +IDChoice, +Value + + + + + + + + + +This request creates a pixmap and assigns the identifier pid to it. +The width and height must be nonzero (or a +Value +error results). +The depth must be one of the depths supported by the root of the specified +drawable (or a +Value +error results). +The initial contents of the pixmap are undefined. + + +It is legal to pass an +InputOnly +window as a drawable to this request. + + +
+
+ FreePixmap + FreePixmap + + + + + + + + +pixmap: PIXMAP + + + + + + +Errors: +Pixmap + + + + + + + + + +This request deletes the association between the resource ID and the pixmap. +The pixmap storage will be freed when no other resource references it. + + +
+
+ CreateGC + CreateGC + Graphics context + + + + + + + + +cid: GCONTEXT + + + + +drawable: DRAWABLE + + + + +value-mask: BITMASK + + + + +value-list: LISTofVALUE + + + + + + +Errors: +Alloc, +Drawable, +Font, +IDChoice, +Match, +Pixmap, +Value + + + + + + + + + +This request creates a graphics context +and assigns the identifier cid to it. +The gcontext can be used with any destination drawable having the same root +and depth as the specified drawable; +use with other drawables results in a +Match +error. + + +The value-mask and value-list specify which components are to be +explicitly initialized. +The context components are: + + + + + + + + + + Component + Type + + + + + function + +{ Clear, +And, +AndReverse, +Copy, +AndInverted, +NoOp, +Xor, +Or, +Nor, +Equiv, +Invert, +OrReverse, +CopyInverted, +OrInverted, +Nand, +Set } + + + + plane-mask + CARD32 + + + foreground + CARD32 + + + background + CARD32 + + + line-width + CARD16 + + + line-style + +{ Solid, +OnOffDash, +DoubleDash } + + + + cap-style + +{ NotLast, +Butt, +Round, +Projecting } + + + + join-style + +{ Miter, +Round, +Bevel } + + + + fill-style + +{ Solid, +Tiled, +OpaqueStippled, +Stippled } + + + + fill-rule + +{ EvenOdd, +Winding } + + + + arc-mode + +{ Chord, +PieSlice } + + + + tile + PIXMAP + + + stipple + PIXMAP + + + tile-stipple-x-origin + INT16 + + + tile-stipple-y-origin + INT16 + + + font + FONT + + + subwindow-mode + +{ ClipByChildren, +IncludeInferiors } + + + + graphics-exposures + BOOL + + + clip-x-origin + INT16 + + + clip-y-origin + INT16 + + + clip-mask + +PIXMAP or +None + + + + dash-offset + CARD16 + + + dashes + CARD8 + + + + + + +Planemask +In graphics operations, +given a source and destination pixel, +the result is computed bitwise on corresponding bits of the pixels; +that is, a Boolean operation is performed in each bit plane. +The plane-mask restricts the operation to a subset of planes, +so the result is: + + + + ((src FUNC dst) AND plane-mask) OR (dst AND (NOT plane-mask)) + + + +Range checking is not performed on the values for foreground, background, +or plane-mask. +They are simply truncated to the appropriate number of bits. + + + +The meanings of the functions are: + + + + + + + + + + Function + Operation + + + + + +Clear + + 0 + + + +And + + src AND dst + + + +AndReverse + + src AND (NOT dst) + + + +Copy + + src + + + +AndInverted + + (NOT src) AND dst + + + +NoOp + + dst + + + +Xor + + src XOR dst + + + +Or + + src OR dst + + + +Nor + + (NOT src) AND (NOT dst) + + + +Equiv + + (NOT src) XOR dst + + + +Invert + + NOT dst + + + +OrReverse + + src OR (NOT dst) + + + +CopyInverted + + NOT src + + + +OrInverted + + (NOT src) OR dst + + + +Nand + + (NOT src) OR (NOT dst) + + + +Set + + 1 + + + + + + +Linedrawing +The line-width is measured in pixels and can be greater than or equal to +one, a wide line, or the special value zero, a thin line. + + + +Wide lines are drawn centered on the path described by the graphics request. +Unless otherwise specified by the join or cap style, +the bounding box of a wide line with endpoints [x1, y1], [x2, y2] and +width w is a rectangle with vertices at the following real coordinates: + + + + [x1-(w*sn/2), y1+(w*cs/2)], [x1+(w*sn/2), y1-(w*cs/2)], + [x2-(w*sn/2), y2+(w*cs/2)], [x2+(w*sn/2), y2-(w*cs/2)] + + + +The sn is the sine of the angle of the line and cs is the cosine of +the angle of the line. +A pixel is part of the line (and hence drawn) if the center of the pixel +is fully inside the bounding box, which is viewed as having infinitely thin +edges. +If the center of the pixel is exactly on the bounding box, +it is part of the line if and only if the interior is immediately to its right +(x increasing direction). +Pixels with centers on a horizontal edge are a special case and are part of +the line if and only if the interior or the boundary is immediately below +(y increasing direction) and if the interior or the boundary is immediately +to the right (x increasing direction). +Note that this description is a mathematical model describing the pixels +that are drawn for a wide line and does not imply that trigonometry is required +to implement such a model. +Real or fixed point arithmetic is recommended for computing the corners of the +line endpoints for lines greater than one pixel in width. + + +Thin lines (zero line-width) are nominally one pixel wide lines drawn using an +unspecified, device-dependent algorithm. +There are only two constraints on this algorithm. +First, if a line is drawn unclipped from [x1,y1] to [x2,y2] +and another line is drawn unclipped from [x1+dx,y1+dy] to [x2+dx,y2+dy], +then a point [x,y] is touched by drawing the first line if +and only if the point [x+dx,y+dy] is touched by drawing the second line. +Second, the effective set of points comprising a line cannot be affected +by clipping. +Thus, a point is touched in a clipped line if and only if the point lies +inside the clipping region and the point would be touched by the line +when drawn unclipped. + + +Note that a wide line drawn from [x1,y1] to [x2,y2] always draws the +same pixels as a wide line drawn from [x2,y2] to [x1,y1], not counting +cap-style and join-style. +Implementors are encouraged to make this property true for thin lines, +but it is not required. +A line-width of zero may differ from a line-width of one in which pixels +are drawn. +In general, +drawing a thin line will be faster than drawing a wide line of width one, +but thin lines may not mix well aesthetically with wide lines +because of the different drawing algorithms. +If it is desirable to obtain precise and uniform results across all displays, +a client should always use a line-width of one, rather than a line-width of +zero. + + +The line-style defines which sections of a line are drawn: + + + + + + + + + + +Solid + + +The full path of the line is drawn. + + + + +DoubleDash + + +The full path of the line is drawn, +but the even dashes are filled differently than the odd dashes +(see fill-style), with +Butt +cap-style used where even and odd dashes meet. + + + + +OnOffDash + + +Only the even dashes are drawn, +and cap-style applies to all internal ends of the individual dashes +(except +NotLast +is treated as +Butt). + + + + + + + +The cap-style defines how the endpoints of a path are drawn: + + + + + + + + + + +NotLast + + +The result is equivalent to +Butt, +except that for a line-width of zero the final endpoint is not drawn. + + + + +Butt + + +The result is square at the endpoint (perpendicular to the slope of the +line) with no projection beyond. + + + + +Round + + +The result is a circular arc with its diameter equal to the line-width, +centered on the endpoint; it is equivalent to +Butt +for line-width zero. + + + + +Projecting + + +The result is square at the end, but the path continues beyond the +endpoint for a distance equal to half the line-width; +it is equivalent to +Butt +for line-width zero. + + + + + + + + + +The join-style defines how corners are drawn for wide lines: + + + + + + + + + + +Miter + + +The outer edges of the two lines extend to meet at an angle. +However, if the angle is less than 11 degrees, a +Bevel +join-style is used instead. + + + + +Round + + +The result is a circular arc with a diameter equal to the line-width, +centered on the joinpoint. + + + + +Bevel + + +The result is +Butt +endpoint styles, and then the triangular notch is filled. + + + + + + + + +For a line with coincident endpoints (x1=x2, y1=y2), when the cap-style +is applied to both endpoints, the semantics depends on the line-width +and the cap-style: + + + + + + + + + + + +NotLast + + thin + +This is device-dependent, but the desired effect is that nothing is drawn. + + + + +Butt + + thin + +This is device-dependent, but the desired effect is that +a single pixel is drawn. + + + + +Round + + thin + +This is the same as +Butt/thin. + + + + +Projecting + + thin + +This is the same as +Butt/thin. + + + + +Butt + + wide + +Nothing is drawn. + + + + +Round + + wide + +The closed path is a circle, centered at the endpoint and +with a diameter equal to the line-width. + + + + +Projecting + + wide + +The closed path is a square, aligned with the coordinate axes, +centered at the endpoint and with sides equal to the line-width. + + + + + + + +For a line with coincident endpoints (x1=x2, y1=y2), +when the join-style is applied at one or both endpoints, +the effect is as if the line was removed from the overall path. +However, if the total path consists of (or is reduced to) a single point +joined with itself, +the effect is the same as when the cap-style is applied at both endpoints. + + +The tile/stipple represents an infinite two-dimensional plane +with the tile/stipple +replicated in all dimensions. When that plane is superimposed on +the drawable for use in a graphics operation, the upper-left corner +of some instance of the tile/stipple is at the coordinates within +the drawable specified by the tile/stipple origin. +The tile/stipple and clip origins are interpreted relative to the +origin of whatever destination drawable is specified in a graphics +request. + + +The tile pixmap must have the same root and depth as the gcontext (or a +Match +error results). +The stipple pixmap must have depth one and must have the same root +as the gcontext (or a +Match +error results). +For fill-style +Stippled +(but not fill-style +OpaqueStippled), +the stipple pattern is tiled in a single plane +and acts as an additional clip mask to be ANDed with the clip-mask. +Any size pixmap can be used for tiling or stippling, +although some sizes may be faster to use than others. + + +The fill-style defines the contents of the source for line, text, and +fill requests. +For all text and fill requests (for example, +PolyText8, +PolyText16, +PolyFillRectangle, +FillPoly, +and +PolyFillArc) +as well as for line requests with line-style +Solid, +(for example, +PolyLine, +PolySegment, +PolyRectangle, +PolyArc ) +and for the even dashes for line requests with line-style +OnOffDash +or +DoubleDash: + + + + + + + + + + +Solid + + Foreground + + + +Tiled + + Tile + + + +OpaqueStippled + + +A tile with the same width and height as stipple +but with background everywhere stipple has a zero +and with foreground everywhere stipple has a one + + + + +Stippled + + +Foreground masked by stipple + + + + + + + +For the odd dashes for line requests with line-style +DoubleDash: + + + + + + + + + + +Solid + + Background + + + +Tiled + + Same as for even dashes + + + +OpaqueStippled + + Same as for even dashes + + + +Stippled + + Background masked by stipple + + + + + + + +The dashes value allowed here is actually a simplified form of the more +general patterns that can be set with +SetDashes. +Specifying a value of N here is equivalent to specifying +the two element list [N, N] in +SetDashes. +The value must be nonzero (or a +Value +error results). +The meaning of dash-offset and dashes are explained in the +SetDashes +request. + + +Clipping region +The clip-mask restricts writes to the destination drawable. +Only pixels where the clip-mask has bits set to 1 are drawn. +Pixels are not drawn outside the area covered by the clip-mask +or where the clip-mask has bits set to 0. +The clip-mask affects all graphics requests, +but it does not clip sources. +The clip-mask origin is interpreted relative to the origin of whatever +destination drawable is specified in a graphics request. +If a pixmap is specified as the clip-mask, +it must have depth 1 and have the same root as the gcontext (or a +Match +error results). +If clip-mask is +None, +then pixels are always drawn, regardless of the clip origin. +The clip-mask can also be set with the +SetClipRectangles +request. + + +For +ClipByChildren, +both source and destination windows are additionally clipped by all viewable +InputOutput +children. +For +IncludeInferiors, +neither source nor destination window is clipped by inferiors. +This will result in including subwindow contents in the +source and drawing through subwindow boundaries of the destination. +The use of +IncludeInferiors +with a source or destination window of one depth with mapped inferiors +of differing depth is not illegal, +but the semantics is undefined by the core protocol. + + +Winding rule +Fill rule +The fill-rule defines what pixels are inside (that is, are drawn) for +paths given in +FillPoly +requests. +EvenOdd +means a point is inside if an infinite ray with the point as origin crosses +the path an odd number of times. +For +Winding, +a point is inside if an infinite ray with the point as origin crosses an +unequal number of clockwise and counterclockwise directed path segments. +A clockwise directed path segment is one that crosses the ray from left +to right as observed from the point. +A counter-clockwise segment is one that crosses the ray from right to left +as observed from the point. +The case where a directed line segment is coincident with the ray is +uninteresting because one can simply choose a different ray that is not +coincident with a segment. + + +For both fill rules, +a point is infinitely small and the path is an infinitely thin line. +A pixel is inside if the center point of the pixel is inside +and the center point is not on the boundary. +If the center point is on the boundary, +the pixel is inside if and only if the polygon interior is immediately +to its right (x increasing direction). +Pixels with centers along a horizontal edge are a special case +and are inside if and only if the polygon interior is immediately below +(y increasing direction). + + +The arc-mode controls filling in the +PolyFillArc +request. + + +The graphics-exposures flag controls +GraphicsExposure +event generation for +CopyArea +and +CopyPlane +requests (and any similar requests defined by extensions). + + +The default component values are: + + + + + + + + + + Component + Default + + + + + function + +Copy + + + + plane-mask + all ones + + + foreground + 0 + + + background + 1 + + + line-width + 0 + + + line-style + Solid + + + cap-style + Butt + + + join-style + Miter + + + fill-style + Solid + + + fill-rule + EvenOdd + + + arc-mode + PieSlice + + + tile + + +Pixmap of unspecified size filled with foreground pixel + + +(that is, client specified pixel if any, else 0) + + +(subsequent changes to foreground do not affect this pixmap) + + + + + stipple + +Pixmap of unspecified size filled with ones + + + + tile-stipple-x-origin + 0 + + + tile-stipple-y-origin + 0 + + + font + <server-dependent-font> + + + subwindow-mode + +ClipByChildren + + + + graphics-exposures + +True + + + + clip-x-origin + 0 + + + clip-y-origin + 0 + + + clip-mask + +None + + + + dash-offset + 0 + + + dashes + 4 (that is, the list [4, 4]) + + + + + + +Storing a pixmap in a gcontext might or might not result in a copy +being made. +If the pixmap is later used as the destination for a graphics request, +the change might or might not be reflected in the gcontext. +If the pixmap is used simultaneously in a graphics request +as both a destination and as a tile or stipple, +the results are not defined. + + +It is quite likely that some amount of gcontext information will be +cached in display hardware and that such hardware can only cache a +small number of gcontexts. +Given the number and complexity of components, +clients should view switching between gcontexts with nearly +identical state as significantly more expensive than making minor +changes to a single gcontext. + + +
+
+ ChangeGC + ChangeGC + + + + + + + + +gc: GCONTEXT + + + + +value-mask: BITMASK + + + + +value-list: LISTofVALUE + + + + + + +Errors: +Alloc, +Font, +GContext, +Match, +Pixmap, +Value + + + + + + + + + +This request changes components in gc. +The value-mask and value-list specify which components are to be changed. +The values and restrictions are the same +as for +CreateGC. + + +Changing the clip-mask also overrides any previous +SetClipRectangles +request on the context. +Changing dash-offset or dashes overrides any previous +SetDashes +request on the context. + + +The order in which components are verified and altered is server-dependent. +If an error is generated, +a subset of the components may have been altered. + + +
+
+ CopyGC + CopyGC + + + + + + + + +src-gc, dst-gc: GCONTEXT + + + + +value-mask: BITMASK + + + + + + +Errors: +Alloc, +GContext, +Match, +Value + + + + + + + + + +This request copies components from src-gc to dst-gc. +The value-mask specifies which components to copy, as for +CreateGC. +The two gcontexts must have the same root and the same depth (or a +Match +error results). + + +
+
+ SetDashes + SetDashes + + + + + + + + +gc: GCONTEXT + + + + +dash-offset: CARD16 + + + + +dashes: LISTofCARD8 + + + + + + +Errors: +Alloc, +GContext, +Value + + + + + + + + + +This request sets dash-offset and dashes in gc for dashed line styles. +Dashes cannot be empty (or a +Value +error results). +Specifying an odd-length list is equivalent to specifying the same list +concatenated with itself to produce an even-length list. +The initial and alternating elements of dashes are the even dashes; +the others are the odd dashes. +Each element specifies a dash length in pixels. +All of the elements must be nonzero (or a +Value +error results). +The dash-offset defines the phase of the pattern, +specifying how many pixels into dashes the pattern should actually begin in +any single graphics request. +Dashing is continuous through path elements combined with a join-style +but is reset to the dash-offset between each sequence of joined lines. + + +The unit of measure for dashes is the same as in the ordinary +coordinate system. +Ideally, a dash length is measured along the slope of the line, +but implementations are only required to match this ideal +for horizontal and vertical lines. +Failing the ideal semantics, +it is suggested that the length be measured along the major axis of the line. +The major axis is defined as the x axis for lines drawn at an angle of +between -45 and +45 degrees or between 135 and 225 degrees from the x axis. +For all other lines, the major axis is the y axis. + + +For any graphics primitive, the computation of the endpoint of an individual +dash only depends on the geometry of the primitive, the start position +of the dash, the direction of the dash, and the dash length. + + +For any graphics primitive, the total set of pixels used to render the +primitive (both even and odd numbered dash elements) with +DoubleDash +line-style is the same as the set of pixels used to render the +primitive with +Solid +line-style. + + +For any graphics primitive, if the primitive is drawn with +OnOffDash +or +DoubleDash +line-style unclipped at position [x,y] and again at position +[x+dx,y+dy], then a point [x1,y1] is included in a dash in the first +instance if and only if the point [x1+dx,y1+dy] is included in the dash in +the second instance. In addition, the effective set of points comprising a +dash cannot be affected by clipping. A point is included in a clipped dash +if and only if the point lies inside the clipping region and the point +would be included in the dash when drawn unclipped. + + +
+
+ SetClipRectangles + SetClipRectangles + + + + + + + + +gc: GCONTEXT + + + + +clip-x-origin, clip-y-origin: INT16 + + + + +rectangles: LISTofRECTANGLE + + + + +ordering: +{ UnSorted, +YSorted, +YXSorted, +YXBanded} + + + + + + +Errors: +Alloc, +GContext, +Match, +Value + + + + + + + + + +This request changes clip-mask in gc to the specified list of rectangles +and sets the clip origin. +Output will be clipped to remain contained within the rectangles. +The clip origin is interpreted relative to the origin of +whatever destination drawable is specified in a graphics request. +The rectangle coordinates are interpreted relative to the clip origin. +The rectangles should be nonintersecting, or graphics results will be +undefined. +Note that the list of rectangles can be empty, +which effectively disables output. +This is the opposite of passing +None +as the clip-mask in +CreateGC +and +ChangeGC. + + +If known by the client, +ordering relations on the rectangles can be specified with the ordering +argument. +This may provide faster operation by the server. +If an incorrect ordering is specified, +the server may generate a +Match +error, but it is not required to do so. +If no error is generated, +the graphics results are undefined. +UnSorted +means that the rectangles are in arbitrary order. +YSorted +means that the rectangles are nondecreasing in their Y origin. +YXSorted +additionally constrains +YSorted +order in that all rectangles with an equal Y origin are +nondecreasing in their X origin. +YXBanded +additionally constrains +YXSorted +by requiring that, for every possible Y scanline, +all rectangles that include that scanline have identical Y origins and Y +extents. + + +
+
+ FreeGC + FreeGC + + + + + + + + +gc: GCONTEXT + + + + + + +Errors: +GContext + + + + + + + + + +This request deletes the association between the resource ID and the gcontext +and destroys the gcontext. + + +
+
+ ClearArea + ClearArea + Background + + + + + + + +window: WINDOW + + + + +x, y: INT16 + + + + +width, height: CARD16 + + + + +exposures: BOOL + + + + + + +Errors: +Match, +Value, +Window + + + + + + + + + +The x and y coordinates are relative to the window's origin +and specify the upper-left corner of the rectangle. +If width is zero, +it is replaced with the current width of the window minus x. +If height is zero, +it is replaced with the current height of the window minus y. +If the window has a defined background tile, +the rectangle is tiled with a plane-mask of all ones and function of +Copy +and a subwindow-mode of +ClipByChildren. +If the window has background +None, +the contents of the window are not changed. +In either case, +if exposures is +True, +then one or more exposure events are generated for regions of the rectangle +that are either visible or are being retained in a backing store. + + +It is a +Match +error to use an +InputOnly +window in this request. + + +
+
+ CopyArea + CopyArea + + + + + + + + +src-drawable, dst-drawable: DRAWABLE + + + + +gc: GCONTEXT + + + + +src-x, src-y: INT16 + + + + +width, height: CARD16 + + + + +dst-x, dst-y: INT16 + + + + + + +Errors: +Drawable, +GContext, +Match + + + + + + + + + +This request combines the specified rectangle of src-drawable with the +specified rectangle of dst-drawable. +The src-x and src-y coordinates are relative to src-drawable's origin. +The dst-x and dst-y are relative to dst-drawable's origin, +each pair specifying the upper-left corner of the rectangle. +The src-drawable must have the same root and the same depth +as dst-drawable (or a +Match +error results). + + +If regions of the source rectangle are obscured and have not been retained +in backing store +or if regions outside the boundaries of the source drawable are specified, +then those regions are not copied, +but the following occurs on all corresponding destination regions that are +either visible or are retained in backing-store. +If the dst-drawable is a window with a background other than +None, +these corresponding destination regions are tiled +(with plane-mask of all ones and function +Copy) +with that background. +Regardless of tiling and whether the destination is a window or a pixmap, +if graphics-exposures in gc is +True, +then +GraphicsExposure +events for all corresponding destination regions are generated. + + +If graphics-exposures is +True +but no +GraphicsExposure +events are generated, +then a +NoExposure +event is generated. + + +GC components: function, plane-mask, subwindow-mode, +graphics-exposures, clip-x-origin, clip-y-origin, clip-mask + + +
+
+ CopyPlane + CopyPlane + + + + + + + + +src-drawable, dst-drawable: DRAWABLE + + + + +gc: GCONTEXT + + + + +src-x, src-y: INT16 + + + + +width, height: CARD16 + + + + +dst-x, dst-y: INT16 + + + + +bit-plane: CARD32 + + + + + + +Errors: +Drawable, +GContext, +Match, +Value + + + + + + + + + +The src-drawable must have the same root as dst-drawable (or a +Match +error results), but it need not have the same depth. +The bit-plane must have exactly one bit set to 1 and the value of bit-plane +must be less than %2 sup n% where n is the depth of src-drawable (or a +Value +error results). +Effectively, a pixmap of the same depth as dst-drawable and with size specified +by the source region is formed using the foreground/background pixels in gc +(foreground everywhere the bit-plane in src-drawable contains a bit set to 1, +background everywhere the bit-plane contains a bit set to 0), +and the equivalent of a +CopyArea +is performed, with all the same exposure semantics. +This can also be thought of as using the specified region of the source +bit-plane as a stipple with a fill-style of +OpaqueStippled +for filling a rectangular area of the destination. + + +GC components: function, plane-mask, foreground, background, +subwindow-mode, graphics-exposures, clip-x-origin, clip-y-origin, +clip-mask + + +
+
+ PolyPoint + PolyPoint + + + + + + + + +drawable: DRAWABLE + + + + +gc: GCONTEXT + + + + +coordinate-mode: +{ Origin, +Previous} + + + + +points: LISTofPOINT + + + + + + +Errors: +Drawable, +GContext, +Match, +Value + + + + + + + + + +This request combines the foreground pixel in gc with the pixel +at each point in the drawable. +The points are drawn in the order listed. + + +The first point is always relative to the drawable's origin. +The rest are relative either to that origin or the previous point, +depending on the coordinate-mode. + + +GC components: function, plane-mask, foreground, subwindow-mode, +clip-x-origin, clip-y-origin, clip-mask + + +
+
+ PolyLine + PolyLine + Linedrawing + + + + + + + + +drawable: DRAWABLE + + + + +gc: GCONTEXT + + + + +coordinate-mode: +{ Origin, +Previous} + + + + +points: LISTofPOINT + + + + + + +Errors: +Drawable, +GContext, +Match, +Value + + + + + + + + + +This request draws lines between each pair of points (point[i], point[i+1]). +The lines are drawn in the order listed. +The lines join correctly at all intermediate points, +and if the first and last points coincide, +the first and last lines also join correctly. + + +For any given line, +no pixel is drawn more than once. +If thin (zero line-width) lines intersect, +the intersecting pixels are drawn multiple times. +If wide lines intersect, +the intersecting pixels are drawn only once, as though the entire +PolyLine +were a single filled shape. + + +The first point is always relative to the drawable's origin. +The rest are relative either to that origin or the previous point, +depending on the coordinate-mode. + + +When either of the two lines involved in a +Bevel +join is neither vertical +nor horizontal, then the slope and position of the line segment defining +the bevel join edge is implementation dependent. However, the computation +of the slope and distance (relative to the join point) only depends on +the line width and the slopes of the two lines. + + +GC components: function, plane-mask, line-width, line-style, +cap-style, join-style, fill-style, subwindow-mode, clip-x-origin, +clip-y-origin, clip-mask + + +GC mode-dependent components: foreground, background, tile, stipple, +tile-stipple-x-origin, tile-stipple-y-origin, dash-offset, dashes + + +
+
+ PolySegment + PolySegment + + + + + + + + +drawable: DRAWABLE + + + + +gc: GCONTEXT + + + + +segments: LISTofSEGMENT + + + + + + +where: + + + + + + +SEGMENT: [x1, y1, x2, y2: INT16] + + + + + + +Errors: +Drawable, +GContext, +Match + + + + + + + + + +For each segment, +this request draws a line between [x1, y1] and [x2, y2]. +The lines are drawn in the order listed. +No joining is performed at coincident endpoints. +For any given line, +no pixel is drawn more than once. +If lines intersect, +the intersecting pixels are drawn multiple times. + + +GC components: function, plane-mask, line-width, line-style, +cap-style, fill-style, subwindow-mode, clip-x-origin, clip-y-origin, +clip-mask + + +GC mode-dependent components: foreground, background, tile, stipple, +tile-stipple-x-origin, tile-stipple-y-origin, dash-offset, dashes + + +
+
+ PolyRectangle + PolyRectangle + + + + + + + + +drawable: DRAWABLE + + + + +gc: GCONTEXT + + + + +rectangles: LISTofRECTANGLE + + + + + + +Errors: +Drawable, +GContext, +Match + + + + + + + + + +This request draws the outlines of the specified rectangles, as if a five-point +PolyLine +were specified for each rectangle: + + + + [x,y] [x+width,y] [x+width,y+height] [x,y+height] [x,y] + + + +The x and y coordinates of each rectangle are relative to the drawable's origin +and define the upper-left corner of the rectangle. + + +The rectangles are drawn in the order listed. +For any given rectangle, +no pixel is drawn more than once. +If rectangles intersect, +the intersecting pixels are drawn multiple times. + + +GC components: function, plane-mask, line-width, line-style, +cap-style, join-style, fill-style, subwindow-mode, clip-x-origin, +clip-y-origin, clip-mask + + +GC mode-dependent components: foreground, background, tile, stipple, +tile-stipple-x-origin, tile-stipple-y-origin, dash-offset, dashes + + +
+
+ PolyArc + PolyArc + + + + + + + + +drawable: DRAWABLE + + + + +gc: GCONTEXT + + + + +arcs: LISTofARC + + + + + + +Errors: +Drawable, +GContext, +Match + + + + + + + + + +This request draws circular or elliptical arcs. +Each arc is specified by a rectangle and two angles. +The angles are signed integers in degrees scaled by 64, +with positive indicating counterclockwise motion and +negative indicating clockwise motion. +The start of the arc is specified by angle1 relative to the three-o'clock +position from the center of the rectangle, +and the path and extent of the arc is specified by angle2 relative to the +start of the arc. +If the magnitude of angle2 is greater than 360 degrees, +it is truncated to 360 degrees. +The x and y coordinates of the rectangle are relative to the origin of +the drawable. +For an arc specified as [x,y,w,h,a1,a2], +the origin of the major and minor axes is at [x+(w/2),y+(h/2)], +and the infinitely thin path describing the entire circle/ellipse intersects +the horizontal axis at [x,y+(h/2)] and [x+w,y+(h/2)] and intersects the +vertical axis at [x+(w/2),y] and [x+(w/2),y+h]. +These coordinates are not necessarily integral; that is, +they are not truncated to discrete coordinates. + + +For a wide line with line-width lw, the ideal bounding outlines for filling +are given by the two infinitely thin paths consisting of all points whose +perpendicular distance from a tangent to the path of the circle/ellipse is +equal to lw/2 (which may be a fractional value). When the width and height +of the arc are not equal and both are nonzero, then the actual bounding +outlines are implementation dependent. However, the computation of the +shape and position of the bounding outlines (relative to the center of the +arc) only depends on the width and height of the arc and the +line-width. + + +The cap-style is applied the same as for a line corresponding to the +tangent of the circle/ellipse at the endpoint. When the angle of an arc +face is not an integral multiple of 90 degrees, and the width and height of +the arc are both are nonzero, then the shape and position of the cap at +that face is implementation dependent. However, for a +Butt +cap, the face +is defined by a straight line, and the computation of the position +(relative to the center of the arc) and the slope of the line only +depends on the width and height of the arc and the angle of the arc face. +For other cap styles, the computation of the position (relative to the +center of the arc) and the shape of the cap only depends on the width +and height of the arc, the line-width, the angle of the arc face, and the +direction (clockwise or counter clockwise) of the arc from the endpoint. + + +The join-style is applied the same as for two lines corresponding to the +tangents of the circles/ellipses at the join point. When the width and +height of both arcs are nonzero, and the angle of either arc face is not an +integral multiple of 90 degrees, then the shape of the join is +implementation dependent. However, the computation of the shape only +depends on the width and height of each arc, the line-width, the angles of +the two arc faces, the direction (clockwise or counter clockwise) of the +arcs from the join point, and the relative orientation of the two arc +center points. + + +For an arc specified as [x,y,w,h,a1,a2], +the angles must be specified in the effectively skewed coordinate system of +the ellipse (for a circle, the angles and coordinate systems are identical). +The relationship between these angles and angles expressed in the normal +coordinate system of the screen (as measured with a protractor) is as +follows: + + skewed-angle = atan(tan(normal-angle) * w/h) + adjust + + + +The skewed-angle and normal-angle are expressed in radians (rather +than in degrees scaled by 64) in the range [0,2*PI). +The atan returns a value in the range [-PI/2,PI/2]. +The adjust is: + + + + + + + + 0 + for normal-angle in the range [0,PI/2) + + + PI + for normal-angle in the range [PI/2,(3*PI)/2) + + + 2*PI + for normal-angle in the range [(3*PI)/2,2*PI) + + + + + + +The arcs are drawn in the order listed. +If the last point in one arc coincides with the first point in the following +arc, +the two arcs will join correctly. +If the first point in the first arc coincides with the last point +in the last arc, +the two arcs will join correctly. +For any given arc, +no pixel is drawn more than once. +If two arcs join correctly and the line-width is greater than zero +and the arcs intersect, +no pixel is drawn more than once. +Otherwise, the intersecting pixels of intersecting arcs are drawn multiple +times. +Specifying an arc with one endpoint and a clockwise extent draws the +same pixels as specifying the other endpoint and an equivalent +counterclockwise extent, except as it affects joins. + + +By specifying one axis to be zero, +a horizontal or vertical line can be drawn. + + +Angles are computed based solely on the coordinate system, +ignoring the aspect ratio. + + +GC components: function, plane-mask, line-width, line-style, +cap-style, join-style, fill-style, subwindow-mode, clip-x-origin, +clip-y-origin, clip-mask + + +GC mode-dependent components: foreground, background, tile, stipple, +tile-stipple-x-origin, tile-stipple-y-origin, dash-offset, dashes + + +
+
+ FillPoly + FillPoly + + + + + + + + +drawable: DRAWABLE + + + + +gc: GCONTEXT + + + + +shape: +{ Complex, +Nonconvex, +Convex} + + + + +coordinate-mode: +{ Origin, +Previous} + + + + +points: LISTofPOINT + + + + + + +Errors: +Drawable, +GContext, +Match, +Value + + + + + + + + + +This request fills the region closed by the specified path. +The path is closed automatically if the last point in the list does not +coincide with the first point. +No pixel of the region is drawn more than once. + + +The first point is always relative to the drawable's origin. +The rest are relative either to that origin or the previous point, +depending on the coordinate-mode. + + +The shape parameter may be used by the server to improve performance. +Complex +means the path may self-intersect. +Contiguous coincident points in the path are not treated +as self-intersection. + + +Nonconvex +means the path does not self-intersect, +but the shape is not wholly convex. +If known by the client, +specifying +Nonconvex +over +Complex +may improve performance. +If +Nonconvex +is specified for a self-intersecting path, +the graphics results are undefined. + + +Convex +means that for every pair of points inside the polygon, +the line segment connecting them does not intersect the path. +If known by the client, +specifying +Convex +can improve performance. +If +Convex +is specified for a path that is not convex, +the graphics results are undefined. + + +GC components: function, plane-mask, fill-style, fill-rule, +subwindow-mode, clip-x-origin, clip-y-origin, clip-mask + + +GC mode-dependent components: foreground, background, tile, stipple, +tile-stipple-x-origin, tile-stipple-y-origin + + +
+
+ PolyFillRectangle + PolyFillRectangle + + + + + + + + +drawable: DRAWABLE + + + + +gc: GCONTEXT + + + + +rectangles: LISTofRECTANGLE + + + + + + +Errors: +Drawable, +GContext, +Match + + + + + + + + + +This request fills the specified rectangles, as if a four-point +FillPoly +were specified for each rectangle: + + [x,y] [x+width,y] [x+width,y+height] [x,y+height] + + + +The x and y coordinates of each rectangle are relative to the drawable's origin +and define the upper-left corner of the rectangle. + + +The rectangles are drawn in the order listed. +For any given rectangle, +no pixel is drawn more than once. +If rectangles intersect, +the intersecting pixels are drawn multiple times. + + +GC components: function, plane-mask, fill-style, subwindow-mode, +clip-x-origin, clip-y-origin, clip-mask + + +GC mode-dependent components: foreground, background, tile, stipple, +tile-stipple-x-origin, tile-stipple-y-origin + + +
+
+ PolyFillArc + PolyFillArc + + + + + + + + +drawable: DRAWABLE + + + + +gc: GCONTEXT + + + + +arcs: LISTofARC + + + + + + +Errors: +Drawable, +GContext, +Match + + + + + + + + + +For each arc, +this request fills the region closed by the infinitely thin path +described by the specified arc and one or two line segments, +depending on the arc-mode. +For +Chord, +the single line segment joining the endpoints of the arc is used. +For +PieSlice, +the two line segments joining the endpoints of the arc with the center point +are used. + + +For an arc specified as [x,y,w,h,a1,a2], the origin of the major and minor +axes is at [x+(w/2),y+(h/2)], and the infinitely thin path describing the +entire circle/ellipse intersects the horizontal axis at [x,y+(h/2)] and +[x+w,y+(h/2)] and intersects the vertical axis at [x+(w/2),y] and +[x+(w/2),y+h]. These coordinates are not necessarily integral; that is, +they are not truncated to discrete coordinates. + + +The arc angles are interpreted as specified in the +PolyArc +request. When +the angle of an arc face is not an integral multiple of 90 degrees, then +the precise endpoint on the arc is implementation dependent. However, for +Chord +arc-mode, the computation of the pair of endpoints (relative to the +center of the arc) only depends on the width and height of the arc and +the angles of the two arc faces. For +PieSlice +arc-mode, the computation of +an endpoint only depends on the angle of the arc face for that +endpoint and the ratio of the arc width to arc height. + + +The arcs are filled in the order listed. +For any given arc, +no pixel is drawn more than once. +If regions intersect, +the intersecting pixels are drawn multiple times. + + +GC components: function, plane-mask, fill-style, arc-mode, +subwindow-mode, clip-x-origin, clip-y-origin, clip-mask + + +GC mode-dependent components: foreground, background, tile, stipple, +tile-stipple-x-origin, tile-stipple-y-origin + + +
+
+ PutImage + PutImage + + + + + + + + +drawable: DRAWABLE + + + + +gc: GCONTEXT + + + + +depth: CARD8 + + + + +width, height: CARD16 + + + + +dst-x, dst-y: INT16 + + + + +left-pad: CARD8 + + + + +format: +{ Bitmap, +XYPixmap, +ZPixmap} + + + + +data: LISTofBYTE + + + + + + +Errors: +Drawable, +GContext, +Match, +Value + + + + + + + + + +This request combines an image with a rectangle of the drawable. +The dst-x and dst-y coordinates are relative to the drawable's origin. + + +If +Bitmap +format is used, +then depth must be one (or a +Match +error results), and the image must be in XY format. +The foreground pixel in gc defines the source for bits set to 1 in the image, +and the background pixel defines the source for the bits set to 0. + + +For +XYPixmap +and +ZPixmap, +the depth must match the depth of the drawable (or a +Match +error results). +For +XYPixmap, +the image must be sent in XY format. +For +ZPixmap, +the image must be sent in the Z format defined for the given depth. + + +The left-pad must be zero for +ZPixmap +format (or a +Match +error results). +For +Bitmap +and +XYPixmap +format, +left-pad must be less than bitmap-scanline-pad as given in the server +connection setup information (or a +Match +error results). +The first left-pad bits in every scanline are to be ignored by the server. +The actual image begins that many bits into the data. +The width argument defines the width of the actual image +and does not include left-pad. + + +GC components: function, plane-mask, subwindow-mode, clip-x-origin, +clip-y-origin, clip-mask + + +GC mode-dependent components: foreground, background + + +
+
+ GetImage + GetImage + + + + + + + + +drawable: DRAWABLE + + + + +x, y: INT16 + + + + +width, height: CARD16 + + + + +plane-mask: CARD32 + + + + +format: +{ XYPixmap, +ZPixmap} + + + + + + ▶ + + + + + +depth: CARD8 + + + + +visual: VISUALID or +None + + + + +data: LISTofBYTE + + + + + + +Errors: +Drawable, +Match, +Value + + + + + + + + + +This request returns the contents of the given rectangle of the drawable in the +given format. +The x and y coordinates are relative to the drawable's origin +and define the upper-left corner of the rectangle. +If +XYPixmap +is specified, +only the bit planes specified in plane-mask are transmitted, +with the planes appearing from most significant to least significant +in bit order. +If +ZPixmap +is specified, then bits in all planes not specified in plane-mask are +transmitted as zero. +Range checking is not performed on plane-mask; +extraneous bits are simply ignored. +The returned depth is as specified when the drawable was created +and is the same as a depth component in a FORMAT structure (in the connection +setup), not a bits-per-pixel component. +If the drawable is a window, +its visual type is returned. +If the drawable is a pixmap, +the visual is +None. + + +If the drawable is a pixmap, +then the given rectangle must be wholly contained within the pixmap (or a +Match +error results). +If the drawable is a window, +the window must be viewable, +and it must be the case that, +if there were no inferiors or overlapping windows, +the specified rectangle of the window would be fully visible on the screen +and wholly contained within the outside edges of the window (or a +Match +error results). +Note that the borders of the window can be included and read with this request. +If the window has a backing store, +then the backing-store contents are returned for regions of the window +that are obscured by noninferior windows; +otherwise, the returned contents of such obscured regions are undefined. +Also undefined are the returned contents of visible +regions of inferiors of different depth than the specified window. +The pointer cursor image is not included in the contents returned. + + +This request is not general-purpose in the same sense as other +graphics-related requests. +It is intended specifically for rudimentary hardcopy support. + + +
+
+ PolyText8 + PolyText8 + + + + + + + + + + + +drawable: DRAWABLE + + + + +gc: GCONTEXT + + + + +x, y: INT16 + + + + +items: LISTofTEXTITEM8 + + + + + + +where: + + + + +TEXTITEM8: + + +TEXTELT8 or FONT + + + + +TEXTELT8: + + +[delta: INT8 + + + + +string: STRING8] + + + + + + +Errors: +Drawable, +Font, +GContext, +Match + + + + + + + + + +The x and y coordinates are relative to the drawable's origin +and specify the baseline starting position (the initial character origin). +Each text item is processed in turn. +A font item causes the font to be stored in gc +and to be used for subsequent text. +Switching among fonts does not affect the next character origin. +A text element delta specifies an additional change in the position +along the x axis before the string is drawn; +the delta is always added to the character origin. +Each character image, as defined by the font in gc, +is treated as an additional mask for a fill operation on the drawable. + + +All contained FONTs are always transmitted most significant byte first. + + +If a +Font +error is generated for an item, +the previous items may have been drawn. + + +For fonts defined with 2-byte matrix indexing, +each STRING8 byte is interpreted as a byte2 value of a CHAR2B with a byte1 +value of zero. + + +GC components: function, plane-mask, fill-style, font, +subwindow-mode, clip-x-origin, clip-y-origin, clip-mask + + +GC mode-dependent components: foreground, background, tile, stipple, +tile-stipple-x-origin, tile-stipple-y-origin + + +
+
+ PolyText16 + PolyText16 + + + + + + + + + + + +drawable: DRAWABLE + + + + +gc: GCONTEXT + + + + +x, y: INT16 + + + + +items: LISTofTEXTITEM16 + + + + + + +where: + + + + +TEXTITEM16: + + +TEXTELT16 or FONT + + + + +TEXTELT16: + + +[delta: INT8 + + + + +string: STRING16] + + + + + + +Errors: +Drawable, +Font, +GContext, +Match + + + + + + + + + +This request is similar to +PolyText8, +except 2-byte (or 16-bit) characters are used. +For fonts defined with linear indexing rather than 2-byte matrix indexing, +the server will interpret each CHAR2B as a 16-bit number that +has been transmitted most significant byte first (that is, byte1 of the +CHAR2B is taken as the most significant byte). + + +
+
+ ImageText8 + ImageText8 + + + + + + + + +drawable: DRAWABLE + + + + +gc: GCONTEXT + + + + +x, y: INT16 + + + + +string: STRING8 + + + + + + +Errors: +Drawable, +GContext, +Match + + + + + + + + + +The x and y coordinates are relative to the drawable's origin +and specify the baseline starting position (the initial character origin). +The effect is first to fill a destination rectangle with the background +pixel defined in gc and then to paint the text with the foreground pixel. +The upper-left corner of the filled rectangle is at: + + [x, y - font-ascent] + + + +the width is: + + overall-width + + + +and the height is: + + font-ascent + font-descent + + + +The overall-width, font-ascent, and font-descent are as +they would be returned by a +QueryTextExtents +call using gc and string. + + +The function and fill-style defined in gc are ignored for this request. +The effective function is +Copy, +and the effective fill-style +Solid. + + +For fonts defined with 2-byte matrix indexing, +each STRING8 byte is interpreted as a byte2 value of a CHAR2B with a byte1 +value of zero. + + +GC components: plane-mask, foreground, background, font, +subwindow-mode, clip-x-origin, clip-y-origin, clip-mask + + +
+
+ ImageText16 + ImageText16 + + + + + + + + +drawable: DRAWABLE + + + + +gc: GCONTEXT + + + + +x, y: INT16 + + + + +string: STRING16 + + + + + + +Errors: +Drawable, +GContext, +Match + + + + + + + + + +This request is similar to +ImageText8, +except 2-byte (or 16-bit) characters are used. +For fonts defined with linear indexing rather than 2-byte matrix indexing, +the server will interpret each CHAR2B as a 16-bit number that +has been transmitted most significant byte first (that is, byte1 of the +CHAR2B is taken as the most significant byte). + + +
+
+ CreateColormap + CreateColormap + Colormap + + + + + + + + +mid: COLORMAP + + + + +visual: VISUALID + + + + +window: WINDOW + + + + +alloc: +{ None, +All} + + + + + + +Errors: +Alloc, +IDChoice, +Match, +Value, +Window + + + + + + + + + +This request creates a colormap of the specified visual type for the screen +on which the window resides and associates the identifier mid with it. +The visual type must be one supported by the screen (or a +Match +error results). +The initial values of the colormap entries are undefined for classes +GrayScale, +PseudoColor, +and +DirectColor. +For +StaticGray, +StaticColor, +and +TrueColor, +the entries will have defined values, +but those values are specific to the visual and are not defined +by the core protocol. +For +StaticGray, +StaticColor, +and +TrueColor, +alloc must be specified as +None +(or a +Match +error results). +For the other classes, if alloc is +None, +the colormap initially has no allocated entries, +and clients can allocate entries. + + +If alloc is +All, +then the entire colormap is allocated writable. +The initial values of all allocated entries are undefined. +For +GrayScale +and +PseudoColor, +the effect is as if an +AllocColorCells +request returned all pixel values from zero to N - 1, +where N is the colormap-entries value in the specified visual. +For +DirectColor, +the effect is as if an +AllocColorPlanes +request returned a pixel value of zero and red-mask, +green-mask, and blue-mask values containing the same bits as the +corresponding masks in the specified visual. +However, +in all cases, none of these entries can be freed with +FreeColors. + + +
+
+ FreeColormap + FreeColormap + + + + + + + + +cmap: COLORMAP + + + + + + +Errors: +Colormap + + + + + + + + + +This request deletes the association between the resource ID and the colormap +and frees the colormap storage. +If the colormap is an installed map for a screen, +it is uninstalled (see +UninstallColormap +request). +If the colormap is defined as the colormap for a window (by means of +CreateWindow +or +ChangeWindowAttributes), +the colormap for the window is changed to +None, +and a +ColormapNotify +event is generated. +The protocol does not define the colors displayed for a window with a colormap of +None. + + +This request has no effect on a default colormap for a screen. + + +
+
+ CopyColormapAndFree + CopyColormapAndFree + + + + + + + + +mid, src-cmap: COLORMAP + + + + + + +Errors: +Alloc, +Colormap, +IDChoice + + + + + + + + + +This request creates a colormap of the same visual type +and for the same screen as src-cmap, +and it associates identifier mid with it. +It also moves all of the client's existing allocations from src-cmap +to the new colormap with their color values intact +and their read-only or writable characteristics intact, +and it frees those entries in src-cmap. +Color values in other entries in the new colormap are undefined. +If src-cmap was created by the client with alloc +All +(see +CreateColormap +request), +then the new colormap is also created with alloc +All, +all color values for all entries are copied from src-cmap, +and then all entries in src-cmap are freed. +If src-cmap was not created by the client with alloc +All, +then the allocations to be moved are all those pixels and planes that have +been allocated by the client using either +AllocColor, +AllocNamedColor, +AllocColorCells, +or +AllocColorPlanes +and that have not been freed since they were allocated. + + +
+
+ InstallColormap + InstallColormap + + + + + + + + +cmap: COLORMAP + + + + + + +Errors: +Colormap + + + + + + + + + +This request makes this colormap an installed map for its screen. +All windows associated with this colormap immediately display with true colors. +As a side effect, +additional colormaps might be implicitly installed +or uninstalled by the server. +Which other colormaps get installed or uninstalled is server-dependent +except that the required list must remain installed. + + +If cmap is not already an installed map, a +ColormapNotify +event is generated on every window having cmap as an attribute. +In addition, +for every other colormap that is installed or uninstalled as a result +of the request, a +ColormapNotify +event is generated on every window having that colormap as an attribute. + + +At any time, there is a subset of the installed maps that are viewed as an +ordered list and are called the required list. +The length of the required list is at most M, +where M is the min-installed-maps specified for the screen in the +connection setup. +The required list is maintained as follows. +When a colormap is an explicit argument to +InstallColormap, +it is added to the head of the list; the list is truncated at the +tail, if necessary, to keep the length of the list to at most M. +When a colormap is an explicit argument to +UninstallColormap +and it is in the required list, it is removed from the list. +A colormap is not added to the required list when it is installed implicitly +by the server, and the server cannot implicitly uninstall a colormap that is +in the required list. + + +Initially the default colormap for a screen is installed (but is not in +the required list). + + +
+
+ UninstallColormap + UninstallColormap + + + + + + + + +cmap: COLORMAP + + + + + + +Errors: +Colormap + + + + + + + + + +If cmap is on the required list for its screen (see +InstallColormap +request), +it is removed from the list. +As a side effect, +cmap might be uninstalled, +and additional colormaps might be implicitly installed or uninstalled. +Which colormaps get installed or uninstalled is server-dependent +except that the required list must remain installed. + + +If cmap becomes uninstalled, a +ColormapNotify +event is generated on every window having cmap as an attribute. +In addition, +for every other colormap that is installed or uninstalled as a result of +the request, a +ColormapNotify +event is generated on every window having that colormap as an attribute. + + +
+
+ ListInstalledColormaps + ListInstalledColormaps + + + + + + + + +window: WINDOW + + + + + + ▶ + + + + + +cmaps: LISTofCOLORMAP + + + + + + +Errors: +Window + + + + + + + + + +This request returns a list of the currently installed colormaps for the +screen of the specified window. +The order of colormaps is not significant, +and there is no explicit indication of the required list (see +InstallColormap +request). + + +
+
+ AllocColor + AllocColor + + + + + + + + +cmap: COLORMAP + + + + +red, green, blue: CARD16 + + + + + + ▶ + + + + + +pixel: CARD32 + + + + +red, green, blue: CARD16 + + + + + + +Errors: +Alloc, +Colormap + + + + + + + + + +This request allocates a read-only colormap entry corresponding to the closest +RGB values provided by the hardware. +It also returns the pixel and the RGB values actually used. +Multiple clients requesting the same effective RGB values can be assigned +the same read-only entry, allowing entries to be shared. + + +
+
+ AllocNamedColor + AllocNamedColor + + + + + + + + +cmap: COLORMAP + + + + +name: STRING8 + + + + + + ▶ + + + + + +pixel: CARD32 + + + + +exact-red, exact-green, exact-blue: CARD16 + + + + +visual-red, visual-green, visual-blue: CARD16 + + + + + + +Errors: +Alloc, +Colormap, +Name + + + + + + + + + +This request looks up the named color with respect to the screen associated +with the colormap. +Then, it does an +AllocColor +on cmap. +The name should use the ISO Latin-1 encoding, +and uppercase and lowercase do not matter. +The exact RGB values specify the true values for the color, +and the visual values specify the values actually used in the colormap. + + +
+
+ AllocColorCells + AllocColorCells + + + + + + + + +cmap: COLORMAP + + + + +colors, planes: CARD16 + + + + +contiguous: BOOL + + + + + + ▶ + + + + + +pixels, masks: LISTofCARD32 + + + + + + +Errors: +Alloc, +Colormap, +Value + + + + + + + + + +The number of colors must be positive, +and the number of planes must be nonnegative (or a +Value +error results). +If C colors and P planes are requested, +then C pixels and P masks are returned. +No mask will have any bits in common with any other mask +or with any of the pixels. +By ORing together masks and pixels, +C*%2 sup P% distinct pixels can be produced; +all of these are allocated writable by the request. +For +GrayScale +or +PseudoColor, +each mask will have exactly one bit set to 1; for +DirectColor, +each will have exactly three bits set to 1. +If contiguous is +True +and if all masks are ORed together, +a single contiguous set of bits will be formed for +GrayScale +or +PseudoColor, +and three contiguous sets of bits (one within each pixel subfield) for +DirectColor. +The RGB values of the allocated entries are undefined. + + +
+
+ AllocColorPlanes + AllocColorPlanes + + + + + + + + +cmap: COLORMAP + + + + +colors, reds, greens, blues: CARD16 + + + + +contiguous: BOOL + + + + + + ▶ + + + + + +pixels: LISTofCARD32 + + + + +red-mask, green-mask, blue-mask: CARD32 + + + + + + +Errors: +Alloc, +Colormap, +Value + + + + + + + + + +The number of colors must be positive, +and the reds, greens, and blues must be nonnegative (or a +Value +error results). +If C colors, R reds, G greens, and B blues are requested, +then C pixels are returned, and the masks have R, G, and B bits set, +respectively. +If contiguous is +True, +then each mask will have a contiguous set of bits. +No mask will have any bits in common with any other mask +or with any of the pixels. +For +DirectColor, +each mask will lie within the corresponding pixel subfield. +By ORing together subsets of masks with pixels, +C*%2 sup R+G+B% distinct pixels can be produced; +all of these are allocated writable by the request. +The initial RGB values of the allocated entries are undefined. +In the colormap, +there are only C*%2 sup R% independent red entries, +C*%2 sup G% independent green entries, +and C*%2 sup B% independent blue entries. +This is true even for +PseudoColor. +When the colormap entry for a pixel value is changed using +StoreColors +or +StoreNamedColor, +the pixel is decomposed according to the masks and the +corresponding independent entries are updated. + + +
+
+ FreeColors + FreeColors + + + + + + + + +cmap: COLORMAP + + + + +pixels: LISTofCARD32 + + + + +plane-mask: CARD32 + + + + + + +Errors: +Access, +Colormap, +Value + + + + + + + + + +The plane-mask should not have any bits in common with any of the +pixels. +The set of all pixels is produced by ORing together subsets of +plane-mask with the pixels. +The request frees all of these pixels that +were allocated by the client (using +AllocColor, +AllocNamedColor, +AllocColorCells, +and +AllocColorPlanes). +Note that freeing an +individual pixel obtained from +AllocColorPlanes +may not actually allow it to be reused until all of its related pixels +are also freed. +Similarly, a read-only entry is not actually freed until it has been +freed by all clients, and if a client allocates the same read-only entry +multiple times, it must free the entry that many times before the +entry is actually freed. + + +All specified pixels that are allocated by the client in cmap are freed, +even if one or more pixels produce an error. +A +Value +error is generated if a specified pixel is not a valid index into cmap. +An +Access +error is generated if a specified pixel is not allocated by the +client (that is, is unallocated or is only allocated by another client) +or if the colormap was created with all entries writable (using an alloc +value of +All +in +CreateColormap). +If more than one pixel is in error, +it is arbitrary as to which pixel is reported. + + +
+
+ StoreColors + StoreColors + + + + + + + + +cmap: COLORMAP + + + + +items: LISTofCOLORITEM + + + + +where: + + + + + + + + + + + + + COLORITEM: + [pixel: CARD32 + + + + +do-red, do-green, do-blue: BOOL + + + + + +red, green, blue: CARD16] + + + + + + + + + + +Errors: +Access, +Colormap, +Value + + + + + + + +This request changes the colormap entries of the specified pixels. +The do-red, do-green, and do-blue fields indicate which components +should actually be changed. +If the colormap is an installed map for its screen, +the changes are visible immediately. + + +All specified pixels that are allocated writable in cmap (by any client) +are changed, even if one or more pixels produce an error. +A +Value +error is generated if a specified pixel is not a valid index into cmap, and an +Access +error is generated if a specified pixel is unallocated or is allocated +read-only. +If more than one pixel is in error, +it is arbitrary as to which pixel is reported. + + +
+
+ StoreNamedColor + StoreNamedColor + + + + + + + + +cmap: COLORMAP + + + + +pixel: CARD32 + + + + +name: STRING8 + + + + +do-red, do-green, do-blue: BOOL + + + + + + +Errors: +Access, +Colormap, +Name, +Value + + + + + + + + + +This request looks up the named color with respect to the screen associated +with cmap and then does a +StoreColors +in cmap. +The name should use the ISO Latin-1 encoding, +and uppercase and lowercase do not matter. +The +Access +and +Value +errors are the same as in +StoreColors. + + +
+
+ QueryColors + QueryColors + + + + + + + + +cmap: COLORMAP + + + + +pixels: LISTofCARD32 + + + + + + ▶ + + + + + +colors: LISTofRGB + + + + + + +where: + + + + + + +RGB: [red, green, blue: CARD16] + + + + + + +Errors: +Colormap, +Value + + + + + + + + + +This request returns the hardware-specific color values stored in cmap for +the specified pixels. +The values returned for an unallocated entry are undefined. +A +Value +error is generated if a pixel is not a valid index into cmap. +If more than one pixel is in error, +it is arbitrary as to which pixel is reported. + + +
+
+ LookupColor + LookupColor + + + + + + + + +cmap: COLORMAP + + + + +name: STRING8 + + + + + + ▶ + + + + + +exact-red, exact-green, exact-blue: CARD16 + + + + +visual-red, visual-green, visual-blue: CARD16 + + + + + + +Errors: +Colormap, +Name + + + + + + + + + +This request looks up the string name of a color with respect to the screen +associated with cmap and returns both the exact color values and +the closest values provided by the hardware with respect to the visual +type of cmap. +The name should use the ISO Latin-1 encoding, +and uppercase and lowercase do not matter. + + +
+
+ CreateCursor + CreateCursor + Cursor + + + + + + + + +cid: CURSOR + + + + +source: PIXMAP + + + + +mask: PIXMAP or +None + + + + +fore-red, fore-green, fore-blue: CARD16 + + + + +back-red, back-green, back-blue: CARD16 + + + + +x, y: CARD16 + + + + + + +Errors: +Alloc, +IDChoice, +Match, +Pixmap + + + + + + + + + +This request creates a cursor and associates identifier cid with it. +The foreground and background RGB values must be specified, +even if the server only has a +StaticGray +or +GrayScale +screen. +The foreground is used for the bits set to 1 in the source, +and the background is used for the bits set to 0. +Both source and mask (if specified) must have depth one (or a +Match +error results), but they can have any root. +The mask pixmap defines the shape of the cursor. +That is, +the bits set to 1 in the mask define which source pixels will be displayed, +and where the mask has bits set to 0, +the corresponding bits of the source pixmap are ignored. +If no mask is given, +all pixels of the source are displayed. +The mask, if present, must be the same size as the source (or a +Match +error results). +The x and y coordinates define the hotspot relative to the source's origin +and must be a point within the source (or a +Match +error results). + + +The components of the cursor may be transformed arbitrarily to meet +display limitations. + + +The pixmaps can be freed immediately if no further explicit references +to them are to be made. + + +Subsequent drawing in the source or mask pixmap has an undefined effect +on the cursor. +The server might or might not make a copy of the pixmap. + + +
+
+ CreateGlyphCursor + CreateGlyphCursor + + + + + + + + +cid: CURSOR + + + + +source-font: FONT + + + + +mask-font: FONT or +None + + + + +source-char, mask-char: CARD16 + + + + +fore-red, fore-green, fore-blue: CARD16 + + + + +back-red, back-green, back-blue: CARD16 + + + + + + +Errors: +Alloc, +Font, +IDChoice, +Value + + + + + + + + + +This request is similar to +CreateCursor, +except the source and mask bitmaps are obtained from the specified font glyphs. +The source-char must be a defined glyph in source-font, +and if mask-font is given, mask-char must be a defined glyph in mask-font +(or a +Value +error results). +The mask font and character are optional. +The origins of the source and mask (if it is defined) glyphs +are positioned coincidently and define the hotspot. +The source and mask need not have the same bounding box metrics, +and there is no restriction on the placement of the hotspot relative +to the bounding boxes. +If no mask is given, +all pixels of the source are displayed. +Note that source-char and mask-char are CARD16, not CHAR2B. +For 2-byte matrix fonts, +the 16-bit value should be formed with byte1 in the most significant byte +and byte2 in the least significant byte. + + +The components of the cursor may be transformed arbitrarily to meet +display limitations. + + +The fonts can be freed immediately if no further explicit references to +them are to be made. + + +
+
+ FreeCursor + FreeCursor + + + + + + + + +cursor: CURSOR + + + + + + +Errors: +Cursor + + + + + + + + + +This request deletes the association between the resource ID and the cursor. +The cursor storage will be freed when no other resource references it. + + +
+
+ RecolorCursor + RecolorCursor + + + + + + + + +cursor: CURSOR + + + + +fore-red, fore-green, fore-blue: CARD16 + + + + +back-red, back-green, back-blue: CARD16 + + + + + + +Errors: +Cursor + + + + + + + + + +This request changes the color of a cursor. +If the cursor is being displayed on a screen, +the change is visible immediately. + + +
+
+ QueryBestSize + QueryBestSize + + + + + + + + +class: +{ Cursor, +Tile, +Stipple} + + + + +drawable: DRAWABLE + + + + +width, height: CARD16 + + + + + + ▶ + + + + + +width, height: CARD16 + + + + + + +Errors: +Drawable, +Match, +Value + + + + + + + + + +This request returns the best size that is closest to the argument size. +For +Cursor, +this is the largest size that can be fully displayed. +For +Tile, +this is the size that can be tiled fastest. +For +Stipple, +this is the size that can be stippled fastest. + + +For +Cursor, +the drawable indicates the desired screen. +For +Tile +and +Stipple, +the drawable indicates the screen and also possibly the window class and depth. +An +InputOnly +window cannot be used as the drawable for +Tile +or +Stipple +(or a +Match +error results). + + +
+
+ QueryExtension + QueryExtension + Extensionquerying + + + + + + + + +name: STRING8 + + + + + + ▶ + + + + + +present: BOOL + + + + +major-opcode: CARD8 + + + + +first-event: CARD8 + + + + +first-error: CARD8 + + + + + + + + + +This request determines if the named extension is present. +If so, +the major opcode for the extension is returned, if it has one. +Otherwise, zero is returned. +Any minor opcode and the request formats are specific to the extension. +If the extension involves additional event types, +the base event type code is returned. +Otherwise, zero is returned. +The format of the events is specific to the extension. +If the extension involves additional error codes, +the base error code is returned. +Otherwise, zero is returned. +The format of additional data in the errors is specific to the extension. + + +The extension name should use the ISO Latin-1 encoding, +and uppercase and lowercase matter. + + +
+
+ ListExtensions + ListExtensions + Extensionlisting + + + + + + + + ▶ + + + + + +names: LISTofSTRING8 + + + + + + + + + +This request returns a list of all extensions supported by the server. + +
+
+ SetModifierMapping + SetModifierMapping + Modifier keys + + + + + + + + +keycodes-per-modifier: CARD8 + + + + +keycodes: LISTofKEYCODE + + + + + + ▶ + + + + + +status: +{ Success, +Busy, +Failed} + + + + + + +Errors: +Alloc, +Value + + + + + + + + + +This request specifies the keycodes (if any) of the keys to be used as +modifiers. +The number of keycodes in the list must be 8*keycodes-per-modifier (or a +Length +error results). +The keycodes are divided into eight sets, +with each set containing keycodes-per-modifier elements. +The sets are assigned to the modifiers +Shift, +Lock, +Control, +Mod1, +Mod2, +Mod3, +Mod4, +and +Mod5, +in order. +Only nonzero keycode values are used within each set; +zero values are ignored. +All of the nonzero keycodes must be in the range specified by min-keycode +and max-keycode in the connection setup (or a +Value +error results). +The order of keycodes within a set does not matter. +If no nonzero values are specified in a set, +the use of the corresponding modifier is disabled, +and the modifier bit will always be zero. +Otherwise, the modifier bit will be one whenever +at least one of the keys in the corresponding set is in the down +position. + + +A server can impose restrictions on how modifiers can be changed (for example, +if certain keys do not generate up transitions in hardware, +if auto-repeat cannot be disabled on certain keys, +or if multiple keys per modifier are not supported). +The status reply is +Failed +if some such restriction is violated, +and none of the modifiers is changed. + + +If the new nonzero keycodes specified for a modifier differ from those +currently defined and any (current or new) keys for that modifier are +logically in the down state, then the status reply is +Busy, +and none of the modifiers is changed. + + +This request generates a +MappingNotify +event on a +Success +status. + + +
+
+ GetModifierMapping + GetModifierMapping + Modifier keys + + + + + + + + ▶ + + + + + +keycodes-per-modifier: CARD8 + + + + +keycodes: LISTofKEYCODE + + + + + + + + + +This request returns the keycodes of the keys being used as modifiers. +The number of keycodes in the list is 8*keycodes-per-modifier. +The keycodes are divided into eight sets, +with each set containing keycodes-per-modifier elements. +The sets are assigned to the modifiers +Shift, +Lock, +Control, +Mod1, +Mod2, +Mod3, +Mod4, +and +Mod5, +in order. +The keycodes-per-modifier value is chosen arbitrarily by the server; +zeroes are used to fill in unused elements within each set. +If only zero values are given in a set, +the use of the corresponding modifier has been disabled. +The order of keycodes within each set is chosen arbitrarily by the server. + + +
+
+ ChangeKeyboardMapping + ChangeKeyboardMapping + Keysym + + + + + + + + +first-keycode: KEYCODE + + + + +keysyms-per-keycode: CARD8 + + + + +keysyms: LISTofKEYSYM + + + + + + +Errors: +Alloc, +Value + + + + + + + + + +This request defines the symbols for the specified number of keycodes, +starting with the specified keycode. +The symbols for keycodes outside this range remained unchanged. +The number of elements in the keysyms list must be a multiple of +keysyms-per-keycode (or a +Length +error results). +The first-keycode must be greater than or equal to min-keycode as returned +in the connection setup (or a +Value +error results) and: + + first-keycode + (keysyms-length / keysyms-per-keycode) - 1 + + + +must be less than or equal to max-keycode as returned in the connection +setup (or a +Value +error results). +KEYSYM number N (counting from zero) for keycode K has an index +(counting from zero) of: + + (K - first-keycode) * keysyms-per-keycode + N + + + +in keysyms. +The keysyms-per-keycode can be chosen arbitrarily by the client +to be large enough to hold all desired symbols. +A special KEYSYM value of +NoSymbol +should be used to fill in unused elements for individual keycodes. +It is legal for +NoSymbol +to appear in nontrailing positions of the effective list for a keycode. + + +This request generates a +MappingNotify +event. + + +There is no requirement that the server interpret this mapping; +it is merely stored for reading and writing by clients +(see section 5). + + +
+
+ GetKeyboardMapping + GetKeyboardMapping + Keysym + + + + + + + + +first-keycode: KEYCODE + + + + +count: CARD8 + + + + + + ▶ + + + + + +keysyms-per-keycode: CARD8 + + + + +keysyms: LISTofKEYSYM + + + + + + +Errors: +Value + + + + + + + + + +This request returns the symbols for the specified number of keycodes, +starting with the specified keycode. +The first-keycode must be greater than or equal to +min-keycode as returned in the connection setup (or a +Value +error results), and: + + first-keycode + count - 1 + + + +must be less than or equal to max-keycode as returned in the connection setup +(or a +Value +error results). +The number of elements in the keysyms list is: + + count * keysyms-per-keycode + + + +and KEYSYM number N (counting from zero) for keycode K has an index +(counting from zero) of: + + (K - first-keycode) * keysyms-per-keycode + N + + + +in keysyms. +The keysyms-per-keycode value is chosen arbitrarily by the server +to be large enough to report all requested symbols. +A special KEYSYM value of +NoSymbol +is used to fill in unused elements for individual keycodes. + + +
+
+ ChangeKeyboardControl + ChangeKeyboardControl + + + + + + + + +value-mask: BITMASK + + + + +value-list: LISTofVALUE + + + + + +Errors: +Match, +Value + + + + + + + +This request controls various aspects of the keyboard. +The value-mask and value-list specify which controls are to be changed. +The possible values are: + + + + + + + + + + Control + Type + + + + + key-click-percent + INT8 + + + bell-percent + INT8 + + + bell-pitch + INT16 + + + bell-duration + INT16 + + + led + CARD8 + + + led-mode + +{ On, +Off } + + + + key + KEYCODE + + + auto-repeat-mode + +{ On, +Off, +Default } + + + + + + + +The key-click-percent sets the volume for key clicks between 0 (off) and +100 (loud) inclusive, if possible. +Setting to -1 restores the default. +Other negative values generate a +Value +error. + + +The bell-percent sets the base volume for the bell between 0 (off) and 100 +(loud) inclusive, if possible. +Setting to -1 restores the default. +Other negative values generate a +Value +error. + + +The bell-pitch sets the pitch (specified in Hz) of the bell, if possible. +Setting to -1 restores the default. +Other negative values generate a +Value +error. + + +The bell-duration sets the duration of the bell (specified in milliseconds), +if possible. +Setting to -1 restores the default. +Other negative values generate a +Value +error. + + +If both led-mode and led are specified, +then the state of that LED is changed, if possible. +If only led-mode is specified, +then the state of all LEDs are changed, if possible. +At most 32 LEDs, numbered from one, are supported. +No standard interpretation of LEDs is defined. +It is a +Match +error if an led is specified without an led-mode. + + +If both auto-repeat-mode and key are specified, +then the auto-repeat mode of that key is changed, if possible. +If only auto-repeat-mode is specified, +then the global auto-repeat mode for the entire keyboard is changed, +if possible, without affecting the per-key settings. +It is a +Match +error if a key is specified without an auto-repeat-mode. +Each key has an individual mode of whether or not it should auto-repeat +and a default setting for that mode. +In addition, there is a global mode of whether auto-repeat should be +enabled or not and a default setting for that mode. +When the global mode is +On, +keys should obey their individual auto-repeat modes. +When the global mode is +Off, +no keys should auto-repeat. +An auto-repeating key generates alternating +KeyPress +and +KeyRelease +events. +When a key is used as a modifier, +it is desirable for the key not to auto-repeat, +regardless of the auto-repeat setting for that key. + + +A bell generator connected with the console but not directly on the +keyboard is treated as if it were part of the keyboard. + + +The order in which controls are verified and altered is server-dependent. +If an error is generated, +a subset of the controls may have been altered. + + +
+
+ GetKeyboardControl + GetKeyboardControl + + + + + + + + ▶ + + + + + +key-click-percent: CARD8 + + + + +bell-percent: CARD8 + + + + +bell-pitch: CARD16 + + + + +bell-duration: CARD16 + + + + +led-mask: CARD32 + + + + +global-auto-repeat: +{ On, +Off} + + + + +auto-repeats: LISTofCARD8 + + + + + + + + + +This request returns the current control values for the keyboard. +For the LEDs, +the least significant bit of led-mask corresponds to LED one, +and each one bit in led-mask indicates an LED that is lit. +The auto-repeats is a bit vector; +each one bit indicates that auto-repeat is enabled for the corresponding key. +The vector is represented as 32 bytes. +Byte N (from 0) contains the bits for keys 8N to 8N + 7, +with the least significant bit in the byte representing key 8N. + + +
+
+ Bell + Bell + + + + + + + + +percent: INT8 + + + + + + +Errors: +Value + + + + + + + + + +This request rings the bell on the keyboard at a volume relative to the +base volume for the keyboard, if possible. +Percent can range from -100 to 100 inclusive (or a +Value +error results). +The volume at which the bell is rung when percent is nonnegative is: + + base - [(base * percent) / 100] + percent + + + +When percent is negative, it is: + + base + [(base * percent) / 100] + + + +
+
+ SetPointerMapping + SetPointerMapping + + + + + + + + +map: LISTofCARD8 + + + + + + ▶ + + + + + +status: +{ Success, +Busy} + + + + + + +Errors: +Value + + + + + + + + + +This request sets the mapping of the pointer. +Elements of the list are indexed starting from one. +The length of the list must be the same as +GetPointerMapping +would return (or a +Value +error results). +The index is a core button number, +and the element of the list defines the effective number. + + +A zero element disables a button. +Elements are not restricted in value by the number of physical buttons, +but no two elements can have the same nonzero value (or a +Value +error results). + + +If any of the buttons to be altered are logically in the down state, +the status reply is +Busy, +and the mapping is not changed. + + +This request generates a +MappingNotify +event on a +Success +status. + + +
+
+ GetPointerMapping + GetPointerMapping + + + + + + + + ▶ + + + + + +map: LISTofCARD8 + + + + + + + + + +This request returns the current mapping of the pointer. +Elements of the list are indexed starting from one. +The length of the list indicates the number of physical buttons. + + +The nominal mapping for a pointer is the identity mapping: map[i]=i. + + +
+
+ ChangePointerControl + ChangePointerControl + + + + + + + + +do-acceleration, do-threshold: BOOL + + + + +acceleration-numerator, acceleration-denominator: INT16 + + + + +threshold: INT16 + + + + + + +Errors: +Value + + + + + + + + + +This request defines how the pointer moves. +The acceleration is a multiplier for movement expressed as a fraction. +For example, +specifying 3/1 means the pointer moves three times as fast as normal. +The fraction can be rounded arbitrarily by the server. +Acceleration only takes effect if the pointer moves more than threshold +number of pixels at once and only applies to the amount beyond the threshold. +Setting a value to -1 restores the default. +Other negative values generate a +Value +error, as does a zero value for acceleration-denominator. + + +
+
+ GetPointerControl + GetPointerControl + + + + + + + + ▶ + + + + + +acceleration-numerator, acceleration-denominator: CARD16 + + + + +threshold: CARD16 + + + + + + + + + +This request returns the current acceleration and threshold for the pointer. + + +
+
+ SetScreenSaver + SetScreenSaver + + + + + + + + +timeout, interval: INT16 + + + + +prefer-blanking: +{ Yes, +No, +Default} + + + + +allow-exposures: +{ Yes, +No, +Default} + + + + + + +Errors: +Value + + + + + + + + + +The timeout and interval are specified in seconds; +setting a value to -1 restores the default. +Other negative values generate a +Value +error. +If the timeout value is zero, +screen-saver is disabled (but an activated screen-saver is not deactivated). +If the timeout value is nonzero, +screen-saver is enabled. +Once screen-saver is enabled, +if no input from the keyboard or pointer is generated for timeout seconds, +screen-saver is activated. +For each screen, +if blanking is preferred and the hardware supports video blanking, +the screen will simply go blank. +Otherwise, +if either exposures are allowed or the screen can be regenerated without +sending exposure events to clients, +the screen is changed in a server-dependent fashion to avoid phosphor burn. +Otherwise, +the state of the screens does not change, and screen-saver is not activated. +At the next keyboard or pointer input or at the next +ForceScreenSaver +with mode +Reset, +screen-saver is deactivated, and all screen states are restored. + + +If the server-dependent screen-saver method is amenable to periodic change, +interval serves as a hint about how long the change period should be, +with zero hinting that no periodic change should be made. +Examples of ways to change the screen include scrambling the color map +periodically, moving an icon image about the screen periodically, or +tiling the screen with the root window background tile, +randomly reorigined periodically. + + +
+
+ GetScreenSaver + GetScreenSaver + + + + + + + + ▶ + + + + + +timeout, interval: CARD16 + + + + +prefer-blanking: +{ Yes, +No} + + + + +allow-exposures: +{ Yes, +No} + + + + + + + + + +This request returns the current screen-saver control values. + + +
+
+ ForceScreenSaver + ForceScreenSaver + + + + + + + + +mode: +{ Activate, +Reset} + + + + + + +Errors: +Value + + + + + + + + + +If the mode is +Activate +and screen-saver is currently deactivated, +then screen-saver is activated (even if screen-saver has been disabled with +a timeout value of zero). +If the mode is +Reset +and screen-saver is currently enabled, +then screen-saver is deactivated (if it was activated), +and the activation timer is reset to its initial state +as if device input had just been received. + + +
+
+ ChangeHosts + ChangeHosts + + + + + + + + +mode: +{ Insert, +Delete} + + + + +host: HOST + + + + + + +Errors: +Access, +Value + + + + + + + + + +This request adds or removes the specified host from the access control list. +Access control list +When the access control mechanism is enabled and a client attempts to +establish a connection to the server, +the host on which the client resides must be in the access control list, +or the client must have been granted permission by a server-dependent +method, or the server will refuse the connection. + + +The client must reside on the same host as the server and/or have been granted +permission by a server-dependent method to execute this request (or an +Access +error results). + + +An initial access control list can usually be specified, +typically by naming a file that the server reads at startup and reset. + + +The following address families are defined. +TypesHOST +A server is not required to support these families +and may support families not listed here. +Use of an unsupported family, an improper address format, +or an improper address length within a supported family results in a +Value +error. + + +For the Internet family, +the address must be four bytes long. +The address bytes are in standard IP order; +the server performs no automatic swapping on the address bytes. +The Internet family supports IP version 4 addresses only. + + +For the InternetV6 family, the address must be sixteen bytes +long. The address bytes are in standard IP order; the +server performs no automatic swapping on the address bytes. +The InternetV6 family supports IP version 6 addresses only. + + +For the DECnet family, +the server performs no automatic swapping on the address bytes. +A Phase IV address is two bytes long: +the first byte contains the least significant eight bits of the node number, +and the second byte contains the most significant two bits of the node number in +the least significant two bits of the byte and the area in the most +significant six bits of the byte. + + +For the Chaos family, +the address must be two bytes long. +The host number is always the first byte in the address, +and the subnet number is always the second byte. +The server performs no automatic swapping on the address bytes. + + +For the ServerInterpreted family, the address may be of any +length up to 65535 bytes. The address consists of two strings +of ASCII characters, separated by a byte with a value of 0. +The first string represents the type of address, and the second +string contains the address value. Address types and the syntax +for their associated values will be registered via the X.Org Registry. +Implementors who wish to add implementation specific types may register +a unique prefix with the X.Org registry to prevent namespace +collisions. + + +Use of a host address in the ChangeHosts request is deprecated. It is +only useful when a host has a unique, constant address, a requirement +that is increasingly unmet as sites adopt dynamically assigned +addresses, network address translation gateways, IPv6 link local +addresses, and various other technologies. It also assumes all users of +a host share equivalent access rights, and as such has never been +suitable for many multi-user machine environments. Instead, more +secure forms of authentication, such as those based on shared secrets +or public key encryption, are recommended. + + +
+
+ ListHosts + ListHosts + + + + + + + + ▶ + + + + + +mode: +{ Enabled, +Disabled} + + + + +hosts: LISTofHOST + + + + + + + + + +This request returns the hosts on the access control list +and whether use of the list at connection setup is currently +enabled or disabled. + + +Each HOST is padded to a multiple of four bytes. + + +
+
+ SetAccessControl + SetAccessControl + + + + + + + + +mode: +{ Enable, +Disable} + + + + + + +Errors: +Access, +Value + + + + + + + + + +This request enables or disables the use of the access control list +at connection setups. + + +The client must reside on the same host as the server +and/or have been granted permission by a server-dependent method +to execute this request (or an +Access +error results). + + +
+
+ SetCloseDownMode + SetCloseDownMode + + + + + + + + +mode: +{ Destroy, +RetainPermanent, +RetainTemporary} + + + + + + +Errors: +Value + + + + + + + + + +This request defines what will happen to the client's resources +at connection close. +A connection starts in +Destroy +mode. +The meaning of the close-down mode is described +in section 10. + + +
+
+ KillClient + KillClient + + + + + + + + +resource: CARD32 or +AllTemporary + + + + + + +Errors: +Value + + + + + + + + + +If a valid resource is specified, +KillClient +forces a close-down of the client that created the resource. +If the client has already terminated in either +RetainPermanent +or +RetainTemporary +mode, all of the client's resources are destroyed +(see section 10). +If +AllTemporary +is specified, +then the resources of all clients that have terminated in +RetainTemporary +are destroyed. + + +
+
+ NoOperation + NoOperation + +This request has no arguments and no results, +but the request length field +allows the request to be any multiple of four bytes in length. +The bytes contained in the request are uninterpreted by the server. + + +This request can be used in its minimum four byte form as padding where +necessary by client libraries that find it convenient to force requests +to begin on 64-bit boundaries. + +
+ + + +Connection Close + Connectionclosing + + + + +At connection close, +all event selections made by the client are discarded. +If the client has the pointer actively grabbed, an +UngrabPointer +is performed. +If the client has the keyboard actively grabbed, an +UngrabKeyboard +is performed. +All passive grabs by the client are released. +If the client has the server grabbed, an +UngrabServer +is performed. +All selections (see +SetSelectionOwner +request) +owned by the client are disowned. +If close-down mode (see +SetCloseDownMode +request) is +RetainPermanent +or +RetainTemporary, +then all resources (including colormap entries) +allocated by the client are marked as permanent or temporary, +respectively (but this does not prevent other clients from explicitly +destroying them). +If the mode is +Destroy, +all of the client's resources are destroyed. + + +When a client's resources are destroyed, +for each window in the client's save-set, +if the window is an inferior of a window created by the client, +the save-set window is reparented to the closest ancestor such that +the save-set window is not an inferior of a window created by the client. +If the save-set window is unmapped, a +MapWindow +request is performed on it (even if it was not an inferior +of a window created by the client). +The reparenting leaves unchanged the absolute coordinates +(with respect to the root window) of the upper-left outer corner of the +save-set window. +After save-set processing, +all windows created by the client are destroyed. +For each nonwindow resource created by the client, +the appropriate +Free +request is performed. +All colors and colormap entries allocated by the client are freed. + + +A server goes through a cycle of having no connections and having some +connections. +At every transition to the state of having no connections +as a result of a connection closing with a +Destroy +close-down mode, +the server resets its state as if it had just been started. +This starts by destroying all lingering resources from clients +that have terminated in +RetainPermanent +or +RetainTemporary +mode. +It additionally includes deleting all but the predefined atom identifiers, +deleting all properties on all root windows, resetting all device maps and +attributes (key click, bell volume, acceleration), resetting the access +control list, restoring the standard root tiles and cursors, restoring +the default font path, and restoring the input focus to state +PointerRoot. + + +Note that closing a connection with a close-down mode of +RetainPermanent +or +RetainTemporary +will not cause the server to reset. + + + + +Events + + + + +Event +When a button press is processed with the pointer in some window W +and no active pointer grab is in progress, +the ancestors of W are searched from the root down, +looking for a passive grab to activate. +If no matching passive grab on the button exists, +then an active grab is started automatically for the client receiving the event, +and the last-pointer-grab time is set to the current server time. +The effect is essentially equivalent to a +GrabButton +with arguments: + + + + + + + + + + Argument + Value + + + + + event-window + Event window + + + event-mask + +Client's selected pointer events on the event window + + + + pointer-mode and keyboard-mode + +Asynchronous + + + + owner-events + +True +if the client has +OwnerGrabButton +selected on the event window, otherwise +False + + + + confine-to + +None + + + + cursor + +None + + + + + + + + + +The grab is terminated automatically when the logical state of the pointer +has all buttons released. +UngrabPointer +and +ChangeActivePointerGrab +can both be used to modify the active grab. + + + +
+ Input Device events + Input deviceevents + + + + + + + + +KeyPress +KeyPress + + + + +KeyRelease +KeyRelease + + + + +ButtonPress +ButtonPress + + + + +ButtonRelease +ButtonRelease + + + + +MotionNotify +MotionNotify + + + + + +root, event: WINDOW + + + + +child: WINDOW or +None + + + + +same-screen: BOOL + + + + +root-x, root-y, event-x, event-y: INT16 + + + + +detail: <see below> + + + + +state: SETofKEYBUTMASK + + + + +time: TIMESTAMP + + + + + + + + + +These events are generated either when a key or button logically changes state +or when the pointer logically moves. +The generation of these logical changes may lag the physical changes +if device event processing is frozen. +Note that +KeyPress +and +KeyRelease +are generated for all keys, even those mapped to modifier bits. + +The source of the event is the window the pointer is in. + +Eventsource +The window the event is reported with respect to is called the event window. +The event window is found by starting with the source window and +looking up the hierarchy for the first window on which any client has selected +interest in the event (provided no intervening window prohibits event +generation by including the event type in its do-not-propagate-mask). +The actual window used for reporting can be modified by active grabs and, +in the case of keyboard events, can be modified by the focus window. + + +The root is the root window of the source window, +and root-x and root-y are the pointer coordinates relative to root's origin +at the time of the event. +Event is the event window. +If the event window is on the same screen as root, +then event-x and event-y are the pointer coordinates relative to the +event window's origin. +Otherwise, event-x and event-y are zero. +If the source window is an inferior of the event window, +then child is set to the child of the event window that is an +ancestor of (or is) the source window. +Otherwise, it is set to +None. +The state component gives the logical state of the buttons and modifier keys +just before the event. +The detail component type varies with the event type: + + + + + + + + + + Event + Component + + + + + +KeyPress, +KeyRelease + + KEYCODE + + + +ButtonPress, +ButtonRelease + + BUTTON + + + +MotionNotify + + +{ Normal +Hint } + + + + + + + +MotionNotify +events are only generated when the motion begins and ends in the window. +The granularity of motion events is not guaranteed, +but a client selecting for motion events is guaranteed to get at least one +event when the pointer moves and comes to rest. +Selecting +PointerMotion +receives events independent of the state of the pointer buttons. +By selecting some subset of +Button[1-5]Motion +instead, +MotionNotify +events will only be received when one or more of the +specified buttons are pressed. +By selecting +ButtonMotion, +MotionNotify +events will be received only when at least one button is pressed. +The events are always of type +MotionNotify, +independent of the selection. +If +PointerMotionHint +is selected, +the server is free to send only one +MotionNotify +event (with detail +Hint) +to the client for the event window until +either the key or button state changes, +the pointer leaves the event window, +or the client issues a +QueryPointer +or +GetMotionEvents +request. + + +
+
+ Pointer Window events + + + + + + + +EnterNotify +EnterNotify + + + + +LeaveNotify +LeaveNotify + + + + + +root, event: WINDOW + + + + +child: WINDOW or +None + + + + +same-screen: BOOL + + + + +root-x, root-y, event-x, event-y: INT16 + + + + +mode: +{ Normal, +Grab, +Ungrab} + + + + +detail: +{ Ancestor, +Virtual, +Inferior, +Nonlinear, +NonlinearVirtual} + + + + +focus: BOOL + + + + +state: SETofKEYBUTMASK + + + + +time: TIMESTAMP + + + + + + + + + +If pointer motion or window hierarchy change causes the pointer to be +in a different window than before, +EnterNotify +and +LeaveNotify +events are generated instead of a +MotionNotify +event. +Only clients selecting +EnterWindow +on a window receive +EnterNotify +events, and only clients selecting +LeaveWindow +receive +LeaveNotify +events. +The pointer position reported in the event is always the final position, +not the initial position of the pointer. +The root is the root window for this position, +and root-x and root-y are the pointer coordinates relative to root's +origin at the time of the event. +Event is the event window. +If the event window is on the same screen as root, +then event-x and event-y are the pointer coordinates relative +to the event window's origin. +Otherwise, event-x and event-y are zero. +In a +LeaveNotify +event, if a child of the event window contains the initial position of the +pointer, then the child component is set to that child. +Otherwise, it is +None. +For an +EnterNotify +event, if a child of the event window contains the final pointer position, +then the child component is set to that child. +Otherwise, it is +None. +If the event window is the focus window or an inferior of the focus window, +then focus is +True. +Otherwise, focus is +False. + + +Normal pointer motion events have mode +Normal. +Pseudo-motion events when a grab activates have mode +Grab, +and pseudo-motion events when a grab deactivates have mode +Ungrab. + + +All +EnterNotify +and +LeaveNotify +events caused by a hierarchy change are generated after any hierarchy event +caused by that change (that is, +UnmapNotify, +MapNotify, +ConfigureNotify, +GravityNotify, +CirculateNotify), +but the ordering of +EnterNotify +and +LeaveNotify +events with respect to +FocusOut, +VisibilityNotify, +and +Expose +events is not constrained. + + +Normal events are generated as follows: + + + +When the pointer moves from window A to window B and A is an inferior +of B: + + + + + +LeaveNotify +with detail +Ancestor +is generated on A. + + + + +LeaveNotify +with detail +Virtual +is generated on each window between A and B exclusive (in that order). + + + + +EnterNotify +with detail +Inferior +is generated on B. + + + + + +When the pointer moves from window A to window B and B is an inferior +of A: + + + + + + +LeaveNotify +with detail +Inferior +is generated on A. + + + + +EnterNotify +with detail +Virtual +is generated on each window between A and B exclusive (in that order). + + + + +EnterNotify +with detail +Ancestor +is generated on B. + + + + + +When the pointer moves from window A to window B and window C is +their least common ancestor: + + + + + +LeaveNotify +with detail +Nonlinear +is generated on A. + + + + +LeaveNotify +with detail +NonlinearVirtual +is generated on each window between A and C exclusive (in that order). + + + + +EnterNotify +with detail +NonlinearVirtual +is generated on each window between C and B exclusive (in that order). + + + + +EnterNotify +with detail +Nonlinear +is generated on B. + + + + + +When the pointer moves from window A to window B on different screens: + + + + + +LeaveNotify +with detail +Nonlinear +is generated on A. + + + + +If A is not a root window, +LeaveNotify +with detail +NonlinearVirtual +is generated on each window above A up to and including its root (in order). + + + + +If B is not a root window, +EnterNotify +with detail +NonlinearVirtual +is generated on each window from B's root down to but not including B +(in order). + + + + +EnterNotify +with detail +Nonlinear +is generated on B. + + + + + +When a pointer grab activates (but after any initial warp into a confine-to +window and before generating any actual +ButtonPress +event that activates the grab), +G is the grab-window for the grab, and P is the window the pointer is in: + + + + + +EnterNotify +and +LeaveNotify +events with mode +Grab +are generated (as for +Normal +above) as if the pointer were to suddenly warp from its current +position in P to some position in G. +However, the pointer does not warp, +and the pointer position is used as both the initial +and final positions for the events. + + + + + +When a pointer grab deactivates (but after generating any actual +ButtonRelease +event that deactivates the grab), G is the grab-window for +the grab, and P is the window the pointer is in: + + + + + +EnterNotify +and +LeaveNotify +events with mode +Ungrab +are generated (as for +Normal +above) as if the pointer were to suddenly warp from +some position in G to its current position in P. +However, the pointer does not warp, +and the current pointer position is used as both the initial +and final positions for the events. + + + + +
+
+ Input Focus events + Input focusevents + + + + + + + + +FocusIn +FocusIn + + + + +FocusOut +FocusOut + + + + + +event: WINDOW + + + + +mode: +{ Normal, +WhileGrabbed, +Grab, +Ungrab} + + + + +detail: +{ Ancestor, +Virtual, +Inferior, +Nonlinear, +NonlinearVirtual, +Pointer, + + + + +PointerRoot, +None } + + + + + + + + + +These events are generated when the input focus changes +and are reported to clients selecting +FocusChange +on the window. +Events generated by +SetInputFocus +when the keyboard is not grabbed have mode +Normal. +Events generated by +SetInputFocus +when the keyboard is grabbed have mode +WhileGrabbed. +Events generated when a keyboard grab activates have mode +Grab, +and events generated when a keyboard grab deactivates have mode +Ungrab. + + +All +FocusOut +events caused by a window unmap are generated after any +UnmapNotify +event, but the ordering of +FocusOut +with respect to generated +EnterNotify, +LeaveNotify, +VisibilityNotify, +and +Expose +events is not constrained. + + +Normal +and +WhileGrabbed +events are generated as follows: + + +When the focus moves from window A to window B, A is an inferior of B, +and the pointer is in window P: + + + + + +FocusOut +with detail +Ancestor +is generated on A. + + + + +FocusOut +with detail +Virtual +is generated on each window between A and B exclusive (in order). + + + + +FocusIn +with detail +Inferior +is generated on B. + + + + +If P is an inferior of B +but P is not A or an inferior of A or an ancestor of A, +FocusIn +with detail +Pointer +is generated on each window below B down to and including P (in order). + + + + + + +When the focus moves from window A to window B, B is an inferior of A, +and the pointer is in window P: + + + + + +If P is an inferior of A +but P is not an inferior of B or an ancestor of B, +FocusOut +with detail +Pointer +is generated on each window from P up to but not including A (in order). + + + + +FocusOut +with detail +Inferior +is generated on A. + + + + +FocusIn +with detail +Virtual +is generated on each window between A and B exclusive (in order). + + + + +FocusIn +with detail +Ancestor +is generated on B. + + + + + +When the focus moves from window A to window B, window C is their +least common ancestor, and the pointer is in window P: + + + + + +If P is an inferior of A, +FocusOut +with detail +Pointer +is generated on each window from P up to but not including A (in order). + + + + +FocusOut +with detail +Nonlinear +is generated on A. + + + + +FocusOut +with detail +NonlinearVirtual +is generated on each window between A and C exclusive (in order). + + + + +FocusIn +with detail +NonlinearVirtual +is generated on each window between C and B exclusive (in order). + + + + +FocusIn +with detail +Nonlinear +is generated on B. + + + + +If P is an inferior of B, +FocusIn +with detail +Pointer +is generated on each window below B down to and including P (in order). + + + + + +When the focus moves from window A to window B on different screens +and the pointer is in window P: + + + + + + +If P is an inferior of A, +FocusOut +with detail +Pointer +is generated on each window from P up to but not including A (in order). + + + + +FocusOut +with detail +Nonlinear +is generated on A. + + + + +If A is not a root window, +FocusOut +with detail +NonlinearVirtual +is generated on each window above A up to and including its root (in order). + + + + +If B is not a root window, +FocusIn +with detail +NonlinearVirtual +is generated on each window from B's root down to but not including B +(in order). + + + + +FocusIn +with detail +Nonlinear +is generated on B. + + + + +If P is an inferior of B, +FocusIn +with detail +Pointer +is generated on each window below B down to and including P (in order). + + + + + +When the focus moves from window A to +PointerRoot +(or +None) +and the pointer is in window P: + + + + + + +If P is an inferior of A, +FocusOut +with detail +Pointer +is generated on each window from P up to but not including A (in order). + + + + +FocusOut +with detail +Nonlinear +is generated on A. + + + + +If A is not a root window, +FocusOut +with detail +NonlinearVirtual +is generated on each window above A up to and including its root (in order). + + + + +FocusIn +with detail +PointerRoot +(or +None) +is generated on all root windows. + + + + +If the new focus is +PointerRoot, +FocusIn +with detail +Pointer +is generated on each window from P's root down to and including P (in order). + + + + + +When the focus moves from +PointerRoot +(or +None) +to window A and the pointer is in window P: + + + + + + +If the old focus is +PointerRoot, +FocusOut +with detail +Pointer +is generated on each window from P up to and including P's root (in order). + + + + +FocusOut +with detail +PointerRoot +(or +None) +is generated on all root windows. + + + + +If A is not a root window, +FocusIn +with detail +NonlinearVirtual +is generated on each window from A's root down to but not including A +(in order). + + + + +FocusIn +with detail +Nonlinear +is generated on A. + + + + +If P is an inferior of A, +FocusIn +with detail +Pointer +is generated on each window below A down to and including P (in order). + + + + + +When the focus moves from +PointerRoot +to +None +(or vice versa) and the pointer is in window P: + + + + + +If the old focus is +PointerRoot, +FocusOut +with detail +Pointer +is generated on each window from P up to and including P's root (in order). + + + + +FocusOut +with detail +PointerRoot +(or +None) +is generated on all root windows. + + + + +FocusIn +with detail +None +(or +PointerRoot) +is generated on all root windows. + + + + +If the new focus is +PointerRoot, +FocusIn +with detail +Pointer +is generated on each window from P's root down to and including P (in order). + + + + + + +When a keyboard grab activates (but before generating any actual +KeyPress +event that activates the grab), G is the grab-window for the grab, +and F is the current focus: + + + + + +FocusIn +and +FocusOut +events with mode +Grab +are generated (as for +Normal +above) as if the focus were to change from F to G. + + + + + +When a keyboard grab deactivates (but after generating any actual +KeyRelease +event that deactivates the grab), G is the grab-window for the grab, +and F is the current focus: + + + + + +FocusIn +and +FocusOut +events with mode +Ungrab +are generated (as for +Normal +above) as if the focus were to change from G to F. + + + + +
+
+ KeymapNotify + KeymapNotify + + + + + + + + + KeymapNotify + + + + +keys: LISTofCARD8 + + + + + + + +The value is a bit vector as described in +QueryKeymap. +This event is reported to clients selecting +KeymapState +on a window and is generated immediately after every +EnterNotify +and +FocusIn. + + +
+
+ Expose + Expose + EventExposure + + + + + + + + Expose + + + + + +window: WINDOW + + + + +x, +y, +width, +height: CARD16 + + + + +count: CARD16 + + + + + + + + +This event is reported to clients selecting +Exposure +on the window. +It is generated when no valid contents are available for regions of a window, +and either the regions are visible, the regions are viewable +and the server is (perhaps newly) maintaining backing store on the window, +or the window is not viewable but the server is (perhaps newly) honoring +window's backing-store attribute of +Always +or +WhenMapped. +The regions are decomposed into an arbitrary set of rectangles, +and an +Expose +event is generated for each rectangle. + + +For a given action causing exposure events, +the set of events for a given window are guaranteed to be reported contiguously. +If count is zero, +then no more +Expose +events for this window follow. +If count is nonzero, +then at least that many more +Expose +events for this window follow (and possibly more). + + +The x and y coordinates are relative to window's origin +and specify the upper-left corner of a rectangle. +The width and height specify the extent of the rectangle. + + +Expose +events are never generated on +InputOnly +windows. + + +All +Expose +events caused by a hierarchy change are generated after any +hierarchy event caused by that change (for example, +UnmapNotify, +MapNotify, +ConfigureNotify, +GravityNotify, +CirculateNotify). +All +Expose +events on a given window are generated after any +VisibilityNotify +event on that window, +but it is not required that all +Expose +events on all windows be generated after all +Visibilitity +events on all windows. +The ordering of +Expose +events with respect to +FocusOut, +EnterNotify, +and +LeaveNotify +events is not constrained. + + +
+
+ GraphicsExposure + GraphicsExposure + + + + + + + + GraphicsExposure + + + + + +drawable: DRAWABLE + + + + +x, y, width, height: CARD16 + + + + +count: CARD16 + + + + +major-opcode: CARD8 + + + + +minor-opcode: CARD16 + + + + + + + + + +This event is reported to a client using a graphics context +with graphics-exposures selected +and is generated when a destination region could not be computed due +to an obscured or out-of-bounds source region. +All of the regions exposed by a given graphics request +are guaranteed to be reported contiguously. +If count is zero then no more +GraphicsExposure +events for this window follow. +If count is nonzero, +then at least that many more +GraphicsExposure +events for this window follow (and possibly more). + + +The x and y coordinates are relative to drawable's origin +and specify the upper-left corner of a rectangle. +The width and height specify the extent of the rectangle. + + +The major and minor opcodes identify the graphics request used. +For the core protocol, +major-opcode is always +CopyArea +or +CopyPlane, +and minor-opcode is always zero. + + +
+
+ NoExposure + NoExposure + + + + + + + + NoExposure + + + + + +drawable: DRAWABLE + + + + +major-opcode: CARD8 + + + + +minor-opcode: CARD16 + + + + + + + + + +This event is reported to a client using a graphics context +with graphics-exposures selected +and is generated when a graphics request +that might produce +GraphicsExposure +events does not produce any. +The drawable specifies the destination used for the graphics request. + + +The major and minor opcodes identify the graphics request used. +For the core protocol, +major-opcode is always +CopyArea +or +CopyPlane, +and the minor-opcode is always zero. + + +
+
+ VisibilityNotify + VisibilityNotify + + + + + + + + VisibilityNotify + + + + + +window: WINDOW + + + + +state: +{ Unobscured, +PartiallyObscured, +FullyObscured} + + + + + + + + + +This event is reported to clients selecting +VisibilityChange +on the window. +In the following, +the state of the window is calculated ignoring all of the window's subwindows. +When a window changes state from partially or fully obscured or +not viewable to viewable and completely unobscured, +an event with +Unobscured +is generated. +When a window changes state from viewable and completely unobscured, +from viewable and completely obscured, +or from not viewable, to viewable and partially obscured, +an event with +PartiallyObscured +is generated. +When a window changes state from viewable and completely unobscured, +from viewable and partially obscured, +or from not viewable to viewable and fully obscured, +an event with +FullyObscured +is generated. + + +VisibilityNotify +events are never generated on +InputOnly +windows. + + +All +VisibilityNotify +events caused by a hierarchy change are generated after any hierarchy event +caused by that change (for example, +UnmapNotify, +MapNotify, +ConfigureNotify, +GravityNotify, +CirculateNotify). +Any +VisibilityNotify +event on a given window is generated before any +Expose +events on that window, +but it is not required that all +VisibilityNotify +events on all windows be generated before all +Expose +events on all windows. +The ordering of +VisibilityNotify +events with respect to +FocusOut, +EnterNotify, +and +LeaveNotify +events is not constrained. + + +
+
+ CreateNotify + CreateNotify + + + + + + + + CreateNotify + + + + + +parent, window: WINDOW + + + + +x, y: INT16 + + + + +width, height, border-width: CARD16 + + + + +override-redirect: BOOL + + + + + + + + + +This event is reported to clients selecting +SubstructureNotify +on the parent +and is generated when the window is created. +The arguments are as in the +CreateWindow +request. + + +
+
+ DestroyNotify + DestroyNotify + + + + + + + + DestroyNotify + + + + + +event, window: WINDOW + + + + + + + + + +This event is reported to clients selecting +StructureNotify +on the window and to clients selecting +SubstructureNotify +on the parent. +It is generated when the window is destroyed. +The event is the window on which the event was generated, +and the window is the window that is destroyed. + + +The ordering of the +DestroyNotify +events is such that for any given window, +DestroyNotify +is generated on all inferiors of the window +before being generated on the window itself. +The ordering among siblings and across subhierarchies is not +otherwise constrained. + + +
+
+ UnmapNotify + UnmapNotify + + + + + + + + UnmapNotify + + + + + +event, window: WINDOW + + + + +from-configure: BOOL + + + + + + + + + +This event is reported to clients selecting +StructureNotify +on the window and to clients selecting +SubstructureNotify +on the parent. +It is generated when the window changes state from mapped to unmapped. +The event is the window on which the event was generated, +and the window is the window that is unmapped. +The from-configure flag is +True +if the event was generated as a result of the window's parent being resized +when the window itself had a win-gravity of +Unmap. + + +
+
+ MapNotify + MapNotify + Mapped window + + + + + + + + MapNotify + + + + + +event, window: WINDOW + + + + +override-redirect: BOOL + + + + + + + + + +This event is reported to clients selecting +StructureNotify +on the window and to clients selecting +SubstructureNotify +on the parent. +It is generated when the window changes state from unmapped to mapped. +The event is the window on which the event was generated, +and the window is the window that is mapped. +The override-redirect flag is from the window's attribute. + + +
+
+ MapRequest + MapRequest + + + + + + + + MapRequest + + + + + +parent, window: WINDOW + + + + + + + + + +This event is reported to the client selecting +SubstructureRedirect +on the parent and is generated when a +MapWindow +request is issued on an unmapped window with an override-redirect attribute of +False. + + +
+
+ ReparentNotify + ReparentNotify + + + + + + + + ReparentNotify + + + + + +event, window, parent: WINDOW + + + + +x, y: INT16 + + + + +override-redirect: BOOL + + + + + + + + + +This event is reported to clients selecting +SubstructureNotify +on either the old or the new parent and to clients selecting +StructureNotify +on the window. +It is generated when the window is reparented. +The event is the window on which the event was generated. +The window is the window that has been rerooted. +The parent specifies the new parent. +The x and y coordinates are relative to the new parent's origin +and specify the position of the upper-left outer corner of the window. +The override-redirect flag is from the window's attribute. + + +
+
+ ConfigureNotify + ConfigureNotify + + + + + + + + ConfigureNotify + + + + + +event, window: WINDOW + + + + +x, y: INT16 + + + + +width, height, border-width: CARD16 + + + + +above-sibling: WINDOW or +None + + + + +override-redirect: BOOL + + + + + + + + + +This event is reported to clients selecting +StructureNotify +on the window and to clients selecting +SubstructureNotify +on the parent. +It is generated when a +ConfigureWindow +request actually changes the state of the window. +The event is the window on which the event was generated, +and the window is the window that is changed. +The x and y coordinates are relative to the new parent's origin +and specify the position of the upper-left outer corner of the window. +The width and height specify the inside size, not including the border. +If above-sibling is +None, +then the window is on the bottom of the stack with respect to siblings. +Otherwise, the window is immediately on top of the specified sibling. +The override-redirect flag is from the window's attribute. + + +
+
+ GravityNotify + GravityNotify + + + + + + + + GravityNotify + + + + + +event, window: WINDOW + + + + +x, y: INT16 + + + + + + + + + +This event is reported to clients selecting +SubstructureNotify +on the parent and to clients selecting +StructureNotify +on the window. +It is generated when a window is moved because of a change in size +of the parent. +The event is the window on which the event was generated, +and the window is the window that is moved. +The x and y coordinates are relative to the new parent's origin +and specify the position of the upper-left outer corner of the window. + + +
+
+ ResizeRequest + ResizeRequest + + + + + + + + ResizeRequest + + + + + +window: WINDOW + + + + +width, height: CARD16 + + + + + + + + + +This event is reported to the client selecting +ResizeRedirect +on the window and is generated when a +ConfigureWindow +request by some other client on the window attempts to change the size +of the window. +The width and height are the requested inside size, not including the border. + + +
+
+ ConfigureRequest + ConfigureRequest + + + + + + + + ConfigureRequest + + + + + +parent, window: WINDOW + + + + +x, y: INT16 + + + + +width, height, border-width: CARD16 + + + + +sibling: WINDOW or +None + + + + +stack-mode: +{ Above, +Below, +TopIf, +BottomIf, +Opposite} + + + + +value-mask: BITMASK + + + + + + + + + +This event is reported to the client selecting +SubstructureRedirect +on the parent and is generated when a +ConfigureWindow +request is issued on the window by some other client. +The value-mask indicates which components were specified in the request. +The value-mask and the corresponding values are reported as given +in the request. +The remaining values are filled in from the current geometry of the window, +except in the case of sibling and stack-mode, +which are reported as +None +and +Above +(respectively) if not given in the request. + + +
+
+ CirculateNotify + CirculateNotify + + + + + + + + CirculateNotify + + + + + +event, window: WINDOW + + + + +place: +{ Top, +Bottom} + + + + + + + + + +This event is reported to clients selecting +StructureNotify +on the window and to clients selecting +SubstructureNotify +on the parent. +It is generated when the window is actually restacked from a +CirculateWindow +request. +The event is the window on which the event was generated, +and the window is the window that is restacked. +If place is +Top, +the window is now on top of all siblings. +Otherwise, it is below all siblings. + + +
+
+ CirculateRequest + CirculateRequest + + + + + + + + CirculateRequest + + + + + +parent, window: WINDOW + + + + +place: +{ Top, +Bottom} + + + + + + + + + +This event is reported to the client selecting +SubstructureRedirect +on the parent and is generated when a +CirculateWindow +request is issued on the parent and a window actually needs to be restacked. +The window specifies the window to be restacked, +and the place specifies what the new position in the stacking order should be. + + +
+
+ PropertyNotify + PropertyNotify + + + + + + + + PropertyNotify + + + + + +window: WINDOW + + + + +atom: ATOM + + + + +state: +{ NewValue, +Deleted} + + + + +time: TIMESTAMP + + + + + + + + + +This event is reported to clients selecting +PropertyChange +on the window and is generated with state +NewValue +when a property of the window is changed using +ChangeProperty +or +RotateProperties, +even when adding zero-length data using +ChangeProperty +and when replacing all or part of a property with identical data using +ChangeProperty +or +RotateProperties. +It is generated with state +Deleted +when a property of the +window is deleted using request +DeleteProperty +or +GetProperty. +The timestamp indicates the server time when the property was changed. + + +
+
+ SelectionClear + SelectionClear + + + + + + + + SelectionClear + + + + + +owner: WINDOW + + + + +selection: ATOM + + + + +time: TIMESTAMP + + + + + + + + + +This event is reported to the current owner of a selection +and is generated when a new owner is being defined by means of +SetSelectionOwner. +The timestamp is the last-change time recorded for the selection. +The owner argument is the window that was specified by the current owner in its +SetSelectionOwner +request. + + +
+
+ SelectionRequest + SelectionRequest + + + + + + + + SelectionRequest + + + + + +owner: WINDOW + + + + +selection: ATOM + + + + +target: ATOM + + + + +property: ATOM or +None + + + + +requestor: WINDOW + + + + +time: TIMESTAMP or +CurrentTime + + + + + + + + + +This event is reported to the owner of a selection +and is generated when a client issues a +ConvertSelection +request. +The owner argument is the window that was specified in the +SetSelectionOwner +request. +The remaining arguments are as in the +ConvertSelection +request. + + +The owner should convert the selection based on the specified target type +and send a +SelectionNotify +back to the requestor. +A complete specification for using selections is given in the X.Org +standard Inter-Client Communication Conventions Manual. + + +
+
+ SelectionNotify + SelectionNotify + + + + + + + + SelectionNotify + + + + + +requestor: WINDOW + + + + +selection, target: ATOM + + + + +property: ATOM or +None + + + + +time: TIMESTAMP or +CurrentTime + + + + + + + + + +This event is generated by the server in response to a +ConvertSelection +request when there is no owner for the selection. +When there is an owner, +it should be generated by the owner using +SendEvent. +The owner of a selection should send this event to a requestor either +when a selection has been converted and stored as a property +or when a selection conversion could not be performed (indicated with property +None). + + +
+
+ ColormapNotify + ColormapNotify + + + + + + + + ColormapNotify + + + + + +window: WINDOW + + + + +colormap: COLORMAP or +None + + + + +new: BOOL + + + + +state: +{ Installed, +Uninstalled} + + + + + + + + + +This event is reported to clients selecting +ColormapChange +on the window. +It is generated with value +True +for new when the colormap attribute of the window is changed +and is generated with value +False +for new when the colormap of a window is installed or uninstalled. +In either case, +the state indicates whether the colormap is currently installed. + + +
+
+ MappingNotify + MappingNotify + + + + + + + + MappingNotify + + + + + +request: +{ Modifier, +Keyboard, +Pointer} + + + + +first-keycode, count: CARD8 + + + + + + + + + +This event is sent to all clients. +There is no mechanism to express disinterest in this event. +The detail indicates the kind of change that occurred: +Modifiers +for a successful +SetModifierMapping, +Keyboard +for a successful +ChangeKeyboardMapping, +and +Pointer +for a successful +SetPointerMapping. +If the detail is +Keyboard, +then first-keycode and count indicate the range of altered keycodes. + + +
+
+ ClientMessage + ClientMessage + + + + + + + + ClientMessage + + + + + +window: WINDOW + + + + +type: ATOM + + + + +format: {8, 16, 32} + + + + +data: LISTofINT8 or LISTofINT16 or LISTofINT32 + + + + + + + + + +This event is only generated by clients using +SendEvent. +The type specifies how the data is to be interpreted by the receiving client; +the server places no interpretation on the type or the data. +The format specifies whether the data should be viewed as a list of 8-bit, +16-bit, or 32-bit quantities, so that the server can correctly +byte-swap, as necessary. +The data always consists of either 20 8-bit values or 10 16-bit values +or 5 32-bit values, although particular message types might not make use +of all of these values. + +
+ + +Flow Control and Concurrency + + + + +Whenever the server is writing to a given connection, +it is permissible for the server to stop reading from that connection +(but if the writing would block, it must continue to service other connections). +The server is not required to buffer more than a single request per connection +at one time. +For a given connection to the server, +a client can block while reading from the connection +but should undertake to read (events and errors) when writing would block. +Failure on the part of a client to obey this rule could result +in a deadlocked connection, +although deadlock is probably unlikely unless either +the transport layer has very little buffering or the client attempts to +send large numbers of requests without ever reading replies or checking for +errors and events. + + +Whether or not a server is implemented with internal concurrency, +the overall effect must be as if individual requests are executed to completion +in some serial order, +and requests from a given connection must be executed in delivery order +(that is, the total execution order is a shuffle of the individual streams). +The execution of a request includes validating all arguments, +collecting all data for any reply, +and generating and queueing all required events. +However, +it does not include the actual transmission of the reply and the events. +In addition, the effect of any other cause that can generate multiple events +(for example, activation of a grab or pointer motion) must effectively generate +and queue all required events indivisibly with respect to all other causes +and requests. +For a request from a given client, +any events destined for that client that are caused by executing the request +must be sent to the client before any reply or error is sent. + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xproto/x11protocol.xml b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xproto/x11protocol.xml new file mode 100644 index 0000000000000000000000000000000000000000..87ac55545cc889ccf89cd9e0da0ab99746e74202 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/doc/xproto/x11protocol.xml @@ -0,0 +1,64 @@ + + %defs; +]> + + + + + + X Window System Protocol + X Consortium Standard + + Robert + W. + Scheifler + X Consortium, Inc. + + X Version 11, Release &fullrelvers; + Version 1.0 + 19861987198819942004 + The Open Group + + + + + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + + +THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + +Except as contained in this notice, the name of the Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from the Open Group. + +X Window System is a trademark of The Open Group. + + + + + + + + + + diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/applewmproto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/applewmproto.pc new file mode 100644 index 0000000000000000000000000000000000000000..91d7367b9a093b4200c27ee838117be531858784 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/applewmproto.pc @@ -0,0 +1,7 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: AppleWMProto +Description: AppleWM extension headers +Version: 1.4.2 +Cflags: -I${includedir} diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/bigreqsproto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/bigreqsproto.pc new file mode 100644 index 0000000000000000000000000000000000000000..0efee87e0e1f36699fcd4a009d73f8c730c10261 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/bigreqsproto.pc @@ -0,0 +1,7 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: BigReqsProto +Description: BigReqs extension headers +Version: 1.1.2 +Cflags: -I${includedir} diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/compositeproto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/compositeproto.pc new file mode 100644 index 0000000000000000000000000000000000000000..5c9775783720afc3090a08cf768741bcbcf8327a --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/compositeproto.pc @@ -0,0 +1,7 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: CompositeExt +Description: Composite extension headers +Version: 0.4.2 +Cflags: -I${includedir} diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/damageproto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/damageproto.pc new file mode 100644 index 0000000000000000000000000000000000000000..7c6bae267871840e7f9220821261cb2ed484c2d2 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/damageproto.pc @@ -0,0 +1,7 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: DamageProto +Description: Damage extension headers +Version: 1.2.1 +Cflags: -I${includedir} diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/dmxproto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/dmxproto.pc new file mode 100644 index 0000000000000000000000000000000000000000..e35f63be767957e8a2a4f8f294fc11bbeeb9afce --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/dmxproto.pc @@ -0,0 +1,7 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: DMXProto +Description: DMX extension headers +Version: 2.3.1 +Cflags: -I${includedir} diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/dpmsproto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/dpmsproto.pc new file mode 100644 index 0000000000000000000000000000000000000000..d5ec1ded25653e963ed8be73585019e6bd5ee670 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/dpmsproto.pc @@ -0,0 +1,7 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: DPMSProto +Description: DPMS extension headers +Version: 1.2 +Cflags: -I${includedir} diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/dri2proto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/dri2proto.pc new file mode 100644 index 0000000000000000000000000000000000000000..15c2c893a2c6e5c60ec066a874af776396cc071d --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/dri2proto.pc @@ -0,0 +1,7 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: DRI2Proto +Description: DRI2 extension headers +Version: 2.8 +Cflags: -I${includedir} diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/dri3proto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/dri3proto.pc new file mode 100644 index 0000000000000000000000000000000000000000..b4bf1b3d2b653f6e63a68e1ebb71e10e37c9c510 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/dri3proto.pc @@ -0,0 +1,7 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: DRI3Proto +Description: DRI3 extension headers +Version: 1.4 +Cflags: -I${includedir} diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/fixesproto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/fixesproto.pc new file mode 100644 index 0000000000000000000000000000000000000000..d7b5086df8b87d8f43d1cc7fcd0888b620c29252 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/fixesproto.pc @@ -0,0 +1,8 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: FixesProto +Description: X Fixes extension headers +Version: 6.1 +Cflags: -I${includedir} +Requires: xextproto >= 7.0.99.1 diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/fontsproto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/fontsproto.pc new file mode 100644 index 0000000000000000000000000000000000000000..cea965307723c32923ed1a42d08e6178507c87ff --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/fontsproto.pc @@ -0,0 +1,7 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: FontsProto +Description: Fonts extension headers +Version: 2.1.3 +Cflags: -I${includedir} diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/glproto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/glproto.pc new file mode 100644 index 0000000000000000000000000000000000000000..a4fdc604b0211254b64eba68c02505c369185ecb --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/glproto.pc @@ -0,0 +1,7 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: GLProto +Description: GL extension headers +Version: 1.4.17 +Cflags: -I${includedir} diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/inputproto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/inputproto.pc new file mode 100644 index 0000000000000000000000000000000000000000..f75756488804b0b99bc6ceeb198ffb912c60c5fb --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/inputproto.pc @@ -0,0 +1,7 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: InputProto +Description: Input extension headers +Version: 2.3.99.2 +Cflags: -I${includedir} diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/kbproto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/kbproto.pc new file mode 100644 index 0000000000000000000000000000000000000000..cf655d5f2761997f9ea762a4ea04654f2fc75e6c --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/kbproto.pc @@ -0,0 +1,7 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: KBProto +Description: KB extension headers +Version: 1.0.7 +Cflags: -I${includedir} diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/presentproto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/presentproto.pc new file mode 100644 index 0000000000000000000000000000000000000000..65620535c968bbc2b95eba1655ebf9f2160e0040 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/presentproto.pc @@ -0,0 +1,7 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: PresentProto +Description: Present extension headers +Version: 1.4 +Cflags: -I${includedir} diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/randrproto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/randrproto.pc new file mode 100644 index 0000000000000000000000000000000000000000..86d35d00bf8030557912b253d9aee4c76cc1648b --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/randrproto.pc @@ -0,0 +1,7 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: RandrProto +Description: Randr extension headers +Version: 1.6.0 +Cflags: -I${includedir} diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/recordproto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/recordproto.pc new file mode 100644 index 0000000000000000000000000000000000000000..b6be29330dc1626981205faac41adc674eb6c28a --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/recordproto.pc @@ -0,0 +1,7 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: RecordProto +Description: Record extension headers +Version: 1.14.2 +Cflags: -I${includedir} diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/renderproto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/renderproto.pc new file mode 100644 index 0000000000000000000000000000000000000000..4f7403729b5d91c9873f7823b2e2d93dcf7680d5 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/renderproto.pc @@ -0,0 +1,7 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: RenderProto +Description: Render extension headers +Version: 0.11.1 +Cflags: -I${includedir} diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/resourceproto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/resourceproto.pc new file mode 100644 index 0000000000000000000000000000000000000000..387d14ee06700eaa912f126a34d1f9d7c9cfcf1e --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/resourceproto.pc @@ -0,0 +1,7 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: ResourceProto +Description: Resource extension headers +Version: 1.2.0 +Cflags: -I${includedir} diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/scrnsaverproto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/scrnsaverproto.pc new file mode 100644 index 0000000000000000000000000000000000000000..776c8ae7c4bfeab631b90c4b8b08626855217c6e --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/scrnsaverproto.pc @@ -0,0 +1,7 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: ScrnSaverProto +Description: ScrnSaver extension headers +Version: 1.2.3 +Cflags: -I${includedir} diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/videoproto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/videoproto.pc new file mode 100644 index 0000000000000000000000000000000000000000..a6007f4247f54b55d8ab784e2cfcba673d4dcdc2 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/videoproto.pc @@ -0,0 +1,7 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: VideoProto +Description: Video extension headers +Version: 2.3.3 +Cflags: -I${includedir} diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/xcmiscproto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/xcmiscproto.pc new file mode 100644 index 0000000000000000000000000000000000000000..c7583104468818991d66f5df0007325e15462394 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/xcmiscproto.pc @@ -0,0 +1,7 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: XCMiscProto +Description: XCMisc extension headers +Version: 1.2.2 +Cflags: -I${includedir} diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/xextproto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/xextproto.pc new file mode 100644 index 0000000000000000000000000000000000000000..06b4a9445c45c839d3525ac39a07a96262c8e115 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/xextproto.pc @@ -0,0 +1,7 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: XExtProto +Description: XExt extension headers +Version: 7.3.0 +Cflags: -I${includedir} diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/xf86bigfontproto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/xf86bigfontproto.pc new file mode 100644 index 0000000000000000000000000000000000000000..c6488f8e6b49765c7ba984b7f7ac7d6541ffdbc5 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/xf86bigfontproto.pc @@ -0,0 +1,7 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: XF86BigFontProto +Description: XF86BigFont extension headers +Version: 1.2.0 +Cflags: -I${includedir} diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/xf86dgaproto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/xf86dgaproto.pc new file mode 100644 index 0000000000000000000000000000000000000000..fb3dfa504e0ea93377bb7ace6f6d6f747cdbce16 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/xf86dgaproto.pc @@ -0,0 +1,7 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: XF86DGAProto +Description: XF86DGA extension headers +Version: 2.1 +Cflags: -I${includedir} diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/xf86driproto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/xf86driproto.pc new file mode 100644 index 0000000000000000000000000000000000000000..77a8111b3d32e46b59f6fa06ac4c0b8f531f48e8 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/xf86driproto.pc @@ -0,0 +1,7 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: XF86DRIProto +Description: XF86DRI extension headers +Version: 2.1.1 +Cflags: -I${includedir}/X11/dri diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/xf86vidmodeproto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/xf86vidmodeproto.pc new file mode 100644 index 0000000000000000000000000000000000000000..275408dd714233fbdea5f7705ff80baddc43f9f5 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/xf86vidmodeproto.pc @@ -0,0 +1,7 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: XF86VidModeProto +Description: XF86VidMode extension headers +Version: 2.3.1 +Cflags: -I${includedir} diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/xineramaproto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/xineramaproto.pc new file mode 100644 index 0000000000000000000000000000000000000000..1cdb46a2cd1399d46ddf5a0224eb303039245131 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/xineramaproto.pc @@ -0,0 +1,7 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: XineramaProto +Description: Xinerama extension headers +Version: 1.2.1 +Cflags: -I${includedir} diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/xproto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/xproto.pc new file mode 100644 index 0000000000000000000000000000000000000000..85e26264d1dcd98d25106ac0bda156e75d095061 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/xproto.pc @@ -0,0 +1,8 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include +includex11dir=${prefix}/include/X11 + +Name: Xproto +Description: Xproto headers +Version: 7.0.33 +Cflags: -I${includedir} diff --git a/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/xwaylandproto.pc b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/xwaylandproto.pc new file mode 100644 index 0000000000000000000000000000000000000000..d7af1a02ec81957868109d35c9361b56900c05f3 --- /dev/null +++ b/miniconda3/pkgs/xorg-xorgproto-2024.1-h5eee18b_1/share/pkgconfig/xwaylandproto.pc @@ -0,0 +1,7 @@ +prefix=/croot/xorg-xorgproto_1746046208107/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_pl +includedir=${prefix}/include + +Name: XwaylandProto +Description: Xwayland extension headers +Version: 1.0 +Cflags: -I${includedir} diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/lzcmp b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/lzcmp new file mode 100644 index 0000000000000000000000000000000000000000..d76f65118f96cd9ea2e366974ef228c27b0cdbe0 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/lzcmp @@ -0,0 +1,224 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0-or-later + +# Copyright (C) 1998, 2002, 2006, 2007 Free Software Foundation +# Copyright (C) 1993 Jean-loup Gailly + +# Modified for XZ Utils by Andrew Dudman and Lasse Collin. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# shellcheck shell=sh disable=SC1003,SC2016 + + +#SET_PATH - This line is a placeholder to ease patching this script. + +# Instead of unsetting XZ_OPT, just make sure that xz will use file format +# autodetection. This way memory usage limit and thread limit can be +# specified via XZ_OPT. With gzip, bzip2, and lzop it's OK to just unset the +# environment variables. +xz='xz --format=auto' +unset GZIP BZIP BZIP2 LZOP + +case ${0##*/} in + *cmp*) prog=xzcmp; cmp=${CMP:-cmp};; + *) prog=xzdiff; cmp=${DIFF:-diff};; +esac + +version="$prog (XZ Utils) 5.8.2" + +usage="Usage: ${0##*/} [OPTION]... FILE1 [FILE2] +Compare FILE1 to FILE2, using their uncompressed contents if they are +compressed. If FILE2 is omitted, then the files compared are FILE1 and +FILE1 from which the compression format suffix has been stripped. + +Do comparisons like '$cmp' does. OPTIONs are the same as for '$cmp'. + +Report bugs to ." + +# sed script to escape all ' for the shell, and then (to handle trailing +# newlines correctly) turn trailing X on last line into '. +escape=' + s/'\''/'\''\\'\'''\''/g + $s/X$/'\''/ +' + +while :; do + case $1 in + --h*) printf '%s\n' "$usage" || exit 2; exit;; + --v*) printf '%s\n' "$version" || exit 2; exit;; + --) shift; break;; + -*\'*) cmp="$cmp '"`printf '%sX\n' "$1" | sed "$escape"`;; + -?*) cmp="$cmp '$1'";; + *) break;; + esac + shift +done +cmp="$cmp --" + +for file; do + test "X$file" = X- || true < "$file" || exit 2 +done + +# xz needs -qQ to ignore warnings like unsupported check type. +xz1="$xz -qQ" +xz2="$xz -qQ" +xz_status=0 +exec 3>&1 + +if test $# -eq 1; then + case $1 in + *[-.]xz | *[-.]lzma | *[-.]lz | *.t[lx]z) + ;; + *[-.]bz2 | *.tbz | *.tbz2) + xz1=bzip2;; + *[-.][zZ] | *_z | *[-.]gz | *.t[ag]z) + xz1=gzip;; + *[-.]lzo | *.tzo) + xz1=lzop;; + *[-.]zst | *.tzst) + xz1='zstd -q';; + *[-.]lz4) + xz1=lz4;; + *) + printf '%s\n' "$0: $1: Unknown compressed file name suffix" >&2 + exit 2;; + esac + # The FILE variable is used with eval, and shellcheck doesn't see that. + # shellcheck disable=SC2034 + case $1 in + *[-.][zZ] | *_z | *[-.][gx]z | *[-.]bz2 | *[-.]lzma | *[-.]lz | *[-.]lzo | *[-.]zst | *[-.]lz4) + FILE=`expr "X$1" : 'X\(.*\)[-.][abglmostxzZ24]*$'`;; + *.t[abglx]z) + FILE=`expr "X$1" : 'X\(.*[-.]t\)[abglx]z$'`ar;; + *.tbz2) + FILE=`expr "X$1" : 'X\(.*[-.]t\)bz2$'`ar;; + *.tzo) + FILE=`expr "X$1" : 'X\(.*[-.]t\)zo$'`ar;; + *.tzst) + FILE=`expr "X$1" : 'X\(.*[-.]t\)zst$'`ar;; + esac + xz_status=$( + exec 4>&1 + ($xz1 -cd -- "$1" 4>&-; echo $? >&4) 3>&- | eval "$cmp" - '"$FILE"' >&3 + ) +elif test $# -eq 2; then + case $1 in + *[-.]bz2 | *.tbz | *.tbz2) xz1=bzip2;; + *[-.][zZ] | *_z | *[-.]gz | *.t[ag]z) xz1=gzip;; + *[-.]lzo | *.tzo) xz1=lzop;; + *[-.]zst | *.tzst) xz1='zstd -q';; + *[-.]lz4) xz1=lz4;; + esac + case $2 in + *[-.]bz2 | *.tbz | *.tbz2) xz2=bzip2;; + *[-.][zZ] | *_z | *[-.]gz | *.t[ag]z) xz2=gzip;; + *[-.]lzo | *.tzo) xz2=lzop;; + *[-.]zst | *.tzst) xz2='zstd -q';; + *[-.]lz4) xz2=lz4;; + esac + case $1 in + *[-.][zZ] | *_z | *[-.][gx]z | *[-.]bz2 | *[-.]lzma | *[-.]lz | *.t[abglx]z | *.tbz2 | *[-.]lzo | *.tzo | *[-.]zst | *.tzst | *[-.]lz4 | -) + case "$2" in + *[-.][zZ] | *_z | *[-.][gx]z | *[-.]bz2 | *[-.]lzma | *[-.]lz | *.t[abglx]z | *.tbz2 | *[-.]lzo | *.tzo | *[-.]zst | *.tzst | *[-.]lz4 | -) + if test "$1$2" = --; then + xz_status=$( + exec 4>&1 + ($xz1 -cdf - 4>&-; echo $? >&4) 3>&- | + eval "$cmp" - - >&3 + ) + elif # Reject Solaris 8's buggy /bin/bash 2.03. + echo X | (echo X | eval "$cmp" /dev/fd/5 - >/dev/null 2>&1) 5<&0; then + # NOTE: xz_status will contain two numbers. + xz_status=$( + exec 4>&1 + ($xz1 -cdf -- "$1" 4>&-; echo $? >&4) 3>&- | + ( ($xz2 -cdf -- "$2" 4>&-; echo $? >&4) 3>&- 5<&- &3) 5<&0 + ) + else + F=`expr "/$2" : '.*/\(.*\)[-.][ablmotxz2]*$'` || F=$prog + tmp= + trap ' + test -n "$tmp" && rm -rf "$tmp" + (exit 2); exit 2 + ' HUP INT PIPE TERM 0 + if type mktemp >/dev/null 2>&1; then + # Note that FreeBSD's mktemp isn't fully compatible with + # the implementations from mktemp.org and GNU coreutils. + # It is important that the -t argument is the last argument + # and that no "--" is used between -t and the template argument. + # This way this command works on all implementations. + tmp=`mktemp -d -t "$prog.XXXXXXXXXX"` || exit 2 + else + # Fallback code if mktemp is missing. This isn't as + # robust as using mktemp since this doesn't try with + # different file names in case of a file name conflict. + # + # There's no need to save the original umask since + # we don't create any non-temp files. Note that using + # mkdir -m 0077 isn't secure since some mkdir implementations + # create the dir with the default umask and chmod the + # the dir afterwards. + umask 0077 + mkdir -- "${TMPDIR-/tmp}/$prog.$$" || exit 2 + tmp="${TMPDIR-/tmp}/$prog.$$" + fi + $xz2 -cdf -- "$2" > "$tmp/$F" || exit 2 + xz_status=$( + exec 4>&1 + ($xz1 -cdf -- "$1" 4>&-; echo $? >&4) 3>&- | + eval "$cmp" - '"$tmp/$F"' >&3 + ) + cmp_status=$? + rm -rf "$tmp" || xz_status=$? + trap - HUP INT PIPE TERM 0 + (exit $cmp_status) + fi;; + *) + xz_status=$( + exec 4>&1 + ($xz1 -cdf -- "$1" 4>&-; echo $? >&4) 3>&- | + eval "$cmp" - '"$2"' >&3 + );; + esac;; + *) + case "$2" in + *[-.][zZ] | *_z | *[-.][gx]z | *[-.]bz2 | *[-.]lzma | *[-.]lz | *.t[abglx]z | *.tbz2 | *[-.]lzo | *.tzo | *[-.]zst | *.tzst | *[-.]lz4 | -) + xz_status=$( + exec 4>&1 + ($xz2 -cdf -- "$2" 4>&-; echo $? >&4) 3>&- | + eval "$cmp" '"$1"' - >&3 + );; + *) + eval "$cmp" '"$1"' '"$2"';; + esac;; + esac +else + printf '%s\n' "$0: Invalid number of operands; try '${0##*/} --help' for help" >&2 + exit 2 +fi + +cmp_status=$? +for num in $xz_status ; do + # 0 from decompressor means successful decompression. SIGPIPE from + # decompressor is possible when diff or cmp exits before the whole file + # has been decompressed. In that case we want to retain the exit status + # from diff or cmp. Note that using "trap '' PIPE" is not possible + # because gzip changes its behavior (including exit status) if SIGPIPE + # is ignored. + test "$num" -eq 0 && continue + test "$num" -ge 128 \ + && test "$(kill -l "$num" 2> /dev/null)" = "PIPE" \ + && continue + exit 2 +done +exit $cmp_status diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/lzdiff b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/lzdiff new file mode 100644 index 0000000000000000000000000000000000000000..d76f65118f96cd9ea2e366974ef228c27b0cdbe0 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/lzdiff @@ -0,0 +1,224 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0-or-later + +# Copyright (C) 1998, 2002, 2006, 2007 Free Software Foundation +# Copyright (C) 1993 Jean-loup Gailly + +# Modified for XZ Utils by Andrew Dudman and Lasse Collin. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# shellcheck shell=sh disable=SC1003,SC2016 + + +#SET_PATH - This line is a placeholder to ease patching this script. + +# Instead of unsetting XZ_OPT, just make sure that xz will use file format +# autodetection. This way memory usage limit and thread limit can be +# specified via XZ_OPT. With gzip, bzip2, and lzop it's OK to just unset the +# environment variables. +xz='xz --format=auto' +unset GZIP BZIP BZIP2 LZOP + +case ${0##*/} in + *cmp*) prog=xzcmp; cmp=${CMP:-cmp};; + *) prog=xzdiff; cmp=${DIFF:-diff};; +esac + +version="$prog (XZ Utils) 5.8.2" + +usage="Usage: ${0##*/} [OPTION]... FILE1 [FILE2] +Compare FILE1 to FILE2, using their uncompressed contents if they are +compressed. If FILE2 is omitted, then the files compared are FILE1 and +FILE1 from which the compression format suffix has been stripped. + +Do comparisons like '$cmp' does. OPTIONs are the same as for '$cmp'. + +Report bugs to ." + +# sed script to escape all ' for the shell, and then (to handle trailing +# newlines correctly) turn trailing X on last line into '. +escape=' + s/'\''/'\''\\'\'''\''/g + $s/X$/'\''/ +' + +while :; do + case $1 in + --h*) printf '%s\n' "$usage" || exit 2; exit;; + --v*) printf '%s\n' "$version" || exit 2; exit;; + --) shift; break;; + -*\'*) cmp="$cmp '"`printf '%sX\n' "$1" | sed "$escape"`;; + -?*) cmp="$cmp '$1'";; + *) break;; + esac + shift +done +cmp="$cmp --" + +for file; do + test "X$file" = X- || true < "$file" || exit 2 +done + +# xz needs -qQ to ignore warnings like unsupported check type. +xz1="$xz -qQ" +xz2="$xz -qQ" +xz_status=0 +exec 3>&1 + +if test $# -eq 1; then + case $1 in + *[-.]xz | *[-.]lzma | *[-.]lz | *.t[lx]z) + ;; + *[-.]bz2 | *.tbz | *.tbz2) + xz1=bzip2;; + *[-.][zZ] | *_z | *[-.]gz | *.t[ag]z) + xz1=gzip;; + *[-.]lzo | *.tzo) + xz1=lzop;; + *[-.]zst | *.tzst) + xz1='zstd -q';; + *[-.]lz4) + xz1=lz4;; + *) + printf '%s\n' "$0: $1: Unknown compressed file name suffix" >&2 + exit 2;; + esac + # The FILE variable is used with eval, and shellcheck doesn't see that. + # shellcheck disable=SC2034 + case $1 in + *[-.][zZ] | *_z | *[-.][gx]z | *[-.]bz2 | *[-.]lzma | *[-.]lz | *[-.]lzo | *[-.]zst | *[-.]lz4) + FILE=`expr "X$1" : 'X\(.*\)[-.][abglmostxzZ24]*$'`;; + *.t[abglx]z) + FILE=`expr "X$1" : 'X\(.*[-.]t\)[abglx]z$'`ar;; + *.tbz2) + FILE=`expr "X$1" : 'X\(.*[-.]t\)bz2$'`ar;; + *.tzo) + FILE=`expr "X$1" : 'X\(.*[-.]t\)zo$'`ar;; + *.tzst) + FILE=`expr "X$1" : 'X\(.*[-.]t\)zst$'`ar;; + esac + xz_status=$( + exec 4>&1 + ($xz1 -cd -- "$1" 4>&-; echo $? >&4) 3>&- | eval "$cmp" - '"$FILE"' >&3 + ) +elif test $# -eq 2; then + case $1 in + *[-.]bz2 | *.tbz | *.tbz2) xz1=bzip2;; + *[-.][zZ] | *_z | *[-.]gz | *.t[ag]z) xz1=gzip;; + *[-.]lzo | *.tzo) xz1=lzop;; + *[-.]zst | *.tzst) xz1='zstd -q';; + *[-.]lz4) xz1=lz4;; + esac + case $2 in + *[-.]bz2 | *.tbz | *.tbz2) xz2=bzip2;; + *[-.][zZ] | *_z | *[-.]gz | *.t[ag]z) xz2=gzip;; + *[-.]lzo | *.tzo) xz2=lzop;; + *[-.]zst | *.tzst) xz2='zstd -q';; + *[-.]lz4) xz2=lz4;; + esac + case $1 in + *[-.][zZ] | *_z | *[-.][gx]z | *[-.]bz2 | *[-.]lzma | *[-.]lz | *.t[abglx]z | *.tbz2 | *[-.]lzo | *.tzo | *[-.]zst | *.tzst | *[-.]lz4 | -) + case "$2" in + *[-.][zZ] | *_z | *[-.][gx]z | *[-.]bz2 | *[-.]lzma | *[-.]lz | *.t[abglx]z | *.tbz2 | *[-.]lzo | *.tzo | *[-.]zst | *.tzst | *[-.]lz4 | -) + if test "$1$2" = --; then + xz_status=$( + exec 4>&1 + ($xz1 -cdf - 4>&-; echo $? >&4) 3>&- | + eval "$cmp" - - >&3 + ) + elif # Reject Solaris 8's buggy /bin/bash 2.03. + echo X | (echo X | eval "$cmp" /dev/fd/5 - >/dev/null 2>&1) 5<&0; then + # NOTE: xz_status will contain two numbers. + xz_status=$( + exec 4>&1 + ($xz1 -cdf -- "$1" 4>&-; echo $? >&4) 3>&- | + ( ($xz2 -cdf -- "$2" 4>&-; echo $? >&4) 3>&- 5<&- &3) 5<&0 + ) + else + F=`expr "/$2" : '.*/\(.*\)[-.][ablmotxz2]*$'` || F=$prog + tmp= + trap ' + test -n "$tmp" && rm -rf "$tmp" + (exit 2); exit 2 + ' HUP INT PIPE TERM 0 + if type mktemp >/dev/null 2>&1; then + # Note that FreeBSD's mktemp isn't fully compatible with + # the implementations from mktemp.org and GNU coreutils. + # It is important that the -t argument is the last argument + # and that no "--" is used between -t and the template argument. + # This way this command works on all implementations. + tmp=`mktemp -d -t "$prog.XXXXXXXXXX"` || exit 2 + else + # Fallback code if mktemp is missing. This isn't as + # robust as using mktemp since this doesn't try with + # different file names in case of a file name conflict. + # + # There's no need to save the original umask since + # we don't create any non-temp files. Note that using + # mkdir -m 0077 isn't secure since some mkdir implementations + # create the dir with the default umask and chmod the + # the dir afterwards. + umask 0077 + mkdir -- "${TMPDIR-/tmp}/$prog.$$" || exit 2 + tmp="${TMPDIR-/tmp}/$prog.$$" + fi + $xz2 -cdf -- "$2" > "$tmp/$F" || exit 2 + xz_status=$( + exec 4>&1 + ($xz1 -cdf -- "$1" 4>&-; echo $? >&4) 3>&- | + eval "$cmp" - '"$tmp/$F"' >&3 + ) + cmp_status=$? + rm -rf "$tmp" || xz_status=$? + trap - HUP INT PIPE TERM 0 + (exit $cmp_status) + fi;; + *) + xz_status=$( + exec 4>&1 + ($xz1 -cdf -- "$1" 4>&-; echo $? >&4) 3>&- | + eval "$cmp" - '"$2"' >&3 + );; + esac;; + *) + case "$2" in + *[-.][zZ] | *_z | *[-.][gx]z | *[-.]bz2 | *[-.]lzma | *[-.]lz | *.t[abglx]z | *.tbz2 | *[-.]lzo | *.tzo | *[-.]zst | *.tzst | *[-.]lz4 | -) + xz_status=$( + exec 4>&1 + ($xz2 -cdf -- "$2" 4>&-; echo $? >&4) 3>&- | + eval "$cmp" '"$1"' - >&3 + );; + *) + eval "$cmp" '"$1"' '"$2"';; + esac;; + esac +else + printf '%s\n' "$0: Invalid number of operands; try '${0##*/} --help' for help" >&2 + exit 2 +fi + +cmp_status=$? +for num in $xz_status ; do + # 0 from decompressor means successful decompression. SIGPIPE from + # decompressor is possible when diff or cmp exits before the whole file + # has been decompressed. In that case we want to retain the exit status + # from diff or cmp. Note that using "trap '' PIPE" is not possible + # because gzip changes its behavior (including exit status) if SIGPIPE + # is ignored. + test "$num" -eq 0 && continue + test "$num" -ge 128 \ + && test "$(kill -l "$num" 2> /dev/null)" = "PIPE" \ + && continue + exit 2 +done +exit $cmp_status diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/lzegrep b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/lzegrep new file mode 100644 index 0000000000000000000000000000000000000000..e740ea1a0f4bfe6eb8cac7cd647069236aec6e28 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/lzegrep @@ -0,0 +1,302 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0-or-later + +# xzgrep -- a wrapper around a grep program that decompresses files as needed +# Adapted from a version sent by Charles Levert + +# Copyright (C) 1998, 2001, 2002, 2006, 2007 Free Software Foundation +# Copyright (C) 1993 Jean-loup Gailly + +# Modified for XZ Utils by Andrew Dudman and Lasse Collin. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# shellcheck shell=sh disable=SC1003,SC2016 + + +#SET_PATH - This line is a placeholder to ease patching this script. + +# Instead of unsetting XZ_OPT, just make sure that xz will use file format +# autodetection. This way memory usage limit and thread limit can be +# specified via XZ_OPT. With gzip, bzip2, and lzop it's OK to just unset the +# environment variables. +xz='xz --format=auto' +unset GZIP BZIP BZIP2 LZOP + +case ${0##*/} in + *egrep*) prog=xzegrep; grep=${GREP:-grep -E};; + *fgrep*) prog=xzfgrep; grep=${GREP:-grep -F};; + *) prog=xzgrep; grep=${GREP:-grep};; +esac + +version="$prog (XZ Utils) 5.8.2" + +usage="Usage: ${0##*/} [OPTION]... [-e] PATTERN [FILE]... +Look for instances of PATTERN in the input FILEs, using their +uncompressed contents if they are compressed. + +OPTIONs are the same as for '$grep'. + +Report bugs to ." + +# sed script to escape all ' for the shell, and then (to handle trailing +# newlines correctly) turn trailing X on last line into '. +escape=' + s/'\''/'\''\\'\'''\''/g + $s/X$/'\''/ +' +operands= +have_pat=0 +files_with_matches=0 +files_without_matches=0 +no_filename=0 +with_filename=0 + +# See if -H and --label options are supported (GNU and *BSDs). +if test f:x = "$(eval "echo x | $grep -H --label=f x 2> /dev/null")"; then + grep_supports_label=1 +else + grep_supports_label=0 +fi + +while test $# -ne 0; do + option=$1 + shift + optarg= + + case $option in + (-[0123456789abcdEFGhHiIKlLnoPqrRsTuUvVwxyzZ]*[!0123456789]*) + # Something like -Fiv was specified, that is, $option contains more + # than one option of which the first option (in this example -F) + # doesn't take an argument. Split the first option into a standalone + # argument and continue parsing the rest of the options (in this example, + # replace -Fiv with -iv in the argument list and set option=-F). + # + # If there are digits [0-9] they are treated as if they were a single + # option character because this syntax is an alias for -C for GNU grep. + # For example, "grep -25F" is equivalent to "grep -C25 -F". If only + # digits are specified like "grep -25" we don't get here because the + # above pattern in the case-statement doesn't match such strings. + arg2=-\'$(LC_ALL=C expr "X${option}X" : 'X-.[0-9]*\(.*\)' | + LC_ALL=C sed "$escape") + eval "set -- $arg2 "'${1+"$@"}' + option=$(LC_ALL=C expr "X$option" : 'X\(-.[0-9]*\)');; + (--binary-*=* | --[lm]a*=* | --reg*=*) + # These options require an argument and an argument has been provided + # with the --foo=argument syntax. All is good. + ;; + (-[ABCDefmX] | --binary-* | --file | --[lm]a* | --reg*) + # These options require an argument which should now be in $1. + # If it isn't, display an error and exit. + case ${1?"$option option requires an argument"} in + (*\'*) + optarg=" '"$(printf '%sX\n' "$1" | LC_ALL=C sed "$escape");; + (*) + optarg=" '$1'";; + esac + shift;; + (--) + break;; + (-?*) + ;; + (*) + case $option in + (*\'*) + operands="$operands '"$(printf '%sX\n' "$option" | + LC_ALL=C sed "$escape");; + (*) + operands="$operands '$option'";; + esac + ${POSIXLY_CORRECT+break} + continue;; + esac + + case $option in + (-[drRzZ] | --di* | --exc* | --inc* | --rec* | --nu*) + printf >&2 '%s: %s: Option not supported\n' "$0" "$option" + exit 2;; + (-[ef]* | --file | --file=* | --reg*) + have_pat=1;; + (--h | --he | --hel | --help) + printf '%s\n' "$usage" || exit 2 + exit;; + (-H | --wi | --wit | --with | --with- | --with-f | --with-fi \ + | --with-fil | --with-file | --with-filen | --with-filena | --with-filenam \ + | --with-filename) + with_filename=1 + continue;; + (-l | --files-with-*) + files_with_matches=1 + continue;; + (-L | --files-witho*) + files_without_matches=1 + continue;; + (-h | --no-f*) + no_filename=1;; + (-V | --v | --ve | --ver | --vers | --versi | --versio | --version) + printf '%s\n' "$version" || exit 2 + exit;; + esac + + case $option in + (*\'?*) + option=\'$(printf '%sX\n' "$option" | LC_ALL=C sed "$escape");; + (*) + option="'$option'";; + esac + + grep="$grep $option$optarg" +done + +eval "set -- $operands "'${1+"$@"}' + +if test $have_pat -eq 0; then + case ${1?"Missing pattern; try '${0##*/} --help' for help"} in + (*\'*) + grep="$grep -e '"$(printf '%sX\n' "$1" | LC_ALL=C sed "$escape");; + (*) + grep="$grep -e '$1'";; + esac + shift +fi + +if test $# -eq 0; then + set -- - +fi + +exec 3>&1 + +# res=1 means that no file matched yet +res=1 + +for i; do + case $i in + *[-.][zZ] | *_z | *[-.]gz | *.t[ag]z) uncompress="gzip -cdf";; + *[-.]bz2 | *[-.]tbz | *.tbz2) uncompress="bzip2 -cdf";; + *[-.]lzo | *[-.]tzo) uncompress="lzop -cdf";; + *[-.]zst | *[-.]tzst) uncompress="zstd -cdfq";; # zstd needs -q. + *[-.]lz4) uncompress="lz4 -cdf";; + *) uncompress="$xz -cdfqQ";; # -qQ to ignore warnings like unsupp. check. + esac + # xz_status will hold the decompressor's exit status. + # Exit status of grep (and in rare cases, printf or sed) is + # available as the exit status of this assignment command. + xz_status=$( + exec 5>&1 + ($uncompress -- "$i" 5>&-; echo $? >&5) 3>&- | + if test $files_with_matches -eq 1; then + eval "$grep -q" && { printf '%s\n' "$i" || exit 2; } + elif test $files_without_matches -eq 1; then + eval "$grep -q" || { + r=$? + if test $r -eq 1; then + printf '%s\n' "$i" || r=2 + fi + exit $r + } + elif test $with_filename -eq 0 && + { test $# -eq 1 || test $no_filename -eq 1; }; then + eval "$grep" + elif test $grep_supports_label -eq 1; then + # The grep implementation in use allows us to specify the filename + # that grep will prefix to the output lines. This is faster and + # less prone to security bugs than the fallback method that uses sed. + # This also avoids confusing output with GNU grep >= 3.5 (2020-09-27) + # which prints "binary file matches" to stderr instead of stdout. + # + # If reading from stdin, let grep use whatever name it prefers for + # stdin. With GNU grep it is a locale-specific translated string. + if test "x$i" = "x-"; then + eval "$grep -H" + else + eval "$grep -H --label \"\$i\"" + fi + else + # Append a colon so that the last character will never be a newline + # which would otherwise get lost in shell command substitution. + i="$i:" + + # Escape & \ | and newlines only if such characters are present + # (speed optimization). + case $i in + (*' +'* | *'&'* | *'\'* | *'|'*) + # If sed fails, set i to a known safe string to ensure that + # failing sed did not create a half-escaped dangerous string. + i=$(printf '%s\n' "$i" | LC_ALL=C sed 's/[&\|]/\\&/g; $!s/$/\\/') || + i='(unknown filename):';; + esac + + # $i already ends with a colon so do not add it here. + sed_script="s|^|$i|" + + # If grep or sed fails, pick the larger value of the two exit statuses. + # If sed fails, use at least 2 since we use >= 2 to indicate errors. + r=$( + exec 4>&1 + (eval "$grep" 4>&-; echo $? >&4) 3>&- | + LC_ALL=C sed "$sed_script" >&3 4>&- + ) || { + sed_status=$? + test "$sed_status" -lt 2 && sed_status=2 + test "$r" -lt "$sed_status" && r=$sed_status + } + exit $r + fi >&3 5>&- + ) + r=$? + + # If grep or sed or other non-decompression command failed with a signal, + # exit immediately and ignore the possible remaining files. + # + # NOTE: Instead of 128 + signal_number, some shells use + # 256 + signal_number (ksh) or 384 + signal_number (yash). + # This is fine for us since their "exit" and "kill -l" commands take + # this into account. (At least the versions I tried do but there is + # a report of an old ksh variant whose "exit" truncates the exit status + # to 8 bits without any special handling for values indicating a signal.) + test "$r" -ge 128 && exit "$r" + + if test -z "$xz_status"; then + # Something unusual happened, for example, we got a signal and + # the exit status of the decompressor was never echoed and thus + # $xz_status is empty. Exit immediately and ignore the possible + # remaining files. + exit 2 + elif test "$xz_status" -ge 128; then + # The decompressor died due to a signal. SIGPIPE is ignored since it can + # occur if grep exits before the whole file has been decompressed (grep -q + # can do that). If the decompressor died with some other signal, exit + # immediately and ignore the possible remaining files. + test "$(kill -l "$xz_status" 2> /dev/null)" != "PIPE" && exit "$xz_status" + elif test "$xz_status" -gt 0; then + # Decompression failed but we will continue with the remaining + # files anyway. Set exit status to at least 2 to indicate an error. + test "$r" -lt 2 && r=2 + fi + + # Since res=1 is the initial value, we only need to care about + # matches (r == 0) and errors (r >= 2) here; r == 1 can be ignored. + if test "$r" -ge 2; then + # An error occurred in decompressor, grep, or some other command. Update + # res unless a larger error code has been seen with an earlier file. + test "$res" -lt "$r" && res=$r + elif test "$r" -eq 0; then + # grep found a match and no errors occurred. Update res if no errors have + # occurred with earlier files. + test "$res" -eq 1 && res=0 + fi +done + +# 0: At least one file matched and no errors occurred. +# 1: No matches were found and no errors occurred. +# >=2: Error. It's unknown if matches were found. +exit "$res" diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/lzfgrep b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/lzfgrep new file mode 100644 index 0000000000000000000000000000000000000000..e740ea1a0f4bfe6eb8cac7cd647069236aec6e28 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/lzfgrep @@ -0,0 +1,302 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0-or-later + +# xzgrep -- a wrapper around a grep program that decompresses files as needed +# Adapted from a version sent by Charles Levert + +# Copyright (C) 1998, 2001, 2002, 2006, 2007 Free Software Foundation +# Copyright (C) 1993 Jean-loup Gailly + +# Modified for XZ Utils by Andrew Dudman and Lasse Collin. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# shellcheck shell=sh disable=SC1003,SC2016 + + +#SET_PATH - This line is a placeholder to ease patching this script. + +# Instead of unsetting XZ_OPT, just make sure that xz will use file format +# autodetection. This way memory usage limit and thread limit can be +# specified via XZ_OPT. With gzip, bzip2, and lzop it's OK to just unset the +# environment variables. +xz='xz --format=auto' +unset GZIP BZIP BZIP2 LZOP + +case ${0##*/} in + *egrep*) prog=xzegrep; grep=${GREP:-grep -E};; + *fgrep*) prog=xzfgrep; grep=${GREP:-grep -F};; + *) prog=xzgrep; grep=${GREP:-grep};; +esac + +version="$prog (XZ Utils) 5.8.2" + +usage="Usage: ${0##*/} [OPTION]... [-e] PATTERN [FILE]... +Look for instances of PATTERN in the input FILEs, using their +uncompressed contents if they are compressed. + +OPTIONs are the same as for '$grep'. + +Report bugs to ." + +# sed script to escape all ' for the shell, and then (to handle trailing +# newlines correctly) turn trailing X on last line into '. +escape=' + s/'\''/'\''\\'\'''\''/g + $s/X$/'\''/ +' +operands= +have_pat=0 +files_with_matches=0 +files_without_matches=0 +no_filename=0 +with_filename=0 + +# See if -H and --label options are supported (GNU and *BSDs). +if test f:x = "$(eval "echo x | $grep -H --label=f x 2> /dev/null")"; then + grep_supports_label=1 +else + grep_supports_label=0 +fi + +while test $# -ne 0; do + option=$1 + shift + optarg= + + case $option in + (-[0123456789abcdEFGhHiIKlLnoPqrRsTuUvVwxyzZ]*[!0123456789]*) + # Something like -Fiv was specified, that is, $option contains more + # than one option of which the first option (in this example -F) + # doesn't take an argument. Split the first option into a standalone + # argument and continue parsing the rest of the options (in this example, + # replace -Fiv with -iv in the argument list and set option=-F). + # + # If there are digits [0-9] they are treated as if they were a single + # option character because this syntax is an alias for -C for GNU grep. + # For example, "grep -25F" is equivalent to "grep -C25 -F". If only + # digits are specified like "grep -25" we don't get here because the + # above pattern in the case-statement doesn't match such strings. + arg2=-\'$(LC_ALL=C expr "X${option}X" : 'X-.[0-9]*\(.*\)' | + LC_ALL=C sed "$escape") + eval "set -- $arg2 "'${1+"$@"}' + option=$(LC_ALL=C expr "X$option" : 'X\(-.[0-9]*\)');; + (--binary-*=* | --[lm]a*=* | --reg*=*) + # These options require an argument and an argument has been provided + # with the --foo=argument syntax. All is good. + ;; + (-[ABCDefmX] | --binary-* | --file | --[lm]a* | --reg*) + # These options require an argument which should now be in $1. + # If it isn't, display an error and exit. + case ${1?"$option option requires an argument"} in + (*\'*) + optarg=" '"$(printf '%sX\n' "$1" | LC_ALL=C sed "$escape");; + (*) + optarg=" '$1'";; + esac + shift;; + (--) + break;; + (-?*) + ;; + (*) + case $option in + (*\'*) + operands="$operands '"$(printf '%sX\n' "$option" | + LC_ALL=C sed "$escape");; + (*) + operands="$operands '$option'";; + esac + ${POSIXLY_CORRECT+break} + continue;; + esac + + case $option in + (-[drRzZ] | --di* | --exc* | --inc* | --rec* | --nu*) + printf >&2 '%s: %s: Option not supported\n' "$0" "$option" + exit 2;; + (-[ef]* | --file | --file=* | --reg*) + have_pat=1;; + (--h | --he | --hel | --help) + printf '%s\n' "$usage" || exit 2 + exit;; + (-H | --wi | --wit | --with | --with- | --with-f | --with-fi \ + | --with-fil | --with-file | --with-filen | --with-filena | --with-filenam \ + | --with-filename) + with_filename=1 + continue;; + (-l | --files-with-*) + files_with_matches=1 + continue;; + (-L | --files-witho*) + files_without_matches=1 + continue;; + (-h | --no-f*) + no_filename=1;; + (-V | --v | --ve | --ver | --vers | --versi | --versio | --version) + printf '%s\n' "$version" || exit 2 + exit;; + esac + + case $option in + (*\'?*) + option=\'$(printf '%sX\n' "$option" | LC_ALL=C sed "$escape");; + (*) + option="'$option'";; + esac + + grep="$grep $option$optarg" +done + +eval "set -- $operands "'${1+"$@"}' + +if test $have_pat -eq 0; then + case ${1?"Missing pattern; try '${0##*/} --help' for help"} in + (*\'*) + grep="$grep -e '"$(printf '%sX\n' "$1" | LC_ALL=C sed "$escape");; + (*) + grep="$grep -e '$1'";; + esac + shift +fi + +if test $# -eq 0; then + set -- - +fi + +exec 3>&1 + +# res=1 means that no file matched yet +res=1 + +for i; do + case $i in + *[-.][zZ] | *_z | *[-.]gz | *.t[ag]z) uncompress="gzip -cdf";; + *[-.]bz2 | *[-.]tbz | *.tbz2) uncompress="bzip2 -cdf";; + *[-.]lzo | *[-.]tzo) uncompress="lzop -cdf";; + *[-.]zst | *[-.]tzst) uncompress="zstd -cdfq";; # zstd needs -q. + *[-.]lz4) uncompress="lz4 -cdf";; + *) uncompress="$xz -cdfqQ";; # -qQ to ignore warnings like unsupp. check. + esac + # xz_status will hold the decompressor's exit status. + # Exit status of grep (and in rare cases, printf or sed) is + # available as the exit status of this assignment command. + xz_status=$( + exec 5>&1 + ($uncompress -- "$i" 5>&-; echo $? >&5) 3>&- | + if test $files_with_matches -eq 1; then + eval "$grep -q" && { printf '%s\n' "$i" || exit 2; } + elif test $files_without_matches -eq 1; then + eval "$grep -q" || { + r=$? + if test $r -eq 1; then + printf '%s\n' "$i" || r=2 + fi + exit $r + } + elif test $with_filename -eq 0 && + { test $# -eq 1 || test $no_filename -eq 1; }; then + eval "$grep" + elif test $grep_supports_label -eq 1; then + # The grep implementation in use allows us to specify the filename + # that grep will prefix to the output lines. This is faster and + # less prone to security bugs than the fallback method that uses sed. + # This also avoids confusing output with GNU grep >= 3.5 (2020-09-27) + # which prints "binary file matches" to stderr instead of stdout. + # + # If reading from stdin, let grep use whatever name it prefers for + # stdin. With GNU grep it is a locale-specific translated string. + if test "x$i" = "x-"; then + eval "$grep -H" + else + eval "$grep -H --label \"\$i\"" + fi + else + # Append a colon so that the last character will never be a newline + # which would otherwise get lost in shell command substitution. + i="$i:" + + # Escape & \ | and newlines only if such characters are present + # (speed optimization). + case $i in + (*' +'* | *'&'* | *'\'* | *'|'*) + # If sed fails, set i to a known safe string to ensure that + # failing sed did not create a half-escaped dangerous string. + i=$(printf '%s\n' "$i" | LC_ALL=C sed 's/[&\|]/\\&/g; $!s/$/\\/') || + i='(unknown filename):';; + esac + + # $i already ends with a colon so do not add it here. + sed_script="s|^|$i|" + + # If grep or sed fails, pick the larger value of the two exit statuses. + # If sed fails, use at least 2 since we use >= 2 to indicate errors. + r=$( + exec 4>&1 + (eval "$grep" 4>&-; echo $? >&4) 3>&- | + LC_ALL=C sed "$sed_script" >&3 4>&- + ) || { + sed_status=$? + test "$sed_status" -lt 2 && sed_status=2 + test "$r" -lt "$sed_status" && r=$sed_status + } + exit $r + fi >&3 5>&- + ) + r=$? + + # If grep or sed or other non-decompression command failed with a signal, + # exit immediately and ignore the possible remaining files. + # + # NOTE: Instead of 128 + signal_number, some shells use + # 256 + signal_number (ksh) or 384 + signal_number (yash). + # This is fine for us since their "exit" and "kill -l" commands take + # this into account. (At least the versions I tried do but there is + # a report of an old ksh variant whose "exit" truncates the exit status + # to 8 bits without any special handling for values indicating a signal.) + test "$r" -ge 128 && exit "$r" + + if test -z "$xz_status"; then + # Something unusual happened, for example, we got a signal and + # the exit status of the decompressor was never echoed and thus + # $xz_status is empty. Exit immediately and ignore the possible + # remaining files. + exit 2 + elif test "$xz_status" -ge 128; then + # The decompressor died due to a signal. SIGPIPE is ignored since it can + # occur if grep exits before the whole file has been decompressed (grep -q + # can do that). If the decompressor died with some other signal, exit + # immediately and ignore the possible remaining files. + test "$(kill -l "$xz_status" 2> /dev/null)" != "PIPE" && exit "$xz_status" + elif test "$xz_status" -gt 0; then + # Decompression failed but we will continue with the remaining + # files anyway. Set exit status to at least 2 to indicate an error. + test "$r" -lt 2 && r=2 + fi + + # Since res=1 is the initial value, we only need to care about + # matches (r == 0) and errors (r >= 2) here; r == 1 can be ignored. + if test "$r" -ge 2; then + # An error occurred in decompressor, grep, or some other command. Update + # res unless a larger error code has been seen with an earlier file. + test "$res" -lt "$r" && res=$r + elif test "$r" -eq 0; then + # grep found a match and no errors occurred. Update res if no errors have + # occurred with earlier files. + test "$res" -eq 1 && res=0 + fi +done + +# 0: At least one file matched and no errors occurred. +# 1: No matches were found and no errors occurred. +# >=2: Error. It's unknown if matches were found. +exit "$res" diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/lzgrep b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/lzgrep new file mode 100644 index 0000000000000000000000000000000000000000..e740ea1a0f4bfe6eb8cac7cd647069236aec6e28 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/lzgrep @@ -0,0 +1,302 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0-or-later + +# xzgrep -- a wrapper around a grep program that decompresses files as needed +# Adapted from a version sent by Charles Levert + +# Copyright (C) 1998, 2001, 2002, 2006, 2007 Free Software Foundation +# Copyright (C) 1993 Jean-loup Gailly + +# Modified for XZ Utils by Andrew Dudman and Lasse Collin. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# shellcheck shell=sh disable=SC1003,SC2016 + + +#SET_PATH - This line is a placeholder to ease patching this script. + +# Instead of unsetting XZ_OPT, just make sure that xz will use file format +# autodetection. This way memory usage limit and thread limit can be +# specified via XZ_OPT. With gzip, bzip2, and lzop it's OK to just unset the +# environment variables. +xz='xz --format=auto' +unset GZIP BZIP BZIP2 LZOP + +case ${0##*/} in + *egrep*) prog=xzegrep; grep=${GREP:-grep -E};; + *fgrep*) prog=xzfgrep; grep=${GREP:-grep -F};; + *) prog=xzgrep; grep=${GREP:-grep};; +esac + +version="$prog (XZ Utils) 5.8.2" + +usage="Usage: ${0##*/} [OPTION]... [-e] PATTERN [FILE]... +Look for instances of PATTERN in the input FILEs, using their +uncompressed contents if they are compressed. + +OPTIONs are the same as for '$grep'. + +Report bugs to ." + +# sed script to escape all ' for the shell, and then (to handle trailing +# newlines correctly) turn trailing X on last line into '. +escape=' + s/'\''/'\''\\'\'''\''/g + $s/X$/'\''/ +' +operands= +have_pat=0 +files_with_matches=0 +files_without_matches=0 +no_filename=0 +with_filename=0 + +# See if -H and --label options are supported (GNU and *BSDs). +if test f:x = "$(eval "echo x | $grep -H --label=f x 2> /dev/null")"; then + grep_supports_label=1 +else + grep_supports_label=0 +fi + +while test $# -ne 0; do + option=$1 + shift + optarg= + + case $option in + (-[0123456789abcdEFGhHiIKlLnoPqrRsTuUvVwxyzZ]*[!0123456789]*) + # Something like -Fiv was specified, that is, $option contains more + # than one option of which the first option (in this example -F) + # doesn't take an argument. Split the first option into a standalone + # argument and continue parsing the rest of the options (in this example, + # replace -Fiv with -iv in the argument list and set option=-F). + # + # If there are digits [0-9] they are treated as if they were a single + # option character because this syntax is an alias for -C for GNU grep. + # For example, "grep -25F" is equivalent to "grep -C25 -F". If only + # digits are specified like "grep -25" we don't get here because the + # above pattern in the case-statement doesn't match such strings. + arg2=-\'$(LC_ALL=C expr "X${option}X" : 'X-.[0-9]*\(.*\)' | + LC_ALL=C sed "$escape") + eval "set -- $arg2 "'${1+"$@"}' + option=$(LC_ALL=C expr "X$option" : 'X\(-.[0-9]*\)');; + (--binary-*=* | --[lm]a*=* | --reg*=*) + # These options require an argument and an argument has been provided + # with the --foo=argument syntax. All is good. + ;; + (-[ABCDefmX] | --binary-* | --file | --[lm]a* | --reg*) + # These options require an argument which should now be in $1. + # If it isn't, display an error and exit. + case ${1?"$option option requires an argument"} in + (*\'*) + optarg=" '"$(printf '%sX\n' "$1" | LC_ALL=C sed "$escape");; + (*) + optarg=" '$1'";; + esac + shift;; + (--) + break;; + (-?*) + ;; + (*) + case $option in + (*\'*) + operands="$operands '"$(printf '%sX\n' "$option" | + LC_ALL=C sed "$escape");; + (*) + operands="$operands '$option'";; + esac + ${POSIXLY_CORRECT+break} + continue;; + esac + + case $option in + (-[drRzZ] | --di* | --exc* | --inc* | --rec* | --nu*) + printf >&2 '%s: %s: Option not supported\n' "$0" "$option" + exit 2;; + (-[ef]* | --file | --file=* | --reg*) + have_pat=1;; + (--h | --he | --hel | --help) + printf '%s\n' "$usage" || exit 2 + exit;; + (-H | --wi | --wit | --with | --with- | --with-f | --with-fi \ + | --with-fil | --with-file | --with-filen | --with-filena | --with-filenam \ + | --with-filename) + with_filename=1 + continue;; + (-l | --files-with-*) + files_with_matches=1 + continue;; + (-L | --files-witho*) + files_without_matches=1 + continue;; + (-h | --no-f*) + no_filename=1;; + (-V | --v | --ve | --ver | --vers | --versi | --versio | --version) + printf '%s\n' "$version" || exit 2 + exit;; + esac + + case $option in + (*\'?*) + option=\'$(printf '%sX\n' "$option" | LC_ALL=C sed "$escape");; + (*) + option="'$option'";; + esac + + grep="$grep $option$optarg" +done + +eval "set -- $operands "'${1+"$@"}' + +if test $have_pat -eq 0; then + case ${1?"Missing pattern; try '${0##*/} --help' for help"} in + (*\'*) + grep="$grep -e '"$(printf '%sX\n' "$1" | LC_ALL=C sed "$escape");; + (*) + grep="$grep -e '$1'";; + esac + shift +fi + +if test $# -eq 0; then + set -- - +fi + +exec 3>&1 + +# res=1 means that no file matched yet +res=1 + +for i; do + case $i in + *[-.][zZ] | *_z | *[-.]gz | *.t[ag]z) uncompress="gzip -cdf";; + *[-.]bz2 | *[-.]tbz | *.tbz2) uncompress="bzip2 -cdf";; + *[-.]lzo | *[-.]tzo) uncompress="lzop -cdf";; + *[-.]zst | *[-.]tzst) uncompress="zstd -cdfq";; # zstd needs -q. + *[-.]lz4) uncompress="lz4 -cdf";; + *) uncompress="$xz -cdfqQ";; # -qQ to ignore warnings like unsupp. check. + esac + # xz_status will hold the decompressor's exit status. + # Exit status of grep (and in rare cases, printf or sed) is + # available as the exit status of this assignment command. + xz_status=$( + exec 5>&1 + ($uncompress -- "$i" 5>&-; echo $? >&5) 3>&- | + if test $files_with_matches -eq 1; then + eval "$grep -q" && { printf '%s\n' "$i" || exit 2; } + elif test $files_without_matches -eq 1; then + eval "$grep -q" || { + r=$? + if test $r -eq 1; then + printf '%s\n' "$i" || r=2 + fi + exit $r + } + elif test $with_filename -eq 0 && + { test $# -eq 1 || test $no_filename -eq 1; }; then + eval "$grep" + elif test $grep_supports_label -eq 1; then + # The grep implementation in use allows us to specify the filename + # that grep will prefix to the output lines. This is faster and + # less prone to security bugs than the fallback method that uses sed. + # This also avoids confusing output with GNU grep >= 3.5 (2020-09-27) + # which prints "binary file matches" to stderr instead of stdout. + # + # If reading from stdin, let grep use whatever name it prefers for + # stdin. With GNU grep it is a locale-specific translated string. + if test "x$i" = "x-"; then + eval "$grep -H" + else + eval "$grep -H --label \"\$i\"" + fi + else + # Append a colon so that the last character will never be a newline + # which would otherwise get lost in shell command substitution. + i="$i:" + + # Escape & \ | and newlines only if such characters are present + # (speed optimization). + case $i in + (*' +'* | *'&'* | *'\'* | *'|'*) + # If sed fails, set i to a known safe string to ensure that + # failing sed did not create a half-escaped dangerous string. + i=$(printf '%s\n' "$i" | LC_ALL=C sed 's/[&\|]/\\&/g; $!s/$/\\/') || + i='(unknown filename):';; + esac + + # $i already ends with a colon so do not add it here. + sed_script="s|^|$i|" + + # If grep or sed fails, pick the larger value of the two exit statuses. + # If sed fails, use at least 2 since we use >= 2 to indicate errors. + r=$( + exec 4>&1 + (eval "$grep" 4>&-; echo $? >&4) 3>&- | + LC_ALL=C sed "$sed_script" >&3 4>&- + ) || { + sed_status=$? + test "$sed_status" -lt 2 && sed_status=2 + test "$r" -lt "$sed_status" && r=$sed_status + } + exit $r + fi >&3 5>&- + ) + r=$? + + # If grep or sed or other non-decompression command failed with a signal, + # exit immediately and ignore the possible remaining files. + # + # NOTE: Instead of 128 + signal_number, some shells use + # 256 + signal_number (ksh) or 384 + signal_number (yash). + # This is fine for us since their "exit" and "kill -l" commands take + # this into account. (At least the versions I tried do but there is + # a report of an old ksh variant whose "exit" truncates the exit status + # to 8 bits without any special handling for values indicating a signal.) + test "$r" -ge 128 && exit "$r" + + if test -z "$xz_status"; then + # Something unusual happened, for example, we got a signal and + # the exit status of the decompressor was never echoed and thus + # $xz_status is empty. Exit immediately and ignore the possible + # remaining files. + exit 2 + elif test "$xz_status" -ge 128; then + # The decompressor died due to a signal. SIGPIPE is ignored since it can + # occur if grep exits before the whole file has been decompressed (grep -q + # can do that). If the decompressor died with some other signal, exit + # immediately and ignore the possible remaining files. + test "$(kill -l "$xz_status" 2> /dev/null)" != "PIPE" && exit "$xz_status" + elif test "$xz_status" -gt 0; then + # Decompression failed but we will continue with the remaining + # files anyway. Set exit status to at least 2 to indicate an error. + test "$r" -lt 2 && r=2 + fi + + # Since res=1 is the initial value, we only need to care about + # matches (r == 0) and errors (r >= 2) here; r == 1 can be ignored. + if test "$r" -ge 2; then + # An error occurred in decompressor, grep, or some other command. Update + # res unless a larger error code has been seen with an earlier file. + test "$res" -lt "$r" && res=$r + elif test "$r" -eq 0; then + # grep found a match and no errors occurred. Update res if no errors have + # occurred with earlier files. + test "$res" -eq 1 && res=0 + fi +done + +# 0: At least one file matched and no errors occurred. +# 1: No matches were found and no errors occurred. +# >=2: Error. It's unknown if matches were found. +exit "$res" diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/lzless b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/lzless new file mode 100644 index 0000000000000000000000000000000000000000..bd177e93df1cea09f4ab4aeb7efc4582ba4fea4f --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/lzless @@ -0,0 +1,76 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0-or-later + +# Copyright (C) 1998, 2002, 2006, 2007 Free Software Foundation + +# The original version for gzip was written by Paul Eggert. +# Modified for XZ Utils by Andrew Dudman and Lasse Collin. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# shellcheck shell=sh disable=SC2089,SC2090 + + +#SET_PATH - This line is a placeholder to ease patching this script. + +# Instead of unsetting XZ_OPT, just make sure that xz will use file format +# autodetection. This way memory usage limit and thread limit can be +# specified via XZ_OPT. +xz='xz --format=auto' + +version='xzless (XZ Utils) 5.8.2' + +usage="Usage: ${0##*/} [OPTION]... [FILE]... +Like 'less', but operate on the uncompressed contents of xz compressed FILEs. + +Options are the same as for 'less'. + +Report bugs to ." + +case $1 in + --help) printf '%s\n' "$usage" || exit 2; exit;; + --version) printf '%s\n' "$version" || exit 2; exit;; +esac + +if test "${LESSMETACHARS+set}" != set; then + # Work around a bug in less 394 and earlier; + # it mishandles the metacharacters '$%=~'. + space=' ' + tab=' ' + nl=' +' + LESSMETACHARS="$space$tab$nl'"';*?"()<>[|&^`#\$%=~' +fi + +VER=$(less -V | { read _ ver _ && echo ${ver%%.*}; }) +if test "$VER" -ge 451; then + # less 451 or later: If the compressed file is valid but has + # zero bytes of uncompressed data, using two vertical bars ||- makes + # "less" check the exit status of xz and if it is zero then display + # an empty file. With a single vertical bar |- and no output from xz, + # "less" would attempt to display the raw input file instead. + LESSOPEN="||-$xz -cdfqQ -- %s" +elif test "$VER" -ge 429; then + # less 429 or later: LESSOPEN pipe will be used on + # standard input if $LESSOPEN begins with |-. + LESSOPEN="|-$xz -cdfqQ -- %s" +else + LESSOPEN="|$xz -cdfqQ -- %s" +fi + +SHOW_PREPROC_ERRORS= +if test "$VER" -ge 632; then + SHOW_PREPROC_ERRORS=--show-preproc-errors +fi + +export LESSMETACHARS LESSOPEN + +exec less $SHOW_PREPROC_ERRORS "$@" diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/lzmadec b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/lzmadec new file mode 100644 index 0000000000000000000000000000000000000000..d3ca57b5de37d789705db9c159a28f76d90dc921 Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/lzmadec differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/lzmainfo b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/lzmainfo new file mode 100644 index 0000000000000000000000000000000000000000..afdb4b941fc8ce22fec119da4847312b4f499a9b Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/lzmainfo differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/lzmore b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/lzmore new file mode 100644 index 0000000000000000000000000000000000000000..0816c6dbca2c077885ae788dc4e6c379d7dd2920 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/lzmore @@ -0,0 +1,82 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0-or-later + +# Copyright (C) 2001, 2002, 2007 Free Software Foundation +# Copyright (C) 1992, 1993 Jean-loup Gailly + +# Modified for XZ Utils by Andrew Dudman and Lasse Collin. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# shellcheck shell=sh + + +#SET_PATH - This line is a placeholder to ease patching this script. + +# Instead of unsetting XZ_OPT, just make sure that xz will use file format +# autodetection. This way memory usage limit and thread limit can be +# specified via XZ_OPT. +xz='xz --format=auto' + +version='xzmore (XZ Utils) 5.8.2' + +usage="Usage: ${0##*/} [OPTION]... [FILE]... +Like 'more', but operate on the uncompressed contents of xz compressed FILEs. + +Report bugs to ." + +case $1 in + --help) printf '%s\n' "$usage" || exit 2; exit;; + --version) printf '%s\n' "$version" || exit 2; exit;; +esac + +oldtty=`stty -g 2>/dev/null` +if stty -cbreak 2>/dev/null; then + cb='cbreak'; ncb='-cbreak' +else + # 'stty min 1' resets eof to ^a on both SunOS and SysV! + cb='min 1 -icanon'; ncb='icanon eof ^d' +fi +if test $? -eq 0 && test -n "$oldtty"; then + trap 'stty $oldtty 2>/dev/null; exit' 0 2 3 5 10 13 15 +else + trap 'stty $ncb echo 2>/dev/null; exit' 0 2 3 5 10 13 15 +fi + +if test $# = 0; then + if test -t 0; then + printf '%s\n' "$usage"; exit 1 + else + $xz -cdfqQ | eval "${PAGER:-more}" + fi +else + FIRST=1 + for FILE; do + true < "$FILE" || continue + if test $FIRST -eq 0; then + printf "%s--More--(Next file: %s)" "" "$FILE" + stty $cb -echo 2>/dev/null + ANS=`dd bs=1 count=1 2>/dev/null` + stty $ncb echo 2>/dev/null + echo " " + case "$ANS" in + [eq]) exit;; + esac + fi + if test "$ANS" != 's'; then + printf '%s\n' "------> $FILE <------" + $xz -cdfqQ -- "$FILE" | eval "${PAGER:-more}" + fi + if test -t 1; then + FIRST=0 + fi + done +fi diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/xzcmp b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/xzcmp new file mode 100644 index 0000000000000000000000000000000000000000..d76f65118f96cd9ea2e366974ef228c27b0cdbe0 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/xzcmp @@ -0,0 +1,224 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0-or-later + +# Copyright (C) 1998, 2002, 2006, 2007 Free Software Foundation +# Copyright (C) 1993 Jean-loup Gailly + +# Modified for XZ Utils by Andrew Dudman and Lasse Collin. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# shellcheck shell=sh disable=SC1003,SC2016 + + +#SET_PATH - This line is a placeholder to ease patching this script. + +# Instead of unsetting XZ_OPT, just make sure that xz will use file format +# autodetection. This way memory usage limit and thread limit can be +# specified via XZ_OPT. With gzip, bzip2, and lzop it's OK to just unset the +# environment variables. +xz='xz --format=auto' +unset GZIP BZIP BZIP2 LZOP + +case ${0##*/} in + *cmp*) prog=xzcmp; cmp=${CMP:-cmp};; + *) prog=xzdiff; cmp=${DIFF:-diff};; +esac + +version="$prog (XZ Utils) 5.8.2" + +usage="Usage: ${0##*/} [OPTION]... FILE1 [FILE2] +Compare FILE1 to FILE2, using their uncompressed contents if they are +compressed. If FILE2 is omitted, then the files compared are FILE1 and +FILE1 from which the compression format suffix has been stripped. + +Do comparisons like '$cmp' does. OPTIONs are the same as for '$cmp'. + +Report bugs to ." + +# sed script to escape all ' for the shell, and then (to handle trailing +# newlines correctly) turn trailing X on last line into '. +escape=' + s/'\''/'\''\\'\'''\''/g + $s/X$/'\''/ +' + +while :; do + case $1 in + --h*) printf '%s\n' "$usage" || exit 2; exit;; + --v*) printf '%s\n' "$version" || exit 2; exit;; + --) shift; break;; + -*\'*) cmp="$cmp '"`printf '%sX\n' "$1" | sed "$escape"`;; + -?*) cmp="$cmp '$1'";; + *) break;; + esac + shift +done +cmp="$cmp --" + +for file; do + test "X$file" = X- || true < "$file" || exit 2 +done + +# xz needs -qQ to ignore warnings like unsupported check type. +xz1="$xz -qQ" +xz2="$xz -qQ" +xz_status=0 +exec 3>&1 + +if test $# -eq 1; then + case $1 in + *[-.]xz | *[-.]lzma | *[-.]lz | *.t[lx]z) + ;; + *[-.]bz2 | *.tbz | *.tbz2) + xz1=bzip2;; + *[-.][zZ] | *_z | *[-.]gz | *.t[ag]z) + xz1=gzip;; + *[-.]lzo | *.tzo) + xz1=lzop;; + *[-.]zst | *.tzst) + xz1='zstd -q';; + *[-.]lz4) + xz1=lz4;; + *) + printf '%s\n' "$0: $1: Unknown compressed file name suffix" >&2 + exit 2;; + esac + # The FILE variable is used with eval, and shellcheck doesn't see that. + # shellcheck disable=SC2034 + case $1 in + *[-.][zZ] | *_z | *[-.][gx]z | *[-.]bz2 | *[-.]lzma | *[-.]lz | *[-.]lzo | *[-.]zst | *[-.]lz4) + FILE=`expr "X$1" : 'X\(.*\)[-.][abglmostxzZ24]*$'`;; + *.t[abglx]z) + FILE=`expr "X$1" : 'X\(.*[-.]t\)[abglx]z$'`ar;; + *.tbz2) + FILE=`expr "X$1" : 'X\(.*[-.]t\)bz2$'`ar;; + *.tzo) + FILE=`expr "X$1" : 'X\(.*[-.]t\)zo$'`ar;; + *.tzst) + FILE=`expr "X$1" : 'X\(.*[-.]t\)zst$'`ar;; + esac + xz_status=$( + exec 4>&1 + ($xz1 -cd -- "$1" 4>&-; echo $? >&4) 3>&- | eval "$cmp" - '"$FILE"' >&3 + ) +elif test $# -eq 2; then + case $1 in + *[-.]bz2 | *.tbz | *.tbz2) xz1=bzip2;; + *[-.][zZ] | *_z | *[-.]gz | *.t[ag]z) xz1=gzip;; + *[-.]lzo | *.tzo) xz1=lzop;; + *[-.]zst | *.tzst) xz1='zstd -q';; + *[-.]lz4) xz1=lz4;; + esac + case $2 in + *[-.]bz2 | *.tbz | *.tbz2) xz2=bzip2;; + *[-.][zZ] | *_z | *[-.]gz | *.t[ag]z) xz2=gzip;; + *[-.]lzo | *.tzo) xz2=lzop;; + *[-.]zst | *.tzst) xz2='zstd -q';; + *[-.]lz4) xz2=lz4;; + esac + case $1 in + *[-.][zZ] | *_z | *[-.][gx]z | *[-.]bz2 | *[-.]lzma | *[-.]lz | *.t[abglx]z | *.tbz2 | *[-.]lzo | *.tzo | *[-.]zst | *.tzst | *[-.]lz4 | -) + case "$2" in + *[-.][zZ] | *_z | *[-.][gx]z | *[-.]bz2 | *[-.]lzma | *[-.]lz | *.t[abglx]z | *.tbz2 | *[-.]lzo | *.tzo | *[-.]zst | *.tzst | *[-.]lz4 | -) + if test "$1$2" = --; then + xz_status=$( + exec 4>&1 + ($xz1 -cdf - 4>&-; echo $? >&4) 3>&- | + eval "$cmp" - - >&3 + ) + elif # Reject Solaris 8's buggy /bin/bash 2.03. + echo X | (echo X | eval "$cmp" /dev/fd/5 - >/dev/null 2>&1) 5<&0; then + # NOTE: xz_status will contain two numbers. + xz_status=$( + exec 4>&1 + ($xz1 -cdf -- "$1" 4>&-; echo $? >&4) 3>&- | + ( ($xz2 -cdf -- "$2" 4>&-; echo $? >&4) 3>&- 5<&- &3) 5<&0 + ) + else + F=`expr "/$2" : '.*/\(.*\)[-.][ablmotxz2]*$'` || F=$prog + tmp= + trap ' + test -n "$tmp" && rm -rf "$tmp" + (exit 2); exit 2 + ' HUP INT PIPE TERM 0 + if type mktemp >/dev/null 2>&1; then + # Note that FreeBSD's mktemp isn't fully compatible with + # the implementations from mktemp.org and GNU coreutils. + # It is important that the -t argument is the last argument + # and that no "--" is used between -t and the template argument. + # This way this command works on all implementations. + tmp=`mktemp -d -t "$prog.XXXXXXXXXX"` || exit 2 + else + # Fallback code if mktemp is missing. This isn't as + # robust as using mktemp since this doesn't try with + # different file names in case of a file name conflict. + # + # There's no need to save the original umask since + # we don't create any non-temp files. Note that using + # mkdir -m 0077 isn't secure since some mkdir implementations + # create the dir with the default umask and chmod the + # the dir afterwards. + umask 0077 + mkdir -- "${TMPDIR-/tmp}/$prog.$$" || exit 2 + tmp="${TMPDIR-/tmp}/$prog.$$" + fi + $xz2 -cdf -- "$2" > "$tmp/$F" || exit 2 + xz_status=$( + exec 4>&1 + ($xz1 -cdf -- "$1" 4>&-; echo $? >&4) 3>&- | + eval "$cmp" - '"$tmp/$F"' >&3 + ) + cmp_status=$? + rm -rf "$tmp" || xz_status=$? + trap - HUP INT PIPE TERM 0 + (exit $cmp_status) + fi;; + *) + xz_status=$( + exec 4>&1 + ($xz1 -cdf -- "$1" 4>&-; echo $? >&4) 3>&- | + eval "$cmp" - '"$2"' >&3 + );; + esac;; + *) + case "$2" in + *[-.][zZ] | *_z | *[-.][gx]z | *[-.]bz2 | *[-.]lzma | *[-.]lz | *.t[abglx]z | *.tbz2 | *[-.]lzo | *.tzo | *[-.]zst | *.tzst | *[-.]lz4 | -) + xz_status=$( + exec 4>&1 + ($xz2 -cdf -- "$2" 4>&-; echo $? >&4) 3>&- | + eval "$cmp" '"$1"' - >&3 + );; + *) + eval "$cmp" '"$1"' '"$2"';; + esac;; + esac +else + printf '%s\n' "$0: Invalid number of operands; try '${0##*/} --help' for help" >&2 + exit 2 +fi + +cmp_status=$? +for num in $xz_status ; do + # 0 from decompressor means successful decompression. SIGPIPE from + # decompressor is possible when diff or cmp exits before the whole file + # has been decompressed. In that case we want to retain the exit status + # from diff or cmp. Note that using "trap '' PIPE" is not possible + # because gzip changes its behavior (including exit status) if SIGPIPE + # is ignored. + test "$num" -eq 0 && continue + test "$num" -ge 128 \ + && test "$(kill -l "$num" 2> /dev/null)" = "PIPE" \ + && continue + exit 2 +done +exit $cmp_status diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/xzdec b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/xzdec new file mode 100644 index 0000000000000000000000000000000000000000..15c3fd554a7e547e40c718cca53f3cb11f5f6c0b Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/xzdec differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/xzdiff b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/xzdiff new file mode 100644 index 0000000000000000000000000000000000000000..d76f65118f96cd9ea2e366974ef228c27b0cdbe0 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/xzdiff @@ -0,0 +1,224 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0-or-later + +# Copyright (C) 1998, 2002, 2006, 2007 Free Software Foundation +# Copyright (C) 1993 Jean-loup Gailly + +# Modified for XZ Utils by Andrew Dudman and Lasse Collin. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# shellcheck shell=sh disable=SC1003,SC2016 + + +#SET_PATH - This line is a placeholder to ease patching this script. + +# Instead of unsetting XZ_OPT, just make sure that xz will use file format +# autodetection. This way memory usage limit and thread limit can be +# specified via XZ_OPT. With gzip, bzip2, and lzop it's OK to just unset the +# environment variables. +xz='xz --format=auto' +unset GZIP BZIP BZIP2 LZOP + +case ${0##*/} in + *cmp*) prog=xzcmp; cmp=${CMP:-cmp};; + *) prog=xzdiff; cmp=${DIFF:-diff};; +esac + +version="$prog (XZ Utils) 5.8.2" + +usage="Usage: ${0##*/} [OPTION]... FILE1 [FILE2] +Compare FILE1 to FILE2, using their uncompressed contents if they are +compressed. If FILE2 is omitted, then the files compared are FILE1 and +FILE1 from which the compression format suffix has been stripped. + +Do comparisons like '$cmp' does. OPTIONs are the same as for '$cmp'. + +Report bugs to ." + +# sed script to escape all ' for the shell, and then (to handle trailing +# newlines correctly) turn trailing X on last line into '. +escape=' + s/'\''/'\''\\'\'''\''/g + $s/X$/'\''/ +' + +while :; do + case $1 in + --h*) printf '%s\n' "$usage" || exit 2; exit;; + --v*) printf '%s\n' "$version" || exit 2; exit;; + --) shift; break;; + -*\'*) cmp="$cmp '"`printf '%sX\n' "$1" | sed "$escape"`;; + -?*) cmp="$cmp '$1'";; + *) break;; + esac + shift +done +cmp="$cmp --" + +for file; do + test "X$file" = X- || true < "$file" || exit 2 +done + +# xz needs -qQ to ignore warnings like unsupported check type. +xz1="$xz -qQ" +xz2="$xz -qQ" +xz_status=0 +exec 3>&1 + +if test $# -eq 1; then + case $1 in + *[-.]xz | *[-.]lzma | *[-.]lz | *.t[lx]z) + ;; + *[-.]bz2 | *.tbz | *.tbz2) + xz1=bzip2;; + *[-.][zZ] | *_z | *[-.]gz | *.t[ag]z) + xz1=gzip;; + *[-.]lzo | *.tzo) + xz1=lzop;; + *[-.]zst | *.tzst) + xz1='zstd -q';; + *[-.]lz4) + xz1=lz4;; + *) + printf '%s\n' "$0: $1: Unknown compressed file name suffix" >&2 + exit 2;; + esac + # The FILE variable is used with eval, and shellcheck doesn't see that. + # shellcheck disable=SC2034 + case $1 in + *[-.][zZ] | *_z | *[-.][gx]z | *[-.]bz2 | *[-.]lzma | *[-.]lz | *[-.]lzo | *[-.]zst | *[-.]lz4) + FILE=`expr "X$1" : 'X\(.*\)[-.][abglmostxzZ24]*$'`;; + *.t[abglx]z) + FILE=`expr "X$1" : 'X\(.*[-.]t\)[abglx]z$'`ar;; + *.tbz2) + FILE=`expr "X$1" : 'X\(.*[-.]t\)bz2$'`ar;; + *.tzo) + FILE=`expr "X$1" : 'X\(.*[-.]t\)zo$'`ar;; + *.tzst) + FILE=`expr "X$1" : 'X\(.*[-.]t\)zst$'`ar;; + esac + xz_status=$( + exec 4>&1 + ($xz1 -cd -- "$1" 4>&-; echo $? >&4) 3>&- | eval "$cmp" - '"$FILE"' >&3 + ) +elif test $# -eq 2; then + case $1 in + *[-.]bz2 | *.tbz | *.tbz2) xz1=bzip2;; + *[-.][zZ] | *_z | *[-.]gz | *.t[ag]z) xz1=gzip;; + *[-.]lzo | *.tzo) xz1=lzop;; + *[-.]zst | *.tzst) xz1='zstd -q';; + *[-.]lz4) xz1=lz4;; + esac + case $2 in + *[-.]bz2 | *.tbz | *.tbz2) xz2=bzip2;; + *[-.][zZ] | *_z | *[-.]gz | *.t[ag]z) xz2=gzip;; + *[-.]lzo | *.tzo) xz2=lzop;; + *[-.]zst | *.tzst) xz2='zstd -q';; + *[-.]lz4) xz2=lz4;; + esac + case $1 in + *[-.][zZ] | *_z | *[-.][gx]z | *[-.]bz2 | *[-.]lzma | *[-.]lz | *.t[abglx]z | *.tbz2 | *[-.]lzo | *.tzo | *[-.]zst | *.tzst | *[-.]lz4 | -) + case "$2" in + *[-.][zZ] | *_z | *[-.][gx]z | *[-.]bz2 | *[-.]lzma | *[-.]lz | *.t[abglx]z | *.tbz2 | *[-.]lzo | *.tzo | *[-.]zst | *.tzst | *[-.]lz4 | -) + if test "$1$2" = --; then + xz_status=$( + exec 4>&1 + ($xz1 -cdf - 4>&-; echo $? >&4) 3>&- | + eval "$cmp" - - >&3 + ) + elif # Reject Solaris 8's buggy /bin/bash 2.03. + echo X | (echo X | eval "$cmp" /dev/fd/5 - >/dev/null 2>&1) 5<&0; then + # NOTE: xz_status will contain two numbers. + xz_status=$( + exec 4>&1 + ($xz1 -cdf -- "$1" 4>&-; echo $? >&4) 3>&- | + ( ($xz2 -cdf -- "$2" 4>&-; echo $? >&4) 3>&- 5<&- &3) 5<&0 + ) + else + F=`expr "/$2" : '.*/\(.*\)[-.][ablmotxz2]*$'` || F=$prog + tmp= + trap ' + test -n "$tmp" && rm -rf "$tmp" + (exit 2); exit 2 + ' HUP INT PIPE TERM 0 + if type mktemp >/dev/null 2>&1; then + # Note that FreeBSD's mktemp isn't fully compatible with + # the implementations from mktemp.org and GNU coreutils. + # It is important that the -t argument is the last argument + # and that no "--" is used between -t and the template argument. + # This way this command works on all implementations. + tmp=`mktemp -d -t "$prog.XXXXXXXXXX"` || exit 2 + else + # Fallback code if mktemp is missing. This isn't as + # robust as using mktemp since this doesn't try with + # different file names in case of a file name conflict. + # + # There's no need to save the original umask since + # we don't create any non-temp files. Note that using + # mkdir -m 0077 isn't secure since some mkdir implementations + # create the dir with the default umask and chmod the + # the dir afterwards. + umask 0077 + mkdir -- "${TMPDIR-/tmp}/$prog.$$" || exit 2 + tmp="${TMPDIR-/tmp}/$prog.$$" + fi + $xz2 -cdf -- "$2" > "$tmp/$F" || exit 2 + xz_status=$( + exec 4>&1 + ($xz1 -cdf -- "$1" 4>&-; echo $? >&4) 3>&- | + eval "$cmp" - '"$tmp/$F"' >&3 + ) + cmp_status=$? + rm -rf "$tmp" || xz_status=$? + trap - HUP INT PIPE TERM 0 + (exit $cmp_status) + fi;; + *) + xz_status=$( + exec 4>&1 + ($xz1 -cdf -- "$1" 4>&-; echo $? >&4) 3>&- | + eval "$cmp" - '"$2"' >&3 + );; + esac;; + *) + case "$2" in + *[-.][zZ] | *_z | *[-.][gx]z | *[-.]bz2 | *[-.]lzma | *[-.]lz | *.t[abglx]z | *.tbz2 | *[-.]lzo | *.tzo | *[-.]zst | *.tzst | *[-.]lz4 | -) + xz_status=$( + exec 4>&1 + ($xz2 -cdf -- "$2" 4>&-; echo $? >&4) 3>&- | + eval "$cmp" '"$1"' - >&3 + );; + *) + eval "$cmp" '"$1"' '"$2"';; + esac;; + esac +else + printf '%s\n' "$0: Invalid number of operands; try '${0##*/} --help' for help" >&2 + exit 2 +fi + +cmp_status=$? +for num in $xz_status ; do + # 0 from decompressor means successful decompression. SIGPIPE from + # decompressor is possible when diff or cmp exits before the whole file + # has been decompressed. In that case we want to retain the exit status + # from diff or cmp. Note that using "trap '' PIPE" is not possible + # because gzip changes its behavior (including exit status) if SIGPIPE + # is ignored. + test "$num" -eq 0 && continue + test "$num" -ge 128 \ + && test "$(kill -l "$num" 2> /dev/null)" = "PIPE" \ + && continue + exit 2 +done +exit $cmp_status diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/xzegrep b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/xzegrep new file mode 100644 index 0000000000000000000000000000000000000000..e740ea1a0f4bfe6eb8cac7cd647069236aec6e28 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/xzegrep @@ -0,0 +1,302 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0-or-later + +# xzgrep -- a wrapper around a grep program that decompresses files as needed +# Adapted from a version sent by Charles Levert + +# Copyright (C) 1998, 2001, 2002, 2006, 2007 Free Software Foundation +# Copyright (C) 1993 Jean-loup Gailly + +# Modified for XZ Utils by Andrew Dudman and Lasse Collin. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# shellcheck shell=sh disable=SC1003,SC2016 + + +#SET_PATH - This line is a placeholder to ease patching this script. + +# Instead of unsetting XZ_OPT, just make sure that xz will use file format +# autodetection. This way memory usage limit and thread limit can be +# specified via XZ_OPT. With gzip, bzip2, and lzop it's OK to just unset the +# environment variables. +xz='xz --format=auto' +unset GZIP BZIP BZIP2 LZOP + +case ${0##*/} in + *egrep*) prog=xzegrep; grep=${GREP:-grep -E};; + *fgrep*) prog=xzfgrep; grep=${GREP:-grep -F};; + *) prog=xzgrep; grep=${GREP:-grep};; +esac + +version="$prog (XZ Utils) 5.8.2" + +usage="Usage: ${0##*/} [OPTION]... [-e] PATTERN [FILE]... +Look for instances of PATTERN in the input FILEs, using their +uncompressed contents if they are compressed. + +OPTIONs are the same as for '$grep'. + +Report bugs to ." + +# sed script to escape all ' for the shell, and then (to handle trailing +# newlines correctly) turn trailing X on last line into '. +escape=' + s/'\''/'\''\\'\'''\''/g + $s/X$/'\''/ +' +operands= +have_pat=0 +files_with_matches=0 +files_without_matches=0 +no_filename=0 +with_filename=0 + +# See if -H and --label options are supported (GNU and *BSDs). +if test f:x = "$(eval "echo x | $grep -H --label=f x 2> /dev/null")"; then + grep_supports_label=1 +else + grep_supports_label=0 +fi + +while test $# -ne 0; do + option=$1 + shift + optarg= + + case $option in + (-[0123456789abcdEFGhHiIKlLnoPqrRsTuUvVwxyzZ]*[!0123456789]*) + # Something like -Fiv was specified, that is, $option contains more + # than one option of which the first option (in this example -F) + # doesn't take an argument. Split the first option into a standalone + # argument and continue parsing the rest of the options (in this example, + # replace -Fiv with -iv in the argument list and set option=-F). + # + # If there are digits [0-9] they are treated as if they were a single + # option character because this syntax is an alias for -C for GNU grep. + # For example, "grep -25F" is equivalent to "grep -C25 -F". If only + # digits are specified like "grep -25" we don't get here because the + # above pattern in the case-statement doesn't match such strings. + arg2=-\'$(LC_ALL=C expr "X${option}X" : 'X-.[0-9]*\(.*\)' | + LC_ALL=C sed "$escape") + eval "set -- $arg2 "'${1+"$@"}' + option=$(LC_ALL=C expr "X$option" : 'X\(-.[0-9]*\)');; + (--binary-*=* | --[lm]a*=* | --reg*=*) + # These options require an argument and an argument has been provided + # with the --foo=argument syntax. All is good. + ;; + (-[ABCDefmX] | --binary-* | --file | --[lm]a* | --reg*) + # These options require an argument which should now be in $1. + # If it isn't, display an error and exit. + case ${1?"$option option requires an argument"} in + (*\'*) + optarg=" '"$(printf '%sX\n' "$1" | LC_ALL=C sed "$escape");; + (*) + optarg=" '$1'";; + esac + shift;; + (--) + break;; + (-?*) + ;; + (*) + case $option in + (*\'*) + operands="$operands '"$(printf '%sX\n' "$option" | + LC_ALL=C sed "$escape");; + (*) + operands="$operands '$option'";; + esac + ${POSIXLY_CORRECT+break} + continue;; + esac + + case $option in + (-[drRzZ] | --di* | --exc* | --inc* | --rec* | --nu*) + printf >&2 '%s: %s: Option not supported\n' "$0" "$option" + exit 2;; + (-[ef]* | --file | --file=* | --reg*) + have_pat=1;; + (--h | --he | --hel | --help) + printf '%s\n' "$usage" || exit 2 + exit;; + (-H | --wi | --wit | --with | --with- | --with-f | --with-fi \ + | --with-fil | --with-file | --with-filen | --with-filena | --with-filenam \ + | --with-filename) + with_filename=1 + continue;; + (-l | --files-with-*) + files_with_matches=1 + continue;; + (-L | --files-witho*) + files_without_matches=1 + continue;; + (-h | --no-f*) + no_filename=1;; + (-V | --v | --ve | --ver | --vers | --versi | --versio | --version) + printf '%s\n' "$version" || exit 2 + exit;; + esac + + case $option in + (*\'?*) + option=\'$(printf '%sX\n' "$option" | LC_ALL=C sed "$escape");; + (*) + option="'$option'";; + esac + + grep="$grep $option$optarg" +done + +eval "set -- $operands "'${1+"$@"}' + +if test $have_pat -eq 0; then + case ${1?"Missing pattern; try '${0##*/} --help' for help"} in + (*\'*) + grep="$grep -e '"$(printf '%sX\n' "$1" | LC_ALL=C sed "$escape");; + (*) + grep="$grep -e '$1'";; + esac + shift +fi + +if test $# -eq 0; then + set -- - +fi + +exec 3>&1 + +# res=1 means that no file matched yet +res=1 + +for i; do + case $i in + *[-.][zZ] | *_z | *[-.]gz | *.t[ag]z) uncompress="gzip -cdf";; + *[-.]bz2 | *[-.]tbz | *.tbz2) uncompress="bzip2 -cdf";; + *[-.]lzo | *[-.]tzo) uncompress="lzop -cdf";; + *[-.]zst | *[-.]tzst) uncompress="zstd -cdfq";; # zstd needs -q. + *[-.]lz4) uncompress="lz4 -cdf";; + *) uncompress="$xz -cdfqQ";; # -qQ to ignore warnings like unsupp. check. + esac + # xz_status will hold the decompressor's exit status. + # Exit status of grep (and in rare cases, printf or sed) is + # available as the exit status of this assignment command. + xz_status=$( + exec 5>&1 + ($uncompress -- "$i" 5>&-; echo $? >&5) 3>&- | + if test $files_with_matches -eq 1; then + eval "$grep -q" && { printf '%s\n' "$i" || exit 2; } + elif test $files_without_matches -eq 1; then + eval "$grep -q" || { + r=$? + if test $r -eq 1; then + printf '%s\n' "$i" || r=2 + fi + exit $r + } + elif test $with_filename -eq 0 && + { test $# -eq 1 || test $no_filename -eq 1; }; then + eval "$grep" + elif test $grep_supports_label -eq 1; then + # The grep implementation in use allows us to specify the filename + # that grep will prefix to the output lines. This is faster and + # less prone to security bugs than the fallback method that uses sed. + # This also avoids confusing output with GNU grep >= 3.5 (2020-09-27) + # which prints "binary file matches" to stderr instead of stdout. + # + # If reading from stdin, let grep use whatever name it prefers for + # stdin. With GNU grep it is a locale-specific translated string. + if test "x$i" = "x-"; then + eval "$grep -H" + else + eval "$grep -H --label \"\$i\"" + fi + else + # Append a colon so that the last character will never be a newline + # which would otherwise get lost in shell command substitution. + i="$i:" + + # Escape & \ | and newlines only if such characters are present + # (speed optimization). + case $i in + (*' +'* | *'&'* | *'\'* | *'|'*) + # If sed fails, set i to a known safe string to ensure that + # failing sed did not create a half-escaped dangerous string. + i=$(printf '%s\n' "$i" | LC_ALL=C sed 's/[&\|]/\\&/g; $!s/$/\\/') || + i='(unknown filename):';; + esac + + # $i already ends with a colon so do not add it here. + sed_script="s|^|$i|" + + # If grep or sed fails, pick the larger value of the two exit statuses. + # If sed fails, use at least 2 since we use >= 2 to indicate errors. + r=$( + exec 4>&1 + (eval "$grep" 4>&-; echo $? >&4) 3>&- | + LC_ALL=C sed "$sed_script" >&3 4>&- + ) || { + sed_status=$? + test "$sed_status" -lt 2 && sed_status=2 + test "$r" -lt "$sed_status" && r=$sed_status + } + exit $r + fi >&3 5>&- + ) + r=$? + + # If grep or sed or other non-decompression command failed with a signal, + # exit immediately and ignore the possible remaining files. + # + # NOTE: Instead of 128 + signal_number, some shells use + # 256 + signal_number (ksh) or 384 + signal_number (yash). + # This is fine for us since their "exit" and "kill -l" commands take + # this into account. (At least the versions I tried do but there is + # a report of an old ksh variant whose "exit" truncates the exit status + # to 8 bits without any special handling for values indicating a signal.) + test "$r" -ge 128 && exit "$r" + + if test -z "$xz_status"; then + # Something unusual happened, for example, we got a signal and + # the exit status of the decompressor was never echoed and thus + # $xz_status is empty. Exit immediately and ignore the possible + # remaining files. + exit 2 + elif test "$xz_status" -ge 128; then + # The decompressor died due to a signal. SIGPIPE is ignored since it can + # occur if grep exits before the whole file has been decompressed (grep -q + # can do that). If the decompressor died with some other signal, exit + # immediately and ignore the possible remaining files. + test "$(kill -l "$xz_status" 2> /dev/null)" != "PIPE" && exit "$xz_status" + elif test "$xz_status" -gt 0; then + # Decompression failed but we will continue with the remaining + # files anyway. Set exit status to at least 2 to indicate an error. + test "$r" -lt 2 && r=2 + fi + + # Since res=1 is the initial value, we only need to care about + # matches (r == 0) and errors (r >= 2) here; r == 1 can be ignored. + if test "$r" -ge 2; then + # An error occurred in decompressor, grep, or some other command. Update + # res unless a larger error code has been seen with an earlier file. + test "$res" -lt "$r" && res=$r + elif test "$r" -eq 0; then + # grep found a match and no errors occurred. Update res if no errors have + # occurred with earlier files. + test "$res" -eq 1 && res=0 + fi +done + +# 0: At least one file matched and no errors occurred. +# 1: No matches were found and no errors occurred. +# >=2: Error. It's unknown if matches were found. +exit "$res" diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/xzfgrep b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/xzfgrep new file mode 100644 index 0000000000000000000000000000000000000000..e740ea1a0f4bfe6eb8cac7cd647069236aec6e28 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/xzfgrep @@ -0,0 +1,302 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0-or-later + +# xzgrep -- a wrapper around a grep program that decompresses files as needed +# Adapted from a version sent by Charles Levert + +# Copyright (C) 1998, 2001, 2002, 2006, 2007 Free Software Foundation +# Copyright (C) 1993 Jean-loup Gailly + +# Modified for XZ Utils by Andrew Dudman and Lasse Collin. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# shellcheck shell=sh disable=SC1003,SC2016 + + +#SET_PATH - This line is a placeholder to ease patching this script. + +# Instead of unsetting XZ_OPT, just make sure that xz will use file format +# autodetection. This way memory usage limit and thread limit can be +# specified via XZ_OPT. With gzip, bzip2, and lzop it's OK to just unset the +# environment variables. +xz='xz --format=auto' +unset GZIP BZIP BZIP2 LZOP + +case ${0##*/} in + *egrep*) prog=xzegrep; grep=${GREP:-grep -E};; + *fgrep*) prog=xzfgrep; grep=${GREP:-grep -F};; + *) prog=xzgrep; grep=${GREP:-grep};; +esac + +version="$prog (XZ Utils) 5.8.2" + +usage="Usage: ${0##*/} [OPTION]... [-e] PATTERN [FILE]... +Look for instances of PATTERN in the input FILEs, using their +uncompressed contents if they are compressed. + +OPTIONs are the same as for '$grep'. + +Report bugs to ." + +# sed script to escape all ' for the shell, and then (to handle trailing +# newlines correctly) turn trailing X on last line into '. +escape=' + s/'\''/'\''\\'\'''\''/g + $s/X$/'\''/ +' +operands= +have_pat=0 +files_with_matches=0 +files_without_matches=0 +no_filename=0 +with_filename=0 + +# See if -H and --label options are supported (GNU and *BSDs). +if test f:x = "$(eval "echo x | $grep -H --label=f x 2> /dev/null")"; then + grep_supports_label=1 +else + grep_supports_label=0 +fi + +while test $# -ne 0; do + option=$1 + shift + optarg= + + case $option in + (-[0123456789abcdEFGhHiIKlLnoPqrRsTuUvVwxyzZ]*[!0123456789]*) + # Something like -Fiv was specified, that is, $option contains more + # than one option of which the first option (in this example -F) + # doesn't take an argument. Split the first option into a standalone + # argument and continue parsing the rest of the options (in this example, + # replace -Fiv with -iv in the argument list and set option=-F). + # + # If there are digits [0-9] they are treated as if they were a single + # option character because this syntax is an alias for -C for GNU grep. + # For example, "grep -25F" is equivalent to "grep -C25 -F". If only + # digits are specified like "grep -25" we don't get here because the + # above pattern in the case-statement doesn't match such strings. + arg2=-\'$(LC_ALL=C expr "X${option}X" : 'X-.[0-9]*\(.*\)' | + LC_ALL=C sed "$escape") + eval "set -- $arg2 "'${1+"$@"}' + option=$(LC_ALL=C expr "X$option" : 'X\(-.[0-9]*\)');; + (--binary-*=* | --[lm]a*=* | --reg*=*) + # These options require an argument and an argument has been provided + # with the --foo=argument syntax. All is good. + ;; + (-[ABCDefmX] | --binary-* | --file | --[lm]a* | --reg*) + # These options require an argument which should now be in $1. + # If it isn't, display an error and exit. + case ${1?"$option option requires an argument"} in + (*\'*) + optarg=" '"$(printf '%sX\n' "$1" | LC_ALL=C sed "$escape");; + (*) + optarg=" '$1'";; + esac + shift;; + (--) + break;; + (-?*) + ;; + (*) + case $option in + (*\'*) + operands="$operands '"$(printf '%sX\n' "$option" | + LC_ALL=C sed "$escape");; + (*) + operands="$operands '$option'";; + esac + ${POSIXLY_CORRECT+break} + continue;; + esac + + case $option in + (-[drRzZ] | --di* | --exc* | --inc* | --rec* | --nu*) + printf >&2 '%s: %s: Option not supported\n' "$0" "$option" + exit 2;; + (-[ef]* | --file | --file=* | --reg*) + have_pat=1;; + (--h | --he | --hel | --help) + printf '%s\n' "$usage" || exit 2 + exit;; + (-H | --wi | --wit | --with | --with- | --with-f | --with-fi \ + | --with-fil | --with-file | --with-filen | --with-filena | --with-filenam \ + | --with-filename) + with_filename=1 + continue;; + (-l | --files-with-*) + files_with_matches=1 + continue;; + (-L | --files-witho*) + files_without_matches=1 + continue;; + (-h | --no-f*) + no_filename=1;; + (-V | --v | --ve | --ver | --vers | --versi | --versio | --version) + printf '%s\n' "$version" || exit 2 + exit;; + esac + + case $option in + (*\'?*) + option=\'$(printf '%sX\n' "$option" | LC_ALL=C sed "$escape");; + (*) + option="'$option'";; + esac + + grep="$grep $option$optarg" +done + +eval "set -- $operands "'${1+"$@"}' + +if test $have_pat -eq 0; then + case ${1?"Missing pattern; try '${0##*/} --help' for help"} in + (*\'*) + grep="$grep -e '"$(printf '%sX\n' "$1" | LC_ALL=C sed "$escape");; + (*) + grep="$grep -e '$1'";; + esac + shift +fi + +if test $# -eq 0; then + set -- - +fi + +exec 3>&1 + +# res=1 means that no file matched yet +res=1 + +for i; do + case $i in + *[-.][zZ] | *_z | *[-.]gz | *.t[ag]z) uncompress="gzip -cdf";; + *[-.]bz2 | *[-.]tbz | *.tbz2) uncompress="bzip2 -cdf";; + *[-.]lzo | *[-.]tzo) uncompress="lzop -cdf";; + *[-.]zst | *[-.]tzst) uncompress="zstd -cdfq";; # zstd needs -q. + *[-.]lz4) uncompress="lz4 -cdf";; + *) uncompress="$xz -cdfqQ";; # -qQ to ignore warnings like unsupp. check. + esac + # xz_status will hold the decompressor's exit status. + # Exit status of grep (and in rare cases, printf or sed) is + # available as the exit status of this assignment command. + xz_status=$( + exec 5>&1 + ($uncompress -- "$i" 5>&-; echo $? >&5) 3>&- | + if test $files_with_matches -eq 1; then + eval "$grep -q" && { printf '%s\n' "$i" || exit 2; } + elif test $files_without_matches -eq 1; then + eval "$grep -q" || { + r=$? + if test $r -eq 1; then + printf '%s\n' "$i" || r=2 + fi + exit $r + } + elif test $with_filename -eq 0 && + { test $# -eq 1 || test $no_filename -eq 1; }; then + eval "$grep" + elif test $grep_supports_label -eq 1; then + # The grep implementation in use allows us to specify the filename + # that grep will prefix to the output lines. This is faster and + # less prone to security bugs than the fallback method that uses sed. + # This also avoids confusing output with GNU grep >= 3.5 (2020-09-27) + # which prints "binary file matches" to stderr instead of stdout. + # + # If reading from stdin, let grep use whatever name it prefers for + # stdin. With GNU grep it is a locale-specific translated string. + if test "x$i" = "x-"; then + eval "$grep -H" + else + eval "$grep -H --label \"\$i\"" + fi + else + # Append a colon so that the last character will never be a newline + # which would otherwise get lost in shell command substitution. + i="$i:" + + # Escape & \ | and newlines only if such characters are present + # (speed optimization). + case $i in + (*' +'* | *'&'* | *'\'* | *'|'*) + # If sed fails, set i to a known safe string to ensure that + # failing sed did not create a half-escaped dangerous string. + i=$(printf '%s\n' "$i" | LC_ALL=C sed 's/[&\|]/\\&/g; $!s/$/\\/') || + i='(unknown filename):';; + esac + + # $i already ends with a colon so do not add it here. + sed_script="s|^|$i|" + + # If grep or sed fails, pick the larger value of the two exit statuses. + # If sed fails, use at least 2 since we use >= 2 to indicate errors. + r=$( + exec 4>&1 + (eval "$grep" 4>&-; echo $? >&4) 3>&- | + LC_ALL=C sed "$sed_script" >&3 4>&- + ) || { + sed_status=$? + test "$sed_status" -lt 2 && sed_status=2 + test "$r" -lt "$sed_status" && r=$sed_status + } + exit $r + fi >&3 5>&- + ) + r=$? + + # If grep or sed or other non-decompression command failed with a signal, + # exit immediately and ignore the possible remaining files. + # + # NOTE: Instead of 128 + signal_number, some shells use + # 256 + signal_number (ksh) or 384 + signal_number (yash). + # This is fine for us since their "exit" and "kill -l" commands take + # this into account. (At least the versions I tried do but there is + # a report of an old ksh variant whose "exit" truncates the exit status + # to 8 bits without any special handling for values indicating a signal.) + test "$r" -ge 128 && exit "$r" + + if test -z "$xz_status"; then + # Something unusual happened, for example, we got a signal and + # the exit status of the decompressor was never echoed and thus + # $xz_status is empty. Exit immediately and ignore the possible + # remaining files. + exit 2 + elif test "$xz_status" -ge 128; then + # The decompressor died due to a signal. SIGPIPE is ignored since it can + # occur if grep exits before the whole file has been decompressed (grep -q + # can do that). If the decompressor died with some other signal, exit + # immediately and ignore the possible remaining files. + test "$(kill -l "$xz_status" 2> /dev/null)" != "PIPE" && exit "$xz_status" + elif test "$xz_status" -gt 0; then + # Decompression failed but we will continue with the remaining + # files anyway. Set exit status to at least 2 to indicate an error. + test "$r" -lt 2 && r=2 + fi + + # Since res=1 is the initial value, we only need to care about + # matches (r == 0) and errors (r >= 2) here; r == 1 can be ignored. + if test "$r" -ge 2; then + # An error occurred in decompressor, grep, or some other command. Update + # res unless a larger error code has been seen with an earlier file. + test "$res" -lt "$r" && res=$r + elif test "$r" -eq 0; then + # grep found a match and no errors occurred. Update res if no errors have + # occurred with earlier files. + test "$res" -eq 1 && res=0 + fi +done + +# 0: At least one file matched and no errors occurred. +# 1: No matches were found and no errors occurred. +# >=2: Error. It's unknown if matches were found. +exit "$res" diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/xzgrep b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/xzgrep new file mode 100644 index 0000000000000000000000000000000000000000..e740ea1a0f4bfe6eb8cac7cd647069236aec6e28 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/xzgrep @@ -0,0 +1,302 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0-or-later + +# xzgrep -- a wrapper around a grep program that decompresses files as needed +# Adapted from a version sent by Charles Levert + +# Copyright (C) 1998, 2001, 2002, 2006, 2007 Free Software Foundation +# Copyright (C) 1993 Jean-loup Gailly + +# Modified for XZ Utils by Andrew Dudman and Lasse Collin. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# shellcheck shell=sh disable=SC1003,SC2016 + + +#SET_PATH - This line is a placeholder to ease patching this script. + +# Instead of unsetting XZ_OPT, just make sure that xz will use file format +# autodetection. This way memory usage limit and thread limit can be +# specified via XZ_OPT. With gzip, bzip2, and lzop it's OK to just unset the +# environment variables. +xz='xz --format=auto' +unset GZIP BZIP BZIP2 LZOP + +case ${0##*/} in + *egrep*) prog=xzegrep; grep=${GREP:-grep -E};; + *fgrep*) prog=xzfgrep; grep=${GREP:-grep -F};; + *) prog=xzgrep; grep=${GREP:-grep};; +esac + +version="$prog (XZ Utils) 5.8.2" + +usage="Usage: ${0##*/} [OPTION]... [-e] PATTERN [FILE]... +Look for instances of PATTERN in the input FILEs, using their +uncompressed contents if they are compressed. + +OPTIONs are the same as for '$grep'. + +Report bugs to ." + +# sed script to escape all ' for the shell, and then (to handle trailing +# newlines correctly) turn trailing X on last line into '. +escape=' + s/'\''/'\''\\'\'''\''/g + $s/X$/'\''/ +' +operands= +have_pat=0 +files_with_matches=0 +files_without_matches=0 +no_filename=0 +with_filename=0 + +# See if -H and --label options are supported (GNU and *BSDs). +if test f:x = "$(eval "echo x | $grep -H --label=f x 2> /dev/null")"; then + grep_supports_label=1 +else + grep_supports_label=0 +fi + +while test $# -ne 0; do + option=$1 + shift + optarg= + + case $option in + (-[0123456789abcdEFGhHiIKlLnoPqrRsTuUvVwxyzZ]*[!0123456789]*) + # Something like -Fiv was specified, that is, $option contains more + # than one option of which the first option (in this example -F) + # doesn't take an argument. Split the first option into a standalone + # argument and continue parsing the rest of the options (in this example, + # replace -Fiv with -iv in the argument list and set option=-F). + # + # If there are digits [0-9] they are treated as if they were a single + # option character because this syntax is an alias for -C for GNU grep. + # For example, "grep -25F" is equivalent to "grep -C25 -F". If only + # digits are specified like "grep -25" we don't get here because the + # above pattern in the case-statement doesn't match such strings. + arg2=-\'$(LC_ALL=C expr "X${option}X" : 'X-.[0-9]*\(.*\)' | + LC_ALL=C sed "$escape") + eval "set -- $arg2 "'${1+"$@"}' + option=$(LC_ALL=C expr "X$option" : 'X\(-.[0-9]*\)');; + (--binary-*=* | --[lm]a*=* | --reg*=*) + # These options require an argument and an argument has been provided + # with the --foo=argument syntax. All is good. + ;; + (-[ABCDefmX] | --binary-* | --file | --[lm]a* | --reg*) + # These options require an argument which should now be in $1. + # If it isn't, display an error and exit. + case ${1?"$option option requires an argument"} in + (*\'*) + optarg=" '"$(printf '%sX\n' "$1" | LC_ALL=C sed "$escape");; + (*) + optarg=" '$1'";; + esac + shift;; + (--) + break;; + (-?*) + ;; + (*) + case $option in + (*\'*) + operands="$operands '"$(printf '%sX\n' "$option" | + LC_ALL=C sed "$escape");; + (*) + operands="$operands '$option'";; + esac + ${POSIXLY_CORRECT+break} + continue;; + esac + + case $option in + (-[drRzZ] | --di* | --exc* | --inc* | --rec* | --nu*) + printf >&2 '%s: %s: Option not supported\n' "$0" "$option" + exit 2;; + (-[ef]* | --file | --file=* | --reg*) + have_pat=1;; + (--h | --he | --hel | --help) + printf '%s\n' "$usage" || exit 2 + exit;; + (-H | --wi | --wit | --with | --with- | --with-f | --with-fi \ + | --with-fil | --with-file | --with-filen | --with-filena | --with-filenam \ + | --with-filename) + with_filename=1 + continue;; + (-l | --files-with-*) + files_with_matches=1 + continue;; + (-L | --files-witho*) + files_without_matches=1 + continue;; + (-h | --no-f*) + no_filename=1;; + (-V | --v | --ve | --ver | --vers | --versi | --versio | --version) + printf '%s\n' "$version" || exit 2 + exit;; + esac + + case $option in + (*\'?*) + option=\'$(printf '%sX\n' "$option" | LC_ALL=C sed "$escape");; + (*) + option="'$option'";; + esac + + grep="$grep $option$optarg" +done + +eval "set -- $operands "'${1+"$@"}' + +if test $have_pat -eq 0; then + case ${1?"Missing pattern; try '${0##*/} --help' for help"} in + (*\'*) + grep="$grep -e '"$(printf '%sX\n' "$1" | LC_ALL=C sed "$escape");; + (*) + grep="$grep -e '$1'";; + esac + shift +fi + +if test $# -eq 0; then + set -- - +fi + +exec 3>&1 + +# res=1 means that no file matched yet +res=1 + +for i; do + case $i in + *[-.][zZ] | *_z | *[-.]gz | *.t[ag]z) uncompress="gzip -cdf";; + *[-.]bz2 | *[-.]tbz | *.tbz2) uncompress="bzip2 -cdf";; + *[-.]lzo | *[-.]tzo) uncompress="lzop -cdf";; + *[-.]zst | *[-.]tzst) uncompress="zstd -cdfq";; # zstd needs -q. + *[-.]lz4) uncompress="lz4 -cdf";; + *) uncompress="$xz -cdfqQ";; # -qQ to ignore warnings like unsupp. check. + esac + # xz_status will hold the decompressor's exit status. + # Exit status of grep (and in rare cases, printf or sed) is + # available as the exit status of this assignment command. + xz_status=$( + exec 5>&1 + ($uncompress -- "$i" 5>&-; echo $? >&5) 3>&- | + if test $files_with_matches -eq 1; then + eval "$grep -q" && { printf '%s\n' "$i" || exit 2; } + elif test $files_without_matches -eq 1; then + eval "$grep -q" || { + r=$? + if test $r -eq 1; then + printf '%s\n' "$i" || r=2 + fi + exit $r + } + elif test $with_filename -eq 0 && + { test $# -eq 1 || test $no_filename -eq 1; }; then + eval "$grep" + elif test $grep_supports_label -eq 1; then + # The grep implementation in use allows us to specify the filename + # that grep will prefix to the output lines. This is faster and + # less prone to security bugs than the fallback method that uses sed. + # This also avoids confusing output with GNU grep >= 3.5 (2020-09-27) + # which prints "binary file matches" to stderr instead of stdout. + # + # If reading from stdin, let grep use whatever name it prefers for + # stdin. With GNU grep it is a locale-specific translated string. + if test "x$i" = "x-"; then + eval "$grep -H" + else + eval "$grep -H --label \"\$i\"" + fi + else + # Append a colon so that the last character will never be a newline + # which would otherwise get lost in shell command substitution. + i="$i:" + + # Escape & \ | and newlines only if such characters are present + # (speed optimization). + case $i in + (*' +'* | *'&'* | *'\'* | *'|'*) + # If sed fails, set i to a known safe string to ensure that + # failing sed did not create a half-escaped dangerous string. + i=$(printf '%s\n' "$i" | LC_ALL=C sed 's/[&\|]/\\&/g; $!s/$/\\/') || + i='(unknown filename):';; + esac + + # $i already ends with a colon so do not add it here. + sed_script="s|^|$i|" + + # If grep or sed fails, pick the larger value of the two exit statuses. + # If sed fails, use at least 2 since we use >= 2 to indicate errors. + r=$( + exec 4>&1 + (eval "$grep" 4>&-; echo $? >&4) 3>&- | + LC_ALL=C sed "$sed_script" >&3 4>&- + ) || { + sed_status=$? + test "$sed_status" -lt 2 && sed_status=2 + test "$r" -lt "$sed_status" && r=$sed_status + } + exit $r + fi >&3 5>&- + ) + r=$? + + # If grep or sed or other non-decompression command failed with a signal, + # exit immediately and ignore the possible remaining files. + # + # NOTE: Instead of 128 + signal_number, some shells use + # 256 + signal_number (ksh) or 384 + signal_number (yash). + # This is fine for us since their "exit" and "kill -l" commands take + # this into account. (At least the versions I tried do but there is + # a report of an old ksh variant whose "exit" truncates the exit status + # to 8 bits without any special handling for values indicating a signal.) + test "$r" -ge 128 && exit "$r" + + if test -z "$xz_status"; then + # Something unusual happened, for example, we got a signal and + # the exit status of the decompressor was never echoed and thus + # $xz_status is empty. Exit immediately and ignore the possible + # remaining files. + exit 2 + elif test "$xz_status" -ge 128; then + # The decompressor died due to a signal. SIGPIPE is ignored since it can + # occur if grep exits before the whole file has been decompressed (grep -q + # can do that). If the decompressor died with some other signal, exit + # immediately and ignore the possible remaining files. + test "$(kill -l "$xz_status" 2> /dev/null)" != "PIPE" && exit "$xz_status" + elif test "$xz_status" -gt 0; then + # Decompression failed but we will continue with the remaining + # files anyway. Set exit status to at least 2 to indicate an error. + test "$r" -lt 2 && r=2 + fi + + # Since res=1 is the initial value, we only need to care about + # matches (r == 0) and errors (r >= 2) here; r == 1 can be ignored. + if test "$r" -ge 2; then + # An error occurred in decompressor, grep, or some other command. Update + # res unless a larger error code has been seen with an earlier file. + test "$res" -lt "$r" && res=$r + elif test "$r" -eq 0; then + # grep found a match and no errors occurred. Update res if no errors have + # occurred with earlier files. + test "$res" -eq 1 && res=0 + fi +done + +# 0: At least one file matched and no errors occurred. +# 1: No matches were found and no errors occurred. +# >=2: Error. It's unknown if matches were found. +exit "$res" diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/xzless b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/xzless new file mode 100644 index 0000000000000000000000000000000000000000..bd177e93df1cea09f4ab4aeb7efc4582ba4fea4f --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/xzless @@ -0,0 +1,76 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0-or-later + +# Copyright (C) 1998, 2002, 2006, 2007 Free Software Foundation + +# The original version for gzip was written by Paul Eggert. +# Modified for XZ Utils by Andrew Dudman and Lasse Collin. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# shellcheck shell=sh disable=SC2089,SC2090 + + +#SET_PATH - This line is a placeholder to ease patching this script. + +# Instead of unsetting XZ_OPT, just make sure that xz will use file format +# autodetection. This way memory usage limit and thread limit can be +# specified via XZ_OPT. +xz='xz --format=auto' + +version='xzless (XZ Utils) 5.8.2' + +usage="Usage: ${0##*/} [OPTION]... [FILE]... +Like 'less', but operate on the uncompressed contents of xz compressed FILEs. + +Options are the same as for 'less'. + +Report bugs to ." + +case $1 in + --help) printf '%s\n' "$usage" || exit 2; exit;; + --version) printf '%s\n' "$version" || exit 2; exit;; +esac + +if test "${LESSMETACHARS+set}" != set; then + # Work around a bug in less 394 and earlier; + # it mishandles the metacharacters '$%=~'. + space=' ' + tab=' ' + nl=' +' + LESSMETACHARS="$space$tab$nl'"';*?"()<>[|&^`#\$%=~' +fi + +VER=$(less -V | { read _ ver _ && echo ${ver%%.*}; }) +if test "$VER" -ge 451; then + # less 451 or later: If the compressed file is valid but has + # zero bytes of uncompressed data, using two vertical bars ||- makes + # "less" check the exit status of xz and if it is zero then display + # an empty file. With a single vertical bar |- and no output from xz, + # "less" would attempt to display the raw input file instead. + LESSOPEN="||-$xz -cdfqQ -- %s" +elif test "$VER" -ge 429; then + # less 429 or later: LESSOPEN pipe will be used on + # standard input if $LESSOPEN begins with |-. + LESSOPEN="|-$xz -cdfqQ -- %s" +else + LESSOPEN="|$xz -cdfqQ -- %s" +fi + +SHOW_PREPROC_ERRORS= +if test "$VER" -ge 632; then + SHOW_PREPROC_ERRORS=--show-preproc-errors +fi + +export LESSMETACHARS LESSOPEN + +exec less $SHOW_PREPROC_ERRORS "$@" diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/xzmore b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/xzmore new file mode 100644 index 0000000000000000000000000000000000000000..0816c6dbca2c077885ae788dc4e6c379d7dd2920 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/bin/xzmore @@ -0,0 +1,82 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0-or-later + +# Copyright (C) 2001, 2002, 2007 Free Software Foundation +# Copyright (C) 1992, 1993 Jean-loup Gailly + +# Modified for XZ Utils by Andrew Dudman and Lasse Collin. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# shellcheck shell=sh + + +#SET_PATH - This line is a placeholder to ease patching this script. + +# Instead of unsetting XZ_OPT, just make sure that xz will use file format +# autodetection. This way memory usage limit and thread limit can be +# specified via XZ_OPT. +xz='xz --format=auto' + +version='xzmore (XZ Utils) 5.8.2' + +usage="Usage: ${0##*/} [OPTION]... [FILE]... +Like 'more', but operate on the uncompressed contents of xz compressed FILEs. + +Report bugs to ." + +case $1 in + --help) printf '%s\n' "$usage" || exit 2; exit;; + --version) printf '%s\n' "$version" || exit 2; exit;; +esac + +oldtty=`stty -g 2>/dev/null` +if stty -cbreak 2>/dev/null; then + cb='cbreak'; ncb='-cbreak' +else + # 'stty min 1' resets eof to ^a on both SunOS and SysV! + cb='min 1 -icanon'; ncb='icanon eof ^d' +fi +if test $? -eq 0 && test -n "$oldtty"; then + trap 'stty $oldtty 2>/dev/null; exit' 0 2 3 5 10 13 15 +else + trap 'stty $ncb echo 2>/dev/null; exit' 0 2 3 5 10 13 15 +fi + +if test $# = 0; then + if test -t 0; then + printf '%s\n' "$usage"; exit 1 + else + $xz -cdfqQ | eval "${PAGER:-more}" + fi +else + FIRST=1 + for FILE; do + true < "$FILE" || continue + if test $FIRST -eq 0; then + printf "%s--More--(Next file: %s)" "" "$FILE" + stty $cb -echo 2>/dev/null + ANS=`dd bs=1 count=1 2>/dev/null` + stty $ncb echo 2>/dev/null + echo " " + case "$ANS" in + [eq]) exit;; + esac + fi + if test "$ANS" != 's'; then + printf '%s\n' "------> $FILE <------" + $xz -cdfqQ -- "$FILE" | eval "${PAGER:-more}" + fi + if test -t 1; then + FIRST=0 + fi + done +fi diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma.h b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma.h new file mode 100644 index 0000000000000000000000000000000000000000..6ca6e503d8a6eb0b49ff4ba66ca89b0fd014347b --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma.h @@ -0,0 +1,327 @@ +/* SPDX-License-Identifier: 0BSD */ + +/** + * \file api/lzma.h + * \brief The public API of liblzma data compression library + * \mainpage + * + * liblzma is a general-purpose data compression library with a zlib-like API. + * The native file format is .xz, but also the old .lzma format and raw (no + * headers) streams are supported. Multiple compression algorithms (filters) + * are supported. Currently LZMA2 is the primary filter. + * + * liblzma is part of XZ Utils . XZ Utils + * includes a gzip-like command line tool named xz and some other tools. + * XZ Utils is developed and maintained by Lasse Collin. + * + * Major parts of liblzma are based on code written by Igor Pavlov, + * specifically the LZMA SDK . + * + * The SHA-256 implementation in liblzma is based on code written by + * Wei Dai in Crypto++ Library . + * + * liblzma is distributed under the BSD Zero Clause License (0BSD). + */ + +/* + * Author: Lasse Collin + */ + +#ifndef LZMA_H +#define LZMA_H + +/***************************** + * Required standard headers * + *****************************/ + +/* + * liblzma API headers need some standard types and macros. To allow + * including lzma.h without requiring the application to include other + * headers first, lzma.h includes the required standard headers unless + * they already seem to be included already or if LZMA_MANUAL_HEADERS + * has been defined. + * + * Here's what types and macros are needed and from which headers: + * - stddef.h: size_t, NULL + * - stdint.h: uint8_t, uint32_t, uint64_t, UINT32_C(n), uint64_C(n), + * UINT32_MAX, UINT64_MAX + * + * However, inttypes.h is a little more portable than stdint.h, although + * inttypes.h declares some unneeded things compared to plain stdint.h. + * + * The hacks below aren't perfect, specifically they assume that inttypes.h + * exists and that it typedefs at least uint8_t, uint32_t, and uint64_t, + * and that, in case of incomplete inttypes.h, unsigned int is 32-bit. + * If the application already takes care of setting up all the types and + * macros properly (for example by using gnulib's stdint.h or inttypes.h), + * we try to detect that the macros are already defined and don't include + * inttypes.h here again. However, you may define LZMA_MANUAL_HEADERS to + * force this file to never include any system headers. + * + * Some could argue that liblzma API should provide all the required types, + * for example lzma_uint64, LZMA_UINT64_C(n), and LZMA_UINT64_MAX. This was + * seen as an unnecessary mess, since most systems already provide all the + * necessary types and macros in the standard headers. + * + * Note that liblzma API still has lzma_bool, because using stdbool.h would + * break C89 and C++ programs on many systems. sizeof(bool) in C99 isn't + * necessarily the same as sizeof(bool) in C++. + */ + +#ifndef LZMA_MANUAL_HEADERS + /* + * I suppose this works portably also in C++. Note that in C++, + * we need to get size_t into the global namespace. + */ +# include + + /* + * Skip inttypes.h if we already have all the required macros. If we + * have the macros, we assume that we have the matching typedefs too. + */ +# if !defined(UINT32_C) || !defined(UINT64_C) \ + || !defined(UINT32_MAX) || !defined(UINT64_MAX) + /* + * MSVC versions older than 2013 have no C99 support, and + * thus they cannot be used to compile liblzma. Using an + * existing liblzma.dll with old MSVC can work though(*), + * but we need to define the required standard integer + * types here in a MSVC-specific way. + * + * (*) If you do this, the existing liblzma.dll probably uses + * a different runtime library than your MSVC-built + * application. Mixing runtimes is generally bad, but + * in this case it should work as long as you avoid + * the few rarely-needed liblzma functions that allocate + * memory and expect the caller to free it using free(). + */ +# if defined(_WIN32) && defined(_MSC_VER) && _MSC_VER < 1800 + typedef unsigned __int8 uint8_t; + typedef unsigned __int32 uint32_t; + typedef unsigned __int64 uint64_t; +# else + /* Use the standard inttypes.h. */ +# ifdef __cplusplus + /* + * C99 sections 7.18.2 and 7.18.4 specify + * that C++ implementations define the limit + * and constant macros only if specifically + * requested. Note that if you want the + * format macros (PRIu64 etc.) too, you need + * to define __STDC_FORMAT_MACROS before + * including lzma.h, since re-including + * inttypes.h with __STDC_FORMAT_MACROS + * defined doesn't necessarily work. + */ +# ifndef __STDC_LIMIT_MACROS +# define __STDC_LIMIT_MACROS 1 +# endif +# ifndef __STDC_CONSTANT_MACROS +# define __STDC_CONSTANT_MACROS 1 +# endif +# endif + +# include +# endif + + /* + * Some old systems have only the typedefs in inttypes.h, and + * lack all the macros. For those systems, we need a few more + * hacks. We assume that unsigned int is 32-bit and unsigned + * long is either 32-bit or 64-bit. If these hacks aren't + * enough, the application has to setup the types manually + * before including lzma.h. + */ +# ifndef UINT32_C +# if defined(_WIN32) && defined(_MSC_VER) +# define UINT32_C(n) n ## UI32 +# else +# define UINT32_C(n) n ## U +# endif +# endif + +# ifndef UINT64_C +# if defined(_WIN32) && defined(_MSC_VER) +# define UINT64_C(n) n ## UI64 +# else + /* Get ULONG_MAX. */ +# include +# if ULONG_MAX == 4294967295UL +# define UINT64_C(n) n ## ULL +# else +# define UINT64_C(n) n ## UL +# endif +# endif +# endif + +# ifndef UINT32_MAX +# define UINT32_MAX (UINT32_C(4294967295)) +# endif + +# ifndef UINT64_MAX +# define UINT64_MAX (UINT64_C(18446744073709551615)) +# endif +# endif +#endif /* ifdef LZMA_MANUAL_HEADERS */ + + +/****************** + * LZMA_API macro * + ******************/ + +/* + * Some systems require that the functions and function pointers are + * declared specially in the headers. LZMA_API_IMPORT is for importing + * symbols and LZMA_API_CALL is to specify the calling convention. + * + * By default it is assumed that the application will link dynamically + * against liblzma. #define LZMA_API_STATIC in your application if you + * want to link against static liblzma. If you don't care about portability + * to operating systems like Windows, or at least don't care about linking + * against static liblzma on them, don't worry about LZMA_API_STATIC. That + * is, most developers will never need to use LZMA_API_STATIC. + * + * The GCC variants are a special case on Windows (Cygwin and MinGW-w64). + * We rely on GCC doing the right thing with its auto-import feature, + * and thus don't use __declspec(dllimport). This way developers don't + * need to worry about LZMA_API_STATIC. Also the calling convention is + * omitted on Cygwin but not on MinGW-w64. + */ +#ifndef LZMA_API_IMPORT +# if !defined(LZMA_API_STATIC) && defined(_WIN32) && !defined(__GNUC__) +# define LZMA_API_IMPORT __declspec(dllimport) +# else +# define LZMA_API_IMPORT +# endif +#endif + +#ifndef LZMA_API_CALL +# if defined(_WIN32) && !defined(__CYGWIN__) +# define LZMA_API_CALL __cdecl +# else +# define LZMA_API_CALL +# endif +#endif + +#ifndef LZMA_API +# define LZMA_API(type) LZMA_API_IMPORT type LZMA_API_CALL +#endif + + +/*********** + * nothrow * + ***********/ + +/* + * None of the functions in liblzma may throw an exception. Even + * the functions that use callback functions won't throw exceptions, + * because liblzma would break if a callback function threw an exception. + */ +#ifndef lzma_nothrow +# if defined(__cplusplus) +# if __cplusplus >= 201103L || (defined(_MSVC_LANG) \ + && _MSVC_LANG >= 201103L) +# define lzma_nothrow noexcept +# else +# define lzma_nothrow throw() +# endif +# elif defined(__GNUC__) && (__GNUC__ > 3 \ + || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)) +# define lzma_nothrow __attribute__((__nothrow__)) +# else +# define lzma_nothrow +# endif +#endif + + +/******************** + * GNU C extensions * + ********************/ + +/* + * GNU C extensions are used conditionally in the public API. It doesn't + * break anything if these are sometimes enabled and sometimes not, only + * affects warnings and optimizations. + */ +#if defined(__GNUC__) && __GNUC__ >= 3 +# ifndef lzma_attribute +# define lzma_attribute(attr) __attribute__(attr) +# endif + + /* warn_unused_result was added in GCC 3.4. */ +# ifndef lzma_attr_warn_unused_result +# if __GNUC__ == 3 && __GNUC_MINOR__ < 4 +# define lzma_attr_warn_unused_result +# endif +# endif + +#else +# ifndef lzma_attribute +# define lzma_attribute(attr) +# endif +#endif + + +#ifndef lzma_attr_pure +# define lzma_attr_pure lzma_attribute((__pure__)) +#endif + +#ifndef lzma_attr_const +# define lzma_attr_const lzma_attribute((__const__)) +#endif + +#ifndef lzma_attr_warn_unused_result +# define lzma_attr_warn_unused_result \ + lzma_attribute((__warn_unused_result__)) +#endif + + +/************** + * Subheaders * + **************/ + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Subheaders check that this is defined. It is to prevent including + * them directly from applications. + */ +#define LZMA_H_INTERNAL 1 + +/* Basic features */ +#include "lzma/version.h" +#include "lzma/base.h" +#include "lzma/vli.h" +#include "lzma/check.h" + +/* Filters */ +#include "lzma/filter.h" +#include "lzma/bcj.h" +#include "lzma/delta.h" +#include "lzma/lzma12.h" + +/* Container formats */ +#include "lzma/container.h" + +/* Advanced features */ +#include "lzma/stream_flags.h" +#include "lzma/block.h" +#include "lzma/index.h" +#include "lzma/index_hash.h" + +/* Hardware information */ +#include "lzma/hardware.h" + +/* + * All subheaders included. Undefine LZMA_H_INTERNAL to prevent applications + * re-including the subheaders. + */ +#undef LZMA_H_INTERNAL + +#ifdef __cplusplus +} +#endif + +#endif /* ifndef LZMA_H */ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/base.h b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/base.h new file mode 100644 index 0000000000000000000000000000000000000000..00499381426a8490704244a02a59e620ff5c1f9c --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/base.h @@ -0,0 +1,749 @@ +/* SPDX-License-Identifier: 0BSD */ + +/** + * \file lzma/base.h + * \brief Data types and functions used in many places in liblzma API + * \note Never include this file directly. Use instead. + */ + +/* + * Author: Lasse Collin + */ + +#ifndef LZMA_H_INTERNAL +# error Never include this file directly. Use instead. +#endif + + +/** + * \brief Boolean + * + * This is here because C89 doesn't have stdbool.h. To set a value for + * variables having type lzma_bool, you can use + * - C99's 'true' and 'false' from stdbool.h; + * - C++'s internal 'true' and 'false'; or + * - integers one (true) and zero (false). + */ +typedef unsigned char lzma_bool; + + +/** + * \brief Type of reserved enumeration variable in structures + * + * To avoid breaking library ABI when new features are added, several + * structures contain extra variables that may be used in future. Since + * sizeof(enum) can be different than sizeof(int), and sizeof(enum) may + * even vary depending on the range of enumeration constants, we specify + * a separate type to be used for reserved enumeration variables. All + * enumeration constants in liblzma API will be non-negative and less + * than 128, which should guarantee that the ABI won't break even when + * new constants are added to existing enumerations. + */ +typedef enum { + LZMA_RESERVED_ENUM = 0 +} lzma_reserved_enum; + + +/** + * \brief Return values used by several functions in liblzma + * + * Check the descriptions of specific functions to find out which return + * values they can return. With some functions the return values may have + * more specific meanings than described here; those differences are + * described per-function basis. + */ +typedef enum { + LZMA_OK = 0, + /**< + * \brief Operation completed successfully + */ + + LZMA_STREAM_END = 1, + /**< + * \brief End of stream was reached + * + * In encoder, LZMA_SYNC_FLUSH, LZMA_FULL_FLUSH, or + * LZMA_FINISH was finished. In decoder, this indicates + * that all the data was successfully decoded. + * + * In all cases, when LZMA_STREAM_END is returned, the last + * output bytes should be picked from strm->next_out. + */ + + LZMA_NO_CHECK = 2, + /**< + * \brief Input stream has no integrity check + * + * This return value can be returned only if the + * LZMA_TELL_NO_CHECK flag was used when initializing + * the decoder. LZMA_NO_CHECK is just a warning, and + * the decoding can be continued normally. + * + * It is possible to call lzma_get_check() immediately after + * lzma_code has returned LZMA_NO_CHECK. The result will + * naturally be LZMA_CHECK_NONE, but the possibility to call + * lzma_get_check() may be convenient in some applications. + */ + + LZMA_UNSUPPORTED_CHECK = 3, + /**< + * \brief Cannot calculate the integrity check + * + * The usage of this return value is different in encoders + * and decoders. + * + * Encoders can return this value only from the initialization + * function. If initialization fails with this value, the + * encoding cannot be done, because there's no way to produce + * output with the correct integrity check. + * + * Decoders can return this value only from lzma_code() and + * only if the LZMA_TELL_UNSUPPORTED_CHECK flag was used when + * initializing the decoder. The decoding can still be + * continued normally even if the check type is unsupported, + * but naturally the check will not be validated, and possible + * errors may go undetected. + * + * With decoder, it is possible to call lzma_get_check() + * immediately after lzma_code() has returned + * LZMA_UNSUPPORTED_CHECK. This way it is possible to find + * out what the unsupported Check ID was. + */ + + LZMA_GET_CHECK = 4, + /**< + * \brief Integrity check type is now available + * + * This value can be returned only by the lzma_code() function + * and only if the decoder was initialized with the + * LZMA_TELL_ANY_CHECK flag. LZMA_GET_CHECK tells the + * application that it may now call lzma_get_check() to find + * out the Check ID. This can be used, for example, to + * implement a decoder that accepts only files that have + * strong enough integrity check. + */ + + LZMA_MEM_ERROR = 5, + /**< + * \brief Cannot allocate memory + * + * Memory allocation failed, or the size of the allocation + * would be greater than SIZE_MAX. + * + * Due to internal implementation reasons, the coding cannot + * be continued even if more memory were made available after + * LZMA_MEM_ERROR. + */ + + LZMA_MEMLIMIT_ERROR = 6, + /**< + * \brief Memory usage limit was reached + * + * Decoder would need more memory than allowed by the + * specified memory usage limit. To continue decoding, + * the memory usage limit has to be increased with + * lzma_memlimit_set(). + * + * liblzma 5.2.6 and earlier had a bug in single-threaded .xz + * decoder (lzma_stream_decoder()) which made it impossible + * to continue decoding after LZMA_MEMLIMIT_ERROR even if + * the limit was increased using lzma_memlimit_set(). + * Other decoders worked correctly. + */ + + LZMA_FORMAT_ERROR = 7, + /**< + * \brief File format not recognized + * + * The decoder did not recognize the input as supported file + * format. This error can occur, for example, when trying to + * decode .lzma format file with lzma_stream_decoder, + * because lzma_stream_decoder accepts only the .xz format. + */ + + LZMA_OPTIONS_ERROR = 8, + /**< + * \brief Invalid or unsupported options + * + * Invalid or unsupported options, for example + * - unsupported filter(s) or filter options; or + * - reserved bits set in headers (decoder only). + * + * Rebuilding liblzma with more features enabled, or + * upgrading to a newer version of liblzma may help. + */ + + LZMA_DATA_ERROR = 9, + /**< + * \brief Data is corrupt + * + * The usage of this return value is different in encoders + * and decoders. In both encoder and decoder, the coding + * cannot continue after this error. + * + * Encoders return this if size limits of the target file + * format would be exceeded. These limits are huge, thus + * getting this error from an encoder is mostly theoretical. + * For example, the maximum compressed and uncompressed + * size of a .xz Stream is roughly 8 EiB (2^63 bytes). + * + * Decoders return this error if the input data is corrupt. + * This can mean, for example, invalid CRC32 in headers + * or invalid check of uncompressed data. + */ + + LZMA_BUF_ERROR = 10, + /**< + * \brief No progress is possible + * + * This error code is returned when the coder cannot consume + * any new input and produce any new output. The most common + * reason for this error is that the input stream being + * decoded is truncated or corrupt. + * + * This error is not fatal. Coding can be continued normally + * by providing more input and/or more output space, if + * possible. + * + * Typically the first call to lzma_code() that can do no + * progress returns LZMA_OK instead of LZMA_BUF_ERROR. Only + * the second consecutive call doing no progress will return + * LZMA_BUF_ERROR. This is intentional. + * + * With zlib, Z_BUF_ERROR may be returned even if the + * application is doing nothing wrong, so apps will need + * to handle Z_BUF_ERROR specially. The above hack + * guarantees that liblzma never returns LZMA_BUF_ERROR + * to properly written applications unless the input file + * is truncated or corrupt. This should simplify the + * applications a little. + */ + + LZMA_PROG_ERROR = 11, + /**< + * \brief Programming error + * + * This indicates that the arguments given to the function are + * invalid or the internal state of the decoder is corrupt. + * - Function arguments are invalid or the structures + * pointed by the argument pointers are invalid + * e.g. if strm->next_out has been set to NULL and + * strm->avail_out > 0 when calling lzma_code(). + * - lzma_* functions have been called in wrong order + * e.g. lzma_code() was called right after lzma_end(). + * - If errors occur randomly, the reason might be flaky + * hardware. + * + * If you think that your code is correct, this error code + * can be a sign of a bug in liblzma. See the documentation + * how to report bugs. + */ + + LZMA_SEEK_NEEDED = 12, + /**< + * \brief Request to change the input file position + * + * Some coders can do random access in the input file. The + * initialization functions of these coders take the file size + * as an argument. No other coders can return LZMA_SEEK_NEEDED. + * + * When this value is returned, the application must seek to + * the file position given in lzma_stream.seek_pos. This value + * is guaranteed to never exceed the file size that was + * specified at the coder initialization. + * + * After seeking the application should read new input and + * pass it normally via lzma_stream.next_in and .avail_in. + */ + + /* + * These enumerations may be used internally by liblzma + * but they will never be returned to applications. + */ + LZMA_RET_INTERNAL1 = 101, + LZMA_RET_INTERNAL2 = 102, + LZMA_RET_INTERNAL3 = 103, + LZMA_RET_INTERNAL4 = 104, + LZMA_RET_INTERNAL5 = 105, + LZMA_RET_INTERNAL6 = 106, + LZMA_RET_INTERNAL7 = 107, + LZMA_RET_INTERNAL8 = 108 +} lzma_ret; + + +/** + * \brief The 'action' argument for lzma_code() + * + * After the first use of LZMA_SYNC_FLUSH, LZMA_FULL_FLUSH, LZMA_FULL_BARRIER, + * or LZMA_FINISH, the same 'action' must be used until lzma_code() returns + * LZMA_STREAM_END. Also, the amount of input (that is, strm->avail_in) must + * not be modified by the application until lzma_code() returns + * LZMA_STREAM_END. Changing the 'action' or modifying the amount of input + * will make lzma_code() return LZMA_PROG_ERROR. + */ +typedef enum { + LZMA_RUN = 0, + /**< + * \brief Continue coding + * + * Encoder: Encode as much input as possible. Some internal + * buffering will probably be done (depends on the filter + * chain in use), which causes latency: the input used won't + * usually be decodeable from the output of the same + * lzma_code() call. + * + * Decoder: Decode as much input as possible and produce as + * much output as possible. + */ + + LZMA_SYNC_FLUSH = 1, + /**< + * \brief Make all the input available at output + * + * Normally the encoder introduces some latency. + * LZMA_SYNC_FLUSH forces all the buffered data to be + * available at output without resetting the internal + * state of the encoder. This way it is possible to use + * compressed stream for example for communication over + * network. + * + * Only some filters support LZMA_SYNC_FLUSH. Trying to use + * LZMA_SYNC_FLUSH with filters that don't support it will + * make lzma_code() return LZMA_OPTIONS_ERROR. For example, + * LZMA1 doesn't support LZMA_SYNC_FLUSH but LZMA2 does. + * + * Using LZMA_SYNC_FLUSH very often can dramatically reduce + * the compression ratio. With some filters (for example, + * LZMA2), fine-tuning the compression options may help + * mitigate this problem significantly (for example, + * match finder with LZMA2). + * + * Decoders don't support LZMA_SYNC_FLUSH. + */ + + LZMA_FULL_FLUSH = 2, + /**< + * \brief Finish encoding of the current Block + * + * All the input data going to the current Block must have + * been given to the encoder (the last bytes can still be + * pending in *next_in). Call lzma_code() with LZMA_FULL_FLUSH + * until it returns LZMA_STREAM_END. Then continue normally + * with LZMA_RUN or finish the Stream with LZMA_FINISH. + * + * This action is currently supported only by Stream encoder + * and easy encoder (which uses Stream encoder). If there is + * no unfinished Block, no empty Block is created. + */ + + LZMA_FULL_BARRIER = 4, + /**< + * \brief Finish encoding of the current Block + * + * This is like LZMA_FULL_FLUSH except that this doesn't + * necessarily wait until all the input has been made + * available via the output buffer. That is, lzma_code() + * might return LZMA_STREAM_END as soon as all the input + * has been consumed (avail_in == 0). + * + * LZMA_FULL_BARRIER is useful with a threaded encoder if + * one wants to split the .xz Stream into Blocks at specific + * offsets but doesn't care if the output isn't flushed + * immediately. Using LZMA_FULL_BARRIER allows keeping + * the threads busy while LZMA_FULL_FLUSH would make + * lzma_code() wait until all the threads have finished + * until more data could be passed to the encoder. + * + * With a lzma_stream initialized with the single-threaded + * lzma_stream_encoder() or lzma_easy_encoder(), + * LZMA_FULL_BARRIER is an alias for LZMA_FULL_FLUSH. + */ + + LZMA_FINISH = 3 + /**< + * \brief Finish the coding operation + * + * All the input data must have been given to the encoder + * (the last bytes can still be pending in next_in). + * Call lzma_code() with LZMA_FINISH until it returns + * LZMA_STREAM_END. Once LZMA_FINISH has been used, + * the amount of input must no longer be changed by + * the application. + * + * When decoding, using LZMA_FINISH is optional unless the + * LZMA_CONCATENATED flag was used when the decoder was + * initialized. When LZMA_CONCATENATED was not used, the only + * effect of LZMA_FINISH is that the amount of input must not + * be changed just like in the encoder. + */ +} lzma_action; + + +/** + * \brief Custom functions for memory handling + * + * A pointer to lzma_allocator may be passed via lzma_stream structure + * to liblzma, and some advanced functions take a pointer to lzma_allocator + * as a separate function argument. The library will use the functions + * specified in lzma_allocator for memory handling instead of the default + * malloc() and free(). C++ users should note that the custom memory + * handling functions must not throw exceptions. + * + * Single-threaded mode only: liblzma doesn't make an internal copy of + * lzma_allocator. Thus, it is OK to change these function pointers in + * the middle of the coding process, but obviously it must be done + * carefully to make sure that the replacement 'free' can deallocate + * memory allocated by the earlier 'alloc' function(s). + * + * Multithreaded mode: liblzma might internally store pointers to the + * lzma_allocator given via the lzma_stream structure. The application + * must not change the allocator pointer in lzma_stream or the contents + * of the pointed lzma_allocator structure until lzma_end() has been used + * to free the memory associated with that lzma_stream. The allocation + * functions might be called simultaneously from multiple threads, and + * thus they must be thread safe. + */ +typedef struct { + /** + * \brief Pointer to a custom memory allocation function + * + * If you don't want a custom allocator, but still want + * custom free(), set this to NULL and liblzma will use + * the standard malloc(). + * + * \param opaque lzma_allocator.opaque (see below) + * \param nmemb Number of elements like in calloc(). liblzma + * will always set nmemb to 1, so it is safe to + * ignore nmemb in a custom allocator if you like. + * The nmemb argument exists only for + * compatibility with zlib and libbzip2. + * \param size Size of an element in bytes. + * liblzma never sets this to zero. + * + * \return Pointer to the beginning of a memory block of + * 'size' bytes, or NULL if allocation fails + * for some reason. When allocation fails, functions + * of liblzma return LZMA_MEM_ERROR. + * + * The allocator should not waste time zeroing the allocated buffers. + * This is not only about speed, but also memory usage, since the + * operating system kernel doesn't necessarily allocate the requested + * memory in physical memory until it is actually used. With small + * input files, liblzma may actually need only a fraction of the + * memory that it requested for allocation. + * + * \note LZMA_MEM_ERROR is also used when the size of the + * allocation would be greater than SIZE_MAX. Thus, + * don't assume that the custom allocator must have + * returned NULL if some function from liblzma + * returns LZMA_MEM_ERROR. + */ + void *(LZMA_API_CALL *alloc)(void *opaque, size_t nmemb, size_t size); + + /** + * \brief Pointer to a custom memory freeing function + * + * If you don't want a custom freeing function, but still + * want a custom allocator, set this to NULL and liblzma + * will use the standard free(). + * + * \param opaque lzma_allocator.opaque (see below) + * \param ptr Pointer returned by lzma_allocator.alloc(), + * or when it is set to NULL, a pointer returned + * by the standard malloc(). In addition, NULL + * is a possible value. The function should do + * nothing when ptr == NULL. + */ + void (LZMA_API_CALL *free)(void *opaque, void *ptr); + + /** + * \brief Pointer passed to .alloc() and .free() + * + * opaque is passed as the first argument to lzma_allocator.alloc() + * and lzma_allocator.free(). This intended to ease implementing + * custom memory allocation functions for use with liblzma. + * + * If you don't need this, you should set this to NULL. + */ + void *opaque; + +} lzma_allocator; + + +/** + * \brief Internal data structure + * + * The contents of this structure is not visible outside the library. + */ +typedef struct lzma_internal_s lzma_internal; + + +/** + * \brief Passing data to and from liblzma + * + * The lzma_stream structure is used for + * - passing pointers to input and output buffers to liblzma; + * - defining custom memory handler functions; and + * - holding a pointer to coder-specific internal data structures. + * + * Typical usage: + * + * - After allocating lzma_stream (on stack or with malloc()), it must be + * initialized to LZMA_STREAM_INIT (see LZMA_STREAM_INIT for details). + * + * - Initialize a coder to the lzma_stream, for example by using + * lzma_easy_encoder() or lzma_auto_decoder(). Some notes: + * - In contrast to zlib, strm->next_in and strm->next_out are + * ignored by all initialization functions, thus it is safe + * to not initialize them yet. + * - The initialization functions always set strm->total_in and + * strm->total_out to zero. + * - If the initialization function fails, no memory is left allocated + * that would require freeing with lzma_end() even if some memory was + * associated with the lzma_stream structure when the initialization + * function was called. + * + * - Use lzma_code() to do the actual work. + * + * - Once the coding has been finished, the existing lzma_stream can be + * reused. It is OK to reuse lzma_stream with different initialization + * function without calling lzma_end() first. Old allocations are + * automatically freed. + * + * - Finally, use lzma_end() to free the allocated memory. lzma_end() never + * frees the lzma_stream structure itself. + * + * Application may modify the values of total_in and total_out as it wants. + * They are updated by liblzma to match the amount of data read and + * written but aren't used for anything else except as a possible return + * values from lzma_get_progress(). + */ +typedef struct { + const uint8_t *next_in; /**< Pointer to the next input byte. */ + size_t avail_in; /**< Number of available input bytes in next_in. */ + uint64_t total_in; /**< Total number of bytes read by liblzma. */ + + uint8_t *next_out; /**< Pointer to the next output position. */ + size_t avail_out; /**< Amount of free space in next_out. */ + uint64_t total_out; /**< Total number of bytes written by liblzma. */ + + /** + * \brief Custom memory allocation functions + * + * In most cases this is NULL which makes liblzma use + * the standard malloc() and free(). + * + * \note In 5.0.x this is not a const pointer. + */ + const lzma_allocator *allocator; + + /** Internal state is not visible to applications. */ + lzma_internal *internal; + + /* + * Reserved space to allow possible future extensions without + * breaking the ABI. Excluding the initialization of this structure, + * you should not touch these, because the names of these variables + * may change. + */ + + /** \private Reserved member. */ + void *reserved_ptr1; + + /** \private Reserved member. */ + void *reserved_ptr2; + + /** \private Reserved member. */ + void *reserved_ptr3; + + /** \private Reserved member. */ + void *reserved_ptr4; + + /** + * \brief New seek input position for LZMA_SEEK_NEEDED + * + * When lzma_code() returns LZMA_SEEK_NEEDED, the new input position + * needed by liblzma will be available in seek_pos. The value is + * guaranteed to not exceed the file size that was specified when + * this lzma_stream was initialized. + * + * In all other situations the value of this variable is undefined. + */ + uint64_t seek_pos; + + /** \private Reserved member. */ + uint64_t reserved_int2; + + /** \private Reserved member. */ + size_t reserved_int3; + + /** \private Reserved member. */ + size_t reserved_int4; + + /** \private Reserved member. */ + lzma_reserved_enum reserved_enum1; + + /** \private Reserved member. */ + lzma_reserved_enum reserved_enum2; + +} lzma_stream; + + +/** + * \brief Initialization for lzma_stream + * + * When you declare an instance of lzma_stream, you can immediately + * initialize it so that initialization functions know that no memory + * has been allocated yet: + * + * lzma_stream strm = LZMA_STREAM_INIT; + * + * If you need to initialize a dynamically allocated lzma_stream, you can use + * memset(strm_pointer, 0, sizeof(lzma_stream)). Strictly speaking, this + * violates the C standard since NULL may have different internal + * representation than zero, but it should be portable enough in practice. + * Anyway, for maximum portability, you can use something like this: + * + * lzma_stream tmp = LZMA_STREAM_INIT; + * *strm = tmp; + */ +#define LZMA_STREAM_INIT \ + { NULL, 0, 0, NULL, 0, 0, NULL, NULL, \ + NULL, NULL, NULL, NULL, 0, 0, 0, 0, \ + LZMA_RESERVED_ENUM, LZMA_RESERVED_ENUM } + + +/** + * \brief Encode or decode data + * + * Once the lzma_stream has been successfully initialized (e.g. with + * lzma_stream_encoder()), the actual encoding or decoding is done + * using this function. The application has to update strm->next_in, + * strm->avail_in, strm->next_out, and strm->avail_out to pass input + * to and get output from liblzma. + * + * See the description of the coder-specific initialization function to find + * out what 'action' values are supported by the coder. + * + * \param strm Pointer to lzma_stream that is at least initialized + * with LZMA_STREAM_INIT. + * \param action Action for this function to take. Must be a valid + * lzma_action enum value. + * + * \return Any valid lzma_ret. See the lzma_ret enum description for more + * information. + */ +extern LZMA_API(lzma_ret) lzma_code(lzma_stream *strm, lzma_action action) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Free memory allocated for the coder data structures + * + * After lzma_end(strm), strm->internal is guaranteed to be NULL. No other + * members of the lzma_stream structure are touched. + * + * \note zlib indicates an error if application end()s unfinished + * stream structure. liblzma doesn't do this, and assumes that + * application knows what it is doing. + * + * \param strm Pointer to lzma_stream that is at least initialized + * with LZMA_STREAM_INIT. + */ +extern LZMA_API(void) lzma_end(lzma_stream *strm) lzma_nothrow; + + +/** + * \brief Get progress information + * + * In single-threaded mode, applications can get progress information from + * strm->total_in and strm->total_out. In multi-threaded mode this is less + * useful because a significant amount of both input and output data gets + * buffered internally by liblzma. This makes total_in and total_out give + * misleading information and also makes the progress indicator updates + * non-smooth. + * + * This function gives realistic progress information also in multi-threaded + * mode by taking into account the progress made by each thread. In + * single-threaded mode *progress_in and *progress_out are set to + * strm->total_in and strm->total_out, respectively. + * + * \param strm Pointer to lzma_stream that is at least + * initialized with LZMA_STREAM_INIT. + * \param[out] progress_in Pointer to the number of input bytes processed. + * \param[out] progress_out Pointer to the number of output bytes processed. + */ +extern LZMA_API(void) lzma_get_progress(lzma_stream *strm, + uint64_t *progress_in, uint64_t *progress_out) lzma_nothrow; + + +/** + * \brief Get the memory usage of decoder filter chain + * + * This function is currently supported only when *strm has been initialized + * with a function that takes a memlimit argument. With other functions, you + * should use e.g. lzma_raw_encoder_memusage() or lzma_raw_decoder_memusage() + * to estimate the memory requirements. + * + * This function is useful e.g. after LZMA_MEMLIMIT_ERROR to find out how big + * the memory usage limit should have been to decode the input. Note that + * this may give misleading information if decoding .xz Streams that have + * multiple Blocks, because each Block can have different memory requirements. + * + * \param strm Pointer to lzma_stream that is at least initialized + * with LZMA_STREAM_INIT. + * + * \return How much memory is currently allocated for the filter + * decoders. If no filter chain is currently allocated, + * some non-zero value is still returned, which is less than + * or equal to what any filter chain would indicate as its + * memory requirement. + * + * If this function isn't supported by *strm or some other error + * occurs, zero is returned. + */ +extern LZMA_API(uint64_t) lzma_memusage(const lzma_stream *strm) + lzma_nothrow lzma_attr_pure; + + +/** + * \brief Get the current memory usage limit + * + * This function is supported only when *strm has been initialized with + * a function that takes a memlimit argument. + * + * \param strm Pointer to lzma_stream that is at least initialized + * with LZMA_STREAM_INIT. + * + * \return On success, the current memory usage limit is returned + * (always non-zero). On error, zero is returned. + */ +extern LZMA_API(uint64_t) lzma_memlimit_get(const lzma_stream *strm) + lzma_nothrow lzma_attr_pure; + + +/** + * \brief Set the memory usage limit + * + * This function is supported only when *strm has been initialized with + * a function that takes a memlimit argument. + * + * liblzma 5.2.3 and earlier has a bug where memlimit value of 0 causes + * this function to do nothing (leaving the limit unchanged) and still + * return LZMA_OK. Later versions treat 0 as if 1 had been specified (so + * lzma_memlimit_get() will return 1 even if you specify 0 here). + * + * liblzma 5.2.6 and earlier had a bug in single-threaded .xz decoder + * (lzma_stream_decoder()) which made it impossible to continue decoding + * after LZMA_MEMLIMIT_ERROR even if the limit was increased using + * lzma_memlimit_set(). Other decoders worked correctly. + * + * \return Possible lzma_ret values: + * - LZMA_OK: New memory usage limit successfully set. + * - LZMA_MEMLIMIT_ERROR: The new limit is too small. + * The limit was not changed. + * - LZMA_PROG_ERROR: Invalid arguments, e.g. *strm doesn't + * support memory usage limit. + */ +extern LZMA_API(lzma_ret) lzma_memlimit_set( + lzma_stream *strm, uint64_t memlimit) lzma_nothrow; diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/bcj.h b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/bcj.h new file mode 100644 index 0000000000000000000000000000000000000000..fb737cbba49c7c0c15b28651124bfe2af9efc43e --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/bcj.h @@ -0,0 +1,195 @@ +/* SPDX-License-Identifier: 0BSD */ + +/** + * \file lzma/bcj.h + * \brief Branch/Call/Jump conversion filters + * \note Never include this file directly. Use instead. + */ + +/* + * Author: Lasse Collin + */ + +#ifndef LZMA_H_INTERNAL +# error Never include this file directly. Use instead. +#endif + + +/* Filter IDs for lzma_filter.id */ + +/** + * \brief Filter for x86 binaries + */ +#define LZMA_FILTER_X86 LZMA_VLI_C(0x04) + +/** + * \brief Filter for Big endian PowerPC binaries + */ +#define LZMA_FILTER_POWERPC LZMA_VLI_C(0x05) + +/** + * \brief Filter for IA-64 (Itanium) binaries + */ +#define LZMA_FILTER_IA64 LZMA_VLI_C(0x06) + +/** + * \brief Filter for ARM binaries + */ +#define LZMA_FILTER_ARM LZMA_VLI_C(0x07) + +/** + * \brief Filter for ARM-Thumb binaries + */ +#define LZMA_FILTER_ARMTHUMB LZMA_VLI_C(0x08) + +/** + * \brief Filter for SPARC binaries + */ +#define LZMA_FILTER_SPARC LZMA_VLI_C(0x09) + +/** + * \brief Filter for ARM64 binaries + */ +#define LZMA_FILTER_ARM64 LZMA_VLI_C(0x0A) + +/** + * \brief Filter for RISC-V binaries + */ +#define LZMA_FILTER_RISCV LZMA_VLI_C(0x0B) + + +/** + * \brief Options for BCJ filters + * + * The BCJ filters never change the size of the data. Specifying options + * for them is optional: if pointer to options is NULL, default value is + * used. You probably never need to specify options to BCJ filters, so just + * set the options pointer to NULL and be happy. + * + * If options with non-default values have been specified when encoding, + * the same options must also be specified when decoding. + * + * \note At the moment, none of the BCJ filters support + * LZMA_SYNC_FLUSH. If LZMA_SYNC_FLUSH is specified, + * LZMA_OPTIONS_ERROR will be returned. If there is need, + * partial support for LZMA_SYNC_FLUSH can be added in future. + * Partial means that flushing would be possible only at + * offsets that are multiple of 2, 4, or 16 depending on + * the filter, except x86 which cannot be made to support + * LZMA_SYNC_FLUSH predictably. + */ +typedef struct { + /** + * \brief Start offset for conversions + * + * This setting is useful only when the same filter is used + * _separately_ for multiple sections of the same executable file, + * and the sections contain cross-section branch/call/jump + * instructions. In that case it is beneficial to set the start + * offset of the non-first sections so that the relative addresses + * of the cross-section branch/call/jump instructions will use the + * same absolute addresses as in the first section. + * + * When the pointer to options is NULL, the default value (zero) + * is used. + */ + uint32_t start_offset; + +} lzma_options_bcj; + + +/** + * \brief Raw ARM64 BCJ encoder + * + * This is for special use cases only. + * + * \param start_offset The lowest 32 bits of the offset in the + * executable being filtered. For the ARM64 + * filter, this must be a multiple of four. + * For the very best results, this should also + * be in sync with 4096-byte page boundaries + * in the executable due to how ARM64's ADRP + * instruction works. + * \param buf Buffer to be filtered in place + * \param size Size of the buffer + * + * \return Number of bytes that were processed in `buf`. This is at most + * `size`. With the ARM64 filter, the return value is always + * a multiple of 4, and at most 3 bytes are left unfiltered. + * + * \since 5.7.1alpha + */ +extern LZMA_API(size_t) lzma_bcj_arm64_encode( + uint32_t start_offset, uint8_t *buf, size_t size) lzma_nothrow; + +/** + * \brief Raw ARM64 BCJ decoder + * + * See lzma_bcj_arm64_encode(). + * + * \since 5.7.1alpha + */ +extern LZMA_API(size_t) lzma_bcj_arm64_decode( + uint32_t start_offset, uint8_t *buf, size_t size) lzma_nothrow; + + +/** + * \brief Raw RISC-V BCJ encoder + * + * This is for special use cases only. + * + * \param start_offset The lowest 32 bits of the offset in the + * executable being filtered. For the RISC-V + * filter, this must be a multiple of 2. + * \param buf Buffer to be filtered in place + * \param size Size of the buffer + * + * \return Number of bytes that were processed in `buf`. This is at most + * `size`. With the RISC-V filter, the return value is always + * a multiple of 2, and at most 7 bytes are left unfiltered. + * + * \since 5.7.1alpha + */ +extern LZMA_API(size_t) lzma_bcj_riscv_encode( + uint32_t start_offset, uint8_t *buf, size_t size) lzma_nothrow; + +/** + * \brief Raw RISC-V BCJ decoder + * + * See lzma_bcj_riscv_encode(). + * + * \since 5.7.1alpha + */ +extern LZMA_API(size_t) lzma_bcj_riscv_decode( + uint32_t start_offset, uint8_t *buf, size_t size) lzma_nothrow; + + +/** + * \brief Raw x86 BCJ encoder + * + * This is for special use cases only. + * + * \param start_offset The lowest 32 bits of the offset in the + * executable being filtered. For the x86 + * filter, all values are valid. + * \param buf Buffer to be filtered in place + * \param size Size of the buffer + * + * \return Number of bytes that were processed in `buf`. This is at most + * `size`. For the x86 filter, the return value is always + * a multiple of 1, and at most 4 bytes are left unfiltered. + * + * \since 5.7.1alpha + */ +extern LZMA_API(size_t) lzma_bcj_x86_encode( + uint32_t start_offset, uint8_t *buf, size_t size) lzma_nothrow; + +/** + * \brief Raw x86 BCJ decoder + * + * See lzma_bcj_x86_encode(). + * + * \since 5.7.1alpha + */ +extern LZMA_API(size_t) lzma_bcj_x86_decode( + uint32_t start_offset, uint8_t *buf, size_t size) lzma_nothrow; diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/block.h b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/block.h new file mode 100644 index 0000000000000000000000000000000000000000..05b77e59aabbbd515ab0033cebfe9fea02c069da --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/block.h @@ -0,0 +1,694 @@ +/* SPDX-License-Identifier: 0BSD */ + +/** + * \file lzma/block.h + * \brief .xz Block handling + * \note Never include this file directly. Use instead. + */ + +/* + * Author: Lasse Collin + */ + +#ifndef LZMA_H_INTERNAL +# error Never include this file directly. Use instead. +#endif + + +/** + * \brief Options for the Block and Block Header encoders and decoders + * + * Different Block handling functions use different parts of this structure. + * Some read some members, other functions write, and some do both. Only the + * members listed for reading need to be initialized when the specified + * functions are called. The members marked for writing will be assigned + * new values at some point either by calling the given function or by + * later calls to lzma_code(). + */ +typedef struct { + /** + * \brief Block format version + * + * To prevent API and ABI breakages when new features are needed, + * a version number is used to indicate which members in this + * structure are in use: + * - liblzma >= 5.0.0: version = 0 is supported. + * - liblzma >= 5.1.4beta: Support for version = 1 was added, + * which adds the ignore_check member. + * + * If version is greater than one, most Block related functions + * will return LZMA_OPTIONS_ERROR (lzma_block_header_decode() works + * with any version value). + * + * Read by: + * - lzma_block_header_size() + * - lzma_block_header_encode() + * - lzma_block_header_decode() + * - lzma_block_compressed_size() + * - lzma_block_unpadded_size() + * - lzma_block_total_size() + * - lzma_block_encoder() + * - lzma_block_decoder() + * - lzma_block_buffer_encode() + * - lzma_block_uncomp_encode() + * - lzma_block_buffer_decode() + * + * Written by: + * - lzma_block_header_decode() + */ + uint32_t version; + + /** + * \brief Size of the Block Header field in bytes + * + * This is always a multiple of four. + * + * Read by: + * - lzma_block_header_encode() + * - lzma_block_header_decode() + * - lzma_block_compressed_size() + * - lzma_block_unpadded_size() + * - lzma_block_total_size() + * - lzma_block_decoder() + * - lzma_block_buffer_decode() + * + * Written by: + * - lzma_block_header_size() + * - lzma_block_buffer_encode() + * - lzma_block_uncomp_encode() + */ + uint32_t header_size; +# define LZMA_BLOCK_HEADER_SIZE_MIN 8 +# define LZMA_BLOCK_HEADER_SIZE_MAX 1024 + + /** + * \brief Type of integrity Check + * + * The Check ID is not stored into the Block Header, thus its value + * must be provided also when decoding. + * + * Read by: + * - lzma_block_header_encode() + * - lzma_block_header_decode() + * - lzma_block_compressed_size() + * - lzma_block_unpadded_size() + * - lzma_block_total_size() + * - lzma_block_encoder() + * - lzma_block_decoder() + * - lzma_block_buffer_encode() + * - lzma_block_buffer_decode() + */ + lzma_check check; + + /** + * \brief Size of the Compressed Data in bytes + * + * Encoding: If this is not LZMA_VLI_UNKNOWN, Block Header encoder + * will store this value to the Block Header. Block encoder doesn't + * care about this value, but will set it once the encoding has been + * finished. + * + * Decoding: If this is not LZMA_VLI_UNKNOWN, Block decoder will + * verify that the size of the Compressed Data field matches + * compressed_size. + * + * Usually you don't know this value when encoding in streamed mode, + * and thus cannot write this field into the Block Header. + * + * In non-streamed mode you can reserve space for this field before + * encoding the actual Block. After encoding the data, finish the + * Block by encoding the Block Header. Steps in detail: + * + * - Set compressed_size to some big enough value. If you don't know + * better, use LZMA_VLI_MAX, but remember that bigger values take + * more space in Block Header. + * + * - Call lzma_block_header_size() to see how much space you need to + * reserve for the Block Header. + * + * - Encode the Block using lzma_block_encoder() and lzma_code(). + * It sets compressed_size to the correct value. + * + * - Use lzma_block_header_encode() to encode the Block Header. + * Because space was reserved in the first step, you don't need + * to call lzma_block_header_size() anymore, because due to + * reserving, header_size has to be big enough. If it is "too big", + * lzma_block_header_encode() will add enough Header Padding to + * make Block Header to match the size specified by header_size. + * + * Read by: + * - lzma_block_header_size() + * - lzma_block_header_encode() + * - lzma_block_compressed_size() + * - lzma_block_unpadded_size() + * - lzma_block_total_size() + * - lzma_block_decoder() + * - lzma_block_buffer_decode() + * + * Written by: + * - lzma_block_header_decode() + * - lzma_block_compressed_size() + * - lzma_block_encoder() + * - lzma_block_decoder() + * - lzma_block_buffer_encode() + * - lzma_block_uncomp_encode() + * - lzma_block_buffer_decode() + */ + lzma_vli compressed_size; + + /** + * \brief Uncompressed Size in bytes + * + * This is handled very similarly to compressed_size above. + * + * uncompressed_size is needed by fewer functions than + * compressed_size. This is because uncompressed_size isn't + * needed to validate that Block stays within proper limits. + * + * Read by: + * - lzma_block_header_size() + * - lzma_block_header_encode() + * - lzma_block_decoder() + * - lzma_block_buffer_decode() + * + * Written by: + * - lzma_block_header_decode() + * - lzma_block_encoder() + * - lzma_block_decoder() + * - lzma_block_buffer_encode() + * - lzma_block_uncomp_encode() + * - lzma_block_buffer_decode() + */ + lzma_vli uncompressed_size; + + /** + * \brief Array of filters + * + * There can be 1-4 filters. The end of the array is marked with + * .id = LZMA_VLI_UNKNOWN. + * + * Read by: + * - lzma_block_header_size() + * - lzma_block_header_encode() + * - lzma_block_encoder() + * - lzma_block_decoder() + * - lzma_block_buffer_encode() + * - lzma_block_buffer_decode() + * + * Written by: + * - lzma_block_header_decode(): Note that this does NOT free() + * the old filter options structures. All unused filters[] will + * have .id == LZMA_VLI_UNKNOWN and .options == NULL. If + * decoding fails, all filters[] are guaranteed to be + * LZMA_VLI_UNKNOWN and NULL. + * + * \note Because of the array is terminated with + * .id = LZMA_VLI_UNKNOWN, the actual array must + * have LZMA_FILTERS_MAX + 1 members or the Block + * Header decoder will overflow the buffer. + */ + lzma_filter *filters; + + /** + * \brief Raw value stored in the Check field + * + * After successful coding, the first lzma_check_size(check) bytes + * of this array contain the raw value stored in the Check field. + * + * Note that CRC32 and CRC64 are stored in little endian byte order. + * Take it into account if you display the Check values to the user. + * + * Written by: + * - lzma_block_encoder() + * - lzma_block_decoder() + * - lzma_block_buffer_encode() + * - lzma_block_uncomp_encode() + * - lzma_block_buffer_decode() + */ + uint8_t raw_check[LZMA_CHECK_SIZE_MAX]; + + /* + * Reserved space to allow possible future extensions without + * breaking the ABI. You should not touch these, because the names + * of these variables may change. These are and will never be used + * with the currently supported options, so it is safe to leave these + * uninitialized. + */ + + /** \private Reserved member. */ + void *reserved_ptr1; + + /** \private Reserved member. */ + void *reserved_ptr2; + + /** \private Reserved member. */ + void *reserved_ptr3; + + /** \private Reserved member. */ + uint32_t reserved_int1; + + /** \private Reserved member. */ + uint32_t reserved_int2; + + /** \private Reserved member. */ + lzma_vli reserved_int3; + + /** \private Reserved member. */ + lzma_vli reserved_int4; + + /** \private Reserved member. */ + lzma_vli reserved_int5; + + /** \private Reserved member. */ + lzma_vli reserved_int6; + + /** \private Reserved member. */ + lzma_vli reserved_int7; + + /** \private Reserved member. */ + lzma_vli reserved_int8; + + /** \private Reserved member. */ + lzma_reserved_enum reserved_enum1; + + /** \private Reserved member. */ + lzma_reserved_enum reserved_enum2; + + /** \private Reserved member. */ + lzma_reserved_enum reserved_enum3; + + /** \private Reserved member. */ + lzma_reserved_enum reserved_enum4; + + /** + * \brief A flag to Block decoder to not verify the Check field + * + * This member is supported by liblzma >= 5.1.4beta if .version >= 1. + * + * If this is set to true, the integrity check won't be calculated + * and verified. Unless you know what you are doing, you should + * leave this to false. (A reason to set this to true is when the + * file integrity is verified externally anyway and you want to + * speed up the decompression, which matters mostly when using + * SHA-256 as the integrity check.) + * + * If .version >= 1, read by: + * - lzma_block_decoder() + * - lzma_block_buffer_decode() + * + * Written by (.version is ignored): + * - lzma_block_header_decode() always sets this to false + */ + lzma_bool ignore_check; + + /** \private Reserved member. */ + lzma_bool reserved_bool2; + + /** \private Reserved member. */ + lzma_bool reserved_bool3; + + /** \private Reserved member. */ + lzma_bool reserved_bool4; + + /** \private Reserved member. */ + lzma_bool reserved_bool5; + + /** \private Reserved member. */ + lzma_bool reserved_bool6; + + /** \private Reserved member. */ + lzma_bool reserved_bool7; + + /** \private Reserved member. */ + lzma_bool reserved_bool8; + +} lzma_block; + + +/** + * \brief Decode the Block Header Size field + * + * To decode Block Header using lzma_block_header_decode(), the size of the + * Block Header has to be known and stored into lzma_block.header_size. + * The size can be calculated from the first byte of a Block using this macro. + * Note that if the first byte is 0x00, it indicates beginning of Index; use + * this macro only when the byte is not 0x00. + * + * There is no encoding macro because lzma_block_header_size() and + * lzma_block_header_encode() should be used. + */ +#define lzma_block_header_size_decode(b) (((uint32_t)(b) + 1) * 4) + + +/** + * \brief Calculate Block Header Size + * + * Calculate the minimum size needed for the Block Header field using the + * settings specified in the lzma_block structure. Note that it is OK to + * increase the calculated header_size value as long as it is a multiple of + * four and doesn't exceed LZMA_BLOCK_HEADER_SIZE_MAX. Increasing header_size + * just means that lzma_block_header_encode() will add Header Padding. + * + * \note This doesn't check that all the options are valid i.e. this + * may return LZMA_OK even if lzma_block_header_encode() or + * lzma_block_encoder() would fail. If you want to validate the + * filter chain, consider using lzma_memlimit_encoder() which as + * a side-effect validates the filter chain. + * + * \param block Block options + * + * \return Possible lzma_ret values: + * - LZMA_OK: Size calculated successfully and stored to + * block->header_size. + * - LZMA_OPTIONS_ERROR: Unsupported version, filters or + * filter options. + * - LZMA_PROG_ERROR: Invalid values like compressed_size == 0. + */ +extern LZMA_API(lzma_ret) lzma_block_header_size(lzma_block *block) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Encode Block Header + * + * The caller must have calculated the size of the Block Header already with + * lzma_block_header_size(). If a value larger than the one calculated by + * lzma_block_header_size() is used, the Block Header will be padded to the + * specified size. + * + * \param block Block options to be encoded. + * \param[out] out Beginning of the output buffer. This must be + * at least block->header_size bytes. + * + * \return Possible lzma_ret values: + * - LZMA_OK: Encoding was successful. block->header_size + * bytes were written to output buffer. + * - LZMA_OPTIONS_ERROR: Invalid or unsupported options. + * - LZMA_PROG_ERROR: Invalid arguments, for example + * block->header_size is invalid or block->filters is NULL. + */ +extern LZMA_API(lzma_ret) lzma_block_header_encode( + const lzma_block *block, uint8_t *out) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Decode Block Header + * + * block->version should (usually) be set to the highest value supported + * by the application. If the application sets block->version to a value + * higher than supported by the current liblzma version, this function will + * downgrade block->version to the highest value supported by it. Thus one + * should check the value of block->version after calling this function if + * block->version was set to a non-zero value and the application doesn't + * otherwise know that the liblzma version being used is new enough to + * support the specified block->version. + * + * The size of the Block Header must have already been decoded with + * lzma_block_header_size_decode() macro and stored to block->header_size. + * + * The integrity check type from Stream Header must have been stored + * to block->check. + * + * block->filters must have been allocated, but they don't need to be + * initialized (possible existing filter options are not freed). + * + * \param[out] block Destination for Block options + * \param allocator lzma_allocator for custom allocator functions. + * Set to NULL to use malloc() (and also free() + * if an error occurs). + * \param in Beginning of the input buffer. This must be + * at least block->header_size bytes. + * + * \return Possible lzma_ret values: + * - LZMA_OK: Decoding was successful. block->header_size + * bytes were read from the input buffer. + * - LZMA_OPTIONS_ERROR: The Block Header specifies some + * unsupported options such as unsupported filters. This can + * happen also if block->version was set to a too low value + * compared to what would be required to properly represent + * the information stored in the Block Header. + * - LZMA_DATA_ERROR: Block Header is corrupt, for example, + * the CRC32 doesn't match. + * - LZMA_PROG_ERROR: Invalid arguments, for example + * block->header_size is invalid or block->filters is NULL. + */ +extern LZMA_API(lzma_ret) lzma_block_header_decode(lzma_block *block, + const lzma_allocator *allocator, const uint8_t *in) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Validate and set Compressed Size according to Unpadded Size + * + * Block Header stores Compressed Size, but Index has Unpadded Size. If the + * application has already parsed the Index and is now decoding Blocks, + * it can calculate Compressed Size from Unpadded Size. This function does + * exactly that with error checking: + * + * - Compressed Size calculated from Unpadded Size must be positive integer, + * that is, Unpadded Size must be big enough that after Block Header and + * Check fields there's still at least one byte for Compressed Size. + * + * - If Compressed Size was present in Block Header, the new value + * calculated from Unpadded Size is compared against the value + * from Block Header. + * + * \note This function must be called _after_ decoding the Block Header + * field so that it can properly validate Compressed Size if it + * was present in Block Header. + * + * \param block Block options: block->header_size must + * already be set with lzma_block_header_size(). + * \param unpadded_size Unpadded Size from the Index field in bytes + * + * \return Possible lzma_ret values: + * - LZMA_OK: block->compressed_size was set successfully. + * - LZMA_DATA_ERROR: unpadded_size is too small compared to + * block->header_size and lzma_check_size(block->check). + * - LZMA_PROG_ERROR: Some values are invalid. For example, + * block->header_size must be a multiple of four and + * between 8 and 1024 inclusive. + */ +extern LZMA_API(lzma_ret) lzma_block_compressed_size( + lzma_block *block, lzma_vli unpadded_size) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Calculate Unpadded Size + * + * The Index field stores Unpadded Size and Uncompressed Size. The latter + * can be taken directly from the lzma_block structure after coding a Block, + * but Unpadded Size needs to be calculated from Block Header Size, + * Compressed Size, and size of the Check field. This is where this function + * is needed. + * + * \param block Block options: block->header_size must already be + * set with lzma_block_header_size(). + * + * \return Unpadded Size on success, or zero on error. + */ +extern LZMA_API(lzma_vli) lzma_block_unpadded_size(const lzma_block *block) + lzma_nothrow lzma_attr_pure; + + +/** + * \brief Calculate the total encoded size of a Block + * + * This is equivalent to lzma_block_unpadded_size() except that the returned + * value includes the size of the Block Padding field. + * + * \param block Block options: block->header_size must already be + * set with lzma_block_header_size(). + * + * \return On success, total encoded size of the Block. On error, + * zero is returned. + */ +extern LZMA_API(lzma_vli) lzma_block_total_size(const lzma_block *block) + lzma_nothrow lzma_attr_pure; + + +/** + * \brief Initialize .xz Block encoder + * + * Valid actions for lzma_code() are LZMA_RUN, LZMA_SYNC_FLUSH (only if the + * filter chain supports it), and LZMA_FINISH. + * + * The Block encoder encodes the Block Data, Block Padding, and Check value. + * It does NOT encode the Block Header which can be encoded with + * lzma_block_header_encode(). + * + * \param strm Pointer to lzma_stream that is at least initialized + * with LZMA_STREAM_INIT. + * \param block Block options: block->version, block->check, + * and block->filters must have been initialized. + * + * \return Possible lzma_ret values: + * - LZMA_OK: All good, continue with lzma_code(). + * - LZMA_MEM_ERROR + * - LZMA_OPTIONS_ERROR + * - LZMA_UNSUPPORTED_CHECK: block->check specifies a Check ID + * that is not supported by this build of liblzma. Initializing + * the encoder failed. + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_block_encoder( + lzma_stream *strm, lzma_block *block) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Initialize .xz Block decoder + * + * Valid actions for lzma_code() are LZMA_RUN and LZMA_FINISH. Using + * LZMA_FINISH is not required. It is supported only for convenience. + * + * The Block decoder decodes the Block Data, Block Padding, and Check value. + * It does NOT decode the Block Header which can be decoded with + * lzma_block_header_decode(). + * + * \param strm Pointer to lzma_stream that is at least initialized + * with LZMA_STREAM_INIT. + * \param block Block options + * + * \return Possible lzma_ret values: + * - LZMA_OK: All good, continue with lzma_code(). + * - LZMA_PROG_ERROR + * - LZMA_MEM_ERROR + */ +extern LZMA_API(lzma_ret) lzma_block_decoder( + lzma_stream *strm, lzma_block *block) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Calculate maximum output size for single-call Block encoding + * + * This is equivalent to lzma_stream_buffer_bound() but for .xz Blocks. + * See the documentation of lzma_stream_buffer_bound(). + * + * \param uncompressed_size Size of the data to be encoded with the + * single-call Block encoder. + * + * \return Maximum output size in bytes for single-call Block encoding. + */ +extern LZMA_API(size_t) lzma_block_buffer_bound(size_t uncompressed_size) + lzma_nothrow; + + +/** + * \brief Single-call .xz Block encoder + * + * In contrast to the multi-call encoder initialized with + * lzma_block_encoder(), this function encodes also the Block Header. This + * is required to make it possible to write appropriate Block Header also + * in case the data isn't compressible, and different filter chain has to be + * used to encode the data in uncompressed form using uncompressed chunks + * of the LZMA2 filter. + * + * When the data isn't compressible, header_size, compressed_size, and + * uncompressed_size are set just like when the data was compressible, but + * it is possible that header_size is too small to hold the filter chain + * specified in block->filters, because that isn't necessarily the filter + * chain that was actually used to encode the data. lzma_block_unpadded_size() + * still works normally, because it doesn't read the filters array. + * + * \param block Block options: block->version, block->check, + * and block->filters must have been initialized. + * \param allocator lzma_allocator for custom allocator functions. + * Set to NULL to use malloc() and free(). + * \param in Beginning of the input buffer + * \param in_size Size of the input buffer + * \param[out] out Beginning of the output buffer + * \param[out] out_pos The next byte will be written to out[*out_pos]. + * *out_pos is updated only if encoding succeeds. + * \param out_size Size of the out buffer; the first byte into + * which no data is written to is out[out_size]. + * + * \return Possible lzma_ret values: + * - LZMA_OK: Encoding was successful. + * - LZMA_BUF_ERROR: Not enough output buffer space. + * - LZMA_UNSUPPORTED_CHECK + * - LZMA_OPTIONS_ERROR + * - LZMA_MEM_ERROR + * - LZMA_DATA_ERROR + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_block_buffer_encode( + lzma_block *block, const lzma_allocator *allocator, + const uint8_t *in, size_t in_size, + uint8_t *out, size_t *out_pos, size_t out_size) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Single-call uncompressed .xz Block encoder + * + * This is like lzma_block_buffer_encode() except this doesn't try to + * compress the data and instead encodes the data using LZMA2 uncompressed + * chunks. The required output buffer size can be determined with + * lzma_block_buffer_bound(). + * + * Since the data won't be compressed, this function ignores block->filters. + * This function doesn't take lzma_allocator because this function doesn't + * allocate any memory from the heap. + * + * \param block Block options: block->version, block->check, + * and block->filters must have been initialized. + * \param in Beginning of the input buffer + * \param in_size Size of the input buffer + * \param[out] out Beginning of the output buffer + * \param[out] out_pos The next byte will be written to out[*out_pos]. + * *out_pos is updated only if encoding succeeds. + * \param out_size Size of the out buffer; the first byte into + * which no data is written to is out[out_size]. + * + * \return Possible lzma_ret values: + * - LZMA_OK: Encoding was successful. + * - LZMA_BUF_ERROR: Not enough output buffer space. + * - LZMA_UNSUPPORTED_CHECK + * - LZMA_OPTIONS_ERROR + * - LZMA_MEM_ERROR + * - LZMA_DATA_ERROR + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_block_uncomp_encode(lzma_block *block, + const uint8_t *in, size_t in_size, + uint8_t *out, size_t *out_pos, size_t out_size) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Single-call .xz Block decoder + * + * This is single-call equivalent of lzma_block_decoder(), and requires that + * the caller has already decoded Block Header and checked its memory usage. + * + * \param block Block options + * \param allocator lzma_allocator for custom allocator functions. + * Set to NULL to use malloc() and free(). + * \param in Beginning of the input buffer + * \param in_pos The next byte will be read from in[*in_pos]. + * *in_pos is updated only if decoding succeeds. + * \param in_size Size of the input buffer; the first byte that + * won't be read is in[in_size]. + * \param[out] out Beginning of the output buffer + * \param[out] out_pos The next byte will be written to out[*out_pos]. + * *out_pos is updated only if encoding succeeds. + * \param out_size Size of the out buffer; the first byte into + * which no data is written to is out[out_size]. + * + * \return Possible lzma_ret values: + * - LZMA_OK: Decoding was successful. + * - LZMA_OPTIONS_ERROR + * - LZMA_DATA_ERROR + * - LZMA_MEM_ERROR + * - LZMA_BUF_ERROR: Output buffer was too small. + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_block_buffer_decode( + lzma_block *block, const lzma_allocator *allocator, + const uint8_t *in, size_t *in_pos, size_t in_size, + uint8_t *out, size_t *out_pos, size_t out_size) + lzma_nothrow; diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/check.h b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/check.h new file mode 100644 index 0000000000000000000000000000000000000000..e7a50ed3a3c3dc6c85049a62b35caa34c38d8ebd --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/check.h @@ -0,0 +1,163 @@ +/* SPDX-License-Identifier: 0BSD */ + +/** + * \file lzma/check.h + * \brief Integrity checks + * \note Never include this file directly. Use instead. + */ + +/* + * Author: Lasse Collin + */ + +#ifndef LZMA_H_INTERNAL +# error Never include this file directly. Use instead. +#endif + + +/** + * \brief Type of the integrity check (Check ID) + * + * The .xz format supports multiple types of checks that are calculated + * from the uncompressed data. They vary in both speed and ability to + * detect errors. + */ +typedef enum { + LZMA_CHECK_NONE = 0, + /**< + * No Check is calculated. + * + * Size of the Check field: 0 bytes + */ + + LZMA_CHECK_CRC32 = 1, + /**< + * CRC32 using the polynomial from the IEEE 802.3 standard + * + * Size of the Check field: 4 bytes + */ + + LZMA_CHECK_CRC64 = 4, + /**< + * CRC64 using the polynomial from the ECMA-182 standard + * + * Size of the Check field: 8 bytes + */ + + LZMA_CHECK_SHA256 = 10 + /**< + * SHA-256 + * + * Size of the Check field: 32 bytes + */ +} lzma_check; + + +/** + * \brief Maximum valid Check ID + * + * The .xz file format specification specifies 16 Check IDs (0-15). Some + * of them are only reserved, that is, no actual Check algorithm has been + * assigned. When decoding, liblzma still accepts unknown Check IDs for + * future compatibility. If a valid but unsupported Check ID is detected, + * liblzma can indicate a warning; see the flags LZMA_TELL_NO_CHECK, + * LZMA_TELL_UNSUPPORTED_CHECK, and LZMA_TELL_ANY_CHECK in container.h. + */ +#define LZMA_CHECK_ID_MAX 15 + + +/** + * \brief Test if the given Check ID is supported + * + * LZMA_CHECK_NONE and LZMA_CHECK_CRC32 are always supported (even if + * liblzma is built with limited features). + * + * \note It is safe to call this with a value that is not in the + * range [0, 15]; in that case the return value is always false. + * + * \param check Check ID + * + * \return lzma_bool: + * - true if Check ID is supported by this liblzma build. + * - false otherwise. + */ +extern LZMA_API(lzma_bool) lzma_check_is_supported(lzma_check check) + lzma_nothrow lzma_attr_const; + + +/** + * \brief Get the size of the Check field with the given Check ID + * + * Although not all Check IDs have a check algorithm associated, the size of + * every Check is already frozen. This function returns the size (in bytes) of + * the Check field with the specified Check ID. The values are: + * { 0, 4, 4, 4, 8, 8, 8, 16, 16, 16, 32, 32, 32, 64, 64, 64 } + * + * \param check Check ID + * + * \return Size of the Check field in bytes. If the argument is not in + * the range [0, 15], UINT32_MAX is returned. + */ +extern LZMA_API(uint32_t) lzma_check_size(lzma_check check) + lzma_nothrow lzma_attr_const; + + +/** + * \brief Maximum size of a Check field + */ +#define LZMA_CHECK_SIZE_MAX 64 + + +/** + * \brief Calculate CRC32 + * + * Calculate CRC32 using the polynomial from the IEEE 802.3 standard. + * + * \param buf Pointer to the input buffer + * \param size Size of the input buffer + * \param crc Previously returned CRC value. This is used to + * calculate the CRC of a big buffer in smaller chunks. + * Set to zero when starting a new calculation. + * + * \return Updated CRC value, which can be passed to this function + * again to continue CRC calculation. + */ +extern LZMA_API(uint32_t) lzma_crc32( + const uint8_t *buf, size_t size, uint32_t crc) + lzma_nothrow lzma_attr_pure; + + +/** + * \brief Calculate CRC64 + * + * Calculate CRC64 using the polynomial from the ECMA-182 standard. + * + * This function is used similarly to lzma_crc32(). + * + * \param buf Pointer to the input buffer + * \param size Size of the input buffer + * \param crc Previously returned CRC value. This is used to + * calculate the CRC of a big buffer in smaller chunks. + * Set to zero when starting a new calculation. + * + * \return Updated CRC value, which can be passed to this function + * again to continue CRC calculation. + */ +extern LZMA_API(uint64_t) lzma_crc64( + const uint8_t *buf, size_t size, uint64_t crc) + lzma_nothrow lzma_attr_pure; + + +/** + * \brief Get the type of the integrity check + * + * This function can be called only immediately after lzma_code() has + * returned LZMA_NO_CHECK, LZMA_UNSUPPORTED_CHECK, or LZMA_GET_CHECK. + * Calling this function in any other situation has undefined behavior. + * + * \param strm Pointer to lzma_stream meeting the above conditions. + * + * \return Check ID in the lzma_stream, or undefined if called improperly. + */ +extern LZMA_API(lzma_check) lzma_get_check(const lzma_stream *strm) + lzma_nothrow; diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/container.h b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/container.h new file mode 100644 index 0000000000000000000000000000000000000000..37d9ab92f4b52da5384ffd0b08fdf2a8a486f915 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/container.h @@ -0,0 +1,993 @@ +/* SPDX-License-Identifier: 0BSD */ + +/** + * \file lzma/container.h + * \brief File formats + * \note Never include this file directly. Use instead. + */ + +/* + * Author: Lasse Collin + */ + +#ifndef LZMA_H_INTERNAL +# error Never include this file directly. Use instead. +#endif + + +/************ + * Encoding * + ************/ + +/** + * \brief Default compression preset + * + * It's not straightforward to recommend a default preset, because in some + * cases keeping the resource usage relatively low is more important that + * getting the maximum compression ratio. + */ +#define LZMA_PRESET_DEFAULT UINT32_C(6) + + +/** + * \brief Mask for preset level + * + * This is useful only if you need to extract the level from the preset + * variable. That should be rare. + */ +#define LZMA_PRESET_LEVEL_MASK UINT32_C(0x1F) + + +/* + * Preset flags + * + * Currently only one flag is defined. + */ + +/** + * \brief Extreme compression preset + * + * This flag modifies the preset to make the encoding significantly slower + * while improving the compression ratio only marginally. This is useful + * when you don't mind spending time to get as small result as possible. + * + * This flag doesn't affect the memory usage requirements of the decoder (at + * least not significantly). The memory usage of the encoder may be increased + * a little but only at the lowest preset levels (0-3). + */ +#define LZMA_PRESET_EXTREME (UINT32_C(1) << 31) + + +/** + * \brief Multithreading options + */ +typedef struct { + /** + * \brief Flags + * + * Set this to zero if no flags are wanted. + * + * Encoder: No flags are currently supported. + * + * Decoder: Bitwise-or of zero or more of the decoder flags: + * - LZMA_TELL_NO_CHECK + * - LZMA_TELL_UNSUPPORTED_CHECK + * - LZMA_TELL_ANY_CHECK + * - LZMA_IGNORE_CHECK + * - LZMA_CONCATENATED + * - LZMA_FAIL_FAST + */ + uint32_t flags; + + /** + * \brief Number of worker threads to use + */ + uint32_t threads; + + /** + * \brief Encoder only: Maximum uncompressed size of a Block + * + * The encoder will start a new .xz Block every block_size bytes. + * Using LZMA_FULL_FLUSH or LZMA_FULL_BARRIER with lzma_code() + * the caller may tell liblzma to start a new Block earlier. + * + * With LZMA2, a recommended block size is 2-4 times the LZMA2 + * dictionary size. With very small dictionaries, it is recommended + * to use at least 1 MiB block size for good compression ratio, even + * if this is more than four times the dictionary size. Note that + * these are only recommendations for typical use cases; feel free + * to use other values. Just keep in mind that using a block size + * less than the LZMA2 dictionary size is waste of RAM. + * + * Set this to 0 to let liblzma choose the block size depending + * on the compression options. For LZMA2 it will be 3*dict_size + * or 1 MiB, whichever is more. + * + * For each thread, about 3 * block_size bytes of memory will be + * allocated. This may change in later liblzma versions. If so, + * the memory usage will probably be reduced, not increased. + */ + uint64_t block_size; + + /** + * \brief Timeout to allow lzma_code() to return early + * + * Multithreading can make liblzma consume input and produce + * output in a very bursty way: it may first read a lot of input + * to fill internal buffers, then no input or output occurs for + * a while. + * + * In single-threaded mode, lzma_code() won't return until it has + * either consumed all the input or filled the output buffer. If + * this is done in multithreaded mode, it may cause a call + * lzma_code() to take even tens of seconds, which isn't acceptable + * in all applications. + * + * To avoid very long blocking times in lzma_code(), a timeout + * (in milliseconds) may be set here. If lzma_code() would block + * longer than this number of milliseconds, it will return with + * LZMA_OK. Reasonable values are 100 ms or more. The xz command + * line tool uses 300 ms. + * + * If long blocking times are acceptable, set timeout to a special + * value of 0. This will disable the timeout mechanism and will make + * lzma_code() block until all the input is consumed or the output + * buffer has been filled. + * + * \note Even with a timeout, lzma_code() might sometimes take + * a long time to return. No timing guarantees are made. + */ + uint32_t timeout; + + /** + * \brief Encoder only: Compression preset + * + * The preset is set just like with lzma_easy_encoder(). + * The preset is ignored if filters below is non-NULL. + */ + uint32_t preset; + + /** + * \brief Encoder only: Filter chain (alternative to a preset) + * + * If this is NULL, the preset above is used. Otherwise the preset + * is ignored and the filter chain specified here is used. + */ + const lzma_filter *filters; + + /** + * \brief Encoder only: Integrity check type + * + * See check.h for available checks. The xz command line tool + * defaults to LZMA_CHECK_CRC64, which is a good choice if you + * are unsure. + */ + lzma_check check; + + /* + * Reserved space to allow possible future extensions without + * breaking the ABI. You should not touch these, because the names + * of these variables may change. These are and will never be used + * with the currently supported options, so it is safe to leave these + * uninitialized. + */ + /** \private Reserved member. */ + lzma_reserved_enum reserved_enum1; + + /** \private Reserved member. */ + lzma_reserved_enum reserved_enum2; + + /** \private Reserved member. */ + lzma_reserved_enum reserved_enum3; + + /** \private Reserved member. */ + uint32_t reserved_int1; + + /** \private Reserved member. */ + uint32_t reserved_int2; + + /** \private Reserved member. */ + uint32_t reserved_int3; + + /** \private Reserved member. */ + uint32_t reserved_int4; + + /** + * \brief Memory usage limit to reduce the number of threads + * + * Encoder: Ignored. + * + * Decoder: + * + * If the number of threads has been set so high that more than + * memlimit_threading bytes of memory would be needed, the number + * of threads will be reduced so that the memory usage will not exceed + * memlimit_threading bytes. However, if memlimit_threading cannot + * be met even in single-threaded mode, then decoding will continue + * in single-threaded mode and memlimit_threading may be exceeded + * even by a large amount. That is, memlimit_threading will never make + * lzma_code() return LZMA_MEMLIMIT_ERROR. To truly cap the memory + * usage, see memlimit_stop below. + * + * Setting memlimit_threading to UINT64_MAX or a similar huge value + * means that liblzma is allowed to keep the whole compressed file + * and the whole uncompressed file in memory in addition to the memory + * needed by the decompressor data structures used by each thread! + * In other words, a reasonable value limit must be set here or it + * will cause problems sooner or later. If you have no idea what + * a reasonable value could be, try lzma_physmem() / 4 as a starting + * point. Setting this limit will never prevent decompression of + * a file; this will only reduce the number of threads. + * + * If memlimit_threading is greater than memlimit_stop, then the value + * of memlimit_stop will be used for both. + */ + uint64_t memlimit_threading; + + /** + * \brief Memory usage limit that should never be exceeded + * + * Encoder: Ignored. + * + * Decoder: If decompressing will need more than this amount of + * memory even in the single-threaded mode, then lzma_code() will + * return LZMA_MEMLIMIT_ERROR. + */ + uint64_t memlimit_stop; + + /** \private Reserved member. */ + uint64_t reserved_int7; + + /** \private Reserved member. */ + uint64_t reserved_int8; + + /** \private Reserved member. */ + void *reserved_ptr1; + + /** \private Reserved member. */ + void *reserved_ptr2; + + /** \private Reserved member. */ + void *reserved_ptr3; + + /** \private Reserved member. */ + void *reserved_ptr4; + +} lzma_mt; + + +/** + * \brief Calculate approximate memory usage of easy encoder + * + * This function is a wrapper for lzma_raw_encoder_memusage(). + * + * \param preset Compression preset (level and possible flags) + * + * \return Number of bytes of memory required for the given + * preset when encoding or UINT64_MAX on error. + */ +extern LZMA_API(uint64_t) lzma_easy_encoder_memusage(uint32_t preset) + lzma_nothrow lzma_attr_pure; + + +/** + * \brief Calculate approximate decoder memory usage of a preset + * + * This function is a wrapper for lzma_raw_decoder_memusage(). + * + * \param preset Compression preset (level and possible flags) + * + * \return Number of bytes of memory required to decompress a file + * that was compressed using the given preset or UINT64_MAX + * on error. + */ +extern LZMA_API(uint64_t) lzma_easy_decoder_memusage(uint32_t preset) + lzma_nothrow lzma_attr_pure; + + +/** + * \brief Initialize .xz Stream encoder using a preset number + * + * This function is intended for those who just want to use the basic features + * of liblzma (that is, most developers out there). + * + * If initialization fails (return value is not LZMA_OK), all the memory + * allocated for *strm by liblzma is always freed. Thus, there is no need + * to call lzma_end() after failed initialization. + * + * If initialization succeeds, use lzma_code() to do the actual encoding. + * Valid values for 'action' (the second argument of lzma_code()) are + * LZMA_RUN, LZMA_SYNC_FLUSH, LZMA_FULL_FLUSH, and LZMA_FINISH. In future, + * there may be compression levels or flags that don't support LZMA_SYNC_FLUSH. + * + * \param strm Pointer to lzma_stream that is at least initialized + * with LZMA_STREAM_INIT. + * \param preset Compression preset to use. A preset consist of level + * number and zero or more flags. Usually flags aren't + * used, so preset is simply a number [0, 9] which match + * the options -0 ... -9 of the xz command line tool. + * Additional flags can be set using bitwise-or with + * the preset level number, e.g. 6 | LZMA_PRESET_EXTREME. + * \param check Integrity check type to use. See check.h for available + * checks. The xz command line tool defaults to + * LZMA_CHECK_CRC64, which is a good choice if you are + * unsure. LZMA_CHECK_CRC32 is good too as long as the + * uncompressed file is not many gigabytes. + * + * \return Possible lzma_ret values: + * - LZMA_OK: Initialization succeeded. Use lzma_code() to + * encode your data. + * - LZMA_MEM_ERROR: Memory allocation failed. + * - LZMA_OPTIONS_ERROR: The given compression preset is not + * supported by this build of liblzma. + * - LZMA_UNSUPPORTED_CHECK: The given check type is not + * supported by this liblzma build. + * - LZMA_PROG_ERROR: One or more of the parameters have values + * that will never be valid. For example, strm == NULL. + */ +extern LZMA_API(lzma_ret) lzma_easy_encoder( + lzma_stream *strm, uint32_t preset, lzma_check check) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Single-call .xz Stream encoding using a preset number + * + * The maximum required output buffer size can be calculated with + * lzma_stream_buffer_bound(). + * + * \param preset Compression preset to use. See the description + * in lzma_easy_encoder(). + * \param check Type of the integrity check to calculate from + * uncompressed data. + * \param allocator lzma_allocator for custom allocator functions. + * Set to NULL to use malloc() and free(). + * \param in Beginning of the input buffer + * \param in_size Size of the input buffer + * \param[out] out Beginning of the output buffer + * \param[out] out_pos The next byte will be written to out[*out_pos]. + * *out_pos is updated only if encoding succeeds. + * \param out_size Size of the out buffer; the first byte into + * which no data is written to is out[out_size]. + * + * \return Possible lzma_ret values: + * - LZMA_OK: Encoding was successful. + * - LZMA_BUF_ERROR: Not enough output buffer space. + * - LZMA_UNSUPPORTED_CHECK + * - LZMA_OPTIONS_ERROR + * - LZMA_MEM_ERROR + * - LZMA_DATA_ERROR + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_easy_buffer_encode( + uint32_t preset, lzma_check check, + const lzma_allocator *allocator, + const uint8_t *in, size_t in_size, + uint8_t *out, size_t *out_pos, size_t out_size) lzma_nothrow; + + +/** + * \brief Initialize .xz Stream encoder using a custom filter chain + * + * \param strm Pointer to lzma_stream that is at least initialized + * with LZMA_STREAM_INIT. + * \param filters Array of filters terminated with + * .id == LZMA_VLI_UNKNOWN. See filters.h for more + * information. + * \param check Type of the integrity check to calculate from + * uncompressed data. + * + * \return Possible lzma_ret values: + * - LZMA_OK: Initialization was successful. + * - LZMA_MEM_ERROR + * - LZMA_UNSUPPORTED_CHECK + * - LZMA_OPTIONS_ERROR + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_stream_encoder(lzma_stream *strm, + const lzma_filter *filters, lzma_check check) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Calculate approximate memory usage of multithreaded .xz encoder + * + * Since doing the encoding in threaded mode doesn't affect the memory + * requirements of single-threaded decompressor, you can use + * lzma_easy_decoder_memusage(options->preset) or + * lzma_raw_decoder_memusage(options->filters) to calculate + * the decompressor memory requirements. + * + * \param options Compression options + * + * \return Number of bytes of memory required for encoding with the + * given options. If an error occurs, for example due to + * unsupported preset or filter chain, UINT64_MAX is returned. + */ +extern LZMA_API(uint64_t) lzma_stream_encoder_mt_memusage( + const lzma_mt *options) lzma_nothrow lzma_attr_pure; + + +/** + * \brief Initialize multithreaded .xz Stream encoder + * + * This provides the functionality of lzma_easy_encoder() and + * lzma_stream_encoder() as a single function for multithreaded use. + * + * The supported actions for lzma_code() are LZMA_RUN, LZMA_FULL_FLUSH, + * LZMA_FULL_BARRIER, and LZMA_FINISH. Support for LZMA_SYNC_FLUSH might be + * added in the future. + * + * \param strm Pointer to lzma_stream that is at least initialized + * with LZMA_STREAM_INIT. + * \param options Pointer to multithreaded compression options + * + * \return Possible lzma_ret values: + * - LZMA_OK + * - LZMA_MEM_ERROR + * - LZMA_UNSUPPORTED_CHECK + * - LZMA_OPTIONS_ERROR + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_stream_encoder_mt( + lzma_stream *strm, const lzma_mt *options) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Calculate recommended Block size for multithreaded .xz encoder + * + * This calculates a recommended Block size for multithreaded encoding given + * a filter chain. This is used internally by lzma_stream_encoder_mt() to + * determine the Block size if the block_size member is not set to the + * special value of 0 in the lzma_mt options struct. + * + * If one wishes to change the filters between Blocks, this function is + * helpful to set the block_size member of the lzma_mt struct before calling + * lzma_stream_encoder_mt(). Since the block_size member represents the + * maximum possible Block size for the multithreaded .xz encoder, one can + * use this function to find the maximum recommended Block size based on + * all planned filter chains. Otherwise, the multithreaded encoder will + * base its maximum Block size on the first filter chain used (if the + * block_size member is not set), which may unnecessarily limit the Block + * size for a later filter chain. + * + * \param filters Array of filters terminated with + * .id == LZMA_VLI_UNKNOWN. + * + * \return Recommended Block size in bytes, or UINT64_MAX if + * an error occurred. + */ +extern LZMA_API(uint64_t) lzma_mt_block_size(const lzma_filter *filters) + lzma_nothrow; + + +/** + * \brief Initialize .lzma encoder (legacy file format) + * + * The .lzma format is sometimes called the LZMA_Alone format, which is the + * reason for the name of this function. The .lzma format supports only the + * LZMA1 filter. There is no support for integrity checks like CRC32. + * + * Use this function if and only if you need to create files readable by + * legacy LZMA tools such as LZMA Utils 4.32.x. Moving to the .xz format + * is strongly recommended. + * + * The valid action values for lzma_code() are LZMA_RUN and LZMA_FINISH. + * No kind of flushing is supported, because the file format doesn't make + * it possible. + * + * \param strm Pointer to lzma_stream that is at least initialized + * with LZMA_STREAM_INIT. + * \param options Pointer to encoder options + * + * \return Possible lzma_ret values: + * - LZMA_OK + * - LZMA_MEM_ERROR + * - LZMA_OPTIONS_ERROR + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_alone_encoder( + lzma_stream *strm, const lzma_options_lzma *options) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Calculate output buffer size for single-call Stream encoder + * + * When trying to compress incompressible data, the encoded size will be + * slightly bigger than the input data. This function calculates how much + * output buffer space is required to be sure that lzma_stream_buffer_encode() + * doesn't return LZMA_BUF_ERROR. + * + * The calculated value is not exact, but it is guaranteed to be big enough. + * The actual maximum output space required may be slightly smaller (up to + * about 100 bytes). This should not be a problem in practice. + * + * If the calculated maximum size doesn't fit into size_t or would make the + * Stream grow past LZMA_VLI_MAX (which should never happen in practice), + * zero is returned to indicate the error. + * + * \note The limit calculated by this function applies only to + * single-call encoding. Multi-call encoding may (and probably + * will) have larger maximum expansion when encoding + * incompressible data. Currently there is no function to + * calculate the maximum expansion of multi-call encoding. + * + * \param uncompressed_size Size in bytes of the uncompressed + * input data + * + * \return Maximum number of bytes needed to store the compressed data. + */ +extern LZMA_API(size_t) lzma_stream_buffer_bound(size_t uncompressed_size) + lzma_nothrow; + + +/** + * \brief Single-call .xz Stream encoder + * + * \param filters Array of filters terminated with + * .id == LZMA_VLI_UNKNOWN. See filters.h for more + * information. + * \param check Type of the integrity check to calculate from + * uncompressed data. + * \param allocator lzma_allocator for custom allocator functions. + * Set to NULL to use malloc() and free(). + * \param in Beginning of the input buffer + * \param in_size Size of the input buffer + * \param[out] out Beginning of the output buffer + * \param[out] out_pos The next byte will be written to out[*out_pos]. + * *out_pos is updated only if encoding succeeds. + * \param out_size Size of the out buffer; the first byte into + * which no data is written to is out[out_size]. + * + * \return Possible lzma_ret values: + * - LZMA_OK: Encoding was successful. + * - LZMA_BUF_ERROR: Not enough output buffer space. + * - LZMA_UNSUPPORTED_CHECK + * - LZMA_OPTIONS_ERROR + * - LZMA_MEM_ERROR + * - LZMA_DATA_ERROR + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_stream_buffer_encode( + lzma_filter *filters, lzma_check check, + const lzma_allocator *allocator, + const uint8_t *in, size_t in_size, + uint8_t *out, size_t *out_pos, size_t out_size) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief MicroLZMA encoder + * + * The MicroLZMA format is a raw LZMA stream whose first byte (always 0x00) + * has been replaced with bitwise-negation of the LZMA properties (lc/lp/pb). + * This encoding ensures that the first byte of MicroLZMA stream is never + * 0x00. There is no end of payload marker and thus the uncompressed size + * must be stored separately. For the best error detection the dictionary + * size should be stored separately as well but alternatively one may use + * the uncompressed size as the dictionary size when decoding. + * + * With the MicroLZMA encoder, lzma_code() behaves slightly unusually. + * The action argument must be LZMA_FINISH and the return value will never be + * LZMA_OK. Thus the encoding is always done with a single lzma_code() after + * the initialization. The benefit of the combination of initialization + * function and lzma_code() is that memory allocations can be reused for + * better performance. + * + * lzma_code() will try to encode as much input as is possible to fit into + * the given output buffer. If not all input can be encoded, the stream will + * be finished without encoding all the input. The caller must check both + * input and output buffer usage after lzma_code() (total_in and total_out + * in lzma_stream can be convenient). Often lzma_code() can fill the output + * buffer completely if there is a lot of input, but sometimes a few bytes + * may remain unused because the next LZMA symbol would require more space. + * + * lzma_stream.avail_out must be at least 6. Otherwise LZMA_PROG_ERROR + * will be returned. + * + * The LZMA dictionary should be reasonably low to speed up the encoder + * re-initialization. A good value is bigger than the resulting + * uncompressed size of most of the output chunks. For example, if output + * size is 4 KiB, dictionary size of 32 KiB or 64 KiB is good. If the + * data compresses extremely well, even 128 KiB may be useful. + * + * The MicroLZMA format and this encoder variant were made with the EROFS + * file system in mind. This format may be convenient in other embedded + * uses too where many small streams are needed. XZ Embedded includes a + * decoder for this format. + * + * \param strm Pointer to lzma_stream that is at least initialized + * with LZMA_STREAM_INIT. + * \param options Pointer to encoder options + * + * \return Possible lzma_ret values: + * - LZMA_STREAM_END: All good. Check the amounts of input used + * and output produced. Store the amount of input used + * (uncompressed size) as it needs to be known to decompress + * the data. + * - LZMA_OPTIONS_ERROR + * - LZMA_MEM_ERROR + * - LZMA_PROG_ERROR: In addition to the generic reasons for this + * error code, this may also be returned if there isn't enough + * output space (6 bytes) to create a valid MicroLZMA stream. + */ +extern LZMA_API(lzma_ret) lzma_microlzma_encoder( + lzma_stream *strm, const lzma_options_lzma *options) + lzma_nothrow; + + +/************ + * Decoding * + ************/ + +/** + * This flag makes lzma_code() return LZMA_NO_CHECK if the input stream + * being decoded has no integrity check. Note that when used with + * lzma_auto_decoder(), all .lzma files will trigger LZMA_NO_CHECK + * if LZMA_TELL_NO_CHECK is used. + */ +#define LZMA_TELL_NO_CHECK UINT32_C(0x01) + + +/** + * This flag makes lzma_code() return LZMA_UNSUPPORTED_CHECK if the input + * stream has an integrity check, but the type of the integrity check is not + * supported by this liblzma version or build. Such files can still be + * decoded, but the integrity check cannot be verified. + */ +#define LZMA_TELL_UNSUPPORTED_CHECK UINT32_C(0x02) + + +/** + * This flag makes lzma_code() return LZMA_GET_CHECK as soon as the type + * of the integrity check is known. The type can then be got with + * lzma_get_check(). + */ +#define LZMA_TELL_ANY_CHECK UINT32_C(0x04) + + +/** + * This flag makes lzma_code() not calculate and verify the integrity check + * of the compressed data in .xz files. This means that invalid integrity + * check values won't be detected and LZMA_DATA_ERROR won't be returned in + * such cases. + * + * This flag only affects the checks of the compressed data itself; the CRC32 + * values in the .xz headers will still be verified normally. + * + * Don't use this flag unless you know what you are doing. Possible reasons + * to use this flag: + * + * - Trying to recover data from a corrupt .xz file. + * + * - Speeding up decompression, which matters mostly with SHA-256 + * or with files that have compressed extremely well. It's recommended + * to not use this flag for this purpose unless the file integrity is + * verified externally in some other way. + * + * Support for this flag was added in liblzma 5.1.4beta. + */ +#define LZMA_IGNORE_CHECK UINT32_C(0x10) + + +/** + * This flag enables decoding of concatenated files with file formats that + * allow concatenating compressed files as is. From the formats currently + * supported by liblzma, only the .xz and .lz formats allow concatenated + * files. Concatenated files are not allowed with the legacy .lzma format. + * + * This flag also affects the usage of the 'action' argument for lzma_code(). + * When LZMA_CONCATENATED is used, lzma_code() won't return LZMA_STREAM_END + * unless LZMA_FINISH is used as 'action'. Thus, the application has to set + * LZMA_FINISH in the same way as it does when encoding. + * + * If LZMA_CONCATENATED is not used, the decoders still accept LZMA_FINISH + * as 'action' for lzma_code(), but the usage of LZMA_FINISH isn't required. + */ +#define LZMA_CONCATENATED UINT32_C(0x08) + + +/** + * This flag makes the threaded decoder report errors (like LZMA_DATA_ERROR) + * as soon as they are detected. This saves time when the application has no + * interest in a partially decompressed truncated or corrupt file. Note that + * due to timing randomness, if the same truncated or corrupt input is + * decompressed multiple times with this flag, a different amount of output + * may be produced by different runs, and even the error code might vary. + * + * When using LZMA_FAIL_FAST, it is recommended to use LZMA_FINISH to tell + * the decoder when no more input will be coming because it can help fast + * detection and reporting of truncated files. Note that in this situation + * truncated files might be diagnosed with LZMA_DATA_ERROR instead of + * LZMA_OK or LZMA_BUF_ERROR! + * + * Without this flag the threaded decoder will provide as much output as + * possible at first and then report the pending error. This default behavior + * matches the single-threaded decoder and provides repeatable behavior + * with truncated or corrupt input. There are a few special cases where the + * behavior can still differ like memory allocation failures (LZMA_MEM_ERROR). + * + * Single-threaded decoders currently ignore this flag. + * + * Support for this flag was added in liblzma 5.3.3alpha. Note that in older + * versions this flag isn't supported (LZMA_OPTIONS_ERROR) even by functions + * that ignore this flag in newer liblzma versions. + */ +#define LZMA_FAIL_FAST UINT32_C(0x20) + + +/** + * \brief Initialize .xz Stream decoder + * + * \param strm Pointer to lzma_stream that is at least initialized + * with LZMA_STREAM_INIT. + * \param memlimit Memory usage limit as bytes. Use UINT64_MAX + * to effectively disable the limiter. liblzma + * 5.2.3 and earlier don't allow 0 here and return + * LZMA_PROG_ERROR; later versions treat 0 as if 1 + * had been specified. + * \param flags Bitwise-or of zero or more of the decoder flags: + * LZMA_TELL_NO_CHECK, LZMA_TELL_UNSUPPORTED_CHECK, + * LZMA_TELL_ANY_CHECK, LZMA_IGNORE_CHECK, + * LZMA_CONCATENATED, LZMA_FAIL_FAST + * + * \return Possible lzma_ret values: + * - LZMA_OK: Initialization was successful. + * - LZMA_MEM_ERROR: Cannot allocate memory. + * - LZMA_OPTIONS_ERROR: Unsupported flags + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_stream_decoder( + lzma_stream *strm, uint64_t memlimit, uint32_t flags) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Initialize multithreaded .xz Stream decoder + * + * The decoder can decode multiple Blocks in parallel. This requires that each + * Block Header contains the Compressed Size and Uncompressed size fields + * which are added by the multi-threaded encoder, see lzma_stream_encoder_mt(). + * + * A Stream with one Block will only utilize one thread. A Stream with multiple + * Blocks but without size information in Block Headers will be processed in + * single-threaded mode in the same way as done by lzma_stream_decoder(). + * Concatenated Streams are processed one Stream at a time; no inter-Stream + * parallelization is done. + * + * This function behaves like lzma_stream_decoder() when options->threads == 1 + * and options->memlimit_threading <= 1. + * + * \param strm Pointer to lzma_stream that is at least initialized + * with LZMA_STREAM_INIT. + * \param options Pointer to multithreaded compression options + * + * \return Possible lzma_ret values: + * - LZMA_OK: Initialization was successful. + * - LZMA_MEM_ERROR: Cannot allocate memory. + * - LZMA_MEMLIMIT_ERROR: Memory usage limit was reached. + * - LZMA_OPTIONS_ERROR: Unsupported flags. + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_stream_decoder_mt( + lzma_stream *strm, const lzma_mt *options) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Decode .xz, .lzma, and .lz (lzip) files with autodetection + * + * This decoder autodetects between the .xz, .lzma, and .lz file formats, + * and calls lzma_stream_decoder(), lzma_alone_decoder(), or + * lzma_lzip_decoder() once the type of the input file has been detected. + * + * Support for .lz was added in 5.4.0. + * + * If the flag LZMA_CONCATENATED is used and the input is a .lzma file: + * For historical reasons concatenated .lzma files aren't supported. + * If there is trailing data after one .lzma stream, lzma_code() will + * return LZMA_DATA_ERROR. (lzma_alone_decoder() doesn't have such a check + * as it doesn't support any decoder flags. It will return LZMA_STREAM_END + * after one .lzma stream.) + * + * \param strm Pointer to lzma_stream that is at least initialized + * with LZMA_STREAM_INIT. + * \param memlimit Memory usage limit as bytes. Use UINT64_MAX + * to effectively disable the limiter. liblzma + * 5.2.3 and earlier don't allow 0 here and return + * LZMA_PROG_ERROR; later versions treat 0 as if 1 + * had been specified. + * \param flags Bitwise-or of zero or more of the decoder flags: + * LZMA_TELL_NO_CHECK, LZMA_TELL_UNSUPPORTED_CHECK, + * LZMA_TELL_ANY_CHECK, LZMA_IGNORE_CHECK, + * LZMA_CONCATENATED, LZMA_FAIL_FAST + * + * \return Possible lzma_ret values: + * - LZMA_OK: Initialization was successful. + * - LZMA_MEM_ERROR: Cannot allocate memory. + * - LZMA_OPTIONS_ERROR: Unsupported flags + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_auto_decoder( + lzma_stream *strm, uint64_t memlimit, uint32_t flags) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Initialize .lzma decoder (legacy file format) + * + * Valid 'action' arguments to lzma_code() are LZMA_RUN and LZMA_FINISH. + * There is no need to use LZMA_FINISH, but it's allowed because it may + * simplify certain types of applications. + * + * \param strm Pointer to lzma_stream that is at least initialized + * with LZMA_STREAM_INIT. + * \param memlimit Memory usage limit as bytes. Use UINT64_MAX + * to effectively disable the limiter. liblzma + * 5.2.3 and earlier don't allow 0 here and return + * LZMA_PROG_ERROR; later versions treat 0 as if 1 + * had been specified. + * + * \return Possible lzma_ret values: + * - LZMA_OK + * - LZMA_MEM_ERROR + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_alone_decoder( + lzma_stream *strm, uint64_t memlimit) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Initialize .lz (lzip) decoder (a foreign file format) + * + * This decoder supports the .lz format versions 0 and 1: + * + * - Files in the format version 0 were produced by lzip 1.3 and older. + * Such files aren't common but may be found from file archives + * as a few source packages were released in this format. People + * might have old personal files in this format too. Decompression + * support for the format version 0 was removed in lzip 1.18. + * + * - lzip 1.3 added decompression support for .lz format version 1 files. + * Compression support was added in lzip 1.4. + * + * - lzlib extends version 1 format with the Sync Flush marker. This + * extension is only meant for lzlib use; it's not valid in normal .lz + * files. This extension is not supported by liblzma. lzma_code() will + * return LZMA_DATA_ERROR at the location of the Sync Flush marker. + * + * Just like with lzma_stream_decoder() for .xz files, LZMA_CONCATENATED + * should be used when decompressing normal standalone .lz files. + * + * If LZMA_CONCATENATED is used and there is non-.lz data after at least one + * valid .lz member, lzma_code() leaves lzma_stream.next_in pointing to the + * first byte of the non-.lz data and returns LZMA_STREAM_END. That is, one + * can append custom data at the end of a .lz file and the decoder will + * ignore it. An exception to this is if the first 1-3 bytes of the non-.lz + * data are identical to the .lz magic bytes (0x4C, 0x5A, 0x49, 0x50; "LZIP" + * in US-ASCII). In such a case the 1-3 bytes are consumed by lzma_code(). + * If one wishes to locate the non-.lz data reliably, one must ensure that + * the first byte isn't 0x4C. It's best if none of the first four bytes of + * trailing data are equal to the magic bytes because if two or three bytes + * are, lzip >= 1.20 diagnoses it as a corrupt member header by default. + * + * \param strm Pointer to lzma_stream that is at least initialized + * with LZMA_STREAM_INIT. + * \param memlimit Memory usage limit as bytes. Use UINT64_MAX + * to effectively disable the limiter. + * \param flags Bitwise-or of flags, or zero for no flags. + * All decoder flags listed above are supported + * although only LZMA_CONCATENATED and (in very rare + * cases) LZMA_IGNORE_CHECK are actually useful. + * LZMA_TELL_NO_CHECK, LZMA_TELL_UNSUPPORTED_CHECK, + * and LZMA_FAIL_FAST do nothing. LZMA_TELL_ANY_CHECK + * is supported for consistency only as CRC32 is + * always used in the .lz format. + * + * \return Possible lzma_ret values: + * - LZMA_OK: Initialization was successful. + * - LZMA_MEM_ERROR: Cannot allocate memory. + * - LZMA_OPTIONS_ERROR: Unsupported flags + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_lzip_decoder( + lzma_stream *strm, uint64_t memlimit, uint32_t flags) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Single-call .xz Stream decoder + * + * \param memlimit Pointer to how much memory the decoder is allowed + * to allocate. The value pointed by this pointer is + * modified if and only if LZMA_MEMLIMIT_ERROR is + * returned. + * \param flags Bitwise-or of zero or more of the decoder flags: + * LZMA_TELL_NO_CHECK, LZMA_TELL_UNSUPPORTED_CHECK, + * LZMA_IGNORE_CHECK, LZMA_CONCATENATED, + * LZMA_FAIL_FAST. Note that LZMA_TELL_ANY_CHECK + * is not allowed and will return LZMA_PROG_ERROR. + * \param allocator lzma_allocator for custom allocator functions. + * Set to NULL to use malloc() and free(). + * \param in Beginning of the input buffer + * \param in_pos The next byte will be read from in[*in_pos]. + * *in_pos is updated only if decoding succeeds. + * \param in_size Size of the input buffer; the first byte that + * won't be read is in[in_size]. + * \param[out] out Beginning of the output buffer + * \param[out] out_pos The next byte will be written to out[*out_pos]. + * *out_pos is updated only if decoding succeeds. + * \param out_size Size of the out buffer; the first byte into + * which no data is written to is out[out_size]. + * + * \return Possible lzma_ret values: + * - LZMA_OK: Decoding was successful. + * - LZMA_FORMAT_ERROR + * - LZMA_OPTIONS_ERROR + * - LZMA_DATA_ERROR + * - LZMA_NO_CHECK: This can be returned only if using + * the LZMA_TELL_NO_CHECK flag. + * - LZMA_UNSUPPORTED_CHECK: This can be returned only if using + * the LZMA_TELL_UNSUPPORTED_CHECK flag. + * - LZMA_MEM_ERROR + * - LZMA_MEMLIMIT_ERROR: Memory usage limit was reached. + * The minimum required memlimit value was stored to *memlimit. + * - LZMA_BUF_ERROR: Output buffer was too small. + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_stream_buffer_decode( + uint64_t *memlimit, uint32_t flags, + const lzma_allocator *allocator, + const uint8_t *in, size_t *in_pos, size_t in_size, + uint8_t *out, size_t *out_pos, size_t out_size) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief MicroLZMA decoder + * + * See lzma_microlzma_encoder() for more information. + * + * The lzma_code() usage with this decoder is completely normal. The + * special behavior of lzma_code() applies to lzma_microlzma_encoder() only. + * + * \param strm Pointer to lzma_stream that is at least initialized + * with LZMA_STREAM_INIT. + * \param comp_size Compressed size of the MicroLZMA stream. + * The caller must somehow know this exactly. + * \param uncomp_size Uncompressed size of the MicroLZMA stream. + * If the exact uncompressed size isn't known, this + * can be set to a value that is at most as big as + * the exact uncompressed size would be, but then the + * next argument uncomp_size_is_exact must be false. + * \param uncomp_size_is_exact + * If true, uncomp_size must be exactly correct. + * This will improve error detection at the end of + * the stream. If the exact uncompressed size isn't + * known, this must be false. uncomp_size must still + * be at most as big as the exact uncompressed size + * is. Setting this to false when the exact size is + * known will work but error detection at the end of + * the stream will be weaker. + * \param dict_size LZMA dictionary size that was used when + * compressing the data. It is OK to use a bigger + * value too but liblzma will then allocate more + * memory than would actually be required and error + * detection will be slightly worse. (Note that with + * the implementation in XZ Embedded it doesn't + * affect the memory usage if one specifies bigger + * dictionary than actually required.) + * + * \return Possible lzma_ret values: + * - LZMA_OK + * - LZMA_MEM_ERROR + * - LZMA_OPTIONS_ERROR + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_microlzma_decoder( + lzma_stream *strm, uint64_t comp_size, + uint64_t uncomp_size, lzma_bool uncomp_size_is_exact, + uint32_t dict_size) lzma_nothrow; diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/delta.h b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/delta.h new file mode 100644 index 0000000000000000000000000000000000000000..5ebacef815841ae3206b15c46aca1034f992df67 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/delta.h @@ -0,0 +1,95 @@ +/* SPDX-License-Identifier: 0BSD */ + +/** + * \file lzma/delta.h + * \brief Delta filter + * \note Never include this file directly. Use instead. + */ + +/* + * Author: Lasse Collin + */ + +#ifndef LZMA_H_INTERNAL +# error Never include this file directly. Use instead. +#endif + + +/** + * \brief Filter ID + * + * Filter ID of the Delta filter. This is used as lzma_filter.id. + */ +#define LZMA_FILTER_DELTA LZMA_VLI_C(0x03) + + +/** + * \brief Type of the delta calculation + * + * Currently only byte-wise delta is supported. Other possible types could + * be, for example, delta of 16/32/64-bit little/big endian integers, but + * these are not currently planned since byte-wise delta is almost as good. + */ +typedef enum { + LZMA_DELTA_TYPE_BYTE +} lzma_delta_type; + + +/** + * \brief Options for the Delta filter + * + * These options are needed by both encoder and decoder. + */ +typedef struct { + /** For now, this must always be LZMA_DELTA_TYPE_BYTE. */ + lzma_delta_type type; + + /** + * \brief Delta distance + * + * With the only currently supported type, LZMA_DELTA_TYPE_BYTE, + * the distance is as bytes. + * + * Examples: + * - 16-bit stereo audio: distance = 4 bytes + * - 24-bit RGB image data: distance = 3 bytes + */ + uint32_t dist; + + /** + * \brief Minimum value for lzma_options_delta.dist. + */ +# define LZMA_DELTA_DIST_MIN 1 + + /** + * \brief Maximum value for lzma_options_delta.dist. + */ +# define LZMA_DELTA_DIST_MAX 256 + + /* + * Reserved space to allow possible future extensions without + * breaking the ABI. You should not touch these, because the names + * of these variables may change. These are and will never be used + * when type is LZMA_DELTA_TYPE_BYTE, so it is safe to leave these + * uninitialized. + */ + + /** \private Reserved member. */ + uint32_t reserved_int1; + + /** \private Reserved member. */ + uint32_t reserved_int2; + + /** \private Reserved member. */ + uint32_t reserved_int3; + + /** \private Reserved member. */ + uint32_t reserved_int4; + + /** \private Reserved member. */ + void *reserved_ptr1; + + /** \private Reserved member. */ + void *reserved_ptr2; + +} lzma_options_delta; diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/filter.h b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/filter.h new file mode 100644 index 0000000000000000000000000000000000000000..e86809c4e395d71d2a7f0e8dfc40873906b98be2 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/filter.h @@ -0,0 +1,769 @@ +/* SPDX-License-Identifier: 0BSD */ + +/** + * \file lzma/filter.h + * \brief Common filter related types and functions + * \note Never include this file directly. Use instead. + */ + +/* + * Author: Lasse Collin + */ + +#ifndef LZMA_H_INTERNAL +# error Never include this file directly. Use instead. +#endif + + +/** + * \brief Maximum number of filters in a chain + * + * A filter chain can have 1-4 filters, of which three are allowed to change + * the size of the data. Usually only one or two filters are needed. + */ +#define LZMA_FILTERS_MAX 4 + + +/** + * \brief Filter options + * + * This structure is used to pass a Filter ID and a pointer to the filter's + * options to liblzma. A few functions work with a single lzma_filter + * structure, while most functions expect a filter chain. + * + * A filter chain is indicated with an array of lzma_filter structures. + * The array is terminated with .id = LZMA_VLI_UNKNOWN. Thus, the filter + * array must have LZMA_FILTERS_MAX + 1 elements (that is, five) to + * be able to hold any arbitrary filter chain. This is important when + * using lzma_block_header_decode() from block.h, because a filter array + * that is too small would make liblzma write past the end of the array. + */ +typedef struct { + /** + * \brief Filter ID + * + * Use constants whose name begin with 'LZMA_FILTER_' to specify + * different filters. In an array of lzma_filter structures, use + * LZMA_VLI_UNKNOWN to indicate end of filters. + * + * \note This is not an enum, because on some systems enums + * cannot be 64-bit. + */ + lzma_vli id; + + /** + * \brief Pointer to filter-specific options structure + * + * If the filter doesn't need options, set this to NULL. If id is + * set to LZMA_VLI_UNKNOWN, options is ignored, and thus + * doesn't need be initialized. + */ + void *options; + +} lzma_filter; + + +/** + * \brief Test if the given Filter ID is supported for encoding + * + * \param id Filter ID + * + * \return lzma_bool: + * - true if the Filter ID is supported for encoding by this + * liblzma build. + * - false otherwise. + */ +extern LZMA_API(lzma_bool) lzma_filter_encoder_is_supported(lzma_vli id) + lzma_nothrow lzma_attr_const; + + +/** + * \brief Test if the given Filter ID is supported for decoding + * + * \param id Filter ID + * + * \return lzma_bool: + * - true if the Filter ID is supported for decoding by this + * liblzma build. + * - false otherwise. + */ +extern LZMA_API(lzma_bool) lzma_filter_decoder_is_supported(lzma_vli id) + lzma_nothrow lzma_attr_const; + + +/** + * \brief Copy the filters array + * + * Copy the Filter IDs and filter-specific options from src to dest. + * Up to LZMA_FILTERS_MAX filters are copied, plus the terminating + * .id == LZMA_VLI_UNKNOWN. Thus, dest should have at least + * LZMA_FILTERS_MAX + 1 elements space unless the caller knows that + * src is smaller than that. + * + * Unless the filter-specific options is NULL, the Filter ID has to be + * supported by liblzma, because liblzma needs to know the size of every + * filter-specific options structure. The filter-specific options are not + * validated. If options is NULL, any unsupported Filter IDs are copied + * without returning an error. + * + * Old filter-specific options in dest are not freed, so dest doesn't + * need to be initialized by the caller in any way. + * + * If an error occurs, memory possibly already allocated by this function + * is always freed. liblzma versions older than 5.2.7 may modify the dest + * array and leave its contents in an undefined state if an error occurs. + * liblzma 5.2.7 and newer only modify the dest array when returning LZMA_OK. + * + * \param src Array of filters terminated with + * .id == LZMA_VLI_UNKNOWN. + * \param[out] dest Destination filter array + * \param allocator lzma_allocator for custom allocator functions. + * Set to NULL to use malloc() and free(). + * + * \return Possible lzma_ret values: + * - LZMA_OK + * - LZMA_MEM_ERROR + * - LZMA_OPTIONS_ERROR: Unsupported Filter ID and its options + * is not NULL. + * - LZMA_PROG_ERROR: src or dest is NULL. + */ +extern LZMA_API(lzma_ret) lzma_filters_copy( + const lzma_filter *src, lzma_filter *dest, + const lzma_allocator *allocator) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Free the options in the array of lzma_filter structures + * + * This frees the filter chain options. The filters array itself is not freed. + * + * The filters array must have at most LZMA_FILTERS_MAX + 1 elements + * including the terminating element which must have .id = LZMA_VLI_UNKNOWN. + * For all elements before the terminating element: + * - options will be freed using the given lzma_allocator or, + * if allocator is NULL, using free(). + * - options will be set to NULL. + * - id will be set to LZMA_VLI_UNKNOWN. + * + * If filters is NULL, this does nothing. Again, this never frees the + * filters array itself. + * + * \param filters Array of filters terminated with + * .id == LZMA_VLI_UNKNOWN. + * \param allocator lzma_allocator for custom allocator functions. + * Set to NULL to use malloc() and free(). + */ +extern LZMA_API(void) lzma_filters_free( + lzma_filter *filters, const lzma_allocator *allocator) + lzma_nothrow; + + +/** + * \brief Calculate approximate memory requirements for raw encoder + * + * This function can be used to calculate the memory requirements for + * Block and Stream encoders too because Block and Stream encoders don't + * need significantly more memory than raw encoder. + * + * \param filters Array of filters terminated with + * .id == LZMA_VLI_UNKNOWN. + * + * \return Number of bytes of memory required for the given + * filter chain when encoding or UINT64_MAX on error. + */ +extern LZMA_API(uint64_t) lzma_raw_encoder_memusage(const lzma_filter *filters) + lzma_nothrow lzma_attr_pure; + + +/** + * \brief Calculate approximate memory requirements for raw decoder + * + * This function can be used to calculate the memory requirements for + * Block and Stream decoders too because Block and Stream decoders don't + * need significantly more memory than raw decoder. + * + * \param filters Array of filters terminated with + * .id == LZMA_VLI_UNKNOWN. + * + * \return Number of bytes of memory required for the given + * filter chain when decoding or UINT64_MAX on error. + */ +extern LZMA_API(uint64_t) lzma_raw_decoder_memusage(const lzma_filter *filters) + lzma_nothrow lzma_attr_pure; + + +/** + * \brief Initialize raw encoder + * + * This function may be useful when implementing custom file formats. + * + * The 'action' with lzma_code() can be LZMA_RUN, LZMA_SYNC_FLUSH (if the + * filter chain supports it), or LZMA_FINISH. + * + * \param strm Pointer to lzma_stream that is at least + * initialized with LZMA_STREAM_INIT. + * \param filters Array of filters terminated with + * .id == LZMA_VLI_UNKNOWN. + * + * \return Possible lzma_ret values: + * - LZMA_OK + * - LZMA_MEM_ERROR + * - LZMA_OPTIONS_ERROR + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_raw_encoder( + lzma_stream *strm, const lzma_filter *filters) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Initialize raw decoder + * + * The initialization of raw decoder goes similarly to raw encoder. + * + * The 'action' with lzma_code() can be LZMA_RUN or LZMA_FINISH. Using + * LZMA_FINISH is not required, it is supported just for convenience. + * + * \param strm Pointer to lzma_stream that is at least + * initialized with LZMA_STREAM_INIT. + * \param filters Array of filters terminated with + * .id == LZMA_VLI_UNKNOWN. + * + * \return Possible lzma_ret values: + * - LZMA_OK + * - LZMA_MEM_ERROR + * - LZMA_OPTIONS_ERROR + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_raw_decoder( + lzma_stream *strm, const lzma_filter *filters) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Update the filter chain in the encoder + * + * This function may be called after lzma_code() has returned LZMA_STREAM_END + * when LZMA_FULL_BARRIER, LZMA_FULL_FLUSH, or LZMA_SYNC_FLUSH was used: + * + * - After LZMA_FULL_BARRIER or LZMA_FULL_FLUSH: Single-threaded .xz Stream + * encoder (lzma_stream_encoder()) and (since liblzma 5.4.0) multi-threaded + * Stream encoder (lzma_stream_encoder_mt()) allow setting a new filter + * chain to be used for the next Block(s). + * + * - After LZMA_SYNC_FLUSH: Raw encoder (lzma_raw_encoder()), + * Block encoder (lzma_block_encoder()), and single-threaded .xz Stream + * encoder (lzma_stream_encoder()) allow changing certain filter-specific + * options in the middle of encoding. The actual filters in the chain + * (Filter IDs) must not be changed! Currently only the lc, lp, and pb + * options of LZMA2 (not LZMA1) can be changed this way. + * + * - In the future some filters might allow changing some of their options + * without any barrier or flushing but currently such filters don't exist. + * + * This function may also be called when no data has been compressed yet + * although this is rarely useful. In that case, this function will behave + * as if LZMA_FULL_FLUSH (Stream encoders) or LZMA_SYNC_FLUSH (Raw or Block + * encoder) had been used right before calling this function. + * + * \param strm Pointer to lzma_stream that is at least + * initialized with LZMA_STREAM_INIT. + * \param filters Array of filters terminated with + * .id == LZMA_VLI_UNKNOWN. + * + * \return Possible lzma_ret values: + * - LZMA_OK + * - LZMA_MEM_ERROR + * - LZMA_MEMLIMIT_ERROR + * - LZMA_OPTIONS_ERROR + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_filters_update( + lzma_stream *strm, const lzma_filter *filters) lzma_nothrow; + + +/** + * \brief Single-call raw encoder + * + * \note There is no function to calculate how big output buffer + * would surely be big enough. (lzma_stream_buffer_bound() + * works only for lzma_stream_buffer_encode(); raw encoder + * won't necessarily meet that bound.) + * + * \param filters Array of filters terminated with + * .id == LZMA_VLI_UNKNOWN. + * \param allocator lzma_allocator for custom allocator functions. + * Set to NULL to use malloc() and free(). + * \param in Beginning of the input buffer + * \param in_size Size of the input buffer + * \param[out] out Beginning of the output buffer + * \param[out] out_pos The next byte will be written to out[*out_pos]. + * *out_pos is updated only if encoding succeeds. + * \param out_size Size of the out buffer; the first byte into + * which no data is written to is out[out_size]. + * + * \return Possible lzma_ret values: + * - LZMA_OK: Encoding was successful. + * - LZMA_BUF_ERROR: Not enough output buffer space. + * - LZMA_OPTIONS_ERROR + * - LZMA_MEM_ERROR + * - LZMA_DATA_ERROR + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_raw_buffer_encode( + const lzma_filter *filters, const lzma_allocator *allocator, + const uint8_t *in, size_t in_size, uint8_t *out, + size_t *out_pos, size_t out_size) lzma_nothrow; + + +/** + * \brief Single-call raw decoder + * + * \param filters Array of filters terminated with + * .id == LZMA_VLI_UNKNOWN. + * \param allocator lzma_allocator for custom allocator functions. + * Set to NULL to use malloc() and free(). + * \param in Beginning of the input buffer + * \param in_pos The next byte will be read from in[*in_pos]. + * *in_pos is updated only if decoding succeeds. + * \param in_size Size of the input buffer; the first byte that + * won't be read is in[in_size]. + * \param[out] out Beginning of the output buffer + * \param[out] out_pos The next byte will be written to out[*out_pos]. + * *out_pos is updated only if encoding succeeds. + * \param out_size Size of the out buffer; the first byte into + * which no data is written to is out[out_size]. + * + * \return Possible lzma_ret values: + * - LZMA_OK: Decoding was successful. + * - LZMA_BUF_ERROR: Not enough output buffer space. + * - LZMA_OPTIONS_ERROR + * - LZMA_MEM_ERROR + * - LZMA_DATA_ERROR + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_raw_buffer_decode( + const lzma_filter *filters, const lzma_allocator *allocator, + const uint8_t *in, size_t *in_pos, size_t in_size, + uint8_t *out, size_t *out_pos, size_t out_size) lzma_nothrow; + + +/** + * \brief Get the size of the Filter Properties field + * + * This function may be useful when implementing custom file formats + * using the raw encoder and decoder. + * + * \note This function validates the Filter ID, but does not + * necessarily validate the options. Thus, it is possible + * that this returns LZMA_OK while the following call to + * lzma_properties_encode() returns LZMA_OPTIONS_ERROR. + * + * \param[out] size Pointer to uint32_t to hold the size of the properties + * \param filter Filter ID and options (the size of the properties may + * vary depending on the options) + * + * \return Possible lzma_ret values: + * - LZMA_OK + * - LZMA_OPTIONS_ERROR + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_properties_size( + uint32_t *size, const lzma_filter *filter) lzma_nothrow; + + +/** + * \brief Encode the Filter Properties field + * + * \note Even this function won't validate more options than actually + * necessary. Thus, it is possible that encoding the properties + * succeeds but using the same options to initialize the encoder + * will fail. + * + * \note If lzma_properties_size() indicated that the size + * of the Filter Properties field is zero, calling + * lzma_properties_encode() is not required, but it + * won't do any harm either. + * + * \param filter Filter ID and options + * \param[out] props Buffer to hold the encoded options. The size of + * the buffer must have been already determined with + * lzma_properties_size(). + * + * \return Possible lzma_ret values: + * - LZMA_OK + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_properties_encode( + const lzma_filter *filter, uint8_t *props) lzma_nothrow; + + +/** + * \brief Decode the Filter Properties field + * + * \param filter filter->id must have been set to the correct + * Filter ID. filter->options doesn't need to be + * initialized (it's not freed by this function). The + * decoded options will be stored in filter->options; + * it's application's responsibility to free it when + * appropriate. filter->options is set to NULL if + * there are no properties or if an error occurs. + * \param allocator lzma_allocator for custom allocator functions. + * Set to NULL to use malloc() and free(). + * and in case of an error, also free(). + * \param props Input buffer containing the properties. + * \param props_size Size of the properties. This must be the exact + * size; giving too much or too little input will + * return LZMA_OPTIONS_ERROR. + * + * \return Possible lzma_ret values: + * - LZMA_OK + * - LZMA_OPTIONS_ERROR + * - LZMA_MEM_ERROR + */ +extern LZMA_API(lzma_ret) lzma_properties_decode( + lzma_filter *filter, const lzma_allocator *allocator, + const uint8_t *props, size_t props_size) lzma_nothrow; + + +/** + * \brief Calculate encoded size of a Filter Flags field + * + * Knowing the size of Filter Flags is useful to know when allocating + * memory to hold the encoded Filter Flags. + * + * \note If you need to calculate size of List of Filter Flags, + * you need to loop over every lzma_filter entry. + * + * \param[out] size Pointer to integer to hold the calculated size + * \param filter Filter ID and associated options whose encoded + * size is to be calculated + * + * \return Possible lzma_ret values: + * - LZMA_OK: *size set successfully. Note that this doesn't + * guarantee that filter->options is valid, thus + * lzma_filter_flags_encode() may still fail. + * - LZMA_OPTIONS_ERROR: Unknown Filter ID or unsupported options. + * - LZMA_PROG_ERROR: Invalid options + */ +extern LZMA_API(lzma_ret) lzma_filter_flags_size( + uint32_t *size, const lzma_filter *filter) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Encode Filter Flags into given buffer + * + * In contrast to some functions, this doesn't allocate the needed buffer. + * This is due to how this function is used internally by liblzma. + * + * \param filter Filter ID and options to be encoded + * \param[out] out Beginning of the output buffer + * \param[out] out_pos out[*out_pos] is the next write position. This + * is updated by the encoder. + * \param out_size out[out_size] is the first byte to not write. + * + * \return Possible lzma_ret values: + * - LZMA_OK: Encoding was successful. + * - LZMA_OPTIONS_ERROR: Invalid or unsupported options. + * - LZMA_PROG_ERROR: Invalid options or not enough output + * buffer space (you should have checked it with + * lzma_filter_flags_size()). + */ +extern LZMA_API(lzma_ret) lzma_filter_flags_encode(const lzma_filter *filter, + uint8_t *out, size_t *out_pos, size_t out_size) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Decode Filter Flags from given buffer + * + * The decoded result is stored into *filter. The old value of + * filter->options is not free()d. If anything other than LZMA_OK + * is returned, filter->options is set to NULL. + * + * \param[out] filter Destination filter. The decoded Filter ID will + * be stored in filter->id. If options are needed + * they will be allocated and the pointer will be + * stored in filter->options. + * \param allocator lzma_allocator for custom allocator functions. + * Set to NULL to use malloc() and free(). + * \param in Beginning of the input buffer + * \param[out] in_pos The next byte will be read from in[*in_pos]. + * *in_pos is updated only if decoding succeeds. + * \param in_size Size of the input buffer; the first byte that + * won't be read is in[in_size]. + * + * \return Possible lzma_ret values: + * - LZMA_OK + * - LZMA_OPTIONS_ERROR + * - LZMA_MEM_ERROR + * - LZMA_DATA_ERROR + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_filter_flags_decode( + lzma_filter *filter, const lzma_allocator *allocator, + const uint8_t *in, size_t *in_pos, size_t in_size) + lzma_nothrow lzma_attr_warn_unused_result; + + +/*********** + * Strings * + ***********/ + +/** + * \brief Allow or show all filters + * + * By default only the filters supported in the .xz format are accept by + * lzma_str_to_filters() or shown by lzma_str_list_filters(). + */ +#define LZMA_STR_ALL_FILTERS UINT32_C(0x01) + + +/** + * \brief Do not validate the filter chain in lzma_str_to_filters() + * + * By default lzma_str_to_filters() can return an error if the filter chain + * as a whole isn't usable in the .xz format or in the raw encoder or decoder. + * With this flag, this validation is skipped. This flag doesn't affect the + * handling of the individual filter options. To allow non-.xz filters also + * LZMA_STR_ALL_FILTERS is needed. + */ +#define LZMA_STR_NO_VALIDATION UINT32_C(0x02) + + +/** + * \brief Stringify encoder options + * + * Show the filter-specific options that the encoder will use. + * This may be useful for verbose diagnostic messages. + * + * Note that if options were decoded from .xz headers then the encoder options + * may be undefined. This flag shouldn't be used in such a situation. + */ +#define LZMA_STR_ENCODER UINT32_C(0x10) + + +/** + * \brief Stringify decoder options + * + * Show the filter-specific options that the decoder will use. + * This may be useful for showing what filter options were decoded + * from file headers. + */ +#define LZMA_STR_DECODER UINT32_C(0x20) + + +/** + * \brief Produce xz-compatible getopt_long() syntax + * + * That is, "delta:dist=2 lzma2:dict=4MiB,pb=1,lp=1" becomes + * "--delta=dist=2 --lzma2=dict=4MiB,pb=1,lp=1". + * + * This syntax is compatible with xz 5.0.0 as long as the filters and + * their options are supported too. + */ +#define LZMA_STR_GETOPT_LONG UINT32_C(0x40) + + +/** + * \brief Use two dashes "--" instead of a space to separate filters + * + * That is, "delta:dist=2 lzma2:pb=1,lp=1" becomes + * "delta:dist=2--lzma2:pb=1,lp=1". This looks slightly odd but this + * kind of strings should be usable on the command line without quoting. + * However, it is possible that future versions with new filter options + * might produce strings that require shell quoting anyway as the exact + * set of possible characters isn't frozen for now. + * + * It is guaranteed that the single quote (') will never be used in + * filter chain strings (even if LZMA_STR_NO_SPACES isn't used). + */ +#define LZMA_STR_NO_SPACES UINT32_C(0x80) + + +/** + * \brief Convert a string to a filter chain + * + * This tries to make it easier to write applications that allow users + * to set custom compression options. This only handles the filter + * configuration (including presets) but not the number of threads, + * block size, check type, or memory limits. + * + * The input string can be either a preset or a filter chain. Presets + * begin with a digit 0-9 and may be followed by zero or more flags + * which are lower-case letters. Currently only "e" is supported, matching + * LZMA_PRESET_EXTREME. For partial xz command line syntax compatibility, + * a preset string may start with a single dash "-". + * + * A filter chain consists of one or more "filtername:opt1=value1,opt2=value2" + * strings separated by one or more spaces. Leading and trailing spaces are + * ignored. All names and values must be lower-case. Extra commas in the + * option list are ignored. The order of filters is significant: when + * encoding, the uncompressed input data goes to the leftmost filter first. + * Normally "lzma2" is the last filter in the chain. + * + * If one wishes to avoid spaces, for example, to avoid shell quoting, + * it is possible to use two dashes "--" instead of spaces to separate + * the filters. + * + * For xz command line compatibility, each filter may be prefixed with + * two dashes "--" and the colon ":" separating the filter name from + * the options may be replaced with an equals sign "=". + * + * By default, only filters that can be used in the .xz format are accepted. + * To allow all filters (LZMA1) use the flag LZMA_STR_ALL_FILTERS. + * + * By default, very basic validation is done for the filter chain as a whole, + * for example, that LZMA2 is only used as the last filter in the chain. + * The validation isn't perfect though and it's possible that this function + * succeeds but using the filter chain for encoding or decoding will still + * result in LZMA_OPTIONS_ERROR. To disable this validation, use the flag + * LZMA_STR_NO_VALIDATION. + * + * The available filter names and their options are available via + * lzma_str_list_filters(). See the xz man page for the description + * of filter names and options. + * + * For command line applications, below is an example how an error message + * can be displayed. Note the use of an empty string for the field width. + * If "^" was used there it would create an off-by-one error except at + * the very beginning of the line. + * + * \code{.c} + * const char *str = ...; // From user + * lzma_filter filters[LZMA_FILTERS_MAX + 1]; + * int pos; + * const char *msg = lzma_str_to_filters(str, &pos, filters, 0, NULL); + * if (msg != NULL) { + * printf("%s: Error in XZ compression options:\n", argv[0]); + * printf("%s: %s\n", argv[0], str); + * printf("%s: %*s^\n", argv[0], errpos, ""); + * printf("%s: %s\n", argv[0], msg); + * } + * \endcode + * + * \param str User-supplied string describing a preset or + * a filter chain. If a default value is needed and + * you don't know what would be good, use "6" since + * that is the default preset in xz too. + * \param[out] error_pos If this isn't NULL, this value will be set on + * both success and on all errors. This tells the + * location of the error in the string. This is + * an int to make it straightforward to use this + * as printf() field width. The value is guaranteed + * to be in the range [0, INT_MAX] even if strlen(str) + * somehow was greater than INT_MAX. + * \param[out] filters An array of lzma_filter structures. There must + * be LZMA_FILTERS_MAX + 1 (that is, five) elements + * in the array. The old contents are ignored so it + * doesn't need to be initialized. This array is + * modified only if this function returns NULL. + * Once the allocated filter options are no longer + * needed, lzma_filters_free() can be used to free the + * options (it doesn't free the filters array itself). + * \param flags Bitwise-or of zero or more of the flags + * LZMA_STR_ALL_FILTERS and LZMA_STR_NO_VALIDATION. + * \param allocator lzma_allocator for custom allocator functions. + * Set to NULL to use malloc() and free(). + * + * \return On success, NULL is returned. On error, a statically-allocated + * error message is returned which together with the error_pos + * should give some idea what is wrong. + */ +extern LZMA_API(const char *) lzma_str_to_filters( + const char *str, int *error_pos, lzma_filter *filters, + uint32_t flags, const lzma_allocator *allocator) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Convert a filter chain to a string + * + * Use cases: + * + * - Verbose output showing the full encoder options to the user + * (use LZMA_STR_ENCODER in flags) + * + * - Showing the filters and options that are required to decode a file + * (use LZMA_STR_DECODER in flags) + * + * - Showing the filter names without any options in informational messages + * where the technical details aren't important (no flags). In this case + * the .options in the filters array are ignored and may be NULL even if + * a filter has a mandatory options structure. + * + * Note that even if the filter chain was specified using a preset, + * the resulting filter chain isn't reversed to a preset. So if you + * specify "6" to lzma_str_to_filters() then lzma_str_from_filters() + * will produce a string containing "lzma2". + * + * \param[out] str On success *str will be set to point to an + * allocated string describing the given filter + * chain. Old value is ignored. On error *str is + * always set to NULL. + * \param filters Array of filters terminated with + * .id == LZMA_VLI_UNKNOWN. + * \param flags Bitwise-or of zero or more of the flags + * LZMA_STR_ENCODER, LZMA_STR_DECODER, + * LZMA_STR_GETOPT_LONG, and LZMA_STR_NO_SPACES. + * \param allocator lzma_allocator for custom allocator functions. + * Set to NULL to use malloc() and free(). + * + * \return Possible lzma_ret values: + * - LZMA_OK + * - LZMA_OPTIONS_ERROR: Empty filter chain + * (filters[0].id == LZMA_VLI_UNKNOWN) or the filter chain + * includes a Filter ID that is not supported by this function. + * - LZMA_MEM_ERROR + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_str_from_filters( + char **str, const lzma_filter *filters, uint32_t flags, + const lzma_allocator *allocator) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief List available filters and/or their options (for help message) + * + * If a filter_id is given then only one line is created which contains the + * filter name. If LZMA_STR_ENCODER or LZMA_STR_DECODER is used then the + * options read by the encoder or decoder are printed on the same line. + * + * If filter_id is LZMA_VLI_UNKNOWN then all supported .xz-compatible filters + * are listed: + * + * - If neither LZMA_STR_ENCODER nor LZMA_STR_DECODER is used then + * the supported filter names are listed on a single line separated + * by spaces. + * + * - If LZMA_STR_ENCODER or LZMA_STR_DECODER is used then filters and + * the supported options are listed one filter per line. There won't + * be a newline after the last filter. + * + * - If LZMA_STR_ALL_FILTERS is used then the list will include also + * those filters that cannot be used in the .xz format (LZMA1). + * + * \param str On success *str will be set to point to an + * allocated string listing the filters and options. + * Old value is ignored. On error *str is always set + * to NULL. + * \param filter_id Filter ID or LZMA_VLI_UNKNOWN. + * \param flags Bitwise-or of zero or more of the flags + * LZMA_STR_ALL_FILTERS, LZMA_STR_ENCODER, + * LZMA_STR_DECODER, and LZMA_STR_GETOPT_LONG. + * \param allocator lzma_allocator for custom allocator functions. + * Set to NULL to use malloc() and free(). + * + * \return Possible lzma_ret values: + * - LZMA_OK + * - LZMA_OPTIONS_ERROR: Unsupported filter_id or flags + * - LZMA_MEM_ERROR + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_str_list_filters( + char **str, lzma_vli filter_id, uint32_t flags, + const lzma_allocator *allocator) + lzma_nothrow lzma_attr_warn_unused_result; diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/hardware.h b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/hardware.h new file mode 100644 index 0000000000000000000000000000000000000000..7a1a84fcccfcbc3a05111789f142dc1bb6697685 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/hardware.h @@ -0,0 +1,62 @@ +/* SPDX-License-Identifier: 0BSD */ + +/** + * \file lzma/hardware.h + * \brief Hardware information + * \note Never include this file directly. Use instead. + * + * Since liblzma can consume a lot of system resources, it also provides + * ways to limit the resource usage. Applications linking against liblzma + * need to do the actual decisions how much resources to let liblzma to use. + * To ease making these decisions, liblzma provides functions to find out + * the relevant capabilities of the underlying hardware. Currently there + * is only a function to find out the amount of RAM, but in the future there + * will be also a function to detect how many concurrent threads the system + * can run. + * + * \note On some operating systems, these function may temporarily + * load a shared library or open file descriptor(s) to find out + * the requested hardware information. Unless the application + * assumes that specific file descriptors are not touched by + * other threads, this should have no effect on thread safety. + * Possible operations involving file descriptors will restart + * the syscalls if they return EINTR. + */ + +/* + * Author: Lasse Collin + */ + +#ifndef LZMA_H_INTERNAL +# error Never include this file directly. Use instead. +#endif + + +/** + * \brief Get the total amount of physical memory (RAM) in bytes + * + * This function may be useful when determining a reasonable memory + * usage limit for decompressing or how much memory it is OK to use + * for compressing. + * + * \return On success, the total amount of physical memory in bytes + * is returned. If the amount of RAM cannot be determined, + * zero is returned. This can happen if an error occurs + * or if there is no code in liblzma to detect the amount + * of RAM on the specific operating system. + */ +extern LZMA_API(uint64_t) lzma_physmem(void) lzma_nothrow; + + +/** + * \brief Get the number of processor cores or threads + * + * This function may be useful when determining how many threads to use. + * If the hardware supports more than one thread per CPU core, the number + * of hardware threads is returned if that information is available. + * + * \return On success, the number of available CPU threads or cores is + * returned. If this information isn't available or an error + * occurs, zero is returned. + */ +extern LZMA_API(uint32_t) lzma_cputhreads(void) lzma_nothrow; diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/index.h b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/index.h new file mode 100644 index 0000000000000000000000000000000000000000..b17025e3d901663b7a44bdf988e93c2f83db6c45 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/index.h @@ -0,0 +1,882 @@ +/* SPDX-License-Identifier: 0BSD */ + +/** + * \file lzma/index.h + * \brief Handling of .xz Index and related information + * \note Never include this file directly. Use instead. + */ + +/* + * Author: Lasse Collin + */ + +#ifndef LZMA_H_INTERNAL +# error Never include this file directly. Use instead. +#endif + + +/** + * \brief Opaque data type to hold the Index(es) and other information + * + * lzma_index often holds just one .xz Index and possibly the Stream Flags + * of the same Stream and size of the Stream Padding field. However, + * multiple lzma_indexes can be concatenated with lzma_index_cat() and then + * there may be information about multiple Streams in the same lzma_index. + * + * Notes about thread safety: Only one thread may modify lzma_index at + * a time. All functions that take non-const pointer to lzma_index + * modify it. As long as no thread is modifying the lzma_index, getting + * information from the same lzma_index can be done from multiple threads + * at the same time with functions that take a const pointer to + * lzma_index or use lzma_index_iter. The same iterator must be used + * only by one thread at a time, of course, but there can be as many + * iterators for the same lzma_index as needed. + */ +typedef struct lzma_index_s lzma_index; + + +/** + * \brief Iterator to get information about Blocks and Streams + */ +typedef struct { + struct { + /** + * \brief Pointer to Stream Flags + * + * This is NULL if Stream Flags have not been set for + * this Stream with lzma_index_stream_flags(). + */ + const lzma_stream_flags *flags; + + /** \private Reserved member. */ + const void *reserved_ptr1; + + /** \private Reserved member. */ + const void *reserved_ptr2; + + /** \private Reserved member. */ + const void *reserved_ptr3; + + /** + * \brief Stream number in the lzma_index + * + * The first Stream is 1. + */ + lzma_vli number; + + /** + * \brief Number of Blocks in the Stream + * + * If this is zero, the block structure below has + * undefined values. + */ + lzma_vli block_count; + + /** + * \brief Compressed start offset of this Stream + * + * The offset is relative to the beginning of the lzma_index + * (i.e. usually the beginning of the .xz file). + */ + lzma_vli compressed_offset; + + /** + * \brief Uncompressed start offset of this Stream + * + * The offset is relative to the beginning of the lzma_index + * (i.e. usually the beginning of the .xz file). + */ + lzma_vli uncompressed_offset; + + /** + * \brief Compressed size of this Stream + * + * This includes all headers except the possible + * Stream Padding after this Stream. + */ + lzma_vli compressed_size; + + /** + * \brief Uncompressed size of this Stream + */ + lzma_vli uncompressed_size; + + /** + * \brief Size of Stream Padding after this Stream + * + * If it hasn't been set with lzma_index_stream_padding(), + * this defaults to zero. Stream Padding is always + * a multiple of four bytes. + */ + lzma_vli padding; + + + /** \private Reserved member. */ + lzma_vli reserved_vli1; + + /** \private Reserved member. */ + lzma_vli reserved_vli2; + + /** \private Reserved member. */ + lzma_vli reserved_vli3; + + /** \private Reserved member. */ + lzma_vli reserved_vli4; + } stream; + + struct { + /** + * \brief Block number in the file + * + * The first Block is 1. + */ + lzma_vli number_in_file; + + /** + * \brief Compressed start offset of this Block + * + * This offset is relative to the beginning of the + * lzma_index (i.e. usually the beginning of the .xz file). + * Normally this is where you should seek in the .xz file + * to start decompressing this Block. + */ + lzma_vli compressed_file_offset; + + /** + * \brief Uncompressed start offset of this Block + * + * This offset is relative to the beginning of the lzma_index + * (i.e. usually the beginning of the .xz file). + * + * When doing random-access reading, it is possible that + * the target offset is not exactly at Block boundary. One + * will need to compare the target offset against + * uncompressed_file_offset or uncompressed_stream_offset, + * and possibly decode and throw away some amount of data + * before reaching the target offset. + */ + lzma_vli uncompressed_file_offset; + + /** + * \brief Block number in this Stream + * + * The first Block is 1. + */ + lzma_vli number_in_stream; + + /** + * \brief Compressed start offset of this Block + * + * This offset is relative to the beginning of the Stream + * containing this Block. + */ + lzma_vli compressed_stream_offset; + + /** + * \brief Uncompressed start offset of this Block + * + * This offset is relative to the beginning of the Stream + * containing this Block. + */ + lzma_vli uncompressed_stream_offset; + + /** + * \brief Uncompressed size of this Block + * + * You should pass this to the Block decoder if you will + * decode this Block. It will allow the Block decoder to + * validate the uncompressed size. + */ + lzma_vli uncompressed_size; + + /** + * \brief Unpadded size of this Block + * + * You should pass this to the Block decoder if you will + * decode this Block. It will allow the Block decoder to + * validate the unpadded size. + */ + lzma_vli unpadded_size; + + /** + * \brief Total compressed size + * + * This includes all headers and padding in this Block. + * This is useful if you need to know how many bytes + * the Block decoder will actually read. + */ + lzma_vli total_size; + + /** \private Reserved member. */ + lzma_vli reserved_vli1; + + /** \private Reserved member. */ + lzma_vli reserved_vli2; + + /** \private Reserved member. */ + lzma_vli reserved_vli3; + + /** \private Reserved member. */ + lzma_vli reserved_vli4; + + /** \private Reserved member. */ + const void *reserved_ptr1; + + /** \private Reserved member. */ + const void *reserved_ptr2; + + /** \private Reserved member. */ + const void *reserved_ptr3; + + /** \private Reserved member. */ + const void *reserved_ptr4; + } block; + + /** + * \private Internal data + * + * Internal data which is used to store the state of the iterator. + * The exact format may vary between liblzma versions, so don't + * touch these in any way. + */ + union { + /** \private Internal member. */ + const void *p; + + /** \private Internal member. */ + size_t s; + + /** \private Internal member. */ + lzma_vli v; + } internal[6]; +} lzma_index_iter; + + +/** + * \brief Operation mode for lzma_index_iter_next() + */ +typedef enum { + LZMA_INDEX_ITER_ANY = 0, + /**< + * \brief Get the next Block or Stream + * + * Go to the next Block if the current Stream has at least + * one Block left. Otherwise go to the next Stream even if + * it has no Blocks. If the Stream has no Blocks + * (lzma_index_iter.stream.block_count == 0), + * lzma_index_iter.block will have undefined values. + */ + + LZMA_INDEX_ITER_STREAM = 1, + /**< + * \brief Get the next Stream + * + * Go to the next Stream even if the current Stream has + * unread Blocks left. If the next Stream has at least one + * Block, the iterator will point to the first Block. + * If there are no Blocks, lzma_index_iter.block will have + * undefined values. + */ + + LZMA_INDEX_ITER_BLOCK = 2, + /**< + * \brief Get the next Block + * + * Go to the next Block if the current Stream has at least + * one Block left. If the current Stream has no Blocks left, + * the next Stream with at least one Block is located and + * the iterator will be made to point to the first Block of + * that Stream. + */ + + LZMA_INDEX_ITER_NONEMPTY_BLOCK = 3 + /**< + * \brief Get the next non-empty Block + * + * This is like LZMA_INDEX_ITER_BLOCK except that it will + * skip Blocks whose Uncompressed Size is zero. + */ + +} lzma_index_iter_mode; + + +/** + * \brief Mask for return value from lzma_index_checks() for check none + * + * \note This and the other CHECK_MASK macros were added in 5.5.1alpha. + */ +#define LZMA_INDEX_CHECK_MASK_NONE (UINT32_C(1) << LZMA_CHECK_NONE) + +/** + * \brief Mask for return value from lzma_index_checks() for check CRC32 + */ +#define LZMA_INDEX_CHECK_MASK_CRC32 (UINT32_C(1) << LZMA_CHECK_CRC32) + +/** + * \brief Mask for return value from lzma_index_checks() for check CRC64 + */ +#define LZMA_INDEX_CHECK_MASK_CRC64 (UINT32_C(1) << LZMA_CHECK_CRC64) + +/** + * \brief Mask for return value from lzma_index_checks() for check SHA256 + */ +#define LZMA_INDEX_CHECK_MASK_SHA256 (UINT32_C(1) << LZMA_CHECK_SHA256) + +/** + * \brief Calculate memory usage of lzma_index + * + * On disk, the size of the Index field depends on both the number of Records + * stored and the size of the Records (due to variable-length integer + * encoding). When the Index is kept in lzma_index structure, the memory usage + * depends only on the number of Records/Blocks stored in the Index(es), and + * in case of concatenated lzma_indexes, the number of Streams. The size in + * RAM is almost always significantly bigger than in the encoded form on disk. + * + * This function calculates an approximate amount of memory needed to hold + * the given number of Streams and Blocks in lzma_index structure. This + * value may vary between CPU architectures and also between liblzma versions + * if the internal implementation is modified. + * + * \param streams Number of Streams + * \param blocks Number of Blocks + * + * \return Approximate memory in bytes needed in a lzma_index structure. + */ +extern LZMA_API(uint64_t) lzma_index_memusage( + lzma_vli streams, lzma_vli blocks) lzma_nothrow; + + +/** + * \brief Calculate the memory usage of an existing lzma_index + * + * This is a shorthand for lzma_index_memusage(lzma_index_stream_count(i), + * lzma_index_block_count(i)). + * + * \param i Pointer to lzma_index structure + * + * \return Approximate memory in bytes used by the lzma_index structure. + */ +extern LZMA_API(uint64_t) lzma_index_memused(const lzma_index *i) + lzma_nothrow; + + +/** + * \brief Allocate and initialize a new lzma_index structure + * + * \param allocator lzma_allocator for custom allocator functions. + * Set to NULL to use malloc() and free(). + * + * \return On success, a pointer to an empty initialized lzma_index is + * returned. If allocation fails, NULL is returned. + */ +extern LZMA_API(lzma_index *) lzma_index_init(const lzma_allocator *allocator) + lzma_nothrow; + + +/** + * \brief Deallocate lzma_index + * + * If i is NULL, this does nothing. + * + * \param i Pointer to lzma_index structure to deallocate + * \param allocator lzma_allocator for custom allocator functions. + * Set to NULL to use malloc() and free(). + */ +extern LZMA_API(void) lzma_index_end( + lzma_index *i, const lzma_allocator *allocator) lzma_nothrow; + + +/** + * \brief Add a new Block to lzma_index + * + * \param i Pointer to a lzma_index structure + * \param allocator lzma_allocator for custom allocator + * functions. Set to NULL to use malloc() + * and free(). + * \param unpadded_size Unpadded Size of a Block. This can be + * calculated with lzma_block_unpadded_size() + * after encoding or decoding the Block. + * \param uncompressed_size Uncompressed Size of a Block. This can be + * taken directly from lzma_block structure + * after encoding or decoding the Block. + * + * Appending a new Block does not invalidate iterators. For example, + * if an iterator was pointing to the end of the lzma_index, after + * lzma_index_append() it is possible to read the next Block with + * an existing iterator. + * + * \return Possible lzma_ret values: + * - LZMA_OK + * - LZMA_MEM_ERROR + * - LZMA_DATA_ERROR: Compressed or uncompressed size of the + * Stream or size of the Index field would grow too big. + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_index_append( + lzma_index *i, const lzma_allocator *allocator, + lzma_vli unpadded_size, lzma_vli uncompressed_size) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Set the Stream Flags + * + * Set the Stream Flags of the last (and typically the only) Stream + * in lzma_index. This can be useful when reading information from the + * lzma_index, because to decode Blocks, knowing the integrity check type + * is needed. + * + * \param i Pointer to lzma_index structure + * \param stream_flags Pointer to lzma_stream_flags structure. This + * is copied into the internal preallocated + * structure, so the caller doesn't need to keep + * the flags' data available after calling this + * function. + * + * \return Possible lzma_ret values: + * - LZMA_OK + * - LZMA_OPTIONS_ERROR: Unsupported stream_flags->version. + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_index_stream_flags( + lzma_index *i, const lzma_stream_flags *stream_flags) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Get the types of integrity Checks + * + * If lzma_index_stream_flags() is used to set the Stream Flags for + * every Stream, lzma_index_checks() can be used to get a bitmask to + * indicate which Check types have been used. It can be useful e.g. if + * showing the Check types to the user. + * + * The bitmask is 1 << check_id, e.g. CRC32 is 1 << 1 and SHA-256 is 1 << 10. + * These masks are defined for convenience as LZMA_INDEX_CHECK_MASK_XXX + * + * \param i Pointer to lzma_index structure + * + * \return Bitmask indicating which Check types are used in the lzma_index + */ +extern LZMA_API(uint32_t) lzma_index_checks(const lzma_index *i) + lzma_nothrow lzma_attr_pure; + + +/** + * \brief Set the amount of Stream Padding + * + * Set the amount of Stream Padding of the last (and typically the only) + * Stream in the lzma_index. This is needed when planning to do random-access + * reading within multiple concatenated Streams. + * + * By default, the amount of Stream Padding is assumed to be zero bytes. + * + * \return Possible lzma_ret values: + * - LZMA_OK + * - LZMA_DATA_ERROR: The file size would grow too big. + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_index_stream_padding( + lzma_index *i, lzma_vli stream_padding) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Get the number of Streams + * + * \param i Pointer to lzma_index structure + * + * \return Number of Streams in the lzma_index + */ +extern LZMA_API(lzma_vli) lzma_index_stream_count(const lzma_index *i) + lzma_nothrow lzma_attr_pure; + + +/** + * \brief Get the number of Blocks + * + * This returns the total number of Blocks in lzma_index. To get number + * of Blocks in individual Streams, use lzma_index_iter. + * + * \param i Pointer to lzma_index structure + * + * \return Number of blocks in the lzma_index + */ +extern LZMA_API(lzma_vli) lzma_index_block_count(const lzma_index *i) + lzma_nothrow lzma_attr_pure; + + +/** + * \brief Get the size of the Index field as bytes + * + * This is needed to verify the Backward Size field in the Stream Footer. + * + * \param i Pointer to lzma_index structure + * + * \return Size in bytes of the Index + */ +extern LZMA_API(lzma_vli) lzma_index_size(const lzma_index *i) + lzma_nothrow lzma_attr_pure; + + +/** + * \brief Get the total size of the Stream + * + * If multiple lzma_indexes have been combined, this works as if the Blocks + * were in a single Stream. This is useful if you are going to combine + * Blocks from multiple Streams into a single new Stream. + * + * \param i Pointer to lzma_index structure + * + * \return Size in bytes of the Stream (if all Blocks are combined + * into one Stream). + */ +extern LZMA_API(lzma_vli) lzma_index_stream_size(const lzma_index *i) + lzma_nothrow lzma_attr_pure; + + +/** + * \brief Get the total size of the Blocks + * + * This doesn't include the Stream Header, Stream Footer, Stream Padding, + * or Index fields. + * + * \param i Pointer to lzma_index structure + * + * \return Size in bytes of all Blocks in the Stream(s) + */ +extern LZMA_API(lzma_vli) lzma_index_total_size(const lzma_index *i) + lzma_nothrow lzma_attr_pure; + + +/** + * \brief Get the total size of the file + * + * When no lzma_indexes have been combined with lzma_index_cat() and there is + * no Stream Padding, this function is identical to lzma_index_stream_size(). + * If multiple lzma_indexes have been combined, this includes also the headers + * of each separate Stream and the possible Stream Padding fields. + * + * \param i Pointer to lzma_index structure + * + * \return Total size of the .xz file in bytes + */ +extern LZMA_API(lzma_vli) lzma_index_file_size(const lzma_index *i) + lzma_nothrow lzma_attr_pure; + + +/** + * \brief Get the uncompressed size of the file + * + * \param i Pointer to lzma_index structure + * + * \return Size in bytes of the uncompressed data in the file + */ +extern LZMA_API(lzma_vli) lzma_index_uncompressed_size(const lzma_index *i) + lzma_nothrow lzma_attr_pure; + + +/** + * \brief Initialize an iterator + * + * This function associates the iterator with the given lzma_index, and calls + * lzma_index_iter_rewind() on the iterator. + * + * This function doesn't allocate any memory, thus there is no + * lzma_index_iter_end(). The iterator is valid as long as the + * associated lzma_index is valid, that is, until lzma_index_end() or + * using it as source in lzma_index_cat(). Specifically, lzma_index doesn't + * become invalid if new Blocks are added to it with lzma_index_append() or + * if it is used as the destination in lzma_index_cat(). + * + * It is safe to make copies of an initialized lzma_index_iter, for example, + * to easily restart reading at some particular position. + * + * \param iter Pointer to a lzma_index_iter structure + * \param i lzma_index to which the iterator will be associated + */ +extern LZMA_API(void) lzma_index_iter_init( + lzma_index_iter *iter, const lzma_index *i) lzma_nothrow; + + +/** + * \brief Rewind the iterator + * + * Rewind the iterator so that next call to lzma_index_iter_next() will + * return the first Block or Stream. + * + * \param iter Pointer to a lzma_index_iter structure + */ +extern LZMA_API(void) lzma_index_iter_rewind(lzma_index_iter *iter) + lzma_nothrow; + + +/** + * \brief Get the next Block or Stream + * + * \param iter Iterator initialized with lzma_index_iter_init() + * \param mode Specify what kind of information the caller wants + * to get. See lzma_index_iter_mode for details. + * + * \return lzma_bool: + * - true if no Block or Stream matching the mode is found. + * *iter is not updated (failure). + * - false if the next Block or Stream matching the mode was + * found. *iter is updated (success). + */ +extern LZMA_API(lzma_bool) lzma_index_iter_next( + lzma_index_iter *iter, lzma_index_iter_mode mode) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Locate a Block + * + * If it is possible to seek in the .xz file, it is possible to parse + * the Index field(s) and use lzma_index_iter_locate() to do random-access + * reading with granularity of Block size. + * + * If the target is smaller than the uncompressed size of the Stream (can be + * checked with lzma_index_uncompressed_size()): + * - Information about the Stream and Block containing the requested + * uncompressed offset is stored into *iter. + * - Internal state of the iterator is adjusted so that + * lzma_index_iter_next() can be used to read subsequent Blocks or Streams. + * + * If the target is greater than the uncompressed size of the Stream, *iter + * is not modified. + * + * \param iter Iterator that was earlier initialized with + * lzma_index_iter_init(). + * \param target Uncompressed target offset which the caller would + * like to locate from the Stream + * + * \return lzma_bool: + * - true if the target is greater than or equal to the + * uncompressed size of the Stream (failure) + * - false if the target is smaller than the uncompressed size + * of the Stream (success) + */ +extern LZMA_API(lzma_bool) lzma_index_iter_locate( + lzma_index_iter *iter, lzma_vli target) lzma_nothrow; + + +/** + * \brief Concatenate lzma_indexes + * + * Concatenating lzma_indexes is useful when doing random-access reading in + * multi-Stream .xz file, or when combining multiple Streams into single + * Stream. + * + * \param[out] dest lzma_index after which src is appended + * \param src lzma_index to be appended after dest. If this + * function succeeds, the memory allocated for src + * is freed or moved to be part of dest, and all + * iterators pointing to src will become invalid. + * \param allocator lzma_allocator for custom allocator functions. + * Set to NULL to use malloc() and free(). + * + * \return Possible lzma_ret values: + * - LZMA_OK: lzma_indexes were concatenated successfully. + * src is now a dangling pointer. + * - LZMA_DATA_ERROR: *dest would grow too big. + * - LZMA_MEM_ERROR + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_index_cat(lzma_index *dest, lzma_index *src, + const lzma_allocator *allocator) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Duplicate lzma_index + * + * \param i Pointer to lzma_index structure to be duplicated + * \param allocator lzma_allocator for custom allocator functions. + * Set to NULL to use malloc() and free(). + * + * \return A copy of the lzma_index, or NULL if memory allocation failed. + */ +extern LZMA_API(lzma_index *) lzma_index_dup( + const lzma_index *i, const lzma_allocator *allocator) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Initialize .xz Index encoder + * + * \param strm Pointer to properly prepared lzma_stream + * \param i Pointer to lzma_index which should be encoded. + * + * The valid 'action' values for lzma_code() are LZMA_RUN and LZMA_FINISH. + * It is enough to use only one of them (you can choose freely). + * + * \return Possible lzma_ret values: + * - LZMA_OK: Initialization succeeded, continue with lzma_code(). + * - LZMA_MEM_ERROR + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_index_encoder( + lzma_stream *strm, const lzma_index *i) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Initialize .xz Index decoder + * + * \param strm Pointer to properly prepared lzma_stream + * \param[out] i The decoded Index will be made available via + * this pointer. Initially this function will + * set *i to NULL (the old value is ignored). If + * decoding succeeds (lzma_code() returns + * LZMA_STREAM_END), *i will be set to point + * to a new lzma_index, which the application + * has to later free with lzma_index_end(). + * \param memlimit How much memory the resulting lzma_index is + * allowed to require. liblzma 5.2.3 and earlier + * don't allow 0 here and return LZMA_PROG_ERROR; + * later versions treat 0 as if 1 had been specified. + * + * Valid 'action' arguments to lzma_code() are LZMA_RUN and LZMA_FINISH. + * There is no need to use LZMA_FINISH, but it's allowed because it may + * simplify certain types of applications. + * + * \return Possible lzma_ret values: + * - LZMA_OK: Initialization succeeded, continue with lzma_code(). + * - LZMA_MEM_ERROR + * - LZMA_PROG_ERROR + * + * \note liblzma 5.2.3 and older list also LZMA_MEMLIMIT_ERROR here + * but that error code has never been possible from this + * initialization function. + */ +extern LZMA_API(lzma_ret) lzma_index_decoder( + lzma_stream *strm, lzma_index **i, uint64_t memlimit) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Single-call .xz Index encoder + * + * \note This function doesn't take allocator argument since all + * the internal data is allocated on stack. + * + * \param i lzma_index to be encoded + * \param[out] out Beginning of the output buffer + * \param[out] out_pos The next byte will be written to out[*out_pos]. + * *out_pos is updated only if encoding succeeds. + * \param out_size Size of the out buffer; the first byte into + * which no data is written to is out[out_size]. + * + * \return Possible lzma_ret values: + * - LZMA_OK: Encoding was successful. + * - LZMA_BUF_ERROR: Output buffer is too small. Use + * lzma_index_size() to find out how much output + * space is needed. + * - LZMA_PROG_ERROR + * + */ +extern LZMA_API(lzma_ret) lzma_index_buffer_encode(const lzma_index *i, + uint8_t *out, size_t *out_pos, size_t out_size) lzma_nothrow; + + +/** + * \brief Single-call .xz Index decoder + * + * \param[out] i If decoding succeeds, *i will point to a new + * lzma_index, which the application has to + * later free with lzma_index_end(). If an error + * occurs, *i will be NULL. The old value of *i + * is always ignored and thus doesn't need to be + * initialized by the caller. + * \param[out] memlimit Pointer to how much memory the resulting + * lzma_index is allowed to require. The value + * pointed by this pointer is modified if and only + * if LZMA_MEMLIMIT_ERROR is returned. + * \param allocator lzma_allocator for custom allocator functions. + * Set to NULL to use malloc() and free(). + * \param in Beginning of the input buffer + * \param in_pos The next byte will be read from in[*in_pos]. + * *in_pos is updated only if decoding succeeds. + * \param in_size Size of the input buffer; the first byte that + * won't be read is in[in_size]. + * + * \return Possible lzma_ret values: + * - LZMA_OK: Decoding was successful. + * - LZMA_MEM_ERROR + * - LZMA_MEMLIMIT_ERROR: Memory usage limit was reached. + * The minimum required memlimit value was stored to *memlimit. + * - LZMA_DATA_ERROR + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_index_buffer_decode(lzma_index **i, + uint64_t *memlimit, const lzma_allocator *allocator, + const uint8_t *in, size_t *in_pos, size_t in_size) + lzma_nothrow; + + +/** + * \brief Initialize a .xz file information decoder + * + * This decoder decodes the Stream Header, Stream Footer, Index, and + * Stream Padding field(s) from the input .xz file and stores the resulting + * combined index in *dest_index. This information can be used to get the + * uncompressed file size with lzma_index_uncompressed_size(*dest_index) or, + * for example, to implement random access reading by locating the Blocks + * in the Streams. + * + * To get the required information from the .xz file, lzma_code() may ask + * the application to seek in the input file by returning LZMA_SEEK_NEEDED + * and having the target file position specified in lzma_stream.seek_pos. + * The number of seeks required depends on the input file and how big buffers + * the application provides. When possible, the decoder will seek backward + * and forward in the given buffer to avoid useless seek requests. Thus, if + * the application provides the whole file at once, no external seeking will + * be required (that is, lzma_code() won't return LZMA_SEEK_NEEDED). + * + * The value in lzma_stream.total_in can be used to estimate how much data + * liblzma had to read to get the file information. However, due to seeking + * and the way total_in is updated, the value of total_in will be somewhat + * inaccurate (a little too big). Thus, total_in is a good estimate but don't + * expect to see the same exact value for the same file if you change the + * input buffer size or switch to a different liblzma version. + * + * Valid 'action' arguments to lzma_code() are LZMA_RUN and LZMA_FINISH. + * You only need to use LZMA_RUN; LZMA_FINISH is only supported because it + * might be convenient for some applications. If you use LZMA_FINISH and if + * lzma_code() asks the application to seek, remember to reset 'action' back + * to LZMA_RUN unless you hit the end of the file again. + * + * Possible return values from lzma_code(): + * - LZMA_OK: All OK so far, more input needed + * - LZMA_SEEK_NEEDED: Provide more input starting from the absolute + * file position strm->seek_pos + * - LZMA_STREAM_END: Decoding was successful, *dest_index has been set + * - LZMA_FORMAT_ERROR: The input file is not in the .xz format (the + * expected magic bytes were not found from the beginning of the file) + * - LZMA_OPTIONS_ERROR: File looks valid but contains headers that aren't + * supported by this version of liblzma + * - LZMA_DATA_ERROR: File is corrupt + * - LZMA_BUF_ERROR + * - LZMA_MEM_ERROR + * - LZMA_MEMLIMIT_ERROR + * - LZMA_PROG_ERROR + * + * \param strm Pointer to a properly prepared lzma_stream + * \param[out] dest_index Pointer to a pointer where the decoder will put + * the decoded lzma_index. The old value + * of *dest_index is ignored (not freed). + * \param memlimit How much memory the resulting lzma_index is + * allowed to require. Use UINT64_MAX to + * effectively disable the limiter. + * \param file_size Size of the input .xz file + * + * \return Possible lzma_ret values: + * - LZMA_OK + * - LZMA_MEM_ERROR + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_file_info_decoder( + lzma_stream *strm, lzma_index **dest_index, + uint64_t memlimit, uint64_t file_size) + lzma_nothrow; diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/index_hash.h b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/index_hash.h new file mode 100644 index 0000000000000000000000000000000000000000..68f9024eb3bc66561107d1767c8585828546ef0d --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/index_hash.h @@ -0,0 +1,123 @@ +/* SPDX-License-Identifier: 0BSD */ + +/** + * \file lzma/index_hash.h + * \brief Validate Index by using a hash function + * \note Never include this file directly. Use instead. + * + * Hashing makes it possible to use constant amount of memory to validate + * Index of arbitrary size. + */ + +/* + * Author: Lasse Collin + */ + +#ifndef LZMA_H_INTERNAL +# error Never include this file directly. Use instead. +#endif + +/** + * \brief Opaque data type to hold the Index hash + */ +typedef struct lzma_index_hash_s lzma_index_hash; + + +/** + * \brief Allocate and initialize a new lzma_index_hash structure + * + * If index_hash is NULL, this function allocates and initializes a new + * lzma_index_hash structure and returns a pointer to it. If allocation + * fails, NULL is returned. + * + * If index_hash is non-NULL, this function reinitializes the lzma_index_hash + * structure and returns the same pointer. In this case, return value cannot + * be NULL or a different pointer than the index_hash that was given as + * an argument. + * + * \param index_hash Pointer to a lzma_index_hash structure or NULL. + * \param allocator lzma_allocator for custom allocator functions. + * Set to NULL to use malloc() and free(). + * + * \return Initialized lzma_index_hash structure on success or + * NULL on failure. + */ +extern LZMA_API(lzma_index_hash *) lzma_index_hash_init( + lzma_index_hash *index_hash, const lzma_allocator *allocator) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Deallocate lzma_index_hash structure + * + * \param index_hash Pointer to a lzma_index_hash structure to free. + * \param allocator lzma_allocator for custom allocator functions. + * Set to NULL to use malloc() and free(). + */ +extern LZMA_API(void) lzma_index_hash_end( + lzma_index_hash *index_hash, const lzma_allocator *allocator) + lzma_nothrow; + + +/** + * \brief Add a new Record to an Index hash + * + * \param index_hash Pointer to a lzma_index_hash structure + * \param unpadded_size Unpadded Size of a Block + * \param uncompressed_size Uncompressed Size of a Block + * + * \return Possible lzma_ret values: + * - LZMA_OK + * - LZMA_DATA_ERROR: Compressed or uncompressed size of the + * Stream or size of the Index field would grow too big. + * - LZMA_PROG_ERROR: Invalid arguments or this function is being + * used when lzma_index_hash_decode() has already been used. + */ +extern LZMA_API(lzma_ret) lzma_index_hash_append(lzma_index_hash *index_hash, + lzma_vli unpadded_size, lzma_vli uncompressed_size) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Decode and validate the Index field + * + * After telling the sizes of all Blocks with lzma_index_hash_append(), + * the actual Index field is decoded with this function. Specifically, + * once decoding of the Index field has been started, no more Records + * can be added using lzma_index_hash_append(). + * + * This function doesn't use lzma_stream structure to pass the input data. + * Instead, the input buffer is specified using three arguments. This is + * because it matches better the internal APIs of liblzma. + * + * \param index_hash Pointer to a lzma_index_hash structure + * \param in Pointer to the beginning of the input buffer + * \param[out] in_pos in[*in_pos] is the next byte to process + * \param in_size in[in_size] is the first byte not to process + * + * \return Possible lzma_ret values: + * - LZMA_OK: So far good, but more input is needed. + * - LZMA_STREAM_END: Index decoded successfully and it matches + * the Records given with lzma_index_hash_append(). + * - LZMA_DATA_ERROR: Index is corrupt or doesn't match the + * information given with lzma_index_hash_append(). + * - LZMA_BUF_ERROR: Cannot progress because *in_pos >= in_size. + * - LZMA_PROG_ERROR + */ +extern LZMA_API(lzma_ret) lzma_index_hash_decode(lzma_index_hash *index_hash, + const uint8_t *in, size_t *in_pos, size_t in_size) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Get the size of the Index field as bytes + * + * This is needed to verify the Backward Size field in the Stream Footer. + * + * \param index_hash Pointer to a lzma_index_hash structure + * + * \return Size of the Index field in bytes. + */ +extern LZMA_API(lzma_vli) lzma_index_hash_size( + const lzma_index_hash *index_hash) + lzma_nothrow lzma_attr_pure; diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/lzma12.h b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/lzma12.h new file mode 100644 index 0000000000000000000000000000000000000000..fec3e0dadb2332561697c8cb996b9d76d686f3dc --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/lzma12.h @@ -0,0 +1,568 @@ +/* SPDX-License-Identifier: 0BSD */ + +/** + * \file lzma/lzma12.h + * \brief LZMA1 and LZMA2 filters + * \note Never include this file directly. Use instead. + */ + +/* + * Author: Lasse Collin + */ + +#ifndef LZMA_H_INTERNAL +# error Never include this file directly. Use instead. +#endif + + +/** + * \brief LZMA1 Filter ID (for raw encoder/decoder only, not in .xz) + * + * LZMA1 is the very same thing as what was called just LZMA in LZMA Utils, + * 7-Zip, and LZMA SDK. It's called LZMA1 here to prevent developers from + * accidentally using LZMA when they actually want LZMA2. + */ +#define LZMA_FILTER_LZMA1 LZMA_VLI_C(0x4000000000000001) + +/** + * \brief LZMA1 Filter ID with extended options (for raw encoder/decoder) + * + * This is like LZMA_FILTER_LZMA1 but with this ID a few extra options + * are supported in the lzma_options_lzma structure: + * + * - A flag to tell the encoder if the end of payload marker (EOPM) alias + * end of stream (EOS) marker must be written at the end of the stream. + * In contrast, LZMA_FILTER_LZMA1 always writes the end marker. + * + * - Decoder needs to be told the uncompressed size of the stream + * or that it is unknown (using the special value UINT64_MAX). + * If the size is known, a flag can be set to allow the presence of + * the end marker anyway. In contrast, LZMA_FILTER_LZMA1 always + * behaves as if the uncompressed size was unknown. + * + * This allows handling file formats where LZMA1 streams are used but where + * the end marker isn't allowed or where it might not (always) be present. + * This extended LZMA1 functionality is provided as a Filter ID for raw + * encoder and decoder instead of adding new encoder and decoder initialization + * functions because this way it is possible to also use extra filters, + * for example, LZMA_FILTER_X86 in a filter chain with LZMA_FILTER_LZMA1EXT, + * which might be needed to handle some file formats. + */ +#define LZMA_FILTER_LZMA1EXT LZMA_VLI_C(0x4000000000000002) + +/** + * \brief LZMA2 Filter ID + * + * Usually you want this instead of LZMA1. Compared to LZMA1, LZMA2 adds + * support for LZMA_SYNC_FLUSH, uncompressed chunks (smaller expansion + * when trying to compress incompressible data), possibility to change + * lc/lp/pb in the middle of encoding, and some other internal improvements. + */ +#define LZMA_FILTER_LZMA2 LZMA_VLI_C(0x21) + + +/** + * \brief Match finders + * + * Match finder has major effect on both speed and compression ratio. + * Usually hash chains are faster than binary trees. + * + * If you will use LZMA_SYNC_FLUSH often, the hash chains may be a better + * choice, because binary trees get much higher compression ratio penalty + * with LZMA_SYNC_FLUSH. + * + * The memory usage formulas are only rough estimates, which are closest to + * reality when dict_size is a power of two. The formulas are more complex + * in reality, and can also change a little between liblzma versions. Use + * lzma_raw_encoder_memusage() to get more accurate estimate of memory usage. + */ +typedef enum { + LZMA_MF_HC3 = 0x03, + /**< + * \brief Hash Chain with 2- and 3-byte hashing + * + * Minimum nice_len: 3 + * + * Memory usage: + * - dict_size <= 16 MiB: dict_size * 7.5 + * - dict_size > 16 MiB: dict_size * 5.5 + 64 MiB + */ + + LZMA_MF_HC4 = 0x04, + /**< + * \brief Hash Chain with 2-, 3-, and 4-byte hashing + * + * Minimum nice_len: 4 + * + * Memory usage: + * - dict_size <= 32 MiB: dict_size * 7.5 + * - dict_size > 32 MiB: dict_size * 6.5 + */ + + LZMA_MF_BT2 = 0x12, + /**< + * \brief Binary Tree with 2-byte hashing + * + * Minimum nice_len: 2 + * + * Memory usage: dict_size * 9.5 + */ + + LZMA_MF_BT3 = 0x13, + /**< + * \brief Binary Tree with 2- and 3-byte hashing + * + * Minimum nice_len: 3 + * + * Memory usage: + * - dict_size <= 16 MiB: dict_size * 11.5 + * - dict_size > 16 MiB: dict_size * 9.5 + 64 MiB + */ + + LZMA_MF_BT4 = 0x14 + /**< + * \brief Binary Tree with 2-, 3-, and 4-byte hashing + * + * Minimum nice_len: 4 + * + * Memory usage: + * - dict_size <= 32 MiB: dict_size * 11.5 + * - dict_size > 32 MiB: dict_size * 10.5 + */ +} lzma_match_finder; + + +/** + * \brief Test if given match finder is supported + * + * It is safe to call this with a value that isn't listed in + * lzma_match_finder enumeration; the return value will be false. + * + * There is no way to list which match finders are available in this + * particular liblzma version and build. It would be useless, because + * a new match finder, which the application developer wasn't aware, + * could require giving additional options to the encoder that the older + * match finders don't need. + * + * \param match_finder Match finder ID + * + * \return lzma_bool: + * - true if the match finder is supported by this liblzma build. + * - false otherwise. + */ +extern LZMA_API(lzma_bool) lzma_mf_is_supported(lzma_match_finder match_finder) + lzma_nothrow lzma_attr_const; + + +/** + * \brief Compression modes + * + * This selects the function used to analyze the data produced by the match + * finder. + */ +typedef enum { + LZMA_MODE_FAST = 1, + /**< + * \brief Fast compression + * + * Fast mode is usually at its best when combined with + * a hash chain match finder. + */ + + LZMA_MODE_NORMAL = 2 + /**< + * \brief Normal compression + * + * This is usually notably slower than fast mode. Use this + * together with binary tree match finders to expose the + * full potential of the LZMA1 or LZMA2 encoder. + */ +} lzma_mode; + + +/** + * \brief Test if given compression mode is supported + * + * It is safe to call this with a value that isn't listed in lzma_mode + * enumeration; the return value will be false. + * + * There is no way to list which modes are available in this particular + * liblzma version and build. It would be useless, because a new compression + * mode, which the application developer wasn't aware, could require giving + * additional options to the encoder that the older modes don't need. + * + * \param mode Mode ID. + * + * \return lzma_bool: + * - true if the compression mode is supported by this liblzma + * build. + * - false otherwise. + */ +extern LZMA_API(lzma_bool) lzma_mode_is_supported(lzma_mode mode) + lzma_nothrow lzma_attr_const; + + +/** + * \brief Options specific to the LZMA1 and LZMA2 filters + * + * Since LZMA1 and LZMA2 share most of the code, it's simplest to share + * the options structure too. For encoding, all but the reserved variables + * need to be initialized unless specifically mentioned otherwise. + * lzma_lzma_preset() can be used to get a good starting point. + * + * For raw decoding, both LZMA1 and LZMA2 need dict_size, preset_dict, and + * preset_dict_size (if preset_dict != NULL). LZMA1 needs also lc, lp, and pb. + */ +typedef struct { + /** + * \brief Dictionary size in bytes + * + * Dictionary size indicates how many bytes of the recently processed + * uncompressed data is kept in memory. One method to reduce size of + * the uncompressed data is to store distance-length pairs, which + * indicate what data to repeat from the dictionary buffer. Thus, + * the bigger the dictionary, the better the compression ratio + * usually is. + * + * Maximum size of the dictionary depends on multiple things: + * - Memory usage limit + * - Available address space (not a problem on 64-bit systems) + * - Selected match finder (encoder only) + * + * Currently the maximum dictionary size for encoding is 1.5 GiB + * (i.e. (UINT32_C(1) << 30) + (UINT32_C(1) << 29)) even on 64-bit + * systems for certain match finder implementation reasons. In the + * future, there may be match finders that support bigger + * dictionaries. + * + * Decoder already supports dictionaries up to 4 GiB - 1 B (i.e. + * UINT32_MAX), so increasing the maximum dictionary size of the + * encoder won't cause problems for old decoders. + * + * Because extremely small dictionaries sizes would have unneeded + * overhead in the decoder, the minimum dictionary size is 4096 bytes. + * + * \note When decoding, too big dictionary does no other harm + * than wasting memory. + */ + uint32_t dict_size; +# define LZMA_DICT_SIZE_MIN UINT32_C(4096) +# define LZMA_DICT_SIZE_DEFAULT (UINT32_C(1) << 23) + + /** + * \brief Pointer to an initial dictionary + * + * It is possible to initialize the LZ77 history window using + * a preset dictionary. It is useful when compressing many + * similar, relatively small chunks of data independently from + * each other. The preset dictionary should contain typical + * strings that occur in the files being compressed. The most + * probable strings should be near the end of the preset dictionary. + * + * This feature should be used only in special situations. For + * now, it works correctly only with raw encoding and decoding. + * Currently none of the container formats supported by + * liblzma allow preset dictionary when decoding, thus if + * you create a .xz or .lzma file with preset dictionary, it + * cannot be decoded with the regular decoder functions. In the + * future, the .xz format will likely get support for preset + * dictionary though. + */ + const uint8_t *preset_dict; + + /** + * \brief Size of the preset dictionary + * + * Specifies the size of the preset dictionary. If the size is + * bigger than dict_size, only the last dict_size bytes are + * processed. + * + * This variable is read only when preset_dict is not NULL. + * If preset_dict is not NULL but preset_dict_size is zero, + * no preset dictionary is used (identical to only setting + * preset_dict to NULL). + */ + uint32_t preset_dict_size; + + /** + * \brief Number of literal context bits + * + * How many of the highest bits of the previous uncompressed + * eight-bit byte (also known as 'literal') are taken into + * account when predicting the bits of the next literal. + * + * E.g. in typical English text, an upper-case letter is + * often followed by a lower-case letter, and a lower-case + * letter is usually followed by another lower-case letter. + * In the US-ASCII character set, the highest three bits are 010 + * for upper-case letters and 011 for lower-case letters. + * When lc is at least 3, the literal coding can take advantage of + * this property in the uncompressed data. + * + * There is a limit that applies to literal context bits and literal + * position bits together: lc + lp <= 4. Without this limit the + * decoding could become very slow, which could have security related + * results in some cases like email servers doing virus scanning. + * This limit also simplifies the internal implementation in liblzma. + * + * There may be LZMA1 streams that have lc + lp > 4 (maximum possible + * lc would be 8). It is not possible to decode such streams with + * liblzma. + */ + uint32_t lc; +# define LZMA_LCLP_MIN 0 +# define LZMA_LCLP_MAX 4 +# define LZMA_LC_DEFAULT 3 + + /** + * \brief Number of literal position bits + * + * lp affects what kind of alignment in the uncompressed data is + * assumed when encoding literals. A literal is a single 8-bit byte. + * See pb below for more information about alignment. + */ + uint32_t lp; +# define LZMA_LP_DEFAULT 0 + + /** + * \brief Number of position bits + * + * pb affects what kind of alignment in the uncompressed data is + * assumed in general. The default means four-byte alignment + * (2^ pb =2^2=4), which is often a good choice when there's + * no better guess. + * + * When the alignment is known, setting pb accordingly may reduce + * the file size a little. E.g. with text files having one-byte + * alignment (US-ASCII, ISO-8859-*, UTF-8), setting pb=0 can + * improve compression slightly. For UTF-16 text, pb=1 is a good + * choice. If the alignment is an odd number like 3 bytes, pb=0 + * might be the best choice. + * + * Even though the assumed alignment can be adjusted with pb and + * lp, LZMA1 and LZMA2 still slightly favor 16-byte alignment. + * It might be worth taking into account when designing file formats + * that are likely to be often compressed with LZMA1 or LZMA2. + */ + uint32_t pb; +# define LZMA_PB_MIN 0 +# define LZMA_PB_MAX 4 +# define LZMA_PB_DEFAULT 2 + + /** Compression mode */ + lzma_mode mode; + + /** + * \brief Nice length of a match + * + * This determines how many bytes the encoder compares from the match + * candidates when looking for the best match. Once a match of at + * least nice_len bytes long is found, the encoder stops looking for + * better candidates and encodes the match. (Naturally, if the found + * match is actually longer than nice_len, the actual length is + * encoded; it's not truncated to nice_len.) + * + * Bigger values usually increase the compression ratio and + * compression time. For most files, 32 to 128 is a good value, + * which gives very good compression ratio at good speed. + * + * The exact minimum value depends on the match finder. The maximum + * is 273, which is the maximum length of a match that LZMA1 and + * LZMA2 can encode. + */ + uint32_t nice_len; + + /** Match finder ID */ + lzma_match_finder mf; + + /** + * \brief Maximum search depth in the match finder + * + * For every input byte, match finder searches through the hash chain + * or binary tree in a loop, each iteration going one step deeper in + * the chain or tree. The searching stops if + * - a match of at least nice_len bytes long is found; + * - all match candidates from the hash chain or binary tree have + * been checked; or + * - maximum search depth is reached. + * + * Maximum search depth is needed to prevent the match finder from + * wasting too much time in case there are lots of short match + * candidates. On the other hand, stopping the search before all + * candidates have been checked can reduce compression ratio. + * + * Setting depth to zero tells liblzma to use an automatic default + * value, that depends on the selected match finder and nice_len. + * The default is in the range [4, 200] or so (it may vary between + * liblzma versions). + * + * Using a bigger depth value than the default can increase + * compression ratio in some cases. There is no strict maximum value, + * but high values (thousands or millions) should be used with care: + * the encoder could remain fast enough with typical input, but + * malicious input could cause the match finder to slow down + * dramatically, possibly creating a denial of service attack. + */ + uint32_t depth; + + /** + * \brief For LZMA_FILTER_LZMA1EXT: Extended flags + * + * This is used only with LZMA_FILTER_LZMA1EXT. + * + * Currently only one flag is supported, LZMA_LZMA1EXT_ALLOW_EOPM: + * + * - Encoder: If the flag is set, then end marker is written just + * like it is with LZMA_FILTER_LZMA1. Without this flag the + * end marker isn't written and the application has to store + * the uncompressed size somewhere outside the compressed stream. + * To decompress streams without the end marker, the application + * has to set the correct uncompressed size in ext_size_low and + * ext_size_high. + * + * - Decoder: If the uncompressed size in ext_size_low and + * ext_size_high is set to the special value UINT64_MAX + * (indicating unknown uncompressed size) then this flag is + * ignored and the end marker must always be present, that is, + * the behavior is identical to LZMA_FILTER_LZMA1. + * + * Otherwise, if this flag isn't set, then the input stream + * must not have the end marker; if the end marker is detected + * then it will result in LZMA_DATA_ERROR. This is useful when + * it is known that the stream must not have the end marker and + * strict validation is wanted. + * + * If this flag is set, then it is autodetected if the end marker + * is present after the specified number of uncompressed bytes + * has been decompressed (ext_size_low and ext_size_high). The + * end marker isn't allowed in any other position. This behavior + * is useful when uncompressed size is known but the end marker + * may or may not be present. This is the case, for example, + * in .7z files (valid .7z files that have the end marker in + * LZMA1 streams are rare but they do exist). + */ + uint32_t ext_flags; +# define LZMA_LZMA1EXT_ALLOW_EOPM UINT32_C(0x01) + + /** + * \brief For LZMA_FILTER_LZMA1EXT: Uncompressed size (low bits) + * + * The 64-bit uncompressed size is needed for decompression with + * LZMA_FILTER_LZMA1EXT. The size is ignored by the encoder. + * + * The special value UINT64_MAX indicates that the uncompressed size + * is unknown and that the end of payload marker (also known as + * end of stream marker) must be present to indicate the end of + * the LZMA1 stream. Any other value indicates the expected + * uncompressed size of the LZMA1 stream. (If LZMA1 was used together + * with filters that change the size of the data then the uncompressed + * size of the LZMA1 stream could be different than the final + * uncompressed size of the filtered stream.) + * + * ext_size_low holds the least significant 32 bits of the + * uncompressed size. The most significant 32 bits must be set + * in ext_size_high. The macro lzma_set_ext_size(opt_lzma, u64size) + * can be used to set these members. + * + * The 64-bit uncompressed size is split into two uint32_t variables + * because there were no reserved uint64_t members and using the + * same options structure for LZMA_FILTER_LZMA1, LZMA_FILTER_LZMA1EXT, + * and LZMA_FILTER_LZMA2 was otherwise more convenient than having + * a new options structure for LZMA_FILTER_LZMA1EXT. (Replacing two + * uint32_t members with one uint64_t changes the ABI on some systems + * as the alignment of this struct can increase from 4 bytes to 8.) + */ + uint32_t ext_size_low; + + /** + * \brief For LZMA_FILTER_LZMA1EXT: Uncompressed size (high bits) + * + * This holds the most significant 32 bits of the uncompressed size. + */ + uint32_t ext_size_high; + + /* + * Reserved space to allow possible future extensions without + * breaking the ABI. You should not touch these, because the names + * of these variables may change. These are and will never be used + * with the currently supported options, so it is safe to leave these + * uninitialized. + */ + + /** \private Reserved member. */ + uint32_t reserved_int4; + + /** \private Reserved member. */ + uint32_t reserved_int5; + + /** \private Reserved member. */ + uint32_t reserved_int6; + + /** \private Reserved member. */ + uint32_t reserved_int7; + + /** \private Reserved member. */ + uint32_t reserved_int8; + + /** \private Reserved member. */ + lzma_reserved_enum reserved_enum1; + + /** \private Reserved member. */ + lzma_reserved_enum reserved_enum2; + + /** \private Reserved member. */ + lzma_reserved_enum reserved_enum3; + + /** \private Reserved member. */ + lzma_reserved_enum reserved_enum4; + + /** \private Reserved member. */ + void *reserved_ptr1; + + /** \private Reserved member. */ + void *reserved_ptr2; + +} lzma_options_lzma; + + +/** + * \brief Macro to set the 64-bit uncompressed size in ext_size_* + * + * This might be convenient when decoding using LZMA_FILTER_LZMA1EXT. + * This isn't used with LZMA_FILTER_LZMA1 or LZMA_FILTER_LZMA2. + */ +#define lzma_set_ext_size(opt_lzma2, u64size) \ +do { \ + (opt_lzma2).ext_size_low = (uint32_t)(u64size); \ + (opt_lzma2).ext_size_high = (uint32_t)((uint64_t)(u64size) >> 32); \ +} while (0) + + +/** + * \brief Set a compression preset to lzma_options_lzma structure + * + * 0 is the fastest and 9 is the slowest. These match the switches -0 .. -9 + * of the xz command line tool. In addition, it is possible to bitwise-or + * flags to the preset. Currently only LZMA_PRESET_EXTREME is supported. + * The flags are defined in container.h, because the flags are used also + * with lzma_easy_encoder(). + * + * The preset levels are subject to changes between liblzma versions. + * + * This function is available only if LZMA1 or LZMA2 encoder has been enabled + * when building liblzma. + * + * If features (like certain match finders) have been disabled at build time, + * then the function may return success (false) even though the resulting + * LZMA1/LZMA2 options may not be usable for encoder initialization + * (LZMA_OPTIONS_ERROR). + * + * \param[out] options Pointer to LZMA1 or LZMA2 options to be filled + * \param preset Preset level bitwse-ORed with preset flags + * + * \return lzma_bool: + * - true if the preset is not supported (failure). + * - false otherwise (success). + */ +extern LZMA_API(lzma_bool) lzma_lzma_preset( + lzma_options_lzma *options, uint32_t preset) lzma_nothrow; diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/stream_flags.h b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/stream_flags.h new file mode 100644 index 0000000000000000000000000000000000000000..a33fe46837602a8a5314505a3a660209fe4fdf91 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/stream_flags.h @@ -0,0 +1,265 @@ +/* SPDX-License-Identifier: 0BSD */ + +/** + * \file lzma/stream_flags.h + * \brief .xz Stream Header and Stream Footer encoder and decoder + * \note Never include this file directly. Use instead. + */ + +/* + * Author: Lasse Collin + */ + +#ifndef LZMA_H_INTERNAL +# error Never include this file directly. Use instead. +#endif + + +/** + * \brief Size of Stream Header and Stream Footer + * + * Stream Header and Stream Footer have the same size and they are not + * going to change even if a newer version of the .xz file format is + * developed in future. + */ +#define LZMA_STREAM_HEADER_SIZE 12 + + +/** + * \brief Options for encoding/decoding Stream Header and Stream Footer + */ +typedef struct { + /** + * \brief Stream Flags format version + * + * To prevent API and ABI breakages if new features are needed in + * Stream Header or Stream Footer, a version number is used to + * indicate which members in this structure are in use. For now, + * version must always be zero. With non-zero version, the + * lzma_stream_header_encode() and lzma_stream_footer_encode() + * will return LZMA_OPTIONS_ERROR. + * + * lzma_stream_header_decode() and lzma_stream_footer_decode() + * will always set this to the lowest value that supports all the + * features indicated by the Stream Flags field. The application + * must check that the version number set by the decoding functions + * is supported by the application. Otherwise it is possible that + * the application will decode the Stream incorrectly. + */ + uint32_t version; + + /** + * \brief Backward Size + * + * Backward Size must be a multiple of four bytes. In this Stream + * format version, Backward Size is the size of the Index field. + * + * Backward Size isn't actually part of the Stream Flags field, but + * it is convenient to include in this structure anyway. Backward + * Size is present only in the Stream Footer. There is no need to + * initialize backward_size when encoding Stream Header. + * + * lzma_stream_header_decode() always sets backward_size to + * LZMA_VLI_UNKNOWN so that it is convenient to use + * lzma_stream_flags_compare() when both Stream Header and Stream + * Footer have been decoded. + */ + lzma_vli backward_size; + + /** + * \brief Minimum value for lzma_stream_flags.backward_size + */ +# define LZMA_BACKWARD_SIZE_MIN 4 + + /** + * \brief Maximum value for lzma_stream_flags.backward_size + */ +# define LZMA_BACKWARD_SIZE_MAX (LZMA_VLI_C(1) << 34) + + /** + * \brief Check ID + * + * This indicates the type of the integrity check calculated from + * uncompressed data. + */ + lzma_check check; + + /* + * Reserved space to allow possible future extensions without + * breaking the ABI. You should not touch these, because the + * names of these variables may change. + * + * (We will never be able to use all of these since Stream Flags + * is just two bytes plus Backward Size of four bytes. But it's + * nice to have the proper types when they are needed.) + */ + + /** \private Reserved member. */ + lzma_reserved_enum reserved_enum1; + + /** \private Reserved member. */ + lzma_reserved_enum reserved_enum2; + + /** \private Reserved member. */ + lzma_reserved_enum reserved_enum3; + + /** \private Reserved member. */ + lzma_reserved_enum reserved_enum4; + + /** \private Reserved member. */ + lzma_bool reserved_bool1; + + /** \private Reserved member. */ + lzma_bool reserved_bool2; + + /** \private Reserved member. */ + lzma_bool reserved_bool3; + + /** \private Reserved member. */ + lzma_bool reserved_bool4; + + /** \private Reserved member. */ + lzma_bool reserved_bool5; + + /** \private Reserved member. */ + lzma_bool reserved_bool6; + + /** \private Reserved member. */ + lzma_bool reserved_bool7; + + /** \private Reserved member. */ + lzma_bool reserved_bool8; + + /** \private Reserved member. */ + uint32_t reserved_int1; + + /** \private Reserved member. */ + uint32_t reserved_int2; + +} lzma_stream_flags; + + +/** + * \brief Encode Stream Header + * + * \param options Stream Header options to be encoded. + * options->backward_size is ignored and doesn't + * need to be initialized. + * \param[out] out Beginning of the output buffer of + * LZMA_STREAM_HEADER_SIZE bytes. + * + * \return Possible lzma_ret values: + * - LZMA_OK: Encoding was successful. + * - LZMA_OPTIONS_ERROR: options->version is not supported by + * this liblzma version. + * - LZMA_PROG_ERROR: Invalid options. + */ +extern LZMA_API(lzma_ret) lzma_stream_header_encode( + const lzma_stream_flags *options, uint8_t *out) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Encode Stream Footer + * + * \param options Stream Footer options to be encoded. + * \param[out] out Beginning of the output buffer of + * LZMA_STREAM_HEADER_SIZE bytes. + * + * \return Possible lzma_ret values: + * - LZMA_OK: Encoding was successful. + * - LZMA_OPTIONS_ERROR: options->version is not supported by + * this liblzma version. + * - LZMA_PROG_ERROR: Invalid options. + */ +extern LZMA_API(lzma_ret) lzma_stream_footer_encode( + const lzma_stream_flags *options, uint8_t *out) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Decode Stream Header + * + * options->backward_size is always set to LZMA_VLI_UNKNOWN. This is to + * help comparing Stream Flags from Stream Header and Stream Footer with + * lzma_stream_flags_compare(). + * + * \note When decoding .xz files that contain multiple Streams, it may + * make sense to print "file format not recognized" only if + * decoding of the Stream Header of the \a first Stream gives + * LZMA_FORMAT_ERROR. If non-first Stream Header gives + * LZMA_FORMAT_ERROR, the message used for LZMA_DATA_ERROR is + * probably more appropriate. + * For example, the Stream decoder in liblzma uses + * LZMA_DATA_ERROR if LZMA_FORMAT_ERROR is returned by + * lzma_stream_header_decode() when decoding non-first Stream. + * + * \param[out] options Target for the decoded Stream Header options. + * \param in Beginning of the input buffer of + * LZMA_STREAM_HEADER_SIZE bytes. + * + * + * \return Possible lzma_ret values: + * - LZMA_OK: Decoding was successful. + * - LZMA_FORMAT_ERROR: Magic bytes don't match, thus the given + * buffer cannot be Stream Header. + * - LZMA_DATA_ERROR: CRC32 doesn't match, thus the header + * is corrupt. + * - LZMA_OPTIONS_ERROR: Unsupported options are present + * in the header. + */ +extern LZMA_API(lzma_ret) lzma_stream_header_decode( + lzma_stream_flags *options, const uint8_t *in) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Decode Stream Footer + * + * \note If Stream Header was already decoded successfully, but + * decoding Stream Footer returns LZMA_FORMAT_ERROR, the + * application should probably report some other error message + * than "file format not recognized". The file likely + * is corrupt (possibly truncated). The Stream decoder in liblzma + * uses LZMA_DATA_ERROR in this situation. + * + * \param[out] options Target for the decoded Stream Footer options. + * \param in Beginning of the input buffer of + * LZMA_STREAM_HEADER_SIZE bytes. + * + * \return Possible lzma_ret values: + * - LZMA_OK: Decoding was successful. + * - LZMA_FORMAT_ERROR: Magic bytes don't match, thus the given + * buffer cannot be Stream Footer. + * - LZMA_DATA_ERROR: CRC32 doesn't match, thus the Stream Footer + * is corrupt. + * - LZMA_OPTIONS_ERROR: Unsupported options are present + * in Stream Footer. + */ +extern LZMA_API(lzma_ret) lzma_stream_footer_decode( + lzma_stream_flags *options, const uint8_t *in) + lzma_nothrow lzma_attr_warn_unused_result; + + +/** + * \brief Compare two lzma_stream_flags structures + * + * backward_size values are compared only if both are not + * LZMA_VLI_UNKNOWN. + * + * \param a Pointer to lzma_stream_flags structure + * \param b Pointer to lzma_stream_flags structure + * + * \return Possible lzma_ret values: + * - LZMA_OK: Both are equal. If either had backward_size set + * to LZMA_VLI_UNKNOWN, backward_size values were not + * compared or validated. + * - LZMA_DATA_ERROR: The structures differ. + * - LZMA_OPTIONS_ERROR: version in either structure is greater + * than the maximum supported version (currently zero). + * - LZMA_PROG_ERROR: Invalid value, e.g. invalid check or + * backward_size. + */ +extern LZMA_API(lzma_ret) lzma_stream_flags_compare( + const lzma_stream_flags *a, const lzma_stream_flags *b) + lzma_nothrow lzma_attr_pure; diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/version.h b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/version.h new file mode 100644 index 0000000000000000000000000000000000000000..263ad819a90609cef243f1c90152f5987ed153b3 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/version.h @@ -0,0 +1,134 @@ +/* SPDX-License-Identifier: 0BSD */ + +/** + * \file lzma/version.h + * \brief Version number + * \note Never include this file directly. Use instead. + */ + +/* + * Author: Lasse Collin + */ + +#ifndef LZMA_H_INTERNAL +# error Never include this file directly. Use instead. +#endif + + +/** \brief Major version number of the liblzma release. */ +#define LZMA_VERSION_MAJOR 5 + +/** \brief Minor version number of the liblzma release. */ +#define LZMA_VERSION_MINOR 8 + +/** \brief Patch version number of the liblzma release. */ +#define LZMA_VERSION_PATCH 2 + +/** + * \brief Version stability marker + * + * This will always be one of three values: + * - LZMA_VERSION_STABILITY_ALPHA + * - LZMA_VERSION_STABILITY_BETA + * - LZMA_VERSION_STABILITY_STABLE + */ +#define LZMA_VERSION_STABILITY LZMA_VERSION_STABILITY_STABLE + +/** \brief Commit version number of the liblzma release */ +#ifndef LZMA_VERSION_COMMIT +# define LZMA_VERSION_COMMIT "" +#endif + + +/* + * Map symbolic stability levels to integers. + */ +#define LZMA_VERSION_STABILITY_ALPHA 0 +#define LZMA_VERSION_STABILITY_BETA 1 +#define LZMA_VERSION_STABILITY_STABLE 2 + + +/** + * \brief Compile-time version number + * + * The version number is of format xyyyzzzs where + * - x = major + * - yyy = minor + * - zzz = revision + * - s indicates stability: 0 = alpha, 1 = beta, 2 = stable + * + * The same xyyyzzz triplet is never reused with different stability levels. + * For example, if 5.1.0alpha has been released, there will never be 5.1.0beta + * or 5.1.0 stable. + * + * \note The version number of liblzma has nothing to with + * the version number of Igor Pavlov's LZMA SDK. + */ +#define LZMA_VERSION (LZMA_VERSION_MAJOR * UINT32_C(10000000) \ + + LZMA_VERSION_MINOR * UINT32_C(10000) \ + + LZMA_VERSION_PATCH * UINT32_C(10) \ + + LZMA_VERSION_STABILITY) + + +/* + * Macros to construct the compile-time version string + */ +#if LZMA_VERSION_STABILITY == LZMA_VERSION_STABILITY_ALPHA +# define LZMA_VERSION_STABILITY_STRING "alpha" +#elif LZMA_VERSION_STABILITY == LZMA_VERSION_STABILITY_BETA +# define LZMA_VERSION_STABILITY_STRING "beta" +#elif LZMA_VERSION_STABILITY == LZMA_VERSION_STABILITY_STABLE +# define LZMA_VERSION_STABILITY_STRING "" +#else +# error Incorrect LZMA_VERSION_STABILITY +#endif + +#define LZMA_VERSION_STRING_C_(major, minor, patch, stability, commit) \ + #major "." #minor "." #patch stability commit + +#define LZMA_VERSION_STRING_C(major, minor, patch, stability, commit) \ + LZMA_VERSION_STRING_C_(major, minor, patch, stability, commit) + + +/** + * \brief Compile-time version as a string + * + * This can be for example "4.999.5alpha", "4.999.8beta", or "5.0.0" (stable + * versions don't have any "stable" suffix). In future, a snapshot built + * from source code repository may include an additional suffix, for example + * "4.999.8beta-21-g1d92". The commit ID won't be available in numeric form + * in LZMA_VERSION macro. + */ +#define LZMA_VERSION_STRING LZMA_VERSION_STRING_C( \ + LZMA_VERSION_MAJOR, LZMA_VERSION_MINOR, \ + LZMA_VERSION_PATCH, LZMA_VERSION_STABILITY_STRING, \ + LZMA_VERSION_COMMIT) + + +/* #ifndef is needed for use with windres (MinGW-w64 or Cygwin). */ +#ifndef LZMA_H_INTERNAL_RC + +/** + * \brief Run-time version number as an integer + * + * This allows an application to compare if it was built against the same, + * older, or newer version of liblzma that is currently running. + * + * \return The value of LZMA_VERSION macro at the compile time of liblzma + */ +extern LZMA_API(uint32_t) lzma_version_number(void) + lzma_nothrow lzma_attr_const; + + +/** + * \brief Run-time version as a string + * + * This function may be useful to display which version of liblzma an + * application is currently using. + * + * \return Run-time version of liblzma + */ +extern LZMA_API(const char *) lzma_version_string(void) + lzma_nothrow lzma_attr_const; + +#endif diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/vli.h b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/vli.h new file mode 100644 index 0000000000000000000000000000000000000000..6b049021b9090a913db9996f24ad90cb62e760af --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/include/lzma/vli.h @@ -0,0 +1,166 @@ +/* SPDX-License-Identifier: 0BSD */ + +/** + * \file lzma/vli.h + * \brief Variable-length integer handling + * \note Never include this file directly. Use instead. + * + * In the .xz format, most integers are encoded in a variable-length + * representation, which is sometimes called little endian base-128 encoding. + * This saves space when smaller values are more likely than bigger values. + * + * The encoding scheme encodes seven bits to every byte, using minimum + * number of bytes required to represent the given value. Encodings that use + * non-minimum number of bytes are invalid, thus every integer has exactly + * one encoded representation. The maximum number of bits in a VLI is 63, + * thus the vli argument must be less than or equal to UINT64_MAX / 2. You + * should use LZMA_VLI_MAX for clarity. + */ + +/* + * Author: Lasse Collin + */ + +#ifndef LZMA_H_INTERNAL +# error Never include this file directly. Use instead. +#endif + + +/** + * \brief Maximum supported value of a variable-length integer + */ +#define LZMA_VLI_MAX (UINT64_MAX / 2) + +/** + * \brief VLI value to denote that the value is unknown + */ +#define LZMA_VLI_UNKNOWN UINT64_MAX + +/** + * \brief Maximum supported encoded length of variable length integers + */ +#define LZMA_VLI_BYTES_MAX 9 + +/** + * \brief VLI constant suffix + */ +#define LZMA_VLI_C(n) UINT64_C(n) + + +/** + * \brief Variable-length integer type + * + * Valid VLI values are in the range [0, LZMA_VLI_MAX]. Unknown value is + * indicated with LZMA_VLI_UNKNOWN, which is the maximum value of the + * underlying integer type. + * + * lzma_vli will be uint64_t for the foreseeable future. If a bigger size + * is needed in the future, it is guaranteed that 2 * LZMA_VLI_MAX will + * not overflow lzma_vli. This simplifies integer overflow detection. + */ +typedef uint64_t lzma_vli; + + +/** + * \brief Validate a variable-length integer + * + * This is useful to test that application has given acceptable values + * for example in the uncompressed_size and compressed_size variables. + * + * \return True if the integer is representable as a VLI or if it + * indicates an unknown value. False otherwise. + */ +#define lzma_vli_is_valid(vli) \ + ((vli) <= LZMA_VLI_MAX || (vli) == LZMA_VLI_UNKNOWN) + + +/** + * \brief Encode a variable-length integer + * + * This function has two modes: single-call and multi-call. Single-call mode + * encodes the whole integer at once; it is an error if the output buffer is + * too small. Multi-call mode saves the position in *vli_pos, and thus it is + * possible to continue encoding if the buffer becomes full before the whole + * integer has been encoded. + * + * \param vli Integer to be encoded + * \param[out] vli_pos How many VLI-encoded bytes have already been written + * out. When starting to encode a new integer in + * multi-call mode, *vli_pos must be set to zero. + * To use single-call encoding, set vli_pos to NULL. + * \param[out] out Beginning of the output buffer + * \param[out] out_pos The next byte will be written to out[*out_pos]. + * \param out_size Size of the out buffer; the first byte into + * which no data is written to is out[out_size]. + * + * \return Slightly different return values are used in multi-call and + * single-call modes. + * + * Single-call (vli_pos == NULL): + * - LZMA_OK: Integer successfully encoded. + * - LZMA_PROG_ERROR: Arguments are not sane. This can be due + * to too little output space; single-call mode doesn't use + * LZMA_BUF_ERROR, since the application should have checked + * the encoded size with lzma_vli_size(). + * + * Multi-call (vli_pos != NULL): + * - LZMA_OK: So far all OK, but the integer is not + * completely written out yet. + * - LZMA_STREAM_END: Integer successfully encoded. + * - LZMA_BUF_ERROR: No output space was provided. + * - LZMA_PROG_ERROR: Arguments are not sane. + */ +extern LZMA_API(lzma_ret) lzma_vli_encode(lzma_vli vli, size_t *vli_pos, + uint8_t *out, size_t *out_pos, size_t out_size) lzma_nothrow; + + +/** + * \brief Decode a variable-length integer + * + * Like lzma_vli_encode(), this function has single-call and multi-call modes. + * + * \param[out] vli Pointer to decoded integer. The decoder will + * initialize it to zero when *vli_pos == 0, so + * application isn't required to initialize *vli. + * \param[out] vli_pos How many bytes have already been decoded. When + * starting to decode a new integer in multi-call + * mode, *vli_pos must be initialized to zero. To + * use single-call decoding, set vli_pos to NULL. + * \param in Beginning of the input buffer + * \param[out] in_pos The next byte will be read from in[*in_pos]. + * \param in_size Size of the input buffer; the first byte that + * won't be read is in[in_size]. + * + * \return Slightly different return values are used in multi-call and + * single-call modes. + * + * Single-call (vli_pos == NULL): + * - LZMA_OK: Integer successfully decoded. + * - LZMA_DATA_ERROR: Integer is corrupt. This includes hitting + * the end of the input buffer before the whole integer was + * decoded; providing no input at all will use LZMA_DATA_ERROR. + * - LZMA_PROG_ERROR: Arguments are not sane. + * + * Multi-call (vli_pos != NULL): + * - LZMA_OK: So far all OK, but the integer is not + * completely decoded yet. + * - LZMA_STREAM_END: Integer successfully decoded. + * - LZMA_DATA_ERROR: Integer is corrupt. + * - LZMA_BUF_ERROR: No input was provided. + * - LZMA_PROG_ERROR: Arguments are not sane. + */ +extern LZMA_API(lzma_ret) lzma_vli_decode(lzma_vli *vli, size_t *vli_pos, + const uint8_t *in, size_t *in_pos, size_t in_size) + lzma_nothrow; + + +/** + * \brief Get the number of bytes required to encode a VLI + * + * \param vli Integer whose encoded size is to be determined + * + * \return Number of bytes on success (1-9). If vli isn't valid, + * zero is returned. + */ +extern LZMA_API(uint32_t) lzma_vli_size(lzma_vli vli) + lzma_nothrow lzma_attr_pure; diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/about.json b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/about.json new file mode 100644 index 0000000000000000000000000000000000000000..7d8e4008c120f956ba08b831944d8764d4231eda --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/about.json @@ -0,0 +1,167 @@ +{ + "channels": [ + "https://repo.anaconda.com/pkgs/main", + "https://repo.anaconda.com/pkgs/main" + ], + "conda_build_version": "26.1.0", + "conda_version": "26.1.1", + "description": "XZ Utils is free general-purpose data compression software with a high\ncompression ratio. XZ Utils were written for POSIX-like systems, but also\nwork on some not-so-POSIX systems.\n", + "dev_url": "https://github.com/tukaani-project/xz", + "doc_url": "https://tukaani.org/xz/#_documentation", + "env_vars": { + "CIO_TEST": "" + }, + "extra": { + "copy_test_source_files": true, + "final": true, + "pbp_graph_uuid": "59a56d01-5092-4d3b-b4dd-0a1f17128357", + "recipe-maintainers": [ + "msarahan", + "ocefpaf", + "mingwandroid", + "nehaljwani", + "scopatz" + ], + "remote_url": "https://github.com/AnacondaRecipes/xz-feedstock", + "sha": "4783e2f43c7a92fb112ceb569d162fa290780d80", + "task_id": "NMJPrbJgTIWKXqQPQ93B2Q", + "task_run_id": "0" + }, + "home": "https://tukaani.org/xz/", + "identifiers": [], + "keywords": [], + "license": "LGPL-2.1-or-later and GPL-2.0-or-later and 0BSD", + "license_family": "GPL2", + "license_file": "COPYING", + "root_pkgs": [ + "_libgcc_mutex 0.1 main", + "ca-certificates 2025.12.2 h06a4308_0", + "ld_impl_linux-64 2.44 h153f514_2", + "libgomp 15.2.0 h4751f2c_7", + "nlohmann_json 3.11.2 h6a678d5_0", + "pybind11-abi 5 hd3eb1b0_0", + "python_abi 3.13 3_cp313", + "tzdata 2025c he532380_0", + "_openmp_mutex 5.1 1_gnu", + "libgcc 15.2.0 h69a1729_7", + "libgcc-ng 15.2.0 h166f726_7", + "libiconv 1.18 h75a1612_0", + "libstdcxx 15.2.0 h39759b7_7", + "openssl 3.5.5 h1b28b03_0", + "bzip2 1.0.8 h5eee18b_6", + "c-ares 1.34.6 hd44998d_0", + "jansson 2.14 h5eee18b_1", + "libasprintf 0.25.1 hf2ab22a_0", + "libbrotlicommon 1.2.0 h32cd6e7_0", + "libev 4.33 h7f8727e_1", + "libexpat 2.7.4 h7354ed3_0", + "libgettextpo 0.25.1 hf2ab22a_0", + "libmpdec 4.0.0 h5eee18b_0", + "libstdcxx-ng 15.2.0 hc03a8fd_7", + "libunistring 1.3 hb25bd0a_0", + "libuuid 1.41.5 h5eee18b_0", + "libzlib 1.3.1 hb25bd0a_0", + "lmdb 0.9.31 hb25bd0a_0", + "ncurses 6.5 h7934f7d_0", + "patch 2.8 hb25bd0a_0", + "pthread-stubs 0.3 h0ce48e5_1", + "reproc 14.2.4 h6a678d5_2", + "xorg-libxau 1.0.12 h9b100fa_0", + "xorg-libxdmcp 1.1.5 h9b100fa_0", + "xorg-xorgproto 2024.1 h5eee18b_1", + "xz 5.6.4 h5eee18b_1", + "yaml 0.2.5 h7b6447c_0", + "cpp-expected 1.1.0 hdb19cb5_0", + "fmt 11.2.0 hca5f364_0", + "gettext-tools 0.25.1 h6a67909_0", + "icu 73.1 h6a678d5_0", + "libasprintf-devel 0.25.1 hf2ab22a_0", + "libbrotlidec 1.2.0 ha2c5f68_0", + "libbrotlienc 1.2.0 h2e96acb_0", + "libffi 3.4.4 h6a678d5_1", + "libgettextpo-devel 0.25.1 hf2ab22a_0", + "libkrb5 1.22.1 h6d2bf13_0", + "libxcb 1.17.0 h9b100fa_0", + "lz4-c 1.9.4 h6a678d5_1", + "mbedtls 3.5.1 h6a678d5_1", + "patchelf 0.17.2 h6a678d5_0", + "readline 8.3 hc2a1206_0", + "reproc-cpp 14.2.4 h6a678d5_2", + "simdjson 3.10.1 hdb19cb5_0", + "yaml-cpp 0.8.0 h6a678d5_1", + "zlib 1.3.1 hb25bd0a_0", + "gettext 0.25.1 h92eb808_0", + "liblief 0.16.4 h789ee31_1", + "libssh2 1.11.1 h251f7ec_0", + "libxml2 2.13.9 h2c43086_0", + "pcre2 10.46 hf426167_0", + "sqlite 3.51.1 he0a8d7e_0", + "xorg-libx11 1.8.12 h9b100fa_1", + "zstd 1.5.7 h11fc155_0", + "libarchive 3.8.2 h3ec8f01_0", + "libidn2 2.3.8 hf80d704_0", + "libnghttp2 1.67.1 h697f920_0", + "libsolv 0.7.30 h6f1ccf3_2", + "tk 8.6.15 h54e0aa7_0", + "libcurl 8.18.0 h3506a8c_0", + "python 3.13.12 hb7b561f_100_cp313", + "libmamba 2.3.2 h860b5fb_1", + "menuinst 2.4.2 py313h06a4308_1", + "archspec 0.2.5 pyhd3eb1b0_0", + "attrs 25.4.0 py313h06a4308_2", + "boltons 25.0.0 py313h06a4308_0", + "certifi 2026.01.04 py313h06a4308_0", + "chardet 5.2.0 py313h06a4308_0", + "charset-normalizer 3.4.4 py313h06a4308_0", + "click 8.2.1 py313h06a4308_1", + "distro 1.9.0 py313h06a4308_0", + "evalidate 2.0.3 py313h06a4308_0", + "filelock 3.20.3 py313h06a4308_0", + "frozendict 2.4.6 py313hee96239_0", + "idna 3.11 py313h06a4308_0", + "jsonpointer 3.0.0 py313h06a4308_0", + "libmambapy 2.3.2 py313h3f77f5b_1", + "markupsafe 3.0.2 py313h5eee18b_0", + "msgpack-python 1.1.1 py313h6a678d5_0", + "packaging 25.0 py313h06a4308_1", + "pkginfo 1.12.1.2 py313h06a4308_0", + "platformdirs 4.5.0 py313h06a4308_0", + "pluggy 1.5.0 py313h06a4308_0", + "psutil 7.0.0 py313hee96239_1", + "py-lief 0.16.4 py313h789ee31_1", + "pycosat 0.6.6 py313h5eee18b_2", + "pycparser 2.23 py313h06a4308_0", + "pysocks 1.7.1 py313h06a4308_1", + "python-libarchive-c 5.3 py313h06a4308_0", + "pytz 2025.2 py313h06a4308_0", + "pyyaml 6.0.3 py313h591646f_0", + "rpds-py 0.28.0 py313h498d7c9_0", + "ruamel.yaml.clib 0.2.14 py313h4aee224_0", + "setuptools 80.10.2 py313h06a4308_0", + "soupsieve 2.5 py313h06a4308_0", + "tqdm 4.67.3 py313h7040dfc_1", + "truststore 0.10.1 py313h06a4308_1", + "typing_extensions 4.15.0 py313h06a4308_0", + "cffi 2.0.0 py313h4eded50_1", + "jinja2 3.1.6 py313h06a4308_0", + "jsonpatch 1.33 py313h06a4308_1", + "referencing 0.37.0 py313h06a4308_0", + "ruamel.yaml 0.18.16 py313h4aee224_0", + "typing-extensions 4.15.0 py313h06a4308_0", + "beautifulsoup4 4.14.3 py313h06a4308_0", + "brotlicffi 1.2.0.0 py313h7354ed3_0", + "jsonschema-specifications 2025.9.1 py313h06a4308_0", + "zstandard 0.24.0 py313h3d778a8_0", + "jsonschema 4.25.1 py313h06a4308_0", + "urllib3 2.6.3 py313h06a4308_0", + "requests 2.32.5 py313h06a4308_1", + "conda-package-streaming 0.12.0 py313h06a4308_1", + "conda-package-handling 2.4.0 py313h06a4308_1", + "conda 26.1.1 py313h06a4308_0", + "conda-index 0.7.0 py313h06a4308_1", + "conda-libmamba-solver 25.11.0 pyhdf14ebd_0", + "conda-build 26.1.0 py313h76456e7_1" + ], + "summary": "Data compression software with high compression ratio", + "tags": [] +} \ No newline at end of file diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/files b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/files new file mode 100644 index 0000000000000000000000000000000000000000..ac6bbff3e6e54f44dca9d324d031aef98e6b8aa5 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/files @@ -0,0 +1,295 @@ +bin/lzcat +bin/lzcmp +bin/lzdiff +bin/lzegrep +bin/lzfgrep +bin/lzgrep +bin/lzless +bin/lzma +bin/lzmadec +bin/lzmainfo +bin/lzmore +bin/unlzma +bin/unxz +bin/xz +bin/xzcat +bin/xzcmp +bin/xzdec +bin/xzdiff +bin/xzegrep +bin/xzfgrep +bin/xzgrep +bin/xzless +bin/xzmore +include/lzma.h +include/lzma/base.h +include/lzma/bcj.h +include/lzma/block.h +include/lzma/check.h +include/lzma/container.h +include/lzma/delta.h +include/lzma/filter.h +include/lzma/hardware.h +include/lzma/index.h +include/lzma/index_hash.h +include/lzma/lzma12.h +include/lzma/stream_flags.h +include/lzma/version.h +include/lzma/vli.h +lib/cmake/liblzma/liblzma-config-version.cmake +lib/cmake/liblzma/liblzma-config.cmake +lib/cmake/liblzma/liblzma-targets-release.cmake +lib/cmake/liblzma/liblzma-targets.cmake +lib/liblzma.so +lib/liblzma.so.5 +lib/liblzma.so.5.8.2 +lib/pkgconfig/liblzma.pc +share/doc/xz/AUTHORS +share/doc/xz/COPYING +share/doc/xz/COPYING.0BSD +share/doc/xz/COPYING.GPLv2 +share/doc/xz/NEWS +share/doc/xz/README +share/doc/xz/THANKS +share/doc/xz/examples/00_README.txt +share/doc/xz/examples/01_compress_easy.c +share/doc/xz/examples/02_decompress.c +share/doc/xz/examples/03_compress_custom.c +share/doc/xz/examples/04_compress_easy_mt.c +share/doc/xz/examples/11_file_info.c +share/doc/xz/examples/Makefile +share/doc/xz/faq.txt +share/doc/xz/history.txt +share/doc/xz/lzma-file-format.txt +share/doc/xz/xz-file-format.txt +share/locale/ca/LC_MESSAGES/xz.mo +share/locale/cs/LC_MESSAGES/xz.mo +share/locale/da/LC_MESSAGES/xz.mo +share/locale/de/LC_MESSAGES/xz.mo +share/locale/eo/LC_MESSAGES/xz.mo +share/locale/es/LC_MESSAGES/xz.mo +share/locale/fi/LC_MESSAGES/xz.mo +share/locale/fr/LC_MESSAGES/xz.mo +share/locale/hr/LC_MESSAGES/xz.mo +share/locale/hu/LC_MESSAGES/xz.mo +share/locale/it/LC_MESSAGES/xz.mo +share/locale/ka/LC_MESSAGES/xz.mo +share/locale/ko/LC_MESSAGES/xz.mo +share/locale/nl/LC_MESSAGES/xz.mo +share/locale/pl/LC_MESSAGES/xz.mo +share/locale/pt/LC_MESSAGES/xz.mo +share/locale/pt_BR/LC_MESSAGES/xz.mo +share/locale/ro/LC_MESSAGES/xz.mo +share/locale/sr/LC_MESSAGES/xz.mo +share/locale/sv/LC_MESSAGES/xz.mo +share/locale/tr/LC_MESSAGES/xz.mo +share/locale/uk/LC_MESSAGES/xz.mo +share/locale/vi/LC_MESSAGES/xz.mo +share/locale/zh_CN/LC_MESSAGES/xz.mo +share/locale/zh_TW/LC_MESSAGES/xz.mo +share/man/de/man1/lzcat.1 +share/man/de/man1/lzcmp.1 +share/man/de/man1/lzdiff.1 +share/man/de/man1/lzegrep.1 +share/man/de/man1/lzfgrep.1 +share/man/de/man1/lzgrep.1 +share/man/de/man1/lzless.1 +share/man/de/man1/lzma.1 +share/man/de/man1/lzmadec.1 +share/man/de/man1/lzmainfo.1 +share/man/de/man1/lzmore.1 +share/man/de/man1/unlzma.1 +share/man/de/man1/unxz.1 +share/man/de/man1/xz.1 +share/man/de/man1/xzcat.1 +share/man/de/man1/xzcmp.1 +share/man/de/man1/xzdec.1 +share/man/de/man1/xzdiff.1 +share/man/de/man1/xzegrep.1 +share/man/de/man1/xzfgrep.1 +share/man/de/man1/xzgrep.1 +share/man/de/man1/xzless.1 +share/man/de/man1/xzmore.1 +share/man/fr/man1/lzcat.1 +share/man/fr/man1/lzless.1 +share/man/fr/man1/lzma.1 +share/man/fr/man1/lzmadec.1 +share/man/fr/man1/lzmainfo.1 +share/man/fr/man1/unlzma.1 +share/man/fr/man1/unxz.1 +share/man/fr/man1/xz.1 +share/man/fr/man1/xzcat.1 +share/man/fr/man1/xzdec.1 +share/man/fr/man1/xzless.1 +share/man/it/man1/lzcat.1 +share/man/it/man1/lzcmp.1 +share/man/it/man1/lzdiff.1 +share/man/it/man1/lzegrep.1 +share/man/it/man1/lzfgrep.1 +share/man/it/man1/lzgrep.1 +share/man/it/man1/lzless.1 +share/man/it/man1/lzma.1 +share/man/it/man1/lzmadec.1 +share/man/it/man1/lzmainfo.1 +share/man/it/man1/lzmore.1 +share/man/it/man1/unlzma.1 +share/man/it/man1/unxz.1 +share/man/it/man1/xz.1 +share/man/it/man1/xzcat.1 +share/man/it/man1/xzcmp.1 +share/man/it/man1/xzdec.1 +share/man/it/man1/xzdiff.1 +share/man/it/man1/xzegrep.1 +share/man/it/man1/xzfgrep.1 +share/man/it/man1/xzgrep.1 +share/man/it/man1/xzless.1 +share/man/it/man1/xzmore.1 +share/man/ko/man1/lzcat.1 +share/man/ko/man1/lzcmp.1 +share/man/ko/man1/lzdiff.1 +share/man/ko/man1/lzegrep.1 +share/man/ko/man1/lzfgrep.1 +share/man/ko/man1/lzgrep.1 +share/man/ko/man1/lzless.1 +share/man/ko/man1/lzma.1 +share/man/ko/man1/lzmadec.1 +share/man/ko/man1/lzmainfo.1 +share/man/ko/man1/lzmore.1 +share/man/ko/man1/unlzma.1 +share/man/ko/man1/unxz.1 +share/man/ko/man1/xz.1 +share/man/ko/man1/xzcat.1 +share/man/ko/man1/xzcmp.1 +share/man/ko/man1/xzdec.1 +share/man/ko/man1/xzdiff.1 +share/man/ko/man1/xzegrep.1 +share/man/ko/man1/xzfgrep.1 +share/man/ko/man1/xzgrep.1 +share/man/ko/man1/xzless.1 +share/man/ko/man1/xzmore.1 +share/man/man1/lzcat.1 +share/man/man1/lzcmp.1 +share/man/man1/lzdiff.1 +share/man/man1/lzegrep.1 +share/man/man1/lzfgrep.1 +share/man/man1/lzgrep.1 +share/man/man1/lzless.1 +share/man/man1/lzma.1 +share/man/man1/lzmadec.1 +share/man/man1/lzmainfo.1 +share/man/man1/lzmore.1 +share/man/man1/unlzma.1 +share/man/man1/unxz.1 +share/man/man1/xz.1 +share/man/man1/xzcat.1 +share/man/man1/xzcmp.1 +share/man/man1/xzdec.1 +share/man/man1/xzdiff.1 +share/man/man1/xzegrep.1 +share/man/man1/xzfgrep.1 +share/man/man1/xzgrep.1 +share/man/man1/xzless.1 +share/man/man1/xzmore.1 +share/man/pt_BR/man1/lzcat.1 +share/man/pt_BR/man1/lzless.1 +share/man/pt_BR/man1/lzma.1 +share/man/pt_BR/man1/lzmadec.1 +share/man/pt_BR/man1/lzmainfo.1 +share/man/pt_BR/man1/unlzma.1 +share/man/pt_BR/man1/unxz.1 +share/man/pt_BR/man1/xz.1 +share/man/pt_BR/man1/xzcat.1 +share/man/pt_BR/man1/xzdec.1 +share/man/pt_BR/man1/xzless.1 +share/man/ro/man1/lzcat.1 +share/man/ro/man1/lzcmp.1 +share/man/ro/man1/lzdiff.1 +share/man/ro/man1/lzegrep.1 +share/man/ro/man1/lzfgrep.1 +share/man/ro/man1/lzgrep.1 +share/man/ro/man1/lzless.1 +share/man/ro/man1/lzma.1 +share/man/ro/man1/lzmadec.1 +share/man/ro/man1/lzmainfo.1 +share/man/ro/man1/lzmore.1 +share/man/ro/man1/unlzma.1 +share/man/ro/man1/unxz.1 +share/man/ro/man1/xz.1 +share/man/ro/man1/xzcat.1 +share/man/ro/man1/xzcmp.1 +share/man/ro/man1/xzdec.1 +share/man/ro/man1/xzdiff.1 +share/man/ro/man1/xzegrep.1 +share/man/ro/man1/xzfgrep.1 +share/man/ro/man1/xzgrep.1 +share/man/ro/man1/xzless.1 +share/man/ro/man1/xzmore.1 +share/man/sr/man1/lzcat.1 +share/man/sr/man1/lzcmp.1 +share/man/sr/man1/lzdiff.1 +share/man/sr/man1/lzegrep.1 +share/man/sr/man1/lzfgrep.1 +share/man/sr/man1/lzgrep.1 +share/man/sr/man1/lzless.1 +share/man/sr/man1/lzma.1 +share/man/sr/man1/lzmadec.1 +share/man/sr/man1/lzmainfo.1 +share/man/sr/man1/lzmore.1 +share/man/sr/man1/unlzma.1 +share/man/sr/man1/unxz.1 +share/man/sr/man1/xz.1 +share/man/sr/man1/xzcat.1 +share/man/sr/man1/xzcmp.1 +share/man/sr/man1/xzdec.1 +share/man/sr/man1/xzdiff.1 +share/man/sr/man1/xzegrep.1 +share/man/sr/man1/xzfgrep.1 +share/man/sr/man1/xzgrep.1 +share/man/sr/man1/xzless.1 +share/man/sr/man1/xzmore.1 +share/man/sv/man1/lzcat.1 +share/man/sv/man1/lzcmp.1 +share/man/sv/man1/lzdiff.1 +share/man/sv/man1/lzegrep.1 +share/man/sv/man1/lzfgrep.1 +share/man/sv/man1/lzgrep.1 +share/man/sv/man1/lzless.1 +share/man/sv/man1/lzma.1 +share/man/sv/man1/lzmadec.1 +share/man/sv/man1/lzmainfo.1 +share/man/sv/man1/lzmore.1 +share/man/sv/man1/unlzma.1 +share/man/sv/man1/unxz.1 +share/man/sv/man1/xz.1 +share/man/sv/man1/xzcat.1 +share/man/sv/man1/xzcmp.1 +share/man/sv/man1/xzdec.1 +share/man/sv/man1/xzdiff.1 +share/man/sv/man1/xzegrep.1 +share/man/sv/man1/xzfgrep.1 +share/man/sv/man1/xzgrep.1 +share/man/sv/man1/xzless.1 +share/man/sv/man1/xzmore.1 +share/man/uk/man1/lzcat.1 +share/man/uk/man1/lzcmp.1 +share/man/uk/man1/lzdiff.1 +share/man/uk/man1/lzegrep.1 +share/man/uk/man1/lzfgrep.1 +share/man/uk/man1/lzgrep.1 +share/man/uk/man1/lzless.1 +share/man/uk/man1/lzma.1 +share/man/uk/man1/lzmadec.1 +share/man/uk/man1/lzmainfo.1 +share/man/uk/man1/lzmore.1 +share/man/uk/man1/unlzma.1 +share/man/uk/man1/unxz.1 +share/man/uk/man1/xz.1 +share/man/uk/man1/xzcat.1 +share/man/uk/man1/xzcmp.1 +share/man/uk/man1/xzdec.1 +share/man/uk/man1/xzdiff.1 +share/man/uk/man1/xzegrep.1 +share/man/uk/man1/xzfgrep.1 +share/man/uk/man1/xzgrep.1 +share/man/uk/man1/xzless.1 +share/man/uk/man1/xzmore.1 diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/git b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/git new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/has_prefix b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/has_prefix new file mode 100644 index 0000000000000000000000000000000000000000..7d04d799abed86efbef652d35ce9a47f4ad18b84 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/has_prefix @@ -0,0 +1,3 @@ +/home/task_177254812424319/croot/xz_1772548347995/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol binary bin/lzmainfo +/home/task_177254812424319/croot/xz_1772548347995/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol binary bin/xz +/home/task_177254812424319/croot/xz_1772548347995/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol text lib/pkgconfig/liblzma.pc diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/hash_input.json b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/hash_input.json new file mode 100644 index 0000000000000000000000000000000000000000..0513b6956c0cf82f2937b826451fcf8734ee7b97 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/hash_input.json @@ -0,0 +1,11 @@ +{ + "c_compiler_version": "14.3.0", + "channel_targets": "defaults", + "xz": "5", + "vc": "14", + "c_compiler": "gcc", + "target_platform": "linux-64", + "c_stdlib_version": "2.28", + "c_stdlib": "sysroot", + "__glibc": "__glibc >=2.28,<3.0.a0" +} \ No newline at end of file diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/index.json b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/index.json new file mode 100644 index 0000000000000000000000000000000000000000..8a2c288a53329b28f8cdaeb6cb763b7400e35f7c --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/index.json @@ -0,0 +1,16 @@ +{ + "arch": "x86_64", + "build": "h448239c_0", + "build_number": 0, + "depends": [ + "__glibc >=2.28,<3.0.a0", + "libgcc >=14" + ], + "license": "LGPL-2.1-or-later and GPL-2.0-or-later and 0BSD", + "license_family": "GPL2", + "name": "xz", + "platform": "linux", + "subdir": "linux-64", + "timestamp": 1772548381644, + "version": "5.8.2" +} \ No newline at end of file diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/licenses/COPYING b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/licenses/COPYING new file mode 100644 index 0000000000000000000000000000000000000000..ef3371389d7d45db6593a146fd9e027347f3122c --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/licenses/COPYING @@ -0,0 +1,70 @@ + +XZ Utils Licensing +================== + + Different licenses apply to different files in this package. Here + is a summary of which licenses apply to which parts of this package: + + - liblzma is under the BSD Zero Clause License (0BSD). + + - The command line tools xz, xzdec, lzmadec, and lzmainfo are + under 0BSD except that, on systems that don't have a usable + getopt_long, GNU getopt_long is compiled and linked in from the + 'lib' directory. The getopt_long code is under GNU LGPLv2.1+. + + - The scripts to grep, diff, and view compressed files have been + adapted from GNU gzip. These scripts (xzgrep, xzdiff, xzless, + and xzmore) are under GNU GPLv2+. The man pages of the scripts + are under 0BSD; they aren't based on the man pages of GNU gzip. + + - Most of the XZ Utils specific documentation that is in + plain text files (like README, INSTALL, PACKAGERS, NEWS, + and ChangeLog) are under 0BSD unless stated otherwise in + the file itself. The files xz-file-format.txt and + lzma-file-format.xt are in the public domain but may + be distributed under the terms of 0BSD too. + + - Translated messages and man pages are under 0BSD except that + some old translations are in the public domain. + + - Test files and test code in the 'tests' directory, and + debugging utilities in the 'debug' directory are under + the BSD Zero Clause License (0BSD). + + - The GNU Autotools based build system contains files that are + under GNU GPLv2+, GNU GPLv3+, and a few permissive licenses. + These files don't affect the licensing of the binaries being + built. + + - The 'extra' directory contains files that are under various + free software licenses. These aren't built or installed as + part of XZ Utils. + + The following command may be helpful in finding per-file license + information. It works on xz.git and on a clean file tree extracted + from a release tarball. + + sh build-aux/license-check.sh -v + + For the files under the BSD Zero Clause License (0BSD), if + a copyright notice is needed, the following is sufficient: + + Copyright (C) The XZ Utils authors and contributors + + If you copy significant amounts of 0BSD-licensed code from XZ Utils + into your project, acknowledging this somewhere in your software is + polite (especially if it is proprietary, non-free software), but + it is not legally required by the license terms. Here is an example + of a good notice to put into "about box" or into documentation: + + This software includes code from XZ Utils . + + The following license texts are included in the following files: + - COPYING.0BSD: BSD Zero Clause License + - COPYING.LGPLv2.1: GNU Lesser General Public License version 2.1 + - COPYING.GPLv2: GNU General Public License version 2 + - COPYING.GPLv3: GNU General Public License version 3 + + If you have questions, don't hesitate to ask for more information. + The contact information is in the README file. + diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/paths.json b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/paths.json new file mode 100644 index 0000000000000000000000000000000000000000..7274d8bdfd9a71c443ec136753932cca8da06ae7 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/paths.json @@ -0,0 +1,1781 @@ +{ + "paths": [ + { + "_path": "bin/lzcat", + "path_type": "softlink", + "sha256": "20c86ebe209e5a119ad921b150d83e310e720ec7e12c54c61aea26e07f928840", + "size_in_bytes": 118920 + }, + { + "_path": "bin/lzcmp", + "path_type": "softlink", + "sha256": "a3ad653e352ef1c6359bf38d8ba7a05d52ea88b993e1013812d7131cc64b0cc6", + "size_in_bytes": 7743 + }, + { + "_path": "bin/lzdiff", + "path_type": "softlink", + "sha256": "a3ad653e352ef1c6359bf38d8ba7a05d52ea88b993e1013812d7131cc64b0cc6", + "size_in_bytes": 7743 + }, + { + "_path": "bin/lzegrep", + "path_type": "softlink", + "sha256": "bce1301b8285e490cbdfd33915f5907f3ba3726292f078a01c6ec1feb6f61b29", + "size_in_bytes": 10458 + }, + { + "_path": "bin/lzfgrep", + "path_type": "softlink", + "sha256": "bce1301b8285e490cbdfd33915f5907f3ba3726292f078a01c6ec1feb6f61b29", + "size_in_bytes": 10458 + }, + { + "_path": "bin/lzgrep", + "path_type": "softlink", + "sha256": "bce1301b8285e490cbdfd33915f5907f3ba3726292f078a01c6ec1feb6f61b29", + "size_in_bytes": 10458 + }, + { + "_path": "bin/lzless", + "path_type": "softlink", + "sha256": "21d1f0c4ba548aad44e632ece2a6f0297fdb0e48d526ddee3106f77755e30680", + "size_in_bytes": 2428 + }, + { + "_path": "bin/lzma", + "path_type": "softlink", + "sha256": "20c86ebe209e5a119ad921b150d83e310e720ec7e12c54c61aea26e07f928840", + "size_in_bytes": 118920 + }, + { + "_path": "bin/lzmadec", + "path_type": "hardlink", + "sha256": "f2092dd575331cf91cbd9f0d5616b1f389a42fb16075befafe0744100d4c5c07", + "size_in_bytes": 23208 + }, + { + "_path": "bin/lzmainfo", + "file_mode": "binary", + "path_type": "hardlink", + "prefix_placeholder": "/home/task_177254812424319/croot/xz_1772548347995/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "173e805c6e4bdf415ea7c311cb2b0c9d8b011bbb524d16af9254682566aeffb3", + "size_in_bytes": 23544 + }, + { + "_path": "bin/lzmore", + "path_type": "softlink", + "sha256": "c823d41b5287933395cee4b4c9d24a18d6cb2d0d6f7d7e42f9a72823d125f3e4", + "size_in_bytes": 2262 + }, + { + "_path": "bin/unlzma", + "path_type": "softlink", + "sha256": "20c86ebe209e5a119ad921b150d83e310e720ec7e12c54c61aea26e07f928840", + "size_in_bytes": 118920 + }, + { + "_path": "bin/unxz", + "path_type": "softlink", + "sha256": "20c86ebe209e5a119ad921b150d83e310e720ec7e12c54c61aea26e07f928840", + "size_in_bytes": 118920 + }, + { + "_path": "bin/xz", + "file_mode": "binary", + "path_type": "hardlink", + "prefix_placeholder": "/home/task_177254812424319/croot/xz_1772548347995/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "20c86ebe209e5a119ad921b150d83e310e720ec7e12c54c61aea26e07f928840", + "size_in_bytes": 118920 + }, + { + "_path": "bin/xzcat", + "path_type": "softlink", + "sha256": "20c86ebe209e5a119ad921b150d83e310e720ec7e12c54c61aea26e07f928840", + "size_in_bytes": 118920 + }, + { + "_path": "bin/xzcmp", + "path_type": "softlink", + "sha256": "a3ad653e352ef1c6359bf38d8ba7a05d52ea88b993e1013812d7131cc64b0cc6", + "size_in_bytes": 7743 + }, + { + "_path": "bin/xzdec", + "path_type": "hardlink", + "sha256": "c87d468cb6fea4c497b89ae9ca00fc6ba5cd9cb59c1fce2810bc156a9ecf8ffb", + "size_in_bytes": 23208 + }, + { + "_path": "bin/xzdiff", + "path_type": "hardlink", + "sha256": "a3ad653e352ef1c6359bf38d8ba7a05d52ea88b993e1013812d7131cc64b0cc6", + "size_in_bytes": 7743 + }, + { + "_path": "bin/xzegrep", + "path_type": "softlink", + "sha256": "bce1301b8285e490cbdfd33915f5907f3ba3726292f078a01c6ec1feb6f61b29", + "size_in_bytes": 10458 + }, + { + "_path": "bin/xzfgrep", + "path_type": "softlink", + "sha256": "bce1301b8285e490cbdfd33915f5907f3ba3726292f078a01c6ec1feb6f61b29", + "size_in_bytes": 10458 + }, + { + "_path": "bin/xzgrep", + "path_type": "hardlink", + "sha256": "bce1301b8285e490cbdfd33915f5907f3ba3726292f078a01c6ec1feb6f61b29", + "size_in_bytes": 10458 + }, + { + "_path": "bin/xzless", + "path_type": "hardlink", + "sha256": "21d1f0c4ba548aad44e632ece2a6f0297fdb0e48d526ddee3106f77755e30680", + "size_in_bytes": 2428 + }, + { + "_path": "bin/xzmore", + "path_type": "hardlink", + "sha256": "c823d41b5287933395cee4b4c9d24a18d6cb2d0d6f7d7e42f9a72823d125f3e4", + "size_in_bytes": 2262 + }, + { + "_path": "include/lzma.h", + "path_type": "hardlink", + "sha256": "6829350ef1ee35fae25481cc87a4f4b17c4b6c2a3df26f2b34dc1804df75c0d9", + "size_in_bytes": 9790 + }, + { + "_path": "include/lzma/base.h", + "path_type": "hardlink", + "sha256": "e6de2ae8c447f98dfb12d7fbdd7510ed2c5c0d9a7a52ba2fabab10b638b3171d", + "size_in_bytes": 28223 + }, + { + "_path": "include/lzma/bcj.h", + "path_type": "hardlink", + "sha256": "7420ecbd1bd0e7ed726ccb4b771c92c5e99366fd98f725b57055ddd90cd6384b", + "size_in_bytes": 6105 + }, + { + "_path": "include/lzma/block.h", + "path_type": "hardlink", + "sha256": "c99bf801dc0d771196f318f0eb2db454c8ba007fb516c1e83ece91ac079e3440", + "size_in_bytes": 25964 + }, + { + "_path": "include/lzma/check.h", + "path_type": "hardlink", + "sha256": "a6954d5e59c87c09e000f6df9b61615125a4fb20b5014ce8cb3eea762999acff", + "size_in_bytes": 4840 + }, + { + "_path": "include/lzma/container.h", + "path_type": "hardlink", + "sha256": "c85bd006270273ef2ca8983fc7aab928ee73dc00948616b62de0278cf9cd94fc", + "size_in_bytes": 41872 + }, + { + "_path": "include/lzma/delta.h", + "path_type": "hardlink", + "sha256": "ff69bb02c2beb169284a50f68962006dde746e1859c31d47be0bc8e56db7a7b1", + "size_in_bytes": 2187 + }, + { + "_path": "include/lzma/filter.h", + "path_type": "hardlink", + "sha256": "bdc89d83271fd6cfc6e345913d6c6882c4c0f9093c71ea576c64ba562233ca6b", + "size_in_bytes": 31746 + }, + { + "_path": "include/lzma/hardware.h", + "path_type": "hardlink", + "sha256": "84a3af36971a1acc33c90305ec72f67d18bc74aa0742cef17833e023dd2992b3", + "size_in_bytes": 2550 + }, + { + "_path": "include/lzma/index.h", + "path_type": "hardlink", + "sha256": "f87c272b613742f18177186990144fa2c70f0800656c8b1a4142c3d9f0e94c9a", + "size_in_bytes": 31090 + }, + { + "_path": "include/lzma/index_hash.h", + "path_type": "hardlink", + "sha256": "b10127b60fedb010dad8d9c07635e73da9e995b287e823ae1838bbd302a8b260", + "size_in_bytes": 4671 + }, + { + "_path": "include/lzma/lzma12.h", + "path_type": "hardlink", + "sha256": "863e8c4b64472c5bca2246f17e2208af6dac9a07a34386a6e0af707708abdb50", + "size_in_bytes": 20818 + }, + { + "_path": "include/lzma/stream_flags.h", + "path_type": "hardlink", + "sha256": "192f8e6fdedcc26fabf2751128eab1f41fd6fbf976eea0d3d225a1d57b6a459c", + "size_in_bytes": 9239 + }, + { + "_path": "include/lzma/version.h", + "path_type": "hardlink", + "sha256": "504a3ace4e5a4420bac57648ac3d0afc27aec79018c8f8cfe43d431f771de5df", + "size_in_bytes": 3872 + }, + { + "_path": "include/lzma/vli.h", + "path_type": "hardlink", + "sha256": "16a498e75b0f5136de11e205e36ce9641277cfddad538fff5b22b6991f4110f7", + "size_in_bytes": 6590 + }, + { + "_path": "lib/cmake/liblzma/liblzma-config-version.cmake", + "path_type": "hardlink", + "sha256": "c79a0c1624ebb545132309ccb6e7cc7fc8ad21c7c8017427fb8ed4eb8389da91", + "size_in_bytes": 2878 + }, + { + "_path": "lib/cmake/liblzma/liblzma-config.cmake", + "path_type": "hardlink", + "sha256": "afb199e8891a9d071ff033095d3cb3e0c341b4df83cef1cf6b23c15d153b4c8d", + "size_in_bytes": 680 + }, + { + "_path": "lib/cmake/liblzma/liblzma-targets-release.cmake", + "path_type": "hardlink", + "sha256": "825e68a90f85a8955b1abb5926bdc635f61d35afc9d484d53ee807f3f97475de", + "size_in_bytes": 854 + }, + { + "_path": "lib/cmake/liblzma/liblzma-targets.cmake", + "path_type": "hardlink", + "sha256": "ee7a59f138a306e008b9631e2787a3d25971e5a7a0fa7c3670710770eac56cd2", + "size_in_bytes": 3908 + }, + { + "_path": "lib/liblzma.so", + "path_type": "softlink", + "sha256": "e54df1cc3cd5873fa0961b599cd28a86af87f3337a9021654fd1e1e8e650cb0d", + "size_in_bytes": 223000 + }, + { + "_path": "lib/liblzma.so.5", + "path_type": "softlink", + "sha256": "e54df1cc3cd5873fa0961b599cd28a86af87f3337a9021654fd1e1e8e650cb0d", + "size_in_bytes": 223000 + }, + { + "_path": "lib/liblzma.so.5.8.2", + "path_type": "hardlink", + "sha256": "e54df1cc3cd5873fa0961b599cd28a86af87f3337a9021654fd1e1e8e650cb0d", + "size_in_bytes": 223000 + }, + { + "_path": "lib/pkgconfig/liblzma.pc", + "file_mode": "text", + "path_type": "hardlink", + "prefix_placeholder": "/home/task_177254812424319/croot/xz_1772548347995/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol", + "sha256": "11044b15d9dad5ec54169a4d4d87f8f58675b68c5ee8eb3ace2c80a485978563", + "size_in_bytes": 616 + }, + { + "_path": "share/doc/xz/AUTHORS", + "path_type": "hardlink", + "sha256": "01e6df90d71d591f4307db3f397a5a4fac93b18533f5a3862156f1a0a7dc8610", + "size_in_bytes": 2146 + }, + { + "_path": "share/doc/xz/COPYING", + "path_type": "hardlink", + "sha256": "616a3ad264ce29b8f1cb97e53037b139d406899ca8d1f799651e17bfa09830b8", + "size_in_bytes": 3119 + }, + { + "_path": "share/doc/xz/COPYING.0BSD", + "path_type": "hardlink", + "sha256": "0b01625d853911cd0e2e088dcfb743261034a091bb379246cb25a14cc4c74bf1", + "size_in_bytes": 607 + }, + { + "_path": "share/doc/xz/COPYING.GPLv2", + "path_type": "hardlink", + "sha256": "edaef632cbb643e4e7a221717a6c441a4c1a7c918e6e4d56debc3d8739b233f6", + "size_in_bytes": 17984 + }, + { + "_path": "share/doc/xz/NEWS", + "path_type": "hardlink", + "sha256": "8dd9b864758e9d009c0527703dd50b1f7a43a392287510b22d113125cdeb3587", + "size_in_bytes": 118456 + }, + { + "_path": "share/doc/xz/README", + "path_type": "hardlink", + "sha256": "63835489293d61f417043b97bad206447c390e007605ddff97fc70a31e9d6d55", + "size_in_bytes": 11393 + }, + { + "_path": "share/doc/xz/THANKS", + "path_type": "hardlink", + "sha256": "1c77640ab2d3a1f40b65fc1500dc5c7c91e1489b8ec445dba7619cc6f9b8ea67", + "size_in_bytes": 5087 + }, + { + "_path": "share/doc/xz/examples/00_README.txt", + "path_type": "hardlink", + "sha256": "f0ddaa731c89d6028f55281229e56b89f32b8c477aba4f52367488f0f42651be", + "size_in_bytes": 1037 + }, + { + "_path": "share/doc/xz/examples/01_compress_easy.c", + "path_type": "hardlink", + "sha256": "7d4a9186e9121eef5924cadc913f513615de697e3a86b5b01307e8cd54d9e0d0", + "size_in_bytes": 9464 + }, + { + "_path": "share/doc/xz/examples/02_decompress.c", + "path_type": "hardlink", + "sha256": "8c085ac46579444a4f33fbb6a4d480265dc8db43dbb05698fb58c8faf58100ab", + "size_in_bytes": 8844 + }, + { + "_path": "share/doc/xz/examples/03_compress_custom.c", + "path_type": "hardlink", + "sha256": "27229e1b873e4ecac4a3f57db932a23e9729930822f7932e618a72f50499c860", + "size_in_bytes": 4952 + }, + { + "_path": "share/doc/xz/examples/04_compress_easy_mt.c", + "path_type": "hardlink", + "sha256": "304f9b8501e224288cfeb7c89aad34890857dd83874a5b152508f2203661a0c6", + "size_in_bytes": 5145 + }, + { + "_path": "share/doc/xz/examples/11_file_info.c", + "path_type": "hardlink", + "sha256": "1d3e56a70ef81cb36813624b360355561932164a19184b76f5f190734ee92046", + "size_in_bytes": 5314 + }, + { + "_path": "share/doc/xz/examples/Makefile", + "path_type": "hardlink", + "sha256": "cc4018f5f9e0d0b6d46e6433cf18205f1437e587b369e35c718c88cf5a200dca", + "size_in_bytes": 283 + }, + { + "_path": "share/doc/xz/faq.txt", + "path_type": "hardlink", + "sha256": "97ea64c7578870443ff4669cd6dce43d94d857faa7cffef1aa462ff9c8089c07", + "size_in_bytes": 10419 + }, + { + "_path": "share/doc/xz/history.txt", + "path_type": "hardlink", + "sha256": "9d6a0a72822734a0afb1816e07f0a7edab03339119bed4f393c1c7eec884eab6", + "size_in_bytes": 7427 + }, + { + "_path": "share/doc/xz/lzma-file-format.txt", + "path_type": "hardlink", + "sha256": "7ca841284a3912ae2fc2edef4919a1398fc846e4b62ea6d2259de481a1d9caa2", + "size_in_bytes": 6090 + }, + { + "_path": "share/doc/xz/xz-file-format.txt", + "path_type": "hardlink", + "sha256": "acc324b995261e6d9d5793c6a504639a6dfe97f2ccaf3cf8667f20a2486fc85b", + "size_in_bytes": 44512 + }, + { + "_path": "share/locale/ca/LC_MESSAGES/xz.mo", + "path_type": "hardlink", + "sha256": "383f94cb55bd4f525d74b6595012f915692c69c12b8d758f2dce3a25601a93bd", + "size_in_bytes": 15587 + }, + { + "_path": "share/locale/cs/LC_MESSAGES/xz.mo", + "path_type": "hardlink", + "sha256": "4fdf1f5b733ac1a7959befb3a2719e1fd960dfb4b480d9df82f7a7045b1634c3", + "size_in_bytes": 7983 + }, + { + "_path": "share/locale/da/LC_MESSAGES/xz.mo", + "path_type": "hardlink", + "sha256": "e1c5b084a55fd4a6b3877cfad66ba5a623fa077159fd457c94bb50bbb5a9c32c", + "size_in_bytes": 9040 + }, + { + "_path": "share/locale/de/LC_MESSAGES/xz.mo", + "path_type": "hardlink", + "sha256": "ace73e3140097791a12cb1c66880a3857338bbba362d19ac07275b3601543e71", + "size_in_bytes": 29882 + }, + { + "_path": "share/locale/eo/LC_MESSAGES/xz.mo", + "path_type": "hardlink", + "sha256": "8522c0617d9e4a08c71e2dce413ae60df9e8d27e52de3ce134e33688045e2652", + "size_in_bytes": 15060 + }, + { + "_path": "share/locale/es/LC_MESSAGES/xz.mo", + "path_type": "hardlink", + "sha256": "e0d4ef308f9bfbedf3574e91d778c92d1ad29c635778394e46d61d424410b3b2", + "size_in_bytes": 29244 + }, + { + "_path": "share/locale/fi/LC_MESSAGES/xz.mo", + "path_type": "hardlink", + "sha256": "b9ff1c1e4eee6a48dc64c3092401e40073ad5bbaece3571e7e53e37c2235d2fa", + "size_in_bytes": 28225 + }, + { + "_path": "share/locale/fr/LC_MESSAGES/xz.mo", + "path_type": "hardlink", + "sha256": "dbf21e8cfc95efebd0df1cda553669694eefe36ef4b1b764dfa5eec3c8348ffc", + "size_in_bytes": 10232 + }, + { + "_path": "share/locale/hr/LC_MESSAGES/xz.mo", + "path_type": "hardlink", + "sha256": "2e8e6ab4bc52048b856f454a5de55ecde6c27a19147ed11b731abf76bc7819ba", + "size_in_bytes": 28799 + }, + { + "_path": "share/locale/hu/LC_MESSAGES/xz.mo", + "path_type": "hardlink", + "sha256": "fb3e91c4c5dd42128cfa11431bed3b96668793e6b67a7b6ad7f94c2a48953726", + "size_in_bytes": 15949 + }, + { + "_path": "share/locale/it/LC_MESSAGES/xz.mo", + "path_type": "hardlink", + "sha256": "2b9e0dde28c5d34109c02bb0b2c36b3518e1a03b96186283322da19df6bcc4cf", + "size_in_bytes": 28688 + }, + { + "_path": "share/locale/ka/LC_MESSAGES/xz.mo", + "path_type": "hardlink", + "sha256": "1d8c37b24859bf29b990ef73f7c4fad0e8d654e58a442cd7cbc8d4f364f4ad10", + "size_in_bytes": 46526 + }, + { + "_path": "share/locale/ko/LC_MESSAGES/xz.mo", + "path_type": "hardlink", + "sha256": "72561f8e72763ab38f0dc60cc3544b83ffc0af44e21370878a03bbd9b28ed5ce", + "size_in_bytes": 29850 + }, + { + "_path": "share/locale/nl/LC_MESSAGES/xz.mo", + "path_type": "hardlink", + "sha256": "f2dea756a475cebd40a5637114a03977f93c4c132ddbb31cd91c0aa625d5e1e0", + "size_in_bytes": 28532 + }, + { + "_path": "share/locale/pl/LC_MESSAGES/xz.mo", + "path_type": "hardlink", + "sha256": "2479537bd629094e76c60fe448514be46437ae866bb15cc494081b339d96c589", + "size_in_bytes": 29090 + }, + { + "_path": "share/locale/pt/LC_MESSAGES/xz.mo", + "path_type": "hardlink", + "sha256": "f6e1325290dfca9f2b8337a1ce72404a3d367ba3e4e275483d35fae4980a59c4", + "size_in_bytes": 28796 + }, + { + "_path": "share/locale/pt_BR/LC_MESSAGES/xz.mo", + "path_type": "hardlink", + "sha256": "87f17eec4444224f1385eecb7e7e0c1947ac1dbc3c97e8d8418184478d92ff71", + "size_in_bytes": 15660 + }, + { + "_path": "share/locale/ro/LC_MESSAGES/xz.mo", + "path_type": "hardlink", + "sha256": "c58b91bb5b7f58f5e0d3e915c0b49e79e92c0e1706a5bc0c970368f1e6cdd8de", + "size_in_bytes": 30418 + }, + { + "_path": "share/locale/sr/LC_MESSAGES/xz.mo", + "path_type": "hardlink", + "sha256": "06576e347d4155df05ff96765dd01f18ab4e2085875d5add2858fc61f6b96e1e", + "size_in_bytes": 36503 + }, + { + "_path": "share/locale/sv/LC_MESSAGES/xz.mo", + "path_type": "hardlink", + "sha256": "b1afa24967fa8cd9f8193dab316d22360f1e3e0cb2385e1a27d43db05dd08eca", + "size_in_bytes": 28399 + }, + { + "_path": "share/locale/tr/LC_MESSAGES/xz.mo", + "path_type": "hardlink", + "sha256": "f563955adfc19fd3fc9690a102efa4bb593e52cf730d92544933623746f79b31", + "size_in_bytes": 28887 + }, + { + "_path": "share/locale/uk/LC_MESSAGES/xz.mo", + "path_type": "hardlink", + "sha256": "1ee61b3632cc9d2e9a63176193bc99453a7d4ba695c7243b24d7d1f2dbac09b4", + "size_in_bytes": 39005 + }, + { + "_path": "share/locale/vi/LC_MESSAGES/xz.mo", + "path_type": "hardlink", + "sha256": "1afa3eb5be6410321f452ada61fcfa9a6783388dc7d21781be82eb7b84648e9b", + "size_in_bytes": 16808 + }, + { + "_path": "share/locale/zh_CN/LC_MESSAGES/xz.mo", + "path_type": "hardlink", + "sha256": "5b82c75ed5dca05c707ca1f2471e5bdd08924754305a343d0ed9196f869dae2f", + "size_in_bytes": 14488 + }, + { + "_path": "share/locale/zh_TW/LC_MESSAGES/xz.mo", + "path_type": "hardlink", + "sha256": "aa29965a0bfe611341428da061805cdfcb9dc8c5030139a0aa0919e2e5cb8115", + "size_in_bytes": 26773 + }, + { + "_path": "share/man/de/man1/lzcat.1", + "path_type": "softlink", + "sha256": "1fb9cedbbf671e280952c2641769464e539687d8b03e1586a73dd15f729c54ab", + "size_in_bytes": 94798 + }, + { + "_path": "share/man/de/man1/lzcmp.1", + "path_type": "softlink", + "sha256": "fb778bde0504320b3286015d18814db6df5a17209f1ef739b875aefb7128ea15", + "size_in_bytes": 2319 + }, + { + "_path": "share/man/de/man1/lzdiff.1", + "path_type": "softlink", + "sha256": "fb778bde0504320b3286015d18814db6df5a17209f1ef739b875aefb7128ea15", + "size_in_bytes": 2319 + }, + { + "_path": "share/man/de/man1/lzegrep.1", + "path_type": "softlink", + "sha256": "bdc6680103eb2b5b44c3e12fcff26150d936d216864546ad1b8fa59285dee011", + "size_in_bytes": 3108 + }, + { + "_path": "share/man/de/man1/lzfgrep.1", + "path_type": "softlink", + "sha256": "bdc6680103eb2b5b44c3e12fcff26150d936d216864546ad1b8fa59285dee011", + "size_in_bytes": 3108 + }, + { + "_path": "share/man/de/man1/lzgrep.1", + "path_type": "softlink", + "sha256": "bdc6680103eb2b5b44c3e12fcff26150d936d216864546ad1b8fa59285dee011", + "size_in_bytes": 3108 + }, + { + "_path": "share/man/de/man1/lzless.1", + "path_type": "softlink", + "sha256": "da3a087a6baa1ef01e1dfe48ab032d8542ed1af0b2012577edd0ac2933223501", + "size_in_bytes": 2077 + }, + { + "_path": "share/man/de/man1/lzma.1", + "path_type": "softlink", + "sha256": "1fb9cedbbf671e280952c2641769464e539687d8b03e1586a73dd15f729c54ab", + "size_in_bytes": 94798 + }, + { + "_path": "share/man/de/man1/lzmadec.1", + "path_type": "softlink", + "sha256": "3215c94db86a49e02c86bd44ec3f0efbc7e5239b038297ec65c16deee471891b", + "size_in_bytes": 3808 + }, + { + "_path": "share/man/de/man1/lzmainfo.1", + "path_type": "hardlink", + "sha256": "c75cd677c0e6f67fa471fddf53364a728b7ed9dca3ef9591ac0df9c556541827", + "size_in_bytes": 1835 + }, + { + "_path": "share/man/de/man1/lzmore.1", + "path_type": "softlink", + "sha256": "7ecb6f1a3b22e41ce5e73455b997df7f5a134de3d63efe89414a46a558279546", + "size_in_bytes": 2065 + }, + { + "_path": "share/man/de/man1/unlzma.1", + "path_type": "softlink", + "sha256": "1fb9cedbbf671e280952c2641769464e539687d8b03e1586a73dd15f729c54ab", + "size_in_bytes": 94798 + }, + { + "_path": "share/man/de/man1/unxz.1", + "path_type": "softlink", + "sha256": "1fb9cedbbf671e280952c2641769464e539687d8b03e1586a73dd15f729c54ab", + "size_in_bytes": 94798 + }, + { + "_path": "share/man/de/man1/xz.1", + "path_type": "hardlink", + "sha256": "1fb9cedbbf671e280952c2641769464e539687d8b03e1586a73dd15f729c54ab", + "size_in_bytes": 94798 + }, + { + "_path": "share/man/de/man1/xzcat.1", + "path_type": "softlink", + "sha256": "1fb9cedbbf671e280952c2641769464e539687d8b03e1586a73dd15f729c54ab", + "size_in_bytes": 94798 + }, + { + "_path": "share/man/de/man1/xzcmp.1", + "path_type": "softlink", + "sha256": "fb778bde0504320b3286015d18814db6df5a17209f1ef739b875aefb7128ea15", + "size_in_bytes": 2319 + }, + { + "_path": "share/man/de/man1/xzdec.1", + "path_type": "hardlink", + "sha256": "3215c94db86a49e02c86bd44ec3f0efbc7e5239b038297ec65c16deee471891b", + "size_in_bytes": 3808 + }, + { + "_path": "share/man/de/man1/xzdiff.1", + "path_type": "hardlink", + "sha256": "fb778bde0504320b3286015d18814db6df5a17209f1ef739b875aefb7128ea15", + "size_in_bytes": 2319 + }, + { + "_path": "share/man/de/man1/xzegrep.1", + "path_type": "softlink", + "sha256": "bdc6680103eb2b5b44c3e12fcff26150d936d216864546ad1b8fa59285dee011", + "size_in_bytes": 3108 + }, + { + "_path": "share/man/de/man1/xzfgrep.1", + "path_type": "softlink", + "sha256": "bdc6680103eb2b5b44c3e12fcff26150d936d216864546ad1b8fa59285dee011", + "size_in_bytes": 3108 + }, + { + "_path": "share/man/de/man1/xzgrep.1", + "path_type": "hardlink", + "sha256": "bdc6680103eb2b5b44c3e12fcff26150d936d216864546ad1b8fa59285dee011", + "size_in_bytes": 3108 + }, + { + "_path": "share/man/de/man1/xzless.1", + "path_type": "hardlink", + "sha256": "da3a087a6baa1ef01e1dfe48ab032d8542ed1af0b2012577edd0ac2933223501", + "size_in_bytes": 2077 + }, + { + "_path": "share/man/de/man1/xzmore.1", + "path_type": "hardlink", + "sha256": "7ecb6f1a3b22e41ce5e73455b997df7f5a134de3d63efe89414a46a558279546", + "size_in_bytes": 2065 + }, + { + "_path": "share/man/fr/man1/lzcat.1", + "path_type": "softlink", + "sha256": "1de5630535bbf389c21e3f2ebf9756b8ac8117b72bab654868501edd75b58985", + "size_in_bytes": 88473 + }, + { + "_path": "share/man/fr/man1/lzless.1", + "path_type": "softlink", + "sha256": "b61dc629b85c8e81e3257da201788144a0f0f83e9b8f0b29c29c344c89bead88", + "size_in_bytes": 2003 + }, + { + "_path": "share/man/fr/man1/lzma.1", + "path_type": "softlink", + "sha256": "1de5630535bbf389c21e3f2ebf9756b8ac8117b72bab654868501edd75b58985", + "size_in_bytes": 88473 + }, + { + "_path": "share/man/fr/man1/lzmadec.1", + "path_type": "softlink", + "sha256": "e7f436ab212228f517cfad42e88863dc8754decda2c8838e8dfffe5f0541ec59", + "size_in_bytes": 3670 + }, + { + "_path": "share/man/fr/man1/lzmainfo.1", + "path_type": "hardlink", + "sha256": "afda43fbf8c6fd6146f1180c703881ae7daa65eb3c78dd8253e16b260fc7996d", + "size_in_bytes": 1847 + }, + { + "_path": "share/man/fr/man1/unlzma.1", + "path_type": "softlink", + "sha256": "1de5630535bbf389c21e3f2ebf9756b8ac8117b72bab654868501edd75b58985", + "size_in_bytes": 88473 + }, + { + "_path": "share/man/fr/man1/unxz.1", + "path_type": "softlink", + "sha256": "1de5630535bbf389c21e3f2ebf9756b8ac8117b72bab654868501edd75b58985", + "size_in_bytes": 88473 + }, + { + "_path": "share/man/fr/man1/xz.1", + "path_type": "hardlink", + "sha256": "1de5630535bbf389c21e3f2ebf9756b8ac8117b72bab654868501edd75b58985", + "size_in_bytes": 88473 + }, + { + "_path": "share/man/fr/man1/xzcat.1", + "path_type": "softlink", + "sha256": "1de5630535bbf389c21e3f2ebf9756b8ac8117b72bab654868501edd75b58985", + "size_in_bytes": 88473 + }, + { + "_path": "share/man/fr/man1/xzdec.1", + "path_type": "hardlink", + "sha256": "e7f436ab212228f517cfad42e88863dc8754decda2c8838e8dfffe5f0541ec59", + "size_in_bytes": 3670 + }, + { + "_path": "share/man/fr/man1/xzless.1", + "path_type": "hardlink", + "sha256": "b61dc629b85c8e81e3257da201788144a0f0f83e9b8f0b29c29c344c89bead88", + "size_in_bytes": 2003 + }, + { + "_path": "share/man/it/man1/lzcat.1", + "path_type": "softlink", + "sha256": "6479ad1c957e49791fe865b0881a16da0846827dfaa7dca00db4745a2e6f0612", + "size_in_bytes": 91212 + }, + { + "_path": "share/man/it/man1/lzcmp.1", + "path_type": "softlink", + "sha256": "4370bd3e8b7653517e349e041bbedcd59c1cc14282680ceabb0ccc707f33e406", + "size_in_bytes": 2148 + }, + { + "_path": "share/man/it/man1/lzdiff.1", + "path_type": "softlink", + "sha256": "4370bd3e8b7653517e349e041bbedcd59c1cc14282680ceabb0ccc707f33e406", + "size_in_bytes": 2148 + }, + { + "_path": "share/man/it/man1/lzegrep.1", + "path_type": "softlink", + "sha256": "d15e05118547ed08bda73c41603c152481967d5dff8753f66f66fc3616335187", + "size_in_bytes": 2852 + }, + { + "_path": "share/man/it/man1/lzfgrep.1", + "path_type": "softlink", + "sha256": "d15e05118547ed08bda73c41603c152481967d5dff8753f66f66fc3616335187", + "size_in_bytes": 2852 + }, + { + "_path": "share/man/it/man1/lzgrep.1", + "path_type": "softlink", + "sha256": "d15e05118547ed08bda73c41603c152481967d5dff8753f66f66fc3616335187", + "size_in_bytes": 2852 + }, + { + "_path": "share/man/it/man1/lzless.1", + "path_type": "softlink", + "sha256": "ad6e9a3fe27a00913e56eed3fac7951a9d0556f51096c5cef21774992bb071d0", + "size_in_bytes": 1859 + }, + { + "_path": "share/man/it/man1/lzma.1", + "path_type": "softlink", + "sha256": "6479ad1c957e49791fe865b0881a16da0846827dfaa7dca00db4745a2e6f0612", + "size_in_bytes": 91212 + }, + { + "_path": "share/man/it/man1/lzmadec.1", + "path_type": "softlink", + "sha256": "14ba8091a6f224be20844e07f0cdb0183a8c0849ab5cd79da76f3e6ab853d041", + "size_in_bytes": 3556 + }, + { + "_path": "share/man/it/man1/lzmainfo.1", + "path_type": "hardlink", + "sha256": "c64e12f4ded99647d4ee00f5a4e27a2b72355649d574c0372c85db872db9972f", + "size_in_bytes": 1699 + }, + { + "_path": "share/man/it/man1/lzmore.1", + "path_type": "softlink", + "sha256": "09c894c95919660dcf15b90b4e12caf44b953e9a388114622e40816777fb3936", + "size_in_bytes": 1802 + }, + { + "_path": "share/man/it/man1/unlzma.1", + "path_type": "softlink", + "sha256": "6479ad1c957e49791fe865b0881a16da0846827dfaa7dca00db4745a2e6f0612", + "size_in_bytes": 91212 + }, + { + "_path": "share/man/it/man1/unxz.1", + "path_type": "softlink", + "sha256": "6479ad1c957e49791fe865b0881a16da0846827dfaa7dca00db4745a2e6f0612", + "size_in_bytes": 91212 + }, + { + "_path": "share/man/it/man1/xz.1", + "path_type": "hardlink", + "sha256": "6479ad1c957e49791fe865b0881a16da0846827dfaa7dca00db4745a2e6f0612", + "size_in_bytes": 91212 + }, + { + "_path": "share/man/it/man1/xzcat.1", + "path_type": "softlink", + "sha256": "6479ad1c957e49791fe865b0881a16da0846827dfaa7dca00db4745a2e6f0612", + "size_in_bytes": 91212 + }, + { + "_path": "share/man/it/man1/xzcmp.1", + "path_type": "softlink", + "sha256": "4370bd3e8b7653517e349e041bbedcd59c1cc14282680ceabb0ccc707f33e406", + "size_in_bytes": 2148 + }, + { + "_path": "share/man/it/man1/xzdec.1", + "path_type": "hardlink", + "sha256": "14ba8091a6f224be20844e07f0cdb0183a8c0849ab5cd79da76f3e6ab853d041", + "size_in_bytes": 3556 + }, + { + "_path": "share/man/it/man1/xzdiff.1", + "path_type": "hardlink", + "sha256": "4370bd3e8b7653517e349e041bbedcd59c1cc14282680ceabb0ccc707f33e406", + "size_in_bytes": 2148 + }, + { + "_path": "share/man/it/man1/xzegrep.1", + "path_type": "softlink", + "sha256": "d15e05118547ed08bda73c41603c152481967d5dff8753f66f66fc3616335187", + "size_in_bytes": 2852 + }, + { + "_path": "share/man/it/man1/xzfgrep.1", + "path_type": "softlink", + "sha256": "d15e05118547ed08bda73c41603c152481967d5dff8753f66f66fc3616335187", + "size_in_bytes": 2852 + }, + { + "_path": "share/man/it/man1/xzgrep.1", + "path_type": "hardlink", + "sha256": "d15e05118547ed08bda73c41603c152481967d5dff8753f66f66fc3616335187", + "size_in_bytes": 2852 + }, + { + "_path": "share/man/it/man1/xzless.1", + "path_type": "hardlink", + "sha256": "ad6e9a3fe27a00913e56eed3fac7951a9d0556f51096c5cef21774992bb071d0", + "size_in_bytes": 1859 + }, + { + "_path": "share/man/it/man1/xzmore.1", + "path_type": "hardlink", + "sha256": "09c894c95919660dcf15b90b4e12caf44b953e9a388114622e40816777fb3936", + "size_in_bytes": 1802 + }, + { + "_path": "share/man/ko/man1/lzcat.1", + "path_type": "softlink", + "sha256": "ae371cc15c158bc8b29d3deb046ab176de86b5e9d843007516c17974f3028663", + "size_in_bytes": 94283 + }, + { + "_path": "share/man/ko/man1/lzcmp.1", + "path_type": "softlink", + "sha256": "6fe356d80bde8b4d90fd532cf4d52ae872216c9eead46d79d32d0bb0707b37e6", + "size_in_bytes": 2407 + }, + { + "_path": "share/man/ko/man1/lzdiff.1", + "path_type": "softlink", + "sha256": "6fe356d80bde8b4d90fd532cf4d52ae872216c9eead46d79d32d0bb0707b37e6", + "size_in_bytes": 2407 + }, + { + "_path": "share/man/ko/man1/lzegrep.1", + "path_type": "softlink", + "sha256": "659202a10dd5454be44b8a53d36d3c729f1bdaa3252a1b15755606f8e67f1a30", + "size_in_bytes": 3124 + }, + { + "_path": "share/man/ko/man1/lzfgrep.1", + "path_type": "softlink", + "sha256": "659202a10dd5454be44b8a53d36d3c729f1bdaa3252a1b15755606f8e67f1a30", + "size_in_bytes": 3124 + }, + { + "_path": "share/man/ko/man1/lzgrep.1", + "path_type": "softlink", + "sha256": "659202a10dd5454be44b8a53d36d3c729f1bdaa3252a1b15755606f8e67f1a30", + "size_in_bytes": 3124 + }, + { + "_path": "share/man/ko/man1/lzless.1", + "path_type": "softlink", + "sha256": "9fa31916834dbc3e21c9450aa83d1ebe75aa19270dfc1ed99c12109c4f1cab3f", + "size_in_bytes": 2018 + }, + { + "_path": "share/man/ko/man1/lzma.1", + "path_type": "softlink", + "sha256": "ae371cc15c158bc8b29d3deb046ab176de86b5e9d843007516c17974f3028663", + "size_in_bytes": 94283 + }, + { + "_path": "share/man/ko/man1/lzmadec.1", + "path_type": "softlink", + "sha256": "8cb0c84ef06fc94e2ba58f1f16f368579aab02645ffc9c8216c8099a15843c6a", + "size_in_bytes": 3974 + }, + { + "_path": "share/man/ko/man1/lzmainfo.1", + "path_type": "hardlink", + "sha256": "4c44a0f1356d9d36c24e149ae2219fa2f62076c5b347cb60fa097177c5f91456", + "size_in_bytes": 1717 + }, + { + "_path": "share/man/ko/man1/lzmore.1", + "path_type": "softlink", + "sha256": "7beae2953015cb5d6526ebc3c170244f055d447095f20a76b1d920c42f125699", + "size_in_bytes": 2078 + }, + { + "_path": "share/man/ko/man1/unlzma.1", + "path_type": "softlink", + "sha256": "ae371cc15c158bc8b29d3deb046ab176de86b5e9d843007516c17974f3028663", + "size_in_bytes": 94283 + }, + { + "_path": "share/man/ko/man1/unxz.1", + "path_type": "softlink", + "sha256": "ae371cc15c158bc8b29d3deb046ab176de86b5e9d843007516c17974f3028663", + "size_in_bytes": 94283 + }, + { + "_path": "share/man/ko/man1/xz.1", + "path_type": "hardlink", + "sha256": "ae371cc15c158bc8b29d3deb046ab176de86b5e9d843007516c17974f3028663", + "size_in_bytes": 94283 + }, + { + "_path": "share/man/ko/man1/xzcat.1", + "path_type": "softlink", + "sha256": "ae371cc15c158bc8b29d3deb046ab176de86b5e9d843007516c17974f3028663", + "size_in_bytes": 94283 + }, + { + "_path": "share/man/ko/man1/xzcmp.1", + "path_type": "softlink", + "sha256": "6fe356d80bde8b4d90fd532cf4d52ae872216c9eead46d79d32d0bb0707b37e6", + "size_in_bytes": 2407 + }, + { + "_path": "share/man/ko/man1/xzdec.1", + "path_type": "hardlink", + "sha256": "8cb0c84ef06fc94e2ba58f1f16f368579aab02645ffc9c8216c8099a15843c6a", + "size_in_bytes": 3974 + }, + { + "_path": "share/man/ko/man1/xzdiff.1", + "path_type": "hardlink", + "sha256": "6fe356d80bde8b4d90fd532cf4d52ae872216c9eead46d79d32d0bb0707b37e6", + "size_in_bytes": 2407 + }, + { + "_path": "share/man/ko/man1/xzegrep.1", + "path_type": "softlink", + "sha256": "659202a10dd5454be44b8a53d36d3c729f1bdaa3252a1b15755606f8e67f1a30", + "size_in_bytes": 3124 + }, + { + "_path": "share/man/ko/man1/xzfgrep.1", + "path_type": "softlink", + "sha256": "659202a10dd5454be44b8a53d36d3c729f1bdaa3252a1b15755606f8e67f1a30", + "size_in_bytes": 3124 + }, + { + "_path": "share/man/ko/man1/xzgrep.1", + "path_type": "hardlink", + "sha256": "659202a10dd5454be44b8a53d36d3c729f1bdaa3252a1b15755606f8e67f1a30", + "size_in_bytes": 3124 + }, + { + "_path": "share/man/ko/man1/xzless.1", + "path_type": "hardlink", + "sha256": "9fa31916834dbc3e21c9450aa83d1ebe75aa19270dfc1ed99c12109c4f1cab3f", + "size_in_bytes": 2018 + }, + { + "_path": "share/man/ko/man1/xzmore.1", + "path_type": "hardlink", + "sha256": "7beae2953015cb5d6526ebc3c170244f055d447095f20a76b1d920c42f125699", + "size_in_bytes": 2078 + }, + { + "_path": "share/man/man1/lzcat.1", + "path_type": "softlink", + "sha256": "33ecb0be784a815e4644fd67a4dbcd13d39f758e5667f2709d7cca55aec857f2", + "size_in_bytes": 77349 + }, + { + "_path": "share/man/man1/lzcmp.1", + "path_type": "softlink", + "sha256": "071a169ccb998131e77bf9f02f43a331f273d11a146d7f0c3115791193d15799", + "size_in_bytes": 1670 + }, + { + "_path": "share/man/man1/lzdiff.1", + "path_type": "softlink", + "sha256": "071a169ccb998131e77bf9f02f43a331f273d11a146d7f0c3115791193d15799", + "size_in_bytes": 1670 + }, + { + "_path": "share/man/man1/lzegrep.1", + "path_type": "softlink", + "sha256": "fa6bef6f17b99ca7c5e40ddc1f71cbb0f308b213f9c0f8105394c352ee74c4bb", + "size_in_bytes": 2302 + }, + { + "_path": "share/man/man1/lzfgrep.1", + "path_type": "softlink", + "sha256": "fa6bef6f17b99ca7c5e40ddc1f71cbb0f308b213f9c0f8105394c352ee74c4bb", + "size_in_bytes": 2302 + }, + { + "_path": "share/man/man1/lzgrep.1", + "path_type": "softlink", + "sha256": "fa6bef6f17b99ca7c5e40ddc1f71cbb0f308b213f9c0f8105394c352ee74c4bb", + "size_in_bytes": 2302 + }, + { + "_path": "share/man/man1/lzless.1", + "path_type": "softlink", + "sha256": "a745856da33b528519efbc2c09ffcc3255e93e39c3e8afcc04045c694392f73e", + "size_in_bytes": 1407 + }, + { + "_path": "share/man/man1/lzma.1", + "path_type": "softlink", + "sha256": "33ecb0be784a815e4644fd67a4dbcd13d39f758e5667f2709d7cca55aec857f2", + "size_in_bytes": 77349 + }, + { + "_path": "share/man/man1/lzmadec.1", + "path_type": "softlink", + "sha256": "f76956a912083452e30c06cb3c45958cd789b5a2b099188be42fbeff023fceef", + "size_in_bytes": 2768 + }, + { + "_path": "share/man/man1/lzmainfo.1", + "path_type": "hardlink", + "sha256": "31ffd26a376af65fbf2c04841f16d6433321ba49456f4ded396bebecc9ebf4c6", + "size_in_bytes": 1180 + }, + { + "_path": "share/man/man1/lzmore.1", + "path_type": "softlink", + "sha256": "62da41e175b65b7512e2cc71d5b8b2fed49ff083e02621ce0f1e059ade4a784f", + "size_in_bytes": 1376 + }, + { + "_path": "share/man/man1/unlzma.1", + "path_type": "softlink", + "sha256": "33ecb0be784a815e4644fd67a4dbcd13d39f758e5667f2709d7cca55aec857f2", + "size_in_bytes": 77349 + }, + { + "_path": "share/man/man1/unxz.1", + "path_type": "softlink", + "sha256": "33ecb0be784a815e4644fd67a4dbcd13d39f758e5667f2709d7cca55aec857f2", + "size_in_bytes": 77349 + }, + { + "_path": "share/man/man1/xz.1", + "path_type": "hardlink", + "sha256": "33ecb0be784a815e4644fd67a4dbcd13d39f758e5667f2709d7cca55aec857f2", + "size_in_bytes": 77349 + }, + { + "_path": "share/man/man1/xzcat.1", + "path_type": "softlink", + "sha256": "33ecb0be784a815e4644fd67a4dbcd13d39f758e5667f2709d7cca55aec857f2", + "size_in_bytes": 77349 + }, + { + "_path": "share/man/man1/xzcmp.1", + "path_type": "softlink", + "sha256": "071a169ccb998131e77bf9f02f43a331f273d11a146d7f0c3115791193d15799", + "size_in_bytes": 1670 + }, + { + "_path": "share/man/man1/xzdec.1", + "path_type": "hardlink", + "sha256": "f76956a912083452e30c06cb3c45958cd789b5a2b099188be42fbeff023fceef", + "size_in_bytes": 2768 + }, + { + "_path": "share/man/man1/xzdiff.1", + "path_type": "hardlink", + "sha256": "071a169ccb998131e77bf9f02f43a331f273d11a146d7f0c3115791193d15799", + "size_in_bytes": 1670 + }, + { + "_path": "share/man/man1/xzegrep.1", + "path_type": "softlink", + "sha256": "fa6bef6f17b99ca7c5e40ddc1f71cbb0f308b213f9c0f8105394c352ee74c4bb", + "size_in_bytes": 2302 + }, + { + "_path": "share/man/man1/xzfgrep.1", + "path_type": "softlink", + "sha256": "fa6bef6f17b99ca7c5e40ddc1f71cbb0f308b213f9c0f8105394c352ee74c4bb", + "size_in_bytes": 2302 + }, + { + "_path": "share/man/man1/xzgrep.1", + "path_type": "hardlink", + "sha256": "fa6bef6f17b99ca7c5e40ddc1f71cbb0f308b213f9c0f8105394c352ee74c4bb", + "size_in_bytes": 2302 + }, + { + "_path": "share/man/man1/xzless.1", + "path_type": "hardlink", + "sha256": "a745856da33b528519efbc2c09ffcc3255e93e39c3e8afcc04045c694392f73e", + "size_in_bytes": 1407 + }, + { + "_path": "share/man/man1/xzmore.1", + "path_type": "hardlink", + "sha256": "62da41e175b65b7512e2cc71d5b8b2fed49ff083e02621ce0f1e059ade4a784f", + "size_in_bytes": 1376 + }, + { + "_path": "share/man/pt_BR/man1/lzcat.1", + "path_type": "softlink", + "sha256": "11c871f6683a8c0eef8a0aeb0f79efc7121c54eee67e6f7ccff3f4e212f90600", + "size_in_bytes": 87044 + }, + { + "_path": "share/man/pt_BR/man1/lzless.1", + "path_type": "softlink", + "sha256": "79492c31962eb1f6fd5451c70e867184009a6e62f36dd7b351220361adbe7733", + "size_in_bytes": 1945 + }, + { + "_path": "share/man/pt_BR/man1/lzma.1", + "path_type": "softlink", + "sha256": "11c871f6683a8c0eef8a0aeb0f79efc7121c54eee67e6f7ccff3f4e212f90600", + "size_in_bytes": 87044 + }, + { + "_path": "share/man/pt_BR/man1/lzmadec.1", + "path_type": "softlink", + "sha256": "4f0d204b8beffb0424cb465444603e08ef136038d3b77f503e7ca7473b1a13b9", + "size_in_bytes": 3525 + }, + { + "_path": "share/man/pt_BR/man1/lzmainfo.1", + "path_type": "hardlink", + "sha256": "39e348e1629b07676246d0baf563054f129f7179d947574ae340c47fff6cb358", + "size_in_bytes": 1774 + }, + { + "_path": "share/man/pt_BR/man1/unlzma.1", + "path_type": "softlink", + "sha256": "11c871f6683a8c0eef8a0aeb0f79efc7121c54eee67e6f7ccff3f4e212f90600", + "size_in_bytes": 87044 + }, + { + "_path": "share/man/pt_BR/man1/unxz.1", + "path_type": "softlink", + "sha256": "11c871f6683a8c0eef8a0aeb0f79efc7121c54eee67e6f7ccff3f4e212f90600", + "size_in_bytes": 87044 + }, + { + "_path": "share/man/pt_BR/man1/xz.1", + "path_type": "hardlink", + "sha256": "11c871f6683a8c0eef8a0aeb0f79efc7121c54eee67e6f7ccff3f4e212f90600", + "size_in_bytes": 87044 + }, + { + "_path": "share/man/pt_BR/man1/xzcat.1", + "path_type": "softlink", + "sha256": "11c871f6683a8c0eef8a0aeb0f79efc7121c54eee67e6f7ccff3f4e212f90600", + "size_in_bytes": 87044 + }, + { + "_path": "share/man/pt_BR/man1/xzdec.1", + "path_type": "hardlink", + "sha256": "4f0d204b8beffb0424cb465444603e08ef136038d3b77f503e7ca7473b1a13b9", + "size_in_bytes": 3525 + }, + { + "_path": "share/man/pt_BR/man1/xzless.1", + "path_type": "hardlink", + "sha256": "79492c31962eb1f6fd5451c70e867184009a6e62f36dd7b351220361adbe7733", + "size_in_bytes": 1945 + }, + { + "_path": "share/man/ro/man1/lzcat.1", + "path_type": "softlink", + "sha256": "629e6bf8e233ba170636eb95d6e03c7a9442227a9a723362c6f977187f10da70", + "size_in_bytes": 96334 + }, + { + "_path": "share/man/ro/man1/lzcmp.1", + "path_type": "softlink", + "sha256": "53ed8b3d41d3b2eb4b758ed2ecc5acbf482bf1c6176e443ab5f7ee0c5b8ae32d", + "size_in_bytes": 3287 + }, + { + "_path": "share/man/ro/man1/lzdiff.1", + "path_type": "softlink", + "sha256": "53ed8b3d41d3b2eb4b758ed2ecc5acbf482bf1c6176e443ab5f7ee0c5b8ae32d", + "size_in_bytes": 3287 + }, + { + "_path": "share/man/ro/man1/lzegrep.1", + "path_type": "softlink", + "sha256": "c6cb096ea86c336916d9da9aef97e4591bac33792c40f1542b8ae814ac504cea", + "size_in_bytes": 4020 + }, + { + "_path": "share/man/ro/man1/lzfgrep.1", + "path_type": "softlink", + "sha256": "c6cb096ea86c336916d9da9aef97e4591bac33792c40f1542b8ae814ac504cea", + "size_in_bytes": 4020 + }, + { + "_path": "share/man/ro/man1/lzgrep.1", + "path_type": "softlink", + "sha256": "c6cb096ea86c336916d9da9aef97e4591bac33792c40f1542b8ae814ac504cea", + "size_in_bytes": 4020 + }, + { + "_path": "share/man/ro/man1/lzless.1", + "path_type": "softlink", + "sha256": "3d695b8d4b587cee44c64ae50b812aca43ededea394c8d1020c7b51a31c1676d", + "size_in_bytes": 2996 + }, + { + "_path": "share/man/ro/man1/lzma.1", + "path_type": "softlink", + "sha256": "629e6bf8e233ba170636eb95d6e03c7a9442227a9a723362c6f977187f10da70", + "size_in_bytes": 96334 + }, + { + "_path": "share/man/ro/man1/lzmadec.1", + "path_type": "softlink", + "sha256": "026ddc5b0d1e11e934ce91e3d6cc929869778516f03247bfc241554911915b50", + "size_in_bytes": 4783 + }, + { + "_path": "share/man/ro/man1/lzmainfo.1", + "path_type": "hardlink", + "sha256": "33063f7597e1b6a8cfe4488e3e187ef1a45f66445e1b07b58d0f0703f4fa4766", + "size_in_bytes": 2713 + }, + { + "_path": "share/man/ro/man1/lzmore.1", + "path_type": "softlink", + "sha256": "5871337f26f852f920a61a39cf9715b6ddcb887412b3d9250ad8dece644f90d3", + "size_in_bytes": 2947 + }, + { + "_path": "share/man/ro/man1/unlzma.1", + "path_type": "softlink", + "sha256": "629e6bf8e233ba170636eb95d6e03c7a9442227a9a723362c6f977187f10da70", + "size_in_bytes": 96334 + }, + { + "_path": "share/man/ro/man1/unxz.1", + "path_type": "softlink", + "sha256": "629e6bf8e233ba170636eb95d6e03c7a9442227a9a723362c6f977187f10da70", + "size_in_bytes": 96334 + }, + { + "_path": "share/man/ro/man1/xz.1", + "path_type": "hardlink", + "sha256": "629e6bf8e233ba170636eb95d6e03c7a9442227a9a723362c6f977187f10da70", + "size_in_bytes": 96334 + }, + { + "_path": "share/man/ro/man1/xzcat.1", + "path_type": "softlink", + "sha256": "629e6bf8e233ba170636eb95d6e03c7a9442227a9a723362c6f977187f10da70", + "size_in_bytes": 96334 + }, + { + "_path": "share/man/ro/man1/xzcmp.1", + "path_type": "softlink", + "sha256": "53ed8b3d41d3b2eb4b758ed2ecc5acbf482bf1c6176e443ab5f7ee0c5b8ae32d", + "size_in_bytes": 3287 + }, + { + "_path": "share/man/ro/man1/xzdec.1", + "path_type": "hardlink", + "sha256": "026ddc5b0d1e11e934ce91e3d6cc929869778516f03247bfc241554911915b50", + "size_in_bytes": 4783 + }, + { + "_path": "share/man/ro/man1/xzdiff.1", + "path_type": "hardlink", + "sha256": "53ed8b3d41d3b2eb4b758ed2ecc5acbf482bf1c6176e443ab5f7ee0c5b8ae32d", + "size_in_bytes": 3287 + }, + { + "_path": "share/man/ro/man1/xzegrep.1", + "path_type": "softlink", + "sha256": "c6cb096ea86c336916d9da9aef97e4591bac33792c40f1542b8ae814ac504cea", + "size_in_bytes": 4020 + }, + { + "_path": "share/man/ro/man1/xzfgrep.1", + "path_type": "softlink", + "sha256": "c6cb096ea86c336916d9da9aef97e4591bac33792c40f1542b8ae814ac504cea", + "size_in_bytes": 4020 + }, + { + "_path": "share/man/ro/man1/xzgrep.1", + "path_type": "hardlink", + "sha256": "c6cb096ea86c336916d9da9aef97e4591bac33792c40f1542b8ae814ac504cea", + "size_in_bytes": 4020 + }, + { + "_path": "share/man/ro/man1/xzless.1", + "path_type": "hardlink", + "sha256": "3d695b8d4b587cee44c64ae50b812aca43ededea394c8d1020c7b51a31c1676d", + "size_in_bytes": 2996 + }, + { + "_path": "share/man/ro/man1/xzmore.1", + "path_type": "hardlink", + "sha256": "5871337f26f852f920a61a39cf9715b6ddcb887412b3d9250ad8dece644f90d3", + "size_in_bytes": 2947 + }, + { + "_path": "share/man/sr/man1/lzcat.1", + "path_type": "softlink", + "sha256": "ca93c933f355d98971dbb7d91b06bea336b2f483966f6d162ad54ac56241ea5f", + "size_in_bytes": 126890 + }, + { + "_path": "share/man/sr/man1/lzcmp.1", + "path_type": "softlink", + "sha256": "26fabc00b6185baa2070011bdcbc00dfdd82f68482f8a954b316ef43b3c589a8", + "size_in_bytes": 2882 + }, + { + "_path": "share/man/sr/man1/lzdiff.1", + "path_type": "softlink", + "sha256": "26fabc00b6185baa2070011bdcbc00dfdd82f68482f8a954b316ef43b3c589a8", + "size_in_bytes": 2882 + }, + { + "_path": "share/man/sr/man1/lzegrep.1", + "path_type": "softlink", + "sha256": "93bc4f85bacd7a16658d0c660edc3d83d58ec307729422095a47a45a14371c7c", + "size_in_bytes": 3743 + }, + { + "_path": "share/man/sr/man1/lzfgrep.1", + "path_type": "softlink", + "sha256": "93bc4f85bacd7a16658d0c660edc3d83d58ec307729422095a47a45a14371c7c", + "size_in_bytes": 3743 + }, + { + "_path": "share/man/sr/man1/lzgrep.1", + "path_type": "softlink", + "sha256": "93bc4f85bacd7a16658d0c660edc3d83d58ec307729422095a47a45a14371c7c", + "size_in_bytes": 3743 + }, + { + "_path": "share/man/sr/man1/lzless.1", + "path_type": "softlink", + "sha256": "6d56e4b8f109fda85e7e7103d934a8cd554c9811e642f050e7d5f7a02023e2f3", + "size_in_bytes": 2523 + }, + { + "_path": "share/man/sr/man1/lzma.1", + "path_type": "softlink", + "sha256": "ca93c933f355d98971dbb7d91b06bea336b2f483966f6d162ad54ac56241ea5f", + "size_in_bytes": 126890 + }, + { + "_path": "share/man/sr/man1/lzmadec.1", + "path_type": "softlink", + "sha256": "4bc22faf9e27a413cd6cc9b78e618ab1bea4a26b5a6cbf83574910606f81b273", + "size_in_bytes": 4682 + }, + { + "_path": "share/man/sr/man1/lzmainfo.1", + "path_type": "hardlink", + "sha256": "bccc0f79b62ad4cd4cf49efcb50d09c749957fc7578fb072f16d8ef55e2960a6", + "size_in_bytes": 2311 + }, + { + "_path": "share/man/sr/man1/lzmore.1", + "path_type": "softlink", + "sha256": "3cda4204b01200323fcadf4f5be17f887ab9c788c881ffd7efa8cdf8e78b8177", + "size_in_bytes": 2409 + }, + { + "_path": "share/man/sr/man1/unlzma.1", + "path_type": "softlink", + "sha256": "ca93c933f355d98971dbb7d91b06bea336b2f483966f6d162ad54ac56241ea5f", + "size_in_bytes": 126890 + }, + { + "_path": "share/man/sr/man1/unxz.1", + "path_type": "softlink", + "sha256": "ca93c933f355d98971dbb7d91b06bea336b2f483966f6d162ad54ac56241ea5f", + "size_in_bytes": 126890 + }, + { + "_path": "share/man/sr/man1/xz.1", + "path_type": "hardlink", + "sha256": "ca93c933f355d98971dbb7d91b06bea336b2f483966f6d162ad54ac56241ea5f", + "size_in_bytes": 126890 + }, + { + "_path": "share/man/sr/man1/xzcat.1", + "path_type": "softlink", + "sha256": "ca93c933f355d98971dbb7d91b06bea336b2f483966f6d162ad54ac56241ea5f", + "size_in_bytes": 126890 + }, + { + "_path": "share/man/sr/man1/xzcmp.1", + "path_type": "softlink", + "sha256": "26fabc00b6185baa2070011bdcbc00dfdd82f68482f8a954b316ef43b3c589a8", + "size_in_bytes": 2882 + }, + { + "_path": "share/man/sr/man1/xzdec.1", + "path_type": "hardlink", + "sha256": "4bc22faf9e27a413cd6cc9b78e618ab1bea4a26b5a6cbf83574910606f81b273", + "size_in_bytes": 4682 + }, + { + "_path": "share/man/sr/man1/xzdiff.1", + "path_type": "hardlink", + "sha256": "26fabc00b6185baa2070011bdcbc00dfdd82f68482f8a954b316ef43b3c589a8", + "size_in_bytes": 2882 + }, + { + "_path": "share/man/sr/man1/xzegrep.1", + "path_type": "softlink", + "sha256": "93bc4f85bacd7a16658d0c660edc3d83d58ec307729422095a47a45a14371c7c", + "size_in_bytes": 3743 + }, + { + "_path": "share/man/sr/man1/xzfgrep.1", + "path_type": "softlink", + "sha256": "93bc4f85bacd7a16658d0c660edc3d83d58ec307729422095a47a45a14371c7c", + "size_in_bytes": 3743 + }, + { + "_path": "share/man/sr/man1/xzgrep.1", + "path_type": "hardlink", + "sha256": "93bc4f85bacd7a16658d0c660edc3d83d58ec307729422095a47a45a14371c7c", + "size_in_bytes": 3743 + }, + { + "_path": "share/man/sr/man1/xzless.1", + "path_type": "hardlink", + "sha256": "6d56e4b8f109fda85e7e7103d934a8cd554c9811e642f050e7d5f7a02023e2f3", + "size_in_bytes": 2523 + }, + { + "_path": "share/man/sr/man1/xzmore.1", + "path_type": "hardlink", + "sha256": "3cda4204b01200323fcadf4f5be17f887ab9c788c881ffd7efa8cdf8e78b8177", + "size_in_bytes": 2409 + }, + { + "_path": "share/man/sv/man1/lzcat.1", + "path_type": "softlink", + "sha256": "5ff7ff4c49d80d61392ee82713e4e3c3a92ac730bd76935e18a8e71992de2ad8", + "size_in_bytes": 83947 + }, + { + "_path": "share/man/sv/man1/lzcmp.1", + "path_type": "softlink", + "sha256": "42c2390a38b74367fc5373da9dc907a187b1c6b87e10958bce40ba3953c1ed37", + "size_in_bytes": 2033 + }, + { + "_path": "share/man/sv/man1/lzdiff.1", + "path_type": "softlink", + "sha256": "42c2390a38b74367fc5373da9dc907a187b1c6b87e10958bce40ba3953c1ed37", + "size_in_bytes": 2033 + }, + { + "_path": "share/man/sv/man1/lzegrep.1", + "path_type": "softlink", + "sha256": "5d3a7032eeba771955dd15ce681f0ea4d4d0b2ee14d9060c99be037e91c0249e", + "size_in_bytes": 2746 + }, + { + "_path": "share/man/sv/man1/lzfgrep.1", + "path_type": "softlink", + "sha256": "5d3a7032eeba771955dd15ce681f0ea4d4d0b2ee14d9060c99be037e91c0249e", + "size_in_bytes": 2746 + }, + { + "_path": "share/man/sv/man1/lzgrep.1", + "path_type": "softlink", + "sha256": "5d3a7032eeba771955dd15ce681f0ea4d4d0b2ee14d9060c99be037e91c0249e", + "size_in_bytes": 2746 + }, + { + "_path": "share/man/sv/man1/lzless.1", + "path_type": "softlink", + "sha256": "d17225c583f38649dfd99cf9d238432945cd5ea39ea0855ac62681cc7e0d02b2", + "size_in_bytes": 1785 + }, + { + "_path": "share/man/sv/man1/lzma.1", + "path_type": "softlink", + "sha256": "5ff7ff4c49d80d61392ee82713e4e3c3a92ac730bd76935e18a8e71992de2ad8", + "size_in_bytes": 83947 + }, + { + "_path": "share/man/sv/man1/lzmadec.1", + "path_type": "softlink", + "sha256": "311a8121530dc3d16f120249bb195c9a27380ca2e947637393c09dcb1c862368", + "size_in_bytes": 3448 + }, + { + "_path": "share/man/sv/man1/lzmainfo.1", + "path_type": "hardlink", + "sha256": "94b66bf69ac34a0f64d5c004c309b3a312ed9ccfdb5e389039e5662bbd859d7c", + "size_in_bytes": 1540 + }, + { + "_path": "share/man/sv/man1/lzmore.1", + "path_type": "softlink", + "sha256": "033d64e6ffc5e7fdad1792e180962625f77e5122a71034374a57408e340b01eb", + "size_in_bytes": 1758 + }, + { + "_path": "share/man/sv/man1/unlzma.1", + "path_type": "softlink", + "sha256": "5ff7ff4c49d80d61392ee82713e4e3c3a92ac730bd76935e18a8e71992de2ad8", + "size_in_bytes": 83947 + }, + { + "_path": "share/man/sv/man1/unxz.1", + "path_type": "softlink", + "sha256": "5ff7ff4c49d80d61392ee82713e4e3c3a92ac730bd76935e18a8e71992de2ad8", + "size_in_bytes": 83947 + }, + { + "_path": "share/man/sv/man1/xz.1", + "path_type": "hardlink", + "sha256": "5ff7ff4c49d80d61392ee82713e4e3c3a92ac730bd76935e18a8e71992de2ad8", + "size_in_bytes": 83947 + }, + { + "_path": "share/man/sv/man1/xzcat.1", + "path_type": "softlink", + "sha256": "5ff7ff4c49d80d61392ee82713e4e3c3a92ac730bd76935e18a8e71992de2ad8", + "size_in_bytes": 83947 + }, + { + "_path": "share/man/sv/man1/xzcmp.1", + "path_type": "softlink", + "sha256": "42c2390a38b74367fc5373da9dc907a187b1c6b87e10958bce40ba3953c1ed37", + "size_in_bytes": 2033 + }, + { + "_path": "share/man/sv/man1/xzdec.1", + "path_type": "hardlink", + "sha256": "311a8121530dc3d16f120249bb195c9a27380ca2e947637393c09dcb1c862368", + "size_in_bytes": 3448 + }, + { + "_path": "share/man/sv/man1/xzdiff.1", + "path_type": "hardlink", + "sha256": "42c2390a38b74367fc5373da9dc907a187b1c6b87e10958bce40ba3953c1ed37", + "size_in_bytes": 2033 + }, + { + "_path": "share/man/sv/man1/xzegrep.1", + "path_type": "softlink", + "sha256": "5d3a7032eeba771955dd15ce681f0ea4d4d0b2ee14d9060c99be037e91c0249e", + "size_in_bytes": 2746 + }, + { + "_path": "share/man/sv/man1/xzfgrep.1", + "path_type": "softlink", + "sha256": "5d3a7032eeba771955dd15ce681f0ea4d4d0b2ee14d9060c99be037e91c0249e", + "size_in_bytes": 2746 + }, + { + "_path": "share/man/sv/man1/xzgrep.1", + "path_type": "hardlink", + "sha256": "5d3a7032eeba771955dd15ce681f0ea4d4d0b2ee14d9060c99be037e91c0249e", + "size_in_bytes": 2746 + }, + { + "_path": "share/man/sv/man1/xzless.1", + "path_type": "hardlink", + "sha256": "d17225c583f38649dfd99cf9d238432945cd5ea39ea0855ac62681cc7e0d02b2", + "size_in_bytes": 1785 + }, + { + "_path": "share/man/sv/man1/xzmore.1", + "path_type": "hardlink", + "sha256": "033d64e6ffc5e7fdad1792e180962625f77e5122a71034374a57408e340b01eb", + "size_in_bytes": 1758 + }, + { + "_path": "share/man/uk/man1/lzcat.1", + "path_type": "softlink", + "sha256": "818f93576fbeef61c6b29a8151d3b8d9006c2ebe627e97df315cf4260d475a2f", + "size_in_bytes": 143833 + }, + { + "_path": "share/man/uk/man1/lzcmp.1", + "path_type": "softlink", + "sha256": "f0f0358cc9328a45a96b630fbd24004577342362ace03ee3407619abd17a33a2", + "size_in_bytes": 2994 + }, + { + "_path": "share/man/uk/man1/lzdiff.1", + "path_type": "softlink", + "sha256": "f0f0358cc9328a45a96b630fbd24004577342362ace03ee3407619abd17a33a2", + "size_in_bytes": 2994 + }, + { + "_path": "share/man/uk/man1/lzegrep.1", + "path_type": "softlink", + "sha256": "2fa8edcd0b43cba9a43870356a4a6737173f0d4c4363cdff760b073a3f56b93a", + "size_in_bytes": 4141 + }, + { + "_path": "share/man/uk/man1/lzfgrep.1", + "path_type": "softlink", + "sha256": "2fa8edcd0b43cba9a43870356a4a6737173f0d4c4363cdff760b073a3f56b93a", + "size_in_bytes": 4141 + }, + { + "_path": "share/man/uk/man1/lzgrep.1", + "path_type": "softlink", + "sha256": "2fa8edcd0b43cba9a43870356a4a6737173f0d4c4363cdff760b073a3f56b93a", + "size_in_bytes": 4141 + }, + { + "_path": "share/man/uk/man1/lzless.1", + "path_type": "softlink", + "sha256": "245d8bc1f91783045c21293335c12b35e6c608280e2ad74c84aec5cbd4743e95", + "size_in_bytes": 2822 + }, + { + "_path": "share/man/uk/man1/lzma.1", + "path_type": "softlink", + "sha256": "818f93576fbeef61c6b29a8151d3b8d9006c2ebe627e97df315cf4260d475a2f", + "size_in_bytes": 143833 + }, + { + "_path": "share/man/uk/man1/lzmadec.1", + "path_type": "softlink", + "sha256": "fcfddac492df39f79a16f54e3411cdbfcbde14e35d8447f96fece3702e635f56", + "size_in_bytes": 5293 + }, + { + "_path": "share/man/uk/man1/lzmainfo.1", + "path_type": "hardlink", + "sha256": "504f5bf7bea3e2cf424fa334420edb0e429df3043bfa9aa2886360c81c943e63", + "size_in_bytes": 2422 + }, + { + "_path": "share/man/uk/man1/lzmore.1", + "path_type": "softlink", + "sha256": "6fd22561350aaee77a3308b7eae35d91c3de5fb68c20a68843a65dd2bf489efd", + "size_in_bytes": 2646 + }, + { + "_path": "share/man/uk/man1/unlzma.1", + "path_type": "softlink", + "sha256": "818f93576fbeef61c6b29a8151d3b8d9006c2ebe627e97df315cf4260d475a2f", + "size_in_bytes": 143833 + }, + { + "_path": "share/man/uk/man1/unxz.1", + "path_type": "softlink", + "sha256": "818f93576fbeef61c6b29a8151d3b8d9006c2ebe627e97df315cf4260d475a2f", + "size_in_bytes": 143833 + }, + { + "_path": "share/man/uk/man1/xz.1", + "path_type": "hardlink", + "sha256": "818f93576fbeef61c6b29a8151d3b8d9006c2ebe627e97df315cf4260d475a2f", + "size_in_bytes": 143833 + }, + { + "_path": "share/man/uk/man1/xzcat.1", + "path_type": "softlink", + "sha256": "818f93576fbeef61c6b29a8151d3b8d9006c2ebe627e97df315cf4260d475a2f", + "size_in_bytes": 143833 + }, + { + "_path": "share/man/uk/man1/xzcmp.1", + "path_type": "softlink", + "sha256": "f0f0358cc9328a45a96b630fbd24004577342362ace03ee3407619abd17a33a2", + "size_in_bytes": 2994 + }, + { + "_path": "share/man/uk/man1/xzdec.1", + "path_type": "hardlink", + "sha256": "fcfddac492df39f79a16f54e3411cdbfcbde14e35d8447f96fece3702e635f56", + "size_in_bytes": 5293 + }, + { + "_path": "share/man/uk/man1/xzdiff.1", + "path_type": "hardlink", + "sha256": "f0f0358cc9328a45a96b630fbd24004577342362ace03ee3407619abd17a33a2", + "size_in_bytes": 2994 + }, + { + "_path": "share/man/uk/man1/xzegrep.1", + "path_type": "softlink", + "sha256": "2fa8edcd0b43cba9a43870356a4a6737173f0d4c4363cdff760b073a3f56b93a", + "size_in_bytes": 4141 + }, + { + "_path": "share/man/uk/man1/xzfgrep.1", + "path_type": "softlink", + "sha256": "2fa8edcd0b43cba9a43870356a4a6737173f0d4c4363cdff760b073a3f56b93a", + "size_in_bytes": 4141 + }, + { + "_path": "share/man/uk/man1/xzgrep.1", + "path_type": "hardlink", + "sha256": "2fa8edcd0b43cba9a43870356a4a6737173f0d4c4363cdff760b073a3f56b93a", + "size_in_bytes": 4141 + }, + { + "_path": "share/man/uk/man1/xzless.1", + "path_type": "hardlink", + "sha256": "245d8bc1f91783045c21293335c12b35e6c608280e2ad74c84aec5cbd4743e95", + "size_in_bytes": 2822 + }, + { + "_path": "share/man/uk/man1/xzmore.1", + "path_type": "hardlink", + "sha256": "6fd22561350aaee77a3308b7eae35d91c3de5fb68c20a68843a65dd2bf489efd", + "size_in_bytes": 2646 + } + ], + "paths_version": 1 +} \ No newline at end of file diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/recipe/bld.bat b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/recipe/bld.bat new file mode 100644 index 0000000000000000000000000000000000000000..a9edf59386a9ed428655fe626d5472d0530ce1e4 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/recipe/bld.bat @@ -0,0 +1,14 @@ +:: Create and enter the build directory +md build && cd build + +:: Build shared library +cmake -GNinja ^ + -DCMAKE_INSTALL_PREFIX="%LIBRARY_PREFIX%" ^ + -DCMAKE_C_USE_RESPONSE_FILE_FOR_OBJECTS=FALSE ^ + -DCMAKE_BUILD_TYPE=Release ^ + -DBUILD_SHARED_LIBS=ON ^ + .. +if errorlevel 1 exit /b 1 + +ninja && ninja install +if errorlevel 1 exit /b 1 diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/recipe/build.sh b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/recipe/build.sh new file mode 100644 index 0000000000000000000000000000000000000000..a4dc4400833070ebfdf84bd0a761d02ce41887b1 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/recipe/build.sh @@ -0,0 +1,13 @@ +#!/bin/bash + +# Create and enter the build directory +mkdir -p build && cd build + +# Build shared library +cmake -GNinja \ + -DCMAKE_INSTALL_PREFIX="$PREFIX" \ + -DCMAKE_BUILD_TYPE=Release \ + -DBUILD_SHARED_LIBS=ON \ + .. || exit 1 + +ninja && ninja install \ No newline at end of file diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/recipe/conda_build_config.yaml b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/recipe/conda_build_config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..2aed950a1d5c7f419a21d08c7954212be783793c --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/recipe/conda_build_config.yaml @@ -0,0 +1,33 @@ +c_compiler: gcc +c_compiler_version: 14.3.0 +c_stdlib: sysroot +c_stdlib_version: '2.28' +channel_targets: defaults +cpu_optimization_target: nocona +cran_mirror: https://cran.r-project.org +cxx_compiler: gxx +extend_keys: +- extend_keys +- ignore_build_only_deps +- pin_run_as_build +- ignore_version +fortran_compiler: gfortran +ignore_build_only_deps: +- numpy +- python +lua: '5' +numpy: '1.26' +perl: 5.26.2 +pin_run_as_build: + python: + max_pin: x.x + min_pin: x.x + r-base: + max_pin: x.x + min_pin: x.x +platform: linux-64 +python: '3.11' +r_base: '3.5' +target_platform: linux-64 +vc: '14' +xz: '5' diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/recipe/meta.yaml b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/recipe/meta.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ef9c3ab1012c5e37b310e23d9379511856d2cefc --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/recipe/meta.yaml @@ -0,0 +1,90 @@ +# This file created by conda-build 26.1.0 +# meta.yaml template originally from: +# /home/task_177254812424319/xz-feedstock/recipe, last modified Tue Mar 3 14:31:59 2026 +# ------------------------------------------------ + +package: + name: xz + version: 5.8.2 +source: + url: https://github.com/tukaani-project/xz/releases/download/v5.8.2/xz-5.8.2.tar.gz + sha256: ce09c50a5962786b83e5da389c90dd2c15ecd0980a258dd01f70f9e7ce58a8f1 +build: + number: '0' + run_exports: + - xz >=5.8.2,<6.0a0 + string: h448239c_0 +requirements: + build: + - _libgcc_mutex 0.1 main + - _openmp_mutex 5.1 1_gnu + - binutils_impl_linux-64 2.44 h4b9a079_2 + - binutils_linux-64 2.44 hc03a8fd_2 + - cmake-no-system 3.25.3 h6a678d5_0 + - gcc_impl_linux-64 14.3.0 h4943218_4 + - gcc_linux-64 14.3.0 hda73cce_12 + - kernel-headers_linux-64 4.18.0 h3108a97_1 + - ld_impl_linux-64 2.44 h153f514_2 + - libgcc 15.2.0 h69a1729_7 + - libgcc-devel_linux-64 14.3.0 he7458c1_104 + - libgcc-ng 15.2.0 h166f726_7 + - libgomp 15.2.0 h4751f2c_7 + - libsanitizer 14.3.0 hd4faa28_4 + - libstdcxx 15.2.0 h39759b7_7 + - libstdcxx-ng 15.2.0 hc03a8fd_7 + - ninja-base 1.13.1 h0f57076_0 + - sysroot_linux-64 2.28 h3108a97_1 + - tzdata 2025c he532380_0 + host: + - _libgcc_mutex 0.1 main + - _openmp_mutex 5.1 1_gnu + - libgcc 15.2.0 h69a1729_7 + - libgomp 15.2.0 h4751f2c_7 + run: + - __glibc >=2.28,<3.0.a0 + - libgcc >=14 +test: + requires: + - pkg-config + commands: + - xz --help + - unxz --help + - lzma --help + - test -f ${PREFIX}/include/lzma.h + - test -f ${PREFIX}/lib/cmake/liblzma/liblzma-config.cmake + - test -f ${PREFIX}/lib/pkgconfig/liblzma.pc + - test -f `pkg-config --variable=libdir --dont-define-prefix liblzma`/liblzma${SHLIB_EXT} + - test ! -f ${PREFIX}/lib/liblzma.a + - test -f ${PREFIX}/lib/liblzma${SHLIB_EXT} + - test -f ${PREFIX}/lib/liblzma${SHLIB_EXT}.5 + - test -f ${PREFIX}/lib/liblzma${SHLIB_EXT}.5.8.2 +about: + home: https://tukaani.org/xz/ + license: LGPL-2.1-or-later and GPL-2.0-or-later and 0BSD + license_file: COPYING + license_family: GPL2 + summary: Data compression software with high compression ratio + description: 'XZ Utils is free general-purpose data compression software with a + high + + compression ratio. XZ Utils were written for POSIX-like systems, but also + + work on some not-so-POSIX systems. + + ' + doc_url: https://tukaani.org/xz/#_documentation + dev_url: https://github.com/tukaani-project/xz +extra: + recipe-maintainers: + - mingwandroid + - msarahan + - nehaljwani + - ocefpaf + - scopatz + final: true + copy_test_source_files: true + remote_url: https://github.com/AnacondaRecipes/xz-feedstock + sha: 4783e2f43c7a92fb112ceb569d162fa290780d80 + task_id: NMJPrbJgTIWKXqQPQ93B2Q + task_run_id: '0' + pbp_graph_uuid: 59a56d01-5092-4d3b-b4dd-0a1f17128357 diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/recipe/meta.yaml.template b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/recipe/meta.yaml.template new file mode 100644 index 0000000000000000000000000000000000000000..f2465b21fbd4dd628cc20c241507d536c036a5ba --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/recipe/meta.yaml.template @@ -0,0 +1,71 @@ +{% set version = "5.8.2" %} +{% set major = version.split('.')[0] %} + +package: + name: xz + version: {{ version }} + +source: + url: https://github.com/tukaani-project/xz/releases/download/v{{ version }}/xz-{{ version }}.tar.gz + sha256: ce09c50a5962786b83e5da389c90dd2c15ecd0980a258dd01f70f9e7ce58a8f1 + +build: + number: 0 + run_exports: + # XZ's track record of backcompat is very good. Keep default pins (next major version) + # https://abi-laboratory.pro/tracker/timeline/xz/ + - {{ pin_subpackage('xz') }} + +requirements: + build: + - {{ stdlib('c') }} + - {{ compiler('c') }} + - cmake-no-system + - ninja-base + host: + - msinttypes # [win and vc<14] + +test: + requires: + - pkg-config # [unix] + commands: + - xz --help # [not win] + - unxz --help # [not win] + - lzma --help # [not win] + - xz.exe --help # [win] + - test -f ${PREFIX}/include/lzma.h # [unix] + - test -f ${PREFIX}/lib/cmake/liblzma/liblzma-config.cmake # [unix] + - test -f ${PREFIX}/lib/pkgconfig/liblzma.pc # [unix] + - test -f `pkg-config --variable=libdir --dont-define-prefix liblzma`/liblzma${SHLIB_EXT} # [unix] + - test ! -f ${PREFIX}/lib/liblzma.a # [unix] + - test -f ${PREFIX}/lib/liblzma${SHLIB_EXT} # [unix] + - test -f ${PREFIX}/lib/liblzma.{{ major }}${SHLIB_EXT} # [osx] + - test -f ${PREFIX}/lib/liblzma${SHLIB_EXT}.{{ major }} # [linux] + - test -f ${PREFIX}/lib/liblzma${SHLIB_EXT}.{{ version }} # [linux] + - if not exist %PREFIX%\\Library\\bin\\liblzma.dll exit 1 # [win] + - if exist %PREFIX%\\Library\\lib\\lzma_static.lib exit 1 # [win] + - if not exist %PREFIX%\\Library\\lib\\pkgconfig\\liblzma.pc exit 1 # [win] + - if not exist %PREFIX%\\Library\\include\\lzma.h exit 1 # [win] + - if not exist %PREFIX%\\Library\\bin\\xz.exe exit 1 # [win] + - if exist %PREFIX%\\lib exit 1 # [win] + +about: + home: https://tukaani.org/xz/ + license: LGPL-2.1-or-later and GPL-2.0-or-later and 0BSD + license_file: COPYING + license_family: GPL2 + summary: Data compression software with high compression ratio + description: | + XZ Utils is free general-purpose data compression software with a high + compression ratio. XZ Utils were written for POSIX-like systems, but also + work on some not-so-POSIX systems. + doc_url: https://tukaani.org/xz/#_documentation + dev_url: https://github.com/tukaani-project/xz + +extra: + recipe-maintainers: + - msarahan + - ocefpaf + - mingwandroid + - nehaljwani + - scopatz diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/repodata_record.json b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/repodata_record.json new file mode 100644 index 0000000000000000000000000000000000000000..c05aa0a00057506f97ac262a650a6c897c9346f4 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/repodata_record.json @@ -0,0 +1,23 @@ +{ + "arch": "x86_64", + "build": "h448239c_0", + "build_number": 0, + "channel": "https://repo.anaconda.com/pkgs/main/linux-64/", + "constrains": [], + "depends": [ + "__glibc >=2.28,<3.0.a0", + "libgcc >=14" + ], + "fn": "xz-5.8.2-h448239c_0.conda", + "license": "LGPL-2.1-or-later and GPL-2.0-or-later and 0BSD", + "license_family": "GPL2", + "md5": "3cf8f0b9f45cd775a7ee57ede84f827f", + "name": "xz", + "platform": "linux", + "sha256": "6394c59cbb6ff035f3a5e4d599a32214cb304b362299fd40be39d7ed20bef9d1", + "size": 635646, + "subdir": "linux-64", + "timestamp": 1772548381000, + "url": "https://repo.anaconda.com/pkgs/main/linux-64/xz-5.8.2-h448239c_0.conda", + "version": "5.8.2" +} \ No newline at end of file diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/run_exports.json b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/run_exports.json new file mode 100644 index 0000000000000000000000000000000000000000..746a479b88eaef50a878d93d9be48d8c9296ea96 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/run_exports.json @@ -0,0 +1 @@ +{"weak": ["xz >=5.8.2,<6.0a0"]} \ No newline at end of file diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/test/run_test.sh b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/test/run_test.sh new file mode 100644 index 0000000000000000000000000000000000000000..95407a6695099444e77d7ecd584aa12338a8cbfa --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/test/run_test.sh @@ -0,0 +1,18 @@ + + +set -ex + + + +xz --help +unxz --help +lzma --help +test -f ${PREFIX}/include/lzma.h +test -f ${PREFIX}/lib/cmake/liblzma/liblzma-config.cmake +test -f ${PREFIX}/lib/pkgconfig/liblzma.pc +test -f `pkg-config --variable=libdir --dont-define-prefix liblzma`/liblzma${SHLIB_EXT} +test ! -f ${PREFIX}/lib/liblzma.a +test -f ${PREFIX}/lib/liblzma${SHLIB_EXT} +test -f ${PREFIX}/lib/liblzma${SHLIB_EXT}.5 +test -f ${PREFIX}/lib/liblzma${SHLIB_EXT}.5.8.2 +exit 0 diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/test/test_time_dependencies.json b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/test/test_time_dependencies.json new file mode 100644 index 0000000000000000000000000000000000000000..b4b720166413087a828db5c9405622e8257f7cb0 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/info/test/test_time_dependencies.json @@ -0,0 +1 @@ +["pkg-config"] \ No newline at end of file diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/lib/cmake/liblzma/liblzma-config-version.cmake b/miniconda3/pkgs/xz-5.8.2-h448239c_0/lib/cmake/liblzma/liblzma-config-version.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d1811751b2d761c5fe4e761c9728211d2c735c3d --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/lib/cmake/liblzma/liblzma-config-version.cmake @@ -0,0 +1,70 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version, +# but only if the requested major version is the same as the current one. +# The variable CVF_VERSION must be set before calling configure_file(). + + +set(PACKAGE_VERSION "5.8.2") + +if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) +else() + + if("5.8.2" MATCHES "^([0-9]+)\\.") + set(CVF_VERSION_MAJOR "${CMAKE_MATCH_1}") + if(NOT CVF_VERSION_MAJOR VERSION_EQUAL 0) + string(REGEX REPLACE "^0+" "" CVF_VERSION_MAJOR "${CVF_VERSION_MAJOR}") + endif() + else() + set(CVF_VERSION_MAJOR "5.8.2") + endif() + + if(PACKAGE_FIND_VERSION_RANGE) + # both endpoints of the range must have the expected major version + math (EXPR CVF_VERSION_MAJOR_NEXT "${CVF_VERSION_MAJOR} + 1") + if (NOT PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND NOT PACKAGE_FIND_VERSION_MAX_MAJOR STREQUAL CVF_VERSION_MAJOR) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND NOT PACKAGE_FIND_VERSION_MAX VERSION_LESS_EQUAL CVF_VERSION_MAJOR_NEXT))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + elseif(PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR + AND ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS_EQUAL PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE TRUE) + else() + set(PACKAGE_VERSION_COMPATIBLE FALSE) + endif() + else() + if(PACKAGE_FIND_VERSION_MAJOR STREQUAL CVF_VERSION_MAJOR) + set(PACKAGE_VERSION_COMPATIBLE TRUE) + else() + set(PACKAGE_VERSION_COMPATIBLE FALSE) + endif() + + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed project requested no architecture check, don't perform the check +if("FALSE") + return() +endif() + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/lib/cmake/liblzma/liblzma-config.cmake b/miniconda3/pkgs/xz-5.8.2-h448239c_0/lib/cmake/liblzma/liblzma-config.cmake new file mode 100644 index 0000000000000000000000000000000000000000..181f55a935c295549869d578133b3d4ea45f1209 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/lib/cmake/liblzma/liblzma-config.cmake @@ -0,0 +1,16 @@ +include(CMakeFindDependencyMacro) +set(THREADS_PREFER_PTHREAD_FLAG TRUE) +find_dependency(Threads) + +include("${CMAKE_CURRENT_LIST_DIR}/liblzma-targets.cmake") + +if(NOT TARGET LibLZMA::LibLZMA) + # Be compatible with the spelling used by the FindLibLZMA module. This + # doesn't use ALIAS because it would make CMake resolve LibLZMA::LibLZMA + # to liblzma::liblzma instead of keeping the original spelling. Keeping + # the original spelling is important for good FindLibLZMA compatibility. + add_library(LibLZMA::LibLZMA INTERFACE IMPORTED) + set_target_properties(LibLZMA::LibLZMA PROPERTIES + INTERFACE_LINK_LIBRARIES liblzma::liblzma) +endif() + diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/lib/cmake/liblzma/liblzma-targets-release.cmake b/miniconda3/pkgs/xz-5.8.2-h448239c_0/lib/cmake/liblzma/liblzma-targets-release.cmake new file mode 100644 index 0000000000000000000000000000000000000000..57d860d984d358e7a7c453137300818ece894a1f --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/lib/cmake/liblzma/liblzma-targets-release.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Release". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "liblzma::liblzma" for configuration "Release" +set_property(TARGET liblzma::liblzma APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) +set_target_properties(liblzma::liblzma PROPERTIES + IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/liblzma.so.5.8.2" + IMPORTED_SONAME_RELEASE "liblzma.so.5" + ) + +list(APPEND _cmake_import_check_targets liblzma::liblzma ) +list(APPEND _cmake_import_check_files_for_liblzma::liblzma "${_IMPORT_PREFIX}/lib/liblzma.so.5.8.2" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/lib/cmake/liblzma/liblzma-targets.cmake b/miniconda3/pkgs/xz-5.8.2-h448239c_0/lib/cmake/liblzma/liblzma-targets.cmake new file mode 100644 index 0000000000000000000000000000000000000000..fc4d550f0c984c8b636012fd7f2aea2e1e632ee5 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/lib/cmake/liblzma/liblzma-targets.cmake @@ -0,0 +1,102 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8) + message(FATAL_ERROR "CMake >= 2.8.0 required") +endif() +if(CMAKE_VERSION VERSION_LESS "2.8.3") + message(FATAL_ERROR "CMake >= 2.8.3 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 2.8.3...3.23) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_cmake_targets_defined "") +set(_cmake_targets_not_defined "") +set(_cmake_expected_targets "") +foreach(_cmake_expected_target IN ITEMS liblzma::liblzma) + list(APPEND _cmake_expected_targets "${_cmake_expected_target}") + if(TARGET "${_cmake_expected_target}") + list(APPEND _cmake_targets_defined "${_cmake_expected_target}") + else() + list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}") + endif() +endforeach() +unset(_cmake_expected_target) +if(_cmake_targets_defined STREQUAL _cmake_expected_targets) + unset(_cmake_targets_defined) + unset(_cmake_targets_not_defined) + unset(_cmake_expected_targets) + unset(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT _cmake_targets_defined STREQUAL "") + string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}") + string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n") +endif() +unset(_cmake_targets_defined) +unset(_cmake_targets_not_defined) +unset(_cmake_expected_targets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target liblzma::liblzma +add_library(liblzma::liblzma SHARED IMPORTED) + +set_target_properties(liblzma::liblzma PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include" +) + +# Load information for each installed configuration. +file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/liblzma-targets-*.cmake") +foreach(_cmake_config_file IN LISTS _cmake_config_files) + include("${_cmake_config_file}") +endforeach() +unset(_cmake_config_file) +unset(_cmake_config_files) + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(_cmake_target IN LISTS _cmake_import_check_targets) + foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}") + if(NOT EXISTS "${_cmake_file}") + message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file + \"${_cmake_file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + unset(_cmake_file) + unset("_cmake_import_check_files_for_${_cmake_target}") +endforeach() +unset(_cmake_target) +unset(_cmake_import_check_targets) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/lib/pkgconfig/liblzma.pc b/miniconda3/pkgs/xz-5.8.2-h448239c_0/lib/pkgconfig/liblzma.pc new file mode 100644 index 0000000000000000000000000000000000000000..880b9911ee417de36e90a7868f94c3b33d29af49 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/lib/pkgconfig/liblzma.pc @@ -0,0 +1,16 @@ +# SPDX-License-Identifier: 0BSD +# Author: Lasse Collin + +prefix=/home/task_177254812424319/croot/xz_1772548347995/_h_env_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehold_placehol +exec_prefix=${prefix} +libdir=${exec_prefix}/lib +includedir=${prefix}/include + +Name: liblzma +Description: General purpose data compression library +URL: https://tukaani.org/xz/ +Version: 5.8.2 +Cflags: -I${includedir} +Cflags.private: -DLZMA_API_STATIC +Libs: -L${libdir} -llzma +Libs.private: -pthread diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/AUTHORS b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/AUTHORS new file mode 100644 index 0000000000000000000000000000000000000000..f805a204ecb75ca7245e3488101740ec013870c1 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/AUTHORS @@ -0,0 +1,58 @@ + +Authors of XZ Utils +=================== + + XZ Utils is developed and maintained by + Lasse Collin . + + Major parts of liblzma are based on code written by Igor Pavlov, + specifically the LZMA SDK . Without + this code, XZ Utils wouldn't exist. + + The SHA-256 implementation in liblzma is based on code written by + Wei Dai in Crypto++ Library . + + A few scripts have been adapted from GNU gzip. The original + versions were written by Jean-loup Gailly, Charles Levert, and + Paul Eggert. Andrew Dudman helped adapting the scripts and their + man pages for XZ Utils. + + The initial version of the threaded .xz decompressor was written + by Sebastian Andrzej Siewior. + + The initial version of the .lz (lzip) decoder was written + by Michał Górny. + + Architecture-specific CRC optimizations were contributed by + Ilya Kurdyukov, Chenxi Mao, and Xi Ruoyao. + + Other authors: + - Jonathan Nieder + - Joachim Henke + + Special author: Jia Tan was a co-maintainer in 2022-2024. He and + the team behind him inserted a backdoor (CVE-2024-3094) into + XZ Utils 5.6.0 and 5.6.1 releases. He suddenly disappeared when + this was discovered. + + Many people have contributed improvements or reported bugs. + Most of these people are mentioned in the file THANKS. + + The translations of the command line tools and man pages have been + contributed by many people via the Translation Project: + + - https://translationproject.org/domain/xz.html + - https://translationproject.org/domain/xz-man.html + + The authors of the translated man pages are in the header comments + of the man page files. In the source package, the authors of the + translations are in po/*.po and po4a/*.po files. + + Third-party code whose authors aren't listed here: + + - GNU getopt_long() in the 'lib' directory is included for + platforms that don't have a usable getopt_long(). + + - The build system files from GNU Autoconf, GNU Automake, + GNU Libtool, GNU Gettext, Autoconf Archive, and related files. + diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/COPYING b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/COPYING new file mode 100644 index 0000000000000000000000000000000000000000..ef3371389d7d45db6593a146fd9e027347f3122c --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/COPYING @@ -0,0 +1,70 @@ + +XZ Utils Licensing +================== + + Different licenses apply to different files in this package. Here + is a summary of which licenses apply to which parts of this package: + + - liblzma is under the BSD Zero Clause License (0BSD). + + - The command line tools xz, xzdec, lzmadec, and lzmainfo are + under 0BSD except that, on systems that don't have a usable + getopt_long, GNU getopt_long is compiled and linked in from the + 'lib' directory. The getopt_long code is under GNU LGPLv2.1+. + + - The scripts to grep, diff, and view compressed files have been + adapted from GNU gzip. These scripts (xzgrep, xzdiff, xzless, + and xzmore) are under GNU GPLv2+. The man pages of the scripts + are under 0BSD; they aren't based on the man pages of GNU gzip. + + - Most of the XZ Utils specific documentation that is in + plain text files (like README, INSTALL, PACKAGERS, NEWS, + and ChangeLog) are under 0BSD unless stated otherwise in + the file itself. The files xz-file-format.txt and + lzma-file-format.xt are in the public domain but may + be distributed under the terms of 0BSD too. + + - Translated messages and man pages are under 0BSD except that + some old translations are in the public domain. + + - Test files and test code in the 'tests' directory, and + debugging utilities in the 'debug' directory are under + the BSD Zero Clause License (0BSD). + + - The GNU Autotools based build system contains files that are + under GNU GPLv2+, GNU GPLv3+, and a few permissive licenses. + These files don't affect the licensing of the binaries being + built. + + - The 'extra' directory contains files that are under various + free software licenses. These aren't built or installed as + part of XZ Utils. + + The following command may be helpful in finding per-file license + information. It works on xz.git and on a clean file tree extracted + from a release tarball. + + sh build-aux/license-check.sh -v + + For the files under the BSD Zero Clause License (0BSD), if + a copyright notice is needed, the following is sufficient: + + Copyright (C) The XZ Utils authors and contributors + + If you copy significant amounts of 0BSD-licensed code from XZ Utils + into your project, acknowledging this somewhere in your software is + polite (especially if it is proprietary, non-free software), but + it is not legally required by the license terms. Here is an example + of a good notice to put into "about box" or into documentation: + + This software includes code from XZ Utils . + + The following license texts are included in the following files: + - COPYING.0BSD: BSD Zero Clause License + - COPYING.LGPLv2.1: GNU Lesser General Public License version 2.1 + - COPYING.GPLv2: GNU General Public License version 2 + - COPYING.GPLv3: GNU General Public License version 3 + + If you have questions, don't hesitate to ask for more information. + The contact information is in the README file. + diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/COPYING.0BSD b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/COPYING.0BSD new file mode 100644 index 0000000000000000000000000000000000000000..4322122aecf1aecff317bd50334ba206dcb9ac41 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/COPYING.0BSD @@ -0,0 +1,11 @@ +Permission to use, copy, modify, and/or distribute this +software for any purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL +WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL +THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR +CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, +NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN +CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/COPYING.GPLv2 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/COPYING.GPLv2 new file mode 100644 index 0000000000000000000000000000000000000000..9efa6fbc962836e243e20f7f23db062e2c077d28 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/COPYING.GPLv2 @@ -0,0 +1,338 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc., + + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Lesser General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along + with this program; if not, see . + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Moe Ghoul, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/NEWS b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/NEWS new file mode 100644 index 0000000000000000000000000000000000000000..73ff8558da08fca0bee21fb60922891f7de0e828 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/NEWS @@ -0,0 +1,2992 @@ + +XZ Utils Release Notes +====================== + +5.8.2 (2025-12-17) + + * liblzma: + + - Fix the build on ARM64 on glibc versions older than + 2.24 (2016). They don't have HWCAP_CRC32 in . + + - Disable CLMUL CRC code when building for 32-bit x86 with + old MSVC versions. This avoids a compiler bug. The exact + compiler version in which the issue was fixed is unknown, + but VS 2022 17.13 (MSVC 19.43.34808) is known to work, so + CLMUL CRC on 32-bit x86 is disabled with MSVC versions + older than that. + + * xz: + + - Add a workaround for Red Hat Enterprise Linux 9 kernel bug + which made xz fail with "xz: Failed to enable the sandbox". + It only occurs with xz 5.8.0 and 5.8.1 binaries built for + other distros. For example, running Debian 13 in a container + on RHEL/CentOS 9 would trigger the issue. + + The bug was introduced in RHEL 9 kernel 5.14.0-603.el9 + (2025-07-30) and fixed in 5.14.0-648.el9 (2025-12-05). + However, as of writing, the fixed kernel isn't available + to RHEL 9 users yet, so including the workaround in this + xz release seems reasonable. The workaround will be removed + when it's no longer needed. + + xzdec was also affected by this issue. + + - On AIX, don't use fsync() on directories because it fails. + + - Fix the build on Emscripten. + + - Fix the build on clang-cl on Windows. + + - Take resource limits (RLIMIT_DATA, RLIMIT_AS, and RLIMIT_VMEM) + into account when determining the default memory usage limit + for multithreaded mode. This should prevent xz from failing + when a resource limit has been set to a value that is less + than 1/4 of total RAM. Other memory limits can still trigger + the same issue, for example, Linux cgroup v2 memory.max. + + * Build systems: + + - When symbol versioning is enabled, pass --undefined-version + to the linker if the option is supported. This fixes the + build when using LLVM's lld and some liblzma features have + been disabled at build time. + + - ARM64: Fix autodetection of fast unaligned memory access when + using GCC and -mstrict-align is in effect. Previously the + build systems would incorrectly guess that unaligned access + is fast, which would result in much slower binaries than + needed. The fix is a workaround for GCC bug 111555; + autodetection already worked with Clang. + + - LoongArch: Autodetect if fast unaligned memory access is + supported. This can improve compression speed by 15 % (but + not decompression speed). + + * Translations: + + - Update the Spanish translation. + + - Add Swedish man page translations. + + - Update Italian, Korean, Romanian, Serbian, and Ukrainian + man page translations. + + +5.8.1 (2025-04-03) + + IMPORTANT: This includes a security fix for CVE-2025-31115 which + affects XZ Utils from 5.3.3alpha to 5.8.0. No new 5.4.x or 5.6.x + releases will be made, but the fix is in the v5.4 and v5.6 branches + in the xz Git repository. A standalone patch for all affected + versions is available as well. + + * Multithreaded .xz decoder (lzma_stream_decoder_mt()): + + - Fix a bug that could at least result in a crash with + invalid input. (CVE-2025-31115) + + - Fix a performance bug: Only one thread was used if the whole + input file was provided at once to lzma_code(), the output + buffer was big enough, timeout was disabled, and LZMA_FINISH + was used. There are no bug reports about this, thus it's + possible that no real-world application was affected. + + * Avoid even with C11/C17 compilers. This fixes the + build with Oracle Developer Studio 12.6 on Solaris 10 when the + compiler is in C11 mode (the header doesn't exist). + + * Autotools: Restore compatibility with GNU make versions older + than 4.0 by creating the package using GNU gettext 0.23.1 + infrastructure instead of 0.24. + + * Update Croatian translation. + + +5.8.0 (2025-03-25) + + This bumps the minor version of liblzma because new features were + added. The API and ABI are still backward compatible with liblzma + 5.6.x, 5.4.x, 5.2.x, and 5.0.x. + + * liblzma on 32/64-bit x86: When possible, use SSE2 intrinsics + instead of memcpy() in the LZMA/LZMA2 decoder. In typical cases, + this may reduce decompression time by 0-5 %. However, when built + against musl libc, over 15 % time reduction was observed with + highly compressed files. + + * CMake: Make the feature test macros match the Autotools-based + build on NetBSD, Darwin, and mingw-w64. + + * Update the Croatian, Italian, Portuguese, and Romanian + translations. + + * Update the German, Italian, Korean, Romanian, Serbian, and + Ukrainian man page translations. + + Summary of changes in the 5.7.x development releases: + + * Mark the following LZMA Utils script aliases as deprecated: + lzcmp, lzdiff, lzless, lzmore, lzgrep, lzegrep, and lzfgrep. + + * liblzma: + + - Improve LZMA/LZMA2 encoder speed on 64-bit PowerPC (both + endiannesses) and those 64-bit RISC-V processors that + support fast unaligned access. + + - Add low-level APIs for RISC-V, ARM64, and x86 BCJ filters + to lzma/bcj.h. These are primarily for erofs-utils. + + - x86/x86-64/E2K CLMUL CRC code was rewritten. + + - Use the CRC32 instructions on LoongArch. + + * xz: + + - Synchronize the output file and its directory using fsync() + before deleting the input file. No syncing is done when xz + isn't going to delete the input file. + + - Add --no-sync to disable the sync-before-delete behavior. + + - Make --single-stream imply --keep. + + * xz, xzdec, lzmainfo: When printing messages, replace + non-printable characters with question marks. + + * xz and xzdec on Linux: Support Landlock ABI versions 5 and 6. + + * CMake: Revise the configuration variables and some of their + options, and document them in the file INSTALL. CMake support + is no longer experimental. (It was already not experimental + when building for native Windows.) + + * Add build-aux/license-check.sh. + + +5.7.2beta (2025-03-08) + + * On the man pages, mark the following LZMA Utils script aliases as + deprecated: lzcmp, lzdiff, lzless, lzmore, lzgrep, lzegrep, and + lzfgrep. The commands that start with xz* instead of lz* have + identical behavior. + + The LZMA Utils aliases lzma, unlzma, and lzcat aren't deprecated + because some of these aliases are still in common use. lzmadec + and lzmainfo aren't deprecated either. + + * xz: In the ENVIRONMENT section of the man page, warn about + problems that some uses of XZ_DEFAULTS and XZ_OPT may create. + + * Windows (native builds, not Cygwin): In xz, xzdec, and lzmadec, + avoid an error message on broken pipe. + + * Autotools: Fix out-of-tree builds when using the bundled + getopt_long. + + * Translations: + + - Updated: Chinese (traditional), Croatian, Finnish, Georgian, + German, Korean, Polish, Romanian, Serbian, Spanish, Swedish, + Turkish, and Ukrainian + + - Added: Dutch + + * Man page translations: + + - Updated: German, Korean, Romanian, and Ukrainian + + - Added: Italian and Serbian + + +5.7.1alpha (2025-01-23) + + * All fixes from 5.6.4. + + * liblzma: + + - Improve LZMA/LZMA2 encoder speed on 64-bit PowerPC (both + endiannesses) and those 64-bit RISC-V processors that + support fast unaligned access. + + - x86/x86-64/E2K CLMUL CRC code was rewritten. It's faster and + doesn't cause false positives from sanitizers. Attributes + like __attribute__((__no_sanitize_address__)) are no longer + present. + + - On 32-bit x86, CLMUL CRC and the old (but still good) + assembly versions now co-exist with runtime detection. + Both Autotools and CMake build systems handle this + automatically now. + + - Use the CRC32 instructions on LoongArch to make CRC32 + calculation faster. + + - Add low-level APIs for RISC-V, ARM64, and x86 BCJ filters + to lzma/bcj.h. These are primarily for erofs-utils. + + - Minor tweaks to ARM64 CRC32 code and BCJ filters were made. + + * xz: + + - Synchronize the output file and its directory before deleting + the input file using fsync(). This reduces the probability of + data loss after a system crash. However, it can be a major + performance hit if processing many small files. + + NOTE: No syncing is done when xz isn't going to delete + the input file. + + - Add a new option --no-sync to disable the sync-before-delete + behavior. It's useful when compressing many small files and + one doesn't worry about data loss in case of a system crash. + + - Make --single-stream imply --keep. + + - Use automatic word wrapping for the text in --help and + similar situations to hopefully make the strings easier for + majority of translators (no need to count spaces anymore). + + * xz, xzdec, lzmainfo: When printing messages, replace + non-printable characters with question marks. This way + malicious filenames cannot be used to send escape sequences + to a terminal. This change is also applied to filenames shown + in "xz --robot --list". + + * xz and xzdec on Linux: Add support for Landlock ABI versions 5 + and 6. + + * CMake updates: + + - Increase the minimum required CMake version to 3.20. + + - Revise the configuration variables and some of their options. + Document them in the file INSTALL. + + - Attempt to produce liblzma.pc so that the paths are based on + ${prefix}, which makes it simpler to override the paths + if the liblzma files have been moved. + + - To enable translations, gettext-tools is now required. The + CMake build no longer supports installing pre-compiled + message catalog binary files (po/*.gmo). + + - Apple: Use Mach-O shared library versioning that is + compatible with GNU Libtool. This should make it easier to + switch between the build systems on Apple OSes that enforce + the correct compatibility_version (macOS >= 12 doesn't?). + This change is backward compatible: binaries linked against + old CMake-built liblzma will run with liblzma that uses + Libtool style versioning. + + - Windows (not Cygwin): Document CMAKE_DLL_NAME_WITH_SOVERSION + (CMake >= 3.27) in the file INSTALL. This option should + usually be left to its default value (OFF). It can be set + to ON if the liblzma DLL filename must be compatible with + the versioned filename produced by GNU Libtool. For example, + binaries distributed in MSYS2 use a versioned DLL filename. + + - CMake support is no longer experimental. (It was already + not experimental when building for native Windows.) + + * Windows: Building liblzma with Visual Studio 2013 is no longer + supported. Visual Studio 2015 or later (with CMake) can be used + to build liblzma and the command line tools. + + * Add preliminary Georgian translation. This already contains + translations of most of the strings that are now automatically + word wrapped. + + * Add build-aux/license-check.sh. Without arguments, it checks that + no license information has been forgotten. With the -v argument, + it shows the license info (or the lack of it) for each file. + + If the .git directory is available, only the files in the + repository are checked. Without the .git directory, a clean tree + from an extracted release tarball is expected. + + +5.6.4 (2025-01-23) + + * liblzma: Fix LZMA/LZMA2 encoder on big endian ARM64. + + * xz: + + - Fix --filters= and --filters1= ... --filters9= options + parsing. They require an argument, thus "xz --filters lzma2" + should work in addition to "xz --filters=lzma2". + + - On the man page, note in the --compress and --decompress + options that the default behavior is to delete the input + file unless writing to standard output. It was already + documented in the DESCRIPTION section but new users in + a hurry might miss it. + + * Windows (native builds, not Cygwin): Fix regressions introduced + in XZ Utils 5.6.3 which caused non-ASCII characters to display + incorrectly. Only builds with translation support were affected + (--enable-nls or ENABLE_NLS=ON). The following changes affect + builds that have translations enabled: + + - Require UCRT because MSVCRT doesn't support UTF-8 + locales and thus translations won't be readable on + Windows 10 version 1903 and later. (MSVCRT builds + are still possible with --disable-nls or ENABLE_NLS=OFF.) + + - Require gettext-runtime >= 0.23.1 because older versions + don't autodetect the use of the UTF-8 code page. This + resulted in garbled non-ASCII characters even with UCRT. + + - Partially fix alignment issues in xz --verbose --list + with translated messages. Chinese (simplified), + Chinese (traditional), and Korean column headings + are misaligned still because Windows and MinGW-w64 + don't provide wcwidth() and XZ Utils doesn't include + a replacement function either. + + * CMake: Explicitly disable unity builds. This prevents build + failures when another project uses XZ Utils via CMake's + FetchContent module, and that project enables unity builds. + + * Update Chinese (traditional) and Serbian translations. + + +5.6.3 (2024-10-01) + + IMPORTANT: This includes a Windows-specific security fix to + the command line tools (CVE-2024-47611). liblzma isn't affected + by this issue. + + * liblzma: + + - Fix x86-64 inline assembly compatibility with GNU Binutils + older than 2.27. + + - Fix the build with GCC 4.2 on OpenBSD/sparc64. + + * xzdec: Display an error instead of failing silently if the + unsupported option -M is specified. + + * lzmainfo: Fix integer overflows when rounding the dictionary and + uncompressed sizes to the nearest mebibyte. + + * Windows (except Cygwin and MSYS2): Add an application manifest to + xz, xzdec, lzmadec, and lzmainfo executables: + + - Declare them compatible with Vista/7/8/8.1/10/11. This way + the programs won't needlessly use Operating System Context + of Vista when running on later Windows versions. This setting + doesn't mean that the executables cannot run on even older + versions if otherwise built that way. + + - Declare them as UAC-compliant. MSVC added this by default + already but it wasn't done with MinGW-w64, at least not + with all toolchain variants. + + - Declare them long path aware. This makes long path names + work on Windows 10 and 11 if the feature has been enabled + in the Windows registry. + + - Use the UTF-8 code page on Windows 10 version 1903 and later. + + * Now command line tools can access files whose names + contain characters that don't exist in the current + legacy code page. + + * The options --files and --files0 now expect file lists + to be in UTF-8 instead of the legacy code page. + + * This fixes a security issue: If a command line contains + Unicode characters (for example, filenames) that don't + exist in the current legacy code page, the characters are + converted to similar-looking characters with best-fit + mapping. Some best-fit mappings result in ASCII + characters that change the meaning of the command line, + which can be exploited with malicious filenames to do + argument injection or directory traversal attacks. + UTF-8 avoids best-fit mappings and thus fixes the issue. + (CVE-2024-47611) + + Forcing the process code page to UTF-8 is possible only + on Windows 10 version 1903 and later. The command line + tools remain vulnerable if used on an old older + version of Windows. + + This issue was discovered by Orange Tsai and splitline + from DEVCORE Research Team. + + A related smaller issue remains: Windows filenames may + contain unpaired surrogates (invalid UTF-16). These are + converted to the replacement character U+FFFD in the + UTF-8 code page. Thus, filenames with different unpaired + surrogates appear identical and aren't distinguishable + from filenames that contain the actual replacement + character U+FFFD. + + * When building with MinGW-w64, it is recommended to use + UCRT version instead of the old MSVCRT. For example, + non-ASCII characters from filenames won't print + correctly in messages to console with MSVCRT with + the UTF-8 code page (a cosmetic issue). liblzma-only + builds are still fine with MSVCRT. + + - Cygwin and MSYS2 process command line options differently and + the above issues don't exist. There is no need to replace the + default application manifest on Cygwin and MSYS2. + + * Autotools-based build: + + - Fix feature checks with link-time optimization (-flto). + + - Solaris: Fix a compatibility issue in version.sh. It matters + if one wants to regenerate configure by running autoconf. + + * CMake: + + - Use paths relative to ${prefix} in liblzma.pc when possible. + This is done only with CMake >= 3.20. + + - MSVC: Install liblzma.pc as it can be useful with MSVC too. + + - Windows: Fix liblzma filename prefix, for example: + + * Cygwin: The DLL was incorrectly named liblzma-5.dll. + Now it is cyglzma-5.dll. + + * MSVC: Rename import library from liblzma.lib to lzma.lib + while keeping liblzma.dll name as is. This helps with + "pkgconf --msvc-syntax --libs liblzma" because it mungles + "-llzma" in liblzma.pc to "lzma.lib". + + * MinGW-w64: No changes. + + - Windows: Use the correct resource file for lzmadec.exe. + Previously the resource file for xzdec.exe was used for both. + Autotools-based build isn't affected. + + - Prefer a C11 compiler over a C99 compiler but accept both. + + - Link Threads::Threads against liblzma using PRIVATE so that + -pthread and such flags won't unnecessarily get included in + the usage requirements of shared liblzma. That is, + target_link_libraries(foo PRIVATE liblzma::liblzma) no + longer adds -pthread if using POSIX threads and linking + against shared liblzma. The threading flags are still added + if linking against static liblzma. + + * Updated translations: Catalan, Chinese (simplified), and + Brazilian Portuguese. + + +5.6.2 (2024-05-29) + + * Remove the backdoor (CVE-2024-3094). + + * Not changed: Memory sanitizer (MSAN) has a false positive + in the CRC CLMUL code which also makes OSS Fuzz unhappy. + Valgrind is smarter and doesn't complain. + + A revision to the CLMUL code is coming anyway and this issue + will be cleaned up as part of it. It won't be backported to + 5.6.x or 5.4.x because the old code isn't wrong. There is + no reason to risk introducing regressions in old branches + just to silence a false positive. + + * liblzma: + + - lzma_index_decoder() and lzma_index_buffer_decode(): Fix + a missing output pointer initialization (*i = NULL) if the + functions are called with invalid arguments. The API docs + say that such an initialization is always done. In practice + this matters very little because the problem can only occur + if the calling application has a bug and these functions + return LZMA_PROG_ERROR. + + - lzma_str_to_filters(): Fix a missing output pointer + initialization (*error_pos = 0). This is very similar + to the fix above. + + - Fix C standard conformance with function pointer types. + + - Remove GNU indirect function (IFUNC) support. This is *NOT* + done for security reasons even though the backdoor relied on + this code. The performance benefits of IFUNC are too tiny in + this project to make the extra complexity worth it. + + - FreeBSD on ARM64: Add error checking to CRC32 instruction + support detection. + + - Fix building with NVIDIA HPC SDK. + + * xz: + + - Fix a C standard conformance issue in --block-list parsing + (arithmetic on a null pointer). + + - Fix a warning from GNU groff when processing the man page: + "warning: cannot select font 'CW'" + + * xzdec: Add support for Linux Landlock ABI version 4. xz already + had the v3-to-v4 change but it had been forgotten from xzdec. + + * Autotools-based build system (configure): + + - Symbol versioning variant can now be overridden with + --enable-symbol-versions. Documentation in INSTALL was + updated to match. + + - Add new configure option --enable-doxygen to enable + generation and installation of the liblzma API documentation + using Doxygen. Documentation in INSTALL and PACKAGERS was + updated to match. + + CMake: + + - Fix detection of Linux Landlock support. The detection code + in CMakeLists.txt had been sabotaged. + + - Disable symbol versioning on non-glibc Linux to match what + the Autotools build does. For example, symbol versioning + isn't enabled with musl. + + - Symbol versioning variant can now be overridden by setting + SYMBOL_VERSIONING to "OFF", "generic", or "linux". + + - Add support for all tests in typical build configurations. + Now the only difference to the tests coverage to Autotools + is that CMake-based build will skip more tests if features + are disabled. Such builds are only for special cases like + embedded systems. + + - Separate the CMake code for the tests into tests/tests.cmake. + It is used conditionally, thus it is possible to + + rm -rf tests + + and the CMake-based build will still work normally except + that no tests are then available. + + - Add a option ENABLE_DOXYGEN to enable generation and + installation of the liblzma API documentation using Doxygen. + + * Documentation: + + - Omit the Doxygen-generated liblzma API documentation from the + package. Instead, the generation and installation of the API + docs can be enabled with a configure or CMake option if + Doxygen is available. + + - Remove the XZ logo which was used in the API documentation. + The logo has been retired and isn't used by the project + anymore. However, it's OK to use it in contexts that refer + to the backdoor incident. + + - Remove the PDF versions of the man pages from the source + package. These existed primarily for users of operating + systems which don't come with tools to render man page + source files. The plain text versions are still included + in doc/man/txt. PDF files can still be generated to doc/man, + if the required tools are available, using "make pdf" after + running "configure". + + - Update home page URLs back to their old locations on + tukaani.org. + + - Update maintainer info. + + * Tests: + + - In tests/files/README, explain how to recreate the ARM64 + test files. + + - Remove two tests that used tiny x86 and SPARC object files + as the input files. The matching .c file was included but + the object files aren't easy to reproduce. The test cases + weren't great anyway; they were from the early days (2009) + of the project when the test suite had very few tests. + + - Improve a few tests. + + +5.6.1 (2024-03-09) + + IMPORTANT: This fixed bugs in the backdoor (CVE-2024-3094) (someone + had forgot to run Valgrind). + + * liblzma: Fixed two bugs relating to GNU indirect function (IFUNC) + with GCC. The more serious bug caused a program linked with + liblzma to crash on start up if the flag -fprofile-generate was + used to build liblzma. The second bug caused liblzma to falsely + report an invalid write to Valgrind when loading liblzma. + + * xz: Changed the messages for thread reduction due to memory + constraints to only appear under the highest verbosity level. + + * Build: + + - Fixed a build issue when the header file + was present on the system but the Landlock system calls were + not defined in . + + - The CMake build now warns and disables NLS if both gettext + tools and pre-created .gmo files are missing. Previously, + this caused the CMake build to fail. + + * Minor improvements to man pages. + + * Minor improvements to tests. + + +5.6.0 (2024-02-24) + + IMPORTANT: This added a backdoor (CVE-2024-3094). It's enabled only + in the release tarballs. + + This bumps the minor version of liblzma because new features were + added. The API and ABI are still backward compatible with liblzma + 5.4.x and 5.2.x and 5.0.x. + + NOTE: As described in the NEWS for 5.5.2beta, the core components + are now under the BSD Zero Clause License (0BSD). + + Since 5.5.2beta: + + * liblzma: + + - Disabled the branchless C variant in the LZMA decoder based + on the benchmark results from the community. + + - Disabled x86-64 inline assembly on x32 to fix the build. + + * Sandboxing support in xz: + + - Landlock is now used even when xz needs to create files. + In this case the sandbox has to be more permissive than + when no files need to be created. A similar thing was + already in use with pledge(2) since 5.3.4alpha. + + - Landlock and pledge(2) are now stricter when reading from + more than one input file and only writing to standard output. + + - Added support for Landlock ABI version 4. + + * CMake: + + - Default to -O2 instead of -O3 with CMAKE_BUILD_TYPE=Release. + -O3 is not useful for speed and makes the code larger. + + - Now builds lzmainfo and lzmadec. + + - xzdiff, xzgrep, xzless, xzmore, and their symlinks are now + installed. The scripts are also tested during "make test". + + - Added translation support for xz, lzmainfo, and the + man pages. + + - Applied the symbol versioning workaround for MicroBlaze that + is used in the Autotools build. + + - The general XZ Utils and liblzma API documentation is now + installed. + + - The CMake component names were changed a little and several + were added. liblzma_Runtime and liblzma_Development are + unchanged. + + - Minimum required CMake version is now 3.14. However, + translation support is disabled with CMake versions + older than 3.20. + + - The CMake-based build is now close to feature parity with the + Autotools-based build. Most importantly a few tests aren't + run yet. Testing the CMake-based build on different operating + systems would be welcome now. See the comment at the top of + CMakeLists.txt. + + * Fixed a bug in the Autotools feature test for ARM64 CRC32 + instruction support for old versions of Clang. This did not + affect the CMake build. + + * Windows: + + - The build instructions in INSTALL and windows/INSTALL*.txt + were revised completely. + + - windows/build-with-cmake.bat along with the instructions + in windows/INSTALL-MinGW-w64_with_CMake.txt should make + it very easy to build liblzma.dll and xz.exe on Windows + using CMake and MinGW-w64 with either GCC or Clang/LLVM. + + - windows/build.bash was updated. It now works on MSYS2 and + on GNU/Linux (cross-compiling) to create a .zip and .7z + package for 32-bit and 64-bit x86 using GCC + MinGW-w64. + + * The TODO file is no longer installed as part of the + documentation. The file is out of date and does not reflect + the actual tasks that will be completed in the future. + + * Translations: + + - Translated lzmainfo man pages are now installed. These + had been forgotten in earlier versions. + + - Updated Croatian, Esperanto, German, Hungarian, Korean, + Polish, Romanian, Spanish, Swedish, Vietnamese, and Ukrainian + translations. + + - Updated German, Korean, Romanian, and Ukrainian man page + translations. + + * Added a few tests. + + Summary of new features added in the 5.5.x development releases: + + * liblzma: + + - LZMA decoder: Speed optimizations to the C code and + added GCC & Clang compatible inline assembly for x86-64. + + - Added lzma_mt_block_size() to recommend a Block size for + multithreaded encoding. + + - Added CLMUL-based CRC32 on x86-64 and E2K with runtime + processor detection. Similar to CRC64, on 32-bit x86 it + isn't available unless --disable-assembler is used. + + - Optimized the CRC32 calculation on ARM64 platforms using the + CRC32 instructions. Runtime detection for the instruction is + used on GNU/Linux, FreeBSD, Windows, and macOS. If the + compiler flags indicate unconditional CRC32 instruction + support (+crc) then the generic version is not built. + + - Added definitions of mask values like + LZMA_INDEX_CHECK_MASK_CRC32 to . + + * xz: + + - Multithreaded mode is now the default. This improves + compression speed and creates .xz files that can be + decompressed in multithreaded mode. The downsides are + increased memory usage and slightly worse compression ratio. + + - Added a new command line option --filters to set the filter + chain using the liblzma filter string syntax. + + - Added new command line options --filters1 ... --filters9 to + set additional filter chains using the liblzma filter string + syntax. The --block-list option now allows specifying filter + chains that were set using these new options. + + - Ported the command line tools to Windows MSVC. + Visual Studio 2015 or later is required. + + * Added lz4 support to xzdiff/xzcmp and xzgrep. + + +5.5.2beta (2024-02-14) + + * Licensing change: The core components are now under the + BSD Zero Clause License (0BSD). In XZ Utils 5.4.6 and older + and 5.5.1alpha these components are in the public domain and + obviously remain so; the change affects the new releases only. + + 0BSD is an extremely permissive license which doesn't require + retaining or reproducing copyright or license notices when + distributing the code, thus in practice there is extremely + little difference to public domain. + + * liblzma + + - Significant speed optimizations to the LZMA decoder were + made. There are now three variants that can be chosen at + build time: + + * Basic C version: This is a few percent faster than + 5.4.x due to some new optimizations. + + * Branchless C: This is currently the default on platforms + for which there is no assembly code. This should be a few + percent faster than the basic C version. + + * x86-64 inline assembly. This works with GCC and Clang. + + The default choice can currently be overridden by setting + LZMA_RANGE_DECODER_CONFIG in CPPFLAGS: 0 means the basic + version and 3 means that branchless C version. + + - Optimized the CRC32 calculation on ARM64 platforms using the + CRC32 instructions. The instructions are optional in ARMv8.0 + and are required in ARMv8.1 and later. Runtime detection for + the instruction is used on GNU/Linux, FreeBSD, Windows, and + macOS. If the compiler flags indicate unconditional CRC32 + instruction support (+crc) then the generic version is not + built. + + * Added lz4 support to xzdiff/xzcmp and xzgrep. + + * Man pages of xzdiff/xzcmp, xzgrep, and xzmore were rewritten + to simplify licensing of the man page translations. + + * Translations: + + - Updated Chinese (simplified), German, Korean, Polish, + Romanian, Spanish, Swedish, and Ukrainian translations. + + - Updated German, Korean, Romanian, and Ukrainian man page + translations. + + * Small improvements to the tests. + + * Added doc/examples/11_file_info.c. It was added to the Git + repository in 2017 but forgotten to be added into distribution + tarballs. + + * Removed doc/examples_old. These were from 2012. + + * Removed the macos/build.sh script. It had not been updated + since 2013. + + +5.5.1alpha (2024-01-26) + + * Added a new filter for RISC-V binaries. The filter can be used + for 32-bit and 64-bit binaries with either little or big + endianness. In liblzma, the Filter ID is LZMA_FILTER_RISCV (0x0B) + and the xz option is --riscv. liblzma filter string syntax + recognizes this filter as "riscv". + + * liblzma: + + - Added lzma_mt_block_size() to recommend a Block size for + multithreaded encoding + + - Added CLMUL-based CRC32 on x86-64 and E2K with runtime + processor detection. Similar to CRC64, on 32-bit x86 it + isn't available unless --disable-assembler is used. + + - Implemented GNU indirect function (IFUNC) as a runtime + function dispatching method for CRC32 and CRC64 fast + implementations on x86. Only GNU/Linux (glibc) and FreeBSD + builds will use IFUNC, unless --enable-ifunc is specified to + configure. + + - Added definitions of mask values like + LZMA_INDEX_CHECK_MASK_CRC32 to . + + - The XZ logo is now included in the Doxygen generated + documentation. It is licensed under Creative Commons + Attribution-ShareAlike 4.0. + + * xz: + + - Multithreaded mode is now the default. This improves + compression speed and creates .xz files that can be + decompressed multithreaded at the cost of increased memory + usage and slightly worse compression ratio. + + - Added new command line option --filters to set the filter + chain using liblzma filter string syntax. + + - Added new command line options --filters1 ... --filters9 to + set additional filter chains using liblzma filter string + syntax. The --block-list option now allows specifying filter + chains that were set using these new options. + + - Added support for Linux Landlock as a sandboxing method. + + - xzdec now supports pledge(2), Capsicum, and Linux Landlock as + sandboxing methods. + + - Progress indicator time stats remain accurate after pausing + xz with SIGTSTP. + + - Ported xz and xzdec to Windows MSVC. Visual Studio 2015 or + later is required. + + * CMake Build: + + - Supports pledge(2), Capsicum, and Linux Landlock sandboxing + methods. + + - Replacement functions for getopt_long() are used on platforms + that do not have it. + + * Enabled unaligned access by default on PowerPC64LE and on RISC-V + targets that define __riscv_misaligned_fast. + + * Tests: + + - Added two new fuzz targets to OSS-Fuzz. + + - Implemented Continuous Integration (CI) testing using + GitHub Actions. + + * Changed quoting style from `...' to '...' in all messages, + scripts, and documentation. + + * Added basic Codespell support to help catch typo errors. + + +5.4.7 (2024-05-29) + + * Not changed: Memory sanitizer (MSAN) has a false positive + in the CRC CLMUL code which also makes OSS Fuzz unhappy. + Valgrind is smarter and doesn't complain. + + A revision to the CLMUL code is coming anyway and this issue + will be cleaned up as part of it. It won't be backported to + 5.6.x or 5.4.x because the old code isn't wrong. There is + no reason to risk introducing regressions in old branches + just to silence a false positive. + + * liblzma: + + - lzma_index_decoder() and lzma_index_buffer_decode(): Fix + a missing output pointer initialization (*i = NULL) if the + functions are called with invalid arguments. The API docs + say that such an initialization is always done. In practice + this matters very little because the problem can only occur + if the calling application has a bug and these functions + return LZMA_PROG_ERROR. + + - lzma_str_to_filters(): Fix a missing output pointer + initialization (*error_pos = 0). This is very similar + to the fix above. + + - Fix C standard conformance with function pointer types. + This newly showed up with Clang 17 with -fsanitize=undefined. + There are no bug reports about this. + + - Fix building with NVIDIA HPC SDK. + + * xz: + + - Fix a C standard conformance issue in --block-list parsing + (arithmetic on a null pointer). + + - Fix a warning from GNU groff when processing the man page: + "warning: cannot select font 'CW'" + + - Fix outdated threading related information on the man page. + + * xzless: + + - With "less" version 451 and later, use "||-" instead of "|-" + in the environment variable LESSOPEN. This way compressed + files that contain no uncompressed data are shown correctly + as empty. + + - With "less" version 632 and later, use --show-preproc-errors + to make "less" show a warning on decompression errors. + + * Autotools-based build system (configure): + + - Symbol versioning variant can now be overridden with + --enable-symbol-versions. Documentation in INSTALL was + updated to match. + + CMake: + + - Linux on MicroBlaze is handled specially now. This matches + the changes made to the Autotools-based build in XZ Utils + 5.4.2 and 5.2.11. + + - Disable symbol versioning on non-glibc Linux to match what + the Autotools build does. For example, symbol versioning + isn't enabled with musl. + + - Symbol versioning variant can now be overridden by setting + SYMBOL_VERSIONING to "OFF", "generic", or "linux". + + * Documentation: + + - Clarify the description of --disable-assembler in INSTALL. + The option only affects 32-bit x86 assembly usage. + + - Add doc/examples/11_file_info.c. It was added to the + Git repository in 2017 but forgotten to be added into + distribution tarballs. + + - Don't install the TODO file as part of the documentation. + The file is out of date. + + - Update home page URLs back to their old locations on + tukaani.org. + + - Update maintainer info. + + +5.4.6 (2024-01-26) + + * Fixed a bug involving internal function pointers in liblzma not + being initialized to NULL. The bug can only be triggered if + lzma_filters_update() is called on a LZMA1 encoder, so it does + not affect xz or any application known to us that uses liblzma. + + * xz: + + - Fixed a regression introduced in 5.4.2 that caused encoding + in the raw format to unnecessarily fail if --suffix was not + used. For instance, the following command no longer reports + that --suffix must be used: + + echo foo | xz --format=raw --lzma2 | wc -c + + - Fixed an issue on MinGW-w64 builds that prevented reading + from or writing to non-terminal character devices like NUL. + + * Added a new test. + + +5.4.5 (2023-11-01) + + * liblzma: + + - Use __attribute__((__no_sanitize_address__)) to avoid address + sanitization with CRC64 CLMUL. It uses 16-byte-aligned reads + which can extend past the bounds of the input buffer and + inherently trigger address sanitization errors. This isn't + a bug. + + - Fixed an assertion failure that could be triggered by a large + unpadded_size argument. It was verified that there was no + other bug than the assertion failure. + + - Fixed a bug that prevented building with Windows Vista + threading when __attribute__((__constructor__)) is not + supported. + + * xz now properly handles special files such as "con" or "nul" on + Windows. Before this fix, the following wrote "foo" to the + console and deleted the input file "con_xz": + + echo foo | xz > con_xz + xz --suffix=_xz --decompress con_xz + + * Build systems: + + - Allow builds with Windows win95 threading and small mode when + __attribute__((__constructor__)) is supported. + + - Added a new line to liblzma.pc for MSYS2 (Windows): + + Cflags.private: -DLZMA_API_STATIC + + When compiling code that will link against static liblzma, + the LZMA_API_STATIC macro needs to be defined on Windows. + + - CMake specific changes: + + * Fixed a bug that allowed CLOCK_MONOTONIC to be used even + if the check for it failed. + + * Fixed a bug where configuring CMake multiple times + resulted in HAVE_CLOCK_GETTIME and HAVE_CLOCK_MONOTONIC + not being set. + + * Fixed the build with MinGW-w64-based Clang/LLVM 17. + llvm-windres now has more accurate GNU windres emulation + so the GNU windres workaround from 5.4.1 is needed with + llvm-windres version 17 too. + + * The import library on Windows is now properly named + "liblzma.dll.a" instead of "libliblzma.dll.a" + + * Fixed a bug causing the Ninja Generator to fail on + UNIX-like systems. This bug was introduced in 5.4.0. + + * Added a new option to disable CLMUL CRC64. + + * A module-definition (.def) file is now created when + building liblzma.dll with MinGW-w64. + + * The pkg-config liblzma.pc file is now installed on all + builds except when using MSVC on Windows. + + * Added large file support by default for platforms that + need it to handle files larger than 2 GiB. This includes + MinGW-w64, even 64-bit builds. + + * Small fixes and improvements to the tests. + + * Updated translations: Chinese (simplified) and Esperanto. + + +5.4.4 (2023-08-02) + + * liblzma and xzdec can now build against WASI SDK when threading + support is disabled. xz and tests don't build yet. + + * CMake: + + - Fixed a bug preventing other projects from including liblzma + multiple times using find_package(). + + - Don't create broken symlinks in Cygwin and MSYS2 unless + supported by the environment. This prevented building for the + default MSYS2 environment. The problem was introduced in + xz 5.4.0. + + * Documentation: + + - Small improvements to man pages. + + - Small improvements and typo fixes for liblzma API + documentation. + + * Tests: + + - Added a new section to INSTALL to describe basic test usage + and address recent questions about building the tests when + cross compiling. + + - Small fixes and improvements to the tests. + + * Translations: + + - Fixed a mistake that caused one of the error messages to not + be translated. This only affected versions 5.4.2 and 5.4.3. + + - Updated the Chinese (simplified), Croatian, Esperanto, German, + Korean, Polish, Romanian, Spanish, Swedish, Ukrainian, and + Vietnamese translations. + + - Updated the German, Korean, Romanian, and Ukrainian man page + translations. + + +5.4.3 (2023-05-04) + + * All fixes from 5.2.12 + + * Features in the CMake build can now be disabled as CMake cache + variables, similar to the Autotools build. + + * Minor update to the Croatian translation. + + +5.4.2 (2023-03-18) + + * All fixes from 5.2.11 that were not included in 5.4.1. + + * If xz is built with support for the Capsicum sandbox but running + in an environment that doesn't support Capsicum, xz now runs + normally without sandboxing instead of exiting with an error. + + * liblzma: + + - Documentation was updated to improve the style, consistency, + and completeness of the liblzma API headers. + + - The Doxygen-generated HTML documentation for the liblzma API + header files is now included in the source release and is + installed as part of "make install". All JavaScript is + removed to simplify license compliance and to reduce the + install size. + + - Fixed a minor bug in lzma_str_from_filters() that produced + too many filters in the output string instead of reporting + an error if the input array had more than four filters. This + bug did not affect xz. + + * Build systems: + + - autogen.sh now invokes the doxygen tool via the new wrapper + script doxygen/update-doxygen, unless the command line option + --no-doxygen is used. + + - Added microlzma_encoder.c and microlzma_decoder.c to the + VS project files for Windows and to the CMake build. These + should have been included in 5.3.2alpha. + + * Tests: + + - Added a test to the CMake build that was forgotten in the + previous release. + + - Added and refactored a few tests. + + * Translations: + + - Updated the Brazilian Portuguese translation. + + - Added Brazilian Portuguese man page translation. + + +5.4.1 (2023-01-11) + + * liblzma: + + - Fixed the return value of lzma_microlzma_encoder() if the + LZMA options lc/lp/pb are invalid. Invalid lc/lp/pb options + made the function return LZMA_STREAM_END without encoding + anything instead of returning LZMA_OPTIONS_ERROR. + + - Windows / Visual Studio: Workaround a possible compiler bug + when targeting 32-bit x86 and compiling the CLMUL version of + the CRC64 code. The CLMUL code isn't enabled by the Windows + project files but it is in the CMake-based builds. + + * Build systems: + + - Windows-specific CMake changes: + + * Don't try to enable CLMUL CRC64 code if _mm_set_epi64x() + isn't available. This fixes CMake-based build with Visual + Studio 2013. + + * Created a workaround for a build failure with windres + from GNU binutils. It is used only when the C compiler + is GCC (not Clang). The workaround is incompatible + with llvm-windres, resulting in "XZx20Utils" instead + of "XZ Utils" in the resource file, but without the + workaround llvm-windres works correctly. See the + comment in CMakeLists.txt for details. + + * Included the resource files in the xz and xzdec build + rules. Building the command line tools is still + experimental but possible with MinGW-w64. + + - Visual Studio: Added stream_decoder_mt.c to the project + files. Now the threaded decompressor lzma_stream_decoder_mt() + gets built. CMake-based build wasn't affected. + + - Updated windows/INSTALL-MSVC.txt to mention that CMake-based + build is now the preferred method with Visual Studio. The + project files will probably be removed after 5.4.x releases. + + - Changes to #defines in config.h: + + * HAVE_DECL_CLOCK_MONOTONIC was replaced by + HAVE_CLOCK_MONOTONIC. The old macro was always defined + in configure-generated config.h to either 0 or 1. The + new macro is defined (to 1) only if the declaration of + CLOCK_MONOTONIC is available. This matches the way most + other config.h macros work and makes things simpler with + other build systems. + + * HAVE_DECL_PROGRAM_INVOCATION_NAME was replaced by + HAVE_PROGRAM_INVOCATION_NAME for the same reason. + + * Tests: + + - Fixed test script compatibility with ancient /bin/sh + versions. Now the five test_compress_* tests should + no longer fail on Solaris 10. + + - Added and refactored a few tests. + + * Translations: + + - Updated the Catalan and Esperanto translations. + + - Added Korean and Ukrainian man page translations. + + +5.4.0 (2022-12-13) + + This bumps the minor version of liblzma because new features were + added. The API and ABI are still backward compatible with liblzma + 5.2.x and 5.0.x. + + Since 5.3.5beta: + + * All fixes from 5.2.10. + + * The ARM64 filter is now stable. The xz option is now --arm64. + Decompression requires XZ Utils 5.4.0. In the future the ARM64 + filter will be supported by XZ for Java, XZ Embedded (including + the version in Linux), LZMA SDK, and 7-Zip. + + * Translations: + + - Updated Catalan, Croatian, German, Romanian, and Turkish + translations. + + - Updated German man page translations. + + - Added Romanian man page translations. + + Summary of new features added in the 5.3.x development releases: + + * liblzma: + + - Added threaded .xz decompressor lzma_stream_decoder_mt(). + It can use multiple threads with .xz files that have multiple + Blocks with size information in Block Headers. The threaded + encoder in xz has always created such files. + + Single-threaded encoder cannot store the size information in + Block Headers even if one used LZMA_FULL_FLUSH to create + multiple Blocks, so this threaded decoder cannot use multiple + threads with such files. + + If there are multiple Streams (concatenated .xz files), one + Stream will be decompressed completely before starting the + next Stream. + + - A new decoder flag LZMA_FAIL_FAST was added. It makes the + threaded decompressor report errors soon instead of first + flushing all pending data before the error location. + + - New Filter IDs: + * LZMA_FILTER_ARM64 is for ARM64 binaries. + * LZMA_FILTER_LZMA1EXT is for raw LZMA1 streams that don't + necessarily use the end marker. + + - Added lzma_str_to_filters(), lzma_str_from_filters(), and + lzma_str_list_filters() to convert a preset or a filter chain + string to a lzma_filter[] and vice versa. These should make + it easier to write applications that allow users to specify + custom compression options. + + - Added lzma_filters_free() which can be convenient for freeing + the filter options in a filter chain (an array of lzma_filter + structures). + + - lzma_file_info_decoder() to makes it a little easier to get + the Index field from .xz files. This helps in getting the + uncompressed file size but an easy-to-use random access + API is still missing which has existed in XZ for Java for + a long time. + + - Added lzma_microlzma_encoder() and lzma_microlzma_decoder(). + It is used by erofs-utils and may be used by others too. + + The MicroLZMA format is a raw LZMA stream (without end marker) + whose first byte (always 0x00) has been replaced with + bitwise-negation of the LZMA properties (lc/lp/pb). It was + created for use in EROFS but may be used in other contexts + as well where it is important to avoid wasting bytes for + stream headers or footers. The format is also supported by + XZ Embedded (the XZ Embedded version in Linux got MicroLZMA + support in Linux 5.16). + + The MicroLZMA encoder API in liblzma can compress into a + fixed-sized output buffer so that as much data is compressed + as can be fit into the buffer while still creating a valid + MicroLZMA stream. This is needed for EROFS. + + - Added lzma_lzip_decoder() to decompress the .lz (lzip) file + format version 0 and the original unextended version 1 files. + Also lzma_auto_decoder() supports .lz files. + + - lzma_filters_update() can now be used with the multi-threaded + encoder (lzma_stream_encoder_mt()) to change the filter chain + after LZMA_FULL_BARRIER or LZMA_FULL_FLUSH. + + - In lzma_options_lzma, allow nice_len = 2 and 3 with the match + finders that require at least 3 or 4. Now it is internally + rounded up if needed. + + - CLMUL-based CRC64 on x86-64 and E2K with runtime processor + detection. On 32-bit x86 it currently isn't available unless + --disable-assembler is used which can make the non-CLMUL + CRC64 slower; this might be fixed in the future. + + - Building with --disable-threads --enable-small + is now thread-safe if the compiler supports + __attribute__((__constructor__)). + + * xz: + + - Using -T0 (--threads=0) will now use multi-threaded encoder + even on a single-core system. This is to ensure that output + from the same xz binary is identical on both single-core and + multi-core systems. + + - --threads=+1 or -T+1 is now a way to put xz into + multi-threaded mode while using only one worker thread. + The + is ignored if the number is not 1. + + - A default soft memory usage limit is now used for compression + when -T0 is used and no explicit limit has been specified. + This soft limit is used to restrict the number of threads + but if the limit is exceeded with even one thread then xz + will continue with one thread using the multi-threaded + encoder and this limit is ignored. If the number of threads + is specified manually then no default limit will be used; + this affects only -T0. + + This change helps on systems that have very many cores and + using all of them for xz makes no sense. Previously xz -T0 + could run out of memory on such systems because it attempted + to reserve memory for too many threads. + + This also helps with 32-bit builds which don't have a large + amount of address space that would be required for many + threads. The default soft limit for -T0 is at most 1400 MiB + on all 32-bit platforms. + + - Previously a low value in --memlimit-compress wouldn't cause + xz to switch from multi-threaded mode to single-threaded mode + if the limit cannot otherwise be met; xz failed instead. Now + xz can switch to single-threaded mode and then, if needed, + scale down the LZMA2 dictionary size too just like it already + did when it was started in single-threaded mode. + + - The option --no-adjust no longer prevents xz from scaling down + the number of threads as that doesn't affect the compressed + output (only performance). Now --no-adjust only prevents + adjustments that affect compressed output, that is, with + --no-adjust xz won't switch from multi-threaded mode to + single-threaded mode and won't scale down the LZMA2 + dictionary size. + + - Added a new option --memlimit-mt-decompress=LIMIT. This is + used to limit the number of decompressor threads (possibly + falling back to single-threaded mode) but it will never make + xz refuse to decompress a file. This has a system-specific + default value because without any limit xz could end up + allocating memory for the whole compressed input file, the + whole uncompressed output file, multiple thread-specific + decompressor instances and so on. Basically xz could + attempt to use an insane amount of memory even with fairly + common files. The system-specific default value is currently + the same as the one used for compression with -T0. + + The new option works together with the existing option + --memlimit-decompress=LIMIT. The old option sets a hard limit + that must not be exceeded (xz will refuse to decompress) + while the new option only restricts the number of threads. + If the limit set with --memlimit-mt-decompress is greater + than the limit set with --memlimit-compress, then the latter + value is used also for --memlimit-mt-decompress. + + - Added new information to the output of xz --info-memory and + new fields to the output of xz --robot --info-memory. + + - In --lzma2=nice=NUMBER allow 2 and 3 with all match finders + now that liblzma handles it. + + - Don't mention endianness for ARM and ARM-Thumb filters in + --long-help. The filters only work for little endian + instruction encoding but modern ARM processors using + big endian data access still use little endian + instruction encoding. So the help text was misleading. + In contrast, the PowerPC filter is only for big endian + 32/64-bit PowerPC code. Little endian PowerPC would need + a separate filter. + + - Added decompression support for the .lz (lzip) file format + version 0 and the original unextended version 1. It is + autodetected by default. See also the option --format on + the xz man page. + + - Sandboxing enabled by default: + * Capsicum (FreeBSD) + * pledge(2) (OpenBSD) + + * Scripts now support the .lz format using xz. + + * A few new tests were added. + + * The liblzma-specific tests are now supported in CMake-based + builds too ("make test"). + + +5.3.5beta (2022-12-01) + + * All fixes from 5.2.9. + + * liblzma: + + - Added new LZMA_FILTER_LZMA1EXT for raw encoder and decoder to + handle raw LZMA1 streams that don't have end of payload marker + (EOPM) alias end of stream (EOS) marker. It can be used in + filter chains, for example, with the x86 BCJ filter. + + - Added lzma_str_to_filters(), lzma_str_from_filters(), and + lzma_str_list_filters() to make it easier for applications + to get custom compression options from a user and convert + it to an array of lzma_filter structures. + + - Added lzma_filters_free(). + + - lzma_filters_update() can now be used with the multi-threaded + encoder (lzma_stream_encoder_mt()) to change the filter chain + after LZMA_FULL_BARRIER or LZMA_FULL_FLUSH. + + - In lzma_options_lzma, allow nice_len = 2 and 3 with the match + finders that require at least 3 or 4. Now it is internally + rounded up if needed. + + - ARM64 filter was modified. It is still experimental. + + - Fixed LTO build with Clang if -fgnuc-version=10 or similar + was used to make Clang look like GCC >= 10. Now it uses + __has_attribute(__symver__) which should be reliable. + + * xz: + + - --threads=+1 or -T+1 is now a way to put xz into multi-threaded + mode while using only one worker thread. + + - In --lzma2=nice=NUMBER allow 2 and 3 with all match finders + now that liblzma handles it. + + * Updated translations: Chinese (simplified), Korean, and Turkish. + + +5.3.4alpha (2022-11-15) + + * All fixes from 5.2.7 and 5.2.8. + + * liblzma: + + - Minor improvements to the threaded decoder. + + - Added CRC64 implementation that uses SSSE3, SSE4.1, and CLMUL + instructions on 32/64-bit x86 and E2K. On 32-bit x86 it's + not enabled unless --disable-assembler is used but then + the non-CLMUL code might be slower. Processor support is + detected at runtime so this is built by default on x86-64 + and E2K. On these platforms, if compiler flags indicate + unconditional CLMUL support (-msse4.1 -mpclmul) then the + generic version is not built, making liblzma 8-9 KiB smaller + compared to having both versions included. + + With extremely compressible files this can make decompression + up to twice as fast but with typical files 5 % improvement + is a more realistic expectation. + + The CLMUL version is slower than the generic version with + tiny inputs (especially at 1-8 bytes per call, but up to + 16 bytes). In normal use in xz this doesn't matter at all. + + - Added an experimental ARM64 filter. This is *not* the final + version! Files created with this experimental version won't + be supported in the future versions! The filter design is + a compromise where improving one use case makes some other + cases worse. + + - Added decompression support for the .lz (lzip) file format + version 0 and the original unextended version 1. See the + API docs of lzma_lzip_decoder() for details. Also + lzma_auto_decoder() supports .lz files. + + - Building with --disable-threads --enable-small + is now thread-safe if the compiler supports + __attribute__((__constructor__)) + + * xz: + + - Added support for OpenBSD's pledge(2) as a sandboxing method. + + - Don't mention endianness for ARM and ARM-Thumb filters in + --long-help. The filters only work for little endian + instruction encoding but modern ARM processors using + big endian data access still use little endian + instruction encoding. So the help text was misleading. + In contrast, the PowerPC filter is only for big endian + 32/64-bit PowerPC code. Little endian PowerPC would need + a separate filter. + + - Added --experimental-arm64. This will be renamed once the + filter is finished. Files created with this experimental + filter will not be supported in the future! + + - Added new fields to the output of xz --robot --info-memory. + + - Added decompression support for the .lz (lzip) file format + version 0 and the original unextended version 1. It is + autodetected by default. See also the option --format on + the xz man page. + + * Scripts now support the .lz format using xz. + + * Build systems: + + - New #defines in config.h: HAVE_ENCODER_ARM64, + HAVE_DECODER_ARM64, HAVE_LZIP_DECODER, HAVE_CPUID_H, + HAVE_FUNC_ATTRIBUTE_CONSTRUCTOR, HAVE_USABLE_CLMUL + + - New configure options: --disable-clmul-crc, + --disable-microlzma, --disable-lzip-decoder, and + 'pledge' is now an option in --enable-sandbox (but + it's autodetected by default anyway). + + - INSTALL was updated to document the new configure options. + + - PACKAGERS now lists also --disable-microlzma and + --disable-lzip-decoder as configure options that must + not be used in builds for non-embedded use. + + * Tests: + + - Fix some of the tests so that they skip instead of fail if + certain features have been disabled with configure options. + It's still not perfect. + + - Other improvements to tests. + + * Updated translations: Croatian, Finnish, Hungarian, Polish, + Romanian, Spanish, Swedish, and Ukrainian. + + +5.3.3alpha (2022-08-22) + + * All fixes from 5.2.6. + + * liblzma: + + - Fixed 32-bit build. + + - Added threaded .xz decompressor lzma_stream_decoder_mt(). + It can use multiple threads with .xz files that have multiple + Blocks with size information in Block Headers. The threaded + encoder in xz has always created such files. + + Single-threaded encoder cannot store the size information in + Block Headers even if one used LZMA_FULL_FLUSH to create + multiple Blocks, so this threaded decoder cannot use multiple + threads with such files. + + If there are multiple Streams (concatenated .xz files), one + Stream will be decompressed completely before starting the + next Stream. + + - A new decoder flag LZMA_FAIL_FAST was added. It makes the + threaded decompressor report errors soon instead of first + flushing all pending data before the error location. + + * xz: + + - Using -T0 (--threads=0) will now use multi-threaded encoder + even on a single-core system. This is to ensure that output + from the same xz binary is identical on both single-core and + multi-core systems. + + - A default soft memory usage limit is now used for compression + when -T0 is used and no explicit limit has been specified. + This soft limit is used to restrict the number of threads + but if the limit is exceeded with even one thread then xz + will continue with one thread using the multi-threaded + encoder and this limit is ignored. If the number of threads + is specified manually then no default limit will be used; + this affects only -T0. + + This change helps on systems that have very many cores and + using all of them for xz makes no sense. Previously xz -T0 + could run out of memory on such systems because it attempted + to reserve memory for too many threads. + + This also helps with 32-bit builds which don't have a large + amount of address space that would be required for many + threads. The default limit is 1400 MiB on all 32-bit + platforms with -T0. + + Now xz -T0 should just work. It might use too few threads + in some cases but at least it shouldn't easily run out of + memory. It's possible that this will be tweaked before 5.4.0. + + - Changes to --memlimit-compress and --no-adjust: + + In single-threaded mode, --memlimit-compress can make xz + scale down the LZMA2 dictionary size to meet the memory usage + limit. This obviously affects the compressed output. However, + if xz was in threaded mode, --memlimit-compress could make xz + reduce the number of threads but it wouldn't make xz switch + from multi-threaded mode to single-threaded mode or scale + down the LZMA2 dictionary size. This seemed illogical. + + Now --memlimit-compress can make xz switch to single-threaded + mode if one thread in multi-threaded mode uses too much + memory. If memory usage is still too high, then the LZMA2 + dictionary size can be scaled down too. + + The option --no-adjust was also changed so that it no longer + prevents xz from scaling down the number of threads as that + doesn't affect compressed output (only performance). After + this commit --no-adjust only prevents adjustments that affect + compressed output, that is, with --no-adjust xz won't switch + from multithreaded mode to single-threaded mode and won't + scale down the LZMA2 dictionary size. + + - Added a new option --memlimit-mt-decompress=LIMIT. This is + used to limit the number of decompressor threads (possibly + falling back to single-threaded mode) but it will never make + xz refuse to decompress a file. This has a system-specific + default value because without any limit xz could end up + allocating memory for the whole compressed input file, the + whole uncompressed output file, multiple thread-specific + decompressor instances and so on. Basically xz could + attempt to use an insane amount of memory even with fairly + common files. + + The new option works together with the existing option + --memlimit-decompress=LIMIT. The old option sets a hard limit + that must not be exceeded (xz will refuse to decompress) + while the new option only restricts the number of threads. + If the limit set with --memlimit-mt-decompress is greater + than the limit set with --memlimit-compress, then the latter + value is used also for --memlimit-mt-decompress. + + * Tests: + + - Added a few more tests. + + - Added tests/code_coverage.sh to create a code coverage report + of the tests. + + * Build systems: + + - Automake's parallel test harness is now used to make tests + finish faster. + + - Added the CMake files to the distribution tarball. These were + supposed to be in 5.2.5 already. + + - Added liblzma tests to the CMake build. + + - Windows: Fix building of liblzma.dll with the included + Visual Studio project files. + + +5.3.2alpha (2021-10-28) + + This release was made on short notice so that recent erofs-utils can + be built with LZMA support without needing a snapshot from xz.git. + Thus many pending things were not included, not even updated + translations (which would need to be updated for the new --list + strings anyway). + + * All fixes from 5.2.5. + + * xz: + + - When copying metadata from the source file to the destination + file, don't try to set the group (GID) if it is already set + correctly. This avoids a failure on OpenBSD (and possibly on + a few other OSes) where files may get created so that their + group doesn't belong to the user, and fchown(2) can fail even + if it needs to do nothing. + + - The --keep option now accepts symlinks, hardlinks, and + setuid, setgid, and sticky files. Previously this required + using --force. + + - Split the long strings used in --list and --info-memory modes + to make them much easier for translators. + + - If built with sandbox support and enabling the sandbox fails, + xz will now immediately exit with exit status of 1. Previously + it would only display a warning if -vv was used. + + - Cap --memlimit-compress to 2000 MiB on MIPS32 because on + MIPS32 userspace processes are limited to 2 GiB of address + space. + + * liblzma: + + - Added lzma_microlzma_encoder() and lzma_microlzma_decoder(). + The API is in lzma/container.h. + + The MicroLZMA format is a raw LZMA stream (without end marker) + whose first byte (always 0x00) has been replaced with + bitwise-negation of the LZMA properties (lc/lp/pb). It was + created for use in EROFS but may be used in other contexts + as well where it is important to avoid wasting bytes for + stream headers or footers. The format is also supported by + XZ Embedded. + + The MicroLZMA encoder API in liblzma can compress into a + fixed-sized output buffer so that as much data is compressed + as can be fit into the buffer while still creating a valid + MicroLZMA stream. This is needed for EROFS. + + - Added fuzzing support. + + - Support Intel Control-flow Enforcement Technology (CET) in + 32-bit x86 assembly files. + + - Visual Studio: Use non-standard _MSVC_LANG to detect C++ + standard version in the lzma.h API header. It's used to + detect when "noexcept" can be used. + + * Scripts: + + - Fix exit status of xzdiff/xzcmp. Exit status could be 2 when + the correct value is 1. + + - Fix exit status of xzgrep. + + - Detect corrupt .bz2 files in xzgrep. + + - Add zstd support to xzgrep and xzdiff/xzcmp. + + - Fix less(1) version detection in xzless. It failed if the + version number from "less -V" contained a dot. + + * Fix typos and technical issues in man pages. + + * Build systems: + + - Windows: Fix building of resource files when config.h isn't + used. CMake + Visual Studio can now build liblzma.dll. + + - Various fixes to the CMake support. It might still need a few + more fixes even for liblzma-only builds. + + +5.3.1alpha (2018-04-29) + + * All fixes from 5.2.4. + + * Add lzma_file_info_decoder() into liblzma and use it in xz to + implement the --list feature. + + * Capsicum sandbox support is enabled by default where available + (FreeBSD >= 10). + + +5.2.13 (2024-05-29) + + * liblzma: + + - lzma_index_append(): Fix an assertion failure that could be + triggered by a large unpadded_size argument. It was verified + that there was no other bug than the assertion failure. + + - lzma_index_decoder() and lzma_index_buffer_decode(): Fix + a missing output pointer initialization (*i = NULL) if the + functions are called with invalid arguments. The API docs + say that such an initialization is always done. In practice + this matters very little because the problem can only occur + if the calling application has a bug and these functions + return LZMA_PROG_ERROR. + + - Fix C standard conformance with function pointer types. + This newly showed up with Clang 17 with -fsanitize=undefined. + There are no bug reports about this. + + - Fix building with NVIDIA HPC SDK. + + - Fix building with Windows Vista threads and --enable-small. + (CMake build doesn't support ENABLE_SMALL in XZ Utils 5.2.x.) + + * xz: + + - Fix a C standard conformance issue in --block-list parsing + (arithmetic on a null pointer). + + - Fix a warning from GNU groff when processing the man page: + "warning: cannot select font 'CW'" + + - Windows: Handle special files such as "con" or "nul". Earlier + the following wrote "foo" to the console and deleted the input + file "con_xz": + + echo foo | xz > con_xz + xz --suffix=_xz --decompress con_xz + + - Windows: Fix an issue that prevented reading from or writing + to non-terminal character devices like NUL. + + * xzless: + + - With "less" version 451 and later, use "||-" instead of "|-" + in the environment variable LESSOPEN. This way compressed + files that contain no uncompressed data are shown correctly + as empty. + + - With "less" version 632 and later, use --show-preproc-errors + to make "less" show a warning on decompression errors. + + * Build systems: + + - Add a new line to liblzma.pc for MSYS2 (Windows): + + Cflags.private: -DLZMA_API_STATIC + + When compiling code that will link against static liblzma, + the LZMA_API_STATIC macro needs to be defined on Windows. + + - Autotools (configure): + + * Symbol versioning variant can now be overridden with + --enable-symbol-versions. Documentation in INSTALL was + updated to match. + + - CMake: + + * Fix a bug that prevented other projects from including + liblzma multiple times using find_package(). + + * Fix a bug where configuring CMake multiple times resulted + in HAVE_CLOCK_GETTIME and HAVE_CLOCK_MONOTONIC not being + defined. + + * Fix the build with MinGW-w64-based Clang/LLVM 17. + llvm-windres now has more accurate GNU windres emulation + so the GNU windres workaround from 5.4.1 is needed with + llvm-windres version 17 too. + + * The import library on Windows is now properly named + "liblzma.dll.a" instead of "libliblzma.dll.a" + + * Add large file support by default for platforms that + need it to handle files larger than 2 GiB. This includes + MinGW-w64, even 64-bit builds. + + * Linux on MicroBlaze is handled specially now. This + matches the changes made to the Autotools-based build + in XZ Utils 5.4.2 and 5.2.11. + + * Disable symbol versioning on non-glibc Linux to match + what the Autotools build does. For example, symbol + versioning isn't enabled with musl. + + * Symbol versioning variant can now be overridden by + setting SYMBOL_VERSIONING to "OFF", "generic", or + "linux". + + * Documentation: + + - Clarify the description of --disable-assembler in INSTALL. + The option only affects 32-bit x86 assembly usage. + + - Don't install the TODO file as part of the documentation. + The file is out of date. + + - Update home page URLs back to their old locations on + tukaani.org. + + - Update maintainer info. + + +5.2.12 (2023-05-04) + + * Fixed a build system bug that prevented building liblzma as a + shared library when configured with --disable-threads. This bug + affected releases 5.2.6 to 5.2.11 and 5.4.0 to 5.4.2. + + * Include for Windows intrinsic functions where they are + needed. This fixed a bug that prevented building liblzma using + clang-cl on Windows. + + * Minor update to the Croatian translation. The small change + applies to a string in both 5.2 and 5.4 branches. + + +5.2.11 (2023-03-18) + + * Removed all possible cases of null pointer + 0. It is undefined + behavior in C99 and C17. This was detected by a sanitizer and had + not caused any known issues. + + * Build systems: + + - Added a workaround for building with GCC on MicroBlaze Linux. + GCC 12 on MicroBlaze doesn't support the __symver__ attribute + even though __has_attribute(__symver__) returns true. The + build is now done without the extra RHEL/CentOS 7 symbols + that were added in XZ Utils 5.2.7. The workaround only + applies to the Autotools build (not CMake). + + - CMake: Ensure that the C compiler language is set to C99 or + a newer standard. + + - CMake changes from XZ Utils 5.4.1: + + * Added a workaround for a build failure with + windres from GNU binutils. + + * Included the Windows resource files in the xz + and xzdec build rules. + + +5.2.10 (2022-12-13) + + * xz: Don't modify argv[] when parsing the --memlimit* and + --block-list command line options. This fixes confusing + arguments in process listing (like "ps auxf"). + + * GNU/Linux only: Use __has_attribute(__symver__) to detect if + that attribute is supported. This fixes build on Mandriva where + Clang is patched to define __GNUC__ to 11 by default (instead + of 4 as used by Clang upstream). + + +5.2.9 (2022-11-30) + + * liblzma: + + - Fixed an infinite loop in LZMA encoder initialization + if dict_size >= 2 GiB. (The encoder only supports up + to 1536 MiB.) + + - Fixed two cases of invalid free() that can happen if + a tiny allocation fails in encoder re-initialization + or in lzma_filters_update(). These bugs had some + similarities with the bug fixed in 5.2.7. + + - Fixed lzma_block_encoder() not allowing the use of + LZMA_SYNC_FLUSH with lzma_code() even though it was + documented to be supported. The sync-flush code in + the Block encoder was already used internally via + lzma_stream_encoder(), so this was just a missing flag + in the lzma_block_encoder() API function. + + - GNU/Linux only: Don't put symbol versions into static + liblzma as it breaks things in some cases (and even if + it didn't break anything, symbol versions in static + libraries are useless anyway). The downside of the fix + is that if the configure options --with-pic or --without-pic + are used then it's not possible to build both shared and + static liblzma at the same time on GNU/Linux anymore; + with those options --disable-static or --disable-shared + must be used too. + + * New email address for bug reports is which + forwards messages to Lasse Collin and Jia Tan. + + +5.2.8 (2022-11-13) + + * xz: + + - If xz cannot remove an input file when it should, this + is now treated as a warning (exit status 2) instead of + an error (exit status 1). This matches GNU gzip and it + is more logical as at that point the output file has + already been successfully closed. + + - Fix handling of .xz files with an unsupported check type. + Previously such printed a warning message but then xz + behaved as if an error had occurred (didn't decompress, + exit status 1). Now a warning is printed, decompression + is done anyway, and exit status is 2. This used to work + slightly before 5.0.0. In practice this bug matters only + if xz has been built with some check types disabled. As + instructed in PACKAGERS, such builds should be done in + special situations only. + + - Fix "xz -dc --single-stream tests/files/good-0-empty.xz" + which failed with "Internal error (bug)". That is, + --single-stream was broken if the first .xz stream in + the input file didn't contain any uncompressed data. + + - Fix displaying file sizes in the progress indicator when + working in passthru mode and there are multiple input files. + Just like "gzip -cdf", "xz -cdf" works like "cat" when the + input file isn't a supported compressed file format. In + this case the file size counters weren't reset between + files so with multiple input files the progress indicator + displayed an incorrect (too large) value. + + * liblzma: + + - API docs in lzma/container.h: + * Update the list of decoder flags in the decoder + function docs. + * Explain LZMA_CONCATENATED behavior with .lzma files + in lzma_auto_decoder() docs. + + - OpenBSD: Use HW_NCPUONLINE to detect the number of + available hardware threads in lzma_physmem(). + + - Fix use of wrong macro to detect x86 SSE2 support. + __SSE2_MATH__ was used with GCC/Clang but the correct + one is __SSE2__. The first one means that SSE2 is used + for floating point math which is irrelevant here. + The affected SSE2 code isn't used on x86-64 so this affects + only 32-bit x86 builds that use -msse2 without -mfpmath=sse + (there is no runtime detection for SSE2). It improves LZMA + compression speed (not decompression). + + - Fix the build with Intel C compiler 2021 (ICC, not ICX) + on Linux. It defines __GNUC__ to 10 but doesn't support + the __symver__ attribute introduced in GCC 10. + + * Scripts: Ignore warnings from xz by using --quiet --no-warn. + This is needed if the input .xz files use an unsupported + check type. + + * Translations: + + - Updated Croatian and Turkish translations. + + - One new translations wasn't included because it needed + technical fixes. It will be in upcoming 5.4.0. No new + translations will be added to the 5.2.x branch anymore. + + - Renamed the French man page translation file from + fr_FR.po to fr.po and thus also its install directory + (like /usr/share/man/fr_FR -> .../fr). + + - Man page translations for upcoming 5.4.0 are now handled + in the Translation Project. + + * Update doc/faq.txt a little so it's less out-of-date. + + +5.2.7 (2022-09-30) + + * liblzma: + + - Made lzma_filters_copy() to never modify the destination + array if an error occurs. lzma_stream_encoder() and + lzma_stream_encoder_mt() already assumed this. Before this + change, if a tiny memory allocation in lzma_filters_copy() + failed it would lead to a crash (invalid free() or invalid + memory reads) in the cleanup paths of these two encoder + initialization functions. + + - Added missing integer overflow check to lzma_index_append(). + This affects xz --list and other applications that decode + the Index field from .xz files using lzma_index_decoder(). + Normal decompression of .xz files doesn't call this code + and thus most applications using liblzma aren't affected + by this bug. + + - Single-threaded .xz decoder (lzma_stream_decoder()): If + lzma_code() returns LZMA_MEMLIMIT_ERROR it is now possible + to use lzma_memlimit_set() to increase the limit and continue + decoding. This was supposed to work from the beginning + but there was a bug. With other decoders (.lzma or + threaded .xz decoder) this already worked correctly. + + - Fixed accumulation of integrity check type statistics in + lzma_index_cat(). This bug made lzma_index_checks() return + only the type of the integrity check of the last Stream + when multiple lzma_indexes were concatenated. Most + applications don't use these APIs but in xz it made + xz --list not list all check types from concatenated .xz + files. In xz --list --verbose only the per-file "Check:" + lines were affected and in xz --robot --list only the "file" + line was affected. + + - Added ABI compatibility with executables that were linked + against liblzma in RHEL/CentOS 7 or other liblzma builds + that had copied the problematic patch from RHEL/CentOS 7 + (xz-5.2.2-compat-libs.patch). For the details, see the + comment at the top of src/liblzma/validate_map.sh. + + WARNING: This uses __symver__ attribute with GCC >= 10. + In other cases the traditional __asm__(".symver ...") + is used. Using link-time optimization (LTO, -flto) with + GCC versions older than 10 can silently result in + broken liblzma.so.5 (incorrect symbol versions)! If you + want to use -flto with GCC, you must use GCC >= 10. + LTO with Clang seems to work even with the traditional + __asm__(".symver ...") method. + + * xzgrep: Fixed compatibility with old shells that break if + comments inside command substitutions have apostrophes ('). + This problem was introduced in 5.2.6. + + * Build systems: + + - New #define in config.h: HAVE_SYMBOL_VERSIONS_LINUX + + - Windows: Fixed liblzma.dll build with Visual Studio project + files. It broke in 5.2.6 due to a change that was made to + improve CMake support. + + - Windows: Building liblzma with UNICODE defined should now + work. + + - CMake files are now actually included in the release tarball. + They should have been in 5.2.5 already. + + - Minor CMake fixes and improvements. + + * Added a new translation: Turkish + + +5.2.6 (2022-08-12) + + * xz: + + - The --keep option now accepts symlinks, hardlinks, and + setuid, setgid, and sticky files. Previously this required + using --force. + + - When copying metadata from the source file to the destination + file, don't try to set the group (GID) if it is already set + correctly. This avoids a failure on OpenBSD (and possibly on + a few other OSes) where files may get created so that their + group doesn't belong to the user, and fchown(2) can fail even + if it needs to do nothing. + + - Cap --memlimit-compress to 2000 MiB instead of 4020 MiB on + MIPS32 because on MIPS32 userspace processes are limited + to 2 GiB of address space. + + * liblzma: + + - Fixed a missing error-check in the threaded encoder. If a + small memory allocation fails, a .xz file with an invalid + Index field would be created. Decompressing such a file would + produce the correct output but result in an error at the end. + Thus this is a "mild" data corruption bug. Note that while + a failed memory allocation can trigger the bug, it cannot + cause invalid memory access. + + - The decoder for .lzma files now supports files that have + uncompressed size stored in the header and still use the + end of payload marker (end of stream marker) at the end + of the LZMA stream. Such files are rare but, according to + the documentation in LZMA SDK, they are valid. + doc/lzma-file-format.txt was updated too. + + - Improved 32-bit x86 assembly files: + * Support Intel Control-flow Enforcement Technology (CET) + * Use non-executable stack on FreeBSD. + + - Visual Studio: Use non-standard _MSVC_LANG to detect C++ + standard version in the lzma.h API header. It's used to + detect when "noexcept" can be used. + + * xzgrep: + + - Fixed arbitrary command injection via a malicious filename + (CVE-2022-1271, ZDI-CAN-16587). A standalone patch for + this was released to the public on 2022-04-07. A slight + robustness improvement has been made since then and, if + using GNU or *BSD grep, a new faster method is now used + that doesn't use the old sed-based construct at all. This + also fixes bad output with GNU grep >= 3.5 (2020-09-27) + when xzgrepping binary files. + + This vulnerability was discovered by: + cleemy desu wayo working with Trend Micro Zero Day Initiative + + - Fixed detection of corrupt .bz2 files. + + - Improved error handling to fix exit status in some situations + and to fix handling of signals: in some situations a signal + didn't make xzgrep exit when it clearly should have. It's + possible that the signal handling still isn't quite perfect + but hopefully it's good enough. + + - Documented exit statuses on the man page. + + - xzegrep and xzfgrep now use "grep -E" and "grep -F" instead + of the deprecated egrep and fgrep commands. + + - Fixed parsing of the options -E, -F, -G, -P, and -X. The + problem occurred when multiple options were specified in + a single argument, for example, + + echo foo | xzgrep -Fe foo + + treated foo as a filename because -Fe wasn't correctly + split into -F -e. + + - Added zstd support. + + * xzdiff/xzcmp: + + - Fixed wrong exit status. Exit status could be 2 when the + correct value is 1. + + - Documented on the man page that exit status of 2 is used + for decompression errors. + + - Added zstd support. + + * xzless: + + - Fix less(1) version detection. It failed if the version number + from "less -V" contained a dot. + + * Translations: + + - Added new translations: Catalan, Croatian, Esperanto, + Korean, Portuguese, Romanian, Serbian, Spanish, Swedish, + and Ukrainian + + - Updated the Brazilian Portuguese translation. + + - Added French man page translation. This and the existing + German translation aren't complete anymore because the + English man pages got a few updates and the translators + weren't reached so that they could update their work. + + * Build systems: + + - Windows: Fix building of resource files when config.h isn't + used. CMake + Visual Studio can now build liblzma.dll. + + - Various fixes to the CMake support. Building static or shared + liblzma should work fine in most cases. In contrast, building + the command line tools with CMake is still clearly incomplete + and experimental and should be used for testing only. + + +5.2.5 (2020-03-17) + + * liblzma: + + - Fixed several C99/C11 conformance bugs. Now the code is clean + under gcc/clang -fsanitize=undefined. Some of these changes + might have a negative effect on performance with old GCC + versions or compilers other than GCC and Clang. The configure + option --enable-unsafe-type-punning can be used to (mostly) + restore the old behavior but it shouldn't normally be used. + + - Improved API documentation of lzma_properties_decode(). + + - Added a very minor encoder speed optimization. + + * xz: + + - Fixed a crash in "xz -dcfv not_an_xz_file". All four options + were required to trigger it. The crash occurred in the + progress indicator code when xz was in passthru mode where + xz works like "cat". + + - Fixed an integer overflow with 32-bit off_t. It could happen + when decompressing a file that has a long run of zero bytes + which xz would try to write as a sparse file. Since the build + system enables large file support by default, off_t is + normally 64-bit even on 32-bit systems. + + - Fixes for --flush-timeout: + * Fix semi-busy-waiting. + * Avoid unneeded flushes when no new input has arrived + since the previous flush was completed. + + - Added a special case for 32-bit xz: If --memlimit-compress is + used to specify a limit that exceeds 4020 MiB, the limit will + be set to 4020 MiB. The values "0" and "max" aren't affected + by this and neither is decompression. This hack can be + helpful when a 32-bit xz has access to 4 GiB address space + but the specified memlimit exceeds 4 GiB. This can happen + e.g. with some scripts. + + - Capsicum sandbox is now enabled by default where available + (FreeBSD >= 10). The sandbox debug messages (xz -vv) were + removed since they seemed to be more annoying than useful. + + - DOS build now requires DJGPP 2.05 instead of 2.04beta. + A workaround for a locale problem with DJGPP 2.05 was added. + + * xzgrep and other scripts: + + - Added a configure option --enable-path-for-scripts=PREFIX. + It is disabled by default except on Solaris where the default + is /usr/xpg4/bin. See INSTALL for details. + + - Added a workaround for a POSIX shell detection problem on + Solaris. + + * Build systems: + + - Added preliminary build instructions for z/OS. See INSTALL + section 1.2.9. + + - Experimental CMake support was added. It should work to build + static liblzma on a few operating systems. It may or may not + work to build shared liblzma. On some platforms it can build + xz and xzdec too but those are only for testing. See the + comment in the beginning of CMakeLists.txt for details. + + - Visual Studio project files were updated. + WindowsTargetPlatformVersion was removed from VS2017 files + and set to "10.0" in the added VS2019 files. In the future + the VS project files will be removed when CMake support is + good enough. + + - New #defines in config.h: HAVE___BUILTIN_ASSUME_ALIGNED, + HAVE___BUILTIN_BSWAPXX, and TUKLIB_USE_UNSAFE_TYPE_PUNNING. + + - autogen.sh has a new optional dependency on po4a and a new + option --no-po4a to skip that step. This matters only if one + wants to remake the build files. po4a is used to update the + translated man pages but as long as the man pages haven't + been modified, there's nothing to update and one can use + --no-po4a to avoid the dependency on po4a. + + * Translations: + + - XZ Utils translations are now handled by the Translation + Project: https://translationproject.org/domain/xz.html + + - All man pages are now included in German too. + + - New xz translations: Brazilian Portuguese, Finnish, + Hungarian, Chinese (simplified), Chinese (traditional), + and Danish (partial translation) + + - Updated xz translations: French, German, Italian, and Polish + + - Unfortunately a few new xz translations weren't included due + to technical problems like too long lines in --help output or + misaligned column headings in tables. In the future, many of + these strings will be split and e.g. the table column + alignment will be handled in software. This should make the + strings easier to translate. + + +5.2.4 (2018-04-29) + + * liblzma: + + - Allow 0 as memory usage limit instead of returning + LZMA_PROG_ERROR. Now 0 is treated as if 1 byte was specified, + which effectively is the same as 0. + + - Use "noexcept" keyword instead of "throw()" in the public + headers when a C++11 (or newer standard) compiler is used. + + - Added a portability fix for recent Intel C Compilers. + + - Microsoft Visual Studio build files have been moved under + windows/vs2013 and windows/vs2017. + + * xz: + + - Fix "xz --list --robot missing_or_bad_file.xz" which would + try to print an uninitialized string and thus produce garbage + output. Since the exit status is non-zero, most uses of such + a command won't try to interpret the garbage output. + + - "xz --list foo.xz" could print "Internal error (bug)" in a + corner case where a specific memory usage limit had been set. + + +5.2.3 (2016-12-30) + + * xz: + + - Always close a file before trying to delete it to avoid + problems on some operating system and file system combinations. + + - Fixed copying of file timestamps on Windows. + + - Added experimental (disabled by default) sandbox support using + Capsicum (FreeBSD >= 10). See --enable-sandbox in INSTALL. + + * C99/C11 conformance fixes to liblzma. The issues affected at least + some builds using link-time optimizations. + + * Fixed bugs in the rarely-used function lzma_index_dup(). + + * Use of external SHA-256 code is now disabled by default. + It can still be enabled by passing --enable-external-sha256 + to configure. The reasons to disable it by default (see INSTALL + for more details): + + - Some OS-specific SHA-256 implementations conflict with + OpenSSL and cause problems in programs that link against both + liblzma and libcrypto. At least FreeBSD 10 and MINIX 3.3.0 + are affected. + + - The internal SHA-256 is faster than the SHA-256 code in + some operating systems. + + * Changed CPU core count detection to use sched_getaffinity() on + GNU/Linux and GNU/kFreeBSD. + + * Fixes to the build-system and xz to make xz buildable even when + encoders, decoders, or threading have been disabled from libilzma + using configure options. These fixes added two new #defines to + config.h: HAVE_ENCODERS and HAVE_DECODERS. + + +5.2.2 (2015-09-29) + + * Fixed bugs in QNX-specific code. + + * Omitted the use of pipe2() even if it is available to avoid + portability issues with some old Linux and glibc combinations. + + * Updated German translation. + + * Added project files to build static and shared liblzma (not the + whole XZ Utils) with Visual Studio 2013 update 2 or later. + + * Documented that threaded decompression hasn't been implemented + yet. A 5.2.0 NEWS entry describing multi-threading support had + incorrectly said "decompression" when it should have said + "compression". + + +5.2.1 (2015-02-26) + + * Fixed a compression-ratio regression in fast mode of LZMA1 and + LZMA2. The bug is present in 5.1.4beta and 5.2.0 releases. + + * Fixed a portability problem in xz that affected at least OpenBSD. + + * Fixed xzdiff to be compatible with FreeBSD's mktemp which differs + from most other mktemp implementations. + + * Changed CPU core count detection to use cpuset_getaffinity() on + FreeBSD. + + +5.2.0 (2014-12-21) + + Since 5.1.4beta: + + * All fixes from 5.0.8 + + * liblzma: Fixed lzma_stream_encoder_mt_memusage() when a preset + was used. + + * xzdiff: If mktemp isn't installed, mkdir will be used as + a fallback to create a temporary directory. Installing mktemp + is still recommended. + + * Updated French, German, Italian, Polish, and Vietnamese + translations. + + Summary of fixes and new features added in the 5.1.x development + releases: + + * liblzma: + + - Added support for multi-threaded compression. See the + lzma_mt structure, lzma_stream_encoder_mt(), and + lzma_stream_encoder_mt_memusage() in , + lzma_get_progress() in , and lzma_cputhreads() + in for details. + + - Made the uses of lzma_allocator const correct. + + - Added lzma_block_uncomp_encode() to create uncompressed + .xz Blocks using LZMA2 uncompressed chunks. + + - Added support for LZMA_IGNORE_CHECK. + + - A few speed optimizations were made. + + - Added support for symbol versioning. It is enabled by default + on GNU/Linux, other GNU-based systems, and FreeBSD. + + - liblzma (not the whole XZ Utils) should now be buildable + with MSVC 2013 update 2 or later using windows/config.h. + + * xz: + + - Fixed a race condition in the signal handling. It was + possible that e.g. the first SIGINT didn't make xz exit + if reading or writing blocked and one had bad luck. The fix + is non-trivial, so as of writing it is unknown if it will be + backported to the v5.0 branch. + + - Multi-threaded compression can be enabled with the + --threads (-T) option. + [Fixed: This originally said "decompression".] + + - New command line options in xz: --single-stream, + --block-size=SIZE, --block-list=SIZES, + --flush-timeout=TIMEOUT, and --ignore-check. + + - xz -lvv now shows the minimum xz version that is required to + decompress the file. Currently it is 5.0.0 for all supported + .xz files except files with empty LZMA2 streams require 5.0.2. + + * xzdiff and xzgrep now support .lzo files if lzop is installed. + The .tzo suffix is also recognized as a shorthand for .tar.lzo. + + +5.1.4beta (2014-09-14) + + * All fixes from 5.0.6 + + * liblzma: Fixed the use of presets in threaded encoder + initialization. + + * xz --block-list and --block-size can now be used together + in single-threaded mode. Previously the combination only + worked in multi-threaded mode. + + * Added support for LZMA_IGNORE_CHECK to liblzma and made it + available in xz as --ignore-check. + + * liblzma speed optimizations: + + - Initialization of a new LZMA1 or LZMA2 encoder has been + optimized. (The speed of reinitializing an already-allocated + encoder isn't affected.) This helps when compressing many + small buffers with lzma_stream_buffer_encode() and other + similar situations where an already-allocated encoder state + isn't reused. This speed-up is visible in xz too if one + compresses many small files one at a time instead running xz + once and giving all files as command-line arguments. + + - Buffer comparisons are now much faster when unaligned access + is allowed (configured with --enable-unaligned-access). This + speeds up encoding significantly. There is arch-specific code + for 32-bit and 64-bit x86 (32-bit needs SSE2 for the best + results and there's no run-time CPU detection for now). + For other archs there is only generic code which probably + isn't as optimal as arch-specific solutions could be. + + - A few speed optimizations were made to the SHA-256 code. + (Note that the builtin SHA-256 code isn't used on all + operating systems.) + + * liblzma can now be built with MSVC 2013 update 2 or later + using windows/config.h. + + * Vietnamese translation was added. + + +5.1.3alpha (2013-10-26) + + * All fixes from 5.0.5 + + * liblzma: + + - Fixed a deadlock in the threaded encoder. + + - Made the uses of lzma_allocator const correct. + + - Added lzma_block_uncomp_encode() to create uncompressed + .xz Blocks using LZMA2 uncompressed chunks. + + - Added support for native threads on Windows and the ability + to detect the number of CPU cores. + + * xz: + + - Fixed a race condition in the signal handling. It was + possible that e.g. the first SIGINT didn't make xz exit + if reading or writing blocked and one had bad luck. The fix + is non-trivial, so as of writing it is unknown if it will be + backported to the v5.0 branch. + + - Made the progress indicator work correctly in threaded mode. + + - Threaded encoder now works together with --block-list=SIZES. + + - Added preliminary support for --flush-timeout=TIMEOUT. + It can be useful for (somewhat) real-time streaming. For + now the decompression side has to be done with something + else than the xz tool due to how xz does buffering, but this + should be fixed. + + +5.1.2alpha (2012-07-04) + + * All fixes from 5.0.3 and 5.0.4 + + * liblzma: + + - Fixed a deadlock and an invalid free() in the threaded encoder. + + - Added support for symbol versioning. It is enabled by default + on GNU/Linux, other GNU-based systems, and FreeBSD. + + - Use SHA-256 implementation from the operating system if one is + available in libc, libmd, or libutil. liblzma won't use e.g. + OpenSSL or libgcrypt to avoid introducing new dependencies. + + - Fixed liblzma.pc for static linking. + + - Fixed a few portability bugs. + + * xz --decompress --single-stream now fixes the input position after + successful decompression. Now the following works: + + echo foo | xz > foo.xz + echo bar | xz >> foo.xz + ( xz -dc --single-stream ; xz -dc --single-stream ) < foo.xz + + Note that it doesn't work if the input is not seekable + or if there is Stream Padding between the concatenated + .xz Streams. + + * xz -lvv now shows the minimum xz version that is required to + decompress the file. Currently it is 5.0.0 for all supported .xz + files except files with empty LZMA2 streams require 5.0.2. + + * Added an *incomplete* implementation of --block-list=SIZES to xz. + It only works correctly in single-threaded mode and when + --block-size isn't used at the same time. --block-list allows + specifying the sizes of Blocks which can be useful e.g. when + creating files for random-access reading. + + +5.1.1alpha (2011-04-12) + + * All fixes from 5.0.2 + + * liblzma fixes that will also be included in 5.0.3: + + - A memory leak was fixed. + + - lzma_stream_buffer_encode() no longer creates an empty .xz + Block if encoding an empty buffer. Such an empty Block with + LZMA2 data would trigger a bug in 5.0.1 and older (see the + first bullet point in 5.0.2 notes). When releasing 5.0.2, + I thought that no encoder creates this kind of files but + I was wrong. + + - Validate function arguments better in a few functions. Most + importantly, specifying an unsupported integrity check to + lzma_stream_buffer_encode() no longer creates a corrupt .xz + file. Probably no application tries to do that, so this + shouldn't be a big problem in practice. + + - Document that lzma_block_buffer_encode(), + lzma_easy_buffer_encode(), lzma_stream_encoder(), and + lzma_stream_buffer_encode() may return LZMA_UNSUPPORTED_CHECK. + + - The return values of the _memusage() functions are now + documented better. + + * Support for multithreaded compression was added using the simplest + method, which splits the input data into blocks and compresses + them independently. Other methods will be added in the future. + The current method has room for improvement, e.g. it is possible + to reduce the memory usage. + + * Added the options --single-stream and --block-size=SIZE to xz. + + * xzdiff and xzgrep now support .lzo files if lzop is installed. + The .tzo suffix is also recognized as a shorthand for .tar.lzo. + + * Support for short 8.3 filenames under DOS was added to xz. It is + experimental and may change before it gets into a stable release. + + +5.0.8 (2014-12-21) + + * Fixed an old bug in xzgrep that affected OpenBSD and probably + a few other operating systems too. + + * Updated French and German translations. + + * Added support for detecting the amount of RAM on AmigaOS/AROS. + + * Minor build system updates. + + +5.0.7 (2014-09-20) + + * Fix regressions introduced in 5.0.6: + + - Fix building with non-GNU make. + + - Fix invalid Libs.private value in liblzma.pc which broke + static linking against liblzma if the linker flags were + taken from pkg-config. + + +5.0.6 (2014-09-14) + + * xzgrep now exits with status 0 if at least one file matched. + + * A few minor portability and build system fixes + + +5.0.5 (2013-06-30) + + * lzmadec and liblzma's lzma_alone_decoder(): Support decompressing + .lzma files that have less common settings in the headers + (dictionary size other than 2^n or 2^n + 2^(n-1), or uncompressed + size greater than 256 GiB). The limitations existed to avoid false + positives when detecting .lzma files. The lc + lp <= 4 limitation + still remains since liblzma's LZMA decoder has that limitation. + + NOTE: xz's .lzma support or liblzma's lzma_auto_decoder() are NOT + affected by this change. They still consider uncommon .lzma headers + as not being in the .lzma format. Changing this would give way too + many false positives. + + * xz: + + - Interaction of preset and custom filter chain options was + made less illogical. This affects only certain less typical + uses cases so few people are expected to notice this change. + + Now when a custom filter chain option (e.g. --lzma2) is + specified, all preset options (-0 ... -9, -e) earlier are on + the command line are completely forgotten. Similarly, when + a preset option is specified, all custom filter chain options + earlier on the command line are completely forgotten. + + Example 1: "xz -9 --lzma2=preset=5 -e" is equivalent to "xz -e" + which is equivalent to "xz -6e". Earlier -e didn't put xz back + into preset mode and thus the example command was equivalent + to "xz --lzma2=preset=5". + + Example 2: "xz -9e --lzma2=preset=5 -7" is equivalent to + "xz -7". Earlier a custom filter chain option didn't make + xz forget the -e option so the example was equivalent to + "xz -7e". + + - Fixes and improvements to error handling. + + - Various fixes to the man page. + + * xzless: Fixed to work with "less" versions 448 and later. + + * xzgrep: Made -h an alias for --no-filename. + + * Include the previously missing debug/translation.bash which can + be useful for translators. + + * Include a build script for Mac OS X. This has been in the Git + repository since 2010 but due to a mistake in Makefile.am the + script hasn't been included in a release tarball before. + + +5.0.4 (2012-06-22) + + * liblzma: + + - Fix lzma_index_init(). It could crash if memory allocation + failed. + + - Fix the possibility of an incorrect LZMA_BUF_ERROR when a BCJ + filter is used and the application only provides exactly as + much output space as is the uncompressed size of the file. + + - Fix a bug in doc/examples_old/xz_pipe_decompress.c. It didn't + check if the last call to lzma_code() really returned + LZMA_STREAM_END, which made the program think that truncated + files are valid. + + - New example programs in doc/examples (old programs are now in + doc/examples_old). These have more comments and more detailed + error handling. + + * Fix "xz -lvv foo.xz". It could crash on some corrupted files. + + * Fix output of "xz --robot -lv" and "xz --robot -lvv" which + incorrectly printed the filename also in the "foo (x/x)" format. + + * Fix exit status of "xzdiff foo.xz bar.xz". + + * Fix exit status of "xzgrep foo binary_file". + + * Fix portability to EBCDIC systems. + + * Fix a configure issue on AIX with the XL C compiler. See INSTALL + for details. + + * Update French, German, Italian, and Polish translations. + + +5.0.3 (2011-05-21) + + * liblzma fixes: + + - A memory leak was fixed. + + - lzma_stream_buffer_encode() no longer creates an empty .xz + Block if encoding an empty buffer. Such an empty Block with + LZMA2 data would trigger a bug in 5.0.1 and older (see the + first bullet point in 5.0.2 notes). When releasing 5.0.2, + I thought that no encoder creates this kind of files but + I was wrong. + + - Validate function arguments better in a few functions. Most + importantly, specifying an unsupported integrity check to + lzma_stream_buffer_encode() no longer creates a corrupt .xz + file. Probably no application tries to do that, so this + shouldn't be a big problem in practice. + + - Document that lzma_block_buffer_encode(), + lzma_easy_buffer_encode(), lzma_stream_encoder(), and + lzma_stream_buffer_encode() may return LZMA_UNSUPPORTED_CHECK. + + - The return values of the _memusage() functions are now + documented better. + + * Fix command name detection in xzgrep. xzegrep and xzfgrep now + correctly use egrep and fgrep instead of grep. + + * French translation was added. + + +5.0.2 (2011-04-01) + + * LZMA2 decompressor now correctly accepts LZMA2 streams with no + uncompressed data. Previously it considered them corrupt. The + bug can affect applications that use raw LZMA2 streams. It is + very unlikely to affect .xz files because no compressor creates + .xz files with empty LZMA2 streams. (Empty .xz files are a + different thing than empty LZMA2 streams.) + + * "xz --suffix=.foo filename.foo" now refuses to compress the + file due to it already having the suffix .foo. It was already + documented on the man page, but the code lacked the test. + + * "xzgrep -l foo bar.xz" works now. + + * Polish translation was added. + + +5.0.1 (2011-01-29) + + * xz --force now (de)compresses files that have setuid, setgid, + or sticky bit set and files that have multiple hard links. + The man page had it documented this way already, but the code + had a bug. + + * gzip and bzip2 support in xzdiff was fixed. + + * Portability fixes + + * Minor fix to Czech translation + + +5.0.0 (2010-10-23) + + Only the most important changes compared to 4.999.9beta are listed + here. One change is especially important: + + * The memory usage limit is now disabled by default. Some scripts + written before this change may have used --memory=max on xz command + line or in XZ_OPT. THESE USES OF --memory=max SHOULD BE REMOVED + NOW, because they interfere with user's ability to set the memory + usage limit himself. If user-specified limit causes problems to + your script, blame the user. + + Other significant changes: + + * Added support for XZ_DEFAULTS environment variable. This variable + allows users to set default options for xz, e.g. default memory + usage limit or default compression level. Scripts that use xz + must never set or unset XZ_DEFAULTS. Scripts should use XZ_OPT + instead if they need a way to pass options to xz via an + environment variable. + + * The compression settings associated with the preset levels + -0 ... -9 have been changed. --extreme was changed a little too. + It is now less likely to make compression worse, but with some + files the new --extreme may compress slightly worse than the old + --extreme. + + * If a preset level (-0 ... -9) is specified after a custom filter + chain options have been used (e.g. --lzma2), the custom filter + chain will be forgotten. Earlier the preset options were + completely ignored after custom filter chain options had been + seen. + + * xz will create sparse files when decompressing if the uncompressed + data contains long sequences of binary zeros. This is done even + when writing to standard output that is connected to a regular + file and certain additional conditions are met to make it safe. + + * Support for "xz --list" was added. Combine with --verbose or + --verbose --verbose (-vv) for detailed output. + + * I had hoped that liblzma API would have been stable after + 4.999.9beta, but there have been a couple of changes in the + advanced features, which don't affect most applications: + + - Index handling code was revised. If you were using the old + API, you will get a compiler error (so it's easy to notice). + + - A subtle but important change was made to the Block handling + API. lzma_block.version has to be initialized even for + lzma_block_header_decode(). Code that doesn't do it will work + for now, but might break in the future, which makes this API + change easy to miss. + + * The major soname has been bumped to 5.0.0. liblzma API and ABI + are now stable, so the need to recompile programs linking against + liblzma shouldn't arise soon. + diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/README b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/README new file mode 100644 index 0000000000000000000000000000000000000000..41671676a516e32c56c75c38c487f262dde4fa59 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/README @@ -0,0 +1,281 @@ + +XZ Utils +======== + + 0. Overview + 1. Documentation + 1.1. Overall documentation + 1.2. Documentation for command-line tools + 1.3. Documentation for liblzma + 2. Version numbering + 3. Reporting bugs + 4. Translations + 4.1. Testing translations + 5. Other implementations of the .xz format + 6. Contact information + + +0. Overview +----------- + + XZ Utils provide a general-purpose data-compression library plus + command-line tools. The native file format is the .xz format, but + also the legacy .lzma format is supported. The .xz format supports + multiple compression algorithms, which are called "filters" in the + context of XZ Utils. The primary filter is currently LZMA2. With + typical files, XZ Utils create about 30 % smaller files than gzip. + + To ease adapting support for the .xz format into existing applications + and scripts, the API of liblzma is somewhat similar to the API of the + popular zlib library. For the same reason, the command-line tool xz + has a command-line syntax similar to that of gzip. + + When aiming for the highest compression ratio, the LZMA2 encoder uses + a lot of CPU time and may use, depending on the settings, even + hundreds of megabytes of RAM. However, in fast modes, the LZMA2 encoder + competes with bzip2 in compression speed, RAM usage, and compression + ratio. + + LZMA2 is reasonably fast to decompress. It is a little slower than + gzip, but a lot faster than bzip2. Being fast to decompress means + that the .xz format is especially nice when the same file will be + decompressed very many times (usually on different computers), which + is the case e.g. when distributing software packages. In such + situations, it's not too bad if the compression takes some time, + since that needs to be done only once to benefit many people. + + With some file types, combining (or "chaining") LZMA2 with an + additional filter can improve the compression ratio. A filter chain may + contain up to four filters, although usually only one or two are used. + For example, putting a BCJ (Branch/Call/Jump) filter before LZMA2 + in the filter chain can improve compression ratio of executable files. + + Since the .xz format allows adding new filter IDs, it is possible that + some day there will be a filter that is, for example, much faster to + compress than LZMA2 (but probably with worse compression ratio). + Similarly, it is possible that some day there is a filter that will + compress better than LZMA2. + + XZ Utils supports multithreaded compression. XZ Utils doesn't support + multithreaded decompression yet. It has been planned though and taken + into account when designing the .xz file format. In the future, files + that were created in threaded mode can be decompressed in threaded + mode too. + + +1. Documentation +---------------- + +1.1. Overall documentation + + README This file + + INSTALL.generic Generic install instructions for those not + familiar with packages using GNU Autotools + INSTALL Installation instructions specific to XZ Utils + PACKAGERS Information to packagers of XZ Utils + + COPYING XZ Utils copyright and license information + COPYING.0BSD BSD Zero Clause License + COPYING.GPLv2 GNU General Public License version 2 + COPYING.GPLv3 GNU General Public License version 3 + COPYING.LGPLv2.1 GNU Lesser General Public License version 2.1 + + AUTHORS The main authors of XZ Utils + THANKS Incomplete list of people who have helped making + this software + NEWS User-visible changes between XZ Utils releases + ChangeLog Detailed list of changes (commit log) + TODO Known bugs and some sort of to-do list + + Note that only some of the above files are included in binary + packages. + + +1.2. Documentation for command-line tools + + The command-line tools are documented as man pages. In source code + releases (and possibly also in some binary packages), the man pages + are also provided in plain text (ASCII only) format in the directory + "doc/man" to make the man pages more accessible to those whose + operating system doesn't provide an easy way to view man pages. + + +1.3. Documentation for liblzma + + The liblzma API headers include short docs about each function + and data type as Doxygen tags. These docs should be quite OK as + a quick reference. + + There are a few example/tutorial programs that should help in + getting started with liblzma. In the source package the examples + are in "doc/examples" and in binary packages they may be under + "examples" in the same directory as this README. + + Since the liblzma API has similarities to the zlib API, some people + may find it useful to read the zlib docs and tutorial too: + + https://zlib.net/manual.html + https://zlib.net/zlib_how.html + + +2. Version numbering +-------------------- + + The version number format of XZ Utils is X.Y.ZS: + + - X is the major version. When this is incremented, the library + API and ABI break. + + - Y is the minor version. It is incremented when new features + are added without breaking the existing API or ABI. An even Y + indicates a stable release and an odd Y indicates unstable + (alpha or beta version). + + - Z is the revision. This has a different meaning for stable and + unstable releases: + + * Stable: Z is incremented when bugs get fixed without adding + any new features. This is intended to be convenient for + downstream distributors that want bug fixes but don't want + any new features to minimize the risk of introducing new bugs. + + * Unstable: Z is just a counter. API or ABI of features added + in earlier unstable releases having the same X.Y may break. + + - S indicates stability of the release. It is missing from the + stable releases, where Y is an even number. When Y is odd, S + is either "alpha" or "beta" to make it very clear that such + versions are not stable releases. The same X.Y.Z combination is + not used for more than one stability level, i.e. after X.Y.Zalpha, + the next version can be X.Y.(Z+1)beta but not X.Y.Zbeta. + + +3. Reporting bugs +----------------- + + Naturally it is easiest for me if you already know what causes the + unexpected behavior. Even better if you have a patch to propose. + However, quite often the reason for unexpected behavior is unknown, + so here are a few things to do before sending a bug report: + + 1. Try to create a small example how to reproduce the issue. + + 2. Compile XZ Utils with debugging code using configure switches + --enable-debug and, if possible, --disable-shared. If you are + using GCC, use CFLAGS='-O0 -ggdb3'. Don't strip the resulting + binaries. + + 3. Turn on core dumps. The exact command depends on your shell; + for example in GNU bash it is done with "ulimit -c unlimited", + and in tcsh with "limit coredumpsize unlimited". + + 4. Try to reproduce the suspected bug. If you get "assertion failed" + message, be sure to include the complete message in your bug + report. If the application leaves a coredump, get a backtrace + using gdb: + $ gdb /path/to/app-binary # Load the app to the debugger. + (gdb) core core # Open the coredump. + (gdb) bt # Print the backtrace. Copy & paste to bug report. + (gdb) quit # Quit gdb. + + Report your bug via email or IRC (see Contact information below). + Don't send core dump files or any executables. If you have a small + example file(s) (total size less than 256 KiB), please include + it/them as an attachment. If you have bigger test files, put them + online somewhere and include a URL to the file(s) in the bug report. + + Always include the exact version number of XZ Utils in the bug report. + If you are using a snapshot from the git repository, use "git describe" + to get the exact snapshot version. If you are using XZ Utils shipped + in an operating system distribution, mention the distribution name, + distribution version, and exact xz package version; if you cannot + repeat the bug with the code compiled from unpatched source code, + you probably need to report a bug to your distribution's bug tracking + system. + + +4. Translations +--------------- + + The xz command line tool and all man pages can be translated. + The translations are handled via the Translation Project. If you + wish to help translating xz, please join the Translation Project: + + https://translationproject.org/html/translators.html + + Updates to translations won't be accepted by methods that bypass + the Translation Project because there is a risk of duplicate work: + translation updates made in the xz repository aren't seen by the + translators in the Translation Project. If you have found bugs in + a translation, please report them to the Language-Team address + which can be found near the beginning of the PO file. + + If you find language problems in the original English strings, + feel free to suggest improvements. Ask if something is unclear. + + +4.1. Testing translations + + Testing can be done by installing xz into a temporary directory. + + If building from Git repository (not tarball), generate the + Autotools files: + + ./autogen.sh + + Create a subdirectory for the build files. The tmp-build directory + can be deleted after testing. + + mkdir tmp-build + cd tmp-build + ../configure --disable-shared --enable-debug --prefix=$PWD/inst + + Edit the .po file in the po directory. Then build and install to + the "tmp-build/inst" directory, and use translations.bash to see + how some of the messages look. Repeat these steps if needed: + + make -C po update-po + make -j"$(nproc)" install + bash ../debug/translation.bash | less + bash ../debug/translation.bash | less -S # For --list outputs + + To test other languages, set the LANGUAGE environment variable + before running translations.bash. The value should match the PO file + name without the .po suffix. Example: + + export LANGUAGE=fi + + +5. Other implementations of the .xz format +------------------------------------------ + + 7-Zip and the p7zip port of 7-Zip support the .xz format starting + from the version 9.00alpha. + + https://7-zip.org/ + https://p7zip.sourceforge.net/ + + XZ Embedded is a limited implementation written for use in the Linux + kernel, but it is also suitable for other embedded use. + + https://tukaani.org/xz/embedded.html + + XZ for Java is a complete implementation written in pure Java. + + https://tukaani.org/xz/java.html + + +6. Contact information +---------------------- + + XZ Utils in general: + - Home page: https://tukaani.org/xz/ + - Email to maintainer(s): xz@tukaani.org + - IRC: #tukaani on Libera Chat + - GitHub: https://github.com/tukaani-project/xz + + Lead maintainer: + - Email: Lasse Collin + - IRC: Larhzu on Libera Chat + diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/THANKS b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/THANKS new file mode 100644 index 0000000000000000000000000000000000000000..e1c21ebfe5d22a6683f30bef678c3414012de49f --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/THANKS @@ -0,0 +1,257 @@ + +Thanks +====== + +Some people have helped more, some less, but nevertheless everyone's help +has been important. :-) + - Adam Borowski + - Adam Walling + - Adrien Nader + - Agostino Sarubbo + - Alexander Bluhm + - Alexander M. Greenham + - Alexander Neumann + - Alexandre Sauvé + - Alexey Tourbin + - Anders F. Björklund + - Andraž 'ruskie' Levstik + - Andre Noll + - Andreas K. Hüttel + - Andreas Müller + - Andreas Schwab + - Andreas Zieringer + - Andrej Skenderija + - Andres Freund + - Andrew Dudman + - Andrew Murray + - Antoine Cœur + - Anton Kochkov + - Antonio Diaz Diaz + - Arkadiusz Miskiewicz + - Asgeir Storesund Nilsen + - Aziz Chaudhry + - Bela Lubkin + - Ben Boeckel + - Benjamin Buch + - Benno Schulenberg + - Bernhard Reutner-Fischer + - Bert Wesarg + - Bhargava Shastry + - Bill Glessner + - Bjarni Ingi Gislason + - Boud Roukema + - Brad Smith + - Bruce Stark + - Cary Lewis + - Charles Wilson + - Chenxi Mao + - Chien Wong + - Chris Donawa + - Chris McCrohan + - Christian Hesse + - Christian Kujau + - Christian von Roques + - Christian Weisgerber + - Christoph Junghans + - Collin Funk + - Conley Moorhous + - Cristian Rodríguez + - Cristiano Ceglia + - Dan Shechter + - Dan Stromberg + - Dan Weiss + - Daniel Leonard + - Daniel Mealha Cabrita + - Daniel Packard + - Daniel Richard G. + - David Burklund + - Denis Excoffier + - Derwin McGeary + - Dexter Castor Döpping + - Diederik de Haas + - Diego Elio Pettenò + - Dimitri Papadopoulos Orfanos + - Dirk Müller + - Douglas Thor + - Ed Maste + - Elbert Pol + - Eli Schwartz + - Elijah Almeida Coimbra + - Émilie Labbé + - Emmanuel Blot + - Eric Lindblad + - Eric S. Raymond + - Étienne Mollier + - Evan Nemerson + - Fangrui Song + - Felix Collin + - Filip Palian + - Firas Khalil Khana + - François Etcheverry + - Frank Busse + - Frank Prochnow + - Fredrik Wikstrom + - Gabi Davar + - Gabriela Gutierrez + - Gilles Espinasse + - Gregory Margo + - Guillaume Outters + - Guiorgy Potskhishvili + - H. Peter Anvin + - Hajin Jang + - Hans Jansen + - Harri K. Koskinen + - Hin-Tak Leung + - H.J. Lu + - Hongbo Ni + - Igor Pavlov + - İhsan Doğan + - Ilya Kurdyukov + - Iouri Kharon + - İsmail Dönmez + - Ivan A. Melnikov + - Jakub Bogusz + - James Buren + - James M Leddy + - Jan Kratochvil + - Jan Terje Hansen + - Jason Gorski + - Jeff Bastian + - Jeffrey Walton + - Jeroen Roovers + - Jim Meyering + - Jim Wilcoxson + - Joachim Henke + - John Paul Adrian Glaubitz + - Jonathan Nieder + - Jonathan Stott + - Joona Kannisto + - Jouk Jansen + - Juan Manuel Guerrero + - Jukka Salmi + - Julien Marrec + - Jun I Jin + - Kai Pastor + - Karl Beldan + - Karl Berry + - Keith Patton + - Kelvin Lee + - Kevin R. Bulgrien + - Kian-Meng Ang + - Kim Jinyeong + - Kirill A. Korinsky + - Kiyoshi Kanazawa + - Lars Wirzenius + - Li Chenggang + - Lizandro Heredia + - Loganaden Velvindron + - Lorenzo De Liso + - Lukas Braune + - Maarten Bosmans + - Maksym Vatsyk + - Marcin Kowalczyk + - Marcus Comstedt + - Marcus Tillmanns + - Marek Černocký + - Mark Adler + - Mark Wielaard + - Markus Duft + - Markus Rickert + - Martin Blumenstingl + - Martin Matuška + - Martin Storsjö + - Martin Väth + - Mathieu Vachon + - Matthew Good + - Matthieu Rakotojaona + - Melanie Blower + - Michael Felt + - Michael Fox + - Michał Górny + - Mike Frysinger + - Mikko Pouru + - Milo Casagrande + - Mohammed Adnène Trojette + - Nathan Moinvaziri + - Nelson H. F. Beebe + - Nicholas Jackson + - Ole André Vadla Ravnås + - Orange Tsai + - Orgad Shaneh + - Patrick J. Volkerding + - Paul Eggert + - Paul Townsend + - Pavel Raiskup + - Per Øyvind Karlsen + - Peter Ivanov + - Peter Lawler + - Peter O'Gorman + - Peter Pallinger + - Peter Seiderer + - Pierre-Yves Martin + - Pilorz Wojciech + - Pippijn van Steenhoven + - Rafał Mużyło + - Rainer Müller + - Ralf Wildenhues + - Rich Prohaska + - Richard Koch + - Richard W.M. Jones + - Robert Elz + - Robert Readman + - Roel Bouckaert + - Ron Desmond + - Ruarí Ødegaard + - Rui Paulo + - Ryan Colyer + - Ryan Young + - Sam James + - Scott McAllister + - Sean Fenian + - Sebastian Andrzej Siewior + - Sergey Kosukhin + - Simon Josefsson + - Siteshwar Vashisht + - Steffen Nurpmeso + - Stephan Kulow + - Stephen Sachs + - Stuart Shelton + - Taiki Tsunekawa + - Thomas Klausner + - Tobias Lahrmann Hansen + - Tobias Stoeckmann + - Tomasz Gajc + - Tomer Chachamu + - Torsten Rupp + - Trần Ngọc Quân + - Trent W. Buck + - Victoria Alexia + - Vijay Sarvepalli + - Ville Koskinen + - Ville Skyttä + - Vincent Cruz + - Vincent Fazio + - Vincent Lefevre + - Vincent Torri + - Vincent Wixsom + - Vincenzo Innocente + - Vitaly Chikunov + - Wim Lewis + - Xi Ruoyao + - Xin Li + - Yifeng Li + - 榆柳松 (ZhengSen Wang) + +Companies: + - Google + - Sandfly Security + +Other credits: + - cleemy desu wayo working with Trend Micro Zero Day Initiative + - Orange Tsai and splitline from DEVCORE Research Team + +Also thanks to all the people who have participated in the Tukaani project. + +I have probably forgot to add some names to the above list. Sorry about +that and thanks for your help. + diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/examples/00_README.txt b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/examples/00_README.txt new file mode 100644 index 0000000000000000000000000000000000000000..120e1eb7e7c507a8293a060767d60fcfac3babde --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/examples/00_README.txt @@ -0,0 +1,31 @@ + +liblzma example programs +======================== + +Introduction + + The examples are written so that the same comments aren't + repeated (much) in later files. + + On POSIX systems, the examples should build by just typing "make". + + The examples that use stdin or stdout don't set stdin and stdout + to binary mode. On systems where it matters (e.g. Windows) it is + possible that the examples won't work without modification. + + +List of examples + + 01_compress_easy.c Multi-call compression using + a compression preset + + 02_decompress.c Multi-call decompression + + 03_compress_custom.c Like 01_compress_easy.c but using + a custom filter chain + (x86 BCJ + LZMA2) + + 04_compress_easy_mt.c Multi-threaded multi-call + compression using a compression + preset + diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/examples/01_compress_easy.c b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/examples/01_compress_easy.c new file mode 100644 index 0000000000000000000000000000000000000000..31bcf928508afd0e63699114cf1fb2e944e7e1d8 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/examples/01_compress_easy.c @@ -0,0 +1,296 @@ +// SPDX-License-Identifier: 0BSD + +/////////////////////////////////////////////////////////////////////////////// +// +/// \file 01_compress_easy.c +/// \brief Compress from stdin to stdout in multi-call mode +/// +/// Usage: ./01_compress_easy PRESET < INFILE > OUTFILE +/// +/// Example: ./01_compress_easy 6 < foo > foo.xz +// +// Author: Lasse Collin +// +/////////////////////////////////////////////////////////////////////////////// + +#include +#include +#include +#include +#include +#include + + +static void +show_usage_and_exit(const char *argv0) +{ + fprintf(stderr, "Usage: %s PRESET < INFILE > OUTFILE\n" + "PRESET is a number 0-9 and can optionally be " + "followed by 'e' to indicate extreme preset\n", + argv0); + exit(EXIT_FAILURE); +} + + +static uint32_t +get_preset(int argc, char **argv) +{ + // One argument whose first char must be 0-9. + if (argc != 2 || argv[1][0] < '0' || argv[1][0] > '9') + show_usage_and_exit(argv[0]); + + // Calculate the preste level 0-9. + uint32_t preset = argv[1][0] - '0'; + + // If there is a second char, it must be 'e'. It will set + // the LZMA_PRESET_EXTREME flag. + if (argv[1][1] != '\0') { + if (argv[1][1] != 'e' || argv[1][2] != '\0') + show_usage_and_exit(argv[0]); + + preset |= LZMA_PRESET_EXTREME; + } + + return preset; +} + + +static bool +init_encoder(lzma_stream *strm, uint32_t preset) +{ + // Initialize the encoder using a preset. Set the integrity to check + // to CRC64, which is the default in the xz command line tool. If + // the .xz file needs to be decompressed with XZ Embedded, use + // LZMA_CHECK_CRC32 instead. + lzma_ret ret = lzma_easy_encoder(strm, preset, LZMA_CHECK_CRC64); + + // Return successfully if the initialization went fine. + if (ret == LZMA_OK) + return true; + + // Something went wrong. The possible errors are documented in + // lzma/container.h (src/liblzma/api/lzma/container.h in the source + // package or e.g. /usr/include/lzma/container.h depending on the + // install prefix). + const char *msg; + switch (ret) { + case LZMA_MEM_ERROR: + msg = "Memory allocation failed"; + break; + + case LZMA_OPTIONS_ERROR: + msg = "Specified preset is not supported"; + break; + + case LZMA_UNSUPPORTED_CHECK: + msg = "Specified integrity check is not supported"; + break; + + default: + // This is most likely LZMA_PROG_ERROR indicating a bug in + // this program or in liblzma. It is inconvenient to have a + // separate error message for errors that should be impossible + // to occur, but knowing the error code is important for + // debugging. That's why it is good to print the error code + // at least when there is no good error message to show. + msg = "Unknown error, possibly a bug"; + break; + } + + fprintf(stderr, "Error initializing the encoder: %s (error code %u)\n", + msg, ret); + return false; +} + + +static bool +compress(lzma_stream *strm, FILE *infile, FILE *outfile) +{ + // This will be LZMA_RUN until the end of the input file is reached. + // This tells lzma_code() when there will be no more input. + lzma_action action = LZMA_RUN; + + // Buffers to temporarily hold uncompressed input + // and compressed output. + uint8_t inbuf[BUFSIZ]; + uint8_t outbuf[BUFSIZ]; + + // Initialize the input and output pointers. Initializing next_in + // and avail_in isn't really necessary when we are going to encode + // just one file since LZMA_STREAM_INIT takes care of initializing + // those already. But it doesn't hurt much and it will be needed + // if encoding more than one file like we will in 02_decompress.c. + // + // While we don't care about strm->total_in or strm->total_out in this + // example, it is worth noting that initializing the encoder will + // always reset total_in and total_out to zero. But the encoder + // initialization doesn't touch next_in, avail_in, next_out, or + // avail_out. + strm->next_in = NULL; + strm->avail_in = 0; + strm->next_out = outbuf; + strm->avail_out = sizeof(outbuf); + + // Loop until the file has been successfully compressed or until + // an error occurs. + while (true) { + // Fill the input buffer if it is empty. + if (strm->avail_in == 0 && !feof(infile)) { + strm->next_in = inbuf; + strm->avail_in = fread(inbuf, 1, sizeof(inbuf), + infile); + + if (ferror(infile)) { + fprintf(stderr, "Read error: %s\n", + strerror(errno)); + return false; + } + + // Once the end of the input file has been reached, + // we need to tell lzma_code() that no more input + // will be coming and that it should finish the + // encoding. + if (feof(infile)) + action = LZMA_FINISH; + } + + // Tell liblzma do the actual encoding. + // + // This reads up to strm->avail_in bytes of input starting + // from strm->next_in. avail_in will be decremented and + // next_in incremented by an equal amount to match the + // number of input bytes consumed. + // + // Up to strm->avail_out bytes of compressed output will be + // written starting from strm->next_out. avail_out and next_out + // will be incremented by an equal amount to match the number + // of output bytes written. + // + // The encoder has to do internal buffering, which means that + // it may take quite a bit of input before the same data is + // available in compressed form in the output buffer. + lzma_ret ret = lzma_code(strm, action); + + // If the output buffer is full or if the compression finished + // successfully, write the data from the output buffer to + // the output file. + if (strm->avail_out == 0 || ret == LZMA_STREAM_END) { + // When lzma_code() has returned LZMA_STREAM_END, + // the output buffer is likely to be only partially + // full. Calculate how much new data there is to + // be written to the output file. + size_t write_size = sizeof(outbuf) - strm->avail_out; + + if (fwrite(outbuf, 1, write_size, outfile) + != write_size) { + fprintf(stderr, "Write error: %s\n", + strerror(errno)); + return false; + } + + // Reset next_out and avail_out. + strm->next_out = outbuf; + strm->avail_out = sizeof(outbuf); + } + + // Normally the return value of lzma_code() will be LZMA_OK + // until everything has been encoded. + if (ret != LZMA_OK) { + // Once everything has been encoded successfully, the + // return value of lzma_code() will be LZMA_STREAM_END. + // + // It is important to check for LZMA_STREAM_END. Do not + // assume that getting ret != LZMA_OK would mean that + // everything has gone well. + if (ret == LZMA_STREAM_END) + return true; + + // It's not LZMA_OK nor LZMA_STREAM_END, + // so it must be an error code. See lzma/base.h + // (src/liblzma/api/lzma/base.h in the source package + // or e.g. /usr/include/lzma/base.h depending on the + // install prefix) for the list and documentation of + // possible values. Most values listen in lzma_ret + // enumeration aren't possible in this example. + const char *msg; + switch (ret) { + case LZMA_MEM_ERROR: + msg = "Memory allocation failed"; + break; + + case LZMA_DATA_ERROR: + // This error is returned if the compressed + // or uncompressed size get near 8 EiB + // (2^63 bytes) because that's where the .xz + // file format size limits currently are. + // That is, the possibility of this error + // is mostly theoretical unless you are doing + // something very unusual. + // + // Note that strm->total_in and strm->total_out + // have nothing to do with this error. Changing + // those variables won't increase or decrease + // the chance of getting this error. + msg = "File size limits exceeded"; + break; + + default: + // This is most likely LZMA_PROG_ERROR, but + // if this program is buggy (or liblzma has + // a bug), it may be e.g. LZMA_BUF_ERROR or + // LZMA_OPTIONS_ERROR too. + // + // It is inconvenient to have a separate + // error message for errors that should be + // impossible to occur, but knowing the error + // code is important for debugging. That's why + // it is good to print the error code at least + // when there is no good error message to show. + msg = "Unknown error, possibly a bug"; + break; + } + + fprintf(stderr, "Encoder error: %s (error code %u)\n", + msg, ret); + return false; + } + } +} + + +extern int +main(int argc, char **argv) +{ + // Get the preset number from the command line. + uint32_t preset = get_preset(argc, argv); + + // Initialize a lzma_stream structure. When it is allocated on stack, + // it is simplest to use LZMA_STREAM_INIT macro like below. When it + // is allocated on heap, using memset(strmptr, 0, sizeof(*strmptr)) + // works (as long as NULL pointers are represented with zero bits + // as they are on practically all computers today). + lzma_stream strm = LZMA_STREAM_INIT; + + // Initialize the encoder. If it succeeds, compress from + // stdin to stdout. + bool success = init_encoder(&strm, preset); + if (success) + success = compress(&strm, stdin, stdout); + + // Free the memory allocated for the encoder. If we were encoding + // multiple files, this would only need to be done after the last + // file. See 02_decompress.c for handling of multiple files. + // + // It is OK to call lzma_end() multiple times or when it hasn't been + // actually used except initialized with LZMA_STREAM_INIT. + lzma_end(&strm); + + // Close stdout to catch possible write errors that can occur + // when pending data is flushed from the stdio buffers. + if (fclose(stdout)) { + fprintf(stderr, "Write error: %s\n", strerror(errno)); + success = false; + } + + return success ? EXIT_SUCCESS : EXIT_FAILURE; +} diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/examples/02_decompress.c b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/examples/02_decompress.c new file mode 100644 index 0000000000000000000000000000000000000000..a87a5d3ece2ed6edbc6e01e77b6e48a112867e47 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/examples/02_decompress.c @@ -0,0 +1,286 @@ +// SPDX-License-Identifier: 0BSD + +/////////////////////////////////////////////////////////////////////////////// +// +/// \file 02_decompress.c +/// \brief Decompress .xz files to stdout +/// +/// Usage: ./02_decompress INPUT_FILES... > OUTFILE +/// +/// Example: ./02_decompress foo.xz bar.xz > foobar +// +// Author: Lasse Collin +// +/////////////////////////////////////////////////////////////////////////////// + +#include +#include +#include +#include +#include +#include + + +static bool +init_decoder(lzma_stream *strm) +{ + // Initialize a .xz decoder. The decoder supports a memory usage limit + // and a set of flags. + // + // The memory usage of the decompressor depends on the settings used + // to compress a .xz file. It can vary from less than a megabyte to + // a few gigabytes, but in practice (at least for now) it rarely + // exceeds 65 MiB because that's how much memory is required to + // decompress files created with "xz -9". Settings requiring more + // memory take extra effort to use and don't (at least for now) + // provide significantly better compression in most cases. + // + // Memory usage limit is useful if it is important that the + // decompressor won't consume gigabytes of memory. The need + // for limiting depends on the application. In this example, + // no memory usage limiting is used. This is done by setting + // the limit to UINT64_MAX. + // + // The .xz format allows concatenating compressed files as is: + // + // echo foo | xz > foobar.xz + // echo bar | xz >> foobar.xz + // + // When decompressing normal standalone .xz files, LZMA_CONCATENATED + // should always be used to support decompression of concatenated + // .xz files. If LZMA_CONCATENATED isn't used, the decoder will stop + // after the first .xz stream. This can be useful when .xz data has + // been embedded inside another file format. + // + // Flags other than LZMA_CONCATENATED are supported too, and can + // be combined with bitwise-or. See lzma/container.h + // (src/liblzma/api/lzma/container.h in the source package or e.g. + // /usr/include/lzma/container.h depending on the install prefix) + // for details. + lzma_ret ret = lzma_stream_decoder( + strm, UINT64_MAX, LZMA_CONCATENATED); + + // Return successfully if the initialization went fine. + if (ret == LZMA_OK) + return true; + + // Something went wrong. The possible errors are documented in + // lzma/container.h (src/liblzma/api/lzma/container.h in the source + // package or e.g. /usr/include/lzma/container.h depending on the + // install prefix). + // + // Note that LZMA_MEMLIMIT_ERROR is never possible here. If you + // specify a very tiny limit, the error will be delayed until + // the first headers have been parsed by a call to lzma_code(). + const char *msg; + switch (ret) { + case LZMA_MEM_ERROR: + msg = "Memory allocation failed"; + break; + + case LZMA_OPTIONS_ERROR: + msg = "Unsupported decompressor flags"; + break; + + default: + // This is most likely LZMA_PROG_ERROR indicating a bug in + // this program or in liblzma. It is inconvenient to have a + // separate error message for errors that should be impossible + // to occur, but knowing the error code is important for + // debugging. That's why it is good to print the error code + // at least when there is no good error message to show. + msg = "Unknown error, possibly a bug"; + break; + } + + fprintf(stderr, "Error initializing the decoder: %s (error code %u)\n", + msg, ret); + return false; +} + + +static bool +decompress(lzma_stream *strm, const char *inname, FILE *infile, FILE *outfile) +{ + // When LZMA_CONCATENATED flag was used when initializing the decoder, + // we need to tell lzma_code() when there will be no more input. + // This is done by setting action to LZMA_FINISH instead of LZMA_RUN + // in the same way as it is done when encoding. + // + // When LZMA_CONCATENATED isn't used, there is no need to use + // LZMA_FINISH to tell when all the input has been read, but it + // is still OK to use it if you want. When LZMA_CONCATENATED isn't + // used, the decoder will stop after the first .xz stream. In that + // case some unused data may be left in strm->next_in. + lzma_action action = LZMA_RUN; + + uint8_t inbuf[BUFSIZ]; + uint8_t outbuf[BUFSIZ]; + + strm->next_in = NULL; + strm->avail_in = 0; + strm->next_out = outbuf; + strm->avail_out = sizeof(outbuf); + + while (true) { + if (strm->avail_in == 0 && !feof(infile)) { + strm->next_in = inbuf; + strm->avail_in = fread(inbuf, 1, sizeof(inbuf), + infile); + + if (ferror(infile)) { + fprintf(stderr, "%s: Read error: %s\n", + inname, strerror(errno)); + return false; + } + + // Once the end of the input file has been reached, + // we need to tell lzma_code() that no more input + // will be coming. As said before, this isn't required + // if the LZMA_CONCATENATED flag isn't used when + // initializing the decoder. + if (feof(infile)) + action = LZMA_FINISH; + } + + lzma_ret ret = lzma_code(strm, action); + + if (strm->avail_out == 0 || ret == LZMA_STREAM_END) { + size_t write_size = sizeof(outbuf) - strm->avail_out; + + if (fwrite(outbuf, 1, write_size, outfile) + != write_size) { + fprintf(stderr, "Write error: %s\n", + strerror(errno)); + return false; + } + + strm->next_out = outbuf; + strm->avail_out = sizeof(outbuf); + } + + if (ret != LZMA_OK) { + // Once everything has been decoded successfully, the + // return value of lzma_code() will be LZMA_STREAM_END. + // + // It is important to check for LZMA_STREAM_END. Do not + // assume that getting ret != LZMA_OK would mean that + // everything has gone well or that when you aren't + // getting more output it must have successfully + // decoded everything. + if (ret == LZMA_STREAM_END) + return true; + + // It's not LZMA_OK nor LZMA_STREAM_END, + // so it must be an error code. See lzma/base.h + // (src/liblzma/api/lzma/base.h in the source package + // or e.g. /usr/include/lzma/base.h depending on the + // install prefix) for the list and documentation of + // possible values. Many values listen in lzma_ret + // enumeration aren't possible in this example, but + // can be made possible by enabling memory usage limit + // or adding flags to the decoder initialization. + const char *msg; + switch (ret) { + case LZMA_MEM_ERROR: + msg = "Memory allocation failed"; + break; + + case LZMA_FORMAT_ERROR: + // .xz magic bytes weren't found. + msg = "The input is not in the .xz format"; + break; + + case LZMA_OPTIONS_ERROR: + // For example, the headers specify a filter + // that isn't supported by this liblzma + // version (or it hasn't been enabled when + // building liblzma, but no-one sane does + // that unless building liblzma for an + // embedded system). Upgrading to a newer + // liblzma might help. + // + // Note that it is unlikely that the file has + // accidentally became corrupt if you get this + // error. The integrity of the .xz headers is + // always verified with a CRC32, so + // unintentionally corrupt files can be + // distinguished from unsupported files. + msg = "Unsupported compression options"; + break; + + case LZMA_DATA_ERROR: + msg = "Compressed file is corrupt"; + break; + + case LZMA_BUF_ERROR: + // Typically this error means that a valid + // file has got truncated, but it might also + // be a damaged part in the file that makes + // the decoder think the file is truncated. + // If you prefer, you can use the same error + // message for this as for LZMA_DATA_ERROR. + msg = "Compressed file is truncated or " + "otherwise corrupt"; + break; + + default: + // This is most likely LZMA_PROG_ERROR. + msg = "Unknown error, possibly a bug"; + break; + } + + fprintf(stderr, "%s: Decoder error: " + "%s (error code %u)\n", + inname, msg, ret); + return false; + } + } +} + + +extern int +main(int argc, char **argv) +{ + if (argc <= 1) { + fprintf(stderr, "Usage: %s FILES...\n", argv[0]); + return EXIT_FAILURE; + } + + lzma_stream strm = LZMA_STREAM_INIT; + + bool success = true; + + // Try to decompress all files. + for (int i = 1; i < argc; ++i) { + if (!init_decoder(&strm)) { + // Decoder initialization failed. There's no point + // to retry it so we need to exit. + success = false; + break; + } + + FILE *infile = fopen(argv[i], "rb"); + + if (infile == NULL) { + fprintf(stderr, "%s: Error opening the " + "input file: %s\n", + argv[i], strerror(errno)); + success = false; + } else { + success &= decompress(&strm, argv[i], infile, stdout); + fclose(infile); + } + } + + // Free the memory allocated for the decoder. This only needs to be + // done after the last file. + lzma_end(&strm); + + if (fclose(stdout)) { + fprintf(stderr, "Write error: %s\n", strerror(errno)); + success = false; + } + + return success ? EXIT_SUCCESS : EXIT_FAILURE; +} diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/examples/03_compress_custom.c b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/examples/03_compress_custom.c new file mode 100644 index 0000000000000000000000000000000000000000..80ad189a5e3eab826eb17b4e97ba11b1035bbb53 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/examples/03_compress_custom.c @@ -0,0 +1,192 @@ +// SPDX-License-Identifier: 0BSD + +/////////////////////////////////////////////////////////////////////////////// +// +/// \file 03_compress_custom.c +/// \brief Compress in multi-call mode using x86 BCJ and LZMA2 +/// +/// Usage: ./03_compress_custom < INFILE > OUTFILE +/// +/// Example: ./03_compress_custom < foo > foo.xz +// +// Author: Lasse Collin +// +/////////////////////////////////////////////////////////////////////////////// + +#include +#include +#include +#include +#include +#include + + +static bool +init_encoder(lzma_stream *strm) +{ + // Use the default preset (6) for LZMA2. + // + // The lzma_options_lzma structure and the lzma_lzma_preset() function + // are declared in lzma/lzma12.h (src/liblzma/api/lzma/lzma12.h in the + // source package or e.g. /usr/include/lzma/lzma12.h depending on + // the install prefix). + lzma_options_lzma opt_lzma2; + if (lzma_lzma_preset(&opt_lzma2, LZMA_PRESET_DEFAULT)) { + // It should never fail because the default preset + // (and presets 0-9 optionally with LZMA_PRESET_EXTREME) + // are supported by all stable liblzma versions. + // + // (The encoder initialization later in this function may + // still fail due to unsupported preset *if* the features + // required by the preset have been disabled at build time, + // but no-one does such things except on embedded systems.) + fprintf(stderr, "Unsupported preset, possibly a bug\n"); + return false; + } + + // Now we could customize the LZMA2 options if we wanted. For example, + // we could set the dictionary size (opt_lzma2.dict_size) to + // something else than the default (8 MiB) of the default preset. + // See lzma/lzma12.h for details of all LZMA2 options. + // + // The x86 BCJ filter will try to modify the x86 instruction stream so + // that LZMA2 can compress it better. The x86 BCJ filter doesn't need + // any options so it will be set to NULL below. + // + // Construct the filter chain. The uncompressed data goes first to + // the first filter in the array, in this case the x86 BCJ filter. + // The array is always terminated by setting .id = LZMA_VLI_UNKNOWN. + // + // See lzma/filter.h for more information about the lzma_filter + // structure. + lzma_filter filters[] = { + { .id = LZMA_FILTER_X86, .options = NULL }, + { .id = LZMA_FILTER_LZMA2, .options = &opt_lzma2 }, + { .id = LZMA_VLI_UNKNOWN, .options = NULL }, + }; + + // Initialize the encoder using the custom filter chain. + lzma_ret ret = lzma_stream_encoder(strm, filters, LZMA_CHECK_CRC64); + + if (ret == LZMA_OK) + return true; + + const char *msg; + switch (ret) { + case LZMA_MEM_ERROR: + msg = "Memory allocation failed"; + break; + + case LZMA_OPTIONS_ERROR: + // We are no longer using a plain preset so this error + // message has been edited accordingly compared to + // 01_compress_easy.c. + msg = "Specified filter chain is not supported"; + break; + + case LZMA_UNSUPPORTED_CHECK: + msg = "Specified integrity check is not supported"; + break; + + default: + msg = "Unknown error, possibly a bug"; + break; + } + + fprintf(stderr, "Error initializing the encoder: %s (error code %u)\n", + msg, ret); + return false; +} + + +// This function is identical to the one in 01_compress_easy.c. +static bool +compress(lzma_stream *strm, FILE *infile, FILE *outfile) +{ + lzma_action action = LZMA_RUN; + + uint8_t inbuf[BUFSIZ]; + uint8_t outbuf[BUFSIZ]; + + strm->next_in = NULL; + strm->avail_in = 0; + strm->next_out = outbuf; + strm->avail_out = sizeof(outbuf); + + while (true) { + if (strm->avail_in == 0 && !feof(infile)) { + strm->next_in = inbuf; + strm->avail_in = fread(inbuf, 1, sizeof(inbuf), + infile); + + if (ferror(infile)) { + fprintf(stderr, "Read error: %s\n", + strerror(errno)); + return false; + } + + if (feof(infile)) + action = LZMA_FINISH; + } + + lzma_ret ret = lzma_code(strm, action); + + if (strm->avail_out == 0 || ret == LZMA_STREAM_END) { + size_t write_size = sizeof(outbuf) - strm->avail_out; + + if (fwrite(outbuf, 1, write_size, outfile) + != write_size) { + fprintf(stderr, "Write error: %s\n", + strerror(errno)); + return false; + } + + strm->next_out = outbuf; + strm->avail_out = sizeof(outbuf); + } + + if (ret != LZMA_OK) { + if (ret == LZMA_STREAM_END) + return true; + + const char *msg; + switch (ret) { + case LZMA_MEM_ERROR: + msg = "Memory allocation failed"; + break; + + case LZMA_DATA_ERROR: + msg = "File size limits exceeded"; + break; + + default: + msg = "Unknown error, possibly a bug"; + break; + } + + fprintf(stderr, "Encoder error: %s (error code %u)\n", + msg, ret); + return false; + } + } +} + + +extern int +main(void) +{ + lzma_stream strm = LZMA_STREAM_INIT; + + bool success = init_encoder(&strm); + if (success) + success = compress(&strm, stdin, stdout); + + lzma_end(&strm); + + if (fclose(stdout)) { + fprintf(stderr, "Write error: %s\n", strerror(errno)); + success = false; + } + + return success ? EXIT_SUCCESS : EXIT_FAILURE; +} diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/examples/04_compress_easy_mt.c b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/examples/04_compress_easy_mt.c new file mode 100644 index 0000000000000000000000000000000000000000..c721a6618ae0f13cf63541d59b0a31824fb9e55d --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/examples/04_compress_easy_mt.c @@ -0,0 +1,205 @@ +// SPDX-License-Identifier: 0BSD + +/////////////////////////////////////////////////////////////////////////////// +// +/// \file 04_compress_easy_mt.c +/// \brief Compress in multi-call mode using LZMA2 in multi-threaded mode +/// +/// Usage: ./04_compress_easy_mt < INFILE > OUTFILE +/// +/// Example: ./04_compress_easy_mt < foo > foo.xz +// +// Author: Lasse Collin +// +/////////////////////////////////////////////////////////////////////////////// + +#include +#include +#include +#include +#include +#include + + +static bool +init_encoder(lzma_stream *strm) +{ + // The threaded encoder takes the options as pointer to + // a lzma_mt structure. + lzma_mt mt = { + // No flags are needed. + .flags = 0, + + // Let liblzma determine a sane block size. + .block_size = 0, + + // Use no timeout for lzma_code() calls by setting timeout + // to zero. That is, sometimes lzma_code() might block for + // a long time (from several seconds to even minutes). + // If this is not OK, for example due to progress indicator + // needing updates, specify a timeout in milliseconds here. + // See the documentation of lzma_mt in lzma/container.h for + // information how to choose a reasonable timeout. + .timeout = 0, + + // Use the default preset (6) for LZMA2. + // To use a preset, filters must be set to NULL. + .preset = LZMA_PRESET_DEFAULT, + .filters = NULL, + + // Use CRC64 for integrity checking. See also + // 01_compress_easy.c about choosing the integrity check. + .check = LZMA_CHECK_CRC64, + }; + + // Detect how many threads the CPU supports. + mt.threads = lzma_cputhreads(); + + // If the number of CPU cores/threads cannot be detected, + // use one thread. Note that this isn't the same as the normal + // single-threaded mode as this will still split the data into + // blocks and use more RAM than the normal single-threaded mode. + // You may want to consider using lzma_easy_encoder() or + // lzma_stream_encoder() instead of lzma_stream_encoder_mt() if + // lzma_cputhreads() returns 0 or 1. + if (mt.threads == 0) + mt.threads = 1; + + // If the number of CPU cores/threads exceeds threads_max, + // limit the number of threads to keep memory usage lower. + // The number 8 is arbitrarily chosen and may be too low or + // high depending on the compression preset and the computer + // being used. + // + // FIXME: A better way could be to check the amount of RAM + // (or available RAM) and use lzma_stream_encoder_mt_memusage() + // to determine if the number of threads should be reduced. + const uint32_t threads_max = 8; + if (mt.threads > threads_max) + mt.threads = threads_max; + + // Initialize the threaded encoder. + lzma_ret ret = lzma_stream_encoder_mt(strm, &mt); + + if (ret == LZMA_OK) + return true; + + const char *msg; + switch (ret) { + case LZMA_MEM_ERROR: + msg = "Memory allocation failed"; + break; + + case LZMA_OPTIONS_ERROR: + // We are no longer using a plain preset so this error + // message has been edited accordingly compared to + // 01_compress_easy.c. + msg = "Specified filter chain is not supported"; + break; + + case LZMA_UNSUPPORTED_CHECK: + msg = "Specified integrity check is not supported"; + break; + + default: + msg = "Unknown error, possibly a bug"; + break; + } + + fprintf(stderr, "Error initializing the encoder: %s (error code %u)\n", + msg, ret); + return false; +} + + +// This function is identical to the one in 01_compress_easy.c. +static bool +compress(lzma_stream *strm, FILE *infile, FILE *outfile) +{ + lzma_action action = LZMA_RUN; + + uint8_t inbuf[BUFSIZ]; + uint8_t outbuf[BUFSIZ]; + + strm->next_in = NULL; + strm->avail_in = 0; + strm->next_out = outbuf; + strm->avail_out = sizeof(outbuf); + + while (true) { + if (strm->avail_in == 0 && !feof(infile)) { + strm->next_in = inbuf; + strm->avail_in = fread(inbuf, 1, sizeof(inbuf), + infile); + + if (ferror(infile)) { + fprintf(stderr, "Read error: %s\n", + strerror(errno)); + return false; + } + + if (feof(infile)) + action = LZMA_FINISH; + } + + lzma_ret ret = lzma_code(strm, action); + + if (strm->avail_out == 0 || ret == LZMA_STREAM_END) { + size_t write_size = sizeof(outbuf) - strm->avail_out; + + if (fwrite(outbuf, 1, write_size, outfile) + != write_size) { + fprintf(stderr, "Write error: %s\n", + strerror(errno)); + return false; + } + + strm->next_out = outbuf; + strm->avail_out = sizeof(outbuf); + } + + if (ret != LZMA_OK) { + if (ret == LZMA_STREAM_END) + return true; + + const char *msg; + switch (ret) { + case LZMA_MEM_ERROR: + msg = "Memory allocation failed"; + break; + + case LZMA_DATA_ERROR: + msg = "File size limits exceeded"; + break; + + default: + msg = "Unknown error, possibly a bug"; + break; + } + + fprintf(stderr, "Encoder error: %s (error code %u)\n", + msg, ret); + return false; + } + } +} + + +extern int +main(void) +{ + lzma_stream strm = LZMA_STREAM_INIT; + + bool success = init_encoder(&strm); + if (success) + success = compress(&strm, stdin, stdout); + + lzma_end(&strm); + + if (fclose(stdout)) { + fprintf(stderr, "Write error: %s\n", strerror(errno)); + success = false; + } + + return success ? EXIT_SUCCESS : EXIT_FAILURE; +} diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/examples/11_file_info.c b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/examples/11_file_info.c new file mode 100644 index 0000000000000000000000000000000000000000..caadd98072fbf0ced7e27869a6f32dd90b45d71f --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/examples/11_file_info.c @@ -0,0 +1,205 @@ +// SPDX-License-Identifier: 0BSD + +/////////////////////////////////////////////////////////////////////////////// +// +/// \file 11_file_info.c +/// \brief Get uncompressed size of .xz file(s) +/// +/// Usage: ./11_file_info INFILE1.xz [INFILEn.xz]... +/// +/// Example: ./11_file_info foo.xz +// +// Author: Lasse Collin +// +/////////////////////////////////////////////////////////////////////////////// + +#include +#include +#include +#include +#include +#include +#include + + +static bool +print_file_size(lzma_stream *strm, FILE *infile, const char *filename) +{ + // Get the file size. In standard C it can be done by seeking to + // the end of the file and then getting the file position. + // In POSIX one can use fstat() and then st_size from struct stat. + // Also note that fseek() and ftell() use long and thus don't support + // large files on 32-bit systems (POSIX versions fseeko() and + // ftello() can support large files). + if (fseek(infile, 0, SEEK_END)) { + fprintf(stderr, "Error seeking the file '%s': %s\n", + filename, strerror(errno)); + return false; + } + + const long file_size = ftell(infile); + + // The decoder wants to start from the beginning of the .xz file. + rewind(infile); + + // Initialize the decoder. + lzma_index *i; + lzma_ret ret = lzma_file_info_decoder(strm, &i, UINT64_MAX, + (uint64_t)file_size); + switch (ret) { + case LZMA_OK: + // Initialization succeeded. + break; + + case LZMA_MEM_ERROR: + fprintf(stderr, "Out of memory when initializing " + "the .xz file info decoder\n"); + return false; + + case LZMA_PROG_ERROR: + default: + fprintf(stderr, "Unknown error, possibly a bug\n"); + return false; + } + + // This example program reuses the same lzma_stream structure + // for multiple files, so we need to reset this when starting + // a new file. + strm->avail_in = 0; + + // Buffer for input data. + uint8_t inbuf[BUFSIZ]; + + // Pass data to the decoder and seek when needed. + while (true) { + if (strm->avail_in == 0) { + strm->next_in = inbuf; + strm->avail_in = fread(inbuf, 1, sizeof(inbuf), + infile); + + if (ferror(infile)) { + fprintf(stderr, + "Error reading from '%s': %s\n", + filename, strerror(errno)); + return false; + } + + // We don't need to care about hitting the end of + // the file so no need to check for feof(). + } + + ret = lzma_code(strm, LZMA_RUN); + + switch (ret) { + case LZMA_OK: + break; + + case LZMA_SEEK_NEEDED: + // The cast is safe because liblzma won't ask us to + // seek past the known size of the input file which + // did fit into a long. + // + // NOTE: Remember to change these to off_t if you + // switch fseeko() or lseek(). + if (fseek(infile, (long)(strm->seek_pos), SEEK_SET)) { + fprintf(stderr, "Error seeking the " + "file '%s': %s\n", + filename, strerror(errno)); + return false; + } + + // The old data in the inbuf is useless now. Set + // avail_in to zero so that we will read new input + // from the new file position on the next iteration + // of this loop. + strm->avail_in = 0; + break; + + case LZMA_STREAM_END: + // File information was successfully decoded. + // See for functions that can be + // used on it. In this example we just print + // the uncompressed size (in bytes) of + // the .xz file followed by its file name. + printf("%10" PRIu64 " %s\n", + lzma_index_uncompressed_size(i), + filename); + + // Free the memory of the lzma_index structure. + lzma_index_end(i, NULL); + + return true; + + case LZMA_FORMAT_ERROR: + // .xz magic bytes weren't found. + fprintf(stderr, "The file '%s' is not " + "in the .xz format\n", filename); + return false; + + case LZMA_OPTIONS_ERROR: + fprintf(stderr, "The file '%s' has .xz headers that " + "are not supported by this liblzma " + "version\n", filename); + return false; + + case LZMA_DATA_ERROR: + fprintf(stderr, "The file '%s' is corrupt\n", + filename); + return false; + + case LZMA_MEM_ERROR: + fprintf(stderr, "Memory allocation failed when " + "decoding the file '%s'\n", filename); + return false; + + // LZMA_MEMLIMIT_ERROR shouldn't happen because we used + // UINT64_MAX as the limit. + // + // LZMA_BUF_ERROR shouldn't happen because we always provide + // new input when the input buffer is empty. The decoder + // knows the input file size and thus won't try to read past + // the end of the file. + case LZMA_MEMLIMIT_ERROR: + case LZMA_BUF_ERROR: + case LZMA_PROG_ERROR: + default: + fprintf(stderr, "Unknown error, possibly a bug\n"); + return false; + } + } + + // This line is never reached. +} + + +extern int +main(int argc, char **argv) +{ + bool success = true; + lzma_stream strm = LZMA_STREAM_INIT; + + for (int i = 1; i < argc; ++i) { + FILE *infile = fopen(argv[i], "rb"); + + if (infile == NULL) { + fprintf(stderr, "Cannot open the file '%s': %s\n", + argv[i], strerror(errno)); + success = false; + } + + success &= print_file_size(&strm, infile, argv[i]); + + (void)fclose(infile); + } + + lzma_end(&strm); + + // Close stdout to catch possible write errors that can occur + // when pending data is flushed from the stdio buffers. + if (fclose(stdout)) { + fprintf(stderr, "Write error: %s\n", strerror(errno)); + success = false; + } + + return success ? EXIT_SUCCESS : EXIT_FAILURE; +} diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/examples/Makefile b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/examples/Makefile new file mode 100644 index 0000000000000000000000000000000000000000..f5b98788ece821f1727ec3644c30f7115bd9148f --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/examples/Makefile @@ -0,0 +1,21 @@ +# SPDX-License-Identifier: 0BSD +# Author: Lasse Collin + +CC = c99 +CFLAGS = -g +LDFLAGS = -llzma + +PROGS = \ + 01_compress_easy \ + 02_decompress \ + 03_compress_custom \ + 04_compress_easy_mt \ + 11_file_info + +all: $(PROGS) + +.c: + $(CC) $(CFLAGS) -o $@ $< $(LDFLAGS) + +clean: + -rm -f $(PROGS) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/faq.txt b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/faq.txt new file mode 100644 index 0000000000000000000000000000000000000000..3f9068b4b278040489220702772738604209df03 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/faq.txt @@ -0,0 +1,244 @@ + +XZ Utils FAQ +============ + +Q: What do the letters XZ mean? + +A: Nothing. They are just two letters, which come from the file format + suffix .xz. The .xz suffix was selected, because it seemed to be + pretty much unused. It has no deeper meaning. + + +Q: What are LZMA and LZMA2? + +A: LZMA stands for Lempel-Ziv-Markov chain-Algorithm. It is the name + of the compression algorithm designed by Igor Pavlov for 7-Zip. + LZMA is based on LZ77 and range encoding. + + LZMA2 is an updated version of the original LZMA to fix a couple of + practical issues. In context of XZ Utils, LZMA is called LZMA1 to + emphasize that LZMA is not the same thing as LZMA2. LZMA2 is the + primary compression algorithm in the .xz file format. + + +Q: There are many LZMA related projects. How does XZ Utils relate to them? + +A: 7-Zip and LZMA SDK are the original projects. LZMA SDK is roughly + a subset of the 7-Zip source tree. + + p7zip is 7-Zip's command-line tools ported to POSIX-like systems. + + LZMA Utils provide a gzip-like lzma tool for POSIX-like systems. + LZMA Utils are based on LZMA SDK. XZ Utils are the successor to + LZMA Utils. + + There are several other projects using LZMA. Most are more or less + based on LZMA SDK. See . + + +Q: Why is liblzma named liblzma if its primary file format is .xz? + Shouldn't it be e.g. libxz? + +A: When the designing of the .xz format began, the idea was to replace + the .lzma format and use the same .lzma suffix. It would have been + quite OK to reuse the suffix when there were very few .lzma files + around. However, the old .lzma format became popular before the + new format was finished. The new format was renamed to .xz but the + name of liblzma wasn't changed. + + +Q: Do XZ Utils support the .7z format? + +A: No. Use 7-Zip (Windows) or p7zip (POSIX-like systems) to handle .7z + files. + + +Q: I have many .tar.7z files. Can I convert them to .tar.xz without + spending hours recompressing the data? + +A: In the "extra" directory, there is a script named 7z2lzma.bash which + is able to convert some .7z files to the .lzma format (not .xz). It + needs the 7za (or 7z) command from p7zip. The script may silently + produce corrupt output if certain assumptions are not met, so + decompress the resulting .lzma file and compare it against the + original before deleting the original file! + + +Q: I have many .lzma files. Can I quickly convert them to the .xz format? + +A: For now, no. Since XZ Utils supports the .lzma format, it's usually + not too bad to keep the old files in the old format. If you want to + do the conversion anyway, you need to decompress the .lzma files and + then recompress to the .xz format. + + Technically, there is a way to make the conversion relatively fast + (roughly twice the time that normal decompression takes). Writing + such a tool would take quite a bit of time though, and would probably + be useful to only a few people. If you really want such a conversion + tool, contact Lasse Collin and offer some money. + + +Q: I have installed xz, but my tar doesn't recognize .tar.xz files. + How can I extract .tar.xz files? + +A: xz -dc foo.tar.xz | tar xf - + + +Q: Can I recover parts of a broken .xz file (e.g. a corrupted CD-R)? + +A: It may be possible if the file consists of multiple blocks, which + typically is not the case if the file was created in single-threaded + mode. There is no recovery program yet. + + +Q: Is (some part of) XZ Utils patented? + +A: Lasse Collin is not aware of any patents that could affect XZ Utils. + However, due to the nature of software patents, it's not possible to + guarantee that XZ Utils isn't affected by any third party patent(s). + + +Q: Where can I find documentation about the file format and algorithms? + +A: The .xz format is documented in xz-file-format.txt. It is a container + format only, and doesn't include descriptions of any non-trivial + filters. + + Documenting LZMA and LZMA2 is planned, but for now, there is no other + documentation than the source code. Before you begin, you should know + the basics of LZ77 and range-coding algorithms. LZMA is based on LZ77, + but LZMA is a lot more complex. Range coding is used to compress + the final bitstream like Huffman coding is used in Deflate. + + +Q: I cannot find BCJ and BCJ2 filters. Don't they exist in liblzma? + +A: BCJ filter is called "x86" in liblzma. BCJ2 is not included, + because it requires using more than one encoded output stream. + + +Q: I need to use a script that runs "xz -9". On a system with 256 MiB + of RAM, xz says that it cannot allocate memory. Can I make the + script work without modifying it? + +A: Set a default memory usage limit for compression. You can do it e.g. + in a shell initialization script such as ~/.bashrc or /etc/profile: + + XZ_DEFAULTS=--memlimit-compress=150MiB + export XZ_DEFAULTS + + xz will then scale the compression settings down so that the given + memory usage limit is not reached. This way xz shouldn't run out + of memory. + + Check also that memory-related resource limits are high enough. + On most systems, "ulimit -a" will show the current resource limits. + + +Q: How do I create files that can be decompressed with XZ Embedded? + +A: See the documentation in XZ Embedded. In short, something like + this is a good start: + + xz --check=crc32 --lzma2=preset=6e,dict=64KiB + + Or if a BCJ filter is needed too, e.g. if compressing + a kernel image for PowerPC: + + xz --check=crc32 --powerpc --lzma2=preset=6e,dict=64KiB + + Adjust the dictionary size to get a good compromise between + compression ratio and decompressor memory usage. Note that + in single-call decompression mode of XZ Embedded, a big + dictionary doesn't increase memory usage. + + +Q: How is multi-threaded compression implemented in XZ Utils? + +A: The simplest method is splitting the uncompressed data into blocks + and compressing them in parallel independent from each other. + This is currently the only threading method supported in XZ Utils. + Since the blocks are compressed independently, they can also be + decompressed independently. Together with the index feature in .xz, + this allows using threads to create .xz files for random-access + reading. This also makes threaded decompression possible. + + The independent blocks method has a couple of disadvantages too. It + will compress worse than a single-block method. Often the difference + is not too big (maybe 1-2 %) but sometimes it can be too big. Also, + the memory usage of the compressor increases linearly when adding + threads. + + At least two other threading methods are possible but these haven't + been implemented in XZ Utils: + + Match finder parallelization has been in 7-Zip for ages. It doesn't + affect compression ratio or memory usage significantly. Among the + three threading methods, only this is useful when compressing small + files (files that are not significantly bigger than the dictionary). + Unfortunately this method scales only to about two CPU cores. + + The third method is pigz-style threading (I use that name, because + pigz uses that method). It doesn't + affect compression ratio significantly and scales to many cores. + The memory usage scales linearly when threads are added. This isn't + significant with pigz, because Deflate uses only a 32 KiB dictionary, + but with LZMA2 the memory usage will increase dramatically just like + with the independent-blocks method. There is also a constant + computational overhead, which may make pigz-method a bit dull on + dual-core compared to the parallel match finder method, but with more + cores the overhead is not a big deal anymore. + + Combining the threading methods will be possible and also useful. + For example, combining match finder parallelization with pigz-style + threading or independent-blocks-threading can cut the memory usage + by 50 %. + + +Q: I told xz to use many threads but it is using only one or two + processor cores. What is wrong? + +A: Since multi-threaded compression is done by splitting the data into + blocks that are compressed individually, if the input file is too + small for the block size, then many threads cannot be used. The + default block size increases when the compression level is + increased. For example, xz -6 uses 8 MiB LZMA2 dictionary and + 24 MiB blocks, and xz -9 uses 64 MiB LZMA dictionary and 192 MiB + blocks. If the input file is 100 MiB, xz -6 can use five threads + of which one will finish quickly as it has only 4 MiB to compress. + However, for the same file, xz -9 can only use one thread. + + One can adjust block size with --block-size=SIZE but making the + block size smaller than LZMA2 dictionary is waste of RAM: using + xz -9 with 6 MiB blocks isn't any better than using xz -6 with + 6 MiB blocks. The default settings use a block size bigger than + the LZMA2 dictionary size because this was seen as a reasonable + compromise between RAM usage and compression ratio. + + When decompressing, the ability to use threads depends on how the + file was created. If it was created in multi-threaded mode then + it can be decompressed in multi-threaded mode too if there are + multiple blocks in the file. + + +Q: How do I build a program that needs liblzmadec (lzmadec.h)? + +A: liblzmadec is part of LZMA Utils. XZ Utils has liblzma, but no + liblzmadec. The code using liblzmadec should be ported to use + liblzma instead. If you cannot or don't want to do that, download + LZMA Utils from . + + +Q: The default build of liblzma is too big. How can I make it smaller? + +A: Give --enable-small to the configure script. Use also appropriate + --enable or --disable options to include only those filter encoders + and decoders and integrity checks that you actually need. Use + CFLAGS=-Os (with GCC) or equivalent to tell your compiler to optimize + for size. See INSTALL for information about configure options. + + If the result is still too big, take a look at XZ Embedded. It is + a separate project, which provides a limited but significantly + smaller XZ decoder implementation than XZ Utils. You can find it + at . + diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/history.txt b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/history.txt new file mode 100644 index 0000000000000000000000000000000000000000..8545e232254ed5d64bab1aa9f713cc3a24cf3abe --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/history.txt @@ -0,0 +1,150 @@ + +History of LZMA Utils and XZ Utils +================================== + +Tukaani distribution + + In 2005, there was a small group working on the Tukaani distribution, + which was a Slackware fork. One of the project's goals was to fit the + distro on a single 700 MiB ISO-9660 image. Using LZMA instead of gzip + helped a lot. Roughly speaking, one could fit data that took 1000 MiB + in gzipped form into 700 MiB with LZMA. Naturally, the compression + ratio varied across packages, but this was what we got on average. + + Slackware packages have traditionally had .tgz as the filename suffix, + which is an abbreviation of .tar.gz. A logical naming for LZMA + compressed packages was .tlz, being an abbreviation of .tar.lzma. + + At the end of the year 2007, there was no distribution under the + Tukaani project anymore, but development of LZMA Utils was kept going. + Still, there were .tlz packages around, because at least Vector Linux + (a Slackware based distribution) used LZMA for its packages. + + First versions of the modified pkgtools used the LZMA_Alone tool from + Igor Pavlov's LZMA SDK as is. It was fine, because users wouldn't need + to interact with LZMA_Alone directly. But people soon wanted to use + LZMA for other files too, and the interface of LZMA_Alone wasn't + comfortable for those used to gzip and bzip2. + + +First steps of LZMA Utils + + The first version of LZMA Utils (4.22.0) included a shell script called + lzmash. It was a wrapper that had a gzip-like command-line interface. It + used the LZMA_Alone tool from LZMA SDK to do all the real work. zgrep, + zdiff, and related scripts from gzip were adapted to work with LZMA and + were part of the first LZMA Utils release too. + + LZMA Utils 4.22.0 included also lzmadec, which was a small (less than + 10 KiB) decoder-only command-line tool. It was written on top of the + decoder-only C code found from the LZMA SDK. lzmadec was convenient in + situations where LZMA_Alone (a few hundred KiB) would be too big. + + lzmash and lzmadec were written by Lasse Collin. + + +Second generation + + The lzmash script was an ugly and not very secure hack. The last + version of LZMA Utils to use lzmash was 4.27.1. + + LZMA Utils 4.32.0beta1 introduced a new lzma command-line tool written + by Ville Koskinen. It was written in C++, and used the encoder and + decoder from C++ LZMA SDK with some little modifications. This tool + replaced both the lzmash script and the LZMA_Alone command-line tool + in LZMA Utils. + + Introducing this new tool caused some temporary incompatibilities, + because the LZMA_Alone executable was simply named lzma like the new + command-line tool, but they had a completely different command-line + interface. The file format was still the same. + + Lasse wrote liblzmadec, which was a small decoder-only library based + on the C code found from LZMA SDK. liblzmadec had an API similar to + zlib, although there were some significant differences, which made it + non-trivial to use it in some applications designed for zlib and + libbzip2. + + The lzmadec command-line tool was converted to use liblzmadec. + + Alexandre Sauvé helped converting the build system to use GNU + Autotools. This made it easier to test for certain less portable + features needed by the new command-line tool. + + Since the new command-line tool never got completely finished (for + example, it didn't support the LZMA_OPT environment variable), the + intent was to not call 4.32.x stable. Similarly, liblzmadec wasn't + polished, but appeared to work well enough, so some people started + using it too. + + Because the development of the third generation of LZMA Utils was + delayed considerably (3-4 years), the 4.32.x branch had to be kept + maintained. It got some bug fixes now and then, and finally it was + decided to call it stable, although most of the missing features were + never added. + + +File format problems + + The file format used by LZMA_Alone was primitive. It was designed with + embedded systems in mind, and thus provided only a minimal set of + features. The two biggest problems for non-embedded use were the lack + of magic bytes and an integrity check. + + Igor and Lasse started developing a new file format with some help + from Ville Koskinen. Also Mark Adler, Mikko Pouru, H. Peter Anvin, + and Lars Wirzenius helped with some minor things at some point of the + development. Designing the new format took quite a long time (actually, + too long a time would be a more appropriate expression). It was mostly + because Lasse was quite slow at getting things done due to personal + reasons. + + Originally the new format was supposed to use the same .lzma suffix + that was already used by the old file format. Switching to the new + format wouldn't have caused much trouble when the old format wasn't + used by many people. But since the development of the new format took + such a long time, the old format got quite popular, and it was decided + that the new file format must use a different suffix. + + It was decided to use .xz as the suffix of the new file format. The + first stable .xz file format specification was finally released in + December 2008. In addition to fixing the most obvious problems of + the old .lzma format, the .xz format added some new features like + support for multiple filters (compression algorithms), filter chaining + (like piping on the command line), and limited random-access reading. + + Currently the primary compression algorithm used in .xz is LZMA2. + It is an extension on top of the original LZMA to fix some practical + problems: LZMA2 adds support for flushing the encoder, uncompressed + chunks, eases stateful decoder implementations, and improves support + for multithreading. Since LZMA2 is better than the original LZMA, the + original LZMA is not supported in .xz. + + +Transition to XZ Utils + + The early versions of XZ Utils were called LZMA Utils. The first + releases were 4.42.0alphas. They dropped the rest of the C++ LZMA SDK. + The code was still directly based on LZMA SDK but ported to C and + converted from a callback API to a stateful API. Later, Igor Pavlov + made a C version of the LZMA encoder too; these ports from C++ to C + were independent in LZMA SDK and LZMA Utils. + + The core of the new LZMA Utils was liblzma, a compression library with + a zlib-like API. liblzma supported both the old and new file format. + The gzip-like lzma command-line tool was rewritten to use liblzma. + + The new LZMA Utils code base was renamed to XZ Utils when the name + of the new file format had been decided. The liblzma compression + library retained its name though, because changing it would have + caused unnecessary breakage in applications already using the early + liblzma snapshots. + + The xz command-line tool can emulate the gzip-like lzma tool by + creating appropriate symlinks (e.g. lzma -> xz). Thus, practically + all scripts using the lzma tool from LZMA Utils will work as is with + XZ Utils (and will keep using the old .lzma format). Still, the .lzma + format is more or less deprecated. XZ Utils will keep supporting it, + but new applications should use the .xz format, and migrating old + applications to .xz is often a good idea too. + diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/lzma-file-format.txt b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/lzma-file-format.txt new file mode 100644 index 0000000000000000000000000000000000000000..8cce5dcce749121b0855010e6e5576d545ba6a68 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/lzma-file-format.txt @@ -0,0 +1,173 @@ + +The .lzma File Format +===================== + + 0. Preface + 0.1. Notices and Acknowledgements + 0.2. Changes + 1. File Format + 1.1. Header + 1.1.1. Properties + 1.1.2. Dictionary Size + 1.1.3. Uncompressed Size + 1.2. LZMA Compressed Data + 2. References + + +0. Preface + + This document describes the .lzma file format, which is + sometimes also called LZMA_Alone format. It is a legacy file + format, which is being or has been replaced by the .xz format. + The MIME type of the .lzma format is `application/x-lzma'. + + The most commonly used software to handle .lzma files are + LZMA SDK, LZMA Utils, 7-Zip, and XZ Utils. This document + describes some of the differences between these implementations + and gives hints what subset of the .lzma format is the most + portable. + + +0.1. Notices and Acknowledgements + + This file format was designed by Igor Pavlov for use in + LZMA SDK. This document was written by Lasse Collin + using the documentation found + from the LZMA SDK. + + This document has been put into the public domain. + + +0.2. Changes + + Last modified: 2024-04-08 17:35+0300 + + From version 2011-04-12 11:55+0300 to 2022-07-13 21:00+0300: + The section 1.1.3 was modified to allow End of Payload Marker + with a known Uncompressed Size. + + +1. File Format + + +-+-+-+-+-+-+-+-+-+-+-+-+-+==========================+ + | Header | LZMA Compressed Data | + +-+-+-+-+-+-+-+-+-+-+-+-+-+==========================+ + + The .lzma format file consist of 13-byte Header followed by + the LZMA Compressed Data. + + Unlike the .gz, .bz2, and .xz formats, it is not possible to + concatenate multiple .lzma files as is and expect the + decompression tool to decode the resulting file as if it were + a single .lzma file. + + For example, the command line tools from LZMA Utils and + LZMA SDK silently ignore all the data after the first .lzma + stream. In contrast, the command line tool from XZ Utils + considers the .lzma file to be corrupt if there is data after + the first .lzma stream. + + +1.1. Header + + +------------+----+----+----+----+--+--+--+--+--+--+--+--+ + | Properties | Dictionary Size | Uncompressed Size | + +------------+----+----+----+----+--+--+--+--+--+--+--+--+ + + +1.1.1. Properties + + The Properties field contains three properties. An abbreviation + is given in parentheses, followed by the value range of the + property. The field consists of + + 1) the number of literal context bits (lc, [0, 8]); + 2) the number of literal position bits (lp, [0, 4]); and + 3) the number of position bits (pb, [0, 4]). + + The properties are encoded using the following formula: + + Properties = (pb * 5 + lp) * 9 + lc + + The following C code illustrates a straightforward way to + decode the Properties field: + + uint8_t lc, lp, pb; + uint8_t prop = get_lzma_properties(); + if (prop > (4 * 5 + 4) * 9 + 8) + return LZMA_PROPERTIES_ERROR; + + pb = prop / (9 * 5); + prop -= pb * 9 * 5; + lp = prop / 9; + lc = prop - lp * 9; + + XZ Utils has an additional requirement: lc + lp <= 4. Files + which don't follow this requirement cannot be decompressed + with XZ Utils. Usually this isn't a problem since the most + common lc/lp/pb values are 3/0/2. It is the only lc/lp/pb + combination that the files created by LZMA Utils can have, + but LZMA Utils can decompress files with any lc/lp/pb. + + +1.1.2. Dictionary Size + + Dictionary Size is stored as an unsigned 32-bit little endian + integer. Any 32-bit value is possible, but for maximum + portability, only sizes of 2^n and 2^n + 2^(n-1) should be + used. + + LZMA Utils creates only files with dictionary size 2^n, + 16 <= n <= 25. LZMA Utils can decompress files with any + dictionary size. + + XZ Utils creates and decompresses .lzma files only with + dictionary sizes 2^n and 2^n + 2^(n-1). If some other + dictionary size is specified when compressing, the value + stored in the Dictionary Size field is a rounded up, but the + specified value is still used in the actual compression code. + + +1.1.3. Uncompressed Size + + Uncompressed Size is stored as unsigned 64-bit little endian + integer. A special value of 0xFFFF_FFFF_FFFF_FFFF indicates + that Uncompressed Size is unknown. End of Payload Marker (*) + is used if Uncompressed Size is unknown. End of Payload Marker + is allowed but rarely used if Uncompressed Size is known. + XZ Utils 5.2.5 and older don't support .lzma files that have + End of Payload Marker together with a known Uncompressed Size. + + XZ Utils rejects files whose Uncompressed Size field specifies + a known size that is 256 GiB or more. This is to reject false + positives when trying to guess if the input file is in the + .lzma format. When Uncompressed Size is unknown, there is no + limit for the uncompressed size of the file. + + (*) Some tools use the term End of Stream (EOS) marker + instead of End of Payload Marker. + + +1.2. LZMA Compressed Data + + Detailed description of the format of this field is out of + scope of this document. + + +2. References + + LZMA SDK - The original LZMA implementation + https://7-zip.org/sdk.html + + 7-Zip + https://7-zip.org/ + + LZMA Utils - LZMA adapted to POSIX-like systems + https://tukaani.org/lzma/ + + XZ Utils - The next generation of LZMA Utils + https://tukaani.org/xz/ + + The .xz file format - The successor of the .lzma format + https://tukaani.org/xz/xz-file-format.txt + diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/xz-file-format.txt b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/xz-file-format.txt new file mode 100644 index 0000000000000000000000000000000000000000..12d2530cda4831e133ffaebad7d0f3f22ae302f2 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/doc/xz/xz-file-format.txt @@ -0,0 +1,1174 @@ + +The .xz File Format +=================== + +Version 1.2.1 (2024-04-08) + + + 0. Preface + 0.1. Notices and Acknowledgements + 0.2. Getting the Latest Version + 0.3. Version History + 1. Conventions + 1.1. Byte and Its Representation + 1.2. Multibyte Integers + 2. Overall Structure of .xz File + 2.1. Stream + 2.1.1. Stream Header + 2.1.1.1. Header Magic Bytes + 2.1.1.2. Stream Flags + 2.1.1.3. CRC32 + 2.1.2. Stream Footer + 2.1.2.1. CRC32 + 2.1.2.2. Backward Size + 2.1.2.3. Stream Flags + 2.1.2.4. Footer Magic Bytes + 2.2. Stream Padding + 3. Block + 3.1. Block Header + 3.1.1. Block Header Size + 3.1.2. Block Flags + 3.1.3. Compressed Size + 3.1.4. Uncompressed Size + 3.1.5. List of Filter Flags + 3.1.6. Header Padding + 3.1.7. CRC32 + 3.2. Compressed Data + 3.3. Block Padding + 3.4. Check + 4. Index + 4.1. Index Indicator + 4.2. Number of Records + 4.3. List of Records + 4.3.1. Unpadded Size + 4.3.2. Uncompressed Size + 4.4. Index Padding + 4.5. CRC32 + 5. Filter Chains + 5.1. Alignment + 5.2. Security + 5.3. Filters + 5.3.1. LZMA2 + 5.3.2. Branch/Call/Jump Filters for Executables + 5.3.3. Delta + 5.3.3.1. Format of the Encoded Output + 5.4. Custom Filter IDs + 5.4.1. Reserved Custom Filter ID Ranges + 6. Cyclic Redundancy Checks + 7. References + + +0. Preface + + This document describes the .xz file format (filename suffix + ".xz", MIME type "application/x-xz"). It is intended that this + this format replace the old .lzma format used by LZMA SDK and + LZMA Utils. + + +0.1. Notices and Acknowledgements + + This file format was designed by Lasse Collin + and Igor Pavlov. + + Special thanks for helping with this document goes to + Ville Koskinen. Thanks for helping with this document goes to + Mark Adler, H. Peter Anvin, Mikko Pouru, and Lars Wirzenius. + + This document has been put into the public domain. + + +0.2. Getting the Latest Version + + The latest official version of this document can be downloaded + from . + + Specific versions of this document have a filename + xz-file-format-X.Y.Z.txt where X.Y.Z is the version number. + For example, the version 1.0.0 of this document is available + at . + + +0.3. Version History + + Version Date Description + + 1.2.1 2024-04-08 The URLs of this specification and + XZ Utils were changed back to the + original ones in Sections 0.2 and 7. + + 1.2.0 2024-01-19 Added RISC-V filter and updated URLs in + Sections 0.2 and 7. The URL of this + specification was changed. + + 1.1.0 2022-12-11 Added ARM64 filter and clarified 32-bit + ARM endianness in Section 5.3.2, + language improvements in Section 5.4 + + 1.0.4 2009-08-27 Language improvements in Sections 1.2, + 2.1.1.2, 3.1.1, 3.1.2, and 5.3.1 + + 1.0.3 2009-06-05 Spelling fixes in Sections 5.1 and 5.4 + + 1.0.2 2009-06-04 Typo fixes in Sections 4 and 5.3.1 + + 1.0.1 2009-06-01 Typo fix in Section 0.3 and minor + clarifications to Sections 2, 2.2, + 3.3, 4.4, and 5.3.2 + + 1.0.0 2009-01-14 The first official version + + +1. Conventions + + The key words "MUST", "MUST NOT", "REQUIRED", "SHOULD", + "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this + document are to be interpreted as described in [RFC-2119]. + + Indicating a warning means displaying a message, returning + appropriate exit status, or doing something else to let the + user know that something worth warning occurred. The operation + SHOULD still finish if a warning is indicated. + + Indicating an error means displaying a message, returning + appropriate exit status, or doing something else to let the + user know that something prevented successfully finishing the + operation. The operation MUST be aborted once an error has + been indicated. + + +1.1. Byte and Its Representation + + In this document, byte is always 8 bits. + + A "null byte" has all bits unset. That is, the value of a null + byte is 0x00. + + To represent byte blocks, this document uses notation that + is similar to the notation used in [RFC-1952]: + + +-------+ + | Foo | One byte. + +-------+ + + +---+---+ + | Foo | Two bytes; that is, some of the vertical bars + +---+---+ can be missing. + + +=======+ + | Foo | Zero or more bytes. + +=======+ + + In this document, a boxed byte or a byte sequence declared + using this notation is called "a field". The example field + above would be called "the Foo field" or plain "Foo". + + If there are many fields, they may be split to multiple lines. + This is indicated with an arrow ("--->"): + + +=====+ + | Foo | + +=====+ + + +=====+ + ---> | Bar | + +=====+ + + The above is equivalent to this: + + +=====+=====+ + | Foo | Bar | + +=====+=====+ + + +1.2. Multibyte Integers + + Multibyte integers of static length, such as CRC values, + are stored in little endian byte order (least significant + byte first). + + When smaller values are more likely than bigger values (for + example file sizes), multibyte integers are encoded in a + variable-length representation: + - Numbers in the range [0, 127] are copied as is, and take + one byte of space. + - Bigger numbers will occupy two or more bytes. All but the + last byte of the multibyte representation have the highest + (eighth) bit set. + + For now, the value of the variable-length integers is limited + to 63 bits, which limits the encoded size of the integer to + nine bytes. These limits may be increased in the future if + needed. + + The following C code illustrates encoding and decoding of + variable-length integers. The functions return the number of + bytes occupied by the integer (1-9), or zero on error. + + #include + #include + + size_t + encode(uint8_t buf[static 9], uint64_t num) + { + if (num > UINT64_MAX / 2) + return 0; + + size_t i = 0; + + while (num >= 0x80) { + buf[i++] = (uint8_t)(num) | 0x80; + num >>= 7; + } + + buf[i++] = (uint8_t)(num); + + return i; + } + + size_t + decode(const uint8_t buf[], size_t size_max, uint64_t *num) + { + if (size_max == 0) + return 0; + + if (size_max > 9) + size_max = 9; + + *num = buf[0] & 0x7F; + size_t i = 0; + + while (buf[i++] & 0x80) { + if (i >= size_max || buf[i] == 0x00) + return 0; + + *num |= (uint64_t)(buf[i] & 0x7F) << (i * 7); + } + + return i; + } + + +2. Overall Structure of .xz File + + A standalone .xz files consist of one or more Streams which may + have Stream Padding between or after them: + + +========+================+========+================+ + | Stream | Stream Padding | Stream | Stream Padding | ... + +========+================+========+================+ + + The sizes of Stream and Stream Padding are always multiples + of four bytes, thus the size of every valid .xz file MUST be + a multiple of four bytes. + + While a typical file contains only one Stream and no Stream + Padding, a decoder handling standalone .xz files SHOULD support + files that have more than one Stream or Stream Padding. + + In contrast to standalone .xz files, when the .xz file format + is used as an internal part of some other file format or + communication protocol, it usually is expected that the decoder + stops after the first Stream, and doesn't look for Stream + Padding or possibly other Streams. + + +2.1. Stream + + +-+-+-+-+-+-+-+-+-+-+-+-+=======+=======+ +=======+ + | Stream Header | Block | Block | ... | Block | + +-+-+-+-+-+-+-+-+-+-+-+-+=======+=======+ +=======+ + + +=======+-+-+-+-+-+-+-+-+-+-+-+-+ + ---> | Index | Stream Footer | + +=======+-+-+-+-+-+-+-+-+-+-+-+-+ + + All the above fields have a size that is a multiple of four. If + Stream is used as an internal part of another file format, it + is RECOMMENDED to make the Stream start at an offset that is + a multiple of four bytes. + + Stream Header, Index, and Stream Footer are always present in + a Stream. The maximum size of the Index field is 16 GiB (2^34). + + There are zero or more Blocks. The maximum number of Blocks is + limited only by the maximum size of the Index field. + + Total size of a Stream MUST be less than 8 EiB (2^63 bytes). + The same limit applies to the total amount of uncompressed + data stored in a Stream. + + If an implementation supports handling .xz files with multiple + concatenated Streams, it MAY apply the above limits to the file + as a whole instead of limiting per Stream basis. + + +2.1.1. Stream Header + + +---+---+---+---+---+---+-------+------+--+--+--+--+ + | Header Magic Bytes | Stream Flags | CRC32 | + +---+---+---+---+---+---+-------+------+--+--+--+--+ + + +2.1.1.1. Header Magic Bytes + + The first six (6) bytes of the Stream are so called Header + Magic Bytes. They can be used to identify the file type. + + Using a C array and ASCII: + const uint8_t HEADER_MAGIC[6] + = { 0xFD, '7', 'z', 'X', 'Z', 0x00 }; + + In plain hexadecimal: + FD 37 7A 58 5A 00 + + Notes: + - The first byte (0xFD) was chosen so that the files cannot + be erroneously detected as being in .lzma format, in which + the first byte is in the range [0x00, 0xE0]. + - The sixth byte (0x00) was chosen to prevent applications + from misdetecting the file as a text file. + + If the Header Magic Bytes don't match, the decoder MUST + indicate an error. + + +2.1.1.2. Stream Flags + + The first byte of Stream Flags is always a null byte. In the + future, this byte may be used to indicate a new Stream version + or other Stream properties. + + The second byte of Stream Flags is a bit field: + + Bit(s) Mask Description + 0-3 0x0F Type of Check (see Section 3.4): + ID Size Check name + 0x00 0 bytes None + 0x01 4 bytes CRC32 + 0x02 4 bytes (Reserved) + 0x03 4 bytes (Reserved) + 0x04 8 bytes CRC64 + 0x05 8 bytes (Reserved) + 0x06 8 bytes (Reserved) + 0x07 16 bytes (Reserved) + 0x08 16 bytes (Reserved) + 0x09 16 bytes (Reserved) + 0x0A 32 bytes SHA-256 + 0x0B 32 bytes (Reserved) + 0x0C 32 bytes (Reserved) + 0x0D 64 bytes (Reserved) + 0x0E 64 bytes (Reserved) + 0x0F 64 bytes (Reserved) + 4-7 0xF0 Reserved for future use; MUST be zero for now. + + Implementations SHOULD support at least the Check IDs 0x00 + (None) and 0x01 (CRC32). Supporting other Check IDs is + OPTIONAL. If an unsupported Check is used, the decoder SHOULD + indicate a warning or error. + + If any reserved bit is set, the decoder MUST indicate an error. + It is possible that there is a new field present which the + decoder is not aware of, and can thus parse the Stream Header + incorrectly. + + +2.1.1.3. CRC32 + + The CRC32 is calculated from the Stream Flags field. It is + stored as an unsigned 32-bit little endian integer. If the + calculated value does not match the stored one, the decoder + MUST indicate an error. + + The idea is that Stream Flags would always be two bytes, even + if new features are needed. This way old decoders will be able + to verify the CRC32 calculated from Stream Flags, and thus + distinguish between corrupt files (CRC32 doesn't match) and + files that the decoder doesn't support (CRC32 matches but + Stream Flags has reserved bits set). + + +2.1.2. Stream Footer + + +-+-+-+-+---+---+---+---+-------+------+----------+---------+ + | CRC32 | Backward Size | Stream Flags | Footer Magic Bytes | + +-+-+-+-+---+---+---+---+-------+------+----------+---------+ + + +2.1.2.1. CRC32 + + The CRC32 is calculated from the Backward Size and Stream Flags + fields. It is stored as an unsigned 32-bit little endian + integer. If the calculated value does not match the stored one, + the decoder MUST indicate an error. + + The reason to have the CRC32 field before the Backward Size and + Stream Flags fields is to keep the four-byte fields aligned to + a multiple of four bytes. + + +2.1.2.2. Backward Size + + Backward Size is stored as a 32-bit little endian integer, + which indicates the size of the Index field as multiple of + four bytes, minimum value being four bytes: + + real_backward_size = (stored_backward_size + 1) * 4; + + If the stored value does not match the real size of the Index + field, the decoder MUST indicate an error. + + Using a fixed-size integer to store Backward Size makes + it slightly simpler to parse the Stream Footer when the + application needs to parse the Stream backwards. + + +2.1.2.3. Stream Flags + + This is a copy of the Stream Flags field from the Stream + Header. The information stored to Stream Flags is needed + when parsing the Stream backwards. The decoder MUST compare + the Stream Flags fields in both Stream Header and Stream + Footer, and indicate an error if they are not identical. + + +2.1.2.4. Footer Magic Bytes + + As the last step of the decoding process, the decoder MUST + verify the existence of Footer Magic Bytes. If they don't + match, an error MUST be indicated. + + Using a C array and ASCII: + const uint8_t FOOTER_MAGIC[2] = { 'Y', 'Z' }; + + In hexadecimal: + 59 5A + + The primary reason to have Footer Magic Bytes is to make + it easier to detect incomplete files quickly, without + uncompressing. If the file does not end with Footer Magic Bytes + (excluding Stream Padding described in Section 2.2), it cannot + be undamaged, unless someone has intentionally appended garbage + after the end of the Stream. + + +2.2. Stream Padding + + Only the decoders that support decoding of concatenated Streams + MUST support Stream Padding. + + Stream Padding MUST contain only null bytes. To preserve the + four-byte alignment of consecutive Streams, the size of Stream + Padding MUST be a multiple of four bytes. Empty Stream Padding + is allowed. If these requirements are not met, the decoder MUST + indicate an error. + + Note that non-empty Stream Padding is allowed at the end of the + file; there doesn't need to be a new Stream after non-empty + Stream Padding. This can be convenient in certain situations + [GNU-tar]. + + The possibility of Stream Padding MUST be taken into account + when designing an application that parses Streams backwards, + and the application supports concatenated Streams. + + +3. Block + + +==============+=================+===============+=======+ + | Block Header | Compressed Data | Block Padding | Check | + +==============+=================+===============+=======+ + + +3.1. Block Header + + +-------------------+-------------+=================+ + | Block Header Size | Block Flags | Compressed Size | + +-------------------+-------------+=================+ + + +===================+======================+ + ---> | Uncompressed Size | List of Filter Flags | + +===================+======================+ + + +================+--+--+--+--+ + ---> | Header Padding | CRC32 | + +================+--+--+--+--+ + + +3.1.1. Block Header Size + + This field overlaps with the Index Indicator field (see + Section 4.1). + + This field contains the size of the Block Header field, + including the Block Header Size field itself. Valid values are + in the range [0x01, 0xFF], which indicate the size of the Block + Header as multiples of four bytes, minimum size being eight + bytes: + + real_header_size = (encoded_header_size + 1) * 4; + + If a Block Header bigger than 1024 bytes is needed in the + future, a new field can be added between the Block Header and + Compressed Data fields. The presence of this new field would + be indicated in the Block Header field. + + +3.1.2. Block Flags + + The Block Flags field is a bit field: + + Bit(s) Mask Description + 0-1 0x03 Number of filters (1-4) + 2-5 0x3C Reserved for future use; MUST be zero for now. + 6 0x40 The Compressed Size field is present. + 7 0x80 The Uncompressed Size field is present. + + If any reserved bit is set, the decoder MUST indicate an error. + It is possible that there is a new field present which the + decoder is not aware of, and can thus parse the Block Header + incorrectly. + + +3.1.3. Compressed Size + + This field is present only if the appropriate bit is set in + the Block Flags field (see Section 3.1.2). + + The Compressed Size field contains the size of the Compressed + Data field, which MUST be non-zero. Compressed Size is stored + using the encoding described in Section 1.2. If the Compressed + Size doesn't match the size of the Compressed Data field, the + decoder MUST indicate an error. + + +3.1.4. Uncompressed Size + + This field is present only if the appropriate bit is set in + the Block Flags field (see Section 3.1.2). + + The Uncompressed Size field contains the size of the Block + after uncompressing. Uncompressed Size is stored using the + encoding described in Section 1.2. If the Uncompressed Size + does not match the real uncompressed size, the decoder MUST + indicate an error. + + Storing the Compressed Size and Uncompressed Size fields serves + several purposes: + - The decoder knows how much memory it needs to allocate + for a temporary buffer in multithreaded mode. + - Simple error detection: wrong size indicates a broken file. + - Seeking forwards to a specific location in streamed mode. + + It should be noted that the only reliable way to determine + the real uncompressed size is to uncompress the Block, + because the Block Header and Index fields may contain + (intentionally or unintentionally) invalid information. + + +3.1.5. List of Filter Flags + + +================+================+ +================+ + | Filter 0 Flags | Filter 1 Flags | ... | Filter n Flags | + +================+================+ +================+ + + The number of Filter Flags fields is stored in the Block Flags + field (see Section 3.1.2). + + The format of each Filter Flags field is as follows: + + +===========+====================+===================+ + | Filter ID | Size of Properties | Filter Properties | + +===========+====================+===================+ + + Both Filter ID and Size of Properties are stored using the + encoding described in Section 1.2. Size of Properties indicates + the size of the Filter Properties field as bytes. The list of + officially defined Filter IDs and the formats of their Filter + Properties are described in Section 5.3. + + Filter IDs greater than or equal to 0x4000_0000_0000_0000 + (2^62) are reserved for implementation-specific internal use. + These Filter IDs MUST never be used in List of Filter Flags. + + +3.1.6. Header Padding + + This field contains as many null byte as it is needed to make + the Block Header have the size specified in Block Header Size. + If any of the bytes are not null bytes, the decoder MUST + indicate an error. It is possible that there is a new field + present which the decoder is not aware of, and can thus parse + the Block Header incorrectly. + + +3.1.7. CRC32 + + The CRC32 is calculated over everything in the Block Header + field except the CRC32 field itself. It is stored as an + unsigned 32-bit little endian integer. If the calculated + value does not match the stored one, the decoder MUST indicate + an error. + + By verifying the CRC32 of the Block Header before parsing the + actual contents allows the decoder to distinguish between + corrupt and unsupported files. + + +3.2. Compressed Data + + The format of Compressed Data depends on Block Flags and List + of Filter Flags. Excluding the descriptions of the simplest + filters in Section 5.3, the format of the filter-specific + encoded data is out of scope of this document. + + +3.3. Block Padding + + Block Padding MUST contain 0-3 null bytes to make the size of + the Block a multiple of four bytes. This can be needed when + the size of Compressed Data is not a multiple of four. If any + of the bytes in Block Padding are not null bytes, the decoder + MUST indicate an error. + + +3.4. Check + + The type and size of the Check field depends on which bits + are set in the Stream Flags field (see Section 2.1.1.2). + + The Check, when used, is calculated from the original + uncompressed data. If the calculated Check does not match the + stored one, the decoder MUST indicate an error. If the selected + type of Check is not supported by the decoder, it SHOULD + indicate a warning or error. + + +4. Index + + +-----------------+===================+ + | Index Indicator | Number of Records | + +-----------------+===================+ + + +=================+===============+-+-+-+-+ + ---> | List of Records | Index Padding | CRC32 | + +=================+===============+-+-+-+-+ + + Index serves several purposes. Using it, one can + - verify that all Blocks in a Stream have been processed; + - find out the uncompressed size of a Stream; and + - quickly access the beginning of any Block (random access). + + +4.1. Index Indicator + + This field overlaps with the Block Header Size field (see + Section 3.1.1). The value of Index Indicator is always 0x00. + + +4.2. Number of Records + + This field indicates how many Records there are in the List + of Records field, and thus how many Blocks there are in the + Stream. The value is stored using the encoding described in + Section 1.2. If the decoder has decoded all the Blocks of the + Stream, and then notices that the Number of Records doesn't + match the real number of Blocks, the decoder MUST indicate an + error. + + +4.3. List of Records + + List of Records consists of as many Records as indicated by the + Number of Records field: + + +========+========+ + | Record | Record | ... + +========+========+ + + Each Record contains information about one Block: + + +===============+===================+ + | Unpadded Size | Uncompressed Size | + +===============+===================+ + + If the decoder has decoded all the Blocks of the Stream, it + MUST verify that the contents of the Records match the real + Unpadded Size and Uncompressed Size of the respective Blocks. + + Implementation hint: It is possible to verify the Index with + constant memory usage by calculating for example SHA-256 of + both the real size values and the List of Records, then + comparing the hash values. Implementing this using + non-cryptographic hash like CRC32 SHOULD be avoided unless + small code size is important. + + If the decoder supports random-access reading, it MUST verify + that Unpadded Size and Uncompressed Size of every completely + decoded Block match the sizes stored in the Index. If only + partial Block is decoded, the decoder MUST verify that the + processed sizes don't exceed the sizes stored in the Index. + + +4.3.1. Unpadded Size + + This field indicates the size of the Block excluding the Block + Padding field. That is, Unpadded Size is the size of the Block + Header, Compressed Data, and Check fields. Unpadded Size is + stored using the encoding described in Section 1.2. The value + MUST never be zero; with the current structure of Blocks, the + actual minimum value for Unpadded Size is five. + + Implementation note: Because the size of the Block Padding + field is not included in Unpadded Size, calculating the total + size of a Stream or doing random-access reading requires + calculating the actual size of the Blocks by rounding Unpadded + Sizes up to the next multiple of four. + + The reason to exclude Block Padding from Unpadded Size is to + ease making a raw copy of Compressed Data without Block + Padding. This can be useful, for example, if someone wants + to convert Streams to some other file format quickly. + + +4.3.2. Uncompressed Size + + This field indicates the Uncompressed Size of the respective + Block as bytes. The value is stored using the encoding + described in Section 1.2. + + +4.4. Index Padding + + This field MUST contain 0-3 null bytes to pad the Index to + a multiple of four bytes. If any of the bytes are not null + bytes, the decoder MUST indicate an error. + + +4.5. CRC32 + + The CRC32 is calculated over everything in the Index field + except the CRC32 field itself. The CRC32 is stored as an + unsigned 32-bit little endian integer. If the calculated + value does not match the stored one, the decoder MUST indicate + an error. + + +5. Filter Chains + + The Block Flags field defines how many filters are used. When + more than one filter is used, the filters are chained; that is, + the output of one filter is the input of another filter. The + following figure illustrates the direction of data flow. + + v Uncompressed Data ^ + | Filter 0 | + Encoder | Filter 1 | Decoder + | Filter n | + v Compressed Data ^ + + +5.1. Alignment + + Alignment of uncompressed input data is usually the job of + the application producing the data. For example, to get the + best results, an archiver tool should make sure that all + PowerPC executable files in the archive stream start at + offsets that are multiples of four bytes. + + Some filters, for example LZMA2, can be configured to take + advantage of specified alignment of input data. Note that + taking advantage of aligned input can be beneficial also when + a filter is not the first filter in the chain. For example, + if you compress PowerPC executables, you may want to use the + PowerPC filter and chain that with the LZMA2 filter. Because + not only the input but also the output alignment of the PowerPC + filter is four bytes, it is now beneficial to set LZMA2 + settings so that the LZMA2 encoder can take advantage of its + four-byte-aligned input data. + + The output of the last filter in the chain is stored to the + Compressed Data field, which is is guaranteed to be aligned + to a multiple of four bytes relative to the beginning of the + Stream. This can increase + - speed, if the filtered data is handled multiple bytes at + a time by the filter-specific encoder and decoder, + because accessing aligned data in computer memory is + usually faster; and + - compression ratio, if the output data is later compressed + with an external compression tool. + + +5.2. Security + + If filters would be allowed to be chained freely, it would be + possible to create malicious files, that would be very slow to + decode. Such files could be used to create denial of service + attacks. + + Slow files could occur when multiple filters are chained: + + v Compressed input data + | Filter 1 decoder (last filter) + | Filter 0 decoder (non-last filter) + v Uncompressed output data + + The decoder of the last filter in the chain produces a lot of + output from little input. Another filter in the chain takes the + output of the last filter, and produces very little output + while consuming a lot of input. As a result, a lot of data is + moved inside the filter chain, but the filter chain as a whole + gets very little work done. + + To prevent this kind of slow files, there are restrictions on + how the filters can be chained. These restrictions MUST be + taken into account when designing new filters. + + The maximum number of filters in the chain has been limited to + four, thus there can be at maximum of three non-last filters. + Of these three non-last filters, only two are allowed to change + the size of the data. + + The non-last filters, that change the size of the data, MUST + have a limit how much the decoder can compress the data: the + decoder SHOULD produce at least n bytes of output when the + filter is given 2n bytes of input. This limit is not + absolute, but significant deviations MUST be avoided. + + The above limitations guarantee that if the last filter in the + chain produces 4n bytes of output, the chain as a whole will + produce at least n bytes of output. + + +5.3. Filters + +5.3.1. LZMA2 + + LZMA (Lempel-Ziv-Markov chain-Algorithm) is a general-purpose + compression algorithm with high compression ratio and fast + decompression. LZMA is based on LZ77 and range coding + algorithms. + + LZMA2 is an extension on top of the original LZMA. LZMA2 uses + LZMA internally, but adds support for flushing the encoder, + uncompressed chunks, eases stateful decoder implementations, + and improves support for multithreading. Thus, the plain LZMA + will not be supported in this file format. + + Filter ID: 0x21 + Size of Filter Properties: 1 byte + Changes size of data: Yes + Allow as a non-last filter: No + Allow as the last filter: Yes + + Preferred alignment: + Input data: Adjustable to 1/2/4/8/16 byte(s) + Output data: 1 byte + + The format of the one-byte Filter Properties field is as + follows: + + Bits Mask Description + 0-5 0x3F Dictionary Size + 6-7 0xC0 Reserved for future use; MUST be zero for now. + + Dictionary Size is encoded with one-bit mantissa and five-bit + exponent. The smallest dictionary size is 4 KiB and the biggest + is 4 GiB. + + Raw value Mantissa Exponent Dictionary size + 0 2 11 4 KiB + 1 3 11 6 KiB + 2 2 12 8 KiB + 3 3 12 12 KiB + 4 2 13 16 KiB + 5 3 13 24 KiB + 6 2 14 32 KiB + ... ... ... ... + 35 3 27 768 MiB + 36 2 28 1024 MiB + 37 3 29 1536 MiB + 38 2 30 2048 MiB + 39 3 30 3072 MiB + 40 2 31 4096 MiB - 1 B + + Instead of having a table in the decoder, the dictionary size + can be decoded using the following C code: + + const uint8_t bits = get_dictionary_flags() & 0x3F; + if (bits > 40) + return DICTIONARY_TOO_BIG; // Bigger than 4 GiB + + uint32_t dictionary_size; + if (bits == 40) { + dictionary_size = UINT32_MAX; + } else { + dictionary_size = 2 | (bits & 1); + dictionary_size <<= bits / 2 + 11; + } + + +5.3.2. Branch/Call/Jump Filters for Executables + + These filters convert relative branch, call, and jump + instructions to their absolute counterparts in executable + files. This conversion increases redundancy and thus + compression ratio. + + Size of Filter Properties: 0 or 4 bytes + Changes size of data: No + Allow as a non-last filter: Yes + Allow as the last filter: No + + Below is the list of filters in this category. The alignment + is the same for both input and output data. + + Filter ID Alignment Description + 0x04 1 byte x86 filter (BCJ) + 0x05 4 bytes PowerPC (big endian) filter + 0x06 16 bytes IA64 filter + 0x07 4 bytes ARM filter [1] + 0x08 2 bytes ARM Thumb filter [1] + 0x09 4 bytes SPARC filter + 0x0A 4 bytes ARM64 filter [2] + 0x0B 2 bytes RISC-V filter + + [1] These are for little endian instruction encoding. + This must not be confused with data endianness. + A processor configured for big endian data access + may still use little endian instruction encoding. + The filters don't care about the data endianness. + + [2] 4096-byte alignment gives the best results + because the address in the ADRP instruction + is a multiple of 4096 bytes. + + If the size of Filter Properties is four bytes, the Filter + Properties field contains the start offset used for address + conversions. It is stored as an unsigned 32-bit little endian + integer. The start offset MUST be a multiple of the alignment + of the filter as listed in the table above; if it isn't, the + decoder MUST indicate an error. If the size of Filter + Properties is zero, the start offset is zero. + + Setting the start offset may be useful if an executable has + multiple sections, and there are many cross-section calls. + Taking advantage of this feature usually requires usage of + the Subblock filter, whose design is not complete yet. + + +5.3.3. Delta + + The Delta filter may increase compression ratio when the value + of the next byte correlates with the value of an earlier byte + at specified distance. + + Filter ID: 0x03 + Size of Filter Properties: 1 byte + Changes size of data: No + Allow as a non-last filter: Yes + Allow as the last filter: No + + Preferred alignment: + Input data: 1 byte + Output data: Same as the original input data + + The Properties byte indicates the delta distance, which can be + 1-256 bytes backwards from the current byte: 0x00 indicates + distance of 1 byte and 0xFF distance of 256 bytes. + + +5.3.3.1. Format of the Encoded Output + + The code below illustrates both encoding and decoding with + the Delta filter. + + // Distance is in the range [1, 256]. + const unsigned int distance = get_properties_byte() + 1; + uint8_t pos = 0; + uint8_t delta[256]; + + memset(delta, 0, sizeof(delta)); + + while (1) { + const int byte = read_byte(); + if (byte == EOF) + break; + + uint8_t tmp = delta[(uint8_t)(distance + pos)]; + if (is_encoder) { + tmp = (uint8_t)(byte) - tmp; + delta[pos] = (uint8_t)(byte); + } else { + tmp = (uint8_t)(byte) + tmp; + delta[pos] = tmp; + } + + write_byte(tmp); + --pos; + } + + +5.4. Custom Filter IDs + + If a developer wants to use custom Filter IDs, there are two + choices. The first choice is to contact Lasse Collin and ask + him to allocate a range of IDs for the developer. + + The second choice is to generate a 40-bit random integer + which the developer can use as a personal Developer ID. + To minimize the risk of collisions, Developer ID has to be + a randomly generated integer, not manually selected "hex word". + The following command, which works on many free operating + systems, can be used to generate Developer ID: + + dd if=/dev/urandom bs=5 count=1 | hexdump + + The developer can then use the Developer ID to create unique + (well, hopefully unique) Filter IDs. + + Bits Mask Description + 0-15 0x0000_0000_0000_FFFF Filter ID + 16-55 0x00FF_FFFF_FFFF_0000 Developer ID + 56-62 0x3F00_0000_0000_0000 Static prefix: 0x3F + + The resulting 63-bit integer will use 9 bytes of space when + stored using the encoding described in Section 1.2. To get + a shorter ID, see the beginning of this Section how to + request a custom ID range. + + +5.4.1. Reserved Custom Filter ID Ranges + + Range Description + 0x0000_0300 - 0x0000_04FF Reserved to ease .7z compatibility + 0x0002_0000 - 0x0007_FFFF Reserved to ease .7z compatibility + 0x0200_0000 - 0x07FF_FFFF Reserved to ease .7z compatibility + + +6. Cyclic Redundancy Checks + + There are several incompatible variations to calculate CRC32 + and CRC64. For simplicity and clarity, complete examples are + provided to calculate the checks as they are used in this file + format. Implementations MAY use different code as long as it + gives identical results. + + The program below reads data from standard input, calculates + the CRC32 and CRC64 values, and prints the calculated values + as big endian hexadecimal strings to standard output. + + #include + #include + #include + + uint32_t crc32_table[256]; + uint64_t crc64_table[256]; + + void + init(void) + { + static const uint32_t poly32 = UINT32_C(0xEDB88320); + static const uint64_t poly64 + = UINT64_C(0xC96C5795D7870F42); + + for (size_t i = 0; i < 256; ++i) { + uint32_t crc32 = i; + uint64_t crc64 = i; + + for (size_t j = 0; j < 8; ++j) { + if (crc32 & 1) + crc32 = (crc32 >> 1) ^ poly32; + else + crc32 >>= 1; + + if (crc64 & 1) + crc64 = (crc64 >> 1) ^ poly64; + else + crc64 >>= 1; + } + + crc32_table[i] = crc32; + crc64_table[i] = crc64; + } + } + + uint32_t + crc32(const uint8_t *buf, size_t size, uint32_t crc) + { + crc = ~crc; + for (size_t i = 0; i < size; ++i) + crc = crc32_table[buf[i] ^ (crc & 0xFF)] + ^ (crc >> 8); + return ~crc; + } + + uint64_t + crc64(const uint8_t *buf, size_t size, uint64_t crc) + { + crc = ~crc; + for (size_t i = 0; i < size; ++i) + crc = crc64_table[buf[i] ^ (crc & 0xFF)] + ^ (crc >> 8); + return ~crc; + } + + int + main() + { + init(); + + uint32_t value32 = 0; + uint64_t value64 = 0; + uint64_t total_size = 0; + uint8_t buf[8192]; + + while (1) { + const size_t buf_size + = fread(buf, 1, sizeof(buf), stdin); + if (buf_size == 0) + break; + + total_size += buf_size; + value32 = crc32(buf, buf_size, value32); + value64 = crc64(buf, buf_size, value64); + } + + printf("Bytes: %" PRIu64 "\n", total_size); + printf("CRC-32: 0x%08" PRIX32 "\n", value32); + printf("CRC-64: 0x%016" PRIX64 "\n", value64); + + return 0; + } + + +7. References + + LZMA SDK - The original LZMA implementation + https://7-zip.org/sdk.html + + LZMA Utils - LZMA adapted to POSIX-like systems + https://tukaani.org/lzma/ + + XZ Utils - The next generation of LZMA Utils + https://tukaani.org/xz/ + + [RFC-1952] + GZIP file format specification version 4.3 + https://www.ietf.org/rfc/rfc1952.txt + - Notation of byte boxes in section "2.1. Overall conventions" + + [RFC-2119] + Key words for use in RFCs to Indicate Requirement Levels + https://www.ietf.org/rfc/rfc2119.txt + + [GNU-tar] + GNU tar 1.35 manual + https://www.gnu.org/software/tar/manual/html_node/Blocking-Factor.html + - Node 9.4.2 "Blocking Factor", paragraph that begins + "gzip will complain about trailing garbage" + - Note that this URL points to the latest version of the + manual, and may some day not contain the note which is in + 1.35. For the exact version of the manual, download GNU + tar 1.35: ftp://ftp.gnu.org/pub/gnu/tar/tar-1.35.tar.gz + diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/ca/LC_MESSAGES/xz.mo b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/ca/LC_MESSAGES/xz.mo new file mode 100644 index 0000000000000000000000000000000000000000..4670cf7d2f22d967a5e4aba44e4593d347ef21ce Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/ca/LC_MESSAGES/xz.mo differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/cs/LC_MESSAGES/xz.mo b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/cs/LC_MESSAGES/xz.mo new file mode 100644 index 0000000000000000000000000000000000000000..f9ebe3d90b343a6ef4f0b24d2e1bf028bf4287b0 Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/cs/LC_MESSAGES/xz.mo differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/da/LC_MESSAGES/xz.mo b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/da/LC_MESSAGES/xz.mo new file mode 100644 index 0000000000000000000000000000000000000000..460dae3cf0da253aa610134613b98dab9238e11a Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/da/LC_MESSAGES/xz.mo differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/de/LC_MESSAGES/xz.mo b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/de/LC_MESSAGES/xz.mo new file mode 100644 index 0000000000000000000000000000000000000000..b1880f4e73982b1a4a8d7a7cccf928f851fce873 Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/de/LC_MESSAGES/xz.mo differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/eo/LC_MESSAGES/xz.mo b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/eo/LC_MESSAGES/xz.mo new file mode 100644 index 0000000000000000000000000000000000000000..7839b5360b2dd9819c8174168223f7adb22042cc Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/eo/LC_MESSAGES/xz.mo differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/es/LC_MESSAGES/xz.mo b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/es/LC_MESSAGES/xz.mo new file mode 100644 index 0000000000000000000000000000000000000000..abc29a1e5981a0eb6fb800342a0bfa8ad1dbfa84 Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/es/LC_MESSAGES/xz.mo differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/fi/LC_MESSAGES/xz.mo b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/fi/LC_MESSAGES/xz.mo new file mode 100644 index 0000000000000000000000000000000000000000..a85048858951e44183a4dee5428cb335f7406742 Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/fi/LC_MESSAGES/xz.mo differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/fr/LC_MESSAGES/xz.mo b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/fr/LC_MESSAGES/xz.mo new file mode 100644 index 0000000000000000000000000000000000000000..6b7b53ba2690a5f140cc4cb05be88841004f103f Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/fr/LC_MESSAGES/xz.mo differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/hr/LC_MESSAGES/xz.mo b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/hr/LC_MESSAGES/xz.mo new file mode 100644 index 0000000000000000000000000000000000000000..e43f132de575467c6f0c3d2d39a85405f382dd91 Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/hr/LC_MESSAGES/xz.mo differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/hu/LC_MESSAGES/xz.mo b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/hu/LC_MESSAGES/xz.mo new file mode 100644 index 0000000000000000000000000000000000000000..800f812947af292c8cb65964565ad13ef4ed75e7 Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/hu/LC_MESSAGES/xz.mo differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/it/LC_MESSAGES/xz.mo b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/it/LC_MESSAGES/xz.mo new file mode 100644 index 0000000000000000000000000000000000000000..910262b2de06b4c77e38677c2e3ec7b1ed62681b Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/it/LC_MESSAGES/xz.mo differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/ka/LC_MESSAGES/xz.mo b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/ka/LC_MESSAGES/xz.mo new file mode 100644 index 0000000000000000000000000000000000000000..a3573a11d7bcc32d044bdb43765e9d39a1cde8a1 Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/ka/LC_MESSAGES/xz.mo differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/ko/LC_MESSAGES/xz.mo b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/ko/LC_MESSAGES/xz.mo new file mode 100644 index 0000000000000000000000000000000000000000..4d7123e36aee93244356b11c9613600943349565 Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/ko/LC_MESSAGES/xz.mo differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/nl/LC_MESSAGES/xz.mo b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/nl/LC_MESSAGES/xz.mo new file mode 100644 index 0000000000000000000000000000000000000000..6f2c6756bbb1b98bd8a277721cc8badcfa45a213 Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/nl/LC_MESSAGES/xz.mo differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/pl/LC_MESSAGES/xz.mo b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/pl/LC_MESSAGES/xz.mo new file mode 100644 index 0000000000000000000000000000000000000000..93864523d4fe9984c447bf5a1fc2a5a196128c67 Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/pl/LC_MESSAGES/xz.mo differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/pt/LC_MESSAGES/xz.mo b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/pt/LC_MESSAGES/xz.mo new file mode 100644 index 0000000000000000000000000000000000000000..506bb9612066c31bccbbc3a532c88d01d59f379f Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/pt/LC_MESSAGES/xz.mo differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/pt_BR/LC_MESSAGES/xz.mo b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/pt_BR/LC_MESSAGES/xz.mo new file mode 100644 index 0000000000000000000000000000000000000000..82858f7617876e6fbcea8675aacd016043573bf1 Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/pt_BR/LC_MESSAGES/xz.mo differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/ro/LC_MESSAGES/xz.mo b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/ro/LC_MESSAGES/xz.mo new file mode 100644 index 0000000000000000000000000000000000000000..0c8bdccbe18406a1b2944915ed7e46156c1b7b9f Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/ro/LC_MESSAGES/xz.mo differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/sr/LC_MESSAGES/xz.mo b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/sr/LC_MESSAGES/xz.mo new file mode 100644 index 0000000000000000000000000000000000000000..979a12df0c607f81cddcea580692232631134086 Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/sr/LC_MESSAGES/xz.mo differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/sv/LC_MESSAGES/xz.mo b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/sv/LC_MESSAGES/xz.mo new file mode 100644 index 0000000000000000000000000000000000000000..93c65cb07b4d799dd3550523065867fe1889096d Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/sv/LC_MESSAGES/xz.mo differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/tr/LC_MESSAGES/xz.mo b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/tr/LC_MESSAGES/xz.mo new file mode 100644 index 0000000000000000000000000000000000000000..80e3501997ad1cd50a5f9478960b7648fbef6419 Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/tr/LC_MESSAGES/xz.mo differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/uk/LC_MESSAGES/xz.mo b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/uk/LC_MESSAGES/xz.mo new file mode 100644 index 0000000000000000000000000000000000000000..5975b6d850ee4f431b8c580879f956523dc7df4d Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/uk/LC_MESSAGES/xz.mo differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/vi/LC_MESSAGES/xz.mo b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/vi/LC_MESSAGES/xz.mo new file mode 100644 index 0000000000000000000000000000000000000000..6b124fe4c6392b87cf9fa57555365f81b907035e Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/vi/LC_MESSAGES/xz.mo differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/zh_CN/LC_MESSAGES/xz.mo b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/zh_CN/LC_MESSAGES/xz.mo new file mode 100644 index 0000000000000000000000000000000000000000..b9206e45833f169c59ad5fda7f8b2aa05f41aa4a Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/zh_CN/LC_MESSAGES/xz.mo differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/zh_TW/LC_MESSAGES/xz.mo b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/zh_TW/LC_MESSAGES/xz.mo new file mode 100644 index 0000000000000000000000000000000000000000..38ebcdbb81e66d155ca1fec2e3e628c92abfb716 Binary files /dev/null and b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/locale/zh_TW/LC_MESSAGES/xz.mo differ diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzcat.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzcat.1 new file mode 100644 index 0000000000000000000000000000000000000000..39e92ce91c266281499195e6ac04416517932d31 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzcat.1 @@ -0,0 +1,2117 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" German translation for xz-man. +.\" Mario Blättermann , 2015, 2019-2020, 2022-2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 "8. März 2025" Tukaani XZ\-Dienstprogramme +. +.SH BEZEICHNUNG +xz, unxz, xzcat, lzma, unlzma, lzcat \- .xz\- und .lzma\-Dateien komprimieren +oder dekomprimieren +. +.SH ÜBERSICHT +\fBxz\fP [\fIOption…\fP] [\fIDatei…\fP] +. +.SH BEFEHLSALIASE +\fBunxz\fP ist gleichbedeutend mit \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP ist gleichbedeutend mit \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP ist gleichbedeutend mit \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP ist gleichbedeutend mit \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP ist gleichbedeutend mit \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Wenn Sie Skripte schreiben, die Dateien dekomprimieren, sollten Sie stets +den Namen \fBxz\fP mit den entsprechenden Argumenten (\fBxz \-d\fP oder \fBxz \-dc\fP) +anstelle der Namen \fBunxz\fP und \fBxzcat\fP verwenden. +. +.SH BESCHREIBUNG +\fBxz\fP ist ein Allzweckwerkzeug zur Datenkompression, dessen +Befehlszeilensyntax denen von \fBgzip\fP(1) und \fBbzip2\fP(1) ähnelt. Das native +Dateiformat ist das \fB.xz\fP\-Format, aber das veraltete, von den +LZMA\-Dienstprogrammen verwendete Format sowie komprimierte Rohdatenströme +ohne Containerformat\-Header werden ebenfalls unterstützt. Außerdem wird die +Dekompression des von \fBlzip\fP verwendeten \fB.lz\fP\-Formats unterstützt. +.PP +\fBxz\fP komprimiert oder dekomprimiert jede \fIDatei\fP entsprechend des +gewählten Vorgangsmodus. Falls entweder \fB\-\fP oder keine Datei angegeben ist, +liest \fBxz\fP aus der Standardeingabe und leitet die verarbeiteten Dateien in +die Standardausgabe. Wenn die Standardausgabe kein Terminal ist, verweigert +\fBxz\fP das Schreiben komprimierter Daten in die Standardausgabe. Dabei wird +eine Fehlermeldung angezeigt und die \fIDatei\fP übersprungen. Ebenso +verweigert \fBxz\fP das Lesen komprimierter Daten aus der Standardeingabe, wenn +diese ein Terminal ist. +.PP +\fIDateien\fP, die nicht als \fB\-\fP angegeben sind, werden in eine neue Datei +geschrieben, deren Name aus dem Namen der Quell\-\fIDatei\fP abgeleitet wird +(außer wenn \fB\-\-stdout\fP angegeben ist): +.IP \(bu 3 +Bei der Kompression wird das Suffix des Formats der Zieldatei (\fB.xz\fP oder +\&\fB.lzma\fP) an den Namen der Quelldatei angehängt und so der Name der +Zieldatei gebildet. +.IP \(bu 3 +Bei der Dekompression wird das Suffix \fB.xz\fP, \fB.lzma\fP oder \fB.lz\fP vom +Dateinamen entfernt und so der Name der Zieldatei gebildet. Außerdem erkennt +\fBxz\fP die Suffixe \fB.txz\fP und \fB.tlz\fP und ersetzt diese durch \fB.tar\fP. +.PP +Wenn die Zieldatei bereits existiert, wird eine Fehlermeldung angezeigt und +die \fIDatei\fP übersprungen. +.PP +Außer beim Schreiben in die Standardausgabe zeigt \fBxz\fP eine Warnung an und +überspringt die \fIDatei\fP, wenn eine der folgenden Bedingungen zutreffend +ist: +.IP \(bu 3 +Die \fIDatei\fP ist keine reguläre Datei. Symbolischen Verknüpfungen wird nicht +gefolgt und diese daher nicht zu den regulären Dateien gezählt. +.IP \(bu 3 +Die \fIDatei\fP hat mehr als eine harte Verknüpfung. +.IP \(bu 3 +Für die \fIDatei\fP ist das »setuid«\-, »setgid«\- oder »sticky«\-Bit gesetzt. +.IP \(bu 3 +Der Aktionsmodus wird auf Kompression gesetzt und die \fIDatei\fP hat bereits +das Suffix des Zieldateiformats (\fB.xz\fP oder \fB.txz\fP beim Komprimieren in +das \fB.xz\fP\-Format und \fB.lzma\fP oder \fB.tlz\fP beim Komprimieren in das +\&\fB.lzma\fP\-Format). +.IP \(bu 3 +Der Aktionsmodus wird auf Dekompression gesetzt und die \fIDatei\fP hat nicht +das Suffix eines der unterstützten Zieldateiformate (\fB.xz\fP, \fB.txz\fP, +\&\fB.lzma\fP, \fB.tlz\fP oder \fB.lz\fP). +.PP +Nach erfolgreicher Kompression oder Dekompression der \fIDatei\fP kopiert \fBxz\fP +Eigentümer, Gruppe, Zugriffsrechte, Zugriffszeit und Änderungszeit aus der +Ursprungs\-\fIDatei\fP in die Zieldatei. Sollte das Kopieren der Gruppe +fehlschlagen, werden die Zugriffsrechte so angepasst, dass jenen Benutzern +der Zugriff auf die Zieldatei verwehrt bleibt, die auch keinen Zugriff auf +die Ursprungs\-\fIDatei\fP hatten. Das Kopieren anderer Metadaten wie +Zugriffssteuerlisten oder erweiterter Attribute wird von \fBxz\fP noch nicht +unterstützt. +.PP +Sobald die Zieldatei erfolgreich geschlossen wurde, wird die +Ursprungs\-\fIDatei\fP entfernt. Dies wird durch die Option \fB\-\-keep\fP +verhindert. Die Ursprungs\-\fIDatei\fP wird niemals entfernt, wenn die Ausgabe +in die Standardausgabe geschrieben wird oder falls ein Fehler auftritt. +.PP +Durch Senden der Signale \fBSIGINFO\fP oder \fBSIGUSR1\fP an den \fBxz\fP\-Prozess +werden Fortschrittsinformationen in den Fehlerkanal der Standardausgabe +geleitet. Dies ist nur eingeschränkt hilfreich, wenn die +Standardfehlerausgabe ein Terminal ist. Mittels \fB\-\-verbose\fP wird ein +automatisch aktualisierter Fortschrittsanzeiger angezeigt. +. +.SS Speicherbedarf +In Abhängigkeit von den gewählten Kompressionseinstellungen bewegt sich der +Speicherverbrauch zwischen wenigen hundert Kilobyte und mehreren +Gigabyte. Die Einstellungen bei der Kompression einer Datei bestimmen dabei +den Speicherbedarf bei der Dekompression. Die Dekompression benötigt +üblicherweise zwischen 5\ % und 20\ % des Speichers, der bei der Kompression +der Datei erforderlich war. Beispielsweise benötigt die Dekompression einer +Datei, die mit \fBxz \-9\fP komprimiert wurde, gegenwärtig etwa 65\ MiB +Speicher. Es ist jedoch auch möglich, dass \fB.xz\fP\-Dateien mehrere Gigabyte +an Speicher zur Dekompression erfordern. +.PP +Insbesondere für Benutzer älterer Systeme wird eventuell ein sehr großer +Speicherbedarf ärgerlich sein. Um unangenehme Überraschungen zu vermeiden, +verfügt \fBxz\fP über eine eingebaute Begrenzung des Speicherbedarfs, die +allerdings in der Voreinstellung deaktiviert ist. Zwar verfügen einige +Betriebssysteme über eingebaute Möglichkeiten zur prozessabhängigen +Speicherbegrenzung, doch diese sind zu unflexibel (zum Beispiel kann +\fBulimit\fP(1) beim Begrenzen des virtuellen Speichers \fBmmap\fP(2) +beeinträchtigen). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Die Begrenzung des Speicherbedarfs kann mit der Befehlszeilenoption +\fB\-\-memlimit=\fP\fIBegrenzung\fP aktiviert werden. Oft ist es jedoch bequemer, +die Begrenzung durch Setzen der Umgebungsvariable \fBXZ_DEFAULTS\fP +standardmäßig zu aktivieren, zum Beispiel +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Die Begrenzungen können getrennt für +Kompression und Dekompression mittels \fB\-\-memlimit\-compress=\fP\fIBegrenzung\fP +und \fB\-\-memlimit\-decompress=\fP\fIBegrenzung\fP festgelegt werden. Die Verwendung +einer solchen Option außerhalb der Variable \fBXZ_DEFAULTS\fP ist kaum +sinnvoll, da \fBxz\fP in einer einzelnen Aktion nicht gleichzeitig Kompression +und Dekompression ausführen kann und \fB\-\-memlimit=\fP\fIBegrenzung\fP (oder \fB\-M\fP +\fIBegrenzung\fP) lässt sich einfacher in der Befehlszeile eingeben. +.PP +Wenn die angegebene Speicherbegrenzung bei der Dekompression überschritten +wird, schlägt der Vorgang fehl und \fBxz\fP zeigt eine Fehlermeldung an. Wird +die Begrenzung bei der Kompression überschritten, dann versucht \fBxz\fP die +Einstellungen entsprechend anzupassen, außer wenn \fB\-\-format=raw\fP oder +\fB\-\-no\-adjust\fP angegeben ist. Auf diese Weise schlägt die Aktion nicht fehl, +es sei denn, die Begrenzung wurde sehr niedrig angesetzt. Die Anpassung der +Einstellungen wird schrittweise vorgenommen, allerdings entsprechen die +Schritte nicht den Voreinstellungen der Kompressionsstufen. Das bedeutet, +wenn beispielsweise die Begrenzung nur geringfügig unter den Anforderungen +für \fBxz \-9\fP liegt, werden auch die Einstellungen nur wenig angepasst und +nicht vollständig herunter zu den Werten für \fBxz \-8\fP +. +.SS "Verkettung und Auffüllung von .xz\-Dateien" +Es ist möglich, \fB.xz\fP\-Dateien direkt zu verketten. Solche Dateien werden +von \fBxz\fP genauso dekomprimiert wie eine einzelne \fB.xz\fP\-Datei. +.PP +Es ist weiterhin möglich, eine Auffüllung zwischen den verketteten Teilen +oder nach dem letzten Teil einzufügen. Die Auffüllung muss aus Null\-Bytes +bestehen und deren Größe muss ein Vielfaches von vier Byte sein. Dies kann +zum Beispiel dann vorteilhaft sein, wenn die \fB.xz\fP\-Datei auf einem +Datenträger gespeichert wird, dessen Dateisystem die Dateigrößen in +512\-Byte\-Blöcken speichert. +.PP +Verkettung und Auffüllung sind für \fB.lzma\fP\-Dateien oder Rohdatenströme +nicht erlaubt. +. +.SH OPTIONEN +. +.SS "Ganzzahlige Suffixe und spezielle Werte" +An den meisten Stellen, wo ein ganzzahliges Argument akzeptiert wird, kann +ein optionales Suffix große Ganzzahlwerte einfacher darstellen. Zwischen +Ganzzahl und dem Suffix dürfen sich keine Leerzeichen befinden. +.TP +\fBKiB\fP +multipliziert die Ganzzahl mit 1.024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP und +\fBKB\fP werden als Synonyme für \fBKiB\fP akzeptiert. +.TP +\fBMiB\fP +multipliziert die Ganzzahl mit 1.048.576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP und \fBMB\fP +werden als Synonyme für \fBMiB\fP akzeptiert. +.TP +\fBGiB\fP +multipliziert die Ganzzahl mit 1.073.741.824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP und +\fBGB\fP werden als Synonyme für \fBGiB\fP akzeptiert. +.PP +Der spezielle Wert \fBmax\fP kann dazu verwendet werden, um den von der +jeweiligen Option akzeptierten maximalen Ganzzahlwert anzugeben. +. +.SS Aktionsmodus +Falls mehrere Aktionsmodi angegeben sind, wird der zuletzt angegebene +verwendet. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Kompression. Dies ist der voreingestellte Aktionsmodus, sofern keiner +angegeben ist und auch kein bestimmter Modus aus dem Befehlsnamen abgeleitet +werden kann (der Befehl \fBunxz\fP impliziert zum Beispiel \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Nach erfolgreicher Kompression wird die Quelldatei gelöscht, außer wenn in +die Standardausgabe geschrieben wird oder \fB\-\-keep\fP angegeben wurde. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Dekomprimieren. Nach erfolgreicher Dekompression wird die Quelldatei +gelöscht, außer wenn in die Standardausgabe geschrieben wird oder \fB\-\-keep\fP +angegeben wurde. +.TP +\fB\-t\fP, \fB\-\-test\fP +prüft die Integrität der komprimierten \fIDateien\fP. Diese Option ist +gleichbedeutend mit \fB\-\-decompress \-\-stdout\fP, außer dass die dekomprimierten +Daten verworfen werden, anstatt sie in die Standardausgabe zu leiten. Es +werden keine Dateien erstellt oder entfernt. +.TP +\fB\-l\fP, \fB\-\-list\fP +gibt Informationen zu den komprimierten \fIDateien\fP aus. Es werden keine +unkomprimierten Dateien ausgegeben und keine Dateien angelegt oder +entfernt. Im Listenmodus kann das Programm keine komprimierten Daten aus der +Standardeingabe oder anderen nicht durchsuchbaren Quellen lesen. +.IP "" +Die Liste zeigt in der Standardeinstellung grundlegende Informationen zu den +\fIDateien\fP an, zeilenweise pro Datei. Detailliertere Informationen erhalten +Sie mit der Option \fB\-\-verbose\fP. Wenn Sie diese Option zweimal angeben, +werden noch ausführlichere Informationen ausgegeben. Das kann den Vorgang +allerdings deutlich verlangsamen, da die Ermittlung der zusätzlichen +Informationen zahlreiche Suchvorgänge erfordert. Die Breite der +ausführlichen Ausgabe übersteigt 80 Zeichen, daher könnte die Weiterleitung +in beispielsweise\& \fBless\ \-S\fP sinnvoll sein, falls das Terminal nicht +breit genug ist. +.IP "" +Die exakte Ausgabe kann in verschiedenen \fBxz\fP\-Versionen und +Spracheinstellungen unterschiedlich sein. Wenn eine maschinell auswertbare +Ausgabe gewünscht ist, dann sollten Sie \fB\-\-robot \-\-list\fP verwenden. +. +.SS Aktionsattribute +.TP +\fB\-k\fP, \fB\-\-keep\fP +verhindert das Löschen der Eingabedateien. +.IP "" +Seit der \fBxz\fP\-Version 5.2.6 wird die Kompression oder Dekompression auch +dann ausgeführt, wenn die Eingabe ein symbolischer Link zu einer regulären +Datei ist, mehr als einen harten Link hat oder das »setuid«\-, »setgid«\- oder +»sticky«\-Bit gesetzt ist. Die genannten Bits werden nicht in die Zieldatei +kopiert. In früheren Versionen geschah dies nur mit \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Diese Option hat verschiedene Auswirkungen: +.RS +.IP \(bu 3 +Wenn die Zieldatei bereits existiert, wird diese vor der Kompression oder +Dekompression gelöscht. +.IP \(bu 3 +Die Kompression oder Dekompression wird auch dann ausgeführt, wenn die +Eingabe ein symbolischer Link zu einer regulären Datei ist, mehr als einen +harten Link hat oder das »setuid«\-, »setgid«\- oder »sticky«\-Bit gesetzt +ist. Die genannten Bits werden nicht in die Zieldatei kopiert. +.IP \(bu 3 +Wenn es zusammen mit \fB\-\-decompress\fP und \fB\-\-stdout\fP verwendet wird und +\fBxz\fP den Typ der Quelldatei nicht ermitteln kann, wird die Quelldatei +unverändert in die Standardausgabe kopiert. Dadurch kann \fBxzcat\fP \fB\-\-force\fP +für Dateien, die nicht mit \fBxz\fP komprimiert wurden, wie \fBcat\fP(1) verwendet +werden. Zukünftig könnte \fBxz\fP neue Dateikompressionsformate unterstützen, +wodurch \fBxz\fP mehr Dateitypen dekomprimieren kann, anstatt sie unverändert +in die Standardausgabe zu kopieren. Mit der Option \fB\-\-format=\fP\fIFormat\fP +können Sie \fBxz\fP anweisen, nur ein einzelnes Dateiformat zu dekomprimieren. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +schreibt die komprimierten oder dekomprimierten Daten in die Standardausgabe +anstatt in eine Datei. Dies impliziert \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +dekomprimiert nur den ersten \fB.xz\fP\-Datenstrom und ignoriert stillschweigend +weitere Eingabedaten, die möglicherweise dem Datenstrom +folgen. Normalerweise führt solcher anhängender Datenmüll dazu, dass \fBxz\fP +eine Fehlermeldung ausgibt. +.IP "" +\fBxz\fP dekomprimiert niemals mehr als einen Datenstrom aus \fB.lzma\fP\-Dateien +oder Rohdatenströmen, aber dennoch wird durch diese Option möglicherweise +vorhandener Datenmüll nach der \fB.lzma\fP\-Datei oder dem Rohdatenstrom +ignoriert. +.IP "" +Diese Option ist wirkungslos, wenn der Aktionsmodus nicht \fB\-\-decompress\fP +oder \fB\-\-test\fP ist. +.IP "" +Seit der Programmversion \fBxz\fP 5.7.1alpha impliziert \fB\-\-single\-stream\fP +zusätzlich die Option \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +verhindert die Erzeugung von Sparse\-Dateien. In der Voreinstellung versucht +\fBxz\fP, bei der Dekompression in eine reguläre Datei eine Sparse\-Datei zu +erzeugen, wenn die dekomprimierten Daten lange Abfolgen von binären Nullen +enthalten. Dies funktioniert auch beim Schreiben in die Standardausgabe, +sofern diese in eine reguläre Datei weitergeleitet wird und bestimmte +Zusatzbedingungen erfüllt sind, die die Aktion absichern. Die Erzeugung von +Sparse\-Dateien kann Plattenplatz sparen und beschleunigt die Dekompression +durch Verringerung der Ein\-/Ausgaben der Platte. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +verwendet \fI.suf\fP bei der Dekompression anstelle von \fB.xz\fP oder \fB.lzma\fP +als Suffix für die Zieldatei. Falls nicht in die Standardausgabe geschrieben +wird und die Quelldatei bereits das Suffix \fI.suf\fP hat, wird eine Warnung +angezeigt und die Datei übersprungen. +.IP "" +berücksichtigt bei der Dekompression zusätzlich zu Dateien mit den Suffixen +\&\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP oder \fB.lz\fP auch jene mit dem Suffix +\&\fI.suf\fP. Falls die Quelldatei das Suffix \fI.suf\fP hat, wird dieses entfernt +und so der Name der Zieldatei abgeleitet. +.IP "" +Beim Komprimieren oder Dekomprimieren von Rohdatenströmen mit +\fB\-\-format=raw\fP muss das Suffix stets angegeben werden, außer wenn die +Ausgabe in die Standardausgabe erfolgt. Der Grund dafür ist, dass es kein +vorgegebenes Suffix für Rohdatenströme gibt. +.TP +\fB\-\-files\fP[\fB=\fP\fIDatei\fP] +liest die zu verarbeitenden Dateinamen aus \fIDatei\fP. Falls keine \fIDatei\fP +angegeben ist, werden die Dateinamen aus der Standardeingabe +gelesen. Dateinamen müssen mit einem Zeilenumbruch beendet werden. Ein +Bindestrich (\fB\-\fP) wird als regulärer Dateiname angesehen und nicht als +Standardeingabe interpretiert. Falls Dateinamen außerdem als +Befehlszeilenargumente angegeben sind, werden diese vor den Dateinamen aus +der \fIDatei\fP verarbeitet. +.TP +\fB\-\-files0\fP[\fB=\fP\fIDatei\fP] +Dies ist gleichbedeutend mit \fB\-\-files\fP[\fB=\fP\fIDatei\fP], außer dass jeder +Dateiname mit einem Null\-Zeichen abgeschlossen werden muss. +. +.SS "Grundlegende Dateiformat\- und Kompressionsoptionen" +.TP +\fB\-F\fP \fIFormat\fP, \fB\-\-format=\fP\fIFormat\fP +gibt das \fIFormat\fP der zu komprimierenden oder dekomprimierenden Datei an: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Dies ist die Voreinstellung. Bei der Kompression ist \fBauto\fP gleichbedeutend +mit \fBxz\fP. Bei der Dekompression wird das Format der Eingabedatei +automatisch erkannt. Beachten Sie, dass Rohdatenströme, wie sie mit +\fB\-\-format=raw\fP erzeugt werden, nicht automatisch erkannt werden können. +.TP +\fBxz\fP +Die Kompression erfolgt in das \fB.xz\fP\-Dateiformat oder akzeptiert nur +\&\fB.xz\fP\-Dateien bei der Dekompression. +.TP +\fBlzma\fP, \fBalone\fP +Die Kompression erfolgt in das veraltete \fB.lzma\fP\-Dateiformat oder +akzeptiert nur \fB.lzma\fP\-Dateien bei der Dekompression. Der alternative Name +\fBalone\fP dient der Abwärtskompatibilität zu den LZMA\-Dienstprogrammen. +.TP +\fBlzip\fP +Akzeptiert nur \fB.lz\fP\-Dateien bei der Dekompression. Kompression wird nicht +unterstützt. +.IP "" +The \fB.lz\fP format versions 0 and 1 are supported. Version 0 files were +produced by \fBlzip\fP 1.3 and older. Such files aren't common but may be +found from file archives as a few source packages were released in this +format. People might have old personal files in this format too. +Decompression support for the format version 0 was removed in \fBlzip\fP 1.18. +\fBlzip\fP 1.4 and later create files in the format version 1. +.TP +\fBraw\fP +Komprimiert oder dekomprimiert einen Rohdatenstrom (ohne Header). Diese +Option ist nur für fortgeschrittene Benutzer bestimmt. Zum Dekodieren von +Rohdatenströmen müssen Sie die Option \fB\-\-format=raw\fP verwenden und die +Filterkette ausdrücklich angeben, die normalerweise in den (hier fehlenden) +Container\-Headern gespeichert worden wäre. +.RE +.TP +\fB\-C\fP \fIPrüfung\fP, \fB\-\-check=\fP\fIPrüfung\fP +gibt den Typ der Integritätsprüfung an. Die Prüfsumme wird aus den +unkomprimierten Daten berechnet und in der \fB.xz\fP\-Datei gespeichert. Diese +Option wird nur bei der Kompression in das \fB.xz\fP\-Format angewendet, da das +\&\fB.lzma\fP\-Format keine Integritätsprüfungen unterstützt. Die eigentliche +Integritätsprüfung erfolgt (falls möglich), wenn die \fB.xz\fP\-Datei +dekomprimiert wird. +.IP "" +Folgende Typen von \fIPrüfungen\fP werden unterstützt: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +führt keine Integritätsprüfung aus. Dies ist eine eher schlechte +Idee. Dennoch kann es nützlich sein, wenn die Integrität der Daten auf +andere Weise sichergestellt werden kann. +.TP +\fBcrc32\fP +berechnet die CRC32\-Prüfsumme anhand des Polynoms aus IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +berechnet die CRC64\-Prüfsumme anhand des Polynoms aus ECMA\-182. Dies ist die +Voreinstellung, da beschädigte Dateien etwas besser als mit CRC32 erkannt +werden und die Geschwindigkeitsdifferenz unerheblich ist. +.TP +\fBsha256\fP +berechnet die SHA\-256\-Prüfsumme. Dies ist etwas langsamer als CRC32 und +CRC64. +.RE +.IP "" +Die Integrität der \fB.xz\fP\-Header wird immer mit CRC32 geprüft. Es ist nicht +möglich, dies zu ändern oder zu deaktivieren. +.TP +\fB\-\-ignore\-check\fP +verifiziert die Integritätsprüfsumme der komprimierten Daten bei der +Dekompression nicht. Die CRC32\-Werte in den \fB.xz\fP\-Headern werden weiterhin +normal verifiziert. +.IP "" +\fBVerwenden Sie diese Option nicht, außer Sie wissen, was Sie tun.\fP Mögliche +Gründe, diese Option zu verwenden: +.RS +.IP \(bu 3 +Versuchen, Daten aus einer beschädigten .xz\-Datei wiederherzustellen. +.IP \(bu 3 +Erhöhung der Geschwindigkeit bei der Dekompression. Dies macht sich meist +mit SHA\-256 bemerkbar, oder mit Dateien, die extrem stark komprimiert +sind. Wir empfehlen, diese Option nicht für diesen Zweck zu verwenden, es +sei denn, die Integrität der Datei wird extern auf andere Weise überprüft. +.RE +.TP +\fB\-0\fP … \fB\-9\fP +wählt eine der voreingestellten Kompressionsstufen, standardmäßig +\fB\-6\fP. Wenn mehrere Voreinstellungsstufen angegeben sind, ist nur die +zuletzt angegebene wirksam. Falls bereits eine benutzerdefinierte +Filterkette angegeben wurde, wird diese durch die Festlegung der +Voreinstellung geleert. +.IP "" +Die Unterschiede zwischen den Voreinstellungsstufen sind deutlicher als bei +\fBgzip\fP(1) und \fBbzip2\fP(1). Die gewählten Kompressionseinstellungen +bestimmen den Speicherbedarf bei der Dekompression, daher ist es auf älteren +Systemen mit wenig Speicher bei einer zu hoch gewählten Voreinstellung +schwer, eine Datei zu dekomprimieren. Insbesondere \fBist es keine gute Idee, blindlings \-9 für alles\fP zu verwenden, wie dies häufig mit \fBgzip\fP(1) und +\fBbzip2\fP(1) gehandhabt wird. +.RS +.TP +\fB\-0\fP … \fB\-3\fP +Diese Voreinstellungen sind recht schnell. \fB\-0\fP ist manchmal schneller als +\fBgzip \-9\fP, wobei aber die Kompression wesentlich besser ist. Die +schnelleren Voreinstellungen sind im Hinblick auf die Geschwindigkeit mit +\fBbzip2\fP(1) vergleichbar , mit einem ähnlichen oder besseren +Kompressionsverhältnis, wobei das Ergebnis aber stark vom Typ der zu +komprimierenden Daten abhängig ist. +.TP +\fB\-4\fP … \fB\-6\fP +Gute bis sehr gute Kompression, wobei der Speicherbedarf für die +Dekompression selbst auf alten Systemen akzeptabel ist. \fB\-6\fP ist die +Voreinstellung, welche üblicherweise eine gute Wahl für die Verteilung von +Dateien ist, die selbst noch auf Systemen mit nur 16\ MiB Arbeitsspeicher +dekomprimiert werden müssen (\fB\-5e\fP oder \fB\-6e\fP sind ebenfalls eine +Überlegung wert. Siehe \fB\-\-extreme\fP). +.TP +\fB\-7 … \-9\fP +Ähnlich wie \fB\-6\fP, aber mit einem höheren Speicherbedarf für die Kompression +und Dekompression. Sie sind nur nützlich, wenn Dateien komprimiert werden +sollen, die größer als 8\ MiB, 16\ MiB beziehungsweise 32\ MiB sind. +.RE +.IP "" +Auf der gleichen Hardware ist die Dekompressionsgeschwindigkeit ein nahezu +konstanter Wert in Bytes komprimierter Daten pro Sekunde. Anders +ausgedrückt: Je besser die Kompression, umso schneller wird üblicherweise +die Dekompression sein. Das bedeutet auch, dass die Menge der pro Sekunde +ausgegebenen unkomprimierten Daten stark variieren kann. +.IP "" +Die folgende Tabelle fasst die Eigenschaften der Voreinstellungen zusammen: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Voreinst.;Wörtb.Gr;KomprCPU;KompSpeich;DekompSpeich +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Spaltenbeschreibungen: +.RS +.IP \(bu 3 +Wörtb.Größe ist die Größe des LZMA2\-Wörterbuchs. Es ist +Speicherverschwendung, ein Wörterbuch zu verwenden, das größer als die +unkomprimierte Datei ist. Daher ist es besser, die Voreinstellungen \fB\-7\fP … +\fB\-9\fP zu vermeiden, falls es keinen wirklichen Bedarf dafür gibt. Mit \fB\-6\fP +und weniger wird üblicherweise so wenig Speicher verschwendet, dass dies +nicht ins Gewicht fällt. +.IP \(bu 3 +KomprCPU ist eine vereinfachte Repräsentation der LZMA2\-Einstellungen, +welche die Kompressionsgeschwindigkeit beeinflussen. Die Wörterbuchgröße +wirkt sich ebenfalls auf die Geschwindigkeit aus. Während KompCPU für die +Stufen \fB\-6\fP bis \fB\-9\fP gleich ist, tendieren höhere Stufen dazu, etwas +langsamer zu sein. Um eine noch langsamere, aber möglicherweise bessere +Kompression zu erhalten, siehe \fB\-\-extreme\fP. +.IP \(bu 3 +KompSpeich enthält den Speicherbedarf des Kompressors im +Einzel\-Thread\-Modus. Dieser kann zwischen den \fBxz\fP\-Versionen leicht +variieren. +.IP \(bu 3 +DekompSpeich enthält den Speicherbedarf für die Dekompression. Das bedeutet, +dass die Kompressionseinstellungen den Speicherbedarf bei der Dekompression +bestimmen. Der exakte Speicherbedarf bei der Dekompression ist geringfügig +größer als die Größe des LZMA2\-Wörterbuchs, aber die Werte in der Tabelle +wurden auf ganze MiB aufgerundet. +.RE +.IP "" + Der Speicherbedarf einiger der zukünftigen Multithread\-Modi kann dramatisch +höher sein als im Einzel\-Thread\-Modus. Mit dem Standardwert von +\fB\-\-block\-size\fP benötigt jeder Thread 3*3*Wörtb.Gr plus KompSpeich oder +DekompSpeich. Beispielsweise benötigen vier Threads mit der Voreinstellung +\fB\-6\fP etwa 660 bis 670 MiB Speicher. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +verwendet eine langsamere Variante der gewählten +Kompressions\-Voreinstellungsstufe (\fB\-0\fP … \fB\-9\fP), um hoffentlich ein etwas +besseres Kompressionsverhältnis zu erreichen, das aber in ungünstigen Fällen +auch schlechter werden kann. Der Speicherverbrauch bei der Dekompression +wird dabei nicht beeinflusst, aber der Speicherverbrauch der Kompression +steigt in den Voreinstellungsstufen \fB\-0\fP bis \fB\-3\fP geringfügig an. +.IP "" +Da es zwei Voreinstellungen mit den Wörterbuchgrößen 4\ MiB und 8\ MiB gibt, +verwenden die Voreinstellungsstufen \fB\-3e\fP und \fB\-5e\fP etwas schnellere +Einstellungen (niedrigere KompCPU) als \fB\-4e\fP beziehungsweise \fB\-6e\fP. Auf +diese Weise sind zwei Voreinstellungen nie identisch. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Voreinst.;Wörtb.Gr;KomprCPU;KompSpeich;DekompSpeich +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Zum Beispiel gibt es insgesamt vier Voreinstellungen, die ein 8\ MiB großes +Wörterbuch verwenden, deren Reihenfolge von der schnellsten zur langsamsten +\fB\-5\fP, \fB\-6\fP, \fB\-5e\fP und \fB\-6e\fP ist. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +sind etwas irreführende Aliase für \fB\-0\fP beziehungsweise \fB\-9\fP. Sie werden +nur zwecks Abwärtskompatibilität zu den LZMA\-Dienstprogrammen +bereitgestellt. Sie sollten diese Optionen besser nicht verwenden. +.TP +\fB\-\-block\-size=\fP\fIGröße\fP +teilt beim Komprimieren in das \fB.xz\fP\-Format die Eingabedaten in Blöcke der +angegebenen \fIGröße\fP in Byte. Die Blöcke werden unabhängig voneinander +komprimiert, was dem Multi\-Threading entgegen kommt und Zufallszugriffe bei +der Dekompression begrenzt. Diese Option wird typischerweise eingesetzt, um +die vorgegebene Blockgröße im Multi\-Thread\-Modus außer Kraft zu setzen, aber +sie kann auch im Einzel\-Thread\-Modus angewendet werden. +.IP "" +Im Multi\-Thread\-Modus wird etwa die dreifache \fIGröße\fP in jedem Thread zur +Pufferung der Ein\- und Ausgabe belegt. Die vorgegebene \fIGröße\fP ist das +Dreifache der Größe des LZMA2\-Wörterbuchs oder 1 MiB, je nachdem, was mehr +ist. Typischerweise ist das Zwei\- bis Vierfache der Größe des +LZMA2\-Wörterbuchs oder wenigstens 1 MB ein guter Wert. Eine \fIGröße\fP, die +geringer ist als die des LZMA2\-Wörterbuchs, ist Speicherverschwendung, weil +dann der LZMA2\-Wörterbuchpuffer niemals vollständig genutzt werden würde. Im +Multi\-Thread\-Modus wird die Größe der Blöcke wird in den Block\-Headern +gespeichert. Die Größeninformation wird für eine Multi\-Thread\-Dekompression +genutzt. +.IP "" +Im Einzel\-Thread\-Modus werden die Blöcke standardmäßig nicht geteilt. Das +Setzen dieser Option wirkt sich nicht auf den Speicherbedarf aus. In den +Block\-Headern werden keine Größeninformationen gespeichert, daher werden im +Einzel\-Thread\-Modus erzeugte Dateien nicht zu den im Multi\-Thread\-Modus +erzeugten Dateien identisch sein. Das Fehlen der Größeninformation bedingt +auch, dass \fBxz\fP nicht in der Lage sein wird, die Dateien im +Multi\-Thread\-Modus zu dekomprimieren. +.TP +\fB\-\-block\-list=\fP\fIBlöcke\fP +beginnt bei der Kompression in das \fB.xz\fP\-Format nach den angegebenen +Intervallen unkomprimierter Daten einen neuen Block, optional mit einer +benutzerdefinierten Filterkette. +.IP "" +Die \fIBlöcke\fP werden in einer durch Kommata getrennten Liste +angegeben. Jeder Block besteht aus einer optionalen Filterkettennummer +zwischen 0 und 9, gefolgt von einem Doppelpunkt (\fB:\fP) und der Größe der +unkomprimierten Daten (diese Angabe ist erforderlich). Überspringen eines +Blocks (zwei oder mehr aufeinander folgende Kommata) ist ein Kürzel dafür, +die Größe und die Filter des vorherigen Blocks zu verwenden. +.IP "" +Falls die Eingabedatei größer ist als die Summe der \fIBlöcke\fP, dann wird der +letzte in \fIVBlöcke\fP angegebene Wert bis zum Ende der Datei wiederholt. Mit +dem speziellen Wert \fB0\fP können Sie angeben, dass der Rest der Datei als +einzelner Block kodiert werden soll. +.IP "" +Eine alternative Filterkette für jeden Block kann in Kombination mit den +Optionen \fB\-\-filters1=\fP\fIFilter\fP \&…\& \fB\-\-filters9=\fP\fIFilter\fP angegeben +werden. Diese Optionen definieren Filterketten mit einem Bezeichner zwischen +1 und 9. Die Filterkette 0 bezeichnet hierbei die voreingestellte +Filterkette, was dem Nichtangeben einer Filterkette gleichkommt. Der +Filterkettenbezeichner kann vor der unkomprimierten Größe verwendet werden, +gefolgt von einem Doppelpunkt (\fB:\fP). Falls Sie beispielsweise +\fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP angeben, werden die Blöcke +folgendermaßen erstellt: +.RS +.IP \(bu 3 +Die durch \fB\-\-filters1\fP angegebene Filterkette und 2 MiB Eingabe +.IP \(bu 3 +Die durch \fB\-\-filters3\fP angegebene Filterkette und 2 MiB Eingabe +.IP \(bu 3 +Die durch \fB\-\-filters2\fP angegebene Filterkette und 4 MiB Eingabe +.IP \(bu 3 +Die durch \fB\-\-filters2\fP angegebene Filterkette und 4 MiB Eingabe +.IP \(bu 3 +Die vorgegebene Filterkette und 2 MiB Eingabe +.IP \(bu 3 +Die vorgegebene Filterkette und 4 MiB Eingabe für jeden Block bis zum Ende +der Eingabe. +.RE +.IP "" +Falls Sie eine Größe angeben, welche die Blockgröße des Encoders übersteigen +(entweder den Vorgabewert im Thread\-Modus oder den mit +\fB\-\-block\-size=\fP\fIGröße\fP angegebenen Wert), wird der Encoder zusätzliche +Blöcke erzeugen, wobei die in den \fIBlöcke\fP angegebenen Grenzen eingehalten +werden. Wenn Sie zum Beispiel \fB\-\-block\-size=10MiB\fP +\fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP angeben und die Eingabedatei 80 +MiB groß ist, erhalten Sie 11 Blöcke: 5, 10, 8, 10, 2, 10, 10, 4, 10, 10 und +1 MiB. +.IP "" +Im Multi\-Thread\-Modus werden die Blockgrößen in den Block\-Headern +gespeichert. Dies geschieht im Einzel\-Thread\-Modus nicht, daher wird die +kodierte Ausgabe zu der im Multi\-Thread\-Modus nicht identisch sein. +.TP +\fB\-\-flush\-timeout=\fP\fIZeit\fP +löscht bei der Kompression die ausstehenden Daten aus dem Encoder und macht +sie im Ausgabedatenstrom verfügbar, wenn mehr als die angegebene \fIZeit\fP in +Millisekunden (als positive Ganzzahl) seit dem vorherigen Löschen vergangen +ist und das Lesen weiterer Eingaben blockieren würde. Dies kann nützlich +sein, wenn \fBxz\fP zum Komprimieren von über das Netzwerk eingehenden Daten +verwendet wird. Kleine \fIZeit\fP\-Werte machen die Daten unmittelbar nach dem +Empfang nach einer kurzen Verzögerung verfügbar, während große \fIZeit\fP\-Werte +ein besseres Kompressionsverhältnis bewirken. +.IP "" +Dieses Funktionsmerkmal ist standardmäßig deaktiviert. Wenn diese Option +mehrfach angegeben wird, ist die zuletzt angegebene wirksam. Für die Angabe +der \fIZeit\fP kann der spezielle Wert \fB0\fP verwendet werden, um dieses +Funktionsmerkmal explizit zu deaktivieren. +.IP "" +Dieses Funktionsmerkmal ist außerhalb von POSIX\-Systemen nicht verfügbar. +.IP "" +.\" FIXME +\fBDieses Funktionsmerkmal ist noch experimentell.\fP Gegenwärtig ist \fBxz\fP +aufgrund der Art und Weise, wie \fBxz\fP puffert, für Dekompression in Echtzeit +ungeeignet. +.TP +\fB\-\-no\-sync\fP +synchronisiert die Zieldatei und deren Verzeichnis auf dem Speichergerät +nicht, bevor die Quelldatei gelöscht wird. So kann die Performance beim +Komprimieren oder Dekomprimieren vieler kleiner Dateien verbessert +werden. Jedoch wäre es möglich, falls es kurz nach dem Löschen zu einem +Systemabsturz kommt, dass die Zieldatei noch nicht auf dem Speichergerät +geschrieben, aber der Löschvorgang bereits ausgeführt wurde. In diesem Fall +gehen sowohl die Quelldatei als auch die Zieldatei verloren. +.IP "" +Diese Option ist nur wirksam, wenn \fBxz\fP die Quelldatei löscht. In anderen +Fällen wird niemals synchronisiert. +.IP "" +Die Synchronisierung und \fB\-\-no\-sync\fP wurden in Version \fBxz\fP 5.7.1alpha +hinzugefügt. +.TP +\fB\-\-memlimit\-compress=\fP\fIGrenze\fP +legt eine Grenze für die Speichernutzung bei der Kompression fest. Wenn +diese Option mehrmals angegeben wird, ist die zuletzt angegebene wirksam. +.IP "" +Falls die Kompressionseinstellungen die \fIGrenze\fP überschreiten, versucht +\fBxz\fP, die Einstellungen nach unten anzupassen, so dass die Grenze nicht +mehr überschritten wird und zeigt einen Hinweis an, dass eine automatische +Anpassung vorgenommen wurde. Die Anpassungen werden in folgender Reihenfolge +angewendet: Reduzierung der Anzahl der Threads, Wechsel in den +Einzelthread\-Modus, falls sogar ein einziger Thread im Multithread\-Modus die +\fIGrenze\fP überschreitet, und schlussendlich die Reduzierung der Größe des +LZMA2\-Wörterbuchs. +.IP "" +Beim Komprimieren mit \fB\-\-format=raw\fP oder falls \fB\-\-no\-adjust\fP angegeben +wurde, wird nur die Anzahl der Threads reduziert, da nur so die komprimierte +Ausgabe nicht beeinflusst wird. +.IP "" +Falls die \fIGrenze\fP nicht anhand der vorstehend beschriebenen Anpassungen +gesetzt werden kann, wird ein Fehler angezeigt und \fBxz\fP wird mit dem +Exit\-Status 1 beendet. +.IP "" +Die \fIGrenze\fP kann auf verschiedene Arten angegeben werden: +.RS +.IP \(bu 3 +Die \fIGrenze\fP kann ein absoluter Wert in Byte sein. Ein Suffix wie \fBMiB\fP +kann dabei hilfreich sein. Beispiel: \fB\-\-memlimit\-compress=80MiB\fP. +.IP \(bu 3 +Die \fIGrenze\fP kann als Prozentsatz des physischen Gesamtspeichers (RAM) +angegeben werden. Dies ist insbesondere nützlich, wenn in einem +Shell\-Initialisierungsskript, das mehrere unterschiedliche Rechner gemeinsam +verwenden, die Umgebungsvariable \fBXZ_DEFAULTS\fP gesetzt ist. Auf diese Weise +ist die Grenze auf Systemen mit mehr Speicher höher. Beispiel: +\fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +Mit \fB0\fP kann die \fIGrenze\fP auf den Standardwert zurückgesetzt werden. Dies +ist gegenwärtig gleichbedeutend mit dem Setzen der \fIGrenze\fP auf \fBmax\fP +(keine Speicherbegrenzung). +.RE +.IP "" +Für die 32\-Bit\-Version von \fBxz\fP gibt es einen Spezialfall: Falls die Grenze +über \fB4020\ MiB\fP liegt, wird die \fIGrenze\fP auf \fB4020\ MiB\fP gesetzt. Auf +MIPS32 wird stattdessen \fB2000\ MB\fP verwendet (die Werte \fB0\fP und \fBmax\fP +werden hiervon nicht beeinflusst; für die Dekompression gibt es keine +vergleichbare Funktion). Dies kann hilfreich sein, wenn ein +32\-Bit\-Executable auf einen 4\ GiB großen Adressraum (2 GiB auf MIPS32) +zugreifen kann, wobei wir hoffen wollen, dass es in anderen Situationen +keine negativen Effekte hat. +.IP "" +Siehe auch den Abschnitt \fBSpeicherbedarf\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIGrenze\fP +legt eine Begrenzung des Speicherverbrauchs für die Dekompression fest. Dies +beeinflusst auch den Modus \fB\-\-list\fP. Falls die Aktion nicht ausführbar ist, +ohne die \fIGrenze\fP zu überschreiten, gibt \fBxz\fP eine Fehlermeldung aus und +die Dekompression wird fehlschlagen. Siehe \fB\-\-memlimit\-compress=\fP\fIGrenze\fP +zu möglichen Wegen, die \fIGrenze\fP anzugeben. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIGrenze\fP +legt eine Begrenzung des Speicherverbrauchs für Multithread\-Dekompression +fest. Dies beeinflusst lediglich die Anzahl der Threads; \fBxz\fP wird dadurch +niemals die Dekompression einer Datei verweigern. Falls die \fIGrenze\fP für +jegliches Multithreading zu niedrig ist, wird sie ignoriert und \fBxz\fP setzt +im Einzelthread\-modus fort. Beachten Sie auch, dass bei der Verwendung von +\fB\-\-memlimit\-decompress\fP dies stets sowohl auf den Einzelthread\-als auch auf +den Multithread\-Modus angewendet wird und so die effektive \fIGrenze\fP für den +Multithread\-Modus niemals höher sein wird als die mit +\fB\-\-memlimit\-decompress\fP gesetzte Grenze. +.IP "" +Im Gegensatz zu anderen Optionen zur Begrenzung des Speicherverbrauchs hat +\fB\-\-memlimit\-mt\-decompress=\fP\fIGrenze\fP eine systemspezifisch vorgegebene +\fIGrenze\fP. Mit \fBxz \-\-info\-memory\fP können Sie deren aktuellen Wert anzeigen +lassen. +.IP "" +Diese Option und ihr Standardwert existieren, weil die unbegrenzte +threadbezogene Dekompression bei einigen Eingabedateien zu unglaublich +großem Speicherverbrauch führen würde. Falls die vorgegebene \fIGrenze\fP auf +Ihrem System zu niedrig ist, können Sie die \fIGrenze\fP durchaus erhöhen, aber +setzen Sie sie niemals auf einen Wert größer als die Menge des nutzbaren +Speichers, da \fBxz\fP bei entsprechenden Eingabedateien versuchen wird, diese +Menge an Speicher auch bei einer geringen Anzahl von Threads zu +verwnden. Speichermangel oder Auslagerung verbessern die +Dekomprimierungsleistung nicht. +.IP "" +Siehe \fB\-\-memlimit\-compress=\fP\fIGrenze\fP für mögliche Wege zur Angabe der +\fIGrenze\fP. Sezen der \fIGrenze\fP auf \fB0\fP setzt die \fIGrenze\fP auf den +vorgegebenen systemspezifischen Wert zurück. +.TP +\fB\-M\fP \fIGrenze\fP, \fB\-\-memlimit=\fP\fIGrenze\fP, \fB\-\-memory=\fP\fIGrenze\fP +Dies ist gleichbedeutend mit \fB\-\-memlimit\-compress=\fP\fIGrenze\fP +\fB\-\-memlimit\-decompress=\fP\fIGrenze\fP \fB\-\-memlimit\-mt\-decompress=\fP\fIGrenze\fP. +.TP +\fB\-\-no\-adjust\fP +zeigt einen Fehler an und beendet, falls die Grenze der Speichernutzung +nicht ohne Änderung der Einstellungen, welche die komprimierte Ausgabe +beeinflussen, berücksichtigt werden kann. Das bedeutet, dass \fBxz\fP daran +gehindert wird, den Encoder vom Multithread\-Modus in den Einzelthread\-Modus +zu versetzen und die Größe des LZMA2\-Wörterbuchs zu reduzieren. Allerdings +kann bei Verwendung dieser Option dennoch die Anzahl der Threads reduziert +werden, um die Grenze der Speichernutzung zu halten, sofern dies die +komprimierte Ausgabe nicht beeinflusst. +.IP "" +Die automatische Anpassung ist beim Erzeugen von Rohdatenströmen +(\fB\-\-format=raw\fP) immer deaktiviert. +.TP +\fB\-T\fP \fIThreads\fP, \fB\-\-threads=\fP\fIThreads\fP +gibt die Anzahl der zu verwendenden Arbeits\-Threads an. Wenn Sie \fIThreads\fP +auf einen speziellen Wert \fB0\fP setzen, verwendet \fBxz\fP maximal so viele +Threads, wie der/die Prozessor(en) im System untestützen. Die tatsächliche +Anzahl kann geringer sein als die angegebenen \fIThreads\fP, wenn die +Eingabedatei nicht groß genug für Threading mit den gegebenen Einstellungen +ist oder wenn mehr Threads die Speicherbegrenzung übersteigen würden. +.IP "" +Die Multithread\- bzw. Einzelthread\-Kompressoren erzeugen unterschiedliche +Ausgaben. Der Einzelthread\-Kompressor erzeugt die geringste Dateigröße, aber +nur die Ausgabe des Multithread\-Kompressors kann mit mehreren Threads wieder +dekomprimiert werden. Das Setzen der Anzahl der \fIThreads\fP auf \fB1\fP wird den +Einzelthread\-Modus verwenden. Das Setzen der Anzahl der \fIThreads\fP auf +einen anderen Wert einschließlich \fB0\fP verwendet den Multithread\-Kompressor, +und zwar sogar dann, wenn das System nur einen einzigen Hardware\-Thread +unterstützt (\fBxz\fP 5.2.x verwendete in diesem Fall noch den +Einzelthread\-Modus). +.IP "" +Um den Multithread\-Modus mit nur einem einzigen Thread zu verwenden, setzen +Sie die Anzahl der \fIThreads\fP auf \fB+1\fP. Das Präfix \fB+\fP hat mit Werten +verschieden von \fB1\fP keinen Effekt. Eine Begrenzung des Speicherverbrauchs +kann \fBxz\fP dennoch veranlassen, den Einzelthread\-Modus zu verwenden, außer +wenn \fB\-\-no\-adjust\fP verwendet wird. Die Unterstützung für das Präfix \fB+\fP +wurde in \fBxz\fP 5.4.0 hinzugefügt. +.IP "" +Falls das automatische Setzen der Anzahl der Threads angefordert und keine +Speicherbegrenzung angegeben wurde, dann wird eine systemspezifisch +vorgegebene weiche Grenze verwendet, um eventuell die Anzahl der Threads zu +begrenzen. Es ist eine weiche Grenze im Sinne davon, dass sie ignoriert +wird, falls die Anzahl der Threads 1 ist; daher wird eine weiche Grenze +\fBxz\fP niemals an der Kompression oder Dekompression hindern. Diese +vorgegebene weiche Grenze veranlasst \fBxz\fP nicht, vom Multithread\-Modus in +den Einzelthread\-Modus zu wechseln. Die aktiven Grenzen können Sie mit dem +Befehl \fBxz \-\-info\-memory\fP anzeigen lassen. +.IP "" +Die gegenwärtig einzige Threading\-Methode teilt die Eingabe in Blöcke und +komprimiert diese unabhängig voneinander. Die vorgegebene Blockgröße ist von +der Kompressionsstufe abhängig und kann mit der Option +\fB\-\-block\-size=\fP\fIGröße\fP außer Kraft gesetzt werden. +.IP "" +Eine thread\-basierte Dekompression wird nur bei Dateien funktionieren, die +mehrere Blöcke mit Größeninformationen in deren Headern enthalten. Alle im +Multi\-Thread\-Modus komprimierten Dateien, die groß genug sind, erfüllen +diese Bedingung, im Einzel\-Thread\-Modus komprimierte Dateien dagegen nicht, +selbst wenn \fB\-\-block\-size=\fP\fIGröße\fP verwendet wurde. +.IP "" +Der Vorgabewert für \fIThreads\fP is \fB0\fP. In \fBxz\fP 5.4.x und älteren Versionen +ist der Vorgabewert \fB1\fP. +. +.SS "Benutzerdefinierte Filterketten für die Kompression" +Eine benutzerdefinierte Filterkette ermöglicht die Angabe detaillierter +Kompressionseinstellungen, anstatt von den Voreinstellungen auszugehen. Wenn +eine benutzerdefinierte Filterkette angegeben wird, werden die vorher in der +Befehlszeile angegebenen Voreinstellungsoptionen (\fB\-0\fP … \fB\-9\fP und +\fB\-\-extreme\fP) außer Kraft gesetzt. Wenn eine Voreinstellungsoption nach +einer oder mehreren benutzerdefinierten Filterkettenoptionen angegeben wird, +dann wird die neue Voreinstellung wirksam und die zuvor angegebenen +Filterkettenoptionen werden außer Kraft gesetzt. +.PP +Eine Filterkette ist mit dem Piping (der Weiterleitung) in der Befehlszeile +vergleichbar. Bei der Kompression gelangt die unkomprimierte Eingabe in den +ersten Filter, dessen Ausgabe wiederum in den zweiten Filter geleitet wird +(sofern ein solcher vorhanden ist). Die Ausgabe des letzten Filters wird in +die komprimierte Datei geschrieben. In einer Filterkette sind maximal vier +Filter zulässig, aber typischerweise besteht eine Filterkette nur aus einem +oder zwei Filtern. +.PP +Bei vielen Filtern ist die Positionierung in der Filterkette eingeschränkt: +Einige Filter sind nur als letzte in der Kette verwendbar, einige können +nicht als letzte Filter gesetzt werden, und andere funktionieren an +beliebiger Stelle. Abhängig von dem Filter ist diese Beschränkung entweder +auf das Design des Filters selbst zurückzuführen oder ist aus +Sicherheitsgründen vorhanden. +.PP +Eine benutzerdefinierte Filterkette kann auf zwei verschiedene Arten +angegeben werden. Die Optionen \fB\-\-filters=\fP\fIFilter\fP und +\fB\-\-filters1=\fP\fIFilter\fP \&…\& \fB\-\-filters9=\fP\fIFilter\fP ermöglichen die Angabe +einer ganzen Filterkette in einer einzelnen Option gemäß der +Liblzma\-Filterzeichenkettensyntax. Alternativ können Sie eine Filterkette +mit einer oder mehreren individuellen Filteroptionen in der Reihenfolge +angeben, in der sie in der Filterkette verwendet werden sollen. Daher ist +die Reihenfolge der individuellen Filteroptionen wichtig! Beim Dekodieren +von Rohdatenströmen (\fB\-\-format=raw\fP) muss die Filterkette in der gleichen +Reihenfolge wie bei der Komprimierung angegeben werden. Alle individuellen +Filter\- oder Voreinstellungsoptionen, die \fIvor\fP der vollen +Filterkettenoption (\fB\-\-filters=\fP\fIFilter\fP) angegeben werden, werden +verworfen. Individuelle Filter, die \fInach\fP der vollen Filterkettenoption +angegeben werden, setzen die Filterkette zurück +.PP +Sowohl vollständige als auch individuelle Filteroptionen akzeptieren +filterspezifische \fIOptionen\fP in einer durch Kommata getrennten +Liste. Zusätzliche Kommata in den \fIOptionen\fP werden ignoriert. Jede Option +hat einen Standardwert, daher brauchen Sie nur jene anzugeben, die Sie +ändern wollen. +.PP +Um die gesamte Filterkette und die \fIOptionen\fP anzuzeigen, rufen Sie \fBxz \-vv\fP auf (was gleichbedeutend mit der zweimaligen Angabe von \fB\-\-verbose\fP +ist). Dies funktioniert auch zum Betrachten der von den Voreinstellungen +verwendeten Filterkettenoptionen. +.TP +\fB\-\-filters=\fP\fIFilter\fP +gibt die vollständige Filterkette oder eine Voreinstellung in einer +einzelnen Option an. Mehrere Filter können durch Leerzeichen oder zwei +Minuszeichen (\fB\-\-\fP) voneinander getrennt werden. Es kann notwendig sein, +die \fIFilter\fP in der Shell\-Befehlszeile zu maskieren, so dass diese als +einzelne Option ausgewertet werden. Um Optionen Werte zuzuordnen, verwenden +Sie \fB:\fP oder \fB=\fP. Einer Voreinstellung kann ein \fB\-\fP vorangestellt werden, +dem keiner oder mehrere Schalter folgen. Der einzige unterstützte Schalter +ist \fBe\fP zum Anwenden der gleichen Optionen wie \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIFilter\fP … \fB\-\-filters9\fP=\fIFilter\fP +gibt bis zu neun optionale Filterketten an, die mit \fB\-\-block\-list\fP +verwendet werden können. +.IP "" +Wenn Sie beispielsweise ein Archiv mit ausführbaren Dateien gefolgt von +Textdateien komprimieren, könnte der Teil mit den ausführbaren Dateien eine +Filterkette mit einem BCJ\-Filter und der Textdateiteil lediglich den +LZMA2\-Filter verwenden. +.TP +\fB\-\-filters\-help\fP +zeigt eine Hilfemeldung an, welche beschreibt, wie Voreinstellungen und +benutzerdefinierte Filterketten in den Optionen \fB\-\-filters\fP und +\fB\-\-filters1=\fP\fIFilter\fP \&… \& \fB\-\-filters9=\fP\fIFilter\fP angegeben werden und +beendet das Programm. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIOptionen\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIOptionen\fP] +.PD +fügt LZMA1\- oder LZMA2\-Filter zur Filterkette hinzu. Diese Filter können nur +als letzte Filter in der Kette verwendet werden. +.IP "" +LZMA1 ist ein veralteter Filter, welcher nur wegen des veralteten +\&\fB.lzma\fP\-Dateiformats unterstützt wird, welches nur LZMA1 unterstützt. LZMA2 +ist eine aktualisierte Version von LZMA1, welche einige praktische Probleme +von LZMA1 behebt. Das \fB.xz\fP\-Format verwendet LZMA2 und unterstützt LZMA1 +gar nicht. Kompressionsgeschwindigkeit und \-verhältnis sind bei LZMA1 und +LZMA2 praktisch gleich. +.IP "" +LZMA1 und LZMA2 haben die gleichen \fIOptionen\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIVoreinstellung\fP +setzt alle LZMA1\- oder LZMA2\-\fIOptionen\fP auf die \fIVoreinstellung\fP +zurück. Diese \fIVoreinstellung\fP wird in Form einer Ganzzahl angegeben, der +ein aus einem einzelnen Buchstaben bestehender Voreinstellungsmodifikator +folgen kann. Die Ganzzahl kann \fB0\fP bis \fB9\fP sein, entsprechend den +Befehlszeilenoptionen \fB\-0\fP … \fB\-9\fP. Gegenwärtig ist \fBe\fP der einzige +unterstützte Modifikator, was \fB\-\-extreme\fP entspricht. Wenn keine +\fBVoreinstellung\fP angegeben ist, werden die Standardwerte der LZMA1\- oder +LZMA2\-\fIOptionen\fP der Voreinstellung \fB6\fP entnommen. +.TP +\fBdict=\fP\fIGröße\fP +Die \fIGröße\fP des Wörterbuchs (Chronikpuffers) gibt an, wie viel Byte der +kürzlich verarbeiteten unkomprimierten Daten im Speicher behalten werden +sollen. Der Algorithmus versucht, sich wiederholende Byte\-Abfolgen +(Übereinstimmungen) in den unkomprimierten Daten zu finden und diese durch +Referenzen zu den Daten zu ersetzen, die sich gegenwärtig im Wörterbuch +befinden. Je größer das Wörterbuch, umso größer ist die Chance, eine +Übereinstimmung zu finden. Daher bewirkt eine Erhöhung der \fIGröße\fP des +Wörterbuchs üblicherweise ein besseres Kompressionsverhältnis, aber ein +Wörterbuch, das größer ist als die unkomprimierte Datei, wäre +Speicherverschwendung. +.IP "" +Typische Wörterbuch\-\fIGrößen\fP liegen im Bereich von 64\ KiB bis 64\ MiB. Das +Minimum ist 4\ KiB. Das Maximum für die Kompression ist gegenwärtig 1.5\ GiB +(1536\ MiB). Bei der Dekompression wird bereits eine Wörterbuchgröße bis zu +4\ GiB minus 1 Byte unterstützt, welche das Maximum für die LZMA1\- und +LZMA2\-Datenstromformate ist. +.IP "" +Die \fIGröße\fP des Wörterbuchs und der Übereinstimmungsfinder (\fIÜf\fP) +bestimmen zusammen den Speicherverbrauch des LZMA1\- oder +LZMA2\-Kodierers. Bei der Dekompression ist ein Wörterbuch der gleichen +\fIGröße\fP (oder ein noch größeres) wie bei der Kompression erforderlich, +daher wird der Speicherverbrauch des Dekoders durch die Größe des bei der +Kompression verwendeten Wörterbuchs bestimmt. Die \fB.xz\fP\-Header speichern +die \fIGröße\fP des Wörterbuchs entweder als 2^\fIn\fP oder 2^\fIn\fP + 2^(\fIn\fP\-1), +so dass diese \fIGrößen\fP für die Kompression etwas bevorzugt werden. Andere +\fIGrößen\fP werden beim Speichern in den \fB.xz\fP\-Headern aufgerundet. +.TP +\fBlc=\fP\fIlc\fP +gibt die Anzahl der literalen Kontextbits an. Das Minimum ist 0 und das +Maximum 4; der Standardwert ist 3. Außerdem darf die Summe von \fIlc\fP und +\fIlp\fP nicht größer als 4 sein. +.IP "" +Alle Bytes, die nicht als Übereinstimmungen kodiert werden können, werden +als Literale kodiert. Solche Literale sind einfache 8\-bit\-Bytes, die jeweils +für sich kodiert werden. +.IP "" +Bei der Literalkodierung wird angenommen, dass die höchsten \fIlc\fP\-Bits des +zuvor unkomprimierten Bytes mit dem nächsten Byte in Beziehung stehen. Zum +Beispiel folgt in typischen englischsprachigen Texten auf einen +Großbuchstaben ein Kleinbuchstabe und auf einen Kleinbuchstaben +üblicherweise wieder ein Kleinbuchstabe. Im US\-ASCII\-Zeichensatz sind die +höchsten drei Bits 010 für Großbuchstaben und 011 für Kleinbuchstaben. Wenn +\fIlc\fP mindestens 3 ist, kann die literale Kodierung diese Eigenschaft der +unkomprimierten Daten ausnutzen. +.IP "" +Der Vorgabewert (3) ist üblicherweise gut. Wenn Sie die maximale Kompression +erreichen wollen, versuchen Sie \fBlc=4\fP. Manchmal hilft es ein wenig, doch +manchmal verschlechtert es die Kompression. Im letzteren Fall versuchen Sie +zum Beispiel auch\& \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +gibt die Anzahl der literalen Positionsbits an. Das Minimum ist 0 und das +Maximum 4; die Vorgabe ist 0. +.IP "" +\fILp\fP beeinflusst, welche Art der Ausrichtung der unkomprimierten Daten beim +Kodieren von Literalen angenommen wird. Siehe \fIpb\fP weiter unten für weitere +Informationen zur Ausrichtung. +.TP +\fBpb=\fP\fIAnzahl\fP +legt die Anzahl der Positions\-Bits fest. Das Minimum ist 0 und das Maximum +4; Standard ist 2. +.IP "" +\fIPb\fP beeinflusst, welche Art der Ausrichtung der unkomprimierten Daten +generell angenommen wird. Standardmäßig wird eine Vier\-Byte\-Ausrichtung +angenommen (2^\fIpb\fP=2^2=4), was oft eine gute Wahl ist, wenn es keine +bessere Schätzung gibt. +.IP "" +Wenn die Ausrichtung bekannt ist, kann das entsprechende Setzen von \fIpb\fP +die Dateigröße ein wenig verringern. Wenn Textdateien zum Beispiel eine +Ein\-Byte\-Ausrichtung haben (US\-ASCII, ISO\-8859\-*, UTF\-8), kann das Setzen +von \fBpb=0\fP die Kompression etwas verbessern. Für UTF\-16\-Text ist \fBpb=1\fP +eine gute Wahl. Wenn die Ausrichtung eine ungerade Zahl wie beispielsweise 3 +Byte ist, könnte \fBpb=0\fP die beste Wahl sein. +.IP "" +Obwohl die angenommene Ausrichtung mit \fIpb\fP und \fIlp\fP angepasst werden +kann, bevorzugen LZMA1 und LZMA2 noch etwas die 16\-Byte\-Ausrichtung. Das +sollten Sie vielleicht beim Design von Dateiformaten berücksichtigen, die +wahrscheinlich oft mit LZMA1 oder LZMA2 komprimiert werden. +.TP +\fBmf=\fP\fIÜf\fP +Der Übereinstimmungsfinder hat einen großen Einfluss auf die Geschwindigkeit +des Kodierers, den Speicherbedarf und das +Kompressionsverhältnis. Üblicherweise sind auf Hash\-Ketten basierende +Übereinstimmungsfinder schneller als jene, die mit Binärbäumen arbeiten. Die +Vorgabe hängt von der \fIVoreinstellungsstufe\fP ab: 0 verwendet \fBhc3\fP, 1\-3 +verwenden \fBhc4\fP und der Rest verwendet \fBbt4\fP. +.IP "" +Die folgenden Übereinstimmungsfinder werden unterstützt. Die Formeln zur +Ermittlung des Speicherverbrauchs sind grobe Schätzungen, die der Realität +am nächsten kommen, wenn \fIWörterbuch\fP eine Zweierpotenz ist. +.RS +.TP +\fBhc3\fP +Hash\-Kette mit 2\- und 3\-Byte\-Hashing +.br +Minimalwert für \fInice\fP: 3 +.br +Speicherbedarf: +.br +\fIdict\fP * 7,5 (falls \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 5,5 + 64 MiB (falls \fIdict\fP > 16 MiB) +.TP +\fBhc4\fP +Hash\-Kette mit 2\-, 3\- und 4\-Byte\-Hashing +.br +Minimaler Wert für \fInice\fP: 4 +.br +Speicherbedarf: +.br +\fIdict\fP * 7,5 (falls \fIdict\fP <= 32 MiB ist); +.br +\fIdict\fP * 6,5 (falls \fIdict\fP > 32 MiB ist) +.TP +\fBbt2\fP +Binärbaum mit 2\-Byte\-Hashing +.br +Minimaler Wert für \fInice\fP: 2 +.br +Speicherverbrauch: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Binärbaum mit 2\- und 3\-Byte\-Hashing +.br +Minimalwert für \fInice\fP: 3 +.br +Speicherbedarf: +.br +\fIdict\fP * 11,5 (falls \fIdict\fP <= 16 MiB ist); +.br +\fIdict\fP * 9,5 + 64 MiB (falls \fIdict\fP > 16 MiB ist) +.TP +\fBbt4\fP +Binärbaum mit 2\-, 3\- und 4\-Byte\-Hashing +.br +Minimaler Wert für \fInice\fP: 4 +.br +Speicherbedarf: +.br +\fIdict\fP * 11,5 (falls \fIdict\fP <= 32 MiB ist); +.br +\fIdict\fP * 10,5 (falls \fIdict\fP > 32 MiB ist) +.RE +.TP +\fBmode=\fP\fIModus\fP +gibt die Methode zum Analysieren der vom Übereinstimmungsfinder gelieferten +Daten an. Als \fIModi\fP werden \fBfast\fP und \fBnormal\fP unterstützt. Die Vorgabe +ist \fBfast\fP für die \fIVoreinstellungsstufen\fP 0\-3 und \fBnormal\fP für die +\fIVoreinstellungsstufen\fP 4\-9. +.IP "" +Üblicherweise wird \fBfast\fP mit Hashketten\-basierten Übereinstimmungsfindern +und \fBnormal\fP mit Binärbaum\-basierten Übereinstimmungsfindern verwendet. So +machen es auch die \fIVoreinstellungsstufen\fP. +.TP +\fBnice=\fP\fInice\fP +gibt an, was als annehmbarer Wert für eine Übereinstimmung angesehen werden +kann. Wenn eine Übereinstimmung gefunden wird, die mindestens diesen +\fInice\fP\-Wert hat, sucht der Algorithmus nicht weiter nach besseren +Übereinstimmungen. +.IP "" +Der \fInice\fP\-Wert kann 2\-273 Byte sein. Höhere Werte tendieren zu einem +besseren Kompressionsverhältnis, aber auf Kosten der Geschwindigkeit. Die +Vorgabe hängt von der \fIVoreinstellungsstufe\fP ab. +.TP +\fBdepth=\fP\fITiefe\fP +legt die maximale Suchtiefe im Übereinstimmungsfinder fest. Vorgegeben ist +der spezielle Wert 0, der den Kompressor veranlasst, einen annehmbaren Wert +für \fITiefe\fP aus \fIÜf\fP und \fInice\fP\-Wert zu bestimmen. +.IP "" +Die angemessene \fITiefe\fP für Hash\-Ketten ist 4\-100 und 16\-1000 für +Binärbäume. Hohe Werte für die \fITiefe\fP können den Kodierer bei einigen +Dateien extrem verlangsamen. Vermeiden Sie es, die \fITiefe\fP über einen Wert +von 100 zu setzen, oder stellen Sie sich darauf ein, die Kompression +abzubrechen, wenn sie zu lange dauert. +.RE +.IP "" +Beim Dekodieren von Rohdatenströmen (\fB\-\-format=raw\fP) benötigt LZMA2 nur die +Wörterbuch\-\fIGröße\fP. LZMA1 benötigt außerdem \fIlc\fP, \fIlp\fP und \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIOptionen\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIOptionen\fP] +.PD +fügt ein »Branch/Call/Jump«\-(BCJ\-)Filter zur Filterkette hinzu. Diese Filter +können nicht als letzter Filter in der Filterkette verwendet werden. +.IP "" +Ein BCJ\-Filter wandelt relative Adressen im Maschinencode in deren absolute +Gegenstücke um. Die Datengröße wird dadurch nicht geändert, aber die +Redundanz erhöht, was LZMA2 dabei helfen kann, eine um 10 bis 15% kleinere +\&\fB.xz\fP\-Datei zu erstellen. Die BCJ\-Filter sind immer reversibel, daher +verursacht die Anwendung eines BCJ\-Filters auf den falschen Datentyp keinen +Datenverlust, wobei aber das Kompressionsverhältnis etwas schlechter werden +könnte. Die BCJ\-Filter sind sehr schnell und verbrauchen nur wenig mehr +Speicher. +.IP "" +Diese BCJ\-Filter haben bekannte Probleme mit dem Kompressionsverhältnis: +.RS +.IP \(bu 3 +In einigen Dateitypen, die ausführbaren Code enthalten (zum Beispiel +Objektdateien, statische Bibliotheken und Linux\-Kernelmodule), sind die +Adressen in den Anweisungen mit Füllwerten gefüllt. Diese BCJ\-Filter führen +dennoch die Adressumwandlung aus, wodurch die Kompression bei diesen Dateien +schlechter wird. +.IP \(bu 3 +Falls ein BCJ\-Filter auf ein Archiv angewendet wird, ist es möglich, dass +das Kompressionsverhältnis schlechter als ohne Filter wird. Falls es +beispielsweise ähnliche oder sogar identische ausführbare Dateien gibt, dann +werden diese durch die Filterung wahrscheinlich »unähnlicher« und +verschlechtern dadurch das Kompressionsverhältnis. Der Inhalt +nicht\-ausführbarer Dateien im gleichen Archiv kann sich ebenfalls darauf +auswirken. In der Praxis werden Sie durch Versuche mit oder ohne BCJ\-Filter +selbst herausfinden müssen, was situationsbezogen besser ist. +.RE +.IP "" +Verschiedene Befehlssätze haben unterschiedliche Ausrichtungen: Die +ausführbare Datei muss in den Eingabedateien einem Vielfachen dieses Wertes +entsprechen, damit dieser Filter funktioniert. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filter;Ausrichtung;Hinweise +x86;1;32\-Bit oder 64\-Bit x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096\-Byte\-Ausrichtung ist optimal +PowerPC;4;Nur Big Endian +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Da die BCJ\-gefilterten Daten üblicherweise mit LZMA2 komprimiert sind, kann +das Kompressionsverhältnis dadurch etwas verbessert werden, dass die +LZMA2\-Optionen so gesetzt werden, dass sie der Ausrichtung des gewählten +BCJ\-Filters entsprechen. Beispiele: +.RS +.IP \(bu 3 +Der IA\-64\-Filter hat eine 16\-Byte\-Ausrichtung, daher ist \fBpb=4,lp=4,lc=0\fP +für LZMA2 passend (2^4=16). +.IP \(bu 3 +RISC\-V\-Code hat eine 2\-Byte\- oder 4\-Byte\-Ausrichtung, abhängig davon, ob die +Datei 16\-bit\-komprimierte Instruktionen enthält (die C\-Erweiterung). Wenn +16\-bit\-Instruktionen verwendet werden, ist \fBpb=2,lp=1,lc=3\fP oder +\fBpb=1,lp=1,lc=3\fP passend. Wenn keine 16\-bit\-Instruktionen vorhanden sind, +ist \fBpb=2,lp=2,lc=2\fP am besten. Mit \fBreadelf \-h\fP können Sie überprüfen, ob +»RVC« in der »Flags«\-Zeile auftritt. +.IP \(bu 3 +ARM64 hat stets eine 4\-Byte\-Ausrichtung, daher ist \fBpb=2,lp=2,lc=2\fP am +besten. +.IP \(bu 3 +Der x86\-Filter stellt eine Ausnahme dar. Es ist üblicherweise eine gute +Wahl, bei den Voreinstellungen von LZMA2 (\fBpb=2,lp=0,lc=3\fP) zu bleiben, +wenn Sie ausführbare x86\-Dateien komprimieren +.RE +.IP "" +Alle BCJ\-Filter unterstützen die gleichen \fIOptionen\fP: +.RS +.TP +\fBstart=\fP\fIVersatz\fP +gibt den Start\-\fIVersatz\fP an, der bei der Umwandlung zwischen relativen und +absoluten Adressen verwendet wird. Der \fIVersatz\fP muss ein Vielfaches der +Filterausrichtung sein (siehe die Tabelle oben). Der Standardwert ist 0. In +der Praxis ist dieser Standardwert gut; die Angabe eines benutzerdefinierten +\fIVersatzes\fP ist fast immer unnütz. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIOptionen\fP] +fügt den Delta\-Filter zur Filterkette hinzu. Der Delta\-Filter kann nicht als +letzter Filter in der Filterkette verwendet werden. +.IP "" +Gegenwärtig wird nur eine einfache, Byte\-bezogene Delta\-Berechnung +unterstützt. Beim Komprimieren von zum Beispiel unkomprimierten +Bitmap\-Bildern oder unkomprimierten PCM\-Audiodaten kann es jedoch sinnvoll +sein. Dennoch können für spezielle Zwecke entworfene Algorithmen deutlich +bessere Ergebnisse als Delta und LZMA2 liefern. Dies trifft insbesondere auf +Audiodaten zu, die sich zum Beispiel mit \fBflac\fP(1) schneller und besser +komprimieren lassen. +.IP "" +Unterstützte \fIOptionen\fP: +.RS +.TP +\fBdist=\fP\fIAbstand\fP +gibt den \fIAbstand\fP der Delta\-Berechnung in Byte an. Zulässige Werte für den +\fIAbstand\fP sind 1 bis 256. Der Vorgabewert ist 1. +.IP "" +Zum Beispiel wird mit \fBdist=2\fP und der 8\-Byte\-Eingabe A1 B1 A2 B3 A3 B5 A4 +B7 die Ausgabe A1 B1 01 02 01 02 01 02 sein. +.RE +. +.SS "Andere Optionen" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +unterdrückt Warnungen und Hinweise. Geben Sie dies zweimal an, um auch +Fehlermeldungen zu unterdrücken. Diese Option wirkt sich nicht auf den +Exit\-Status aus. Das bedeutet, das selbst bei einer unterdrückten Warnung +der Exit\-Status zur Anzeige einer Warnung dennoch verwendet wird. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +bewirkt ausführliche Ausgaben. Wenn die Standardfehlerausgabe mit einem +Terminal verbunden ist, zeigt \fBxz\fP den Fortschritt an. Durch zweimalige +Angabe von \fB\-\-verbose\fP wird die Ausgabe noch ausführlicher. +.IP "" +Der Fortschrittsanzeiger stellt die folgenden Informationen dar: +.RS +.IP \(bu 3 +Der Prozentsatz des Fortschritts wird angezeigt, wenn die Größe der +Eingabedatei bekannt ist. Das bedeutet, dass der Prozentsatz in +Weiterleitungen (Pipes) nicht angezeigt werden kann. +.IP \(bu 3 +Menge der erzeugten komprimierten Daten (bei der Kompression) oder der +verarbeiteten Daten (bei der Dekompression). +.IP \(bu 3 +Menge der verarbeiteten unkomprimierten Daten (bei der Kompression) oder der +erzeugten Daten (bei der Dekompression). +.IP \(bu 3 +Kompressionsverhältnis, das mittels Dividieren der Menge der bisher +komprimierten Daten durch die Menge der bisher verarbeiteten unkomprimierten +Daten ermittelt wird. +.IP \(bu 3 +Kompressions\- oder Dekompressionsgeschwindigkeit. Diese wird anhand der +Menge der unkomprimierten verarbeiteten Daten (bei der Kompression) oder der +Menge der erzeugten Daten (bei der Dekompression) pro Sekunde gemessen. Die +Anzeige startet einige Sekunden nachdem \fBxz\fP mit der Verarbeitung der Datei +begonnen hat. +.IP \(bu 3 +Die vergangene Zeit im Format M:SS oder H:MM:SS. +.IP \(bu 3 +Die geschätzte verbleibende Zeit wird nur angezeigt, wenn die Größe der +Eingabedatei bekannt ist und bereits einige Sekunden vergangen sind, nachdem +\fBxz\fP mit der Verarbeitung der Datei begonnen hat. Die Zeit wird in einem +weniger präzisen Format ohne Doppelpunkte angezeigt, zum Beispiel 2 min 30 +s. +.RE +.IP "" +Wenn die Standardfehlerausgabe kein Terminal ist, schreibt \fBxz\fP mit +\fB\-\-verbose\fP nach dem Komprimieren oder Dekomprimieren der Datei in einer +einzelnen Zeile den Dateinamen, die komprimierte Größe, die unkomprimierte +Größe, das Kompressionsverhältnis und eventuell auch die Geschwindigkeit und +die vergangene Zeit in die Standardfehlerausgabe. Die Geschwindigkeit und +die vergangene Zeit werden nur angezeigt, wenn der Vorgang mindestens ein +paar Sekunden gedauert hat. Wurde der Vorgang nicht beendet, zum Beispiel +weil ihn der Benutzer abgebrochen hat, wird außerdem der Prozentsatz des +erreichten Verarbeitungsfortschritts aufgenommen, sofern die Größe der +Eingabedatei bekannt ist. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +setzt den Exit\-Status nicht auf 2, selbst wenn eine Bedingung erfüllt ist, +die eine Warnung gerechtfertigt hätte. Diese Option wirkt sich nicht auf die +Ausführlichkeitsstufe aus, daher müssen sowohl \fB\-\-quiet\fP als auch +\fB\-\-no\-warn\fP angegeben werden, um einerseits keine Warnungen anzuzeigen und +andererseits auch den Exit\-Status nicht zu ändern. +.TP +\fB\-\-robot\fP +gibt Meldungen in einem maschinenlesbaren Format aus. Dadurch soll das +Schreiben von Frontends erleichtert werden, die \fBxz\fP anstelle von Liblzma +verwenden wollen, was in verschiedenen Skripten der Fall sein kann. Die +Ausgabe mit dieser aktivierten Option sollte über mehrere +\fBxz\fP\-Veröffentlichungen stabil sein. Details hierzu finden Sie im Abschnitt +\fBROBOTER\-MODUS\fP. +.TP +\fB\-\-info\-memory\fP +zeigt in einem menschenlesbaren Format an, wieviel physischen Speicher (RAM) +und wie viele Prozessor\-Threads das System nach Annahme von \fBxz\fP hat, sowie +die Speicherbedarfsbegrenzung für Kompression und Dekompression, und beendet +das Programm erfolgreich. +.TP +\fB\-h\fP, \fB\-\-help\fP +zeigt eine Hilfemeldung mit den am häufigsten genutzten Optionen an und +beendet das Programm erfolgreich. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +zeigt eine Hilfemeldung an, die alle Funktionsmerkmale von \fBxz\fP beschreibt +und beendet das Programm erfolgreich. +.TP +\fB\-V\fP, \fB\-\-version\fP +zeigt die Versionsnummer von \fBxz\fP und Liblzma in einem menschenlesbaren +Format an. Um eine maschinell auswertbare Ausgabe zu erhalten, geben Sie +\fB\-\-robot\fP vor \fB\-\-version\fP an. +. +.SH ROBOTER\-MODUS +Der Roboter\-Modus wird mit der Option \fB\-\-robot\fP aktiviert. Er bewirkt, dass +die Ausgabe von \fBxz\fP leichter von anderen Programmen ausgewertet werden +kann. Gegenwärtig wird \fB\-\-robot\fP nur zusammen mit \fB\-\-list\fP, +\fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP und \fB\-\-version\fP unterstützt. In der +Zukunft wird dieser Modus auch für Kompression und Dekompression +unterstützt. +. +.SS Listenmodus +\fBxz \-\-robot \-\-list\fP verwendet eine durch Tabulatoren getrennte Ausgabe. In +der ersten Spalte jeder Zeile bezeichnet eine Zeichenkette den Typ der +Information, die in dieser Zeile enthalten ist: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Dies ist stets die erste Zeile, wenn eine Datei aufgelistet wird. Die zweite +Spalte in der Zeile enthält den Dateinamen. +.TP +\fBfile\fP +Diese Zeile enthält allgemeine Informationen zur \fB.xz\fP\-Datei. Diese Zeile +wird stets nach der \fBname\fP\-Zeile ausgegeben. +.TP +\fBstream\fP +Dieser Zeilentyp wird nur verwendet, wenn \fB\-\-verbose\fP angegeben wurde. Es +gibt genau so viele \fBstream\fP\-Zeilen, wie Datenströme in der \fB.xz\fP\-Datei +enthalten sind. +.TP +\fBblock\fP +Dieser Zeilentyp wird nur verwendet, wenn \fB\-\-verbose\fP angegeben wurde. Es +gibt so viele \fBblock\fP\-Zeilen, wie Blöcke in der \fB.xz\fP\-Datei. Die +\fBblock\fP\-Zeilen werden nach allen \fBstream\fP\-Zeilen angezeigt; verschiedene +Zeilentypen werden nicht verschachtelt. +.TP +\fBsummary\fP +Dieser Zeilentyp wird nur verwendet, wenn \fB\-\-verbose\fP zwei Mal angegeben +wurde. Diese Zeile wird nach allen \fBblock\fP\-Zeilen ausgegeben. Wie die +\fBfile\fP\-Zeile enthält die \fBsummary\fP\-Zeile allgemeine Informationen zur +\&\fB.xz\fP\-Datei. +.TP +\fBtotals\fP +Diese Zeile ist immer die letzte der Listenausgabe. Sie zeigt die +Gesamtanzahlen und \-größen an. +.PP +Die Spalten der \fBfile\fP\-Zeilen: +.PD 0 +.RS +.IP 2. 4 +Anzahl der Datenströme in der Datei +.IP 3. 4 +Gesamtanzahl der Blöcke in den Datenströmen +.IP 4. 4 +Komprimierte Größe der Datei +.IP 5. 4 +Unkomprimierte Größe der Datei +.IP 6. 4 +Das Kompressionsverhältnis, zum Beispiel \fB0.123\fP. Wenn das Verhältnis über +9.999 liegt, werden drei Minuszeichen (\fB\-\-\-\fP) anstelle des +Kompressionsverhältnisses angezeigt. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Durch Kommata getrennte Liste der Namen der Integritätsprüfungen. Für die +bekannten Überprüfungstypen werden folgende Zeichenketten verwendet: +\fBNone\fP, \fBCRC32\fP, \fBCRC64\fP und \fBSHA\-256\fP. \fBUnknown\-\fP\fIN\fP wird verwendet, +wobei \fIN\fP die Kennung der Überprüfung als Dezimalzahl angibt (ein\- oder +zweistellig). +.IP 8. 4 +Gesamtgröße der Datenstromauffüllung in der Datei +.RE +.PD +.PP +Die Spalten der \fBstream\fP\-Zeilen: +.PD 0 +.RS +.IP 2. 4 +Datenstromnummer (der erste Datenstrom ist 1) +.IP 3. 4 +Anzahl der Blöcke im Datenstrom +.IP 4. 4 +Komprimierte Startposition +.IP 5. 4 +Unkomprimierte Startposition +.IP 6. 4 +Komprimierte Größe (schließt die Datenstromauffüllung nicht mit ein) +.IP 7. 4 +Unkomprimierte Größe +.IP 8. 4 +Kompressionsverhältnis +.IP 9. 4 +Name der Integritätsprüfung +.IP 10. 4 +Größe der Datenstromauffüllung +.RE +.PD +.PP +Die Spalten der \fBblock\fP\-Zeilen: +.PD 0 +.RS +.IP 2. 4 +Anzahl der in diesem Block enthaltenen Datenströme +.IP 3. 4 +Blocknummer relativ zum Anfang des Datenstroms (der erste Block ist 1) +.IP 4. 4 +Blocknummer relativ zum Anfang der Datei +.IP 5. 4 +Komprimierter Startversatz relativ zum Beginn der Datei +.IP 6. 4 +Unkomprimierter Startversatz relativ zum Beginn der Datei +.IP 7. 4 +Komprimierte Gesamtgröße des Blocks (einschließlich Header) +.IP 8. 4 +Unkomprimierte Größe +.IP 9. 4 +Kompressionsverhältnis +.IP 10. 4 +Name der Integritätsprüfung +.RE +.PD +.PP +Wenn \fB\-\-verbose\fP zwei Mal angegeben wurde, werden zusätzliche Spalten in +die \fBblock\fP\-Zeilen eingefügt. Diese werden mit einem einfachen \fB\-\-verbose\fP +nicht angezeigt, da das Ermitteln dieser Informationen viele Suchvorgänge +erfordert und daher recht langsam sein kann: +.PD 0 +.RS +.IP 11. 4 +Wert der Integritätsprüfung in hexadezimaler Notation +.IP 12. 4 +Block\-Header\-Größe +.IP 13. 4 +Block\-Schalter: \fBc\fP gibt an, dass die komprimierte Größe verfügbar ist, und +\fBu\fP gibt an, dass die unkomprimierte Größe verfügbar ist. Falls der +Schalter nicht gesetzt ist, wird stattdessen ein Bindestrich (\fB\-\fP) +angezeigt, um die Länge der Zeichenkette beizubehalten. In Zukunft könnten +neue Schalter am Ende der Zeichenkette hinzugefügt werden. +.IP 14. 4 +Größe der tatsächlichen komprimierten Daten im Block. Ausgeschlossen sind +hierbei die Block\-Header, die Blockauffüllung und die Prüffelder. +.IP 15. 4 +Größe des Speichers (in Byte), der zum Dekomprimieren dieses Blocks mit +dieser \fBxz\fP\-Version benötigt wird. +.IP 16. 4 +Filterkette. Beachten Sie, dass die meisten der bei der Kompression +verwendeten Optionen nicht bekannt sein können, da in den \fB.xz\fP\-Headern nur +die für die Dekompression erforderlichen Optionen gespeichert sind. +.RE +.PD +.PP +Die Spalten der \fBsummary\fP\-Zeilen: +.PD 0 +.RS +.IP 2. 4 +Größe des Speichers (in Byte), der zum Dekomprimieren dieser Datei mit +dieser \fBxz\fP\-Version benötigt wird. +.IP 3. 4 +\fByes\fP oder \fBno\fP geben an, ob in allen Block\-Headern sowohl die +komprimierte als auch die unkomprimierte Größe gespeichert ist. +.PP +\fISeit\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Minimale \fBxz\fP\-Version, die zur Dekompression der Datei erforderlich ist +.RE +.PD +.PP +Die Spalten der \fBtotals\fP\-Zeile: +.PD 0 +.RS +.IP 2. 4 +Anzahl der Datenströme +.IP 3. 4 +Anzahl der Blöcke +.IP 4. 4 +Komprimierte Größe +.IP 5. 4 +Unkomprimierte Größe +.IP 6. 4 +Durchschnittliches Kompressionsverhältnis +.IP 7. 4 +Durch Kommata getrennte Liste der Namen der Integritätsprüfungen, die in den +Dateien präsent waren. +.IP 8. 4 +Größe der Datenstromauffüllung +.IP 9. 4 +Anzahl der Dateien. Dies dient dazu, die Reihenfolge der vorigen Spalten an +die in den \fBfile\fP\-Zeilen anzugleichen. +.PD +.RE +.PP +Wenn \fB\-\-verbose\fP zwei Mal angegeben wird, werden zusätzliche Spalten in die +\fBtotals\fP\-Zeile eingefügt: +.PD 0 +.RS +.IP 10. 4 +Maximale Größe des Speichers (in Byte), der zum Dekomprimieren der Dateien +mit dieser \fBxz\fP\-Version benötigt wird. +.IP 11. 4 +\fByes\fP oder \fBno\fP geben an, ob in allen Block\-Headern sowohl die +komprimierte als auch die unkomprimierte Größe gespeichert ist. +.PP +\fISeit\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Minimale \fBxz\fP\-Version, die zur Dekompression der Datei erforderlich ist +.RE +.PD +.PP +Zukünftige Versionen könnten neue Zeilentypen hinzufügen, weiterhin könnten +auch in den vorhandenen Zeilentypen weitere Spalten hinzugefügt werden, aber +die existierenden Spalten werden nicht geändert. +. +.SS Filterhilfe +\fBxz \-\-robot \-\-filters\-help\fP gibt die unterstützten Filter im folgenden +Format aus: +.PP +\fIFilter\fP\fB:\fP\fIOption\fP\fB=<\fP\fIWert\fP\fB>,\fP\fIOption\fP\fB=<\fP\fIWert\fP\fB>\fP +… +.TP +\fIFilter\fP +Name des Filters +.TP +\fIOption\fP +Name der filterspezifischen Option +.TP +\fIWert\fP +Der numerische \fIWert\fP erscheint als Bereich +\fB<\fP\fIMinimum\fP\fB\-\fP\fIMaximum\fP\fB>\fP. Die Auswahl des +Zeichenketten\-\fIWert\fPs wird in \fB< >\fP eingeschlossen und durch \fB|\fP +getrennt. +.PP +Jeder Filter wird in einer separaten Zeile ausgegeben. +. +.SS "Informationen zur Speicherbedarfsbegrenzung" +\fBxz \-\-robot \-\-info\-memory\fP gibt eine einzelne Zeile mit mehreren durch +Tabulatoren getrennten Spalten aus: +.IP 1. 4 +Gesamter physischer Speicher (RAM) in Byte. +.IP 2. 4 +Speicherbedarfsbegrenzung für die Kompression in Byte +(\fB\-\-memlimit\-compress\fP). Ein spezieller Wert von \fB0\fP bezeichnet die +Standardeinstellung, die im Einzelthread\-Modus bedeutet, dass keine +Begrenzung vorhanden ist. +.IP 3. 4 +Speicherbedarfsbegrenzung für die Dekompression in Byte +(\fB\-\-memlimit\-decompress\fP). Ein spezieller Wert von \fB0\fP bezeichnet die +Standardeinstellung, die im Einzelthread\-Modus bedeutet, dass keine +Begrenzung vorhanden ist. +.IP 4. 4 +Seit \fBxz\fP 5.3.4alpha: Die Speichernutzung für Multithread\-Dekompression in +Byte (\fB\-\-memlimit\-mt\-decompress\fP). Dies ist niemals \fB0\fP, da ein +systemspezifischer Vorgabewert (gezeigt in Spalte 5) verwendet wird, falls +keine Grenze ausdrücklich angegeben wurde. Dies ist außerdem niemals größer +als der Wert in in Spalte 3, selbst wenn mit \fB\-\-memlimit\-mt\-decompress\fP ein +größerer Wert angegeben wurde. +.IP 5. 4 +Seit \fBxz\fP 5.3.4alpha: Eine systemspezifisch vorgegebene Begrenzung des +Speicherverbrauchs, die zur Begrenzung der Anzahl der Threads beim +Komprimieren mit automatischer Anzahl der Threads (\fB\-\-threads=0\fP) und wenn +keine Speicherbedarfsbegrenzung angegeben wurde (\fB\-\-memlimit\-compress\fP) +verwendet wird. Dies wird auch als Standardwert für +\fB\-\-memlimit\-mt\-decompress\fP verwendet. +.IP 6. 4 +Seit \fBxz\fP 5.3.4alpha: Anzahl der verfügbaren Prozessorthreads. +.PP +In der Zukunft könnte die Ausgabe von \fBxz \-\-robot \-\-info\-memory\fP weitere +Spalten enthalten, aber niemals mehr als eine einzelne Zeile. +. +.SS Version +\fBxz \-\-robot \-\-version\fP gibt die Versionsnummern von \fBxz\fP und Liblzma im +folgenden Format aus: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Hauptversion. +.TP +\fIYYY\fP +Unterversion. Gerade Zahlen bezeichnen eine stabile Version. Ungerade Zahlen +bezeichnen Alpha\- oder Betaversionen. +.TP +\fIZZZ\fP +Patch\-Stufe für stabile Veröffentlichungen oder einfach nur ein Zähler für +Entwicklungsversionen. +.TP +\fIS\fP +Stabilität. 0 ist Alpha, 1 ist Beta und 2 ist stabil. \fIS\fP sollte immer 2 +sein, wenn \fIYYY\fP eine gerade Zahl ist. +.PP +\fIXYYYZZZS\fP sind in beiden Zeilen gleich, sofern \fBxz\fP und Liblzma aus der +gleichen Veröffentlichung der XZ\-Utils stammen. +.PP +Beispiele: 4.999.9beta ist \fB49990091\fP und 5.0.0 is \fB50000002\fP. +. +.SH EXIT\-STATUS +.TP +\fB0\fP +Alles ist in Ordnung. +.TP +\fB1\fP +Ein Fehler ist aufgetreten. +.TP +\fB2\fP +Es ist etwas passiert, das eine Warnung rechtfertigt, aber es sind keine +tatsächlichen Fehler aufgetreten. +.PP +In die Standardausgabe geschriebene Hinweise (keine Warnungen oder Fehler), +welche den Exit\-Status nicht beeinflussen. +. +.SH UMGEBUNGSVARIABLEN +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP wertet eine durch Leerzeichen getrennte Liste von Optionen in den +Umgebungsvariablen \fBXZ_DEFAULTS\fP und \fBXZ_OPT\fP aus (in dieser Reihenfolge), +bevor die Optionen aus der Befehlszeile ausgewertet werden. Beachten Sie, +dass beim Auswerten der Umgebungsvariablen nur Optionen berücksichtigt +werden; alle Einträge, die keine Optionen sind, werden stillschweigend +ignoriert. Die Auswertung erfolgt mit \fBgetopt_long\fP(3), welches auch für +die Befehlszeilenargumente verwendet wird. +.PP +\fBWarnung:\fP Durch Setzen dieser Umgebungsvariablen könnte man effektiv +Programme und Skripte modifizieren, die \fBxz\fP ausführen. Meist ist es +sicher, die Speichernutzungsbegrenzung und Kompressionsoptionen über die +Umgebungsvariablen zu setzen. Dennoch können einige Optionen Skripte +beeinflussen. Ein typisches Beispiel ist die Option \fB\-\-help\fP, die einen +Hilfetext anzeigt, anstatt eine Datei zu komprimieren oder zu +dekomprimieren. Weniger augenfällige Beispiele sind die Optionen \fB\-\-quiet\fP +und \fB\-\-verbose\fP. In vielen Fällen funktioniert es gut, den +Fortschrittsindikator mit \fB\-\-verbose\fP zu aktivieren, aber in einigen +Situationen können die zusätzlichen Meldungen Probleme verursachen. Die +Ausführlichkeitsstufe beeinflusst auch das Verhalten von \fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Benutzerspezifische oder systemweite Standardoptionen. Typischerweise werden +diese in einem Shell\-Initialisierungsskript gesetzt, um die +Speicherbedarfsbegrenzung von \fBxz\fP standardmäßig zu aktivieren oder die +Anzahl der Threads festzulegen. Außer bei Shell\-Initialisierungsskripten und +in ähnlichen Spezialfällen sollte die Variable \fBXZ_DEFAULTS\fP in Skripten +niemals gesetzt oder außer Kraft gesetzt werden. +.TP +\fBXZ_OPT\fP +Dies dient der Übergabe von Optionen an \fBxz\fP, wenn es nicht möglich ist, +die Optionen direkt in der Befehlszeile von \fBxz\fP zu übergeben. Dies ist der +Fall, wenn \fBxz\fP von einem Skript oder Dienstprogramm ausgeführt wird, zum +Beispiel GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Skripte können \fBXZ_OPT\fP zum Beispiel zum Setzen skriptspezifischer +Standard\-Kompressionsoptionen verwenden. Es ist weiterhin empfehlenswert, +Benutzern die Außerkraftsetzung von \fBXZ_OPT\fP zu erlauben, falls dies +angemessen ist. Zum Beispiel könnte in \fBsh\fP(1)\-Skripten Folgendes stehen: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "KOMPATIBILITÄT ZU DEN LZMA\-UTILS" +Die Befehlszeilensyntax von \fBxz\fP ist praktisch eine Obermenge der von +\fBlzma\fP, \fBunlzma\fP und \fBlzcat\fP in den LZMA\-Utils der Versionen 4.32.x. In +den meisten Fällen sollte es möglich sein, die LZMA\-Utils durch die XZ\-Utils +zu ersetzen, ohne vorhandene Skripte ändern zu müssen. Dennoch gibt es +einige Inkompatibilitäten, die manchmal Probleme verursachen können. +. +.SS "Voreinstellungsstufen zur Kompression" +Die Nummerierung der Voreinstellungsstufen der Kompression ist in \fBxz\fP und +den LZMA\-Utils unterschiedlich. Der wichtigste Unterschied ist die Zuweisung +der Wörterbuchgrößen zu den verschiedenen Voreinstellungsstufen. Die +Wörterbuchgröße ist etwa gleich dem Speicherbedarf bei der Dekompression. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Stufe;xz;LZMA\-Utils +\-0;256 KiB;nicht verfügbar +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Die Unterschiede in der Wörterbuchgröße beeinflussen auch den Speicherbedarf +bei der Kompression, aber es gibt noch einige andere Unterschiede zwischen +den LZMA\-Utils und den XZ\-Utils, die die Kluft noch vergrößern: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Stufe;xz;LZMA\-Utils 4.32.x +\-0;3 MiB;nicht verfügbar +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Die standardmäßige Voreinstellungsstufe in den LZMA\-Utils ist \fB\-7\fP, während +diese in den XZ\-Utils \fB\-6\fP ist, daher verwenden beide standardmäßig ein 8 +MiB großes Wörterbuch. +. +.SS "Vor\- und Nachteile von .lzma\-Dateien als Datenströme" +Die unkomprimierte Größe der Datei kann in den \fB.lzma\fP\-Headern gespeichert +werden. Die LZMA\-Utils tun das beim Komprimieren gewöhnlicher Dateien. Als +Alternative kann die unkomprimierte Größe als unbekannt markiert und eine +Nutzdatenende\-Markierung (end\-of\-payload) verwendet werden, um anzugeben, wo +der Dekompressor stoppen soll. Die LZMA\-Utils verwenden diese Methode, wenn +die unkomprimierte Größe unbekannt ist, was beispielsweise in Pipes +(Befehlsverkettungen) der Fall ist. +.PP +\fBxz\fP unterstützt die Dekompression von \fB.lzma\fP\-Dateien mit oder ohne +Nutzdatenende\-Markierung, aber alle von \fBxz\fP erstellten \fB.lzma\fP\-Dateien +verwenden diesen Nutzdatenende\-Markierung, wobei die unkomprimierte Größe in +den \fB.lzma\fP\-Headern als unbekannt markiert wird. Das könnte in einigen +unüblichen Situationen ein Problem sein. Zum Beispiel könnte ein +\&\fB.lzma\fP\-Dekompressor in einem Gerät mit eingebettetem System nur mit +Dateien funktionieren, deren unkomprimierte Größe bekannt ist. Falls Sie auf +dieses Problem stoßen, müssen Sie die LZMA\-Utils oder das LZMA\-SDK +verwenden, um \fB.lzma\fP\-Dateien mit bekannter unkomprimierter Größe zu +erzeugen. +. +.SS "Nicht unterstützte .lzma\-Dateien" +Das \fB.lzma\fP\-Format erlaubt \fIlc\fP\-Werte bis zu 8 und \fIlp\fP\-Werte bis zu +4. Die LZMA\-Utils können Dateien mit beliebigem \fIlc\fP und \fIlp\fP +dekomprimieren, aber erzeugen immer Dateien mit \fBlc=3\fP und \fBlp=0\fP. Das +Erzeugen von Dateien mit anderem \fIlc\fP und \fIlp\fP ist mit \fBxz\fP und mit dem +LZMA\-SDK möglich. +.PP +Die Implementation des LZMA\-Filters in liblzma setzt voraus, dass die Summe +von \fIlc\fP und \fIlp\fP nicht größer als 4 ist. Daher können \fB.lzma\fP\-Dateien, +welche diese Begrenzung überschreiten, mit \fBxz\fP nicht dekomprimiert werden. +.PP +Die LZMA\-Utils erzeugen nur \fB.lzma\fP\-Dateien mit einer Wörterbuchgröße von +2^\fIn\fP (einer Zweierpotenz), aber akzeptieren Dateien mit einer beliebigen +Wörterbuchgröße. Liblzma akzeptiert nur \fB.lzma\fP\-Dateien mit einer +Wörterbuchgröße von 2^\fIn\fP oder 2^\fIn\fP + 2^(\fIn\fP\-1). Dies dient zum +Verringern von Fehlalarmen beim Erkennen von \fB.lzma\fP\-Dateien. +.PP +Diese Einschränkungen sollten in der Praxis kein Problem sein, da praktisch +alle \fB.lzma\fP\-Dateien mit Einstellungen komprimiert wurden, die Liblzma +akzeptieren wird. +. +.SS "Angehängter Datenmüll" +Bei der Dekompression ignorieren die LZMA\-Utils stillschweigend alles nach +dem ersten \fB.lzma\fP\-Datenstrom. In den meisten Situationen ist das ein +Fehler. Das bedeutet auch, dass die LZMA\-Utils die Dekompression verketteter +\&\fB.lzma\fP\-Dateien nicht unterstützen. +.PP +Wenn nach dem ersten \fB.lzma\fP\-Datenstrom Daten verbleiben, erachtet \fBxz\fP +die Datei als beschädigt, es sei denn, die Option \fB\-\-single\-stream\fP wurde +verwendet. Dies könnte die Ausführung von Skripten beeinflussen, die davon +ausgehen, dass angehängter Datenmüll ignoriert wird. +. +.SH ANMERKUNGEN +. +.SS "Die komprimierte Ausgabe kann variieren" +Die exakte komprimierte Ausgabe, die aus der gleichen unkomprimierten +Eingabedatei erzeugt wird, kann zwischen den Versionen der XZ\-Utils +unterschiedlich sein, selbst wenn die Kompressionsoptionen identisch +sind. Das kommt daher, weil der Kodierer verbessert worden sein könnte +(hinsichtlich schnellerer oder besserer Kompression), ohne das Dateiformat +zu beeinflussen. Die Ausgabe kann sogar zwischen verschiedenen Programmen +der gleichen Version der XZ\-Utils variieren, wenn bei der Erstellung des +Binärprogramms unterschiedliche Optionen verwendet wurden. +.PP +Sobald \fB\-\-rsyncable\fP implementiert wurde, bedeutet das, dass die sich +ergebenden Dateien nicht notwendigerweise mit Rsync abgeglichen werden +können, außer wenn die alte und neue Datei mit der gleichen \fBxz\fP\-Version +erzeugt wurden. Das Problem kann beseitigt werden, wenn ein Teil der +Encoder\-Implementierung eingefroren wird, um die mit Rsync abgleichbare +Ausgabe über \fBxz\fP\-Versionsgrenzen hinweg stabil zu halten. +. +.SS "Eingebettete .xz\-Dekompressoren" +Eingebettete \fB.xz\fP\-Dekompressor\-Implementierungen wie XZ Embedded +unterstützen nicht unbedingt Dateien, die mit anderen Integritätsprüfungen +(\fIPrüfung\fP\-Typen) als \fBnone\fP und \fBcrc32\fP erzeugt wurden. Da +\fB\-\-check=crc64\fP die Voreinstellung ist, müssen Sie \fB\-\-check=none\fP oder +\fB\-\-check=crc32\fP verwenden, wenn Sie Dateien für eingebettete Systeme +erstellen. +.PP +Außerhalb eingebetteter Systeme unterstützen die Dekompressoren des +\&\fB.xz\fP\-Formats alle \fIPrüfung\fP\-Typen oder sind mindestens in der Lage, die +Datei zu dekomprimieren, ohne deren Integrität zu prüfen, wenn die bestimmte +\fIPrüfung\fP nicht verfügbar ist. +.PP +XZ Embedded unterstützt BCJ\-Filter, aber nur mit dem vorgegebenen +Startversatz. +. +.SH BEISPIELE +. +.SS Grundlagen +Komprimiert die Datei \fIfoo\fP mit der Standard\-Kompressionsstufe (\fB\-6\fP) zu +\fIfoo.xz\fP und entfernt \fIfoo\fP nach erfolgreicher Kompression: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +\fIbar.xz\fP in \fIbar\fP dekomprimieren und \fIbar.xz\fP selbst dann nicht löschen, +wenn die Dekompression erfolgreich war: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +\fIbaz.tar.xz\fP mit der Voreinstellung \fB\-4e\fP (\fB\-4 \-\-extreme\fP) erzeugen, was +langsamer ist als die Vorgabe \fB\-6\fP, aber weniger Speicher für Kompression +und Dekompression benötigt (48\ MiB beziehungsweise 5\ MiB): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Eine Mischung aus komprimierten und unkomprimierten Dateien kann mit einem +einzelnen Befehl dekomprimiert in die Standardausgabe geschrieben werden: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Parallele Kompression von vielen Dateien" +Auf GNU\- und *BSD\-Systemen können \fBfind\fP(1) und \fBxargs\fP(1) zum +Parallelisieren der Kompression vieler Dateien verwendet werden: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Die Option \fB\-P\fP von \fBxargs\fP(1) legt die Anzahl der parallelen +\fBxz\fP\-Prozesse fest. Der beste Wert für die Option \fB\-n\fP hängt davon ab, wie +viele Dateien komprimiert werden sollen. Wenn es sich nur um wenige Dateien +handelt, sollte der Wert wahrscheinlich 1 sein; bei Zehntausenden von +Dateien kann 100 oder noch mehr angemessener sein, um die Anzahl der +\fBxz\fP\-Prozesse zu beschränken, die \fBxargs\fP(1) schließlich erzeugen wird. +.PP +Die Option \fB\-T1\fP für \fBxz\fP dient dazu, den Einzelthread\-Modus zu erzwingen, +da \fBxargs\fP(1) zur Steuerung des Umfangs der Parallelisierung verwendet +wird. +. +.SS Roboter\-Modus +Berechnen, wie viel Byte nach der Kompression mehrerer Dateien insgesamt +eingespart wurden: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Ein Skript könnte abfragen wollen, ob es ein \fBxz\fP verwendet, das aktuell +genug ist. Das folgende \fBsh\fP(1)\-Skript prüft, ob die Versionsnummer des +Dienstprogramms \fBxz\fP mindestens 5.0.0 ist. Diese Methode ist zu alten +Beta\-Versionen kompatibel, welche die Option \fB\-\-robot\fP nicht unterstützen: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Ihre Version von Xz ist zu alt." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Eine Speicherbedarfsbegrenzung für die Dekompression mit \fBXZ_OPT\fP setzen, +aber eine bereits gesetzte Begrenzung nicht erhöhen: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Benutzerdefinierte Filterketten für die Kompression" +Der einfachste Anwendungsfall für benutzerdefinierte Filterketten ist die +Anpassung von LZMA2\-Voreinstellungsstufen. Das kann nützlich sein, weil die +Voreinstellungen nur einen Teil der potenziell sinnvollen Kombinationen aus +Kompressionseinstellungen abdecken. +.PP +Die KompCPU\-Spalten der Tabellen aus den Beschreibungen der Optionen \fB\-0\fP … +\fB\-9\fP und \fB\-\-extreme\fP sind beim Anpassen der LZMA2\-Voreinstellungen +nützlich. Diese sind die relevanten Teile aus diesen zwei Tabellen: +.RS +.PP +.TS +tab(;); +c c +n n. +Voreinst.;KomprCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Wenn Sie wissen, dass eine Datei für eine gute Kompression ein etwas +größeres Wörterbuch benötigt (zum Beispiel 32 MiB), aber Sie sie schneller +komprimieren wollen, als dies mit \fBxz \-8\fP geschehen würde, kann eine +Voreinstellung mit einem niedrigen KompCPU\-Wert (zum Beispiel 1) dahingehend +angepasst werden, ein größeres Wörterbuch zu verwenden: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Mit bestimmten Dateien kann der obige Befehl schneller sein als \fBxz \-6\fP, +wobei die Kompression deutlich besser wird. Dennoch muss betont werden, dass +nur wenige Dateien von einem größeren Wörterbuch profitieren, wenn der +KompCPU\-Wert niedrig bleibt. Der offensichtlichste Fall, in dem ein größeres +Wörterbuch sehr hilfreich sein kann, ist ein Archiv, das einander sehr +ähnliche Dateien enthält, die jeweils wenigstens einige Megabyte groß +sind. Das Wörterbuch muss dann deutlich größer sein als die einzelne Datei, +damit LZMA2 den größtmöglichen Vorteil aus den Ähnlichkeiten der aufeinander +folgenden Dateien zieht. +.PP +Wenn hoher Speicherbedarf für Kompression und Dekompression kein Problem ist +und die zu komprimierende Datei mindestens einige Hundert Megabyte groß ist, +kann es sinnvoll sein, ein noch größeres Wörterbuch zu verwenden, als die 64 +MiB, die mit \fBxz \-9\fP verwendet werden würden: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Die Verwendung von \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) wie im obigen Beispiel +kann nützlich sein, um den Speicherbedarf für Kompressor und Dekompressor zu +sehen. Denken Sie daran, dass ein Wörterbuch, das größer als die +unkomprimierte Datei ist, Speicherverschwendung wäre. Daher ist der obige +Befehl für kleine Dateien nicht sinnvoll. +.PP +Manchmal spielt die Kompressionszeit keine Rolle, aber der Speicherbedarf +bei der Dekompression muss gering gehalten werden, zum Beispiel um die Datei +auf eingebetteten Systemen dekomprimieren zu können. Der folgende Befehl +verwendet \fB\-6e\fP (\fB\-6 \-\-extreme\fP) als Basis und setzt die Wörterbuchgröße +auf nur 64\ KiB. Die sich ergebende Datei kann mit XZ Embedded (aus diesem +Grund ist dort \fB\-\-check=crc32\fP) mit nur etwa 100\ KiB Speicher +dekomprimiert werden. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Wenn Sie so viele Byte wie möglich herausquetschen wollen, kann die +Anpassung der Anzahl der literalen Kontextbits (\fIlc\fP) und der Anzahl der +Positionsbits (\fIpb\fP) manchmal hilfreich sein. Auch die Anpassung der Anzahl +der literalen Positionsbits (\fIlp\fP) könnte helfen, aber üblicherweise sind +\fIlc\fP und \fIpb\fP wichtiger. Wenn ein Quellcode\-Archiv zum Beispiel +hauptsächlich ASCII\-Text enthält, könnte ein Aufruf wie der folgende eine +etwas kleinere Datei (etwa 0,1\ %) ergeben als mit \fBxz \-6e\fP (versuchen Sie +es auch \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Die Verwendung eines anderen Filters mit LZMA2 kann die Kompression bei +verschiedenen Dateitypen verbessern. So könnten Sie eine gemeinsam genutzte +Bibliothek der Architekturen x86\-32 oder x86\-64 mit dem BCJ\-Filter für x86 +komprimieren: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Beachten Sie, dass die Reihenfolge der Filteroptionen von Bedeutung +ist. Falls \fB\-\-x86\fP nach \fB\-\-lzma2\fP angegeben wird, gibt \fBxz\fP einen Fehler +aus, weil nach LZMA2 kein weiterer Filter sein darf und auch weil der +BCJ\-Filter für x86 nicht als letzter Filter in der Filterkette gesetzt +werden darf. +.PP +Der Delta\-Filter zusammen mit LZMA2 kann bei Bitmap\-Bildern gute Ergebnisse +liefern. Er sollte üblicherweise besser sein als PNG, welches zwar einige +fortgeschrittene Filter als ein simples delta bietet, aber für die +eigentliche Kompression »Deflate« verwendet. +.PP +Das Bild muss in einem unkomprimierten Format gespeichert werden, zum +Beispiel als unkomprimiertes TIFF. Der Abstandsparameter des Delta\-Filters +muss so gesetzt werden, dass er der Anzahl der Bytes pro Pixel im Bild +entspricht. Zum Beispiel erfordert ein 24\-Bit\-RGB\-Bitmap \fBdist=3\fP, außerdem +ist es gut, \fBpb=0\fP an LZMA2 zu übergeben, um die 3\-Byte\-Ausrichtung zu +berücksichtigen: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Wenn sich mehrere Bilder in einem einzelnen Archiv befinden (zum Beispiel\& +\&\fB.tar\fP), funktioniert der Delta\-Filter damit auch, sofern alle Bilder im +Archiv die gleiche Anzahl Bytes pro Pixel haben. +. +.SH "SIEHE AUCH" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA\-SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzcmp.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzcmp.1 new file mode 100644 index 0000000000000000000000000000000000000000..2e879253737b4051db7cbc889cf8c5325acf9822 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzcmp.1 @@ -0,0 +1,59 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" German translation for xz-man. +.\" Mario Blättermann , 2015, 2019-2020, 2022-2025. +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 "6. März 2025" Tukaani XZ\-Dienstprogramme +.SH BEZEICHNUNG +xzcmp, xzdiff, lzcmp, lzdiff \- komprimierte Dateien vergleichen +. +.SH ÜBERSICHT +\fBxzcmp\fP [\fIOption …\fP] \fIDatei1\fP [\fIDatei2\fP] +.br +\fBxzdiff\fP \&… +.br +\fBlzcmp\fP \&… (VERALTET) +.br +\fBlzdiff\fP \&… (VERALTET) +. +.SH BESCHREIBUNG +\fBxzcmp\fP und \fBxzdiff\fP vergleichen den unkomprimierten Inhalt zweier +Dateien. Die unkomprimierten Daten und Optionen werden an \fBcmp\fP(1) oder +\fBdiff\fP(1) übergeben, sofern weder \fB\-\-help\fP noch \fB\-\-version\fP angegeben +wird. +.PP +Wenn sowohl \fIDatei1\fP als auch \fIDatei2\fP angegeben sind, können diese +unkomprimierte Dateien oder Dateien in Formaten sein, die \fBxz\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) oder \fBlz4\fP(1) +dekomprimieren können. Die erforderlichen Dekomprimierungsbefehle werden aus +den Dateiendungen von \fIDatei1\fP und \fIDatei2\fP abgeleitet. Für eine Datei mit +einer unbekannten Endung wird angenommen, dass sie entweder unkomprimiert +ist oder von \fBxz\fP(1) dekomprimiert werden kann. +.PP +Falls nur ein Dateiname angegeben wird, muss \fIDatei1\fP eine Endung eines +unterstützten Kompressionsformat haben und der Name von \fIDatei2\fP wird aus +\fIDatei1\fP abgeleitet, indem die Endung des Kompressionsformats entfernt +wird. +.PP +Die Befehle \fBlzcmp\fP und \fBlzdiff\fP dienen der Abwärtskompatibilität zu den +LZMA\-Dienstprogrammen. Sie werden als veraltet angesehen und werden in einer +zukünftigen Version entfernt. +. +.SH EXIT\-STATUS +Falls ein Dekompressionsfehler auftritt, ist der Exit\-Status +\fB2\fP. Anderenfalls wird der Exit\-Status von \fBcmp\fP(1) oder \fBdiff\fP(1) +verwendet. +. +.SH "SIEHE AUCH" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzdiff.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzdiff.1 new file mode 100644 index 0000000000000000000000000000000000000000..2e879253737b4051db7cbc889cf8c5325acf9822 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzdiff.1 @@ -0,0 +1,59 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" German translation for xz-man. +.\" Mario Blättermann , 2015, 2019-2020, 2022-2025. +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 "6. März 2025" Tukaani XZ\-Dienstprogramme +.SH BEZEICHNUNG +xzcmp, xzdiff, lzcmp, lzdiff \- komprimierte Dateien vergleichen +. +.SH ÜBERSICHT +\fBxzcmp\fP [\fIOption …\fP] \fIDatei1\fP [\fIDatei2\fP] +.br +\fBxzdiff\fP \&… +.br +\fBlzcmp\fP \&… (VERALTET) +.br +\fBlzdiff\fP \&… (VERALTET) +. +.SH BESCHREIBUNG +\fBxzcmp\fP und \fBxzdiff\fP vergleichen den unkomprimierten Inhalt zweier +Dateien. Die unkomprimierten Daten und Optionen werden an \fBcmp\fP(1) oder +\fBdiff\fP(1) übergeben, sofern weder \fB\-\-help\fP noch \fB\-\-version\fP angegeben +wird. +.PP +Wenn sowohl \fIDatei1\fP als auch \fIDatei2\fP angegeben sind, können diese +unkomprimierte Dateien oder Dateien in Formaten sein, die \fBxz\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) oder \fBlz4\fP(1) +dekomprimieren können. Die erforderlichen Dekomprimierungsbefehle werden aus +den Dateiendungen von \fIDatei1\fP und \fIDatei2\fP abgeleitet. Für eine Datei mit +einer unbekannten Endung wird angenommen, dass sie entweder unkomprimiert +ist oder von \fBxz\fP(1) dekomprimiert werden kann. +.PP +Falls nur ein Dateiname angegeben wird, muss \fIDatei1\fP eine Endung eines +unterstützten Kompressionsformat haben und der Name von \fIDatei2\fP wird aus +\fIDatei1\fP abgeleitet, indem die Endung des Kompressionsformats entfernt +wird. +.PP +Die Befehle \fBlzcmp\fP und \fBlzdiff\fP dienen der Abwärtskompatibilität zu den +LZMA\-Dienstprogrammen. Sie werden als veraltet angesehen und werden in einer +zukünftigen Version entfernt. +. +.SH EXIT\-STATUS +Falls ein Dekompressionsfehler auftritt, ist der Exit\-Status +\fB2\fP. Anderenfalls wird der Exit\-Status von \fBcmp\fP(1) oder \fBdiff\fP(1) +verwendet. +. +.SH "SIEHE AUCH" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzegrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzegrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..5b3f0617644885368b9bbb1c3ec5bf3e88a8c3de --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzegrep.1 @@ -0,0 +1,97 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" German translation for xz-man. +.\" Mario Blättermann , 2015, 2019-2020, 2022-2025. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 "6. März 2025" Tukaani XZ\-Dienstprogramme +.SH BEZEICHNUNG +xzgrep \- möglicherweise komprimierte Dateien nach Mustern durchsuchen +. +.SH ÜBERSICHT +\fBxzgrep\fP [\fIOption …\fP] [\fIMusterliste\fP] [\fIDatei …\fP] +.br +\fBxzegrep\fP … +.br +\fBxzfgrep\fP … +.br +\fBlzgrep\fP \&… (VERALTET) +.br +\fBlzegrep\fP \&… (VERALTET) +.br +\fBlzfgrep\fP \&… (VERALTET) +. +.SH BESCHREIBUNG +\fBxzgrep\fP ruft \fBgrep\fP(1) mit dem unkomprimierten Inhalt von Dateien +auf. Die Formate der \fIDateien\fP werden aus den Dateiendungen +abgeleitet. Jede \fIDatei\fP mit einer Endung, die von \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) oder \fBlz4\fP(1) unterstützt wird, wird +dekomprimiert; für andere Dateien wird angenommen, dass sie bereits in +unkomprimierter Form vorliegen. +.PP +Wenn keine \fIDateien\fP angegeben werden oder \fIDatei\fP als \fB\-\fP angegeben +wird, wird aus der Standardeingabe gelesen. Beim Lesen aus der +Standardeingabe werden nur die von \fBxz\fP(1) unterstützten Dateien +dekomprimiert. Für andere Dateien wird angenommen, dass sie bereits in +unkomprimierter Form vorliegen. +.PP +Die meisten \fIOptionen\fP von \fBgrep\fP(1) werden unterstützt, die folgenden +jedoch nicht: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIAktion\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIGlob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIGlob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIDatei\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIGlob\fP +.PP +\fBxzegrep\fP ist ein Alias für \fBxzgrep \-E\fP. \fBxzfgrep\fP ist ein Alias für +\fBxzgrep \-F\fP. +.PP +Die Befehle \fBlzgrep\fP, \fBlzegrep\fP und \fBlzfgrep\fP dienen der +Abwärtskompatibilität zu den LZMA\-Dienstprogrammen. Sie werden als veraltet +angesehen und werden in einer zukünftigen Version entfernt. +. +.SH EXIT\-STATUS +.TP +0 +In mindestens einer der Eingabedateien wurde mindestens ein Treffer +gefunden. Es sind keine Fehler aufgetreten. +.TP +1 +In keiner der Eingabedateien wurde ein Treffer gefunden. Es sind keine +Fehler aufgetreten. +.TP +>1 +Ein oder mehrere Fehler sind aufgetreten. Es ist unbekannt, ob Treffer +gefunden wurden. +. +.SH UMGEBUNGSVARIABLEN +.TP +\fBGREP\fP +Wenn die Umgebungsvariable \fBGREP\fP auf einen nicht\-leeren Wert gesetzt ist, +wird diese anstelle von \fBgrep\fP(1), \fBgrep \-E\fP oder \fBgrep \-F\fP verwendet. +. +.SH "SIEHE AUCH" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzfgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzfgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..5b3f0617644885368b9bbb1c3ec5bf3e88a8c3de --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzfgrep.1 @@ -0,0 +1,97 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" German translation for xz-man. +.\" Mario Blättermann , 2015, 2019-2020, 2022-2025. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 "6. März 2025" Tukaani XZ\-Dienstprogramme +.SH BEZEICHNUNG +xzgrep \- möglicherweise komprimierte Dateien nach Mustern durchsuchen +. +.SH ÜBERSICHT +\fBxzgrep\fP [\fIOption …\fP] [\fIMusterliste\fP] [\fIDatei …\fP] +.br +\fBxzegrep\fP … +.br +\fBxzfgrep\fP … +.br +\fBlzgrep\fP \&… (VERALTET) +.br +\fBlzegrep\fP \&… (VERALTET) +.br +\fBlzfgrep\fP \&… (VERALTET) +. +.SH BESCHREIBUNG +\fBxzgrep\fP ruft \fBgrep\fP(1) mit dem unkomprimierten Inhalt von Dateien +auf. Die Formate der \fIDateien\fP werden aus den Dateiendungen +abgeleitet. Jede \fIDatei\fP mit einer Endung, die von \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) oder \fBlz4\fP(1) unterstützt wird, wird +dekomprimiert; für andere Dateien wird angenommen, dass sie bereits in +unkomprimierter Form vorliegen. +.PP +Wenn keine \fIDateien\fP angegeben werden oder \fIDatei\fP als \fB\-\fP angegeben +wird, wird aus der Standardeingabe gelesen. Beim Lesen aus der +Standardeingabe werden nur die von \fBxz\fP(1) unterstützten Dateien +dekomprimiert. Für andere Dateien wird angenommen, dass sie bereits in +unkomprimierter Form vorliegen. +.PP +Die meisten \fIOptionen\fP von \fBgrep\fP(1) werden unterstützt, die folgenden +jedoch nicht: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIAktion\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIGlob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIGlob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIDatei\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIGlob\fP +.PP +\fBxzegrep\fP ist ein Alias für \fBxzgrep \-E\fP. \fBxzfgrep\fP ist ein Alias für +\fBxzgrep \-F\fP. +.PP +Die Befehle \fBlzgrep\fP, \fBlzegrep\fP und \fBlzfgrep\fP dienen der +Abwärtskompatibilität zu den LZMA\-Dienstprogrammen. Sie werden als veraltet +angesehen und werden in einer zukünftigen Version entfernt. +. +.SH EXIT\-STATUS +.TP +0 +In mindestens einer der Eingabedateien wurde mindestens ein Treffer +gefunden. Es sind keine Fehler aufgetreten. +.TP +1 +In keiner der Eingabedateien wurde ein Treffer gefunden. Es sind keine +Fehler aufgetreten. +.TP +>1 +Ein oder mehrere Fehler sind aufgetreten. Es ist unbekannt, ob Treffer +gefunden wurden. +. +.SH UMGEBUNGSVARIABLEN +.TP +\fBGREP\fP +Wenn die Umgebungsvariable \fBGREP\fP auf einen nicht\-leeren Wert gesetzt ist, +wird diese anstelle von \fBgrep\fP(1), \fBgrep \-E\fP oder \fBgrep \-F\fP verwendet. +. +.SH "SIEHE AUCH" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..5b3f0617644885368b9bbb1c3ec5bf3e88a8c3de --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzgrep.1 @@ -0,0 +1,97 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" German translation for xz-man. +.\" Mario Blättermann , 2015, 2019-2020, 2022-2025. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 "6. März 2025" Tukaani XZ\-Dienstprogramme +.SH BEZEICHNUNG +xzgrep \- möglicherweise komprimierte Dateien nach Mustern durchsuchen +. +.SH ÜBERSICHT +\fBxzgrep\fP [\fIOption …\fP] [\fIMusterliste\fP] [\fIDatei …\fP] +.br +\fBxzegrep\fP … +.br +\fBxzfgrep\fP … +.br +\fBlzgrep\fP \&… (VERALTET) +.br +\fBlzegrep\fP \&… (VERALTET) +.br +\fBlzfgrep\fP \&… (VERALTET) +. +.SH BESCHREIBUNG +\fBxzgrep\fP ruft \fBgrep\fP(1) mit dem unkomprimierten Inhalt von Dateien +auf. Die Formate der \fIDateien\fP werden aus den Dateiendungen +abgeleitet. Jede \fIDatei\fP mit einer Endung, die von \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) oder \fBlz4\fP(1) unterstützt wird, wird +dekomprimiert; für andere Dateien wird angenommen, dass sie bereits in +unkomprimierter Form vorliegen. +.PP +Wenn keine \fIDateien\fP angegeben werden oder \fIDatei\fP als \fB\-\fP angegeben +wird, wird aus der Standardeingabe gelesen. Beim Lesen aus der +Standardeingabe werden nur die von \fBxz\fP(1) unterstützten Dateien +dekomprimiert. Für andere Dateien wird angenommen, dass sie bereits in +unkomprimierter Form vorliegen. +.PP +Die meisten \fIOptionen\fP von \fBgrep\fP(1) werden unterstützt, die folgenden +jedoch nicht: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIAktion\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIGlob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIGlob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIDatei\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIGlob\fP +.PP +\fBxzegrep\fP ist ein Alias für \fBxzgrep \-E\fP. \fBxzfgrep\fP ist ein Alias für +\fBxzgrep \-F\fP. +.PP +Die Befehle \fBlzgrep\fP, \fBlzegrep\fP und \fBlzfgrep\fP dienen der +Abwärtskompatibilität zu den LZMA\-Dienstprogrammen. Sie werden als veraltet +angesehen und werden in einer zukünftigen Version entfernt. +. +.SH EXIT\-STATUS +.TP +0 +In mindestens einer der Eingabedateien wurde mindestens ein Treffer +gefunden. Es sind keine Fehler aufgetreten. +.TP +1 +In keiner der Eingabedateien wurde ein Treffer gefunden. Es sind keine +Fehler aufgetreten. +.TP +>1 +Ein oder mehrere Fehler sind aufgetreten. Es ist unbekannt, ob Treffer +gefunden wurden. +. +.SH UMGEBUNGSVARIABLEN +.TP +\fBGREP\fP +Wenn die Umgebungsvariable \fBGREP\fP auf einen nicht\-leeren Wert gesetzt ist, +wird diese anstelle von \fBgrep\fP(1), \fBgrep \-E\fP oder \fBgrep \-F\fP verwendet. +. +.SH "SIEHE AUCH" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzless.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzless.1 new file mode 100644 index 0000000000000000000000000000000000000000..5dbd5fc0776390efbe688cbaec6ac5aedf54c125 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzless.1 @@ -0,0 +1,50 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" German translation for xz-man. +.\" Mario Blättermann , 2015, 2019-2020, 2022-2025. +.\" +.\" (Note that this file is not based on gzip's zless.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZLESS 1 "6. März 2025" Tukaani XZ\-Dienstprogramme +.SH BEZEICHNUNG +xzless, lzless \- mit xz oder lzma komprimierte (Text\-)Dateien betrachten +.SH ÜBERSICHT +\fBxzless\fP [\fIDatei\fP …] +.br +\fBlzless\fP [\fIDatei\fP …] (VERALTET) +.SH BESCHREIBUNG +\fBxzless\fP ist ein Filter, der Text aus komprimierten Dateien in einem +Terminal anzeigt. Von \fBxz\fP(1) unterstützte Dateien werden dekomprimiert; +für andere Dateien wird angenommen, dass sie bereits in unkomprimierter Form +vorliegen. Wenn keine \fIDateien\fP angegeben werden, liest \fBxzless\fP aus der +Standardeingabe. +.PP +\fBxzless\fP verwendet \fBless\fP(1) zur Darstellung der Ausgabe. Im Gegensatz zu +\fBxzmore\fP können Sie das zu verwendende Textanzeigeprogramm nicht durch +Setzen einer Umgebungsvariable ändern. Die Befehle basieren auf \fBmore\fP(1) +und \fBvi\fP(1) und ermöglichen Vorwärts\- und Rückwärtssprünge sowie +Suchvorgänge. In der Handbuchseite zu \fBless\fP(1) finden Sie weitere +Informationen. +.PP +Der Befehl \fBlzless\fP dient der Abwärtskompatibilität zu den +LZMA\-Dienstprogrammen. Er wird als veraltet angesehen und wird in einer +zukünftigen Version entfernt. +.SH UMGEBUNGSVARIABLEN +.TP +\fBLESSMETACHARS\fP +Dies enthält eine Zeichenliste mit Bezug zur Shell. Wenn diese Variable +nicht bereits gesetzt ist, wird sie durch \fBxzless\fP gesetzt. +.TP +\fBLESSOPEN\fP +Dies ist auf die Befehlszeile zum Aufruf von \fBxz\fP(1) gesetzt, die zur +Vorverarbeitung der Eingabedateien für \fBless\fP(1) nötig ist. +.SH "SIEHE AUCH" +\fBless\fP(1), \fBxz\fP(1), \fBxzmore\fP(1), \fBzless\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzma.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzma.1 new file mode 100644 index 0000000000000000000000000000000000000000..39e92ce91c266281499195e6ac04416517932d31 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzma.1 @@ -0,0 +1,2117 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" German translation for xz-man. +.\" Mario Blättermann , 2015, 2019-2020, 2022-2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 "8. März 2025" Tukaani XZ\-Dienstprogramme +. +.SH BEZEICHNUNG +xz, unxz, xzcat, lzma, unlzma, lzcat \- .xz\- und .lzma\-Dateien komprimieren +oder dekomprimieren +. +.SH ÜBERSICHT +\fBxz\fP [\fIOption…\fP] [\fIDatei…\fP] +. +.SH BEFEHLSALIASE +\fBunxz\fP ist gleichbedeutend mit \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP ist gleichbedeutend mit \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP ist gleichbedeutend mit \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP ist gleichbedeutend mit \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP ist gleichbedeutend mit \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Wenn Sie Skripte schreiben, die Dateien dekomprimieren, sollten Sie stets +den Namen \fBxz\fP mit den entsprechenden Argumenten (\fBxz \-d\fP oder \fBxz \-dc\fP) +anstelle der Namen \fBunxz\fP und \fBxzcat\fP verwenden. +. +.SH BESCHREIBUNG +\fBxz\fP ist ein Allzweckwerkzeug zur Datenkompression, dessen +Befehlszeilensyntax denen von \fBgzip\fP(1) und \fBbzip2\fP(1) ähnelt. Das native +Dateiformat ist das \fB.xz\fP\-Format, aber das veraltete, von den +LZMA\-Dienstprogrammen verwendete Format sowie komprimierte Rohdatenströme +ohne Containerformat\-Header werden ebenfalls unterstützt. Außerdem wird die +Dekompression des von \fBlzip\fP verwendeten \fB.lz\fP\-Formats unterstützt. +.PP +\fBxz\fP komprimiert oder dekomprimiert jede \fIDatei\fP entsprechend des +gewählten Vorgangsmodus. Falls entweder \fB\-\fP oder keine Datei angegeben ist, +liest \fBxz\fP aus der Standardeingabe und leitet die verarbeiteten Dateien in +die Standardausgabe. Wenn die Standardausgabe kein Terminal ist, verweigert +\fBxz\fP das Schreiben komprimierter Daten in die Standardausgabe. Dabei wird +eine Fehlermeldung angezeigt und die \fIDatei\fP übersprungen. Ebenso +verweigert \fBxz\fP das Lesen komprimierter Daten aus der Standardeingabe, wenn +diese ein Terminal ist. +.PP +\fIDateien\fP, die nicht als \fB\-\fP angegeben sind, werden in eine neue Datei +geschrieben, deren Name aus dem Namen der Quell\-\fIDatei\fP abgeleitet wird +(außer wenn \fB\-\-stdout\fP angegeben ist): +.IP \(bu 3 +Bei der Kompression wird das Suffix des Formats der Zieldatei (\fB.xz\fP oder +\&\fB.lzma\fP) an den Namen der Quelldatei angehängt und so der Name der +Zieldatei gebildet. +.IP \(bu 3 +Bei der Dekompression wird das Suffix \fB.xz\fP, \fB.lzma\fP oder \fB.lz\fP vom +Dateinamen entfernt und so der Name der Zieldatei gebildet. Außerdem erkennt +\fBxz\fP die Suffixe \fB.txz\fP und \fB.tlz\fP und ersetzt diese durch \fB.tar\fP. +.PP +Wenn die Zieldatei bereits existiert, wird eine Fehlermeldung angezeigt und +die \fIDatei\fP übersprungen. +.PP +Außer beim Schreiben in die Standardausgabe zeigt \fBxz\fP eine Warnung an und +überspringt die \fIDatei\fP, wenn eine der folgenden Bedingungen zutreffend +ist: +.IP \(bu 3 +Die \fIDatei\fP ist keine reguläre Datei. Symbolischen Verknüpfungen wird nicht +gefolgt und diese daher nicht zu den regulären Dateien gezählt. +.IP \(bu 3 +Die \fIDatei\fP hat mehr als eine harte Verknüpfung. +.IP \(bu 3 +Für die \fIDatei\fP ist das »setuid«\-, »setgid«\- oder »sticky«\-Bit gesetzt. +.IP \(bu 3 +Der Aktionsmodus wird auf Kompression gesetzt und die \fIDatei\fP hat bereits +das Suffix des Zieldateiformats (\fB.xz\fP oder \fB.txz\fP beim Komprimieren in +das \fB.xz\fP\-Format und \fB.lzma\fP oder \fB.tlz\fP beim Komprimieren in das +\&\fB.lzma\fP\-Format). +.IP \(bu 3 +Der Aktionsmodus wird auf Dekompression gesetzt und die \fIDatei\fP hat nicht +das Suffix eines der unterstützten Zieldateiformate (\fB.xz\fP, \fB.txz\fP, +\&\fB.lzma\fP, \fB.tlz\fP oder \fB.lz\fP). +.PP +Nach erfolgreicher Kompression oder Dekompression der \fIDatei\fP kopiert \fBxz\fP +Eigentümer, Gruppe, Zugriffsrechte, Zugriffszeit und Änderungszeit aus der +Ursprungs\-\fIDatei\fP in die Zieldatei. Sollte das Kopieren der Gruppe +fehlschlagen, werden die Zugriffsrechte so angepasst, dass jenen Benutzern +der Zugriff auf die Zieldatei verwehrt bleibt, die auch keinen Zugriff auf +die Ursprungs\-\fIDatei\fP hatten. Das Kopieren anderer Metadaten wie +Zugriffssteuerlisten oder erweiterter Attribute wird von \fBxz\fP noch nicht +unterstützt. +.PP +Sobald die Zieldatei erfolgreich geschlossen wurde, wird die +Ursprungs\-\fIDatei\fP entfernt. Dies wird durch die Option \fB\-\-keep\fP +verhindert. Die Ursprungs\-\fIDatei\fP wird niemals entfernt, wenn die Ausgabe +in die Standardausgabe geschrieben wird oder falls ein Fehler auftritt. +.PP +Durch Senden der Signale \fBSIGINFO\fP oder \fBSIGUSR1\fP an den \fBxz\fP\-Prozess +werden Fortschrittsinformationen in den Fehlerkanal der Standardausgabe +geleitet. Dies ist nur eingeschränkt hilfreich, wenn die +Standardfehlerausgabe ein Terminal ist. Mittels \fB\-\-verbose\fP wird ein +automatisch aktualisierter Fortschrittsanzeiger angezeigt. +. +.SS Speicherbedarf +In Abhängigkeit von den gewählten Kompressionseinstellungen bewegt sich der +Speicherverbrauch zwischen wenigen hundert Kilobyte und mehreren +Gigabyte. Die Einstellungen bei der Kompression einer Datei bestimmen dabei +den Speicherbedarf bei der Dekompression. Die Dekompression benötigt +üblicherweise zwischen 5\ % und 20\ % des Speichers, der bei der Kompression +der Datei erforderlich war. Beispielsweise benötigt die Dekompression einer +Datei, die mit \fBxz \-9\fP komprimiert wurde, gegenwärtig etwa 65\ MiB +Speicher. Es ist jedoch auch möglich, dass \fB.xz\fP\-Dateien mehrere Gigabyte +an Speicher zur Dekompression erfordern. +.PP +Insbesondere für Benutzer älterer Systeme wird eventuell ein sehr großer +Speicherbedarf ärgerlich sein. Um unangenehme Überraschungen zu vermeiden, +verfügt \fBxz\fP über eine eingebaute Begrenzung des Speicherbedarfs, die +allerdings in der Voreinstellung deaktiviert ist. Zwar verfügen einige +Betriebssysteme über eingebaute Möglichkeiten zur prozessabhängigen +Speicherbegrenzung, doch diese sind zu unflexibel (zum Beispiel kann +\fBulimit\fP(1) beim Begrenzen des virtuellen Speichers \fBmmap\fP(2) +beeinträchtigen). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Die Begrenzung des Speicherbedarfs kann mit der Befehlszeilenoption +\fB\-\-memlimit=\fP\fIBegrenzung\fP aktiviert werden. Oft ist es jedoch bequemer, +die Begrenzung durch Setzen der Umgebungsvariable \fBXZ_DEFAULTS\fP +standardmäßig zu aktivieren, zum Beispiel +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Die Begrenzungen können getrennt für +Kompression und Dekompression mittels \fB\-\-memlimit\-compress=\fP\fIBegrenzung\fP +und \fB\-\-memlimit\-decompress=\fP\fIBegrenzung\fP festgelegt werden. Die Verwendung +einer solchen Option außerhalb der Variable \fBXZ_DEFAULTS\fP ist kaum +sinnvoll, da \fBxz\fP in einer einzelnen Aktion nicht gleichzeitig Kompression +und Dekompression ausführen kann und \fB\-\-memlimit=\fP\fIBegrenzung\fP (oder \fB\-M\fP +\fIBegrenzung\fP) lässt sich einfacher in der Befehlszeile eingeben. +.PP +Wenn die angegebene Speicherbegrenzung bei der Dekompression überschritten +wird, schlägt der Vorgang fehl und \fBxz\fP zeigt eine Fehlermeldung an. Wird +die Begrenzung bei der Kompression überschritten, dann versucht \fBxz\fP die +Einstellungen entsprechend anzupassen, außer wenn \fB\-\-format=raw\fP oder +\fB\-\-no\-adjust\fP angegeben ist. Auf diese Weise schlägt die Aktion nicht fehl, +es sei denn, die Begrenzung wurde sehr niedrig angesetzt. Die Anpassung der +Einstellungen wird schrittweise vorgenommen, allerdings entsprechen die +Schritte nicht den Voreinstellungen der Kompressionsstufen. Das bedeutet, +wenn beispielsweise die Begrenzung nur geringfügig unter den Anforderungen +für \fBxz \-9\fP liegt, werden auch die Einstellungen nur wenig angepasst und +nicht vollständig herunter zu den Werten für \fBxz \-8\fP +. +.SS "Verkettung und Auffüllung von .xz\-Dateien" +Es ist möglich, \fB.xz\fP\-Dateien direkt zu verketten. Solche Dateien werden +von \fBxz\fP genauso dekomprimiert wie eine einzelne \fB.xz\fP\-Datei. +.PP +Es ist weiterhin möglich, eine Auffüllung zwischen den verketteten Teilen +oder nach dem letzten Teil einzufügen. Die Auffüllung muss aus Null\-Bytes +bestehen und deren Größe muss ein Vielfaches von vier Byte sein. Dies kann +zum Beispiel dann vorteilhaft sein, wenn die \fB.xz\fP\-Datei auf einem +Datenträger gespeichert wird, dessen Dateisystem die Dateigrößen in +512\-Byte\-Blöcken speichert. +.PP +Verkettung und Auffüllung sind für \fB.lzma\fP\-Dateien oder Rohdatenströme +nicht erlaubt. +. +.SH OPTIONEN +. +.SS "Ganzzahlige Suffixe und spezielle Werte" +An den meisten Stellen, wo ein ganzzahliges Argument akzeptiert wird, kann +ein optionales Suffix große Ganzzahlwerte einfacher darstellen. Zwischen +Ganzzahl und dem Suffix dürfen sich keine Leerzeichen befinden. +.TP +\fBKiB\fP +multipliziert die Ganzzahl mit 1.024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP und +\fBKB\fP werden als Synonyme für \fBKiB\fP akzeptiert. +.TP +\fBMiB\fP +multipliziert die Ganzzahl mit 1.048.576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP und \fBMB\fP +werden als Synonyme für \fBMiB\fP akzeptiert. +.TP +\fBGiB\fP +multipliziert die Ganzzahl mit 1.073.741.824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP und +\fBGB\fP werden als Synonyme für \fBGiB\fP akzeptiert. +.PP +Der spezielle Wert \fBmax\fP kann dazu verwendet werden, um den von der +jeweiligen Option akzeptierten maximalen Ganzzahlwert anzugeben. +. +.SS Aktionsmodus +Falls mehrere Aktionsmodi angegeben sind, wird der zuletzt angegebene +verwendet. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Kompression. Dies ist der voreingestellte Aktionsmodus, sofern keiner +angegeben ist und auch kein bestimmter Modus aus dem Befehlsnamen abgeleitet +werden kann (der Befehl \fBunxz\fP impliziert zum Beispiel \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Nach erfolgreicher Kompression wird die Quelldatei gelöscht, außer wenn in +die Standardausgabe geschrieben wird oder \fB\-\-keep\fP angegeben wurde. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Dekomprimieren. Nach erfolgreicher Dekompression wird die Quelldatei +gelöscht, außer wenn in die Standardausgabe geschrieben wird oder \fB\-\-keep\fP +angegeben wurde. +.TP +\fB\-t\fP, \fB\-\-test\fP +prüft die Integrität der komprimierten \fIDateien\fP. Diese Option ist +gleichbedeutend mit \fB\-\-decompress \-\-stdout\fP, außer dass die dekomprimierten +Daten verworfen werden, anstatt sie in die Standardausgabe zu leiten. Es +werden keine Dateien erstellt oder entfernt. +.TP +\fB\-l\fP, \fB\-\-list\fP +gibt Informationen zu den komprimierten \fIDateien\fP aus. Es werden keine +unkomprimierten Dateien ausgegeben und keine Dateien angelegt oder +entfernt. Im Listenmodus kann das Programm keine komprimierten Daten aus der +Standardeingabe oder anderen nicht durchsuchbaren Quellen lesen. +.IP "" +Die Liste zeigt in der Standardeinstellung grundlegende Informationen zu den +\fIDateien\fP an, zeilenweise pro Datei. Detailliertere Informationen erhalten +Sie mit der Option \fB\-\-verbose\fP. Wenn Sie diese Option zweimal angeben, +werden noch ausführlichere Informationen ausgegeben. Das kann den Vorgang +allerdings deutlich verlangsamen, da die Ermittlung der zusätzlichen +Informationen zahlreiche Suchvorgänge erfordert. Die Breite der +ausführlichen Ausgabe übersteigt 80 Zeichen, daher könnte die Weiterleitung +in beispielsweise\& \fBless\ \-S\fP sinnvoll sein, falls das Terminal nicht +breit genug ist. +.IP "" +Die exakte Ausgabe kann in verschiedenen \fBxz\fP\-Versionen und +Spracheinstellungen unterschiedlich sein. Wenn eine maschinell auswertbare +Ausgabe gewünscht ist, dann sollten Sie \fB\-\-robot \-\-list\fP verwenden. +. +.SS Aktionsattribute +.TP +\fB\-k\fP, \fB\-\-keep\fP +verhindert das Löschen der Eingabedateien. +.IP "" +Seit der \fBxz\fP\-Version 5.2.6 wird die Kompression oder Dekompression auch +dann ausgeführt, wenn die Eingabe ein symbolischer Link zu einer regulären +Datei ist, mehr als einen harten Link hat oder das »setuid«\-, »setgid«\- oder +»sticky«\-Bit gesetzt ist. Die genannten Bits werden nicht in die Zieldatei +kopiert. In früheren Versionen geschah dies nur mit \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Diese Option hat verschiedene Auswirkungen: +.RS +.IP \(bu 3 +Wenn die Zieldatei bereits existiert, wird diese vor der Kompression oder +Dekompression gelöscht. +.IP \(bu 3 +Die Kompression oder Dekompression wird auch dann ausgeführt, wenn die +Eingabe ein symbolischer Link zu einer regulären Datei ist, mehr als einen +harten Link hat oder das »setuid«\-, »setgid«\- oder »sticky«\-Bit gesetzt +ist. Die genannten Bits werden nicht in die Zieldatei kopiert. +.IP \(bu 3 +Wenn es zusammen mit \fB\-\-decompress\fP und \fB\-\-stdout\fP verwendet wird und +\fBxz\fP den Typ der Quelldatei nicht ermitteln kann, wird die Quelldatei +unverändert in die Standardausgabe kopiert. Dadurch kann \fBxzcat\fP \fB\-\-force\fP +für Dateien, die nicht mit \fBxz\fP komprimiert wurden, wie \fBcat\fP(1) verwendet +werden. Zukünftig könnte \fBxz\fP neue Dateikompressionsformate unterstützen, +wodurch \fBxz\fP mehr Dateitypen dekomprimieren kann, anstatt sie unverändert +in die Standardausgabe zu kopieren. Mit der Option \fB\-\-format=\fP\fIFormat\fP +können Sie \fBxz\fP anweisen, nur ein einzelnes Dateiformat zu dekomprimieren. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +schreibt die komprimierten oder dekomprimierten Daten in die Standardausgabe +anstatt in eine Datei. Dies impliziert \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +dekomprimiert nur den ersten \fB.xz\fP\-Datenstrom und ignoriert stillschweigend +weitere Eingabedaten, die möglicherweise dem Datenstrom +folgen. Normalerweise führt solcher anhängender Datenmüll dazu, dass \fBxz\fP +eine Fehlermeldung ausgibt. +.IP "" +\fBxz\fP dekomprimiert niemals mehr als einen Datenstrom aus \fB.lzma\fP\-Dateien +oder Rohdatenströmen, aber dennoch wird durch diese Option möglicherweise +vorhandener Datenmüll nach der \fB.lzma\fP\-Datei oder dem Rohdatenstrom +ignoriert. +.IP "" +Diese Option ist wirkungslos, wenn der Aktionsmodus nicht \fB\-\-decompress\fP +oder \fB\-\-test\fP ist. +.IP "" +Seit der Programmversion \fBxz\fP 5.7.1alpha impliziert \fB\-\-single\-stream\fP +zusätzlich die Option \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +verhindert die Erzeugung von Sparse\-Dateien. In der Voreinstellung versucht +\fBxz\fP, bei der Dekompression in eine reguläre Datei eine Sparse\-Datei zu +erzeugen, wenn die dekomprimierten Daten lange Abfolgen von binären Nullen +enthalten. Dies funktioniert auch beim Schreiben in die Standardausgabe, +sofern diese in eine reguläre Datei weitergeleitet wird und bestimmte +Zusatzbedingungen erfüllt sind, die die Aktion absichern. Die Erzeugung von +Sparse\-Dateien kann Plattenplatz sparen und beschleunigt die Dekompression +durch Verringerung der Ein\-/Ausgaben der Platte. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +verwendet \fI.suf\fP bei der Dekompression anstelle von \fB.xz\fP oder \fB.lzma\fP +als Suffix für die Zieldatei. Falls nicht in die Standardausgabe geschrieben +wird und die Quelldatei bereits das Suffix \fI.suf\fP hat, wird eine Warnung +angezeigt und die Datei übersprungen. +.IP "" +berücksichtigt bei der Dekompression zusätzlich zu Dateien mit den Suffixen +\&\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP oder \fB.lz\fP auch jene mit dem Suffix +\&\fI.suf\fP. Falls die Quelldatei das Suffix \fI.suf\fP hat, wird dieses entfernt +und so der Name der Zieldatei abgeleitet. +.IP "" +Beim Komprimieren oder Dekomprimieren von Rohdatenströmen mit +\fB\-\-format=raw\fP muss das Suffix stets angegeben werden, außer wenn die +Ausgabe in die Standardausgabe erfolgt. Der Grund dafür ist, dass es kein +vorgegebenes Suffix für Rohdatenströme gibt. +.TP +\fB\-\-files\fP[\fB=\fP\fIDatei\fP] +liest die zu verarbeitenden Dateinamen aus \fIDatei\fP. Falls keine \fIDatei\fP +angegeben ist, werden die Dateinamen aus der Standardeingabe +gelesen. Dateinamen müssen mit einem Zeilenumbruch beendet werden. Ein +Bindestrich (\fB\-\fP) wird als regulärer Dateiname angesehen und nicht als +Standardeingabe interpretiert. Falls Dateinamen außerdem als +Befehlszeilenargumente angegeben sind, werden diese vor den Dateinamen aus +der \fIDatei\fP verarbeitet. +.TP +\fB\-\-files0\fP[\fB=\fP\fIDatei\fP] +Dies ist gleichbedeutend mit \fB\-\-files\fP[\fB=\fP\fIDatei\fP], außer dass jeder +Dateiname mit einem Null\-Zeichen abgeschlossen werden muss. +. +.SS "Grundlegende Dateiformat\- und Kompressionsoptionen" +.TP +\fB\-F\fP \fIFormat\fP, \fB\-\-format=\fP\fIFormat\fP +gibt das \fIFormat\fP der zu komprimierenden oder dekomprimierenden Datei an: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Dies ist die Voreinstellung. Bei der Kompression ist \fBauto\fP gleichbedeutend +mit \fBxz\fP. Bei der Dekompression wird das Format der Eingabedatei +automatisch erkannt. Beachten Sie, dass Rohdatenströme, wie sie mit +\fB\-\-format=raw\fP erzeugt werden, nicht automatisch erkannt werden können. +.TP +\fBxz\fP +Die Kompression erfolgt in das \fB.xz\fP\-Dateiformat oder akzeptiert nur +\&\fB.xz\fP\-Dateien bei der Dekompression. +.TP +\fBlzma\fP, \fBalone\fP +Die Kompression erfolgt in das veraltete \fB.lzma\fP\-Dateiformat oder +akzeptiert nur \fB.lzma\fP\-Dateien bei der Dekompression. Der alternative Name +\fBalone\fP dient der Abwärtskompatibilität zu den LZMA\-Dienstprogrammen. +.TP +\fBlzip\fP +Akzeptiert nur \fB.lz\fP\-Dateien bei der Dekompression. Kompression wird nicht +unterstützt. +.IP "" +The \fB.lz\fP format versions 0 and 1 are supported. Version 0 files were +produced by \fBlzip\fP 1.3 and older. Such files aren't common but may be +found from file archives as a few source packages were released in this +format. People might have old personal files in this format too. +Decompression support for the format version 0 was removed in \fBlzip\fP 1.18. +\fBlzip\fP 1.4 and later create files in the format version 1. +.TP +\fBraw\fP +Komprimiert oder dekomprimiert einen Rohdatenstrom (ohne Header). Diese +Option ist nur für fortgeschrittene Benutzer bestimmt. Zum Dekodieren von +Rohdatenströmen müssen Sie die Option \fB\-\-format=raw\fP verwenden und die +Filterkette ausdrücklich angeben, die normalerweise in den (hier fehlenden) +Container\-Headern gespeichert worden wäre. +.RE +.TP +\fB\-C\fP \fIPrüfung\fP, \fB\-\-check=\fP\fIPrüfung\fP +gibt den Typ der Integritätsprüfung an. Die Prüfsumme wird aus den +unkomprimierten Daten berechnet und in der \fB.xz\fP\-Datei gespeichert. Diese +Option wird nur bei der Kompression in das \fB.xz\fP\-Format angewendet, da das +\&\fB.lzma\fP\-Format keine Integritätsprüfungen unterstützt. Die eigentliche +Integritätsprüfung erfolgt (falls möglich), wenn die \fB.xz\fP\-Datei +dekomprimiert wird. +.IP "" +Folgende Typen von \fIPrüfungen\fP werden unterstützt: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +führt keine Integritätsprüfung aus. Dies ist eine eher schlechte +Idee. Dennoch kann es nützlich sein, wenn die Integrität der Daten auf +andere Weise sichergestellt werden kann. +.TP +\fBcrc32\fP +berechnet die CRC32\-Prüfsumme anhand des Polynoms aus IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +berechnet die CRC64\-Prüfsumme anhand des Polynoms aus ECMA\-182. Dies ist die +Voreinstellung, da beschädigte Dateien etwas besser als mit CRC32 erkannt +werden und die Geschwindigkeitsdifferenz unerheblich ist. +.TP +\fBsha256\fP +berechnet die SHA\-256\-Prüfsumme. Dies ist etwas langsamer als CRC32 und +CRC64. +.RE +.IP "" +Die Integrität der \fB.xz\fP\-Header wird immer mit CRC32 geprüft. Es ist nicht +möglich, dies zu ändern oder zu deaktivieren. +.TP +\fB\-\-ignore\-check\fP +verifiziert die Integritätsprüfsumme der komprimierten Daten bei der +Dekompression nicht. Die CRC32\-Werte in den \fB.xz\fP\-Headern werden weiterhin +normal verifiziert. +.IP "" +\fBVerwenden Sie diese Option nicht, außer Sie wissen, was Sie tun.\fP Mögliche +Gründe, diese Option zu verwenden: +.RS +.IP \(bu 3 +Versuchen, Daten aus einer beschädigten .xz\-Datei wiederherzustellen. +.IP \(bu 3 +Erhöhung der Geschwindigkeit bei der Dekompression. Dies macht sich meist +mit SHA\-256 bemerkbar, oder mit Dateien, die extrem stark komprimiert +sind. Wir empfehlen, diese Option nicht für diesen Zweck zu verwenden, es +sei denn, die Integrität der Datei wird extern auf andere Weise überprüft. +.RE +.TP +\fB\-0\fP … \fB\-9\fP +wählt eine der voreingestellten Kompressionsstufen, standardmäßig +\fB\-6\fP. Wenn mehrere Voreinstellungsstufen angegeben sind, ist nur die +zuletzt angegebene wirksam. Falls bereits eine benutzerdefinierte +Filterkette angegeben wurde, wird diese durch die Festlegung der +Voreinstellung geleert. +.IP "" +Die Unterschiede zwischen den Voreinstellungsstufen sind deutlicher als bei +\fBgzip\fP(1) und \fBbzip2\fP(1). Die gewählten Kompressionseinstellungen +bestimmen den Speicherbedarf bei der Dekompression, daher ist es auf älteren +Systemen mit wenig Speicher bei einer zu hoch gewählten Voreinstellung +schwer, eine Datei zu dekomprimieren. Insbesondere \fBist es keine gute Idee, blindlings \-9 für alles\fP zu verwenden, wie dies häufig mit \fBgzip\fP(1) und +\fBbzip2\fP(1) gehandhabt wird. +.RS +.TP +\fB\-0\fP … \fB\-3\fP +Diese Voreinstellungen sind recht schnell. \fB\-0\fP ist manchmal schneller als +\fBgzip \-9\fP, wobei aber die Kompression wesentlich besser ist. Die +schnelleren Voreinstellungen sind im Hinblick auf die Geschwindigkeit mit +\fBbzip2\fP(1) vergleichbar , mit einem ähnlichen oder besseren +Kompressionsverhältnis, wobei das Ergebnis aber stark vom Typ der zu +komprimierenden Daten abhängig ist. +.TP +\fB\-4\fP … \fB\-6\fP +Gute bis sehr gute Kompression, wobei der Speicherbedarf für die +Dekompression selbst auf alten Systemen akzeptabel ist. \fB\-6\fP ist die +Voreinstellung, welche üblicherweise eine gute Wahl für die Verteilung von +Dateien ist, die selbst noch auf Systemen mit nur 16\ MiB Arbeitsspeicher +dekomprimiert werden müssen (\fB\-5e\fP oder \fB\-6e\fP sind ebenfalls eine +Überlegung wert. Siehe \fB\-\-extreme\fP). +.TP +\fB\-7 … \-9\fP +Ähnlich wie \fB\-6\fP, aber mit einem höheren Speicherbedarf für die Kompression +und Dekompression. Sie sind nur nützlich, wenn Dateien komprimiert werden +sollen, die größer als 8\ MiB, 16\ MiB beziehungsweise 32\ MiB sind. +.RE +.IP "" +Auf der gleichen Hardware ist die Dekompressionsgeschwindigkeit ein nahezu +konstanter Wert in Bytes komprimierter Daten pro Sekunde. Anders +ausgedrückt: Je besser die Kompression, umso schneller wird üblicherweise +die Dekompression sein. Das bedeutet auch, dass die Menge der pro Sekunde +ausgegebenen unkomprimierten Daten stark variieren kann. +.IP "" +Die folgende Tabelle fasst die Eigenschaften der Voreinstellungen zusammen: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Voreinst.;Wörtb.Gr;KomprCPU;KompSpeich;DekompSpeich +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Spaltenbeschreibungen: +.RS +.IP \(bu 3 +Wörtb.Größe ist die Größe des LZMA2\-Wörterbuchs. Es ist +Speicherverschwendung, ein Wörterbuch zu verwenden, das größer als die +unkomprimierte Datei ist. Daher ist es besser, die Voreinstellungen \fB\-7\fP … +\fB\-9\fP zu vermeiden, falls es keinen wirklichen Bedarf dafür gibt. Mit \fB\-6\fP +und weniger wird üblicherweise so wenig Speicher verschwendet, dass dies +nicht ins Gewicht fällt. +.IP \(bu 3 +KomprCPU ist eine vereinfachte Repräsentation der LZMA2\-Einstellungen, +welche die Kompressionsgeschwindigkeit beeinflussen. Die Wörterbuchgröße +wirkt sich ebenfalls auf die Geschwindigkeit aus. Während KompCPU für die +Stufen \fB\-6\fP bis \fB\-9\fP gleich ist, tendieren höhere Stufen dazu, etwas +langsamer zu sein. Um eine noch langsamere, aber möglicherweise bessere +Kompression zu erhalten, siehe \fB\-\-extreme\fP. +.IP \(bu 3 +KompSpeich enthält den Speicherbedarf des Kompressors im +Einzel\-Thread\-Modus. Dieser kann zwischen den \fBxz\fP\-Versionen leicht +variieren. +.IP \(bu 3 +DekompSpeich enthält den Speicherbedarf für die Dekompression. Das bedeutet, +dass die Kompressionseinstellungen den Speicherbedarf bei der Dekompression +bestimmen. Der exakte Speicherbedarf bei der Dekompression ist geringfügig +größer als die Größe des LZMA2\-Wörterbuchs, aber die Werte in der Tabelle +wurden auf ganze MiB aufgerundet. +.RE +.IP "" + Der Speicherbedarf einiger der zukünftigen Multithread\-Modi kann dramatisch +höher sein als im Einzel\-Thread\-Modus. Mit dem Standardwert von +\fB\-\-block\-size\fP benötigt jeder Thread 3*3*Wörtb.Gr plus KompSpeich oder +DekompSpeich. Beispielsweise benötigen vier Threads mit der Voreinstellung +\fB\-6\fP etwa 660 bis 670 MiB Speicher. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +verwendet eine langsamere Variante der gewählten +Kompressions\-Voreinstellungsstufe (\fB\-0\fP … \fB\-9\fP), um hoffentlich ein etwas +besseres Kompressionsverhältnis zu erreichen, das aber in ungünstigen Fällen +auch schlechter werden kann. Der Speicherverbrauch bei der Dekompression +wird dabei nicht beeinflusst, aber der Speicherverbrauch der Kompression +steigt in den Voreinstellungsstufen \fB\-0\fP bis \fB\-3\fP geringfügig an. +.IP "" +Da es zwei Voreinstellungen mit den Wörterbuchgrößen 4\ MiB und 8\ MiB gibt, +verwenden die Voreinstellungsstufen \fB\-3e\fP und \fB\-5e\fP etwas schnellere +Einstellungen (niedrigere KompCPU) als \fB\-4e\fP beziehungsweise \fB\-6e\fP. Auf +diese Weise sind zwei Voreinstellungen nie identisch. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Voreinst.;Wörtb.Gr;KomprCPU;KompSpeich;DekompSpeich +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Zum Beispiel gibt es insgesamt vier Voreinstellungen, die ein 8\ MiB großes +Wörterbuch verwenden, deren Reihenfolge von der schnellsten zur langsamsten +\fB\-5\fP, \fB\-6\fP, \fB\-5e\fP und \fB\-6e\fP ist. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +sind etwas irreführende Aliase für \fB\-0\fP beziehungsweise \fB\-9\fP. Sie werden +nur zwecks Abwärtskompatibilität zu den LZMA\-Dienstprogrammen +bereitgestellt. Sie sollten diese Optionen besser nicht verwenden. +.TP +\fB\-\-block\-size=\fP\fIGröße\fP +teilt beim Komprimieren in das \fB.xz\fP\-Format die Eingabedaten in Blöcke der +angegebenen \fIGröße\fP in Byte. Die Blöcke werden unabhängig voneinander +komprimiert, was dem Multi\-Threading entgegen kommt und Zufallszugriffe bei +der Dekompression begrenzt. Diese Option wird typischerweise eingesetzt, um +die vorgegebene Blockgröße im Multi\-Thread\-Modus außer Kraft zu setzen, aber +sie kann auch im Einzel\-Thread\-Modus angewendet werden. +.IP "" +Im Multi\-Thread\-Modus wird etwa die dreifache \fIGröße\fP in jedem Thread zur +Pufferung der Ein\- und Ausgabe belegt. Die vorgegebene \fIGröße\fP ist das +Dreifache der Größe des LZMA2\-Wörterbuchs oder 1 MiB, je nachdem, was mehr +ist. Typischerweise ist das Zwei\- bis Vierfache der Größe des +LZMA2\-Wörterbuchs oder wenigstens 1 MB ein guter Wert. Eine \fIGröße\fP, die +geringer ist als die des LZMA2\-Wörterbuchs, ist Speicherverschwendung, weil +dann der LZMA2\-Wörterbuchpuffer niemals vollständig genutzt werden würde. Im +Multi\-Thread\-Modus wird die Größe der Blöcke wird in den Block\-Headern +gespeichert. Die Größeninformation wird für eine Multi\-Thread\-Dekompression +genutzt. +.IP "" +Im Einzel\-Thread\-Modus werden die Blöcke standardmäßig nicht geteilt. Das +Setzen dieser Option wirkt sich nicht auf den Speicherbedarf aus. In den +Block\-Headern werden keine Größeninformationen gespeichert, daher werden im +Einzel\-Thread\-Modus erzeugte Dateien nicht zu den im Multi\-Thread\-Modus +erzeugten Dateien identisch sein. Das Fehlen der Größeninformation bedingt +auch, dass \fBxz\fP nicht in der Lage sein wird, die Dateien im +Multi\-Thread\-Modus zu dekomprimieren. +.TP +\fB\-\-block\-list=\fP\fIBlöcke\fP +beginnt bei der Kompression in das \fB.xz\fP\-Format nach den angegebenen +Intervallen unkomprimierter Daten einen neuen Block, optional mit einer +benutzerdefinierten Filterkette. +.IP "" +Die \fIBlöcke\fP werden in einer durch Kommata getrennten Liste +angegeben. Jeder Block besteht aus einer optionalen Filterkettennummer +zwischen 0 und 9, gefolgt von einem Doppelpunkt (\fB:\fP) und der Größe der +unkomprimierten Daten (diese Angabe ist erforderlich). Überspringen eines +Blocks (zwei oder mehr aufeinander folgende Kommata) ist ein Kürzel dafür, +die Größe und die Filter des vorherigen Blocks zu verwenden. +.IP "" +Falls die Eingabedatei größer ist als die Summe der \fIBlöcke\fP, dann wird der +letzte in \fIVBlöcke\fP angegebene Wert bis zum Ende der Datei wiederholt. Mit +dem speziellen Wert \fB0\fP können Sie angeben, dass der Rest der Datei als +einzelner Block kodiert werden soll. +.IP "" +Eine alternative Filterkette für jeden Block kann in Kombination mit den +Optionen \fB\-\-filters1=\fP\fIFilter\fP \&…\& \fB\-\-filters9=\fP\fIFilter\fP angegeben +werden. Diese Optionen definieren Filterketten mit einem Bezeichner zwischen +1 und 9. Die Filterkette 0 bezeichnet hierbei die voreingestellte +Filterkette, was dem Nichtangeben einer Filterkette gleichkommt. Der +Filterkettenbezeichner kann vor der unkomprimierten Größe verwendet werden, +gefolgt von einem Doppelpunkt (\fB:\fP). Falls Sie beispielsweise +\fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP angeben, werden die Blöcke +folgendermaßen erstellt: +.RS +.IP \(bu 3 +Die durch \fB\-\-filters1\fP angegebene Filterkette und 2 MiB Eingabe +.IP \(bu 3 +Die durch \fB\-\-filters3\fP angegebene Filterkette und 2 MiB Eingabe +.IP \(bu 3 +Die durch \fB\-\-filters2\fP angegebene Filterkette und 4 MiB Eingabe +.IP \(bu 3 +Die durch \fB\-\-filters2\fP angegebene Filterkette und 4 MiB Eingabe +.IP \(bu 3 +Die vorgegebene Filterkette und 2 MiB Eingabe +.IP \(bu 3 +Die vorgegebene Filterkette und 4 MiB Eingabe für jeden Block bis zum Ende +der Eingabe. +.RE +.IP "" +Falls Sie eine Größe angeben, welche die Blockgröße des Encoders übersteigen +(entweder den Vorgabewert im Thread\-Modus oder den mit +\fB\-\-block\-size=\fP\fIGröße\fP angegebenen Wert), wird der Encoder zusätzliche +Blöcke erzeugen, wobei die in den \fIBlöcke\fP angegebenen Grenzen eingehalten +werden. Wenn Sie zum Beispiel \fB\-\-block\-size=10MiB\fP +\fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP angeben und die Eingabedatei 80 +MiB groß ist, erhalten Sie 11 Blöcke: 5, 10, 8, 10, 2, 10, 10, 4, 10, 10 und +1 MiB. +.IP "" +Im Multi\-Thread\-Modus werden die Blockgrößen in den Block\-Headern +gespeichert. Dies geschieht im Einzel\-Thread\-Modus nicht, daher wird die +kodierte Ausgabe zu der im Multi\-Thread\-Modus nicht identisch sein. +.TP +\fB\-\-flush\-timeout=\fP\fIZeit\fP +löscht bei der Kompression die ausstehenden Daten aus dem Encoder und macht +sie im Ausgabedatenstrom verfügbar, wenn mehr als die angegebene \fIZeit\fP in +Millisekunden (als positive Ganzzahl) seit dem vorherigen Löschen vergangen +ist und das Lesen weiterer Eingaben blockieren würde. Dies kann nützlich +sein, wenn \fBxz\fP zum Komprimieren von über das Netzwerk eingehenden Daten +verwendet wird. Kleine \fIZeit\fP\-Werte machen die Daten unmittelbar nach dem +Empfang nach einer kurzen Verzögerung verfügbar, während große \fIZeit\fP\-Werte +ein besseres Kompressionsverhältnis bewirken. +.IP "" +Dieses Funktionsmerkmal ist standardmäßig deaktiviert. Wenn diese Option +mehrfach angegeben wird, ist die zuletzt angegebene wirksam. Für die Angabe +der \fIZeit\fP kann der spezielle Wert \fB0\fP verwendet werden, um dieses +Funktionsmerkmal explizit zu deaktivieren. +.IP "" +Dieses Funktionsmerkmal ist außerhalb von POSIX\-Systemen nicht verfügbar. +.IP "" +.\" FIXME +\fBDieses Funktionsmerkmal ist noch experimentell.\fP Gegenwärtig ist \fBxz\fP +aufgrund der Art und Weise, wie \fBxz\fP puffert, für Dekompression in Echtzeit +ungeeignet. +.TP +\fB\-\-no\-sync\fP +synchronisiert die Zieldatei und deren Verzeichnis auf dem Speichergerät +nicht, bevor die Quelldatei gelöscht wird. So kann die Performance beim +Komprimieren oder Dekomprimieren vieler kleiner Dateien verbessert +werden. Jedoch wäre es möglich, falls es kurz nach dem Löschen zu einem +Systemabsturz kommt, dass die Zieldatei noch nicht auf dem Speichergerät +geschrieben, aber der Löschvorgang bereits ausgeführt wurde. In diesem Fall +gehen sowohl die Quelldatei als auch die Zieldatei verloren. +.IP "" +Diese Option ist nur wirksam, wenn \fBxz\fP die Quelldatei löscht. In anderen +Fällen wird niemals synchronisiert. +.IP "" +Die Synchronisierung und \fB\-\-no\-sync\fP wurden in Version \fBxz\fP 5.7.1alpha +hinzugefügt. +.TP +\fB\-\-memlimit\-compress=\fP\fIGrenze\fP +legt eine Grenze für die Speichernutzung bei der Kompression fest. Wenn +diese Option mehrmals angegeben wird, ist die zuletzt angegebene wirksam. +.IP "" +Falls die Kompressionseinstellungen die \fIGrenze\fP überschreiten, versucht +\fBxz\fP, die Einstellungen nach unten anzupassen, so dass die Grenze nicht +mehr überschritten wird und zeigt einen Hinweis an, dass eine automatische +Anpassung vorgenommen wurde. Die Anpassungen werden in folgender Reihenfolge +angewendet: Reduzierung der Anzahl der Threads, Wechsel in den +Einzelthread\-Modus, falls sogar ein einziger Thread im Multithread\-Modus die +\fIGrenze\fP überschreitet, und schlussendlich die Reduzierung der Größe des +LZMA2\-Wörterbuchs. +.IP "" +Beim Komprimieren mit \fB\-\-format=raw\fP oder falls \fB\-\-no\-adjust\fP angegeben +wurde, wird nur die Anzahl der Threads reduziert, da nur so die komprimierte +Ausgabe nicht beeinflusst wird. +.IP "" +Falls die \fIGrenze\fP nicht anhand der vorstehend beschriebenen Anpassungen +gesetzt werden kann, wird ein Fehler angezeigt und \fBxz\fP wird mit dem +Exit\-Status 1 beendet. +.IP "" +Die \fIGrenze\fP kann auf verschiedene Arten angegeben werden: +.RS +.IP \(bu 3 +Die \fIGrenze\fP kann ein absoluter Wert in Byte sein. Ein Suffix wie \fBMiB\fP +kann dabei hilfreich sein. Beispiel: \fB\-\-memlimit\-compress=80MiB\fP. +.IP \(bu 3 +Die \fIGrenze\fP kann als Prozentsatz des physischen Gesamtspeichers (RAM) +angegeben werden. Dies ist insbesondere nützlich, wenn in einem +Shell\-Initialisierungsskript, das mehrere unterschiedliche Rechner gemeinsam +verwenden, die Umgebungsvariable \fBXZ_DEFAULTS\fP gesetzt ist. Auf diese Weise +ist die Grenze auf Systemen mit mehr Speicher höher. Beispiel: +\fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +Mit \fB0\fP kann die \fIGrenze\fP auf den Standardwert zurückgesetzt werden. Dies +ist gegenwärtig gleichbedeutend mit dem Setzen der \fIGrenze\fP auf \fBmax\fP +(keine Speicherbegrenzung). +.RE +.IP "" +Für die 32\-Bit\-Version von \fBxz\fP gibt es einen Spezialfall: Falls die Grenze +über \fB4020\ MiB\fP liegt, wird die \fIGrenze\fP auf \fB4020\ MiB\fP gesetzt. Auf +MIPS32 wird stattdessen \fB2000\ MB\fP verwendet (die Werte \fB0\fP und \fBmax\fP +werden hiervon nicht beeinflusst; für die Dekompression gibt es keine +vergleichbare Funktion). Dies kann hilfreich sein, wenn ein +32\-Bit\-Executable auf einen 4\ GiB großen Adressraum (2 GiB auf MIPS32) +zugreifen kann, wobei wir hoffen wollen, dass es in anderen Situationen +keine negativen Effekte hat. +.IP "" +Siehe auch den Abschnitt \fBSpeicherbedarf\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIGrenze\fP +legt eine Begrenzung des Speicherverbrauchs für die Dekompression fest. Dies +beeinflusst auch den Modus \fB\-\-list\fP. Falls die Aktion nicht ausführbar ist, +ohne die \fIGrenze\fP zu überschreiten, gibt \fBxz\fP eine Fehlermeldung aus und +die Dekompression wird fehlschlagen. Siehe \fB\-\-memlimit\-compress=\fP\fIGrenze\fP +zu möglichen Wegen, die \fIGrenze\fP anzugeben. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIGrenze\fP +legt eine Begrenzung des Speicherverbrauchs für Multithread\-Dekompression +fest. Dies beeinflusst lediglich die Anzahl der Threads; \fBxz\fP wird dadurch +niemals die Dekompression einer Datei verweigern. Falls die \fIGrenze\fP für +jegliches Multithreading zu niedrig ist, wird sie ignoriert und \fBxz\fP setzt +im Einzelthread\-modus fort. Beachten Sie auch, dass bei der Verwendung von +\fB\-\-memlimit\-decompress\fP dies stets sowohl auf den Einzelthread\-als auch auf +den Multithread\-Modus angewendet wird und so die effektive \fIGrenze\fP für den +Multithread\-Modus niemals höher sein wird als die mit +\fB\-\-memlimit\-decompress\fP gesetzte Grenze. +.IP "" +Im Gegensatz zu anderen Optionen zur Begrenzung des Speicherverbrauchs hat +\fB\-\-memlimit\-mt\-decompress=\fP\fIGrenze\fP eine systemspezifisch vorgegebene +\fIGrenze\fP. Mit \fBxz \-\-info\-memory\fP können Sie deren aktuellen Wert anzeigen +lassen. +.IP "" +Diese Option und ihr Standardwert existieren, weil die unbegrenzte +threadbezogene Dekompression bei einigen Eingabedateien zu unglaublich +großem Speicherverbrauch führen würde. Falls die vorgegebene \fIGrenze\fP auf +Ihrem System zu niedrig ist, können Sie die \fIGrenze\fP durchaus erhöhen, aber +setzen Sie sie niemals auf einen Wert größer als die Menge des nutzbaren +Speichers, da \fBxz\fP bei entsprechenden Eingabedateien versuchen wird, diese +Menge an Speicher auch bei einer geringen Anzahl von Threads zu +verwnden. Speichermangel oder Auslagerung verbessern die +Dekomprimierungsleistung nicht. +.IP "" +Siehe \fB\-\-memlimit\-compress=\fP\fIGrenze\fP für mögliche Wege zur Angabe der +\fIGrenze\fP. Sezen der \fIGrenze\fP auf \fB0\fP setzt die \fIGrenze\fP auf den +vorgegebenen systemspezifischen Wert zurück. +.TP +\fB\-M\fP \fIGrenze\fP, \fB\-\-memlimit=\fP\fIGrenze\fP, \fB\-\-memory=\fP\fIGrenze\fP +Dies ist gleichbedeutend mit \fB\-\-memlimit\-compress=\fP\fIGrenze\fP +\fB\-\-memlimit\-decompress=\fP\fIGrenze\fP \fB\-\-memlimit\-mt\-decompress=\fP\fIGrenze\fP. +.TP +\fB\-\-no\-adjust\fP +zeigt einen Fehler an und beendet, falls die Grenze der Speichernutzung +nicht ohne Änderung der Einstellungen, welche die komprimierte Ausgabe +beeinflussen, berücksichtigt werden kann. Das bedeutet, dass \fBxz\fP daran +gehindert wird, den Encoder vom Multithread\-Modus in den Einzelthread\-Modus +zu versetzen und die Größe des LZMA2\-Wörterbuchs zu reduzieren. Allerdings +kann bei Verwendung dieser Option dennoch die Anzahl der Threads reduziert +werden, um die Grenze der Speichernutzung zu halten, sofern dies die +komprimierte Ausgabe nicht beeinflusst. +.IP "" +Die automatische Anpassung ist beim Erzeugen von Rohdatenströmen +(\fB\-\-format=raw\fP) immer deaktiviert. +.TP +\fB\-T\fP \fIThreads\fP, \fB\-\-threads=\fP\fIThreads\fP +gibt die Anzahl der zu verwendenden Arbeits\-Threads an. Wenn Sie \fIThreads\fP +auf einen speziellen Wert \fB0\fP setzen, verwendet \fBxz\fP maximal so viele +Threads, wie der/die Prozessor(en) im System untestützen. Die tatsächliche +Anzahl kann geringer sein als die angegebenen \fIThreads\fP, wenn die +Eingabedatei nicht groß genug für Threading mit den gegebenen Einstellungen +ist oder wenn mehr Threads die Speicherbegrenzung übersteigen würden. +.IP "" +Die Multithread\- bzw. Einzelthread\-Kompressoren erzeugen unterschiedliche +Ausgaben. Der Einzelthread\-Kompressor erzeugt die geringste Dateigröße, aber +nur die Ausgabe des Multithread\-Kompressors kann mit mehreren Threads wieder +dekomprimiert werden. Das Setzen der Anzahl der \fIThreads\fP auf \fB1\fP wird den +Einzelthread\-Modus verwenden. Das Setzen der Anzahl der \fIThreads\fP auf +einen anderen Wert einschließlich \fB0\fP verwendet den Multithread\-Kompressor, +und zwar sogar dann, wenn das System nur einen einzigen Hardware\-Thread +unterstützt (\fBxz\fP 5.2.x verwendete in diesem Fall noch den +Einzelthread\-Modus). +.IP "" +Um den Multithread\-Modus mit nur einem einzigen Thread zu verwenden, setzen +Sie die Anzahl der \fIThreads\fP auf \fB+1\fP. Das Präfix \fB+\fP hat mit Werten +verschieden von \fB1\fP keinen Effekt. Eine Begrenzung des Speicherverbrauchs +kann \fBxz\fP dennoch veranlassen, den Einzelthread\-Modus zu verwenden, außer +wenn \fB\-\-no\-adjust\fP verwendet wird. Die Unterstützung für das Präfix \fB+\fP +wurde in \fBxz\fP 5.4.0 hinzugefügt. +.IP "" +Falls das automatische Setzen der Anzahl der Threads angefordert und keine +Speicherbegrenzung angegeben wurde, dann wird eine systemspezifisch +vorgegebene weiche Grenze verwendet, um eventuell die Anzahl der Threads zu +begrenzen. Es ist eine weiche Grenze im Sinne davon, dass sie ignoriert +wird, falls die Anzahl der Threads 1 ist; daher wird eine weiche Grenze +\fBxz\fP niemals an der Kompression oder Dekompression hindern. Diese +vorgegebene weiche Grenze veranlasst \fBxz\fP nicht, vom Multithread\-Modus in +den Einzelthread\-Modus zu wechseln. Die aktiven Grenzen können Sie mit dem +Befehl \fBxz \-\-info\-memory\fP anzeigen lassen. +.IP "" +Die gegenwärtig einzige Threading\-Methode teilt die Eingabe in Blöcke und +komprimiert diese unabhängig voneinander. Die vorgegebene Blockgröße ist von +der Kompressionsstufe abhängig und kann mit der Option +\fB\-\-block\-size=\fP\fIGröße\fP außer Kraft gesetzt werden. +.IP "" +Eine thread\-basierte Dekompression wird nur bei Dateien funktionieren, die +mehrere Blöcke mit Größeninformationen in deren Headern enthalten. Alle im +Multi\-Thread\-Modus komprimierten Dateien, die groß genug sind, erfüllen +diese Bedingung, im Einzel\-Thread\-Modus komprimierte Dateien dagegen nicht, +selbst wenn \fB\-\-block\-size=\fP\fIGröße\fP verwendet wurde. +.IP "" +Der Vorgabewert für \fIThreads\fP is \fB0\fP. In \fBxz\fP 5.4.x und älteren Versionen +ist der Vorgabewert \fB1\fP. +. +.SS "Benutzerdefinierte Filterketten für die Kompression" +Eine benutzerdefinierte Filterkette ermöglicht die Angabe detaillierter +Kompressionseinstellungen, anstatt von den Voreinstellungen auszugehen. Wenn +eine benutzerdefinierte Filterkette angegeben wird, werden die vorher in der +Befehlszeile angegebenen Voreinstellungsoptionen (\fB\-0\fP … \fB\-9\fP und +\fB\-\-extreme\fP) außer Kraft gesetzt. Wenn eine Voreinstellungsoption nach +einer oder mehreren benutzerdefinierten Filterkettenoptionen angegeben wird, +dann wird die neue Voreinstellung wirksam und die zuvor angegebenen +Filterkettenoptionen werden außer Kraft gesetzt. +.PP +Eine Filterkette ist mit dem Piping (der Weiterleitung) in der Befehlszeile +vergleichbar. Bei der Kompression gelangt die unkomprimierte Eingabe in den +ersten Filter, dessen Ausgabe wiederum in den zweiten Filter geleitet wird +(sofern ein solcher vorhanden ist). Die Ausgabe des letzten Filters wird in +die komprimierte Datei geschrieben. In einer Filterkette sind maximal vier +Filter zulässig, aber typischerweise besteht eine Filterkette nur aus einem +oder zwei Filtern. +.PP +Bei vielen Filtern ist die Positionierung in der Filterkette eingeschränkt: +Einige Filter sind nur als letzte in der Kette verwendbar, einige können +nicht als letzte Filter gesetzt werden, und andere funktionieren an +beliebiger Stelle. Abhängig von dem Filter ist diese Beschränkung entweder +auf das Design des Filters selbst zurückzuführen oder ist aus +Sicherheitsgründen vorhanden. +.PP +Eine benutzerdefinierte Filterkette kann auf zwei verschiedene Arten +angegeben werden. Die Optionen \fB\-\-filters=\fP\fIFilter\fP und +\fB\-\-filters1=\fP\fIFilter\fP \&…\& \fB\-\-filters9=\fP\fIFilter\fP ermöglichen die Angabe +einer ganzen Filterkette in einer einzelnen Option gemäß der +Liblzma\-Filterzeichenkettensyntax. Alternativ können Sie eine Filterkette +mit einer oder mehreren individuellen Filteroptionen in der Reihenfolge +angeben, in der sie in der Filterkette verwendet werden sollen. Daher ist +die Reihenfolge der individuellen Filteroptionen wichtig! Beim Dekodieren +von Rohdatenströmen (\fB\-\-format=raw\fP) muss die Filterkette in der gleichen +Reihenfolge wie bei der Komprimierung angegeben werden. Alle individuellen +Filter\- oder Voreinstellungsoptionen, die \fIvor\fP der vollen +Filterkettenoption (\fB\-\-filters=\fP\fIFilter\fP) angegeben werden, werden +verworfen. Individuelle Filter, die \fInach\fP der vollen Filterkettenoption +angegeben werden, setzen die Filterkette zurück +.PP +Sowohl vollständige als auch individuelle Filteroptionen akzeptieren +filterspezifische \fIOptionen\fP in einer durch Kommata getrennten +Liste. Zusätzliche Kommata in den \fIOptionen\fP werden ignoriert. Jede Option +hat einen Standardwert, daher brauchen Sie nur jene anzugeben, die Sie +ändern wollen. +.PP +Um die gesamte Filterkette und die \fIOptionen\fP anzuzeigen, rufen Sie \fBxz \-vv\fP auf (was gleichbedeutend mit der zweimaligen Angabe von \fB\-\-verbose\fP +ist). Dies funktioniert auch zum Betrachten der von den Voreinstellungen +verwendeten Filterkettenoptionen. +.TP +\fB\-\-filters=\fP\fIFilter\fP +gibt die vollständige Filterkette oder eine Voreinstellung in einer +einzelnen Option an. Mehrere Filter können durch Leerzeichen oder zwei +Minuszeichen (\fB\-\-\fP) voneinander getrennt werden. Es kann notwendig sein, +die \fIFilter\fP in der Shell\-Befehlszeile zu maskieren, so dass diese als +einzelne Option ausgewertet werden. Um Optionen Werte zuzuordnen, verwenden +Sie \fB:\fP oder \fB=\fP. Einer Voreinstellung kann ein \fB\-\fP vorangestellt werden, +dem keiner oder mehrere Schalter folgen. Der einzige unterstützte Schalter +ist \fBe\fP zum Anwenden der gleichen Optionen wie \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIFilter\fP … \fB\-\-filters9\fP=\fIFilter\fP +gibt bis zu neun optionale Filterketten an, die mit \fB\-\-block\-list\fP +verwendet werden können. +.IP "" +Wenn Sie beispielsweise ein Archiv mit ausführbaren Dateien gefolgt von +Textdateien komprimieren, könnte der Teil mit den ausführbaren Dateien eine +Filterkette mit einem BCJ\-Filter und der Textdateiteil lediglich den +LZMA2\-Filter verwenden. +.TP +\fB\-\-filters\-help\fP +zeigt eine Hilfemeldung an, welche beschreibt, wie Voreinstellungen und +benutzerdefinierte Filterketten in den Optionen \fB\-\-filters\fP und +\fB\-\-filters1=\fP\fIFilter\fP \&… \& \fB\-\-filters9=\fP\fIFilter\fP angegeben werden und +beendet das Programm. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIOptionen\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIOptionen\fP] +.PD +fügt LZMA1\- oder LZMA2\-Filter zur Filterkette hinzu. Diese Filter können nur +als letzte Filter in der Kette verwendet werden. +.IP "" +LZMA1 ist ein veralteter Filter, welcher nur wegen des veralteten +\&\fB.lzma\fP\-Dateiformats unterstützt wird, welches nur LZMA1 unterstützt. LZMA2 +ist eine aktualisierte Version von LZMA1, welche einige praktische Probleme +von LZMA1 behebt. Das \fB.xz\fP\-Format verwendet LZMA2 und unterstützt LZMA1 +gar nicht. Kompressionsgeschwindigkeit und \-verhältnis sind bei LZMA1 und +LZMA2 praktisch gleich. +.IP "" +LZMA1 und LZMA2 haben die gleichen \fIOptionen\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIVoreinstellung\fP +setzt alle LZMA1\- oder LZMA2\-\fIOptionen\fP auf die \fIVoreinstellung\fP +zurück. Diese \fIVoreinstellung\fP wird in Form einer Ganzzahl angegeben, der +ein aus einem einzelnen Buchstaben bestehender Voreinstellungsmodifikator +folgen kann. Die Ganzzahl kann \fB0\fP bis \fB9\fP sein, entsprechend den +Befehlszeilenoptionen \fB\-0\fP … \fB\-9\fP. Gegenwärtig ist \fBe\fP der einzige +unterstützte Modifikator, was \fB\-\-extreme\fP entspricht. Wenn keine +\fBVoreinstellung\fP angegeben ist, werden die Standardwerte der LZMA1\- oder +LZMA2\-\fIOptionen\fP der Voreinstellung \fB6\fP entnommen. +.TP +\fBdict=\fP\fIGröße\fP +Die \fIGröße\fP des Wörterbuchs (Chronikpuffers) gibt an, wie viel Byte der +kürzlich verarbeiteten unkomprimierten Daten im Speicher behalten werden +sollen. Der Algorithmus versucht, sich wiederholende Byte\-Abfolgen +(Übereinstimmungen) in den unkomprimierten Daten zu finden und diese durch +Referenzen zu den Daten zu ersetzen, die sich gegenwärtig im Wörterbuch +befinden. Je größer das Wörterbuch, umso größer ist die Chance, eine +Übereinstimmung zu finden. Daher bewirkt eine Erhöhung der \fIGröße\fP des +Wörterbuchs üblicherweise ein besseres Kompressionsverhältnis, aber ein +Wörterbuch, das größer ist als die unkomprimierte Datei, wäre +Speicherverschwendung. +.IP "" +Typische Wörterbuch\-\fIGrößen\fP liegen im Bereich von 64\ KiB bis 64\ MiB. Das +Minimum ist 4\ KiB. Das Maximum für die Kompression ist gegenwärtig 1.5\ GiB +(1536\ MiB). Bei der Dekompression wird bereits eine Wörterbuchgröße bis zu +4\ GiB minus 1 Byte unterstützt, welche das Maximum für die LZMA1\- und +LZMA2\-Datenstromformate ist. +.IP "" +Die \fIGröße\fP des Wörterbuchs und der Übereinstimmungsfinder (\fIÜf\fP) +bestimmen zusammen den Speicherverbrauch des LZMA1\- oder +LZMA2\-Kodierers. Bei der Dekompression ist ein Wörterbuch der gleichen +\fIGröße\fP (oder ein noch größeres) wie bei der Kompression erforderlich, +daher wird der Speicherverbrauch des Dekoders durch die Größe des bei der +Kompression verwendeten Wörterbuchs bestimmt. Die \fB.xz\fP\-Header speichern +die \fIGröße\fP des Wörterbuchs entweder als 2^\fIn\fP oder 2^\fIn\fP + 2^(\fIn\fP\-1), +so dass diese \fIGrößen\fP für die Kompression etwas bevorzugt werden. Andere +\fIGrößen\fP werden beim Speichern in den \fB.xz\fP\-Headern aufgerundet. +.TP +\fBlc=\fP\fIlc\fP +gibt die Anzahl der literalen Kontextbits an. Das Minimum ist 0 und das +Maximum 4; der Standardwert ist 3. Außerdem darf die Summe von \fIlc\fP und +\fIlp\fP nicht größer als 4 sein. +.IP "" +Alle Bytes, die nicht als Übereinstimmungen kodiert werden können, werden +als Literale kodiert. Solche Literale sind einfache 8\-bit\-Bytes, die jeweils +für sich kodiert werden. +.IP "" +Bei der Literalkodierung wird angenommen, dass die höchsten \fIlc\fP\-Bits des +zuvor unkomprimierten Bytes mit dem nächsten Byte in Beziehung stehen. Zum +Beispiel folgt in typischen englischsprachigen Texten auf einen +Großbuchstaben ein Kleinbuchstabe und auf einen Kleinbuchstaben +üblicherweise wieder ein Kleinbuchstabe. Im US\-ASCII\-Zeichensatz sind die +höchsten drei Bits 010 für Großbuchstaben und 011 für Kleinbuchstaben. Wenn +\fIlc\fP mindestens 3 ist, kann die literale Kodierung diese Eigenschaft der +unkomprimierten Daten ausnutzen. +.IP "" +Der Vorgabewert (3) ist üblicherweise gut. Wenn Sie die maximale Kompression +erreichen wollen, versuchen Sie \fBlc=4\fP. Manchmal hilft es ein wenig, doch +manchmal verschlechtert es die Kompression. Im letzteren Fall versuchen Sie +zum Beispiel auch\& \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +gibt die Anzahl der literalen Positionsbits an. Das Minimum ist 0 und das +Maximum 4; die Vorgabe ist 0. +.IP "" +\fILp\fP beeinflusst, welche Art der Ausrichtung der unkomprimierten Daten beim +Kodieren von Literalen angenommen wird. Siehe \fIpb\fP weiter unten für weitere +Informationen zur Ausrichtung. +.TP +\fBpb=\fP\fIAnzahl\fP +legt die Anzahl der Positions\-Bits fest. Das Minimum ist 0 und das Maximum +4; Standard ist 2. +.IP "" +\fIPb\fP beeinflusst, welche Art der Ausrichtung der unkomprimierten Daten +generell angenommen wird. Standardmäßig wird eine Vier\-Byte\-Ausrichtung +angenommen (2^\fIpb\fP=2^2=4), was oft eine gute Wahl ist, wenn es keine +bessere Schätzung gibt. +.IP "" +Wenn die Ausrichtung bekannt ist, kann das entsprechende Setzen von \fIpb\fP +die Dateigröße ein wenig verringern. Wenn Textdateien zum Beispiel eine +Ein\-Byte\-Ausrichtung haben (US\-ASCII, ISO\-8859\-*, UTF\-8), kann das Setzen +von \fBpb=0\fP die Kompression etwas verbessern. Für UTF\-16\-Text ist \fBpb=1\fP +eine gute Wahl. Wenn die Ausrichtung eine ungerade Zahl wie beispielsweise 3 +Byte ist, könnte \fBpb=0\fP die beste Wahl sein. +.IP "" +Obwohl die angenommene Ausrichtung mit \fIpb\fP und \fIlp\fP angepasst werden +kann, bevorzugen LZMA1 und LZMA2 noch etwas die 16\-Byte\-Ausrichtung. Das +sollten Sie vielleicht beim Design von Dateiformaten berücksichtigen, die +wahrscheinlich oft mit LZMA1 oder LZMA2 komprimiert werden. +.TP +\fBmf=\fP\fIÜf\fP +Der Übereinstimmungsfinder hat einen großen Einfluss auf die Geschwindigkeit +des Kodierers, den Speicherbedarf und das +Kompressionsverhältnis. Üblicherweise sind auf Hash\-Ketten basierende +Übereinstimmungsfinder schneller als jene, die mit Binärbäumen arbeiten. Die +Vorgabe hängt von der \fIVoreinstellungsstufe\fP ab: 0 verwendet \fBhc3\fP, 1\-3 +verwenden \fBhc4\fP und der Rest verwendet \fBbt4\fP. +.IP "" +Die folgenden Übereinstimmungsfinder werden unterstützt. Die Formeln zur +Ermittlung des Speicherverbrauchs sind grobe Schätzungen, die der Realität +am nächsten kommen, wenn \fIWörterbuch\fP eine Zweierpotenz ist. +.RS +.TP +\fBhc3\fP +Hash\-Kette mit 2\- und 3\-Byte\-Hashing +.br +Minimalwert für \fInice\fP: 3 +.br +Speicherbedarf: +.br +\fIdict\fP * 7,5 (falls \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 5,5 + 64 MiB (falls \fIdict\fP > 16 MiB) +.TP +\fBhc4\fP +Hash\-Kette mit 2\-, 3\- und 4\-Byte\-Hashing +.br +Minimaler Wert für \fInice\fP: 4 +.br +Speicherbedarf: +.br +\fIdict\fP * 7,5 (falls \fIdict\fP <= 32 MiB ist); +.br +\fIdict\fP * 6,5 (falls \fIdict\fP > 32 MiB ist) +.TP +\fBbt2\fP +Binärbaum mit 2\-Byte\-Hashing +.br +Minimaler Wert für \fInice\fP: 2 +.br +Speicherverbrauch: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Binärbaum mit 2\- und 3\-Byte\-Hashing +.br +Minimalwert für \fInice\fP: 3 +.br +Speicherbedarf: +.br +\fIdict\fP * 11,5 (falls \fIdict\fP <= 16 MiB ist); +.br +\fIdict\fP * 9,5 + 64 MiB (falls \fIdict\fP > 16 MiB ist) +.TP +\fBbt4\fP +Binärbaum mit 2\-, 3\- und 4\-Byte\-Hashing +.br +Minimaler Wert für \fInice\fP: 4 +.br +Speicherbedarf: +.br +\fIdict\fP * 11,5 (falls \fIdict\fP <= 32 MiB ist); +.br +\fIdict\fP * 10,5 (falls \fIdict\fP > 32 MiB ist) +.RE +.TP +\fBmode=\fP\fIModus\fP +gibt die Methode zum Analysieren der vom Übereinstimmungsfinder gelieferten +Daten an. Als \fIModi\fP werden \fBfast\fP und \fBnormal\fP unterstützt. Die Vorgabe +ist \fBfast\fP für die \fIVoreinstellungsstufen\fP 0\-3 und \fBnormal\fP für die +\fIVoreinstellungsstufen\fP 4\-9. +.IP "" +Üblicherweise wird \fBfast\fP mit Hashketten\-basierten Übereinstimmungsfindern +und \fBnormal\fP mit Binärbaum\-basierten Übereinstimmungsfindern verwendet. So +machen es auch die \fIVoreinstellungsstufen\fP. +.TP +\fBnice=\fP\fInice\fP +gibt an, was als annehmbarer Wert für eine Übereinstimmung angesehen werden +kann. Wenn eine Übereinstimmung gefunden wird, die mindestens diesen +\fInice\fP\-Wert hat, sucht der Algorithmus nicht weiter nach besseren +Übereinstimmungen. +.IP "" +Der \fInice\fP\-Wert kann 2\-273 Byte sein. Höhere Werte tendieren zu einem +besseren Kompressionsverhältnis, aber auf Kosten der Geschwindigkeit. Die +Vorgabe hängt von der \fIVoreinstellungsstufe\fP ab. +.TP +\fBdepth=\fP\fITiefe\fP +legt die maximale Suchtiefe im Übereinstimmungsfinder fest. Vorgegeben ist +der spezielle Wert 0, der den Kompressor veranlasst, einen annehmbaren Wert +für \fITiefe\fP aus \fIÜf\fP und \fInice\fP\-Wert zu bestimmen. +.IP "" +Die angemessene \fITiefe\fP für Hash\-Ketten ist 4\-100 und 16\-1000 für +Binärbäume. Hohe Werte für die \fITiefe\fP können den Kodierer bei einigen +Dateien extrem verlangsamen. Vermeiden Sie es, die \fITiefe\fP über einen Wert +von 100 zu setzen, oder stellen Sie sich darauf ein, die Kompression +abzubrechen, wenn sie zu lange dauert. +.RE +.IP "" +Beim Dekodieren von Rohdatenströmen (\fB\-\-format=raw\fP) benötigt LZMA2 nur die +Wörterbuch\-\fIGröße\fP. LZMA1 benötigt außerdem \fIlc\fP, \fIlp\fP und \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIOptionen\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIOptionen\fP] +.PD +fügt ein »Branch/Call/Jump«\-(BCJ\-)Filter zur Filterkette hinzu. Diese Filter +können nicht als letzter Filter in der Filterkette verwendet werden. +.IP "" +Ein BCJ\-Filter wandelt relative Adressen im Maschinencode in deren absolute +Gegenstücke um. Die Datengröße wird dadurch nicht geändert, aber die +Redundanz erhöht, was LZMA2 dabei helfen kann, eine um 10 bis 15% kleinere +\&\fB.xz\fP\-Datei zu erstellen. Die BCJ\-Filter sind immer reversibel, daher +verursacht die Anwendung eines BCJ\-Filters auf den falschen Datentyp keinen +Datenverlust, wobei aber das Kompressionsverhältnis etwas schlechter werden +könnte. Die BCJ\-Filter sind sehr schnell und verbrauchen nur wenig mehr +Speicher. +.IP "" +Diese BCJ\-Filter haben bekannte Probleme mit dem Kompressionsverhältnis: +.RS +.IP \(bu 3 +In einigen Dateitypen, die ausführbaren Code enthalten (zum Beispiel +Objektdateien, statische Bibliotheken und Linux\-Kernelmodule), sind die +Adressen in den Anweisungen mit Füllwerten gefüllt. Diese BCJ\-Filter führen +dennoch die Adressumwandlung aus, wodurch die Kompression bei diesen Dateien +schlechter wird. +.IP \(bu 3 +Falls ein BCJ\-Filter auf ein Archiv angewendet wird, ist es möglich, dass +das Kompressionsverhältnis schlechter als ohne Filter wird. Falls es +beispielsweise ähnliche oder sogar identische ausführbare Dateien gibt, dann +werden diese durch die Filterung wahrscheinlich »unähnlicher« und +verschlechtern dadurch das Kompressionsverhältnis. Der Inhalt +nicht\-ausführbarer Dateien im gleichen Archiv kann sich ebenfalls darauf +auswirken. In der Praxis werden Sie durch Versuche mit oder ohne BCJ\-Filter +selbst herausfinden müssen, was situationsbezogen besser ist. +.RE +.IP "" +Verschiedene Befehlssätze haben unterschiedliche Ausrichtungen: Die +ausführbare Datei muss in den Eingabedateien einem Vielfachen dieses Wertes +entsprechen, damit dieser Filter funktioniert. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filter;Ausrichtung;Hinweise +x86;1;32\-Bit oder 64\-Bit x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096\-Byte\-Ausrichtung ist optimal +PowerPC;4;Nur Big Endian +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Da die BCJ\-gefilterten Daten üblicherweise mit LZMA2 komprimiert sind, kann +das Kompressionsverhältnis dadurch etwas verbessert werden, dass die +LZMA2\-Optionen so gesetzt werden, dass sie der Ausrichtung des gewählten +BCJ\-Filters entsprechen. Beispiele: +.RS +.IP \(bu 3 +Der IA\-64\-Filter hat eine 16\-Byte\-Ausrichtung, daher ist \fBpb=4,lp=4,lc=0\fP +für LZMA2 passend (2^4=16). +.IP \(bu 3 +RISC\-V\-Code hat eine 2\-Byte\- oder 4\-Byte\-Ausrichtung, abhängig davon, ob die +Datei 16\-bit\-komprimierte Instruktionen enthält (die C\-Erweiterung). Wenn +16\-bit\-Instruktionen verwendet werden, ist \fBpb=2,lp=1,lc=3\fP oder +\fBpb=1,lp=1,lc=3\fP passend. Wenn keine 16\-bit\-Instruktionen vorhanden sind, +ist \fBpb=2,lp=2,lc=2\fP am besten. Mit \fBreadelf \-h\fP können Sie überprüfen, ob +»RVC« in der »Flags«\-Zeile auftritt. +.IP \(bu 3 +ARM64 hat stets eine 4\-Byte\-Ausrichtung, daher ist \fBpb=2,lp=2,lc=2\fP am +besten. +.IP \(bu 3 +Der x86\-Filter stellt eine Ausnahme dar. Es ist üblicherweise eine gute +Wahl, bei den Voreinstellungen von LZMA2 (\fBpb=2,lp=0,lc=3\fP) zu bleiben, +wenn Sie ausführbare x86\-Dateien komprimieren +.RE +.IP "" +Alle BCJ\-Filter unterstützen die gleichen \fIOptionen\fP: +.RS +.TP +\fBstart=\fP\fIVersatz\fP +gibt den Start\-\fIVersatz\fP an, der bei der Umwandlung zwischen relativen und +absoluten Adressen verwendet wird. Der \fIVersatz\fP muss ein Vielfaches der +Filterausrichtung sein (siehe die Tabelle oben). Der Standardwert ist 0. In +der Praxis ist dieser Standardwert gut; die Angabe eines benutzerdefinierten +\fIVersatzes\fP ist fast immer unnütz. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIOptionen\fP] +fügt den Delta\-Filter zur Filterkette hinzu. Der Delta\-Filter kann nicht als +letzter Filter in der Filterkette verwendet werden. +.IP "" +Gegenwärtig wird nur eine einfache, Byte\-bezogene Delta\-Berechnung +unterstützt. Beim Komprimieren von zum Beispiel unkomprimierten +Bitmap\-Bildern oder unkomprimierten PCM\-Audiodaten kann es jedoch sinnvoll +sein. Dennoch können für spezielle Zwecke entworfene Algorithmen deutlich +bessere Ergebnisse als Delta und LZMA2 liefern. Dies trifft insbesondere auf +Audiodaten zu, die sich zum Beispiel mit \fBflac\fP(1) schneller und besser +komprimieren lassen. +.IP "" +Unterstützte \fIOptionen\fP: +.RS +.TP +\fBdist=\fP\fIAbstand\fP +gibt den \fIAbstand\fP der Delta\-Berechnung in Byte an. Zulässige Werte für den +\fIAbstand\fP sind 1 bis 256. Der Vorgabewert ist 1. +.IP "" +Zum Beispiel wird mit \fBdist=2\fP und der 8\-Byte\-Eingabe A1 B1 A2 B3 A3 B5 A4 +B7 die Ausgabe A1 B1 01 02 01 02 01 02 sein. +.RE +. +.SS "Andere Optionen" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +unterdrückt Warnungen und Hinweise. Geben Sie dies zweimal an, um auch +Fehlermeldungen zu unterdrücken. Diese Option wirkt sich nicht auf den +Exit\-Status aus. Das bedeutet, das selbst bei einer unterdrückten Warnung +der Exit\-Status zur Anzeige einer Warnung dennoch verwendet wird. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +bewirkt ausführliche Ausgaben. Wenn die Standardfehlerausgabe mit einem +Terminal verbunden ist, zeigt \fBxz\fP den Fortschritt an. Durch zweimalige +Angabe von \fB\-\-verbose\fP wird die Ausgabe noch ausführlicher. +.IP "" +Der Fortschrittsanzeiger stellt die folgenden Informationen dar: +.RS +.IP \(bu 3 +Der Prozentsatz des Fortschritts wird angezeigt, wenn die Größe der +Eingabedatei bekannt ist. Das bedeutet, dass der Prozentsatz in +Weiterleitungen (Pipes) nicht angezeigt werden kann. +.IP \(bu 3 +Menge der erzeugten komprimierten Daten (bei der Kompression) oder der +verarbeiteten Daten (bei der Dekompression). +.IP \(bu 3 +Menge der verarbeiteten unkomprimierten Daten (bei der Kompression) oder der +erzeugten Daten (bei der Dekompression). +.IP \(bu 3 +Kompressionsverhältnis, das mittels Dividieren der Menge der bisher +komprimierten Daten durch die Menge der bisher verarbeiteten unkomprimierten +Daten ermittelt wird. +.IP \(bu 3 +Kompressions\- oder Dekompressionsgeschwindigkeit. Diese wird anhand der +Menge der unkomprimierten verarbeiteten Daten (bei der Kompression) oder der +Menge der erzeugten Daten (bei der Dekompression) pro Sekunde gemessen. Die +Anzeige startet einige Sekunden nachdem \fBxz\fP mit der Verarbeitung der Datei +begonnen hat. +.IP \(bu 3 +Die vergangene Zeit im Format M:SS oder H:MM:SS. +.IP \(bu 3 +Die geschätzte verbleibende Zeit wird nur angezeigt, wenn die Größe der +Eingabedatei bekannt ist und bereits einige Sekunden vergangen sind, nachdem +\fBxz\fP mit der Verarbeitung der Datei begonnen hat. Die Zeit wird in einem +weniger präzisen Format ohne Doppelpunkte angezeigt, zum Beispiel 2 min 30 +s. +.RE +.IP "" +Wenn die Standardfehlerausgabe kein Terminal ist, schreibt \fBxz\fP mit +\fB\-\-verbose\fP nach dem Komprimieren oder Dekomprimieren der Datei in einer +einzelnen Zeile den Dateinamen, die komprimierte Größe, die unkomprimierte +Größe, das Kompressionsverhältnis und eventuell auch die Geschwindigkeit und +die vergangene Zeit in die Standardfehlerausgabe. Die Geschwindigkeit und +die vergangene Zeit werden nur angezeigt, wenn der Vorgang mindestens ein +paar Sekunden gedauert hat. Wurde der Vorgang nicht beendet, zum Beispiel +weil ihn der Benutzer abgebrochen hat, wird außerdem der Prozentsatz des +erreichten Verarbeitungsfortschritts aufgenommen, sofern die Größe der +Eingabedatei bekannt ist. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +setzt den Exit\-Status nicht auf 2, selbst wenn eine Bedingung erfüllt ist, +die eine Warnung gerechtfertigt hätte. Diese Option wirkt sich nicht auf die +Ausführlichkeitsstufe aus, daher müssen sowohl \fB\-\-quiet\fP als auch +\fB\-\-no\-warn\fP angegeben werden, um einerseits keine Warnungen anzuzeigen und +andererseits auch den Exit\-Status nicht zu ändern. +.TP +\fB\-\-robot\fP +gibt Meldungen in einem maschinenlesbaren Format aus. Dadurch soll das +Schreiben von Frontends erleichtert werden, die \fBxz\fP anstelle von Liblzma +verwenden wollen, was in verschiedenen Skripten der Fall sein kann. Die +Ausgabe mit dieser aktivierten Option sollte über mehrere +\fBxz\fP\-Veröffentlichungen stabil sein. Details hierzu finden Sie im Abschnitt +\fBROBOTER\-MODUS\fP. +.TP +\fB\-\-info\-memory\fP +zeigt in einem menschenlesbaren Format an, wieviel physischen Speicher (RAM) +und wie viele Prozessor\-Threads das System nach Annahme von \fBxz\fP hat, sowie +die Speicherbedarfsbegrenzung für Kompression und Dekompression, und beendet +das Programm erfolgreich. +.TP +\fB\-h\fP, \fB\-\-help\fP +zeigt eine Hilfemeldung mit den am häufigsten genutzten Optionen an und +beendet das Programm erfolgreich. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +zeigt eine Hilfemeldung an, die alle Funktionsmerkmale von \fBxz\fP beschreibt +und beendet das Programm erfolgreich. +.TP +\fB\-V\fP, \fB\-\-version\fP +zeigt die Versionsnummer von \fBxz\fP und Liblzma in einem menschenlesbaren +Format an. Um eine maschinell auswertbare Ausgabe zu erhalten, geben Sie +\fB\-\-robot\fP vor \fB\-\-version\fP an. +. +.SH ROBOTER\-MODUS +Der Roboter\-Modus wird mit der Option \fB\-\-robot\fP aktiviert. Er bewirkt, dass +die Ausgabe von \fBxz\fP leichter von anderen Programmen ausgewertet werden +kann. Gegenwärtig wird \fB\-\-robot\fP nur zusammen mit \fB\-\-list\fP, +\fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP und \fB\-\-version\fP unterstützt. In der +Zukunft wird dieser Modus auch für Kompression und Dekompression +unterstützt. +. +.SS Listenmodus +\fBxz \-\-robot \-\-list\fP verwendet eine durch Tabulatoren getrennte Ausgabe. In +der ersten Spalte jeder Zeile bezeichnet eine Zeichenkette den Typ der +Information, die in dieser Zeile enthalten ist: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Dies ist stets die erste Zeile, wenn eine Datei aufgelistet wird. Die zweite +Spalte in der Zeile enthält den Dateinamen. +.TP +\fBfile\fP +Diese Zeile enthält allgemeine Informationen zur \fB.xz\fP\-Datei. Diese Zeile +wird stets nach der \fBname\fP\-Zeile ausgegeben. +.TP +\fBstream\fP +Dieser Zeilentyp wird nur verwendet, wenn \fB\-\-verbose\fP angegeben wurde. Es +gibt genau so viele \fBstream\fP\-Zeilen, wie Datenströme in der \fB.xz\fP\-Datei +enthalten sind. +.TP +\fBblock\fP +Dieser Zeilentyp wird nur verwendet, wenn \fB\-\-verbose\fP angegeben wurde. Es +gibt so viele \fBblock\fP\-Zeilen, wie Blöcke in der \fB.xz\fP\-Datei. Die +\fBblock\fP\-Zeilen werden nach allen \fBstream\fP\-Zeilen angezeigt; verschiedene +Zeilentypen werden nicht verschachtelt. +.TP +\fBsummary\fP +Dieser Zeilentyp wird nur verwendet, wenn \fB\-\-verbose\fP zwei Mal angegeben +wurde. Diese Zeile wird nach allen \fBblock\fP\-Zeilen ausgegeben. Wie die +\fBfile\fP\-Zeile enthält die \fBsummary\fP\-Zeile allgemeine Informationen zur +\&\fB.xz\fP\-Datei. +.TP +\fBtotals\fP +Diese Zeile ist immer die letzte der Listenausgabe. Sie zeigt die +Gesamtanzahlen und \-größen an. +.PP +Die Spalten der \fBfile\fP\-Zeilen: +.PD 0 +.RS +.IP 2. 4 +Anzahl der Datenströme in der Datei +.IP 3. 4 +Gesamtanzahl der Blöcke in den Datenströmen +.IP 4. 4 +Komprimierte Größe der Datei +.IP 5. 4 +Unkomprimierte Größe der Datei +.IP 6. 4 +Das Kompressionsverhältnis, zum Beispiel \fB0.123\fP. Wenn das Verhältnis über +9.999 liegt, werden drei Minuszeichen (\fB\-\-\-\fP) anstelle des +Kompressionsverhältnisses angezeigt. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Durch Kommata getrennte Liste der Namen der Integritätsprüfungen. Für die +bekannten Überprüfungstypen werden folgende Zeichenketten verwendet: +\fBNone\fP, \fBCRC32\fP, \fBCRC64\fP und \fBSHA\-256\fP. \fBUnknown\-\fP\fIN\fP wird verwendet, +wobei \fIN\fP die Kennung der Überprüfung als Dezimalzahl angibt (ein\- oder +zweistellig). +.IP 8. 4 +Gesamtgröße der Datenstromauffüllung in der Datei +.RE +.PD +.PP +Die Spalten der \fBstream\fP\-Zeilen: +.PD 0 +.RS +.IP 2. 4 +Datenstromnummer (der erste Datenstrom ist 1) +.IP 3. 4 +Anzahl der Blöcke im Datenstrom +.IP 4. 4 +Komprimierte Startposition +.IP 5. 4 +Unkomprimierte Startposition +.IP 6. 4 +Komprimierte Größe (schließt die Datenstromauffüllung nicht mit ein) +.IP 7. 4 +Unkomprimierte Größe +.IP 8. 4 +Kompressionsverhältnis +.IP 9. 4 +Name der Integritätsprüfung +.IP 10. 4 +Größe der Datenstromauffüllung +.RE +.PD +.PP +Die Spalten der \fBblock\fP\-Zeilen: +.PD 0 +.RS +.IP 2. 4 +Anzahl der in diesem Block enthaltenen Datenströme +.IP 3. 4 +Blocknummer relativ zum Anfang des Datenstroms (der erste Block ist 1) +.IP 4. 4 +Blocknummer relativ zum Anfang der Datei +.IP 5. 4 +Komprimierter Startversatz relativ zum Beginn der Datei +.IP 6. 4 +Unkomprimierter Startversatz relativ zum Beginn der Datei +.IP 7. 4 +Komprimierte Gesamtgröße des Blocks (einschließlich Header) +.IP 8. 4 +Unkomprimierte Größe +.IP 9. 4 +Kompressionsverhältnis +.IP 10. 4 +Name der Integritätsprüfung +.RE +.PD +.PP +Wenn \fB\-\-verbose\fP zwei Mal angegeben wurde, werden zusätzliche Spalten in +die \fBblock\fP\-Zeilen eingefügt. Diese werden mit einem einfachen \fB\-\-verbose\fP +nicht angezeigt, da das Ermitteln dieser Informationen viele Suchvorgänge +erfordert und daher recht langsam sein kann: +.PD 0 +.RS +.IP 11. 4 +Wert der Integritätsprüfung in hexadezimaler Notation +.IP 12. 4 +Block\-Header\-Größe +.IP 13. 4 +Block\-Schalter: \fBc\fP gibt an, dass die komprimierte Größe verfügbar ist, und +\fBu\fP gibt an, dass die unkomprimierte Größe verfügbar ist. Falls der +Schalter nicht gesetzt ist, wird stattdessen ein Bindestrich (\fB\-\fP) +angezeigt, um die Länge der Zeichenkette beizubehalten. In Zukunft könnten +neue Schalter am Ende der Zeichenkette hinzugefügt werden. +.IP 14. 4 +Größe der tatsächlichen komprimierten Daten im Block. Ausgeschlossen sind +hierbei die Block\-Header, die Blockauffüllung und die Prüffelder. +.IP 15. 4 +Größe des Speichers (in Byte), der zum Dekomprimieren dieses Blocks mit +dieser \fBxz\fP\-Version benötigt wird. +.IP 16. 4 +Filterkette. Beachten Sie, dass die meisten der bei der Kompression +verwendeten Optionen nicht bekannt sein können, da in den \fB.xz\fP\-Headern nur +die für die Dekompression erforderlichen Optionen gespeichert sind. +.RE +.PD +.PP +Die Spalten der \fBsummary\fP\-Zeilen: +.PD 0 +.RS +.IP 2. 4 +Größe des Speichers (in Byte), der zum Dekomprimieren dieser Datei mit +dieser \fBxz\fP\-Version benötigt wird. +.IP 3. 4 +\fByes\fP oder \fBno\fP geben an, ob in allen Block\-Headern sowohl die +komprimierte als auch die unkomprimierte Größe gespeichert ist. +.PP +\fISeit\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Minimale \fBxz\fP\-Version, die zur Dekompression der Datei erforderlich ist +.RE +.PD +.PP +Die Spalten der \fBtotals\fP\-Zeile: +.PD 0 +.RS +.IP 2. 4 +Anzahl der Datenströme +.IP 3. 4 +Anzahl der Blöcke +.IP 4. 4 +Komprimierte Größe +.IP 5. 4 +Unkomprimierte Größe +.IP 6. 4 +Durchschnittliches Kompressionsverhältnis +.IP 7. 4 +Durch Kommata getrennte Liste der Namen der Integritätsprüfungen, die in den +Dateien präsent waren. +.IP 8. 4 +Größe der Datenstromauffüllung +.IP 9. 4 +Anzahl der Dateien. Dies dient dazu, die Reihenfolge der vorigen Spalten an +die in den \fBfile\fP\-Zeilen anzugleichen. +.PD +.RE +.PP +Wenn \fB\-\-verbose\fP zwei Mal angegeben wird, werden zusätzliche Spalten in die +\fBtotals\fP\-Zeile eingefügt: +.PD 0 +.RS +.IP 10. 4 +Maximale Größe des Speichers (in Byte), der zum Dekomprimieren der Dateien +mit dieser \fBxz\fP\-Version benötigt wird. +.IP 11. 4 +\fByes\fP oder \fBno\fP geben an, ob in allen Block\-Headern sowohl die +komprimierte als auch die unkomprimierte Größe gespeichert ist. +.PP +\fISeit\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Minimale \fBxz\fP\-Version, die zur Dekompression der Datei erforderlich ist +.RE +.PD +.PP +Zukünftige Versionen könnten neue Zeilentypen hinzufügen, weiterhin könnten +auch in den vorhandenen Zeilentypen weitere Spalten hinzugefügt werden, aber +die existierenden Spalten werden nicht geändert. +. +.SS Filterhilfe +\fBxz \-\-robot \-\-filters\-help\fP gibt die unterstützten Filter im folgenden +Format aus: +.PP +\fIFilter\fP\fB:\fP\fIOption\fP\fB=<\fP\fIWert\fP\fB>,\fP\fIOption\fP\fB=<\fP\fIWert\fP\fB>\fP +… +.TP +\fIFilter\fP +Name des Filters +.TP +\fIOption\fP +Name der filterspezifischen Option +.TP +\fIWert\fP +Der numerische \fIWert\fP erscheint als Bereich +\fB<\fP\fIMinimum\fP\fB\-\fP\fIMaximum\fP\fB>\fP. Die Auswahl des +Zeichenketten\-\fIWert\fPs wird in \fB< >\fP eingeschlossen und durch \fB|\fP +getrennt. +.PP +Jeder Filter wird in einer separaten Zeile ausgegeben. +. +.SS "Informationen zur Speicherbedarfsbegrenzung" +\fBxz \-\-robot \-\-info\-memory\fP gibt eine einzelne Zeile mit mehreren durch +Tabulatoren getrennten Spalten aus: +.IP 1. 4 +Gesamter physischer Speicher (RAM) in Byte. +.IP 2. 4 +Speicherbedarfsbegrenzung für die Kompression in Byte +(\fB\-\-memlimit\-compress\fP). Ein spezieller Wert von \fB0\fP bezeichnet die +Standardeinstellung, die im Einzelthread\-Modus bedeutet, dass keine +Begrenzung vorhanden ist. +.IP 3. 4 +Speicherbedarfsbegrenzung für die Dekompression in Byte +(\fB\-\-memlimit\-decompress\fP). Ein spezieller Wert von \fB0\fP bezeichnet die +Standardeinstellung, die im Einzelthread\-Modus bedeutet, dass keine +Begrenzung vorhanden ist. +.IP 4. 4 +Seit \fBxz\fP 5.3.4alpha: Die Speichernutzung für Multithread\-Dekompression in +Byte (\fB\-\-memlimit\-mt\-decompress\fP). Dies ist niemals \fB0\fP, da ein +systemspezifischer Vorgabewert (gezeigt in Spalte 5) verwendet wird, falls +keine Grenze ausdrücklich angegeben wurde. Dies ist außerdem niemals größer +als der Wert in in Spalte 3, selbst wenn mit \fB\-\-memlimit\-mt\-decompress\fP ein +größerer Wert angegeben wurde. +.IP 5. 4 +Seit \fBxz\fP 5.3.4alpha: Eine systemspezifisch vorgegebene Begrenzung des +Speicherverbrauchs, die zur Begrenzung der Anzahl der Threads beim +Komprimieren mit automatischer Anzahl der Threads (\fB\-\-threads=0\fP) und wenn +keine Speicherbedarfsbegrenzung angegeben wurde (\fB\-\-memlimit\-compress\fP) +verwendet wird. Dies wird auch als Standardwert für +\fB\-\-memlimit\-mt\-decompress\fP verwendet. +.IP 6. 4 +Seit \fBxz\fP 5.3.4alpha: Anzahl der verfügbaren Prozessorthreads. +.PP +In der Zukunft könnte die Ausgabe von \fBxz \-\-robot \-\-info\-memory\fP weitere +Spalten enthalten, aber niemals mehr als eine einzelne Zeile. +. +.SS Version +\fBxz \-\-robot \-\-version\fP gibt die Versionsnummern von \fBxz\fP und Liblzma im +folgenden Format aus: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Hauptversion. +.TP +\fIYYY\fP +Unterversion. Gerade Zahlen bezeichnen eine stabile Version. Ungerade Zahlen +bezeichnen Alpha\- oder Betaversionen. +.TP +\fIZZZ\fP +Patch\-Stufe für stabile Veröffentlichungen oder einfach nur ein Zähler für +Entwicklungsversionen. +.TP +\fIS\fP +Stabilität. 0 ist Alpha, 1 ist Beta und 2 ist stabil. \fIS\fP sollte immer 2 +sein, wenn \fIYYY\fP eine gerade Zahl ist. +.PP +\fIXYYYZZZS\fP sind in beiden Zeilen gleich, sofern \fBxz\fP und Liblzma aus der +gleichen Veröffentlichung der XZ\-Utils stammen. +.PP +Beispiele: 4.999.9beta ist \fB49990091\fP und 5.0.0 is \fB50000002\fP. +. +.SH EXIT\-STATUS +.TP +\fB0\fP +Alles ist in Ordnung. +.TP +\fB1\fP +Ein Fehler ist aufgetreten. +.TP +\fB2\fP +Es ist etwas passiert, das eine Warnung rechtfertigt, aber es sind keine +tatsächlichen Fehler aufgetreten. +.PP +In die Standardausgabe geschriebene Hinweise (keine Warnungen oder Fehler), +welche den Exit\-Status nicht beeinflussen. +. +.SH UMGEBUNGSVARIABLEN +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP wertet eine durch Leerzeichen getrennte Liste von Optionen in den +Umgebungsvariablen \fBXZ_DEFAULTS\fP und \fBXZ_OPT\fP aus (in dieser Reihenfolge), +bevor die Optionen aus der Befehlszeile ausgewertet werden. Beachten Sie, +dass beim Auswerten der Umgebungsvariablen nur Optionen berücksichtigt +werden; alle Einträge, die keine Optionen sind, werden stillschweigend +ignoriert. Die Auswertung erfolgt mit \fBgetopt_long\fP(3), welches auch für +die Befehlszeilenargumente verwendet wird. +.PP +\fBWarnung:\fP Durch Setzen dieser Umgebungsvariablen könnte man effektiv +Programme und Skripte modifizieren, die \fBxz\fP ausführen. Meist ist es +sicher, die Speichernutzungsbegrenzung und Kompressionsoptionen über die +Umgebungsvariablen zu setzen. Dennoch können einige Optionen Skripte +beeinflussen. Ein typisches Beispiel ist die Option \fB\-\-help\fP, die einen +Hilfetext anzeigt, anstatt eine Datei zu komprimieren oder zu +dekomprimieren. Weniger augenfällige Beispiele sind die Optionen \fB\-\-quiet\fP +und \fB\-\-verbose\fP. In vielen Fällen funktioniert es gut, den +Fortschrittsindikator mit \fB\-\-verbose\fP zu aktivieren, aber in einigen +Situationen können die zusätzlichen Meldungen Probleme verursachen. Die +Ausführlichkeitsstufe beeinflusst auch das Verhalten von \fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Benutzerspezifische oder systemweite Standardoptionen. Typischerweise werden +diese in einem Shell\-Initialisierungsskript gesetzt, um die +Speicherbedarfsbegrenzung von \fBxz\fP standardmäßig zu aktivieren oder die +Anzahl der Threads festzulegen. Außer bei Shell\-Initialisierungsskripten und +in ähnlichen Spezialfällen sollte die Variable \fBXZ_DEFAULTS\fP in Skripten +niemals gesetzt oder außer Kraft gesetzt werden. +.TP +\fBXZ_OPT\fP +Dies dient der Übergabe von Optionen an \fBxz\fP, wenn es nicht möglich ist, +die Optionen direkt in der Befehlszeile von \fBxz\fP zu übergeben. Dies ist der +Fall, wenn \fBxz\fP von einem Skript oder Dienstprogramm ausgeführt wird, zum +Beispiel GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Skripte können \fBXZ_OPT\fP zum Beispiel zum Setzen skriptspezifischer +Standard\-Kompressionsoptionen verwenden. Es ist weiterhin empfehlenswert, +Benutzern die Außerkraftsetzung von \fBXZ_OPT\fP zu erlauben, falls dies +angemessen ist. Zum Beispiel könnte in \fBsh\fP(1)\-Skripten Folgendes stehen: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "KOMPATIBILITÄT ZU DEN LZMA\-UTILS" +Die Befehlszeilensyntax von \fBxz\fP ist praktisch eine Obermenge der von +\fBlzma\fP, \fBunlzma\fP und \fBlzcat\fP in den LZMA\-Utils der Versionen 4.32.x. In +den meisten Fällen sollte es möglich sein, die LZMA\-Utils durch die XZ\-Utils +zu ersetzen, ohne vorhandene Skripte ändern zu müssen. Dennoch gibt es +einige Inkompatibilitäten, die manchmal Probleme verursachen können. +. +.SS "Voreinstellungsstufen zur Kompression" +Die Nummerierung der Voreinstellungsstufen der Kompression ist in \fBxz\fP und +den LZMA\-Utils unterschiedlich. Der wichtigste Unterschied ist die Zuweisung +der Wörterbuchgrößen zu den verschiedenen Voreinstellungsstufen. Die +Wörterbuchgröße ist etwa gleich dem Speicherbedarf bei der Dekompression. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Stufe;xz;LZMA\-Utils +\-0;256 KiB;nicht verfügbar +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Die Unterschiede in der Wörterbuchgröße beeinflussen auch den Speicherbedarf +bei der Kompression, aber es gibt noch einige andere Unterschiede zwischen +den LZMA\-Utils und den XZ\-Utils, die die Kluft noch vergrößern: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Stufe;xz;LZMA\-Utils 4.32.x +\-0;3 MiB;nicht verfügbar +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Die standardmäßige Voreinstellungsstufe in den LZMA\-Utils ist \fB\-7\fP, während +diese in den XZ\-Utils \fB\-6\fP ist, daher verwenden beide standardmäßig ein 8 +MiB großes Wörterbuch. +. +.SS "Vor\- und Nachteile von .lzma\-Dateien als Datenströme" +Die unkomprimierte Größe der Datei kann in den \fB.lzma\fP\-Headern gespeichert +werden. Die LZMA\-Utils tun das beim Komprimieren gewöhnlicher Dateien. Als +Alternative kann die unkomprimierte Größe als unbekannt markiert und eine +Nutzdatenende\-Markierung (end\-of\-payload) verwendet werden, um anzugeben, wo +der Dekompressor stoppen soll. Die LZMA\-Utils verwenden diese Methode, wenn +die unkomprimierte Größe unbekannt ist, was beispielsweise in Pipes +(Befehlsverkettungen) der Fall ist. +.PP +\fBxz\fP unterstützt die Dekompression von \fB.lzma\fP\-Dateien mit oder ohne +Nutzdatenende\-Markierung, aber alle von \fBxz\fP erstellten \fB.lzma\fP\-Dateien +verwenden diesen Nutzdatenende\-Markierung, wobei die unkomprimierte Größe in +den \fB.lzma\fP\-Headern als unbekannt markiert wird. Das könnte in einigen +unüblichen Situationen ein Problem sein. Zum Beispiel könnte ein +\&\fB.lzma\fP\-Dekompressor in einem Gerät mit eingebettetem System nur mit +Dateien funktionieren, deren unkomprimierte Größe bekannt ist. Falls Sie auf +dieses Problem stoßen, müssen Sie die LZMA\-Utils oder das LZMA\-SDK +verwenden, um \fB.lzma\fP\-Dateien mit bekannter unkomprimierter Größe zu +erzeugen. +. +.SS "Nicht unterstützte .lzma\-Dateien" +Das \fB.lzma\fP\-Format erlaubt \fIlc\fP\-Werte bis zu 8 und \fIlp\fP\-Werte bis zu +4. Die LZMA\-Utils können Dateien mit beliebigem \fIlc\fP und \fIlp\fP +dekomprimieren, aber erzeugen immer Dateien mit \fBlc=3\fP und \fBlp=0\fP. Das +Erzeugen von Dateien mit anderem \fIlc\fP und \fIlp\fP ist mit \fBxz\fP und mit dem +LZMA\-SDK möglich. +.PP +Die Implementation des LZMA\-Filters in liblzma setzt voraus, dass die Summe +von \fIlc\fP und \fIlp\fP nicht größer als 4 ist. Daher können \fB.lzma\fP\-Dateien, +welche diese Begrenzung überschreiten, mit \fBxz\fP nicht dekomprimiert werden. +.PP +Die LZMA\-Utils erzeugen nur \fB.lzma\fP\-Dateien mit einer Wörterbuchgröße von +2^\fIn\fP (einer Zweierpotenz), aber akzeptieren Dateien mit einer beliebigen +Wörterbuchgröße. Liblzma akzeptiert nur \fB.lzma\fP\-Dateien mit einer +Wörterbuchgröße von 2^\fIn\fP oder 2^\fIn\fP + 2^(\fIn\fP\-1). Dies dient zum +Verringern von Fehlalarmen beim Erkennen von \fB.lzma\fP\-Dateien. +.PP +Diese Einschränkungen sollten in der Praxis kein Problem sein, da praktisch +alle \fB.lzma\fP\-Dateien mit Einstellungen komprimiert wurden, die Liblzma +akzeptieren wird. +. +.SS "Angehängter Datenmüll" +Bei der Dekompression ignorieren die LZMA\-Utils stillschweigend alles nach +dem ersten \fB.lzma\fP\-Datenstrom. In den meisten Situationen ist das ein +Fehler. Das bedeutet auch, dass die LZMA\-Utils die Dekompression verketteter +\&\fB.lzma\fP\-Dateien nicht unterstützen. +.PP +Wenn nach dem ersten \fB.lzma\fP\-Datenstrom Daten verbleiben, erachtet \fBxz\fP +die Datei als beschädigt, es sei denn, die Option \fB\-\-single\-stream\fP wurde +verwendet. Dies könnte die Ausführung von Skripten beeinflussen, die davon +ausgehen, dass angehängter Datenmüll ignoriert wird. +. +.SH ANMERKUNGEN +. +.SS "Die komprimierte Ausgabe kann variieren" +Die exakte komprimierte Ausgabe, die aus der gleichen unkomprimierten +Eingabedatei erzeugt wird, kann zwischen den Versionen der XZ\-Utils +unterschiedlich sein, selbst wenn die Kompressionsoptionen identisch +sind. Das kommt daher, weil der Kodierer verbessert worden sein könnte +(hinsichtlich schnellerer oder besserer Kompression), ohne das Dateiformat +zu beeinflussen. Die Ausgabe kann sogar zwischen verschiedenen Programmen +der gleichen Version der XZ\-Utils variieren, wenn bei der Erstellung des +Binärprogramms unterschiedliche Optionen verwendet wurden. +.PP +Sobald \fB\-\-rsyncable\fP implementiert wurde, bedeutet das, dass die sich +ergebenden Dateien nicht notwendigerweise mit Rsync abgeglichen werden +können, außer wenn die alte und neue Datei mit der gleichen \fBxz\fP\-Version +erzeugt wurden. Das Problem kann beseitigt werden, wenn ein Teil der +Encoder\-Implementierung eingefroren wird, um die mit Rsync abgleichbare +Ausgabe über \fBxz\fP\-Versionsgrenzen hinweg stabil zu halten. +. +.SS "Eingebettete .xz\-Dekompressoren" +Eingebettete \fB.xz\fP\-Dekompressor\-Implementierungen wie XZ Embedded +unterstützen nicht unbedingt Dateien, die mit anderen Integritätsprüfungen +(\fIPrüfung\fP\-Typen) als \fBnone\fP und \fBcrc32\fP erzeugt wurden. Da +\fB\-\-check=crc64\fP die Voreinstellung ist, müssen Sie \fB\-\-check=none\fP oder +\fB\-\-check=crc32\fP verwenden, wenn Sie Dateien für eingebettete Systeme +erstellen. +.PP +Außerhalb eingebetteter Systeme unterstützen die Dekompressoren des +\&\fB.xz\fP\-Formats alle \fIPrüfung\fP\-Typen oder sind mindestens in der Lage, die +Datei zu dekomprimieren, ohne deren Integrität zu prüfen, wenn die bestimmte +\fIPrüfung\fP nicht verfügbar ist. +.PP +XZ Embedded unterstützt BCJ\-Filter, aber nur mit dem vorgegebenen +Startversatz. +. +.SH BEISPIELE +. +.SS Grundlagen +Komprimiert die Datei \fIfoo\fP mit der Standard\-Kompressionsstufe (\fB\-6\fP) zu +\fIfoo.xz\fP und entfernt \fIfoo\fP nach erfolgreicher Kompression: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +\fIbar.xz\fP in \fIbar\fP dekomprimieren und \fIbar.xz\fP selbst dann nicht löschen, +wenn die Dekompression erfolgreich war: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +\fIbaz.tar.xz\fP mit der Voreinstellung \fB\-4e\fP (\fB\-4 \-\-extreme\fP) erzeugen, was +langsamer ist als die Vorgabe \fB\-6\fP, aber weniger Speicher für Kompression +und Dekompression benötigt (48\ MiB beziehungsweise 5\ MiB): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Eine Mischung aus komprimierten und unkomprimierten Dateien kann mit einem +einzelnen Befehl dekomprimiert in die Standardausgabe geschrieben werden: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Parallele Kompression von vielen Dateien" +Auf GNU\- und *BSD\-Systemen können \fBfind\fP(1) und \fBxargs\fP(1) zum +Parallelisieren der Kompression vieler Dateien verwendet werden: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Die Option \fB\-P\fP von \fBxargs\fP(1) legt die Anzahl der parallelen +\fBxz\fP\-Prozesse fest. Der beste Wert für die Option \fB\-n\fP hängt davon ab, wie +viele Dateien komprimiert werden sollen. Wenn es sich nur um wenige Dateien +handelt, sollte der Wert wahrscheinlich 1 sein; bei Zehntausenden von +Dateien kann 100 oder noch mehr angemessener sein, um die Anzahl der +\fBxz\fP\-Prozesse zu beschränken, die \fBxargs\fP(1) schließlich erzeugen wird. +.PP +Die Option \fB\-T1\fP für \fBxz\fP dient dazu, den Einzelthread\-Modus zu erzwingen, +da \fBxargs\fP(1) zur Steuerung des Umfangs der Parallelisierung verwendet +wird. +. +.SS Roboter\-Modus +Berechnen, wie viel Byte nach der Kompression mehrerer Dateien insgesamt +eingespart wurden: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Ein Skript könnte abfragen wollen, ob es ein \fBxz\fP verwendet, das aktuell +genug ist. Das folgende \fBsh\fP(1)\-Skript prüft, ob die Versionsnummer des +Dienstprogramms \fBxz\fP mindestens 5.0.0 ist. Diese Methode ist zu alten +Beta\-Versionen kompatibel, welche die Option \fB\-\-robot\fP nicht unterstützen: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Ihre Version von Xz ist zu alt." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Eine Speicherbedarfsbegrenzung für die Dekompression mit \fBXZ_OPT\fP setzen, +aber eine bereits gesetzte Begrenzung nicht erhöhen: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Benutzerdefinierte Filterketten für die Kompression" +Der einfachste Anwendungsfall für benutzerdefinierte Filterketten ist die +Anpassung von LZMA2\-Voreinstellungsstufen. Das kann nützlich sein, weil die +Voreinstellungen nur einen Teil der potenziell sinnvollen Kombinationen aus +Kompressionseinstellungen abdecken. +.PP +Die KompCPU\-Spalten der Tabellen aus den Beschreibungen der Optionen \fB\-0\fP … +\fB\-9\fP und \fB\-\-extreme\fP sind beim Anpassen der LZMA2\-Voreinstellungen +nützlich. Diese sind die relevanten Teile aus diesen zwei Tabellen: +.RS +.PP +.TS +tab(;); +c c +n n. +Voreinst.;KomprCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Wenn Sie wissen, dass eine Datei für eine gute Kompression ein etwas +größeres Wörterbuch benötigt (zum Beispiel 32 MiB), aber Sie sie schneller +komprimieren wollen, als dies mit \fBxz \-8\fP geschehen würde, kann eine +Voreinstellung mit einem niedrigen KompCPU\-Wert (zum Beispiel 1) dahingehend +angepasst werden, ein größeres Wörterbuch zu verwenden: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Mit bestimmten Dateien kann der obige Befehl schneller sein als \fBxz \-6\fP, +wobei die Kompression deutlich besser wird. Dennoch muss betont werden, dass +nur wenige Dateien von einem größeren Wörterbuch profitieren, wenn der +KompCPU\-Wert niedrig bleibt. Der offensichtlichste Fall, in dem ein größeres +Wörterbuch sehr hilfreich sein kann, ist ein Archiv, das einander sehr +ähnliche Dateien enthält, die jeweils wenigstens einige Megabyte groß +sind. Das Wörterbuch muss dann deutlich größer sein als die einzelne Datei, +damit LZMA2 den größtmöglichen Vorteil aus den Ähnlichkeiten der aufeinander +folgenden Dateien zieht. +.PP +Wenn hoher Speicherbedarf für Kompression und Dekompression kein Problem ist +und die zu komprimierende Datei mindestens einige Hundert Megabyte groß ist, +kann es sinnvoll sein, ein noch größeres Wörterbuch zu verwenden, als die 64 +MiB, die mit \fBxz \-9\fP verwendet werden würden: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Die Verwendung von \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) wie im obigen Beispiel +kann nützlich sein, um den Speicherbedarf für Kompressor und Dekompressor zu +sehen. Denken Sie daran, dass ein Wörterbuch, das größer als die +unkomprimierte Datei ist, Speicherverschwendung wäre. Daher ist der obige +Befehl für kleine Dateien nicht sinnvoll. +.PP +Manchmal spielt die Kompressionszeit keine Rolle, aber der Speicherbedarf +bei der Dekompression muss gering gehalten werden, zum Beispiel um die Datei +auf eingebetteten Systemen dekomprimieren zu können. Der folgende Befehl +verwendet \fB\-6e\fP (\fB\-6 \-\-extreme\fP) als Basis und setzt die Wörterbuchgröße +auf nur 64\ KiB. Die sich ergebende Datei kann mit XZ Embedded (aus diesem +Grund ist dort \fB\-\-check=crc32\fP) mit nur etwa 100\ KiB Speicher +dekomprimiert werden. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Wenn Sie so viele Byte wie möglich herausquetschen wollen, kann die +Anpassung der Anzahl der literalen Kontextbits (\fIlc\fP) und der Anzahl der +Positionsbits (\fIpb\fP) manchmal hilfreich sein. Auch die Anpassung der Anzahl +der literalen Positionsbits (\fIlp\fP) könnte helfen, aber üblicherweise sind +\fIlc\fP und \fIpb\fP wichtiger. Wenn ein Quellcode\-Archiv zum Beispiel +hauptsächlich ASCII\-Text enthält, könnte ein Aufruf wie der folgende eine +etwas kleinere Datei (etwa 0,1\ %) ergeben als mit \fBxz \-6e\fP (versuchen Sie +es auch \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Die Verwendung eines anderen Filters mit LZMA2 kann die Kompression bei +verschiedenen Dateitypen verbessern. So könnten Sie eine gemeinsam genutzte +Bibliothek der Architekturen x86\-32 oder x86\-64 mit dem BCJ\-Filter für x86 +komprimieren: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Beachten Sie, dass die Reihenfolge der Filteroptionen von Bedeutung +ist. Falls \fB\-\-x86\fP nach \fB\-\-lzma2\fP angegeben wird, gibt \fBxz\fP einen Fehler +aus, weil nach LZMA2 kein weiterer Filter sein darf und auch weil der +BCJ\-Filter für x86 nicht als letzter Filter in der Filterkette gesetzt +werden darf. +.PP +Der Delta\-Filter zusammen mit LZMA2 kann bei Bitmap\-Bildern gute Ergebnisse +liefern. Er sollte üblicherweise besser sein als PNG, welches zwar einige +fortgeschrittene Filter als ein simples delta bietet, aber für die +eigentliche Kompression »Deflate« verwendet. +.PP +Das Bild muss in einem unkomprimierten Format gespeichert werden, zum +Beispiel als unkomprimiertes TIFF. Der Abstandsparameter des Delta\-Filters +muss so gesetzt werden, dass er der Anzahl der Bytes pro Pixel im Bild +entspricht. Zum Beispiel erfordert ein 24\-Bit\-RGB\-Bitmap \fBdist=3\fP, außerdem +ist es gut, \fBpb=0\fP an LZMA2 zu übergeben, um die 3\-Byte\-Ausrichtung zu +berücksichtigen: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Wenn sich mehrere Bilder in einem einzelnen Archiv befinden (zum Beispiel\& +\&\fB.tar\fP), funktioniert der Delta\-Filter damit auch, sofern alle Bilder im +Archiv die gleiche Anzahl Bytes pro Pixel haben. +. +.SH "SIEHE AUCH" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA\-SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzmadec.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzmadec.1 new file mode 100644 index 0000000000000000000000000000000000000000..e2812d18124aed0b02009ce0d9d3657a1c1c2dc5 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzmadec.1 @@ -0,0 +1,88 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.\" German translation for xz-man. +.\" Mario Blättermann , 2015, 2019-2020, 2022-2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDEC 1 "8. August 2024" Tukaani XZ\-Dienstprogramme +.SH BEZEICHNUNG +xzdec, lzmadec \- Kleine Dekompressoren für .xz und .lzma +.SH ÜBERSICHT +\fBxzdec\fP [\fIOption…\fP] [\fIDatei…\fP] +.br +\fBlzmadec\fP [\fIOption…\fP] [\fIDatei…\fP] +.SH BESCHREIBUNG +\fBxzdec\fP ist ein auf Liblzma basierendes Nur\-Dekompressionswerkzeug für +\&\fB.xz\fP\-Dateien (und \fBnur\fP für \fB.xz\fP\-Dateien). \fBxzdec\fP ist als direkter +Ersatz für \fBxz\fP(1) in jenen Situationen konzipiert, wo ein Skript \fBxz \-\-decompress \-\-stdout\fP (und eventuelle einige andere höufig genutzte +Optionen) zum Dekomprimieren von \fB.xz\fP\-Dateien. \fBlzmadec\fP ist weitgehend +identisch zu \fBxzdec\fP, mit der Ausnahme, dass \fBlzmadec\fP \fB.lzma\fP\-Dateien +anstelle von \fB.xz\fP\-Dateien unterstützt. +.PP +Um die Größe der ausführbaren Datei zu reduzieren, unterstützt \fBxzdec\fP +weder Multithreading noch Lokalisierung. Außerdem liest es keine Optionen +aus den Umgebungsvariablen \fBXZ_DEFAULTS\fP und \fBXZ_OPT\fP. \fBxzdec\fP +unterstützt keine zwischenzeitlichen Fortschrittsinformationen: Das Senden +von \fBSIGINFO\fP an \fBxzdec\fP hat keine Auswirkungen, jedoch beendet \fBSIGUSR1\fP +den Prozess, anstatt Fortschrittsinformationen anzuzeigen. +.SH OPTIONEN +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +ist zwecks Kompatibilität zu \fBxz\fP(1) vorhanden; wird ignoriert. \fBxzdec\fP +unterstützt nur Dekompression. +.TP +\fB\-k\fP, \fB\-\-keep\fP +ist zwecks Kompatibilität zu \fBxz\fP(1) vorhanden; wird ignoriert. \fBxzdec\fP +erzeugt oder entfernt niemals Dateien. +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +ist zwecks Kompatibilität zu \fBxz\fP(1) vorhanden; wird ignoriert. \fBxzdec\fP +schreibt die dekomprimierten Daten immer in die Standardausgabe. +.TP +\fB\-q\fP, \fB\-\-quiet\fP +hat bei einmaliger Angabe keine Wirkung, da \fBxzdec\fP niemals Warnungen oder +sonstige Meldungen anzeigt. Wenn Sie dies zweimal angeben, werden +Fehlermeldungen unterdrückt. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +ist zwecks Kompatibilität zu \fBxz\fP(1) vorhanden; wird ignoriert. \fBxzdec\fP +verwendet niemals den Exit\-Status 2. +.TP +\fB\-h\fP, \fB\-\-help\fP +zeigt eine Hilfemeldung an und beendet das Programm erfolgreich. +.TP +\fB\-V\fP, \fB\-\-version\fP +zeigt die Versionsnummer von \fBxzdec\fP und liblzma an. +.SH EXIT\-STATUS +.TP +\fB0\fP +Alles ist in Ordnung. +.TP +\fB1\fP +Ein Fehler ist aufgetreten. +.PP +\fBxzdec\fP gibt keine Warnmeldungen wie \fBxz\fP(1) aus, daher wird der +Exit\-Status 2 von \fBxzdec\fP nicht verwendet. +.SH ANMERKUNGEN +Verwenden Sie \fBxz\fP(1) anstelle von \fBxzdec\fP oder \fBlzmadec\fP im normalen +täglichen Gebrauch. \fBxzdec\fP oder \fBlzmadec\fP sind nur für Situationen +gedacht, in denen ein kleinerer Dekompressor statt des voll ausgestatteten +\fBxz\fP(1) wichtig ist. +.PP +\fBxzdec\fP und \fBlzmadec\fP sind nicht wirklich extrem klein. Die Größe kann +durch Deaktivieren von Funktionen bei der Kompilierung von Liblzma weiter +verringert werden, aber das sollte nicht für ausführbare Dateien getan +werden, die in typischen Betriebssystemen ausgeliefert werden, außer in den +Distributionen für eingebettete Systeme. Wenn Sie einen wirklich winzigen +Dekompressor für \fB.xz\fP\-Dateien brauchen, sollten Sie stattdessen XZ +Embedded in Erwägung ziehen. +.SH "SIEHE AUCH" +\fBxz\fP(1) +.PP +XZ Embedded: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzmainfo.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzmainfo.1 new file mode 100644 index 0000000000000000000000000000000000000000..10eba6fb5d58a0887c13913bcf47389b53e464f3 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzmainfo.1 @@ -0,0 +1,46 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.\" German translation for xz-man. +.\" Mario Blättermann , 2015, 2019-2020, 2022-2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH LZMAINFO 1 "30. Juni 2013" Tukaani XZ\-Dienstprogramme +.SH BEZEICHNUNG +lzmainfo \- im .lzma\-Dateikopf enthaltene Informationen anzeigen +.SH ÜBERSICHT +\fBlzmainfo\fP [\fB\-\-help\fP] [\fB\-\-version\fP] [\fIDatei …\fP] +.SH BESCHREIBUNG +\fBlzmainfo\fP zeigt die im \fB.lzma\fP\-Dateikopf enthaltenen Informationen an. Es +liest die ersten 13 Bytes aus der angegebenen \fIDatei\fP, dekodiert den +Dateikopf und gibt das Ergebnis in die Standardausgabe in einem +menschenlesbaren Format aus. Falls keine \fIDatei\fPen angegeben werden oder +die \fIDatei\fP als \fB\-\fP übergeben wird, dann wird aus der Standardeingabe +gelesen. +.PP +In der Regel sind die unkomprimierte Größe der Daten und die Größe des +Wörterbuchs am bedeutsamsten. Die unkomprimierte Größe kann nur dann +angezeigt werden, wenn die Datei im \fB.lzma\fP\-Format kein Datenstrom ist. Die +Größe des für die Dekompression nötigen Speichers beträgt einige Dutzend +Kilobyte zuzüglich der Größe des Inhaltsverzeichnisses. +.PP +\fBlzmainfo\fP ist in den XZ\-Dienstprogrammen hauptsächlich zur Kompatibilität +zu den LZMA\-Dienstprogrammen enthalten. +.SH EXIT\-STATUS +.TP +\fB0\fP +Alles ist in Ordnung. +.TP +\fB1\fP +Ein Fehler ist aufgetreten. +.SH FEHLER +\fBlzmainfo\fP verwendet \fBMB\fP, während das korrekte Suffix \fBMiB\fP (2^20 Bytes) +wäre. Damit wird die Kompatibilität zu den LZMA\-Dienstprogrammen +gewährleistet. +.SH "SIEHE AUCH" +\fBxz\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzmore.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzmore.1 new file mode 100644 index 0000000000000000000000000000000000000000..91b850d8376887b8a29747e945a5f0da83a34dd6 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/lzmore.1 @@ -0,0 +1,52 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" German translation for xz-man. +.\" Mario Blättermann , 2015, 2019-2020, 2022-2025. +.\" +.\" (Note that this file is based on xzless.1 instead of gzip's zmore.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZMORE 1 "6. März 2025" Tukaani XZ\-Dienstprogramme +.SH BEZEICHNUNG +xzmore, lzmore \- mit xz oder lzma komprimierte (Text\-)Dateien lesen +. +.SH ÜBERSICHT +\fBxzmore\fP [\fIDatei\fP …] +.br +\fBlzmore\fP [\fIDatei\fP …] (VERALTET) +. +.SH BESCHREIBUNG +\fBxzmore\fP zeigt Text aus komprimierten Dateien mit Hilfe des Pagers +(Textanzeigeprogramms) \fBmore\fP(1) in einem Terminal an. Von \fBxz\fP(1) +unterstützte Dateien werden dekomprimiert; für andere Dateien wird +angenommen, dass sie bereits in unkomprimierter Form vorliegen. Wenn keine +\fIDateien\fP angegeben werden, liest \fBxzmore\fP aus der Standardeingabe. Im +\fBmore\fP(1)\-Handbuch finden Sie Informationen zu den Tastaturbefehlen. +.PP +Beachten Sie, dass Zurückrollen nicht möglich sein könnte, abhängig von der +Implementierung von \fBmore\fP(1). Das kommt daher, dass \fBxzmore\fP eine Pipe +verwendet, um die dekomprimierten Daten an \fBmore\fP(1) zu +übergeben. \fBxzless\fP(1) verwendet \fBless\fP(1), welches fortgeschrittenere +Funktionen bietet. +.PP +Der Befehl \fBlzmore\fP dient der Abwärtskompatibilität zu den +LZMA\-Dienstprogrammen. Er wird als veraltet angesehen und wird in einer +zukünftigen Version entfernt. +. +.SH UMGEBUNGSVARIABLEN +.TP +.\" TRANSLATORS: Don't translate the uppercase PAGER. +.\" It is a name of an environment variable. +\fBPAGER\fP +Falls die Umgebungsvariable \fBPAGER\fP gesetzt ist, wird deren Wert als Pager +(Textanzeigeprogramm) anstelle von \fBmore\fP(1) verwendet. +. +.SH "SIEHE AUCH" +\fBmore\fP(1), \fBxz\fP(1), \fBxzless\fP(1), \fBzmore\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/unlzma.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/unlzma.1 new file mode 100644 index 0000000000000000000000000000000000000000..39e92ce91c266281499195e6ac04416517932d31 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/unlzma.1 @@ -0,0 +1,2117 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" German translation for xz-man. +.\" Mario Blättermann , 2015, 2019-2020, 2022-2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 "8. März 2025" Tukaani XZ\-Dienstprogramme +. +.SH BEZEICHNUNG +xz, unxz, xzcat, lzma, unlzma, lzcat \- .xz\- und .lzma\-Dateien komprimieren +oder dekomprimieren +. +.SH ÜBERSICHT +\fBxz\fP [\fIOption…\fP] [\fIDatei…\fP] +. +.SH BEFEHLSALIASE +\fBunxz\fP ist gleichbedeutend mit \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP ist gleichbedeutend mit \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP ist gleichbedeutend mit \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP ist gleichbedeutend mit \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP ist gleichbedeutend mit \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Wenn Sie Skripte schreiben, die Dateien dekomprimieren, sollten Sie stets +den Namen \fBxz\fP mit den entsprechenden Argumenten (\fBxz \-d\fP oder \fBxz \-dc\fP) +anstelle der Namen \fBunxz\fP und \fBxzcat\fP verwenden. +. +.SH BESCHREIBUNG +\fBxz\fP ist ein Allzweckwerkzeug zur Datenkompression, dessen +Befehlszeilensyntax denen von \fBgzip\fP(1) und \fBbzip2\fP(1) ähnelt. Das native +Dateiformat ist das \fB.xz\fP\-Format, aber das veraltete, von den +LZMA\-Dienstprogrammen verwendete Format sowie komprimierte Rohdatenströme +ohne Containerformat\-Header werden ebenfalls unterstützt. Außerdem wird die +Dekompression des von \fBlzip\fP verwendeten \fB.lz\fP\-Formats unterstützt. +.PP +\fBxz\fP komprimiert oder dekomprimiert jede \fIDatei\fP entsprechend des +gewählten Vorgangsmodus. Falls entweder \fB\-\fP oder keine Datei angegeben ist, +liest \fBxz\fP aus der Standardeingabe und leitet die verarbeiteten Dateien in +die Standardausgabe. Wenn die Standardausgabe kein Terminal ist, verweigert +\fBxz\fP das Schreiben komprimierter Daten in die Standardausgabe. Dabei wird +eine Fehlermeldung angezeigt und die \fIDatei\fP übersprungen. Ebenso +verweigert \fBxz\fP das Lesen komprimierter Daten aus der Standardeingabe, wenn +diese ein Terminal ist. +.PP +\fIDateien\fP, die nicht als \fB\-\fP angegeben sind, werden in eine neue Datei +geschrieben, deren Name aus dem Namen der Quell\-\fIDatei\fP abgeleitet wird +(außer wenn \fB\-\-stdout\fP angegeben ist): +.IP \(bu 3 +Bei der Kompression wird das Suffix des Formats der Zieldatei (\fB.xz\fP oder +\&\fB.lzma\fP) an den Namen der Quelldatei angehängt und so der Name der +Zieldatei gebildet. +.IP \(bu 3 +Bei der Dekompression wird das Suffix \fB.xz\fP, \fB.lzma\fP oder \fB.lz\fP vom +Dateinamen entfernt und so der Name der Zieldatei gebildet. Außerdem erkennt +\fBxz\fP die Suffixe \fB.txz\fP und \fB.tlz\fP und ersetzt diese durch \fB.tar\fP. +.PP +Wenn die Zieldatei bereits existiert, wird eine Fehlermeldung angezeigt und +die \fIDatei\fP übersprungen. +.PP +Außer beim Schreiben in die Standardausgabe zeigt \fBxz\fP eine Warnung an und +überspringt die \fIDatei\fP, wenn eine der folgenden Bedingungen zutreffend +ist: +.IP \(bu 3 +Die \fIDatei\fP ist keine reguläre Datei. Symbolischen Verknüpfungen wird nicht +gefolgt und diese daher nicht zu den regulären Dateien gezählt. +.IP \(bu 3 +Die \fIDatei\fP hat mehr als eine harte Verknüpfung. +.IP \(bu 3 +Für die \fIDatei\fP ist das »setuid«\-, »setgid«\- oder »sticky«\-Bit gesetzt. +.IP \(bu 3 +Der Aktionsmodus wird auf Kompression gesetzt und die \fIDatei\fP hat bereits +das Suffix des Zieldateiformats (\fB.xz\fP oder \fB.txz\fP beim Komprimieren in +das \fB.xz\fP\-Format und \fB.lzma\fP oder \fB.tlz\fP beim Komprimieren in das +\&\fB.lzma\fP\-Format). +.IP \(bu 3 +Der Aktionsmodus wird auf Dekompression gesetzt und die \fIDatei\fP hat nicht +das Suffix eines der unterstützten Zieldateiformate (\fB.xz\fP, \fB.txz\fP, +\&\fB.lzma\fP, \fB.tlz\fP oder \fB.lz\fP). +.PP +Nach erfolgreicher Kompression oder Dekompression der \fIDatei\fP kopiert \fBxz\fP +Eigentümer, Gruppe, Zugriffsrechte, Zugriffszeit und Änderungszeit aus der +Ursprungs\-\fIDatei\fP in die Zieldatei. Sollte das Kopieren der Gruppe +fehlschlagen, werden die Zugriffsrechte so angepasst, dass jenen Benutzern +der Zugriff auf die Zieldatei verwehrt bleibt, die auch keinen Zugriff auf +die Ursprungs\-\fIDatei\fP hatten. Das Kopieren anderer Metadaten wie +Zugriffssteuerlisten oder erweiterter Attribute wird von \fBxz\fP noch nicht +unterstützt. +.PP +Sobald die Zieldatei erfolgreich geschlossen wurde, wird die +Ursprungs\-\fIDatei\fP entfernt. Dies wird durch die Option \fB\-\-keep\fP +verhindert. Die Ursprungs\-\fIDatei\fP wird niemals entfernt, wenn die Ausgabe +in die Standardausgabe geschrieben wird oder falls ein Fehler auftritt. +.PP +Durch Senden der Signale \fBSIGINFO\fP oder \fBSIGUSR1\fP an den \fBxz\fP\-Prozess +werden Fortschrittsinformationen in den Fehlerkanal der Standardausgabe +geleitet. Dies ist nur eingeschränkt hilfreich, wenn die +Standardfehlerausgabe ein Terminal ist. Mittels \fB\-\-verbose\fP wird ein +automatisch aktualisierter Fortschrittsanzeiger angezeigt. +. +.SS Speicherbedarf +In Abhängigkeit von den gewählten Kompressionseinstellungen bewegt sich der +Speicherverbrauch zwischen wenigen hundert Kilobyte und mehreren +Gigabyte. Die Einstellungen bei der Kompression einer Datei bestimmen dabei +den Speicherbedarf bei der Dekompression. Die Dekompression benötigt +üblicherweise zwischen 5\ % und 20\ % des Speichers, der bei der Kompression +der Datei erforderlich war. Beispielsweise benötigt die Dekompression einer +Datei, die mit \fBxz \-9\fP komprimiert wurde, gegenwärtig etwa 65\ MiB +Speicher. Es ist jedoch auch möglich, dass \fB.xz\fP\-Dateien mehrere Gigabyte +an Speicher zur Dekompression erfordern. +.PP +Insbesondere für Benutzer älterer Systeme wird eventuell ein sehr großer +Speicherbedarf ärgerlich sein. Um unangenehme Überraschungen zu vermeiden, +verfügt \fBxz\fP über eine eingebaute Begrenzung des Speicherbedarfs, die +allerdings in der Voreinstellung deaktiviert ist. Zwar verfügen einige +Betriebssysteme über eingebaute Möglichkeiten zur prozessabhängigen +Speicherbegrenzung, doch diese sind zu unflexibel (zum Beispiel kann +\fBulimit\fP(1) beim Begrenzen des virtuellen Speichers \fBmmap\fP(2) +beeinträchtigen). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Die Begrenzung des Speicherbedarfs kann mit der Befehlszeilenoption +\fB\-\-memlimit=\fP\fIBegrenzung\fP aktiviert werden. Oft ist es jedoch bequemer, +die Begrenzung durch Setzen der Umgebungsvariable \fBXZ_DEFAULTS\fP +standardmäßig zu aktivieren, zum Beispiel +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Die Begrenzungen können getrennt für +Kompression und Dekompression mittels \fB\-\-memlimit\-compress=\fP\fIBegrenzung\fP +und \fB\-\-memlimit\-decompress=\fP\fIBegrenzung\fP festgelegt werden. Die Verwendung +einer solchen Option außerhalb der Variable \fBXZ_DEFAULTS\fP ist kaum +sinnvoll, da \fBxz\fP in einer einzelnen Aktion nicht gleichzeitig Kompression +und Dekompression ausführen kann und \fB\-\-memlimit=\fP\fIBegrenzung\fP (oder \fB\-M\fP +\fIBegrenzung\fP) lässt sich einfacher in der Befehlszeile eingeben. +.PP +Wenn die angegebene Speicherbegrenzung bei der Dekompression überschritten +wird, schlägt der Vorgang fehl und \fBxz\fP zeigt eine Fehlermeldung an. Wird +die Begrenzung bei der Kompression überschritten, dann versucht \fBxz\fP die +Einstellungen entsprechend anzupassen, außer wenn \fB\-\-format=raw\fP oder +\fB\-\-no\-adjust\fP angegeben ist. Auf diese Weise schlägt die Aktion nicht fehl, +es sei denn, die Begrenzung wurde sehr niedrig angesetzt. Die Anpassung der +Einstellungen wird schrittweise vorgenommen, allerdings entsprechen die +Schritte nicht den Voreinstellungen der Kompressionsstufen. Das bedeutet, +wenn beispielsweise die Begrenzung nur geringfügig unter den Anforderungen +für \fBxz \-9\fP liegt, werden auch die Einstellungen nur wenig angepasst und +nicht vollständig herunter zu den Werten für \fBxz \-8\fP +. +.SS "Verkettung und Auffüllung von .xz\-Dateien" +Es ist möglich, \fB.xz\fP\-Dateien direkt zu verketten. Solche Dateien werden +von \fBxz\fP genauso dekomprimiert wie eine einzelne \fB.xz\fP\-Datei. +.PP +Es ist weiterhin möglich, eine Auffüllung zwischen den verketteten Teilen +oder nach dem letzten Teil einzufügen. Die Auffüllung muss aus Null\-Bytes +bestehen und deren Größe muss ein Vielfaches von vier Byte sein. Dies kann +zum Beispiel dann vorteilhaft sein, wenn die \fB.xz\fP\-Datei auf einem +Datenträger gespeichert wird, dessen Dateisystem die Dateigrößen in +512\-Byte\-Blöcken speichert. +.PP +Verkettung und Auffüllung sind für \fB.lzma\fP\-Dateien oder Rohdatenströme +nicht erlaubt. +. +.SH OPTIONEN +. +.SS "Ganzzahlige Suffixe und spezielle Werte" +An den meisten Stellen, wo ein ganzzahliges Argument akzeptiert wird, kann +ein optionales Suffix große Ganzzahlwerte einfacher darstellen. Zwischen +Ganzzahl und dem Suffix dürfen sich keine Leerzeichen befinden. +.TP +\fBKiB\fP +multipliziert die Ganzzahl mit 1.024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP und +\fBKB\fP werden als Synonyme für \fBKiB\fP akzeptiert. +.TP +\fBMiB\fP +multipliziert die Ganzzahl mit 1.048.576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP und \fBMB\fP +werden als Synonyme für \fBMiB\fP akzeptiert. +.TP +\fBGiB\fP +multipliziert die Ganzzahl mit 1.073.741.824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP und +\fBGB\fP werden als Synonyme für \fBGiB\fP akzeptiert. +.PP +Der spezielle Wert \fBmax\fP kann dazu verwendet werden, um den von der +jeweiligen Option akzeptierten maximalen Ganzzahlwert anzugeben. +. +.SS Aktionsmodus +Falls mehrere Aktionsmodi angegeben sind, wird der zuletzt angegebene +verwendet. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Kompression. Dies ist der voreingestellte Aktionsmodus, sofern keiner +angegeben ist und auch kein bestimmter Modus aus dem Befehlsnamen abgeleitet +werden kann (der Befehl \fBunxz\fP impliziert zum Beispiel \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Nach erfolgreicher Kompression wird die Quelldatei gelöscht, außer wenn in +die Standardausgabe geschrieben wird oder \fB\-\-keep\fP angegeben wurde. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Dekomprimieren. Nach erfolgreicher Dekompression wird die Quelldatei +gelöscht, außer wenn in die Standardausgabe geschrieben wird oder \fB\-\-keep\fP +angegeben wurde. +.TP +\fB\-t\fP, \fB\-\-test\fP +prüft die Integrität der komprimierten \fIDateien\fP. Diese Option ist +gleichbedeutend mit \fB\-\-decompress \-\-stdout\fP, außer dass die dekomprimierten +Daten verworfen werden, anstatt sie in die Standardausgabe zu leiten. Es +werden keine Dateien erstellt oder entfernt. +.TP +\fB\-l\fP, \fB\-\-list\fP +gibt Informationen zu den komprimierten \fIDateien\fP aus. Es werden keine +unkomprimierten Dateien ausgegeben und keine Dateien angelegt oder +entfernt. Im Listenmodus kann das Programm keine komprimierten Daten aus der +Standardeingabe oder anderen nicht durchsuchbaren Quellen lesen. +.IP "" +Die Liste zeigt in der Standardeinstellung grundlegende Informationen zu den +\fIDateien\fP an, zeilenweise pro Datei. Detailliertere Informationen erhalten +Sie mit der Option \fB\-\-verbose\fP. Wenn Sie diese Option zweimal angeben, +werden noch ausführlichere Informationen ausgegeben. Das kann den Vorgang +allerdings deutlich verlangsamen, da die Ermittlung der zusätzlichen +Informationen zahlreiche Suchvorgänge erfordert. Die Breite der +ausführlichen Ausgabe übersteigt 80 Zeichen, daher könnte die Weiterleitung +in beispielsweise\& \fBless\ \-S\fP sinnvoll sein, falls das Terminal nicht +breit genug ist. +.IP "" +Die exakte Ausgabe kann in verschiedenen \fBxz\fP\-Versionen und +Spracheinstellungen unterschiedlich sein. Wenn eine maschinell auswertbare +Ausgabe gewünscht ist, dann sollten Sie \fB\-\-robot \-\-list\fP verwenden. +. +.SS Aktionsattribute +.TP +\fB\-k\fP, \fB\-\-keep\fP +verhindert das Löschen der Eingabedateien. +.IP "" +Seit der \fBxz\fP\-Version 5.2.6 wird die Kompression oder Dekompression auch +dann ausgeführt, wenn die Eingabe ein symbolischer Link zu einer regulären +Datei ist, mehr als einen harten Link hat oder das »setuid«\-, »setgid«\- oder +»sticky«\-Bit gesetzt ist. Die genannten Bits werden nicht in die Zieldatei +kopiert. In früheren Versionen geschah dies nur mit \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Diese Option hat verschiedene Auswirkungen: +.RS +.IP \(bu 3 +Wenn die Zieldatei bereits existiert, wird diese vor der Kompression oder +Dekompression gelöscht. +.IP \(bu 3 +Die Kompression oder Dekompression wird auch dann ausgeführt, wenn die +Eingabe ein symbolischer Link zu einer regulären Datei ist, mehr als einen +harten Link hat oder das »setuid«\-, »setgid«\- oder »sticky«\-Bit gesetzt +ist. Die genannten Bits werden nicht in die Zieldatei kopiert. +.IP \(bu 3 +Wenn es zusammen mit \fB\-\-decompress\fP und \fB\-\-stdout\fP verwendet wird und +\fBxz\fP den Typ der Quelldatei nicht ermitteln kann, wird die Quelldatei +unverändert in die Standardausgabe kopiert. Dadurch kann \fBxzcat\fP \fB\-\-force\fP +für Dateien, die nicht mit \fBxz\fP komprimiert wurden, wie \fBcat\fP(1) verwendet +werden. Zukünftig könnte \fBxz\fP neue Dateikompressionsformate unterstützen, +wodurch \fBxz\fP mehr Dateitypen dekomprimieren kann, anstatt sie unverändert +in die Standardausgabe zu kopieren. Mit der Option \fB\-\-format=\fP\fIFormat\fP +können Sie \fBxz\fP anweisen, nur ein einzelnes Dateiformat zu dekomprimieren. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +schreibt die komprimierten oder dekomprimierten Daten in die Standardausgabe +anstatt in eine Datei. Dies impliziert \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +dekomprimiert nur den ersten \fB.xz\fP\-Datenstrom und ignoriert stillschweigend +weitere Eingabedaten, die möglicherweise dem Datenstrom +folgen. Normalerweise führt solcher anhängender Datenmüll dazu, dass \fBxz\fP +eine Fehlermeldung ausgibt. +.IP "" +\fBxz\fP dekomprimiert niemals mehr als einen Datenstrom aus \fB.lzma\fP\-Dateien +oder Rohdatenströmen, aber dennoch wird durch diese Option möglicherweise +vorhandener Datenmüll nach der \fB.lzma\fP\-Datei oder dem Rohdatenstrom +ignoriert. +.IP "" +Diese Option ist wirkungslos, wenn der Aktionsmodus nicht \fB\-\-decompress\fP +oder \fB\-\-test\fP ist. +.IP "" +Seit der Programmversion \fBxz\fP 5.7.1alpha impliziert \fB\-\-single\-stream\fP +zusätzlich die Option \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +verhindert die Erzeugung von Sparse\-Dateien. In der Voreinstellung versucht +\fBxz\fP, bei der Dekompression in eine reguläre Datei eine Sparse\-Datei zu +erzeugen, wenn die dekomprimierten Daten lange Abfolgen von binären Nullen +enthalten. Dies funktioniert auch beim Schreiben in die Standardausgabe, +sofern diese in eine reguläre Datei weitergeleitet wird und bestimmte +Zusatzbedingungen erfüllt sind, die die Aktion absichern. Die Erzeugung von +Sparse\-Dateien kann Plattenplatz sparen und beschleunigt die Dekompression +durch Verringerung der Ein\-/Ausgaben der Platte. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +verwendet \fI.suf\fP bei der Dekompression anstelle von \fB.xz\fP oder \fB.lzma\fP +als Suffix für die Zieldatei. Falls nicht in die Standardausgabe geschrieben +wird und die Quelldatei bereits das Suffix \fI.suf\fP hat, wird eine Warnung +angezeigt und die Datei übersprungen. +.IP "" +berücksichtigt bei der Dekompression zusätzlich zu Dateien mit den Suffixen +\&\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP oder \fB.lz\fP auch jene mit dem Suffix +\&\fI.suf\fP. Falls die Quelldatei das Suffix \fI.suf\fP hat, wird dieses entfernt +und so der Name der Zieldatei abgeleitet. +.IP "" +Beim Komprimieren oder Dekomprimieren von Rohdatenströmen mit +\fB\-\-format=raw\fP muss das Suffix stets angegeben werden, außer wenn die +Ausgabe in die Standardausgabe erfolgt. Der Grund dafür ist, dass es kein +vorgegebenes Suffix für Rohdatenströme gibt. +.TP +\fB\-\-files\fP[\fB=\fP\fIDatei\fP] +liest die zu verarbeitenden Dateinamen aus \fIDatei\fP. Falls keine \fIDatei\fP +angegeben ist, werden die Dateinamen aus der Standardeingabe +gelesen. Dateinamen müssen mit einem Zeilenumbruch beendet werden. Ein +Bindestrich (\fB\-\fP) wird als regulärer Dateiname angesehen und nicht als +Standardeingabe interpretiert. Falls Dateinamen außerdem als +Befehlszeilenargumente angegeben sind, werden diese vor den Dateinamen aus +der \fIDatei\fP verarbeitet. +.TP +\fB\-\-files0\fP[\fB=\fP\fIDatei\fP] +Dies ist gleichbedeutend mit \fB\-\-files\fP[\fB=\fP\fIDatei\fP], außer dass jeder +Dateiname mit einem Null\-Zeichen abgeschlossen werden muss. +. +.SS "Grundlegende Dateiformat\- und Kompressionsoptionen" +.TP +\fB\-F\fP \fIFormat\fP, \fB\-\-format=\fP\fIFormat\fP +gibt das \fIFormat\fP der zu komprimierenden oder dekomprimierenden Datei an: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Dies ist die Voreinstellung. Bei der Kompression ist \fBauto\fP gleichbedeutend +mit \fBxz\fP. Bei der Dekompression wird das Format der Eingabedatei +automatisch erkannt. Beachten Sie, dass Rohdatenströme, wie sie mit +\fB\-\-format=raw\fP erzeugt werden, nicht automatisch erkannt werden können. +.TP +\fBxz\fP +Die Kompression erfolgt in das \fB.xz\fP\-Dateiformat oder akzeptiert nur +\&\fB.xz\fP\-Dateien bei der Dekompression. +.TP +\fBlzma\fP, \fBalone\fP +Die Kompression erfolgt in das veraltete \fB.lzma\fP\-Dateiformat oder +akzeptiert nur \fB.lzma\fP\-Dateien bei der Dekompression. Der alternative Name +\fBalone\fP dient der Abwärtskompatibilität zu den LZMA\-Dienstprogrammen. +.TP +\fBlzip\fP +Akzeptiert nur \fB.lz\fP\-Dateien bei der Dekompression. Kompression wird nicht +unterstützt. +.IP "" +The \fB.lz\fP format versions 0 and 1 are supported. Version 0 files were +produced by \fBlzip\fP 1.3 and older. Such files aren't common but may be +found from file archives as a few source packages were released in this +format. People might have old personal files in this format too. +Decompression support for the format version 0 was removed in \fBlzip\fP 1.18. +\fBlzip\fP 1.4 and later create files in the format version 1. +.TP +\fBraw\fP +Komprimiert oder dekomprimiert einen Rohdatenstrom (ohne Header). Diese +Option ist nur für fortgeschrittene Benutzer bestimmt. Zum Dekodieren von +Rohdatenströmen müssen Sie die Option \fB\-\-format=raw\fP verwenden und die +Filterkette ausdrücklich angeben, die normalerweise in den (hier fehlenden) +Container\-Headern gespeichert worden wäre. +.RE +.TP +\fB\-C\fP \fIPrüfung\fP, \fB\-\-check=\fP\fIPrüfung\fP +gibt den Typ der Integritätsprüfung an. Die Prüfsumme wird aus den +unkomprimierten Daten berechnet und in der \fB.xz\fP\-Datei gespeichert. Diese +Option wird nur bei der Kompression in das \fB.xz\fP\-Format angewendet, da das +\&\fB.lzma\fP\-Format keine Integritätsprüfungen unterstützt. Die eigentliche +Integritätsprüfung erfolgt (falls möglich), wenn die \fB.xz\fP\-Datei +dekomprimiert wird. +.IP "" +Folgende Typen von \fIPrüfungen\fP werden unterstützt: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +führt keine Integritätsprüfung aus. Dies ist eine eher schlechte +Idee. Dennoch kann es nützlich sein, wenn die Integrität der Daten auf +andere Weise sichergestellt werden kann. +.TP +\fBcrc32\fP +berechnet die CRC32\-Prüfsumme anhand des Polynoms aus IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +berechnet die CRC64\-Prüfsumme anhand des Polynoms aus ECMA\-182. Dies ist die +Voreinstellung, da beschädigte Dateien etwas besser als mit CRC32 erkannt +werden und die Geschwindigkeitsdifferenz unerheblich ist. +.TP +\fBsha256\fP +berechnet die SHA\-256\-Prüfsumme. Dies ist etwas langsamer als CRC32 und +CRC64. +.RE +.IP "" +Die Integrität der \fB.xz\fP\-Header wird immer mit CRC32 geprüft. Es ist nicht +möglich, dies zu ändern oder zu deaktivieren. +.TP +\fB\-\-ignore\-check\fP +verifiziert die Integritätsprüfsumme der komprimierten Daten bei der +Dekompression nicht. Die CRC32\-Werte in den \fB.xz\fP\-Headern werden weiterhin +normal verifiziert. +.IP "" +\fBVerwenden Sie diese Option nicht, außer Sie wissen, was Sie tun.\fP Mögliche +Gründe, diese Option zu verwenden: +.RS +.IP \(bu 3 +Versuchen, Daten aus einer beschädigten .xz\-Datei wiederherzustellen. +.IP \(bu 3 +Erhöhung der Geschwindigkeit bei der Dekompression. Dies macht sich meist +mit SHA\-256 bemerkbar, oder mit Dateien, die extrem stark komprimiert +sind. Wir empfehlen, diese Option nicht für diesen Zweck zu verwenden, es +sei denn, die Integrität der Datei wird extern auf andere Weise überprüft. +.RE +.TP +\fB\-0\fP … \fB\-9\fP +wählt eine der voreingestellten Kompressionsstufen, standardmäßig +\fB\-6\fP. Wenn mehrere Voreinstellungsstufen angegeben sind, ist nur die +zuletzt angegebene wirksam. Falls bereits eine benutzerdefinierte +Filterkette angegeben wurde, wird diese durch die Festlegung der +Voreinstellung geleert. +.IP "" +Die Unterschiede zwischen den Voreinstellungsstufen sind deutlicher als bei +\fBgzip\fP(1) und \fBbzip2\fP(1). Die gewählten Kompressionseinstellungen +bestimmen den Speicherbedarf bei der Dekompression, daher ist es auf älteren +Systemen mit wenig Speicher bei einer zu hoch gewählten Voreinstellung +schwer, eine Datei zu dekomprimieren. Insbesondere \fBist es keine gute Idee, blindlings \-9 für alles\fP zu verwenden, wie dies häufig mit \fBgzip\fP(1) und +\fBbzip2\fP(1) gehandhabt wird. +.RS +.TP +\fB\-0\fP … \fB\-3\fP +Diese Voreinstellungen sind recht schnell. \fB\-0\fP ist manchmal schneller als +\fBgzip \-9\fP, wobei aber die Kompression wesentlich besser ist. Die +schnelleren Voreinstellungen sind im Hinblick auf die Geschwindigkeit mit +\fBbzip2\fP(1) vergleichbar , mit einem ähnlichen oder besseren +Kompressionsverhältnis, wobei das Ergebnis aber stark vom Typ der zu +komprimierenden Daten abhängig ist. +.TP +\fB\-4\fP … \fB\-6\fP +Gute bis sehr gute Kompression, wobei der Speicherbedarf für die +Dekompression selbst auf alten Systemen akzeptabel ist. \fB\-6\fP ist die +Voreinstellung, welche üblicherweise eine gute Wahl für die Verteilung von +Dateien ist, die selbst noch auf Systemen mit nur 16\ MiB Arbeitsspeicher +dekomprimiert werden müssen (\fB\-5e\fP oder \fB\-6e\fP sind ebenfalls eine +Überlegung wert. Siehe \fB\-\-extreme\fP). +.TP +\fB\-7 … \-9\fP +Ähnlich wie \fB\-6\fP, aber mit einem höheren Speicherbedarf für die Kompression +und Dekompression. Sie sind nur nützlich, wenn Dateien komprimiert werden +sollen, die größer als 8\ MiB, 16\ MiB beziehungsweise 32\ MiB sind. +.RE +.IP "" +Auf der gleichen Hardware ist die Dekompressionsgeschwindigkeit ein nahezu +konstanter Wert in Bytes komprimierter Daten pro Sekunde. Anders +ausgedrückt: Je besser die Kompression, umso schneller wird üblicherweise +die Dekompression sein. Das bedeutet auch, dass die Menge der pro Sekunde +ausgegebenen unkomprimierten Daten stark variieren kann. +.IP "" +Die folgende Tabelle fasst die Eigenschaften der Voreinstellungen zusammen: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Voreinst.;Wörtb.Gr;KomprCPU;KompSpeich;DekompSpeich +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Spaltenbeschreibungen: +.RS +.IP \(bu 3 +Wörtb.Größe ist die Größe des LZMA2\-Wörterbuchs. Es ist +Speicherverschwendung, ein Wörterbuch zu verwenden, das größer als die +unkomprimierte Datei ist. Daher ist es besser, die Voreinstellungen \fB\-7\fP … +\fB\-9\fP zu vermeiden, falls es keinen wirklichen Bedarf dafür gibt. Mit \fB\-6\fP +und weniger wird üblicherweise so wenig Speicher verschwendet, dass dies +nicht ins Gewicht fällt. +.IP \(bu 3 +KomprCPU ist eine vereinfachte Repräsentation der LZMA2\-Einstellungen, +welche die Kompressionsgeschwindigkeit beeinflussen. Die Wörterbuchgröße +wirkt sich ebenfalls auf die Geschwindigkeit aus. Während KompCPU für die +Stufen \fB\-6\fP bis \fB\-9\fP gleich ist, tendieren höhere Stufen dazu, etwas +langsamer zu sein. Um eine noch langsamere, aber möglicherweise bessere +Kompression zu erhalten, siehe \fB\-\-extreme\fP. +.IP \(bu 3 +KompSpeich enthält den Speicherbedarf des Kompressors im +Einzel\-Thread\-Modus. Dieser kann zwischen den \fBxz\fP\-Versionen leicht +variieren. +.IP \(bu 3 +DekompSpeich enthält den Speicherbedarf für die Dekompression. Das bedeutet, +dass die Kompressionseinstellungen den Speicherbedarf bei der Dekompression +bestimmen. Der exakte Speicherbedarf bei der Dekompression ist geringfügig +größer als die Größe des LZMA2\-Wörterbuchs, aber die Werte in der Tabelle +wurden auf ganze MiB aufgerundet. +.RE +.IP "" + Der Speicherbedarf einiger der zukünftigen Multithread\-Modi kann dramatisch +höher sein als im Einzel\-Thread\-Modus. Mit dem Standardwert von +\fB\-\-block\-size\fP benötigt jeder Thread 3*3*Wörtb.Gr plus KompSpeich oder +DekompSpeich. Beispielsweise benötigen vier Threads mit der Voreinstellung +\fB\-6\fP etwa 660 bis 670 MiB Speicher. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +verwendet eine langsamere Variante der gewählten +Kompressions\-Voreinstellungsstufe (\fB\-0\fP … \fB\-9\fP), um hoffentlich ein etwas +besseres Kompressionsverhältnis zu erreichen, das aber in ungünstigen Fällen +auch schlechter werden kann. Der Speicherverbrauch bei der Dekompression +wird dabei nicht beeinflusst, aber der Speicherverbrauch der Kompression +steigt in den Voreinstellungsstufen \fB\-0\fP bis \fB\-3\fP geringfügig an. +.IP "" +Da es zwei Voreinstellungen mit den Wörterbuchgrößen 4\ MiB und 8\ MiB gibt, +verwenden die Voreinstellungsstufen \fB\-3e\fP und \fB\-5e\fP etwas schnellere +Einstellungen (niedrigere KompCPU) als \fB\-4e\fP beziehungsweise \fB\-6e\fP. Auf +diese Weise sind zwei Voreinstellungen nie identisch. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Voreinst.;Wörtb.Gr;KomprCPU;KompSpeich;DekompSpeich +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Zum Beispiel gibt es insgesamt vier Voreinstellungen, die ein 8\ MiB großes +Wörterbuch verwenden, deren Reihenfolge von der schnellsten zur langsamsten +\fB\-5\fP, \fB\-6\fP, \fB\-5e\fP und \fB\-6e\fP ist. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +sind etwas irreführende Aliase für \fB\-0\fP beziehungsweise \fB\-9\fP. Sie werden +nur zwecks Abwärtskompatibilität zu den LZMA\-Dienstprogrammen +bereitgestellt. Sie sollten diese Optionen besser nicht verwenden. +.TP +\fB\-\-block\-size=\fP\fIGröße\fP +teilt beim Komprimieren in das \fB.xz\fP\-Format die Eingabedaten in Blöcke der +angegebenen \fIGröße\fP in Byte. Die Blöcke werden unabhängig voneinander +komprimiert, was dem Multi\-Threading entgegen kommt und Zufallszugriffe bei +der Dekompression begrenzt. Diese Option wird typischerweise eingesetzt, um +die vorgegebene Blockgröße im Multi\-Thread\-Modus außer Kraft zu setzen, aber +sie kann auch im Einzel\-Thread\-Modus angewendet werden. +.IP "" +Im Multi\-Thread\-Modus wird etwa die dreifache \fIGröße\fP in jedem Thread zur +Pufferung der Ein\- und Ausgabe belegt. Die vorgegebene \fIGröße\fP ist das +Dreifache der Größe des LZMA2\-Wörterbuchs oder 1 MiB, je nachdem, was mehr +ist. Typischerweise ist das Zwei\- bis Vierfache der Größe des +LZMA2\-Wörterbuchs oder wenigstens 1 MB ein guter Wert. Eine \fIGröße\fP, die +geringer ist als die des LZMA2\-Wörterbuchs, ist Speicherverschwendung, weil +dann der LZMA2\-Wörterbuchpuffer niemals vollständig genutzt werden würde. Im +Multi\-Thread\-Modus wird die Größe der Blöcke wird in den Block\-Headern +gespeichert. Die Größeninformation wird für eine Multi\-Thread\-Dekompression +genutzt. +.IP "" +Im Einzel\-Thread\-Modus werden die Blöcke standardmäßig nicht geteilt. Das +Setzen dieser Option wirkt sich nicht auf den Speicherbedarf aus. In den +Block\-Headern werden keine Größeninformationen gespeichert, daher werden im +Einzel\-Thread\-Modus erzeugte Dateien nicht zu den im Multi\-Thread\-Modus +erzeugten Dateien identisch sein. Das Fehlen der Größeninformation bedingt +auch, dass \fBxz\fP nicht in der Lage sein wird, die Dateien im +Multi\-Thread\-Modus zu dekomprimieren. +.TP +\fB\-\-block\-list=\fP\fIBlöcke\fP +beginnt bei der Kompression in das \fB.xz\fP\-Format nach den angegebenen +Intervallen unkomprimierter Daten einen neuen Block, optional mit einer +benutzerdefinierten Filterkette. +.IP "" +Die \fIBlöcke\fP werden in einer durch Kommata getrennten Liste +angegeben. Jeder Block besteht aus einer optionalen Filterkettennummer +zwischen 0 und 9, gefolgt von einem Doppelpunkt (\fB:\fP) und der Größe der +unkomprimierten Daten (diese Angabe ist erforderlich). Überspringen eines +Blocks (zwei oder mehr aufeinander folgende Kommata) ist ein Kürzel dafür, +die Größe und die Filter des vorherigen Blocks zu verwenden. +.IP "" +Falls die Eingabedatei größer ist als die Summe der \fIBlöcke\fP, dann wird der +letzte in \fIVBlöcke\fP angegebene Wert bis zum Ende der Datei wiederholt. Mit +dem speziellen Wert \fB0\fP können Sie angeben, dass der Rest der Datei als +einzelner Block kodiert werden soll. +.IP "" +Eine alternative Filterkette für jeden Block kann in Kombination mit den +Optionen \fB\-\-filters1=\fP\fIFilter\fP \&…\& \fB\-\-filters9=\fP\fIFilter\fP angegeben +werden. Diese Optionen definieren Filterketten mit einem Bezeichner zwischen +1 und 9. Die Filterkette 0 bezeichnet hierbei die voreingestellte +Filterkette, was dem Nichtangeben einer Filterkette gleichkommt. Der +Filterkettenbezeichner kann vor der unkomprimierten Größe verwendet werden, +gefolgt von einem Doppelpunkt (\fB:\fP). Falls Sie beispielsweise +\fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP angeben, werden die Blöcke +folgendermaßen erstellt: +.RS +.IP \(bu 3 +Die durch \fB\-\-filters1\fP angegebene Filterkette und 2 MiB Eingabe +.IP \(bu 3 +Die durch \fB\-\-filters3\fP angegebene Filterkette und 2 MiB Eingabe +.IP \(bu 3 +Die durch \fB\-\-filters2\fP angegebene Filterkette und 4 MiB Eingabe +.IP \(bu 3 +Die durch \fB\-\-filters2\fP angegebene Filterkette und 4 MiB Eingabe +.IP \(bu 3 +Die vorgegebene Filterkette und 2 MiB Eingabe +.IP \(bu 3 +Die vorgegebene Filterkette und 4 MiB Eingabe für jeden Block bis zum Ende +der Eingabe. +.RE +.IP "" +Falls Sie eine Größe angeben, welche die Blockgröße des Encoders übersteigen +(entweder den Vorgabewert im Thread\-Modus oder den mit +\fB\-\-block\-size=\fP\fIGröße\fP angegebenen Wert), wird der Encoder zusätzliche +Blöcke erzeugen, wobei die in den \fIBlöcke\fP angegebenen Grenzen eingehalten +werden. Wenn Sie zum Beispiel \fB\-\-block\-size=10MiB\fP +\fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP angeben und die Eingabedatei 80 +MiB groß ist, erhalten Sie 11 Blöcke: 5, 10, 8, 10, 2, 10, 10, 4, 10, 10 und +1 MiB. +.IP "" +Im Multi\-Thread\-Modus werden die Blockgrößen in den Block\-Headern +gespeichert. Dies geschieht im Einzel\-Thread\-Modus nicht, daher wird die +kodierte Ausgabe zu der im Multi\-Thread\-Modus nicht identisch sein. +.TP +\fB\-\-flush\-timeout=\fP\fIZeit\fP +löscht bei der Kompression die ausstehenden Daten aus dem Encoder und macht +sie im Ausgabedatenstrom verfügbar, wenn mehr als die angegebene \fIZeit\fP in +Millisekunden (als positive Ganzzahl) seit dem vorherigen Löschen vergangen +ist und das Lesen weiterer Eingaben blockieren würde. Dies kann nützlich +sein, wenn \fBxz\fP zum Komprimieren von über das Netzwerk eingehenden Daten +verwendet wird. Kleine \fIZeit\fP\-Werte machen die Daten unmittelbar nach dem +Empfang nach einer kurzen Verzögerung verfügbar, während große \fIZeit\fP\-Werte +ein besseres Kompressionsverhältnis bewirken. +.IP "" +Dieses Funktionsmerkmal ist standardmäßig deaktiviert. Wenn diese Option +mehrfach angegeben wird, ist die zuletzt angegebene wirksam. Für die Angabe +der \fIZeit\fP kann der spezielle Wert \fB0\fP verwendet werden, um dieses +Funktionsmerkmal explizit zu deaktivieren. +.IP "" +Dieses Funktionsmerkmal ist außerhalb von POSIX\-Systemen nicht verfügbar. +.IP "" +.\" FIXME +\fBDieses Funktionsmerkmal ist noch experimentell.\fP Gegenwärtig ist \fBxz\fP +aufgrund der Art und Weise, wie \fBxz\fP puffert, für Dekompression in Echtzeit +ungeeignet. +.TP +\fB\-\-no\-sync\fP +synchronisiert die Zieldatei und deren Verzeichnis auf dem Speichergerät +nicht, bevor die Quelldatei gelöscht wird. So kann die Performance beim +Komprimieren oder Dekomprimieren vieler kleiner Dateien verbessert +werden. Jedoch wäre es möglich, falls es kurz nach dem Löschen zu einem +Systemabsturz kommt, dass die Zieldatei noch nicht auf dem Speichergerät +geschrieben, aber der Löschvorgang bereits ausgeführt wurde. In diesem Fall +gehen sowohl die Quelldatei als auch die Zieldatei verloren. +.IP "" +Diese Option ist nur wirksam, wenn \fBxz\fP die Quelldatei löscht. In anderen +Fällen wird niemals synchronisiert. +.IP "" +Die Synchronisierung und \fB\-\-no\-sync\fP wurden in Version \fBxz\fP 5.7.1alpha +hinzugefügt. +.TP +\fB\-\-memlimit\-compress=\fP\fIGrenze\fP +legt eine Grenze für die Speichernutzung bei der Kompression fest. Wenn +diese Option mehrmals angegeben wird, ist die zuletzt angegebene wirksam. +.IP "" +Falls die Kompressionseinstellungen die \fIGrenze\fP überschreiten, versucht +\fBxz\fP, die Einstellungen nach unten anzupassen, so dass die Grenze nicht +mehr überschritten wird und zeigt einen Hinweis an, dass eine automatische +Anpassung vorgenommen wurde. Die Anpassungen werden in folgender Reihenfolge +angewendet: Reduzierung der Anzahl der Threads, Wechsel in den +Einzelthread\-Modus, falls sogar ein einziger Thread im Multithread\-Modus die +\fIGrenze\fP überschreitet, und schlussendlich die Reduzierung der Größe des +LZMA2\-Wörterbuchs. +.IP "" +Beim Komprimieren mit \fB\-\-format=raw\fP oder falls \fB\-\-no\-adjust\fP angegeben +wurde, wird nur die Anzahl der Threads reduziert, da nur so die komprimierte +Ausgabe nicht beeinflusst wird. +.IP "" +Falls die \fIGrenze\fP nicht anhand der vorstehend beschriebenen Anpassungen +gesetzt werden kann, wird ein Fehler angezeigt und \fBxz\fP wird mit dem +Exit\-Status 1 beendet. +.IP "" +Die \fIGrenze\fP kann auf verschiedene Arten angegeben werden: +.RS +.IP \(bu 3 +Die \fIGrenze\fP kann ein absoluter Wert in Byte sein. Ein Suffix wie \fBMiB\fP +kann dabei hilfreich sein. Beispiel: \fB\-\-memlimit\-compress=80MiB\fP. +.IP \(bu 3 +Die \fIGrenze\fP kann als Prozentsatz des physischen Gesamtspeichers (RAM) +angegeben werden. Dies ist insbesondere nützlich, wenn in einem +Shell\-Initialisierungsskript, das mehrere unterschiedliche Rechner gemeinsam +verwenden, die Umgebungsvariable \fBXZ_DEFAULTS\fP gesetzt ist. Auf diese Weise +ist die Grenze auf Systemen mit mehr Speicher höher. Beispiel: +\fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +Mit \fB0\fP kann die \fIGrenze\fP auf den Standardwert zurückgesetzt werden. Dies +ist gegenwärtig gleichbedeutend mit dem Setzen der \fIGrenze\fP auf \fBmax\fP +(keine Speicherbegrenzung). +.RE +.IP "" +Für die 32\-Bit\-Version von \fBxz\fP gibt es einen Spezialfall: Falls die Grenze +über \fB4020\ MiB\fP liegt, wird die \fIGrenze\fP auf \fB4020\ MiB\fP gesetzt. Auf +MIPS32 wird stattdessen \fB2000\ MB\fP verwendet (die Werte \fB0\fP und \fBmax\fP +werden hiervon nicht beeinflusst; für die Dekompression gibt es keine +vergleichbare Funktion). Dies kann hilfreich sein, wenn ein +32\-Bit\-Executable auf einen 4\ GiB großen Adressraum (2 GiB auf MIPS32) +zugreifen kann, wobei wir hoffen wollen, dass es in anderen Situationen +keine negativen Effekte hat. +.IP "" +Siehe auch den Abschnitt \fBSpeicherbedarf\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIGrenze\fP +legt eine Begrenzung des Speicherverbrauchs für die Dekompression fest. Dies +beeinflusst auch den Modus \fB\-\-list\fP. Falls die Aktion nicht ausführbar ist, +ohne die \fIGrenze\fP zu überschreiten, gibt \fBxz\fP eine Fehlermeldung aus und +die Dekompression wird fehlschlagen. Siehe \fB\-\-memlimit\-compress=\fP\fIGrenze\fP +zu möglichen Wegen, die \fIGrenze\fP anzugeben. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIGrenze\fP +legt eine Begrenzung des Speicherverbrauchs für Multithread\-Dekompression +fest. Dies beeinflusst lediglich die Anzahl der Threads; \fBxz\fP wird dadurch +niemals die Dekompression einer Datei verweigern. Falls die \fIGrenze\fP für +jegliches Multithreading zu niedrig ist, wird sie ignoriert und \fBxz\fP setzt +im Einzelthread\-modus fort. Beachten Sie auch, dass bei der Verwendung von +\fB\-\-memlimit\-decompress\fP dies stets sowohl auf den Einzelthread\-als auch auf +den Multithread\-Modus angewendet wird und so die effektive \fIGrenze\fP für den +Multithread\-Modus niemals höher sein wird als die mit +\fB\-\-memlimit\-decompress\fP gesetzte Grenze. +.IP "" +Im Gegensatz zu anderen Optionen zur Begrenzung des Speicherverbrauchs hat +\fB\-\-memlimit\-mt\-decompress=\fP\fIGrenze\fP eine systemspezifisch vorgegebene +\fIGrenze\fP. Mit \fBxz \-\-info\-memory\fP können Sie deren aktuellen Wert anzeigen +lassen. +.IP "" +Diese Option und ihr Standardwert existieren, weil die unbegrenzte +threadbezogene Dekompression bei einigen Eingabedateien zu unglaublich +großem Speicherverbrauch führen würde. Falls die vorgegebene \fIGrenze\fP auf +Ihrem System zu niedrig ist, können Sie die \fIGrenze\fP durchaus erhöhen, aber +setzen Sie sie niemals auf einen Wert größer als die Menge des nutzbaren +Speichers, da \fBxz\fP bei entsprechenden Eingabedateien versuchen wird, diese +Menge an Speicher auch bei einer geringen Anzahl von Threads zu +verwnden. Speichermangel oder Auslagerung verbessern die +Dekomprimierungsleistung nicht. +.IP "" +Siehe \fB\-\-memlimit\-compress=\fP\fIGrenze\fP für mögliche Wege zur Angabe der +\fIGrenze\fP. Sezen der \fIGrenze\fP auf \fB0\fP setzt die \fIGrenze\fP auf den +vorgegebenen systemspezifischen Wert zurück. +.TP +\fB\-M\fP \fIGrenze\fP, \fB\-\-memlimit=\fP\fIGrenze\fP, \fB\-\-memory=\fP\fIGrenze\fP +Dies ist gleichbedeutend mit \fB\-\-memlimit\-compress=\fP\fIGrenze\fP +\fB\-\-memlimit\-decompress=\fP\fIGrenze\fP \fB\-\-memlimit\-mt\-decompress=\fP\fIGrenze\fP. +.TP +\fB\-\-no\-adjust\fP +zeigt einen Fehler an und beendet, falls die Grenze der Speichernutzung +nicht ohne Änderung der Einstellungen, welche die komprimierte Ausgabe +beeinflussen, berücksichtigt werden kann. Das bedeutet, dass \fBxz\fP daran +gehindert wird, den Encoder vom Multithread\-Modus in den Einzelthread\-Modus +zu versetzen und die Größe des LZMA2\-Wörterbuchs zu reduzieren. Allerdings +kann bei Verwendung dieser Option dennoch die Anzahl der Threads reduziert +werden, um die Grenze der Speichernutzung zu halten, sofern dies die +komprimierte Ausgabe nicht beeinflusst. +.IP "" +Die automatische Anpassung ist beim Erzeugen von Rohdatenströmen +(\fB\-\-format=raw\fP) immer deaktiviert. +.TP +\fB\-T\fP \fIThreads\fP, \fB\-\-threads=\fP\fIThreads\fP +gibt die Anzahl der zu verwendenden Arbeits\-Threads an. Wenn Sie \fIThreads\fP +auf einen speziellen Wert \fB0\fP setzen, verwendet \fBxz\fP maximal so viele +Threads, wie der/die Prozessor(en) im System untestützen. Die tatsächliche +Anzahl kann geringer sein als die angegebenen \fIThreads\fP, wenn die +Eingabedatei nicht groß genug für Threading mit den gegebenen Einstellungen +ist oder wenn mehr Threads die Speicherbegrenzung übersteigen würden. +.IP "" +Die Multithread\- bzw. Einzelthread\-Kompressoren erzeugen unterschiedliche +Ausgaben. Der Einzelthread\-Kompressor erzeugt die geringste Dateigröße, aber +nur die Ausgabe des Multithread\-Kompressors kann mit mehreren Threads wieder +dekomprimiert werden. Das Setzen der Anzahl der \fIThreads\fP auf \fB1\fP wird den +Einzelthread\-Modus verwenden. Das Setzen der Anzahl der \fIThreads\fP auf +einen anderen Wert einschließlich \fB0\fP verwendet den Multithread\-Kompressor, +und zwar sogar dann, wenn das System nur einen einzigen Hardware\-Thread +unterstützt (\fBxz\fP 5.2.x verwendete in diesem Fall noch den +Einzelthread\-Modus). +.IP "" +Um den Multithread\-Modus mit nur einem einzigen Thread zu verwenden, setzen +Sie die Anzahl der \fIThreads\fP auf \fB+1\fP. Das Präfix \fB+\fP hat mit Werten +verschieden von \fB1\fP keinen Effekt. Eine Begrenzung des Speicherverbrauchs +kann \fBxz\fP dennoch veranlassen, den Einzelthread\-Modus zu verwenden, außer +wenn \fB\-\-no\-adjust\fP verwendet wird. Die Unterstützung für das Präfix \fB+\fP +wurde in \fBxz\fP 5.4.0 hinzugefügt. +.IP "" +Falls das automatische Setzen der Anzahl der Threads angefordert und keine +Speicherbegrenzung angegeben wurde, dann wird eine systemspezifisch +vorgegebene weiche Grenze verwendet, um eventuell die Anzahl der Threads zu +begrenzen. Es ist eine weiche Grenze im Sinne davon, dass sie ignoriert +wird, falls die Anzahl der Threads 1 ist; daher wird eine weiche Grenze +\fBxz\fP niemals an der Kompression oder Dekompression hindern. Diese +vorgegebene weiche Grenze veranlasst \fBxz\fP nicht, vom Multithread\-Modus in +den Einzelthread\-Modus zu wechseln. Die aktiven Grenzen können Sie mit dem +Befehl \fBxz \-\-info\-memory\fP anzeigen lassen. +.IP "" +Die gegenwärtig einzige Threading\-Methode teilt die Eingabe in Blöcke und +komprimiert diese unabhängig voneinander. Die vorgegebene Blockgröße ist von +der Kompressionsstufe abhängig und kann mit der Option +\fB\-\-block\-size=\fP\fIGröße\fP außer Kraft gesetzt werden. +.IP "" +Eine thread\-basierte Dekompression wird nur bei Dateien funktionieren, die +mehrere Blöcke mit Größeninformationen in deren Headern enthalten. Alle im +Multi\-Thread\-Modus komprimierten Dateien, die groß genug sind, erfüllen +diese Bedingung, im Einzel\-Thread\-Modus komprimierte Dateien dagegen nicht, +selbst wenn \fB\-\-block\-size=\fP\fIGröße\fP verwendet wurde. +.IP "" +Der Vorgabewert für \fIThreads\fP is \fB0\fP. In \fBxz\fP 5.4.x und älteren Versionen +ist der Vorgabewert \fB1\fP. +. +.SS "Benutzerdefinierte Filterketten für die Kompression" +Eine benutzerdefinierte Filterkette ermöglicht die Angabe detaillierter +Kompressionseinstellungen, anstatt von den Voreinstellungen auszugehen. Wenn +eine benutzerdefinierte Filterkette angegeben wird, werden die vorher in der +Befehlszeile angegebenen Voreinstellungsoptionen (\fB\-0\fP … \fB\-9\fP und +\fB\-\-extreme\fP) außer Kraft gesetzt. Wenn eine Voreinstellungsoption nach +einer oder mehreren benutzerdefinierten Filterkettenoptionen angegeben wird, +dann wird die neue Voreinstellung wirksam und die zuvor angegebenen +Filterkettenoptionen werden außer Kraft gesetzt. +.PP +Eine Filterkette ist mit dem Piping (der Weiterleitung) in der Befehlszeile +vergleichbar. Bei der Kompression gelangt die unkomprimierte Eingabe in den +ersten Filter, dessen Ausgabe wiederum in den zweiten Filter geleitet wird +(sofern ein solcher vorhanden ist). Die Ausgabe des letzten Filters wird in +die komprimierte Datei geschrieben. In einer Filterkette sind maximal vier +Filter zulässig, aber typischerweise besteht eine Filterkette nur aus einem +oder zwei Filtern. +.PP +Bei vielen Filtern ist die Positionierung in der Filterkette eingeschränkt: +Einige Filter sind nur als letzte in der Kette verwendbar, einige können +nicht als letzte Filter gesetzt werden, und andere funktionieren an +beliebiger Stelle. Abhängig von dem Filter ist diese Beschränkung entweder +auf das Design des Filters selbst zurückzuführen oder ist aus +Sicherheitsgründen vorhanden. +.PP +Eine benutzerdefinierte Filterkette kann auf zwei verschiedene Arten +angegeben werden. Die Optionen \fB\-\-filters=\fP\fIFilter\fP und +\fB\-\-filters1=\fP\fIFilter\fP \&…\& \fB\-\-filters9=\fP\fIFilter\fP ermöglichen die Angabe +einer ganzen Filterkette in einer einzelnen Option gemäß der +Liblzma\-Filterzeichenkettensyntax. Alternativ können Sie eine Filterkette +mit einer oder mehreren individuellen Filteroptionen in der Reihenfolge +angeben, in der sie in der Filterkette verwendet werden sollen. Daher ist +die Reihenfolge der individuellen Filteroptionen wichtig! Beim Dekodieren +von Rohdatenströmen (\fB\-\-format=raw\fP) muss die Filterkette in der gleichen +Reihenfolge wie bei der Komprimierung angegeben werden. Alle individuellen +Filter\- oder Voreinstellungsoptionen, die \fIvor\fP der vollen +Filterkettenoption (\fB\-\-filters=\fP\fIFilter\fP) angegeben werden, werden +verworfen. Individuelle Filter, die \fInach\fP der vollen Filterkettenoption +angegeben werden, setzen die Filterkette zurück +.PP +Sowohl vollständige als auch individuelle Filteroptionen akzeptieren +filterspezifische \fIOptionen\fP in einer durch Kommata getrennten +Liste. Zusätzliche Kommata in den \fIOptionen\fP werden ignoriert. Jede Option +hat einen Standardwert, daher brauchen Sie nur jene anzugeben, die Sie +ändern wollen. +.PP +Um die gesamte Filterkette und die \fIOptionen\fP anzuzeigen, rufen Sie \fBxz \-vv\fP auf (was gleichbedeutend mit der zweimaligen Angabe von \fB\-\-verbose\fP +ist). Dies funktioniert auch zum Betrachten der von den Voreinstellungen +verwendeten Filterkettenoptionen. +.TP +\fB\-\-filters=\fP\fIFilter\fP +gibt die vollständige Filterkette oder eine Voreinstellung in einer +einzelnen Option an. Mehrere Filter können durch Leerzeichen oder zwei +Minuszeichen (\fB\-\-\fP) voneinander getrennt werden. Es kann notwendig sein, +die \fIFilter\fP in der Shell\-Befehlszeile zu maskieren, so dass diese als +einzelne Option ausgewertet werden. Um Optionen Werte zuzuordnen, verwenden +Sie \fB:\fP oder \fB=\fP. Einer Voreinstellung kann ein \fB\-\fP vorangestellt werden, +dem keiner oder mehrere Schalter folgen. Der einzige unterstützte Schalter +ist \fBe\fP zum Anwenden der gleichen Optionen wie \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIFilter\fP … \fB\-\-filters9\fP=\fIFilter\fP +gibt bis zu neun optionale Filterketten an, die mit \fB\-\-block\-list\fP +verwendet werden können. +.IP "" +Wenn Sie beispielsweise ein Archiv mit ausführbaren Dateien gefolgt von +Textdateien komprimieren, könnte der Teil mit den ausführbaren Dateien eine +Filterkette mit einem BCJ\-Filter und der Textdateiteil lediglich den +LZMA2\-Filter verwenden. +.TP +\fB\-\-filters\-help\fP +zeigt eine Hilfemeldung an, welche beschreibt, wie Voreinstellungen und +benutzerdefinierte Filterketten in den Optionen \fB\-\-filters\fP und +\fB\-\-filters1=\fP\fIFilter\fP \&… \& \fB\-\-filters9=\fP\fIFilter\fP angegeben werden und +beendet das Programm. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIOptionen\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIOptionen\fP] +.PD +fügt LZMA1\- oder LZMA2\-Filter zur Filterkette hinzu. Diese Filter können nur +als letzte Filter in der Kette verwendet werden. +.IP "" +LZMA1 ist ein veralteter Filter, welcher nur wegen des veralteten +\&\fB.lzma\fP\-Dateiformats unterstützt wird, welches nur LZMA1 unterstützt. LZMA2 +ist eine aktualisierte Version von LZMA1, welche einige praktische Probleme +von LZMA1 behebt. Das \fB.xz\fP\-Format verwendet LZMA2 und unterstützt LZMA1 +gar nicht. Kompressionsgeschwindigkeit und \-verhältnis sind bei LZMA1 und +LZMA2 praktisch gleich. +.IP "" +LZMA1 und LZMA2 haben die gleichen \fIOptionen\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIVoreinstellung\fP +setzt alle LZMA1\- oder LZMA2\-\fIOptionen\fP auf die \fIVoreinstellung\fP +zurück. Diese \fIVoreinstellung\fP wird in Form einer Ganzzahl angegeben, der +ein aus einem einzelnen Buchstaben bestehender Voreinstellungsmodifikator +folgen kann. Die Ganzzahl kann \fB0\fP bis \fB9\fP sein, entsprechend den +Befehlszeilenoptionen \fB\-0\fP … \fB\-9\fP. Gegenwärtig ist \fBe\fP der einzige +unterstützte Modifikator, was \fB\-\-extreme\fP entspricht. Wenn keine +\fBVoreinstellung\fP angegeben ist, werden die Standardwerte der LZMA1\- oder +LZMA2\-\fIOptionen\fP der Voreinstellung \fB6\fP entnommen. +.TP +\fBdict=\fP\fIGröße\fP +Die \fIGröße\fP des Wörterbuchs (Chronikpuffers) gibt an, wie viel Byte der +kürzlich verarbeiteten unkomprimierten Daten im Speicher behalten werden +sollen. Der Algorithmus versucht, sich wiederholende Byte\-Abfolgen +(Übereinstimmungen) in den unkomprimierten Daten zu finden und diese durch +Referenzen zu den Daten zu ersetzen, die sich gegenwärtig im Wörterbuch +befinden. Je größer das Wörterbuch, umso größer ist die Chance, eine +Übereinstimmung zu finden. Daher bewirkt eine Erhöhung der \fIGröße\fP des +Wörterbuchs üblicherweise ein besseres Kompressionsverhältnis, aber ein +Wörterbuch, das größer ist als die unkomprimierte Datei, wäre +Speicherverschwendung. +.IP "" +Typische Wörterbuch\-\fIGrößen\fP liegen im Bereich von 64\ KiB bis 64\ MiB. Das +Minimum ist 4\ KiB. Das Maximum für die Kompression ist gegenwärtig 1.5\ GiB +(1536\ MiB). Bei der Dekompression wird bereits eine Wörterbuchgröße bis zu +4\ GiB minus 1 Byte unterstützt, welche das Maximum für die LZMA1\- und +LZMA2\-Datenstromformate ist. +.IP "" +Die \fIGröße\fP des Wörterbuchs und der Übereinstimmungsfinder (\fIÜf\fP) +bestimmen zusammen den Speicherverbrauch des LZMA1\- oder +LZMA2\-Kodierers. Bei der Dekompression ist ein Wörterbuch der gleichen +\fIGröße\fP (oder ein noch größeres) wie bei der Kompression erforderlich, +daher wird der Speicherverbrauch des Dekoders durch die Größe des bei der +Kompression verwendeten Wörterbuchs bestimmt. Die \fB.xz\fP\-Header speichern +die \fIGröße\fP des Wörterbuchs entweder als 2^\fIn\fP oder 2^\fIn\fP + 2^(\fIn\fP\-1), +so dass diese \fIGrößen\fP für die Kompression etwas bevorzugt werden. Andere +\fIGrößen\fP werden beim Speichern in den \fB.xz\fP\-Headern aufgerundet. +.TP +\fBlc=\fP\fIlc\fP +gibt die Anzahl der literalen Kontextbits an. Das Minimum ist 0 und das +Maximum 4; der Standardwert ist 3. Außerdem darf die Summe von \fIlc\fP und +\fIlp\fP nicht größer als 4 sein. +.IP "" +Alle Bytes, die nicht als Übereinstimmungen kodiert werden können, werden +als Literale kodiert. Solche Literale sind einfache 8\-bit\-Bytes, die jeweils +für sich kodiert werden. +.IP "" +Bei der Literalkodierung wird angenommen, dass die höchsten \fIlc\fP\-Bits des +zuvor unkomprimierten Bytes mit dem nächsten Byte in Beziehung stehen. Zum +Beispiel folgt in typischen englischsprachigen Texten auf einen +Großbuchstaben ein Kleinbuchstabe und auf einen Kleinbuchstaben +üblicherweise wieder ein Kleinbuchstabe. Im US\-ASCII\-Zeichensatz sind die +höchsten drei Bits 010 für Großbuchstaben und 011 für Kleinbuchstaben. Wenn +\fIlc\fP mindestens 3 ist, kann die literale Kodierung diese Eigenschaft der +unkomprimierten Daten ausnutzen. +.IP "" +Der Vorgabewert (3) ist üblicherweise gut. Wenn Sie die maximale Kompression +erreichen wollen, versuchen Sie \fBlc=4\fP. Manchmal hilft es ein wenig, doch +manchmal verschlechtert es die Kompression. Im letzteren Fall versuchen Sie +zum Beispiel auch\& \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +gibt die Anzahl der literalen Positionsbits an. Das Minimum ist 0 und das +Maximum 4; die Vorgabe ist 0. +.IP "" +\fILp\fP beeinflusst, welche Art der Ausrichtung der unkomprimierten Daten beim +Kodieren von Literalen angenommen wird. Siehe \fIpb\fP weiter unten für weitere +Informationen zur Ausrichtung. +.TP +\fBpb=\fP\fIAnzahl\fP +legt die Anzahl der Positions\-Bits fest. Das Minimum ist 0 und das Maximum +4; Standard ist 2. +.IP "" +\fIPb\fP beeinflusst, welche Art der Ausrichtung der unkomprimierten Daten +generell angenommen wird. Standardmäßig wird eine Vier\-Byte\-Ausrichtung +angenommen (2^\fIpb\fP=2^2=4), was oft eine gute Wahl ist, wenn es keine +bessere Schätzung gibt. +.IP "" +Wenn die Ausrichtung bekannt ist, kann das entsprechende Setzen von \fIpb\fP +die Dateigröße ein wenig verringern. Wenn Textdateien zum Beispiel eine +Ein\-Byte\-Ausrichtung haben (US\-ASCII, ISO\-8859\-*, UTF\-8), kann das Setzen +von \fBpb=0\fP die Kompression etwas verbessern. Für UTF\-16\-Text ist \fBpb=1\fP +eine gute Wahl. Wenn die Ausrichtung eine ungerade Zahl wie beispielsweise 3 +Byte ist, könnte \fBpb=0\fP die beste Wahl sein. +.IP "" +Obwohl die angenommene Ausrichtung mit \fIpb\fP und \fIlp\fP angepasst werden +kann, bevorzugen LZMA1 und LZMA2 noch etwas die 16\-Byte\-Ausrichtung. Das +sollten Sie vielleicht beim Design von Dateiformaten berücksichtigen, die +wahrscheinlich oft mit LZMA1 oder LZMA2 komprimiert werden. +.TP +\fBmf=\fP\fIÜf\fP +Der Übereinstimmungsfinder hat einen großen Einfluss auf die Geschwindigkeit +des Kodierers, den Speicherbedarf und das +Kompressionsverhältnis. Üblicherweise sind auf Hash\-Ketten basierende +Übereinstimmungsfinder schneller als jene, die mit Binärbäumen arbeiten. Die +Vorgabe hängt von der \fIVoreinstellungsstufe\fP ab: 0 verwendet \fBhc3\fP, 1\-3 +verwenden \fBhc4\fP und der Rest verwendet \fBbt4\fP. +.IP "" +Die folgenden Übereinstimmungsfinder werden unterstützt. Die Formeln zur +Ermittlung des Speicherverbrauchs sind grobe Schätzungen, die der Realität +am nächsten kommen, wenn \fIWörterbuch\fP eine Zweierpotenz ist. +.RS +.TP +\fBhc3\fP +Hash\-Kette mit 2\- und 3\-Byte\-Hashing +.br +Minimalwert für \fInice\fP: 3 +.br +Speicherbedarf: +.br +\fIdict\fP * 7,5 (falls \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 5,5 + 64 MiB (falls \fIdict\fP > 16 MiB) +.TP +\fBhc4\fP +Hash\-Kette mit 2\-, 3\- und 4\-Byte\-Hashing +.br +Minimaler Wert für \fInice\fP: 4 +.br +Speicherbedarf: +.br +\fIdict\fP * 7,5 (falls \fIdict\fP <= 32 MiB ist); +.br +\fIdict\fP * 6,5 (falls \fIdict\fP > 32 MiB ist) +.TP +\fBbt2\fP +Binärbaum mit 2\-Byte\-Hashing +.br +Minimaler Wert für \fInice\fP: 2 +.br +Speicherverbrauch: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Binärbaum mit 2\- und 3\-Byte\-Hashing +.br +Minimalwert für \fInice\fP: 3 +.br +Speicherbedarf: +.br +\fIdict\fP * 11,5 (falls \fIdict\fP <= 16 MiB ist); +.br +\fIdict\fP * 9,5 + 64 MiB (falls \fIdict\fP > 16 MiB ist) +.TP +\fBbt4\fP +Binärbaum mit 2\-, 3\- und 4\-Byte\-Hashing +.br +Minimaler Wert für \fInice\fP: 4 +.br +Speicherbedarf: +.br +\fIdict\fP * 11,5 (falls \fIdict\fP <= 32 MiB ist); +.br +\fIdict\fP * 10,5 (falls \fIdict\fP > 32 MiB ist) +.RE +.TP +\fBmode=\fP\fIModus\fP +gibt die Methode zum Analysieren der vom Übereinstimmungsfinder gelieferten +Daten an. Als \fIModi\fP werden \fBfast\fP und \fBnormal\fP unterstützt. Die Vorgabe +ist \fBfast\fP für die \fIVoreinstellungsstufen\fP 0\-3 und \fBnormal\fP für die +\fIVoreinstellungsstufen\fP 4\-9. +.IP "" +Üblicherweise wird \fBfast\fP mit Hashketten\-basierten Übereinstimmungsfindern +und \fBnormal\fP mit Binärbaum\-basierten Übereinstimmungsfindern verwendet. So +machen es auch die \fIVoreinstellungsstufen\fP. +.TP +\fBnice=\fP\fInice\fP +gibt an, was als annehmbarer Wert für eine Übereinstimmung angesehen werden +kann. Wenn eine Übereinstimmung gefunden wird, die mindestens diesen +\fInice\fP\-Wert hat, sucht der Algorithmus nicht weiter nach besseren +Übereinstimmungen. +.IP "" +Der \fInice\fP\-Wert kann 2\-273 Byte sein. Höhere Werte tendieren zu einem +besseren Kompressionsverhältnis, aber auf Kosten der Geschwindigkeit. Die +Vorgabe hängt von der \fIVoreinstellungsstufe\fP ab. +.TP +\fBdepth=\fP\fITiefe\fP +legt die maximale Suchtiefe im Übereinstimmungsfinder fest. Vorgegeben ist +der spezielle Wert 0, der den Kompressor veranlasst, einen annehmbaren Wert +für \fITiefe\fP aus \fIÜf\fP und \fInice\fP\-Wert zu bestimmen. +.IP "" +Die angemessene \fITiefe\fP für Hash\-Ketten ist 4\-100 und 16\-1000 für +Binärbäume. Hohe Werte für die \fITiefe\fP können den Kodierer bei einigen +Dateien extrem verlangsamen. Vermeiden Sie es, die \fITiefe\fP über einen Wert +von 100 zu setzen, oder stellen Sie sich darauf ein, die Kompression +abzubrechen, wenn sie zu lange dauert. +.RE +.IP "" +Beim Dekodieren von Rohdatenströmen (\fB\-\-format=raw\fP) benötigt LZMA2 nur die +Wörterbuch\-\fIGröße\fP. LZMA1 benötigt außerdem \fIlc\fP, \fIlp\fP und \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIOptionen\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIOptionen\fP] +.PD +fügt ein »Branch/Call/Jump«\-(BCJ\-)Filter zur Filterkette hinzu. Diese Filter +können nicht als letzter Filter in der Filterkette verwendet werden. +.IP "" +Ein BCJ\-Filter wandelt relative Adressen im Maschinencode in deren absolute +Gegenstücke um. Die Datengröße wird dadurch nicht geändert, aber die +Redundanz erhöht, was LZMA2 dabei helfen kann, eine um 10 bis 15% kleinere +\&\fB.xz\fP\-Datei zu erstellen. Die BCJ\-Filter sind immer reversibel, daher +verursacht die Anwendung eines BCJ\-Filters auf den falschen Datentyp keinen +Datenverlust, wobei aber das Kompressionsverhältnis etwas schlechter werden +könnte. Die BCJ\-Filter sind sehr schnell und verbrauchen nur wenig mehr +Speicher. +.IP "" +Diese BCJ\-Filter haben bekannte Probleme mit dem Kompressionsverhältnis: +.RS +.IP \(bu 3 +In einigen Dateitypen, die ausführbaren Code enthalten (zum Beispiel +Objektdateien, statische Bibliotheken und Linux\-Kernelmodule), sind die +Adressen in den Anweisungen mit Füllwerten gefüllt. Diese BCJ\-Filter führen +dennoch die Adressumwandlung aus, wodurch die Kompression bei diesen Dateien +schlechter wird. +.IP \(bu 3 +Falls ein BCJ\-Filter auf ein Archiv angewendet wird, ist es möglich, dass +das Kompressionsverhältnis schlechter als ohne Filter wird. Falls es +beispielsweise ähnliche oder sogar identische ausführbare Dateien gibt, dann +werden diese durch die Filterung wahrscheinlich »unähnlicher« und +verschlechtern dadurch das Kompressionsverhältnis. Der Inhalt +nicht\-ausführbarer Dateien im gleichen Archiv kann sich ebenfalls darauf +auswirken. In der Praxis werden Sie durch Versuche mit oder ohne BCJ\-Filter +selbst herausfinden müssen, was situationsbezogen besser ist. +.RE +.IP "" +Verschiedene Befehlssätze haben unterschiedliche Ausrichtungen: Die +ausführbare Datei muss in den Eingabedateien einem Vielfachen dieses Wertes +entsprechen, damit dieser Filter funktioniert. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filter;Ausrichtung;Hinweise +x86;1;32\-Bit oder 64\-Bit x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096\-Byte\-Ausrichtung ist optimal +PowerPC;4;Nur Big Endian +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Da die BCJ\-gefilterten Daten üblicherweise mit LZMA2 komprimiert sind, kann +das Kompressionsverhältnis dadurch etwas verbessert werden, dass die +LZMA2\-Optionen so gesetzt werden, dass sie der Ausrichtung des gewählten +BCJ\-Filters entsprechen. Beispiele: +.RS +.IP \(bu 3 +Der IA\-64\-Filter hat eine 16\-Byte\-Ausrichtung, daher ist \fBpb=4,lp=4,lc=0\fP +für LZMA2 passend (2^4=16). +.IP \(bu 3 +RISC\-V\-Code hat eine 2\-Byte\- oder 4\-Byte\-Ausrichtung, abhängig davon, ob die +Datei 16\-bit\-komprimierte Instruktionen enthält (die C\-Erweiterung). Wenn +16\-bit\-Instruktionen verwendet werden, ist \fBpb=2,lp=1,lc=3\fP oder +\fBpb=1,lp=1,lc=3\fP passend. Wenn keine 16\-bit\-Instruktionen vorhanden sind, +ist \fBpb=2,lp=2,lc=2\fP am besten. Mit \fBreadelf \-h\fP können Sie überprüfen, ob +»RVC« in der »Flags«\-Zeile auftritt. +.IP \(bu 3 +ARM64 hat stets eine 4\-Byte\-Ausrichtung, daher ist \fBpb=2,lp=2,lc=2\fP am +besten. +.IP \(bu 3 +Der x86\-Filter stellt eine Ausnahme dar. Es ist üblicherweise eine gute +Wahl, bei den Voreinstellungen von LZMA2 (\fBpb=2,lp=0,lc=3\fP) zu bleiben, +wenn Sie ausführbare x86\-Dateien komprimieren +.RE +.IP "" +Alle BCJ\-Filter unterstützen die gleichen \fIOptionen\fP: +.RS +.TP +\fBstart=\fP\fIVersatz\fP +gibt den Start\-\fIVersatz\fP an, der bei der Umwandlung zwischen relativen und +absoluten Adressen verwendet wird. Der \fIVersatz\fP muss ein Vielfaches der +Filterausrichtung sein (siehe die Tabelle oben). Der Standardwert ist 0. In +der Praxis ist dieser Standardwert gut; die Angabe eines benutzerdefinierten +\fIVersatzes\fP ist fast immer unnütz. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIOptionen\fP] +fügt den Delta\-Filter zur Filterkette hinzu. Der Delta\-Filter kann nicht als +letzter Filter in der Filterkette verwendet werden. +.IP "" +Gegenwärtig wird nur eine einfache, Byte\-bezogene Delta\-Berechnung +unterstützt. Beim Komprimieren von zum Beispiel unkomprimierten +Bitmap\-Bildern oder unkomprimierten PCM\-Audiodaten kann es jedoch sinnvoll +sein. Dennoch können für spezielle Zwecke entworfene Algorithmen deutlich +bessere Ergebnisse als Delta und LZMA2 liefern. Dies trifft insbesondere auf +Audiodaten zu, die sich zum Beispiel mit \fBflac\fP(1) schneller und besser +komprimieren lassen. +.IP "" +Unterstützte \fIOptionen\fP: +.RS +.TP +\fBdist=\fP\fIAbstand\fP +gibt den \fIAbstand\fP der Delta\-Berechnung in Byte an. Zulässige Werte für den +\fIAbstand\fP sind 1 bis 256. Der Vorgabewert ist 1. +.IP "" +Zum Beispiel wird mit \fBdist=2\fP und der 8\-Byte\-Eingabe A1 B1 A2 B3 A3 B5 A4 +B7 die Ausgabe A1 B1 01 02 01 02 01 02 sein. +.RE +. +.SS "Andere Optionen" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +unterdrückt Warnungen und Hinweise. Geben Sie dies zweimal an, um auch +Fehlermeldungen zu unterdrücken. Diese Option wirkt sich nicht auf den +Exit\-Status aus. Das bedeutet, das selbst bei einer unterdrückten Warnung +der Exit\-Status zur Anzeige einer Warnung dennoch verwendet wird. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +bewirkt ausführliche Ausgaben. Wenn die Standardfehlerausgabe mit einem +Terminal verbunden ist, zeigt \fBxz\fP den Fortschritt an. Durch zweimalige +Angabe von \fB\-\-verbose\fP wird die Ausgabe noch ausführlicher. +.IP "" +Der Fortschrittsanzeiger stellt die folgenden Informationen dar: +.RS +.IP \(bu 3 +Der Prozentsatz des Fortschritts wird angezeigt, wenn die Größe der +Eingabedatei bekannt ist. Das bedeutet, dass der Prozentsatz in +Weiterleitungen (Pipes) nicht angezeigt werden kann. +.IP \(bu 3 +Menge der erzeugten komprimierten Daten (bei der Kompression) oder der +verarbeiteten Daten (bei der Dekompression). +.IP \(bu 3 +Menge der verarbeiteten unkomprimierten Daten (bei der Kompression) oder der +erzeugten Daten (bei der Dekompression). +.IP \(bu 3 +Kompressionsverhältnis, das mittels Dividieren der Menge der bisher +komprimierten Daten durch die Menge der bisher verarbeiteten unkomprimierten +Daten ermittelt wird. +.IP \(bu 3 +Kompressions\- oder Dekompressionsgeschwindigkeit. Diese wird anhand der +Menge der unkomprimierten verarbeiteten Daten (bei der Kompression) oder der +Menge der erzeugten Daten (bei der Dekompression) pro Sekunde gemessen. Die +Anzeige startet einige Sekunden nachdem \fBxz\fP mit der Verarbeitung der Datei +begonnen hat. +.IP \(bu 3 +Die vergangene Zeit im Format M:SS oder H:MM:SS. +.IP \(bu 3 +Die geschätzte verbleibende Zeit wird nur angezeigt, wenn die Größe der +Eingabedatei bekannt ist und bereits einige Sekunden vergangen sind, nachdem +\fBxz\fP mit der Verarbeitung der Datei begonnen hat. Die Zeit wird in einem +weniger präzisen Format ohne Doppelpunkte angezeigt, zum Beispiel 2 min 30 +s. +.RE +.IP "" +Wenn die Standardfehlerausgabe kein Terminal ist, schreibt \fBxz\fP mit +\fB\-\-verbose\fP nach dem Komprimieren oder Dekomprimieren der Datei in einer +einzelnen Zeile den Dateinamen, die komprimierte Größe, die unkomprimierte +Größe, das Kompressionsverhältnis und eventuell auch die Geschwindigkeit und +die vergangene Zeit in die Standardfehlerausgabe. Die Geschwindigkeit und +die vergangene Zeit werden nur angezeigt, wenn der Vorgang mindestens ein +paar Sekunden gedauert hat. Wurde der Vorgang nicht beendet, zum Beispiel +weil ihn der Benutzer abgebrochen hat, wird außerdem der Prozentsatz des +erreichten Verarbeitungsfortschritts aufgenommen, sofern die Größe der +Eingabedatei bekannt ist. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +setzt den Exit\-Status nicht auf 2, selbst wenn eine Bedingung erfüllt ist, +die eine Warnung gerechtfertigt hätte. Diese Option wirkt sich nicht auf die +Ausführlichkeitsstufe aus, daher müssen sowohl \fB\-\-quiet\fP als auch +\fB\-\-no\-warn\fP angegeben werden, um einerseits keine Warnungen anzuzeigen und +andererseits auch den Exit\-Status nicht zu ändern. +.TP +\fB\-\-robot\fP +gibt Meldungen in einem maschinenlesbaren Format aus. Dadurch soll das +Schreiben von Frontends erleichtert werden, die \fBxz\fP anstelle von Liblzma +verwenden wollen, was in verschiedenen Skripten der Fall sein kann. Die +Ausgabe mit dieser aktivierten Option sollte über mehrere +\fBxz\fP\-Veröffentlichungen stabil sein. Details hierzu finden Sie im Abschnitt +\fBROBOTER\-MODUS\fP. +.TP +\fB\-\-info\-memory\fP +zeigt in einem menschenlesbaren Format an, wieviel physischen Speicher (RAM) +und wie viele Prozessor\-Threads das System nach Annahme von \fBxz\fP hat, sowie +die Speicherbedarfsbegrenzung für Kompression und Dekompression, und beendet +das Programm erfolgreich. +.TP +\fB\-h\fP, \fB\-\-help\fP +zeigt eine Hilfemeldung mit den am häufigsten genutzten Optionen an und +beendet das Programm erfolgreich. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +zeigt eine Hilfemeldung an, die alle Funktionsmerkmale von \fBxz\fP beschreibt +und beendet das Programm erfolgreich. +.TP +\fB\-V\fP, \fB\-\-version\fP +zeigt die Versionsnummer von \fBxz\fP und Liblzma in einem menschenlesbaren +Format an. Um eine maschinell auswertbare Ausgabe zu erhalten, geben Sie +\fB\-\-robot\fP vor \fB\-\-version\fP an. +. +.SH ROBOTER\-MODUS +Der Roboter\-Modus wird mit der Option \fB\-\-robot\fP aktiviert. Er bewirkt, dass +die Ausgabe von \fBxz\fP leichter von anderen Programmen ausgewertet werden +kann. Gegenwärtig wird \fB\-\-robot\fP nur zusammen mit \fB\-\-list\fP, +\fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP und \fB\-\-version\fP unterstützt. In der +Zukunft wird dieser Modus auch für Kompression und Dekompression +unterstützt. +. +.SS Listenmodus +\fBxz \-\-robot \-\-list\fP verwendet eine durch Tabulatoren getrennte Ausgabe. In +der ersten Spalte jeder Zeile bezeichnet eine Zeichenkette den Typ der +Information, die in dieser Zeile enthalten ist: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Dies ist stets die erste Zeile, wenn eine Datei aufgelistet wird. Die zweite +Spalte in der Zeile enthält den Dateinamen. +.TP +\fBfile\fP +Diese Zeile enthält allgemeine Informationen zur \fB.xz\fP\-Datei. Diese Zeile +wird stets nach der \fBname\fP\-Zeile ausgegeben. +.TP +\fBstream\fP +Dieser Zeilentyp wird nur verwendet, wenn \fB\-\-verbose\fP angegeben wurde. Es +gibt genau so viele \fBstream\fP\-Zeilen, wie Datenströme in der \fB.xz\fP\-Datei +enthalten sind. +.TP +\fBblock\fP +Dieser Zeilentyp wird nur verwendet, wenn \fB\-\-verbose\fP angegeben wurde. Es +gibt so viele \fBblock\fP\-Zeilen, wie Blöcke in der \fB.xz\fP\-Datei. Die +\fBblock\fP\-Zeilen werden nach allen \fBstream\fP\-Zeilen angezeigt; verschiedene +Zeilentypen werden nicht verschachtelt. +.TP +\fBsummary\fP +Dieser Zeilentyp wird nur verwendet, wenn \fB\-\-verbose\fP zwei Mal angegeben +wurde. Diese Zeile wird nach allen \fBblock\fP\-Zeilen ausgegeben. Wie die +\fBfile\fP\-Zeile enthält die \fBsummary\fP\-Zeile allgemeine Informationen zur +\&\fB.xz\fP\-Datei. +.TP +\fBtotals\fP +Diese Zeile ist immer die letzte der Listenausgabe. Sie zeigt die +Gesamtanzahlen und \-größen an. +.PP +Die Spalten der \fBfile\fP\-Zeilen: +.PD 0 +.RS +.IP 2. 4 +Anzahl der Datenströme in der Datei +.IP 3. 4 +Gesamtanzahl der Blöcke in den Datenströmen +.IP 4. 4 +Komprimierte Größe der Datei +.IP 5. 4 +Unkomprimierte Größe der Datei +.IP 6. 4 +Das Kompressionsverhältnis, zum Beispiel \fB0.123\fP. Wenn das Verhältnis über +9.999 liegt, werden drei Minuszeichen (\fB\-\-\-\fP) anstelle des +Kompressionsverhältnisses angezeigt. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Durch Kommata getrennte Liste der Namen der Integritätsprüfungen. Für die +bekannten Überprüfungstypen werden folgende Zeichenketten verwendet: +\fBNone\fP, \fBCRC32\fP, \fBCRC64\fP und \fBSHA\-256\fP. \fBUnknown\-\fP\fIN\fP wird verwendet, +wobei \fIN\fP die Kennung der Überprüfung als Dezimalzahl angibt (ein\- oder +zweistellig). +.IP 8. 4 +Gesamtgröße der Datenstromauffüllung in der Datei +.RE +.PD +.PP +Die Spalten der \fBstream\fP\-Zeilen: +.PD 0 +.RS +.IP 2. 4 +Datenstromnummer (der erste Datenstrom ist 1) +.IP 3. 4 +Anzahl der Blöcke im Datenstrom +.IP 4. 4 +Komprimierte Startposition +.IP 5. 4 +Unkomprimierte Startposition +.IP 6. 4 +Komprimierte Größe (schließt die Datenstromauffüllung nicht mit ein) +.IP 7. 4 +Unkomprimierte Größe +.IP 8. 4 +Kompressionsverhältnis +.IP 9. 4 +Name der Integritätsprüfung +.IP 10. 4 +Größe der Datenstromauffüllung +.RE +.PD +.PP +Die Spalten der \fBblock\fP\-Zeilen: +.PD 0 +.RS +.IP 2. 4 +Anzahl der in diesem Block enthaltenen Datenströme +.IP 3. 4 +Blocknummer relativ zum Anfang des Datenstroms (der erste Block ist 1) +.IP 4. 4 +Blocknummer relativ zum Anfang der Datei +.IP 5. 4 +Komprimierter Startversatz relativ zum Beginn der Datei +.IP 6. 4 +Unkomprimierter Startversatz relativ zum Beginn der Datei +.IP 7. 4 +Komprimierte Gesamtgröße des Blocks (einschließlich Header) +.IP 8. 4 +Unkomprimierte Größe +.IP 9. 4 +Kompressionsverhältnis +.IP 10. 4 +Name der Integritätsprüfung +.RE +.PD +.PP +Wenn \fB\-\-verbose\fP zwei Mal angegeben wurde, werden zusätzliche Spalten in +die \fBblock\fP\-Zeilen eingefügt. Diese werden mit einem einfachen \fB\-\-verbose\fP +nicht angezeigt, da das Ermitteln dieser Informationen viele Suchvorgänge +erfordert und daher recht langsam sein kann: +.PD 0 +.RS +.IP 11. 4 +Wert der Integritätsprüfung in hexadezimaler Notation +.IP 12. 4 +Block\-Header\-Größe +.IP 13. 4 +Block\-Schalter: \fBc\fP gibt an, dass die komprimierte Größe verfügbar ist, und +\fBu\fP gibt an, dass die unkomprimierte Größe verfügbar ist. Falls der +Schalter nicht gesetzt ist, wird stattdessen ein Bindestrich (\fB\-\fP) +angezeigt, um die Länge der Zeichenkette beizubehalten. In Zukunft könnten +neue Schalter am Ende der Zeichenkette hinzugefügt werden. +.IP 14. 4 +Größe der tatsächlichen komprimierten Daten im Block. Ausgeschlossen sind +hierbei die Block\-Header, die Blockauffüllung und die Prüffelder. +.IP 15. 4 +Größe des Speichers (in Byte), der zum Dekomprimieren dieses Blocks mit +dieser \fBxz\fP\-Version benötigt wird. +.IP 16. 4 +Filterkette. Beachten Sie, dass die meisten der bei der Kompression +verwendeten Optionen nicht bekannt sein können, da in den \fB.xz\fP\-Headern nur +die für die Dekompression erforderlichen Optionen gespeichert sind. +.RE +.PD +.PP +Die Spalten der \fBsummary\fP\-Zeilen: +.PD 0 +.RS +.IP 2. 4 +Größe des Speichers (in Byte), der zum Dekomprimieren dieser Datei mit +dieser \fBxz\fP\-Version benötigt wird. +.IP 3. 4 +\fByes\fP oder \fBno\fP geben an, ob in allen Block\-Headern sowohl die +komprimierte als auch die unkomprimierte Größe gespeichert ist. +.PP +\fISeit\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Minimale \fBxz\fP\-Version, die zur Dekompression der Datei erforderlich ist +.RE +.PD +.PP +Die Spalten der \fBtotals\fP\-Zeile: +.PD 0 +.RS +.IP 2. 4 +Anzahl der Datenströme +.IP 3. 4 +Anzahl der Blöcke +.IP 4. 4 +Komprimierte Größe +.IP 5. 4 +Unkomprimierte Größe +.IP 6. 4 +Durchschnittliches Kompressionsverhältnis +.IP 7. 4 +Durch Kommata getrennte Liste der Namen der Integritätsprüfungen, die in den +Dateien präsent waren. +.IP 8. 4 +Größe der Datenstromauffüllung +.IP 9. 4 +Anzahl der Dateien. Dies dient dazu, die Reihenfolge der vorigen Spalten an +die in den \fBfile\fP\-Zeilen anzugleichen. +.PD +.RE +.PP +Wenn \fB\-\-verbose\fP zwei Mal angegeben wird, werden zusätzliche Spalten in die +\fBtotals\fP\-Zeile eingefügt: +.PD 0 +.RS +.IP 10. 4 +Maximale Größe des Speichers (in Byte), der zum Dekomprimieren der Dateien +mit dieser \fBxz\fP\-Version benötigt wird. +.IP 11. 4 +\fByes\fP oder \fBno\fP geben an, ob in allen Block\-Headern sowohl die +komprimierte als auch die unkomprimierte Größe gespeichert ist. +.PP +\fISeit\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Minimale \fBxz\fP\-Version, die zur Dekompression der Datei erforderlich ist +.RE +.PD +.PP +Zukünftige Versionen könnten neue Zeilentypen hinzufügen, weiterhin könnten +auch in den vorhandenen Zeilentypen weitere Spalten hinzugefügt werden, aber +die existierenden Spalten werden nicht geändert. +. +.SS Filterhilfe +\fBxz \-\-robot \-\-filters\-help\fP gibt die unterstützten Filter im folgenden +Format aus: +.PP +\fIFilter\fP\fB:\fP\fIOption\fP\fB=<\fP\fIWert\fP\fB>,\fP\fIOption\fP\fB=<\fP\fIWert\fP\fB>\fP +… +.TP +\fIFilter\fP +Name des Filters +.TP +\fIOption\fP +Name der filterspezifischen Option +.TP +\fIWert\fP +Der numerische \fIWert\fP erscheint als Bereich +\fB<\fP\fIMinimum\fP\fB\-\fP\fIMaximum\fP\fB>\fP. Die Auswahl des +Zeichenketten\-\fIWert\fPs wird in \fB< >\fP eingeschlossen und durch \fB|\fP +getrennt. +.PP +Jeder Filter wird in einer separaten Zeile ausgegeben. +. +.SS "Informationen zur Speicherbedarfsbegrenzung" +\fBxz \-\-robot \-\-info\-memory\fP gibt eine einzelne Zeile mit mehreren durch +Tabulatoren getrennten Spalten aus: +.IP 1. 4 +Gesamter physischer Speicher (RAM) in Byte. +.IP 2. 4 +Speicherbedarfsbegrenzung für die Kompression in Byte +(\fB\-\-memlimit\-compress\fP). Ein spezieller Wert von \fB0\fP bezeichnet die +Standardeinstellung, die im Einzelthread\-Modus bedeutet, dass keine +Begrenzung vorhanden ist. +.IP 3. 4 +Speicherbedarfsbegrenzung für die Dekompression in Byte +(\fB\-\-memlimit\-decompress\fP). Ein spezieller Wert von \fB0\fP bezeichnet die +Standardeinstellung, die im Einzelthread\-Modus bedeutet, dass keine +Begrenzung vorhanden ist. +.IP 4. 4 +Seit \fBxz\fP 5.3.4alpha: Die Speichernutzung für Multithread\-Dekompression in +Byte (\fB\-\-memlimit\-mt\-decompress\fP). Dies ist niemals \fB0\fP, da ein +systemspezifischer Vorgabewert (gezeigt in Spalte 5) verwendet wird, falls +keine Grenze ausdrücklich angegeben wurde. Dies ist außerdem niemals größer +als der Wert in in Spalte 3, selbst wenn mit \fB\-\-memlimit\-mt\-decompress\fP ein +größerer Wert angegeben wurde. +.IP 5. 4 +Seit \fBxz\fP 5.3.4alpha: Eine systemspezifisch vorgegebene Begrenzung des +Speicherverbrauchs, die zur Begrenzung der Anzahl der Threads beim +Komprimieren mit automatischer Anzahl der Threads (\fB\-\-threads=0\fP) und wenn +keine Speicherbedarfsbegrenzung angegeben wurde (\fB\-\-memlimit\-compress\fP) +verwendet wird. Dies wird auch als Standardwert für +\fB\-\-memlimit\-mt\-decompress\fP verwendet. +.IP 6. 4 +Seit \fBxz\fP 5.3.4alpha: Anzahl der verfügbaren Prozessorthreads. +.PP +In der Zukunft könnte die Ausgabe von \fBxz \-\-robot \-\-info\-memory\fP weitere +Spalten enthalten, aber niemals mehr als eine einzelne Zeile. +. +.SS Version +\fBxz \-\-robot \-\-version\fP gibt die Versionsnummern von \fBxz\fP und Liblzma im +folgenden Format aus: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Hauptversion. +.TP +\fIYYY\fP +Unterversion. Gerade Zahlen bezeichnen eine stabile Version. Ungerade Zahlen +bezeichnen Alpha\- oder Betaversionen. +.TP +\fIZZZ\fP +Patch\-Stufe für stabile Veröffentlichungen oder einfach nur ein Zähler für +Entwicklungsversionen. +.TP +\fIS\fP +Stabilität. 0 ist Alpha, 1 ist Beta und 2 ist stabil. \fIS\fP sollte immer 2 +sein, wenn \fIYYY\fP eine gerade Zahl ist. +.PP +\fIXYYYZZZS\fP sind in beiden Zeilen gleich, sofern \fBxz\fP und Liblzma aus der +gleichen Veröffentlichung der XZ\-Utils stammen. +.PP +Beispiele: 4.999.9beta ist \fB49990091\fP und 5.0.0 is \fB50000002\fP. +. +.SH EXIT\-STATUS +.TP +\fB0\fP +Alles ist in Ordnung. +.TP +\fB1\fP +Ein Fehler ist aufgetreten. +.TP +\fB2\fP +Es ist etwas passiert, das eine Warnung rechtfertigt, aber es sind keine +tatsächlichen Fehler aufgetreten. +.PP +In die Standardausgabe geschriebene Hinweise (keine Warnungen oder Fehler), +welche den Exit\-Status nicht beeinflussen. +. +.SH UMGEBUNGSVARIABLEN +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP wertet eine durch Leerzeichen getrennte Liste von Optionen in den +Umgebungsvariablen \fBXZ_DEFAULTS\fP und \fBXZ_OPT\fP aus (in dieser Reihenfolge), +bevor die Optionen aus der Befehlszeile ausgewertet werden. Beachten Sie, +dass beim Auswerten der Umgebungsvariablen nur Optionen berücksichtigt +werden; alle Einträge, die keine Optionen sind, werden stillschweigend +ignoriert. Die Auswertung erfolgt mit \fBgetopt_long\fP(3), welches auch für +die Befehlszeilenargumente verwendet wird. +.PP +\fBWarnung:\fP Durch Setzen dieser Umgebungsvariablen könnte man effektiv +Programme und Skripte modifizieren, die \fBxz\fP ausführen. Meist ist es +sicher, die Speichernutzungsbegrenzung und Kompressionsoptionen über die +Umgebungsvariablen zu setzen. Dennoch können einige Optionen Skripte +beeinflussen. Ein typisches Beispiel ist die Option \fB\-\-help\fP, die einen +Hilfetext anzeigt, anstatt eine Datei zu komprimieren oder zu +dekomprimieren. Weniger augenfällige Beispiele sind die Optionen \fB\-\-quiet\fP +und \fB\-\-verbose\fP. In vielen Fällen funktioniert es gut, den +Fortschrittsindikator mit \fB\-\-verbose\fP zu aktivieren, aber in einigen +Situationen können die zusätzlichen Meldungen Probleme verursachen. Die +Ausführlichkeitsstufe beeinflusst auch das Verhalten von \fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Benutzerspezifische oder systemweite Standardoptionen. Typischerweise werden +diese in einem Shell\-Initialisierungsskript gesetzt, um die +Speicherbedarfsbegrenzung von \fBxz\fP standardmäßig zu aktivieren oder die +Anzahl der Threads festzulegen. Außer bei Shell\-Initialisierungsskripten und +in ähnlichen Spezialfällen sollte die Variable \fBXZ_DEFAULTS\fP in Skripten +niemals gesetzt oder außer Kraft gesetzt werden. +.TP +\fBXZ_OPT\fP +Dies dient der Übergabe von Optionen an \fBxz\fP, wenn es nicht möglich ist, +die Optionen direkt in der Befehlszeile von \fBxz\fP zu übergeben. Dies ist der +Fall, wenn \fBxz\fP von einem Skript oder Dienstprogramm ausgeführt wird, zum +Beispiel GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Skripte können \fBXZ_OPT\fP zum Beispiel zum Setzen skriptspezifischer +Standard\-Kompressionsoptionen verwenden. Es ist weiterhin empfehlenswert, +Benutzern die Außerkraftsetzung von \fBXZ_OPT\fP zu erlauben, falls dies +angemessen ist. Zum Beispiel könnte in \fBsh\fP(1)\-Skripten Folgendes stehen: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "KOMPATIBILITÄT ZU DEN LZMA\-UTILS" +Die Befehlszeilensyntax von \fBxz\fP ist praktisch eine Obermenge der von +\fBlzma\fP, \fBunlzma\fP und \fBlzcat\fP in den LZMA\-Utils der Versionen 4.32.x. In +den meisten Fällen sollte es möglich sein, die LZMA\-Utils durch die XZ\-Utils +zu ersetzen, ohne vorhandene Skripte ändern zu müssen. Dennoch gibt es +einige Inkompatibilitäten, die manchmal Probleme verursachen können. +. +.SS "Voreinstellungsstufen zur Kompression" +Die Nummerierung der Voreinstellungsstufen der Kompression ist in \fBxz\fP und +den LZMA\-Utils unterschiedlich. Der wichtigste Unterschied ist die Zuweisung +der Wörterbuchgrößen zu den verschiedenen Voreinstellungsstufen. Die +Wörterbuchgröße ist etwa gleich dem Speicherbedarf bei der Dekompression. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Stufe;xz;LZMA\-Utils +\-0;256 KiB;nicht verfügbar +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Die Unterschiede in der Wörterbuchgröße beeinflussen auch den Speicherbedarf +bei der Kompression, aber es gibt noch einige andere Unterschiede zwischen +den LZMA\-Utils und den XZ\-Utils, die die Kluft noch vergrößern: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Stufe;xz;LZMA\-Utils 4.32.x +\-0;3 MiB;nicht verfügbar +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Die standardmäßige Voreinstellungsstufe in den LZMA\-Utils ist \fB\-7\fP, während +diese in den XZ\-Utils \fB\-6\fP ist, daher verwenden beide standardmäßig ein 8 +MiB großes Wörterbuch. +. +.SS "Vor\- und Nachteile von .lzma\-Dateien als Datenströme" +Die unkomprimierte Größe der Datei kann in den \fB.lzma\fP\-Headern gespeichert +werden. Die LZMA\-Utils tun das beim Komprimieren gewöhnlicher Dateien. Als +Alternative kann die unkomprimierte Größe als unbekannt markiert und eine +Nutzdatenende\-Markierung (end\-of\-payload) verwendet werden, um anzugeben, wo +der Dekompressor stoppen soll. Die LZMA\-Utils verwenden diese Methode, wenn +die unkomprimierte Größe unbekannt ist, was beispielsweise in Pipes +(Befehlsverkettungen) der Fall ist. +.PP +\fBxz\fP unterstützt die Dekompression von \fB.lzma\fP\-Dateien mit oder ohne +Nutzdatenende\-Markierung, aber alle von \fBxz\fP erstellten \fB.lzma\fP\-Dateien +verwenden diesen Nutzdatenende\-Markierung, wobei die unkomprimierte Größe in +den \fB.lzma\fP\-Headern als unbekannt markiert wird. Das könnte in einigen +unüblichen Situationen ein Problem sein. Zum Beispiel könnte ein +\&\fB.lzma\fP\-Dekompressor in einem Gerät mit eingebettetem System nur mit +Dateien funktionieren, deren unkomprimierte Größe bekannt ist. Falls Sie auf +dieses Problem stoßen, müssen Sie die LZMA\-Utils oder das LZMA\-SDK +verwenden, um \fB.lzma\fP\-Dateien mit bekannter unkomprimierter Größe zu +erzeugen. +. +.SS "Nicht unterstützte .lzma\-Dateien" +Das \fB.lzma\fP\-Format erlaubt \fIlc\fP\-Werte bis zu 8 und \fIlp\fP\-Werte bis zu +4. Die LZMA\-Utils können Dateien mit beliebigem \fIlc\fP und \fIlp\fP +dekomprimieren, aber erzeugen immer Dateien mit \fBlc=3\fP und \fBlp=0\fP. Das +Erzeugen von Dateien mit anderem \fIlc\fP und \fIlp\fP ist mit \fBxz\fP und mit dem +LZMA\-SDK möglich. +.PP +Die Implementation des LZMA\-Filters in liblzma setzt voraus, dass die Summe +von \fIlc\fP und \fIlp\fP nicht größer als 4 ist. Daher können \fB.lzma\fP\-Dateien, +welche diese Begrenzung überschreiten, mit \fBxz\fP nicht dekomprimiert werden. +.PP +Die LZMA\-Utils erzeugen nur \fB.lzma\fP\-Dateien mit einer Wörterbuchgröße von +2^\fIn\fP (einer Zweierpotenz), aber akzeptieren Dateien mit einer beliebigen +Wörterbuchgröße. Liblzma akzeptiert nur \fB.lzma\fP\-Dateien mit einer +Wörterbuchgröße von 2^\fIn\fP oder 2^\fIn\fP + 2^(\fIn\fP\-1). Dies dient zum +Verringern von Fehlalarmen beim Erkennen von \fB.lzma\fP\-Dateien. +.PP +Diese Einschränkungen sollten in der Praxis kein Problem sein, da praktisch +alle \fB.lzma\fP\-Dateien mit Einstellungen komprimiert wurden, die Liblzma +akzeptieren wird. +. +.SS "Angehängter Datenmüll" +Bei der Dekompression ignorieren die LZMA\-Utils stillschweigend alles nach +dem ersten \fB.lzma\fP\-Datenstrom. In den meisten Situationen ist das ein +Fehler. Das bedeutet auch, dass die LZMA\-Utils die Dekompression verketteter +\&\fB.lzma\fP\-Dateien nicht unterstützen. +.PP +Wenn nach dem ersten \fB.lzma\fP\-Datenstrom Daten verbleiben, erachtet \fBxz\fP +die Datei als beschädigt, es sei denn, die Option \fB\-\-single\-stream\fP wurde +verwendet. Dies könnte die Ausführung von Skripten beeinflussen, die davon +ausgehen, dass angehängter Datenmüll ignoriert wird. +. +.SH ANMERKUNGEN +. +.SS "Die komprimierte Ausgabe kann variieren" +Die exakte komprimierte Ausgabe, die aus der gleichen unkomprimierten +Eingabedatei erzeugt wird, kann zwischen den Versionen der XZ\-Utils +unterschiedlich sein, selbst wenn die Kompressionsoptionen identisch +sind. Das kommt daher, weil der Kodierer verbessert worden sein könnte +(hinsichtlich schnellerer oder besserer Kompression), ohne das Dateiformat +zu beeinflussen. Die Ausgabe kann sogar zwischen verschiedenen Programmen +der gleichen Version der XZ\-Utils variieren, wenn bei der Erstellung des +Binärprogramms unterschiedliche Optionen verwendet wurden. +.PP +Sobald \fB\-\-rsyncable\fP implementiert wurde, bedeutet das, dass die sich +ergebenden Dateien nicht notwendigerweise mit Rsync abgeglichen werden +können, außer wenn die alte und neue Datei mit der gleichen \fBxz\fP\-Version +erzeugt wurden. Das Problem kann beseitigt werden, wenn ein Teil der +Encoder\-Implementierung eingefroren wird, um die mit Rsync abgleichbare +Ausgabe über \fBxz\fP\-Versionsgrenzen hinweg stabil zu halten. +. +.SS "Eingebettete .xz\-Dekompressoren" +Eingebettete \fB.xz\fP\-Dekompressor\-Implementierungen wie XZ Embedded +unterstützen nicht unbedingt Dateien, die mit anderen Integritätsprüfungen +(\fIPrüfung\fP\-Typen) als \fBnone\fP und \fBcrc32\fP erzeugt wurden. Da +\fB\-\-check=crc64\fP die Voreinstellung ist, müssen Sie \fB\-\-check=none\fP oder +\fB\-\-check=crc32\fP verwenden, wenn Sie Dateien für eingebettete Systeme +erstellen. +.PP +Außerhalb eingebetteter Systeme unterstützen die Dekompressoren des +\&\fB.xz\fP\-Formats alle \fIPrüfung\fP\-Typen oder sind mindestens in der Lage, die +Datei zu dekomprimieren, ohne deren Integrität zu prüfen, wenn die bestimmte +\fIPrüfung\fP nicht verfügbar ist. +.PP +XZ Embedded unterstützt BCJ\-Filter, aber nur mit dem vorgegebenen +Startversatz. +. +.SH BEISPIELE +. +.SS Grundlagen +Komprimiert die Datei \fIfoo\fP mit der Standard\-Kompressionsstufe (\fB\-6\fP) zu +\fIfoo.xz\fP und entfernt \fIfoo\fP nach erfolgreicher Kompression: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +\fIbar.xz\fP in \fIbar\fP dekomprimieren und \fIbar.xz\fP selbst dann nicht löschen, +wenn die Dekompression erfolgreich war: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +\fIbaz.tar.xz\fP mit der Voreinstellung \fB\-4e\fP (\fB\-4 \-\-extreme\fP) erzeugen, was +langsamer ist als die Vorgabe \fB\-6\fP, aber weniger Speicher für Kompression +und Dekompression benötigt (48\ MiB beziehungsweise 5\ MiB): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Eine Mischung aus komprimierten und unkomprimierten Dateien kann mit einem +einzelnen Befehl dekomprimiert in die Standardausgabe geschrieben werden: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Parallele Kompression von vielen Dateien" +Auf GNU\- und *BSD\-Systemen können \fBfind\fP(1) und \fBxargs\fP(1) zum +Parallelisieren der Kompression vieler Dateien verwendet werden: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Die Option \fB\-P\fP von \fBxargs\fP(1) legt die Anzahl der parallelen +\fBxz\fP\-Prozesse fest. Der beste Wert für die Option \fB\-n\fP hängt davon ab, wie +viele Dateien komprimiert werden sollen. Wenn es sich nur um wenige Dateien +handelt, sollte der Wert wahrscheinlich 1 sein; bei Zehntausenden von +Dateien kann 100 oder noch mehr angemessener sein, um die Anzahl der +\fBxz\fP\-Prozesse zu beschränken, die \fBxargs\fP(1) schließlich erzeugen wird. +.PP +Die Option \fB\-T1\fP für \fBxz\fP dient dazu, den Einzelthread\-Modus zu erzwingen, +da \fBxargs\fP(1) zur Steuerung des Umfangs der Parallelisierung verwendet +wird. +. +.SS Roboter\-Modus +Berechnen, wie viel Byte nach der Kompression mehrerer Dateien insgesamt +eingespart wurden: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Ein Skript könnte abfragen wollen, ob es ein \fBxz\fP verwendet, das aktuell +genug ist. Das folgende \fBsh\fP(1)\-Skript prüft, ob die Versionsnummer des +Dienstprogramms \fBxz\fP mindestens 5.0.0 ist. Diese Methode ist zu alten +Beta\-Versionen kompatibel, welche die Option \fB\-\-robot\fP nicht unterstützen: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Ihre Version von Xz ist zu alt." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Eine Speicherbedarfsbegrenzung für die Dekompression mit \fBXZ_OPT\fP setzen, +aber eine bereits gesetzte Begrenzung nicht erhöhen: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Benutzerdefinierte Filterketten für die Kompression" +Der einfachste Anwendungsfall für benutzerdefinierte Filterketten ist die +Anpassung von LZMA2\-Voreinstellungsstufen. Das kann nützlich sein, weil die +Voreinstellungen nur einen Teil der potenziell sinnvollen Kombinationen aus +Kompressionseinstellungen abdecken. +.PP +Die KompCPU\-Spalten der Tabellen aus den Beschreibungen der Optionen \fB\-0\fP … +\fB\-9\fP und \fB\-\-extreme\fP sind beim Anpassen der LZMA2\-Voreinstellungen +nützlich. Diese sind die relevanten Teile aus diesen zwei Tabellen: +.RS +.PP +.TS +tab(;); +c c +n n. +Voreinst.;KomprCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Wenn Sie wissen, dass eine Datei für eine gute Kompression ein etwas +größeres Wörterbuch benötigt (zum Beispiel 32 MiB), aber Sie sie schneller +komprimieren wollen, als dies mit \fBxz \-8\fP geschehen würde, kann eine +Voreinstellung mit einem niedrigen KompCPU\-Wert (zum Beispiel 1) dahingehend +angepasst werden, ein größeres Wörterbuch zu verwenden: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Mit bestimmten Dateien kann der obige Befehl schneller sein als \fBxz \-6\fP, +wobei die Kompression deutlich besser wird. Dennoch muss betont werden, dass +nur wenige Dateien von einem größeren Wörterbuch profitieren, wenn der +KompCPU\-Wert niedrig bleibt. Der offensichtlichste Fall, in dem ein größeres +Wörterbuch sehr hilfreich sein kann, ist ein Archiv, das einander sehr +ähnliche Dateien enthält, die jeweils wenigstens einige Megabyte groß +sind. Das Wörterbuch muss dann deutlich größer sein als die einzelne Datei, +damit LZMA2 den größtmöglichen Vorteil aus den Ähnlichkeiten der aufeinander +folgenden Dateien zieht. +.PP +Wenn hoher Speicherbedarf für Kompression und Dekompression kein Problem ist +und die zu komprimierende Datei mindestens einige Hundert Megabyte groß ist, +kann es sinnvoll sein, ein noch größeres Wörterbuch zu verwenden, als die 64 +MiB, die mit \fBxz \-9\fP verwendet werden würden: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Die Verwendung von \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) wie im obigen Beispiel +kann nützlich sein, um den Speicherbedarf für Kompressor und Dekompressor zu +sehen. Denken Sie daran, dass ein Wörterbuch, das größer als die +unkomprimierte Datei ist, Speicherverschwendung wäre. Daher ist der obige +Befehl für kleine Dateien nicht sinnvoll. +.PP +Manchmal spielt die Kompressionszeit keine Rolle, aber der Speicherbedarf +bei der Dekompression muss gering gehalten werden, zum Beispiel um die Datei +auf eingebetteten Systemen dekomprimieren zu können. Der folgende Befehl +verwendet \fB\-6e\fP (\fB\-6 \-\-extreme\fP) als Basis und setzt die Wörterbuchgröße +auf nur 64\ KiB. Die sich ergebende Datei kann mit XZ Embedded (aus diesem +Grund ist dort \fB\-\-check=crc32\fP) mit nur etwa 100\ KiB Speicher +dekomprimiert werden. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Wenn Sie so viele Byte wie möglich herausquetschen wollen, kann die +Anpassung der Anzahl der literalen Kontextbits (\fIlc\fP) und der Anzahl der +Positionsbits (\fIpb\fP) manchmal hilfreich sein. Auch die Anpassung der Anzahl +der literalen Positionsbits (\fIlp\fP) könnte helfen, aber üblicherweise sind +\fIlc\fP und \fIpb\fP wichtiger. Wenn ein Quellcode\-Archiv zum Beispiel +hauptsächlich ASCII\-Text enthält, könnte ein Aufruf wie der folgende eine +etwas kleinere Datei (etwa 0,1\ %) ergeben als mit \fBxz \-6e\fP (versuchen Sie +es auch \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Die Verwendung eines anderen Filters mit LZMA2 kann die Kompression bei +verschiedenen Dateitypen verbessern. So könnten Sie eine gemeinsam genutzte +Bibliothek der Architekturen x86\-32 oder x86\-64 mit dem BCJ\-Filter für x86 +komprimieren: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Beachten Sie, dass die Reihenfolge der Filteroptionen von Bedeutung +ist. Falls \fB\-\-x86\fP nach \fB\-\-lzma2\fP angegeben wird, gibt \fBxz\fP einen Fehler +aus, weil nach LZMA2 kein weiterer Filter sein darf und auch weil der +BCJ\-Filter für x86 nicht als letzter Filter in der Filterkette gesetzt +werden darf. +.PP +Der Delta\-Filter zusammen mit LZMA2 kann bei Bitmap\-Bildern gute Ergebnisse +liefern. Er sollte üblicherweise besser sein als PNG, welches zwar einige +fortgeschrittene Filter als ein simples delta bietet, aber für die +eigentliche Kompression »Deflate« verwendet. +.PP +Das Bild muss in einem unkomprimierten Format gespeichert werden, zum +Beispiel als unkomprimiertes TIFF. Der Abstandsparameter des Delta\-Filters +muss so gesetzt werden, dass er der Anzahl der Bytes pro Pixel im Bild +entspricht. Zum Beispiel erfordert ein 24\-Bit\-RGB\-Bitmap \fBdist=3\fP, außerdem +ist es gut, \fBpb=0\fP an LZMA2 zu übergeben, um die 3\-Byte\-Ausrichtung zu +berücksichtigen: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Wenn sich mehrere Bilder in einem einzelnen Archiv befinden (zum Beispiel\& +\&\fB.tar\fP), funktioniert der Delta\-Filter damit auch, sofern alle Bilder im +Archiv die gleiche Anzahl Bytes pro Pixel haben. +. +.SH "SIEHE AUCH" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA\-SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/unxz.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/unxz.1 new file mode 100644 index 0000000000000000000000000000000000000000..39e92ce91c266281499195e6ac04416517932d31 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/unxz.1 @@ -0,0 +1,2117 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" German translation for xz-man. +.\" Mario Blättermann , 2015, 2019-2020, 2022-2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 "8. März 2025" Tukaani XZ\-Dienstprogramme +. +.SH BEZEICHNUNG +xz, unxz, xzcat, lzma, unlzma, lzcat \- .xz\- und .lzma\-Dateien komprimieren +oder dekomprimieren +. +.SH ÜBERSICHT +\fBxz\fP [\fIOption…\fP] [\fIDatei…\fP] +. +.SH BEFEHLSALIASE +\fBunxz\fP ist gleichbedeutend mit \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP ist gleichbedeutend mit \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP ist gleichbedeutend mit \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP ist gleichbedeutend mit \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP ist gleichbedeutend mit \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Wenn Sie Skripte schreiben, die Dateien dekomprimieren, sollten Sie stets +den Namen \fBxz\fP mit den entsprechenden Argumenten (\fBxz \-d\fP oder \fBxz \-dc\fP) +anstelle der Namen \fBunxz\fP und \fBxzcat\fP verwenden. +. +.SH BESCHREIBUNG +\fBxz\fP ist ein Allzweckwerkzeug zur Datenkompression, dessen +Befehlszeilensyntax denen von \fBgzip\fP(1) und \fBbzip2\fP(1) ähnelt. Das native +Dateiformat ist das \fB.xz\fP\-Format, aber das veraltete, von den +LZMA\-Dienstprogrammen verwendete Format sowie komprimierte Rohdatenströme +ohne Containerformat\-Header werden ebenfalls unterstützt. Außerdem wird die +Dekompression des von \fBlzip\fP verwendeten \fB.lz\fP\-Formats unterstützt. +.PP +\fBxz\fP komprimiert oder dekomprimiert jede \fIDatei\fP entsprechend des +gewählten Vorgangsmodus. Falls entweder \fB\-\fP oder keine Datei angegeben ist, +liest \fBxz\fP aus der Standardeingabe und leitet die verarbeiteten Dateien in +die Standardausgabe. Wenn die Standardausgabe kein Terminal ist, verweigert +\fBxz\fP das Schreiben komprimierter Daten in die Standardausgabe. Dabei wird +eine Fehlermeldung angezeigt und die \fIDatei\fP übersprungen. Ebenso +verweigert \fBxz\fP das Lesen komprimierter Daten aus der Standardeingabe, wenn +diese ein Terminal ist. +.PP +\fIDateien\fP, die nicht als \fB\-\fP angegeben sind, werden in eine neue Datei +geschrieben, deren Name aus dem Namen der Quell\-\fIDatei\fP abgeleitet wird +(außer wenn \fB\-\-stdout\fP angegeben ist): +.IP \(bu 3 +Bei der Kompression wird das Suffix des Formats der Zieldatei (\fB.xz\fP oder +\&\fB.lzma\fP) an den Namen der Quelldatei angehängt und so der Name der +Zieldatei gebildet. +.IP \(bu 3 +Bei der Dekompression wird das Suffix \fB.xz\fP, \fB.lzma\fP oder \fB.lz\fP vom +Dateinamen entfernt und so der Name der Zieldatei gebildet. Außerdem erkennt +\fBxz\fP die Suffixe \fB.txz\fP und \fB.tlz\fP und ersetzt diese durch \fB.tar\fP. +.PP +Wenn die Zieldatei bereits existiert, wird eine Fehlermeldung angezeigt und +die \fIDatei\fP übersprungen. +.PP +Außer beim Schreiben in die Standardausgabe zeigt \fBxz\fP eine Warnung an und +überspringt die \fIDatei\fP, wenn eine der folgenden Bedingungen zutreffend +ist: +.IP \(bu 3 +Die \fIDatei\fP ist keine reguläre Datei. Symbolischen Verknüpfungen wird nicht +gefolgt und diese daher nicht zu den regulären Dateien gezählt. +.IP \(bu 3 +Die \fIDatei\fP hat mehr als eine harte Verknüpfung. +.IP \(bu 3 +Für die \fIDatei\fP ist das »setuid«\-, »setgid«\- oder »sticky«\-Bit gesetzt. +.IP \(bu 3 +Der Aktionsmodus wird auf Kompression gesetzt und die \fIDatei\fP hat bereits +das Suffix des Zieldateiformats (\fB.xz\fP oder \fB.txz\fP beim Komprimieren in +das \fB.xz\fP\-Format und \fB.lzma\fP oder \fB.tlz\fP beim Komprimieren in das +\&\fB.lzma\fP\-Format). +.IP \(bu 3 +Der Aktionsmodus wird auf Dekompression gesetzt und die \fIDatei\fP hat nicht +das Suffix eines der unterstützten Zieldateiformate (\fB.xz\fP, \fB.txz\fP, +\&\fB.lzma\fP, \fB.tlz\fP oder \fB.lz\fP). +.PP +Nach erfolgreicher Kompression oder Dekompression der \fIDatei\fP kopiert \fBxz\fP +Eigentümer, Gruppe, Zugriffsrechte, Zugriffszeit und Änderungszeit aus der +Ursprungs\-\fIDatei\fP in die Zieldatei. Sollte das Kopieren der Gruppe +fehlschlagen, werden die Zugriffsrechte so angepasst, dass jenen Benutzern +der Zugriff auf die Zieldatei verwehrt bleibt, die auch keinen Zugriff auf +die Ursprungs\-\fIDatei\fP hatten. Das Kopieren anderer Metadaten wie +Zugriffssteuerlisten oder erweiterter Attribute wird von \fBxz\fP noch nicht +unterstützt. +.PP +Sobald die Zieldatei erfolgreich geschlossen wurde, wird die +Ursprungs\-\fIDatei\fP entfernt. Dies wird durch die Option \fB\-\-keep\fP +verhindert. Die Ursprungs\-\fIDatei\fP wird niemals entfernt, wenn die Ausgabe +in die Standardausgabe geschrieben wird oder falls ein Fehler auftritt. +.PP +Durch Senden der Signale \fBSIGINFO\fP oder \fBSIGUSR1\fP an den \fBxz\fP\-Prozess +werden Fortschrittsinformationen in den Fehlerkanal der Standardausgabe +geleitet. Dies ist nur eingeschränkt hilfreich, wenn die +Standardfehlerausgabe ein Terminal ist. Mittels \fB\-\-verbose\fP wird ein +automatisch aktualisierter Fortschrittsanzeiger angezeigt. +. +.SS Speicherbedarf +In Abhängigkeit von den gewählten Kompressionseinstellungen bewegt sich der +Speicherverbrauch zwischen wenigen hundert Kilobyte und mehreren +Gigabyte. Die Einstellungen bei der Kompression einer Datei bestimmen dabei +den Speicherbedarf bei der Dekompression. Die Dekompression benötigt +üblicherweise zwischen 5\ % und 20\ % des Speichers, der bei der Kompression +der Datei erforderlich war. Beispielsweise benötigt die Dekompression einer +Datei, die mit \fBxz \-9\fP komprimiert wurde, gegenwärtig etwa 65\ MiB +Speicher. Es ist jedoch auch möglich, dass \fB.xz\fP\-Dateien mehrere Gigabyte +an Speicher zur Dekompression erfordern. +.PP +Insbesondere für Benutzer älterer Systeme wird eventuell ein sehr großer +Speicherbedarf ärgerlich sein. Um unangenehme Überraschungen zu vermeiden, +verfügt \fBxz\fP über eine eingebaute Begrenzung des Speicherbedarfs, die +allerdings in der Voreinstellung deaktiviert ist. Zwar verfügen einige +Betriebssysteme über eingebaute Möglichkeiten zur prozessabhängigen +Speicherbegrenzung, doch diese sind zu unflexibel (zum Beispiel kann +\fBulimit\fP(1) beim Begrenzen des virtuellen Speichers \fBmmap\fP(2) +beeinträchtigen). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Die Begrenzung des Speicherbedarfs kann mit der Befehlszeilenoption +\fB\-\-memlimit=\fP\fIBegrenzung\fP aktiviert werden. Oft ist es jedoch bequemer, +die Begrenzung durch Setzen der Umgebungsvariable \fBXZ_DEFAULTS\fP +standardmäßig zu aktivieren, zum Beispiel +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Die Begrenzungen können getrennt für +Kompression und Dekompression mittels \fB\-\-memlimit\-compress=\fP\fIBegrenzung\fP +und \fB\-\-memlimit\-decompress=\fP\fIBegrenzung\fP festgelegt werden. Die Verwendung +einer solchen Option außerhalb der Variable \fBXZ_DEFAULTS\fP ist kaum +sinnvoll, da \fBxz\fP in einer einzelnen Aktion nicht gleichzeitig Kompression +und Dekompression ausführen kann und \fB\-\-memlimit=\fP\fIBegrenzung\fP (oder \fB\-M\fP +\fIBegrenzung\fP) lässt sich einfacher in der Befehlszeile eingeben. +.PP +Wenn die angegebene Speicherbegrenzung bei der Dekompression überschritten +wird, schlägt der Vorgang fehl und \fBxz\fP zeigt eine Fehlermeldung an. Wird +die Begrenzung bei der Kompression überschritten, dann versucht \fBxz\fP die +Einstellungen entsprechend anzupassen, außer wenn \fB\-\-format=raw\fP oder +\fB\-\-no\-adjust\fP angegeben ist. Auf diese Weise schlägt die Aktion nicht fehl, +es sei denn, die Begrenzung wurde sehr niedrig angesetzt. Die Anpassung der +Einstellungen wird schrittweise vorgenommen, allerdings entsprechen die +Schritte nicht den Voreinstellungen der Kompressionsstufen. Das bedeutet, +wenn beispielsweise die Begrenzung nur geringfügig unter den Anforderungen +für \fBxz \-9\fP liegt, werden auch die Einstellungen nur wenig angepasst und +nicht vollständig herunter zu den Werten für \fBxz \-8\fP +. +.SS "Verkettung und Auffüllung von .xz\-Dateien" +Es ist möglich, \fB.xz\fP\-Dateien direkt zu verketten. Solche Dateien werden +von \fBxz\fP genauso dekomprimiert wie eine einzelne \fB.xz\fP\-Datei. +.PP +Es ist weiterhin möglich, eine Auffüllung zwischen den verketteten Teilen +oder nach dem letzten Teil einzufügen. Die Auffüllung muss aus Null\-Bytes +bestehen und deren Größe muss ein Vielfaches von vier Byte sein. Dies kann +zum Beispiel dann vorteilhaft sein, wenn die \fB.xz\fP\-Datei auf einem +Datenträger gespeichert wird, dessen Dateisystem die Dateigrößen in +512\-Byte\-Blöcken speichert. +.PP +Verkettung und Auffüllung sind für \fB.lzma\fP\-Dateien oder Rohdatenströme +nicht erlaubt. +. +.SH OPTIONEN +. +.SS "Ganzzahlige Suffixe und spezielle Werte" +An den meisten Stellen, wo ein ganzzahliges Argument akzeptiert wird, kann +ein optionales Suffix große Ganzzahlwerte einfacher darstellen. Zwischen +Ganzzahl und dem Suffix dürfen sich keine Leerzeichen befinden. +.TP +\fBKiB\fP +multipliziert die Ganzzahl mit 1.024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP und +\fBKB\fP werden als Synonyme für \fBKiB\fP akzeptiert. +.TP +\fBMiB\fP +multipliziert die Ganzzahl mit 1.048.576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP und \fBMB\fP +werden als Synonyme für \fBMiB\fP akzeptiert. +.TP +\fBGiB\fP +multipliziert die Ganzzahl mit 1.073.741.824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP und +\fBGB\fP werden als Synonyme für \fBGiB\fP akzeptiert. +.PP +Der spezielle Wert \fBmax\fP kann dazu verwendet werden, um den von der +jeweiligen Option akzeptierten maximalen Ganzzahlwert anzugeben. +. +.SS Aktionsmodus +Falls mehrere Aktionsmodi angegeben sind, wird der zuletzt angegebene +verwendet. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Kompression. Dies ist der voreingestellte Aktionsmodus, sofern keiner +angegeben ist und auch kein bestimmter Modus aus dem Befehlsnamen abgeleitet +werden kann (der Befehl \fBunxz\fP impliziert zum Beispiel \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Nach erfolgreicher Kompression wird die Quelldatei gelöscht, außer wenn in +die Standardausgabe geschrieben wird oder \fB\-\-keep\fP angegeben wurde. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Dekomprimieren. Nach erfolgreicher Dekompression wird die Quelldatei +gelöscht, außer wenn in die Standardausgabe geschrieben wird oder \fB\-\-keep\fP +angegeben wurde. +.TP +\fB\-t\fP, \fB\-\-test\fP +prüft die Integrität der komprimierten \fIDateien\fP. Diese Option ist +gleichbedeutend mit \fB\-\-decompress \-\-stdout\fP, außer dass die dekomprimierten +Daten verworfen werden, anstatt sie in die Standardausgabe zu leiten. Es +werden keine Dateien erstellt oder entfernt. +.TP +\fB\-l\fP, \fB\-\-list\fP +gibt Informationen zu den komprimierten \fIDateien\fP aus. Es werden keine +unkomprimierten Dateien ausgegeben und keine Dateien angelegt oder +entfernt. Im Listenmodus kann das Programm keine komprimierten Daten aus der +Standardeingabe oder anderen nicht durchsuchbaren Quellen lesen. +.IP "" +Die Liste zeigt in der Standardeinstellung grundlegende Informationen zu den +\fIDateien\fP an, zeilenweise pro Datei. Detailliertere Informationen erhalten +Sie mit der Option \fB\-\-verbose\fP. Wenn Sie diese Option zweimal angeben, +werden noch ausführlichere Informationen ausgegeben. Das kann den Vorgang +allerdings deutlich verlangsamen, da die Ermittlung der zusätzlichen +Informationen zahlreiche Suchvorgänge erfordert. Die Breite der +ausführlichen Ausgabe übersteigt 80 Zeichen, daher könnte die Weiterleitung +in beispielsweise\& \fBless\ \-S\fP sinnvoll sein, falls das Terminal nicht +breit genug ist. +.IP "" +Die exakte Ausgabe kann in verschiedenen \fBxz\fP\-Versionen und +Spracheinstellungen unterschiedlich sein. Wenn eine maschinell auswertbare +Ausgabe gewünscht ist, dann sollten Sie \fB\-\-robot \-\-list\fP verwenden. +. +.SS Aktionsattribute +.TP +\fB\-k\fP, \fB\-\-keep\fP +verhindert das Löschen der Eingabedateien. +.IP "" +Seit der \fBxz\fP\-Version 5.2.6 wird die Kompression oder Dekompression auch +dann ausgeführt, wenn die Eingabe ein symbolischer Link zu einer regulären +Datei ist, mehr als einen harten Link hat oder das »setuid«\-, »setgid«\- oder +»sticky«\-Bit gesetzt ist. Die genannten Bits werden nicht in die Zieldatei +kopiert. In früheren Versionen geschah dies nur mit \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Diese Option hat verschiedene Auswirkungen: +.RS +.IP \(bu 3 +Wenn die Zieldatei bereits existiert, wird diese vor der Kompression oder +Dekompression gelöscht. +.IP \(bu 3 +Die Kompression oder Dekompression wird auch dann ausgeführt, wenn die +Eingabe ein symbolischer Link zu einer regulären Datei ist, mehr als einen +harten Link hat oder das »setuid«\-, »setgid«\- oder »sticky«\-Bit gesetzt +ist. Die genannten Bits werden nicht in die Zieldatei kopiert. +.IP \(bu 3 +Wenn es zusammen mit \fB\-\-decompress\fP und \fB\-\-stdout\fP verwendet wird und +\fBxz\fP den Typ der Quelldatei nicht ermitteln kann, wird die Quelldatei +unverändert in die Standardausgabe kopiert. Dadurch kann \fBxzcat\fP \fB\-\-force\fP +für Dateien, die nicht mit \fBxz\fP komprimiert wurden, wie \fBcat\fP(1) verwendet +werden. Zukünftig könnte \fBxz\fP neue Dateikompressionsformate unterstützen, +wodurch \fBxz\fP mehr Dateitypen dekomprimieren kann, anstatt sie unverändert +in die Standardausgabe zu kopieren. Mit der Option \fB\-\-format=\fP\fIFormat\fP +können Sie \fBxz\fP anweisen, nur ein einzelnes Dateiformat zu dekomprimieren. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +schreibt die komprimierten oder dekomprimierten Daten in die Standardausgabe +anstatt in eine Datei. Dies impliziert \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +dekomprimiert nur den ersten \fB.xz\fP\-Datenstrom und ignoriert stillschweigend +weitere Eingabedaten, die möglicherweise dem Datenstrom +folgen. Normalerweise führt solcher anhängender Datenmüll dazu, dass \fBxz\fP +eine Fehlermeldung ausgibt. +.IP "" +\fBxz\fP dekomprimiert niemals mehr als einen Datenstrom aus \fB.lzma\fP\-Dateien +oder Rohdatenströmen, aber dennoch wird durch diese Option möglicherweise +vorhandener Datenmüll nach der \fB.lzma\fP\-Datei oder dem Rohdatenstrom +ignoriert. +.IP "" +Diese Option ist wirkungslos, wenn der Aktionsmodus nicht \fB\-\-decompress\fP +oder \fB\-\-test\fP ist. +.IP "" +Seit der Programmversion \fBxz\fP 5.7.1alpha impliziert \fB\-\-single\-stream\fP +zusätzlich die Option \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +verhindert die Erzeugung von Sparse\-Dateien. In der Voreinstellung versucht +\fBxz\fP, bei der Dekompression in eine reguläre Datei eine Sparse\-Datei zu +erzeugen, wenn die dekomprimierten Daten lange Abfolgen von binären Nullen +enthalten. Dies funktioniert auch beim Schreiben in die Standardausgabe, +sofern diese in eine reguläre Datei weitergeleitet wird und bestimmte +Zusatzbedingungen erfüllt sind, die die Aktion absichern. Die Erzeugung von +Sparse\-Dateien kann Plattenplatz sparen und beschleunigt die Dekompression +durch Verringerung der Ein\-/Ausgaben der Platte. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +verwendet \fI.suf\fP bei der Dekompression anstelle von \fB.xz\fP oder \fB.lzma\fP +als Suffix für die Zieldatei. Falls nicht in die Standardausgabe geschrieben +wird und die Quelldatei bereits das Suffix \fI.suf\fP hat, wird eine Warnung +angezeigt und die Datei übersprungen. +.IP "" +berücksichtigt bei der Dekompression zusätzlich zu Dateien mit den Suffixen +\&\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP oder \fB.lz\fP auch jene mit dem Suffix +\&\fI.suf\fP. Falls die Quelldatei das Suffix \fI.suf\fP hat, wird dieses entfernt +und so der Name der Zieldatei abgeleitet. +.IP "" +Beim Komprimieren oder Dekomprimieren von Rohdatenströmen mit +\fB\-\-format=raw\fP muss das Suffix stets angegeben werden, außer wenn die +Ausgabe in die Standardausgabe erfolgt. Der Grund dafür ist, dass es kein +vorgegebenes Suffix für Rohdatenströme gibt. +.TP +\fB\-\-files\fP[\fB=\fP\fIDatei\fP] +liest die zu verarbeitenden Dateinamen aus \fIDatei\fP. Falls keine \fIDatei\fP +angegeben ist, werden die Dateinamen aus der Standardeingabe +gelesen. Dateinamen müssen mit einem Zeilenumbruch beendet werden. Ein +Bindestrich (\fB\-\fP) wird als regulärer Dateiname angesehen und nicht als +Standardeingabe interpretiert. Falls Dateinamen außerdem als +Befehlszeilenargumente angegeben sind, werden diese vor den Dateinamen aus +der \fIDatei\fP verarbeitet. +.TP +\fB\-\-files0\fP[\fB=\fP\fIDatei\fP] +Dies ist gleichbedeutend mit \fB\-\-files\fP[\fB=\fP\fIDatei\fP], außer dass jeder +Dateiname mit einem Null\-Zeichen abgeschlossen werden muss. +. +.SS "Grundlegende Dateiformat\- und Kompressionsoptionen" +.TP +\fB\-F\fP \fIFormat\fP, \fB\-\-format=\fP\fIFormat\fP +gibt das \fIFormat\fP der zu komprimierenden oder dekomprimierenden Datei an: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Dies ist die Voreinstellung. Bei der Kompression ist \fBauto\fP gleichbedeutend +mit \fBxz\fP. Bei der Dekompression wird das Format der Eingabedatei +automatisch erkannt. Beachten Sie, dass Rohdatenströme, wie sie mit +\fB\-\-format=raw\fP erzeugt werden, nicht automatisch erkannt werden können. +.TP +\fBxz\fP +Die Kompression erfolgt in das \fB.xz\fP\-Dateiformat oder akzeptiert nur +\&\fB.xz\fP\-Dateien bei der Dekompression. +.TP +\fBlzma\fP, \fBalone\fP +Die Kompression erfolgt in das veraltete \fB.lzma\fP\-Dateiformat oder +akzeptiert nur \fB.lzma\fP\-Dateien bei der Dekompression. Der alternative Name +\fBalone\fP dient der Abwärtskompatibilität zu den LZMA\-Dienstprogrammen. +.TP +\fBlzip\fP +Akzeptiert nur \fB.lz\fP\-Dateien bei der Dekompression. Kompression wird nicht +unterstützt. +.IP "" +The \fB.lz\fP format versions 0 and 1 are supported. Version 0 files were +produced by \fBlzip\fP 1.3 and older. Such files aren't common but may be +found from file archives as a few source packages were released in this +format. People might have old personal files in this format too. +Decompression support for the format version 0 was removed in \fBlzip\fP 1.18. +\fBlzip\fP 1.4 and later create files in the format version 1. +.TP +\fBraw\fP +Komprimiert oder dekomprimiert einen Rohdatenstrom (ohne Header). Diese +Option ist nur für fortgeschrittene Benutzer bestimmt. Zum Dekodieren von +Rohdatenströmen müssen Sie die Option \fB\-\-format=raw\fP verwenden und die +Filterkette ausdrücklich angeben, die normalerweise in den (hier fehlenden) +Container\-Headern gespeichert worden wäre. +.RE +.TP +\fB\-C\fP \fIPrüfung\fP, \fB\-\-check=\fP\fIPrüfung\fP +gibt den Typ der Integritätsprüfung an. Die Prüfsumme wird aus den +unkomprimierten Daten berechnet und in der \fB.xz\fP\-Datei gespeichert. Diese +Option wird nur bei der Kompression in das \fB.xz\fP\-Format angewendet, da das +\&\fB.lzma\fP\-Format keine Integritätsprüfungen unterstützt. Die eigentliche +Integritätsprüfung erfolgt (falls möglich), wenn die \fB.xz\fP\-Datei +dekomprimiert wird. +.IP "" +Folgende Typen von \fIPrüfungen\fP werden unterstützt: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +führt keine Integritätsprüfung aus. Dies ist eine eher schlechte +Idee. Dennoch kann es nützlich sein, wenn die Integrität der Daten auf +andere Weise sichergestellt werden kann. +.TP +\fBcrc32\fP +berechnet die CRC32\-Prüfsumme anhand des Polynoms aus IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +berechnet die CRC64\-Prüfsumme anhand des Polynoms aus ECMA\-182. Dies ist die +Voreinstellung, da beschädigte Dateien etwas besser als mit CRC32 erkannt +werden und die Geschwindigkeitsdifferenz unerheblich ist. +.TP +\fBsha256\fP +berechnet die SHA\-256\-Prüfsumme. Dies ist etwas langsamer als CRC32 und +CRC64. +.RE +.IP "" +Die Integrität der \fB.xz\fP\-Header wird immer mit CRC32 geprüft. Es ist nicht +möglich, dies zu ändern oder zu deaktivieren. +.TP +\fB\-\-ignore\-check\fP +verifiziert die Integritätsprüfsumme der komprimierten Daten bei der +Dekompression nicht. Die CRC32\-Werte in den \fB.xz\fP\-Headern werden weiterhin +normal verifiziert. +.IP "" +\fBVerwenden Sie diese Option nicht, außer Sie wissen, was Sie tun.\fP Mögliche +Gründe, diese Option zu verwenden: +.RS +.IP \(bu 3 +Versuchen, Daten aus einer beschädigten .xz\-Datei wiederherzustellen. +.IP \(bu 3 +Erhöhung der Geschwindigkeit bei der Dekompression. Dies macht sich meist +mit SHA\-256 bemerkbar, oder mit Dateien, die extrem stark komprimiert +sind. Wir empfehlen, diese Option nicht für diesen Zweck zu verwenden, es +sei denn, die Integrität der Datei wird extern auf andere Weise überprüft. +.RE +.TP +\fB\-0\fP … \fB\-9\fP +wählt eine der voreingestellten Kompressionsstufen, standardmäßig +\fB\-6\fP. Wenn mehrere Voreinstellungsstufen angegeben sind, ist nur die +zuletzt angegebene wirksam. Falls bereits eine benutzerdefinierte +Filterkette angegeben wurde, wird diese durch die Festlegung der +Voreinstellung geleert. +.IP "" +Die Unterschiede zwischen den Voreinstellungsstufen sind deutlicher als bei +\fBgzip\fP(1) und \fBbzip2\fP(1). Die gewählten Kompressionseinstellungen +bestimmen den Speicherbedarf bei der Dekompression, daher ist es auf älteren +Systemen mit wenig Speicher bei einer zu hoch gewählten Voreinstellung +schwer, eine Datei zu dekomprimieren. Insbesondere \fBist es keine gute Idee, blindlings \-9 für alles\fP zu verwenden, wie dies häufig mit \fBgzip\fP(1) und +\fBbzip2\fP(1) gehandhabt wird. +.RS +.TP +\fB\-0\fP … \fB\-3\fP +Diese Voreinstellungen sind recht schnell. \fB\-0\fP ist manchmal schneller als +\fBgzip \-9\fP, wobei aber die Kompression wesentlich besser ist. Die +schnelleren Voreinstellungen sind im Hinblick auf die Geschwindigkeit mit +\fBbzip2\fP(1) vergleichbar , mit einem ähnlichen oder besseren +Kompressionsverhältnis, wobei das Ergebnis aber stark vom Typ der zu +komprimierenden Daten abhängig ist. +.TP +\fB\-4\fP … \fB\-6\fP +Gute bis sehr gute Kompression, wobei der Speicherbedarf für die +Dekompression selbst auf alten Systemen akzeptabel ist. \fB\-6\fP ist die +Voreinstellung, welche üblicherweise eine gute Wahl für die Verteilung von +Dateien ist, die selbst noch auf Systemen mit nur 16\ MiB Arbeitsspeicher +dekomprimiert werden müssen (\fB\-5e\fP oder \fB\-6e\fP sind ebenfalls eine +Überlegung wert. Siehe \fB\-\-extreme\fP). +.TP +\fB\-7 … \-9\fP +Ähnlich wie \fB\-6\fP, aber mit einem höheren Speicherbedarf für die Kompression +und Dekompression. Sie sind nur nützlich, wenn Dateien komprimiert werden +sollen, die größer als 8\ MiB, 16\ MiB beziehungsweise 32\ MiB sind. +.RE +.IP "" +Auf der gleichen Hardware ist die Dekompressionsgeschwindigkeit ein nahezu +konstanter Wert in Bytes komprimierter Daten pro Sekunde. Anders +ausgedrückt: Je besser die Kompression, umso schneller wird üblicherweise +die Dekompression sein. Das bedeutet auch, dass die Menge der pro Sekunde +ausgegebenen unkomprimierten Daten stark variieren kann. +.IP "" +Die folgende Tabelle fasst die Eigenschaften der Voreinstellungen zusammen: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Voreinst.;Wörtb.Gr;KomprCPU;KompSpeich;DekompSpeich +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Spaltenbeschreibungen: +.RS +.IP \(bu 3 +Wörtb.Größe ist die Größe des LZMA2\-Wörterbuchs. Es ist +Speicherverschwendung, ein Wörterbuch zu verwenden, das größer als die +unkomprimierte Datei ist. Daher ist es besser, die Voreinstellungen \fB\-7\fP … +\fB\-9\fP zu vermeiden, falls es keinen wirklichen Bedarf dafür gibt. Mit \fB\-6\fP +und weniger wird üblicherweise so wenig Speicher verschwendet, dass dies +nicht ins Gewicht fällt. +.IP \(bu 3 +KomprCPU ist eine vereinfachte Repräsentation der LZMA2\-Einstellungen, +welche die Kompressionsgeschwindigkeit beeinflussen. Die Wörterbuchgröße +wirkt sich ebenfalls auf die Geschwindigkeit aus. Während KompCPU für die +Stufen \fB\-6\fP bis \fB\-9\fP gleich ist, tendieren höhere Stufen dazu, etwas +langsamer zu sein. Um eine noch langsamere, aber möglicherweise bessere +Kompression zu erhalten, siehe \fB\-\-extreme\fP. +.IP \(bu 3 +KompSpeich enthält den Speicherbedarf des Kompressors im +Einzel\-Thread\-Modus. Dieser kann zwischen den \fBxz\fP\-Versionen leicht +variieren. +.IP \(bu 3 +DekompSpeich enthält den Speicherbedarf für die Dekompression. Das bedeutet, +dass die Kompressionseinstellungen den Speicherbedarf bei der Dekompression +bestimmen. Der exakte Speicherbedarf bei der Dekompression ist geringfügig +größer als die Größe des LZMA2\-Wörterbuchs, aber die Werte in der Tabelle +wurden auf ganze MiB aufgerundet. +.RE +.IP "" + Der Speicherbedarf einiger der zukünftigen Multithread\-Modi kann dramatisch +höher sein als im Einzel\-Thread\-Modus. Mit dem Standardwert von +\fB\-\-block\-size\fP benötigt jeder Thread 3*3*Wörtb.Gr plus KompSpeich oder +DekompSpeich. Beispielsweise benötigen vier Threads mit der Voreinstellung +\fB\-6\fP etwa 660 bis 670 MiB Speicher. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +verwendet eine langsamere Variante der gewählten +Kompressions\-Voreinstellungsstufe (\fB\-0\fP … \fB\-9\fP), um hoffentlich ein etwas +besseres Kompressionsverhältnis zu erreichen, das aber in ungünstigen Fällen +auch schlechter werden kann. Der Speicherverbrauch bei der Dekompression +wird dabei nicht beeinflusst, aber der Speicherverbrauch der Kompression +steigt in den Voreinstellungsstufen \fB\-0\fP bis \fB\-3\fP geringfügig an. +.IP "" +Da es zwei Voreinstellungen mit den Wörterbuchgrößen 4\ MiB und 8\ MiB gibt, +verwenden die Voreinstellungsstufen \fB\-3e\fP und \fB\-5e\fP etwas schnellere +Einstellungen (niedrigere KompCPU) als \fB\-4e\fP beziehungsweise \fB\-6e\fP. Auf +diese Weise sind zwei Voreinstellungen nie identisch. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Voreinst.;Wörtb.Gr;KomprCPU;KompSpeich;DekompSpeich +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Zum Beispiel gibt es insgesamt vier Voreinstellungen, die ein 8\ MiB großes +Wörterbuch verwenden, deren Reihenfolge von der schnellsten zur langsamsten +\fB\-5\fP, \fB\-6\fP, \fB\-5e\fP und \fB\-6e\fP ist. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +sind etwas irreführende Aliase für \fB\-0\fP beziehungsweise \fB\-9\fP. Sie werden +nur zwecks Abwärtskompatibilität zu den LZMA\-Dienstprogrammen +bereitgestellt. Sie sollten diese Optionen besser nicht verwenden. +.TP +\fB\-\-block\-size=\fP\fIGröße\fP +teilt beim Komprimieren in das \fB.xz\fP\-Format die Eingabedaten in Blöcke der +angegebenen \fIGröße\fP in Byte. Die Blöcke werden unabhängig voneinander +komprimiert, was dem Multi\-Threading entgegen kommt und Zufallszugriffe bei +der Dekompression begrenzt. Diese Option wird typischerweise eingesetzt, um +die vorgegebene Blockgröße im Multi\-Thread\-Modus außer Kraft zu setzen, aber +sie kann auch im Einzel\-Thread\-Modus angewendet werden. +.IP "" +Im Multi\-Thread\-Modus wird etwa die dreifache \fIGröße\fP in jedem Thread zur +Pufferung der Ein\- und Ausgabe belegt. Die vorgegebene \fIGröße\fP ist das +Dreifache der Größe des LZMA2\-Wörterbuchs oder 1 MiB, je nachdem, was mehr +ist. Typischerweise ist das Zwei\- bis Vierfache der Größe des +LZMA2\-Wörterbuchs oder wenigstens 1 MB ein guter Wert. Eine \fIGröße\fP, die +geringer ist als die des LZMA2\-Wörterbuchs, ist Speicherverschwendung, weil +dann der LZMA2\-Wörterbuchpuffer niemals vollständig genutzt werden würde. Im +Multi\-Thread\-Modus wird die Größe der Blöcke wird in den Block\-Headern +gespeichert. Die Größeninformation wird für eine Multi\-Thread\-Dekompression +genutzt. +.IP "" +Im Einzel\-Thread\-Modus werden die Blöcke standardmäßig nicht geteilt. Das +Setzen dieser Option wirkt sich nicht auf den Speicherbedarf aus. In den +Block\-Headern werden keine Größeninformationen gespeichert, daher werden im +Einzel\-Thread\-Modus erzeugte Dateien nicht zu den im Multi\-Thread\-Modus +erzeugten Dateien identisch sein. Das Fehlen der Größeninformation bedingt +auch, dass \fBxz\fP nicht in der Lage sein wird, die Dateien im +Multi\-Thread\-Modus zu dekomprimieren. +.TP +\fB\-\-block\-list=\fP\fIBlöcke\fP +beginnt bei der Kompression in das \fB.xz\fP\-Format nach den angegebenen +Intervallen unkomprimierter Daten einen neuen Block, optional mit einer +benutzerdefinierten Filterkette. +.IP "" +Die \fIBlöcke\fP werden in einer durch Kommata getrennten Liste +angegeben. Jeder Block besteht aus einer optionalen Filterkettennummer +zwischen 0 und 9, gefolgt von einem Doppelpunkt (\fB:\fP) und der Größe der +unkomprimierten Daten (diese Angabe ist erforderlich). Überspringen eines +Blocks (zwei oder mehr aufeinander folgende Kommata) ist ein Kürzel dafür, +die Größe und die Filter des vorherigen Blocks zu verwenden. +.IP "" +Falls die Eingabedatei größer ist als die Summe der \fIBlöcke\fP, dann wird der +letzte in \fIVBlöcke\fP angegebene Wert bis zum Ende der Datei wiederholt. Mit +dem speziellen Wert \fB0\fP können Sie angeben, dass der Rest der Datei als +einzelner Block kodiert werden soll. +.IP "" +Eine alternative Filterkette für jeden Block kann in Kombination mit den +Optionen \fB\-\-filters1=\fP\fIFilter\fP \&…\& \fB\-\-filters9=\fP\fIFilter\fP angegeben +werden. Diese Optionen definieren Filterketten mit einem Bezeichner zwischen +1 und 9. Die Filterkette 0 bezeichnet hierbei die voreingestellte +Filterkette, was dem Nichtangeben einer Filterkette gleichkommt. Der +Filterkettenbezeichner kann vor der unkomprimierten Größe verwendet werden, +gefolgt von einem Doppelpunkt (\fB:\fP). Falls Sie beispielsweise +\fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP angeben, werden die Blöcke +folgendermaßen erstellt: +.RS +.IP \(bu 3 +Die durch \fB\-\-filters1\fP angegebene Filterkette und 2 MiB Eingabe +.IP \(bu 3 +Die durch \fB\-\-filters3\fP angegebene Filterkette und 2 MiB Eingabe +.IP \(bu 3 +Die durch \fB\-\-filters2\fP angegebene Filterkette und 4 MiB Eingabe +.IP \(bu 3 +Die durch \fB\-\-filters2\fP angegebene Filterkette und 4 MiB Eingabe +.IP \(bu 3 +Die vorgegebene Filterkette und 2 MiB Eingabe +.IP \(bu 3 +Die vorgegebene Filterkette und 4 MiB Eingabe für jeden Block bis zum Ende +der Eingabe. +.RE +.IP "" +Falls Sie eine Größe angeben, welche die Blockgröße des Encoders übersteigen +(entweder den Vorgabewert im Thread\-Modus oder den mit +\fB\-\-block\-size=\fP\fIGröße\fP angegebenen Wert), wird der Encoder zusätzliche +Blöcke erzeugen, wobei die in den \fIBlöcke\fP angegebenen Grenzen eingehalten +werden. Wenn Sie zum Beispiel \fB\-\-block\-size=10MiB\fP +\fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP angeben und die Eingabedatei 80 +MiB groß ist, erhalten Sie 11 Blöcke: 5, 10, 8, 10, 2, 10, 10, 4, 10, 10 und +1 MiB. +.IP "" +Im Multi\-Thread\-Modus werden die Blockgrößen in den Block\-Headern +gespeichert. Dies geschieht im Einzel\-Thread\-Modus nicht, daher wird die +kodierte Ausgabe zu der im Multi\-Thread\-Modus nicht identisch sein. +.TP +\fB\-\-flush\-timeout=\fP\fIZeit\fP +löscht bei der Kompression die ausstehenden Daten aus dem Encoder und macht +sie im Ausgabedatenstrom verfügbar, wenn mehr als die angegebene \fIZeit\fP in +Millisekunden (als positive Ganzzahl) seit dem vorherigen Löschen vergangen +ist und das Lesen weiterer Eingaben blockieren würde. Dies kann nützlich +sein, wenn \fBxz\fP zum Komprimieren von über das Netzwerk eingehenden Daten +verwendet wird. Kleine \fIZeit\fP\-Werte machen die Daten unmittelbar nach dem +Empfang nach einer kurzen Verzögerung verfügbar, während große \fIZeit\fP\-Werte +ein besseres Kompressionsverhältnis bewirken. +.IP "" +Dieses Funktionsmerkmal ist standardmäßig deaktiviert. Wenn diese Option +mehrfach angegeben wird, ist die zuletzt angegebene wirksam. Für die Angabe +der \fIZeit\fP kann der spezielle Wert \fB0\fP verwendet werden, um dieses +Funktionsmerkmal explizit zu deaktivieren. +.IP "" +Dieses Funktionsmerkmal ist außerhalb von POSIX\-Systemen nicht verfügbar. +.IP "" +.\" FIXME +\fBDieses Funktionsmerkmal ist noch experimentell.\fP Gegenwärtig ist \fBxz\fP +aufgrund der Art und Weise, wie \fBxz\fP puffert, für Dekompression in Echtzeit +ungeeignet. +.TP +\fB\-\-no\-sync\fP +synchronisiert die Zieldatei und deren Verzeichnis auf dem Speichergerät +nicht, bevor die Quelldatei gelöscht wird. So kann die Performance beim +Komprimieren oder Dekomprimieren vieler kleiner Dateien verbessert +werden. Jedoch wäre es möglich, falls es kurz nach dem Löschen zu einem +Systemabsturz kommt, dass die Zieldatei noch nicht auf dem Speichergerät +geschrieben, aber der Löschvorgang bereits ausgeführt wurde. In diesem Fall +gehen sowohl die Quelldatei als auch die Zieldatei verloren. +.IP "" +Diese Option ist nur wirksam, wenn \fBxz\fP die Quelldatei löscht. In anderen +Fällen wird niemals synchronisiert. +.IP "" +Die Synchronisierung und \fB\-\-no\-sync\fP wurden in Version \fBxz\fP 5.7.1alpha +hinzugefügt. +.TP +\fB\-\-memlimit\-compress=\fP\fIGrenze\fP +legt eine Grenze für die Speichernutzung bei der Kompression fest. Wenn +diese Option mehrmals angegeben wird, ist die zuletzt angegebene wirksam. +.IP "" +Falls die Kompressionseinstellungen die \fIGrenze\fP überschreiten, versucht +\fBxz\fP, die Einstellungen nach unten anzupassen, so dass die Grenze nicht +mehr überschritten wird und zeigt einen Hinweis an, dass eine automatische +Anpassung vorgenommen wurde. Die Anpassungen werden in folgender Reihenfolge +angewendet: Reduzierung der Anzahl der Threads, Wechsel in den +Einzelthread\-Modus, falls sogar ein einziger Thread im Multithread\-Modus die +\fIGrenze\fP überschreitet, und schlussendlich die Reduzierung der Größe des +LZMA2\-Wörterbuchs. +.IP "" +Beim Komprimieren mit \fB\-\-format=raw\fP oder falls \fB\-\-no\-adjust\fP angegeben +wurde, wird nur die Anzahl der Threads reduziert, da nur so die komprimierte +Ausgabe nicht beeinflusst wird. +.IP "" +Falls die \fIGrenze\fP nicht anhand der vorstehend beschriebenen Anpassungen +gesetzt werden kann, wird ein Fehler angezeigt und \fBxz\fP wird mit dem +Exit\-Status 1 beendet. +.IP "" +Die \fIGrenze\fP kann auf verschiedene Arten angegeben werden: +.RS +.IP \(bu 3 +Die \fIGrenze\fP kann ein absoluter Wert in Byte sein. Ein Suffix wie \fBMiB\fP +kann dabei hilfreich sein. Beispiel: \fB\-\-memlimit\-compress=80MiB\fP. +.IP \(bu 3 +Die \fIGrenze\fP kann als Prozentsatz des physischen Gesamtspeichers (RAM) +angegeben werden. Dies ist insbesondere nützlich, wenn in einem +Shell\-Initialisierungsskript, das mehrere unterschiedliche Rechner gemeinsam +verwenden, die Umgebungsvariable \fBXZ_DEFAULTS\fP gesetzt ist. Auf diese Weise +ist die Grenze auf Systemen mit mehr Speicher höher. Beispiel: +\fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +Mit \fB0\fP kann die \fIGrenze\fP auf den Standardwert zurückgesetzt werden. Dies +ist gegenwärtig gleichbedeutend mit dem Setzen der \fIGrenze\fP auf \fBmax\fP +(keine Speicherbegrenzung). +.RE +.IP "" +Für die 32\-Bit\-Version von \fBxz\fP gibt es einen Spezialfall: Falls die Grenze +über \fB4020\ MiB\fP liegt, wird die \fIGrenze\fP auf \fB4020\ MiB\fP gesetzt. Auf +MIPS32 wird stattdessen \fB2000\ MB\fP verwendet (die Werte \fB0\fP und \fBmax\fP +werden hiervon nicht beeinflusst; für die Dekompression gibt es keine +vergleichbare Funktion). Dies kann hilfreich sein, wenn ein +32\-Bit\-Executable auf einen 4\ GiB großen Adressraum (2 GiB auf MIPS32) +zugreifen kann, wobei wir hoffen wollen, dass es in anderen Situationen +keine negativen Effekte hat. +.IP "" +Siehe auch den Abschnitt \fBSpeicherbedarf\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIGrenze\fP +legt eine Begrenzung des Speicherverbrauchs für die Dekompression fest. Dies +beeinflusst auch den Modus \fB\-\-list\fP. Falls die Aktion nicht ausführbar ist, +ohne die \fIGrenze\fP zu überschreiten, gibt \fBxz\fP eine Fehlermeldung aus und +die Dekompression wird fehlschlagen. Siehe \fB\-\-memlimit\-compress=\fP\fIGrenze\fP +zu möglichen Wegen, die \fIGrenze\fP anzugeben. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIGrenze\fP +legt eine Begrenzung des Speicherverbrauchs für Multithread\-Dekompression +fest. Dies beeinflusst lediglich die Anzahl der Threads; \fBxz\fP wird dadurch +niemals die Dekompression einer Datei verweigern. Falls die \fIGrenze\fP für +jegliches Multithreading zu niedrig ist, wird sie ignoriert und \fBxz\fP setzt +im Einzelthread\-modus fort. Beachten Sie auch, dass bei der Verwendung von +\fB\-\-memlimit\-decompress\fP dies stets sowohl auf den Einzelthread\-als auch auf +den Multithread\-Modus angewendet wird und so die effektive \fIGrenze\fP für den +Multithread\-Modus niemals höher sein wird als die mit +\fB\-\-memlimit\-decompress\fP gesetzte Grenze. +.IP "" +Im Gegensatz zu anderen Optionen zur Begrenzung des Speicherverbrauchs hat +\fB\-\-memlimit\-mt\-decompress=\fP\fIGrenze\fP eine systemspezifisch vorgegebene +\fIGrenze\fP. Mit \fBxz \-\-info\-memory\fP können Sie deren aktuellen Wert anzeigen +lassen. +.IP "" +Diese Option und ihr Standardwert existieren, weil die unbegrenzte +threadbezogene Dekompression bei einigen Eingabedateien zu unglaublich +großem Speicherverbrauch führen würde. Falls die vorgegebene \fIGrenze\fP auf +Ihrem System zu niedrig ist, können Sie die \fIGrenze\fP durchaus erhöhen, aber +setzen Sie sie niemals auf einen Wert größer als die Menge des nutzbaren +Speichers, da \fBxz\fP bei entsprechenden Eingabedateien versuchen wird, diese +Menge an Speicher auch bei einer geringen Anzahl von Threads zu +verwnden. Speichermangel oder Auslagerung verbessern die +Dekomprimierungsleistung nicht. +.IP "" +Siehe \fB\-\-memlimit\-compress=\fP\fIGrenze\fP für mögliche Wege zur Angabe der +\fIGrenze\fP. Sezen der \fIGrenze\fP auf \fB0\fP setzt die \fIGrenze\fP auf den +vorgegebenen systemspezifischen Wert zurück. +.TP +\fB\-M\fP \fIGrenze\fP, \fB\-\-memlimit=\fP\fIGrenze\fP, \fB\-\-memory=\fP\fIGrenze\fP +Dies ist gleichbedeutend mit \fB\-\-memlimit\-compress=\fP\fIGrenze\fP +\fB\-\-memlimit\-decompress=\fP\fIGrenze\fP \fB\-\-memlimit\-mt\-decompress=\fP\fIGrenze\fP. +.TP +\fB\-\-no\-adjust\fP +zeigt einen Fehler an und beendet, falls die Grenze der Speichernutzung +nicht ohne Änderung der Einstellungen, welche die komprimierte Ausgabe +beeinflussen, berücksichtigt werden kann. Das bedeutet, dass \fBxz\fP daran +gehindert wird, den Encoder vom Multithread\-Modus in den Einzelthread\-Modus +zu versetzen und die Größe des LZMA2\-Wörterbuchs zu reduzieren. Allerdings +kann bei Verwendung dieser Option dennoch die Anzahl der Threads reduziert +werden, um die Grenze der Speichernutzung zu halten, sofern dies die +komprimierte Ausgabe nicht beeinflusst. +.IP "" +Die automatische Anpassung ist beim Erzeugen von Rohdatenströmen +(\fB\-\-format=raw\fP) immer deaktiviert. +.TP +\fB\-T\fP \fIThreads\fP, \fB\-\-threads=\fP\fIThreads\fP +gibt die Anzahl der zu verwendenden Arbeits\-Threads an. Wenn Sie \fIThreads\fP +auf einen speziellen Wert \fB0\fP setzen, verwendet \fBxz\fP maximal so viele +Threads, wie der/die Prozessor(en) im System untestützen. Die tatsächliche +Anzahl kann geringer sein als die angegebenen \fIThreads\fP, wenn die +Eingabedatei nicht groß genug für Threading mit den gegebenen Einstellungen +ist oder wenn mehr Threads die Speicherbegrenzung übersteigen würden. +.IP "" +Die Multithread\- bzw. Einzelthread\-Kompressoren erzeugen unterschiedliche +Ausgaben. Der Einzelthread\-Kompressor erzeugt die geringste Dateigröße, aber +nur die Ausgabe des Multithread\-Kompressors kann mit mehreren Threads wieder +dekomprimiert werden. Das Setzen der Anzahl der \fIThreads\fP auf \fB1\fP wird den +Einzelthread\-Modus verwenden. Das Setzen der Anzahl der \fIThreads\fP auf +einen anderen Wert einschließlich \fB0\fP verwendet den Multithread\-Kompressor, +und zwar sogar dann, wenn das System nur einen einzigen Hardware\-Thread +unterstützt (\fBxz\fP 5.2.x verwendete in diesem Fall noch den +Einzelthread\-Modus). +.IP "" +Um den Multithread\-Modus mit nur einem einzigen Thread zu verwenden, setzen +Sie die Anzahl der \fIThreads\fP auf \fB+1\fP. Das Präfix \fB+\fP hat mit Werten +verschieden von \fB1\fP keinen Effekt. Eine Begrenzung des Speicherverbrauchs +kann \fBxz\fP dennoch veranlassen, den Einzelthread\-Modus zu verwenden, außer +wenn \fB\-\-no\-adjust\fP verwendet wird. Die Unterstützung für das Präfix \fB+\fP +wurde in \fBxz\fP 5.4.0 hinzugefügt. +.IP "" +Falls das automatische Setzen der Anzahl der Threads angefordert und keine +Speicherbegrenzung angegeben wurde, dann wird eine systemspezifisch +vorgegebene weiche Grenze verwendet, um eventuell die Anzahl der Threads zu +begrenzen. Es ist eine weiche Grenze im Sinne davon, dass sie ignoriert +wird, falls die Anzahl der Threads 1 ist; daher wird eine weiche Grenze +\fBxz\fP niemals an der Kompression oder Dekompression hindern. Diese +vorgegebene weiche Grenze veranlasst \fBxz\fP nicht, vom Multithread\-Modus in +den Einzelthread\-Modus zu wechseln. Die aktiven Grenzen können Sie mit dem +Befehl \fBxz \-\-info\-memory\fP anzeigen lassen. +.IP "" +Die gegenwärtig einzige Threading\-Methode teilt die Eingabe in Blöcke und +komprimiert diese unabhängig voneinander. Die vorgegebene Blockgröße ist von +der Kompressionsstufe abhängig und kann mit der Option +\fB\-\-block\-size=\fP\fIGröße\fP außer Kraft gesetzt werden. +.IP "" +Eine thread\-basierte Dekompression wird nur bei Dateien funktionieren, die +mehrere Blöcke mit Größeninformationen in deren Headern enthalten. Alle im +Multi\-Thread\-Modus komprimierten Dateien, die groß genug sind, erfüllen +diese Bedingung, im Einzel\-Thread\-Modus komprimierte Dateien dagegen nicht, +selbst wenn \fB\-\-block\-size=\fP\fIGröße\fP verwendet wurde. +.IP "" +Der Vorgabewert für \fIThreads\fP is \fB0\fP. In \fBxz\fP 5.4.x und älteren Versionen +ist der Vorgabewert \fB1\fP. +. +.SS "Benutzerdefinierte Filterketten für die Kompression" +Eine benutzerdefinierte Filterkette ermöglicht die Angabe detaillierter +Kompressionseinstellungen, anstatt von den Voreinstellungen auszugehen. Wenn +eine benutzerdefinierte Filterkette angegeben wird, werden die vorher in der +Befehlszeile angegebenen Voreinstellungsoptionen (\fB\-0\fP … \fB\-9\fP und +\fB\-\-extreme\fP) außer Kraft gesetzt. Wenn eine Voreinstellungsoption nach +einer oder mehreren benutzerdefinierten Filterkettenoptionen angegeben wird, +dann wird die neue Voreinstellung wirksam und die zuvor angegebenen +Filterkettenoptionen werden außer Kraft gesetzt. +.PP +Eine Filterkette ist mit dem Piping (der Weiterleitung) in der Befehlszeile +vergleichbar. Bei der Kompression gelangt die unkomprimierte Eingabe in den +ersten Filter, dessen Ausgabe wiederum in den zweiten Filter geleitet wird +(sofern ein solcher vorhanden ist). Die Ausgabe des letzten Filters wird in +die komprimierte Datei geschrieben. In einer Filterkette sind maximal vier +Filter zulässig, aber typischerweise besteht eine Filterkette nur aus einem +oder zwei Filtern. +.PP +Bei vielen Filtern ist die Positionierung in der Filterkette eingeschränkt: +Einige Filter sind nur als letzte in der Kette verwendbar, einige können +nicht als letzte Filter gesetzt werden, und andere funktionieren an +beliebiger Stelle. Abhängig von dem Filter ist diese Beschränkung entweder +auf das Design des Filters selbst zurückzuführen oder ist aus +Sicherheitsgründen vorhanden. +.PP +Eine benutzerdefinierte Filterkette kann auf zwei verschiedene Arten +angegeben werden. Die Optionen \fB\-\-filters=\fP\fIFilter\fP und +\fB\-\-filters1=\fP\fIFilter\fP \&…\& \fB\-\-filters9=\fP\fIFilter\fP ermöglichen die Angabe +einer ganzen Filterkette in einer einzelnen Option gemäß der +Liblzma\-Filterzeichenkettensyntax. Alternativ können Sie eine Filterkette +mit einer oder mehreren individuellen Filteroptionen in der Reihenfolge +angeben, in der sie in der Filterkette verwendet werden sollen. Daher ist +die Reihenfolge der individuellen Filteroptionen wichtig! Beim Dekodieren +von Rohdatenströmen (\fB\-\-format=raw\fP) muss die Filterkette in der gleichen +Reihenfolge wie bei der Komprimierung angegeben werden. Alle individuellen +Filter\- oder Voreinstellungsoptionen, die \fIvor\fP der vollen +Filterkettenoption (\fB\-\-filters=\fP\fIFilter\fP) angegeben werden, werden +verworfen. Individuelle Filter, die \fInach\fP der vollen Filterkettenoption +angegeben werden, setzen die Filterkette zurück +.PP +Sowohl vollständige als auch individuelle Filteroptionen akzeptieren +filterspezifische \fIOptionen\fP in einer durch Kommata getrennten +Liste. Zusätzliche Kommata in den \fIOptionen\fP werden ignoriert. Jede Option +hat einen Standardwert, daher brauchen Sie nur jene anzugeben, die Sie +ändern wollen. +.PP +Um die gesamte Filterkette und die \fIOptionen\fP anzuzeigen, rufen Sie \fBxz \-vv\fP auf (was gleichbedeutend mit der zweimaligen Angabe von \fB\-\-verbose\fP +ist). Dies funktioniert auch zum Betrachten der von den Voreinstellungen +verwendeten Filterkettenoptionen. +.TP +\fB\-\-filters=\fP\fIFilter\fP +gibt die vollständige Filterkette oder eine Voreinstellung in einer +einzelnen Option an. Mehrere Filter können durch Leerzeichen oder zwei +Minuszeichen (\fB\-\-\fP) voneinander getrennt werden. Es kann notwendig sein, +die \fIFilter\fP in der Shell\-Befehlszeile zu maskieren, so dass diese als +einzelne Option ausgewertet werden. Um Optionen Werte zuzuordnen, verwenden +Sie \fB:\fP oder \fB=\fP. Einer Voreinstellung kann ein \fB\-\fP vorangestellt werden, +dem keiner oder mehrere Schalter folgen. Der einzige unterstützte Schalter +ist \fBe\fP zum Anwenden der gleichen Optionen wie \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIFilter\fP … \fB\-\-filters9\fP=\fIFilter\fP +gibt bis zu neun optionale Filterketten an, die mit \fB\-\-block\-list\fP +verwendet werden können. +.IP "" +Wenn Sie beispielsweise ein Archiv mit ausführbaren Dateien gefolgt von +Textdateien komprimieren, könnte der Teil mit den ausführbaren Dateien eine +Filterkette mit einem BCJ\-Filter und der Textdateiteil lediglich den +LZMA2\-Filter verwenden. +.TP +\fB\-\-filters\-help\fP +zeigt eine Hilfemeldung an, welche beschreibt, wie Voreinstellungen und +benutzerdefinierte Filterketten in den Optionen \fB\-\-filters\fP und +\fB\-\-filters1=\fP\fIFilter\fP \&… \& \fB\-\-filters9=\fP\fIFilter\fP angegeben werden und +beendet das Programm. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIOptionen\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIOptionen\fP] +.PD +fügt LZMA1\- oder LZMA2\-Filter zur Filterkette hinzu. Diese Filter können nur +als letzte Filter in der Kette verwendet werden. +.IP "" +LZMA1 ist ein veralteter Filter, welcher nur wegen des veralteten +\&\fB.lzma\fP\-Dateiformats unterstützt wird, welches nur LZMA1 unterstützt. LZMA2 +ist eine aktualisierte Version von LZMA1, welche einige praktische Probleme +von LZMA1 behebt. Das \fB.xz\fP\-Format verwendet LZMA2 und unterstützt LZMA1 +gar nicht. Kompressionsgeschwindigkeit und \-verhältnis sind bei LZMA1 und +LZMA2 praktisch gleich. +.IP "" +LZMA1 und LZMA2 haben die gleichen \fIOptionen\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIVoreinstellung\fP +setzt alle LZMA1\- oder LZMA2\-\fIOptionen\fP auf die \fIVoreinstellung\fP +zurück. Diese \fIVoreinstellung\fP wird in Form einer Ganzzahl angegeben, der +ein aus einem einzelnen Buchstaben bestehender Voreinstellungsmodifikator +folgen kann. Die Ganzzahl kann \fB0\fP bis \fB9\fP sein, entsprechend den +Befehlszeilenoptionen \fB\-0\fP … \fB\-9\fP. Gegenwärtig ist \fBe\fP der einzige +unterstützte Modifikator, was \fB\-\-extreme\fP entspricht. Wenn keine +\fBVoreinstellung\fP angegeben ist, werden die Standardwerte der LZMA1\- oder +LZMA2\-\fIOptionen\fP der Voreinstellung \fB6\fP entnommen. +.TP +\fBdict=\fP\fIGröße\fP +Die \fIGröße\fP des Wörterbuchs (Chronikpuffers) gibt an, wie viel Byte der +kürzlich verarbeiteten unkomprimierten Daten im Speicher behalten werden +sollen. Der Algorithmus versucht, sich wiederholende Byte\-Abfolgen +(Übereinstimmungen) in den unkomprimierten Daten zu finden und diese durch +Referenzen zu den Daten zu ersetzen, die sich gegenwärtig im Wörterbuch +befinden. Je größer das Wörterbuch, umso größer ist die Chance, eine +Übereinstimmung zu finden. Daher bewirkt eine Erhöhung der \fIGröße\fP des +Wörterbuchs üblicherweise ein besseres Kompressionsverhältnis, aber ein +Wörterbuch, das größer ist als die unkomprimierte Datei, wäre +Speicherverschwendung. +.IP "" +Typische Wörterbuch\-\fIGrößen\fP liegen im Bereich von 64\ KiB bis 64\ MiB. Das +Minimum ist 4\ KiB. Das Maximum für die Kompression ist gegenwärtig 1.5\ GiB +(1536\ MiB). Bei der Dekompression wird bereits eine Wörterbuchgröße bis zu +4\ GiB minus 1 Byte unterstützt, welche das Maximum für die LZMA1\- und +LZMA2\-Datenstromformate ist. +.IP "" +Die \fIGröße\fP des Wörterbuchs und der Übereinstimmungsfinder (\fIÜf\fP) +bestimmen zusammen den Speicherverbrauch des LZMA1\- oder +LZMA2\-Kodierers. Bei der Dekompression ist ein Wörterbuch der gleichen +\fIGröße\fP (oder ein noch größeres) wie bei der Kompression erforderlich, +daher wird der Speicherverbrauch des Dekoders durch die Größe des bei der +Kompression verwendeten Wörterbuchs bestimmt. Die \fB.xz\fP\-Header speichern +die \fIGröße\fP des Wörterbuchs entweder als 2^\fIn\fP oder 2^\fIn\fP + 2^(\fIn\fP\-1), +so dass diese \fIGrößen\fP für die Kompression etwas bevorzugt werden. Andere +\fIGrößen\fP werden beim Speichern in den \fB.xz\fP\-Headern aufgerundet. +.TP +\fBlc=\fP\fIlc\fP +gibt die Anzahl der literalen Kontextbits an. Das Minimum ist 0 und das +Maximum 4; der Standardwert ist 3. Außerdem darf die Summe von \fIlc\fP und +\fIlp\fP nicht größer als 4 sein. +.IP "" +Alle Bytes, die nicht als Übereinstimmungen kodiert werden können, werden +als Literale kodiert. Solche Literale sind einfache 8\-bit\-Bytes, die jeweils +für sich kodiert werden. +.IP "" +Bei der Literalkodierung wird angenommen, dass die höchsten \fIlc\fP\-Bits des +zuvor unkomprimierten Bytes mit dem nächsten Byte in Beziehung stehen. Zum +Beispiel folgt in typischen englischsprachigen Texten auf einen +Großbuchstaben ein Kleinbuchstabe und auf einen Kleinbuchstaben +üblicherweise wieder ein Kleinbuchstabe. Im US\-ASCII\-Zeichensatz sind die +höchsten drei Bits 010 für Großbuchstaben und 011 für Kleinbuchstaben. Wenn +\fIlc\fP mindestens 3 ist, kann die literale Kodierung diese Eigenschaft der +unkomprimierten Daten ausnutzen. +.IP "" +Der Vorgabewert (3) ist üblicherweise gut. Wenn Sie die maximale Kompression +erreichen wollen, versuchen Sie \fBlc=4\fP. Manchmal hilft es ein wenig, doch +manchmal verschlechtert es die Kompression. Im letzteren Fall versuchen Sie +zum Beispiel auch\& \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +gibt die Anzahl der literalen Positionsbits an. Das Minimum ist 0 und das +Maximum 4; die Vorgabe ist 0. +.IP "" +\fILp\fP beeinflusst, welche Art der Ausrichtung der unkomprimierten Daten beim +Kodieren von Literalen angenommen wird. Siehe \fIpb\fP weiter unten für weitere +Informationen zur Ausrichtung. +.TP +\fBpb=\fP\fIAnzahl\fP +legt die Anzahl der Positions\-Bits fest. Das Minimum ist 0 und das Maximum +4; Standard ist 2. +.IP "" +\fIPb\fP beeinflusst, welche Art der Ausrichtung der unkomprimierten Daten +generell angenommen wird. Standardmäßig wird eine Vier\-Byte\-Ausrichtung +angenommen (2^\fIpb\fP=2^2=4), was oft eine gute Wahl ist, wenn es keine +bessere Schätzung gibt. +.IP "" +Wenn die Ausrichtung bekannt ist, kann das entsprechende Setzen von \fIpb\fP +die Dateigröße ein wenig verringern. Wenn Textdateien zum Beispiel eine +Ein\-Byte\-Ausrichtung haben (US\-ASCII, ISO\-8859\-*, UTF\-8), kann das Setzen +von \fBpb=0\fP die Kompression etwas verbessern. Für UTF\-16\-Text ist \fBpb=1\fP +eine gute Wahl. Wenn die Ausrichtung eine ungerade Zahl wie beispielsweise 3 +Byte ist, könnte \fBpb=0\fP die beste Wahl sein. +.IP "" +Obwohl die angenommene Ausrichtung mit \fIpb\fP und \fIlp\fP angepasst werden +kann, bevorzugen LZMA1 und LZMA2 noch etwas die 16\-Byte\-Ausrichtung. Das +sollten Sie vielleicht beim Design von Dateiformaten berücksichtigen, die +wahrscheinlich oft mit LZMA1 oder LZMA2 komprimiert werden. +.TP +\fBmf=\fP\fIÜf\fP +Der Übereinstimmungsfinder hat einen großen Einfluss auf die Geschwindigkeit +des Kodierers, den Speicherbedarf und das +Kompressionsverhältnis. Üblicherweise sind auf Hash\-Ketten basierende +Übereinstimmungsfinder schneller als jene, die mit Binärbäumen arbeiten. Die +Vorgabe hängt von der \fIVoreinstellungsstufe\fP ab: 0 verwendet \fBhc3\fP, 1\-3 +verwenden \fBhc4\fP und der Rest verwendet \fBbt4\fP. +.IP "" +Die folgenden Übereinstimmungsfinder werden unterstützt. Die Formeln zur +Ermittlung des Speicherverbrauchs sind grobe Schätzungen, die der Realität +am nächsten kommen, wenn \fIWörterbuch\fP eine Zweierpotenz ist. +.RS +.TP +\fBhc3\fP +Hash\-Kette mit 2\- und 3\-Byte\-Hashing +.br +Minimalwert für \fInice\fP: 3 +.br +Speicherbedarf: +.br +\fIdict\fP * 7,5 (falls \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 5,5 + 64 MiB (falls \fIdict\fP > 16 MiB) +.TP +\fBhc4\fP +Hash\-Kette mit 2\-, 3\- und 4\-Byte\-Hashing +.br +Minimaler Wert für \fInice\fP: 4 +.br +Speicherbedarf: +.br +\fIdict\fP * 7,5 (falls \fIdict\fP <= 32 MiB ist); +.br +\fIdict\fP * 6,5 (falls \fIdict\fP > 32 MiB ist) +.TP +\fBbt2\fP +Binärbaum mit 2\-Byte\-Hashing +.br +Minimaler Wert für \fInice\fP: 2 +.br +Speicherverbrauch: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Binärbaum mit 2\- und 3\-Byte\-Hashing +.br +Minimalwert für \fInice\fP: 3 +.br +Speicherbedarf: +.br +\fIdict\fP * 11,5 (falls \fIdict\fP <= 16 MiB ist); +.br +\fIdict\fP * 9,5 + 64 MiB (falls \fIdict\fP > 16 MiB ist) +.TP +\fBbt4\fP +Binärbaum mit 2\-, 3\- und 4\-Byte\-Hashing +.br +Minimaler Wert für \fInice\fP: 4 +.br +Speicherbedarf: +.br +\fIdict\fP * 11,5 (falls \fIdict\fP <= 32 MiB ist); +.br +\fIdict\fP * 10,5 (falls \fIdict\fP > 32 MiB ist) +.RE +.TP +\fBmode=\fP\fIModus\fP +gibt die Methode zum Analysieren der vom Übereinstimmungsfinder gelieferten +Daten an. Als \fIModi\fP werden \fBfast\fP und \fBnormal\fP unterstützt. Die Vorgabe +ist \fBfast\fP für die \fIVoreinstellungsstufen\fP 0\-3 und \fBnormal\fP für die +\fIVoreinstellungsstufen\fP 4\-9. +.IP "" +Üblicherweise wird \fBfast\fP mit Hashketten\-basierten Übereinstimmungsfindern +und \fBnormal\fP mit Binärbaum\-basierten Übereinstimmungsfindern verwendet. So +machen es auch die \fIVoreinstellungsstufen\fP. +.TP +\fBnice=\fP\fInice\fP +gibt an, was als annehmbarer Wert für eine Übereinstimmung angesehen werden +kann. Wenn eine Übereinstimmung gefunden wird, die mindestens diesen +\fInice\fP\-Wert hat, sucht der Algorithmus nicht weiter nach besseren +Übereinstimmungen. +.IP "" +Der \fInice\fP\-Wert kann 2\-273 Byte sein. Höhere Werte tendieren zu einem +besseren Kompressionsverhältnis, aber auf Kosten der Geschwindigkeit. Die +Vorgabe hängt von der \fIVoreinstellungsstufe\fP ab. +.TP +\fBdepth=\fP\fITiefe\fP +legt die maximale Suchtiefe im Übereinstimmungsfinder fest. Vorgegeben ist +der spezielle Wert 0, der den Kompressor veranlasst, einen annehmbaren Wert +für \fITiefe\fP aus \fIÜf\fP und \fInice\fP\-Wert zu bestimmen. +.IP "" +Die angemessene \fITiefe\fP für Hash\-Ketten ist 4\-100 und 16\-1000 für +Binärbäume. Hohe Werte für die \fITiefe\fP können den Kodierer bei einigen +Dateien extrem verlangsamen. Vermeiden Sie es, die \fITiefe\fP über einen Wert +von 100 zu setzen, oder stellen Sie sich darauf ein, die Kompression +abzubrechen, wenn sie zu lange dauert. +.RE +.IP "" +Beim Dekodieren von Rohdatenströmen (\fB\-\-format=raw\fP) benötigt LZMA2 nur die +Wörterbuch\-\fIGröße\fP. LZMA1 benötigt außerdem \fIlc\fP, \fIlp\fP und \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIOptionen\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIOptionen\fP] +.PD +fügt ein »Branch/Call/Jump«\-(BCJ\-)Filter zur Filterkette hinzu. Diese Filter +können nicht als letzter Filter in der Filterkette verwendet werden. +.IP "" +Ein BCJ\-Filter wandelt relative Adressen im Maschinencode in deren absolute +Gegenstücke um. Die Datengröße wird dadurch nicht geändert, aber die +Redundanz erhöht, was LZMA2 dabei helfen kann, eine um 10 bis 15% kleinere +\&\fB.xz\fP\-Datei zu erstellen. Die BCJ\-Filter sind immer reversibel, daher +verursacht die Anwendung eines BCJ\-Filters auf den falschen Datentyp keinen +Datenverlust, wobei aber das Kompressionsverhältnis etwas schlechter werden +könnte. Die BCJ\-Filter sind sehr schnell und verbrauchen nur wenig mehr +Speicher. +.IP "" +Diese BCJ\-Filter haben bekannte Probleme mit dem Kompressionsverhältnis: +.RS +.IP \(bu 3 +In einigen Dateitypen, die ausführbaren Code enthalten (zum Beispiel +Objektdateien, statische Bibliotheken und Linux\-Kernelmodule), sind die +Adressen in den Anweisungen mit Füllwerten gefüllt. Diese BCJ\-Filter führen +dennoch die Adressumwandlung aus, wodurch die Kompression bei diesen Dateien +schlechter wird. +.IP \(bu 3 +Falls ein BCJ\-Filter auf ein Archiv angewendet wird, ist es möglich, dass +das Kompressionsverhältnis schlechter als ohne Filter wird. Falls es +beispielsweise ähnliche oder sogar identische ausführbare Dateien gibt, dann +werden diese durch die Filterung wahrscheinlich »unähnlicher« und +verschlechtern dadurch das Kompressionsverhältnis. Der Inhalt +nicht\-ausführbarer Dateien im gleichen Archiv kann sich ebenfalls darauf +auswirken. In der Praxis werden Sie durch Versuche mit oder ohne BCJ\-Filter +selbst herausfinden müssen, was situationsbezogen besser ist. +.RE +.IP "" +Verschiedene Befehlssätze haben unterschiedliche Ausrichtungen: Die +ausführbare Datei muss in den Eingabedateien einem Vielfachen dieses Wertes +entsprechen, damit dieser Filter funktioniert. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filter;Ausrichtung;Hinweise +x86;1;32\-Bit oder 64\-Bit x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096\-Byte\-Ausrichtung ist optimal +PowerPC;4;Nur Big Endian +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Da die BCJ\-gefilterten Daten üblicherweise mit LZMA2 komprimiert sind, kann +das Kompressionsverhältnis dadurch etwas verbessert werden, dass die +LZMA2\-Optionen so gesetzt werden, dass sie der Ausrichtung des gewählten +BCJ\-Filters entsprechen. Beispiele: +.RS +.IP \(bu 3 +Der IA\-64\-Filter hat eine 16\-Byte\-Ausrichtung, daher ist \fBpb=4,lp=4,lc=0\fP +für LZMA2 passend (2^4=16). +.IP \(bu 3 +RISC\-V\-Code hat eine 2\-Byte\- oder 4\-Byte\-Ausrichtung, abhängig davon, ob die +Datei 16\-bit\-komprimierte Instruktionen enthält (die C\-Erweiterung). Wenn +16\-bit\-Instruktionen verwendet werden, ist \fBpb=2,lp=1,lc=3\fP oder +\fBpb=1,lp=1,lc=3\fP passend. Wenn keine 16\-bit\-Instruktionen vorhanden sind, +ist \fBpb=2,lp=2,lc=2\fP am besten. Mit \fBreadelf \-h\fP können Sie überprüfen, ob +»RVC« in der »Flags«\-Zeile auftritt. +.IP \(bu 3 +ARM64 hat stets eine 4\-Byte\-Ausrichtung, daher ist \fBpb=2,lp=2,lc=2\fP am +besten. +.IP \(bu 3 +Der x86\-Filter stellt eine Ausnahme dar. Es ist üblicherweise eine gute +Wahl, bei den Voreinstellungen von LZMA2 (\fBpb=2,lp=0,lc=3\fP) zu bleiben, +wenn Sie ausführbare x86\-Dateien komprimieren +.RE +.IP "" +Alle BCJ\-Filter unterstützen die gleichen \fIOptionen\fP: +.RS +.TP +\fBstart=\fP\fIVersatz\fP +gibt den Start\-\fIVersatz\fP an, der bei der Umwandlung zwischen relativen und +absoluten Adressen verwendet wird. Der \fIVersatz\fP muss ein Vielfaches der +Filterausrichtung sein (siehe die Tabelle oben). Der Standardwert ist 0. In +der Praxis ist dieser Standardwert gut; die Angabe eines benutzerdefinierten +\fIVersatzes\fP ist fast immer unnütz. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIOptionen\fP] +fügt den Delta\-Filter zur Filterkette hinzu. Der Delta\-Filter kann nicht als +letzter Filter in der Filterkette verwendet werden. +.IP "" +Gegenwärtig wird nur eine einfache, Byte\-bezogene Delta\-Berechnung +unterstützt. Beim Komprimieren von zum Beispiel unkomprimierten +Bitmap\-Bildern oder unkomprimierten PCM\-Audiodaten kann es jedoch sinnvoll +sein. Dennoch können für spezielle Zwecke entworfene Algorithmen deutlich +bessere Ergebnisse als Delta und LZMA2 liefern. Dies trifft insbesondere auf +Audiodaten zu, die sich zum Beispiel mit \fBflac\fP(1) schneller und besser +komprimieren lassen. +.IP "" +Unterstützte \fIOptionen\fP: +.RS +.TP +\fBdist=\fP\fIAbstand\fP +gibt den \fIAbstand\fP der Delta\-Berechnung in Byte an. Zulässige Werte für den +\fIAbstand\fP sind 1 bis 256. Der Vorgabewert ist 1. +.IP "" +Zum Beispiel wird mit \fBdist=2\fP und der 8\-Byte\-Eingabe A1 B1 A2 B3 A3 B5 A4 +B7 die Ausgabe A1 B1 01 02 01 02 01 02 sein. +.RE +. +.SS "Andere Optionen" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +unterdrückt Warnungen und Hinweise. Geben Sie dies zweimal an, um auch +Fehlermeldungen zu unterdrücken. Diese Option wirkt sich nicht auf den +Exit\-Status aus. Das bedeutet, das selbst bei einer unterdrückten Warnung +der Exit\-Status zur Anzeige einer Warnung dennoch verwendet wird. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +bewirkt ausführliche Ausgaben. Wenn die Standardfehlerausgabe mit einem +Terminal verbunden ist, zeigt \fBxz\fP den Fortschritt an. Durch zweimalige +Angabe von \fB\-\-verbose\fP wird die Ausgabe noch ausführlicher. +.IP "" +Der Fortschrittsanzeiger stellt die folgenden Informationen dar: +.RS +.IP \(bu 3 +Der Prozentsatz des Fortschritts wird angezeigt, wenn die Größe der +Eingabedatei bekannt ist. Das bedeutet, dass der Prozentsatz in +Weiterleitungen (Pipes) nicht angezeigt werden kann. +.IP \(bu 3 +Menge der erzeugten komprimierten Daten (bei der Kompression) oder der +verarbeiteten Daten (bei der Dekompression). +.IP \(bu 3 +Menge der verarbeiteten unkomprimierten Daten (bei der Kompression) oder der +erzeugten Daten (bei der Dekompression). +.IP \(bu 3 +Kompressionsverhältnis, das mittels Dividieren der Menge der bisher +komprimierten Daten durch die Menge der bisher verarbeiteten unkomprimierten +Daten ermittelt wird. +.IP \(bu 3 +Kompressions\- oder Dekompressionsgeschwindigkeit. Diese wird anhand der +Menge der unkomprimierten verarbeiteten Daten (bei der Kompression) oder der +Menge der erzeugten Daten (bei der Dekompression) pro Sekunde gemessen. Die +Anzeige startet einige Sekunden nachdem \fBxz\fP mit der Verarbeitung der Datei +begonnen hat. +.IP \(bu 3 +Die vergangene Zeit im Format M:SS oder H:MM:SS. +.IP \(bu 3 +Die geschätzte verbleibende Zeit wird nur angezeigt, wenn die Größe der +Eingabedatei bekannt ist und bereits einige Sekunden vergangen sind, nachdem +\fBxz\fP mit der Verarbeitung der Datei begonnen hat. Die Zeit wird in einem +weniger präzisen Format ohne Doppelpunkte angezeigt, zum Beispiel 2 min 30 +s. +.RE +.IP "" +Wenn die Standardfehlerausgabe kein Terminal ist, schreibt \fBxz\fP mit +\fB\-\-verbose\fP nach dem Komprimieren oder Dekomprimieren der Datei in einer +einzelnen Zeile den Dateinamen, die komprimierte Größe, die unkomprimierte +Größe, das Kompressionsverhältnis und eventuell auch die Geschwindigkeit und +die vergangene Zeit in die Standardfehlerausgabe. Die Geschwindigkeit und +die vergangene Zeit werden nur angezeigt, wenn der Vorgang mindestens ein +paar Sekunden gedauert hat. Wurde der Vorgang nicht beendet, zum Beispiel +weil ihn der Benutzer abgebrochen hat, wird außerdem der Prozentsatz des +erreichten Verarbeitungsfortschritts aufgenommen, sofern die Größe der +Eingabedatei bekannt ist. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +setzt den Exit\-Status nicht auf 2, selbst wenn eine Bedingung erfüllt ist, +die eine Warnung gerechtfertigt hätte. Diese Option wirkt sich nicht auf die +Ausführlichkeitsstufe aus, daher müssen sowohl \fB\-\-quiet\fP als auch +\fB\-\-no\-warn\fP angegeben werden, um einerseits keine Warnungen anzuzeigen und +andererseits auch den Exit\-Status nicht zu ändern. +.TP +\fB\-\-robot\fP +gibt Meldungen in einem maschinenlesbaren Format aus. Dadurch soll das +Schreiben von Frontends erleichtert werden, die \fBxz\fP anstelle von Liblzma +verwenden wollen, was in verschiedenen Skripten der Fall sein kann. Die +Ausgabe mit dieser aktivierten Option sollte über mehrere +\fBxz\fP\-Veröffentlichungen stabil sein. Details hierzu finden Sie im Abschnitt +\fBROBOTER\-MODUS\fP. +.TP +\fB\-\-info\-memory\fP +zeigt in einem menschenlesbaren Format an, wieviel physischen Speicher (RAM) +und wie viele Prozessor\-Threads das System nach Annahme von \fBxz\fP hat, sowie +die Speicherbedarfsbegrenzung für Kompression und Dekompression, und beendet +das Programm erfolgreich. +.TP +\fB\-h\fP, \fB\-\-help\fP +zeigt eine Hilfemeldung mit den am häufigsten genutzten Optionen an und +beendet das Programm erfolgreich. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +zeigt eine Hilfemeldung an, die alle Funktionsmerkmale von \fBxz\fP beschreibt +und beendet das Programm erfolgreich. +.TP +\fB\-V\fP, \fB\-\-version\fP +zeigt die Versionsnummer von \fBxz\fP und Liblzma in einem menschenlesbaren +Format an. Um eine maschinell auswertbare Ausgabe zu erhalten, geben Sie +\fB\-\-robot\fP vor \fB\-\-version\fP an. +. +.SH ROBOTER\-MODUS +Der Roboter\-Modus wird mit der Option \fB\-\-robot\fP aktiviert. Er bewirkt, dass +die Ausgabe von \fBxz\fP leichter von anderen Programmen ausgewertet werden +kann. Gegenwärtig wird \fB\-\-robot\fP nur zusammen mit \fB\-\-list\fP, +\fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP und \fB\-\-version\fP unterstützt. In der +Zukunft wird dieser Modus auch für Kompression und Dekompression +unterstützt. +. +.SS Listenmodus +\fBxz \-\-robot \-\-list\fP verwendet eine durch Tabulatoren getrennte Ausgabe. In +der ersten Spalte jeder Zeile bezeichnet eine Zeichenkette den Typ der +Information, die in dieser Zeile enthalten ist: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Dies ist stets die erste Zeile, wenn eine Datei aufgelistet wird. Die zweite +Spalte in der Zeile enthält den Dateinamen. +.TP +\fBfile\fP +Diese Zeile enthält allgemeine Informationen zur \fB.xz\fP\-Datei. Diese Zeile +wird stets nach der \fBname\fP\-Zeile ausgegeben. +.TP +\fBstream\fP +Dieser Zeilentyp wird nur verwendet, wenn \fB\-\-verbose\fP angegeben wurde. Es +gibt genau so viele \fBstream\fP\-Zeilen, wie Datenströme in der \fB.xz\fP\-Datei +enthalten sind. +.TP +\fBblock\fP +Dieser Zeilentyp wird nur verwendet, wenn \fB\-\-verbose\fP angegeben wurde. Es +gibt so viele \fBblock\fP\-Zeilen, wie Blöcke in der \fB.xz\fP\-Datei. Die +\fBblock\fP\-Zeilen werden nach allen \fBstream\fP\-Zeilen angezeigt; verschiedene +Zeilentypen werden nicht verschachtelt. +.TP +\fBsummary\fP +Dieser Zeilentyp wird nur verwendet, wenn \fB\-\-verbose\fP zwei Mal angegeben +wurde. Diese Zeile wird nach allen \fBblock\fP\-Zeilen ausgegeben. Wie die +\fBfile\fP\-Zeile enthält die \fBsummary\fP\-Zeile allgemeine Informationen zur +\&\fB.xz\fP\-Datei. +.TP +\fBtotals\fP +Diese Zeile ist immer die letzte der Listenausgabe. Sie zeigt die +Gesamtanzahlen und \-größen an. +.PP +Die Spalten der \fBfile\fP\-Zeilen: +.PD 0 +.RS +.IP 2. 4 +Anzahl der Datenströme in der Datei +.IP 3. 4 +Gesamtanzahl der Blöcke in den Datenströmen +.IP 4. 4 +Komprimierte Größe der Datei +.IP 5. 4 +Unkomprimierte Größe der Datei +.IP 6. 4 +Das Kompressionsverhältnis, zum Beispiel \fB0.123\fP. Wenn das Verhältnis über +9.999 liegt, werden drei Minuszeichen (\fB\-\-\-\fP) anstelle des +Kompressionsverhältnisses angezeigt. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Durch Kommata getrennte Liste der Namen der Integritätsprüfungen. Für die +bekannten Überprüfungstypen werden folgende Zeichenketten verwendet: +\fBNone\fP, \fBCRC32\fP, \fBCRC64\fP und \fBSHA\-256\fP. \fBUnknown\-\fP\fIN\fP wird verwendet, +wobei \fIN\fP die Kennung der Überprüfung als Dezimalzahl angibt (ein\- oder +zweistellig). +.IP 8. 4 +Gesamtgröße der Datenstromauffüllung in der Datei +.RE +.PD +.PP +Die Spalten der \fBstream\fP\-Zeilen: +.PD 0 +.RS +.IP 2. 4 +Datenstromnummer (der erste Datenstrom ist 1) +.IP 3. 4 +Anzahl der Blöcke im Datenstrom +.IP 4. 4 +Komprimierte Startposition +.IP 5. 4 +Unkomprimierte Startposition +.IP 6. 4 +Komprimierte Größe (schließt die Datenstromauffüllung nicht mit ein) +.IP 7. 4 +Unkomprimierte Größe +.IP 8. 4 +Kompressionsverhältnis +.IP 9. 4 +Name der Integritätsprüfung +.IP 10. 4 +Größe der Datenstromauffüllung +.RE +.PD +.PP +Die Spalten der \fBblock\fP\-Zeilen: +.PD 0 +.RS +.IP 2. 4 +Anzahl der in diesem Block enthaltenen Datenströme +.IP 3. 4 +Blocknummer relativ zum Anfang des Datenstroms (der erste Block ist 1) +.IP 4. 4 +Blocknummer relativ zum Anfang der Datei +.IP 5. 4 +Komprimierter Startversatz relativ zum Beginn der Datei +.IP 6. 4 +Unkomprimierter Startversatz relativ zum Beginn der Datei +.IP 7. 4 +Komprimierte Gesamtgröße des Blocks (einschließlich Header) +.IP 8. 4 +Unkomprimierte Größe +.IP 9. 4 +Kompressionsverhältnis +.IP 10. 4 +Name der Integritätsprüfung +.RE +.PD +.PP +Wenn \fB\-\-verbose\fP zwei Mal angegeben wurde, werden zusätzliche Spalten in +die \fBblock\fP\-Zeilen eingefügt. Diese werden mit einem einfachen \fB\-\-verbose\fP +nicht angezeigt, da das Ermitteln dieser Informationen viele Suchvorgänge +erfordert und daher recht langsam sein kann: +.PD 0 +.RS +.IP 11. 4 +Wert der Integritätsprüfung in hexadezimaler Notation +.IP 12. 4 +Block\-Header\-Größe +.IP 13. 4 +Block\-Schalter: \fBc\fP gibt an, dass die komprimierte Größe verfügbar ist, und +\fBu\fP gibt an, dass die unkomprimierte Größe verfügbar ist. Falls der +Schalter nicht gesetzt ist, wird stattdessen ein Bindestrich (\fB\-\fP) +angezeigt, um die Länge der Zeichenkette beizubehalten. In Zukunft könnten +neue Schalter am Ende der Zeichenkette hinzugefügt werden. +.IP 14. 4 +Größe der tatsächlichen komprimierten Daten im Block. Ausgeschlossen sind +hierbei die Block\-Header, die Blockauffüllung und die Prüffelder. +.IP 15. 4 +Größe des Speichers (in Byte), der zum Dekomprimieren dieses Blocks mit +dieser \fBxz\fP\-Version benötigt wird. +.IP 16. 4 +Filterkette. Beachten Sie, dass die meisten der bei der Kompression +verwendeten Optionen nicht bekannt sein können, da in den \fB.xz\fP\-Headern nur +die für die Dekompression erforderlichen Optionen gespeichert sind. +.RE +.PD +.PP +Die Spalten der \fBsummary\fP\-Zeilen: +.PD 0 +.RS +.IP 2. 4 +Größe des Speichers (in Byte), der zum Dekomprimieren dieser Datei mit +dieser \fBxz\fP\-Version benötigt wird. +.IP 3. 4 +\fByes\fP oder \fBno\fP geben an, ob in allen Block\-Headern sowohl die +komprimierte als auch die unkomprimierte Größe gespeichert ist. +.PP +\fISeit\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Minimale \fBxz\fP\-Version, die zur Dekompression der Datei erforderlich ist +.RE +.PD +.PP +Die Spalten der \fBtotals\fP\-Zeile: +.PD 0 +.RS +.IP 2. 4 +Anzahl der Datenströme +.IP 3. 4 +Anzahl der Blöcke +.IP 4. 4 +Komprimierte Größe +.IP 5. 4 +Unkomprimierte Größe +.IP 6. 4 +Durchschnittliches Kompressionsverhältnis +.IP 7. 4 +Durch Kommata getrennte Liste der Namen der Integritätsprüfungen, die in den +Dateien präsent waren. +.IP 8. 4 +Größe der Datenstromauffüllung +.IP 9. 4 +Anzahl der Dateien. Dies dient dazu, die Reihenfolge der vorigen Spalten an +die in den \fBfile\fP\-Zeilen anzugleichen. +.PD +.RE +.PP +Wenn \fB\-\-verbose\fP zwei Mal angegeben wird, werden zusätzliche Spalten in die +\fBtotals\fP\-Zeile eingefügt: +.PD 0 +.RS +.IP 10. 4 +Maximale Größe des Speichers (in Byte), der zum Dekomprimieren der Dateien +mit dieser \fBxz\fP\-Version benötigt wird. +.IP 11. 4 +\fByes\fP oder \fBno\fP geben an, ob in allen Block\-Headern sowohl die +komprimierte als auch die unkomprimierte Größe gespeichert ist. +.PP +\fISeit\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Minimale \fBxz\fP\-Version, die zur Dekompression der Datei erforderlich ist +.RE +.PD +.PP +Zukünftige Versionen könnten neue Zeilentypen hinzufügen, weiterhin könnten +auch in den vorhandenen Zeilentypen weitere Spalten hinzugefügt werden, aber +die existierenden Spalten werden nicht geändert. +. +.SS Filterhilfe +\fBxz \-\-robot \-\-filters\-help\fP gibt die unterstützten Filter im folgenden +Format aus: +.PP +\fIFilter\fP\fB:\fP\fIOption\fP\fB=<\fP\fIWert\fP\fB>,\fP\fIOption\fP\fB=<\fP\fIWert\fP\fB>\fP +… +.TP +\fIFilter\fP +Name des Filters +.TP +\fIOption\fP +Name der filterspezifischen Option +.TP +\fIWert\fP +Der numerische \fIWert\fP erscheint als Bereich +\fB<\fP\fIMinimum\fP\fB\-\fP\fIMaximum\fP\fB>\fP. Die Auswahl des +Zeichenketten\-\fIWert\fPs wird in \fB< >\fP eingeschlossen und durch \fB|\fP +getrennt. +.PP +Jeder Filter wird in einer separaten Zeile ausgegeben. +. +.SS "Informationen zur Speicherbedarfsbegrenzung" +\fBxz \-\-robot \-\-info\-memory\fP gibt eine einzelne Zeile mit mehreren durch +Tabulatoren getrennten Spalten aus: +.IP 1. 4 +Gesamter physischer Speicher (RAM) in Byte. +.IP 2. 4 +Speicherbedarfsbegrenzung für die Kompression in Byte +(\fB\-\-memlimit\-compress\fP). Ein spezieller Wert von \fB0\fP bezeichnet die +Standardeinstellung, die im Einzelthread\-Modus bedeutet, dass keine +Begrenzung vorhanden ist. +.IP 3. 4 +Speicherbedarfsbegrenzung für die Dekompression in Byte +(\fB\-\-memlimit\-decompress\fP). Ein spezieller Wert von \fB0\fP bezeichnet die +Standardeinstellung, die im Einzelthread\-Modus bedeutet, dass keine +Begrenzung vorhanden ist. +.IP 4. 4 +Seit \fBxz\fP 5.3.4alpha: Die Speichernutzung für Multithread\-Dekompression in +Byte (\fB\-\-memlimit\-mt\-decompress\fP). Dies ist niemals \fB0\fP, da ein +systemspezifischer Vorgabewert (gezeigt in Spalte 5) verwendet wird, falls +keine Grenze ausdrücklich angegeben wurde. Dies ist außerdem niemals größer +als der Wert in in Spalte 3, selbst wenn mit \fB\-\-memlimit\-mt\-decompress\fP ein +größerer Wert angegeben wurde. +.IP 5. 4 +Seit \fBxz\fP 5.3.4alpha: Eine systemspezifisch vorgegebene Begrenzung des +Speicherverbrauchs, die zur Begrenzung der Anzahl der Threads beim +Komprimieren mit automatischer Anzahl der Threads (\fB\-\-threads=0\fP) und wenn +keine Speicherbedarfsbegrenzung angegeben wurde (\fB\-\-memlimit\-compress\fP) +verwendet wird. Dies wird auch als Standardwert für +\fB\-\-memlimit\-mt\-decompress\fP verwendet. +.IP 6. 4 +Seit \fBxz\fP 5.3.4alpha: Anzahl der verfügbaren Prozessorthreads. +.PP +In der Zukunft könnte die Ausgabe von \fBxz \-\-robot \-\-info\-memory\fP weitere +Spalten enthalten, aber niemals mehr als eine einzelne Zeile. +. +.SS Version +\fBxz \-\-robot \-\-version\fP gibt die Versionsnummern von \fBxz\fP und Liblzma im +folgenden Format aus: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Hauptversion. +.TP +\fIYYY\fP +Unterversion. Gerade Zahlen bezeichnen eine stabile Version. Ungerade Zahlen +bezeichnen Alpha\- oder Betaversionen. +.TP +\fIZZZ\fP +Patch\-Stufe für stabile Veröffentlichungen oder einfach nur ein Zähler für +Entwicklungsversionen. +.TP +\fIS\fP +Stabilität. 0 ist Alpha, 1 ist Beta und 2 ist stabil. \fIS\fP sollte immer 2 +sein, wenn \fIYYY\fP eine gerade Zahl ist. +.PP +\fIXYYYZZZS\fP sind in beiden Zeilen gleich, sofern \fBxz\fP und Liblzma aus der +gleichen Veröffentlichung der XZ\-Utils stammen. +.PP +Beispiele: 4.999.9beta ist \fB49990091\fP und 5.0.0 is \fB50000002\fP. +. +.SH EXIT\-STATUS +.TP +\fB0\fP +Alles ist in Ordnung. +.TP +\fB1\fP +Ein Fehler ist aufgetreten. +.TP +\fB2\fP +Es ist etwas passiert, das eine Warnung rechtfertigt, aber es sind keine +tatsächlichen Fehler aufgetreten. +.PP +In die Standardausgabe geschriebene Hinweise (keine Warnungen oder Fehler), +welche den Exit\-Status nicht beeinflussen. +. +.SH UMGEBUNGSVARIABLEN +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP wertet eine durch Leerzeichen getrennte Liste von Optionen in den +Umgebungsvariablen \fBXZ_DEFAULTS\fP und \fBXZ_OPT\fP aus (in dieser Reihenfolge), +bevor die Optionen aus der Befehlszeile ausgewertet werden. Beachten Sie, +dass beim Auswerten der Umgebungsvariablen nur Optionen berücksichtigt +werden; alle Einträge, die keine Optionen sind, werden stillschweigend +ignoriert. Die Auswertung erfolgt mit \fBgetopt_long\fP(3), welches auch für +die Befehlszeilenargumente verwendet wird. +.PP +\fBWarnung:\fP Durch Setzen dieser Umgebungsvariablen könnte man effektiv +Programme und Skripte modifizieren, die \fBxz\fP ausführen. Meist ist es +sicher, die Speichernutzungsbegrenzung und Kompressionsoptionen über die +Umgebungsvariablen zu setzen. Dennoch können einige Optionen Skripte +beeinflussen. Ein typisches Beispiel ist die Option \fB\-\-help\fP, die einen +Hilfetext anzeigt, anstatt eine Datei zu komprimieren oder zu +dekomprimieren. Weniger augenfällige Beispiele sind die Optionen \fB\-\-quiet\fP +und \fB\-\-verbose\fP. In vielen Fällen funktioniert es gut, den +Fortschrittsindikator mit \fB\-\-verbose\fP zu aktivieren, aber in einigen +Situationen können die zusätzlichen Meldungen Probleme verursachen. Die +Ausführlichkeitsstufe beeinflusst auch das Verhalten von \fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Benutzerspezifische oder systemweite Standardoptionen. Typischerweise werden +diese in einem Shell\-Initialisierungsskript gesetzt, um die +Speicherbedarfsbegrenzung von \fBxz\fP standardmäßig zu aktivieren oder die +Anzahl der Threads festzulegen. Außer bei Shell\-Initialisierungsskripten und +in ähnlichen Spezialfällen sollte die Variable \fBXZ_DEFAULTS\fP in Skripten +niemals gesetzt oder außer Kraft gesetzt werden. +.TP +\fBXZ_OPT\fP +Dies dient der Übergabe von Optionen an \fBxz\fP, wenn es nicht möglich ist, +die Optionen direkt in der Befehlszeile von \fBxz\fP zu übergeben. Dies ist der +Fall, wenn \fBxz\fP von einem Skript oder Dienstprogramm ausgeführt wird, zum +Beispiel GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Skripte können \fBXZ_OPT\fP zum Beispiel zum Setzen skriptspezifischer +Standard\-Kompressionsoptionen verwenden. Es ist weiterhin empfehlenswert, +Benutzern die Außerkraftsetzung von \fBXZ_OPT\fP zu erlauben, falls dies +angemessen ist. Zum Beispiel könnte in \fBsh\fP(1)\-Skripten Folgendes stehen: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "KOMPATIBILITÄT ZU DEN LZMA\-UTILS" +Die Befehlszeilensyntax von \fBxz\fP ist praktisch eine Obermenge der von +\fBlzma\fP, \fBunlzma\fP und \fBlzcat\fP in den LZMA\-Utils der Versionen 4.32.x. In +den meisten Fällen sollte es möglich sein, die LZMA\-Utils durch die XZ\-Utils +zu ersetzen, ohne vorhandene Skripte ändern zu müssen. Dennoch gibt es +einige Inkompatibilitäten, die manchmal Probleme verursachen können. +. +.SS "Voreinstellungsstufen zur Kompression" +Die Nummerierung der Voreinstellungsstufen der Kompression ist in \fBxz\fP und +den LZMA\-Utils unterschiedlich. Der wichtigste Unterschied ist die Zuweisung +der Wörterbuchgrößen zu den verschiedenen Voreinstellungsstufen. Die +Wörterbuchgröße ist etwa gleich dem Speicherbedarf bei der Dekompression. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Stufe;xz;LZMA\-Utils +\-0;256 KiB;nicht verfügbar +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Die Unterschiede in der Wörterbuchgröße beeinflussen auch den Speicherbedarf +bei der Kompression, aber es gibt noch einige andere Unterschiede zwischen +den LZMA\-Utils und den XZ\-Utils, die die Kluft noch vergrößern: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Stufe;xz;LZMA\-Utils 4.32.x +\-0;3 MiB;nicht verfügbar +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Die standardmäßige Voreinstellungsstufe in den LZMA\-Utils ist \fB\-7\fP, während +diese in den XZ\-Utils \fB\-6\fP ist, daher verwenden beide standardmäßig ein 8 +MiB großes Wörterbuch. +. +.SS "Vor\- und Nachteile von .lzma\-Dateien als Datenströme" +Die unkomprimierte Größe der Datei kann in den \fB.lzma\fP\-Headern gespeichert +werden. Die LZMA\-Utils tun das beim Komprimieren gewöhnlicher Dateien. Als +Alternative kann die unkomprimierte Größe als unbekannt markiert und eine +Nutzdatenende\-Markierung (end\-of\-payload) verwendet werden, um anzugeben, wo +der Dekompressor stoppen soll. Die LZMA\-Utils verwenden diese Methode, wenn +die unkomprimierte Größe unbekannt ist, was beispielsweise in Pipes +(Befehlsverkettungen) der Fall ist. +.PP +\fBxz\fP unterstützt die Dekompression von \fB.lzma\fP\-Dateien mit oder ohne +Nutzdatenende\-Markierung, aber alle von \fBxz\fP erstellten \fB.lzma\fP\-Dateien +verwenden diesen Nutzdatenende\-Markierung, wobei die unkomprimierte Größe in +den \fB.lzma\fP\-Headern als unbekannt markiert wird. Das könnte in einigen +unüblichen Situationen ein Problem sein. Zum Beispiel könnte ein +\&\fB.lzma\fP\-Dekompressor in einem Gerät mit eingebettetem System nur mit +Dateien funktionieren, deren unkomprimierte Größe bekannt ist. Falls Sie auf +dieses Problem stoßen, müssen Sie die LZMA\-Utils oder das LZMA\-SDK +verwenden, um \fB.lzma\fP\-Dateien mit bekannter unkomprimierter Größe zu +erzeugen. +. +.SS "Nicht unterstützte .lzma\-Dateien" +Das \fB.lzma\fP\-Format erlaubt \fIlc\fP\-Werte bis zu 8 und \fIlp\fP\-Werte bis zu +4. Die LZMA\-Utils können Dateien mit beliebigem \fIlc\fP und \fIlp\fP +dekomprimieren, aber erzeugen immer Dateien mit \fBlc=3\fP und \fBlp=0\fP. Das +Erzeugen von Dateien mit anderem \fIlc\fP und \fIlp\fP ist mit \fBxz\fP und mit dem +LZMA\-SDK möglich. +.PP +Die Implementation des LZMA\-Filters in liblzma setzt voraus, dass die Summe +von \fIlc\fP und \fIlp\fP nicht größer als 4 ist. Daher können \fB.lzma\fP\-Dateien, +welche diese Begrenzung überschreiten, mit \fBxz\fP nicht dekomprimiert werden. +.PP +Die LZMA\-Utils erzeugen nur \fB.lzma\fP\-Dateien mit einer Wörterbuchgröße von +2^\fIn\fP (einer Zweierpotenz), aber akzeptieren Dateien mit einer beliebigen +Wörterbuchgröße. Liblzma akzeptiert nur \fB.lzma\fP\-Dateien mit einer +Wörterbuchgröße von 2^\fIn\fP oder 2^\fIn\fP + 2^(\fIn\fP\-1). Dies dient zum +Verringern von Fehlalarmen beim Erkennen von \fB.lzma\fP\-Dateien. +.PP +Diese Einschränkungen sollten in der Praxis kein Problem sein, da praktisch +alle \fB.lzma\fP\-Dateien mit Einstellungen komprimiert wurden, die Liblzma +akzeptieren wird. +. +.SS "Angehängter Datenmüll" +Bei der Dekompression ignorieren die LZMA\-Utils stillschweigend alles nach +dem ersten \fB.lzma\fP\-Datenstrom. In den meisten Situationen ist das ein +Fehler. Das bedeutet auch, dass die LZMA\-Utils die Dekompression verketteter +\&\fB.lzma\fP\-Dateien nicht unterstützen. +.PP +Wenn nach dem ersten \fB.lzma\fP\-Datenstrom Daten verbleiben, erachtet \fBxz\fP +die Datei als beschädigt, es sei denn, die Option \fB\-\-single\-stream\fP wurde +verwendet. Dies könnte die Ausführung von Skripten beeinflussen, die davon +ausgehen, dass angehängter Datenmüll ignoriert wird. +. +.SH ANMERKUNGEN +. +.SS "Die komprimierte Ausgabe kann variieren" +Die exakte komprimierte Ausgabe, die aus der gleichen unkomprimierten +Eingabedatei erzeugt wird, kann zwischen den Versionen der XZ\-Utils +unterschiedlich sein, selbst wenn die Kompressionsoptionen identisch +sind. Das kommt daher, weil der Kodierer verbessert worden sein könnte +(hinsichtlich schnellerer oder besserer Kompression), ohne das Dateiformat +zu beeinflussen. Die Ausgabe kann sogar zwischen verschiedenen Programmen +der gleichen Version der XZ\-Utils variieren, wenn bei der Erstellung des +Binärprogramms unterschiedliche Optionen verwendet wurden. +.PP +Sobald \fB\-\-rsyncable\fP implementiert wurde, bedeutet das, dass die sich +ergebenden Dateien nicht notwendigerweise mit Rsync abgeglichen werden +können, außer wenn die alte und neue Datei mit der gleichen \fBxz\fP\-Version +erzeugt wurden. Das Problem kann beseitigt werden, wenn ein Teil der +Encoder\-Implementierung eingefroren wird, um die mit Rsync abgleichbare +Ausgabe über \fBxz\fP\-Versionsgrenzen hinweg stabil zu halten. +. +.SS "Eingebettete .xz\-Dekompressoren" +Eingebettete \fB.xz\fP\-Dekompressor\-Implementierungen wie XZ Embedded +unterstützen nicht unbedingt Dateien, die mit anderen Integritätsprüfungen +(\fIPrüfung\fP\-Typen) als \fBnone\fP und \fBcrc32\fP erzeugt wurden. Da +\fB\-\-check=crc64\fP die Voreinstellung ist, müssen Sie \fB\-\-check=none\fP oder +\fB\-\-check=crc32\fP verwenden, wenn Sie Dateien für eingebettete Systeme +erstellen. +.PP +Außerhalb eingebetteter Systeme unterstützen die Dekompressoren des +\&\fB.xz\fP\-Formats alle \fIPrüfung\fP\-Typen oder sind mindestens in der Lage, die +Datei zu dekomprimieren, ohne deren Integrität zu prüfen, wenn die bestimmte +\fIPrüfung\fP nicht verfügbar ist. +.PP +XZ Embedded unterstützt BCJ\-Filter, aber nur mit dem vorgegebenen +Startversatz. +. +.SH BEISPIELE +. +.SS Grundlagen +Komprimiert die Datei \fIfoo\fP mit der Standard\-Kompressionsstufe (\fB\-6\fP) zu +\fIfoo.xz\fP und entfernt \fIfoo\fP nach erfolgreicher Kompression: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +\fIbar.xz\fP in \fIbar\fP dekomprimieren und \fIbar.xz\fP selbst dann nicht löschen, +wenn die Dekompression erfolgreich war: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +\fIbaz.tar.xz\fP mit der Voreinstellung \fB\-4e\fP (\fB\-4 \-\-extreme\fP) erzeugen, was +langsamer ist als die Vorgabe \fB\-6\fP, aber weniger Speicher für Kompression +und Dekompression benötigt (48\ MiB beziehungsweise 5\ MiB): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Eine Mischung aus komprimierten und unkomprimierten Dateien kann mit einem +einzelnen Befehl dekomprimiert in die Standardausgabe geschrieben werden: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Parallele Kompression von vielen Dateien" +Auf GNU\- und *BSD\-Systemen können \fBfind\fP(1) und \fBxargs\fP(1) zum +Parallelisieren der Kompression vieler Dateien verwendet werden: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Die Option \fB\-P\fP von \fBxargs\fP(1) legt die Anzahl der parallelen +\fBxz\fP\-Prozesse fest. Der beste Wert für die Option \fB\-n\fP hängt davon ab, wie +viele Dateien komprimiert werden sollen. Wenn es sich nur um wenige Dateien +handelt, sollte der Wert wahrscheinlich 1 sein; bei Zehntausenden von +Dateien kann 100 oder noch mehr angemessener sein, um die Anzahl der +\fBxz\fP\-Prozesse zu beschränken, die \fBxargs\fP(1) schließlich erzeugen wird. +.PP +Die Option \fB\-T1\fP für \fBxz\fP dient dazu, den Einzelthread\-Modus zu erzwingen, +da \fBxargs\fP(1) zur Steuerung des Umfangs der Parallelisierung verwendet +wird. +. +.SS Roboter\-Modus +Berechnen, wie viel Byte nach der Kompression mehrerer Dateien insgesamt +eingespart wurden: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Ein Skript könnte abfragen wollen, ob es ein \fBxz\fP verwendet, das aktuell +genug ist. Das folgende \fBsh\fP(1)\-Skript prüft, ob die Versionsnummer des +Dienstprogramms \fBxz\fP mindestens 5.0.0 ist. Diese Methode ist zu alten +Beta\-Versionen kompatibel, welche die Option \fB\-\-robot\fP nicht unterstützen: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Ihre Version von Xz ist zu alt." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Eine Speicherbedarfsbegrenzung für die Dekompression mit \fBXZ_OPT\fP setzen, +aber eine bereits gesetzte Begrenzung nicht erhöhen: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Benutzerdefinierte Filterketten für die Kompression" +Der einfachste Anwendungsfall für benutzerdefinierte Filterketten ist die +Anpassung von LZMA2\-Voreinstellungsstufen. Das kann nützlich sein, weil die +Voreinstellungen nur einen Teil der potenziell sinnvollen Kombinationen aus +Kompressionseinstellungen abdecken. +.PP +Die KompCPU\-Spalten der Tabellen aus den Beschreibungen der Optionen \fB\-0\fP … +\fB\-9\fP und \fB\-\-extreme\fP sind beim Anpassen der LZMA2\-Voreinstellungen +nützlich. Diese sind die relevanten Teile aus diesen zwei Tabellen: +.RS +.PP +.TS +tab(;); +c c +n n. +Voreinst.;KomprCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Wenn Sie wissen, dass eine Datei für eine gute Kompression ein etwas +größeres Wörterbuch benötigt (zum Beispiel 32 MiB), aber Sie sie schneller +komprimieren wollen, als dies mit \fBxz \-8\fP geschehen würde, kann eine +Voreinstellung mit einem niedrigen KompCPU\-Wert (zum Beispiel 1) dahingehend +angepasst werden, ein größeres Wörterbuch zu verwenden: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Mit bestimmten Dateien kann der obige Befehl schneller sein als \fBxz \-6\fP, +wobei die Kompression deutlich besser wird. Dennoch muss betont werden, dass +nur wenige Dateien von einem größeren Wörterbuch profitieren, wenn der +KompCPU\-Wert niedrig bleibt. Der offensichtlichste Fall, in dem ein größeres +Wörterbuch sehr hilfreich sein kann, ist ein Archiv, das einander sehr +ähnliche Dateien enthält, die jeweils wenigstens einige Megabyte groß +sind. Das Wörterbuch muss dann deutlich größer sein als die einzelne Datei, +damit LZMA2 den größtmöglichen Vorteil aus den Ähnlichkeiten der aufeinander +folgenden Dateien zieht. +.PP +Wenn hoher Speicherbedarf für Kompression und Dekompression kein Problem ist +und die zu komprimierende Datei mindestens einige Hundert Megabyte groß ist, +kann es sinnvoll sein, ein noch größeres Wörterbuch zu verwenden, als die 64 +MiB, die mit \fBxz \-9\fP verwendet werden würden: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Die Verwendung von \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) wie im obigen Beispiel +kann nützlich sein, um den Speicherbedarf für Kompressor und Dekompressor zu +sehen. Denken Sie daran, dass ein Wörterbuch, das größer als die +unkomprimierte Datei ist, Speicherverschwendung wäre. Daher ist der obige +Befehl für kleine Dateien nicht sinnvoll. +.PP +Manchmal spielt die Kompressionszeit keine Rolle, aber der Speicherbedarf +bei der Dekompression muss gering gehalten werden, zum Beispiel um die Datei +auf eingebetteten Systemen dekomprimieren zu können. Der folgende Befehl +verwendet \fB\-6e\fP (\fB\-6 \-\-extreme\fP) als Basis und setzt die Wörterbuchgröße +auf nur 64\ KiB. Die sich ergebende Datei kann mit XZ Embedded (aus diesem +Grund ist dort \fB\-\-check=crc32\fP) mit nur etwa 100\ KiB Speicher +dekomprimiert werden. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Wenn Sie so viele Byte wie möglich herausquetschen wollen, kann die +Anpassung der Anzahl der literalen Kontextbits (\fIlc\fP) und der Anzahl der +Positionsbits (\fIpb\fP) manchmal hilfreich sein. Auch die Anpassung der Anzahl +der literalen Positionsbits (\fIlp\fP) könnte helfen, aber üblicherweise sind +\fIlc\fP und \fIpb\fP wichtiger. Wenn ein Quellcode\-Archiv zum Beispiel +hauptsächlich ASCII\-Text enthält, könnte ein Aufruf wie der folgende eine +etwas kleinere Datei (etwa 0,1\ %) ergeben als mit \fBxz \-6e\fP (versuchen Sie +es auch \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Die Verwendung eines anderen Filters mit LZMA2 kann die Kompression bei +verschiedenen Dateitypen verbessern. So könnten Sie eine gemeinsam genutzte +Bibliothek der Architekturen x86\-32 oder x86\-64 mit dem BCJ\-Filter für x86 +komprimieren: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Beachten Sie, dass die Reihenfolge der Filteroptionen von Bedeutung +ist. Falls \fB\-\-x86\fP nach \fB\-\-lzma2\fP angegeben wird, gibt \fBxz\fP einen Fehler +aus, weil nach LZMA2 kein weiterer Filter sein darf und auch weil der +BCJ\-Filter für x86 nicht als letzter Filter in der Filterkette gesetzt +werden darf. +.PP +Der Delta\-Filter zusammen mit LZMA2 kann bei Bitmap\-Bildern gute Ergebnisse +liefern. Er sollte üblicherweise besser sein als PNG, welches zwar einige +fortgeschrittene Filter als ein simples delta bietet, aber für die +eigentliche Kompression »Deflate« verwendet. +.PP +Das Bild muss in einem unkomprimierten Format gespeichert werden, zum +Beispiel als unkomprimiertes TIFF. Der Abstandsparameter des Delta\-Filters +muss so gesetzt werden, dass er der Anzahl der Bytes pro Pixel im Bild +entspricht. Zum Beispiel erfordert ein 24\-Bit\-RGB\-Bitmap \fBdist=3\fP, außerdem +ist es gut, \fBpb=0\fP an LZMA2 zu übergeben, um die 3\-Byte\-Ausrichtung zu +berücksichtigen: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Wenn sich mehrere Bilder in einem einzelnen Archiv befinden (zum Beispiel\& +\&\fB.tar\fP), funktioniert der Delta\-Filter damit auch, sofern alle Bilder im +Archiv die gleiche Anzahl Bytes pro Pixel haben. +. +.SH "SIEHE AUCH" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA\-SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xz.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xz.1 new file mode 100644 index 0000000000000000000000000000000000000000..39e92ce91c266281499195e6ac04416517932d31 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xz.1 @@ -0,0 +1,2117 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" German translation for xz-man. +.\" Mario Blättermann , 2015, 2019-2020, 2022-2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 "8. März 2025" Tukaani XZ\-Dienstprogramme +. +.SH BEZEICHNUNG +xz, unxz, xzcat, lzma, unlzma, lzcat \- .xz\- und .lzma\-Dateien komprimieren +oder dekomprimieren +. +.SH ÜBERSICHT +\fBxz\fP [\fIOption…\fP] [\fIDatei…\fP] +. +.SH BEFEHLSALIASE +\fBunxz\fP ist gleichbedeutend mit \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP ist gleichbedeutend mit \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP ist gleichbedeutend mit \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP ist gleichbedeutend mit \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP ist gleichbedeutend mit \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Wenn Sie Skripte schreiben, die Dateien dekomprimieren, sollten Sie stets +den Namen \fBxz\fP mit den entsprechenden Argumenten (\fBxz \-d\fP oder \fBxz \-dc\fP) +anstelle der Namen \fBunxz\fP und \fBxzcat\fP verwenden. +. +.SH BESCHREIBUNG +\fBxz\fP ist ein Allzweckwerkzeug zur Datenkompression, dessen +Befehlszeilensyntax denen von \fBgzip\fP(1) und \fBbzip2\fP(1) ähnelt. Das native +Dateiformat ist das \fB.xz\fP\-Format, aber das veraltete, von den +LZMA\-Dienstprogrammen verwendete Format sowie komprimierte Rohdatenströme +ohne Containerformat\-Header werden ebenfalls unterstützt. Außerdem wird die +Dekompression des von \fBlzip\fP verwendeten \fB.lz\fP\-Formats unterstützt. +.PP +\fBxz\fP komprimiert oder dekomprimiert jede \fIDatei\fP entsprechend des +gewählten Vorgangsmodus. Falls entweder \fB\-\fP oder keine Datei angegeben ist, +liest \fBxz\fP aus der Standardeingabe und leitet die verarbeiteten Dateien in +die Standardausgabe. Wenn die Standardausgabe kein Terminal ist, verweigert +\fBxz\fP das Schreiben komprimierter Daten in die Standardausgabe. Dabei wird +eine Fehlermeldung angezeigt und die \fIDatei\fP übersprungen. Ebenso +verweigert \fBxz\fP das Lesen komprimierter Daten aus der Standardeingabe, wenn +diese ein Terminal ist. +.PP +\fIDateien\fP, die nicht als \fB\-\fP angegeben sind, werden in eine neue Datei +geschrieben, deren Name aus dem Namen der Quell\-\fIDatei\fP abgeleitet wird +(außer wenn \fB\-\-stdout\fP angegeben ist): +.IP \(bu 3 +Bei der Kompression wird das Suffix des Formats der Zieldatei (\fB.xz\fP oder +\&\fB.lzma\fP) an den Namen der Quelldatei angehängt und so der Name der +Zieldatei gebildet. +.IP \(bu 3 +Bei der Dekompression wird das Suffix \fB.xz\fP, \fB.lzma\fP oder \fB.lz\fP vom +Dateinamen entfernt und so der Name der Zieldatei gebildet. Außerdem erkennt +\fBxz\fP die Suffixe \fB.txz\fP und \fB.tlz\fP und ersetzt diese durch \fB.tar\fP. +.PP +Wenn die Zieldatei bereits existiert, wird eine Fehlermeldung angezeigt und +die \fIDatei\fP übersprungen. +.PP +Außer beim Schreiben in die Standardausgabe zeigt \fBxz\fP eine Warnung an und +überspringt die \fIDatei\fP, wenn eine der folgenden Bedingungen zutreffend +ist: +.IP \(bu 3 +Die \fIDatei\fP ist keine reguläre Datei. Symbolischen Verknüpfungen wird nicht +gefolgt und diese daher nicht zu den regulären Dateien gezählt. +.IP \(bu 3 +Die \fIDatei\fP hat mehr als eine harte Verknüpfung. +.IP \(bu 3 +Für die \fIDatei\fP ist das »setuid«\-, »setgid«\- oder »sticky«\-Bit gesetzt. +.IP \(bu 3 +Der Aktionsmodus wird auf Kompression gesetzt und die \fIDatei\fP hat bereits +das Suffix des Zieldateiformats (\fB.xz\fP oder \fB.txz\fP beim Komprimieren in +das \fB.xz\fP\-Format und \fB.lzma\fP oder \fB.tlz\fP beim Komprimieren in das +\&\fB.lzma\fP\-Format). +.IP \(bu 3 +Der Aktionsmodus wird auf Dekompression gesetzt und die \fIDatei\fP hat nicht +das Suffix eines der unterstützten Zieldateiformate (\fB.xz\fP, \fB.txz\fP, +\&\fB.lzma\fP, \fB.tlz\fP oder \fB.lz\fP). +.PP +Nach erfolgreicher Kompression oder Dekompression der \fIDatei\fP kopiert \fBxz\fP +Eigentümer, Gruppe, Zugriffsrechte, Zugriffszeit und Änderungszeit aus der +Ursprungs\-\fIDatei\fP in die Zieldatei. Sollte das Kopieren der Gruppe +fehlschlagen, werden die Zugriffsrechte so angepasst, dass jenen Benutzern +der Zugriff auf die Zieldatei verwehrt bleibt, die auch keinen Zugriff auf +die Ursprungs\-\fIDatei\fP hatten. Das Kopieren anderer Metadaten wie +Zugriffssteuerlisten oder erweiterter Attribute wird von \fBxz\fP noch nicht +unterstützt. +.PP +Sobald die Zieldatei erfolgreich geschlossen wurde, wird die +Ursprungs\-\fIDatei\fP entfernt. Dies wird durch die Option \fB\-\-keep\fP +verhindert. Die Ursprungs\-\fIDatei\fP wird niemals entfernt, wenn die Ausgabe +in die Standardausgabe geschrieben wird oder falls ein Fehler auftritt. +.PP +Durch Senden der Signale \fBSIGINFO\fP oder \fBSIGUSR1\fP an den \fBxz\fP\-Prozess +werden Fortschrittsinformationen in den Fehlerkanal der Standardausgabe +geleitet. Dies ist nur eingeschränkt hilfreich, wenn die +Standardfehlerausgabe ein Terminal ist. Mittels \fB\-\-verbose\fP wird ein +automatisch aktualisierter Fortschrittsanzeiger angezeigt. +. +.SS Speicherbedarf +In Abhängigkeit von den gewählten Kompressionseinstellungen bewegt sich der +Speicherverbrauch zwischen wenigen hundert Kilobyte und mehreren +Gigabyte. Die Einstellungen bei der Kompression einer Datei bestimmen dabei +den Speicherbedarf bei der Dekompression. Die Dekompression benötigt +üblicherweise zwischen 5\ % und 20\ % des Speichers, der bei der Kompression +der Datei erforderlich war. Beispielsweise benötigt die Dekompression einer +Datei, die mit \fBxz \-9\fP komprimiert wurde, gegenwärtig etwa 65\ MiB +Speicher. Es ist jedoch auch möglich, dass \fB.xz\fP\-Dateien mehrere Gigabyte +an Speicher zur Dekompression erfordern. +.PP +Insbesondere für Benutzer älterer Systeme wird eventuell ein sehr großer +Speicherbedarf ärgerlich sein. Um unangenehme Überraschungen zu vermeiden, +verfügt \fBxz\fP über eine eingebaute Begrenzung des Speicherbedarfs, die +allerdings in der Voreinstellung deaktiviert ist. Zwar verfügen einige +Betriebssysteme über eingebaute Möglichkeiten zur prozessabhängigen +Speicherbegrenzung, doch diese sind zu unflexibel (zum Beispiel kann +\fBulimit\fP(1) beim Begrenzen des virtuellen Speichers \fBmmap\fP(2) +beeinträchtigen). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Die Begrenzung des Speicherbedarfs kann mit der Befehlszeilenoption +\fB\-\-memlimit=\fP\fIBegrenzung\fP aktiviert werden. Oft ist es jedoch bequemer, +die Begrenzung durch Setzen der Umgebungsvariable \fBXZ_DEFAULTS\fP +standardmäßig zu aktivieren, zum Beispiel +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Die Begrenzungen können getrennt für +Kompression und Dekompression mittels \fB\-\-memlimit\-compress=\fP\fIBegrenzung\fP +und \fB\-\-memlimit\-decompress=\fP\fIBegrenzung\fP festgelegt werden. Die Verwendung +einer solchen Option außerhalb der Variable \fBXZ_DEFAULTS\fP ist kaum +sinnvoll, da \fBxz\fP in einer einzelnen Aktion nicht gleichzeitig Kompression +und Dekompression ausführen kann und \fB\-\-memlimit=\fP\fIBegrenzung\fP (oder \fB\-M\fP +\fIBegrenzung\fP) lässt sich einfacher in der Befehlszeile eingeben. +.PP +Wenn die angegebene Speicherbegrenzung bei der Dekompression überschritten +wird, schlägt der Vorgang fehl und \fBxz\fP zeigt eine Fehlermeldung an. Wird +die Begrenzung bei der Kompression überschritten, dann versucht \fBxz\fP die +Einstellungen entsprechend anzupassen, außer wenn \fB\-\-format=raw\fP oder +\fB\-\-no\-adjust\fP angegeben ist. Auf diese Weise schlägt die Aktion nicht fehl, +es sei denn, die Begrenzung wurde sehr niedrig angesetzt. Die Anpassung der +Einstellungen wird schrittweise vorgenommen, allerdings entsprechen die +Schritte nicht den Voreinstellungen der Kompressionsstufen. Das bedeutet, +wenn beispielsweise die Begrenzung nur geringfügig unter den Anforderungen +für \fBxz \-9\fP liegt, werden auch die Einstellungen nur wenig angepasst und +nicht vollständig herunter zu den Werten für \fBxz \-8\fP +. +.SS "Verkettung und Auffüllung von .xz\-Dateien" +Es ist möglich, \fB.xz\fP\-Dateien direkt zu verketten. Solche Dateien werden +von \fBxz\fP genauso dekomprimiert wie eine einzelne \fB.xz\fP\-Datei. +.PP +Es ist weiterhin möglich, eine Auffüllung zwischen den verketteten Teilen +oder nach dem letzten Teil einzufügen. Die Auffüllung muss aus Null\-Bytes +bestehen und deren Größe muss ein Vielfaches von vier Byte sein. Dies kann +zum Beispiel dann vorteilhaft sein, wenn die \fB.xz\fP\-Datei auf einem +Datenträger gespeichert wird, dessen Dateisystem die Dateigrößen in +512\-Byte\-Blöcken speichert. +.PP +Verkettung und Auffüllung sind für \fB.lzma\fP\-Dateien oder Rohdatenströme +nicht erlaubt. +. +.SH OPTIONEN +. +.SS "Ganzzahlige Suffixe und spezielle Werte" +An den meisten Stellen, wo ein ganzzahliges Argument akzeptiert wird, kann +ein optionales Suffix große Ganzzahlwerte einfacher darstellen. Zwischen +Ganzzahl und dem Suffix dürfen sich keine Leerzeichen befinden. +.TP +\fBKiB\fP +multipliziert die Ganzzahl mit 1.024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP und +\fBKB\fP werden als Synonyme für \fBKiB\fP akzeptiert. +.TP +\fBMiB\fP +multipliziert die Ganzzahl mit 1.048.576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP und \fBMB\fP +werden als Synonyme für \fBMiB\fP akzeptiert. +.TP +\fBGiB\fP +multipliziert die Ganzzahl mit 1.073.741.824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP und +\fBGB\fP werden als Synonyme für \fBGiB\fP akzeptiert. +.PP +Der spezielle Wert \fBmax\fP kann dazu verwendet werden, um den von der +jeweiligen Option akzeptierten maximalen Ganzzahlwert anzugeben. +. +.SS Aktionsmodus +Falls mehrere Aktionsmodi angegeben sind, wird der zuletzt angegebene +verwendet. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Kompression. Dies ist der voreingestellte Aktionsmodus, sofern keiner +angegeben ist und auch kein bestimmter Modus aus dem Befehlsnamen abgeleitet +werden kann (der Befehl \fBunxz\fP impliziert zum Beispiel \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Nach erfolgreicher Kompression wird die Quelldatei gelöscht, außer wenn in +die Standardausgabe geschrieben wird oder \fB\-\-keep\fP angegeben wurde. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Dekomprimieren. Nach erfolgreicher Dekompression wird die Quelldatei +gelöscht, außer wenn in die Standardausgabe geschrieben wird oder \fB\-\-keep\fP +angegeben wurde. +.TP +\fB\-t\fP, \fB\-\-test\fP +prüft die Integrität der komprimierten \fIDateien\fP. Diese Option ist +gleichbedeutend mit \fB\-\-decompress \-\-stdout\fP, außer dass die dekomprimierten +Daten verworfen werden, anstatt sie in die Standardausgabe zu leiten. Es +werden keine Dateien erstellt oder entfernt. +.TP +\fB\-l\fP, \fB\-\-list\fP +gibt Informationen zu den komprimierten \fIDateien\fP aus. Es werden keine +unkomprimierten Dateien ausgegeben und keine Dateien angelegt oder +entfernt. Im Listenmodus kann das Programm keine komprimierten Daten aus der +Standardeingabe oder anderen nicht durchsuchbaren Quellen lesen. +.IP "" +Die Liste zeigt in der Standardeinstellung grundlegende Informationen zu den +\fIDateien\fP an, zeilenweise pro Datei. Detailliertere Informationen erhalten +Sie mit der Option \fB\-\-verbose\fP. Wenn Sie diese Option zweimal angeben, +werden noch ausführlichere Informationen ausgegeben. Das kann den Vorgang +allerdings deutlich verlangsamen, da die Ermittlung der zusätzlichen +Informationen zahlreiche Suchvorgänge erfordert. Die Breite der +ausführlichen Ausgabe übersteigt 80 Zeichen, daher könnte die Weiterleitung +in beispielsweise\& \fBless\ \-S\fP sinnvoll sein, falls das Terminal nicht +breit genug ist. +.IP "" +Die exakte Ausgabe kann in verschiedenen \fBxz\fP\-Versionen und +Spracheinstellungen unterschiedlich sein. Wenn eine maschinell auswertbare +Ausgabe gewünscht ist, dann sollten Sie \fB\-\-robot \-\-list\fP verwenden. +. +.SS Aktionsattribute +.TP +\fB\-k\fP, \fB\-\-keep\fP +verhindert das Löschen der Eingabedateien. +.IP "" +Seit der \fBxz\fP\-Version 5.2.6 wird die Kompression oder Dekompression auch +dann ausgeführt, wenn die Eingabe ein symbolischer Link zu einer regulären +Datei ist, mehr als einen harten Link hat oder das »setuid«\-, »setgid«\- oder +»sticky«\-Bit gesetzt ist. Die genannten Bits werden nicht in die Zieldatei +kopiert. In früheren Versionen geschah dies nur mit \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Diese Option hat verschiedene Auswirkungen: +.RS +.IP \(bu 3 +Wenn die Zieldatei bereits existiert, wird diese vor der Kompression oder +Dekompression gelöscht. +.IP \(bu 3 +Die Kompression oder Dekompression wird auch dann ausgeführt, wenn die +Eingabe ein symbolischer Link zu einer regulären Datei ist, mehr als einen +harten Link hat oder das »setuid«\-, »setgid«\- oder »sticky«\-Bit gesetzt +ist. Die genannten Bits werden nicht in die Zieldatei kopiert. +.IP \(bu 3 +Wenn es zusammen mit \fB\-\-decompress\fP und \fB\-\-stdout\fP verwendet wird und +\fBxz\fP den Typ der Quelldatei nicht ermitteln kann, wird die Quelldatei +unverändert in die Standardausgabe kopiert. Dadurch kann \fBxzcat\fP \fB\-\-force\fP +für Dateien, die nicht mit \fBxz\fP komprimiert wurden, wie \fBcat\fP(1) verwendet +werden. Zukünftig könnte \fBxz\fP neue Dateikompressionsformate unterstützen, +wodurch \fBxz\fP mehr Dateitypen dekomprimieren kann, anstatt sie unverändert +in die Standardausgabe zu kopieren. Mit der Option \fB\-\-format=\fP\fIFormat\fP +können Sie \fBxz\fP anweisen, nur ein einzelnes Dateiformat zu dekomprimieren. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +schreibt die komprimierten oder dekomprimierten Daten in die Standardausgabe +anstatt in eine Datei. Dies impliziert \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +dekomprimiert nur den ersten \fB.xz\fP\-Datenstrom und ignoriert stillschweigend +weitere Eingabedaten, die möglicherweise dem Datenstrom +folgen. Normalerweise führt solcher anhängender Datenmüll dazu, dass \fBxz\fP +eine Fehlermeldung ausgibt. +.IP "" +\fBxz\fP dekomprimiert niemals mehr als einen Datenstrom aus \fB.lzma\fP\-Dateien +oder Rohdatenströmen, aber dennoch wird durch diese Option möglicherweise +vorhandener Datenmüll nach der \fB.lzma\fP\-Datei oder dem Rohdatenstrom +ignoriert. +.IP "" +Diese Option ist wirkungslos, wenn der Aktionsmodus nicht \fB\-\-decompress\fP +oder \fB\-\-test\fP ist. +.IP "" +Seit der Programmversion \fBxz\fP 5.7.1alpha impliziert \fB\-\-single\-stream\fP +zusätzlich die Option \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +verhindert die Erzeugung von Sparse\-Dateien. In der Voreinstellung versucht +\fBxz\fP, bei der Dekompression in eine reguläre Datei eine Sparse\-Datei zu +erzeugen, wenn die dekomprimierten Daten lange Abfolgen von binären Nullen +enthalten. Dies funktioniert auch beim Schreiben in die Standardausgabe, +sofern diese in eine reguläre Datei weitergeleitet wird und bestimmte +Zusatzbedingungen erfüllt sind, die die Aktion absichern. Die Erzeugung von +Sparse\-Dateien kann Plattenplatz sparen und beschleunigt die Dekompression +durch Verringerung der Ein\-/Ausgaben der Platte. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +verwendet \fI.suf\fP bei der Dekompression anstelle von \fB.xz\fP oder \fB.lzma\fP +als Suffix für die Zieldatei. Falls nicht in die Standardausgabe geschrieben +wird und die Quelldatei bereits das Suffix \fI.suf\fP hat, wird eine Warnung +angezeigt und die Datei übersprungen. +.IP "" +berücksichtigt bei der Dekompression zusätzlich zu Dateien mit den Suffixen +\&\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP oder \fB.lz\fP auch jene mit dem Suffix +\&\fI.suf\fP. Falls die Quelldatei das Suffix \fI.suf\fP hat, wird dieses entfernt +und so der Name der Zieldatei abgeleitet. +.IP "" +Beim Komprimieren oder Dekomprimieren von Rohdatenströmen mit +\fB\-\-format=raw\fP muss das Suffix stets angegeben werden, außer wenn die +Ausgabe in die Standardausgabe erfolgt. Der Grund dafür ist, dass es kein +vorgegebenes Suffix für Rohdatenströme gibt. +.TP +\fB\-\-files\fP[\fB=\fP\fIDatei\fP] +liest die zu verarbeitenden Dateinamen aus \fIDatei\fP. Falls keine \fIDatei\fP +angegeben ist, werden die Dateinamen aus der Standardeingabe +gelesen. Dateinamen müssen mit einem Zeilenumbruch beendet werden. Ein +Bindestrich (\fB\-\fP) wird als regulärer Dateiname angesehen und nicht als +Standardeingabe interpretiert. Falls Dateinamen außerdem als +Befehlszeilenargumente angegeben sind, werden diese vor den Dateinamen aus +der \fIDatei\fP verarbeitet. +.TP +\fB\-\-files0\fP[\fB=\fP\fIDatei\fP] +Dies ist gleichbedeutend mit \fB\-\-files\fP[\fB=\fP\fIDatei\fP], außer dass jeder +Dateiname mit einem Null\-Zeichen abgeschlossen werden muss. +. +.SS "Grundlegende Dateiformat\- und Kompressionsoptionen" +.TP +\fB\-F\fP \fIFormat\fP, \fB\-\-format=\fP\fIFormat\fP +gibt das \fIFormat\fP der zu komprimierenden oder dekomprimierenden Datei an: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Dies ist die Voreinstellung. Bei der Kompression ist \fBauto\fP gleichbedeutend +mit \fBxz\fP. Bei der Dekompression wird das Format der Eingabedatei +automatisch erkannt. Beachten Sie, dass Rohdatenströme, wie sie mit +\fB\-\-format=raw\fP erzeugt werden, nicht automatisch erkannt werden können. +.TP +\fBxz\fP +Die Kompression erfolgt in das \fB.xz\fP\-Dateiformat oder akzeptiert nur +\&\fB.xz\fP\-Dateien bei der Dekompression. +.TP +\fBlzma\fP, \fBalone\fP +Die Kompression erfolgt in das veraltete \fB.lzma\fP\-Dateiformat oder +akzeptiert nur \fB.lzma\fP\-Dateien bei der Dekompression. Der alternative Name +\fBalone\fP dient der Abwärtskompatibilität zu den LZMA\-Dienstprogrammen. +.TP +\fBlzip\fP +Akzeptiert nur \fB.lz\fP\-Dateien bei der Dekompression. Kompression wird nicht +unterstützt. +.IP "" +The \fB.lz\fP format versions 0 and 1 are supported. Version 0 files were +produced by \fBlzip\fP 1.3 and older. Such files aren't common but may be +found from file archives as a few source packages were released in this +format. People might have old personal files in this format too. +Decompression support for the format version 0 was removed in \fBlzip\fP 1.18. +\fBlzip\fP 1.4 and later create files in the format version 1. +.TP +\fBraw\fP +Komprimiert oder dekomprimiert einen Rohdatenstrom (ohne Header). Diese +Option ist nur für fortgeschrittene Benutzer bestimmt. Zum Dekodieren von +Rohdatenströmen müssen Sie die Option \fB\-\-format=raw\fP verwenden und die +Filterkette ausdrücklich angeben, die normalerweise in den (hier fehlenden) +Container\-Headern gespeichert worden wäre. +.RE +.TP +\fB\-C\fP \fIPrüfung\fP, \fB\-\-check=\fP\fIPrüfung\fP +gibt den Typ der Integritätsprüfung an. Die Prüfsumme wird aus den +unkomprimierten Daten berechnet und in der \fB.xz\fP\-Datei gespeichert. Diese +Option wird nur bei der Kompression in das \fB.xz\fP\-Format angewendet, da das +\&\fB.lzma\fP\-Format keine Integritätsprüfungen unterstützt. Die eigentliche +Integritätsprüfung erfolgt (falls möglich), wenn die \fB.xz\fP\-Datei +dekomprimiert wird. +.IP "" +Folgende Typen von \fIPrüfungen\fP werden unterstützt: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +führt keine Integritätsprüfung aus. Dies ist eine eher schlechte +Idee. Dennoch kann es nützlich sein, wenn die Integrität der Daten auf +andere Weise sichergestellt werden kann. +.TP +\fBcrc32\fP +berechnet die CRC32\-Prüfsumme anhand des Polynoms aus IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +berechnet die CRC64\-Prüfsumme anhand des Polynoms aus ECMA\-182. Dies ist die +Voreinstellung, da beschädigte Dateien etwas besser als mit CRC32 erkannt +werden und die Geschwindigkeitsdifferenz unerheblich ist. +.TP +\fBsha256\fP +berechnet die SHA\-256\-Prüfsumme. Dies ist etwas langsamer als CRC32 und +CRC64. +.RE +.IP "" +Die Integrität der \fB.xz\fP\-Header wird immer mit CRC32 geprüft. Es ist nicht +möglich, dies zu ändern oder zu deaktivieren. +.TP +\fB\-\-ignore\-check\fP +verifiziert die Integritätsprüfsumme der komprimierten Daten bei der +Dekompression nicht. Die CRC32\-Werte in den \fB.xz\fP\-Headern werden weiterhin +normal verifiziert. +.IP "" +\fBVerwenden Sie diese Option nicht, außer Sie wissen, was Sie tun.\fP Mögliche +Gründe, diese Option zu verwenden: +.RS +.IP \(bu 3 +Versuchen, Daten aus einer beschädigten .xz\-Datei wiederherzustellen. +.IP \(bu 3 +Erhöhung der Geschwindigkeit bei der Dekompression. Dies macht sich meist +mit SHA\-256 bemerkbar, oder mit Dateien, die extrem stark komprimiert +sind. Wir empfehlen, diese Option nicht für diesen Zweck zu verwenden, es +sei denn, die Integrität der Datei wird extern auf andere Weise überprüft. +.RE +.TP +\fB\-0\fP … \fB\-9\fP +wählt eine der voreingestellten Kompressionsstufen, standardmäßig +\fB\-6\fP. Wenn mehrere Voreinstellungsstufen angegeben sind, ist nur die +zuletzt angegebene wirksam. Falls bereits eine benutzerdefinierte +Filterkette angegeben wurde, wird diese durch die Festlegung der +Voreinstellung geleert. +.IP "" +Die Unterschiede zwischen den Voreinstellungsstufen sind deutlicher als bei +\fBgzip\fP(1) und \fBbzip2\fP(1). Die gewählten Kompressionseinstellungen +bestimmen den Speicherbedarf bei der Dekompression, daher ist es auf älteren +Systemen mit wenig Speicher bei einer zu hoch gewählten Voreinstellung +schwer, eine Datei zu dekomprimieren. Insbesondere \fBist es keine gute Idee, blindlings \-9 für alles\fP zu verwenden, wie dies häufig mit \fBgzip\fP(1) und +\fBbzip2\fP(1) gehandhabt wird. +.RS +.TP +\fB\-0\fP … \fB\-3\fP +Diese Voreinstellungen sind recht schnell. \fB\-0\fP ist manchmal schneller als +\fBgzip \-9\fP, wobei aber die Kompression wesentlich besser ist. Die +schnelleren Voreinstellungen sind im Hinblick auf die Geschwindigkeit mit +\fBbzip2\fP(1) vergleichbar , mit einem ähnlichen oder besseren +Kompressionsverhältnis, wobei das Ergebnis aber stark vom Typ der zu +komprimierenden Daten abhängig ist. +.TP +\fB\-4\fP … \fB\-6\fP +Gute bis sehr gute Kompression, wobei der Speicherbedarf für die +Dekompression selbst auf alten Systemen akzeptabel ist. \fB\-6\fP ist die +Voreinstellung, welche üblicherweise eine gute Wahl für die Verteilung von +Dateien ist, die selbst noch auf Systemen mit nur 16\ MiB Arbeitsspeicher +dekomprimiert werden müssen (\fB\-5e\fP oder \fB\-6e\fP sind ebenfalls eine +Überlegung wert. Siehe \fB\-\-extreme\fP). +.TP +\fB\-7 … \-9\fP +Ähnlich wie \fB\-6\fP, aber mit einem höheren Speicherbedarf für die Kompression +und Dekompression. Sie sind nur nützlich, wenn Dateien komprimiert werden +sollen, die größer als 8\ MiB, 16\ MiB beziehungsweise 32\ MiB sind. +.RE +.IP "" +Auf der gleichen Hardware ist die Dekompressionsgeschwindigkeit ein nahezu +konstanter Wert in Bytes komprimierter Daten pro Sekunde. Anders +ausgedrückt: Je besser die Kompression, umso schneller wird üblicherweise +die Dekompression sein. Das bedeutet auch, dass die Menge der pro Sekunde +ausgegebenen unkomprimierten Daten stark variieren kann. +.IP "" +Die folgende Tabelle fasst die Eigenschaften der Voreinstellungen zusammen: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Voreinst.;Wörtb.Gr;KomprCPU;KompSpeich;DekompSpeich +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Spaltenbeschreibungen: +.RS +.IP \(bu 3 +Wörtb.Größe ist die Größe des LZMA2\-Wörterbuchs. Es ist +Speicherverschwendung, ein Wörterbuch zu verwenden, das größer als die +unkomprimierte Datei ist. Daher ist es besser, die Voreinstellungen \fB\-7\fP … +\fB\-9\fP zu vermeiden, falls es keinen wirklichen Bedarf dafür gibt. Mit \fB\-6\fP +und weniger wird üblicherweise so wenig Speicher verschwendet, dass dies +nicht ins Gewicht fällt. +.IP \(bu 3 +KomprCPU ist eine vereinfachte Repräsentation der LZMA2\-Einstellungen, +welche die Kompressionsgeschwindigkeit beeinflussen. Die Wörterbuchgröße +wirkt sich ebenfalls auf die Geschwindigkeit aus. Während KompCPU für die +Stufen \fB\-6\fP bis \fB\-9\fP gleich ist, tendieren höhere Stufen dazu, etwas +langsamer zu sein. Um eine noch langsamere, aber möglicherweise bessere +Kompression zu erhalten, siehe \fB\-\-extreme\fP. +.IP \(bu 3 +KompSpeich enthält den Speicherbedarf des Kompressors im +Einzel\-Thread\-Modus. Dieser kann zwischen den \fBxz\fP\-Versionen leicht +variieren. +.IP \(bu 3 +DekompSpeich enthält den Speicherbedarf für die Dekompression. Das bedeutet, +dass die Kompressionseinstellungen den Speicherbedarf bei der Dekompression +bestimmen. Der exakte Speicherbedarf bei der Dekompression ist geringfügig +größer als die Größe des LZMA2\-Wörterbuchs, aber die Werte in der Tabelle +wurden auf ganze MiB aufgerundet. +.RE +.IP "" + Der Speicherbedarf einiger der zukünftigen Multithread\-Modi kann dramatisch +höher sein als im Einzel\-Thread\-Modus. Mit dem Standardwert von +\fB\-\-block\-size\fP benötigt jeder Thread 3*3*Wörtb.Gr plus KompSpeich oder +DekompSpeich. Beispielsweise benötigen vier Threads mit der Voreinstellung +\fB\-6\fP etwa 660 bis 670 MiB Speicher. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +verwendet eine langsamere Variante der gewählten +Kompressions\-Voreinstellungsstufe (\fB\-0\fP … \fB\-9\fP), um hoffentlich ein etwas +besseres Kompressionsverhältnis zu erreichen, das aber in ungünstigen Fällen +auch schlechter werden kann. Der Speicherverbrauch bei der Dekompression +wird dabei nicht beeinflusst, aber der Speicherverbrauch der Kompression +steigt in den Voreinstellungsstufen \fB\-0\fP bis \fB\-3\fP geringfügig an. +.IP "" +Da es zwei Voreinstellungen mit den Wörterbuchgrößen 4\ MiB und 8\ MiB gibt, +verwenden die Voreinstellungsstufen \fB\-3e\fP und \fB\-5e\fP etwas schnellere +Einstellungen (niedrigere KompCPU) als \fB\-4e\fP beziehungsweise \fB\-6e\fP. Auf +diese Weise sind zwei Voreinstellungen nie identisch. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Voreinst.;Wörtb.Gr;KomprCPU;KompSpeich;DekompSpeich +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Zum Beispiel gibt es insgesamt vier Voreinstellungen, die ein 8\ MiB großes +Wörterbuch verwenden, deren Reihenfolge von der schnellsten zur langsamsten +\fB\-5\fP, \fB\-6\fP, \fB\-5e\fP und \fB\-6e\fP ist. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +sind etwas irreführende Aliase für \fB\-0\fP beziehungsweise \fB\-9\fP. Sie werden +nur zwecks Abwärtskompatibilität zu den LZMA\-Dienstprogrammen +bereitgestellt. Sie sollten diese Optionen besser nicht verwenden. +.TP +\fB\-\-block\-size=\fP\fIGröße\fP +teilt beim Komprimieren in das \fB.xz\fP\-Format die Eingabedaten in Blöcke der +angegebenen \fIGröße\fP in Byte. Die Blöcke werden unabhängig voneinander +komprimiert, was dem Multi\-Threading entgegen kommt und Zufallszugriffe bei +der Dekompression begrenzt. Diese Option wird typischerweise eingesetzt, um +die vorgegebene Blockgröße im Multi\-Thread\-Modus außer Kraft zu setzen, aber +sie kann auch im Einzel\-Thread\-Modus angewendet werden. +.IP "" +Im Multi\-Thread\-Modus wird etwa die dreifache \fIGröße\fP in jedem Thread zur +Pufferung der Ein\- und Ausgabe belegt. Die vorgegebene \fIGröße\fP ist das +Dreifache der Größe des LZMA2\-Wörterbuchs oder 1 MiB, je nachdem, was mehr +ist. Typischerweise ist das Zwei\- bis Vierfache der Größe des +LZMA2\-Wörterbuchs oder wenigstens 1 MB ein guter Wert. Eine \fIGröße\fP, die +geringer ist als die des LZMA2\-Wörterbuchs, ist Speicherverschwendung, weil +dann der LZMA2\-Wörterbuchpuffer niemals vollständig genutzt werden würde. Im +Multi\-Thread\-Modus wird die Größe der Blöcke wird in den Block\-Headern +gespeichert. Die Größeninformation wird für eine Multi\-Thread\-Dekompression +genutzt. +.IP "" +Im Einzel\-Thread\-Modus werden die Blöcke standardmäßig nicht geteilt. Das +Setzen dieser Option wirkt sich nicht auf den Speicherbedarf aus. In den +Block\-Headern werden keine Größeninformationen gespeichert, daher werden im +Einzel\-Thread\-Modus erzeugte Dateien nicht zu den im Multi\-Thread\-Modus +erzeugten Dateien identisch sein. Das Fehlen der Größeninformation bedingt +auch, dass \fBxz\fP nicht in der Lage sein wird, die Dateien im +Multi\-Thread\-Modus zu dekomprimieren. +.TP +\fB\-\-block\-list=\fP\fIBlöcke\fP +beginnt bei der Kompression in das \fB.xz\fP\-Format nach den angegebenen +Intervallen unkomprimierter Daten einen neuen Block, optional mit einer +benutzerdefinierten Filterkette. +.IP "" +Die \fIBlöcke\fP werden in einer durch Kommata getrennten Liste +angegeben. Jeder Block besteht aus einer optionalen Filterkettennummer +zwischen 0 und 9, gefolgt von einem Doppelpunkt (\fB:\fP) und der Größe der +unkomprimierten Daten (diese Angabe ist erforderlich). Überspringen eines +Blocks (zwei oder mehr aufeinander folgende Kommata) ist ein Kürzel dafür, +die Größe und die Filter des vorherigen Blocks zu verwenden. +.IP "" +Falls die Eingabedatei größer ist als die Summe der \fIBlöcke\fP, dann wird der +letzte in \fIVBlöcke\fP angegebene Wert bis zum Ende der Datei wiederholt. Mit +dem speziellen Wert \fB0\fP können Sie angeben, dass der Rest der Datei als +einzelner Block kodiert werden soll. +.IP "" +Eine alternative Filterkette für jeden Block kann in Kombination mit den +Optionen \fB\-\-filters1=\fP\fIFilter\fP \&…\& \fB\-\-filters9=\fP\fIFilter\fP angegeben +werden. Diese Optionen definieren Filterketten mit einem Bezeichner zwischen +1 und 9. Die Filterkette 0 bezeichnet hierbei die voreingestellte +Filterkette, was dem Nichtangeben einer Filterkette gleichkommt. Der +Filterkettenbezeichner kann vor der unkomprimierten Größe verwendet werden, +gefolgt von einem Doppelpunkt (\fB:\fP). Falls Sie beispielsweise +\fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP angeben, werden die Blöcke +folgendermaßen erstellt: +.RS +.IP \(bu 3 +Die durch \fB\-\-filters1\fP angegebene Filterkette und 2 MiB Eingabe +.IP \(bu 3 +Die durch \fB\-\-filters3\fP angegebene Filterkette und 2 MiB Eingabe +.IP \(bu 3 +Die durch \fB\-\-filters2\fP angegebene Filterkette und 4 MiB Eingabe +.IP \(bu 3 +Die durch \fB\-\-filters2\fP angegebene Filterkette und 4 MiB Eingabe +.IP \(bu 3 +Die vorgegebene Filterkette und 2 MiB Eingabe +.IP \(bu 3 +Die vorgegebene Filterkette und 4 MiB Eingabe für jeden Block bis zum Ende +der Eingabe. +.RE +.IP "" +Falls Sie eine Größe angeben, welche die Blockgröße des Encoders übersteigen +(entweder den Vorgabewert im Thread\-Modus oder den mit +\fB\-\-block\-size=\fP\fIGröße\fP angegebenen Wert), wird der Encoder zusätzliche +Blöcke erzeugen, wobei die in den \fIBlöcke\fP angegebenen Grenzen eingehalten +werden. Wenn Sie zum Beispiel \fB\-\-block\-size=10MiB\fP +\fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP angeben und die Eingabedatei 80 +MiB groß ist, erhalten Sie 11 Blöcke: 5, 10, 8, 10, 2, 10, 10, 4, 10, 10 und +1 MiB. +.IP "" +Im Multi\-Thread\-Modus werden die Blockgrößen in den Block\-Headern +gespeichert. Dies geschieht im Einzel\-Thread\-Modus nicht, daher wird die +kodierte Ausgabe zu der im Multi\-Thread\-Modus nicht identisch sein. +.TP +\fB\-\-flush\-timeout=\fP\fIZeit\fP +löscht bei der Kompression die ausstehenden Daten aus dem Encoder und macht +sie im Ausgabedatenstrom verfügbar, wenn mehr als die angegebene \fIZeit\fP in +Millisekunden (als positive Ganzzahl) seit dem vorherigen Löschen vergangen +ist und das Lesen weiterer Eingaben blockieren würde. Dies kann nützlich +sein, wenn \fBxz\fP zum Komprimieren von über das Netzwerk eingehenden Daten +verwendet wird. Kleine \fIZeit\fP\-Werte machen die Daten unmittelbar nach dem +Empfang nach einer kurzen Verzögerung verfügbar, während große \fIZeit\fP\-Werte +ein besseres Kompressionsverhältnis bewirken. +.IP "" +Dieses Funktionsmerkmal ist standardmäßig deaktiviert. Wenn diese Option +mehrfach angegeben wird, ist die zuletzt angegebene wirksam. Für die Angabe +der \fIZeit\fP kann der spezielle Wert \fB0\fP verwendet werden, um dieses +Funktionsmerkmal explizit zu deaktivieren. +.IP "" +Dieses Funktionsmerkmal ist außerhalb von POSIX\-Systemen nicht verfügbar. +.IP "" +.\" FIXME +\fBDieses Funktionsmerkmal ist noch experimentell.\fP Gegenwärtig ist \fBxz\fP +aufgrund der Art und Weise, wie \fBxz\fP puffert, für Dekompression in Echtzeit +ungeeignet. +.TP +\fB\-\-no\-sync\fP +synchronisiert die Zieldatei und deren Verzeichnis auf dem Speichergerät +nicht, bevor die Quelldatei gelöscht wird. So kann die Performance beim +Komprimieren oder Dekomprimieren vieler kleiner Dateien verbessert +werden. Jedoch wäre es möglich, falls es kurz nach dem Löschen zu einem +Systemabsturz kommt, dass die Zieldatei noch nicht auf dem Speichergerät +geschrieben, aber der Löschvorgang bereits ausgeführt wurde. In diesem Fall +gehen sowohl die Quelldatei als auch die Zieldatei verloren. +.IP "" +Diese Option ist nur wirksam, wenn \fBxz\fP die Quelldatei löscht. In anderen +Fällen wird niemals synchronisiert. +.IP "" +Die Synchronisierung und \fB\-\-no\-sync\fP wurden in Version \fBxz\fP 5.7.1alpha +hinzugefügt. +.TP +\fB\-\-memlimit\-compress=\fP\fIGrenze\fP +legt eine Grenze für die Speichernutzung bei der Kompression fest. Wenn +diese Option mehrmals angegeben wird, ist die zuletzt angegebene wirksam. +.IP "" +Falls die Kompressionseinstellungen die \fIGrenze\fP überschreiten, versucht +\fBxz\fP, die Einstellungen nach unten anzupassen, so dass die Grenze nicht +mehr überschritten wird und zeigt einen Hinweis an, dass eine automatische +Anpassung vorgenommen wurde. Die Anpassungen werden in folgender Reihenfolge +angewendet: Reduzierung der Anzahl der Threads, Wechsel in den +Einzelthread\-Modus, falls sogar ein einziger Thread im Multithread\-Modus die +\fIGrenze\fP überschreitet, und schlussendlich die Reduzierung der Größe des +LZMA2\-Wörterbuchs. +.IP "" +Beim Komprimieren mit \fB\-\-format=raw\fP oder falls \fB\-\-no\-adjust\fP angegeben +wurde, wird nur die Anzahl der Threads reduziert, da nur so die komprimierte +Ausgabe nicht beeinflusst wird. +.IP "" +Falls die \fIGrenze\fP nicht anhand der vorstehend beschriebenen Anpassungen +gesetzt werden kann, wird ein Fehler angezeigt und \fBxz\fP wird mit dem +Exit\-Status 1 beendet. +.IP "" +Die \fIGrenze\fP kann auf verschiedene Arten angegeben werden: +.RS +.IP \(bu 3 +Die \fIGrenze\fP kann ein absoluter Wert in Byte sein. Ein Suffix wie \fBMiB\fP +kann dabei hilfreich sein. Beispiel: \fB\-\-memlimit\-compress=80MiB\fP. +.IP \(bu 3 +Die \fIGrenze\fP kann als Prozentsatz des physischen Gesamtspeichers (RAM) +angegeben werden. Dies ist insbesondere nützlich, wenn in einem +Shell\-Initialisierungsskript, das mehrere unterschiedliche Rechner gemeinsam +verwenden, die Umgebungsvariable \fBXZ_DEFAULTS\fP gesetzt ist. Auf diese Weise +ist die Grenze auf Systemen mit mehr Speicher höher. Beispiel: +\fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +Mit \fB0\fP kann die \fIGrenze\fP auf den Standardwert zurückgesetzt werden. Dies +ist gegenwärtig gleichbedeutend mit dem Setzen der \fIGrenze\fP auf \fBmax\fP +(keine Speicherbegrenzung). +.RE +.IP "" +Für die 32\-Bit\-Version von \fBxz\fP gibt es einen Spezialfall: Falls die Grenze +über \fB4020\ MiB\fP liegt, wird die \fIGrenze\fP auf \fB4020\ MiB\fP gesetzt. Auf +MIPS32 wird stattdessen \fB2000\ MB\fP verwendet (die Werte \fB0\fP und \fBmax\fP +werden hiervon nicht beeinflusst; für die Dekompression gibt es keine +vergleichbare Funktion). Dies kann hilfreich sein, wenn ein +32\-Bit\-Executable auf einen 4\ GiB großen Adressraum (2 GiB auf MIPS32) +zugreifen kann, wobei wir hoffen wollen, dass es in anderen Situationen +keine negativen Effekte hat. +.IP "" +Siehe auch den Abschnitt \fBSpeicherbedarf\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIGrenze\fP +legt eine Begrenzung des Speicherverbrauchs für die Dekompression fest. Dies +beeinflusst auch den Modus \fB\-\-list\fP. Falls die Aktion nicht ausführbar ist, +ohne die \fIGrenze\fP zu überschreiten, gibt \fBxz\fP eine Fehlermeldung aus und +die Dekompression wird fehlschlagen. Siehe \fB\-\-memlimit\-compress=\fP\fIGrenze\fP +zu möglichen Wegen, die \fIGrenze\fP anzugeben. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIGrenze\fP +legt eine Begrenzung des Speicherverbrauchs für Multithread\-Dekompression +fest. Dies beeinflusst lediglich die Anzahl der Threads; \fBxz\fP wird dadurch +niemals die Dekompression einer Datei verweigern. Falls die \fIGrenze\fP für +jegliches Multithreading zu niedrig ist, wird sie ignoriert und \fBxz\fP setzt +im Einzelthread\-modus fort. Beachten Sie auch, dass bei der Verwendung von +\fB\-\-memlimit\-decompress\fP dies stets sowohl auf den Einzelthread\-als auch auf +den Multithread\-Modus angewendet wird und so die effektive \fIGrenze\fP für den +Multithread\-Modus niemals höher sein wird als die mit +\fB\-\-memlimit\-decompress\fP gesetzte Grenze. +.IP "" +Im Gegensatz zu anderen Optionen zur Begrenzung des Speicherverbrauchs hat +\fB\-\-memlimit\-mt\-decompress=\fP\fIGrenze\fP eine systemspezifisch vorgegebene +\fIGrenze\fP. Mit \fBxz \-\-info\-memory\fP können Sie deren aktuellen Wert anzeigen +lassen. +.IP "" +Diese Option und ihr Standardwert existieren, weil die unbegrenzte +threadbezogene Dekompression bei einigen Eingabedateien zu unglaublich +großem Speicherverbrauch führen würde. Falls die vorgegebene \fIGrenze\fP auf +Ihrem System zu niedrig ist, können Sie die \fIGrenze\fP durchaus erhöhen, aber +setzen Sie sie niemals auf einen Wert größer als die Menge des nutzbaren +Speichers, da \fBxz\fP bei entsprechenden Eingabedateien versuchen wird, diese +Menge an Speicher auch bei einer geringen Anzahl von Threads zu +verwnden. Speichermangel oder Auslagerung verbessern die +Dekomprimierungsleistung nicht. +.IP "" +Siehe \fB\-\-memlimit\-compress=\fP\fIGrenze\fP für mögliche Wege zur Angabe der +\fIGrenze\fP. Sezen der \fIGrenze\fP auf \fB0\fP setzt die \fIGrenze\fP auf den +vorgegebenen systemspezifischen Wert zurück. +.TP +\fB\-M\fP \fIGrenze\fP, \fB\-\-memlimit=\fP\fIGrenze\fP, \fB\-\-memory=\fP\fIGrenze\fP +Dies ist gleichbedeutend mit \fB\-\-memlimit\-compress=\fP\fIGrenze\fP +\fB\-\-memlimit\-decompress=\fP\fIGrenze\fP \fB\-\-memlimit\-mt\-decompress=\fP\fIGrenze\fP. +.TP +\fB\-\-no\-adjust\fP +zeigt einen Fehler an und beendet, falls die Grenze der Speichernutzung +nicht ohne Änderung der Einstellungen, welche die komprimierte Ausgabe +beeinflussen, berücksichtigt werden kann. Das bedeutet, dass \fBxz\fP daran +gehindert wird, den Encoder vom Multithread\-Modus in den Einzelthread\-Modus +zu versetzen und die Größe des LZMA2\-Wörterbuchs zu reduzieren. Allerdings +kann bei Verwendung dieser Option dennoch die Anzahl der Threads reduziert +werden, um die Grenze der Speichernutzung zu halten, sofern dies die +komprimierte Ausgabe nicht beeinflusst. +.IP "" +Die automatische Anpassung ist beim Erzeugen von Rohdatenströmen +(\fB\-\-format=raw\fP) immer deaktiviert. +.TP +\fB\-T\fP \fIThreads\fP, \fB\-\-threads=\fP\fIThreads\fP +gibt die Anzahl der zu verwendenden Arbeits\-Threads an. Wenn Sie \fIThreads\fP +auf einen speziellen Wert \fB0\fP setzen, verwendet \fBxz\fP maximal so viele +Threads, wie der/die Prozessor(en) im System untestützen. Die tatsächliche +Anzahl kann geringer sein als die angegebenen \fIThreads\fP, wenn die +Eingabedatei nicht groß genug für Threading mit den gegebenen Einstellungen +ist oder wenn mehr Threads die Speicherbegrenzung übersteigen würden. +.IP "" +Die Multithread\- bzw. Einzelthread\-Kompressoren erzeugen unterschiedliche +Ausgaben. Der Einzelthread\-Kompressor erzeugt die geringste Dateigröße, aber +nur die Ausgabe des Multithread\-Kompressors kann mit mehreren Threads wieder +dekomprimiert werden. Das Setzen der Anzahl der \fIThreads\fP auf \fB1\fP wird den +Einzelthread\-Modus verwenden. Das Setzen der Anzahl der \fIThreads\fP auf +einen anderen Wert einschließlich \fB0\fP verwendet den Multithread\-Kompressor, +und zwar sogar dann, wenn das System nur einen einzigen Hardware\-Thread +unterstützt (\fBxz\fP 5.2.x verwendete in diesem Fall noch den +Einzelthread\-Modus). +.IP "" +Um den Multithread\-Modus mit nur einem einzigen Thread zu verwenden, setzen +Sie die Anzahl der \fIThreads\fP auf \fB+1\fP. Das Präfix \fB+\fP hat mit Werten +verschieden von \fB1\fP keinen Effekt. Eine Begrenzung des Speicherverbrauchs +kann \fBxz\fP dennoch veranlassen, den Einzelthread\-Modus zu verwenden, außer +wenn \fB\-\-no\-adjust\fP verwendet wird. Die Unterstützung für das Präfix \fB+\fP +wurde in \fBxz\fP 5.4.0 hinzugefügt. +.IP "" +Falls das automatische Setzen der Anzahl der Threads angefordert und keine +Speicherbegrenzung angegeben wurde, dann wird eine systemspezifisch +vorgegebene weiche Grenze verwendet, um eventuell die Anzahl der Threads zu +begrenzen. Es ist eine weiche Grenze im Sinne davon, dass sie ignoriert +wird, falls die Anzahl der Threads 1 ist; daher wird eine weiche Grenze +\fBxz\fP niemals an der Kompression oder Dekompression hindern. Diese +vorgegebene weiche Grenze veranlasst \fBxz\fP nicht, vom Multithread\-Modus in +den Einzelthread\-Modus zu wechseln. Die aktiven Grenzen können Sie mit dem +Befehl \fBxz \-\-info\-memory\fP anzeigen lassen. +.IP "" +Die gegenwärtig einzige Threading\-Methode teilt die Eingabe in Blöcke und +komprimiert diese unabhängig voneinander. Die vorgegebene Blockgröße ist von +der Kompressionsstufe abhängig und kann mit der Option +\fB\-\-block\-size=\fP\fIGröße\fP außer Kraft gesetzt werden. +.IP "" +Eine thread\-basierte Dekompression wird nur bei Dateien funktionieren, die +mehrere Blöcke mit Größeninformationen in deren Headern enthalten. Alle im +Multi\-Thread\-Modus komprimierten Dateien, die groß genug sind, erfüllen +diese Bedingung, im Einzel\-Thread\-Modus komprimierte Dateien dagegen nicht, +selbst wenn \fB\-\-block\-size=\fP\fIGröße\fP verwendet wurde. +.IP "" +Der Vorgabewert für \fIThreads\fP is \fB0\fP. In \fBxz\fP 5.4.x und älteren Versionen +ist der Vorgabewert \fB1\fP. +. +.SS "Benutzerdefinierte Filterketten für die Kompression" +Eine benutzerdefinierte Filterkette ermöglicht die Angabe detaillierter +Kompressionseinstellungen, anstatt von den Voreinstellungen auszugehen. Wenn +eine benutzerdefinierte Filterkette angegeben wird, werden die vorher in der +Befehlszeile angegebenen Voreinstellungsoptionen (\fB\-0\fP … \fB\-9\fP und +\fB\-\-extreme\fP) außer Kraft gesetzt. Wenn eine Voreinstellungsoption nach +einer oder mehreren benutzerdefinierten Filterkettenoptionen angegeben wird, +dann wird die neue Voreinstellung wirksam und die zuvor angegebenen +Filterkettenoptionen werden außer Kraft gesetzt. +.PP +Eine Filterkette ist mit dem Piping (der Weiterleitung) in der Befehlszeile +vergleichbar. Bei der Kompression gelangt die unkomprimierte Eingabe in den +ersten Filter, dessen Ausgabe wiederum in den zweiten Filter geleitet wird +(sofern ein solcher vorhanden ist). Die Ausgabe des letzten Filters wird in +die komprimierte Datei geschrieben. In einer Filterkette sind maximal vier +Filter zulässig, aber typischerweise besteht eine Filterkette nur aus einem +oder zwei Filtern. +.PP +Bei vielen Filtern ist die Positionierung in der Filterkette eingeschränkt: +Einige Filter sind nur als letzte in der Kette verwendbar, einige können +nicht als letzte Filter gesetzt werden, und andere funktionieren an +beliebiger Stelle. Abhängig von dem Filter ist diese Beschränkung entweder +auf das Design des Filters selbst zurückzuführen oder ist aus +Sicherheitsgründen vorhanden. +.PP +Eine benutzerdefinierte Filterkette kann auf zwei verschiedene Arten +angegeben werden. Die Optionen \fB\-\-filters=\fP\fIFilter\fP und +\fB\-\-filters1=\fP\fIFilter\fP \&…\& \fB\-\-filters9=\fP\fIFilter\fP ermöglichen die Angabe +einer ganzen Filterkette in einer einzelnen Option gemäß der +Liblzma\-Filterzeichenkettensyntax. Alternativ können Sie eine Filterkette +mit einer oder mehreren individuellen Filteroptionen in der Reihenfolge +angeben, in der sie in der Filterkette verwendet werden sollen. Daher ist +die Reihenfolge der individuellen Filteroptionen wichtig! Beim Dekodieren +von Rohdatenströmen (\fB\-\-format=raw\fP) muss die Filterkette in der gleichen +Reihenfolge wie bei der Komprimierung angegeben werden. Alle individuellen +Filter\- oder Voreinstellungsoptionen, die \fIvor\fP der vollen +Filterkettenoption (\fB\-\-filters=\fP\fIFilter\fP) angegeben werden, werden +verworfen. Individuelle Filter, die \fInach\fP der vollen Filterkettenoption +angegeben werden, setzen die Filterkette zurück +.PP +Sowohl vollständige als auch individuelle Filteroptionen akzeptieren +filterspezifische \fIOptionen\fP in einer durch Kommata getrennten +Liste. Zusätzliche Kommata in den \fIOptionen\fP werden ignoriert. Jede Option +hat einen Standardwert, daher brauchen Sie nur jene anzugeben, die Sie +ändern wollen. +.PP +Um die gesamte Filterkette und die \fIOptionen\fP anzuzeigen, rufen Sie \fBxz \-vv\fP auf (was gleichbedeutend mit der zweimaligen Angabe von \fB\-\-verbose\fP +ist). Dies funktioniert auch zum Betrachten der von den Voreinstellungen +verwendeten Filterkettenoptionen. +.TP +\fB\-\-filters=\fP\fIFilter\fP +gibt die vollständige Filterkette oder eine Voreinstellung in einer +einzelnen Option an. Mehrere Filter können durch Leerzeichen oder zwei +Minuszeichen (\fB\-\-\fP) voneinander getrennt werden. Es kann notwendig sein, +die \fIFilter\fP in der Shell\-Befehlszeile zu maskieren, so dass diese als +einzelne Option ausgewertet werden. Um Optionen Werte zuzuordnen, verwenden +Sie \fB:\fP oder \fB=\fP. Einer Voreinstellung kann ein \fB\-\fP vorangestellt werden, +dem keiner oder mehrere Schalter folgen. Der einzige unterstützte Schalter +ist \fBe\fP zum Anwenden der gleichen Optionen wie \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIFilter\fP … \fB\-\-filters9\fP=\fIFilter\fP +gibt bis zu neun optionale Filterketten an, die mit \fB\-\-block\-list\fP +verwendet werden können. +.IP "" +Wenn Sie beispielsweise ein Archiv mit ausführbaren Dateien gefolgt von +Textdateien komprimieren, könnte der Teil mit den ausführbaren Dateien eine +Filterkette mit einem BCJ\-Filter und der Textdateiteil lediglich den +LZMA2\-Filter verwenden. +.TP +\fB\-\-filters\-help\fP +zeigt eine Hilfemeldung an, welche beschreibt, wie Voreinstellungen und +benutzerdefinierte Filterketten in den Optionen \fB\-\-filters\fP und +\fB\-\-filters1=\fP\fIFilter\fP \&… \& \fB\-\-filters9=\fP\fIFilter\fP angegeben werden und +beendet das Programm. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIOptionen\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIOptionen\fP] +.PD +fügt LZMA1\- oder LZMA2\-Filter zur Filterkette hinzu. Diese Filter können nur +als letzte Filter in der Kette verwendet werden. +.IP "" +LZMA1 ist ein veralteter Filter, welcher nur wegen des veralteten +\&\fB.lzma\fP\-Dateiformats unterstützt wird, welches nur LZMA1 unterstützt. LZMA2 +ist eine aktualisierte Version von LZMA1, welche einige praktische Probleme +von LZMA1 behebt. Das \fB.xz\fP\-Format verwendet LZMA2 und unterstützt LZMA1 +gar nicht. Kompressionsgeschwindigkeit und \-verhältnis sind bei LZMA1 und +LZMA2 praktisch gleich. +.IP "" +LZMA1 und LZMA2 haben die gleichen \fIOptionen\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIVoreinstellung\fP +setzt alle LZMA1\- oder LZMA2\-\fIOptionen\fP auf die \fIVoreinstellung\fP +zurück. Diese \fIVoreinstellung\fP wird in Form einer Ganzzahl angegeben, der +ein aus einem einzelnen Buchstaben bestehender Voreinstellungsmodifikator +folgen kann. Die Ganzzahl kann \fB0\fP bis \fB9\fP sein, entsprechend den +Befehlszeilenoptionen \fB\-0\fP … \fB\-9\fP. Gegenwärtig ist \fBe\fP der einzige +unterstützte Modifikator, was \fB\-\-extreme\fP entspricht. Wenn keine +\fBVoreinstellung\fP angegeben ist, werden die Standardwerte der LZMA1\- oder +LZMA2\-\fIOptionen\fP der Voreinstellung \fB6\fP entnommen. +.TP +\fBdict=\fP\fIGröße\fP +Die \fIGröße\fP des Wörterbuchs (Chronikpuffers) gibt an, wie viel Byte der +kürzlich verarbeiteten unkomprimierten Daten im Speicher behalten werden +sollen. Der Algorithmus versucht, sich wiederholende Byte\-Abfolgen +(Übereinstimmungen) in den unkomprimierten Daten zu finden und diese durch +Referenzen zu den Daten zu ersetzen, die sich gegenwärtig im Wörterbuch +befinden. Je größer das Wörterbuch, umso größer ist die Chance, eine +Übereinstimmung zu finden. Daher bewirkt eine Erhöhung der \fIGröße\fP des +Wörterbuchs üblicherweise ein besseres Kompressionsverhältnis, aber ein +Wörterbuch, das größer ist als die unkomprimierte Datei, wäre +Speicherverschwendung. +.IP "" +Typische Wörterbuch\-\fIGrößen\fP liegen im Bereich von 64\ KiB bis 64\ MiB. Das +Minimum ist 4\ KiB. Das Maximum für die Kompression ist gegenwärtig 1.5\ GiB +(1536\ MiB). Bei der Dekompression wird bereits eine Wörterbuchgröße bis zu +4\ GiB minus 1 Byte unterstützt, welche das Maximum für die LZMA1\- und +LZMA2\-Datenstromformate ist. +.IP "" +Die \fIGröße\fP des Wörterbuchs und der Übereinstimmungsfinder (\fIÜf\fP) +bestimmen zusammen den Speicherverbrauch des LZMA1\- oder +LZMA2\-Kodierers. Bei der Dekompression ist ein Wörterbuch der gleichen +\fIGröße\fP (oder ein noch größeres) wie bei der Kompression erforderlich, +daher wird der Speicherverbrauch des Dekoders durch die Größe des bei der +Kompression verwendeten Wörterbuchs bestimmt. Die \fB.xz\fP\-Header speichern +die \fIGröße\fP des Wörterbuchs entweder als 2^\fIn\fP oder 2^\fIn\fP + 2^(\fIn\fP\-1), +so dass diese \fIGrößen\fP für die Kompression etwas bevorzugt werden. Andere +\fIGrößen\fP werden beim Speichern in den \fB.xz\fP\-Headern aufgerundet. +.TP +\fBlc=\fP\fIlc\fP +gibt die Anzahl der literalen Kontextbits an. Das Minimum ist 0 und das +Maximum 4; der Standardwert ist 3. Außerdem darf die Summe von \fIlc\fP und +\fIlp\fP nicht größer als 4 sein. +.IP "" +Alle Bytes, die nicht als Übereinstimmungen kodiert werden können, werden +als Literale kodiert. Solche Literale sind einfache 8\-bit\-Bytes, die jeweils +für sich kodiert werden. +.IP "" +Bei der Literalkodierung wird angenommen, dass die höchsten \fIlc\fP\-Bits des +zuvor unkomprimierten Bytes mit dem nächsten Byte in Beziehung stehen. Zum +Beispiel folgt in typischen englischsprachigen Texten auf einen +Großbuchstaben ein Kleinbuchstabe und auf einen Kleinbuchstaben +üblicherweise wieder ein Kleinbuchstabe. Im US\-ASCII\-Zeichensatz sind die +höchsten drei Bits 010 für Großbuchstaben und 011 für Kleinbuchstaben. Wenn +\fIlc\fP mindestens 3 ist, kann die literale Kodierung diese Eigenschaft der +unkomprimierten Daten ausnutzen. +.IP "" +Der Vorgabewert (3) ist üblicherweise gut. Wenn Sie die maximale Kompression +erreichen wollen, versuchen Sie \fBlc=4\fP. Manchmal hilft es ein wenig, doch +manchmal verschlechtert es die Kompression. Im letzteren Fall versuchen Sie +zum Beispiel auch\& \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +gibt die Anzahl der literalen Positionsbits an. Das Minimum ist 0 und das +Maximum 4; die Vorgabe ist 0. +.IP "" +\fILp\fP beeinflusst, welche Art der Ausrichtung der unkomprimierten Daten beim +Kodieren von Literalen angenommen wird. Siehe \fIpb\fP weiter unten für weitere +Informationen zur Ausrichtung. +.TP +\fBpb=\fP\fIAnzahl\fP +legt die Anzahl der Positions\-Bits fest. Das Minimum ist 0 und das Maximum +4; Standard ist 2. +.IP "" +\fIPb\fP beeinflusst, welche Art der Ausrichtung der unkomprimierten Daten +generell angenommen wird. Standardmäßig wird eine Vier\-Byte\-Ausrichtung +angenommen (2^\fIpb\fP=2^2=4), was oft eine gute Wahl ist, wenn es keine +bessere Schätzung gibt. +.IP "" +Wenn die Ausrichtung bekannt ist, kann das entsprechende Setzen von \fIpb\fP +die Dateigröße ein wenig verringern. Wenn Textdateien zum Beispiel eine +Ein\-Byte\-Ausrichtung haben (US\-ASCII, ISO\-8859\-*, UTF\-8), kann das Setzen +von \fBpb=0\fP die Kompression etwas verbessern. Für UTF\-16\-Text ist \fBpb=1\fP +eine gute Wahl. Wenn die Ausrichtung eine ungerade Zahl wie beispielsweise 3 +Byte ist, könnte \fBpb=0\fP die beste Wahl sein. +.IP "" +Obwohl die angenommene Ausrichtung mit \fIpb\fP und \fIlp\fP angepasst werden +kann, bevorzugen LZMA1 und LZMA2 noch etwas die 16\-Byte\-Ausrichtung. Das +sollten Sie vielleicht beim Design von Dateiformaten berücksichtigen, die +wahrscheinlich oft mit LZMA1 oder LZMA2 komprimiert werden. +.TP +\fBmf=\fP\fIÜf\fP +Der Übereinstimmungsfinder hat einen großen Einfluss auf die Geschwindigkeit +des Kodierers, den Speicherbedarf und das +Kompressionsverhältnis. Üblicherweise sind auf Hash\-Ketten basierende +Übereinstimmungsfinder schneller als jene, die mit Binärbäumen arbeiten. Die +Vorgabe hängt von der \fIVoreinstellungsstufe\fP ab: 0 verwendet \fBhc3\fP, 1\-3 +verwenden \fBhc4\fP und der Rest verwendet \fBbt4\fP. +.IP "" +Die folgenden Übereinstimmungsfinder werden unterstützt. Die Formeln zur +Ermittlung des Speicherverbrauchs sind grobe Schätzungen, die der Realität +am nächsten kommen, wenn \fIWörterbuch\fP eine Zweierpotenz ist. +.RS +.TP +\fBhc3\fP +Hash\-Kette mit 2\- und 3\-Byte\-Hashing +.br +Minimalwert für \fInice\fP: 3 +.br +Speicherbedarf: +.br +\fIdict\fP * 7,5 (falls \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 5,5 + 64 MiB (falls \fIdict\fP > 16 MiB) +.TP +\fBhc4\fP +Hash\-Kette mit 2\-, 3\- und 4\-Byte\-Hashing +.br +Minimaler Wert für \fInice\fP: 4 +.br +Speicherbedarf: +.br +\fIdict\fP * 7,5 (falls \fIdict\fP <= 32 MiB ist); +.br +\fIdict\fP * 6,5 (falls \fIdict\fP > 32 MiB ist) +.TP +\fBbt2\fP +Binärbaum mit 2\-Byte\-Hashing +.br +Minimaler Wert für \fInice\fP: 2 +.br +Speicherverbrauch: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Binärbaum mit 2\- und 3\-Byte\-Hashing +.br +Minimalwert für \fInice\fP: 3 +.br +Speicherbedarf: +.br +\fIdict\fP * 11,5 (falls \fIdict\fP <= 16 MiB ist); +.br +\fIdict\fP * 9,5 + 64 MiB (falls \fIdict\fP > 16 MiB ist) +.TP +\fBbt4\fP +Binärbaum mit 2\-, 3\- und 4\-Byte\-Hashing +.br +Minimaler Wert für \fInice\fP: 4 +.br +Speicherbedarf: +.br +\fIdict\fP * 11,5 (falls \fIdict\fP <= 32 MiB ist); +.br +\fIdict\fP * 10,5 (falls \fIdict\fP > 32 MiB ist) +.RE +.TP +\fBmode=\fP\fIModus\fP +gibt die Methode zum Analysieren der vom Übereinstimmungsfinder gelieferten +Daten an. Als \fIModi\fP werden \fBfast\fP und \fBnormal\fP unterstützt. Die Vorgabe +ist \fBfast\fP für die \fIVoreinstellungsstufen\fP 0\-3 und \fBnormal\fP für die +\fIVoreinstellungsstufen\fP 4\-9. +.IP "" +Üblicherweise wird \fBfast\fP mit Hashketten\-basierten Übereinstimmungsfindern +und \fBnormal\fP mit Binärbaum\-basierten Übereinstimmungsfindern verwendet. So +machen es auch die \fIVoreinstellungsstufen\fP. +.TP +\fBnice=\fP\fInice\fP +gibt an, was als annehmbarer Wert für eine Übereinstimmung angesehen werden +kann. Wenn eine Übereinstimmung gefunden wird, die mindestens diesen +\fInice\fP\-Wert hat, sucht der Algorithmus nicht weiter nach besseren +Übereinstimmungen. +.IP "" +Der \fInice\fP\-Wert kann 2\-273 Byte sein. Höhere Werte tendieren zu einem +besseren Kompressionsverhältnis, aber auf Kosten der Geschwindigkeit. Die +Vorgabe hängt von der \fIVoreinstellungsstufe\fP ab. +.TP +\fBdepth=\fP\fITiefe\fP +legt die maximale Suchtiefe im Übereinstimmungsfinder fest. Vorgegeben ist +der spezielle Wert 0, der den Kompressor veranlasst, einen annehmbaren Wert +für \fITiefe\fP aus \fIÜf\fP und \fInice\fP\-Wert zu bestimmen. +.IP "" +Die angemessene \fITiefe\fP für Hash\-Ketten ist 4\-100 und 16\-1000 für +Binärbäume. Hohe Werte für die \fITiefe\fP können den Kodierer bei einigen +Dateien extrem verlangsamen. Vermeiden Sie es, die \fITiefe\fP über einen Wert +von 100 zu setzen, oder stellen Sie sich darauf ein, die Kompression +abzubrechen, wenn sie zu lange dauert. +.RE +.IP "" +Beim Dekodieren von Rohdatenströmen (\fB\-\-format=raw\fP) benötigt LZMA2 nur die +Wörterbuch\-\fIGröße\fP. LZMA1 benötigt außerdem \fIlc\fP, \fIlp\fP und \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIOptionen\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIOptionen\fP] +.PD +fügt ein »Branch/Call/Jump«\-(BCJ\-)Filter zur Filterkette hinzu. Diese Filter +können nicht als letzter Filter in der Filterkette verwendet werden. +.IP "" +Ein BCJ\-Filter wandelt relative Adressen im Maschinencode in deren absolute +Gegenstücke um. Die Datengröße wird dadurch nicht geändert, aber die +Redundanz erhöht, was LZMA2 dabei helfen kann, eine um 10 bis 15% kleinere +\&\fB.xz\fP\-Datei zu erstellen. Die BCJ\-Filter sind immer reversibel, daher +verursacht die Anwendung eines BCJ\-Filters auf den falschen Datentyp keinen +Datenverlust, wobei aber das Kompressionsverhältnis etwas schlechter werden +könnte. Die BCJ\-Filter sind sehr schnell und verbrauchen nur wenig mehr +Speicher. +.IP "" +Diese BCJ\-Filter haben bekannte Probleme mit dem Kompressionsverhältnis: +.RS +.IP \(bu 3 +In einigen Dateitypen, die ausführbaren Code enthalten (zum Beispiel +Objektdateien, statische Bibliotheken und Linux\-Kernelmodule), sind die +Adressen in den Anweisungen mit Füllwerten gefüllt. Diese BCJ\-Filter führen +dennoch die Adressumwandlung aus, wodurch die Kompression bei diesen Dateien +schlechter wird. +.IP \(bu 3 +Falls ein BCJ\-Filter auf ein Archiv angewendet wird, ist es möglich, dass +das Kompressionsverhältnis schlechter als ohne Filter wird. Falls es +beispielsweise ähnliche oder sogar identische ausführbare Dateien gibt, dann +werden diese durch die Filterung wahrscheinlich »unähnlicher« und +verschlechtern dadurch das Kompressionsverhältnis. Der Inhalt +nicht\-ausführbarer Dateien im gleichen Archiv kann sich ebenfalls darauf +auswirken. In der Praxis werden Sie durch Versuche mit oder ohne BCJ\-Filter +selbst herausfinden müssen, was situationsbezogen besser ist. +.RE +.IP "" +Verschiedene Befehlssätze haben unterschiedliche Ausrichtungen: Die +ausführbare Datei muss in den Eingabedateien einem Vielfachen dieses Wertes +entsprechen, damit dieser Filter funktioniert. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filter;Ausrichtung;Hinweise +x86;1;32\-Bit oder 64\-Bit x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096\-Byte\-Ausrichtung ist optimal +PowerPC;4;Nur Big Endian +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Da die BCJ\-gefilterten Daten üblicherweise mit LZMA2 komprimiert sind, kann +das Kompressionsverhältnis dadurch etwas verbessert werden, dass die +LZMA2\-Optionen so gesetzt werden, dass sie der Ausrichtung des gewählten +BCJ\-Filters entsprechen. Beispiele: +.RS +.IP \(bu 3 +Der IA\-64\-Filter hat eine 16\-Byte\-Ausrichtung, daher ist \fBpb=4,lp=4,lc=0\fP +für LZMA2 passend (2^4=16). +.IP \(bu 3 +RISC\-V\-Code hat eine 2\-Byte\- oder 4\-Byte\-Ausrichtung, abhängig davon, ob die +Datei 16\-bit\-komprimierte Instruktionen enthält (die C\-Erweiterung). Wenn +16\-bit\-Instruktionen verwendet werden, ist \fBpb=2,lp=1,lc=3\fP oder +\fBpb=1,lp=1,lc=3\fP passend. Wenn keine 16\-bit\-Instruktionen vorhanden sind, +ist \fBpb=2,lp=2,lc=2\fP am besten. Mit \fBreadelf \-h\fP können Sie überprüfen, ob +»RVC« in der »Flags«\-Zeile auftritt. +.IP \(bu 3 +ARM64 hat stets eine 4\-Byte\-Ausrichtung, daher ist \fBpb=2,lp=2,lc=2\fP am +besten. +.IP \(bu 3 +Der x86\-Filter stellt eine Ausnahme dar. Es ist üblicherweise eine gute +Wahl, bei den Voreinstellungen von LZMA2 (\fBpb=2,lp=0,lc=3\fP) zu bleiben, +wenn Sie ausführbare x86\-Dateien komprimieren +.RE +.IP "" +Alle BCJ\-Filter unterstützen die gleichen \fIOptionen\fP: +.RS +.TP +\fBstart=\fP\fIVersatz\fP +gibt den Start\-\fIVersatz\fP an, der bei der Umwandlung zwischen relativen und +absoluten Adressen verwendet wird. Der \fIVersatz\fP muss ein Vielfaches der +Filterausrichtung sein (siehe die Tabelle oben). Der Standardwert ist 0. In +der Praxis ist dieser Standardwert gut; die Angabe eines benutzerdefinierten +\fIVersatzes\fP ist fast immer unnütz. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIOptionen\fP] +fügt den Delta\-Filter zur Filterkette hinzu. Der Delta\-Filter kann nicht als +letzter Filter in der Filterkette verwendet werden. +.IP "" +Gegenwärtig wird nur eine einfache, Byte\-bezogene Delta\-Berechnung +unterstützt. Beim Komprimieren von zum Beispiel unkomprimierten +Bitmap\-Bildern oder unkomprimierten PCM\-Audiodaten kann es jedoch sinnvoll +sein. Dennoch können für spezielle Zwecke entworfene Algorithmen deutlich +bessere Ergebnisse als Delta und LZMA2 liefern. Dies trifft insbesondere auf +Audiodaten zu, die sich zum Beispiel mit \fBflac\fP(1) schneller und besser +komprimieren lassen. +.IP "" +Unterstützte \fIOptionen\fP: +.RS +.TP +\fBdist=\fP\fIAbstand\fP +gibt den \fIAbstand\fP der Delta\-Berechnung in Byte an. Zulässige Werte für den +\fIAbstand\fP sind 1 bis 256. Der Vorgabewert ist 1. +.IP "" +Zum Beispiel wird mit \fBdist=2\fP und der 8\-Byte\-Eingabe A1 B1 A2 B3 A3 B5 A4 +B7 die Ausgabe A1 B1 01 02 01 02 01 02 sein. +.RE +. +.SS "Andere Optionen" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +unterdrückt Warnungen und Hinweise. Geben Sie dies zweimal an, um auch +Fehlermeldungen zu unterdrücken. Diese Option wirkt sich nicht auf den +Exit\-Status aus. Das bedeutet, das selbst bei einer unterdrückten Warnung +der Exit\-Status zur Anzeige einer Warnung dennoch verwendet wird. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +bewirkt ausführliche Ausgaben. Wenn die Standardfehlerausgabe mit einem +Terminal verbunden ist, zeigt \fBxz\fP den Fortschritt an. Durch zweimalige +Angabe von \fB\-\-verbose\fP wird die Ausgabe noch ausführlicher. +.IP "" +Der Fortschrittsanzeiger stellt die folgenden Informationen dar: +.RS +.IP \(bu 3 +Der Prozentsatz des Fortschritts wird angezeigt, wenn die Größe der +Eingabedatei bekannt ist. Das bedeutet, dass der Prozentsatz in +Weiterleitungen (Pipes) nicht angezeigt werden kann. +.IP \(bu 3 +Menge der erzeugten komprimierten Daten (bei der Kompression) oder der +verarbeiteten Daten (bei der Dekompression). +.IP \(bu 3 +Menge der verarbeiteten unkomprimierten Daten (bei der Kompression) oder der +erzeugten Daten (bei der Dekompression). +.IP \(bu 3 +Kompressionsverhältnis, das mittels Dividieren der Menge der bisher +komprimierten Daten durch die Menge der bisher verarbeiteten unkomprimierten +Daten ermittelt wird. +.IP \(bu 3 +Kompressions\- oder Dekompressionsgeschwindigkeit. Diese wird anhand der +Menge der unkomprimierten verarbeiteten Daten (bei der Kompression) oder der +Menge der erzeugten Daten (bei der Dekompression) pro Sekunde gemessen. Die +Anzeige startet einige Sekunden nachdem \fBxz\fP mit der Verarbeitung der Datei +begonnen hat. +.IP \(bu 3 +Die vergangene Zeit im Format M:SS oder H:MM:SS. +.IP \(bu 3 +Die geschätzte verbleibende Zeit wird nur angezeigt, wenn die Größe der +Eingabedatei bekannt ist und bereits einige Sekunden vergangen sind, nachdem +\fBxz\fP mit der Verarbeitung der Datei begonnen hat. Die Zeit wird in einem +weniger präzisen Format ohne Doppelpunkte angezeigt, zum Beispiel 2 min 30 +s. +.RE +.IP "" +Wenn die Standardfehlerausgabe kein Terminal ist, schreibt \fBxz\fP mit +\fB\-\-verbose\fP nach dem Komprimieren oder Dekomprimieren der Datei in einer +einzelnen Zeile den Dateinamen, die komprimierte Größe, die unkomprimierte +Größe, das Kompressionsverhältnis und eventuell auch die Geschwindigkeit und +die vergangene Zeit in die Standardfehlerausgabe. Die Geschwindigkeit und +die vergangene Zeit werden nur angezeigt, wenn der Vorgang mindestens ein +paar Sekunden gedauert hat. Wurde der Vorgang nicht beendet, zum Beispiel +weil ihn der Benutzer abgebrochen hat, wird außerdem der Prozentsatz des +erreichten Verarbeitungsfortschritts aufgenommen, sofern die Größe der +Eingabedatei bekannt ist. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +setzt den Exit\-Status nicht auf 2, selbst wenn eine Bedingung erfüllt ist, +die eine Warnung gerechtfertigt hätte. Diese Option wirkt sich nicht auf die +Ausführlichkeitsstufe aus, daher müssen sowohl \fB\-\-quiet\fP als auch +\fB\-\-no\-warn\fP angegeben werden, um einerseits keine Warnungen anzuzeigen und +andererseits auch den Exit\-Status nicht zu ändern. +.TP +\fB\-\-robot\fP +gibt Meldungen in einem maschinenlesbaren Format aus. Dadurch soll das +Schreiben von Frontends erleichtert werden, die \fBxz\fP anstelle von Liblzma +verwenden wollen, was in verschiedenen Skripten der Fall sein kann. Die +Ausgabe mit dieser aktivierten Option sollte über mehrere +\fBxz\fP\-Veröffentlichungen stabil sein. Details hierzu finden Sie im Abschnitt +\fBROBOTER\-MODUS\fP. +.TP +\fB\-\-info\-memory\fP +zeigt in einem menschenlesbaren Format an, wieviel physischen Speicher (RAM) +und wie viele Prozessor\-Threads das System nach Annahme von \fBxz\fP hat, sowie +die Speicherbedarfsbegrenzung für Kompression und Dekompression, und beendet +das Programm erfolgreich. +.TP +\fB\-h\fP, \fB\-\-help\fP +zeigt eine Hilfemeldung mit den am häufigsten genutzten Optionen an und +beendet das Programm erfolgreich. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +zeigt eine Hilfemeldung an, die alle Funktionsmerkmale von \fBxz\fP beschreibt +und beendet das Programm erfolgreich. +.TP +\fB\-V\fP, \fB\-\-version\fP +zeigt die Versionsnummer von \fBxz\fP und Liblzma in einem menschenlesbaren +Format an. Um eine maschinell auswertbare Ausgabe zu erhalten, geben Sie +\fB\-\-robot\fP vor \fB\-\-version\fP an. +. +.SH ROBOTER\-MODUS +Der Roboter\-Modus wird mit der Option \fB\-\-robot\fP aktiviert. Er bewirkt, dass +die Ausgabe von \fBxz\fP leichter von anderen Programmen ausgewertet werden +kann. Gegenwärtig wird \fB\-\-robot\fP nur zusammen mit \fB\-\-list\fP, +\fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP und \fB\-\-version\fP unterstützt. In der +Zukunft wird dieser Modus auch für Kompression und Dekompression +unterstützt. +. +.SS Listenmodus +\fBxz \-\-robot \-\-list\fP verwendet eine durch Tabulatoren getrennte Ausgabe. In +der ersten Spalte jeder Zeile bezeichnet eine Zeichenkette den Typ der +Information, die in dieser Zeile enthalten ist: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Dies ist stets die erste Zeile, wenn eine Datei aufgelistet wird. Die zweite +Spalte in der Zeile enthält den Dateinamen. +.TP +\fBfile\fP +Diese Zeile enthält allgemeine Informationen zur \fB.xz\fP\-Datei. Diese Zeile +wird stets nach der \fBname\fP\-Zeile ausgegeben. +.TP +\fBstream\fP +Dieser Zeilentyp wird nur verwendet, wenn \fB\-\-verbose\fP angegeben wurde. Es +gibt genau so viele \fBstream\fP\-Zeilen, wie Datenströme in der \fB.xz\fP\-Datei +enthalten sind. +.TP +\fBblock\fP +Dieser Zeilentyp wird nur verwendet, wenn \fB\-\-verbose\fP angegeben wurde. Es +gibt so viele \fBblock\fP\-Zeilen, wie Blöcke in der \fB.xz\fP\-Datei. Die +\fBblock\fP\-Zeilen werden nach allen \fBstream\fP\-Zeilen angezeigt; verschiedene +Zeilentypen werden nicht verschachtelt. +.TP +\fBsummary\fP +Dieser Zeilentyp wird nur verwendet, wenn \fB\-\-verbose\fP zwei Mal angegeben +wurde. Diese Zeile wird nach allen \fBblock\fP\-Zeilen ausgegeben. Wie die +\fBfile\fP\-Zeile enthält die \fBsummary\fP\-Zeile allgemeine Informationen zur +\&\fB.xz\fP\-Datei. +.TP +\fBtotals\fP +Diese Zeile ist immer die letzte der Listenausgabe. Sie zeigt die +Gesamtanzahlen und \-größen an. +.PP +Die Spalten der \fBfile\fP\-Zeilen: +.PD 0 +.RS +.IP 2. 4 +Anzahl der Datenströme in der Datei +.IP 3. 4 +Gesamtanzahl der Blöcke in den Datenströmen +.IP 4. 4 +Komprimierte Größe der Datei +.IP 5. 4 +Unkomprimierte Größe der Datei +.IP 6. 4 +Das Kompressionsverhältnis, zum Beispiel \fB0.123\fP. Wenn das Verhältnis über +9.999 liegt, werden drei Minuszeichen (\fB\-\-\-\fP) anstelle des +Kompressionsverhältnisses angezeigt. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Durch Kommata getrennte Liste der Namen der Integritätsprüfungen. Für die +bekannten Überprüfungstypen werden folgende Zeichenketten verwendet: +\fBNone\fP, \fBCRC32\fP, \fBCRC64\fP und \fBSHA\-256\fP. \fBUnknown\-\fP\fIN\fP wird verwendet, +wobei \fIN\fP die Kennung der Überprüfung als Dezimalzahl angibt (ein\- oder +zweistellig). +.IP 8. 4 +Gesamtgröße der Datenstromauffüllung in der Datei +.RE +.PD +.PP +Die Spalten der \fBstream\fP\-Zeilen: +.PD 0 +.RS +.IP 2. 4 +Datenstromnummer (der erste Datenstrom ist 1) +.IP 3. 4 +Anzahl der Blöcke im Datenstrom +.IP 4. 4 +Komprimierte Startposition +.IP 5. 4 +Unkomprimierte Startposition +.IP 6. 4 +Komprimierte Größe (schließt die Datenstromauffüllung nicht mit ein) +.IP 7. 4 +Unkomprimierte Größe +.IP 8. 4 +Kompressionsverhältnis +.IP 9. 4 +Name der Integritätsprüfung +.IP 10. 4 +Größe der Datenstromauffüllung +.RE +.PD +.PP +Die Spalten der \fBblock\fP\-Zeilen: +.PD 0 +.RS +.IP 2. 4 +Anzahl der in diesem Block enthaltenen Datenströme +.IP 3. 4 +Blocknummer relativ zum Anfang des Datenstroms (der erste Block ist 1) +.IP 4. 4 +Blocknummer relativ zum Anfang der Datei +.IP 5. 4 +Komprimierter Startversatz relativ zum Beginn der Datei +.IP 6. 4 +Unkomprimierter Startversatz relativ zum Beginn der Datei +.IP 7. 4 +Komprimierte Gesamtgröße des Blocks (einschließlich Header) +.IP 8. 4 +Unkomprimierte Größe +.IP 9. 4 +Kompressionsverhältnis +.IP 10. 4 +Name der Integritätsprüfung +.RE +.PD +.PP +Wenn \fB\-\-verbose\fP zwei Mal angegeben wurde, werden zusätzliche Spalten in +die \fBblock\fP\-Zeilen eingefügt. Diese werden mit einem einfachen \fB\-\-verbose\fP +nicht angezeigt, da das Ermitteln dieser Informationen viele Suchvorgänge +erfordert und daher recht langsam sein kann: +.PD 0 +.RS +.IP 11. 4 +Wert der Integritätsprüfung in hexadezimaler Notation +.IP 12. 4 +Block\-Header\-Größe +.IP 13. 4 +Block\-Schalter: \fBc\fP gibt an, dass die komprimierte Größe verfügbar ist, und +\fBu\fP gibt an, dass die unkomprimierte Größe verfügbar ist. Falls der +Schalter nicht gesetzt ist, wird stattdessen ein Bindestrich (\fB\-\fP) +angezeigt, um die Länge der Zeichenkette beizubehalten. In Zukunft könnten +neue Schalter am Ende der Zeichenkette hinzugefügt werden. +.IP 14. 4 +Größe der tatsächlichen komprimierten Daten im Block. Ausgeschlossen sind +hierbei die Block\-Header, die Blockauffüllung und die Prüffelder. +.IP 15. 4 +Größe des Speichers (in Byte), der zum Dekomprimieren dieses Blocks mit +dieser \fBxz\fP\-Version benötigt wird. +.IP 16. 4 +Filterkette. Beachten Sie, dass die meisten der bei der Kompression +verwendeten Optionen nicht bekannt sein können, da in den \fB.xz\fP\-Headern nur +die für die Dekompression erforderlichen Optionen gespeichert sind. +.RE +.PD +.PP +Die Spalten der \fBsummary\fP\-Zeilen: +.PD 0 +.RS +.IP 2. 4 +Größe des Speichers (in Byte), der zum Dekomprimieren dieser Datei mit +dieser \fBxz\fP\-Version benötigt wird. +.IP 3. 4 +\fByes\fP oder \fBno\fP geben an, ob in allen Block\-Headern sowohl die +komprimierte als auch die unkomprimierte Größe gespeichert ist. +.PP +\fISeit\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Minimale \fBxz\fP\-Version, die zur Dekompression der Datei erforderlich ist +.RE +.PD +.PP +Die Spalten der \fBtotals\fP\-Zeile: +.PD 0 +.RS +.IP 2. 4 +Anzahl der Datenströme +.IP 3. 4 +Anzahl der Blöcke +.IP 4. 4 +Komprimierte Größe +.IP 5. 4 +Unkomprimierte Größe +.IP 6. 4 +Durchschnittliches Kompressionsverhältnis +.IP 7. 4 +Durch Kommata getrennte Liste der Namen der Integritätsprüfungen, die in den +Dateien präsent waren. +.IP 8. 4 +Größe der Datenstromauffüllung +.IP 9. 4 +Anzahl der Dateien. Dies dient dazu, die Reihenfolge der vorigen Spalten an +die in den \fBfile\fP\-Zeilen anzugleichen. +.PD +.RE +.PP +Wenn \fB\-\-verbose\fP zwei Mal angegeben wird, werden zusätzliche Spalten in die +\fBtotals\fP\-Zeile eingefügt: +.PD 0 +.RS +.IP 10. 4 +Maximale Größe des Speichers (in Byte), der zum Dekomprimieren der Dateien +mit dieser \fBxz\fP\-Version benötigt wird. +.IP 11. 4 +\fByes\fP oder \fBno\fP geben an, ob in allen Block\-Headern sowohl die +komprimierte als auch die unkomprimierte Größe gespeichert ist. +.PP +\fISeit\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Minimale \fBxz\fP\-Version, die zur Dekompression der Datei erforderlich ist +.RE +.PD +.PP +Zukünftige Versionen könnten neue Zeilentypen hinzufügen, weiterhin könnten +auch in den vorhandenen Zeilentypen weitere Spalten hinzugefügt werden, aber +die existierenden Spalten werden nicht geändert. +. +.SS Filterhilfe +\fBxz \-\-robot \-\-filters\-help\fP gibt die unterstützten Filter im folgenden +Format aus: +.PP +\fIFilter\fP\fB:\fP\fIOption\fP\fB=<\fP\fIWert\fP\fB>,\fP\fIOption\fP\fB=<\fP\fIWert\fP\fB>\fP +… +.TP +\fIFilter\fP +Name des Filters +.TP +\fIOption\fP +Name der filterspezifischen Option +.TP +\fIWert\fP +Der numerische \fIWert\fP erscheint als Bereich +\fB<\fP\fIMinimum\fP\fB\-\fP\fIMaximum\fP\fB>\fP. Die Auswahl des +Zeichenketten\-\fIWert\fPs wird in \fB< >\fP eingeschlossen und durch \fB|\fP +getrennt. +.PP +Jeder Filter wird in einer separaten Zeile ausgegeben. +. +.SS "Informationen zur Speicherbedarfsbegrenzung" +\fBxz \-\-robot \-\-info\-memory\fP gibt eine einzelne Zeile mit mehreren durch +Tabulatoren getrennten Spalten aus: +.IP 1. 4 +Gesamter physischer Speicher (RAM) in Byte. +.IP 2. 4 +Speicherbedarfsbegrenzung für die Kompression in Byte +(\fB\-\-memlimit\-compress\fP). Ein spezieller Wert von \fB0\fP bezeichnet die +Standardeinstellung, die im Einzelthread\-Modus bedeutet, dass keine +Begrenzung vorhanden ist. +.IP 3. 4 +Speicherbedarfsbegrenzung für die Dekompression in Byte +(\fB\-\-memlimit\-decompress\fP). Ein spezieller Wert von \fB0\fP bezeichnet die +Standardeinstellung, die im Einzelthread\-Modus bedeutet, dass keine +Begrenzung vorhanden ist. +.IP 4. 4 +Seit \fBxz\fP 5.3.4alpha: Die Speichernutzung für Multithread\-Dekompression in +Byte (\fB\-\-memlimit\-mt\-decompress\fP). Dies ist niemals \fB0\fP, da ein +systemspezifischer Vorgabewert (gezeigt in Spalte 5) verwendet wird, falls +keine Grenze ausdrücklich angegeben wurde. Dies ist außerdem niemals größer +als der Wert in in Spalte 3, selbst wenn mit \fB\-\-memlimit\-mt\-decompress\fP ein +größerer Wert angegeben wurde. +.IP 5. 4 +Seit \fBxz\fP 5.3.4alpha: Eine systemspezifisch vorgegebene Begrenzung des +Speicherverbrauchs, die zur Begrenzung der Anzahl der Threads beim +Komprimieren mit automatischer Anzahl der Threads (\fB\-\-threads=0\fP) und wenn +keine Speicherbedarfsbegrenzung angegeben wurde (\fB\-\-memlimit\-compress\fP) +verwendet wird. Dies wird auch als Standardwert für +\fB\-\-memlimit\-mt\-decompress\fP verwendet. +.IP 6. 4 +Seit \fBxz\fP 5.3.4alpha: Anzahl der verfügbaren Prozessorthreads. +.PP +In der Zukunft könnte die Ausgabe von \fBxz \-\-robot \-\-info\-memory\fP weitere +Spalten enthalten, aber niemals mehr als eine einzelne Zeile. +. +.SS Version +\fBxz \-\-robot \-\-version\fP gibt die Versionsnummern von \fBxz\fP und Liblzma im +folgenden Format aus: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Hauptversion. +.TP +\fIYYY\fP +Unterversion. Gerade Zahlen bezeichnen eine stabile Version. Ungerade Zahlen +bezeichnen Alpha\- oder Betaversionen. +.TP +\fIZZZ\fP +Patch\-Stufe für stabile Veröffentlichungen oder einfach nur ein Zähler für +Entwicklungsversionen. +.TP +\fIS\fP +Stabilität. 0 ist Alpha, 1 ist Beta und 2 ist stabil. \fIS\fP sollte immer 2 +sein, wenn \fIYYY\fP eine gerade Zahl ist. +.PP +\fIXYYYZZZS\fP sind in beiden Zeilen gleich, sofern \fBxz\fP und Liblzma aus der +gleichen Veröffentlichung der XZ\-Utils stammen. +.PP +Beispiele: 4.999.9beta ist \fB49990091\fP und 5.0.0 is \fB50000002\fP. +. +.SH EXIT\-STATUS +.TP +\fB0\fP +Alles ist in Ordnung. +.TP +\fB1\fP +Ein Fehler ist aufgetreten. +.TP +\fB2\fP +Es ist etwas passiert, das eine Warnung rechtfertigt, aber es sind keine +tatsächlichen Fehler aufgetreten. +.PP +In die Standardausgabe geschriebene Hinweise (keine Warnungen oder Fehler), +welche den Exit\-Status nicht beeinflussen. +. +.SH UMGEBUNGSVARIABLEN +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP wertet eine durch Leerzeichen getrennte Liste von Optionen in den +Umgebungsvariablen \fBXZ_DEFAULTS\fP und \fBXZ_OPT\fP aus (in dieser Reihenfolge), +bevor die Optionen aus der Befehlszeile ausgewertet werden. Beachten Sie, +dass beim Auswerten der Umgebungsvariablen nur Optionen berücksichtigt +werden; alle Einträge, die keine Optionen sind, werden stillschweigend +ignoriert. Die Auswertung erfolgt mit \fBgetopt_long\fP(3), welches auch für +die Befehlszeilenargumente verwendet wird. +.PP +\fBWarnung:\fP Durch Setzen dieser Umgebungsvariablen könnte man effektiv +Programme und Skripte modifizieren, die \fBxz\fP ausführen. Meist ist es +sicher, die Speichernutzungsbegrenzung und Kompressionsoptionen über die +Umgebungsvariablen zu setzen. Dennoch können einige Optionen Skripte +beeinflussen. Ein typisches Beispiel ist die Option \fB\-\-help\fP, die einen +Hilfetext anzeigt, anstatt eine Datei zu komprimieren oder zu +dekomprimieren. Weniger augenfällige Beispiele sind die Optionen \fB\-\-quiet\fP +und \fB\-\-verbose\fP. In vielen Fällen funktioniert es gut, den +Fortschrittsindikator mit \fB\-\-verbose\fP zu aktivieren, aber in einigen +Situationen können die zusätzlichen Meldungen Probleme verursachen. Die +Ausführlichkeitsstufe beeinflusst auch das Verhalten von \fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Benutzerspezifische oder systemweite Standardoptionen. Typischerweise werden +diese in einem Shell\-Initialisierungsskript gesetzt, um die +Speicherbedarfsbegrenzung von \fBxz\fP standardmäßig zu aktivieren oder die +Anzahl der Threads festzulegen. Außer bei Shell\-Initialisierungsskripten und +in ähnlichen Spezialfällen sollte die Variable \fBXZ_DEFAULTS\fP in Skripten +niemals gesetzt oder außer Kraft gesetzt werden. +.TP +\fBXZ_OPT\fP +Dies dient der Übergabe von Optionen an \fBxz\fP, wenn es nicht möglich ist, +die Optionen direkt in der Befehlszeile von \fBxz\fP zu übergeben. Dies ist der +Fall, wenn \fBxz\fP von einem Skript oder Dienstprogramm ausgeführt wird, zum +Beispiel GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Skripte können \fBXZ_OPT\fP zum Beispiel zum Setzen skriptspezifischer +Standard\-Kompressionsoptionen verwenden. Es ist weiterhin empfehlenswert, +Benutzern die Außerkraftsetzung von \fBXZ_OPT\fP zu erlauben, falls dies +angemessen ist. Zum Beispiel könnte in \fBsh\fP(1)\-Skripten Folgendes stehen: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "KOMPATIBILITÄT ZU DEN LZMA\-UTILS" +Die Befehlszeilensyntax von \fBxz\fP ist praktisch eine Obermenge der von +\fBlzma\fP, \fBunlzma\fP und \fBlzcat\fP in den LZMA\-Utils der Versionen 4.32.x. In +den meisten Fällen sollte es möglich sein, die LZMA\-Utils durch die XZ\-Utils +zu ersetzen, ohne vorhandene Skripte ändern zu müssen. Dennoch gibt es +einige Inkompatibilitäten, die manchmal Probleme verursachen können. +. +.SS "Voreinstellungsstufen zur Kompression" +Die Nummerierung der Voreinstellungsstufen der Kompression ist in \fBxz\fP und +den LZMA\-Utils unterschiedlich. Der wichtigste Unterschied ist die Zuweisung +der Wörterbuchgrößen zu den verschiedenen Voreinstellungsstufen. Die +Wörterbuchgröße ist etwa gleich dem Speicherbedarf bei der Dekompression. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Stufe;xz;LZMA\-Utils +\-0;256 KiB;nicht verfügbar +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Die Unterschiede in der Wörterbuchgröße beeinflussen auch den Speicherbedarf +bei der Kompression, aber es gibt noch einige andere Unterschiede zwischen +den LZMA\-Utils und den XZ\-Utils, die die Kluft noch vergrößern: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Stufe;xz;LZMA\-Utils 4.32.x +\-0;3 MiB;nicht verfügbar +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Die standardmäßige Voreinstellungsstufe in den LZMA\-Utils ist \fB\-7\fP, während +diese in den XZ\-Utils \fB\-6\fP ist, daher verwenden beide standardmäßig ein 8 +MiB großes Wörterbuch. +. +.SS "Vor\- und Nachteile von .lzma\-Dateien als Datenströme" +Die unkomprimierte Größe der Datei kann in den \fB.lzma\fP\-Headern gespeichert +werden. Die LZMA\-Utils tun das beim Komprimieren gewöhnlicher Dateien. Als +Alternative kann die unkomprimierte Größe als unbekannt markiert und eine +Nutzdatenende\-Markierung (end\-of\-payload) verwendet werden, um anzugeben, wo +der Dekompressor stoppen soll. Die LZMA\-Utils verwenden diese Methode, wenn +die unkomprimierte Größe unbekannt ist, was beispielsweise in Pipes +(Befehlsverkettungen) der Fall ist. +.PP +\fBxz\fP unterstützt die Dekompression von \fB.lzma\fP\-Dateien mit oder ohne +Nutzdatenende\-Markierung, aber alle von \fBxz\fP erstellten \fB.lzma\fP\-Dateien +verwenden diesen Nutzdatenende\-Markierung, wobei die unkomprimierte Größe in +den \fB.lzma\fP\-Headern als unbekannt markiert wird. Das könnte in einigen +unüblichen Situationen ein Problem sein. Zum Beispiel könnte ein +\&\fB.lzma\fP\-Dekompressor in einem Gerät mit eingebettetem System nur mit +Dateien funktionieren, deren unkomprimierte Größe bekannt ist. Falls Sie auf +dieses Problem stoßen, müssen Sie die LZMA\-Utils oder das LZMA\-SDK +verwenden, um \fB.lzma\fP\-Dateien mit bekannter unkomprimierter Größe zu +erzeugen. +. +.SS "Nicht unterstützte .lzma\-Dateien" +Das \fB.lzma\fP\-Format erlaubt \fIlc\fP\-Werte bis zu 8 und \fIlp\fP\-Werte bis zu +4. Die LZMA\-Utils können Dateien mit beliebigem \fIlc\fP und \fIlp\fP +dekomprimieren, aber erzeugen immer Dateien mit \fBlc=3\fP und \fBlp=0\fP. Das +Erzeugen von Dateien mit anderem \fIlc\fP und \fIlp\fP ist mit \fBxz\fP und mit dem +LZMA\-SDK möglich. +.PP +Die Implementation des LZMA\-Filters in liblzma setzt voraus, dass die Summe +von \fIlc\fP und \fIlp\fP nicht größer als 4 ist. Daher können \fB.lzma\fP\-Dateien, +welche diese Begrenzung überschreiten, mit \fBxz\fP nicht dekomprimiert werden. +.PP +Die LZMA\-Utils erzeugen nur \fB.lzma\fP\-Dateien mit einer Wörterbuchgröße von +2^\fIn\fP (einer Zweierpotenz), aber akzeptieren Dateien mit einer beliebigen +Wörterbuchgröße. Liblzma akzeptiert nur \fB.lzma\fP\-Dateien mit einer +Wörterbuchgröße von 2^\fIn\fP oder 2^\fIn\fP + 2^(\fIn\fP\-1). Dies dient zum +Verringern von Fehlalarmen beim Erkennen von \fB.lzma\fP\-Dateien. +.PP +Diese Einschränkungen sollten in der Praxis kein Problem sein, da praktisch +alle \fB.lzma\fP\-Dateien mit Einstellungen komprimiert wurden, die Liblzma +akzeptieren wird. +. +.SS "Angehängter Datenmüll" +Bei der Dekompression ignorieren die LZMA\-Utils stillschweigend alles nach +dem ersten \fB.lzma\fP\-Datenstrom. In den meisten Situationen ist das ein +Fehler. Das bedeutet auch, dass die LZMA\-Utils die Dekompression verketteter +\&\fB.lzma\fP\-Dateien nicht unterstützen. +.PP +Wenn nach dem ersten \fB.lzma\fP\-Datenstrom Daten verbleiben, erachtet \fBxz\fP +die Datei als beschädigt, es sei denn, die Option \fB\-\-single\-stream\fP wurde +verwendet. Dies könnte die Ausführung von Skripten beeinflussen, die davon +ausgehen, dass angehängter Datenmüll ignoriert wird. +. +.SH ANMERKUNGEN +. +.SS "Die komprimierte Ausgabe kann variieren" +Die exakte komprimierte Ausgabe, die aus der gleichen unkomprimierten +Eingabedatei erzeugt wird, kann zwischen den Versionen der XZ\-Utils +unterschiedlich sein, selbst wenn die Kompressionsoptionen identisch +sind. Das kommt daher, weil der Kodierer verbessert worden sein könnte +(hinsichtlich schnellerer oder besserer Kompression), ohne das Dateiformat +zu beeinflussen. Die Ausgabe kann sogar zwischen verschiedenen Programmen +der gleichen Version der XZ\-Utils variieren, wenn bei der Erstellung des +Binärprogramms unterschiedliche Optionen verwendet wurden. +.PP +Sobald \fB\-\-rsyncable\fP implementiert wurde, bedeutet das, dass die sich +ergebenden Dateien nicht notwendigerweise mit Rsync abgeglichen werden +können, außer wenn die alte und neue Datei mit der gleichen \fBxz\fP\-Version +erzeugt wurden. Das Problem kann beseitigt werden, wenn ein Teil der +Encoder\-Implementierung eingefroren wird, um die mit Rsync abgleichbare +Ausgabe über \fBxz\fP\-Versionsgrenzen hinweg stabil zu halten. +. +.SS "Eingebettete .xz\-Dekompressoren" +Eingebettete \fB.xz\fP\-Dekompressor\-Implementierungen wie XZ Embedded +unterstützen nicht unbedingt Dateien, die mit anderen Integritätsprüfungen +(\fIPrüfung\fP\-Typen) als \fBnone\fP und \fBcrc32\fP erzeugt wurden. Da +\fB\-\-check=crc64\fP die Voreinstellung ist, müssen Sie \fB\-\-check=none\fP oder +\fB\-\-check=crc32\fP verwenden, wenn Sie Dateien für eingebettete Systeme +erstellen. +.PP +Außerhalb eingebetteter Systeme unterstützen die Dekompressoren des +\&\fB.xz\fP\-Formats alle \fIPrüfung\fP\-Typen oder sind mindestens in der Lage, die +Datei zu dekomprimieren, ohne deren Integrität zu prüfen, wenn die bestimmte +\fIPrüfung\fP nicht verfügbar ist. +.PP +XZ Embedded unterstützt BCJ\-Filter, aber nur mit dem vorgegebenen +Startversatz. +. +.SH BEISPIELE +. +.SS Grundlagen +Komprimiert die Datei \fIfoo\fP mit der Standard\-Kompressionsstufe (\fB\-6\fP) zu +\fIfoo.xz\fP und entfernt \fIfoo\fP nach erfolgreicher Kompression: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +\fIbar.xz\fP in \fIbar\fP dekomprimieren und \fIbar.xz\fP selbst dann nicht löschen, +wenn die Dekompression erfolgreich war: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +\fIbaz.tar.xz\fP mit der Voreinstellung \fB\-4e\fP (\fB\-4 \-\-extreme\fP) erzeugen, was +langsamer ist als die Vorgabe \fB\-6\fP, aber weniger Speicher für Kompression +und Dekompression benötigt (48\ MiB beziehungsweise 5\ MiB): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Eine Mischung aus komprimierten und unkomprimierten Dateien kann mit einem +einzelnen Befehl dekomprimiert in die Standardausgabe geschrieben werden: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Parallele Kompression von vielen Dateien" +Auf GNU\- und *BSD\-Systemen können \fBfind\fP(1) und \fBxargs\fP(1) zum +Parallelisieren der Kompression vieler Dateien verwendet werden: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Die Option \fB\-P\fP von \fBxargs\fP(1) legt die Anzahl der parallelen +\fBxz\fP\-Prozesse fest. Der beste Wert für die Option \fB\-n\fP hängt davon ab, wie +viele Dateien komprimiert werden sollen. Wenn es sich nur um wenige Dateien +handelt, sollte der Wert wahrscheinlich 1 sein; bei Zehntausenden von +Dateien kann 100 oder noch mehr angemessener sein, um die Anzahl der +\fBxz\fP\-Prozesse zu beschränken, die \fBxargs\fP(1) schließlich erzeugen wird. +.PP +Die Option \fB\-T1\fP für \fBxz\fP dient dazu, den Einzelthread\-Modus zu erzwingen, +da \fBxargs\fP(1) zur Steuerung des Umfangs der Parallelisierung verwendet +wird. +. +.SS Roboter\-Modus +Berechnen, wie viel Byte nach der Kompression mehrerer Dateien insgesamt +eingespart wurden: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Ein Skript könnte abfragen wollen, ob es ein \fBxz\fP verwendet, das aktuell +genug ist. Das folgende \fBsh\fP(1)\-Skript prüft, ob die Versionsnummer des +Dienstprogramms \fBxz\fP mindestens 5.0.0 ist. Diese Methode ist zu alten +Beta\-Versionen kompatibel, welche die Option \fB\-\-robot\fP nicht unterstützen: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Ihre Version von Xz ist zu alt." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Eine Speicherbedarfsbegrenzung für die Dekompression mit \fBXZ_OPT\fP setzen, +aber eine bereits gesetzte Begrenzung nicht erhöhen: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Benutzerdefinierte Filterketten für die Kompression" +Der einfachste Anwendungsfall für benutzerdefinierte Filterketten ist die +Anpassung von LZMA2\-Voreinstellungsstufen. Das kann nützlich sein, weil die +Voreinstellungen nur einen Teil der potenziell sinnvollen Kombinationen aus +Kompressionseinstellungen abdecken. +.PP +Die KompCPU\-Spalten der Tabellen aus den Beschreibungen der Optionen \fB\-0\fP … +\fB\-9\fP und \fB\-\-extreme\fP sind beim Anpassen der LZMA2\-Voreinstellungen +nützlich. Diese sind die relevanten Teile aus diesen zwei Tabellen: +.RS +.PP +.TS +tab(;); +c c +n n. +Voreinst.;KomprCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Wenn Sie wissen, dass eine Datei für eine gute Kompression ein etwas +größeres Wörterbuch benötigt (zum Beispiel 32 MiB), aber Sie sie schneller +komprimieren wollen, als dies mit \fBxz \-8\fP geschehen würde, kann eine +Voreinstellung mit einem niedrigen KompCPU\-Wert (zum Beispiel 1) dahingehend +angepasst werden, ein größeres Wörterbuch zu verwenden: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Mit bestimmten Dateien kann der obige Befehl schneller sein als \fBxz \-6\fP, +wobei die Kompression deutlich besser wird. Dennoch muss betont werden, dass +nur wenige Dateien von einem größeren Wörterbuch profitieren, wenn der +KompCPU\-Wert niedrig bleibt. Der offensichtlichste Fall, in dem ein größeres +Wörterbuch sehr hilfreich sein kann, ist ein Archiv, das einander sehr +ähnliche Dateien enthält, die jeweils wenigstens einige Megabyte groß +sind. Das Wörterbuch muss dann deutlich größer sein als die einzelne Datei, +damit LZMA2 den größtmöglichen Vorteil aus den Ähnlichkeiten der aufeinander +folgenden Dateien zieht. +.PP +Wenn hoher Speicherbedarf für Kompression und Dekompression kein Problem ist +und die zu komprimierende Datei mindestens einige Hundert Megabyte groß ist, +kann es sinnvoll sein, ein noch größeres Wörterbuch zu verwenden, als die 64 +MiB, die mit \fBxz \-9\fP verwendet werden würden: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Die Verwendung von \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) wie im obigen Beispiel +kann nützlich sein, um den Speicherbedarf für Kompressor und Dekompressor zu +sehen. Denken Sie daran, dass ein Wörterbuch, das größer als die +unkomprimierte Datei ist, Speicherverschwendung wäre. Daher ist der obige +Befehl für kleine Dateien nicht sinnvoll. +.PP +Manchmal spielt die Kompressionszeit keine Rolle, aber der Speicherbedarf +bei der Dekompression muss gering gehalten werden, zum Beispiel um die Datei +auf eingebetteten Systemen dekomprimieren zu können. Der folgende Befehl +verwendet \fB\-6e\fP (\fB\-6 \-\-extreme\fP) als Basis und setzt die Wörterbuchgröße +auf nur 64\ KiB. Die sich ergebende Datei kann mit XZ Embedded (aus diesem +Grund ist dort \fB\-\-check=crc32\fP) mit nur etwa 100\ KiB Speicher +dekomprimiert werden. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Wenn Sie so viele Byte wie möglich herausquetschen wollen, kann die +Anpassung der Anzahl der literalen Kontextbits (\fIlc\fP) und der Anzahl der +Positionsbits (\fIpb\fP) manchmal hilfreich sein. Auch die Anpassung der Anzahl +der literalen Positionsbits (\fIlp\fP) könnte helfen, aber üblicherweise sind +\fIlc\fP und \fIpb\fP wichtiger. Wenn ein Quellcode\-Archiv zum Beispiel +hauptsächlich ASCII\-Text enthält, könnte ein Aufruf wie der folgende eine +etwas kleinere Datei (etwa 0,1\ %) ergeben als mit \fBxz \-6e\fP (versuchen Sie +es auch \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Die Verwendung eines anderen Filters mit LZMA2 kann die Kompression bei +verschiedenen Dateitypen verbessern. So könnten Sie eine gemeinsam genutzte +Bibliothek der Architekturen x86\-32 oder x86\-64 mit dem BCJ\-Filter für x86 +komprimieren: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Beachten Sie, dass die Reihenfolge der Filteroptionen von Bedeutung +ist. Falls \fB\-\-x86\fP nach \fB\-\-lzma2\fP angegeben wird, gibt \fBxz\fP einen Fehler +aus, weil nach LZMA2 kein weiterer Filter sein darf und auch weil der +BCJ\-Filter für x86 nicht als letzter Filter in der Filterkette gesetzt +werden darf. +.PP +Der Delta\-Filter zusammen mit LZMA2 kann bei Bitmap\-Bildern gute Ergebnisse +liefern. Er sollte üblicherweise besser sein als PNG, welches zwar einige +fortgeschrittene Filter als ein simples delta bietet, aber für die +eigentliche Kompression »Deflate« verwendet. +.PP +Das Bild muss in einem unkomprimierten Format gespeichert werden, zum +Beispiel als unkomprimiertes TIFF. Der Abstandsparameter des Delta\-Filters +muss so gesetzt werden, dass er der Anzahl der Bytes pro Pixel im Bild +entspricht. Zum Beispiel erfordert ein 24\-Bit\-RGB\-Bitmap \fBdist=3\fP, außerdem +ist es gut, \fBpb=0\fP an LZMA2 zu übergeben, um die 3\-Byte\-Ausrichtung zu +berücksichtigen: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Wenn sich mehrere Bilder in einem einzelnen Archiv befinden (zum Beispiel\& +\&\fB.tar\fP), funktioniert der Delta\-Filter damit auch, sofern alle Bilder im +Archiv die gleiche Anzahl Bytes pro Pixel haben. +. +.SH "SIEHE AUCH" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA\-SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xzcat.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xzcat.1 new file mode 100644 index 0000000000000000000000000000000000000000..39e92ce91c266281499195e6ac04416517932d31 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xzcat.1 @@ -0,0 +1,2117 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" German translation for xz-man. +.\" Mario Blättermann , 2015, 2019-2020, 2022-2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 "8. März 2025" Tukaani XZ\-Dienstprogramme +. +.SH BEZEICHNUNG +xz, unxz, xzcat, lzma, unlzma, lzcat \- .xz\- und .lzma\-Dateien komprimieren +oder dekomprimieren +. +.SH ÜBERSICHT +\fBxz\fP [\fIOption…\fP] [\fIDatei…\fP] +. +.SH BEFEHLSALIASE +\fBunxz\fP ist gleichbedeutend mit \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP ist gleichbedeutend mit \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP ist gleichbedeutend mit \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP ist gleichbedeutend mit \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP ist gleichbedeutend mit \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Wenn Sie Skripte schreiben, die Dateien dekomprimieren, sollten Sie stets +den Namen \fBxz\fP mit den entsprechenden Argumenten (\fBxz \-d\fP oder \fBxz \-dc\fP) +anstelle der Namen \fBunxz\fP und \fBxzcat\fP verwenden. +. +.SH BESCHREIBUNG +\fBxz\fP ist ein Allzweckwerkzeug zur Datenkompression, dessen +Befehlszeilensyntax denen von \fBgzip\fP(1) und \fBbzip2\fP(1) ähnelt. Das native +Dateiformat ist das \fB.xz\fP\-Format, aber das veraltete, von den +LZMA\-Dienstprogrammen verwendete Format sowie komprimierte Rohdatenströme +ohne Containerformat\-Header werden ebenfalls unterstützt. Außerdem wird die +Dekompression des von \fBlzip\fP verwendeten \fB.lz\fP\-Formats unterstützt. +.PP +\fBxz\fP komprimiert oder dekomprimiert jede \fIDatei\fP entsprechend des +gewählten Vorgangsmodus. Falls entweder \fB\-\fP oder keine Datei angegeben ist, +liest \fBxz\fP aus der Standardeingabe und leitet die verarbeiteten Dateien in +die Standardausgabe. Wenn die Standardausgabe kein Terminal ist, verweigert +\fBxz\fP das Schreiben komprimierter Daten in die Standardausgabe. Dabei wird +eine Fehlermeldung angezeigt und die \fIDatei\fP übersprungen. Ebenso +verweigert \fBxz\fP das Lesen komprimierter Daten aus der Standardeingabe, wenn +diese ein Terminal ist. +.PP +\fIDateien\fP, die nicht als \fB\-\fP angegeben sind, werden in eine neue Datei +geschrieben, deren Name aus dem Namen der Quell\-\fIDatei\fP abgeleitet wird +(außer wenn \fB\-\-stdout\fP angegeben ist): +.IP \(bu 3 +Bei der Kompression wird das Suffix des Formats der Zieldatei (\fB.xz\fP oder +\&\fB.lzma\fP) an den Namen der Quelldatei angehängt und so der Name der +Zieldatei gebildet. +.IP \(bu 3 +Bei der Dekompression wird das Suffix \fB.xz\fP, \fB.lzma\fP oder \fB.lz\fP vom +Dateinamen entfernt und so der Name der Zieldatei gebildet. Außerdem erkennt +\fBxz\fP die Suffixe \fB.txz\fP und \fB.tlz\fP und ersetzt diese durch \fB.tar\fP. +.PP +Wenn die Zieldatei bereits existiert, wird eine Fehlermeldung angezeigt und +die \fIDatei\fP übersprungen. +.PP +Außer beim Schreiben in die Standardausgabe zeigt \fBxz\fP eine Warnung an und +überspringt die \fIDatei\fP, wenn eine der folgenden Bedingungen zutreffend +ist: +.IP \(bu 3 +Die \fIDatei\fP ist keine reguläre Datei. Symbolischen Verknüpfungen wird nicht +gefolgt und diese daher nicht zu den regulären Dateien gezählt. +.IP \(bu 3 +Die \fIDatei\fP hat mehr als eine harte Verknüpfung. +.IP \(bu 3 +Für die \fIDatei\fP ist das »setuid«\-, »setgid«\- oder »sticky«\-Bit gesetzt. +.IP \(bu 3 +Der Aktionsmodus wird auf Kompression gesetzt und die \fIDatei\fP hat bereits +das Suffix des Zieldateiformats (\fB.xz\fP oder \fB.txz\fP beim Komprimieren in +das \fB.xz\fP\-Format und \fB.lzma\fP oder \fB.tlz\fP beim Komprimieren in das +\&\fB.lzma\fP\-Format). +.IP \(bu 3 +Der Aktionsmodus wird auf Dekompression gesetzt und die \fIDatei\fP hat nicht +das Suffix eines der unterstützten Zieldateiformate (\fB.xz\fP, \fB.txz\fP, +\&\fB.lzma\fP, \fB.tlz\fP oder \fB.lz\fP). +.PP +Nach erfolgreicher Kompression oder Dekompression der \fIDatei\fP kopiert \fBxz\fP +Eigentümer, Gruppe, Zugriffsrechte, Zugriffszeit und Änderungszeit aus der +Ursprungs\-\fIDatei\fP in die Zieldatei. Sollte das Kopieren der Gruppe +fehlschlagen, werden die Zugriffsrechte so angepasst, dass jenen Benutzern +der Zugriff auf die Zieldatei verwehrt bleibt, die auch keinen Zugriff auf +die Ursprungs\-\fIDatei\fP hatten. Das Kopieren anderer Metadaten wie +Zugriffssteuerlisten oder erweiterter Attribute wird von \fBxz\fP noch nicht +unterstützt. +.PP +Sobald die Zieldatei erfolgreich geschlossen wurde, wird die +Ursprungs\-\fIDatei\fP entfernt. Dies wird durch die Option \fB\-\-keep\fP +verhindert. Die Ursprungs\-\fIDatei\fP wird niemals entfernt, wenn die Ausgabe +in die Standardausgabe geschrieben wird oder falls ein Fehler auftritt. +.PP +Durch Senden der Signale \fBSIGINFO\fP oder \fBSIGUSR1\fP an den \fBxz\fP\-Prozess +werden Fortschrittsinformationen in den Fehlerkanal der Standardausgabe +geleitet. Dies ist nur eingeschränkt hilfreich, wenn die +Standardfehlerausgabe ein Terminal ist. Mittels \fB\-\-verbose\fP wird ein +automatisch aktualisierter Fortschrittsanzeiger angezeigt. +. +.SS Speicherbedarf +In Abhängigkeit von den gewählten Kompressionseinstellungen bewegt sich der +Speicherverbrauch zwischen wenigen hundert Kilobyte und mehreren +Gigabyte. Die Einstellungen bei der Kompression einer Datei bestimmen dabei +den Speicherbedarf bei der Dekompression. Die Dekompression benötigt +üblicherweise zwischen 5\ % und 20\ % des Speichers, der bei der Kompression +der Datei erforderlich war. Beispielsweise benötigt die Dekompression einer +Datei, die mit \fBxz \-9\fP komprimiert wurde, gegenwärtig etwa 65\ MiB +Speicher. Es ist jedoch auch möglich, dass \fB.xz\fP\-Dateien mehrere Gigabyte +an Speicher zur Dekompression erfordern. +.PP +Insbesondere für Benutzer älterer Systeme wird eventuell ein sehr großer +Speicherbedarf ärgerlich sein. Um unangenehme Überraschungen zu vermeiden, +verfügt \fBxz\fP über eine eingebaute Begrenzung des Speicherbedarfs, die +allerdings in der Voreinstellung deaktiviert ist. Zwar verfügen einige +Betriebssysteme über eingebaute Möglichkeiten zur prozessabhängigen +Speicherbegrenzung, doch diese sind zu unflexibel (zum Beispiel kann +\fBulimit\fP(1) beim Begrenzen des virtuellen Speichers \fBmmap\fP(2) +beeinträchtigen). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Die Begrenzung des Speicherbedarfs kann mit der Befehlszeilenoption +\fB\-\-memlimit=\fP\fIBegrenzung\fP aktiviert werden. Oft ist es jedoch bequemer, +die Begrenzung durch Setzen der Umgebungsvariable \fBXZ_DEFAULTS\fP +standardmäßig zu aktivieren, zum Beispiel +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Die Begrenzungen können getrennt für +Kompression und Dekompression mittels \fB\-\-memlimit\-compress=\fP\fIBegrenzung\fP +und \fB\-\-memlimit\-decompress=\fP\fIBegrenzung\fP festgelegt werden. Die Verwendung +einer solchen Option außerhalb der Variable \fBXZ_DEFAULTS\fP ist kaum +sinnvoll, da \fBxz\fP in einer einzelnen Aktion nicht gleichzeitig Kompression +und Dekompression ausführen kann und \fB\-\-memlimit=\fP\fIBegrenzung\fP (oder \fB\-M\fP +\fIBegrenzung\fP) lässt sich einfacher in der Befehlszeile eingeben. +.PP +Wenn die angegebene Speicherbegrenzung bei der Dekompression überschritten +wird, schlägt der Vorgang fehl und \fBxz\fP zeigt eine Fehlermeldung an. Wird +die Begrenzung bei der Kompression überschritten, dann versucht \fBxz\fP die +Einstellungen entsprechend anzupassen, außer wenn \fB\-\-format=raw\fP oder +\fB\-\-no\-adjust\fP angegeben ist. Auf diese Weise schlägt die Aktion nicht fehl, +es sei denn, die Begrenzung wurde sehr niedrig angesetzt. Die Anpassung der +Einstellungen wird schrittweise vorgenommen, allerdings entsprechen die +Schritte nicht den Voreinstellungen der Kompressionsstufen. Das bedeutet, +wenn beispielsweise die Begrenzung nur geringfügig unter den Anforderungen +für \fBxz \-9\fP liegt, werden auch die Einstellungen nur wenig angepasst und +nicht vollständig herunter zu den Werten für \fBxz \-8\fP +. +.SS "Verkettung und Auffüllung von .xz\-Dateien" +Es ist möglich, \fB.xz\fP\-Dateien direkt zu verketten. Solche Dateien werden +von \fBxz\fP genauso dekomprimiert wie eine einzelne \fB.xz\fP\-Datei. +.PP +Es ist weiterhin möglich, eine Auffüllung zwischen den verketteten Teilen +oder nach dem letzten Teil einzufügen. Die Auffüllung muss aus Null\-Bytes +bestehen und deren Größe muss ein Vielfaches von vier Byte sein. Dies kann +zum Beispiel dann vorteilhaft sein, wenn die \fB.xz\fP\-Datei auf einem +Datenträger gespeichert wird, dessen Dateisystem die Dateigrößen in +512\-Byte\-Blöcken speichert. +.PP +Verkettung und Auffüllung sind für \fB.lzma\fP\-Dateien oder Rohdatenströme +nicht erlaubt. +. +.SH OPTIONEN +. +.SS "Ganzzahlige Suffixe und spezielle Werte" +An den meisten Stellen, wo ein ganzzahliges Argument akzeptiert wird, kann +ein optionales Suffix große Ganzzahlwerte einfacher darstellen. Zwischen +Ganzzahl und dem Suffix dürfen sich keine Leerzeichen befinden. +.TP +\fBKiB\fP +multipliziert die Ganzzahl mit 1.024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP und +\fBKB\fP werden als Synonyme für \fBKiB\fP akzeptiert. +.TP +\fBMiB\fP +multipliziert die Ganzzahl mit 1.048.576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP und \fBMB\fP +werden als Synonyme für \fBMiB\fP akzeptiert. +.TP +\fBGiB\fP +multipliziert die Ganzzahl mit 1.073.741.824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP und +\fBGB\fP werden als Synonyme für \fBGiB\fP akzeptiert. +.PP +Der spezielle Wert \fBmax\fP kann dazu verwendet werden, um den von der +jeweiligen Option akzeptierten maximalen Ganzzahlwert anzugeben. +. +.SS Aktionsmodus +Falls mehrere Aktionsmodi angegeben sind, wird der zuletzt angegebene +verwendet. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Kompression. Dies ist der voreingestellte Aktionsmodus, sofern keiner +angegeben ist und auch kein bestimmter Modus aus dem Befehlsnamen abgeleitet +werden kann (der Befehl \fBunxz\fP impliziert zum Beispiel \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Nach erfolgreicher Kompression wird die Quelldatei gelöscht, außer wenn in +die Standardausgabe geschrieben wird oder \fB\-\-keep\fP angegeben wurde. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Dekomprimieren. Nach erfolgreicher Dekompression wird die Quelldatei +gelöscht, außer wenn in die Standardausgabe geschrieben wird oder \fB\-\-keep\fP +angegeben wurde. +.TP +\fB\-t\fP, \fB\-\-test\fP +prüft die Integrität der komprimierten \fIDateien\fP. Diese Option ist +gleichbedeutend mit \fB\-\-decompress \-\-stdout\fP, außer dass die dekomprimierten +Daten verworfen werden, anstatt sie in die Standardausgabe zu leiten. Es +werden keine Dateien erstellt oder entfernt. +.TP +\fB\-l\fP, \fB\-\-list\fP +gibt Informationen zu den komprimierten \fIDateien\fP aus. Es werden keine +unkomprimierten Dateien ausgegeben und keine Dateien angelegt oder +entfernt. Im Listenmodus kann das Programm keine komprimierten Daten aus der +Standardeingabe oder anderen nicht durchsuchbaren Quellen lesen. +.IP "" +Die Liste zeigt in der Standardeinstellung grundlegende Informationen zu den +\fIDateien\fP an, zeilenweise pro Datei. Detailliertere Informationen erhalten +Sie mit der Option \fB\-\-verbose\fP. Wenn Sie diese Option zweimal angeben, +werden noch ausführlichere Informationen ausgegeben. Das kann den Vorgang +allerdings deutlich verlangsamen, da die Ermittlung der zusätzlichen +Informationen zahlreiche Suchvorgänge erfordert. Die Breite der +ausführlichen Ausgabe übersteigt 80 Zeichen, daher könnte die Weiterleitung +in beispielsweise\& \fBless\ \-S\fP sinnvoll sein, falls das Terminal nicht +breit genug ist. +.IP "" +Die exakte Ausgabe kann in verschiedenen \fBxz\fP\-Versionen und +Spracheinstellungen unterschiedlich sein. Wenn eine maschinell auswertbare +Ausgabe gewünscht ist, dann sollten Sie \fB\-\-robot \-\-list\fP verwenden. +. +.SS Aktionsattribute +.TP +\fB\-k\fP, \fB\-\-keep\fP +verhindert das Löschen der Eingabedateien. +.IP "" +Seit der \fBxz\fP\-Version 5.2.6 wird die Kompression oder Dekompression auch +dann ausgeführt, wenn die Eingabe ein symbolischer Link zu einer regulären +Datei ist, mehr als einen harten Link hat oder das »setuid«\-, »setgid«\- oder +»sticky«\-Bit gesetzt ist. Die genannten Bits werden nicht in die Zieldatei +kopiert. In früheren Versionen geschah dies nur mit \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Diese Option hat verschiedene Auswirkungen: +.RS +.IP \(bu 3 +Wenn die Zieldatei bereits existiert, wird diese vor der Kompression oder +Dekompression gelöscht. +.IP \(bu 3 +Die Kompression oder Dekompression wird auch dann ausgeführt, wenn die +Eingabe ein symbolischer Link zu einer regulären Datei ist, mehr als einen +harten Link hat oder das »setuid«\-, »setgid«\- oder »sticky«\-Bit gesetzt +ist. Die genannten Bits werden nicht in die Zieldatei kopiert. +.IP \(bu 3 +Wenn es zusammen mit \fB\-\-decompress\fP und \fB\-\-stdout\fP verwendet wird und +\fBxz\fP den Typ der Quelldatei nicht ermitteln kann, wird die Quelldatei +unverändert in die Standardausgabe kopiert. Dadurch kann \fBxzcat\fP \fB\-\-force\fP +für Dateien, die nicht mit \fBxz\fP komprimiert wurden, wie \fBcat\fP(1) verwendet +werden. Zukünftig könnte \fBxz\fP neue Dateikompressionsformate unterstützen, +wodurch \fBxz\fP mehr Dateitypen dekomprimieren kann, anstatt sie unverändert +in die Standardausgabe zu kopieren. Mit der Option \fB\-\-format=\fP\fIFormat\fP +können Sie \fBxz\fP anweisen, nur ein einzelnes Dateiformat zu dekomprimieren. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +schreibt die komprimierten oder dekomprimierten Daten in die Standardausgabe +anstatt in eine Datei. Dies impliziert \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +dekomprimiert nur den ersten \fB.xz\fP\-Datenstrom und ignoriert stillschweigend +weitere Eingabedaten, die möglicherweise dem Datenstrom +folgen. Normalerweise führt solcher anhängender Datenmüll dazu, dass \fBxz\fP +eine Fehlermeldung ausgibt. +.IP "" +\fBxz\fP dekomprimiert niemals mehr als einen Datenstrom aus \fB.lzma\fP\-Dateien +oder Rohdatenströmen, aber dennoch wird durch diese Option möglicherweise +vorhandener Datenmüll nach der \fB.lzma\fP\-Datei oder dem Rohdatenstrom +ignoriert. +.IP "" +Diese Option ist wirkungslos, wenn der Aktionsmodus nicht \fB\-\-decompress\fP +oder \fB\-\-test\fP ist. +.IP "" +Seit der Programmversion \fBxz\fP 5.7.1alpha impliziert \fB\-\-single\-stream\fP +zusätzlich die Option \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +verhindert die Erzeugung von Sparse\-Dateien. In der Voreinstellung versucht +\fBxz\fP, bei der Dekompression in eine reguläre Datei eine Sparse\-Datei zu +erzeugen, wenn die dekomprimierten Daten lange Abfolgen von binären Nullen +enthalten. Dies funktioniert auch beim Schreiben in die Standardausgabe, +sofern diese in eine reguläre Datei weitergeleitet wird und bestimmte +Zusatzbedingungen erfüllt sind, die die Aktion absichern. Die Erzeugung von +Sparse\-Dateien kann Plattenplatz sparen und beschleunigt die Dekompression +durch Verringerung der Ein\-/Ausgaben der Platte. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +verwendet \fI.suf\fP bei der Dekompression anstelle von \fB.xz\fP oder \fB.lzma\fP +als Suffix für die Zieldatei. Falls nicht in die Standardausgabe geschrieben +wird und die Quelldatei bereits das Suffix \fI.suf\fP hat, wird eine Warnung +angezeigt und die Datei übersprungen. +.IP "" +berücksichtigt bei der Dekompression zusätzlich zu Dateien mit den Suffixen +\&\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP oder \fB.lz\fP auch jene mit dem Suffix +\&\fI.suf\fP. Falls die Quelldatei das Suffix \fI.suf\fP hat, wird dieses entfernt +und so der Name der Zieldatei abgeleitet. +.IP "" +Beim Komprimieren oder Dekomprimieren von Rohdatenströmen mit +\fB\-\-format=raw\fP muss das Suffix stets angegeben werden, außer wenn die +Ausgabe in die Standardausgabe erfolgt. Der Grund dafür ist, dass es kein +vorgegebenes Suffix für Rohdatenströme gibt. +.TP +\fB\-\-files\fP[\fB=\fP\fIDatei\fP] +liest die zu verarbeitenden Dateinamen aus \fIDatei\fP. Falls keine \fIDatei\fP +angegeben ist, werden die Dateinamen aus der Standardeingabe +gelesen. Dateinamen müssen mit einem Zeilenumbruch beendet werden. Ein +Bindestrich (\fB\-\fP) wird als regulärer Dateiname angesehen und nicht als +Standardeingabe interpretiert. Falls Dateinamen außerdem als +Befehlszeilenargumente angegeben sind, werden diese vor den Dateinamen aus +der \fIDatei\fP verarbeitet. +.TP +\fB\-\-files0\fP[\fB=\fP\fIDatei\fP] +Dies ist gleichbedeutend mit \fB\-\-files\fP[\fB=\fP\fIDatei\fP], außer dass jeder +Dateiname mit einem Null\-Zeichen abgeschlossen werden muss. +. +.SS "Grundlegende Dateiformat\- und Kompressionsoptionen" +.TP +\fB\-F\fP \fIFormat\fP, \fB\-\-format=\fP\fIFormat\fP +gibt das \fIFormat\fP der zu komprimierenden oder dekomprimierenden Datei an: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Dies ist die Voreinstellung. Bei der Kompression ist \fBauto\fP gleichbedeutend +mit \fBxz\fP. Bei der Dekompression wird das Format der Eingabedatei +automatisch erkannt. Beachten Sie, dass Rohdatenströme, wie sie mit +\fB\-\-format=raw\fP erzeugt werden, nicht automatisch erkannt werden können. +.TP +\fBxz\fP +Die Kompression erfolgt in das \fB.xz\fP\-Dateiformat oder akzeptiert nur +\&\fB.xz\fP\-Dateien bei der Dekompression. +.TP +\fBlzma\fP, \fBalone\fP +Die Kompression erfolgt in das veraltete \fB.lzma\fP\-Dateiformat oder +akzeptiert nur \fB.lzma\fP\-Dateien bei der Dekompression. Der alternative Name +\fBalone\fP dient der Abwärtskompatibilität zu den LZMA\-Dienstprogrammen. +.TP +\fBlzip\fP +Akzeptiert nur \fB.lz\fP\-Dateien bei der Dekompression. Kompression wird nicht +unterstützt. +.IP "" +The \fB.lz\fP format versions 0 and 1 are supported. Version 0 files were +produced by \fBlzip\fP 1.3 and older. Such files aren't common but may be +found from file archives as a few source packages were released in this +format. People might have old personal files in this format too. +Decompression support for the format version 0 was removed in \fBlzip\fP 1.18. +\fBlzip\fP 1.4 and later create files in the format version 1. +.TP +\fBraw\fP +Komprimiert oder dekomprimiert einen Rohdatenstrom (ohne Header). Diese +Option ist nur für fortgeschrittene Benutzer bestimmt. Zum Dekodieren von +Rohdatenströmen müssen Sie die Option \fB\-\-format=raw\fP verwenden und die +Filterkette ausdrücklich angeben, die normalerweise in den (hier fehlenden) +Container\-Headern gespeichert worden wäre. +.RE +.TP +\fB\-C\fP \fIPrüfung\fP, \fB\-\-check=\fP\fIPrüfung\fP +gibt den Typ der Integritätsprüfung an. Die Prüfsumme wird aus den +unkomprimierten Daten berechnet und in der \fB.xz\fP\-Datei gespeichert. Diese +Option wird nur bei der Kompression in das \fB.xz\fP\-Format angewendet, da das +\&\fB.lzma\fP\-Format keine Integritätsprüfungen unterstützt. Die eigentliche +Integritätsprüfung erfolgt (falls möglich), wenn die \fB.xz\fP\-Datei +dekomprimiert wird. +.IP "" +Folgende Typen von \fIPrüfungen\fP werden unterstützt: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +führt keine Integritätsprüfung aus. Dies ist eine eher schlechte +Idee. Dennoch kann es nützlich sein, wenn die Integrität der Daten auf +andere Weise sichergestellt werden kann. +.TP +\fBcrc32\fP +berechnet die CRC32\-Prüfsumme anhand des Polynoms aus IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +berechnet die CRC64\-Prüfsumme anhand des Polynoms aus ECMA\-182. Dies ist die +Voreinstellung, da beschädigte Dateien etwas besser als mit CRC32 erkannt +werden und die Geschwindigkeitsdifferenz unerheblich ist. +.TP +\fBsha256\fP +berechnet die SHA\-256\-Prüfsumme. Dies ist etwas langsamer als CRC32 und +CRC64. +.RE +.IP "" +Die Integrität der \fB.xz\fP\-Header wird immer mit CRC32 geprüft. Es ist nicht +möglich, dies zu ändern oder zu deaktivieren. +.TP +\fB\-\-ignore\-check\fP +verifiziert die Integritätsprüfsumme der komprimierten Daten bei der +Dekompression nicht. Die CRC32\-Werte in den \fB.xz\fP\-Headern werden weiterhin +normal verifiziert. +.IP "" +\fBVerwenden Sie diese Option nicht, außer Sie wissen, was Sie tun.\fP Mögliche +Gründe, diese Option zu verwenden: +.RS +.IP \(bu 3 +Versuchen, Daten aus einer beschädigten .xz\-Datei wiederherzustellen. +.IP \(bu 3 +Erhöhung der Geschwindigkeit bei der Dekompression. Dies macht sich meist +mit SHA\-256 bemerkbar, oder mit Dateien, die extrem stark komprimiert +sind. Wir empfehlen, diese Option nicht für diesen Zweck zu verwenden, es +sei denn, die Integrität der Datei wird extern auf andere Weise überprüft. +.RE +.TP +\fB\-0\fP … \fB\-9\fP +wählt eine der voreingestellten Kompressionsstufen, standardmäßig +\fB\-6\fP. Wenn mehrere Voreinstellungsstufen angegeben sind, ist nur die +zuletzt angegebene wirksam. Falls bereits eine benutzerdefinierte +Filterkette angegeben wurde, wird diese durch die Festlegung der +Voreinstellung geleert. +.IP "" +Die Unterschiede zwischen den Voreinstellungsstufen sind deutlicher als bei +\fBgzip\fP(1) und \fBbzip2\fP(1). Die gewählten Kompressionseinstellungen +bestimmen den Speicherbedarf bei der Dekompression, daher ist es auf älteren +Systemen mit wenig Speicher bei einer zu hoch gewählten Voreinstellung +schwer, eine Datei zu dekomprimieren. Insbesondere \fBist es keine gute Idee, blindlings \-9 für alles\fP zu verwenden, wie dies häufig mit \fBgzip\fP(1) und +\fBbzip2\fP(1) gehandhabt wird. +.RS +.TP +\fB\-0\fP … \fB\-3\fP +Diese Voreinstellungen sind recht schnell. \fB\-0\fP ist manchmal schneller als +\fBgzip \-9\fP, wobei aber die Kompression wesentlich besser ist. Die +schnelleren Voreinstellungen sind im Hinblick auf die Geschwindigkeit mit +\fBbzip2\fP(1) vergleichbar , mit einem ähnlichen oder besseren +Kompressionsverhältnis, wobei das Ergebnis aber stark vom Typ der zu +komprimierenden Daten abhängig ist. +.TP +\fB\-4\fP … \fB\-6\fP +Gute bis sehr gute Kompression, wobei der Speicherbedarf für die +Dekompression selbst auf alten Systemen akzeptabel ist. \fB\-6\fP ist die +Voreinstellung, welche üblicherweise eine gute Wahl für die Verteilung von +Dateien ist, die selbst noch auf Systemen mit nur 16\ MiB Arbeitsspeicher +dekomprimiert werden müssen (\fB\-5e\fP oder \fB\-6e\fP sind ebenfalls eine +Überlegung wert. Siehe \fB\-\-extreme\fP). +.TP +\fB\-7 … \-9\fP +Ähnlich wie \fB\-6\fP, aber mit einem höheren Speicherbedarf für die Kompression +und Dekompression. Sie sind nur nützlich, wenn Dateien komprimiert werden +sollen, die größer als 8\ MiB, 16\ MiB beziehungsweise 32\ MiB sind. +.RE +.IP "" +Auf der gleichen Hardware ist die Dekompressionsgeschwindigkeit ein nahezu +konstanter Wert in Bytes komprimierter Daten pro Sekunde. Anders +ausgedrückt: Je besser die Kompression, umso schneller wird üblicherweise +die Dekompression sein. Das bedeutet auch, dass die Menge der pro Sekunde +ausgegebenen unkomprimierten Daten stark variieren kann. +.IP "" +Die folgende Tabelle fasst die Eigenschaften der Voreinstellungen zusammen: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Voreinst.;Wörtb.Gr;KomprCPU;KompSpeich;DekompSpeich +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Spaltenbeschreibungen: +.RS +.IP \(bu 3 +Wörtb.Größe ist die Größe des LZMA2\-Wörterbuchs. Es ist +Speicherverschwendung, ein Wörterbuch zu verwenden, das größer als die +unkomprimierte Datei ist. Daher ist es besser, die Voreinstellungen \fB\-7\fP … +\fB\-9\fP zu vermeiden, falls es keinen wirklichen Bedarf dafür gibt. Mit \fB\-6\fP +und weniger wird üblicherweise so wenig Speicher verschwendet, dass dies +nicht ins Gewicht fällt. +.IP \(bu 3 +KomprCPU ist eine vereinfachte Repräsentation der LZMA2\-Einstellungen, +welche die Kompressionsgeschwindigkeit beeinflussen. Die Wörterbuchgröße +wirkt sich ebenfalls auf die Geschwindigkeit aus. Während KompCPU für die +Stufen \fB\-6\fP bis \fB\-9\fP gleich ist, tendieren höhere Stufen dazu, etwas +langsamer zu sein. Um eine noch langsamere, aber möglicherweise bessere +Kompression zu erhalten, siehe \fB\-\-extreme\fP. +.IP \(bu 3 +KompSpeich enthält den Speicherbedarf des Kompressors im +Einzel\-Thread\-Modus. Dieser kann zwischen den \fBxz\fP\-Versionen leicht +variieren. +.IP \(bu 3 +DekompSpeich enthält den Speicherbedarf für die Dekompression. Das bedeutet, +dass die Kompressionseinstellungen den Speicherbedarf bei der Dekompression +bestimmen. Der exakte Speicherbedarf bei der Dekompression ist geringfügig +größer als die Größe des LZMA2\-Wörterbuchs, aber die Werte in der Tabelle +wurden auf ganze MiB aufgerundet. +.RE +.IP "" + Der Speicherbedarf einiger der zukünftigen Multithread\-Modi kann dramatisch +höher sein als im Einzel\-Thread\-Modus. Mit dem Standardwert von +\fB\-\-block\-size\fP benötigt jeder Thread 3*3*Wörtb.Gr plus KompSpeich oder +DekompSpeich. Beispielsweise benötigen vier Threads mit der Voreinstellung +\fB\-6\fP etwa 660 bis 670 MiB Speicher. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +verwendet eine langsamere Variante der gewählten +Kompressions\-Voreinstellungsstufe (\fB\-0\fP … \fB\-9\fP), um hoffentlich ein etwas +besseres Kompressionsverhältnis zu erreichen, das aber in ungünstigen Fällen +auch schlechter werden kann. Der Speicherverbrauch bei der Dekompression +wird dabei nicht beeinflusst, aber der Speicherverbrauch der Kompression +steigt in den Voreinstellungsstufen \fB\-0\fP bis \fB\-3\fP geringfügig an. +.IP "" +Da es zwei Voreinstellungen mit den Wörterbuchgrößen 4\ MiB und 8\ MiB gibt, +verwenden die Voreinstellungsstufen \fB\-3e\fP und \fB\-5e\fP etwas schnellere +Einstellungen (niedrigere KompCPU) als \fB\-4e\fP beziehungsweise \fB\-6e\fP. Auf +diese Weise sind zwei Voreinstellungen nie identisch. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Voreinst.;Wörtb.Gr;KomprCPU;KompSpeich;DekompSpeich +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Zum Beispiel gibt es insgesamt vier Voreinstellungen, die ein 8\ MiB großes +Wörterbuch verwenden, deren Reihenfolge von der schnellsten zur langsamsten +\fB\-5\fP, \fB\-6\fP, \fB\-5e\fP und \fB\-6e\fP ist. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +sind etwas irreführende Aliase für \fB\-0\fP beziehungsweise \fB\-9\fP. Sie werden +nur zwecks Abwärtskompatibilität zu den LZMA\-Dienstprogrammen +bereitgestellt. Sie sollten diese Optionen besser nicht verwenden. +.TP +\fB\-\-block\-size=\fP\fIGröße\fP +teilt beim Komprimieren in das \fB.xz\fP\-Format die Eingabedaten in Blöcke der +angegebenen \fIGröße\fP in Byte. Die Blöcke werden unabhängig voneinander +komprimiert, was dem Multi\-Threading entgegen kommt und Zufallszugriffe bei +der Dekompression begrenzt. Diese Option wird typischerweise eingesetzt, um +die vorgegebene Blockgröße im Multi\-Thread\-Modus außer Kraft zu setzen, aber +sie kann auch im Einzel\-Thread\-Modus angewendet werden. +.IP "" +Im Multi\-Thread\-Modus wird etwa die dreifache \fIGröße\fP in jedem Thread zur +Pufferung der Ein\- und Ausgabe belegt. Die vorgegebene \fIGröße\fP ist das +Dreifache der Größe des LZMA2\-Wörterbuchs oder 1 MiB, je nachdem, was mehr +ist. Typischerweise ist das Zwei\- bis Vierfache der Größe des +LZMA2\-Wörterbuchs oder wenigstens 1 MB ein guter Wert. Eine \fIGröße\fP, die +geringer ist als die des LZMA2\-Wörterbuchs, ist Speicherverschwendung, weil +dann der LZMA2\-Wörterbuchpuffer niemals vollständig genutzt werden würde. Im +Multi\-Thread\-Modus wird die Größe der Blöcke wird in den Block\-Headern +gespeichert. Die Größeninformation wird für eine Multi\-Thread\-Dekompression +genutzt. +.IP "" +Im Einzel\-Thread\-Modus werden die Blöcke standardmäßig nicht geteilt. Das +Setzen dieser Option wirkt sich nicht auf den Speicherbedarf aus. In den +Block\-Headern werden keine Größeninformationen gespeichert, daher werden im +Einzel\-Thread\-Modus erzeugte Dateien nicht zu den im Multi\-Thread\-Modus +erzeugten Dateien identisch sein. Das Fehlen der Größeninformation bedingt +auch, dass \fBxz\fP nicht in der Lage sein wird, die Dateien im +Multi\-Thread\-Modus zu dekomprimieren. +.TP +\fB\-\-block\-list=\fP\fIBlöcke\fP +beginnt bei der Kompression in das \fB.xz\fP\-Format nach den angegebenen +Intervallen unkomprimierter Daten einen neuen Block, optional mit einer +benutzerdefinierten Filterkette. +.IP "" +Die \fIBlöcke\fP werden in einer durch Kommata getrennten Liste +angegeben. Jeder Block besteht aus einer optionalen Filterkettennummer +zwischen 0 und 9, gefolgt von einem Doppelpunkt (\fB:\fP) und der Größe der +unkomprimierten Daten (diese Angabe ist erforderlich). Überspringen eines +Blocks (zwei oder mehr aufeinander folgende Kommata) ist ein Kürzel dafür, +die Größe und die Filter des vorherigen Blocks zu verwenden. +.IP "" +Falls die Eingabedatei größer ist als die Summe der \fIBlöcke\fP, dann wird der +letzte in \fIVBlöcke\fP angegebene Wert bis zum Ende der Datei wiederholt. Mit +dem speziellen Wert \fB0\fP können Sie angeben, dass der Rest der Datei als +einzelner Block kodiert werden soll. +.IP "" +Eine alternative Filterkette für jeden Block kann in Kombination mit den +Optionen \fB\-\-filters1=\fP\fIFilter\fP \&…\& \fB\-\-filters9=\fP\fIFilter\fP angegeben +werden. Diese Optionen definieren Filterketten mit einem Bezeichner zwischen +1 und 9. Die Filterkette 0 bezeichnet hierbei die voreingestellte +Filterkette, was dem Nichtangeben einer Filterkette gleichkommt. Der +Filterkettenbezeichner kann vor der unkomprimierten Größe verwendet werden, +gefolgt von einem Doppelpunkt (\fB:\fP). Falls Sie beispielsweise +\fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP angeben, werden die Blöcke +folgendermaßen erstellt: +.RS +.IP \(bu 3 +Die durch \fB\-\-filters1\fP angegebene Filterkette und 2 MiB Eingabe +.IP \(bu 3 +Die durch \fB\-\-filters3\fP angegebene Filterkette und 2 MiB Eingabe +.IP \(bu 3 +Die durch \fB\-\-filters2\fP angegebene Filterkette und 4 MiB Eingabe +.IP \(bu 3 +Die durch \fB\-\-filters2\fP angegebene Filterkette und 4 MiB Eingabe +.IP \(bu 3 +Die vorgegebene Filterkette und 2 MiB Eingabe +.IP \(bu 3 +Die vorgegebene Filterkette und 4 MiB Eingabe für jeden Block bis zum Ende +der Eingabe. +.RE +.IP "" +Falls Sie eine Größe angeben, welche die Blockgröße des Encoders übersteigen +(entweder den Vorgabewert im Thread\-Modus oder den mit +\fB\-\-block\-size=\fP\fIGröße\fP angegebenen Wert), wird der Encoder zusätzliche +Blöcke erzeugen, wobei die in den \fIBlöcke\fP angegebenen Grenzen eingehalten +werden. Wenn Sie zum Beispiel \fB\-\-block\-size=10MiB\fP +\fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP angeben und die Eingabedatei 80 +MiB groß ist, erhalten Sie 11 Blöcke: 5, 10, 8, 10, 2, 10, 10, 4, 10, 10 und +1 MiB. +.IP "" +Im Multi\-Thread\-Modus werden die Blockgrößen in den Block\-Headern +gespeichert. Dies geschieht im Einzel\-Thread\-Modus nicht, daher wird die +kodierte Ausgabe zu der im Multi\-Thread\-Modus nicht identisch sein. +.TP +\fB\-\-flush\-timeout=\fP\fIZeit\fP +löscht bei der Kompression die ausstehenden Daten aus dem Encoder und macht +sie im Ausgabedatenstrom verfügbar, wenn mehr als die angegebene \fIZeit\fP in +Millisekunden (als positive Ganzzahl) seit dem vorherigen Löschen vergangen +ist und das Lesen weiterer Eingaben blockieren würde. Dies kann nützlich +sein, wenn \fBxz\fP zum Komprimieren von über das Netzwerk eingehenden Daten +verwendet wird. Kleine \fIZeit\fP\-Werte machen die Daten unmittelbar nach dem +Empfang nach einer kurzen Verzögerung verfügbar, während große \fIZeit\fP\-Werte +ein besseres Kompressionsverhältnis bewirken. +.IP "" +Dieses Funktionsmerkmal ist standardmäßig deaktiviert. Wenn diese Option +mehrfach angegeben wird, ist die zuletzt angegebene wirksam. Für die Angabe +der \fIZeit\fP kann der spezielle Wert \fB0\fP verwendet werden, um dieses +Funktionsmerkmal explizit zu deaktivieren. +.IP "" +Dieses Funktionsmerkmal ist außerhalb von POSIX\-Systemen nicht verfügbar. +.IP "" +.\" FIXME +\fBDieses Funktionsmerkmal ist noch experimentell.\fP Gegenwärtig ist \fBxz\fP +aufgrund der Art und Weise, wie \fBxz\fP puffert, für Dekompression in Echtzeit +ungeeignet. +.TP +\fB\-\-no\-sync\fP +synchronisiert die Zieldatei und deren Verzeichnis auf dem Speichergerät +nicht, bevor die Quelldatei gelöscht wird. So kann die Performance beim +Komprimieren oder Dekomprimieren vieler kleiner Dateien verbessert +werden. Jedoch wäre es möglich, falls es kurz nach dem Löschen zu einem +Systemabsturz kommt, dass die Zieldatei noch nicht auf dem Speichergerät +geschrieben, aber der Löschvorgang bereits ausgeführt wurde. In diesem Fall +gehen sowohl die Quelldatei als auch die Zieldatei verloren. +.IP "" +Diese Option ist nur wirksam, wenn \fBxz\fP die Quelldatei löscht. In anderen +Fällen wird niemals synchronisiert. +.IP "" +Die Synchronisierung und \fB\-\-no\-sync\fP wurden in Version \fBxz\fP 5.7.1alpha +hinzugefügt. +.TP +\fB\-\-memlimit\-compress=\fP\fIGrenze\fP +legt eine Grenze für die Speichernutzung bei der Kompression fest. Wenn +diese Option mehrmals angegeben wird, ist die zuletzt angegebene wirksam. +.IP "" +Falls die Kompressionseinstellungen die \fIGrenze\fP überschreiten, versucht +\fBxz\fP, die Einstellungen nach unten anzupassen, so dass die Grenze nicht +mehr überschritten wird und zeigt einen Hinweis an, dass eine automatische +Anpassung vorgenommen wurde. Die Anpassungen werden in folgender Reihenfolge +angewendet: Reduzierung der Anzahl der Threads, Wechsel in den +Einzelthread\-Modus, falls sogar ein einziger Thread im Multithread\-Modus die +\fIGrenze\fP überschreitet, und schlussendlich die Reduzierung der Größe des +LZMA2\-Wörterbuchs. +.IP "" +Beim Komprimieren mit \fB\-\-format=raw\fP oder falls \fB\-\-no\-adjust\fP angegeben +wurde, wird nur die Anzahl der Threads reduziert, da nur so die komprimierte +Ausgabe nicht beeinflusst wird. +.IP "" +Falls die \fIGrenze\fP nicht anhand der vorstehend beschriebenen Anpassungen +gesetzt werden kann, wird ein Fehler angezeigt und \fBxz\fP wird mit dem +Exit\-Status 1 beendet. +.IP "" +Die \fIGrenze\fP kann auf verschiedene Arten angegeben werden: +.RS +.IP \(bu 3 +Die \fIGrenze\fP kann ein absoluter Wert in Byte sein. Ein Suffix wie \fBMiB\fP +kann dabei hilfreich sein. Beispiel: \fB\-\-memlimit\-compress=80MiB\fP. +.IP \(bu 3 +Die \fIGrenze\fP kann als Prozentsatz des physischen Gesamtspeichers (RAM) +angegeben werden. Dies ist insbesondere nützlich, wenn in einem +Shell\-Initialisierungsskript, das mehrere unterschiedliche Rechner gemeinsam +verwenden, die Umgebungsvariable \fBXZ_DEFAULTS\fP gesetzt ist. Auf diese Weise +ist die Grenze auf Systemen mit mehr Speicher höher. Beispiel: +\fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +Mit \fB0\fP kann die \fIGrenze\fP auf den Standardwert zurückgesetzt werden. Dies +ist gegenwärtig gleichbedeutend mit dem Setzen der \fIGrenze\fP auf \fBmax\fP +(keine Speicherbegrenzung). +.RE +.IP "" +Für die 32\-Bit\-Version von \fBxz\fP gibt es einen Spezialfall: Falls die Grenze +über \fB4020\ MiB\fP liegt, wird die \fIGrenze\fP auf \fB4020\ MiB\fP gesetzt. Auf +MIPS32 wird stattdessen \fB2000\ MB\fP verwendet (die Werte \fB0\fP und \fBmax\fP +werden hiervon nicht beeinflusst; für die Dekompression gibt es keine +vergleichbare Funktion). Dies kann hilfreich sein, wenn ein +32\-Bit\-Executable auf einen 4\ GiB großen Adressraum (2 GiB auf MIPS32) +zugreifen kann, wobei wir hoffen wollen, dass es in anderen Situationen +keine negativen Effekte hat. +.IP "" +Siehe auch den Abschnitt \fBSpeicherbedarf\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIGrenze\fP +legt eine Begrenzung des Speicherverbrauchs für die Dekompression fest. Dies +beeinflusst auch den Modus \fB\-\-list\fP. Falls die Aktion nicht ausführbar ist, +ohne die \fIGrenze\fP zu überschreiten, gibt \fBxz\fP eine Fehlermeldung aus und +die Dekompression wird fehlschlagen. Siehe \fB\-\-memlimit\-compress=\fP\fIGrenze\fP +zu möglichen Wegen, die \fIGrenze\fP anzugeben. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIGrenze\fP +legt eine Begrenzung des Speicherverbrauchs für Multithread\-Dekompression +fest. Dies beeinflusst lediglich die Anzahl der Threads; \fBxz\fP wird dadurch +niemals die Dekompression einer Datei verweigern. Falls die \fIGrenze\fP für +jegliches Multithreading zu niedrig ist, wird sie ignoriert und \fBxz\fP setzt +im Einzelthread\-modus fort. Beachten Sie auch, dass bei der Verwendung von +\fB\-\-memlimit\-decompress\fP dies stets sowohl auf den Einzelthread\-als auch auf +den Multithread\-Modus angewendet wird und so die effektive \fIGrenze\fP für den +Multithread\-Modus niemals höher sein wird als die mit +\fB\-\-memlimit\-decompress\fP gesetzte Grenze. +.IP "" +Im Gegensatz zu anderen Optionen zur Begrenzung des Speicherverbrauchs hat +\fB\-\-memlimit\-mt\-decompress=\fP\fIGrenze\fP eine systemspezifisch vorgegebene +\fIGrenze\fP. Mit \fBxz \-\-info\-memory\fP können Sie deren aktuellen Wert anzeigen +lassen. +.IP "" +Diese Option und ihr Standardwert existieren, weil die unbegrenzte +threadbezogene Dekompression bei einigen Eingabedateien zu unglaublich +großem Speicherverbrauch führen würde. Falls die vorgegebene \fIGrenze\fP auf +Ihrem System zu niedrig ist, können Sie die \fIGrenze\fP durchaus erhöhen, aber +setzen Sie sie niemals auf einen Wert größer als die Menge des nutzbaren +Speichers, da \fBxz\fP bei entsprechenden Eingabedateien versuchen wird, diese +Menge an Speicher auch bei einer geringen Anzahl von Threads zu +verwnden. Speichermangel oder Auslagerung verbessern die +Dekomprimierungsleistung nicht. +.IP "" +Siehe \fB\-\-memlimit\-compress=\fP\fIGrenze\fP für mögliche Wege zur Angabe der +\fIGrenze\fP. Sezen der \fIGrenze\fP auf \fB0\fP setzt die \fIGrenze\fP auf den +vorgegebenen systemspezifischen Wert zurück. +.TP +\fB\-M\fP \fIGrenze\fP, \fB\-\-memlimit=\fP\fIGrenze\fP, \fB\-\-memory=\fP\fIGrenze\fP +Dies ist gleichbedeutend mit \fB\-\-memlimit\-compress=\fP\fIGrenze\fP +\fB\-\-memlimit\-decompress=\fP\fIGrenze\fP \fB\-\-memlimit\-mt\-decompress=\fP\fIGrenze\fP. +.TP +\fB\-\-no\-adjust\fP +zeigt einen Fehler an und beendet, falls die Grenze der Speichernutzung +nicht ohne Änderung der Einstellungen, welche die komprimierte Ausgabe +beeinflussen, berücksichtigt werden kann. Das bedeutet, dass \fBxz\fP daran +gehindert wird, den Encoder vom Multithread\-Modus in den Einzelthread\-Modus +zu versetzen und die Größe des LZMA2\-Wörterbuchs zu reduzieren. Allerdings +kann bei Verwendung dieser Option dennoch die Anzahl der Threads reduziert +werden, um die Grenze der Speichernutzung zu halten, sofern dies die +komprimierte Ausgabe nicht beeinflusst. +.IP "" +Die automatische Anpassung ist beim Erzeugen von Rohdatenströmen +(\fB\-\-format=raw\fP) immer deaktiviert. +.TP +\fB\-T\fP \fIThreads\fP, \fB\-\-threads=\fP\fIThreads\fP +gibt die Anzahl der zu verwendenden Arbeits\-Threads an. Wenn Sie \fIThreads\fP +auf einen speziellen Wert \fB0\fP setzen, verwendet \fBxz\fP maximal so viele +Threads, wie der/die Prozessor(en) im System untestützen. Die tatsächliche +Anzahl kann geringer sein als die angegebenen \fIThreads\fP, wenn die +Eingabedatei nicht groß genug für Threading mit den gegebenen Einstellungen +ist oder wenn mehr Threads die Speicherbegrenzung übersteigen würden. +.IP "" +Die Multithread\- bzw. Einzelthread\-Kompressoren erzeugen unterschiedliche +Ausgaben. Der Einzelthread\-Kompressor erzeugt die geringste Dateigröße, aber +nur die Ausgabe des Multithread\-Kompressors kann mit mehreren Threads wieder +dekomprimiert werden. Das Setzen der Anzahl der \fIThreads\fP auf \fB1\fP wird den +Einzelthread\-Modus verwenden. Das Setzen der Anzahl der \fIThreads\fP auf +einen anderen Wert einschließlich \fB0\fP verwendet den Multithread\-Kompressor, +und zwar sogar dann, wenn das System nur einen einzigen Hardware\-Thread +unterstützt (\fBxz\fP 5.2.x verwendete in diesem Fall noch den +Einzelthread\-Modus). +.IP "" +Um den Multithread\-Modus mit nur einem einzigen Thread zu verwenden, setzen +Sie die Anzahl der \fIThreads\fP auf \fB+1\fP. Das Präfix \fB+\fP hat mit Werten +verschieden von \fB1\fP keinen Effekt. Eine Begrenzung des Speicherverbrauchs +kann \fBxz\fP dennoch veranlassen, den Einzelthread\-Modus zu verwenden, außer +wenn \fB\-\-no\-adjust\fP verwendet wird. Die Unterstützung für das Präfix \fB+\fP +wurde in \fBxz\fP 5.4.0 hinzugefügt. +.IP "" +Falls das automatische Setzen der Anzahl der Threads angefordert und keine +Speicherbegrenzung angegeben wurde, dann wird eine systemspezifisch +vorgegebene weiche Grenze verwendet, um eventuell die Anzahl der Threads zu +begrenzen. Es ist eine weiche Grenze im Sinne davon, dass sie ignoriert +wird, falls die Anzahl der Threads 1 ist; daher wird eine weiche Grenze +\fBxz\fP niemals an der Kompression oder Dekompression hindern. Diese +vorgegebene weiche Grenze veranlasst \fBxz\fP nicht, vom Multithread\-Modus in +den Einzelthread\-Modus zu wechseln. Die aktiven Grenzen können Sie mit dem +Befehl \fBxz \-\-info\-memory\fP anzeigen lassen. +.IP "" +Die gegenwärtig einzige Threading\-Methode teilt die Eingabe in Blöcke und +komprimiert diese unabhängig voneinander. Die vorgegebene Blockgröße ist von +der Kompressionsstufe abhängig und kann mit der Option +\fB\-\-block\-size=\fP\fIGröße\fP außer Kraft gesetzt werden. +.IP "" +Eine thread\-basierte Dekompression wird nur bei Dateien funktionieren, die +mehrere Blöcke mit Größeninformationen in deren Headern enthalten. Alle im +Multi\-Thread\-Modus komprimierten Dateien, die groß genug sind, erfüllen +diese Bedingung, im Einzel\-Thread\-Modus komprimierte Dateien dagegen nicht, +selbst wenn \fB\-\-block\-size=\fP\fIGröße\fP verwendet wurde. +.IP "" +Der Vorgabewert für \fIThreads\fP is \fB0\fP. In \fBxz\fP 5.4.x und älteren Versionen +ist der Vorgabewert \fB1\fP. +. +.SS "Benutzerdefinierte Filterketten für die Kompression" +Eine benutzerdefinierte Filterkette ermöglicht die Angabe detaillierter +Kompressionseinstellungen, anstatt von den Voreinstellungen auszugehen. Wenn +eine benutzerdefinierte Filterkette angegeben wird, werden die vorher in der +Befehlszeile angegebenen Voreinstellungsoptionen (\fB\-0\fP … \fB\-9\fP und +\fB\-\-extreme\fP) außer Kraft gesetzt. Wenn eine Voreinstellungsoption nach +einer oder mehreren benutzerdefinierten Filterkettenoptionen angegeben wird, +dann wird die neue Voreinstellung wirksam und die zuvor angegebenen +Filterkettenoptionen werden außer Kraft gesetzt. +.PP +Eine Filterkette ist mit dem Piping (der Weiterleitung) in der Befehlszeile +vergleichbar. Bei der Kompression gelangt die unkomprimierte Eingabe in den +ersten Filter, dessen Ausgabe wiederum in den zweiten Filter geleitet wird +(sofern ein solcher vorhanden ist). Die Ausgabe des letzten Filters wird in +die komprimierte Datei geschrieben. In einer Filterkette sind maximal vier +Filter zulässig, aber typischerweise besteht eine Filterkette nur aus einem +oder zwei Filtern. +.PP +Bei vielen Filtern ist die Positionierung in der Filterkette eingeschränkt: +Einige Filter sind nur als letzte in der Kette verwendbar, einige können +nicht als letzte Filter gesetzt werden, und andere funktionieren an +beliebiger Stelle. Abhängig von dem Filter ist diese Beschränkung entweder +auf das Design des Filters selbst zurückzuführen oder ist aus +Sicherheitsgründen vorhanden. +.PP +Eine benutzerdefinierte Filterkette kann auf zwei verschiedene Arten +angegeben werden. Die Optionen \fB\-\-filters=\fP\fIFilter\fP und +\fB\-\-filters1=\fP\fIFilter\fP \&…\& \fB\-\-filters9=\fP\fIFilter\fP ermöglichen die Angabe +einer ganzen Filterkette in einer einzelnen Option gemäß der +Liblzma\-Filterzeichenkettensyntax. Alternativ können Sie eine Filterkette +mit einer oder mehreren individuellen Filteroptionen in der Reihenfolge +angeben, in der sie in der Filterkette verwendet werden sollen. Daher ist +die Reihenfolge der individuellen Filteroptionen wichtig! Beim Dekodieren +von Rohdatenströmen (\fB\-\-format=raw\fP) muss die Filterkette in der gleichen +Reihenfolge wie bei der Komprimierung angegeben werden. Alle individuellen +Filter\- oder Voreinstellungsoptionen, die \fIvor\fP der vollen +Filterkettenoption (\fB\-\-filters=\fP\fIFilter\fP) angegeben werden, werden +verworfen. Individuelle Filter, die \fInach\fP der vollen Filterkettenoption +angegeben werden, setzen die Filterkette zurück +.PP +Sowohl vollständige als auch individuelle Filteroptionen akzeptieren +filterspezifische \fIOptionen\fP in einer durch Kommata getrennten +Liste. Zusätzliche Kommata in den \fIOptionen\fP werden ignoriert. Jede Option +hat einen Standardwert, daher brauchen Sie nur jene anzugeben, die Sie +ändern wollen. +.PP +Um die gesamte Filterkette und die \fIOptionen\fP anzuzeigen, rufen Sie \fBxz \-vv\fP auf (was gleichbedeutend mit der zweimaligen Angabe von \fB\-\-verbose\fP +ist). Dies funktioniert auch zum Betrachten der von den Voreinstellungen +verwendeten Filterkettenoptionen. +.TP +\fB\-\-filters=\fP\fIFilter\fP +gibt die vollständige Filterkette oder eine Voreinstellung in einer +einzelnen Option an. Mehrere Filter können durch Leerzeichen oder zwei +Minuszeichen (\fB\-\-\fP) voneinander getrennt werden. Es kann notwendig sein, +die \fIFilter\fP in der Shell\-Befehlszeile zu maskieren, so dass diese als +einzelne Option ausgewertet werden. Um Optionen Werte zuzuordnen, verwenden +Sie \fB:\fP oder \fB=\fP. Einer Voreinstellung kann ein \fB\-\fP vorangestellt werden, +dem keiner oder mehrere Schalter folgen. Der einzige unterstützte Schalter +ist \fBe\fP zum Anwenden der gleichen Optionen wie \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIFilter\fP … \fB\-\-filters9\fP=\fIFilter\fP +gibt bis zu neun optionale Filterketten an, die mit \fB\-\-block\-list\fP +verwendet werden können. +.IP "" +Wenn Sie beispielsweise ein Archiv mit ausführbaren Dateien gefolgt von +Textdateien komprimieren, könnte der Teil mit den ausführbaren Dateien eine +Filterkette mit einem BCJ\-Filter und der Textdateiteil lediglich den +LZMA2\-Filter verwenden. +.TP +\fB\-\-filters\-help\fP +zeigt eine Hilfemeldung an, welche beschreibt, wie Voreinstellungen und +benutzerdefinierte Filterketten in den Optionen \fB\-\-filters\fP und +\fB\-\-filters1=\fP\fIFilter\fP \&… \& \fB\-\-filters9=\fP\fIFilter\fP angegeben werden und +beendet das Programm. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIOptionen\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIOptionen\fP] +.PD +fügt LZMA1\- oder LZMA2\-Filter zur Filterkette hinzu. Diese Filter können nur +als letzte Filter in der Kette verwendet werden. +.IP "" +LZMA1 ist ein veralteter Filter, welcher nur wegen des veralteten +\&\fB.lzma\fP\-Dateiformats unterstützt wird, welches nur LZMA1 unterstützt. LZMA2 +ist eine aktualisierte Version von LZMA1, welche einige praktische Probleme +von LZMA1 behebt. Das \fB.xz\fP\-Format verwendet LZMA2 und unterstützt LZMA1 +gar nicht. Kompressionsgeschwindigkeit und \-verhältnis sind bei LZMA1 und +LZMA2 praktisch gleich. +.IP "" +LZMA1 und LZMA2 haben die gleichen \fIOptionen\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIVoreinstellung\fP +setzt alle LZMA1\- oder LZMA2\-\fIOptionen\fP auf die \fIVoreinstellung\fP +zurück. Diese \fIVoreinstellung\fP wird in Form einer Ganzzahl angegeben, der +ein aus einem einzelnen Buchstaben bestehender Voreinstellungsmodifikator +folgen kann. Die Ganzzahl kann \fB0\fP bis \fB9\fP sein, entsprechend den +Befehlszeilenoptionen \fB\-0\fP … \fB\-9\fP. Gegenwärtig ist \fBe\fP der einzige +unterstützte Modifikator, was \fB\-\-extreme\fP entspricht. Wenn keine +\fBVoreinstellung\fP angegeben ist, werden die Standardwerte der LZMA1\- oder +LZMA2\-\fIOptionen\fP der Voreinstellung \fB6\fP entnommen. +.TP +\fBdict=\fP\fIGröße\fP +Die \fIGröße\fP des Wörterbuchs (Chronikpuffers) gibt an, wie viel Byte der +kürzlich verarbeiteten unkomprimierten Daten im Speicher behalten werden +sollen. Der Algorithmus versucht, sich wiederholende Byte\-Abfolgen +(Übereinstimmungen) in den unkomprimierten Daten zu finden und diese durch +Referenzen zu den Daten zu ersetzen, die sich gegenwärtig im Wörterbuch +befinden. Je größer das Wörterbuch, umso größer ist die Chance, eine +Übereinstimmung zu finden. Daher bewirkt eine Erhöhung der \fIGröße\fP des +Wörterbuchs üblicherweise ein besseres Kompressionsverhältnis, aber ein +Wörterbuch, das größer ist als die unkomprimierte Datei, wäre +Speicherverschwendung. +.IP "" +Typische Wörterbuch\-\fIGrößen\fP liegen im Bereich von 64\ KiB bis 64\ MiB. Das +Minimum ist 4\ KiB. Das Maximum für die Kompression ist gegenwärtig 1.5\ GiB +(1536\ MiB). Bei der Dekompression wird bereits eine Wörterbuchgröße bis zu +4\ GiB minus 1 Byte unterstützt, welche das Maximum für die LZMA1\- und +LZMA2\-Datenstromformate ist. +.IP "" +Die \fIGröße\fP des Wörterbuchs und der Übereinstimmungsfinder (\fIÜf\fP) +bestimmen zusammen den Speicherverbrauch des LZMA1\- oder +LZMA2\-Kodierers. Bei der Dekompression ist ein Wörterbuch der gleichen +\fIGröße\fP (oder ein noch größeres) wie bei der Kompression erforderlich, +daher wird der Speicherverbrauch des Dekoders durch die Größe des bei der +Kompression verwendeten Wörterbuchs bestimmt. Die \fB.xz\fP\-Header speichern +die \fIGröße\fP des Wörterbuchs entweder als 2^\fIn\fP oder 2^\fIn\fP + 2^(\fIn\fP\-1), +so dass diese \fIGrößen\fP für die Kompression etwas bevorzugt werden. Andere +\fIGrößen\fP werden beim Speichern in den \fB.xz\fP\-Headern aufgerundet. +.TP +\fBlc=\fP\fIlc\fP +gibt die Anzahl der literalen Kontextbits an. Das Minimum ist 0 und das +Maximum 4; der Standardwert ist 3. Außerdem darf die Summe von \fIlc\fP und +\fIlp\fP nicht größer als 4 sein. +.IP "" +Alle Bytes, die nicht als Übereinstimmungen kodiert werden können, werden +als Literale kodiert. Solche Literale sind einfache 8\-bit\-Bytes, die jeweils +für sich kodiert werden. +.IP "" +Bei der Literalkodierung wird angenommen, dass die höchsten \fIlc\fP\-Bits des +zuvor unkomprimierten Bytes mit dem nächsten Byte in Beziehung stehen. Zum +Beispiel folgt in typischen englischsprachigen Texten auf einen +Großbuchstaben ein Kleinbuchstabe und auf einen Kleinbuchstaben +üblicherweise wieder ein Kleinbuchstabe. Im US\-ASCII\-Zeichensatz sind die +höchsten drei Bits 010 für Großbuchstaben und 011 für Kleinbuchstaben. Wenn +\fIlc\fP mindestens 3 ist, kann die literale Kodierung diese Eigenschaft der +unkomprimierten Daten ausnutzen. +.IP "" +Der Vorgabewert (3) ist üblicherweise gut. Wenn Sie die maximale Kompression +erreichen wollen, versuchen Sie \fBlc=4\fP. Manchmal hilft es ein wenig, doch +manchmal verschlechtert es die Kompression. Im letzteren Fall versuchen Sie +zum Beispiel auch\& \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +gibt die Anzahl der literalen Positionsbits an. Das Minimum ist 0 und das +Maximum 4; die Vorgabe ist 0. +.IP "" +\fILp\fP beeinflusst, welche Art der Ausrichtung der unkomprimierten Daten beim +Kodieren von Literalen angenommen wird. Siehe \fIpb\fP weiter unten für weitere +Informationen zur Ausrichtung. +.TP +\fBpb=\fP\fIAnzahl\fP +legt die Anzahl der Positions\-Bits fest. Das Minimum ist 0 und das Maximum +4; Standard ist 2. +.IP "" +\fIPb\fP beeinflusst, welche Art der Ausrichtung der unkomprimierten Daten +generell angenommen wird. Standardmäßig wird eine Vier\-Byte\-Ausrichtung +angenommen (2^\fIpb\fP=2^2=4), was oft eine gute Wahl ist, wenn es keine +bessere Schätzung gibt. +.IP "" +Wenn die Ausrichtung bekannt ist, kann das entsprechende Setzen von \fIpb\fP +die Dateigröße ein wenig verringern. Wenn Textdateien zum Beispiel eine +Ein\-Byte\-Ausrichtung haben (US\-ASCII, ISO\-8859\-*, UTF\-8), kann das Setzen +von \fBpb=0\fP die Kompression etwas verbessern. Für UTF\-16\-Text ist \fBpb=1\fP +eine gute Wahl. Wenn die Ausrichtung eine ungerade Zahl wie beispielsweise 3 +Byte ist, könnte \fBpb=0\fP die beste Wahl sein. +.IP "" +Obwohl die angenommene Ausrichtung mit \fIpb\fP und \fIlp\fP angepasst werden +kann, bevorzugen LZMA1 und LZMA2 noch etwas die 16\-Byte\-Ausrichtung. Das +sollten Sie vielleicht beim Design von Dateiformaten berücksichtigen, die +wahrscheinlich oft mit LZMA1 oder LZMA2 komprimiert werden. +.TP +\fBmf=\fP\fIÜf\fP +Der Übereinstimmungsfinder hat einen großen Einfluss auf die Geschwindigkeit +des Kodierers, den Speicherbedarf und das +Kompressionsverhältnis. Üblicherweise sind auf Hash\-Ketten basierende +Übereinstimmungsfinder schneller als jene, die mit Binärbäumen arbeiten. Die +Vorgabe hängt von der \fIVoreinstellungsstufe\fP ab: 0 verwendet \fBhc3\fP, 1\-3 +verwenden \fBhc4\fP und der Rest verwendet \fBbt4\fP. +.IP "" +Die folgenden Übereinstimmungsfinder werden unterstützt. Die Formeln zur +Ermittlung des Speicherverbrauchs sind grobe Schätzungen, die der Realität +am nächsten kommen, wenn \fIWörterbuch\fP eine Zweierpotenz ist. +.RS +.TP +\fBhc3\fP +Hash\-Kette mit 2\- und 3\-Byte\-Hashing +.br +Minimalwert für \fInice\fP: 3 +.br +Speicherbedarf: +.br +\fIdict\fP * 7,5 (falls \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 5,5 + 64 MiB (falls \fIdict\fP > 16 MiB) +.TP +\fBhc4\fP +Hash\-Kette mit 2\-, 3\- und 4\-Byte\-Hashing +.br +Minimaler Wert für \fInice\fP: 4 +.br +Speicherbedarf: +.br +\fIdict\fP * 7,5 (falls \fIdict\fP <= 32 MiB ist); +.br +\fIdict\fP * 6,5 (falls \fIdict\fP > 32 MiB ist) +.TP +\fBbt2\fP +Binärbaum mit 2\-Byte\-Hashing +.br +Minimaler Wert für \fInice\fP: 2 +.br +Speicherverbrauch: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Binärbaum mit 2\- und 3\-Byte\-Hashing +.br +Minimalwert für \fInice\fP: 3 +.br +Speicherbedarf: +.br +\fIdict\fP * 11,5 (falls \fIdict\fP <= 16 MiB ist); +.br +\fIdict\fP * 9,5 + 64 MiB (falls \fIdict\fP > 16 MiB ist) +.TP +\fBbt4\fP +Binärbaum mit 2\-, 3\- und 4\-Byte\-Hashing +.br +Minimaler Wert für \fInice\fP: 4 +.br +Speicherbedarf: +.br +\fIdict\fP * 11,5 (falls \fIdict\fP <= 32 MiB ist); +.br +\fIdict\fP * 10,5 (falls \fIdict\fP > 32 MiB ist) +.RE +.TP +\fBmode=\fP\fIModus\fP +gibt die Methode zum Analysieren der vom Übereinstimmungsfinder gelieferten +Daten an. Als \fIModi\fP werden \fBfast\fP und \fBnormal\fP unterstützt. Die Vorgabe +ist \fBfast\fP für die \fIVoreinstellungsstufen\fP 0\-3 und \fBnormal\fP für die +\fIVoreinstellungsstufen\fP 4\-9. +.IP "" +Üblicherweise wird \fBfast\fP mit Hashketten\-basierten Übereinstimmungsfindern +und \fBnormal\fP mit Binärbaum\-basierten Übereinstimmungsfindern verwendet. So +machen es auch die \fIVoreinstellungsstufen\fP. +.TP +\fBnice=\fP\fInice\fP +gibt an, was als annehmbarer Wert für eine Übereinstimmung angesehen werden +kann. Wenn eine Übereinstimmung gefunden wird, die mindestens diesen +\fInice\fP\-Wert hat, sucht der Algorithmus nicht weiter nach besseren +Übereinstimmungen. +.IP "" +Der \fInice\fP\-Wert kann 2\-273 Byte sein. Höhere Werte tendieren zu einem +besseren Kompressionsverhältnis, aber auf Kosten der Geschwindigkeit. Die +Vorgabe hängt von der \fIVoreinstellungsstufe\fP ab. +.TP +\fBdepth=\fP\fITiefe\fP +legt die maximale Suchtiefe im Übereinstimmungsfinder fest. Vorgegeben ist +der spezielle Wert 0, der den Kompressor veranlasst, einen annehmbaren Wert +für \fITiefe\fP aus \fIÜf\fP und \fInice\fP\-Wert zu bestimmen. +.IP "" +Die angemessene \fITiefe\fP für Hash\-Ketten ist 4\-100 und 16\-1000 für +Binärbäume. Hohe Werte für die \fITiefe\fP können den Kodierer bei einigen +Dateien extrem verlangsamen. Vermeiden Sie es, die \fITiefe\fP über einen Wert +von 100 zu setzen, oder stellen Sie sich darauf ein, die Kompression +abzubrechen, wenn sie zu lange dauert. +.RE +.IP "" +Beim Dekodieren von Rohdatenströmen (\fB\-\-format=raw\fP) benötigt LZMA2 nur die +Wörterbuch\-\fIGröße\fP. LZMA1 benötigt außerdem \fIlc\fP, \fIlp\fP und \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIOptionen\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIOptionen\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIOptionen\fP] +.PD +fügt ein »Branch/Call/Jump«\-(BCJ\-)Filter zur Filterkette hinzu. Diese Filter +können nicht als letzter Filter in der Filterkette verwendet werden. +.IP "" +Ein BCJ\-Filter wandelt relative Adressen im Maschinencode in deren absolute +Gegenstücke um. Die Datengröße wird dadurch nicht geändert, aber die +Redundanz erhöht, was LZMA2 dabei helfen kann, eine um 10 bis 15% kleinere +\&\fB.xz\fP\-Datei zu erstellen. Die BCJ\-Filter sind immer reversibel, daher +verursacht die Anwendung eines BCJ\-Filters auf den falschen Datentyp keinen +Datenverlust, wobei aber das Kompressionsverhältnis etwas schlechter werden +könnte. Die BCJ\-Filter sind sehr schnell und verbrauchen nur wenig mehr +Speicher. +.IP "" +Diese BCJ\-Filter haben bekannte Probleme mit dem Kompressionsverhältnis: +.RS +.IP \(bu 3 +In einigen Dateitypen, die ausführbaren Code enthalten (zum Beispiel +Objektdateien, statische Bibliotheken und Linux\-Kernelmodule), sind die +Adressen in den Anweisungen mit Füllwerten gefüllt. Diese BCJ\-Filter führen +dennoch die Adressumwandlung aus, wodurch die Kompression bei diesen Dateien +schlechter wird. +.IP \(bu 3 +Falls ein BCJ\-Filter auf ein Archiv angewendet wird, ist es möglich, dass +das Kompressionsverhältnis schlechter als ohne Filter wird. Falls es +beispielsweise ähnliche oder sogar identische ausführbare Dateien gibt, dann +werden diese durch die Filterung wahrscheinlich »unähnlicher« und +verschlechtern dadurch das Kompressionsverhältnis. Der Inhalt +nicht\-ausführbarer Dateien im gleichen Archiv kann sich ebenfalls darauf +auswirken. In der Praxis werden Sie durch Versuche mit oder ohne BCJ\-Filter +selbst herausfinden müssen, was situationsbezogen besser ist. +.RE +.IP "" +Verschiedene Befehlssätze haben unterschiedliche Ausrichtungen: Die +ausführbare Datei muss in den Eingabedateien einem Vielfachen dieses Wertes +entsprechen, damit dieser Filter funktioniert. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filter;Ausrichtung;Hinweise +x86;1;32\-Bit oder 64\-Bit x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096\-Byte\-Ausrichtung ist optimal +PowerPC;4;Nur Big Endian +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Da die BCJ\-gefilterten Daten üblicherweise mit LZMA2 komprimiert sind, kann +das Kompressionsverhältnis dadurch etwas verbessert werden, dass die +LZMA2\-Optionen so gesetzt werden, dass sie der Ausrichtung des gewählten +BCJ\-Filters entsprechen. Beispiele: +.RS +.IP \(bu 3 +Der IA\-64\-Filter hat eine 16\-Byte\-Ausrichtung, daher ist \fBpb=4,lp=4,lc=0\fP +für LZMA2 passend (2^4=16). +.IP \(bu 3 +RISC\-V\-Code hat eine 2\-Byte\- oder 4\-Byte\-Ausrichtung, abhängig davon, ob die +Datei 16\-bit\-komprimierte Instruktionen enthält (die C\-Erweiterung). Wenn +16\-bit\-Instruktionen verwendet werden, ist \fBpb=2,lp=1,lc=3\fP oder +\fBpb=1,lp=1,lc=3\fP passend. Wenn keine 16\-bit\-Instruktionen vorhanden sind, +ist \fBpb=2,lp=2,lc=2\fP am besten. Mit \fBreadelf \-h\fP können Sie überprüfen, ob +»RVC« in der »Flags«\-Zeile auftritt. +.IP \(bu 3 +ARM64 hat stets eine 4\-Byte\-Ausrichtung, daher ist \fBpb=2,lp=2,lc=2\fP am +besten. +.IP \(bu 3 +Der x86\-Filter stellt eine Ausnahme dar. Es ist üblicherweise eine gute +Wahl, bei den Voreinstellungen von LZMA2 (\fBpb=2,lp=0,lc=3\fP) zu bleiben, +wenn Sie ausführbare x86\-Dateien komprimieren +.RE +.IP "" +Alle BCJ\-Filter unterstützen die gleichen \fIOptionen\fP: +.RS +.TP +\fBstart=\fP\fIVersatz\fP +gibt den Start\-\fIVersatz\fP an, der bei der Umwandlung zwischen relativen und +absoluten Adressen verwendet wird. Der \fIVersatz\fP muss ein Vielfaches der +Filterausrichtung sein (siehe die Tabelle oben). Der Standardwert ist 0. In +der Praxis ist dieser Standardwert gut; die Angabe eines benutzerdefinierten +\fIVersatzes\fP ist fast immer unnütz. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIOptionen\fP] +fügt den Delta\-Filter zur Filterkette hinzu. Der Delta\-Filter kann nicht als +letzter Filter in der Filterkette verwendet werden. +.IP "" +Gegenwärtig wird nur eine einfache, Byte\-bezogene Delta\-Berechnung +unterstützt. Beim Komprimieren von zum Beispiel unkomprimierten +Bitmap\-Bildern oder unkomprimierten PCM\-Audiodaten kann es jedoch sinnvoll +sein. Dennoch können für spezielle Zwecke entworfene Algorithmen deutlich +bessere Ergebnisse als Delta und LZMA2 liefern. Dies trifft insbesondere auf +Audiodaten zu, die sich zum Beispiel mit \fBflac\fP(1) schneller und besser +komprimieren lassen. +.IP "" +Unterstützte \fIOptionen\fP: +.RS +.TP +\fBdist=\fP\fIAbstand\fP +gibt den \fIAbstand\fP der Delta\-Berechnung in Byte an. Zulässige Werte für den +\fIAbstand\fP sind 1 bis 256. Der Vorgabewert ist 1. +.IP "" +Zum Beispiel wird mit \fBdist=2\fP und der 8\-Byte\-Eingabe A1 B1 A2 B3 A3 B5 A4 +B7 die Ausgabe A1 B1 01 02 01 02 01 02 sein. +.RE +. +.SS "Andere Optionen" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +unterdrückt Warnungen und Hinweise. Geben Sie dies zweimal an, um auch +Fehlermeldungen zu unterdrücken. Diese Option wirkt sich nicht auf den +Exit\-Status aus. Das bedeutet, das selbst bei einer unterdrückten Warnung +der Exit\-Status zur Anzeige einer Warnung dennoch verwendet wird. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +bewirkt ausführliche Ausgaben. Wenn die Standardfehlerausgabe mit einem +Terminal verbunden ist, zeigt \fBxz\fP den Fortschritt an. Durch zweimalige +Angabe von \fB\-\-verbose\fP wird die Ausgabe noch ausführlicher. +.IP "" +Der Fortschrittsanzeiger stellt die folgenden Informationen dar: +.RS +.IP \(bu 3 +Der Prozentsatz des Fortschritts wird angezeigt, wenn die Größe der +Eingabedatei bekannt ist. Das bedeutet, dass der Prozentsatz in +Weiterleitungen (Pipes) nicht angezeigt werden kann. +.IP \(bu 3 +Menge der erzeugten komprimierten Daten (bei der Kompression) oder der +verarbeiteten Daten (bei der Dekompression). +.IP \(bu 3 +Menge der verarbeiteten unkomprimierten Daten (bei der Kompression) oder der +erzeugten Daten (bei der Dekompression). +.IP \(bu 3 +Kompressionsverhältnis, das mittels Dividieren der Menge der bisher +komprimierten Daten durch die Menge der bisher verarbeiteten unkomprimierten +Daten ermittelt wird. +.IP \(bu 3 +Kompressions\- oder Dekompressionsgeschwindigkeit. Diese wird anhand der +Menge der unkomprimierten verarbeiteten Daten (bei der Kompression) oder der +Menge der erzeugten Daten (bei der Dekompression) pro Sekunde gemessen. Die +Anzeige startet einige Sekunden nachdem \fBxz\fP mit der Verarbeitung der Datei +begonnen hat. +.IP \(bu 3 +Die vergangene Zeit im Format M:SS oder H:MM:SS. +.IP \(bu 3 +Die geschätzte verbleibende Zeit wird nur angezeigt, wenn die Größe der +Eingabedatei bekannt ist und bereits einige Sekunden vergangen sind, nachdem +\fBxz\fP mit der Verarbeitung der Datei begonnen hat. Die Zeit wird in einem +weniger präzisen Format ohne Doppelpunkte angezeigt, zum Beispiel 2 min 30 +s. +.RE +.IP "" +Wenn die Standardfehlerausgabe kein Terminal ist, schreibt \fBxz\fP mit +\fB\-\-verbose\fP nach dem Komprimieren oder Dekomprimieren der Datei in einer +einzelnen Zeile den Dateinamen, die komprimierte Größe, die unkomprimierte +Größe, das Kompressionsverhältnis und eventuell auch die Geschwindigkeit und +die vergangene Zeit in die Standardfehlerausgabe. Die Geschwindigkeit und +die vergangene Zeit werden nur angezeigt, wenn der Vorgang mindestens ein +paar Sekunden gedauert hat. Wurde der Vorgang nicht beendet, zum Beispiel +weil ihn der Benutzer abgebrochen hat, wird außerdem der Prozentsatz des +erreichten Verarbeitungsfortschritts aufgenommen, sofern die Größe der +Eingabedatei bekannt ist. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +setzt den Exit\-Status nicht auf 2, selbst wenn eine Bedingung erfüllt ist, +die eine Warnung gerechtfertigt hätte. Diese Option wirkt sich nicht auf die +Ausführlichkeitsstufe aus, daher müssen sowohl \fB\-\-quiet\fP als auch +\fB\-\-no\-warn\fP angegeben werden, um einerseits keine Warnungen anzuzeigen und +andererseits auch den Exit\-Status nicht zu ändern. +.TP +\fB\-\-robot\fP +gibt Meldungen in einem maschinenlesbaren Format aus. Dadurch soll das +Schreiben von Frontends erleichtert werden, die \fBxz\fP anstelle von Liblzma +verwenden wollen, was in verschiedenen Skripten der Fall sein kann. Die +Ausgabe mit dieser aktivierten Option sollte über mehrere +\fBxz\fP\-Veröffentlichungen stabil sein. Details hierzu finden Sie im Abschnitt +\fBROBOTER\-MODUS\fP. +.TP +\fB\-\-info\-memory\fP +zeigt in einem menschenlesbaren Format an, wieviel physischen Speicher (RAM) +und wie viele Prozessor\-Threads das System nach Annahme von \fBxz\fP hat, sowie +die Speicherbedarfsbegrenzung für Kompression und Dekompression, und beendet +das Programm erfolgreich. +.TP +\fB\-h\fP, \fB\-\-help\fP +zeigt eine Hilfemeldung mit den am häufigsten genutzten Optionen an und +beendet das Programm erfolgreich. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +zeigt eine Hilfemeldung an, die alle Funktionsmerkmale von \fBxz\fP beschreibt +und beendet das Programm erfolgreich. +.TP +\fB\-V\fP, \fB\-\-version\fP +zeigt die Versionsnummer von \fBxz\fP und Liblzma in einem menschenlesbaren +Format an. Um eine maschinell auswertbare Ausgabe zu erhalten, geben Sie +\fB\-\-robot\fP vor \fB\-\-version\fP an. +. +.SH ROBOTER\-MODUS +Der Roboter\-Modus wird mit der Option \fB\-\-robot\fP aktiviert. Er bewirkt, dass +die Ausgabe von \fBxz\fP leichter von anderen Programmen ausgewertet werden +kann. Gegenwärtig wird \fB\-\-robot\fP nur zusammen mit \fB\-\-list\fP, +\fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP und \fB\-\-version\fP unterstützt. In der +Zukunft wird dieser Modus auch für Kompression und Dekompression +unterstützt. +. +.SS Listenmodus +\fBxz \-\-robot \-\-list\fP verwendet eine durch Tabulatoren getrennte Ausgabe. In +der ersten Spalte jeder Zeile bezeichnet eine Zeichenkette den Typ der +Information, die in dieser Zeile enthalten ist: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Dies ist stets die erste Zeile, wenn eine Datei aufgelistet wird. Die zweite +Spalte in der Zeile enthält den Dateinamen. +.TP +\fBfile\fP +Diese Zeile enthält allgemeine Informationen zur \fB.xz\fP\-Datei. Diese Zeile +wird stets nach der \fBname\fP\-Zeile ausgegeben. +.TP +\fBstream\fP +Dieser Zeilentyp wird nur verwendet, wenn \fB\-\-verbose\fP angegeben wurde. Es +gibt genau so viele \fBstream\fP\-Zeilen, wie Datenströme in der \fB.xz\fP\-Datei +enthalten sind. +.TP +\fBblock\fP +Dieser Zeilentyp wird nur verwendet, wenn \fB\-\-verbose\fP angegeben wurde. Es +gibt so viele \fBblock\fP\-Zeilen, wie Blöcke in der \fB.xz\fP\-Datei. Die +\fBblock\fP\-Zeilen werden nach allen \fBstream\fP\-Zeilen angezeigt; verschiedene +Zeilentypen werden nicht verschachtelt. +.TP +\fBsummary\fP +Dieser Zeilentyp wird nur verwendet, wenn \fB\-\-verbose\fP zwei Mal angegeben +wurde. Diese Zeile wird nach allen \fBblock\fP\-Zeilen ausgegeben. Wie die +\fBfile\fP\-Zeile enthält die \fBsummary\fP\-Zeile allgemeine Informationen zur +\&\fB.xz\fP\-Datei. +.TP +\fBtotals\fP +Diese Zeile ist immer die letzte der Listenausgabe. Sie zeigt die +Gesamtanzahlen und \-größen an. +.PP +Die Spalten der \fBfile\fP\-Zeilen: +.PD 0 +.RS +.IP 2. 4 +Anzahl der Datenströme in der Datei +.IP 3. 4 +Gesamtanzahl der Blöcke in den Datenströmen +.IP 4. 4 +Komprimierte Größe der Datei +.IP 5. 4 +Unkomprimierte Größe der Datei +.IP 6. 4 +Das Kompressionsverhältnis, zum Beispiel \fB0.123\fP. Wenn das Verhältnis über +9.999 liegt, werden drei Minuszeichen (\fB\-\-\-\fP) anstelle des +Kompressionsverhältnisses angezeigt. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Durch Kommata getrennte Liste der Namen der Integritätsprüfungen. Für die +bekannten Überprüfungstypen werden folgende Zeichenketten verwendet: +\fBNone\fP, \fBCRC32\fP, \fBCRC64\fP und \fBSHA\-256\fP. \fBUnknown\-\fP\fIN\fP wird verwendet, +wobei \fIN\fP die Kennung der Überprüfung als Dezimalzahl angibt (ein\- oder +zweistellig). +.IP 8. 4 +Gesamtgröße der Datenstromauffüllung in der Datei +.RE +.PD +.PP +Die Spalten der \fBstream\fP\-Zeilen: +.PD 0 +.RS +.IP 2. 4 +Datenstromnummer (der erste Datenstrom ist 1) +.IP 3. 4 +Anzahl der Blöcke im Datenstrom +.IP 4. 4 +Komprimierte Startposition +.IP 5. 4 +Unkomprimierte Startposition +.IP 6. 4 +Komprimierte Größe (schließt die Datenstromauffüllung nicht mit ein) +.IP 7. 4 +Unkomprimierte Größe +.IP 8. 4 +Kompressionsverhältnis +.IP 9. 4 +Name der Integritätsprüfung +.IP 10. 4 +Größe der Datenstromauffüllung +.RE +.PD +.PP +Die Spalten der \fBblock\fP\-Zeilen: +.PD 0 +.RS +.IP 2. 4 +Anzahl der in diesem Block enthaltenen Datenströme +.IP 3. 4 +Blocknummer relativ zum Anfang des Datenstroms (der erste Block ist 1) +.IP 4. 4 +Blocknummer relativ zum Anfang der Datei +.IP 5. 4 +Komprimierter Startversatz relativ zum Beginn der Datei +.IP 6. 4 +Unkomprimierter Startversatz relativ zum Beginn der Datei +.IP 7. 4 +Komprimierte Gesamtgröße des Blocks (einschließlich Header) +.IP 8. 4 +Unkomprimierte Größe +.IP 9. 4 +Kompressionsverhältnis +.IP 10. 4 +Name der Integritätsprüfung +.RE +.PD +.PP +Wenn \fB\-\-verbose\fP zwei Mal angegeben wurde, werden zusätzliche Spalten in +die \fBblock\fP\-Zeilen eingefügt. Diese werden mit einem einfachen \fB\-\-verbose\fP +nicht angezeigt, da das Ermitteln dieser Informationen viele Suchvorgänge +erfordert und daher recht langsam sein kann: +.PD 0 +.RS +.IP 11. 4 +Wert der Integritätsprüfung in hexadezimaler Notation +.IP 12. 4 +Block\-Header\-Größe +.IP 13. 4 +Block\-Schalter: \fBc\fP gibt an, dass die komprimierte Größe verfügbar ist, und +\fBu\fP gibt an, dass die unkomprimierte Größe verfügbar ist. Falls der +Schalter nicht gesetzt ist, wird stattdessen ein Bindestrich (\fB\-\fP) +angezeigt, um die Länge der Zeichenkette beizubehalten. In Zukunft könnten +neue Schalter am Ende der Zeichenkette hinzugefügt werden. +.IP 14. 4 +Größe der tatsächlichen komprimierten Daten im Block. Ausgeschlossen sind +hierbei die Block\-Header, die Blockauffüllung und die Prüffelder. +.IP 15. 4 +Größe des Speichers (in Byte), der zum Dekomprimieren dieses Blocks mit +dieser \fBxz\fP\-Version benötigt wird. +.IP 16. 4 +Filterkette. Beachten Sie, dass die meisten der bei der Kompression +verwendeten Optionen nicht bekannt sein können, da in den \fB.xz\fP\-Headern nur +die für die Dekompression erforderlichen Optionen gespeichert sind. +.RE +.PD +.PP +Die Spalten der \fBsummary\fP\-Zeilen: +.PD 0 +.RS +.IP 2. 4 +Größe des Speichers (in Byte), der zum Dekomprimieren dieser Datei mit +dieser \fBxz\fP\-Version benötigt wird. +.IP 3. 4 +\fByes\fP oder \fBno\fP geben an, ob in allen Block\-Headern sowohl die +komprimierte als auch die unkomprimierte Größe gespeichert ist. +.PP +\fISeit\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Minimale \fBxz\fP\-Version, die zur Dekompression der Datei erforderlich ist +.RE +.PD +.PP +Die Spalten der \fBtotals\fP\-Zeile: +.PD 0 +.RS +.IP 2. 4 +Anzahl der Datenströme +.IP 3. 4 +Anzahl der Blöcke +.IP 4. 4 +Komprimierte Größe +.IP 5. 4 +Unkomprimierte Größe +.IP 6. 4 +Durchschnittliches Kompressionsverhältnis +.IP 7. 4 +Durch Kommata getrennte Liste der Namen der Integritätsprüfungen, die in den +Dateien präsent waren. +.IP 8. 4 +Größe der Datenstromauffüllung +.IP 9. 4 +Anzahl der Dateien. Dies dient dazu, die Reihenfolge der vorigen Spalten an +die in den \fBfile\fP\-Zeilen anzugleichen. +.PD +.RE +.PP +Wenn \fB\-\-verbose\fP zwei Mal angegeben wird, werden zusätzliche Spalten in die +\fBtotals\fP\-Zeile eingefügt: +.PD 0 +.RS +.IP 10. 4 +Maximale Größe des Speichers (in Byte), der zum Dekomprimieren der Dateien +mit dieser \fBxz\fP\-Version benötigt wird. +.IP 11. 4 +\fByes\fP oder \fBno\fP geben an, ob in allen Block\-Headern sowohl die +komprimierte als auch die unkomprimierte Größe gespeichert ist. +.PP +\fISeit\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Minimale \fBxz\fP\-Version, die zur Dekompression der Datei erforderlich ist +.RE +.PD +.PP +Zukünftige Versionen könnten neue Zeilentypen hinzufügen, weiterhin könnten +auch in den vorhandenen Zeilentypen weitere Spalten hinzugefügt werden, aber +die existierenden Spalten werden nicht geändert. +. +.SS Filterhilfe +\fBxz \-\-robot \-\-filters\-help\fP gibt die unterstützten Filter im folgenden +Format aus: +.PP +\fIFilter\fP\fB:\fP\fIOption\fP\fB=<\fP\fIWert\fP\fB>,\fP\fIOption\fP\fB=<\fP\fIWert\fP\fB>\fP +… +.TP +\fIFilter\fP +Name des Filters +.TP +\fIOption\fP +Name der filterspezifischen Option +.TP +\fIWert\fP +Der numerische \fIWert\fP erscheint als Bereich +\fB<\fP\fIMinimum\fP\fB\-\fP\fIMaximum\fP\fB>\fP. Die Auswahl des +Zeichenketten\-\fIWert\fPs wird in \fB< >\fP eingeschlossen und durch \fB|\fP +getrennt. +.PP +Jeder Filter wird in einer separaten Zeile ausgegeben. +. +.SS "Informationen zur Speicherbedarfsbegrenzung" +\fBxz \-\-robot \-\-info\-memory\fP gibt eine einzelne Zeile mit mehreren durch +Tabulatoren getrennten Spalten aus: +.IP 1. 4 +Gesamter physischer Speicher (RAM) in Byte. +.IP 2. 4 +Speicherbedarfsbegrenzung für die Kompression in Byte +(\fB\-\-memlimit\-compress\fP). Ein spezieller Wert von \fB0\fP bezeichnet die +Standardeinstellung, die im Einzelthread\-Modus bedeutet, dass keine +Begrenzung vorhanden ist. +.IP 3. 4 +Speicherbedarfsbegrenzung für die Dekompression in Byte +(\fB\-\-memlimit\-decompress\fP). Ein spezieller Wert von \fB0\fP bezeichnet die +Standardeinstellung, die im Einzelthread\-Modus bedeutet, dass keine +Begrenzung vorhanden ist. +.IP 4. 4 +Seit \fBxz\fP 5.3.4alpha: Die Speichernutzung für Multithread\-Dekompression in +Byte (\fB\-\-memlimit\-mt\-decompress\fP). Dies ist niemals \fB0\fP, da ein +systemspezifischer Vorgabewert (gezeigt in Spalte 5) verwendet wird, falls +keine Grenze ausdrücklich angegeben wurde. Dies ist außerdem niemals größer +als der Wert in in Spalte 3, selbst wenn mit \fB\-\-memlimit\-mt\-decompress\fP ein +größerer Wert angegeben wurde. +.IP 5. 4 +Seit \fBxz\fP 5.3.4alpha: Eine systemspezifisch vorgegebene Begrenzung des +Speicherverbrauchs, die zur Begrenzung der Anzahl der Threads beim +Komprimieren mit automatischer Anzahl der Threads (\fB\-\-threads=0\fP) und wenn +keine Speicherbedarfsbegrenzung angegeben wurde (\fB\-\-memlimit\-compress\fP) +verwendet wird. Dies wird auch als Standardwert für +\fB\-\-memlimit\-mt\-decompress\fP verwendet. +.IP 6. 4 +Seit \fBxz\fP 5.3.4alpha: Anzahl der verfügbaren Prozessorthreads. +.PP +In der Zukunft könnte die Ausgabe von \fBxz \-\-robot \-\-info\-memory\fP weitere +Spalten enthalten, aber niemals mehr als eine einzelne Zeile. +. +.SS Version +\fBxz \-\-robot \-\-version\fP gibt die Versionsnummern von \fBxz\fP und Liblzma im +folgenden Format aus: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Hauptversion. +.TP +\fIYYY\fP +Unterversion. Gerade Zahlen bezeichnen eine stabile Version. Ungerade Zahlen +bezeichnen Alpha\- oder Betaversionen. +.TP +\fIZZZ\fP +Patch\-Stufe für stabile Veröffentlichungen oder einfach nur ein Zähler für +Entwicklungsversionen. +.TP +\fIS\fP +Stabilität. 0 ist Alpha, 1 ist Beta und 2 ist stabil. \fIS\fP sollte immer 2 +sein, wenn \fIYYY\fP eine gerade Zahl ist. +.PP +\fIXYYYZZZS\fP sind in beiden Zeilen gleich, sofern \fBxz\fP und Liblzma aus der +gleichen Veröffentlichung der XZ\-Utils stammen. +.PP +Beispiele: 4.999.9beta ist \fB49990091\fP und 5.0.0 is \fB50000002\fP. +. +.SH EXIT\-STATUS +.TP +\fB0\fP +Alles ist in Ordnung. +.TP +\fB1\fP +Ein Fehler ist aufgetreten. +.TP +\fB2\fP +Es ist etwas passiert, das eine Warnung rechtfertigt, aber es sind keine +tatsächlichen Fehler aufgetreten. +.PP +In die Standardausgabe geschriebene Hinweise (keine Warnungen oder Fehler), +welche den Exit\-Status nicht beeinflussen. +. +.SH UMGEBUNGSVARIABLEN +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP wertet eine durch Leerzeichen getrennte Liste von Optionen in den +Umgebungsvariablen \fBXZ_DEFAULTS\fP und \fBXZ_OPT\fP aus (in dieser Reihenfolge), +bevor die Optionen aus der Befehlszeile ausgewertet werden. Beachten Sie, +dass beim Auswerten der Umgebungsvariablen nur Optionen berücksichtigt +werden; alle Einträge, die keine Optionen sind, werden stillschweigend +ignoriert. Die Auswertung erfolgt mit \fBgetopt_long\fP(3), welches auch für +die Befehlszeilenargumente verwendet wird. +.PP +\fBWarnung:\fP Durch Setzen dieser Umgebungsvariablen könnte man effektiv +Programme und Skripte modifizieren, die \fBxz\fP ausführen. Meist ist es +sicher, die Speichernutzungsbegrenzung und Kompressionsoptionen über die +Umgebungsvariablen zu setzen. Dennoch können einige Optionen Skripte +beeinflussen. Ein typisches Beispiel ist die Option \fB\-\-help\fP, die einen +Hilfetext anzeigt, anstatt eine Datei zu komprimieren oder zu +dekomprimieren. Weniger augenfällige Beispiele sind die Optionen \fB\-\-quiet\fP +und \fB\-\-verbose\fP. In vielen Fällen funktioniert es gut, den +Fortschrittsindikator mit \fB\-\-verbose\fP zu aktivieren, aber in einigen +Situationen können die zusätzlichen Meldungen Probleme verursachen. Die +Ausführlichkeitsstufe beeinflusst auch das Verhalten von \fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Benutzerspezifische oder systemweite Standardoptionen. Typischerweise werden +diese in einem Shell\-Initialisierungsskript gesetzt, um die +Speicherbedarfsbegrenzung von \fBxz\fP standardmäßig zu aktivieren oder die +Anzahl der Threads festzulegen. Außer bei Shell\-Initialisierungsskripten und +in ähnlichen Spezialfällen sollte die Variable \fBXZ_DEFAULTS\fP in Skripten +niemals gesetzt oder außer Kraft gesetzt werden. +.TP +\fBXZ_OPT\fP +Dies dient der Übergabe von Optionen an \fBxz\fP, wenn es nicht möglich ist, +die Optionen direkt in der Befehlszeile von \fBxz\fP zu übergeben. Dies ist der +Fall, wenn \fBxz\fP von einem Skript oder Dienstprogramm ausgeführt wird, zum +Beispiel GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Skripte können \fBXZ_OPT\fP zum Beispiel zum Setzen skriptspezifischer +Standard\-Kompressionsoptionen verwenden. Es ist weiterhin empfehlenswert, +Benutzern die Außerkraftsetzung von \fBXZ_OPT\fP zu erlauben, falls dies +angemessen ist. Zum Beispiel könnte in \fBsh\fP(1)\-Skripten Folgendes stehen: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "KOMPATIBILITÄT ZU DEN LZMA\-UTILS" +Die Befehlszeilensyntax von \fBxz\fP ist praktisch eine Obermenge der von +\fBlzma\fP, \fBunlzma\fP und \fBlzcat\fP in den LZMA\-Utils der Versionen 4.32.x. In +den meisten Fällen sollte es möglich sein, die LZMA\-Utils durch die XZ\-Utils +zu ersetzen, ohne vorhandene Skripte ändern zu müssen. Dennoch gibt es +einige Inkompatibilitäten, die manchmal Probleme verursachen können. +. +.SS "Voreinstellungsstufen zur Kompression" +Die Nummerierung der Voreinstellungsstufen der Kompression ist in \fBxz\fP und +den LZMA\-Utils unterschiedlich. Der wichtigste Unterschied ist die Zuweisung +der Wörterbuchgrößen zu den verschiedenen Voreinstellungsstufen. Die +Wörterbuchgröße ist etwa gleich dem Speicherbedarf bei der Dekompression. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Stufe;xz;LZMA\-Utils +\-0;256 KiB;nicht verfügbar +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Die Unterschiede in der Wörterbuchgröße beeinflussen auch den Speicherbedarf +bei der Kompression, aber es gibt noch einige andere Unterschiede zwischen +den LZMA\-Utils und den XZ\-Utils, die die Kluft noch vergrößern: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Stufe;xz;LZMA\-Utils 4.32.x +\-0;3 MiB;nicht verfügbar +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Die standardmäßige Voreinstellungsstufe in den LZMA\-Utils ist \fB\-7\fP, während +diese in den XZ\-Utils \fB\-6\fP ist, daher verwenden beide standardmäßig ein 8 +MiB großes Wörterbuch. +. +.SS "Vor\- und Nachteile von .lzma\-Dateien als Datenströme" +Die unkomprimierte Größe der Datei kann in den \fB.lzma\fP\-Headern gespeichert +werden. Die LZMA\-Utils tun das beim Komprimieren gewöhnlicher Dateien. Als +Alternative kann die unkomprimierte Größe als unbekannt markiert und eine +Nutzdatenende\-Markierung (end\-of\-payload) verwendet werden, um anzugeben, wo +der Dekompressor stoppen soll. Die LZMA\-Utils verwenden diese Methode, wenn +die unkomprimierte Größe unbekannt ist, was beispielsweise in Pipes +(Befehlsverkettungen) der Fall ist. +.PP +\fBxz\fP unterstützt die Dekompression von \fB.lzma\fP\-Dateien mit oder ohne +Nutzdatenende\-Markierung, aber alle von \fBxz\fP erstellten \fB.lzma\fP\-Dateien +verwenden diesen Nutzdatenende\-Markierung, wobei die unkomprimierte Größe in +den \fB.lzma\fP\-Headern als unbekannt markiert wird. Das könnte in einigen +unüblichen Situationen ein Problem sein. Zum Beispiel könnte ein +\&\fB.lzma\fP\-Dekompressor in einem Gerät mit eingebettetem System nur mit +Dateien funktionieren, deren unkomprimierte Größe bekannt ist. Falls Sie auf +dieses Problem stoßen, müssen Sie die LZMA\-Utils oder das LZMA\-SDK +verwenden, um \fB.lzma\fP\-Dateien mit bekannter unkomprimierter Größe zu +erzeugen. +. +.SS "Nicht unterstützte .lzma\-Dateien" +Das \fB.lzma\fP\-Format erlaubt \fIlc\fP\-Werte bis zu 8 und \fIlp\fP\-Werte bis zu +4. Die LZMA\-Utils können Dateien mit beliebigem \fIlc\fP und \fIlp\fP +dekomprimieren, aber erzeugen immer Dateien mit \fBlc=3\fP und \fBlp=0\fP. Das +Erzeugen von Dateien mit anderem \fIlc\fP und \fIlp\fP ist mit \fBxz\fP und mit dem +LZMA\-SDK möglich. +.PP +Die Implementation des LZMA\-Filters in liblzma setzt voraus, dass die Summe +von \fIlc\fP und \fIlp\fP nicht größer als 4 ist. Daher können \fB.lzma\fP\-Dateien, +welche diese Begrenzung überschreiten, mit \fBxz\fP nicht dekomprimiert werden. +.PP +Die LZMA\-Utils erzeugen nur \fB.lzma\fP\-Dateien mit einer Wörterbuchgröße von +2^\fIn\fP (einer Zweierpotenz), aber akzeptieren Dateien mit einer beliebigen +Wörterbuchgröße. Liblzma akzeptiert nur \fB.lzma\fP\-Dateien mit einer +Wörterbuchgröße von 2^\fIn\fP oder 2^\fIn\fP + 2^(\fIn\fP\-1). Dies dient zum +Verringern von Fehlalarmen beim Erkennen von \fB.lzma\fP\-Dateien. +.PP +Diese Einschränkungen sollten in der Praxis kein Problem sein, da praktisch +alle \fB.lzma\fP\-Dateien mit Einstellungen komprimiert wurden, die Liblzma +akzeptieren wird. +. +.SS "Angehängter Datenmüll" +Bei der Dekompression ignorieren die LZMA\-Utils stillschweigend alles nach +dem ersten \fB.lzma\fP\-Datenstrom. In den meisten Situationen ist das ein +Fehler. Das bedeutet auch, dass die LZMA\-Utils die Dekompression verketteter +\&\fB.lzma\fP\-Dateien nicht unterstützen. +.PP +Wenn nach dem ersten \fB.lzma\fP\-Datenstrom Daten verbleiben, erachtet \fBxz\fP +die Datei als beschädigt, es sei denn, die Option \fB\-\-single\-stream\fP wurde +verwendet. Dies könnte die Ausführung von Skripten beeinflussen, die davon +ausgehen, dass angehängter Datenmüll ignoriert wird. +. +.SH ANMERKUNGEN +. +.SS "Die komprimierte Ausgabe kann variieren" +Die exakte komprimierte Ausgabe, die aus der gleichen unkomprimierten +Eingabedatei erzeugt wird, kann zwischen den Versionen der XZ\-Utils +unterschiedlich sein, selbst wenn die Kompressionsoptionen identisch +sind. Das kommt daher, weil der Kodierer verbessert worden sein könnte +(hinsichtlich schnellerer oder besserer Kompression), ohne das Dateiformat +zu beeinflussen. Die Ausgabe kann sogar zwischen verschiedenen Programmen +der gleichen Version der XZ\-Utils variieren, wenn bei der Erstellung des +Binärprogramms unterschiedliche Optionen verwendet wurden. +.PP +Sobald \fB\-\-rsyncable\fP implementiert wurde, bedeutet das, dass die sich +ergebenden Dateien nicht notwendigerweise mit Rsync abgeglichen werden +können, außer wenn die alte und neue Datei mit der gleichen \fBxz\fP\-Version +erzeugt wurden. Das Problem kann beseitigt werden, wenn ein Teil der +Encoder\-Implementierung eingefroren wird, um die mit Rsync abgleichbare +Ausgabe über \fBxz\fP\-Versionsgrenzen hinweg stabil zu halten. +. +.SS "Eingebettete .xz\-Dekompressoren" +Eingebettete \fB.xz\fP\-Dekompressor\-Implementierungen wie XZ Embedded +unterstützen nicht unbedingt Dateien, die mit anderen Integritätsprüfungen +(\fIPrüfung\fP\-Typen) als \fBnone\fP und \fBcrc32\fP erzeugt wurden. Da +\fB\-\-check=crc64\fP die Voreinstellung ist, müssen Sie \fB\-\-check=none\fP oder +\fB\-\-check=crc32\fP verwenden, wenn Sie Dateien für eingebettete Systeme +erstellen. +.PP +Außerhalb eingebetteter Systeme unterstützen die Dekompressoren des +\&\fB.xz\fP\-Formats alle \fIPrüfung\fP\-Typen oder sind mindestens in der Lage, die +Datei zu dekomprimieren, ohne deren Integrität zu prüfen, wenn die bestimmte +\fIPrüfung\fP nicht verfügbar ist. +.PP +XZ Embedded unterstützt BCJ\-Filter, aber nur mit dem vorgegebenen +Startversatz. +. +.SH BEISPIELE +. +.SS Grundlagen +Komprimiert die Datei \fIfoo\fP mit der Standard\-Kompressionsstufe (\fB\-6\fP) zu +\fIfoo.xz\fP und entfernt \fIfoo\fP nach erfolgreicher Kompression: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +\fIbar.xz\fP in \fIbar\fP dekomprimieren und \fIbar.xz\fP selbst dann nicht löschen, +wenn die Dekompression erfolgreich war: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +\fIbaz.tar.xz\fP mit der Voreinstellung \fB\-4e\fP (\fB\-4 \-\-extreme\fP) erzeugen, was +langsamer ist als die Vorgabe \fB\-6\fP, aber weniger Speicher für Kompression +und Dekompression benötigt (48\ MiB beziehungsweise 5\ MiB): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Eine Mischung aus komprimierten und unkomprimierten Dateien kann mit einem +einzelnen Befehl dekomprimiert in die Standardausgabe geschrieben werden: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Parallele Kompression von vielen Dateien" +Auf GNU\- und *BSD\-Systemen können \fBfind\fP(1) und \fBxargs\fP(1) zum +Parallelisieren der Kompression vieler Dateien verwendet werden: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Die Option \fB\-P\fP von \fBxargs\fP(1) legt die Anzahl der parallelen +\fBxz\fP\-Prozesse fest. Der beste Wert für die Option \fB\-n\fP hängt davon ab, wie +viele Dateien komprimiert werden sollen. Wenn es sich nur um wenige Dateien +handelt, sollte der Wert wahrscheinlich 1 sein; bei Zehntausenden von +Dateien kann 100 oder noch mehr angemessener sein, um die Anzahl der +\fBxz\fP\-Prozesse zu beschränken, die \fBxargs\fP(1) schließlich erzeugen wird. +.PP +Die Option \fB\-T1\fP für \fBxz\fP dient dazu, den Einzelthread\-Modus zu erzwingen, +da \fBxargs\fP(1) zur Steuerung des Umfangs der Parallelisierung verwendet +wird. +. +.SS Roboter\-Modus +Berechnen, wie viel Byte nach der Kompression mehrerer Dateien insgesamt +eingespart wurden: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Ein Skript könnte abfragen wollen, ob es ein \fBxz\fP verwendet, das aktuell +genug ist. Das folgende \fBsh\fP(1)\-Skript prüft, ob die Versionsnummer des +Dienstprogramms \fBxz\fP mindestens 5.0.0 ist. Diese Methode ist zu alten +Beta\-Versionen kompatibel, welche die Option \fB\-\-robot\fP nicht unterstützen: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Ihre Version von Xz ist zu alt." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Eine Speicherbedarfsbegrenzung für die Dekompression mit \fBXZ_OPT\fP setzen, +aber eine bereits gesetzte Begrenzung nicht erhöhen: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Benutzerdefinierte Filterketten für die Kompression" +Der einfachste Anwendungsfall für benutzerdefinierte Filterketten ist die +Anpassung von LZMA2\-Voreinstellungsstufen. Das kann nützlich sein, weil die +Voreinstellungen nur einen Teil der potenziell sinnvollen Kombinationen aus +Kompressionseinstellungen abdecken. +.PP +Die KompCPU\-Spalten der Tabellen aus den Beschreibungen der Optionen \fB\-0\fP … +\fB\-9\fP und \fB\-\-extreme\fP sind beim Anpassen der LZMA2\-Voreinstellungen +nützlich. Diese sind die relevanten Teile aus diesen zwei Tabellen: +.RS +.PP +.TS +tab(;); +c c +n n. +Voreinst.;KomprCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Wenn Sie wissen, dass eine Datei für eine gute Kompression ein etwas +größeres Wörterbuch benötigt (zum Beispiel 32 MiB), aber Sie sie schneller +komprimieren wollen, als dies mit \fBxz \-8\fP geschehen würde, kann eine +Voreinstellung mit einem niedrigen KompCPU\-Wert (zum Beispiel 1) dahingehend +angepasst werden, ein größeres Wörterbuch zu verwenden: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Mit bestimmten Dateien kann der obige Befehl schneller sein als \fBxz \-6\fP, +wobei die Kompression deutlich besser wird. Dennoch muss betont werden, dass +nur wenige Dateien von einem größeren Wörterbuch profitieren, wenn der +KompCPU\-Wert niedrig bleibt. Der offensichtlichste Fall, in dem ein größeres +Wörterbuch sehr hilfreich sein kann, ist ein Archiv, das einander sehr +ähnliche Dateien enthält, die jeweils wenigstens einige Megabyte groß +sind. Das Wörterbuch muss dann deutlich größer sein als die einzelne Datei, +damit LZMA2 den größtmöglichen Vorteil aus den Ähnlichkeiten der aufeinander +folgenden Dateien zieht. +.PP +Wenn hoher Speicherbedarf für Kompression und Dekompression kein Problem ist +und die zu komprimierende Datei mindestens einige Hundert Megabyte groß ist, +kann es sinnvoll sein, ein noch größeres Wörterbuch zu verwenden, als die 64 +MiB, die mit \fBxz \-9\fP verwendet werden würden: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Die Verwendung von \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) wie im obigen Beispiel +kann nützlich sein, um den Speicherbedarf für Kompressor und Dekompressor zu +sehen. Denken Sie daran, dass ein Wörterbuch, das größer als die +unkomprimierte Datei ist, Speicherverschwendung wäre. Daher ist der obige +Befehl für kleine Dateien nicht sinnvoll. +.PP +Manchmal spielt die Kompressionszeit keine Rolle, aber der Speicherbedarf +bei der Dekompression muss gering gehalten werden, zum Beispiel um die Datei +auf eingebetteten Systemen dekomprimieren zu können. Der folgende Befehl +verwendet \fB\-6e\fP (\fB\-6 \-\-extreme\fP) als Basis und setzt die Wörterbuchgröße +auf nur 64\ KiB. Die sich ergebende Datei kann mit XZ Embedded (aus diesem +Grund ist dort \fB\-\-check=crc32\fP) mit nur etwa 100\ KiB Speicher +dekomprimiert werden. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Wenn Sie so viele Byte wie möglich herausquetschen wollen, kann die +Anpassung der Anzahl der literalen Kontextbits (\fIlc\fP) und der Anzahl der +Positionsbits (\fIpb\fP) manchmal hilfreich sein. Auch die Anpassung der Anzahl +der literalen Positionsbits (\fIlp\fP) könnte helfen, aber üblicherweise sind +\fIlc\fP und \fIpb\fP wichtiger. Wenn ein Quellcode\-Archiv zum Beispiel +hauptsächlich ASCII\-Text enthält, könnte ein Aufruf wie der folgende eine +etwas kleinere Datei (etwa 0,1\ %) ergeben als mit \fBxz \-6e\fP (versuchen Sie +es auch \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Die Verwendung eines anderen Filters mit LZMA2 kann die Kompression bei +verschiedenen Dateitypen verbessern. So könnten Sie eine gemeinsam genutzte +Bibliothek der Architekturen x86\-32 oder x86\-64 mit dem BCJ\-Filter für x86 +komprimieren: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Beachten Sie, dass die Reihenfolge der Filteroptionen von Bedeutung +ist. Falls \fB\-\-x86\fP nach \fB\-\-lzma2\fP angegeben wird, gibt \fBxz\fP einen Fehler +aus, weil nach LZMA2 kein weiterer Filter sein darf und auch weil der +BCJ\-Filter für x86 nicht als letzter Filter in der Filterkette gesetzt +werden darf. +.PP +Der Delta\-Filter zusammen mit LZMA2 kann bei Bitmap\-Bildern gute Ergebnisse +liefern. Er sollte üblicherweise besser sein als PNG, welches zwar einige +fortgeschrittene Filter als ein simples delta bietet, aber für die +eigentliche Kompression »Deflate« verwendet. +.PP +Das Bild muss in einem unkomprimierten Format gespeichert werden, zum +Beispiel als unkomprimiertes TIFF. Der Abstandsparameter des Delta\-Filters +muss so gesetzt werden, dass er der Anzahl der Bytes pro Pixel im Bild +entspricht. Zum Beispiel erfordert ein 24\-Bit\-RGB\-Bitmap \fBdist=3\fP, außerdem +ist es gut, \fBpb=0\fP an LZMA2 zu übergeben, um die 3\-Byte\-Ausrichtung zu +berücksichtigen: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Wenn sich mehrere Bilder in einem einzelnen Archiv befinden (zum Beispiel\& +\&\fB.tar\fP), funktioniert der Delta\-Filter damit auch, sofern alle Bilder im +Archiv die gleiche Anzahl Bytes pro Pixel haben. +. +.SH "SIEHE AUCH" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA\-SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xzcmp.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xzcmp.1 new file mode 100644 index 0000000000000000000000000000000000000000..2e879253737b4051db7cbc889cf8c5325acf9822 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xzcmp.1 @@ -0,0 +1,59 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" German translation for xz-man. +.\" Mario Blättermann , 2015, 2019-2020, 2022-2025. +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 "6. März 2025" Tukaani XZ\-Dienstprogramme +.SH BEZEICHNUNG +xzcmp, xzdiff, lzcmp, lzdiff \- komprimierte Dateien vergleichen +. +.SH ÜBERSICHT +\fBxzcmp\fP [\fIOption …\fP] \fIDatei1\fP [\fIDatei2\fP] +.br +\fBxzdiff\fP \&… +.br +\fBlzcmp\fP \&… (VERALTET) +.br +\fBlzdiff\fP \&… (VERALTET) +. +.SH BESCHREIBUNG +\fBxzcmp\fP und \fBxzdiff\fP vergleichen den unkomprimierten Inhalt zweier +Dateien. Die unkomprimierten Daten und Optionen werden an \fBcmp\fP(1) oder +\fBdiff\fP(1) übergeben, sofern weder \fB\-\-help\fP noch \fB\-\-version\fP angegeben +wird. +.PP +Wenn sowohl \fIDatei1\fP als auch \fIDatei2\fP angegeben sind, können diese +unkomprimierte Dateien oder Dateien in Formaten sein, die \fBxz\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) oder \fBlz4\fP(1) +dekomprimieren können. Die erforderlichen Dekomprimierungsbefehle werden aus +den Dateiendungen von \fIDatei1\fP und \fIDatei2\fP abgeleitet. Für eine Datei mit +einer unbekannten Endung wird angenommen, dass sie entweder unkomprimiert +ist oder von \fBxz\fP(1) dekomprimiert werden kann. +.PP +Falls nur ein Dateiname angegeben wird, muss \fIDatei1\fP eine Endung eines +unterstützten Kompressionsformat haben und der Name von \fIDatei2\fP wird aus +\fIDatei1\fP abgeleitet, indem die Endung des Kompressionsformats entfernt +wird. +.PP +Die Befehle \fBlzcmp\fP und \fBlzdiff\fP dienen der Abwärtskompatibilität zu den +LZMA\-Dienstprogrammen. Sie werden als veraltet angesehen und werden in einer +zukünftigen Version entfernt. +. +.SH EXIT\-STATUS +Falls ein Dekompressionsfehler auftritt, ist der Exit\-Status +\fB2\fP. Anderenfalls wird der Exit\-Status von \fBcmp\fP(1) oder \fBdiff\fP(1) +verwendet. +. +.SH "SIEHE AUCH" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xzdec.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xzdec.1 new file mode 100644 index 0000000000000000000000000000000000000000..e2812d18124aed0b02009ce0d9d3657a1c1c2dc5 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xzdec.1 @@ -0,0 +1,88 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.\" German translation for xz-man. +.\" Mario Blättermann , 2015, 2019-2020, 2022-2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDEC 1 "8. August 2024" Tukaani XZ\-Dienstprogramme +.SH BEZEICHNUNG +xzdec, lzmadec \- Kleine Dekompressoren für .xz und .lzma +.SH ÜBERSICHT +\fBxzdec\fP [\fIOption…\fP] [\fIDatei…\fP] +.br +\fBlzmadec\fP [\fIOption…\fP] [\fIDatei…\fP] +.SH BESCHREIBUNG +\fBxzdec\fP ist ein auf Liblzma basierendes Nur\-Dekompressionswerkzeug für +\&\fB.xz\fP\-Dateien (und \fBnur\fP für \fB.xz\fP\-Dateien). \fBxzdec\fP ist als direkter +Ersatz für \fBxz\fP(1) in jenen Situationen konzipiert, wo ein Skript \fBxz \-\-decompress \-\-stdout\fP (und eventuelle einige andere höufig genutzte +Optionen) zum Dekomprimieren von \fB.xz\fP\-Dateien. \fBlzmadec\fP ist weitgehend +identisch zu \fBxzdec\fP, mit der Ausnahme, dass \fBlzmadec\fP \fB.lzma\fP\-Dateien +anstelle von \fB.xz\fP\-Dateien unterstützt. +.PP +Um die Größe der ausführbaren Datei zu reduzieren, unterstützt \fBxzdec\fP +weder Multithreading noch Lokalisierung. Außerdem liest es keine Optionen +aus den Umgebungsvariablen \fBXZ_DEFAULTS\fP und \fBXZ_OPT\fP. \fBxzdec\fP +unterstützt keine zwischenzeitlichen Fortschrittsinformationen: Das Senden +von \fBSIGINFO\fP an \fBxzdec\fP hat keine Auswirkungen, jedoch beendet \fBSIGUSR1\fP +den Prozess, anstatt Fortschrittsinformationen anzuzeigen. +.SH OPTIONEN +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +ist zwecks Kompatibilität zu \fBxz\fP(1) vorhanden; wird ignoriert. \fBxzdec\fP +unterstützt nur Dekompression. +.TP +\fB\-k\fP, \fB\-\-keep\fP +ist zwecks Kompatibilität zu \fBxz\fP(1) vorhanden; wird ignoriert. \fBxzdec\fP +erzeugt oder entfernt niemals Dateien. +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +ist zwecks Kompatibilität zu \fBxz\fP(1) vorhanden; wird ignoriert. \fBxzdec\fP +schreibt die dekomprimierten Daten immer in die Standardausgabe. +.TP +\fB\-q\fP, \fB\-\-quiet\fP +hat bei einmaliger Angabe keine Wirkung, da \fBxzdec\fP niemals Warnungen oder +sonstige Meldungen anzeigt. Wenn Sie dies zweimal angeben, werden +Fehlermeldungen unterdrückt. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +ist zwecks Kompatibilität zu \fBxz\fP(1) vorhanden; wird ignoriert. \fBxzdec\fP +verwendet niemals den Exit\-Status 2. +.TP +\fB\-h\fP, \fB\-\-help\fP +zeigt eine Hilfemeldung an und beendet das Programm erfolgreich. +.TP +\fB\-V\fP, \fB\-\-version\fP +zeigt die Versionsnummer von \fBxzdec\fP und liblzma an. +.SH EXIT\-STATUS +.TP +\fB0\fP +Alles ist in Ordnung. +.TP +\fB1\fP +Ein Fehler ist aufgetreten. +.PP +\fBxzdec\fP gibt keine Warnmeldungen wie \fBxz\fP(1) aus, daher wird der +Exit\-Status 2 von \fBxzdec\fP nicht verwendet. +.SH ANMERKUNGEN +Verwenden Sie \fBxz\fP(1) anstelle von \fBxzdec\fP oder \fBlzmadec\fP im normalen +täglichen Gebrauch. \fBxzdec\fP oder \fBlzmadec\fP sind nur für Situationen +gedacht, in denen ein kleinerer Dekompressor statt des voll ausgestatteten +\fBxz\fP(1) wichtig ist. +.PP +\fBxzdec\fP und \fBlzmadec\fP sind nicht wirklich extrem klein. Die Größe kann +durch Deaktivieren von Funktionen bei der Kompilierung von Liblzma weiter +verringert werden, aber das sollte nicht für ausführbare Dateien getan +werden, die in typischen Betriebssystemen ausgeliefert werden, außer in den +Distributionen für eingebettete Systeme. Wenn Sie einen wirklich winzigen +Dekompressor für \fB.xz\fP\-Dateien brauchen, sollten Sie stattdessen XZ +Embedded in Erwägung ziehen. +.SH "SIEHE AUCH" +\fBxz\fP(1) +.PP +XZ Embedded: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xzdiff.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xzdiff.1 new file mode 100644 index 0000000000000000000000000000000000000000..2e879253737b4051db7cbc889cf8c5325acf9822 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xzdiff.1 @@ -0,0 +1,59 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" German translation for xz-man. +.\" Mario Blättermann , 2015, 2019-2020, 2022-2025. +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 "6. März 2025" Tukaani XZ\-Dienstprogramme +.SH BEZEICHNUNG +xzcmp, xzdiff, lzcmp, lzdiff \- komprimierte Dateien vergleichen +. +.SH ÜBERSICHT +\fBxzcmp\fP [\fIOption …\fP] \fIDatei1\fP [\fIDatei2\fP] +.br +\fBxzdiff\fP \&… +.br +\fBlzcmp\fP \&… (VERALTET) +.br +\fBlzdiff\fP \&… (VERALTET) +. +.SH BESCHREIBUNG +\fBxzcmp\fP und \fBxzdiff\fP vergleichen den unkomprimierten Inhalt zweier +Dateien. Die unkomprimierten Daten und Optionen werden an \fBcmp\fP(1) oder +\fBdiff\fP(1) übergeben, sofern weder \fB\-\-help\fP noch \fB\-\-version\fP angegeben +wird. +.PP +Wenn sowohl \fIDatei1\fP als auch \fIDatei2\fP angegeben sind, können diese +unkomprimierte Dateien oder Dateien in Formaten sein, die \fBxz\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) oder \fBlz4\fP(1) +dekomprimieren können. Die erforderlichen Dekomprimierungsbefehle werden aus +den Dateiendungen von \fIDatei1\fP und \fIDatei2\fP abgeleitet. Für eine Datei mit +einer unbekannten Endung wird angenommen, dass sie entweder unkomprimiert +ist oder von \fBxz\fP(1) dekomprimiert werden kann. +.PP +Falls nur ein Dateiname angegeben wird, muss \fIDatei1\fP eine Endung eines +unterstützten Kompressionsformat haben und der Name von \fIDatei2\fP wird aus +\fIDatei1\fP abgeleitet, indem die Endung des Kompressionsformats entfernt +wird. +.PP +Die Befehle \fBlzcmp\fP und \fBlzdiff\fP dienen der Abwärtskompatibilität zu den +LZMA\-Dienstprogrammen. Sie werden als veraltet angesehen und werden in einer +zukünftigen Version entfernt. +. +.SH EXIT\-STATUS +Falls ein Dekompressionsfehler auftritt, ist der Exit\-Status +\fB2\fP. Anderenfalls wird der Exit\-Status von \fBcmp\fP(1) oder \fBdiff\fP(1) +verwendet. +. +.SH "SIEHE AUCH" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xzegrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xzegrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..5b3f0617644885368b9bbb1c3ec5bf3e88a8c3de --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xzegrep.1 @@ -0,0 +1,97 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" German translation for xz-man. +.\" Mario Blättermann , 2015, 2019-2020, 2022-2025. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 "6. März 2025" Tukaani XZ\-Dienstprogramme +.SH BEZEICHNUNG +xzgrep \- möglicherweise komprimierte Dateien nach Mustern durchsuchen +. +.SH ÜBERSICHT +\fBxzgrep\fP [\fIOption …\fP] [\fIMusterliste\fP] [\fIDatei …\fP] +.br +\fBxzegrep\fP … +.br +\fBxzfgrep\fP … +.br +\fBlzgrep\fP \&… (VERALTET) +.br +\fBlzegrep\fP \&… (VERALTET) +.br +\fBlzfgrep\fP \&… (VERALTET) +. +.SH BESCHREIBUNG +\fBxzgrep\fP ruft \fBgrep\fP(1) mit dem unkomprimierten Inhalt von Dateien +auf. Die Formate der \fIDateien\fP werden aus den Dateiendungen +abgeleitet. Jede \fIDatei\fP mit einer Endung, die von \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) oder \fBlz4\fP(1) unterstützt wird, wird +dekomprimiert; für andere Dateien wird angenommen, dass sie bereits in +unkomprimierter Form vorliegen. +.PP +Wenn keine \fIDateien\fP angegeben werden oder \fIDatei\fP als \fB\-\fP angegeben +wird, wird aus der Standardeingabe gelesen. Beim Lesen aus der +Standardeingabe werden nur die von \fBxz\fP(1) unterstützten Dateien +dekomprimiert. Für andere Dateien wird angenommen, dass sie bereits in +unkomprimierter Form vorliegen. +.PP +Die meisten \fIOptionen\fP von \fBgrep\fP(1) werden unterstützt, die folgenden +jedoch nicht: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIAktion\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIGlob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIGlob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIDatei\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIGlob\fP +.PP +\fBxzegrep\fP ist ein Alias für \fBxzgrep \-E\fP. \fBxzfgrep\fP ist ein Alias für +\fBxzgrep \-F\fP. +.PP +Die Befehle \fBlzgrep\fP, \fBlzegrep\fP und \fBlzfgrep\fP dienen der +Abwärtskompatibilität zu den LZMA\-Dienstprogrammen. Sie werden als veraltet +angesehen und werden in einer zukünftigen Version entfernt. +. +.SH EXIT\-STATUS +.TP +0 +In mindestens einer der Eingabedateien wurde mindestens ein Treffer +gefunden. Es sind keine Fehler aufgetreten. +.TP +1 +In keiner der Eingabedateien wurde ein Treffer gefunden. Es sind keine +Fehler aufgetreten. +.TP +>1 +Ein oder mehrere Fehler sind aufgetreten. Es ist unbekannt, ob Treffer +gefunden wurden. +. +.SH UMGEBUNGSVARIABLEN +.TP +\fBGREP\fP +Wenn die Umgebungsvariable \fBGREP\fP auf einen nicht\-leeren Wert gesetzt ist, +wird diese anstelle von \fBgrep\fP(1), \fBgrep \-E\fP oder \fBgrep \-F\fP verwendet. +. +.SH "SIEHE AUCH" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xzfgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xzfgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..5b3f0617644885368b9bbb1c3ec5bf3e88a8c3de --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xzfgrep.1 @@ -0,0 +1,97 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" German translation for xz-man. +.\" Mario Blättermann , 2015, 2019-2020, 2022-2025. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 "6. März 2025" Tukaani XZ\-Dienstprogramme +.SH BEZEICHNUNG +xzgrep \- möglicherweise komprimierte Dateien nach Mustern durchsuchen +. +.SH ÜBERSICHT +\fBxzgrep\fP [\fIOption …\fP] [\fIMusterliste\fP] [\fIDatei …\fP] +.br +\fBxzegrep\fP … +.br +\fBxzfgrep\fP … +.br +\fBlzgrep\fP \&… (VERALTET) +.br +\fBlzegrep\fP \&… (VERALTET) +.br +\fBlzfgrep\fP \&… (VERALTET) +. +.SH BESCHREIBUNG +\fBxzgrep\fP ruft \fBgrep\fP(1) mit dem unkomprimierten Inhalt von Dateien +auf. Die Formate der \fIDateien\fP werden aus den Dateiendungen +abgeleitet. Jede \fIDatei\fP mit einer Endung, die von \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) oder \fBlz4\fP(1) unterstützt wird, wird +dekomprimiert; für andere Dateien wird angenommen, dass sie bereits in +unkomprimierter Form vorliegen. +.PP +Wenn keine \fIDateien\fP angegeben werden oder \fIDatei\fP als \fB\-\fP angegeben +wird, wird aus der Standardeingabe gelesen. Beim Lesen aus der +Standardeingabe werden nur die von \fBxz\fP(1) unterstützten Dateien +dekomprimiert. Für andere Dateien wird angenommen, dass sie bereits in +unkomprimierter Form vorliegen. +.PP +Die meisten \fIOptionen\fP von \fBgrep\fP(1) werden unterstützt, die folgenden +jedoch nicht: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIAktion\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIGlob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIGlob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIDatei\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIGlob\fP +.PP +\fBxzegrep\fP ist ein Alias für \fBxzgrep \-E\fP. \fBxzfgrep\fP ist ein Alias für +\fBxzgrep \-F\fP. +.PP +Die Befehle \fBlzgrep\fP, \fBlzegrep\fP und \fBlzfgrep\fP dienen der +Abwärtskompatibilität zu den LZMA\-Dienstprogrammen. Sie werden als veraltet +angesehen und werden in einer zukünftigen Version entfernt. +. +.SH EXIT\-STATUS +.TP +0 +In mindestens einer der Eingabedateien wurde mindestens ein Treffer +gefunden. Es sind keine Fehler aufgetreten. +.TP +1 +In keiner der Eingabedateien wurde ein Treffer gefunden. Es sind keine +Fehler aufgetreten. +.TP +>1 +Ein oder mehrere Fehler sind aufgetreten. Es ist unbekannt, ob Treffer +gefunden wurden. +. +.SH UMGEBUNGSVARIABLEN +.TP +\fBGREP\fP +Wenn die Umgebungsvariable \fBGREP\fP auf einen nicht\-leeren Wert gesetzt ist, +wird diese anstelle von \fBgrep\fP(1), \fBgrep \-E\fP oder \fBgrep \-F\fP verwendet. +. +.SH "SIEHE AUCH" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xzgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xzgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..5b3f0617644885368b9bbb1c3ec5bf3e88a8c3de --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xzgrep.1 @@ -0,0 +1,97 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" German translation for xz-man. +.\" Mario Blättermann , 2015, 2019-2020, 2022-2025. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 "6. März 2025" Tukaani XZ\-Dienstprogramme +.SH BEZEICHNUNG +xzgrep \- möglicherweise komprimierte Dateien nach Mustern durchsuchen +. +.SH ÜBERSICHT +\fBxzgrep\fP [\fIOption …\fP] [\fIMusterliste\fP] [\fIDatei …\fP] +.br +\fBxzegrep\fP … +.br +\fBxzfgrep\fP … +.br +\fBlzgrep\fP \&… (VERALTET) +.br +\fBlzegrep\fP \&… (VERALTET) +.br +\fBlzfgrep\fP \&… (VERALTET) +. +.SH BESCHREIBUNG +\fBxzgrep\fP ruft \fBgrep\fP(1) mit dem unkomprimierten Inhalt von Dateien +auf. Die Formate der \fIDateien\fP werden aus den Dateiendungen +abgeleitet. Jede \fIDatei\fP mit einer Endung, die von \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) oder \fBlz4\fP(1) unterstützt wird, wird +dekomprimiert; für andere Dateien wird angenommen, dass sie bereits in +unkomprimierter Form vorliegen. +.PP +Wenn keine \fIDateien\fP angegeben werden oder \fIDatei\fP als \fB\-\fP angegeben +wird, wird aus der Standardeingabe gelesen. Beim Lesen aus der +Standardeingabe werden nur die von \fBxz\fP(1) unterstützten Dateien +dekomprimiert. Für andere Dateien wird angenommen, dass sie bereits in +unkomprimierter Form vorliegen. +.PP +Die meisten \fIOptionen\fP von \fBgrep\fP(1) werden unterstützt, die folgenden +jedoch nicht: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIAktion\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIGlob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIGlob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIDatei\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIGlob\fP +.PP +\fBxzegrep\fP ist ein Alias für \fBxzgrep \-E\fP. \fBxzfgrep\fP ist ein Alias für +\fBxzgrep \-F\fP. +.PP +Die Befehle \fBlzgrep\fP, \fBlzegrep\fP und \fBlzfgrep\fP dienen der +Abwärtskompatibilität zu den LZMA\-Dienstprogrammen. Sie werden als veraltet +angesehen und werden in einer zukünftigen Version entfernt. +. +.SH EXIT\-STATUS +.TP +0 +In mindestens einer der Eingabedateien wurde mindestens ein Treffer +gefunden. Es sind keine Fehler aufgetreten. +.TP +1 +In keiner der Eingabedateien wurde ein Treffer gefunden. Es sind keine +Fehler aufgetreten. +.TP +>1 +Ein oder mehrere Fehler sind aufgetreten. Es ist unbekannt, ob Treffer +gefunden wurden. +. +.SH UMGEBUNGSVARIABLEN +.TP +\fBGREP\fP +Wenn die Umgebungsvariable \fBGREP\fP auf einen nicht\-leeren Wert gesetzt ist, +wird diese anstelle von \fBgrep\fP(1), \fBgrep \-E\fP oder \fBgrep \-F\fP verwendet. +. +.SH "SIEHE AUCH" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xzless.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xzless.1 new file mode 100644 index 0000000000000000000000000000000000000000..5dbd5fc0776390efbe688cbaec6ac5aedf54c125 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xzless.1 @@ -0,0 +1,50 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" German translation for xz-man. +.\" Mario Blättermann , 2015, 2019-2020, 2022-2025. +.\" +.\" (Note that this file is not based on gzip's zless.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZLESS 1 "6. März 2025" Tukaani XZ\-Dienstprogramme +.SH BEZEICHNUNG +xzless, lzless \- mit xz oder lzma komprimierte (Text\-)Dateien betrachten +.SH ÜBERSICHT +\fBxzless\fP [\fIDatei\fP …] +.br +\fBlzless\fP [\fIDatei\fP …] (VERALTET) +.SH BESCHREIBUNG +\fBxzless\fP ist ein Filter, der Text aus komprimierten Dateien in einem +Terminal anzeigt. Von \fBxz\fP(1) unterstützte Dateien werden dekomprimiert; +für andere Dateien wird angenommen, dass sie bereits in unkomprimierter Form +vorliegen. Wenn keine \fIDateien\fP angegeben werden, liest \fBxzless\fP aus der +Standardeingabe. +.PP +\fBxzless\fP verwendet \fBless\fP(1) zur Darstellung der Ausgabe. Im Gegensatz zu +\fBxzmore\fP können Sie das zu verwendende Textanzeigeprogramm nicht durch +Setzen einer Umgebungsvariable ändern. Die Befehle basieren auf \fBmore\fP(1) +und \fBvi\fP(1) und ermöglichen Vorwärts\- und Rückwärtssprünge sowie +Suchvorgänge. In der Handbuchseite zu \fBless\fP(1) finden Sie weitere +Informationen. +.PP +Der Befehl \fBlzless\fP dient der Abwärtskompatibilität zu den +LZMA\-Dienstprogrammen. Er wird als veraltet angesehen und wird in einer +zukünftigen Version entfernt. +.SH UMGEBUNGSVARIABLEN +.TP +\fBLESSMETACHARS\fP +Dies enthält eine Zeichenliste mit Bezug zur Shell. Wenn diese Variable +nicht bereits gesetzt ist, wird sie durch \fBxzless\fP gesetzt. +.TP +\fBLESSOPEN\fP +Dies ist auf die Befehlszeile zum Aufruf von \fBxz\fP(1) gesetzt, die zur +Vorverarbeitung der Eingabedateien für \fBless\fP(1) nötig ist. +.SH "SIEHE AUCH" +\fBless\fP(1), \fBxz\fP(1), \fBxzmore\fP(1), \fBzless\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xzmore.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xzmore.1 new file mode 100644 index 0000000000000000000000000000000000000000..91b850d8376887b8a29747e945a5f0da83a34dd6 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/de/man1/xzmore.1 @@ -0,0 +1,52 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" German translation for xz-man. +.\" Mario Blättermann , 2015, 2019-2020, 2022-2025. +.\" +.\" (Note that this file is based on xzless.1 instead of gzip's zmore.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZMORE 1 "6. März 2025" Tukaani XZ\-Dienstprogramme +.SH BEZEICHNUNG +xzmore, lzmore \- mit xz oder lzma komprimierte (Text\-)Dateien lesen +. +.SH ÜBERSICHT +\fBxzmore\fP [\fIDatei\fP …] +.br +\fBlzmore\fP [\fIDatei\fP …] (VERALTET) +. +.SH BESCHREIBUNG +\fBxzmore\fP zeigt Text aus komprimierten Dateien mit Hilfe des Pagers +(Textanzeigeprogramms) \fBmore\fP(1) in einem Terminal an. Von \fBxz\fP(1) +unterstützte Dateien werden dekomprimiert; für andere Dateien wird +angenommen, dass sie bereits in unkomprimierter Form vorliegen. Wenn keine +\fIDateien\fP angegeben werden, liest \fBxzmore\fP aus der Standardeingabe. Im +\fBmore\fP(1)\-Handbuch finden Sie Informationen zu den Tastaturbefehlen. +.PP +Beachten Sie, dass Zurückrollen nicht möglich sein könnte, abhängig von der +Implementierung von \fBmore\fP(1). Das kommt daher, dass \fBxzmore\fP eine Pipe +verwendet, um die dekomprimierten Daten an \fBmore\fP(1) zu +übergeben. \fBxzless\fP(1) verwendet \fBless\fP(1), welches fortgeschrittenere +Funktionen bietet. +.PP +Der Befehl \fBlzmore\fP dient der Abwärtskompatibilität zu den +LZMA\-Dienstprogrammen. Er wird als veraltet angesehen und wird in einer +zukünftigen Version entfernt. +. +.SH UMGEBUNGSVARIABLEN +.TP +.\" TRANSLATORS: Don't translate the uppercase PAGER. +.\" It is a name of an environment variable. +\fBPAGER\fP +Falls die Umgebungsvariable \fBPAGER\fP gesetzt ist, wird deren Wert als Pager +(Textanzeigeprogramm) anstelle von \fBmore\fP(1) verwendet. +. +.SH "SIEHE AUCH" +\fBmore\fP(1), \fBxz\fP(1), \fBxzless\fP(1), \fBzmore\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/lzcat.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/lzcat.1 new file mode 100644 index 0000000000000000000000000000000000000000..297dc7c0d91cc84d9990f8e22984ef3e7be54f5b --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/lzcat.1 @@ -0,0 +1,2027 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" french translation of XZ Utils man +.\" Copyright (C) 2021 Debian French l10n team +.\" Translator +.\" bubu , 2021. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 2025\-03\-08 Tukaani "Utilitaires XZ" +. +.SH NOM +xz, unxz, xzcat, lzma, unlzma, lzcat \- Compresser ou décompresser des +fichiers .xz et .lzma +. +.SH SYNOPSIS +\fBxz\fP [\fIoption...\fP] [\fIfichier...\fP] +. +.SH "ALIAS DES COMMANDES" +\fBunxz\fP est équivalent à \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP est équivalent à \fBxz \-\-decompress \-\-stdout\fP +.br +\fBlzma\fP est équivalent à \fBxz \-\-format=lzma\fP +.br +\fBunlzma\fP est équivalent à \fBxz \-\-format=lzma \-\-decompress\fP +.br +\fBlzcat\fP est équivalent à \fBxz \-\-format=lzma \-\-decompress \-\- stdout\fP +.PP +Lors de l'écriture de scripts qui nécessitent de décompresser des fichiers, +il est recommandé de toujours utiliser la commande \fBxz\fP avec les arguments +appropriés (\fBxz \-d\fP ou \fBxz \-dc\fP) au lieu des commandes \fBunxz\fP et +\fBxzcat\fP. +. +.SH DESCRIPTION +\fBxz\fP is a general\-purpose data compression tool with command line syntax +similar to \fBgzip\fP(1) and \fBbzip2\fP(1). The native file format is the +\&\fB.xz\fP format, but the legacy \fB.lzma\fP format used by LZMA Utils and raw +compressed streams with no container format headers are also supported. In +addition, decompression of the \fB.lz\fP format used by \fBlzip\fP is supported. +.PP +\fBxz\fP compresse ou décompresse chaque \fIfichier\fP en fonction du mode +d'opération choisi. Si aucun \fIfichier\fP n'est donné ou \fIfichier\fP est \fB\-\fP, +\fBxz\fP lit depuis l'entrée standard et écrit les données traitées sur la +sortie standard. \fBxz\fP refusera (affichera une erreur et ignorera le +\fIfichier\fP) d'écrire les données compressées sur la sortie standard si c'est +un terminal. De même, \fBxz\fP refusera de lire des données compressées depuis +l'entrée standard si c'est un terminal. +.PP +A moins que \fB\-\-sdout\fP ne soit indiqué, les \fIfichiers\fP autres que \fB\-\fP sont +écrits dans un nouveau fichier dont le nom est dérivé du nom de \fIfichier\fP +source : +.IP \(bu 3 +Lors de la compression, le suffixe du format de fichier cible (\fB.xz\fP ou +\&\fB.lzma\fP) est ajouté au nom de fichier source pour obtenir le nom de fichier +cible. +.IP \(bu 3 +When decompressing, the \fB.xz\fP, \fB.lzma\fP, or \fB.lz\fP suffix is removed from +the filename to get the target filename. \fBxz\fP also recognizes the suffixes +\&\fB.txz\fP and \fB.tlz\fP, and replaces them with the \fB.tar\fP suffix. +.PP +Si le fichier cible existe déjà, une erreur est affichée et le \fIfichier\fP +est ignoré. +.PP +Sauf s'il écrit dans la sortie standard, \fBxz\fP affichera un avertissement et +ignorera le \fIfichier\fP dans les cas suivants : +.IP \(bu 3 +\fIfichier\fP n'est pas un fichier normal. Les liens symboliques ne sont pas +suivis et donc ne sont pas considérés comme des fichiers normaux. +.IP \(bu 3 +\fIfichier\fP a plusieurs liens physiques. +.IP \(bu 3 +\fIfichier\fP a un setuid, setgid ou sticky bit positionné. +.IP \(bu 3 +Le mode d'opération est défini pour compresser et le \fIfichier\fP a déjà un +suffixe du format de fichier cible (\fB.xz\fP ou \fB.txz\fP lors d'une compression +en format \fB.xz\fP, et \fB.lzma\fP ou \fB.tlz\fP lors d'une compression en format +\&\fB.lzma\fP). +.IP \(bu 3 +The operation mode is set to decompress and the \fIfile\fP doesn't have a +suffix of any of the supported file formats (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, +\&\fB.tlz\fP, or \fB.lz\fP). +.PP +Après la compression ou la décompression réussie du \fIfichier\fP, \fBxz\fP copie +les permissions du propriétaire, du groupe, la date d'accès, et les +modifications d'heure depuis le \fIfichier\fP source du fichier cible. Si la +copie du groupe échoue, les permissions sont modifiées pour que le fichier +cible ne soit pas accessible aux utilisateurs qui n'ont pas les droits +d'accès au \fIfichier\fP source. \fBxz\fP ne prend actuellement pas en charge la +copie d'autres métadonnées telles que les listes de contrôle d'accès ou les +attributs étendus. +.PP +Once the target file has been successfully closed, the source \fIfile\fP is +removed unless \fB\-\-keep\fP was specified. The source \fIfile\fP is never removed +if the output is written to standard output or if an error occurs. +.PP +Envoyer \fBSIGINFO\fP ou \fBSIGURSR1\fP au processus \fBxz\fP, lui fait afficher +l'information de progression sur l'erreur standard. Cela a un intérêt limité +car lorsque l'erreur standard est un terminal, utiliser \fB\-\-verbose\fP +affichera automatiquement un indicateur de progression du processus. +. +.SS "Utilisation de la mémoire" +L'utilisation de la mémoire par \fBxz\fP varie de quelques centaines de +kilo\-octets à plusieurs gigaoctects en fonction des paramètres de +compression. Les réglages utilisés lors de la compression d'un fichier +déterminent les besoins en mémoire pour la décompression. Habituellement la +décompression nécessite 5\% à 20\% de la quantité de mémoire utilisée pour +la compression du fichier. Par exemple, décompresser un fichier créé avec +\fBxz\-9\fP recquiert habituellement 65\ Mio de mémoire. Bien qu'il soit +possible d'avoir des fichiers \fB.xz\fP nécessitant plusieurs gigaoctets de +mémoire pour être décompressés. +.PP +Especially users of older systems may find the possibility of very large +memory usage annoying. To prevent uncomfortable surprises, \fBxz\fP has a +built\-in memory usage limiter, which is disabled by default. While some +operating systems provide ways to limit the memory usage of processes, +relying on it wasn't deemed to be flexible enough (for example, using +\fBulimit\fP(1) to limit virtual memory tends to cripple \fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +The memory usage limiter can be enabled with the command line option +\fB\-\-memlimit=\fP\fIlimit\fP. Often it is more convenient to enable the limiter +by default by setting the environment variable \fBXZ_DEFAULTS\fP, for example, +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. It is possible to set the limits +separately for compression and decompression by using +\fB\-\-memlimit\-compress=\fP\fIlimit\fP and \fB\-\-memlimit\-decompress=\fP\fIlimit\fP. +Using these two options outside \fBXZ_DEFAULTS\fP is rarely useful because a +single run of \fBxz\fP cannot do both compression and decompression and +\fB\-\-memlimit=\fP\fIlimit\fP (or \fB\-M\fP \fIlimit\fP) is shorter to type on the +command line. +.PP +If the specified memory usage limit is exceeded when decompressing, \fBxz\fP +will display an error and decompressing the file will fail. If the limit is +exceeded when compressing, \fBxz\fP will try to scale the settings down so that +the limit is no longer exceeded (except when using \fB\-\-format=raw\fP or +\fB\-\-no\-adjust\fP). This way the operation won't fail unless the limit is very +small. The scaling of the settings is done in steps that don't match the +compression level presets, for example, if the limit is only slightly less +than the amount required for \fBxz \-9\fP, the settings will be scaled down only +a little, not all the way down to \fBxz \-8\fP. +. +.SS "Concaténation et remplissage avec des fichiers .xz" +Il est possible de concaténer les fichiers \fB.xz\fP tels quel. \fBxz\fP +décompressera de tels fichiers comme s'ils étaient un unique fichier \fB.xz\fP. +.PP +It is possible to insert padding between the concatenated parts or after the +last part. The padding must consist of null bytes and the size of the +padding must be a multiple of four bytes. This can be useful, for example, +if the \fB.xz\fP file is stored on a medium that measures file sizes in +512\-byte blocks. +.PP +La concaténation et le remplissage ne sont pas autorisés avec les fichiers +\&\fB.lzma\fP ou les flux bruts. +. +.SH OPTIONS +. +.SS "Suffixes entiers et valeurs spéciales." +Dans la plupart des endroits où un argument entier est attendu, un suffixe +optionel permet d'indiquer facilement les grands entiers. Il ne doit pas y +avoir d'espace entre l'entier et le suffixe. +.TP +\fBKiB\fP +Multiplier l'entier par 1024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP et \fBKB\fP sont +acceptés comme synonymes de \fBKiB\fP. +.TP +\fBMiB\fP +Multiplier l'entier par 1 048 576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP et \fBMB\fP sont +acceptés comme synonymes de \fBMiB\fP. +.TP +\fBGiB\fP +Multiplier l'entier par 1 073 741 824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP et \fBGB\fP +sont acceptés comme synonymes de \fBGiB\fP. +.PP +La valeur spéciale \fBmax\fP peut être utilisée pour indiquer la valeur +maximale de l'entier prise en charge par l'option. +. +.SS "Mode d'opération" +Si plusieurs options de mode d'opération sont données, la dernière prend +effet. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Compresser. C'est le mode d'opération par défaut lorsque aucune option de +mode opératoire n'est spécifiée ou qu'aucun autre mode d'opération n'est +sous\-entendu par le nom de la commande (par exemple \fBunxz\fP sous\-entend +\fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +After successful compression, the source file is removed unless writing to +standard output or \fB\-\-keep\fP was specified. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Decompress. After successful decompression, the source file is removed +unless writing to standard output or \fB\-\-keep\fP was specified. +.TP +\fB\-t\fP, \fB\-\-test\fP +Tester l'intégrité des \fIfichiers\fP compressés. Cette option est équivalente +à \fB\-\-decompress \-\-stdout\fP sauf que les données décompressées sont rejetées +au lieu d'être écrites sur la sortie standard. Aucun fichier n'est créé ou +supprimé. +.TP +\fB\-l\fP, \fB\-\-list\fP +Afficher l'information sur les \fIfichiers\fP compressés. Aucune sortie +non\-compressée n'est produite et aucun fichier n'est créé ou supprimé. En +mode liste, le programme ne peut pas lire les données compressées depuis +l'entrée standard ou depuis d'autres sources non adressables. +.IP "" +The default listing shows basic information about \fIfiles\fP, one file per +line. To get more detailed information, use also the \fB\-\-verbose\fP option. +For even more information, use \fB\-\-verbose\fP twice, but note that this may be +slow, because getting all the extra information requires many seeks. The +width of verbose output exceeds 80 characters, so piping the output to, for +example, \fBless\ \-S\fP may be convenient if the terminal isn't wide enough. +.IP "" +La sortie exacte peut varier suivant les versions de \fBxz\fP et les différents +paramètres régionaux. Pour une sortie lisible par la machine, utiliser +\fB\-\-robot \-\-list\fP. +. +.SS "Modificateurs d'opération" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Ne pas effacer les fichiers d'entrée. +.IP "" +Since \fBxz\fP 5.2.6, this option also makes \fBxz\fP compress or decompress even +if the input is a symbolic link to a regular file, has more than one hard +link, or has the setuid, setgid, or sticky bit set. The setuid, setgid, and +sticky bits are not copied to the target file. In earlier versions this was +only done with \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Cette option a plusieurs effets : +.RS +.IP \(bu 3 +Si le fichier cible existe déjà, l'effacer avant de compresser ou +décompresser. +.IP \(bu 3 +Compresser ou décompresser même si l'entrée est un lien symbolique vers un +fichier normal, a plus qu'un lien physique, ou a le bit setuid, setgid ou +sticky défini. Les bits setuid, setgid et sticky bits ne sont pas copiés +dans le fichier cible. +.IP \(bu 3 +Lorsque \fBxz\fP est utilisé avec \fB\-\-decompress\fP \fB\-\-stdout\fP et qu'il ne peut +pas reconnaitre le type du fichier source, copier le fichier source tel quel +dans la sortie standard. Celà permet à \fBxzcat\fP \fB\-\-force\fP d'être utilisé +comme \fBcat\fP(1) pour les fichiers qui n'ont pas été compressé avec +\fBxz\fP. Remarquez que dans le futur, \fBxz\fP devrait prendre en charge de +nouveaux formats de fichiers compressés, ce qui permettra à \fBxz\fP de +décompresser plus de types de fichiers au lieu de les copier tels quels dans +la sortie standard. \fB\-\-format=\fP\fIformat\fP peut être utilisé pour contraindre +\fBxz\fP à décompresser seulement un format de fichier. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Écrire les données compressées ou décompressées sur la sortie standard +plutôt que dans un fichier. Cela necessite \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Décompresser seulement le premier flux \fB.xz\fP et ignorer silencieusement les +possibles données d'entrée résiduelles qui suivent le flux. Normalement ces +déchets excédentaires provoquent l'affichage d'une erreur par \fBxz\fP. +.IP "" +\fBxz\fP ne décompresse jamais plus d'un flux à partir de fichiers \fB.lzma\fP ou +de flux bruts, mais cette option fait aussi que \fBxz\fP ignorera les données +résiduelles après le fichier \fB.lzma\fP ou le flux brut. +.IP "" +Cette option n'a aucun effet si le mode d'opération n'est pas +\fB\-\-decompress\fP ou \fB\-\-test\fP. +.IP "" +Since \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP implies \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Désactiver la création de fichiers peu denses. Par défaut, lors de la +décompression en un fichier normal, \fBxz\fP essaie d'en faire un fichier creux +si les données décompressées contiennent de longues séquences de zéros +binaires. Cela fonctionne aussi lors de l'écriture sur la sortie standard +aussi longtemps que la sortie standard est connectée à un fichier normal et +que certaines conditions supplémentaires sont satisfaites pour le faire de +manière sécurisée. Créer des fichiers creux peut épargner de l'espace disque +et accélérer la décompression en réduisant la quantité d'entrées/sorties sur +le disque. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Lors de la compression, utiliser \fB.suf\fP comme suffixe du fichier cible au +lieu de \fB.xz\fP ou \fB.lzma\fP. Si \fBxz\fP n'écrit pas sur la sortie standard et +si le fichier source a déja le suffixe \fB.suf\fP, un avertissement est affiché +et le fichier est ignoré. +.IP "" +When decompressing, recognize files with the suffix \fI.suf\fP in addition to +files with the \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, or \fB.lz\fP suffix. If the +source file has the suffix \fI.suf\fP, the suffix is removed to get the target +filename. +.IP "" +Lors de la compression ou décompression de flux bruts (\fB\-\-fomat=raw\fP), le +suffixe doit toujours être spécifié à moins d'écrire sur la sortie standard, +car il n'y a pas de suffixe par défaut pour les flux bruts. +.TP +\fB\-\-files\fP[\fB=\fP\fIfichier\fP] +Lire les noms de fichier à traiter depuis \fIfichier\fP ; si \fIfichier\fP est +omis , les noms de fichier sont lus sur l'entrée standard. Les noms de +fichier doivent se terminer avec le caractère de nouvelle ligne. Un tiret +(\fB\-\fP) est considéré comme un nom de fichier normal ; ce qui ne signifie pas +entrée standard. Si les noms de fichier sont aussi donnés comme arguments de +ligne de commande, ils sont traités avant les noms de fichier lus depuis +\fIfichier\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIfichier\fP] +Cela est identique à \fB\-\-files\fP[\fB=\fP\fIfichier\fP] sauf que chaque nom de +fichier doit se terminer par le caractère null. +. +.SS "Format de fichier basique et options de compression" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fIformat\fP +Indiquer le \fIformat\fP de fichier à compresser ou décompresser : +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +C'est celui par défaut. Lors de la compression, \fBauto\fP est équivalent à +\fBxz\fP. Lors de la décompression, le format du fichier en entrée est détecté +automatiquement. Notez que les flux bruts (créés avec \fB\-\-format=raw\fP) ne +peuvent pas être détectés automatiquement. +.TP +\fBxz\fP +Compresser dans le format de fichier \fB.xz\fP ou n'accepter que les fichiers +\&\fB.xz\fP à décompresser. +.TP +\fBlzma\fP, \fBalone\fP +Compresser au format de fichier \fB.lzma\fP historique, ou n'accepter que les +fichiers \fB.lzma\fP lors de la décompression. Le nom alternatif \fBalone\fP est +fourni pour la rétrocompatibilité avec les utilitaires LZMA. +.TP +\fBlzip\fP +Accept only \fB.lz\fP files when decompressing. Compression is not supported. +.IP "" +The \fB.lz\fP format versions 0 and 1 are supported. Version 0 files were +produced by \fBlzip\fP 1.3 and older. Such files aren't common but may be +found from file archives as a few source packages were released in this +format. People might have old personal files in this format too. +Decompression support for the format version 0 was removed in \fBlzip\fP 1.18. +\fBlzip\fP 1.4 and later create files in the format version 1. +.TP +\fBraw\fP +Compresser ou décompresser un flux brut (sans en\-têtes). Cela est réservé +seulement aux utilisateurs aguerris. Pour décoder des flux bruts, vous devez +utiliser \fB\-\-format=raw\fP et spécifier explicitement la chaîne de filtre, qui +normalement aurait du être stockée dans les en\-têtes du conteneur. +.RE +.TP +\fB\-C\fP \fIvérif.\fP, \fB\-\-check=\fP\fIvérif.\fP +Spécifier le type d'intégrité à vérifier. La vérification est calculée à +partir des données non\-compressées et stockées dans le fichier \fB.xz\fP. Cette +option n'a effet que si la compression a été faite dans le format \fB.xz\fP ; +le format \fB.lzma\fP ne gère pas les vérifications d'intégrité. Le contrôle +d'intégrité (s'il y en a) est vérifié lorsque le fichier \fB.xz\fP est +décompressé. +.IP "" +Types de \fIvérification\fP pris en charge : +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Ne pas calculer de vérification d'intégrité du tout. C'est généralement une +mauvaise idée. Cela peut être utile lorsque l'intégrité des données est +vérifiée de toute façon par d'autres manières. +.TP +\fBcrc32\fP +Calculer CRC32 en utilisant le polynôme de IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Calculer CRC64 en utilisant le polynôme de ECMA\-182. C'est la manière +utilisée par défaut, car c'est légèrement mieux que CRC32 pour détecter les +fichiers endommagés et la différence de vitesse est négligeable. +.TP +\fBsha256\fP +Calculer SHA\-256. C'est quelque peu plus lent que CRC32 et CRC64. +.RE +.IP "" +L'intégrité des en\-têtes \fB.xz\fP est toujours vérifiée avec CRC32. Il n'est +pas possible de le changer ou de le désactiver. +.TP +\fB\-\-ignore\-check\fP +Ne pas contrôler la vérification d'intégrité des données lors de la +décompression. Les valeurs CRC32 dans les en\-têtes \fB.xz\fP seront normalement +toujours vérifiées. +.IP "" +\fBN'utilisez pas cette option à moins de savoir ce que vous faites.\fP Les +raisons possibles pour utiliser cette option : +.RS +.IP \(bu 3 +Essayer de récupérer des données d'un fichier .xz corrompu. +.IP \(bu 3 +Accélérer la décompression. Cela importe surtout avec SHA\-256 ou avec les +fichiers qui ont été compressés extrêmement bien. Il est recommandé de ne +pas utiliser cette option dans ce but à moins que l'intégrité du fichier ne +soit vérifiée extérieurement d'une autre manière. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Choisir un niveau de compression prédéfini. La valeur par défaut est +\fB6\fP. Si plusieurs niveaux de préréglage sont spécifiés, c'est le dernier +qui sera pris en compte. Si une chaîne de filtres personnalisée a déjà été +choisie, définir un niveau de compression préréglé efface la chaîne de +filtres personnalisée. +.IP "" +Les différences entre les préréglages sont plus significatives qu'avec +\fBgzip\fP(1) et \fBbzip2\fP(1). les réglages de compression sélectionnés +déterminent les exigences en mémoire pour la décompression, ainsi, utiliser +un niveau de préréglage trop élevé peut rendre difficile à décompresser un +fichier sur un vieux système avec peu de RAM. Clairement, \fBce n'est pas une bonne idée d'utiliser \-9 aveuglément pour tout\fP comme ça l'est souvent avec +\fBgzip\fP(1) et \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Ce sont des préréglages relativement rapides. \fB0\fP est parfois plus rapide +que \fBgzip \-9\fP tout en compressant bien mieux. Les réglages plus élevés ont +souvent une rapidité comparable à celle de \fBbzip2\fP(1) avec un taux de +compression comparable ou meilleur, même si les résultats dépendent beaucoup +du genre de données compressées. +.TP +\fB\-4\fP ... \fB\-6\fP +Good to very good compression while keeping decompressor memory usage +reasonable even for old systems. \fB\-6\fP is the default, which is usually a +good choice for distributing files that need to be decompressible even on +systems with only 16\ MiB RAM. (\fB\-5e\fP or \fB\-6e\fP may be worth considering +too. See \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +C'est comme \fB\-6\fP mais avec des besoins en mémoire plus élevés pour la +compression et la décompression. Ce n'est utile que lorsque les fichiers +sont plus gros que 8\ Mio, 16\ Mio et 32\ Mio respectivement. +.RE +.IP "" +Sur le même matériel, la vitesse de décompression est sensiblement un nombre +constant d'octets de données compressées par seconde. En d'autres termes, +meilleure est la compression, plus rapide sera en général la +décompression. Cela signifie aussi que la quantité de sortie non compressée +produite par seconde peut varier beaucoup. +.IP "" +Le tableau suivant résume les caractéristiques des préréglages : +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Préréglage;DictSize;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Descriptions des colonnes : +.RS +.IP \(bu 3 +DictSize est la taille du dictionnaire de LZMA2. Utiliser un dictionnaire +plus gros que la taille du fichier non compressé est un gaspillage de +mémoire. C'est pourquoi il est bon d'éviter d'utiliser les préréglages de +\fB\-7\fP à \fB\-9\fP lorsqu'il n'y en a pas vraiment besoin. A \fB\-6\fP et plus bas, +la quantité de mémoire gaspillée est généralement assez basse pour ne pas +être un problème. +.IP \(bu 3 +CompCPU est une représentation des préréglages de LZMA2 qui affectent la +vitesse de compression. La taille du dictionnaire aussi affecte la vitesse, +alors comme CompCPU est le même pour les niveaux de \fB\-6\fP à \fB\-9\fP, les plus +haut niveaux tendent à être un peu moins rapides. Pour être encore moins +rapide et du coup obtenir peut être une meilleure compression, consultez +\fB\-\-extreme\fP. +.IP \(bu 3 +CompMem contains the compressor memory requirements in the single\-threaded +mode. It may vary slightly between \fBxz\fP versions. +.IP \(bu 3 +DecMem contient les besoins en mémoire du décompresseur. Ce sont les +réglages de la compression qui déterminent les besoins en mémoire de la +décompression. L'exacte utilisation de la mémoire est légèrement supérieure +à la taille du dictionnaire LZMA2, mais les valeurs dans la table ont été +arrondies au prochain Mio supérieur. +.RE +.IP "" +Memory requirements of the multi\-threaded mode are significantly higher than +that of the single\-threaded mode. With the default value of +\fB\-\-block\-size\fP, each thread needs 3*3*DictSize plus CompMem or DecMem. For +example, four threads with preset \fB\-6\fP needs 660\(en670\ MiB of memory. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Utilisez un variant plus lent que les préréglages (\fB\-0\fP à \fB\-9\fP) pour +espérer avoir un taux de compression légèrement meilleur, mais en cas de +malchance cela peut être pire. L'utilisation mémoire du décompresseur n'est +pas affectée, mais l'utilisation mémoire du compresseur augmente un peu aux +niveaux de préréglages de \fB\-0\fP à \fB\-3\fP. +.IP "" +Depuis qu'il y a deux préréglages avec des tailles de dictionnaire de 4\ Mio +et 8 \Mio, les préréglages \fB\-3e\fP et \fB\-5e\fP utilisent des réglages +légèrement plus rapides que \fB\-4e\fP et \fB\-6e\fP, respectivement. De cette +manière, il n'y a pas deux préréglages identiques. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Préréglage;DictSize;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Par exemple, il y a un total de quatre préréglages qui utilisent un +dictionnaire de 8 Mio et qui sont dans l'ordre du plus rapide au plus lent : +\fB\-5\fP, \fB\-6\fP, \fB\-5e\fP et \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Il y a néanmoins des alias trompeurs pour \fB\-0\fP et \fB\-9\fP, +respectivement. Ils ne sont fournis que pour des besoins de +rétro\-compatibilité avec les utilitaires LZMA. Evitez d'utiliser ces +options. +.TP +\fB\-\-block\-size=\fP\fItaille\fP +Lors de la compression dans le format \fB.xz\fP, les données de l'entrée sont +réparties en blocs de \fItaille\fP octets. Les blocs sont compressés +indépendamment les un des autres, ce qui aide avec le mode multithread +(multi\-threading) et rend possible la décompression à accès aléatoire +limité. Cette option est typiquement utilisée pour outrepasser la taille de +bloc en mode multithread, mais cette option peut aussi être utilisée en mode +single\-thread. +.IP "" +In multi\-threaded mode about three times \fIsize\fP bytes will be allocated in +each thread for buffering input and output. The default \fIsize\fP is three +times the LZMA2 dictionary size or 1 MiB, whichever is more. Typically a +good value is 2\(en4 times the size of the LZMA2 dictionary or at least 1 +MiB. Using \fIsize\fP less than the LZMA2 dictionary size is waste of RAM +because then the LZMA2 dictionary buffer will never get fully used. In +multi\-threaded mode, the sizes of the blocks are stored in the block +headers. This size information is required for multi\-threaded +decompression. +.IP "" +In single\-threaded mode no block splitting is done by default. Setting this +option doesn't affect memory usage. No size information is stored in block +headers, thus files created in single\-threaded mode won't be identical to +files created in multi\-threaded mode. The lack of size information also +means that \fBxz\fP won't be able decompress the files in multi\-threaded mode. +.TP +\fB\-\-block\-list=\fP\fIitems\fP +When compressing to the \fB.xz\fP format, start a new block with an optional +custom filter chain after the given intervals of uncompressed data. +.IP "" +The \fIitems\fP are a comma\-separated list. Each item consists of an optional +filter chain number between 0 and 9 followed by a colon (\fB:\fP) and a +required size of uncompressed data. Omitting an item (two or more +consecutive commas) is a shorthand to use the size and filters of the +previous item. +.IP "" +If the input file is bigger than the sum of the sizes in \fIitems\fP, the last +item is repeated until the end of the file. A special value of \fB0\fP may be +used as the last size to indicate that the rest of the file should be +encoded as a single block. +.IP "" +An alternative filter chain for each block can be specified in combination +with the \fB\-\-filters1=\fP\fIfilters\fP \&...\& \fB\-\-filters9=\fP\fIfilters\fP options. +These options define filter chains with an identifier between 1\(en9. +Filter chain 0 can be used to refer to the default filter chain, which is +the same as not specifying a filter chain. The filter chain identifier can +be used before the uncompressed size, followed by a colon (\fB:\fP). For +example, if one specifies \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP +then blocks will be created using: +.RS +.IP \(bu 3 +The filter chain specified by \fB\-\-filters1\fP and 2 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters3\fP and 2 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters2\fP and 4 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters2\fP and 4 MiB input +.IP \(bu 3 +The default filter chain and 2 MiB input +.IP \(bu 3 +The default filter chain and 4 MiB input for every block until end of input. +.RE +.IP "" +If one specifies a size that exceeds the encoder's block size (either the +default value in threaded mode or the value specified with +\fB\-\-block\-size=\fP\fIsize\fP), the encoder will create additional blocks while +keeping the boundaries specified in \fIitems\fP. For example, if one specifies +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP and the +input file is 80 MiB, one will get 11 blocks: 5, 10, 8, 10, 2, 10, 10, 4, +10, 10, and 1 MiB. +.IP "" +En mode multi\-threadé les tailles de blocs sont stockées dans les en\-têtes +du bloc. Cela ne se fait pas en mode mono\-threadé, la sortie encodée ne sera +donc pas identique à celle faite en mode multi\-threadé. +.TP +\fB\-\-flush\-timeout=\fP\fItemps_d'attente\fP +Lors de la compression, si plus que \fItemps_d'attente\fP millisecondes (un +entier positif) se sont écoulées depuis le précédent vidage et que lire plus +de données bloquerait, toutes les données d'entrée en attente sont vidées de +l'encodeur et mises à disposition dans le flux de sortie. Cela peut être +utile si \fBxz\fP est utilisé pour compresser les données qui sont diffusées +sur un réseau. Des petites valeurs de \fItemps_d'attente\fP rendent les données +disponibles à l'extrémité réceptrice avec un léger retard, mais les grandes +valeurs de \fItemps_d'attente\fP donnent un meilleur taux de compression. +.IP "" +Cette option est désactivée par défaut. Si cette option est indiquée plus +d'une fois, la dernière prend effet. La valeur spéciale de +\fItemps_d'attente\fP de \fB0\fP peut être utilisée pour explicitement désactiver +cette option. +.IP "" +Cette option n'est pas disponible sur les systèmes qui ne sont pas POSIX. +.IP "" +.\" FIXME +\fBCette option est encore expérimentale.\fP Actuellement, \fBxz\fP ne convient +pas pour décompresser le flux en temps réel en raison de la façon dont \fBxz\fP +effectue la mise en mémoire tampon. +.TP +\fB\-\-no\-sync\fP +Do not synchronize the target file and its directory to the storage device +before removing the source file. This can improve performance if +compressing or decompressing many small files. However, if the system +crashes soon after the deletion, it is possible that the target file was not +written to the storage device but the delete operation was. In that case +neither the original source file nor the target file is available. +.IP "" +This option has an effect only when \fBxz\fP is going to remove the source +file. In other cases synchronization is never done. +.IP "" +The synchronization and \fB\-\-no\-sync\fP were added in \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIlimite\fP +Indiquer une limite d'utilisation de la mémoire pour la compression. Si +cette option est indiquée plusieurs fois, c'est la dernière qui est prise en +compte. +.IP "" +If the compression settings exceed the \fIlimit\fP, \fBxz\fP will attempt to +adjust the settings downwards so that the limit is no longer exceeded and +display a notice that automatic adjustment was done. The adjustments are +done in this order: reducing the number of threads, switching to +single\-threaded mode if even one thread in multi\-threaded mode exceeds the +\fIlimit\fP, and finally reducing the LZMA2 dictionary size. +.IP "" +When compressing with \fB\-\-format=raw\fP or if \fB\-\-no\-adjust\fP has been +specified, only the number of threads may be reduced since it can be done +without affecting the compressed output. +.IP "" +If the \fIlimit\fP cannot be met even with the adjustments described above, an +error is displayed and \fBxz\fP will exit with exit status 1. +.IP "" +La \fIlimite\fP peut être indiquée de plusieurs façons : +.RS +.IP \(bu 3 +La \fIlimite\fP peut être une valeur absolue en octets. Utiliser un suffixe +d'entier comme \fBMiB\fP peut être utile. Exemple : +\fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +La \fIlimite\fP peut être indiquée sous forme d'un pourcentage de la mémoire +physique totale (RAM). Cela peut être particulièrement utile quand la +variable d'environnement \fBXZ_DEFAULTS\fP est indiquée dans un script +d'initialisation de l'interpréteur partagé entre différents ordinateurs. De +cette façon la limite est automatiquement plus grande sur les systèmes avec +plus de mémoire. Exemple : \fB\-\-memlimit=70%\fP +.IP \(bu 3 +The \fIlimit\fP can be reset back to its default value by setting it to \fB0\fP. +This is currently equivalent to setting the \fIlimit\fP to \fBmax\fP (no memory +usage limit). +.RE +.IP "" +For 32\-bit \fBxz\fP there is a special case: if the \fIlimit\fP would be over +\fB4020\ MiB\fP, the \fIlimit\fP is set to \fB4020\ MiB\fP. On MIPS32 \fB2000\ MiB\fP +is used instead. (The values \fB0\fP and \fBmax\fP aren't affected by this. A +similar feature doesn't exist for decompression.) This can be helpful when +a 32\-bit executable has access to 4\ GiB address space (2 GiB on MIPS32) +while hopefully doing no harm in other situations. +.IP "" +Voir aussi la section \fButilisation de la mémoire\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIlimite\fP +Régler une limite d'utilisation de la mémoire pour la décompression. Cela a +un effet sur le mode \fB\-\-list\fP. Si l'opération n'est pas possible sans +dépasser la \fIlimite\fP, \fBxz\fP affichera une erreur et la décompression +échouera. Voir \fB\-\-memlimit\-compress=\fP\fIlimite\fP pour les manières possibles +d'indiquer la \fIlimite\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimit\fP +Set a memory usage limit for multi\-threaded decompression. This can only +affect the number of threads; this will never make \fBxz\fP refuse to +decompress a file. If \fIlimit\fP is too low to allow any multi\-threading, the +\fIlimit\fP is ignored and \fBxz\fP will continue in single\-threaded mode. Note +that if also \fB\-\-memlimit\-decompress\fP is used, it will always apply to both +single\-threaded and multi\-threaded modes, and so the effective \fIlimit\fP for +multi\-threading will never be higher than the limit set with +\fB\-\-memlimit\-decompress\fP. +.IP "" +In contrast to the other memory usage limit options, +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimit\fP has a system\-specific default +\fIlimit\fP. \fBxz \-\-info\-memory\fP can be used to see the current value. +.IP "" +This option and its default value exist because without any limit the +threaded decompressor could end up allocating an insane amount of memory +with some input files. If the default \fIlimit\fP is too low on your system, +feel free to increase the \fIlimit\fP but never set it to a value larger than +the amount of usable RAM as with appropriate input files \fBxz\fP will attempt +to use that amount of memory even with a low number of threads. Running out +of memory or swapping will not improve decompression performance. +.IP "" +See \fB\-\-memlimit\-compress=\fP\fIlimit\fP for possible ways to specify the +\fIlimit\fP. Setting \fIlimit\fP to \fB0\fP resets the \fIlimit\fP to the default +system\-specific value. +.TP +\fB\-M\fP \fIlimite\fP, \fB\-\-memlimit=\fP\fIlimite\fP, \fB\-\-memory=\fP\fIlimite\fP +This is equivalent to specifying \fB\-\-memlimit\-compress=\fP\fIlimit\fP +\fB\-\-memlimit\-decompress=\fP\fIlimit\fP \fB\-\-memlimit\-mt\-decompress=\fP\fIlimit\fP. +.TP +\fB\-\-no\-adjust\fP +Display an error and exit if the memory usage limit cannot be met without +adjusting settings that affect the compressed output. That is, this +prevents \fBxz\fP from switching the encoder from multi\-threaded mode to +single\-threaded mode and from reducing the LZMA2 dictionary size. Even when +this option is used the number of threads may be reduced to meet the memory +usage limit as that won't affect the compressed output. +.IP "" +Automatic adjusting is always disabled when creating raw streams +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fIthreads\fP, \fB\-\-threads=\fP\fIthreads\fP +Specify the number of worker threads to use. Setting \fIthreads\fP to a +special value \fB0\fP makes \fBxz\fP use up to as many threads as the processor(s) +on the system support. The actual number of threads can be fewer than +\fIthreads\fP if the input file is not big enough for threading with the given +settings or if using more threads would exceed the memory usage limit. +.IP "" +The single\-threaded and multi\-threaded compressors produce different +output. Single\-threaded compressor will give the smallest file size but +only the output from the multi\-threaded compressor can be decompressed using +multiple threads. Setting \fIthreads\fP to \fB1\fP will use the single\-threaded +mode. Setting \fIthreads\fP to any other value, including \fB0\fP, will use the +multi\-threaded compressor even if the system supports only one hardware +thread. (\fBxz\fP 5.2.x used single\-threaded mode in this situation.) +.IP "" +To use multi\-threaded mode with only one thread, set \fIthreads\fP to \fB+1\fP. +The \fB+\fP prefix has no effect with values other than \fB1\fP. A memory usage +limit can still make \fBxz\fP switch to single\-threaded mode unless +\fB\-\-no\-adjust\fP is used. Support for the \fB+\fP prefix was added in \fBxz\fP +5.4.0. +.IP "" +If an automatic number of threads has been requested and no memory usage +limit has been specified, then a system\-specific default soft limit will be +used to possibly limit the number of threads. It is a soft limit in sense +that it is ignored if the number of threads becomes one, thus a soft limit +will never stop \fBxz\fP from compressing or decompressing. This default soft +limit will not make \fBxz\fP switch from multi\-threaded mode to single\-threaded +mode. The active limits can be seen with \fBxz \-\-info\-memory\fP. +.IP "" +Actuellement, la seule méthode de gestion avec des threads consiste à +séparer l'entrée en blocs et de les compresser indépendamment les uns des +autres. La taille par défaut des blocs dépend du niveau de compression et +peut\-être remplacée avec l'option \fB\-\-block\-size=\fP\fItaille\fP. +.IP "" +Threaded decompression only works on files that contain multiple blocks with +size information in block headers. All large enough files compressed in +multi\-threaded mode meet this condition, but files compressed in +single\-threaded mode don't even if \fB\-\-block\-size=\fP\fIsize\fP has been used. +.IP "" +The default value for \fIthreads\fP is \fB0\fP. In \fBxz\fP 5.4.x and older the +default is \fB1\fP. +. +.SS "Chaînes de filtres de compresseur personnalisées" +A custom filter chain allows specifying the compression settings in detail +instead of relying on the settings associated to the presets. When a custom +filter chain is specified, preset options (\fB\-0\fP \&...\& \fB\-9\fP and +\fB\-\-extreme\fP) earlier on the command line are forgotten. If a preset +option is specified after one or more custom filter chain options, the new +preset takes effect and the custom filter chain options specified earlier +are forgotten. +.PP +Une chaîne de filtre est comparable à une redirection (pipe) sur la ligne de +commande. Lors de la compression, les entrées non compressées vont au +premier filtre, dont la sortie va au prochain filtre (s'il y en a). La +sortie du dernier filtre est écrite sur le fichier compressé. Le nombre +maximal de filtres dans la chaîne est quatre, mais habituellement, un chaîne +de filtre n'a qu'un ou deux filtres. +.PP +Beaucoup de filtres ont des limitations sur l'endroit où ils peuvent se +placer dans la chaîne de filtre : quelques filtres ne peuvent fonctionner +qu'en tant que dernier filtre dans la chaîne, quelques uns en tant que non +dernier filtre, et d'autres à n'importe quelle position dans la +chaîne. Suivant le filtre, cette limitation est soit inhérente au profil du +filtre, soit existe pour des raisons de sécurité. +.PP +A custom filter chain can be specified in two different ways. The options +\fB\-\-filters=\fP\fIfilters\fP and \fB\-\-filters1=\fP\fIfilters\fP \&...\& +\fB\-\-filters9=\fP\fIfilters\fP allow specifying an entire filter chain in one +option using the liblzma filter string syntax. Alternatively, a filter +chain can be specified by using one or more individual filter options in the +order they are wanted in the filter chain. That is, the order of the +individual filter options is significant! When decoding raw streams +(\fB\-\-format=raw\fP), the filter chain must be specified in the same order as +it was specified when compressing. Any individual filter or preset options +specified before the full chain option (\fB\-\-filters=\fP\fIfilters\fP) will be +forgotten. Individual filters specified after the full chain option will +reset the filter chain. +.PP +Both the full and individual filter options take filter\-specific \fIoptions\fP +as a comma\-separated list. Extra commas in \fIoptions\fP are ignored. Every +option has a default value, so specify those you want to change. +.PP +Pour voir l'entièreté de la chaîne de filtres et ses \fIoptions\fP, utilisez +\fBxz \-vv\fP (ce qui est comme utiliser \fB\-\-verbose\fP deux fois). Cela +fonctionne aussi pour voir les options de chaîne de filtres utilisées par +les préréglages. +.TP +\fB\-\-filters=\fP\fIfilters\fP +Specify the full filter chain or a preset in a single option. Each filter +can be separated by spaces or two dashes (\fB\-\-\fP). \fIfilters\fP may need to be +quoted on the shell command line so it is parsed as a single option. To +denote \fIoptions\fP, use \fB:\fP or \fB=\fP. A preset can be prefixed with a \fB\-\fP +and followed with zero or more flags. The only supported flag is \fBe\fP to +apply the same options as \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIfilters\fP ... \fB\-\-filters9\fP=\fIfilters\fP +Specify up to nine additional filter chains that can be used with +\fB\-\-block\-list\fP. +.IP "" +For example, when compressing an archive with executable files followed by +text files, the executable part could use a filter chain with a BCJ filter +and the text part only the LZMA2 filter. +.TP +\fB\-\-filters\-help\fP +Display a help message describing how to specify presets and custom filter +chains in the \fB\-\-filters\fP and \fB\-\-filters1=\fP\fIfilters\fP \&...\& +\fB\-\-filters9=\fP\fIfilters\fP options, and exit successfully. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIoptions\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIoptions\fP] +.PD +Ajouter le filtre LZMA1 ou LZMA2 à la chaîne de filtres. Ces filtres ne +peuvent être utilisés que comme dernier filtre dans la chaîne. +.IP "" +LZMA1 est un filtre historique, qui n'est pris en charge presque uniquement +à cause de l'ancien format de fichier \fB.lzma\fP, qui ne prend en charge que +LZMA1. LZMA2 est une version mise à jour de LZMA1 pour régler certains +problèmes pratiques de LZMA1. Le format \fBxz\fP utilise LZMA2 et ne prend pas +du tout en charge LZMA1. Les taux et vitesses de compression de LZMA1 et +LZMA2 sont pratiquement identiques. +.IP "" +LZMA1 et LZMA2 partagent le même ensemble d'\fIoptions\fP : +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIpréréglage\fP +Reset all LZMA1 or LZMA2 \fIoptions\fP to \fIpreset\fP. \fIPreset\fP consist of an +integer, which may be followed by single\-letter preset modifiers. The +integer can be from \fB0\fP to \fB9\fP, matching the command line options \fB\-0\fP +\&...\& \fB\-9\fP. The only supported modifier is currently \fBe\fP, which matches +\fB\-\-extreme\fP. If no \fBpreset\fP is specified, the default values of LZMA1 or +LZMA2 \fIoptions\fP are taken from the preset \fB6\fP. +.TP +\fBdict=\fP\fItaille\fP +La \fItaille\fP du dictionnaire (historique du tampon) indique combien d'octets +des données récement décompressées sont gardés en mémoire. L'algorithme +essaie de trouver les séquences d'octets répétées (identiques) dans les +données décompressées et les remplace par les données actuellement dans le +dictionnaire. Plus gros est le dictionnaire, plus grande est la chance de +trouver une correspondance. Ainsi, l'augmentation de la \fItaille\fP du +dictionnaire augmente habituellement le taux de compression, mais un +dictionnaire plus gros que le fichier non compressé est un gachis de +mémoire. +.IP "" +Généralement la \fItaille\fP du dictionnaire est entre 64\ Kio et 64\ Mio. Le +minimum étant 4\ Kio. La \fItaille\fP maximale pour la compression est +habituellement 1,5\ Gio (1536\ Mio). Le décompresseur prend en charge les +dictionnaires jusqu'à un octet de moins que 4\ Gio, ce qui est le maximum +pour les formats de flux LZMA1 et LZMA2. +.IP "" +La \fItaille\fP du dictionnaire et le chercheur de correspondance (match +finder) (\fImf\fP) déterminent ensemble l'utilisation de la mémoire de +l'encodeur LZMA1 ou LZMA2. La même (ou une plus grosse) \fItaille\fP de +dictionnaire est requise pour décompresser que ce qui a été utilisé pour la +compression, ainsi l'utilisation de la mémoire du décodeur est déterminée +par la taille du dictionnaire utilisée lors de la compression. Les en\-têtes +de \fB.xz\fP stockent la \fItaille\fP de dictionnaire sous la forme 2^\fIn\fP ou +2^\fIn\fP + 2^(\fIn\fP\-1), de sorte que ces \fItailles\fP sont quelque peu préférées +pour la compression. Les autres \fItailles\fP seront arrondies à la hausse +lorsque stockées dans les en\-têtes de \fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Spécifiez le nombre d'octets de contexte littéraux. Le minimum est \fB0\fP et +le maximum est \fB4\fP. La valeur par défaut est \fB3\fP. En plus, la somme de +\fIlc\fP et \fIlp\fP ne doit pas excéder \fB4\fP. +.IP "" +Tous les octets qui ne peuvent pas être codés comme des correspondances sont +codés comme des littéraux. C'est à dire que les littéraux sont simplement +des octets 8 bits encodés un à la fois. +.IP "" +The literal coding makes an assumption that the highest \fIlc\fP bits of the +previous uncompressed byte correlate with the next byte. For example, in +typical English text, an upper\-case letter is often followed by a lower\-case +letter, and a lower\-case letter is usually followed by another lower\-case +letter. In the US\-ASCII character set, the highest three bits are 010 for +upper\-case letters and 011 for lower\-case letters. When \fIlc\fP is at least +3, the literal coding can take advantage of this property in the +uncompressed data. +.IP "" +The default value (3) is usually good. If you want maximum compression, +test \fBlc=4\fP. Sometimes it helps a little, and sometimes it makes +compression worse. If it makes it worse, test \fBlc=2\fP too. +.TP +\fBlp=\fP\fIlp\fP +Indiquer le nombre de bits de position littérale. Le minimum est \fB0\fP et le +maximum \fB4\fP; par défaut c'est \fB0\fP. +.IP "" +\fILp\fP affecte le type d'alignement dans les données décompressées qui est +présumé lors de l'encodage des littéraux. Voir \fIpb\fP ci dessous pour plus +d'information sur l'alignement. +.TP +\fBpb=\fP\fIpb\fP +Indiquer le nombre de bits de position. Le minimum est \fB0\fP et le maximum +\fB4\fP; par défaut \fB2\fP. +.IP "" +\fIPb\fP affecte quel genre d'alignement est présumé en général dans les +données non compressées. Par défaut c'est un alignement de quatre octets +(2^\fIpb\fP=2^2=4), ce qui est généralement un bon choix lorsqu'il n'y a pas de +meilleure estimation. +.IP "" +When the alignment is known, setting \fIpb\fP accordingly may reduce the file +size a little. For example, with text files having one\-byte alignment +(US\-ASCII, ISO\-8859\-*, UTF\-8), setting \fBpb=0\fP can improve compression +slightly. For UTF\-16 text, \fBpb=1\fP is a good choice. If the alignment is +an odd number like 3 bytes, \fBpb=0\fP might be the best choice. +.IP "" +Même si l'alignement présumé peut être ajusté avec \fIpb\fP et \fIlp\fP, LZMA1 et +LZMA2 favorisent toujours légèrement l'alignement sur 16 octets. Il peut +être utile d'en tenir compte lors de la conception de formats de fichiers +susceptibles d'être souvent compressés avec LZMA1 ou LZMA2. +.TP +\fBmf=\fP\fImf\fP +Match finder has a major effect on encoder speed, memory usage, and +compression ratio. Usually Hash Chain match finders are faster than Binary +Tree match finders. The default depends on the \fIpreset\fP: 0 uses \fBhc3\fP, +1\(en3 use \fBhc4\fP, and the rest use \fBbt4\fP. +.IP "" +Les chercheurs de correspondance suivants sont pris en charge. Les formules +d'utilisation de la mémoire ci\-dessous sont des approximations grossières +qui sont les plus proches de la réalité lorsque \fIdict\fP est une puissance de +deux. +.RS +.TP +\fBhc3\fP +Chaîne de hachage avec hachage de 2 et 3 octets +.br +Valeur minimale pour \fInice\fP : \fB3\fP +.br +Utilisation de la mémoire : +.br +\fIdict\fP * 7.5 (if \fIdict\fP <= 16 Mio); +.br +\fIdict\fP * 5.5 + 64 MiB (si \fIdict\fP > 16 Mio) +.TP +\fBhc4\fP +Chaîne de hachage avec hachage de 2, 3 et 4 octets +.br +Valeur minimale pour \fInice\fP : \fB4\fP +.br +Utilisation de la mémoire : +.br +\fIdict\fP * 7.5 (si \fIdict\fP <= 32 Mio); +.br +\fIdict\fP * 6.5 (si \fIdict\fP > 32 Mio) +.TP +\fBbt2\fP +Arbre binaire avec hachage de 2 octets +.br +Valeur minimale pour \fInice\fP : \fB2\fP +.br +Utilisation de la mémoire : \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Arbre binaire avec hachage de 2 et 3 octets +.br +Valeur minimale pour \fInice\fP : \fB3\fP +.br +Utilisation de la mémoire : +.br +\fIdict\fP * 11.5 (si \fIdict\fP <= 16 Mio); +.br +\fIdict\fP * 9.5 + 64 MiB (si \fIdict\fP > 16 Mio) +.TP +\fBbt4\fP +Arbre binaire avec hachage 2, 3 et 4 octets +.br +Valeur minimale pour \fInice\fP : \fB4\fP +.br +Utilisation de la mémoire : +.br +\fIdict\fP * 11.5 (si \fIdict\fP <= 32 Mio); +.br +\fIdict\fP * 10.5 (si \fIdict\fP > 32 Mio) +.RE +.TP +\fBmode=\fP\fImode\fP +Compression \fImode\fP specifies the method to analyze the data produced by the +match finder. Supported \fImodes\fP are \fBfast\fP and \fBnormal\fP. The default is +\fBfast\fP for \fIpresets\fP 0\(en3 and \fBnormal\fP for \fIpresets\fP 4\(en9. +.IP "" +Habituellement, \fBfast\fP est utilisé avec les chercheurs de correspondance de +chaîne de hachage et \fBnormal\fP avec les chercheurs de correspondance d'arbre +binaire. C'est aussi ce que font les \fIpréréglages\fP. +.TP +\fBnice=\fP\fInice\fP +Spécifier ce qui est considéré comme une bonne longueur pour une +correspondance. Une fois que la correspondance d'au moins \fInice\fP octets est +trouvée, l'algorithme arrête de chercher de meilleures correspondances +possibles. +.IP "" +\fINice\fP can be 2\(en273 bytes. Higher values tend to give better +compression ratio at the expense of speed. The default depends on the +\fIpreset\fP. +.TP +\fBdepth=\fP\fIprofondeur\fP +Spécifier la profondeur de recherche maximale dans l'outil de recherche de +correspondances. La valeur par défaut est \fB0\fP, ce qui fait que le +compresseur détermine une \fIprofondeur\fP raisonnable en fonction de \fImf\fP et +\fInice\fP. +.IP "" +Reasonable \fIdepth\fP for Hash Chains is 4\(en100 and 16\(en1000 for Binary +Trees. Using very high values for \fIdepth\fP can make the encoder extremely +slow with some files. Avoid setting the \fIdepth\fP over 1000 unless you are +prepared to interrupt the compression in case it is taking far too long. +.RE +.IP "" +Lors du décodage des flux bruts (\fB\-\-format=raw\fP), LZMA2 nécessite seulement +la \fItaille\fP du dictionnaire. LZMA1 nécessite aussi \fIlc\fP, \fIlp\fP et \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIoptions\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIoptions\fP] +.PD +Ajouter un filtre branch/call/jump (BCJ) à la chaîne de filtres. Ces filtres +ne peuvent être utilisés que s'ils ne sont pas le dernier filtre de la +chaîne de filtrage. +.IP "" +A BCJ filter converts relative addresses in the machine code to their +absolute counterparts. This doesn't change the size of the data but it +increases redundancy, which can help LZMA2 to produce 0\(en15\ % smaller +\&\fB.xz\fP file. The BCJ filters are always reversible, so using a BCJ filter +for wrong type of data doesn't cause any data loss, although it may make the +compression ratio slightly worse. The BCJ filters are very fast and use an +insignificant amount of memory. +.IP "" +Ces filtres BCJ présentent des problèmes connus liés au taux de +compression : +.RS +.IP \(bu 3 +Some types of files containing executable code (for example, object files, +static libraries, and Linux kernel modules) have the addresses in the +instructions filled with filler values. These BCJ filters will still do the +address conversion, which will make the compression worse with these files. +.IP \(bu 3 +If a BCJ filter is applied on an archive, it is possible that it makes the +compression ratio worse than not using a BCJ filter. For example, if there +are similar or even identical executables then filtering will likely make +the files less similar and thus compression is worse. The contents of +non\-executable files in the same archive can matter too. In practice one +has to try with and without a BCJ filter to see which is better in each +situation. +.RE +.IP "" +Different instruction sets have different alignment: the executable file +must be aligned to a multiple of this value in the input data to make the +filter work. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filtre;Alignement;Notes +x86;1;32 bits ou 64 bits x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096\-byte alignment is best +PowerPC;4;Grand boutiste seulement +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Since the BCJ\-filtered data is usually compressed with LZMA2, the +compression ratio may be improved slightly if the LZMA2 options are set to +match the alignment of the selected BCJ filter. Examples: +.RS +.IP \(bu 3 +IA\-64 filter has 16\-byte alignment so \fBpb=4,lp=4,lc=0\fP is good with LZMA2 +(2^4=16). +.IP \(bu 3 +RISC\-V code has 2\-byte or 4\-byte alignment depending on whether the file +contains 16\-bit compressed instructions (the C extension). When 16\-bit +instructions are used, \fBpb=2,lp=1,lc=3\fP or \fBpb=1,lp=1,lc=3\fP is good. When +16\-bit instructions aren't present, \fBpb=2,lp=2,lc=2\fP is the best. +\fBreadelf \-h\fP can be used to check if "RVC" appears on the "Flags" line. +.IP \(bu 3 +ARM64 is always 4\-byte aligned so \fBpb=2,lp=2,lc=2\fP is the best. +.IP \(bu 3 +The x86 filter is an exception. It's usually good to stick to LZMA2's +defaults (\fBpb=2,lp=0,lc=3\fP) when compressing x86 executables. +.RE +.IP "" +Tous les filtres BCJ prennent en charge les mêmes \fIoptions\fP : +.RS +.TP +\fBstart=\fP\fIdécalage\fP +Spécifier le \fIdécalage\fP de départ qui est utilisé lors de la conversion +entre les adresses relatives et absolues. Le \fIdécalage\fP doit être un +multiple de l'alignement du filtre (voir la table ci\-dessus). Sa valeur par +défaut est zéro. En pratique, cette dernière convient ; indiquer un +\fIdécalage\fP personnalisé est la plupart du temps inutile. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIoptions\fP] +Ajouter le filtre Delta à la chaîne de filtres. Le filtre Delta ne peut être +utilisé que s'il n'est pas le dernier filtre dans la chaîne. +.IP "" +Currently only simple byte\-wise delta calculation is supported. It can be +useful when compressing, for example, uncompressed bitmap images or +uncompressed PCM audio. However, special purpose algorithms may give +significantly better results than Delta + LZMA2. This is true especially +with audio, which compresses faster and better, for example, with +\fBflac\fP(1). +.IP "" +\fIoptions\fP prises en charge : +.RS +.TP +\fBdist=\fP\fIdistance\fP +Specify the \fIdistance\fP of the delta calculation in bytes. \fIdistance\fP must +be 1\(en256. The default is 1. +.IP "" +Par exemple, avec \fBdist=2\fP et une entrée huit octets A1 B1 A2 B3 A3 B5 A4 +B7, la sortie sera A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Autres options" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Supprimer les avertissements et les notifications. Indiquer cela deux fois +supprimera aussi les erreurs. Cette option n'a aucun effet sur le statut de +sortie. Cela dit, même si un avertissement était supprimé, le statut de +sortie indiquant un avertissement sera encore utilisé. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Être bavard. Si l'erreur standard est connectée à un terminal, \fBxz\fP +affichera une barre de progression. Indiquer \fB\-\-verbose\fP deux fois donnera +une sortie encore plus bavarde. +.IP "" +La barre de progression montre l'information suivante : +.RS +.IP \(bu 3 +Le pourcentage de complétion est montré si la taille du fichier en entrée +est connue. Néanmoins, le pourcentage ne peut pas être montré en cas de +redirection. +.IP \(bu 3 +Quantité de données compressées produites (compression) ou consommées +(décompression). +.IP \(bu 3 +Quantité de données non compressées consommées (compression) ou produites +(décompression). +.IP \(bu 3 +Le taux de compression, calculé en divisant la quantité de données +compréssées déjà traitées par la quantité de données décompressées déjà +traitées. +.IP \(bu 3 +Vitesse de compression ou de décompression. Elle correspond à la quantité de +données non compressées consommées (compression) ou produites +(décompression) par seconde. Elle apparait quelques secondes après le début +du traitement du fichier par \fBxz\fP. +.IP \(bu 3 +Temps écoulé dans le format M:SS ou H:MM:SS. +.IP \(bu 3 +Estimated remaining time is shown only when the size of the input file is +known and a couple of seconds have already passed since \fBxz\fP started +processing the file. The time is shown in a less precise format which never +has any colons, for example, 2 min 30 s. +.RE +.IP "" +When standard error is not a terminal, \fB\-\-verbose\fP will make \fBxz\fP print +the filename, compressed size, uncompressed size, compression ratio, and +possibly also the speed and elapsed time on a single line to standard error +after compressing or decompressing the file. The speed and elapsed time are +included only when the operation took at least a few seconds. If the +operation didn't finish, for example, due to user interruption, also the +completion percentage is printed if the size of the input file is known. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Ne pas mettre l'état de sortie à \fB2\fP même si une condition méritant un +avertissement a été détectée. Cette option n'affecte pas le niveau de +verbosité, néanmoins, les deux options \fB\-\-quiet\fP et \fB\-\-no\-warn\fP doivent +être utilisées pour ne pas afficher d'avertissements, ni altérer le statut +de sortie. +.TP +\fB\-\-robot\fP +Afficher les messages dans un format analysable par une machine. Ceci est +destiné à faciliter l'écriture des frontaux qui voudraient utiliser \fBxz\fP +plutôt que liblzma, ce qui pourrait être le cas pour différents scripts. La +sortie avec cette option activée est destinée à rester stable sur les +différentes versions de \fBxz\fP. Consulter le paragraphe \fBROBOT MODE\fP pour +les détails. +.TP +\fB\-\-info\-memory\fP +Display, in human\-readable format, how much physical memory (RAM) and how +many processor threads \fBxz\fP thinks the system has and the memory usage +limits for compression and decompression, and exit successfully. +.TP +\fB\-h\fP, \fB\-\-help\fP +Afficher un message d'aide décrivant les options les plus couramment +utilisées et quitter. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Afficher un message d'aide décrivant toutes les options de \fBxz\fP et quitter. +.TP +\fB\-V\fP, \fB\-\-version\fP +Afficher le numéro de version de \fBxz\fP et de liblzma dans un format lisible +par un humain. Pour obtenir une sortie analysable par la machine, spécifiez +\fB\-\-robot\fP avant \fB\-\-version\fP. +. +.SH "MODE ROBOT" +The robot mode is activated with the \fB\-\-robot\fP option. It makes the output +of \fBxz\fP easier to parse by other programs. Currently \fB\-\-robot\fP is +supported only together with \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, +and \fB\-\-version\fP. It will be supported for compression and decompression in +the future. +. +.SS "Mode liste" +\fBxz \-\-robot \-\-list\fP utilise une sortie séparée par des tabulations. La +première colonne de toutes les lignes possède une chaîne qui indique le type +d'information trouvée sur cette ligne : +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +C'est toujours la première ligne au début de la liste d'un fichier. La +seconde colonne de la ligne est le nom de fichier. +.TP +\fBfile\fP +Cette ligne contient l'information globale sur le fichier \fB.xz\fP. Cette +ligne est toujours écrite après la ligne \fBname\fP. +.TP +\fBstream\fP +Ce type de ligne n'est utilisée que lorsque \fB \-\-verbose\fP a été indiquée. Il +y a autant de lignes \fBstream\fP qu'il y a de flux dans le fichier \fB.xz\fP. +.TP +\fBblock\fP +Ce type de ligne n'est utilisé seulement lorsque \fB\-\-verbose\fP a été +indiquée. Il y a autant de lignes \fBblock\fP qu'il y a de blocs dans le +fichier \fB.xz\fP. Les lignes \fBblock\fP sont affichées après toutes les lignes +\fBstream\fP ; les différents types de lignes ne sont pas imbriqués. +.TP +\fBsummary\fP +Ce type de ligne n'est utilisé que lorsque \fB\-\-verbose\fP a été indiqué deux +fois. Cette ligne est affichée après toutes les lignes \fBblock\fP. Comme la +ligne \fBfile\fP, la ligne \fBsummary\fP contient l'information globale sur le +fichier \fB.xz\fP. +.TP +\fBtotals\fP +Cette ligne est toujours la toute dernière ligne de la sortie. Elle affiche +les comptes et les tailles totaux. +.PP +Les colonnes des lignes \fBfile\fP : +.PD 0 +.RS +.IP 2. 4 +Nombre de flux dans le fichier +.IP 3. 4 +Nombre total de blocs dans le ou les flux. +.IP 4. 4 +Taille compressée du fichier +.IP 5. 4 +Taille décompressée du fichier +.IP 6. 4 +Compression ratio, for example, \fB0.123\fP. If ratio is over 9.999, three +dashes (\fB\-\-\-\fP) are displayed instead of the ratio. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Liste de noms de contrôles d'intégrité séparés par des virgules. Les chaînes +suivantes sont utilisées pour les types de vérification connus : \fBNone\fP, +\fBCRC32\fP, \fBCRC64\fP et \fBSHA256\fP. Pour le types de vérification inconnus, +\fBUnknown\-\fP\fIN\fP est utilisé, où \fIN\fP est un identifiant de vérification sous +la forme d'un nombre décimal (un ou deux chiffres). +.IP 8. 4 +Taille totale du remplissage du flux dans le fichier +.RE +.PD +.PP +Les colonnes des lignes \fBstream\fP : +.PD 0 +.RS +.IP 2. 4 +Numéro de flux (le premier flux a le numéro 1) +.IP 3. 4 +Nombre de blocs dans le flux +.IP 4. 4 +Décalage de départ compressé +.IP 5. 4 +Décalage de départ décompressé +.IP 6. 4 +Taille compressée (ne comprend pas le remplissage du flux) +.IP 7. 4 +Taille décompressée +.IP 8. 4 +Taux de compression +.IP 9. 4 +Nom de la vérification d'intégrité +.IP 10. 4 +Taille du remplissage de flux +.RE +.PD +.PP +Les colonnes des lignes \fBblock\fP : +.PD 0 +.RS +.IP 2. 4 +Numéro du flux qui contient ce bloc +.IP 3. 4 +Numéro du bloc relatif au commencement du flux (le premier bloc a pour +numéro 1) +.IP 4. 4 +Numéro du bloc relatif au début du fichier +.IP 5. 4 +Décalage de départ compressé relatif au début du fichier +.IP 6. 4 +Décalage de départ décompressé relatif au début du fichier +.IP 7. 4 +Taille compressée totale du bloc (en\-têtes inclus) +.IP 8. 4 +Taille décompressée +.IP 9. 4 +Taux de compression +.IP 10. 4 +Nom de la vérification d'intégrité +.RE +.PD +.PP +Si \fB\-\-verbose\fP a été indiqué deux fois, les colonnes additionnelles sont +inclues sur les lignes \fBblock\fP. Elles ne sont pas affichées avec un seul +\fB\-\-verbose\fP, car l'obtention de ces informations nécessite de nombreuses +recherches et peut donc être lente : +.PD 0 +.RS +.IP 11. 4 +Valeur de la vérification d'intégrité en hexadécimal +.IP 12. 4 +Taille d'en\-tête de bloc +.IP 13. 4 +Drapeaux du bloc : \fBc\fP indique que la taille compressée est présente, et +\fBu\fP indique que la taille décompréssée est présente. Si le drapeau n'est +pas indiqué, un tiret (\fB\-\fP) est affiché à la place pour que la longueur de +la chaîne reste fixe. De nouveaux drapeaux pourraient être ajoutés à la fin +de la chaîne dans le futur. +.IP 14. 4 +Taille des données effectivement compressées dans le bloc (en excluant +l'en\-tête de bloc, le remplissage de bloc et les champs de vérification). +.IP 15. 4 +Quantité de mémoire (en octets) nécessaire pour décompresser ce bloc avec +cette version de \fBxz\fP. +.IP 16. 4 +Chaîne de filtrage. Remarquez que la plupart des options utilisées au moment +de la compression ne peuvent pas être connues, car seules les options +nécessaires pour la décompression sont stockées dans les en\-têtes \fB.xz\fP. +.RE +.PD +.PP +Les colonnes des lignes \fBsummary\fP : +.PD 0 +.RS +.IP 2. 4 +Quantité de mémoire (en octets) nécessaire pour décompresser ce fichier avec +cette version de \fBxz\fP. +.IP 3. 4 +\fByes\fP ou \fBno\fP indique si tous les en\-têtes de bloc stockent à la fois la +taille compressée et la taille décompressée. +.PP +\fIDepuis\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Version minimale de \fBxz\fP nécessaire pour décompresser le fichier. +.RE +.PD +.PP +Les colonnes de la ligne \fBtotals\fP : +.PD 0 +.RS +.IP 2. 4 +Nombre de flux +.IP 3. 4 +Nombre de blocs +.IP 4. 4 +Taille compressée +.IP 5. 4 +Taille décompressée +.IP 6. 4 +Taux de compression moyen +.IP 7. 4 +Liste séparée par des virgules des noms de vérification d'intégrité qui +étaient présents dans les fichiers +.IP 8. 4 +Taille de remplissage de flux +.IP 9. 4 +Nombre de fichiers. Permet de garder l'ordre des colonnes précédentes comme +sur les lignes \fBfile\fP. +.PD +.RE +.PP +Si \fB\-\-verbose\fP a été indiqué deux fois, des colonnes supplémentaires sont +incluses sur la ligne \fBtotals\fP : +.PD 0 +.RS +.IP 10. 4 +Quantité maximale de mémoire (en octets) nécessaire pour décompresser les +fichiers avec cette version de \fBxz\fP. +.IP 11. 4 +\fByes\fP ou \fBno\fP indique si tous les en\-têtes de bloc stockent à la fois la +taille compressée et la taille décompressée. +.PP +\fIDepuis\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Version minimale de \fBxz\fP nécessaire pour décompresser le fichier. +.RE +.PD +.PP +Les versions futures pourront ajouter de nouveaux types de lignes et de +nouvelles colonnes pourront être ajoutées aux types de lignes existants, +mais les colonnes existantes ne seront pas modifiées. +. +.SS "Filters help" +\fBxz \-\-robot \-\-filters\-help\fP prints the supported filters in the following +format: +.PP +\fIfilter\fP\fB:\fP\fIoption\fP\fB=<\fP\fIvalue\fP\fB>,\fP\fIoption\fP\fB=<\fP\fIvalue\fP\fB>\fP... +.TP +\fIfilter\fP +Name of the filter +.TP +\fIoption\fP +Name of a filter specific option +.TP +\fIvalue\fP +Numeric \fIvalue\fP ranges appear as \fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. String +\fIvalue\fP choices are shown within \fB< >\fP and separated by a \fB|\fP +character. +.PP +Each filter is printed on its own line. +. +.SS "Information de limite de mémoire" +\fBxz \-\-robot \-\-info\-memory\fP prints a single line with multiple tab\-separated +columns: +.IP 1. 4 +Total amount of physical memory (RAM) in bytes. +.IP 2. 4 +Memory usage limit for compression in bytes (\fB\-\-memlimit\-compress\fP). A +special value of \fB0\fP indicates the default setting which for +single\-threaded mode is the same as no limit. +.IP 3. 4 +Memory usage limit for decompression in bytes (\fB\-\-memlimit\-decompress\fP). A +special value of \fB0\fP indicates the default setting which for +single\-threaded mode is the same as no limit. +.IP 4. 4 +Since \fBxz\fP 5.3.4alpha: Memory usage for multi\-threaded decompression in +bytes (\fB\-\-memlimit\-mt\-decompress\fP). This is never zero because a +system\-specific default value shown in the column 5 is used if no limit has +been specified explicitly. This is also never greater than the value in the +column 3 even if a larger value has been specified with +\fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Since \fBxz\fP 5.3.4alpha: A system\-specific default memory usage limit that is +used to limit the number of threads when compressing with an automatic +number of threads (\fB\-\-threads=0\fP) and no memory usage limit has been +specified (\fB\-\-memlimit\-compress\fP). This is also used as the default value +for \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Since \fBxz\fP 5.3.4alpha: Number of available processor threads. +.PP +Dans le futur, la sortie de \fBxz \-\-robot \-\-info\-memory\fP pourrait avoir plus +de colonnes, mais jamais plus qu'une ligne unique. +. +.SS Version +\fBxz \-\-robot \-\-version\fP prints the version number of \fBxz\fP and liblzma in +the following format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Version majeure. +.TP +\fIYYY\fP +Version mineure. Les numéros pairs sont stables. Les numéros impairs sont +des versions alpha ou beta. +.TP +\fIZZZ\fP +Niveau de correctif pour les options stables ou juste un compteur pour les +options de développement. +.TP +\fIS\fP +Stabilité. 0 est alpha, 1 est bêta et 2 est stable. \fIS\fP devrait toujours +être 2 quand \fIYYY\fP est pair. +.PP +\fIXYYYZZZS\fP sont identiques sur les deux lignes si \fBxz\fP et liblzma sont +issus de la même version d'utilitaires XZ. +.PP +Exemples : 4.999.9beta est \fB49990091\fP et 5.0.0 est \fB50000002\fP. +. +.SH "STATUT DE SORTIE" +.TP +\fB0\fP +Tout est bon. +.TP +\fB1\fP +Une erreur est survenue. +.TP +\fB2\fP +Quelquechose méritant un avertissement s'est produit, mais aucune erreur +véritable n'est survenue. +.PP +Les notifications (pas les avertissements ou les erreurs) affichées sur +l'erreur standard n'affectent pas le statut de sortie. +. +.SH ENVIRONNEMENT +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP analyse les listes d'options séparées par des espaces à partir des +variables d'environnement \fBXZ_DEFAULTS\fP et \fBXZ_OPT\fP, dans cet ordre, avant +d'analyser les options de la ligne de commandes. Remarquez que seules les +options sont analysées depuis l'environnement des variables ; toutes les +non\-options sont ignorées silencieusement. L'analyse est faite avec +\fBgetopt_long\fP(3) qui est aussi utilisé pour les arguments de la ligne de +commandes. +.PP +\fBWarning:\fP By setting these environment variables, one is effectively +modifying programs and scripts that run \fBxz\fP. Most of the time it is safe +to set memory usage limits, number of threads, and compression options via +the environment variables. However, some options can break scripts. An +obvious example is \fB\-\-help\fP which makes \fBxz\fP show the help text instead of +compressing or decompressing a file. More subtle examples are \fB\-\-quiet\fP +and \fB\-\-verbose\fP. In many cases it works well to enable the progress +indicator using \fB\-\-verbose\fP, but in some situations the extra messages +create problems. The verbosity level also affects the behavior of +\fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +User\-specific or system\-wide default options. Typically this is set in a +shell initialization script to enable \fBxz\fP's memory usage limiter by +default or set the default number of threads. Excluding shell +initialization scripts and similar special cases, scripts should never set +or unset \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +This is for passing options to \fBxz\fP when it is not possible to set the +options directly on the \fBxz\fP command line. This is the case when \fBxz\fP is +run by a script or tool, for example, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Scripts may use \fBXZ_OPT\fP, for example, to set script\-specific default +compression options. It is still recommended to allow users to override +\fBXZ_OPT\fP if that is reasonable. For example, in \fBsh\fP(1) scripts one may +use something like this: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "Compatibilité des utilitaires LZMA" +La syntaxe de la ligne de commande de \fBxz\fP est quasimment un sur\-ensemble +de \fBlzma\fP, \fBunlzma\fP et \fBlzcat\fP comme ils sont trouvés dans les +utilitaires LZMA 4.32.x . Dans la pluspart des cas, il est possible de +remplacer les outils LZMA par les outils XZ sans casser les scripts +existants. Il existe cependant certaines incompatibilités qui peuvent +parfois poser des problèmes. +. +.SS "Niveaux de préréglage de la compression" +La numérotation des préréglages de niveau de compression est différente +entre les outils \fBxz\fP et LZMA. La différence la plus importante est la +manière dont les tailles de dictionnaire sont affectées aux différents +préréglages. La taille de dictionnaire est à peu près égale à celle +d'utilisation de la mémoire de la décompression. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Niveau;xz;Utilitaires LZMA +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Les différences de tailles des dictionnaires affectent aussi l'utilisation +de la mémoire du compresseur, mais il y a quelques autres différences entre +les outils LZMA et les outils XZ, qui rendent la différence encore plus +grande : +.RS +.PP +.TS +tab(;); +c c c +c n n. +Niveau;xz;Utilitaires LZMA 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Le niveau de préréglage par défaut dans les outils LZMA est \fB\-7\fP alors que +pour les outils XZ c'est \fB\-6\fP, les deux utilisent ainsi un dictionnaire de +8 Mio par défaut. +. +.SS "Fichiers .lzma en flux ou non" +The uncompressed size of the file can be stored in the \fB.lzma\fP header. +LZMA Utils does that when compressing regular files. The alternative is to +mark that uncompressed size is unknown and use end\-of\-payload marker to +indicate where the decompressor should stop. LZMA Utils uses this method +when uncompressed size isn't known, which is the case, for example, in +pipes. +.PP +\fBxz\fP prend en charge la décompression des fichiers \fB.lzma\fP avec ou sans +marqueur de fin de charge utile, mais tous les fichiers \fB.lzma\fP créés par +\fBxz\fP utiliseront un marqueur de fin de charge utile et ont la taille non +compréssée marquée comme inconnue dans l'en\-tête \fB.lzma\fP. Cela peut être un +problème dans quelques situations inhabituelles. Par exemple, un +décompresseur \fB.lzma\fP dans un périphérique embarqué pourrait ne fonctionner +qu'avec des fichiers dont la taille non comprimée est connue. Si vous vous +heurtez à ce problème, vous devez utiliser les utilitaires LZMA ou LZMA SDK +pour créer des fichiers \fB.lzma\fP avec une taille non compressée connue. +. +.SS "Fichiers .lzma non pris en charge" +Le format \fB.lzma\fP autorise des valeurs \fIlc\fP jusqu'à 8, et des valeurs +\fIlp\fP jusqu'à 4. Les outils LZMA peuvent décompresser des fichiers avec tous +les \fIlc\fP et \fIlp\fP, mais créez toujours les fichiers avec \fBlc=3\fP et +\fBlp=0\fP. Créer des fichiers avec d'autres valeurs \fIlc\fP et \fIlp\fP est +possible avec \fBxz\fP et avec LZMA SDK. +.PP +L'implémentation du filtre LZMA1 dans liblzma nécessite que la somme de +\fIlc\fP et \fIlp\fP soit inférieure ou égale à 4. Ainsi, les fichiers \fB.lzma\fP +qui excèdent cette limitation ne peuvent pas être décompressés avec \fBxz\fP. +.PP +Les outils LZMA créent seulement des fichiers \fB.lzma\fP qui ont une taille de +dictionnaire de 2^\fIn\fP (une puissance de 2) mais acceptent les fichiers avec +toutes les tailles de dictionnaire. Libzlma n'accepte que les fichiers +\&\fB.lzma\fP qui ont une taille dictionnaire de 2^\fIn\fP ou +2^\fIn\fP + 2^(\fIn\fP\-1). Cela afin de diminuer les faux positifs lors de la +détection des fichiers \fB.lzma\fP. +.PP +Ces limitations ne devraient pas poser problème en pratique, car +pratiquement tous les fichiers \fB.lzma\fP ont été compressés avec des réglages +que liblzma accepte. +. +.SS "Déchets excédentaires" +Lors de la décompession, l'utilitaire LZMA ignore silencieusement tout ce +qui est après le premier flux \fB.lzma\fP. Dans la majorité des situations, +c'est un bogue. Cela veut dire aussi que les outils LZMA ne gèrent pas la +décompression de fichiers \fB.lzma\fP concaténés. +.PP +S'il reste des données après le premier flux \fB.lzma\fP, \fBxz\fP considère que +le fichier est corrompu sauf si \fB\-\-single\-stream\fP a été utilisé. Cela peut +casser des scripts obscurs qui ont supposé que les déchets de fin de ligne +sont ignorés. +. +.SH NOTES +. +.SS "La sortie compressée peut varier" +La sortie compressée exacte produite par les même fichiers non compressés en +entrée peut varier en fonction des différentes versions de l'utilitaire XZ, +même si les options de compression sont identiques. En effet, il est +possible d'améliorer l'encodeur (compression plus rapide ou meilleure) sans +affecter le format du fichier. La sortie peut même varier entre différentes +compilations de la même version d'utilitaire XZ, si des options de +construction différentes sont utilisées. +.PP +Cela signifie qu'une fois que \fB\-\-rsyncable\fP a été implémenté, les fichiers +résultants ne seront pas nécessairement synchronisables avec rsync à moins +que les nouveaux et anciens fichiers n'aient été compressés avec la même +version de xz. Ce problème peut être résolu si une partie de +l'implémentation est gelée pour garantir la stabilité de la sortie rsyncable +à travers les versions de xz. +. +.SS "Décompresseurs .xz embarqués" +Les implémentations de décompresseur embarqué comme XZ Embedded ne gèrent +pas nécessairement les fichiers créés avec d'autres types de \fIvérification\fP +d'intégrité que \fBnone\fP et \fBCRC32\fP. Comme la valeur par défaut est +\fB\-\-check=crc64\fP, vous devez utiliser \fB\-\-check=none\fP ou \fB\-\-check=crc32\fP +lors de la création de fichiers pour les systèmes embarqués. +.PP +En dehors des systèmes embarqués, tous les décompresseurs de format \fB.xz\fP +gèrent tous les types de \fIvérification\fP ou sont au moins capables de +décompresser le fichier sans effectuer la vérification d'intégrité si ce +type de \fIvérification\fP particulière n'est pas pris en charge. +.PP +XZ Embedded prend en charge les filtres BCJ, mais seulement avec le décalage +de départ par défaut. +. +.SH EXEMPLES +. +.SS Bases +Compresser le fichier \fItoto\fP en \fItoto.xz\fP en utilisant le niveau de +compression par défaut (\fB\-6\fP) et supprimer \fItoto\fP si la compression +réussit : +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Décompresser \fIbidule.xz\fP en \fIbidule\fP et ne pas supprimer \fIbidule.xz\fP même +si la compression réussit : +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Create \fIbaz.tar.xz\fP with the preset \fB\-4e\fP (\fB\-4 \-\-extreme\fP), which is +slower than the default \fB\-6\fP, but needs less memory for compression and +decompression (48\ MiB and 5\ MiB, respectively): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Un mélange de fichiers compressés et non compressés peuvent être +décompressés vers la sortie standard avec une simple commande : +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Compression en parallèle de plusieurs fichiers" +Sur GNU et *BSD, \fBfind\fP(1) et \fBxargs\fP(1) peuvent être utilisés pour mettre +en parallèle la compression de plusieurs fichiers : +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +L'option \fBP\fP passée à \fBxargs\fP(1) fixe le nombre de processus \fBxz\fP en +parallèles. La meilleure valeur pour l'option \fBn\fP dépend du nombre de +fichiers à compresser. S\-il n'y a que quelques fichiers, la valeur sera +probablement 1 ; avec des dizaines de milliers de fichiers, 100 ou même plus +serait approprié pour réduire le nombre de processus \fBxz\fP que \fBxargs\fP(1) +créera éventuellement. +.PP +L'option \fB\-T1\fP de \fBxz\fP est là pour le forcer en mode mono\-thread, car +\fBxargs\fP(1) est utilisé pour contrôler la quantité de mise en parallèle. +. +.SS "Mode robot" +Calculer combien d'octets ont été économisés au total après avoir compressé +plusieurs fichiers : +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Un script peut vouloir savoir qu'il utilise une version suffisamment récente +de \fBxz\fP. Le script \fBsh\fP(1) suivant vérifie que le numéro de version de +l'outil \fBxz\fP soit au minimum 5.0.0. Cette méthode est compatible avec les +vieilles versions bêta, qui ne gèrent pas l'option \fB\-\-robot\fP : +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Régler une limite d'utilisation de la mémoire pour la décompression en +utilisant \fBXZ_OPT\fP, mais si une limite a déjà été définie, ne pas +l'augmenter : +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Chaînes de filtres de compresseur personnalisées" +L'utilisation la plus simple des chaînes de filtres personnalisées est la +personnalisation d'un préréglage LZMA2. Cela peut être utile, car les +préréglages ne couvrent qu'un sous\-ensemble des réglages de compression +potentiellement utiles. +.PP +Les colonnes CompCPU des tableaux des descriptions des options \fB\-0\fP à \fB\-9\fP +et \fB\-\-extreme\fP sont utiles lors de la personnalisation des préréglages +LZMA2. Voici les parties pertinentes recueillies à partir de ces deux +tableaux : +.RS +.PP +.TS +tab(;); +c c +n n. +Préréglage;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +If you know that a file requires somewhat big dictionary (for example, 32\ MiB) to compress well, but you want to compress it quicker than \fBxz \-8\fP +would do, a preset with a low CompCPU value (for example, 1) can be +modified to use a bigger dictionary: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Avec certains fichiers, la commande ci\-dessus peut être plus rapide que +\fBxz\-6\fP tout en compressant bien mieux. Cependant, il faut souligner que +seuls certains fichiers bénéficient d'un grand dictionnaire tout en gardant +la valeur de CompCPU faible. La siutation la plus évidente où un gros +dictionnaire peut baucoup aider, est une archive contenant des fichiers très +similaires de quelques megaoctets chacun. La taille de dictionnaire doit +être significativement plus grosse que tout fichier individuel pour +permettre à LZMA2 de tirer pleinement partie des similarités entre des +fichiers consécutifs. +.PP +Si une utilisation de la mémoire élevée pour la compression et décompression +convient, et que le fichier à compresser a une taille de plusieurs centaines +de megaoctets, il peut être utile d'utiliser un plus gros dictionnaire que +celui fourni par \fBxz\-9\fP (64 Mio) : +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Utiliser \fB\-vv\fP (\fB\-\-verbose\-\-verbose\fP) comme dans l'exemple ci\-dessus peut +être utile pour voir les besoins en mémoire du compresseur et du +décompresseur. Rappelez\-vous qu'utiliser un dictionnaire plus gros que la +taille du fichier non compressé est un gachis de mémoire, donc la commande +ci\-dessus n'est pas utile pour les petits fichiers. +.PP +Sometimes the compression time doesn't matter, but the decompressor memory +usage has to be kept low, for example, to make it possible to decompress the +file on an embedded system. The following command uses \fB\-6e\fP (\fB\-6 \-\-extreme\fP) as a base and sets the dictionary to only 64\ KiB. The +resulting file can be decompressed with XZ Embedded (that's why there is +\fB\-\-check=crc32\fP) using about 100\ KiB of memory. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +If you want to squeeze out as many bytes as possible, adjusting the number +of literal context bits (\fIlc\fP) and number of position bits (\fIpb\fP) can +sometimes help. Adjusting the number of literal position bits (\fIlp\fP) +might help too, but usually \fIlc\fP and \fIpb\fP are more important. For +example, a source code archive contains mostly US\-ASCII text, so something +like the following might give slightly (like 0.1\ %) smaller file than \fBxz \-6e\fP (try also without \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Using another filter together with LZMA2 can improve compression with +certain file types. For example, to compress a x86\-32 or x86\-64 shared +library using the x86 BCJ filter: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Notez que l'ordre des options de filtre est significatif. Si \fB\-\-x86\fP est +indiqué après \fB\-\-lzma2\fP, \fBxz\fP donnera une erreur, car il ne peut y avoir +aucun filtre après LZMA2, et aussi parce que le filtre BCJ x86 ne peut pas +être utilisé comme dernier filtre dans la chaîne. +.PP +Le filtre Delta associé à LZMA2 peut donner de bons résultats avec les +images bitmap. Cela devrait habituellement battre PNG, qui a quelques +filtres avancés supplémentaires qu'un simple delta, mais qui utilise Deflate +pour la compression effective. +.PP +The image has to be saved in uncompressed format, for example, as +uncompressed TIFF. The distance parameter of the Delta filter is set to +match the number of bytes per pixel in the image. For example, 24\-bit RGB +bitmap needs \fBdist=3\fP, and it is also good to pass \fBpb=0\fP to LZMA2 to +accommodate the three\-byte alignment: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +If multiple images have been put into a single archive (for example, +\&\fB.tar\fP), the Delta filter will work on that too as long as all images have +the same number of bytes per pixel. +. +.SH "VOIR AUSSI" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/lzless.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/lzless.1 new file mode 100644 index 0000000000000000000000000000000000000000..797382bd5158fcfdbdf4c3e7076bca088de2c223 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/lzless.1 @@ -0,0 +1,49 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" french translation of XZ Utils man +.\" Copyright (C) 2021 Debian French l10n team +.\" Translator +.\" bubu , 2021. +.\" +.\" (Note that this file is not based on gzip's zless.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZLESS 1 2025\-03\-06 Tukaani "Utilitaires XZ" +.SH NOM +xzless, lzless \- Voir le contenu des fichiers (texte) compressés xz ou lzma +.SH SYNOPSIS +\fBxzless\fP [\fIfichier\fP...] +.br +\fBlzless\fP [\fIfile\fP...] (DEPRECATED) +.SH DESCRIPTION +\fBxzless\fP is a filter that displays text from compressed files to a +terminal. Files supported by \fBxz\fP(1) are decompressed; other files are +assumed to be in uncompressed form already. If no \fIfiles\fP are given, +\fBxzless\fP reads from standard input. +.PP +\fBxzless\fP utilise \fBless\fP(1) pour afficher sa sortie. Contrairement à +\fBxzmore\fP, son choix d'afficheur ne peut pas être modifié en indiquant une +variable d'environnement. Les commandes sont basées sur \fBmore\fP(1) et +\fBvi\fP(1) et permettent des déplacements en avant et en arrière et des +recherches. Voir le manuel de \fBless\fP(1) pour plus d'information. +.PP +The command named \fBlzless\fP is provided for backward compatibility with LZMA +Utils. It is deprecated and will be removed in a future version. +.SH ENVIRONNEMENT +.TP +\fBLESSMETACHARS\fP +Une liste de caractères spéciaux pour l'interpréteur. Définis par \fBxzless\fP +à moins qu'ils ne l'aient déjà été dans l'environnement. +.TP +\fBLESSOPEN\fP +Définir en ligne de commande le décompresseur \fBxz\fP(1) à invoquer pour +préparer les fichiers en entrée pour \fBless\fP(1). +.SH "VOIR AUSSI" +\fBless\fP(1), \fBxz\fP(1), \fBxzmore\fP(1), \fBzless\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/lzma.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/lzma.1 new file mode 100644 index 0000000000000000000000000000000000000000..297dc7c0d91cc84d9990f8e22984ef3e7be54f5b --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/lzma.1 @@ -0,0 +1,2027 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" french translation of XZ Utils man +.\" Copyright (C) 2021 Debian French l10n team +.\" Translator +.\" bubu , 2021. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 2025\-03\-08 Tukaani "Utilitaires XZ" +. +.SH NOM +xz, unxz, xzcat, lzma, unlzma, lzcat \- Compresser ou décompresser des +fichiers .xz et .lzma +. +.SH SYNOPSIS +\fBxz\fP [\fIoption...\fP] [\fIfichier...\fP] +. +.SH "ALIAS DES COMMANDES" +\fBunxz\fP est équivalent à \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP est équivalent à \fBxz \-\-decompress \-\-stdout\fP +.br +\fBlzma\fP est équivalent à \fBxz \-\-format=lzma\fP +.br +\fBunlzma\fP est équivalent à \fBxz \-\-format=lzma \-\-decompress\fP +.br +\fBlzcat\fP est équivalent à \fBxz \-\-format=lzma \-\-decompress \-\- stdout\fP +.PP +Lors de l'écriture de scripts qui nécessitent de décompresser des fichiers, +il est recommandé de toujours utiliser la commande \fBxz\fP avec les arguments +appropriés (\fBxz \-d\fP ou \fBxz \-dc\fP) au lieu des commandes \fBunxz\fP et +\fBxzcat\fP. +. +.SH DESCRIPTION +\fBxz\fP is a general\-purpose data compression tool with command line syntax +similar to \fBgzip\fP(1) and \fBbzip2\fP(1). The native file format is the +\&\fB.xz\fP format, but the legacy \fB.lzma\fP format used by LZMA Utils and raw +compressed streams with no container format headers are also supported. In +addition, decompression of the \fB.lz\fP format used by \fBlzip\fP is supported. +.PP +\fBxz\fP compresse ou décompresse chaque \fIfichier\fP en fonction du mode +d'opération choisi. Si aucun \fIfichier\fP n'est donné ou \fIfichier\fP est \fB\-\fP, +\fBxz\fP lit depuis l'entrée standard et écrit les données traitées sur la +sortie standard. \fBxz\fP refusera (affichera une erreur et ignorera le +\fIfichier\fP) d'écrire les données compressées sur la sortie standard si c'est +un terminal. De même, \fBxz\fP refusera de lire des données compressées depuis +l'entrée standard si c'est un terminal. +.PP +A moins que \fB\-\-sdout\fP ne soit indiqué, les \fIfichiers\fP autres que \fB\-\fP sont +écrits dans un nouveau fichier dont le nom est dérivé du nom de \fIfichier\fP +source : +.IP \(bu 3 +Lors de la compression, le suffixe du format de fichier cible (\fB.xz\fP ou +\&\fB.lzma\fP) est ajouté au nom de fichier source pour obtenir le nom de fichier +cible. +.IP \(bu 3 +When decompressing, the \fB.xz\fP, \fB.lzma\fP, or \fB.lz\fP suffix is removed from +the filename to get the target filename. \fBxz\fP also recognizes the suffixes +\&\fB.txz\fP and \fB.tlz\fP, and replaces them with the \fB.tar\fP suffix. +.PP +Si le fichier cible existe déjà, une erreur est affichée et le \fIfichier\fP +est ignoré. +.PP +Sauf s'il écrit dans la sortie standard, \fBxz\fP affichera un avertissement et +ignorera le \fIfichier\fP dans les cas suivants : +.IP \(bu 3 +\fIfichier\fP n'est pas un fichier normal. Les liens symboliques ne sont pas +suivis et donc ne sont pas considérés comme des fichiers normaux. +.IP \(bu 3 +\fIfichier\fP a plusieurs liens physiques. +.IP \(bu 3 +\fIfichier\fP a un setuid, setgid ou sticky bit positionné. +.IP \(bu 3 +Le mode d'opération est défini pour compresser et le \fIfichier\fP a déjà un +suffixe du format de fichier cible (\fB.xz\fP ou \fB.txz\fP lors d'une compression +en format \fB.xz\fP, et \fB.lzma\fP ou \fB.tlz\fP lors d'une compression en format +\&\fB.lzma\fP). +.IP \(bu 3 +The operation mode is set to decompress and the \fIfile\fP doesn't have a +suffix of any of the supported file formats (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, +\&\fB.tlz\fP, or \fB.lz\fP). +.PP +Après la compression ou la décompression réussie du \fIfichier\fP, \fBxz\fP copie +les permissions du propriétaire, du groupe, la date d'accès, et les +modifications d'heure depuis le \fIfichier\fP source du fichier cible. Si la +copie du groupe échoue, les permissions sont modifiées pour que le fichier +cible ne soit pas accessible aux utilisateurs qui n'ont pas les droits +d'accès au \fIfichier\fP source. \fBxz\fP ne prend actuellement pas en charge la +copie d'autres métadonnées telles que les listes de contrôle d'accès ou les +attributs étendus. +.PP +Once the target file has been successfully closed, the source \fIfile\fP is +removed unless \fB\-\-keep\fP was specified. The source \fIfile\fP is never removed +if the output is written to standard output or if an error occurs. +.PP +Envoyer \fBSIGINFO\fP ou \fBSIGURSR1\fP au processus \fBxz\fP, lui fait afficher +l'information de progression sur l'erreur standard. Cela a un intérêt limité +car lorsque l'erreur standard est un terminal, utiliser \fB\-\-verbose\fP +affichera automatiquement un indicateur de progression du processus. +. +.SS "Utilisation de la mémoire" +L'utilisation de la mémoire par \fBxz\fP varie de quelques centaines de +kilo\-octets à plusieurs gigaoctects en fonction des paramètres de +compression. Les réglages utilisés lors de la compression d'un fichier +déterminent les besoins en mémoire pour la décompression. Habituellement la +décompression nécessite 5\% à 20\% de la quantité de mémoire utilisée pour +la compression du fichier. Par exemple, décompresser un fichier créé avec +\fBxz\-9\fP recquiert habituellement 65\ Mio de mémoire. Bien qu'il soit +possible d'avoir des fichiers \fB.xz\fP nécessitant plusieurs gigaoctets de +mémoire pour être décompressés. +.PP +Especially users of older systems may find the possibility of very large +memory usage annoying. To prevent uncomfortable surprises, \fBxz\fP has a +built\-in memory usage limiter, which is disabled by default. While some +operating systems provide ways to limit the memory usage of processes, +relying on it wasn't deemed to be flexible enough (for example, using +\fBulimit\fP(1) to limit virtual memory tends to cripple \fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +The memory usage limiter can be enabled with the command line option +\fB\-\-memlimit=\fP\fIlimit\fP. Often it is more convenient to enable the limiter +by default by setting the environment variable \fBXZ_DEFAULTS\fP, for example, +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. It is possible to set the limits +separately for compression and decompression by using +\fB\-\-memlimit\-compress=\fP\fIlimit\fP and \fB\-\-memlimit\-decompress=\fP\fIlimit\fP. +Using these two options outside \fBXZ_DEFAULTS\fP is rarely useful because a +single run of \fBxz\fP cannot do both compression and decompression and +\fB\-\-memlimit=\fP\fIlimit\fP (or \fB\-M\fP \fIlimit\fP) is shorter to type on the +command line. +.PP +If the specified memory usage limit is exceeded when decompressing, \fBxz\fP +will display an error and decompressing the file will fail. If the limit is +exceeded when compressing, \fBxz\fP will try to scale the settings down so that +the limit is no longer exceeded (except when using \fB\-\-format=raw\fP or +\fB\-\-no\-adjust\fP). This way the operation won't fail unless the limit is very +small. The scaling of the settings is done in steps that don't match the +compression level presets, for example, if the limit is only slightly less +than the amount required for \fBxz \-9\fP, the settings will be scaled down only +a little, not all the way down to \fBxz \-8\fP. +. +.SS "Concaténation et remplissage avec des fichiers .xz" +Il est possible de concaténer les fichiers \fB.xz\fP tels quel. \fBxz\fP +décompressera de tels fichiers comme s'ils étaient un unique fichier \fB.xz\fP. +.PP +It is possible to insert padding between the concatenated parts or after the +last part. The padding must consist of null bytes and the size of the +padding must be a multiple of four bytes. This can be useful, for example, +if the \fB.xz\fP file is stored on a medium that measures file sizes in +512\-byte blocks. +.PP +La concaténation et le remplissage ne sont pas autorisés avec les fichiers +\&\fB.lzma\fP ou les flux bruts. +. +.SH OPTIONS +. +.SS "Suffixes entiers et valeurs spéciales." +Dans la plupart des endroits où un argument entier est attendu, un suffixe +optionel permet d'indiquer facilement les grands entiers. Il ne doit pas y +avoir d'espace entre l'entier et le suffixe. +.TP +\fBKiB\fP +Multiplier l'entier par 1024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP et \fBKB\fP sont +acceptés comme synonymes de \fBKiB\fP. +.TP +\fBMiB\fP +Multiplier l'entier par 1 048 576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP et \fBMB\fP sont +acceptés comme synonymes de \fBMiB\fP. +.TP +\fBGiB\fP +Multiplier l'entier par 1 073 741 824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP et \fBGB\fP +sont acceptés comme synonymes de \fBGiB\fP. +.PP +La valeur spéciale \fBmax\fP peut être utilisée pour indiquer la valeur +maximale de l'entier prise en charge par l'option. +. +.SS "Mode d'opération" +Si plusieurs options de mode d'opération sont données, la dernière prend +effet. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Compresser. C'est le mode d'opération par défaut lorsque aucune option de +mode opératoire n'est spécifiée ou qu'aucun autre mode d'opération n'est +sous\-entendu par le nom de la commande (par exemple \fBunxz\fP sous\-entend +\fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +After successful compression, the source file is removed unless writing to +standard output or \fB\-\-keep\fP was specified. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Decompress. After successful decompression, the source file is removed +unless writing to standard output or \fB\-\-keep\fP was specified. +.TP +\fB\-t\fP, \fB\-\-test\fP +Tester l'intégrité des \fIfichiers\fP compressés. Cette option est équivalente +à \fB\-\-decompress \-\-stdout\fP sauf que les données décompressées sont rejetées +au lieu d'être écrites sur la sortie standard. Aucun fichier n'est créé ou +supprimé. +.TP +\fB\-l\fP, \fB\-\-list\fP +Afficher l'information sur les \fIfichiers\fP compressés. Aucune sortie +non\-compressée n'est produite et aucun fichier n'est créé ou supprimé. En +mode liste, le programme ne peut pas lire les données compressées depuis +l'entrée standard ou depuis d'autres sources non adressables. +.IP "" +The default listing shows basic information about \fIfiles\fP, one file per +line. To get more detailed information, use also the \fB\-\-verbose\fP option. +For even more information, use \fB\-\-verbose\fP twice, but note that this may be +slow, because getting all the extra information requires many seeks. The +width of verbose output exceeds 80 characters, so piping the output to, for +example, \fBless\ \-S\fP may be convenient if the terminal isn't wide enough. +.IP "" +La sortie exacte peut varier suivant les versions de \fBxz\fP et les différents +paramètres régionaux. Pour une sortie lisible par la machine, utiliser +\fB\-\-robot \-\-list\fP. +. +.SS "Modificateurs d'opération" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Ne pas effacer les fichiers d'entrée. +.IP "" +Since \fBxz\fP 5.2.6, this option also makes \fBxz\fP compress or decompress even +if the input is a symbolic link to a regular file, has more than one hard +link, or has the setuid, setgid, or sticky bit set. The setuid, setgid, and +sticky bits are not copied to the target file. In earlier versions this was +only done with \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Cette option a plusieurs effets : +.RS +.IP \(bu 3 +Si le fichier cible existe déjà, l'effacer avant de compresser ou +décompresser. +.IP \(bu 3 +Compresser ou décompresser même si l'entrée est un lien symbolique vers un +fichier normal, a plus qu'un lien physique, ou a le bit setuid, setgid ou +sticky défini. Les bits setuid, setgid et sticky bits ne sont pas copiés +dans le fichier cible. +.IP \(bu 3 +Lorsque \fBxz\fP est utilisé avec \fB\-\-decompress\fP \fB\-\-stdout\fP et qu'il ne peut +pas reconnaitre le type du fichier source, copier le fichier source tel quel +dans la sortie standard. Celà permet à \fBxzcat\fP \fB\-\-force\fP d'être utilisé +comme \fBcat\fP(1) pour les fichiers qui n'ont pas été compressé avec +\fBxz\fP. Remarquez que dans le futur, \fBxz\fP devrait prendre en charge de +nouveaux formats de fichiers compressés, ce qui permettra à \fBxz\fP de +décompresser plus de types de fichiers au lieu de les copier tels quels dans +la sortie standard. \fB\-\-format=\fP\fIformat\fP peut être utilisé pour contraindre +\fBxz\fP à décompresser seulement un format de fichier. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Écrire les données compressées ou décompressées sur la sortie standard +plutôt que dans un fichier. Cela necessite \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Décompresser seulement le premier flux \fB.xz\fP et ignorer silencieusement les +possibles données d'entrée résiduelles qui suivent le flux. Normalement ces +déchets excédentaires provoquent l'affichage d'une erreur par \fBxz\fP. +.IP "" +\fBxz\fP ne décompresse jamais plus d'un flux à partir de fichiers \fB.lzma\fP ou +de flux bruts, mais cette option fait aussi que \fBxz\fP ignorera les données +résiduelles après le fichier \fB.lzma\fP ou le flux brut. +.IP "" +Cette option n'a aucun effet si le mode d'opération n'est pas +\fB\-\-decompress\fP ou \fB\-\-test\fP. +.IP "" +Since \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP implies \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Désactiver la création de fichiers peu denses. Par défaut, lors de la +décompression en un fichier normal, \fBxz\fP essaie d'en faire un fichier creux +si les données décompressées contiennent de longues séquences de zéros +binaires. Cela fonctionne aussi lors de l'écriture sur la sortie standard +aussi longtemps que la sortie standard est connectée à un fichier normal et +que certaines conditions supplémentaires sont satisfaites pour le faire de +manière sécurisée. Créer des fichiers creux peut épargner de l'espace disque +et accélérer la décompression en réduisant la quantité d'entrées/sorties sur +le disque. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Lors de la compression, utiliser \fB.suf\fP comme suffixe du fichier cible au +lieu de \fB.xz\fP ou \fB.lzma\fP. Si \fBxz\fP n'écrit pas sur la sortie standard et +si le fichier source a déja le suffixe \fB.suf\fP, un avertissement est affiché +et le fichier est ignoré. +.IP "" +When decompressing, recognize files with the suffix \fI.suf\fP in addition to +files with the \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, or \fB.lz\fP suffix. If the +source file has the suffix \fI.suf\fP, the suffix is removed to get the target +filename. +.IP "" +Lors de la compression ou décompression de flux bruts (\fB\-\-fomat=raw\fP), le +suffixe doit toujours être spécifié à moins d'écrire sur la sortie standard, +car il n'y a pas de suffixe par défaut pour les flux bruts. +.TP +\fB\-\-files\fP[\fB=\fP\fIfichier\fP] +Lire les noms de fichier à traiter depuis \fIfichier\fP ; si \fIfichier\fP est +omis , les noms de fichier sont lus sur l'entrée standard. Les noms de +fichier doivent se terminer avec le caractère de nouvelle ligne. Un tiret +(\fB\-\fP) est considéré comme un nom de fichier normal ; ce qui ne signifie pas +entrée standard. Si les noms de fichier sont aussi donnés comme arguments de +ligne de commande, ils sont traités avant les noms de fichier lus depuis +\fIfichier\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIfichier\fP] +Cela est identique à \fB\-\-files\fP[\fB=\fP\fIfichier\fP] sauf que chaque nom de +fichier doit se terminer par le caractère null. +. +.SS "Format de fichier basique et options de compression" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fIformat\fP +Indiquer le \fIformat\fP de fichier à compresser ou décompresser : +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +C'est celui par défaut. Lors de la compression, \fBauto\fP est équivalent à +\fBxz\fP. Lors de la décompression, le format du fichier en entrée est détecté +automatiquement. Notez que les flux bruts (créés avec \fB\-\-format=raw\fP) ne +peuvent pas être détectés automatiquement. +.TP +\fBxz\fP +Compresser dans le format de fichier \fB.xz\fP ou n'accepter que les fichiers +\&\fB.xz\fP à décompresser. +.TP +\fBlzma\fP, \fBalone\fP +Compresser au format de fichier \fB.lzma\fP historique, ou n'accepter que les +fichiers \fB.lzma\fP lors de la décompression. Le nom alternatif \fBalone\fP est +fourni pour la rétrocompatibilité avec les utilitaires LZMA. +.TP +\fBlzip\fP +Accept only \fB.lz\fP files when decompressing. Compression is not supported. +.IP "" +The \fB.lz\fP format versions 0 and 1 are supported. Version 0 files were +produced by \fBlzip\fP 1.3 and older. Such files aren't common but may be +found from file archives as a few source packages were released in this +format. People might have old personal files in this format too. +Decompression support for the format version 0 was removed in \fBlzip\fP 1.18. +\fBlzip\fP 1.4 and later create files in the format version 1. +.TP +\fBraw\fP +Compresser ou décompresser un flux brut (sans en\-têtes). Cela est réservé +seulement aux utilisateurs aguerris. Pour décoder des flux bruts, vous devez +utiliser \fB\-\-format=raw\fP et spécifier explicitement la chaîne de filtre, qui +normalement aurait du être stockée dans les en\-têtes du conteneur. +.RE +.TP +\fB\-C\fP \fIvérif.\fP, \fB\-\-check=\fP\fIvérif.\fP +Spécifier le type d'intégrité à vérifier. La vérification est calculée à +partir des données non\-compressées et stockées dans le fichier \fB.xz\fP. Cette +option n'a effet que si la compression a été faite dans le format \fB.xz\fP ; +le format \fB.lzma\fP ne gère pas les vérifications d'intégrité. Le contrôle +d'intégrité (s'il y en a) est vérifié lorsque le fichier \fB.xz\fP est +décompressé. +.IP "" +Types de \fIvérification\fP pris en charge : +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Ne pas calculer de vérification d'intégrité du tout. C'est généralement une +mauvaise idée. Cela peut être utile lorsque l'intégrité des données est +vérifiée de toute façon par d'autres manières. +.TP +\fBcrc32\fP +Calculer CRC32 en utilisant le polynôme de IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Calculer CRC64 en utilisant le polynôme de ECMA\-182. C'est la manière +utilisée par défaut, car c'est légèrement mieux que CRC32 pour détecter les +fichiers endommagés et la différence de vitesse est négligeable. +.TP +\fBsha256\fP +Calculer SHA\-256. C'est quelque peu plus lent que CRC32 et CRC64. +.RE +.IP "" +L'intégrité des en\-têtes \fB.xz\fP est toujours vérifiée avec CRC32. Il n'est +pas possible de le changer ou de le désactiver. +.TP +\fB\-\-ignore\-check\fP +Ne pas contrôler la vérification d'intégrité des données lors de la +décompression. Les valeurs CRC32 dans les en\-têtes \fB.xz\fP seront normalement +toujours vérifiées. +.IP "" +\fBN'utilisez pas cette option à moins de savoir ce que vous faites.\fP Les +raisons possibles pour utiliser cette option : +.RS +.IP \(bu 3 +Essayer de récupérer des données d'un fichier .xz corrompu. +.IP \(bu 3 +Accélérer la décompression. Cela importe surtout avec SHA\-256 ou avec les +fichiers qui ont été compressés extrêmement bien. Il est recommandé de ne +pas utiliser cette option dans ce but à moins que l'intégrité du fichier ne +soit vérifiée extérieurement d'une autre manière. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Choisir un niveau de compression prédéfini. La valeur par défaut est +\fB6\fP. Si plusieurs niveaux de préréglage sont spécifiés, c'est le dernier +qui sera pris en compte. Si une chaîne de filtres personnalisée a déjà été +choisie, définir un niveau de compression préréglé efface la chaîne de +filtres personnalisée. +.IP "" +Les différences entre les préréglages sont plus significatives qu'avec +\fBgzip\fP(1) et \fBbzip2\fP(1). les réglages de compression sélectionnés +déterminent les exigences en mémoire pour la décompression, ainsi, utiliser +un niveau de préréglage trop élevé peut rendre difficile à décompresser un +fichier sur un vieux système avec peu de RAM. Clairement, \fBce n'est pas une bonne idée d'utiliser \-9 aveuglément pour tout\fP comme ça l'est souvent avec +\fBgzip\fP(1) et \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Ce sont des préréglages relativement rapides. \fB0\fP est parfois plus rapide +que \fBgzip \-9\fP tout en compressant bien mieux. Les réglages plus élevés ont +souvent une rapidité comparable à celle de \fBbzip2\fP(1) avec un taux de +compression comparable ou meilleur, même si les résultats dépendent beaucoup +du genre de données compressées. +.TP +\fB\-4\fP ... \fB\-6\fP +Good to very good compression while keeping decompressor memory usage +reasonable even for old systems. \fB\-6\fP is the default, which is usually a +good choice for distributing files that need to be decompressible even on +systems with only 16\ MiB RAM. (\fB\-5e\fP or \fB\-6e\fP may be worth considering +too. See \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +C'est comme \fB\-6\fP mais avec des besoins en mémoire plus élevés pour la +compression et la décompression. Ce n'est utile que lorsque les fichiers +sont plus gros que 8\ Mio, 16\ Mio et 32\ Mio respectivement. +.RE +.IP "" +Sur le même matériel, la vitesse de décompression est sensiblement un nombre +constant d'octets de données compressées par seconde. En d'autres termes, +meilleure est la compression, plus rapide sera en général la +décompression. Cela signifie aussi que la quantité de sortie non compressée +produite par seconde peut varier beaucoup. +.IP "" +Le tableau suivant résume les caractéristiques des préréglages : +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Préréglage;DictSize;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Descriptions des colonnes : +.RS +.IP \(bu 3 +DictSize est la taille du dictionnaire de LZMA2. Utiliser un dictionnaire +plus gros que la taille du fichier non compressé est un gaspillage de +mémoire. C'est pourquoi il est bon d'éviter d'utiliser les préréglages de +\fB\-7\fP à \fB\-9\fP lorsqu'il n'y en a pas vraiment besoin. A \fB\-6\fP et plus bas, +la quantité de mémoire gaspillée est généralement assez basse pour ne pas +être un problème. +.IP \(bu 3 +CompCPU est une représentation des préréglages de LZMA2 qui affectent la +vitesse de compression. La taille du dictionnaire aussi affecte la vitesse, +alors comme CompCPU est le même pour les niveaux de \fB\-6\fP à \fB\-9\fP, les plus +haut niveaux tendent à être un peu moins rapides. Pour être encore moins +rapide et du coup obtenir peut être une meilleure compression, consultez +\fB\-\-extreme\fP. +.IP \(bu 3 +CompMem contains the compressor memory requirements in the single\-threaded +mode. It may vary slightly between \fBxz\fP versions. +.IP \(bu 3 +DecMem contient les besoins en mémoire du décompresseur. Ce sont les +réglages de la compression qui déterminent les besoins en mémoire de la +décompression. L'exacte utilisation de la mémoire est légèrement supérieure +à la taille du dictionnaire LZMA2, mais les valeurs dans la table ont été +arrondies au prochain Mio supérieur. +.RE +.IP "" +Memory requirements of the multi\-threaded mode are significantly higher than +that of the single\-threaded mode. With the default value of +\fB\-\-block\-size\fP, each thread needs 3*3*DictSize plus CompMem or DecMem. For +example, four threads with preset \fB\-6\fP needs 660\(en670\ MiB of memory. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Utilisez un variant plus lent que les préréglages (\fB\-0\fP à \fB\-9\fP) pour +espérer avoir un taux de compression légèrement meilleur, mais en cas de +malchance cela peut être pire. L'utilisation mémoire du décompresseur n'est +pas affectée, mais l'utilisation mémoire du compresseur augmente un peu aux +niveaux de préréglages de \fB\-0\fP à \fB\-3\fP. +.IP "" +Depuis qu'il y a deux préréglages avec des tailles de dictionnaire de 4\ Mio +et 8 \Mio, les préréglages \fB\-3e\fP et \fB\-5e\fP utilisent des réglages +légèrement plus rapides que \fB\-4e\fP et \fB\-6e\fP, respectivement. De cette +manière, il n'y a pas deux préréglages identiques. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Préréglage;DictSize;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Par exemple, il y a un total de quatre préréglages qui utilisent un +dictionnaire de 8 Mio et qui sont dans l'ordre du plus rapide au plus lent : +\fB\-5\fP, \fB\-6\fP, \fB\-5e\fP et \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Il y a néanmoins des alias trompeurs pour \fB\-0\fP et \fB\-9\fP, +respectivement. Ils ne sont fournis que pour des besoins de +rétro\-compatibilité avec les utilitaires LZMA. Evitez d'utiliser ces +options. +.TP +\fB\-\-block\-size=\fP\fItaille\fP +Lors de la compression dans le format \fB.xz\fP, les données de l'entrée sont +réparties en blocs de \fItaille\fP octets. Les blocs sont compressés +indépendamment les un des autres, ce qui aide avec le mode multithread +(multi\-threading) et rend possible la décompression à accès aléatoire +limité. Cette option est typiquement utilisée pour outrepasser la taille de +bloc en mode multithread, mais cette option peut aussi être utilisée en mode +single\-thread. +.IP "" +In multi\-threaded mode about three times \fIsize\fP bytes will be allocated in +each thread for buffering input and output. The default \fIsize\fP is three +times the LZMA2 dictionary size or 1 MiB, whichever is more. Typically a +good value is 2\(en4 times the size of the LZMA2 dictionary or at least 1 +MiB. Using \fIsize\fP less than the LZMA2 dictionary size is waste of RAM +because then the LZMA2 dictionary buffer will never get fully used. In +multi\-threaded mode, the sizes of the blocks are stored in the block +headers. This size information is required for multi\-threaded +decompression. +.IP "" +In single\-threaded mode no block splitting is done by default. Setting this +option doesn't affect memory usage. No size information is stored in block +headers, thus files created in single\-threaded mode won't be identical to +files created in multi\-threaded mode. The lack of size information also +means that \fBxz\fP won't be able decompress the files in multi\-threaded mode. +.TP +\fB\-\-block\-list=\fP\fIitems\fP +When compressing to the \fB.xz\fP format, start a new block with an optional +custom filter chain after the given intervals of uncompressed data. +.IP "" +The \fIitems\fP are a comma\-separated list. Each item consists of an optional +filter chain number between 0 and 9 followed by a colon (\fB:\fP) and a +required size of uncompressed data. Omitting an item (two or more +consecutive commas) is a shorthand to use the size and filters of the +previous item. +.IP "" +If the input file is bigger than the sum of the sizes in \fIitems\fP, the last +item is repeated until the end of the file. A special value of \fB0\fP may be +used as the last size to indicate that the rest of the file should be +encoded as a single block. +.IP "" +An alternative filter chain for each block can be specified in combination +with the \fB\-\-filters1=\fP\fIfilters\fP \&...\& \fB\-\-filters9=\fP\fIfilters\fP options. +These options define filter chains with an identifier between 1\(en9. +Filter chain 0 can be used to refer to the default filter chain, which is +the same as not specifying a filter chain. The filter chain identifier can +be used before the uncompressed size, followed by a colon (\fB:\fP). For +example, if one specifies \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP +then blocks will be created using: +.RS +.IP \(bu 3 +The filter chain specified by \fB\-\-filters1\fP and 2 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters3\fP and 2 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters2\fP and 4 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters2\fP and 4 MiB input +.IP \(bu 3 +The default filter chain and 2 MiB input +.IP \(bu 3 +The default filter chain and 4 MiB input for every block until end of input. +.RE +.IP "" +If one specifies a size that exceeds the encoder's block size (either the +default value in threaded mode or the value specified with +\fB\-\-block\-size=\fP\fIsize\fP), the encoder will create additional blocks while +keeping the boundaries specified in \fIitems\fP. For example, if one specifies +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP and the +input file is 80 MiB, one will get 11 blocks: 5, 10, 8, 10, 2, 10, 10, 4, +10, 10, and 1 MiB. +.IP "" +En mode multi\-threadé les tailles de blocs sont stockées dans les en\-têtes +du bloc. Cela ne se fait pas en mode mono\-threadé, la sortie encodée ne sera +donc pas identique à celle faite en mode multi\-threadé. +.TP +\fB\-\-flush\-timeout=\fP\fItemps_d'attente\fP +Lors de la compression, si plus que \fItemps_d'attente\fP millisecondes (un +entier positif) se sont écoulées depuis le précédent vidage et que lire plus +de données bloquerait, toutes les données d'entrée en attente sont vidées de +l'encodeur et mises à disposition dans le flux de sortie. Cela peut être +utile si \fBxz\fP est utilisé pour compresser les données qui sont diffusées +sur un réseau. Des petites valeurs de \fItemps_d'attente\fP rendent les données +disponibles à l'extrémité réceptrice avec un léger retard, mais les grandes +valeurs de \fItemps_d'attente\fP donnent un meilleur taux de compression. +.IP "" +Cette option est désactivée par défaut. Si cette option est indiquée plus +d'une fois, la dernière prend effet. La valeur spéciale de +\fItemps_d'attente\fP de \fB0\fP peut être utilisée pour explicitement désactiver +cette option. +.IP "" +Cette option n'est pas disponible sur les systèmes qui ne sont pas POSIX. +.IP "" +.\" FIXME +\fBCette option est encore expérimentale.\fP Actuellement, \fBxz\fP ne convient +pas pour décompresser le flux en temps réel en raison de la façon dont \fBxz\fP +effectue la mise en mémoire tampon. +.TP +\fB\-\-no\-sync\fP +Do not synchronize the target file and its directory to the storage device +before removing the source file. This can improve performance if +compressing or decompressing many small files. However, if the system +crashes soon after the deletion, it is possible that the target file was not +written to the storage device but the delete operation was. In that case +neither the original source file nor the target file is available. +.IP "" +This option has an effect only when \fBxz\fP is going to remove the source +file. In other cases synchronization is never done. +.IP "" +The synchronization and \fB\-\-no\-sync\fP were added in \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIlimite\fP +Indiquer une limite d'utilisation de la mémoire pour la compression. Si +cette option est indiquée plusieurs fois, c'est la dernière qui est prise en +compte. +.IP "" +If the compression settings exceed the \fIlimit\fP, \fBxz\fP will attempt to +adjust the settings downwards so that the limit is no longer exceeded and +display a notice that automatic adjustment was done. The adjustments are +done in this order: reducing the number of threads, switching to +single\-threaded mode if even one thread in multi\-threaded mode exceeds the +\fIlimit\fP, and finally reducing the LZMA2 dictionary size. +.IP "" +When compressing with \fB\-\-format=raw\fP or if \fB\-\-no\-adjust\fP has been +specified, only the number of threads may be reduced since it can be done +without affecting the compressed output. +.IP "" +If the \fIlimit\fP cannot be met even with the adjustments described above, an +error is displayed and \fBxz\fP will exit with exit status 1. +.IP "" +La \fIlimite\fP peut être indiquée de plusieurs façons : +.RS +.IP \(bu 3 +La \fIlimite\fP peut être une valeur absolue en octets. Utiliser un suffixe +d'entier comme \fBMiB\fP peut être utile. Exemple : +\fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +La \fIlimite\fP peut être indiquée sous forme d'un pourcentage de la mémoire +physique totale (RAM). Cela peut être particulièrement utile quand la +variable d'environnement \fBXZ_DEFAULTS\fP est indiquée dans un script +d'initialisation de l'interpréteur partagé entre différents ordinateurs. De +cette façon la limite est automatiquement plus grande sur les systèmes avec +plus de mémoire. Exemple : \fB\-\-memlimit=70%\fP +.IP \(bu 3 +The \fIlimit\fP can be reset back to its default value by setting it to \fB0\fP. +This is currently equivalent to setting the \fIlimit\fP to \fBmax\fP (no memory +usage limit). +.RE +.IP "" +For 32\-bit \fBxz\fP there is a special case: if the \fIlimit\fP would be over +\fB4020\ MiB\fP, the \fIlimit\fP is set to \fB4020\ MiB\fP. On MIPS32 \fB2000\ MiB\fP +is used instead. (The values \fB0\fP and \fBmax\fP aren't affected by this. A +similar feature doesn't exist for decompression.) This can be helpful when +a 32\-bit executable has access to 4\ GiB address space (2 GiB on MIPS32) +while hopefully doing no harm in other situations. +.IP "" +Voir aussi la section \fButilisation de la mémoire\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIlimite\fP +Régler une limite d'utilisation de la mémoire pour la décompression. Cela a +un effet sur le mode \fB\-\-list\fP. Si l'opération n'est pas possible sans +dépasser la \fIlimite\fP, \fBxz\fP affichera une erreur et la décompression +échouera. Voir \fB\-\-memlimit\-compress=\fP\fIlimite\fP pour les manières possibles +d'indiquer la \fIlimite\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimit\fP +Set a memory usage limit for multi\-threaded decompression. This can only +affect the number of threads; this will never make \fBxz\fP refuse to +decompress a file. If \fIlimit\fP is too low to allow any multi\-threading, the +\fIlimit\fP is ignored and \fBxz\fP will continue in single\-threaded mode. Note +that if also \fB\-\-memlimit\-decompress\fP is used, it will always apply to both +single\-threaded and multi\-threaded modes, and so the effective \fIlimit\fP for +multi\-threading will never be higher than the limit set with +\fB\-\-memlimit\-decompress\fP. +.IP "" +In contrast to the other memory usage limit options, +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimit\fP has a system\-specific default +\fIlimit\fP. \fBxz \-\-info\-memory\fP can be used to see the current value. +.IP "" +This option and its default value exist because without any limit the +threaded decompressor could end up allocating an insane amount of memory +with some input files. If the default \fIlimit\fP is too low on your system, +feel free to increase the \fIlimit\fP but never set it to a value larger than +the amount of usable RAM as with appropriate input files \fBxz\fP will attempt +to use that amount of memory even with a low number of threads. Running out +of memory or swapping will not improve decompression performance. +.IP "" +See \fB\-\-memlimit\-compress=\fP\fIlimit\fP for possible ways to specify the +\fIlimit\fP. Setting \fIlimit\fP to \fB0\fP resets the \fIlimit\fP to the default +system\-specific value. +.TP +\fB\-M\fP \fIlimite\fP, \fB\-\-memlimit=\fP\fIlimite\fP, \fB\-\-memory=\fP\fIlimite\fP +This is equivalent to specifying \fB\-\-memlimit\-compress=\fP\fIlimit\fP +\fB\-\-memlimit\-decompress=\fP\fIlimit\fP \fB\-\-memlimit\-mt\-decompress=\fP\fIlimit\fP. +.TP +\fB\-\-no\-adjust\fP +Display an error and exit if the memory usage limit cannot be met without +adjusting settings that affect the compressed output. That is, this +prevents \fBxz\fP from switching the encoder from multi\-threaded mode to +single\-threaded mode and from reducing the LZMA2 dictionary size. Even when +this option is used the number of threads may be reduced to meet the memory +usage limit as that won't affect the compressed output. +.IP "" +Automatic adjusting is always disabled when creating raw streams +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fIthreads\fP, \fB\-\-threads=\fP\fIthreads\fP +Specify the number of worker threads to use. Setting \fIthreads\fP to a +special value \fB0\fP makes \fBxz\fP use up to as many threads as the processor(s) +on the system support. The actual number of threads can be fewer than +\fIthreads\fP if the input file is not big enough for threading with the given +settings or if using more threads would exceed the memory usage limit. +.IP "" +The single\-threaded and multi\-threaded compressors produce different +output. Single\-threaded compressor will give the smallest file size but +only the output from the multi\-threaded compressor can be decompressed using +multiple threads. Setting \fIthreads\fP to \fB1\fP will use the single\-threaded +mode. Setting \fIthreads\fP to any other value, including \fB0\fP, will use the +multi\-threaded compressor even if the system supports only one hardware +thread. (\fBxz\fP 5.2.x used single\-threaded mode in this situation.) +.IP "" +To use multi\-threaded mode with only one thread, set \fIthreads\fP to \fB+1\fP. +The \fB+\fP prefix has no effect with values other than \fB1\fP. A memory usage +limit can still make \fBxz\fP switch to single\-threaded mode unless +\fB\-\-no\-adjust\fP is used. Support for the \fB+\fP prefix was added in \fBxz\fP +5.4.0. +.IP "" +If an automatic number of threads has been requested and no memory usage +limit has been specified, then a system\-specific default soft limit will be +used to possibly limit the number of threads. It is a soft limit in sense +that it is ignored if the number of threads becomes one, thus a soft limit +will never stop \fBxz\fP from compressing or decompressing. This default soft +limit will not make \fBxz\fP switch from multi\-threaded mode to single\-threaded +mode. The active limits can be seen with \fBxz \-\-info\-memory\fP. +.IP "" +Actuellement, la seule méthode de gestion avec des threads consiste à +séparer l'entrée en blocs et de les compresser indépendamment les uns des +autres. La taille par défaut des blocs dépend du niveau de compression et +peut\-être remplacée avec l'option \fB\-\-block\-size=\fP\fItaille\fP. +.IP "" +Threaded decompression only works on files that contain multiple blocks with +size information in block headers. All large enough files compressed in +multi\-threaded mode meet this condition, but files compressed in +single\-threaded mode don't even if \fB\-\-block\-size=\fP\fIsize\fP has been used. +.IP "" +The default value for \fIthreads\fP is \fB0\fP. In \fBxz\fP 5.4.x and older the +default is \fB1\fP. +. +.SS "Chaînes de filtres de compresseur personnalisées" +A custom filter chain allows specifying the compression settings in detail +instead of relying on the settings associated to the presets. When a custom +filter chain is specified, preset options (\fB\-0\fP \&...\& \fB\-9\fP and +\fB\-\-extreme\fP) earlier on the command line are forgotten. If a preset +option is specified after one or more custom filter chain options, the new +preset takes effect and the custom filter chain options specified earlier +are forgotten. +.PP +Une chaîne de filtre est comparable à une redirection (pipe) sur la ligne de +commande. Lors de la compression, les entrées non compressées vont au +premier filtre, dont la sortie va au prochain filtre (s'il y en a). La +sortie du dernier filtre est écrite sur le fichier compressé. Le nombre +maximal de filtres dans la chaîne est quatre, mais habituellement, un chaîne +de filtre n'a qu'un ou deux filtres. +.PP +Beaucoup de filtres ont des limitations sur l'endroit où ils peuvent se +placer dans la chaîne de filtre : quelques filtres ne peuvent fonctionner +qu'en tant que dernier filtre dans la chaîne, quelques uns en tant que non +dernier filtre, et d'autres à n'importe quelle position dans la +chaîne. Suivant le filtre, cette limitation est soit inhérente au profil du +filtre, soit existe pour des raisons de sécurité. +.PP +A custom filter chain can be specified in two different ways. The options +\fB\-\-filters=\fP\fIfilters\fP and \fB\-\-filters1=\fP\fIfilters\fP \&...\& +\fB\-\-filters9=\fP\fIfilters\fP allow specifying an entire filter chain in one +option using the liblzma filter string syntax. Alternatively, a filter +chain can be specified by using one or more individual filter options in the +order they are wanted in the filter chain. That is, the order of the +individual filter options is significant! When decoding raw streams +(\fB\-\-format=raw\fP), the filter chain must be specified in the same order as +it was specified when compressing. Any individual filter or preset options +specified before the full chain option (\fB\-\-filters=\fP\fIfilters\fP) will be +forgotten. Individual filters specified after the full chain option will +reset the filter chain. +.PP +Both the full and individual filter options take filter\-specific \fIoptions\fP +as a comma\-separated list. Extra commas in \fIoptions\fP are ignored. Every +option has a default value, so specify those you want to change. +.PP +Pour voir l'entièreté de la chaîne de filtres et ses \fIoptions\fP, utilisez +\fBxz \-vv\fP (ce qui est comme utiliser \fB\-\-verbose\fP deux fois). Cela +fonctionne aussi pour voir les options de chaîne de filtres utilisées par +les préréglages. +.TP +\fB\-\-filters=\fP\fIfilters\fP +Specify the full filter chain or a preset in a single option. Each filter +can be separated by spaces or two dashes (\fB\-\-\fP). \fIfilters\fP may need to be +quoted on the shell command line so it is parsed as a single option. To +denote \fIoptions\fP, use \fB:\fP or \fB=\fP. A preset can be prefixed with a \fB\-\fP +and followed with zero or more flags. The only supported flag is \fBe\fP to +apply the same options as \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIfilters\fP ... \fB\-\-filters9\fP=\fIfilters\fP +Specify up to nine additional filter chains that can be used with +\fB\-\-block\-list\fP. +.IP "" +For example, when compressing an archive with executable files followed by +text files, the executable part could use a filter chain with a BCJ filter +and the text part only the LZMA2 filter. +.TP +\fB\-\-filters\-help\fP +Display a help message describing how to specify presets and custom filter +chains in the \fB\-\-filters\fP and \fB\-\-filters1=\fP\fIfilters\fP \&...\& +\fB\-\-filters9=\fP\fIfilters\fP options, and exit successfully. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIoptions\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIoptions\fP] +.PD +Ajouter le filtre LZMA1 ou LZMA2 à la chaîne de filtres. Ces filtres ne +peuvent être utilisés que comme dernier filtre dans la chaîne. +.IP "" +LZMA1 est un filtre historique, qui n'est pris en charge presque uniquement +à cause de l'ancien format de fichier \fB.lzma\fP, qui ne prend en charge que +LZMA1. LZMA2 est une version mise à jour de LZMA1 pour régler certains +problèmes pratiques de LZMA1. Le format \fBxz\fP utilise LZMA2 et ne prend pas +du tout en charge LZMA1. Les taux et vitesses de compression de LZMA1 et +LZMA2 sont pratiquement identiques. +.IP "" +LZMA1 et LZMA2 partagent le même ensemble d'\fIoptions\fP : +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIpréréglage\fP +Reset all LZMA1 or LZMA2 \fIoptions\fP to \fIpreset\fP. \fIPreset\fP consist of an +integer, which may be followed by single\-letter preset modifiers. The +integer can be from \fB0\fP to \fB9\fP, matching the command line options \fB\-0\fP +\&...\& \fB\-9\fP. The only supported modifier is currently \fBe\fP, which matches +\fB\-\-extreme\fP. If no \fBpreset\fP is specified, the default values of LZMA1 or +LZMA2 \fIoptions\fP are taken from the preset \fB6\fP. +.TP +\fBdict=\fP\fItaille\fP +La \fItaille\fP du dictionnaire (historique du tampon) indique combien d'octets +des données récement décompressées sont gardés en mémoire. L'algorithme +essaie de trouver les séquences d'octets répétées (identiques) dans les +données décompressées et les remplace par les données actuellement dans le +dictionnaire. Plus gros est le dictionnaire, plus grande est la chance de +trouver une correspondance. Ainsi, l'augmentation de la \fItaille\fP du +dictionnaire augmente habituellement le taux de compression, mais un +dictionnaire plus gros que le fichier non compressé est un gachis de +mémoire. +.IP "" +Généralement la \fItaille\fP du dictionnaire est entre 64\ Kio et 64\ Mio. Le +minimum étant 4\ Kio. La \fItaille\fP maximale pour la compression est +habituellement 1,5\ Gio (1536\ Mio). Le décompresseur prend en charge les +dictionnaires jusqu'à un octet de moins que 4\ Gio, ce qui est le maximum +pour les formats de flux LZMA1 et LZMA2. +.IP "" +La \fItaille\fP du dictionnaire et le chercheur de correspondance (match +finder) (\fImf\fP) déterminent ensemble l'utilisation de la mémoire de +l'encodeur LZMA1 ou LZMA2. La même (ou une plus grosse) \fItaille\fP de +dictionnaire est requise pour décompresser que ce qui a été utilisé pour la +compression, ainsi l'utilisation de la mémoire du décodeur est déterminée +par la taille du dictionnaire utilisée lors de la compression. Les en\-têtes +de \fB.xz\fP stockent la \fItaille\fP de dictionnaire sous la forme 2^\fIn\fP ou +2^\fIn\fP + 2^(\fIn\fP\-1), de sorte que ces \fItailles\fP sont quelque peu préférées +pour la compression. Les autres \fItailles\fP seront arrondies à la hausse +lorsque stockées dans les en\-têtes de \fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Spécifiez le nombre d'octets de contexte littéraux. Le minimum est \fB0\fP et +le maximum est \fB4\fP. La valeur par défaut est \fB3\fP. En plus, la somme de +\fIlc\fP et \fIlp\fP ne doit pas excéder \fB4\fP. +.IP "" +Tous les octets qui ne peuvent pas être codés comme des correspondances sont +codés comme des littéraux. C'est à dire que les littéraux sont simplement +des octets 8 bits encodés un à la fois. +.IP "" +The literal coding makes an assumption that the highest \fIlc\fP bits of the +previous uncompressed byte correlate with the next byte. For example, in +typical English text, an upper\-case letter is often followed by a lower\-case +letter, and a lower\-case letter is usually followed by another lower\-case +letter. In the US\-ASCII character set, the highest three bits are 010 for +upper\-case letters and 011 for lower\-case letters. When \fIlc\fP is at least +3, the literal coding can take advantage of this property in the +uncompressed data. +.IP "" +The default value (3) is usually good. If you want maximum compression, +test \fBlc=4\fP. Sometimes it helps a little, and sometimes it makes +compression worse. If it makes it worse, test \fBlc=2\fP too. +.TP +\fBlp=\fP\fIlp\fP +Indiquer le nombre de bits de position littérale. Le minimum est \fB0\fP et le +maximum \fB4\fP; par défaut c'est \fB0\fP. +.IP "" +\fILp\fP affecte le type d'alignement dans les données décompressées qui est +présumé lors de l'encodage des littéraux. Voir \fIpb\fP ci dessous pour plus +d'information sur l'alignement. +.TP +\fBpb=\fP\fIpb\fP +Indiquer le nombre de bits de position. Le minimum est \fB0\fP et le maximum +\fB4\fP; par défaut \fB2\fP. +.IP "" +\fIPb\fP affecte quel genre d'alignement est présumé en général dans les +données non compressées. Par défaut c'est un alignement de quatre octets +(2^\fIpb\fP=2^2=4), ce qui est généralement un bon choix lorsqu'il n'y a pas de +meilleure estimation. +.IP "" +When the alignment is known, setting \fIpb\fP accordingly may reduce the file +size a little. For example, with text files having one\-byte alignment +(US\-ASCII, ISO\-8859\-*, UTF\-8), setting \fBpb=0\fP can improve compression +slightly. For UTF\-16 text, \fBpb=1\fP is a good choice. If the alignment is +an odd number like 3 bytes, \fBpb=0\fP might be the best choice. +.IP "" +Même si l'alignement présumé peut être ajusté avec \fIpb\fP et \fIlp\fP, LZMA1 et +LZMA2 favorisent toujours légèrement l'alignement sur 16 octets. Il peut +être utile d'en tenir compte lors de la conception de formats de fichiers +susceptibles d'être souvent compressés avec LZMA1 ou LZMA2. +.TP +\fBmf=\fP\fImf\fP +Match finder has a major effect on encoder speed, memory usage, and +compression ratio. Usually Hash Chain match finders are faster than Binary +Tree match finders. The default depends on the \fIpreset\fP: 0 uses \fBhc3\fP, +1\(en3 use \fBhc4\fP, and the rest use \fBbt4\fP. +.IP "" +Les chercheurs de correspondance suivants sont pris en charge. Les formules +d'utilisation de la mémoire ci\-dessous sont des approximations grossières +qui sont les plus proches de la réalité lorsque \fIdict\fP est une puissance de +deux. +.RS +.TP +\fBhc3\fP +Chaîne de hachage avec hachage de 2 et 3 octets +.br +Valeur minimale pour \fInice\fP : \fB3\fP +.br +Utilisation de la mémoire : +.br +\fIdict\fP * 7.5 (if \fIdict\fP <= 16 Mio); +.br +\fIdict\fP * 5.5 + 64 MiB (si \fIdict\fP > 16 Mio) +.TP +\fBhc4\fP +Chaîne de hachage avec hachage de 2, 3 et 4 octets +.br +Valeur minimale pour \fInice\fP : \fB4\fP +.br +Utilisation de la mémoire : +.br +\fIdict\fP * 7.5 (si \fIdict\fP <= 32 Mio); +.br +\fIdict\fP * 6.5 (si \fIdict\fP > 32 Mio) +.TP +\fBbt2\fP +Arbre binaire avec hachage de 2 octets +.br +Valeur minimale pour \fInice\fP : \fB2\fP +.br +Utilisation de la mémoire : \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Arbre binaire avec hachage de 2 et 3 octets +.br +Valeur minimale pour \fInice\fP : \fB3\fP +.br +Utilisation de la mémoire : +.br +\fIdict\fP * 11.5 (si \fIdict\fP <= 16 Mio); +.br +\fIdict\fP * 9.5 + 64 MiB (si \fIdict\fP > 16 Mio) +.TP +\fBbt4\fP +Arbre binaire avec hachage 2, 3 et 4 octets +.br +Valeur minimale pour \fInice\fP : \fB4\fP +.br +Utilisation de la mémoire : +.br +\fIdict\fP * 11.5 (si \fIdict\fP <= 32 Mio); +.br +\fIdict\fP * 10.5 (si \fIdict\fP > 32 Mio) +.RE +.TP +\fBmode=\fP\fImode\fP +Compression \fImode\fP specifies the method to analyze the data produced by the +match finder. Supported \fImodes\fP are \fBfast\fP and \fBnormal\fP. The default is +\fBfast\fP for \fIpresets\fP 0\(en3 and \fBnormal\fP for \fIpresets\fP 4\(en9. +.IP "" +Habituellement, \fBfast\fP est utilisé avec les chercheurs de correspondance de +chaîne de hachage et \fBnormal\fP avec les chercheurs de correspondance d'arbre +binaire. C'est aussi ce que font les \fIpréréglages\fP. +.TP +\fBnice=\fP\fInice\fP +Spécifier ce qui est considéré comme une bonne longueur pour une +correspondance. Une fois que la correspondance d'au moins \fInice\fP octets est +trouvée, l'algorithme arrête de chercher de meilleures correspondances +possibles. +.IP "" +\fINice\fP can be 2\(en273 bytes. Higher values tend to give better +compression ratio at the expense of speed. The default depends on the +\fIpreset\fP. +.TP +\fBdepth=\fP\fIprofondeur\fP +Spécifier la profondeur de recherche maximale dans l'outil de recherche de +correspondances. La valeur par défaut est \fB0\fP, ce qui fait que le +compresseur détermine une \fIprofondeur\fP raisonnable en fonction de \fImf\fP et +\fInice\fP. +.IP "" +Reasonable \fIdepth\fP for Hash Chains is 4\(en100 and 16\(en1000 for Binary +Trees. Using very high values for \fIdepth\fP can make the encoder extremely +slow with some files. Avoid setting the \fIdepth\fP over 1000 unless you are +prepared to interrupt the compression in case it is taking far too long. +.RE +.IP "" +Lors du décodage des flux bruts (\fB\-\-format=raw\fP), LZMA2 nécessite seulement +la \fItaille\fP du dictionnaire. LZMA1 nécessite aussi \fIlc\fP, \fIlp\fP et \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIoptions\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIoptions\fP] +.PD +Ajouter un filtre branch/call/jump (BCJ) à la chaîne de filtres. Ces filtres +ne peuvent être utilisés que s'ils ne sont pas le dernier filtre de la +chaîne de filtrage. +.IP "" +A BCJ filter converts relative addresses in the machine code to their +absolute counterparts. This doesn't change the size of the data but it +increases redundancy, which can help LZMA2 to produce 0\(en15\ % smaller +\&\fB.xz\fP file. The BCJ filters are always reversible, so using a BCJ filter +for wrong type of data doesn't cause any data loss, although it may make the +compression ratio slightly worse. The BCJ filters are very fast and use an +insignificant amount of memory. +.IP "" +Ces filtres BCJ présentent des problèmes connus liés au taux de +compression : +.RS +.IP \(bu 3 +Some types of files containing executable code (for example, object files, +static libraries, and Linux kernel modules) have the addresses in the +instructions filled with filler values. These BCJ filters will still do the +address conversion, which will make the compression worse with these files. +.IP \(bu 3 +If a BCJ filter is applied on an archive, it is possible that it makes the +compression ratio worse than not using a BCJ filter. For example, if there +are similar or even identical executables then filtering will likely make +the files less similar and thus compression is worse. The contents of +non\-executable files in the same archive can matter too. In practice one +has to try with and without a BCJ filter to see which is better in each +situation. +.RE +.IP "" +Different instruction sets have different alignment: the executable file +must be aligned to a multiple of this value in the input data to make the +filter work. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filtre;Alignement;Notes +x86;1;32 bits ou 64 bits x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096\-byte alignment is best +PowerPC;4;Grand boutiste seulement +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Since the BCJ\-filtered data is usually compressed with LZMA2, the +compression ratio may be improved slightly if the LZMA2 options are set to +match the alignment of the selected BCJ filter. Examples: +.RS +.IP \(bu 3 +IA\-64 filter has 16\-byte alignment so \fBpb=4,lp=4,lc=0\fP is good with LZMA2 +(2^4=16). +.IP \(bu 3 +RISC\-V code has 2\-byte or 4\-byte alignment depending on whether the file +contains 16\-bit compressed instructions (the C extension). When 16\-bit +instructions are used, \fBpb=2,lp=1,lc=3\fP or \fBpb=1,lp=1,lc=3\fP is good. When +16\-bit instructions aren't present, \fBpb=2,lp=2,lc=2\fP is the best. +\fBreadelf \-h\fP can be used to check if "RVC" appears on the "Flags" line. +.IP \(bu 3 +ARM64 is always 4\-byte aligned so \fBpb=2,lp=2,lc=2\fP is the best. +.IP \(bu 3 +The x86 filter is an exception. It's usually good to stick to LZMA2's +defaults (\fBpb=2,lp=0,lc=3\fP) when compressing x86 executables. +.RE +.IP "" +Tous les filtres BCJ prennent en charge les mêmes \fIoptions\fP : +.RS +.TP +\fBstart=\fP\fIdécalage\fP +Spécifier le \fIdécalage\fP de départ qui est utilisé lors de la conversion +entre les adresses relatives et absolues. Le \fIdécalage\fP doit être un +multiple de l'alignement du filtre (voir la table ci\-dessus). Sa valeur par +défaut est zéro. En pratique, cette dernière convient ; indiquer un +\fIdécalage\fP personnalisé est la plupart du temps inutile. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIoptions\fP] +Ajouter le filtre Delta à la chaîne de filtres. Le filtre Delta ne peut être +utilisé que s'il n'est pas le dernier filtre dans la chaîne. +.IP "" +Currently only simple byte\-wise delta calculation is supported. It can be +useful when compressing, for example, uncompressed bitmap images or +uncompressed PCM audio. However, special purpose algorithms may give +significantly better results than Delta + LZMA2. This is true especially +with audio, which compresses faster and better, for example, with +\fBflac\fP(1). +.IP "" +\fIoptions\fP prises en charge : +.RS +.TP +\fBdist=\fP\fIdistance\fP +Specify the \fIdistance\fP of the delta calculation in bytes. \fIdistance\fP must +be 1\(en256. The default is 1. +.IP "" +Par exemple, avec \fBdist=2\fP et une entrée huit octets A1 B1 A2 B3 A3 B5 A4 +B7, la sortie sera A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Autres options" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Supprimer les avertissements et les notifications. Indiquer cela deux fois +supprimera aussi les erreurs. Cette option n'a aucun effet sur le statut de +sortie. Cela dit, même si un avertissement était supprimé, le statut de +sortie indiquant un avertissement sera encore utilisé. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Être bavard. Si l'erreur standard est connectée à un terminal, \fBxz\fP +affichera une barre de progression. Indiquer \fB\-\-verbose\fP deux fois donnera +une sortie encore plus bavarde. +.IP "" +La barre de progression montre l'information suivante : +.RS +.IP \(bu 3 +Le pourcentage de complétion est montré si la taille du fichier en entrée +est connue. Néanmoins, le pourcentage ne peut pas être montré en cas de +redirection. +.IP \(bu 3 +Quantité de données compressées produites (compression) ou consommées +(décompression). +.IP \(bu 3 +Quantité de données non compressées consommées (compression) ou produites +(décompression). +.IP \(bu 3 +Le taux de compression, calculé en divisant la quantité de données +compréssées déjà traitées par la quantité de données décompressées déjà +traitées. +.IP \(bu 3 +Vitesse de compression ou de décompression. Elle correspond à la quantité de +données non compressées consommées (compression) ou produites +(décompression) par seconde. Elle apparait quelques secondes après le début +du traitement du fichier par \fBxz\fP. +.IP \(bu 3 +Temps écoulé dans le format M:SS ou H:MM:SS. +.IP \(bu 3 +Estimated remaining time is shown only when the size of the input file is +known and a couple of seconds have already passed since \fBxz\fP started +processing the file. The time is shown in a less precise format which never +has any colons, for example, 2 min 30 s. +.RE +.IP "" +When standard error is not a terminal, \fB\-\-verbose\fP will make \fBxz\fP print +the filename, compressed size, uncompressed size, compression ratio, and +possibly also the speed and elapsed time on a single line to standard error +after compressing or decompressing the file. The speed and elapsed time are +included only when the operation took at least a few seconds. If the +operation didn't finish, for example, due to user interruption, also the +completion percentage is printed if the size of the input file is known. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Ne pas mettre l'état de sortie à \fB2\fP même si une condition méritant un +avertissement a été détectée. Cette option n'affecte pas le niveau de +verbosité, néanmoins, les deux options \fB\-\-quiet\fP et \fB\-\-no\-warn\fP doivent +être utilisées pour ne pas afficher d'avertissements, ni altérer le statut +de sortie. +.TP +\fB\-\-robot\fP +Afficher les messages dans un format analysable par une machine. Ceci est +destiné à faciliter l'écriture des frontaux qui voudraient utiliser \fBxz\fP +plutôt que liblzma, ce qui pourrait être le cas pour différents scripts. La +sortie avec cette option activée est destinée à rester stable sur les +différentes versions de \fBxz\fP. Consulter le paragraphe \fBROBOT MODE\fP pour +les détails. +.TP +\fB\-\-info\-memory\fP +Display, in human\-readable format, how much physical memory (RAM) and how +many processor threads \fBxz\fP thinks the system has and the memory usage +limits for compression and decompression, and exit successfully. +.TP +\fB\-h\fP, \fB\-\-help\fP +Afficher un message d'aide décrivant les options les plus couramment +utilisées et quitter. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Afficher un message d'aide décrivant toutes les options de \fBxz\fP et quitter. +.TP +\fB\-V\fP, \fB\-\-version\fP +Afficher le numéro de version de \fBxz\fP et de liblzma dans un format lisible +par un humain. Pour obtenir une sortie analysable par la machine, spécifiez +\fB\-\-robot\fP avant \fB\-\-version\fP. +. +.SH "MODE ROBOT" +The robot mode is activated with the \fB\-\-robot\fP option. It makes the output +of \fBxz\fP easier to parse by other programs. Currently \fB\-\-robot\fP is +supported only together with \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, +and \fB\-\-version\fP. It will be supported for compression and decompression in +the future. +. +.SS "Mode liste" +\fBxz \-\-robot \-\-list\fP utilise une sortie séparée par des tabulations. La +première colonne de toutes les lignes possède une chaîne qui indique le type +d'information trouvée sur cette ligne : +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +C'est toujours la première ligne au début de la liste d'un fichier. La +seconde colonne de la ligne est le nom de fichier. +.TP +\fBfile\fP +Cette ligne contient l'information globale sur le fichier \fB.xz\fP. Cette +ligne est toujours écrite après la ligne \fBname\fP. +.TP +\fBstream\fP +Ce type de ligne n'est utilisée que lorsque \fB \-\-verbose\fP a été indiquée. Il +y a autant de lignes \fBstream\fP qu'il y a de flux dans le fichier \fB.xz\fP. +.TP +\fBblock\fP +Ce type de ligne n'est utilisé seulement lorsque \fB\-\-verbose\fP a été +indiquée. Il y a autant de lignes \fBblock\fP qu'il y a de blocs dans le +fichier \fB.xz\fP. Les lignes \fBblock\fP sont affichées après toutes les lignes +\fBstream\fP ; les différents types de lignes ne sont pas imbriqués. +.TP +\fBsummary\fP +Ce type de ligne n'est utilisé que lorsque \fB\-\-verbose\fP a été indiqué deux +fois. Cette ligne est affichée après toutes les lignes \fBblock\fP. Comme la +ligne \fBfile\fP, la ligne \fBsummary\fP contient l'information globale sur le +fichier \fB.xz\fP. +.TP +\fBtotals\fP +Cette ligne est toujours la toute dernière ligne de la sortie. Elle affiche +les comptes et les tailles totaux. +.PP +Les colonnes des lignes \fBfile\fP : +.PD 0 +.RS +.IP 2. 4 +Nombre de flux dans le fichier +.IP 3. 4 +Nombre total de blocs dans le ou les flux. +.IP 4. 4 +Taille compressée du fichier +.IP 5. 4 +Taille décompressée du fichier +.IP 6. 4 +Compression ratio, for example, \fB0.123\fP. If ratio is over 9.999, three +dashes (\fB\-\-\-\fP) are displayed instead of the ratio. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Liste de noms de contrôles d'intégrité séparés par des virgules. Les chaînes +suivantes sont utilisées pour les types de vérification connus : \fBNone\fP, +\fBCRC32\fP, \fBCRC64\fP et \fBSHA256\fP. Pour le types de vérification inconnus, +\fBUnknown\-\fP\fIN\fP est utilisé, où \fIN\fP est un identifiant de vérification sous +la forme d'un nombre décimal (un ou deux chiffres). +.IP 8. 4 +Taille totale du remplissage du flux dans le fichier +.RE +.PD +.PP +Les colonnes des lignes \fBstream\fP : +.PD 0 +.RS +.IP 2. 4 +Numéro de flux (le premier flux a le numéro 1) +.IP 3. 4 +Nombre de blocs dans le flux +.IP 4. 4 +Décalage de départ compressé +.IP 5. 4 +Décalage de départ décompressé +.IP 6. 4 +Taille compressée (ne comprend pas le remplissage du flux) +.IP 7. 4 +Taille décompressée +.IP 8. 4 +Taux de compression +.IP 9. 4 +Nom de la vérification d'intégrité +.IP 10. 4 +Taille du remplissage de flux +.RE +.PD +.PP +Les colonnes des lignes \fBblock\fP : +.PD 0 +.RS +.IP 2. 4 +Numéro du flux qui contient ce bloc +.IP 3. 4 +Numéro du bloc relatif au commencement du flux (le premier bloc a pour +numéro 1) +.IP 4. 4 +Numéro du bloc relatif au début du fichier +.IP 5. 4 +Décalage de départ compressé relatif au début du fichier +.IP 6. 4 +Décalage de départ décompressé relatif au début du fichier +.IP 7. 4 +Taille compressée totale du bloc (en\-têtes inclus) +.IP 8. 4 +Taille décompressée +.IP 9. 4 +Taux de compression +.IP 10. 4 +Nom de la vérification d'intégrité +.RE +.PD +.PP +Si \fB\-\-verbose\fP a été indiqué deux fois, les colonnes additionnelles sont +inclues sur les lignes \fBblock\fP. Elles ne sont pas affichées avec un seul +\fB\-\-verbose\fP, car l'obtention de ces informations nécessite de nombreuses +recherches et peut donc être lente : +.PD 0 +.RS +.IP 11. 4 +Valeur de la vérification d'intégrité en hexadécimal +.IP 12. 4 +Taille d'en\-tête de bloc +.IP 13. 4 +Drapeaux du bloc : \fBc\fP indique que la taille compressée est présente, et +\fBu\fP indique que la taille décompréssée est présente. Si le drapeau n'est +pas indiqué, un tiret (\fB\-\fP) est affiché à la place pour que la longueur de +la chaîne reste fixe. De nouveaux drapeaux pourraient être ajoutés à la fin +de la chaîne dans le futur. +.IP 14. 4 +Taille des données effectivement compressées dans le bloc (en excluant +l'en\-tête de bloc, le remplissage de bloc et les champs de vérification). +.IP 15. 4 +Quantité de mémoire (en octets) nécessaire pour décompresser ce bloc avec +cette version de \fBxz\fP. +.IP 16. 4 +Chaîne de filtrage. Remarquez que la plupart des options utilisées au moment +de la compression ne peuvent pas être connues, car seules les options +nécessaires pour la décompression sont stockées dans les en\-têtes \fB.xz\fP. +.RE +.PD +.PP +Les colonnes des lignes \fBsummary\fP : +.PD 0 +.RS +.IP 2. 4 +Quantité de mémoire (en octets) nécessaire pour décompresser ce fichier avec +cette version de \fBxz\fP. +.IP 3. 4 +\fByes\fP ou \fBno\fP indique si tous les en\-têtes de bloc stockent à la fois la +taille compressée et la taille décompressée. +.PP +\fIDepuis\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Version minimale de \fBxz\fP nécessaire pour décompresser le fichier. +.RE +.PD +.PP +Les colonnes de la ligne \fBtotals\fP : +.PD 0 +.RS +.IP 2. 4 +Nombre de flux +.IP 3. 4 +Nombre de blocs +.IP 4. 4 +Taille compressée +.IP 5. 4 +Taille décompressée +.IP 6. 4 +Taux de compression moyen +.IP 7. 4 +Liste séparée par des virgules des noms de vérification d'intégrité qui +étaient présents dans les fichiers +.IP 8. 4 +Taille de remplissage de flux +.IP 9. 4 +Nombre de fichiers. Permet de garder l'ordre des colonnes précédentes comme +sur les lignes \fBfile\fP. +.PD +.RE +.PP +Si \fB\-\-verbose\fP a été indiqué deux fois, des colonnes supplémentaires sont +incluses sur la ligne \fBtotals\fP : +.PD 0 +.RS +.IP 10. 4 +Quantité maximale de mémoire (en octets) nécessaire pour décompresser les +fichiers avec cette version de \fBxz\fP. +.IP 11. 4 +\fByes\fP ou \fBno\fP indique si tous les en\-têtes de bloc stockent à la fois la +taille compressée et la taille décompressée. +.PP +\fIDepuis\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Version minimale de \fBxz\fP nécessaire pour décompresser le fichier. +.RE +.PD +.PP +Les versions futures pourront ajouter de nouveaux types de lignes et de +nouvelles colonnes pourront être ajoutées aux types de lignes existants, +mais les colonnes existantes ne seront pas modifiées. +. +.SS "Filters help" +\fBxz \-\-robot \-\-filters\-help\fP prints the supported filters in the following +format: +.PP +\fIfilter\fP\fB:\fP\fIoption\fP\fB=<\fP\fIvalue\fP\fB>,\fP\fIoption\fP\fB=<\fP\fIvalue\fP\fB>\fP... +.TP +\fIfilter\fP +Name of the filter +.TP +\fIoption\fP +Name of a filter specific option +.TP +\fIvalue\fP +Numeric \fIvalue\fP ranges appear as \fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. String +\fIvalue\fP choices are shown within \fB< >\fP and separated by a \fB|\fP +character. +.PP +Each filter is printed on its own line. +. +.SS "Information de limite de mémoire" +\fBxz \-\-robot \-\-info\-memory\fP prints a single line with multiple tab\-separated +columns: +.IP 1. 4 +Total amount of physical memory (RAM) in bytes. +.IP 2. 4 +Memory usage limit for compression in bytes (\fB\-\-memlimit\-compress\fP). A +special value of \fB0\fP indicates the default setting which for +single\-threaded mode is the same as no limit. +.IP 3. 4 +Memory usage limit for decompression in bytes (\fB\-\-memlimit\-decompress\fP). A +special value of \fB0\fP indicates the default setting which for +single\-threaded mode is the same as no limit. +.IP 4. 4 +Since \fBxz\fP 5.3.4alpha: Memory usage for multi\-threaded decompression in +bytes (\fB\-\-memlimit\-mt\-decompress\fP). This is never zero because a +system\-specific default value shown in the column 5 is used if no limit has +been specified explicitly. This is also never greater than the value in the +column 3 even if a larger value has been specified with +\fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Since \fBxz\fP 5.3.4alpha: A system\-specific default memory usage limit that is +used to limit the number of threads when compressing with an automatic +number of threads (\fB\-\-threads=0\fP) and no memory usage limit has been +specified (\fB\-\-memlimit\-compress\fP). This is also used as the default value +for \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Since \fBxz\fP 5.3.4alpha: Number of available processor threads. +.PP +Dans le futur, la sortie de \fBxz \-\-robot \-\-info\-memory\fP pourrait avoir plus +de colonnes, mais jamais plus qu'une ligne unique. +. +.SS Version +\fBxz \-\-robot \-\-version\fP prints the version number of \fBxz\fP and liblzma in +the following format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Version majeure. +.TP +\fIYYY\fP +Version mineure. Les numéros pairs sont stables. Les numéros impairs sont +des versions alpha ou beta. +.TP +\fIZZZ\fP +Niveau de correctif pour les options stables ou juste un compteur pour les +options de développement. +.TP +\fIS\fP +Stabilité. 0 est alpha, 1 est bêta et 2 est stable. \fIS\fP devrait toujours +être 2 quand \fIYYY\fP est pair. +.PP +\fIXYYYZZZS\fP sont identiques sur les deux lignes si \fBxz\fP et liblzma sont +issus de la même version d'utilitaires XZ. +.PP +Exemples : 4.999.9beta est \fB49990091\fP et 5.0.0 est \fB50000002\fP. +. +.SH "STATUT DE SORTIE" +.TP +\fB0\fP +Tout est bon. +.TP +\fB1\fP +Une erreur est survenue. +.TP +\fB2\fP +Quelquechose méritant un avertissement s'est produit, mais aucune erreur +véritable n'est survenue. +.PP +Les notifications (pas les avertissements ou les erreurs) affichées sur +l'erreur standard n'affectent pas le statut de sortie. +. +.SH ENVIRONNEMENT +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP analyse les listes d'options séparées par des espaces à partir des +variables d'environnement \fBXZ_DEFAULTS\fP et \fBXZ_OPT\fP, dans cet ordre, avant +d'analyser les options de la ligne de commandes. Remarquez que seules les +options sont analysées depuis l'environnement des variables ; toutes les +non\-options sont ignorées silencieusement. L'analyse est faite avec +\fBgetopt_long\fP(3) qui est aussi utilisé pour les arguments de la ligne de +commandes. +.PP +\fBWarning:\fP By setting these environment variables, one is effectively +modifying programs and scripts that run \fBxz\fP. Most of the time it is safe +to set memory usage limits, number of threads, and compression options via +the environment variables. However, some options can break scripts. An +obvious example is \fB\-\-help\fP which makes \fBxz\fP show the help text instead of +compressing or decompressing a file. More subtle examples are \fB\-\-quiet\fP +and \fB\-\-verbose\fP. In many cases it works well to enable the progress +indicator using \fB\-\-verbose\fP, but in some situations the extra messages +create problems. The verbosity level also affects the behavior of +\fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +User\-specific or system\-wide default options. Typically this is set in a +shell initialization script to enable \fBxz\fP's memory usage limiter by +default or set the default number of threads. Excluding shell +initialization scripts and similar special cases, scripts should never set +or unset \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +This is for passing options to \fBxz\fP when it is not possible to set the +options directly on the \fBxz\fP command line. This is the case when \fBxz\fP is +run by a script or tool, for example, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Scripts may use \fBXZ_OPT\fP, for example, to set script\-specific default +compression options. It is still recommended to allow users to override +\fBXZ_OPT\fP if that is reasonable. For example, in \fBsh\fP(1) scripts one may +use something like this: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "Compatibilité des utilitaires LZMA" +La syntaxe de la ligne de commande de \fBxz\fP est quasimment un sur\-ensemble +de \fBlzma\fP, \fBunlzma\fP et \fBlzcat\fP comme ils sont trouvés dans les +utilitaires LZMA 4.32.x . Dans la pluspart des cas, il est possible de +remplacer les outils LZMA par les outils XZ sans casser les scripts +existants. Il existe cependant certaines incompatibilités qui peuvent +parfois poser des problèmes. +. +.SS "Niveaux de préréglage de la compression" +La numérotation des préréglages de niveau de compression est différente +entre les outils \fBxz\fP et LZMA. La différence la plus importante est la +manière dont les tailles de dictionnaire sont affectées aux différents +préréglages. La taille de dictionnaire est à peu près égale à celle +d'utilisation de la mémoire de la décompression. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Niveau;xz;Utilitaires LZMA +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Les différences de tailles des dictionnaires affectent aussi l'utilisation +de la mémoire du compresseur, mais il y a quelques autres différences entre +les outils LZMA et les outils XZ, qui rendent la différence encore plus +grande : +.RS +.PP +.TS +tab(;); +c c c +c n n. +Niveau;xz;Utilitaires LZMA 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Le niveau de préréglage par défaut dans les outils LZMA est \fB\-7\fP alors que +pour les outils XZ c'est \fB\-6\fP, les deux utilisent ainsi un dictionnaire de +8 Mio par défaut. +. +.SS "Fichiers .lzma en flux ou non" +The uncompressed size of the file can be stored in the \fB.lzma\fP header. +LZMA Utils does that when compressing regular files. The alternative is to +mark that uncompressed size is unknown and use end\-of\-payload marker to +indicate where the decompressor should stop. LZMA Utils uses this method +when uncompressed size isn't known, which is the case, for example, in +pipes. +.PP +\fBxz\fP prend en charge la décompression des fichiers \fB.lzma\fP avec ou sans +marqueur de fin de charge utile, mais tous les fichiers \fB.lzma\fP créés par +\fBxz\fP utiliseront un marqueur de fin de charge utile et ont la taille non +compréssée marquée comme inconnue dans l'en\-tête \fB.lzma\fP. Cela peut être un +problème dans quelques situations inhabituelles. Par exemple, un +décompresseur \fB.lzma\fP dans un périphérique embarqué pourrait ne fonctionner +qu'avec des fichiers dont la taille non comprimée est connue. Si vous vous +heurtez à ce problème, vous devez utiliser les utilitaires LZMA ou LZMA SDK +pour créer des fichiers \fB.lzma\fP avec une taille non compressée connue. +. +.SS "Fichiers .lzma non pris en charge" +Le format \fB.lzma\fP autorise des valeurs \fIlc\fP jusqu'à 8, et des valeurs +\fIlp\fP jusqu'à 4. Les outils LZMA peuvent décompresser des fichiers avec tous +les \fIlc\fP et \fIlp\fP, mais créez toujours les fichiers avec \fBlc=3\fP et +\fBlp=0\fP. Créer des fichiers avec d'autres valeurs \fIlc\fP et \fIlp\fP est +possible avec \fBxz\fP et avec LZMA SDK. +.PP +L'implémentation du filtre LZMA1 dans liblzma nécessite que la somme de +\fIlc\fP et \fIlp\fP soit inférieure ou égale à 4. Ainsi, les fichiers \fB.lzma\fP +qui excèdent cette limitation ne peuvent pas être décompressés avec \fBxz\fP. +.PP +Les outils LZMA créent seulement des fichiers \fB.lzma\fP qui ont une taille de +dictionnaire de 2^\fIn\fP (une puissance de 2) mais acceptent les fichiers avec +toutes les tailles de dictionnaire. Libzlma n'accepte que les fichiers +\&\fB.lzma\fP qui ont une taille dictionnaire de 2^\fIn\fP ou +2^\fIn\fP + 2^(\fIn\fP\-1). Cela afin de diminuer les faux positifs lors de la +détection des fichiers \fB.lzma\fP. +.PP +Ces limitations ne devraient pas poser problème en pratique, car +pratiquement tous les fichiers \fB.lzma\fP ont été compressés avec des réglages +que liblzma accepte. +. +.SS "Déchets excédentaires" +Lors de la décompession, l'utilitaire LZMA ignore silencieusement tout ce +qui est après le premier flux \fB.lzma\fP. Dans la majorité des situations, +c'est un bogue. Cela veut dire aussi que les outils LZMA ne gèrent pas la +décompression de fichiers \fB.lzma\fP concaténés. +.PP +S'il reste des données après le premier flux \fB.lzma\fP, \fBxz\fP considère que +le fichier est corrompu sauf si \fB\-\-single\-stream\fP a été utilisé. Cela peut +casser des scripts obscurs qui ont supposé que les déchets de fin de ligne +sont ignorés. +. +.SH NOTES +. +.SS "La sortie compressée peut varier" +La sortie compressée exacte produite par les même fichiers non compressés en +entrée peut varier en fonction des différentes versions de l'utilitaire XZ, +même si les options de compression sont identiques. En effet, il est +possible d'améliorer l'encodeur (compression plus rapide ou meilleure) sans +affecter le format du fichier. La sortie peut même varier entre différentes +compilations de la même version d'utilitaire XZ, si des options de +construction différentes sont utilisées. +.PP +Cela signifie qu'une fois que \fB\-\-rsyncable\fP a été implémenté, les fichiers +résultants ne seront pas nécessairement synchronisables avec rsync à moins +que les nouveaux et anciens fichiers n'aient été compressés avec la même +version de xz. Ce problème peut être résolu si une partie de +l'implémentation est gelée pour garantir la stabilité de la sortie rsyncable +à travers les versions de xz. +. +.SS "Décompresseurs .xz embarqués" +Les implémentations de décompresseur embarqué comme XZ Embedded ne gèrent +pas nécessairement les fichiers créés avec d'autres types de \fIvérification\fP +d'intégrité que \fBnone\fP et \fBCRC32\fP. Comme la valeur par défaut est +\fB\-\-check=crc64\fP, vous devez utiliser \fB\-\-check=none\fP ou \fB\-\-check=crc32\fP +lors de la création de fichiers pour les systèmes embarqués. +.PP +En dehors des systèmes embarqués, tous les décompresseurs de format \fB.xz\fP +gèrent tous les types de \fIvérification\fP ou sont au moins capables de +décompresser le fichier sans effectuer la vérification d'intégrité si ce +type de \fIvérification\fP particulière n'est pas pris en charge. +.PP +XZ Embedded prend en charge les filtres BCJ, mais seulement avec le décalage +de départ par défaut. +. +.SH EXEMPLES +. +.SS Bases +Compresser le fichier \fItoto\fP en \fItoto.xz\fP en utilisant le niveau de +compression par défaut (\fB\-6\fP) et supprimer \fItoto\fP si la compression +réussit : +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Décompresser \fIbidule.xz\fP en \fIbidule\fP et ne pas supprimer \fIbidule.xz\fP même +si la compression réussit : +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Create \fIbaz.tar.xz\fP with the preset \fB\-4e\fP (\fB\-4 \-\-extreme\fP), which is +slower than the default \fB\-6\fP, but needs less memory for compression and +decompression (48\ MiB and 5\ MiB, respectively): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Un mélange de fichiers compressés et non compressés peuvent être +décompressés vers la sortie standard avec une simple commande : +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Compression en parallèle de plusieurs fichiers" +Sur GNU et *BSD, \fBfind\fP(1) et \fBxargs\fP(1) peuvent être utilisés pour mettre +en parallèle la compression de plusieurs fichiers : +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +L'option \fBP\fP passée à \fBxargs\fP(1) fixe le nombre de processus \fBxz\fP en +parallèles. La meilleure valeur pour l'option \fBn\fP dépend du nombre de +fichiers à compresser. S\-il n'y a que quelques fichiers, la valeur sera +probablement 1 ; avec des dizaines de milliers de fichiers, 100 ou même plus +serait approprié pour réduire le nombre de processus \fBxz\fP que \fBxargs\fP(1) +créera éventuellement. +.PP +L'option \fB\-T1\fP de \fBxz\fP est là pour le forcer en mode mono\-thread, car +\fBxargs\fP(1) est utilisé pour contrôler la quantité de mise en parallèle. +. +.SS "Mode robot" +Calculer combien d'octets ont été économisés au total après avoir compressé +plusieurs fichiers : +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Un script peut vouloir savoir qu'il utilise une version suffisamment récente +de \fBxz\fP. Le script \fBsh\fP(1) suivant vérifie que le numéro de version de +l'outil \fBxz\fP soit au minimum 5.0.0. Cette méthode est compatible avec les +vieilles versions bêta, qui ne gèrent pas l'option \fB\-\-robot\fP : +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Régler une limite d'utilisation de la mémoire pour la décompression en +utilisant \fBXZ_OPT\fP, mais si une limite a déjà été définie, ne pas +l'augmenter : +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Chaînes de filtres de compresseur personnalisées" +L'utilisation la plus simple des chaînes de filtres personnalisées est la +personnalisation d'un préréglage LZMA2. Cela peut être utile, car les +préréglages ne couvrent qu'un sous\-ensemble des réglages de compression +potentiellement utiles. +.PP +Les colonnes CompCPU des tableaux des descriptions des options \fB\-0\fP à \fB\-9\fP +et \fB\-\-extreme\fP sont utiles lors de la personnalisation des préréglages +LZMA2. Voici les parties pertinentes recueillies à partir de ces deux +tableaux : +.RS +.PP +.TS +tab(;); +c c +n n. +Préréglage;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +If you know that a file requires somewhat big dictionary (for example, 32\ MiB) to compress well, but you want to compress it quicker than \fBxz \-8\fP +would do, a preset with a low CompCPU value (for example, 1) can be +modified to use a bigger dictionary: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Avec certains fichiers, la commande ci\-dessus peut être plus rapide que +\fBxz\-6\fP tout en compressant bien mieux. Cependant, il faut souligner que +seuls certains fichiers bénéficient d'un grand dictionnaire tout en gardant +la valeur de CompCPU faible. La siutation la plus évidente où un gros +dictionnaire peut baucoup aider, est une archive contenant des fichiers très +similaires de quelques megaoctets chacun. La taille de dictionnaire doit +être significativement plus grosse que tout fichier individuel pour +permettre à LZMA2 de tirer pleinement partie des similarités entre des +fichiers consécutifs. +.PP +Si une utilisation de la mémoire élevée pour la compression et décompression +convient, et que le fichier à compresser a une taille de plusieurs centaines +de megaoctets, il peut être utile d'utiliser un plus gros dictionnaire que +celui fourni par \fBxz\-9\fP (64 Mio) : +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Utiliser \fB\-vv\fP (\fB\-\-verbose\-\-verbose\fP) comme dans l'exemple ci\-dessus peut +être utile pour voir les besoins en mémoire du compresseur et du +décompresseur. Rappelez\-vous qu'utiliser un dictionnaire plus gros que la +taille du fichier non compressé est un gachis de mémoire, donc la commande +ci\-dessus n'est pas utile pour les petits fichiers. +.PP +Sometimes the compression time doesn't matter, but the decompressor memory +usage has to be kept low, for example, to make it possible to decompress the +file on an embedded system. The following command uses \fB\-6e\fP (\fB\-6 \-\-extreme\fP) as a base and sets the dictionary to only 64\ KiB. The +resulting file can be decompressed with XZ Embedded (that's why there is +\fB\-\-check=crc32\fP) using about 100\ KiB of memory. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +If you want to squeeze out as many bytes as possible, adjusting the number +of literal context bits (\fIlc\fP) and number of position bits (\fIpb\fP) can +sometimes help. Adjusting the number of literal position bits (\fIlp\fP) +might help too, but usually \fIlc\fP and \fIpb\fP are more important. For +example, a source code archive contains mostly US\-ASCII text, so something +like the following might give slightly (like 0.1\ %) smaller file than \fBxz \-6e\fP (try also without \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Using another filter together with LZMA2 can improve compression with +certain file types. For example, to compress a x86\-32 or x86\-64 shared +library using the x86 BCJ filter: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Notez que l'ordre des options de filtre est significatif. Si \fB\-\-x86\fP est +indiqué après \fB\-\-lzma2\fP, \fBxz\fP donnera une erreur, car il ne peut y avoir +aucun filtre après LZMA2, et aussi parce que le filtre BCJ x86 ne peut pas +être utilisé comme dernier filtre dans la chaîne. +.PP +Le filtre Delta associé à LZMA2 peut donner de bons résultats avec les +images bitmap. Cela devrait habituellement battre PNG, qui a quelques +filtres avancés supplémentaires qu'un simple delta, mais qui utilise Deflate +pour la compression effective. +.PP +The image has to be saved in uncompressed format, for example, as +uncompressed TIFF. The distance parameter of the Delta filter is set to +match the number of bytes per pixel in the image. For example, 24\-bit RGB +bitmap needs \fBdist=3\fP, and it is also good to pass \fBpb=0\fP to LZMA2 to +accommodate the three\-byte alignment: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +If multiple images have been put into a single archive (for example, +\&\fB.tar\fP), the Delta filter will work on that too as long as all images have +the same number of bytes per pixel. +. +.SH "VOIR AUSSI" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/lzmadec.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/lzmadec.1 new file mode 100644 index 0000000000000000000000000000000000000000..cd31d6c9fa4c623de4c5854ab74e2dbc32cbe10d --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/lzmadec.1 @@ -0,0 +1,90 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.\" french translation of XZ Utils man +.\" Copyright (C) 2021 Debian French l10n team +.\" Translator +.\" bubu , 2021. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDEC 1 2024\-04\-08 Tukaani "Utilitaires XZ" +.SH NOM +xzdec, lzmadec \- Small .xz et .lzma decompresseurs +.SH SYNOPSIS +\fBxzdec\fP [\fIoption...\fP] [\fIfichier...\fP] +.br +\fBlzmadec\fP [\fIoption...\fP] [\fIfichier...\fP] +.SH DESCRIPTION +\fBxzdec\fP est un outil uniquement de décompression, basé sur liblzma pour les +fichiers \fB.xz\fP (et seulement \fB.xz\fP). \fBxzdec\fP est destiné à remplacer +\fBxz\fP(1) dans les situations les plus courantes où un script a été écrit +pour utiliser \fBxz \-\-decompress \-\-stdout\fP (et possiblement quelques autres +options courantes) pour décompresser des fichiers \fB.xz\fP. \fBlzmadec\fP est +identique à \fBxzdec\fP, sauf que \fBlzmadec\fP prend en charge les fichiers +\&\fB.lzma\fP au lieu des fichiers \fB.xz\fP. +.PP +Pour réduire la taille de l'exécutable, \fBxzdec\fP ne prend en charge ni le +multithreading ni la localisation et ne lit pas les options des variables +d'environnement \fBXZ_DEFAULTS\fP et \fBXZ_OPT\fP. \fBxzdec\fP ne gère pas +l'affichage d'information sur la progression du traitement : envoyer +\fBSIGINFO\fP à \fBxzdec\fP ne fait rien, mais envoyer \fBSIGUSR1\fP termine le +processus au lieu d'afficher de l'information sur la progression. +.SH OPTIONS +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +Ignoré pour la compatibilité avec \fBxz\fP(1), \fBxzdec\fP ne gère que la +décompression. +.TP +\fB\-k\fP, \fB\-\-keep\fP +Ignoré pour la compatibilité avec \fBxz\fP(1), \fBxzdec\fP ne crée ni ne supprime +jamais aucun fichier. +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Ignoré pour la compatibilité avec \fBxz\fP(1), \fBxzdec\fP écrit toujours les +données décompressées sur la sortie standard. +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Spécifier cela une fois ne fait rien, car \fBxzdec\fP n'affiche jamais aucun +avertissement ou notification. Spécifier cela deux fois pour supprimer les +erreurs. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Ignoré pour la compatibilité avec \fBxz\fP(1), \fBxzdec\fP n'utilise jamais le +satut de sortie 2. +.TP +\fB\-h\fP, \fB\-\-help\fP +Afficher un message d'aide et quitter. +.TP +\fB\-V\fP, \fB\-\-version\fP +Afficher le numéro de version de \fBxzdec\fP et liblzma. +.SH "STATUT DE SORTIE" +.TP +\fB0\fP +Tout s'est bien passé. +.TP +\fB1\fP +Une erreur est survenue. +.PP +A la différence de \fBxz\fP(1),\fBxzdec\fP n'a pas de messages d'avertissement, et +donc le statut de sortie 2 n'est pas utilisé par \fBxzdec\fP. +.SH NOTES +Utilisez \fBxz\fP(1) au lieu de \fBxzdec\fP ou \fBlzmadec\fP pour un usage normal de +tous les jours. \fBxzdec\fP ou \fBlzmadec\fP ne sont utiles que pour les +situations où il est important d'avoir un plus petit décompresseur que le +\fBxz\fP(1) complet. +.PP +\fBxzdec\fP et \fBlzmadec\fP ne sont en fait pas vraiment si petits. La taille +peut être encore réduite en abandonnant des fonctionnalités de liblzma au +moment de la compilation, mais cela ne devrait pas être fait pour des +exécutables distribués sur des systèmes d'exploitation classique non +embarqués. Si vous avez besoin d'un décompresseur vraiment petit, pensez à +utiliser XZ Embedded. +.SH "VOIR AUSSI" +\fBxz\fP(1) +.PP +XZ Embedded: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/lzmainfo.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/lzmainfo.1 new file mode 100644 index 0000000000000000000000000000000000000000..bcba91850c5f7a9fabe11ebd519bc2f0ed5f7cea --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/lzmainfo.1 @@ -0,0 +1,47 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.\" french translation of XZ Utils man +.\" Copyright (C) 2021 Debian French l10n team +.\" Translator +.\" bubu , 2021. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH LZMAINFO 1 30\-06\-2013 Tukaani "Utilitaires XZ" +.SH NOM +lzmainfo \- Afficher l'information stockée dans l'en\-tête du fichier .lzma +.SH SYNOPSIS +\fBlzmainfo\fP [\fB\-\-help\fP] [\fB\-\-version\fP] [\fIfichier...\fP] +.SH DESCRIPTION +\fBlzmainfo\fP affiche l'information stockée dans l'en\-tête du fichier +\&\fB.lzma\fP. Il lit les 13 premiers octets du \fIfichier\fP indiqué, décode +l'en\-tête, et l'écrit sur la sortie standard dans un format lisible par un +humain. Si aucun \fIfichier\fP n'est spécifié ou si \fIfichier\fP est \fB\-\fP, +l'entrée standard est lue. +.PP +Habituellement l'information la plus interressante est la taille non +compressée et la taille du dictionnaire. La taille ne peut être affichée que +si le fichier est dans la variante du format \fB.lzma\fP qui n'est pas en +flux. La quantité de mémoire requise pour décompresser le fichier est de +quelques douzaines de kilooctets en plus de la taille du dictionnaire. +.PP +\fBlzmainfo\fP est inclus dans les utilitaires XZ essentiellement pour des +besoins de rétrocompatibilité avec les utilitaires LZMA. +.SH "STATUT DE SORTIE" +.TP +\fB0\fP +Tout est bon. +.TP +\fB1\fP +Une erreur est survenue. +.SH BOGUES +\fBlzmainfo\fP utilise \fBMB\fP alors que le suffixe correct devrait être +\fBMiB\fP(2^20 octets). Cela pour garder la sortie compatible avec les +utilitaires LZMA. +.SH "VOIR AUSSI" +\fBxz\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/unlzma.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/unlzma.1 new file mode 100644 index 0000000000000000000000000000000000000000..297dc7c0d91cc84d9990f8e22984ef3e7be54f5b --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/unlzma.1 @@ -0,0 +1,2027 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" french translation of XZ Utils man +.\" Copyright (C) 2021 Debian French l10n team +.\" Translator +.\" bubu , 2021. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 2025\-03\-08 Tukaani "Utilitaires XZ" +. +.SH NOM +xz, unxz, xzcat, lzma, unlzma, lzcat \- Compresser ou décompresser des +fichiers .xz et .lzma +. +.SH SYNOPSIS +\fBxz\fP [\fIoption...\fP] [\fIfichier...\fP] +. +.SH "ALIAS DES COMMANDES" +\fBunxz\fP est équivalent à \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP est équivalent à \fBxz \-\-decompress \-\-stdout\fP +.br +\fBlzma\fP est équivalent à \fBxz \-\-format=lzma\fP +.br +\fBunlzma\fP est équivalent à \fBxz \-\-format=lzma \-\-decompress\fP +.br +\fBlzcat\fP est équivalent à \fBxz \-\-format=lzma \-\-decompress \-\- stdout\fP +.PP +Lors de l'écriture de scripts qui nécessitent de décompresser des fichiers, +il est recommandé de toujours utiliser la commande \fBxz\fP avec les arguments +appropriés (\fBxz \-d\fP ou \fBxz \-dc\fP) au lieu des commandes \fBunxz\fP et +\fBxzcat\fP. +. +.SH DESCRIPTION +\fBxz\fP is a general\-purpose data compression tool with command line syntax +similar to \fBgzip\fP(1) and \fBbzip2\fP(1). The native file format is the +\&\fB.xz\fP format, but the legacy \fB.lzma\fP format used by LZMA Utils and raw +compressed streams with no container format headers are also supported. In +addition, decompression of the \fB.lz\fP format used by \fBlzip\fP is supported. +.PP +\fBxz\fP compresse ou décompresse chaque \fIfichier\fP en fonction du mode +d'opération choisi. Si aucun \fIfichier\fP n'est donné ou \fIfichier\fP est \fB\-\fP, +\fBxz\fP lit depuis l'entrée standard et écrit les données traitées sur la +sortie standard. \fBxz\fP refusera (affichera une erreur et ignorera le +\fIfichier\fP) d'écrire les données compressées sur la sortie standard si c'est +un terminal. De même, \fBxz\fP refusera de lire des données compressées depuis +l'entrée standard si c'est un terminal. +.PP +A moins que \fB\-\-sdout\fP ne soit indiqué, les \fIfichiers\fP autres que \fB\-\fP sont +écrits dans un nouveau fichier dont le nom est dérivé du nom de \fIfichier\fP +source : +.IP \(bu 3 +Lors de la compression, le suffixe du format de fichier cible (\fB.xz\fP ou +\&\fB.lzma\fP) est ajouté au nom de fichier source pour obtenir le nom de fichier +cible. +.IP \(bu 3 +When decompressing, the \fB.xz\fP, \fB.lzma\fP, or \fB.lz\fP suffix is removed from +the filename to get the target filename. \fBxz\fP also recognizes the suffixes +\&\fB.txz\fP and \fB.tlz\fP, and replaces them with the \fB.tar\fP suffix. +.PP +Si le fichier cible existe déjà, une erreur est affichée et le \fIfichier\fP +est ignoré. +.PP +Sauf s'il écrit dans la sortie standard, \fBxz\fP affichera un avertissement et +ignorera le \fIfichier\fP dans les cas suivants : +.IP \(bu 3 +\fIfichier\fP n'est pas un fichier normal. Les liens symboliques ne sont pas +suivis et donc ne sont pas considérés comme des fichiers normaux. +.IP \(bu 3 +\fIfichier\fP a plusieurs liens physiques. +.IP \(bu 3 +\fIfichier\fP a un setuid, setgid ou sticky bit positionné. +.IP \(bu 3 +Le mode d'opération est défini pour compresser et le \fIfichier\fP a déjà un +suffixe du format de fichier cible (\fB.xz\fP ou \fB.txz\fP lors d'une compression +en format \fB.xz\fP, et \fB.lzma\fP ou \fB.tlz\fP lors d'une compression en format +\&\fB.lzma\fP). +.IP \(bu 3 +The operation mode is set to decompress and the \fIfile\fP doesn't have a +suffix of any of the supported file formats (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, +\&\fB.tlz\fP, or \fB.lz\fP). +.PP +Après la compression ou la décompression réussie du \fIfichier\fP, \fBxz\fP copie +les permissions du propriétaire, du groupe, la date d'accès, et les +modifications d'heure depuis le \fIfichier\fP source du fichier cible. Si la +copie du groupe échoue, les permissions sont modifiées pour que le fichier +cible ne soit pas accessible aux utilisateurs qui n'ont pas les droits +d'accès au \fIfichier\fP source. \fBxz\fP ne prend actuellement pas en charge la +copie d'autres métadonnées telles que les listes de contrôle d'accès ou les +attributs étendus. +.PP +Once the target file has been successfully closed, the source \fIfile\fP is +removed unless \fB\-\-keep\fP was specified. The source \fIfile\fP is never removed +if the output is written to standard output or if an error occurs. +.PP +Envoyer \fBSIGINFO\fP ou \fBSIGURSR1\fP au processus \fBxz\fP, lui fait afficher +l'information de progression sur l'erreur standard. Cela a un intérêt limité +car lorsque l'erreur standard est un terminal, utiliser \fB\-\-verbose\fP +affichera automatiquement un indicateur de progression du processus. +. +.SS "Utilisation de la mémoire" +L'utilisation de la mémoire par \fBxz\fP varie de quelques centaines de +kilo\-octets à plusieurs gigaoctects en fonction des paramètres de +compression. Les réglages utilisés lors de la compression d'un fichier +déterminent les besoins en mémoire pour la décompression. Habituellement la +décompression nécessite 5\% à 20\% de la quantité de mémoire utilisée pour +la compression du fichier. Par exemple, décompresser un fichier créé avec +\fBxz\-9\fP recquiert habituellement 65\ Mio de mémoire. Bien qu'il soit +possible d'avoir des fichiers \fB.xz\fP nécessitant plusieurs gigaoctets de +mémoire pour être décompressés. +.PP +Especially users of older systems may find the possibility of very large +memory usage annoying. To prevent uncomfortable surprises, \fBxz\fP has a +built\-in memory usage limiter, which is disabled by default. While some +operating systems provide ways to limit the memory usage of processes, +relying on it wasn't deemed to be flexible enough (for example, using +\fBulimit\fP(1) to limit virtual memory tends to cripple \fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +The memory usage limiter can be enabled with the command line option +\fB\-\-memlimit=\fP\fIlimit\fP. Often it is more convenient to enable the limiter +by default by setting the environment variable \fBXZ_DEFAULTS\fP, for example, +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. It is possible to set the limits +separately for compression and decompression by using +\fB\-\-memlimit\-compress=\fP\fIlimit\fP and \fB\-\-memlimit\-decompress=\fP\fIlimit\fP. +Using these two options outside \fBXZ_DEFAULTS\fP is rarely useful because a +single run of \fBxz\fP cannot do both compression and decompression and +\fB\-\-memlimit=\fP\fIlimit\fP (or \fB\-M\fP \fIlimit\fP) is shorter to type on the +command line. +.PP +If the specified memory usage limit is exceeded when decompressing, \fBxz\fP +will display an error and decompressing the file will fail. If the limit is +exceeded when compressing, \fBxz\fP will try to scale the settings down so that +the limit is no longer exceeded (except when using \fB\-\-format=raw\fP or +\fB\-\-no\-adjust\fP). This way the operation won't fail unless the limit is very +small. The scaling of the settings is done in steps that don't match the +compression level presets, for example, if the limit is only slightly less +than the amount required for \fBxz \-9\fP, the settings will be scaled down only +a little, not all the way down to \fBxz \-8\fP. +. +.SS "Concaténation et remplissage avec des fichiers .xz" +Il est possible de concaténer les fichiers \fB.xz\fP tels quel. \fBxz\fP +décompressera de tels fichiers comme s'ils étaient un unique fichier \fB.xz\fP. +.PP +It is possible to insert padding between the concatenated parts or after the +last part. The padding must consist of null bytes and the size of the +padding must be a multiple of four bytes. This can be useful, for example, +if the \fB.xz\fP file is stored on a medium that measures file sizes in +512\-byte blocks. +.PP +La concaténation et le remplissage ne sont pas autorisés avec les fichiers +\&\fB.lzma\fP ou les flux bruts. +. +.SH OPTIONS +. +.SS "Suffixes entiers et valeurs spéciales." +Dans la plupart des endroits où un argument entier est attendu, un suffixe +optionel permet d'indiquer facilement les grands entiers. Il ne doit pas y +avoir d'espace entre l'entier et le suffixe. +.TP +\fBKiB\fP +Multiplier l'entier par 1024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP et \fBKB\fP sont +acceptés comme synonymes de \fBKiB\fP. +.TP +\fBMiB\fP +Multiplier l'entier par 1 048 576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP et \fBMB\fP sont +acceptés comme synonymes de \fBMiB\fP. +.TP +\fBGiB\fP +Multiplier l'entier par 1 073 741 824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP et \fBGB\fP +sont acceptés comme synonymes de \fBGiB\fP. +.PP +La valeur spéciale \fBmax\fP peut être utilisée pour indiquer la valeur +maximale de l'entier prise en charge par l'option. +. +.SS "Mode d'opération" +Si plusieurs options de mode d'opération sont données, la dernière prend +effet. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Compresser. C'est le mode d'opération par défaut lorsque aucune option de +mode opératoire n'est spécifiée ou qu'aucun autre mode d'opération n'est +sous\-entendu par le nom de la commande (par exemple \fBunxz\fP sous\-entend +\fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +After successful compression, the source file is removed unless writing to +standard output or \fB\-\-keep\fP was specified. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Decompress. After successful decompression, the source file is removed +unless writing to standard output or \fB\-\-keep\fP was specified. +.TP +\fB\-t\fP, \fB\-\-test\fP +Tester l'intégrité des \fIfichiers\fP compressés. Cette option est équivalente +à \fB\-\-decompress \-\-stdout\fP sauf que les données décompressées sont rejetées +au lieu d'être écrites sur la sortie standard. Aucun fichier n'est créé ou +supprimé. +.TP +\fB\-l\fP, \fB\-\-list\fP +Afficher l'information sur les \fIfichiers\fP compressés. Aucune sortie +non\-compressée n'est produite et aucun fichier n'est créé ou supprimé. En +mode liste, le programme ne peut pas lire les données compressées depuis +l'entrée standard ou depuis d'autres sources non adressables. +.IP "" +The default listing shows basic information about \fIfiles\fP, one file per +line. To get more detailed information, use also the \fB\-\-verbose\fP option. +For even more information, use \fB\-\-verbose\fP twice, but note that this may be +slow, because getting all the extra information requires many seeks. The +width of verbose output exceeds 80 characters, so piping the output to, for +example, \fBless\ \-S\fP may be convenient if the terminal isn't wide enough. +.IP "" +La sortie exacte peut varier suivant les versions de \fBxz\fP et les différents +paramètres régionaux. Pour une sortie lisible par la machine, utiliser +\fB\-\-robot \-\-list\fP. +. +.SS "Modificateurs d'opération" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Ne pas effacer les fichiers d'entrée. +.IP "" +Since \fBxz\fP 5.2.6, this option also makes \fBxz\fP compress or decompress even +if the input is a symbolic link to a regular file, has more than one hard +link, or has the setuid, setgid, or sticky bit set. The setuid, setgid, and +sticky bits are not copied to the target file. In earlier versions this was +only done with \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Cette option a plusieurs effets : +.RS +.IP \(bu 3 +Si le fichier cible existe déjà, l'effacer avant de compresser ou +décompresser. +.IP \(bu 3 +Compresser ou décompresser même si l'entrée est un lien symbolique vers un +fichier normal, a plus qu'un lien physique, ou a le bit setuid, setgid ou +sticky défini. Les bits setuid, setgid et sticky bits ne sont pas copiés +dans le fichier cible. +.IP \(bu 3 +Lorsque \fBxz\fP est utilisé avec \fB\-\-decompress\fP \fB\-\-stdout\fP et qu'il ne peut +pas reconnaitre le type du fichier source, copier le fichier source tel quel +dans la sortie standard. Celà permet à \fBxzcat\fP \fB\-\-force\fP d'être utilisé +comme \fBcat\fP(1) pour les fichiers qui n'ont pas été compressé avec +\fBxz\fP. Remarquez que dans le futur, \fBxz\fP devrait prendre en charge de +nouveaux formats de fichiers compressés, ce qui permettra à \fBxz\fP de +décompresser plus de types de fichiers au lieu de les copier tels quels dans +la sortie standard. \fB\-\-format=\fP\fIformat\fP peut être utilisé pour contraindre +\fBxz\fP à décompresser seulement un format de fichier. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Écrire les données compressées ou décompressées sur la sortie standard +plutôt que dans un fichier. Cela necessite \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Décompresser seulement le premier flux \fB.xz\fP et ignorer silencieusement les +possibles données d'entrée résiduelles qui suivent le flux. Normalement ces +déchets excédentaires provoquent l'affichage d'une erreur par \fBxz\fP. +.IP "" +\fBxz\fP ne décompresse jamais plus d'un flux à partir de fichiers \fB.lzma\fP ou +de flux bruts, mais cette option fait aussi que \fBxz\fP ignorera les données +résiduelles après le fichier \fB.lzma\fP ou le flux brut. +.IP "" +Cette option n'a aucun effet si le mode d'opération n'est pas +\fB\-\-decompress\fP ou \fB\-\-test\fP. +.IP "" +Since \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP implies \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Désactiver la création de fichiers peu denses. Par défaut, lors de la +décompression en un fichier normal, \fBxz\fP essaie d'en faire un fichier creux +si les données décompressées contiennent de longues séquences de zéros +binaires. Cela fonctionne aussi lors de l'écriture sur la sortie standard +aussi longtemps que la sortie standard est connectée à un fichier normal et +que certaines conditions supplémentaires sont satisfaites pour le faire de +manière sécurisée. Créer des fichiers creux peut épargner de l'espace disque +et accélérer la décompression en réduisant la quantité d'entrées/sorties sur +le disque. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Lors de la compression, utiliser \fB.suf\fP comme suffixe du fichier cible au +lieu de \fB.xz\fP ou \fB.lzma\fP. Si \fBxz\fP n'écrit pas sur la sortie standard et +si le fichier source a déja le suffixe \fB.suf\fP, un avertissement est affiché +et le fichier est ignoré. +.IP "" +When decompressing, recognize files with the suffix \fI.suf\fP in addition to +files with the \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, or \fB.lz\fP suffix. If the +source file has the suffix \fI.suf\fP, the suffix is removed to get the target +filename. +.IP "" +Lors de la compression ou décompression de flux bruts (\fB\-\-fomat=raw\fP), le +suffixe doit toujours être spécifié à moins d'écrire sur la sortie standard, +car il n'y a pas de suffixe par défaut pour les flux bruts. +.TP +\fB\-\-files\fP[\fB=\fP\fIfichier\fP] +Lire les noms de fichier à traiter depuis \fIfichier\fP ; si \fIfichier\fP est +omis , les noms de fichier sont lus sur l'entrée standard. Les noms de +fichier doivent se terminer avec le caractère de nouvelle ligne. Un tiret +(\fB\-\fP) est considéré comme un nom de fichier normal ; ce qui ne signifie pas +entrée standard. Si les noms de fichier sont aussi donnés comme arguments de +ligne de commande, ils sont traités avant les noms de fichier lus depuis +\fIfichier\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIfichier\fP] +Cela est identique à \fB\-\-files\fP[\fB=\fP\fIfichier\fP] sauf que chaque nom de +fichier doit se terminer par le caractère null. +. +.SS "Format de fichier basique et options de compression" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fIformat\fP +Indiquer le \fIformat\fP de fichier à compresser ou décompresser : +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +C'est celui par défaut. Lors de la compression, \fBauto\fP est équivalent à +\fBxz\fP. Lors de la décompression, le format du fichier en entrée est détecté +automatiquement. Notez que les flux bruts (créés avec \fB\-\-format=raw\fP) ne +peuvent pas être détectés automatiquement. +.TP +\fBxz\fP +Compresser dans le format de fichier \fB.xz\fP ou n'accepter que les fichiers +\&\fB.xz\fP à décompresser. +.TP +\fBlzma\fP, \fBalone\fP +Compresser au format de fichier \fB.lzma\fP historique, ou n'accepter que les +fichiers \fB.lzma\fP lors de la décompression. Le nom alternatif \fBalone\fP est +fourni pour la rétrocompatibilité avec les utilitaires LZMA. +.TP +\fBlzip\fP +Accept only \fB.lz\fP files when decompressing. Compression is not supported. +.IP "" +The \fB.lz\fP format versions 0 and 1 are supported. Version 0 files were +produced by \fBlzip\fP 1.3 and older. Such files aren't common but may be +found from file archives as a few source packages were released in this +format. People might have old personal files in this format too. +Decompression support for the format version 0 was removed in \fBlzip\fP 1.18. +\fBlzip\fP 1.4 and later create files in the format version 1. +.TP +\fBraw\fP +Compresser ou décompresser un flux brut (sans en\-têtes). Cela est réservé +seulement aux utilisateurs aguerris. Pour décoder des flux bruts, vous devez +utiliser \fB\-\-format=raw\fP et spécifier explicitement la chaîne de filtre, qui +normalement aurait du être stockée dans les en\-têtes du conteneur. +.RE +.TP +\fB\-C\fP \fIvérif.\fP, \fB\-\-check=\fP\fIvérif.\fP +Spécifier le type d'intégrité à vérifier. La vérification est calculée à +partir des données non\-compressées et stockées dans le fichier \fB.xz\fP. Cette +option n'a effet que si la compression a été faite dans le format \fB.xz\fP ; +le format \fB.lzma\fP ne gère pas les vérifications d'intégrité. Le contrôle +d'intégrité (s'il y en a) est vérifié lorsque le fichier \fB.xz\fP est +décompressé. +.IP "" +Types de \fIvérification\fP pris en charge : +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Ne pas calculer de vérification d'intégrité du tout. C'est généralement une +mauvaise idée. Cela peut être utile lorsque l'intégrité des données est +vérifiée de toute façon par d'autres manières. +.TP +\fBcrc32\fP +Calculer CRC32 en utilisant le polynôme de IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Calculer CRC64 en utilisant le polynôme de ECMA\-182. C'est la manière +utilisée par défaut, car c'est légèrement mieux que CRC32 pour détecter les +fichiers endommagés et la différence de vitesse est négligeable. +.TP +\fBsha256\fP +Calculer SHA\-256. C'est quelque peu plus lent que CRC32 et CRC64. +.RE +.IP "" +L'intégrité des en\-têtes \fB.xz\fP est toujours vérifiée avec CRC32. Il n'est +pas possible de le changer ou de le désactiver. +.TP +\fB\-\-ignore\-check\fP +Ne pas contrôler la vérification d'intégrité des données lors de la +décompression. Les valeurs CRC32 dans les en\-têtes \fB.xz\fP seront normalement +toujours vérifiées. +.IP "" +\fBN'utilisez pas cette option à moins de savoir ce que vous faites.\fP Les +raisons possibles pour utiliser cette option : +.RS +.IP \(bu 3 +Essayer de récupérer des données d'un fichier .xz corrompu. +.IP \(bu 3 +Accélérer la décompression. Cela importe surtout avec SHA\-256 ou avec les +fichiers qui ont été compressés extrêmement bien. Il est recommandé de ne +pas utiliser cette option dans ce but à moins que l'intégrité du fichier ne +soit vérifiée extérieurement d'une autre manière. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Choisir un niveau de compression prédéfini. La valeur par défaut est +\fB6\fP. Si plusieurs niveaux de préréglage sont spécifiés, c'est le dernier +qui sera pris en compte. Si une chaîne de filtres personnalisée a déjà été +choisie, définir un niveau de compression préréglé efface la chaîne de +filtres personnalisée. +.IP "" +Les différences entre les préréglages sont plus significatives qu'avec +\fBgzip\fP(1) et \fBbzip2\fP(1). les réglages de compression sélectionnés +déterminent les exigences en mémoire pour la décompression, ainsi, utiliser +un niveau de préréglage trop élevé peut rendre difficile à décompresser un +fichier sur un vieux système avec peu de RAM. Clairement, \fBce n'est pas une bonne idée d'utiliser \-9 aveuglément pour tout\fP comme ça l'est souvent avec +\fBgzip\fP(1) et \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Ce sont des préréglages relativement rapides. \fB0\fP est parfois plus rapide +que \fBgzip \-9\fP tout en compressant bien mieux. Les réglages plus élevés ont +souvent une rapidité comparable à celle de \fBbzip2\fP(1) avec un taux de +compression comparable ou meilleur, même si les résultats dépendent beaucoup +du genre de données compressées. +.TP +\fB\-4\fP ... \fB\-6\fP +Good to very good compression while keeping decompressor memory usage +reasonable even for old systems. \fB\-6\fP is the default, which is usually a +good choice for distributing files that need to be decompressible even on +systems with only 16\ MiB RAM. (\fB\-5e\fP or \fB\-6e\fP may be worth considering +too. See \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +C'est comme \fB\-6\fP mais avec des besoins en mémoire plus élevés pour la +compression et la décompression. Ce n'est utile que lorsque les fichiers +sont plus gros que 8\ Mio, 16\ Mio et 32\ Mio respectivement. +.RE +.IP "" +Sur le même matériel, la vitesse de décompression est sensiblement un nombre +constant d'octets de données compressées par seconde. En d'autres termes, +meilleure est la compression, plus rapide sera en général la +décompression. Cela signifie aussi que la quantité de sortie non compressée +produite par seconde peut varier beaucoup. +.IP "" +Le tableau suivant résume les caractéristiques des préréglages : +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Préréglage;DictSize;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Descriptions des colonnes : +.RS +.IP \(bu 3 +DictSize est la taille du dictionnaire de LZMA2. Utiliser un dictionnaire +plus gros que la taille du fichier non compressé est un gaspillage de +mémoire. C'est pourquoi il est bon d'éviter d'utiliser les préréglages de +\fB\-7\fP à \fB\-9\fP lorsqu'il n'y en a pas vraiment besoin. A \fB\-6\fP et plus bas, +la quantité de mémoire gaspillée est généralement assez basse pour ne pas +être un problème. +.IP \(bu 3 +CompCPU est une représentation des préréglages de LZMA2 qui affectent la +vitesse de compression. La taille du dictionnaire aussi affecte la vitesse, +alors comme CompCPU est le même pour les niveaux de \fB\-6\fP à \fB\-9\fP, les plus +haut niveaux tendent à être un peu moins rapides. Pour être encore moins +rapide et du coup obtenir peut être une meilleure compression, consultez +\fB\-\-extreme\fP. +.IP \(bu 3 +CompMem contains the compressor memory requirements in the single\-threaded +mode. It may vary slightly between \fBxz\fP versions. +.IP \(bu 3 +DecMem contient les besoins en mémoire du décompresseur. Ce sont les +réglages de la compression qui déterminent les besoins en mémoire de la +décompression. L'exacte utilisation de la mémoire est légèrement supérieure +à la taille du dictionnaire LZMA2, mais les valeurs dans la table ont été +arrondies au prochain Mio supérieur. +.RE +.IP "" +Memory requirements of the multi\-threaded mode are significantly higher than +that of the single\-threaded mode. With the default value of +\fB\-\-block\-size\fP, each thread needs 3*3*DictSize plus CompMem or DecMem. For +example, four threads with preset \fB\-6\fP needs 660\(en670\ MiB of memory. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Utilisez un variant plus lent que les préréglages (\fB\-0\fP à \fB\-9\fP) pour +espérer avoir un taux de compression légèrement meilleur, mais en cas de +malchance cela peut être pire. L'utilisation mémoire du décompresseur n'est +pas affectée, mais l'utilisation mémoire du compresseur augmente un peu aux +niveaux de préréglages de \fB\-0\fP à \fB\-3\fP. +.IP "" +Depuis qu'il y a deux préréglages avec des tailles de dictionnaire de 4\ Mio +et 8 \Mio, les préréglages \fB\-3e\fP et \fB\-5e\fP utilisent des réglages +légèrement plus rapides que \fB\-4e\fP et \fB\-6e\fP, respectivement. De cette +manière, il n'y a pas deux préréglages identiques. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Préréglage;DictSize;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Par exemple, il y a un total de quatre préréglages qui utilisent un +dictionnaire de 8 Mio et qui sont dans l'ordre du plus rapide au plus lent : +\fB\-5\fP, \fB\-6\fP, \fB\-5e\fP et \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Il y a néanmoins des alias trompeurs pour \fB\-0\fP et \fB\-9\fP, +respectivement. Ils ne sont fournis que pour des besoins de +rétro\-compatibilité avec les utilitaires LZMA. Evitez d'utiliser ces +options. +.TP +\fB\-\-block\-size=\fP\fItaille\fP +Lors de la compression dans le format \fB.xz\fP, les données de l'entrée sont +réparties en blocs de \fItaille\fP octets. Les blocs sont compressés +indépendamment les un des autres, ce qui aide avec le mode multithread +(multi\-threading) et rend possible la décompression à accès aléatoire +limité. Cette option est typiquement utilisée pour outrepasser la taille de +bloc en mode multithread, mais cette option peut aussi être utilisée en mode +single\-thread. +.IP "" +In multi\-threaded mode about three times \fIsize\fP bytes will be allocated in +each thread for buffering input and output. The default \fIsize\fP is three +times the LZMA2 dictionary size or 1 MiB, whichever is more. Typically a +good value is 2\(en4 times the size of the LZMA2 dictionary or at least 1 +MiB. Using \fIsize\fP less than the LZMA2 dictionary size is waste of RAM +because then the LZMA2 dictionary buffer will never get fully used. In +multi\-threaded mode, the sizes of the blocks are stored in the block +headers. This size information is required for multi\-threaded +decompression. +.IP "" +In single\-threaded mode no block splitting is done by default. Setting this +option doesn't affect memory usage. No size information is stored in block +headers, thus files created in single\-threaded mode won't be identical to +files created in multi\-threaded mode. The lack of size information also +means that \fBxz\fP won't be able decompress the files in multi\-threaded mode. +.TP +\fB\-\-block\-list=\fP\fIitems\fP +When compressing to the \fB.xz\fP format, start a new block with an optional +custom filter chain after the given intervals of uncompressed data. +.IP "" +The \fIitems\fP are a comma\-separated list. Each item consists of an optional +filter chain number between 0 and 9 followed by a colon (\fB:\fP) and a +required size of uncompressed data. Omitting an item (two or more +consecutive commas) is a shorthand to use the size and filters of the +previous item. +.IP "" +If the input file is bigger than the sum of the sizes in \fIitems\fP, the last +item is repeated until the end of the file. A special value of \fB0\fP may be +used as the last size to indicate that the rest of the file should be +encoded as a single block. +.IP "" +An alternative filter chain for each block can be specified in combination +with the \fB\-\-filters1=\fP\fIfilters\fP \&...\& \fB\-\-filters9=\fP\fIfilters\fP options. +These options define filter chains with an identifier between 1\(en9. +Filter chain 0 can be used to refer to the default filter chain, which is +the same as not specifying a filter chain. The filter chain identifier can +be used before the uncompressed size, followed by a colon (\fB:\fP). For +example, if one specifies \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP +then blocks will be created using: +.RS +.IP \(bu 3 +The filter chain specified by \fB\-\-filters1\fP and 2 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters3\fP and 2 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters2\fP and 4 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters2\fP and 4 MiB input +.IP \(bu 3 +The default filter chain and 2 MiB input +.IP \(bu 3 +The default filter chain and 4 MiB input for every block until end of input. +.RE +.IP "" +If one specifies a size that exceeds the encoder's block size (either the +default value in threaded mode or the value specified with +\fB\-\-block\-size=\fP\fIsize\fP), the encoder will create additional blocks while +keeping the boundaries specified in \fIitems\fP. For example, if one specifies +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP and the +input file is 80 MiB, one will get 11 blocks: 5, 10, 8, 10, 2, 10, 10, 4, +10, 10, and 1 MiB. +.IP "" +En mode multi\-threadé les tailles de blocs sont stockées dans les en\-têtes +du bloc. Cela ne se fait pas en mode mono\-threadé, la sortie encodée ne sera +donc pas identique à celle faite en mode multi\-threadé. +.TP +\fB\-\-flush\-timeout=\fP\fItemps_d'attente\fP +Lors de la compression, si plus que \fItemps_d'attente\fP millisecondes (un +entier positif) se sont écoulées depuis le précédent vidage et que lire plus +de données bloquerait, toutes les données d'entrée en attente sont vidées de +l'encodeur et mises à disposition dans le flux de sortie. Cela peut être +utile si \fBxz\fP est utilisé pour compresser les données qui sont diffusées +sur un réseau. Des petites valeurs de \fItemps_d'attente\fP rendent les données +disponibles à l'extrémité réceptrice avec un léger retard, mais les grandes +valeurs de \fItemps_d'attente\fP donnent un meilleur taux de compression. +.IP "" +Cette option est désactivée par défaut. Si cette option est indiquée plus +d'une fois, la dernière prend effet. La valeur spéciale de +\fItemps_d'attente\fP de \fB0\fP peut être utilisée pour explicitement désactiver +cette option. +.IP "" +Cette option n'est pas disponible sur les systèmes qui ne sont pas POSIX. +.IP "" +.\" FIXME +\fBCette option est encore expérimentale.\fP Actuellement, \fBxz\fP ne convient +pas pour décompresser le flux en temps réel en raison de la façon dont \fBxz\fP +effectue la mise en mémoire tampon. +.TP +\fB\-\-no\-sync\fP +Do not synchronize the target file and its directory to the storage device +before removing the source file. This can improve performance if +compressing or decompressing many small files. However, if the system +crashes soon after the deletion, it is possible that the target file was not +written to the storage device but the delete operation was. In that case +neither the original source file nor the target file is available. +.IP "" +This option has an effect only when \fBxz\fP is going to remove the source +file. In other cases synchronization is never done. +.IP "" +The synchronization and \fB\-\-no\-sync\fP were added in \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIlimite\fP +Indiquer une limite d'utilisation de la mémoire pour la compression. Si +cette option est indiquée plusieurs fois, c'est la dernière qui est prise en +compte. +.IP "" +If the compression settings exceed the \fIlimit\fP, \fBxz\fP will attempt to +adjust the settings downwards so that the limit is no longer exceeded and +display a notice that automatic adjustment was done. The adjustments are +done in this order: reducing the number of threads, switching to +single\-threaded mode if even one thread in multi\-threaded mode exceeds the +\fIlimit\fP, and finally reducing the LZMA2 dictionary size. +.IP "" +When compressing with \fB\-\-format=raw\fP or if \fB\-\-no\-adjust\fP has been +specified, only the number of threads may be reduced since it can be done +without affecting the compressed output. +.IP "" +If the \fIlimit\fP cannot be met even with the adjustments described above, an +error is displayed and \fBxz\fP will exit with exit status 1. +.IP "" +La \fIlimite\fP peut être indiquée de plusieurs façons : +.RS +.IP \(bu 3 +La \fIlimite\fP peut être une valeur absolue en octets. Utiliser un suffixe +d'entier comme \fBMiB\fP peut être utile. Exemple : +\fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +La \fIlimite\fP peut être indiquée sous forme d'un pourcentage de la mémoire +physique totale (RAM). Cela peut être particulièrement utile quand la +variable d'environnement \fBXZ_DEFAULTS\fP est indiquée dans un script +d'initialisation de l'interpréteur partagé entre différents ordinateurs. De +cette façon la limite est automatiquement plus grande sur les systèmes avec +plus de mémoire. Exemple : \fB\-\-memlimit=70%\fP +.IP \(bu 3 +The \fIlimit\fP can be reset back to its default value by setting it to \fB0\fP. +This is currently equivalent to setting the \fIlimit\fP to \fBmax\fP (no memory +usage limit). +.RE +.IP "" +For 32\-bit \fBxz\fP there is a special case: if the \fIlimit\fP would be over +\fB4020\ MiB\fP, the \fIlimit\fP is set to \fB4020\ MiB\fP. On MIPS32 \fB2000\ MiB\fP +is used instead. (The values \fB0\fP and \fBmax\fP aren't affected by this. A +similar feature doesn't exist for decompression.) This can be helpful when +a 32\-bit executable has access to 4\ GiB address space (2 GiB on MIPS32) +while hopefully doing no harm in other situations. +.IP "" +Voir aussi la section \fButilisation de la mémoire\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIlimite\fP +Régler une limite d'utilisation de la mémoire pour la décompression. Cela a +un effet sur le mode \fB\-\-list\fP. Si l'opération n'est pas possible sans +dépasser la \fIlimite\fP, \fBxz\fP affichera une erreur et la décompression +échouera. Voir \fB\-\-memlimit\-compress=\fP\fIlimite\fP pour les manières possibles +d'indiquer la \fIlimite\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimit\fP +Set a memory usage limit for multi\-threaded decompression. This can only +affect the number of threads; this will never make \fBxz\fP refuse to +decompress a file. If \fIlimit\fP is too low to allow any multi\-threading, the +\fIlimit\fP is ignored and \fBxz\fP will continue in single\-threaded mode. Note +that if also \fB\-\-memlimit\-decompress\fP is used, it will always apply to both +single\-threaded and multi\-threaded modes, and so the effective \fIlimit\fP for +multi\-threading will never be higher than the limit set with +\fB\-\-memlimit\-decompress\fP. +.IP "" +In contrast to the other memory usage limit options, +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimit\fP has a system\-specific default +\fIlimit\fP. \fBxz \-\-info\-memory\fP can be used to see the current value. +.IP "" +This option and its default value exist because without any limit the +threaded decompressor could end up allocating an insane amount of memory +with some input files. If the default \fIlimit\fP is too low on your system, +feel free to increase the \fIlimit\fP but never set it to a value larger than +the amount of usable RAM as with appropriate input files \fBxz\fP will attempt +to use that amount of memory even with a low number of threads. Running out +of memory or swapping will not improve decompression performance. +.IP "" +See \fB\-\-memlimit\-compress=\fP\fIlimit\fP for possible ways to specify the +\fIlimit\fP. Setting \fIlimit\fP to \fB0\fP resets the \fIlimit\fP to the default +system\-specific value. +.TP +\fB\-M\fP \fIlimite\fP, \fB\-\-memlimit=\fP\fIlimite\fP, \fB\-\-memory=\fP\fIlimite\fP +This is equivalent to specifying \fB\-\-memlimit\-compress=\fP\fIlimit\fP +\fB\-\-memlimit\-decompress=\fP\fIlimit\fP \fB\-\-memlimit\-mt\-decompress=\fP\fIlimit\fP. +.TP +\fB\-\-no\-adjust\fP +Display an error and exit if the memory usage limit cannot be met without +adjusting settings that affect the compressed output. That is, this +prevents \fBxz\fP from switching the encoder from multi\-threaded mode to +single\-threaded mode and from reducing the LZMA2 dictionary size. Even when +this option is used the number of threads may be reduced to meet the memory +usage limit as that won't affect the compressed output. +.IP "" +Automatic adjusting is always disabled when creating raw streams +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fIthreads\fP, \fB\-\-threads=\fP\fIthreads\fP +Specify the number of worker threads to use. Setting \fIthreads\fP to a +special value \fB0\fP makes \fBxz\fP use up to as many threads as the processor(s) +on the system support. The actual number of threads can be fewer than +\fIthreads\fP if the input file is not big enough for threading with the given +settings or if using more threads would exceed the memory usage limit. +.IP "" +The single\-threaded and multi\-threaded compressors produce different +output. Single\-threaded compressor will give the smallest file size but +only the output from the multi\-threaded compressor can be decompressed using +multiple threads. Setting \fIthreads\fP to \fB1\fP will use the single\-threaded +mode. Setting \fIthreads\fP to any other value, including \fB0\fP, will use the +multi\-threaded compressor even if the system supports only one hardware +thread. (\fBxz\fP 5.2.x used single\-threaded mode in this situation.) +.IP "" +To use multi\-threaded mode with only one thread, set \fIthreads\fP to \fB+1\fP. +The \fB+\fP prefix has no effect with values other than \fB1\fP. A memory usage +limit can still make \fBxz\fP switch to single\-threaded mode unless +\fB\-\-no\-adjust\fP is used. Support for the \fB+\fP prefix was added in \fBxz\fP +5.4.0. +.IP "" +If an automatic number of threads has been requested and no memory usage +limit has been specified, then a system\-specific default soft limit will be +used to possibly limit the number of threads. It is a soft limit in sense +that it is ignored if the number of threads becomes one, thus a soft limit +will never stop \fBxz\fP from compressing or decompressing. This default soft +limit will not make \fBxz\fP switch from multi\-threaded mode to single\-threaded +mode. The active limits can be seen with \fBxz \-\-info\-memory\fP. +.IP "" +Actuellement, la seule méthode de gestion avec des threads consiste à +séparer l'entrée en blocs et de les compresser indépendamment les uns des +autres. La taille par défaut des blocs dépend du niveau de compression et +peut\-être remplacée avec l'option \fB\-\-block\-size=\fP\fItaille\fP. +.IP "" +Threaded decompression only works on files that contain multiple blocks with +size information in block headers. All large enough files compressed in +multi\-threaded mode meet this condition, but files compressed in +single\-threaded mode don't even if \fB\-\-block\-size=\fP\fIsize\fP has been used. +.IP "" +The default value for \fIthreads\fP is \fB0\fP. In \fBxz\fP 5.4.x and older the +default is \fB1\fP. +. +.SS "Chaînes de filtres de compresseur personnalisées" +A custom filter chain allows specifying the compression settings in detail +instead of relying on the settings associated to the presets. When a custom +filter chain is specified, preset options (\fB\-0\fP \&...\& \fB\-9\fP and +\fB\-\-extreme\fP) earlier on the command line are forgotten. If a preset +option is specified after one or more custom filter chain options, the new +preset takes effect and the custom filter chain options specified earlier +are forgotten. +.PP +Une chaîne de filtre est comparable à une redirection (pipe) sur la ligne de +commande. Lors de la compression, les entrées non compressées vont au +premier filtre, dont la sortie va au prochain filtre (s'il y en a). La +sortie du dernier filtre est écrite sur le fichier compressé. Le nombre +maximal de filtres dans la chaîne est quatre, mais habituellement, un chaîne +de filtre n'a qu'un ou deux filtres. +.PP +Beaucoup de filtres ont des limitations sur l'endroit où ils peuvent se +placer dans la chaîne de filtre : quelques filtres ne peuvent fonctionner +qu'en tant que dernier filtre dans la chaîne, quelques uns en tant que non +dernier filtre, et d'autres à n'importe quelle position dans la +chaîne. Suivant le filtre, cette limitation est soit inhérente au profil du +filtre, soit existe pour des raisons de sécurité. +.PP +A custom filter chain can be specified in two different ways. The options +\fB\-\-filters=\fP\fIfilters\fP and \fB\-\-filters1=\fP\fIfilters\fP \&...\& +\fB\-\-filters9=\fP\fIfilters\fP allow specifying an entire filter chain in one +option using the liblzma filter string syntax. Alternatively, a filter +chain can be specified by using one or more individual filter options in the +order they are wanted in the filter chain. That is, the order of the +individual filter options is significant! When decoding raw streams +(\fB\-\-format=raw\fP), the filter chain must be specified in the same order as +it was specified when compressing. Any individual filter or preset options +specified before the full chain option (\fB\-\-filters=\fP\fIfilters\fP) will be +forgotten. Individual filters specified after the full chain option will +reset the filter chain. +.PP +Both the full and individual filter options take filter\-specific \fIoptions\fP +as a comma\-separated list. Extra commas in \fIoptions\fP are ignored. Every +option has a default value, so specify those you want to change. +.PP +Pour voir l'entièreté de la chaîne de filtres et ses \fIoptions\fP, utilisez +\fBxz \-vv\fP (ce qui est comme utiliser \fB\-\-verbose\fP deux fois). Cela +fonctionne aussi pour voir les options de chaîne de filtres utilisées par +les préréglages. +.TP +\fB\-\-filters=\fP\fIfilters\fP +Specify the full filter chain or a preset in a single option. Each filter +can be separated by spaces or two dashes (\fB\-\-\fP). \fIfilters\fP may need to be +quoted on the shell command line so it is parsed as a single option. To +denote \fIoptions\fP, use \fB:\fP or \fB=\fP. A preset can be prefixed with a \fB\-\fP +and followed with zero or more flags. The only supported flag is \fBe\fP to +apply the same options as \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIfilters\fP ... \fB\-\-filters9\fP=\fIfilters\fP +Specify up to nine additional filter chains that can be used with +\fB\-\-block\-list\fP. +.IP "" +For example, when compressing an archive with executable files followed by +text files, the executable part could use a filter chain with a BCJ filter +and the text part only the LZMA2 filter. +.TP +\fB\-\-filters\-help\fP +Display a help message describing how to specify presets and custom filter +chains in the \fB\-\-filters\fP and \fB\-\-filters1=\fP\fIfilters\fP \&...\& +\fB\-\-filters9=\fP\fIfilters\fP options, and exit successfully. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIoptions\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIoptions\fP] +.PD +Ajouter le filtre LZMA1 ou LZMA2 à la chaîne de filtres. Ces filtres ne +peuvent être utilisés que comme dernier filtre dans la chaîne. +.IP "" +LZMA1 est un filtre historique, qui n'est pris en charge presque uniquement +à cause de l'ancien format de fichier \fB.lzma\fP, qui ne prend en charge que +LZMA1. LZMA2 est une version mise à jour de LZMA1 pour régler certains +problèmes pratiques de LZMA1. Le format \fBxz\fP utilise LZMA2 et ne prend pas +du tout en charge LZMA1. Les taux et vitesses de compression de LZMA1 et +LZMA2 sont pratiquement identiques. +.IP "" +LZMA1 et LZMA2 partagent le même ensemble d'\fIoptions\fP : +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIpréréglage\fP +Reset all LZMA1 or LZMA2 \fIoptions\fP to \fIpreset\fP. \fIPreset\fP consist of an +integer, which may be followed by single\-letter preset modifiers. The +integer can be from \fB0\fP to \fB9\fP, matching the command line options \fB\-0\fP +\&...\& \fB\-9\fP. The only supported modifier is currently \fBe\fP, which matches +\fB\-\-extreme\fP. If no \fBpreset\fP is specified, the default values of LZMA1 or +LZMA2 \fIoptions\fP are taken from the preset \fB6\fP. +.TP +\fBdict=\fP\fItaille\fP +La \fItaille\fP du dictionnaire (historique du tampon) indique combien d'octets +des données récement décompressées sont gardés en mémoire. L'algorithme +essaie de trouver les séquences d'octets répétées (identiques) dans les +données décompressées et les remplace par les données actuellement dans le +dictionnaire. Plus gros est le dictionnaire, plus grande est la chance de +trouver une correspondance. Ainsi, l'augmentation de la \fItaille\fP du +dictionnaire augmente habituellement le taux de compression, mais un +dictionnaire plus gros que le fichier non compressé est un gachis de +mémoire. +.IP "" +Généralement la \fItaille\fP du dictionnaire est entre 64\ Kio et 64\ Mio. Le +minimum étant 4\ Kio. La \fItaille\fP maximale pour la compression est +habituellement 1,5\ Gio (1536\ Mio). Le décompresseur prend en charge les +dictionnaires jusqu'à un octet de moins que 4\ Gio, ce qui est le maximum +pour les formats de flux LZMA1 et LZMA2. +.IP "" +La \fItaille\fP du dictionnaire et le chercheur de correspondance (match +finder) (\fImf\fP) déterminent ensemble l'utilisation de la mémoire de +l'encodeur LZMA1 ou LZMA2. La même (ou une plus grosse) \fItaille\fP de +dictionnaire est requise pour décompresser que ce qui a été utilisé pour la +compression, ainsi l'utilisation de la mémoire du décodeur est déterminée +par la taille du dictionnaire utilisée lors de la compression. Les en\-têtes +de \fB.xz\fP stockent la \fItaille\fP de dictionnaire sous la forme 2^\fIn\fP ou +2^\fIn\fP + 2^(\fIn\fP\-1), de sorte que ces \fItailles\fP sont quelque peu préférées +pour la compression. Les autres \fItailles\fP seront arrondies à la hausse +lorsque stockées dans les en\-têtes de \fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Spécifiez le nombre d'octets de contexte littéraux. Le minimum est \fB0\fP et +le maximum est \fB4\fP. La valeur par défaut est \fB3\fP. En plus, la somme de +\fIlc\fP et \fIlp\fP ne doit pas excéder \fB4\fP. +.IP "" +Tous les octets qui ne peuvent pas être codés comme des correspondances sont +codés comme des littéraux. C'est à dire que les littéraux sont simplement +des octets 8 bits encodés un à la fois. +.IP "" +The literal coding makes an assumption that the highest \fIlc\fP bits of the +previous uncompressed byte correlate with the next byte. For example, in +typical English text, an upper\-case letter is often followed by a lower\-case +letter, and a lower\-case letter is usually followed by another lower\-case +letter. In the US\-ASCII character set, the highest three bits are 010 for +upper\-case letters and 011 for lower\-case letters. When \fIlc\fP is at least +3, the literal coding can take advantage of this property in the +uncompressed data. +.IP "" +The default value (3) is usually good. If you want maximum compression, +test \fBlc=4\fP. Sometimes it helps a little, and sometimes it makes +compression worse. If it makes it worse, test \fBlc=2\fP too. +.TP +\fBlp=\fP\fIlp\fP +Indiquer le nombre de bits de position littérale. Le minimum est \fB0\fP et le +maximum \fB4\fP; par défaut c'est \fB0\fP. +.IP "" +\fILp\fP affecte le type d'alignement dans les données décompressées qui est +présumé lors de l'encodage des littéraux. Voir \fIpb\fP ci dessous pour plus +d'information sur l'alignement. +.TP +\fBpb=\fP\fIpb\fP +Indiquer le nombre de bits de position. Le minimum est \fB0\fP et le maximum +\fB4\fP; par défaut \fB2\fP. +.IP "" +\fIPb\fP affecte quel genre d'alignement est présumé en général dans les +données non compressées. Par défaut c'est un alignement de quatre octets +(2^\fIpb\fP=2^2=4), ce qui est généralement un bon choix lorsqu'il n'y a pas de +meilleure estimation. +.IP "" +When the alignment is known, setting \fIpb\fP accordingly may reduce the file +size a little. For example, with text files having one\-byte alignment +(US\-ASCII, ISO\-8859\-*, UTF\-8), setting \fBpb=0\fP can improve compression +slightly. For UTF\-16 text, \fBpb=1\fP is a good choice. If the alignment is +an odd number like 3 bytes, \fBpb=0\fP might be the best choice. +.IP "" +Même si l'alignement présumé peut être ajusté avec \fIpb\fP et \fIlp\fP, LZMA1 et +LZMA2 favorisent toujours légèrement l'alignement sur 16 octets. Il peut +être utile d'en tenir compte lors de la conception de formats de fichiers +susceptibles d'être souvent compressés avec LZMA1 ou LZMA2. +.TP +\fBmf=\fP\fImf\fP +Match finder has a major effect on encoder speed, memory usage, and +compression ratio. Usually Hash Chain match finders are faster than Binary +Tree match finders. The default depends on the \fIpreset\fP: 0 uses \fBhc3\fP, +1\(en3 use \fBhc4\fP, and the rest use \fBbt4\fP. +.IP "" +Les chercheurs de correspondance suivants sont pris en charge. Les formules +d'utilisation de la mémoire ci\-dessous sont des approximations grossières +qui sont les plus proches de la réalité lorsque \fIdict\fP est une puissance de +deux. +.RS +.TP +\fBhc3\fP +Chaîne de hachage avec hachage de 2 et 3 octets +.br +Valeur minimale pour \fInice\fP : \fB3\fP +.br +Utilisation de la mémoire : +.br +\fIdict\fP * 7.5 (if \fIdict\fP <= 16 Mio); +.br +\fIdict\fP * 5.5 + 64 MiB (si \fIdict\fP > 16 Mio) +.TP +\fBhc4\fP +Chaîne de hachage avec hachage de 2, 3 et 4 octets +.br +Valeur minimale pour \fInice\fP : \fB4\fP +.br +Utilisation de la mémoire : +.br +\fIdict\fP * 7.5 (si \fIdict\fP <= 32 Mio); +.br +\fIdict\fP * 6.5 (si \fIdict\fP > 32 Mio) +.TP +\fBbt2\fP +Arbre binaire avec hachage de 2 octets +.br +Valeur minimale pour \fInice\fP : \fB2\fP +.br +Utilisation de la mémoire : \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Arbre binaire avec hachage de 2 et 3 octets +.br +Valeur minimale pour \fInice\fP : \fB3\fP +.br +Utilisation de la mémoire : +.br +\fIdict\fP * 11.5 (si \fIdict\fP <= 16 Mio); +.br +\fIdict\fP * 9.5 + 64 MiB (si \fIdict\fP > 16 Mio) +.TP +\fBbt4\fP +Arbre binaire avec hachage 2, 3 et 4 octets +.br +Valeur minimale pour \fInice\fP : \fB4\fP +.br +Utilisation de la mémoire : +.br +\fIdict\fP * 11.5 (si \fIdict\fP <= 32 Mio); +.br +\fIdict\fP * 10.5 (si \fIdict\fP > 32 Mio) +.RE +.TP +\fBmode=\fP\fImode\fP +Compression \fImode\fP specifies the method to analyze the data produced by the +match finder. Supported \fImodes\fP are \fBfast\fP and \fBnormal\fP. The default is +\fBfast\fP for \fIpresets\fP 0\(en3 and \fBnormal\fP for \fIpresets\fP 4\(en9. +.IP "" +Habituellement, \fBfast\fP est utilisé avec les chercheurs de correspondance de +chaîne de hachage et \fBnormal\fP avec les chercheurs de correspondance d'arbre +binaire. C'est aussi ce que font les \fIpréréglages\fP. +.TP +\fBnice=\fP\fInice\fP +Spécifier ce qui est considéré comme une bonne longueur pour une +correspondance. Une fois que la correspondance d'au moins \fInice\fP octets est +trouvée, l'algorithme arrête de chercher de meilleures correspondances +possibles. +.IP "" +\fINice\fP can be 2\(en273 bytes. Higher values tend to give better +compression ratio at the expense of speed. The default depends on the +\fIpreset\fP. +.TP +\fBdepth=\fP\fIprofondeur\fP +Spécifier la profondeur de recherche maximale dans l'outil de recherche de +correspondances. La valeur par défaut est \fB0\fP, ce qui fait que le +compresseur détermine une \fIprofondeur\fP raisonnable en fonction de \fImf\fP et +\fInice\fP. +.IP "" +Reasonable \fIdepth\fP for Hash Chains is 4\(en100 and 16\(en1000 for Binary +Trees. Using very high values for \fIdepth\fP can make the encoder extremely +slow with some files. Avoid setting the \fIdepth\fP over 1000 unless you are +prepared to interrupt the compression in case it is taking far too long. +.RE +.IP "" +Lors du décodage des flux bruts (\fB\-\-format=raw\fP), LZMA2 nécessite seulement +la \fItaille\fP du dictionnaire. LZMA1 nécessite aussi \fIlc\fP, \fIlp\fP et \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIoptions\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIoptions\fP] +.PD +Ajouter un filtre branch/call/jump (BCJ) à la chaîne de filtres. Ces filtres +ne peuvent être utilisés que s'ils ne sont pas le dernier filtre de la +chaîne de filtrage. +.IP "" +A BCJ filter converts relative addresses in the machine code to their +absolute counterparts. This doesn't change the size of the data but it +increases redundancy, which can help LZMA2 to produce 0\(en15\ % smaller +\&\fB.xz\fP file. The BCJ filters are always reversible, so using a BCJ filter +for wrong type of data doesn't cause any data loss, although it may make the +compression ratio slightly worse. The BCJ filters are very fast and use an +insignificant amount of memory. +.IP "" +Ces filtres BCJ présentent des problèmes connus liés au taux de +compression : +.RS +.IP \(bu 3 +Some types of files containing executable code (for example, object files, +static libraries, and Linux kernel modules) have the addresses in the +instructions filled with filler values. These BCJ filters will still do the +address conversion, which will make the compression worse with these files. +.IP \(bu 3 +If a BCJ filter is applied on an archive, it is possible that it makes the +compression ratio worse than not using a BCJ filter. For example, if there +are similar or even identical executables then filtering will likely make +the files less similar and thus compression is worse. The contents of +non\-executable files in the same archive can matter too. In practice one +has to try with and without a BCJ filter to see which is better in each +situation. +.RE +.IP "" +Different instruction sets have different alignment: the executable file +must be aligned to a multiple of this value in the input data to make the +filter work. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filtre;Alignement;Notes +x86;1;32 bits ou 64 bits x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096\-byte alignment is best +PowerPC;4;Grand boutiste seulement +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Since the BCJ\-filtered data is usually compressed with LZMA2, the +compression ratio may be improved slightly if the LZMA2 options are set to +match the alignment of the selected BCJ filter. Examples: +.RS +.IP \(bu 3 +IA\-64 filter has 16\-byte alignment so \fBpb=4,lp=4,lc=0\fP is good with LZMA2 +(2^4=16). +.IP \(bu 3 +RISC\-V code has 2\-byte or 4\-byte alignment depending on whether the file +contains 16\-bit compressed instructions (the C extension). When 16\-bit +instructions are used, \fBpb=2,lp=1,lc=3\fP or \fBpb=1,lp=1,lc=3\fP is good. When +16\-bit instructions aren't present, \fBpb=2,lp=2,lc=2\fP is the best. +\fBreadelf \-h\fP can be used to check if "RVC" appears on the "Flags" line. +.IP \(bu 3 +ARM64 is always 4\-byte aligned so \fBpb=2,lp=2,lc=2\fP is the best. +.IP \(bu 3 +The x86 filter is an exception. It's usually good to stick to LZMA2's +defaults (\fBpb=2,lp=0,lc=3\fP) when compressing x86 executables. +.RE +.IP "" +Tous les filtres BCJ prennent en charge les mêmes \fIoptions\fP : +.RS +.TP +\fBstart=\fP\fIdécalage\fP +Spécifier le \fIdécalage\fP de départ qui est utilisé lors de la conversion +entre les adresses relatives et absolues. Le \fIdécalage\fP doit être un +multiple de l'alignement du filtre (voir la table ci\-dessus). Sa valeur par +défaut est zéro. En pratique, cette dernière convient ; indiquer un +\fIdécalage\fP personnalisé est la plupart du temps inutile. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIoptions\fP] +Ajouter le filtre Delta à la chaîne de filtres. Le filtre Delta ne peut être +utilisé que s'il n'est pas le dernier filtre dans la chaîne. +.IP "" +Currently only simple byte\-wise delta calculation is supported. It can be +useful when compressing, for example, uncompressed bitmap images or +uncompressed PCM audio. However, special purpose algorithms may give +significantly better results than Delta + LZMA2. This is true especially +with audio, which compresses faster and better, for example, with +\fBflac\fP(1). +.IP "" +\fIoptions\fP prises en charge : +.RS +.TP +\fBdist=\fP\fIdistance\fP +Specify the \fIdistance\fP of the delta calculation in bytes. \fIdistance\fP must +be 1\(en256. The default is 1. +.IP "" +Par exemple, avec \fBdist=2\fP et une entrée huit octets A1 B1 A2 B3 A3 B5 A4 +B7, la sortie sera A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Autres options" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Supprimer les avertissements et les notifications. Indiquer cela deux fois +supprimera aussi les erreurs. Cette option n'a aucun effet sur le statut de +sortie. Cela dit, même si un avertissement était supprimé, le statut de +sortie indiquant un avertissement sera encore utilisé. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Être bavard. Si l'erreur standard est connectée à un terminal, \fBxz\fP +affichera une barre de progression. Indiquer \fB\-\-verbose\fP deux fois donnera +une sortie encore plus bavarde. +.IP "" +La barre de progression montre l'information suivante : +.RS +.IP \(bu 3 +Le pourcentage de complétion est montré si la taille du fichier en entrée +est connue. Néanmoins, le pourcentage ne peut pas être montré en cas de +redirection. +.IP \(bu 3 +Quantité de données compressées produites (compression) ou consommées +(décompression). +.IP \(bu 3 +Quantité de données non compressées consommées (compression) ou produites +(décompression). +.IP \(bu 3 +Le taux de compression, calculé en divisant la quantité de données +compréssées déjà traitées par la quantité de données décompressées déjà +traitées. +.IP \(bu 3 +Vitesse de compression ou de décompression. Elle correspond à la quantité de +données non compressées consommées (compression) ou produites +(décompression) par seconde. Elle apparait quelques secondes après le début +du traitement du fichier par \fBxz\fP. +.IP \(bu 3 +Temps écoulé dans le format M:SS ou H:MM:SS. +.IP \(bu 3 +Estimated remaining time is shown only when the size of the input file is +known and a couple of seconds have already passed since \fBxz\fP started +processing the file. The time is shown in a less precise format which never +has any colons, for example, 2 min 30 s. +.RE +.IP "" +When standard error is not a terminal, \fB\-\-verbose\fP will make \fBxz\fP print +the filename, compressed size, uncompressed size, compression ratio, and +possibly also the speed and elapsed time on a single line to standard error +after compressing or decompressing the file. The speed and elapsed time are +included only when the operation took at least a few seconds. If the +operation didn't finish, for example, due to user interruption, also the +completion percentage is printed if the size of the input file is known. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Ne pas mettre l'état de sortie à \fB2\fP même si une condition méritant un +avertissement a été détectée. Cette option n'affecte pas le niveau de +verbosité, néanmoins, les deux options \fB\-\-quiet\fP et \fB\-\-no\-warn\fP doivent +être utilisées pour ne pas afficher d'avertissements, ni altérer le statut +de sortie. +.TP +\fB\-\-robot\fP +Afficher les messages dans un format analysable par une machine. Ceci est +destiné à faciliter l'écriture des frontaux qui voudraient utiliser \fBxz\fP +plutôt que liblzma, ce qui pourrait être le cas pour différents scripts. La +sortie avec cette option activée est destinée à rester stable sur les +différentes versions de \fBxz\fP. Consulter le paragraphe \fBROBOT MODE\fP pour +les détails. +.TP +\fB\-\-info\-memory\fP +Display, in human\-readable format, how much physical memory (RAM) and how +many processor threads \fBxz\fP thinks the system has and the memory usage +limits for compression and decompression, and exit successfully. +.TP +\fB\-h\fP, \fB\-\-help\fP +Afficher un message d'aide décrivant les options les plus couramment +utilisées et quitter. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Afficher un message d'aide décrivant toutes les options de \fBxz\fP et quitter. +.TP +\fB\-V\fP, \fB\-\-version\fP +Afficher le numéro de version de \fBxz\fP et de liblzma dans un format lisible +par un humain. Pour obtenir une sortie analysable par la machine, spécifiez +\fB\-\-robot\fP avant \fB\-\-version\fP. +. +.SH "MODE ROBOT" +The robot mode is activated with the \fB\-\-robot\fP option. It makes the output +of \fBxz\fP easier to parse by other programs. Currently \fB\-\-robot\fP is +supported only together with \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, +and \fB\-\-version\fP. It will be supported for compression and decompression in +the future. +. +.SS "Mode liste" +\fBxz \-\-robot \-\-list\fP utilise une sortie séparée par des tabulations. La +première colonne de toutes les lignes possède une chaîne qui indique le type +d'information trouvée sur cette ligne : +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +C'est toujours la première ligne au début de la liste d'un fichier. La +seconde colonne de la ligne est le nom de fichier. +.TP +\fBfile\fP +Cette ligne contient l'information globale sur le fichier \fB.xz\fP. Cette +ligne est toujours écrite après la ligne \fBname\fP. +.TP +\fBstream\fP +Ce type de ligne n'est utilisée que lorsque \fB \-\-verbose\fP a été indiquée. Il +y a autant de lignes \fBstream\fP qu'il y a de flux dans le fichier \fB.xz\fP. +.TP +\fBblock\fP +Ce type de ligne n'est utilisé seulement lorsque \fB\-\-verbose\fP a été +indiquée. Il y a autant de lignes \fBblock\fP qu'il y a de blocs dans le +fichier \fB.xz\fP. Les lignes \fBblock\fP sont affichées après toutes les lignes +\fBstream\fP ; les différents types de lignes ne sont pas imbriqués. +.TP +\fBsummary\fP +Ce type de ligne n'est utilisé que lorsque \fB\-\-verbose\fP a été indiqué deux +fois. Cette ligne est affichée après toutes les lignes \fBblock\fP. Comme la +ligne \fBfile\fP, la ligne \fBsummary\fP contient l'information globale sur le +fichier \fB.xz\fP. +.TP +\fBtotals\fP +Cette ligne est toujours la toute dernière ligne de la sortie. Elle affiche +les comptes et les tailles totaux. +.PP +Les colonnes des lignes \fBfile\fP : +.PD 0 +.RS +.IP 2. 4 +Nombre de flux dans le fichier +.IP 3. 4 +Nombre total de blocs dans le ou les flux. +.IP 4. 4 +Taille compressée du fichier +.IP 5. 4 +Taille décompressée du fichier +.IP 6. 4 +Compression ratio, for example, \fB0.123\fP. If ratio is over 9.999, three +dashes (\fB\-\-\-\fP) are displayed instead of the ratio. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Liste de noms de contrôles d'intégrité séparés par des virgules. Les chaînes +suivantes sont utilisées pour les types de vérification connus : \fBNone\fP, +\fBCRC32\fP, \fBCRC64\fP et \fBSHA256\fP. Pour le types de vérification inconnus, +\fBUnknown\-\fP\fIN\fP est utilisé, où \fIN\fP est un identifiant de vérification sous +la forme d'un nombre décimal (un ou deux chiffres). +.IP 8. 4 +Taille totale du remplissage du flux dans le fichier +.RE +.PD +.PP +Les colonnes des lignes \fBstream\fP : +.PD 0 +.RS +.IP 2. 4 +Numéro de flux (le premier flux a le numéro 1) +.IP 3. 4 +Nombre de blocs dans le flux +.IP 4. 4 +Décalage de départ compressé +.IP 5. 4 +Décalage de départ décompressé +.IP 6. 4 +Taille compressée (ne comprend pas le remplissage du flux) +.IP 7. 4 +Taille décompressée +.IP 8. 4 +Taux de compression +.IP 9. 4 +Nom de la vérification d'intégrité +.IP 10. 4 +Taille du remplissage de flux +.RE +.PD +.PP +Les colonnes des lignes \fBblock\fP : +.PD 0 +.RS +.IP 2. 4 +Numéro du flux qui contient ce bloc +.IP 3. 4 +Numéro du bloc relatif au commencement du flux (le premier bloc a pour +numéro 1) +.IP 4. 4 +Numéro du bloc relatif au début du fichier +.IP 5. 4 +Décalage de départ compressé relatif au début du fichier +.IP 6. 4 +Décalage de départ décompressé relatif au début du fichier +.IP 7. 4 +Taille compressée totale du bloc (en\-têtes inclus) +.IP 8. 4 +Taille décompressée +.IP 9. 4 +Taux de compression +.IP 10. 4 +Nom de la vérification d'intégrité +.RE +.PD +.PP +Si \fB\-\-verbose\fP a été indiqué deux fois, les colonnes additionnelles sont +inclues sur les lignes \fBblock\fP. Elles ne sont pas affichées avec un seul +\fB\-\-verbose\fP, car l'obtention de ces informations nécessite de nombreuses +recherches et peut donc être lente : +.PD 0 +.RS +.IP 11. 4 +Valeur de la vérification d'intégrité en hexadécimal +.IP 12. 4 +Taille d'en\-tête de bloc +.IP 13. 4 +Drapeaux du bloc : \fBc\fP indique que la taille compressée est présente, et +\fBu\fP indique que la taille décompréssée est présente. Si le drapeau n'est +pas indiqué, un tiret (\fB\-\fP) est affiché à la place pour que la longueur de +la chaîne reste fixe. De nouveaux drapeaux pourraient être ajoutés à la fin +de la chaîne dans le futur. +.IP 14. 4 +Taille des données effectivement compressées dans le bloc (en excluant +l'en\-tête de bloc, le remplissage de bloc et les champs de vérification). +.IP 15. 4 +Quantité de mémoire (en octets) nécessaire pour décompresser ce bloc avec +cette version de \fBxz\fP. +.IP 16. 4 +Chaîne de filtrage. Remarquez que la plupart des options utilisées au moment +de la compression ne peuvent pas être connues, car seules les options +nécessaires pour la décompression sont stockées dans les en\-têtes \fB.xz\fP. +.RE +.PD +.PP +Les colonnes des lignes \fBsummary\fP : +.PD 0 +.RS +.IP 2. 4 +Quantité de mémoire (en octets) nécessaire pour décompresser ce fichier avec +cette version de \fBxz\fP. +.IP 3. 4 +\fByes\fP ou \fBno\fP indique si tous les en\-têtes de bloc stockent à la fois la +taille compressée et la taille décompressée. +.PP +\fIDepuis\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Version minimale de \fBxz\fP nécessaire pour décompresser le fichier. +.RE +.PD +.PP +Les colonnes de la ligne \fBtotals\fP : +.PD 0 +.RS +.IP 2. 4 +Nombre de flux +.IP 3. 4 +Nombre de blocs +.IP 4. 4 +Taille compressée +.IP 5. 4 +Taille décompressée +.IP 6. 4 +Taux de compression moyen +.IP 7. 4 +Liste séparée par des virgules des noms de vérification d'intégrité qui +étaient présents dans les fichiers +.IP 8. 4 +Taille de remplissage de flux +.IP 9. 4 +Nombre de fichiers. Permet de garder l'ordre des colonnes précédentes comme +sur les lignes \fBfile\fP. +.PD +.RE +.PP +Si \fB\-\-verbose\fP a été indiqué deux fois, des colonnes supplémentaires sont +incluses sur la ligne \fBtotals\fP : +.PD 0 +.RS +.IP 10. 4 +Quantité maximale de mémoire (en octets) nécessaire pour décompresser les +fichiers avec cette version de \fBxz\fP. +.IP 11. 4 +\fByes\fP ou \fBno\fP indique si tous les en\-têtes de bloc stockent à la fois la +taille compressée et la taille décompressée. +.PP +\fIDepuis\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Version minimale de \fBxz\fP nécessaire pour décompresser le fichier. +.RE +.PD +.PP +Les versions futures pourront ajouter de nouveaux types de lignes et de +nouvelles colonnes pourront être ajoutées aux types de lignes existants, +mais les colonnes existantes ne seront pas modifiées. +. +.SS "Filters help" +\fBxz \-\-robot \-\-filters\-help\fP prints the supported filters in the following +format: +.PP +\fIfilter\fP\fB:\fP\fIoption\fP\fB=<\fP\fIvalue\fP\fB>,\fP\fIoption\fP\fB=<\fP\fIvalue\fP\fB>\fP... +.TP +\fIfilter\fP +Name of the filter +.TP +\fIoption\fP +Name of a filter specific option +.TP +\fIvalue\fP +Numeric \fIvalue\fP ranges appear as \fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. String +\fIvalue\fP choices are shown within \fB< >\fP and separated by a \fB|\fP +character. +.PP +Each filter is printed on its own line. +. +.SS "Information de limite de mémoire" +\fBxz \-\-robot \-\-info\-memory\fP prints a single line with multiple tab\-separated +columns: +.IP 1. 4 +Total amount of physical memory (RAM) in bytes. +.IP 2. 4 +Memory usage limit for compression in bytes (\fB\-\-memlimit\-compress\fP). A +special value of \fB0\fP indicates the default setting which for +single\-threaded mode is the same as no limit. +.IP 3. 4 +Memory usage limit for decompression in bytes (\fB\-\-memlimit\-decompress\fP). A +special value of \fB0\fP indicates the default setting which for +single\-threaded mode is the same as no limit. +.IP 4. 4 +Since \fBxz\fP 5.3.4alpha: Memory usage for multi\-threaded decompression in +bytes (\fB\-\-memlimit\-mt\-decompress\fP). This is never zero because a +system\-specific default value shown in the column 5 is used if no limit has +been specified explicitly. This is also never greater than the value in the +column 3 even if a larger value has been specified with +\fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Since \fBxz\fP 5.3.4alpha: A system\-specific default memory usage limit that is +used to limit the number of threads when compressing with an automatic +number of threads (\fB\-\-threads=0\fP) and no memory usage limit has been +specified (\fB\-\-memlimit\-compress\fP). This is also used as the default value +for \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Since \fBxz\fP 5.3.4alpha: Number of available processor threads. +.PP +Dans le futur, la sortie de \fBxz \-\-robot \-\-info\-memory\fP pourrait avoir plus +de colonnes, mais jamais plus qu'une ligne unique. +. +.SS Version +\fBxz \-\-robot \-\-version\fP prints the version number of \fBxz\fP and liblzma in +the following format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Version majeure. +.TP +\fIYYY\fP +Version mineure. Les numéros pairs sont stables. Les numéros impairs sont +des versions alpha ou beta. +.TP +\fIZZZ\fP +Niveau de correctif pour les options stables ou juste un compteur pour les +options de développement. +.TP +\fIS\fP +Stabilité. 0 est alpha, 1 est bêta et 2 est stable. \fIS\fP devrait toujours +être 2 quand \fIYYY\fP est pair. +.PP +\fIXYYYZZZS\fP sont identiques sur les deux lignes si \fBxz\fP et liblzma sont +issus de la même version d'utilitaires XZ. +.PP +Exemples : 4.999.9beta est \fB49990091\fP et 5.0.0 est \fB50000002\fP. +. +.SH "STATUT DE SORTIE" +.TP +\fB0\fP +Tout est bon. +.TP +\fB1\fP +Une erreur est survenue. +.TP +\fB2\fP +Quelquechose méritant un avertissement s'est produit, mais aucune erreur +véritable n'est survenue. +.PP +Les notifications (pas les avertissements ou les erreurs) affichées sur +l'erreur standard n'affectent pas le statut de sortie. +. +.SH ENVIRONNEMENT +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP analyse les listes d'options séparées par des espaces à partir des +variables d'environnement \fBXZ_DEFAULTS\fP et \fBXZ_OPT\fP, dans cet ordre, avant +d'analyser les options de la ligne de commandes. Remarquez que seules les +options sont analysées depuis l'environnement des variables ; toutes les +non\-options sont ignorées silencieusement. L'analyse est faite avec +\fBgetopt_long\fP(3) qui est aussi utilisé pour les arguments de la ligne de +commandes. +.PP +\fBWarning:\fP By setting these environment variables, one is effectively +modifying programs and scripts that run \fBxz\fP. Most of the time it is safe +to set memory usage limits, number of threads, and compression options via +the environment variables. However, some options can break scripts. An +obvious example is \fB\-\-help\fP which makes \fBxz\fP show the help text instead of +compressing or decompressing a file. More subtle examples are \fB\-\-quiet\fP +and \fB\-\-verbose\fP. In many cases it works well to enable the progress +indicator using \fB\-\-verbose\fP, but in some situations the extra messages +create problems. The verbosity level also affects the behavior of +\fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +User\-specific or system\-wide default options. Typically this is set in a +shell initialization script to enable \fBxz\fP's memory usage limiter by +default or set the default number of threads. Excluding shell +initialization scripts and similar special cases, scripts should never set +or unset \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +This is for passing options to \fBxz\fP when it is not possible to set the +options directly on the \fBxz\fP command line. This is the case when \fBxz\fP is +run by a script or tool, for example, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Scripts may use \fBXZ_OPT\fP, for example, to set script\-specific default +compression options. It is still recommended to allow users to override +\fBXZ_OPT\fP if that is reasonable. For example, in \fBsh\fP(1) scripts one may +use something like this: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "Compatibilité des utilitaires LZMA" +La syntaxe de la ligne de commande de \fBxz\fP est quasimment un sur\-ensemble +de \fBlzma\fP, \fBunlzma\fP et \fBlzcat\fP comme ils sont trouvés dans les +utilitaires LZMA 4.32.x . Dans la pluspart des cas, il est possible de +remplacer les outils LZMA par les outils XZ sans casser les scripts +existants. Il existe cependant certaines incompatibilités qui peuvent +parfois poser des problèmes. +. +.SS "Niveaux de préréglage de la compression" +La numérotation des préréglages de niveau de compression est différente +entre les outils \fBxz\fP et LZMA. La différence la plus importante est la +manière dont les tailles de dictionnaire sont affectées aux différents +préréglages. La taille de dictionnaire est à peu près égale à celle +d'utilisation de la mémoire de la décompression. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Niveau;xz;Utilitaires LZMA +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Les différences de tailles des dictionnaires affectent aussi l'utilisation +de la mémoire du compresseur, mais il y a quelques autres différences entre +les outils LZMA et les outils XZ, qui rendent la différence encore plus +grande : +.RS +.PP +.TS +tab(;); +c c c +c n n. +Niveau;xz;Utilitaires LZMA 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Le niveau de préréglage par défaut dans les outils LZMA est \fB\-7\fP alors que +pour les outils XZ c'est \fB\-6\fP, les deux utilisent ainsi un dictionnaire de +8 Mio par défaut. +. +.SS "Fichiers .lzma en flux ou non" +The uncompressed size of the file can be stored in the \fB.lzma\fP header. +LZMA Utils does that when compressing regular files. The alternative is to +mark that uncompressed size is unknown and use end\-of\-payload marker to +indicate where the decompressor should stop. LZMA Utils uses this method +when uncompressed size isn't known, which is the case, for example, in +pipes. +.PP +\fBxz\fP prend en charge la décompression des fichiers \fB.lzma\fP avec ou sans +marqueur de fin de charge utile, mais tous les fichiers \fB.lzma\fP créés par +\fBxz\fP utiliseront un marqueur de fin de charge utile et ont la taille non +compréssée marquée comme inconnue dans l'en\-tête \fB.lzma\fP. Cela peut être un +problème dans quelques situations inhabituelles. Par exemple, un +décompresseur \fB.lzma\fP dans un périphérique embarqué pourrait ne fonctionner +qu'avec des fichiers dont la taille non comprimée est connue. Si vous vous +heurtez à ce problème, vous devez utiliser les utilitaires LZMA ou LZMA SDK +pour créer des fichiers \fB.lzma\fP avec une taille non compressée connue. +. +.SS "Fichiers .lzma non pris en charge" +Le format \fB.lzma\fP autorise des valeurs \fIlc\fP jusqu'à 8, et des valeurs +\fIlp\fP jusqu'à 4. Les outils LZMA peuvent décompresser des fichiers avec tous +les \fIlc\fP et \fIlp\fP, mais créez toujours les fichiers avec \fBlc=3\fP et +\fBlp=0\fP. Créer des fichiers avec d'autres valeurs \fIlc\fP et \fIlp\fP est +possible avec \fBxz\fP et avec LZMA SDK. +.PP +L'implémentation du filtre LZMA1 dans liblzma nécessite que la somme de +\fIlc\fP et \fIlp\fP soit inférieure ou égale à 4. Ainsi, les fichiers \fB.lzma\fP +qui excèdent cette limitation ne peuvent pas être décompressés avec \fBxz\fP. +.PP +Les outils LZMA créent seulement des fichiers \fB.lzma\fP qui ont une taille de +dictionnaire de 2^\fIn\fP (une puissance de 2) mais acceptent les fichiers avec +toutes les tailles de dictionnaire. Libzlma n'accepte que les fichiers +\&\fB.lzma\fP qui ont une taille dictionnaire de 2^\fIn\fP ou +2^\fIn\fP + 2^(\fIn\fP\-1). Cela afin de diminuer les faux positifs lors de la +détection des fichiers \fB.lzma\fP. +.PP +Ces limitations ne devraient pas poser problème en pratique, car +pratiquement tous les fichiers \fB.lzma\fP ont été compressés avec des réglages +que liblzma accepte. +. +.SS "Déchets excédentaires" +Lors de la décompession, l'utilitaire LZMA ignore silencieusement tout ce +qui est après le premier flux \fB.lzma\fP. Dans la majorité des situations, +c'est un bogue. Cela veut dire aussi que les outils LZMA ne gèrent pas la +décompression de fichiers \fB.lzma\fP concaténés. +.PP +S'il reste des données après le premier flux \fB.lzma\fP, \fBxz\fP considère que +le fichier est corrompu sauf si \fB\-\-single\-stream\fP a été utilisé. Cela peut +casser des scripts obscurs qui ont supposé que les déchets de fin de ligne +sont ignorés. +. +.SH NOTES +. +.SS "La sortie compressée peut varier" +La sortie compressée exacte produite par les même fichiers non compressés en +entrée peut varier en fonction des différentes versions de l'utilitaire XZ, +même si les options de compression sont identiques. En effet, il est +possible d'améliorer l'encodeur (compression plus rapide ou meilleure) sans +affecter le format du fichier. La sortie peut même varier entre différentes +compilations de la même version d'utilitaire XZ, si des options de +construction différentes sont utilisées. +.PP +Cela signifie qu'une fois que \fB\-\-rsyncable\fP a été implémenté, les fichiers +résultants ne seront pas nécessairement synchronisables avec rsync à moins +que les nouveaux et anciens fichiers n'aient été compressés avec la même +version de xz. Ce problème peut être résolu si une partie de +l'implémentation est gelée pour garantir la stabilité de la sortie rsyncable +à travers les versions de xz. +. +.SS "Décompresseurs .xz embarqués" +Les implémentations de décompresseur embarqué comme XZ Embedded ne gèrent +pas nécessairement les fichiers créés avec d'autres types de \fIvérification\fP +d'intégrité que \fBnone\fP et \fBCRC32\fP. Comme la valeur par défaut est +\fB\-\-check=crc64\fP, vous devez utiliser \fB\-\-check=none\fP ou \fB\-\-check=crc32\fP +lors de la création de fichiers pour les systèmes embarqués. +.PP +En dehors des systèmes embarqués, tous les décompresseurs de format \fB.xz\fP +gèrent tous les types de \fIvérification\fP ou sont au moins capables de +décompresser le fichier sans effectuer la vérification d'intégrité si ce +type de \fIvérification\fP particulière n'est pas pris en charge. +.PP +XZ Embedded prend en charge les filtres BCJ, mais seulement avec le décalage +de départ par défaut. +. +.SH EXEMPLES +. +.SS Bases +Compresser le fichier \fItoto\fP en \fItoto.xz\fP en utilisant le niveau de +compression par défaut (\fB\-6\fP) et supprimer \fItoto\fP si la compression +réussit : +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Décompresser \fIbidule.xz\fP en \fIbidule\fP et ne pas supprimer \fIbidule.xz\fP même +si la compression réussit : +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Create \fIbaz.tar.xz\fP with the preset \fB\-4e\fP (\fB\-4 \-\-extreme\fP), which is +slower than the default \fB\-6\fP, but needs less memory for compression and +decompression (48\ MiB and 5\ MiB, respectively): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Un mélange de fichiers compressés et non compressés peuvent être +décompressés vers la sortie standard avec une simple commande : +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Compression en parallèle de plusieurs fichiers" +Sur GNU et *BSD, \fBfind\fP(1) et \fBxargs\fP(1) peuvent être utilisés pour mettre +en parallèle la compression de plusieurs fichiers : +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +L'option \fBP\fP passée à \fBxargs\fP(1) fixe le nombre de processus \fBxz\fP en +parallèles. La meilleure valeur pour l'option \fBn\fP dépend du nombre de +fichiers à compresser. S\-il n'y a que quelques fichiers, la valeur sera +probablement 1 ; avec des dizaines de milliers de fichiers, 100 ou même plus +serait approprié pour réduire le nombre de processus \fBxz\fP que \fBxargs\fP(1) +créera éventuellement. +.PP +L'option \fB\-T1\fP de \fBxz\fP est là pour le forcer en mode mono\-thread, car +\fBxargs\fP(1) est utilisé pour contrôler la quantité de mise en parallèle. +. +.SS "Mode robot" +Calculer combien d'octets ont été économisés au total après avoir compressé +plusieurs fichiers : +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Un script peut vouloir savoir qu'il utilise une version suffisamment récente +de \fBxz\fP. Le script \fBsh\fP(1) suivant vérifie que le numéro de version de +l'outil \fBxz\fP soit au minimum 5.0.0. Cette méthode est compatible avec les +vieilles versions bêta, qui ne gèrent pas l'option \fB\-\-robot\fP : +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Régler une limite d'utilisation de la mémoire pour la décompression en +utilisant \fBXZ_OPT\fP, mais si une limite a déjà été définie, ne pas +l'augmenter : +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Chaînes de filtres de compresseur personnalisées" +L'utilisation la plus simple des chaînes de filtres personnalisées est la +personnalisation d'un préréglage LZMA2. Cela peut être utile, car les +préréglages ne couvrent qu'un sous\-ensemble des réglages de compression +potentiellement utiles. +.PP +Les colonnes CompCPU des tableaux des descriptions des options \fB\-0\fP à \fB\-9\fP +et \fB\-\-extreme\fP sont utiles lors de la personnalisation des préréglages +LZMA2. Voici les parties pertinentes recueillies à partir de ces deux +tableaux : +.RS +.PP +.TS +tab(;); +c c +n n. +Préréglage;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +If you know that a file requires somewhat big dictionary (for example, 32\ MiB) to compress well, but you want to compress it quicker than \fBxz \-8\fP +would do, a preset with a low CompCPU value (for example, 1) can be +modified to use a bigger dictionary: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Avec certains fichiers, la commande ci\-dessus peut être plus rapide que +\fBxz\-6\fP tout en compressant bien mieux. Cependant, il faut souligner que +seuls certains fichiers bénéficient d'un grand dictionnaire tout en gardant +la valeur de CompCPU faible. La siutation la plus évidente où un gros +dictionnaire peut baucoup aider, est une archive contenant des fichiers très +similaires de quelques megaoctets chacun. La taille de dictionnaire doit +être significativement plus grosse que tout fichier individuel pour +permettre à LZMA2 de tirer pleinement partie des similarités entre des +fichiers consécutifs. +.PP +Si une utilisation de la mémoire élevée pour la compression et décompression +convient, et que le fichier à compresser a une taille de plusieurs centaines +de megaoctets, il peut être utile d'utiliser un plus gros dictionnaire que +celui fourni par \fBxz\-9\fP (64 Mio) : +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Utiliser \fB\-vv\fP (\fB\-\-verbose\-\-verbose\fP) comme dans l'exemple ci\-dessus peut +être utile pour voir les besoins en mémoire du compresseur et du +décompresseur. Rappelez\-vous qu'utiliser un dictionnaire plus gros que la +taille du fichier non compressé est un gachis de mémoire, donc la commande +ci\-dessus n'est pas utile pour les petits fichiers. +.PP +Sometimes the compression time doesn't matter, but the decompressor memory +usage has to be kept low, for example, to make it possible to decompress the +file on an embedded system. The following command uses \fB\-6e\fP (\fB\-6 \-\-extreme\fP) as a base and sets the dictionary to only 64\ KiB. The +resulting file can be decompressed with XZ Embedded (that's why there is +\fB\-\-check=crc32\fP) using about 100\ KiB of memory. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +If you want to squeeze out as many bytes as possible, adjusting the number +of literal context bits (\fIlc\fP) and number of position bits (\fIpb\fP) can +sometimes help. Adjusting the number of literal position bits (\fIlp\fP) +might help too, but usually \fIlc\fP and \fIpb\fP are more important. For +example, a source code archive contains mostly US\-ASCII text, so something +like the following might give slightly (like 0.1\ %) smaller file than \fBxz \-6e\fP (try also without \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Using another filter together with LZMA2 can improve compression with +certain file types. For example, to compress a x86\-32 or x86\-64 shared +library using the x86 BCJ filter: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Notez que l'ordre des options de filtre est significatif. Si \fB\-\-x86\fP est +indiqué après \fB\-\-lzma2\fP, \fBxz\fP donnera une erreur, car il ne peut y avoir +aucun filtre après LZMA2, et aussi parce que le filtre BCJ x86 ne peut pas +être utilisé comme dernier filtre dans la chaîne. +.PP +Le filtre Delta associé à LZMA2 peut donner de bons résultats avec les +images bitmap. Cela devrait habituellement battre PNG, qui a quelques +filtres avancés supplémentaires qu'un simple delta, mais qui utilise Deflate +pour la compression effective. +.PP +The image has to be saved in uncompressed format, for example, as +uncompressed TIFF. The distance parameter of the Delta filter is set to +match the number of bytes per pixel in the image. For example, 24\-bit RGB +bitmap needs \fBdist=3\fP, and it is also good to pass \fBpb=0\fP to LZMA2 to +accommodate the three\-byte alignment: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +If multiple images have been put into a single archive (for example, +\&\fB.tar\fP), the Delta filter will work on that too as long as all images have +the same number of bytes per pixel. +. +.SH "VOIR AUSSI" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/unxz.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/unxz.1 new file mode 100644 index 0000000000000000000000000000000000000000..297dc7c0d91cc84d9990f8e22984ef3e7be54f5b --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/unxz.1 @@ -0,0 +1,2027 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" french translation of XZ Utils man +.\" Copyright (C) 2021 Debian French l10n team +.\" Translator +.\" bubu , 2021. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 2025\-03\-08 Tukaani "Utilitaires XZ" +. +.SH NOM +xz, unxz, xzcat, lzma, unlzma, lzcat \- Compresser ou décompresser des +fichiers .xz et .lzma +. +.SH SYNOPSIS +\fBxz\fP [\fIoption...\fP] [\fIfichier...\fP] +. +.SH "ALIAS DES COMMANDES" +\fBunxz\fP est équivalent à \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP est équivalent à \fBxz \-\-decompress \-\-stdout\fP +.br +\fBlzma\fP est équivalent à \fBxz \-\-format=lzma\fP +.br +\fBunlzma\fP est équivalent à \fBxz \-\-format=lzma \-\-decompress\fP +.br +\fBlzcat\fP est équivalent à \fBxz \-\-format=lzma \-\-decompress \-\- stdout\fP +.PP +Lors de l'écriture de scripts qui nécessitent de décompresser des fichiers, +il est recommandé de toujours utiliser la commande \fBxz\fP avec les arguments +appropriés (\fBxz \-d\fP ou \fBxz \-dc\fP) au lieu des commandes \fBunxz\fP et +\fBxzcat\fP. +. +.SH DESCRIPTION +\fBxz\fP is a general\-purpose data compression tool with command line syntax +similar to \fBgzip\fP(1) and \fBbzip2\fP(1). The native file format is the +\&\fB.xz\fP format, but the legacy \fB.lzma\fP format used by LZMA Utils and raw +compressed streams with no container format headers are also supported. In +addition, decompression of the \fB.lz\fP format used by \fBlzip\fP is supported. +.PP +\fBxz\fP compresse ou décompresse chaque \fIfichier\fP en fonction du mode +d'opération choisi. Si aucun \fIfichier\fP n'est donné ou \fIfichier\fP est \fB\-\fP, +\fBxz\fP lit depuis l'entrée standard et écrit les données traitées sur la +sortie standard. \fBxz\fP refusera (affichera une erreur et ignorera le +\fIfichier\fP) d'écrire les données compressées sur la sortie standard si c'est +un terminal. De même, \fBxz\fP refusera de lire des données compressées depuis +l'entrée standard si c'est un terminal. +.PP +A moins que \fB\-\-sdout\fP ne soit indiqué, les \fIfichiers\fP autres que \fB\-\fP sont +écrits dans un nouveau fichier dont le nom est dérivé du nom de \fIfichier\fP +source : +.IP \(bu 3 +Lors de la compression, le suffixe du format de fichier cible (\fB.xz\fP ou +\&\fB.lzma\fP) est ajouté au nom de fichier source pour obtenir le nom de fichier +cible. +.IP \(bu 3 +When decompressing, the \fB.xz\fP, \fB.lzma\fP, or \fB.lz\fP suffix is removed from +the filename to get the target filename. \fBxz\fP also recognizes the suffixes +\&\fB.txz\fP and \fB.tlz\fP, and replaces them with the \fB.tar\fP suffix. +.PP +Si le fichier cible existe déjà, une erreur est affichée et le \fIfichier\fP +est ignoré. +.PP +Sauf s'il écrit dans la sortie standard, \fBxz\fP affichera un avertissement et +ignorera le \fIfichier\fP dans les cas suivants : +.IP \(bu 3 +\fIfichier\fP n'est pas un fichier normal. Les liens symboliques ne sont pas +suivis et donc ne sont pas considérés comme des fichiers normaux. +.IP \(bu 3 +\fIfichier\fP a plusieurs liens physiques. +.IP \(bu 3 +\fIfichier\fP a un setuid, setgid ou sticky bit positionné. +.IP \(bu 3 +Le mode d'opération est défini pour compresser et le \fIfichier\fP a déjà un +suffixe du format de fichier cible (\fB.xz\fP ou \fB.txz\fP lors d'une compression +en format \fB.xz\fP, et \fB.lzma\fP ou \fB.tlz\fP lors d'une compression en format +\&\fB.lzma\fP). +.IP \(bu 3 +The operation mode is set to decompress and the \fIfile\fP doesn't have a +suffix of any of the supported file formats (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, +\&\fB.tlz\fP, or \fB.lz\fP). +.PP +Après la compression ou la décompression réussie du \fIfichier\fP, \fBxz\fP copie +les permissions du propriétaire, du groupe, la date d'accès, et les +modifications d'heure depuis le \fIfichier\fP source du fichier cible. Si la +copie du groupe échoue, les permissions sont modifiées pour que le fichier +cible ne soit pas accessible aux utilisateurs qui n'ont pas les droits +d'accès au \fIfichier\fP source. \fBxz\fP ne prend actuellement pas en charge la +copie d'autres métadonnées telles que les listes de contrôle d'accès ou les +attributs étendus. +.PP +Once the target file has been successfully closed, the source \fIfile\fP is +removed unless \fB\-\-keep\fP was specified. The source \fIfile\fP is never removed +if the output is written to standard output or if an error occurs. +.PP +Envoyer \fBSIGINFO\fP ou \fBSIGURSR1\fP au processus \fBxz\fP, lui fait afficher +l'information de progression sur l'erreur standard. Cela a un intérêt limité +car lorsque l'erreur standard est un terminal, utiliser \fB\-\-verbose\fP +affichera automatiquement un indicateur de progression du processus. +. +.SS "Utilisation de la mémoire" +L'utilisation de la mémoire par \fBxz\fP varie de quelques centaines de +kilo\-octets à plusieurs gigaoctects en fonction des paramètres de +compression. Les réglages utilisés lors de la compression d'un fichier +déterminent les besoins en mémoire pour la décompression. Habituellement la +décompression nécessite 5\% à 20\% de la quantité de mémoire utilisée pour +la compression du fichier. Par exemple, décompresser un fichier créé avec +\fBxz\-9\fP recquiert habituellement 65\ Mio de mémoire. Bien qu'il soit +possible d'avoir des fichiers \fB.xz\fP nécessitant plusieurs gigaoctets de +mémoire pour être décompressés. +.PP +Especially users of older systems may find the possibility of very large +memory usage annoying. To prevent uncomfortable surprises, \fBxz\fP has a +built\-in memory usage limiter, which is disabled by default. While some +operating systems provide ways to limit the memory usage of processes, +relying on it wasn't deemed to be flexible enough (for example, using +\fBulimit\fP(1) to limit virtual memory tends to cripple \fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +The memory usage limiter can be enabled with the command line option +\fB\-\-memlimit=\fP\fIlimit\fP. Often it is more convenient to enable the limiter +by default by setting the environment variable \fBXZ_DEFAULTS\fP, for example, +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. It is possible to set the limits +separately for compression and decompression by using +\fB\-\-memlimit\-compress=\fP\fIlimit\fP and \fB\-\-memlimit\-decompress=\fP\fIlimit\fP. +Using these two options outside \fBXZ_DEFAULTS\fP is rarely useful because a +single run of \fBxz\fP cannot do both compression and decompression and +\fB\-\-memlimit=\fP\fIlimit\fP (or \fB\-M\fP \fIlimit\fP) is shorter to type on the +command line. +.PP +If the specified memory usage limit is exceeded when decompressing, \fBxz\fP +will display an error and decompressing the file will fail. If the limit is +exceeded when compressing, \fBxz\fP will try to scale the settings down so that +the limit is no longer exceeded (except when using \fB\-\-format=raw\fP or +\fB\-\-no\-adjust\fP). This way the operation won't fail unless the limit is very +small. The scaling of the settings is done in steps that don't match the +compression level presets, for example, if the limit is only slightly less +than the amount required for \fBxz \-9\fP, the settings will be scaled down only +a little, not all the way down to \fBxz \-8\fP. +. +.SS "Concaténation et remplissage avec des fichiers .xz" +Il est possible de concaténer les fichiers \fB.xz\fP tels quel. \fBxz\fP +décompressera de tels fichiers comme s'ils étaient un unique fichier \fB.xz\fP. +.PP +It is possible to insert padding between the concatenated parts or after the +last part. The padding must consist of null bytes and the size of the +padding must be a multiple of four bytes. This can be useful, for example, +if the \fB.xz\fP file is stored on a medium that measures file sizes in +512\-byte blocks. +.PP +La concaténation et le remplissage ne sont pas autorisés avec les fichiers +\&\fB.lzma\fP ou les flux bruts. +. +.SH OPTIONS +. +.SS "Suffixes entiers et valeurs spéciales." +Dans la plupart des endroits où un argument entier est attendu, un suffixe +optionel permet d'indiquer facilement les grands entiers. Il ne doit pas y +avoir d'espace entre l'entier et le suffixe. +.TP +\fBKiB\fP +Multiplier l'entier par 1024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP et \fBKB\fP sont +acceptés comme synonymes de \fBKiB\fP. +.TP +\fBMiB\fP +Multiplier l'entier par 1 048 576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP et \fBMB\fP sont +acceptés comme synonymes de \fBMiB\fP. +.TP +\fBGiB\fP +Multiplier l'entier par 1 073 741 824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP et \fBGB\fP +sont acceptés comme synonymes de \fBGiB\fP. +.PP +La valeur spéciale \fBmax\fP peut être utilisée pour indiquer la valeur +maximale de l'entier prise en charge par l'option. +. +.SS "Mode d'opération" +Si plusieurs options de mode d'opération sont données, la dernière prend +effet. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Compresser. C'est le mode d'opération par défaut lorsque aucune option de +mode opératoire n'est spécifiée ou qu'aucun autre mode d'opération n'est +sous\-entendu par le nom de la commande (par exemple \fBunxz\fP sous\-entend +\fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +After successful compression, the source file is removed unless writing to +standard output or \fB\-\-keep\fP was specified. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Decompress. After successful decompression, the source file is removed +unless writing to standard output or \fB\-\-keep\fP was specified. +.TP +\fB\-t\fP, \fB\-\-test\fP +Tester l'intégrité des \fIfichiers\fP compressés. Cette option est équivalente +à \fB\-\-decompress \-\-stdout\fP sauf que les données décompressées sont rejetées +au lieu d'être écrites sur la sortie standard. Aucun fichier n'est créé ou +supprimé. +.TP +\fB\-l\fP, \fB\-\-list\fP +Afficher l'information sur les \fIfichiers\fP compressés. Aucune sortie +non\-compressée n'est produite et aucun fichier n'est créé ou supprimé. En +mode liste, le programme ne peut pas lire les données compressées depuis +l'entrée standard ou depuis d'autres sources non adressables. +.IP "" +The default listing shows basic information about \fIfiles\fP, one file per +line. To get more detailed information, use also the \fB\-\-verbose\fP option. +For even more information, use \fB\-\-verbose\fP twice, but note that this may be +slow, because getting all the extra information requires many seeks. The +width of verbose output exceeds 80 characters, so piping the output to, for +example, \fBless\ \-S\fP may be convenient if the terminal isn't wide enough. +.IP "" +La sortie exacte peut varier suivant les versions de \fBxz\fP et les différents +paramètres régionaux. Pour une sortie lisible par la machine, utiliser +\fB\-\-robot \-\-list\fP. +. +.SS "Modificateurs d'opération" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Ne pas effacer les fichiers d'entrée. +.IP "" +Since \fBxz\fP 5.2.6, this option also makes \fBxz\fP compress or decompress even +if the input is a symbolic link to a regular file, has more than one hard +link, or has the setuid, setgid, or sticky bit set. The setuid, setgid, and +sticky bits are not copied to the target file. In earlier versions this was +only done with \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Cette option a plusieurs effets : +.RS +.IP \(bu 3 +Si le fichier cible existe déjà, l'effacer avant de compresser ou +décompresser. +.IP \(bu 3 +Compresser ou décompresser même si l'entrée est un lien symbolique vers un +fichier normal, a plus qu'un lien physique, ou a le bit setuid, setgid ou +sticky défini. Les bits setuid, setgid et sticky bits ne sont pas copiés +dans le fichier cible. +.IP \(bu 3 +Lorsque \fBxz\fP est utilisé avec \fB\-\-decompress\fP \fB\-\-stdout\fP et qu'il ne peut +pas reconnaitre le type du fichier source, copier le fichier source tel quel +dans la sortie standard. Celà permet à \fBxzcat\fP \fB\-\-force\fP d'être utilisé +comme \fBcat\fP(1) pour les fichiers qui n'ont pas été compressé avec +\fBxz\fP. Remarquez que dans le futur, \fBxz\fP devrait prendre en charge de +nouveaux formats de fichiers compressés, ce qui permettra à \fBxz\fP de +décompresser plus de types de fichiers au lieu de les copier tels quels dans +la sortie standard. \fB\-\-format=\fP\fIformat\fP peut être utilisé pour contraindre +\fBxz\fP à décompresser seulement un format de fichier. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Écrire les données compressées ou décompressées sur la sortie standard +plutôt que dans un fichier. Cela necessite \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Décompresser seulement le premier flux \fB.xz\fP et ignorer silencieusement les +possibles données d'entrée résiduelles qui suivent le flux. Normalement ces +déchets excédentaires provoquent l'affichage d'une erreur par \fBxz\fP. +.IP "" +\fBxz\fP ne décompresse jamais plus d'un flux à partir de fichiers \fB.lzma\fP ou +de flux bruts, mais cette option fait aussi que \fBxz\fP ignorera les données +résiduelles après le fichier \fB.lzma\fP ou le flux brut. +.IP "" +Cette option n'a aucun effet si le mode d'opération n'est pas +\fB\-\-decompress\fP ou \fB\-\-test\fP. +.IP "" +Since \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP implies \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Désactiver la création de fichiers peu denses. Par défaut, lors de la +décompression en un fichier normal, \fBxz\fP essaie d'en faire un fichier creux +si les données décompressées contiennent de longues séquences de zéros +binaires. Cela fonctionne aussi lors de l'écriture sur la sortie standard +aussi longtemps que la sortie standard est connectée à un fichier normal et +que certaines conditions supplémentaires sont satisfaites pour le faire de +manière sécurisée. Créer des fichiers creux peut épargner de l'espace disque +et accélérer la décompression en réduisant la quantité d'entrées/sorties sur +le disque. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Lors de la compression, utiliser \fB.suf\fP comme suffixe du fichier cible au +lieu de \fB.xz\fP ou \fB.lzma\fP. Si \fBxz\fP n'écrit pas sur la sortie standard et +si le fichier source a déja le suffixe \fB.suf\fP, un avertissement est affiché +et le fichier est ignoré. +.IP "" +When decompressing, recognize files with the suffix \fI.suf\fP in addition to +files with the \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, or \fB.lz\fP suffix. If the +source file has the suffix \fI.suf\fP, the suffix is removed to get the target +filename. +.IP "" +Lors de la compression ou décompression de flux bruts (\fB\-\-fomat=raw\fP), le +suffixe doit toujours être spécifié à moins d'écrire sur la sortie standard, +car il n'y a pas de suffixe par défaut pour les flux bruts. +.TP +\fB\-\-files\fP[\fB=\fP\fIfichier\fP] +Lire les noms de fichier à traiter depuis \fIfichier\fP ; si \fIfichier\fP est +omis , les noms de fichier sont lus sur l'entrée standard. Les noms de +fichier doivent se terminer avec le caractère de nouvelle ligne. Un tiret +(\fB\-\fP) est considéré comme un nom de fichier normal ; ce qui ne signifie pas +entrée standard. Si les noms de fichier sont aussi donnés comme arguments de +ligne de commande, ils sont traités avant les noms de fichier lus depuis +\fIfichier\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIfichier\fP] +Cela est identique à \fB\-\-files\fP[\fB=\fP\fIfichier\fP] sauf que chaque nom de +fichier doit se terminer par le caractère null. +. +.SS "Format de fichier basique et options de compression" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fIformat\fP +Indiquer le \fIformat\fP de fichier à compresser ou décompresser : +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +C'est celui par défaut. Lors de la compression, \fBauto\fP est équivalent à +\fBxz\fP. Lors de la décompression, le format du fichier en entrée est détecté +automatiquement. Notez que les flux bruts (créés avec \fB\-\-format=raw\fP) ne +peuvent pas être détectés automatiquement. +.TP +\fBxz\fP +Compresser dans le format de fichier \fB.xz\fP ou n'accepter que les fichiers +\&\fB.xz\fP à décompresser. +.TP +\fBlzma\fP, \fBalone\fP +Compresser au format de fichier \fB.lzma\fP historique, ou n'accepter que les +fichiers \fB.lzma\fP lors de la décompression. Le nom alternatif \fBalone\fP est +fourni pour la rétrocompatibilité avec les utilitaires LZMA. +.TP +\fBlzip\fP +Accept only \fB.lz\fP files when decompressing. Compression is not supported. +.IP "" +The \fB.lz\fP format versions 0 and 1 are supported. Version 0 files were +produced by \fBlzip\fP 1.3 and older. Such files aren't common but may be +found from file archives as a few source packages were released in this +format. People might have old personal files in this format too. +Decompression support for the format version 0 was removed in \fBlzip\fP 1.18. +\fBlzip\fP 1.4 and later create files in the format version 1. +.TP +\fBraw\fP +Compresser ou décompresser un flux brut (sans en\-têtes). Cela est réservé +seulement aux utilisateurs aguerris. Pour décoder des flux bruts, vous devez +utiliser \fB\-\-format=raw\fP et spécifier explicitement la chaîne de filtre, qui +normalement aurait du être stockée dans les en\-têtes du conteneur. +.RE +.TP +\fB\-C\fP \fIvérif.\fP, \fB\-\-check=\fP\fIvérif.\fP +Spécifier le type d'intégrité à vérifier. La vérification est calculée à +partir des données non\-compressées et stockées dans le fichier \fB.xz\fP. Cette +option n'a effet que si la compression a été faite dans le format \fB.xz\fP ; +le format \fB.lzma\fP ne gère pas les vérifications d'intégrité. Le contrôle +d'intégrité (s'il y en a) est vérifié lorsque le fichier \fB.xz\fP est +décompressé. +.IP "" +Types de \fIvérification\fP pris en charge : +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Ne pas calculer de vérification d'intégrité du tout. C'est généralement une +mauvaise idée. Cela peut être utile lorsque l'intégrité des données est +vérifiée de toute façon par d'autres manières. +.TP +\fBcrc32\fP +Calculer CRC32 en utilisant le polynôme de IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Calculer CRC64 en utilisant le polynôme de ECMA\-182. C'est la manière +utilisée par défaut, car c'est légèrement mieux que CRC32 pour détecter les +fichiers endommagés et la différence de vitesse est négligeable. +.TP +\fBsha256\fP +Calculer SHA\-256. C'est quelque peu plus lent que CRC32 et CRC64. +.RE +.IP "" +L'intégrité des en\-têtes \fB.xz\fP est toujours vérifiée avec CRC32. Il n'est +pas possible de le changer ou de le désactiver. +.TP +\fB\-\-ignore\-check\fP +Ne pas contrôler la vérification d'intégrité des données lors de la +décompression. Les valeurs CRC32 dans les en\-têtes \fB.xz\fP seront normalement +toujours vérifiées. +.IP "" +\fBN'utilisez pas cette option à moins de savoir ce que vous faites.\fP Les +raisons possibles pour utiliser cette option : +.RS +.IP \(bu 3 +Essayer de récupérer des données d'un fichier .xz corrompu. +.IP \(bu 3 +Accélérer la décompression. Cela importe surtout avec SHA\-256 ou avec les +fichiers qui ont été compressés extrêmement bien. Il est recommandé de ne +pas utiliser cette option dans ce but à moins que l'intégrité du fichier ne +soit vérifiée extérieurement d'une autre manière. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Choisir un niveau de compression prédéfini. La valeur par défaut est +\fB6\fP. Si plusieurs niveaux de préréglage sont spécifiés, c'est le dernier +qui sera pris en compte. Si une chaîne de filtres personnalisée a déjà été +choisie, définir un niveau de compression préréglé efface la chaîne de +filtres personnalisée. +.IP "" +Les différences entre les préréglages sont plus significatives qu'avec +\fBgzip\fP(1) et \fBbzip2\fP(1). les réglages de compression sélectionnés +déterminent les exigences en mémoire pour la décompression, ainsi, utiliser +un niveau de préréglage trop élevé peut rendre difficile à décompresser un +fichier sur un vieux système avec peu de RAM. Clairement, \fBce n'est pas une bonne idée d'utiliser \-9 aveuglément pour tout\fP comme ça l'est souvent avec +\fBgzip\fP(1) et \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Ce sont des préréglages relativement rapides. \fB0\fP est parfois plus rapide +que \fBgzip \-9\fP tout en compressant bien mieux. Les réglages plus élevés ont +souvent une rapidité comparable à celle de \fBbzip2\fP(1) avec un taux de +compression comparable ou meilleur, même si les résultats dépendent beaucoup +du genre de données compressées. +.TP +\fB\-4\fP ... \fB\-6\fP +Good to very good compression while keeping decompressor memory usage +reasonable even for old systems. \fB\-6\fP is the default, which is usually a +good choice for distributing files that need to be decompressible even on +systems with only 16\ MiB RAM. (\fB\-5e\fP or \fB\-6e\fP may be worth considering +too. See \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +C'est comme \fB\-6\fP mais avec des besoins en mémoire plus élevés pour la +compression et la décompression. Ce n'est utile que lorsque les fichiers +sont plus gros que 8\ Mio, 16\ Mio et 32\ Mio respectivement. +.RE +.IP "" +Sur le même matériel, la vitesse de décompression est sensiblement un nombre +constant d'octets de données compressées par seconde. En d'autres termes, +meilleure est la compression, plus rapide sera en général la +décompression. Cela signifie aussi que la quantité de sortie non compressée +produite par seconde peut varier beaucoup. +.IP "" +Le tableau suivant résume les caractéristiques des préréglages : +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Préréglage;DictSize;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Descriptions des colonnes : +.RS +.IP \(bu 3 +DictSize est la taille du dictionnaire de LZMA2. Utiliser un dictionnaire +plus gros que la taille du fichier non compressé est un gaspillage de +mémoire. C'est pourquoi il est bon d'éviter d'utiliser les préréglages de +\fB\-7\fP à \fB\-9\fP lorsqu'il n'y en a pas vraiment besoin. A \fB\-6\fP et plus bas, +la quantité de mémoire gaspillée est généralement assez basse pour ne pas +être un problème. +.IP \(bu 3 +CompCPU est une représentation des préréglages de LZMA2 qui affectent la +vitesse de compression. La taille du dictionnaire aussi affecte la vitesse, +alors comme CompCPU est le même pour les niveaux de \fB\-6\fP à \fB\-9\fP, les plus +haut niveaux tendent à être un peu moins rapides. Pour être encore moins +rapide et du coup obtenir peut être une meilleure compression, consultez +\fB\-\-extreme\fP. +.IP \(bu 3 +CompMem contains the compressor memory requirements in the single\-threaded +mode. It may vary slightly between \fBxz\fP versions. +.IP \(bu 3 +DecMem contient les besoins en mémoire du décompresseur. Ce sont les +réglages de la compression qui déterminent les besoins en mémoire de la +décompression. L'exacte utilisation de la mémoire est légèrement supérieure +à la taille du dictionnaire LZMA2, mais les valeurs dans la table ont été +arrondies au prochain Mio supérieur. +.RE +.IP "" +Memory requirements of the multi\-threaded mode are significantly higher than +that of the single\-threaded mode. With the default value of +\fB\-\-block\-size\fP, each thread needs 3*3*DictSize plus CompMem or DecMem. For +example, four threads with preset \fB\-6\fP needs 660\(en670\ MiB of memory. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Utilisez un variant plus lent que les préréglages (\fB\-0\fP à \fB\-9\fP) pour +espérer avoir un taux de compression légèrement meilleur, mais en cas de +malchance cela peut être pire. L'utilisation mémoire du décompresseur n'est +pas affectée, mais l'utilisation mémoire du compresseur augmente un peu aux +niveaux de préréglages de \fB\-0\fP à \fB\-3\fP. +.IP "" +Depuis qu'il y a deux préréglages avec des tailles de dictionnaire de 4\ Mio +et 8 \Mio, les préréglages \fB\-3e\fP et \fB\-5e\fP utilisent des réglages +légèrement plus rapides que \fB\-4e\fP et \fB\-6e\fP, respectivement. De cette +manière, il n'y a pas deux préréglages identiques. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Préréglage;DictSize;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Par exemple, il y a un total de quatre préréglages qui utilisent un +dictionnaire de 8 Mio et qui sont dans l'ordre du plus rapide au plus lent : +\fB\-5\fP, \fB\-6\fP, \fB\-5e\fP et \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Il y a néanmoins des alias trompeurs pour \fB\-0\fP et \fB\-9\fP, +respectivement. Ils ne sont fournis que pour des besoins de +rétro\-compatibilité avec les utilitaires LZMA. Evitez d'utiliser ces +options. +.TP +\fB\-\-block\-size=\fP\fItaille\fP +Lors de la compression dans le format \fB.xz\fP, les données de l'entrée sont +réparties en blocs de \fItaille\fP octets. Les blocs sont compressés +indépendamment les un des autres, ce qui aide avec le mode multithread +(multi\-threading) et rend possible la décompression à accès aléatoire +limité. Cette option est typiquement utilisée pour outrepasser la taille de +bloc en mode multithread, mais cette option peut aussi être utilisée en mode +single\-thread. +.IP "" +In multi\-threaded mode about three times \fIsize\fP bytes will be allocated in +each thread for buffering input and output. The default \fIsize\fP is three +times the LZMA2 dictionary size or 1 MiB, whichever is more. Typically a +good value is 2\(en4 times the size of the LZMA2 dictionary or at least 1 +MiB. Using \fIsize\fP less than the LZMA2 dictionary size is waste of RAM +because then the LZMA2 dictionary buffer will never get fully used. In +multi\-threaded mode, the sizes of the blocks are stored in the block +headers. This size information is required for multi\-threaded +decompression. +.IP "" +In single\-threaded mode no block splitting is done by default. Setting this +option doesn't affect memory usage. No size information is stored in block +headers, thus files created in single\-threaded mode won't be identical to +files created in multi\-threaded mode. The lack of size information also +means that \fBxz\fP won't be able decompress the files in multi\-threaded mode. +.TP +\fB\-\-block\-list=\fP\fIitems\fP +When compressing to the \fB.xz\fP format, start a new block with an optional +custom filter chain after the given intervals of uncompressed data. +.IP "" +The \fIitems\fP are a comma\-separated list. Each item consists of an optional +filter chain number between 0 and 9 followed by a colon (\fB:\fP) and a +required size of uncompressed data. Omitting an item (two or more +consecutive commas) is a shorthand to use the size and filters of the +previous item. +.IP "" +If the input file is bigger than the sum of the sizes in \fIitems\fP, the last +item is repeated until the end of the file. A special value of \fB0\fP may be +used as the last size to indicate that the rest of the file should be +encoded as a single block. +.IP "" +An alternative filter chain for each block can be specified in combination +with the \fB\-\-filters1=\fP\fIfilters\fP \&...\& \fB\-\-filters9=\fP\fIfilters\fP options. +These options define filter chains with an identifier between 1\(en9. +Filter chain 0 can be used to refer to the default filter chain, which is +the same as not specifying a filter chain. The filter chain identifier can +be used before the uncompressed size, followed by a colon (\fB:\fP). For +example, if one specifies \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP +then blocks will be created using: +.RS +.IP \(bu 3 +The filter chain specified by \fB\-\-filters1\fP and 2 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters3\fP and 2 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters2\fP and 4 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters2\fP and 4 MiB input +.IP \(bu 3 +The default filter chain and 2 MiB input +.IP \(bu 3 +The default filter chain and 4 MiB input for every block until end of input. +.RE +.IP "" +If one specifies a size that exceeds the encoder's block size (either the +default value in threaded mode or the value specified with +\fB\-\-block\-size=\fP\fIsize\fP), the encoder will create additional blocks while +keeping the boundaries specified in \fIitems\fP. For example, if one specifies +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP and the +input file is 80 MiB, one will get 11 blocks: 5, 10, 8, 10, 2, 10, 10, 4, +10, 10, and 1 MiB. +.IP "" +En mode multi\-threadé les tailles de blocs sont stockées dans les en\-têtes +du bloc. Cela ne se fait pas en mode mono\-threadé, la sortie encodée ne sera +donc pas identique à celle faite en mode multi\-threadé. +.TP +\fB\-\-flush\-timeout=\fP\fItemps_d'attente\fP +Lors de la compression, si plus que \fItemps_d'attente\fP millisecondes (un +entier positif) se sont écoulées depuis le précédent vidage et que lire plus +de données bloquerait, toutes les données d'entrée en attente sont vidées de +l'encodeur et mises à disposition dans le flux de sortie. Cela peut être +utile si \fBxz\fP est utilisé pour compresser les données qui sont diffusées +sur un réseau. Des petites valeurs de \fItemps_d'attente\fP rendent les données +disponibles à l'extrémité réceptrice avec un léger retard, mais les grandes +valeurs de \fItemps_d'attente\fP donnent un meilleur taux de compression. +.IP "" +Cette option est désactivée par défaut. Si cette option est indiquée plus +d'une fois, la dernière prend effet. La valeur spéciale de +\fItemps_d'attente\fP de \fB0\fP peut être utilisée pour explicitement désactiver +cette option. +.IP "" +Cette option n'est pas disponible sur les systèmes qui ne sont pas POSIX. +.IP "" +.\" FIXME +\fBCette option est encore expérimentale.\fP Actuellement, \fBxz\fP ne convient +pas pour décompresser le flux en temps réel en raison de la façon dont \fBxz\fP +effectue la mise en mémoire tampon. +.TP +\fB\-\-no\-sync\fP +Do not synchronize the target file and its directory to the storage device +before removing the source file. This can improve performance if +compressing or decompressing many small files. However, if the system +crashes soon after the deletion, it is possible that the target file was not +written to the storage device but the delete operation was. In that case +neither the original source file nor the target file is available. +.IP "" +This option has an effect only when \fBxz\fP is going to remove the source +file. In other cases synchronization is never done. +.IP "" +The synchronization and \fB\-\-no\-sync\fP were added in \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIlimite\fP +Indiquer une limite d'utilisation de la mémoire pour la compression. Si +cette option est indiquée plusieurs fois, c'est la dernière qui est prise en +compte. +.IP "" +If the compression settings exceed the \fIlimit\fP, \fBxz\fP will attempt to +adjust the settings downwards so that the limit is no longer exceeded and +display a notice that automatic adjustment was done. The adjustments are +done in this order: reducing the number of threads, switching to +single\-threaded mode if even one thread in multi\-threaded mode exceeds the +\fIlimit\fP, and finally reducing the LZMA2 dictionary size. +.IP "" +When compressing with \fB\-\-format=raw\fP or if \fB\-\-no\-adjust\fP has been +specified, only the number of threads may be reduced since it can be done +without affecting the compressed output. +.IP "" +If the \fIlimit\fP cannot be met even with the adjustments described above, an +error is displayed and \fBxz\fP will exit with exit status 1. +.IP "" +La \fIlimite\fP peut être indiquée de plusieurs façons : +.RS +.IP \(bu 3 +La \fIlimite\fP peut être une valeur absolue en octets. Utiliser un suffixe +d'entier comme \fBMiB\fP peut être utile. Exemple : +\fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +La \fIlimite\fP peut être indiquée sous forme d'un pourcentage de la mémoire +physique totale (RAM). Cela peut être particulièrement utile quand la +variable d'environnement \fBXZ_DEFAULTS\fP est indiquée dans un script +d'initialisation de l'interpréteur partagé entre différents ordinateurs. De +cette façon la limite est automatiquement plus grande sur les systèmes avec +plus de mémoire. Exemple : \fB\-\-memlimit=70%\fP +.IP \(bu 3 +The \fIlimit\fP can be reset back to its default value by setting it to \fB0\fP. +This is currently equivalent to setting the \fIlimit\fP to \fBmax\fP (no memory +usage limit). +.RE +.IP "" +For 32\-bit \fBxz\fP there is a special case: if the \fIlimit\fP would be over +\fB4020\ MiB\fP, the \fIlimit\fP is set to \fB4020\ MiB\fP. On MIPS32 \fB2000\ MiB\fP +is used instead. (The values \fB0\fP and \fBmax\fP aren't affected by this. A +similar feature doesn't exist for decompression.) This can be helpful when +a 32\-bit executable has access to 4\ GiB address space (2 GiB on MIPS32) +while hopefully doing no harm in other situations. +.IP "" +Voir aussi la section \fButilisation de la mémoire\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIlimite\fP +Régler une limite d'utilisation de la mémoire pour la décompression. Cela a +un effet sur le mode \fB\-\-list\fP. Si l'opération n'est pas possible sans +dépasser la \fIlimite\fP, \fBxz\fP affichera une erreur et la décompression +échouera. Voir \fB\-\-memlimit\-compress=\fP\fIlimite\fP pour les manières possibles +d'indiquer la \fIlimite\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimit\fP +Set a memory usage limit for multi\-threaded decompression. This can only +affect the number of threads; this will never make \fBxz\fP refuse to +decompress a file. If \fIlimit\fP is too low to allow any multi\-threading, the +\fIlimit\fP is ignored and \fBxz\fP will continue in single\-threaded mode. Note +that if also \fB\-\-memlimit\-decompress\fP is used, it will always apply to both +single\-threaded and multi\-threaded modes, and so the effective \fIlimit\fP for +multi\-threading will never be higher than the limit set with +\fB\-\-memlimit\-decompress\fP. +.IP "" +In contrast to the other memory usage limit options, +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimit\fP has a system\-specific default +\fIlimit\fP. \fBxz \-\-info\-memory\fP can be used to see the current value. +.IP "" +This option and its default value exist because without any limit the +threaded decompressor could end up allocating an insane amount of memory +with some input files. If the default \fIlimit\fP is too low on your system, +feel free to increase the \fIlimit\fP but never set it to a value larger than +the amount of usable RAM as with appropriate input files \fBxz\fP will attempt +to use that amount of memory even with a low number of threads. Running out +of memory or swapping will not improve decompression performance. +.IP "" +See \fB\-\-memlimit\-compress=\fP\fIlimit\fP for possible ways to specify the +\fIlimit\fP. Setting \fIlimit\fP to \fB0\fP resets the \fIlimit\fP to the default +system\-specific value. +.TP +\fB\-M\fP \fIlimite\fP, \fB\-\-memlimit=\fP\fIlimite\fP, \fB\-\-memory=\fP\fIlimite\fP +This is equivalent to specifying \fB\-\-memlimit\-compress=\fP\fIlimit\fP +\fB\-\-memlimit\-decompress=\fP\fIlimit\fP \fB\-\-memlimit\-mt\-decompress=\fP\fIlimit\fP. +.TP +\fB\-\-no\-adjust\fP +Display an error and exit if the memory usage limit cannot be met without +adjusting settings that affect the compressed output. That is, this +prevents \fBxz\fP from switching the encoder from multi\-threaded mode to +single\-threaded mode and from reducing the LZMA2 dictionary size. Even when +this option is used the number of threads may be reduced to meet the memory +usage limit as that won't affect the compressed output. +.IP "" +Automatic adjusting is always disabled when creating raw streams +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fIthreads\fP, \fB\-\-threads=\fP\fIthreads\fP +Specify the number of worker threads to use. Setting \fIthreads\fP to a +special value \fB0\fP makes \fBxz\fP use up to as many threads as the processor(s) +on the system support. The actual number of threads can be fewer than +\fIthreads\fP if the input file is not big enough for threading with the given +settings or if using more threads would exceed the memory usage limit. +.IP "" +The single\-threaded and multi\-threaded compressors produce different +output. Single\-threaded compressor will give the smallest file size but +only the output from the multi\-threaded compressor can be decompressed using +multiple threads. Setting \fIthreads\fP to \fB1\fP will use the single\-threaded +mode. Setting \fIthreads\fP to any other value, including \fB0\fP, will use the +multi\-threaded compressor even if the system supports only one hardware +thread. (\fBxz\fP 5.2.x used single\-threaded mode in this situation.) +.IP "" +To use multi\-threaded mode with only one thread, set \fIthreads\fP to \fB+1\fP. +The \fB+\fP prefix has no effect with values other than \fB1\fP. A memory usage +limit can still make \fBxz\fP switch to single\-threaded mode unless +\fB\-\-no\-adjust\fP is used. Support for the \fB+\fP prefix was added in \fBxz\fP +5.4.0. +.IP "" +If an automatic number of threads has been requested and no memory usage +limit has been specified, then a system\-specific default soft limit will be +used to possibly limit the number of threads. It is a soft limit in sense +that it is ignored if the number of threads becomes one, thus a soft limit +will never stop \fBxz\fP from compressing or decompressing. This default soft +limit will not make \fBxz\fP switch from multi\-threaded mode to single\-threaded +mode. The active limits can be seen with \fBxz \-\-info\-memory\fP. +.IP "" +Actuellement, la seule méthode de gestion avec des threads consiste à +séparer l'entrée en blocs et de les compresser indépendamment les uns des +autres. La taille par défaut des blocs dépend du niveau de compression et +peut\-être remplacée avec l'option \fB\-\-block\-size=\fP\fItaille\fP. +.IP "" +Threaded decompression only works on files that contain multiple blocks with +size information in block headers. All large enough files compressed in +multi\-threaded mode meet this condition, but files compressed in +single\-threaded mode don't even if \fB\-\-block\-size=\fP\fIsize\fP has been used. +.IP "" +The default value for \fIthreads\fP is \fB0\fP. In \fBxz\fP 5.4.x and older the +default is \fB1\fP. +. +.SS "Chaînes de filtres de compresseur personnalisées" +A custom filter chain allows specifying the compression settings in detail +instead of relying on the settings associated to the presets. When a custom +filter chain is specified, preset options (\fB\-0\fP \&...\& \fB\-9\fP and +\fB\-\-extreme\fP) earlier on the command line are forgotten. If a preset +option is specified after one or more custom filter chain options, the new +preset takes effect and the custom filter chain options specified earlier +are forgotten. +.PP +Une chaîne de filtre est comparable à une redirection (pipe) sur la ligne de +commande. Lors de la compression, les entrées non compressées vont au +premier filtre, dont la sortie va au prochain filtre (s'il y en a). La +sortie du dernier filtre est écrite sur le fichier compressé. Le nombre +maximal de filtres dans la chaîne est quatre, mais habituellement, un chaîne +de filtre n'a qu'un ou deux filtres. +.PP +Beaucoup de filtres ont des limitations sur l'endroit où ils peuvent se +placer dans la chaîne de filtre : quelques filtres ne peuvent fonctionner +qu'en tant que dernier filtre dans la chaîne, quelques uns en tant que non +dernier filtre, et d'autres à n'importe quelle position dans la +chaîne. Suivant le filtre, cette limitation est soit inhérente au profil du +filtre, soit existe pour des raisons de sécurité. +.PP +A custom filter chain can be specified in two different ways. The options +\fB\-\-filters=\fP\fIfilters\fP and \fB\-\-filters1=\fP\fIfilters\fP \&...\& +\fB\-\-filters9=\fP\fIfilters\fP allow specifying an entire filter chain in one +option using the liblzma filter string syntax. Alternatively, a filter +chain can be specified by using one or more individual filter options in the +order they are wanted in the filter chain. That is, the order of the +individual filter options is significant! When decoding raw streams +(\fB\-\-format=raw\fP), the filter chain must be specified in the same order as +it was specified when compressing. Any individual filter or preset options +specified before the full chain option (\fB\-\-filters=\fP\fIfilters\fP) will be +forgotten. Individual filters specified after the full chain option will +reset the filter chain. +.PP +Both the full and individual filter options take filter\-specific \fIoptions\fP +as a comma\-separated list. Extra commas in \fIoptions\fP are ignored. Every +option has a default value, so specify those you want to change. +.PP +Pour voir l'entièreté de la chaîne de filtres et ses \fIoptions\fP, utilisez +\fBxz \-vv\fP (ce qui est comme utiliser \fB\-\-verbose\fP deux fois). Cela +fonctionne aussi pour voir les options de chaîne de filtres utilisées par +les préréglages. +.TP +\fB\-\-filters=\fP\fIfilters\fP +Specify the full filter chain or a preset in a single option. Each filter +can be separated by spaces or two dashes (\fB\-\-\fP). \fIfilters\fP may need to be +quoted on the shell command line so it is parsed as a single option. To +denote \fIoptions\fP, use \fB:\fP or \fB=\fP. A preset can be prefixed with a \fB\-\fP +and followed with zero or more flags. The only supported flag is \fBe\fP to +apply the same options as \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIfilters\fP ... \fB\-\-filters9\fP=\fIfilters\fP +Specify up to nine additional filter chains that can be used with +\fB\-\-block\-list\fP. +.IP "" +For example, when compressing an archive with executable files followed by +text files, the executable part could use a filter chain with a BCJ filter +and the text part only the LZMA2 filter. +.TP +\fB\-\-filters\-help\fP +Display a help message describing how to specify presets and custom filter +chains in the \fB\-\-filters\fP and \fB\-\-filters1=\fP\fIfilters\fP \&...\& +\fB\-\-filters9=\fP\fIfilters\fP options, and exit successfully. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIoptions\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIoptions\fP] +.PD +Ajouter le filtre LZMA1 ou LZMA2 à la chaîne de filtres. Ces filtres ne +peuvent être utilisés que comme dernier filtre dans la chaîne. +.IP "" +LZMA1 est un filtre historique, qui n'est pris en charge presque uniquement +à cause de l'ancien format de fichier \fB.lzma\fP, qui ne prend en charge que +LZMA1. LZMA2 est une version mise à jour de LZMA1 pour régler certains +problèmes pratiques de LZMA1. Le format \fBxz\fP utilise LZMA2 et ne prend pas +du tout en charge LZMA1. Les taux et vitesses de compression de LZMA1 et +LZMA2 sont pratiquement identiques. +.IP "" +LZMA1 et LZMA2 partagent le même ensemble d'\fIoptions\fP : +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIpréréglage\fP +Reset all LZMA1 or LZMA2 \fIoptions\fP to \fIpreset\fP. \fIPreset\fP consist of an +integer, which may be followed by single\-letter preset modifiers. The +integer can be from \fB0\fP to \fB9\fP, matching the command line options \fB\-0\fP +\&...\& \fB\-9\fP. The only supported modifier is currently \fBe\fP, which matches +\fB\-\-extreme\fP. If no \fBpreset\fP is specified, the default values of LZMA1 or +LZMA2 \fIoptions\fP are taken from the preset \fB6\fP. +.TP +\fBdict=\fP\fItaille\fP +La \fItaille\fP du dictionnaire (historique du tampon) indique combien d'octets +des données récement décompressées sont gardés en mémoire. L'algorithme +essaie de trouver les séquences d'octets répétées (identiques) dans les +données décompressées et les remplace par les données actuellement dans le +dictionnaire. Plus gros est le dictionnaire, plus grande est la chance de +trouver une correspondance. Ainsi, l'augmentation de la \fItaille\fP du +dictionnaire augmente habituellement le taux de compression, mais un +dictionnaire plus gros que le fichier non compressé est un gachis de +mémoire. +.IP "" +Généralement la \fItaille\fP du dictionnaire est entre 64\ Kio et 64\ Mio. Le +minimum étant 4\ Kio. La \fItaille\fP maximale pour la compression est +habituellement 1,5\ Gio (1536\ Mio). Le décompresseur prend en charge les +dictionnaires jusqu'à un octet de moins que 4\ Gio, ce qui est le maximum +pour les formats de flux LZMA1 et LZMA2. +.IP "" +La \fItaille\fP du dictionnaire et le chercheur de correspondance (match +finder) (\fImf\fP) déterminent ensemble l'utilisation de la mémoire de +l'encodeur LZMA1 ou LZMA2. La même (ou une plus grosse) \fItaille\fP de +dictionnaire est requise pour décompresser que ce qui a été utilisé pour la +compression, ainsi l'utilisation de la mémoire du décodeur est déterminée +par la taille du dictionnaire utilisée lors de la compression. Les en\-têtes +de \fB.xz\fP stockent la \fItaille\fP de dictionnaire sous la forme 2^\fIn\fP ou +2^\fIn\fP + 2^(\fIn\fP\-1), de sorte que ces \fItailles\fP sont quelque peu préférées +pour la compression. Les autres \fItailles\fP seront arrondies à la hausse +lorsque stockées dans les en\-têtes de \fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Spécifiez le nombre d'octets de contexte littéraux. Le minimum est \fB0\fP et +le maximum est \fB4\fP. La valeur par défaut est \fB3\fP. En plus, la somme de +\fIlc\fP et \fIlp\fP ne doit pas excéder \fB4\fP. +.IP "" +Tous les octets qui ne peuvent pas être codés comme des correspondances sont +codés comme des littéraux. C'est à dire que les littéraux sont simplement +des octets 8 bits encodés un à la fois. +.IP "" +The literal coding makes an assumption that the highest \fIlc\fP bits of the +previous uncompressed byte correlate with the next byte. For example, in +typical English text, an upper\-case letter is often followed by a lower\-case +letter, and a lower\-case letter is usually followed by another lower\-case +letter. In the US\-ASCII character set, the highest three bits are 010 for +upper\-case letters and 011 for lower\-case letters. When \fIlc\fP is at least +3, the literal coding can take advantage of this property in the +uncompressed data. +.IP "" +The default value (3) is usually good. If you want maximum compression, +test \fBlc=4\fP. Sometimes it helps a little, and sometimes it makes +compression worse. If it makes it worse, test \fBlc=2\fP too. +.TP +\fBlp=\fP\fIlp\fP +Indiquer le nombre de bits de position littérale. Le minimum est \fB0\fP et le +maximum \fB4\fP; par défaut c'est \fB0\fP. +.IP "" +\fILp\fP affecte le type d'alignement dans les données décompressées qui est +présumé lors de l'encodage des littéraux. Voir \fIpb\fP ci dessous pour plus +d'information sur l'alignement. +.TP +\fBpb=\fP\fIpb\fP +Indiquer le nombre de bits de position. Le minimum est \fB0\fP et le maximum +\fB4\fP; par défaut \fB2\fP. +.IP "" +\fIPb\fP affecte quel genre d'alignement est présumé en général dans les +données non compressées. Par défaut c'est un alignement de quatre octets +(2^\fIpb\fP=2^2=4), ce qui est généralement un bon choix lorsqu'il n'y a pas de +meilleure estimation. +.IP "" +When the alignment is known, setting \fIpb\fP accordingly may reduce the file +size a little. For example, with text files having one\-byte alignment +(US\-ASCII, ISO\-8859\-*, UTF\-8), setting \fBpb=0\fP can improve compression +slightly. For UTF\-16 text, \fBpb=1\fP is a good choice. If the alignment is +an odd number like 3 bytes, \fBpb=0\fP might be the best choice. +.IP "" +Même si l'alignement présumé peut être ajusté avec \fIpb\fP et \fIlp\fP, LZMA1 et +LZMA2 favorisent toujours légèrement l'alignement sur 16 octets. Il peut +être utile d'en tenir compte lors de la conception de formats de fichiers +susceptibles d'être souvent compressés avec LZMA1 ou LZMA2. +.TP +\fBmf=\fP\fImf\fP +Match finder has a major effect on encoder speed, memory usage, and +compression ratio. Usually Hash Chain match finders are faster than Binary +Tree match finders. The default depends on the \fIpreset\fP: 0 uses \fBhc3\fP, +1\(en3 use \fBhc4\fP, and the rest use \fBbt4\fP. +.IP "" +Les chercheurs de correspondance suivants sont pris en charge. Les formules +d'utilisation de la mémoire ci\-dessous sont des approximations grossières +qui sont les plus proches de la réalité lorsque \fIdict\fP est une puissance de +deux. +.RS +.TP +\fBhc3\fP +Chaîne de hachage avec hachage de 2 et 3 octets +.br +Valeur minimale pour \fInice\fP : \fB3\fP +.br +Utilisation de la mémoire : +.br +\fIdict\fP * 7.5 (if \fIdict\fP <= 16 Mio); +.br +\fIdict\fP * 5.5 + 64 MiB (si \fIdict\fP > 16 Mio) +.TP +\fBhc4\fP +Chaîne de hachage avec hachage de 2, 3 et 4 octets +.br +Valeur minimale pour \fInice\fP : \fB4\fP +.br +Utilisation de la mémoire : +.br +\fIdict\fP * 7.5 (si \fIdict\fP <= 32 Mio); +.br +\fIdict\fP * 6.5 (si \fIdict\fP > 32 Mio) +.TP +\fBbt2\fP +Arbre binaire avec hachage de 2 octets +.br +Valeur minimale pour \fInice\fP : \fB2\fP +.br +Utilisation de la mémoire : \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Arbre binaire avec hachage de 2 et 3 octets +.br +Valeur minimale pour \fInice\fP : \fB3\fP +.br +Utilisation de la mémoire : +.br +\fIdict\fP * 11.5 (si \fIdict\fP <= 16 Mio); +.br +\fIdict\fP * 9.5 + 64 MiB (si \fIdict\fP > 16 Mio) +.TP +\fBbt4\fP +Arbre binaire avec hachage 2, 3 et 4 octets +.br +Valeur minimale pour \fInice\fP : \fB4\fP +.br +Utilisation de la mémoire : +.br +\fIdict\fP * 11.5 (si \fIdict\fP <= 32 Mio); +.br +\fIdict\fP * 10.5 (si \fIdict\fP > 32 Mio) +.RE +.TP +\fBmode=\fP\fImode\fP +Compression \fImode\fP specifies the method to analyze the data produced by the +match finder. Supported \fImodes\fP are \fBfast\fP and \fBnormal\fP. The default is +\fBfast\fP for \fIpresets\fP 0\(en3 and \fBnormal\fP for \fIpresets\fP 4\(en9. +.IP "" +Habituellement, \fBfast\fP est utilisé avec les chercheurs de correspondance de +chaîne de hachage et \fBnormal\fP avec les chercheurs de correspondance d'arbre +binaire. C'est aussi ce que font les \fIpréréglages\fP. +.TP +\fBnice=\fP\fInice\fP +Spécifier ce qui est considéré comme une bonne longueur pour une +correspondance. Une fois que la correspondance d'au moins \fInice\fP octets est +trouvée, l'algorithme arrête de chercher de meilleures correspondances +possibles. +.IP "" +\fINice\fP can be 2\(en273 bytes. Higher values tend to give better +compression ratio at the expense of speed. The default depends on the +\fIpreset\fP. +.TP +\fBdepth=\fP\fIprofondeur\fP +Spécifier la profondeur de recherche maximale dans l'outil de recherche de +correspondances. La valeur par défaut est \fB0\fP, ce qui fait que le +compresseur détermine une \fIprofondeur\fP raisonnable en fonction de \fImf\fP et +\fInice\fP. +.IP "" +Reasonable \fIdepth\fP for Hash Chains is 4\(en100 and 16\(en1000 for Binary +Trees. Using very high values for \fIdepth\fP can make the encoder extremely +slow with some files. Avoid setting the \fIdepth\fP over 1000 unless you are +prepared to interrupt the compression in case it is taking far too long. +.RE +.IP "" +Lors du décodage des flux bruts (\fB\-\-format=raw\fP), LZMA2 nécessite seulement +la \fItaille\fP du dictionnaire. LZMA1 nécessite aussi \fIlc\fP, \fIlp\fP et \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIoptions\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIoptions\fP] +.PD +Ajouter un filtre branch/call/jump (BCJ) à la chaîne de filtres. Ces filtres +ne peuvent être utilisés que s'ils ne sont pas le dernier filtre de la +chaîne de filtrage. +.IP "" +A BCJ filter converts relative addresses in the machine code to their +absolute counterparts. This doesn't change the size of the data but it +increases redundancy, which can help LZMA2 to produce 0\(en15\ % smaller +\&\fB.xz\fP file. The BCJ filters are always reversible, so using a BCJ filter +for wrong type of data doesn't cause any data loss, although it may make the +compression ratio slightly worse. The BCJ filters are very fast and use an +insignificant amount of memory. +.IP "" +Ces filtres BCJ présentent des problèmes connus liés au taux de +compression : +.RS +.IP \(bu 3 +Some types of files containing executable code (for example, object files, +static libraries, and Linux kernel modules) have the addresses in the +instructions filled with filler values. These BCJ filters will still do the +address conversion, which will make the compression worse with these files. +.IP \(bu 3 +If a BCJ filter is applied on an archive, it is possible that it makes the +compression ratio worse than not using a BCJ filter. For example, if there +are similar or even identical executables then filtering will likely make +the files less similar and thus compression is worse. The contents of +non\-executable files in the same archive can matter too. In practice one +has to try with and without a BCJ filter to see which is better in each +situation. +.RE +.IP "" +Different instruction sets have different alignment: the executable file +must be aligned to a multiple of this value in the input data to make the +filter work. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filtre;Alignement;Notes +x86;1;32 bits ou 64 bits x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096\-byte alignment is best +PowerPC;4;Grand boutiste seulement +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Since the BCJ\-filtered data is usually compressed with LZMA2, the +compression ratio may be improved slightly if the LZMA2 options are set to +match the alignment of the selected BCJ filter. Examples: +.RS +.IP \(bu 3 +IA\-64 filter has 16\-byte alignment so \fBpb=4,lp=4,lc=0\fP is good with LZMA2 +(2^4=16). +.IP \(bu 3 +RISC\-V code has 2\-byte or 4\-byte alignment depending on whether the file +contains 16\-bit compressed instructions (the C extension). When 16\-bit +instructions are used, \fBpb=2,lp=1,lc=3\fP or \fBpb=1,lp=1,lc=3\fP is good. When +16\-bit instructions aren't present, \fBpb=2,lp=2,lc=2\fP is the best. +\fBreadelf \-h\fP can be used to check if "RVC" appears on the "Flags" line. +.IP \(bu 3 +ARM64 is always 4\-byte aligned so \fBpb=2,lp=2,lc=2\fP is the best. +.IP \(bu 3 +The x86 filter is an exception. It's usually good to stick to LZMA2's +defaults (\fBpb=2,lp=0,lc=3\fP) when compressing x86 executables. +.RE +.IP "" +Tous les filtres BCJ prennent en charge les mêmes \fIoptions\fP : +.RS +.TP +\fBstart=\fP\fIdécalage\fP +Spécifier le \fIdécalage\fP de départ qui est utilisé lors de la conversion +entre les adresses relatives et absolues. Le \fIdécalage\fP doit être un +multiple de l'alignement du filtre (voir la table ci\-dessus). Sa valeur par +défaut est zéro. En pratique, cette dernière convient ; indiquer un +\fIdécalage\fP personnalisé est la plupart du temps inutile. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIoptions\fP] +Ajouter le filtre Delta à la chaîne de filtres. Le filtre Delta ne peut être +utilisé que s'il n'est pas le dernier filtre dans la chaîne. +.IP "" +Currently only simple byte\-wise delta calculation is supported. It can be +useful when compressing, for example, uncompressed bitmap images or +uncompressed PCM audio. However, special purpose algorithms may give +significantly better results than Delta + LZMA2. This is true especially +with audio, which compresses faster and better, for example, with +\fBflac\fP(1). +.IP "" +\fIoptions\fP prises en charge : +.RS +.TP +\fBdist=\fP\fIdistance\fP +Specify the \fIdistance\fP of the delta calculation in bytes. \fIdistance\fP must +be 1\(en256. The default is 1. +.IP "" +Par exemple, avec \fBdist=2\fP et une entrée huit octets A1 B1 A2 B3 A3 B5 A4 +B7, la sortie sera A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Autres options" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Supprimer les avertissements et les notifications. Indiquer cela deux fois +supprimera aussi les erreurs. Cette option n'a aucun effet sur le statut de +sortie. Cela dit, même si un avertissement était supprimé, le statut de +sortie indiquant un avertissement sera encore utilisé. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Être bavard. Si l'erreur standard est connectée à un terminal, \fBxz\fP +affichera une barre de progression. Indiquer \fB\-\-verbose\fP deux fois donnera +une sortie encore plus bavarde. +.IP "" +La barre de progression montre l'information suivante : +.RS +.IP \(bu 3 +Le pourcentage de complétion est montré si la taille du fichier en entrée +est connue. Néanmoins, le pourcentage ne peut pas être montré en cas de +redirection. +.IP \(bu 3 +Quantité de données compressées produites (compression) ou consommées +(décompression). +.IP \(bu 3 +Quantité de données non compressées consommées (compression) ou produites +(décompression). +.IP \(bu 3 +Le taux de compression, calculé en divisant la quantité de données +compréssées déjà traitées par la quantité de données décompressées déjà +traitées. +.IP \(bu 3 +Vitesse de compression ou de décompression. Elle correspond à la quantité de +données non compressées consommées (compression) ou produites +(décompression) par seconde. Elle apparait quelques secondes après le début +du traitement du fichier par \fBxz\fP. +.IP \(bu 3 +Temps écoulé dans le format M:SS ou H:MM:SS. +.IP \(bu 3 +Estimated remaining time is shown only when the size of the input file is +known and a couple of seconds have already passed since \fBxz\fP started +processing the file. The time is shown in a less precise format which never +has any colons, for example, 2 min 30 s. +.RE +.IP "" +When standard error is not a terminal, \fB\-\-verbose\fP will make \fBxz\fP print +the filename, compressed size, uncompressed size, compression ratio, and +possibly also the speed and elapsed time on a single line to standard error +after compressing or decompressing the file. The speed and elapsed time are +included only when the operation took at least a few seconds. If the +operation didn't finish, for example, due to user interruption, also the +completion percentage is printed if the size of the input file is known. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Ne pas mettre l'état de sortie à \fB2\fP même si une condition méritant un +avertissement a été détectée. Cette option n'affecte pas le niveau de +verbosité, néanmoins, les deux options \fB\-\-quiet\fP et \fB\-\-no\-warn\fP doivent +être utilisées pour ne pas afficher d'avertissements, ni altérer le statut +de sortie. +.TP +\fB\-\-robot\fP +Afficher les messages dans un format analysable par une machine. Ceci est +destiné à faciliter l'écriture des frontaux qui voudraient utiliser \fBxz\fP +plutôt que liblzma, ce qui pourrait être le cas pour différents scripts. La +sortie avec cette option activée est destinée à rester stable sur les +différentes versions de \fBxz\fP. Consulter le paragraphe \fBROBOT MODE\fP pour +les détails. +.TP +\fB\-\-info\-memory\fP +Display, in human\-readable format, how much physical memory (RAM) and how +many processor threads \fBxz\fP thinks the system has and the memory usage +limits for compression and decompression, and exit successfully. +.TP +\fB\-h\fP, \fB\-\-help\fP +Afficher un message d'aide décrivant les options les plus couramment +utilisées et quitter. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Afficher un message d'aide décrivant toutes les options de \fBxz\fP et quitter. +.TP +\fB\-V\fP, \fB\-\-version\fP +Afficher le numéro de version de \fBxz\fP et de liblzma dans un format lisible +par un humain. Pour obtenir une sortie analysable par la machine, spécifiez +\fB\-\-robot\fP avant \fB\-\-version\fP. +. +.SH "MODE ROBOT" +The robot mode is activated with the \fB\-\-robot\fP option. It makes the output +of \fBxz\fP easier to parse by other programs. Currently \fB\-\-robot\fP is +supported only together with \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, +and \fB\-\-version\fP. It will be supported for compression and decompression in +the future. +. +.SS "Mode liste" +\fBxz \-\-robot \-\-list\fP utilise une sortie séparée par des tabulations. La +première colonne de toutes les lignes possède une chaîne qui indique le type +d'information trouvée sur cette ligne : +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +C'est toujours la première ligne au début de la liste d'un fichier. La +seconde colonne de la ligne est le nom de fichier. +.TP +\fBfile\fP +Cette ligne contient l'information globale sur le fichier \fB.xz\fP. Cette +ligne est toujours écrite après la ligne \fBname\fP. +.TP +\fBstream\fP +Ce type de ligne n'est utilisée que lorsque \fB \-\-verbose\fP a été indiquée. Il +y a autant de lignes \fBstream\fP qu'il y a de flux dans le fichier \fB.xz\fP. +.TP +\fBblock\fP +Ce type de ligne n'est utilisé seulement lorsque \fB\-\-verbose\fP a été +indiquée. Il y a autant de lignes \fBblock\fP qu'il y a de blocs dans le +fichier \fB.xz\fP. Les lignes \fBblock\fP sont affichées après toutes les lignes +\fBstream\fP ; les différents types de lignes ne sont pas imbriqués. +.TP +\fBsummary\fP +Ce type de ligne n'est utilisé que lorsque \fB\-\-verbose\fP a été indiqué deux +fois. Cette ligne est affichée après toutes les lignes \fBblock\fP. Comme la +ligne \fBfile\fP, la ligne \fBsummary\fP contient l'information globale sur le +fichier \fB.xz\fP. +.TP +\fBtotals\fP +Cette ligne est toujours la toute dernière ligne de la sortie. Elle affiche +les comptes et les tailles totaux. +.PP +Les colonnes des lignes \fBfile\fP : +.PD 0 +.RS +.IP 2. 4 +Nombre de flux dans le fichier +.IP 3. 4 +Nombre total de blocs dans le ou les flux. +.IP 4. 4 +Taille compressée du fichier +.IP 5. 4 +Taille décompressée du fichier +.IP 6. 4 +Compression ratio, for example, \fB0.123\fP. If ratio is over 9.999, three +dashes (\fB\-\-\-\fP) are displayed instead of the ratio. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Liste de noms de contrôles d'intégrité séparés par des virgules. Les chaînes +suivantes sont utilisées pour les types de vérification connus : \fBNone\fP, +\fBCRC32\fP, \fBCRC64\fP et \fBSHA256\fP. Pour le types de vérification inconnus, +\fBUnknown\-\fP\fIN\fP est utilisé, où \fIN\fP est un identifiant de vérification sous +la forme d'un nombre décimal (un ou deux chiffres). +.IP 8. 4 +Taille totale du remplissage du flux dans le fichier +.RE +.PD +.PP +Les colonnes des lignes \fBstream\fP : +.PD 0 +.RS +.IP 2. 4 +Numéro de flux (le premier flux a le numéro 1) +.IP 3. 4 +Nombre de blocs dans le flux +.IP 4. 4 +Décalage de départ compressé +.IP 5. 4 +Décalage de départ décompressé +.IP 6. 4 +Taille compressée (ne comprend pas le remplissage du flux) +.IP 7. 4 +Taille décompressée +.IP 8. 4 +Taux de compression +.IP 9. 4 +Nom de la vérification d'intégrité +.IP 10. 4 +Taille du remplissage de flux +.RE +.PD +.PP +Les colonnes des lignes \fBblock\fP : +.PD 0 +.RS +.IP 2. 4 +Numéro du flux qui contient ce bloc +.IP 3. 4 +Numéro du bloc relatif au commencement du flux (le premier bloc a pour +numéro 1) +.IP 4. 4 +Numéro du bloc relatif au début du fichier +.IP 5. 4 +Décalage de départ compressé relatif au début du fichier +.IP 6. 4 +Décalage de départ décompressé relatif au début du fichier +.IP 7. 4 +Taille compressée totale du bloc (en\-têtes inclus) +.IP 8. 4 +Taille décompressée +.IP 9. 4 +Taux de compression +.IP 10. 4 +Nom de la vérification d'intégrité +.RE +.PD +.PP +Si \fB\-\-verbose\fP a été indiqué deux fois, les colonnes additionnelles sont +inclues sur les lignes \fBblock\fP. Elles ne sont pas affichées avec un seul +\fB\-\-verbose\fP, car l'obtention de ces informations nécessite de nombreuses +recherches et peut donc être lente : +.PD 0 +.RS +.IP 11. 4 +Valeur de la vérification d'intégrité en hexadécimal +.IP 12. 4 +Taille d'en\-tête de bloc +.IP 13. 4 +Drapeaux du bloc : \fBc\fP indique que la taille compressée est présente, et +\fBu\fP indique que la taille décompréssée est présente. Si le drapeau n'est +pas indiqué, un tiret (\fB\-\fP) est affiché à la place pour que la longueur de +la chaîne reste fixe. De nouveaux drapeaux pourraient être ajoutés à la fin +de la chaîne dans le futur. +.IP 14. 4 +Taille des données effectivement compressées dans le bloc (en excluant +l'en\-tête de bloc, le remplissage de bloc et les champs de vérification). +.IP 15. 4 +Quantité de mémoire (en octets) nécessaire pour décompresser ce bloc avec +cette version de \fBxz\fP. +.IP 16. 4 +Chaîne de filtrage. Remarquez que la plupart des options utilisées au moment +de la compression ne peuvent pas être connues, car seules les options +nécessaires pour la décompression sont stockées dans les en\-têtes \fB.xz\fP. +.RE +.PD +.PP +Les colonnes des lignes \fBsummary\fP : +.PD 0 +.RS +.IP 2. 4 +Quantité de mémoire (en octets) nécessaire pour décompresser ce fichier avec +cette version de \fBxz\fP. +.IP 3. 4 +\fByes\fP ou \fBno\fP indique si tous les en\-têtes de bloc stockent à la fois la +taille compressée et la taille décompressée. +.PP +\fIDepuis\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Version minimale de \fBxz\fP nécessaire pour décompresser le fichier. +.RE +.PD +.PP +Les colonnes de la ligne \fBtotals\fP : +.PD 0 +.RS +.IP 2. 4 +Nombre de flux +.IP 3. 4 +Nombre de blocs +.IP 4. 4 +Taille compressée +.IP 5. 4 +Taille décompressée +.IP 6. 4 +Taux de compression moyen +.IP 7. 4 +Liste séparée par des virgules des noms de vérification d'intégrité qui +étaient présents dans les fichiers +.IP 8. 4 +Taille de remplissage de flux +.IP 9. 4 +Nombre de fichiers. Permet de garder l'ordre des colonnes précédentes comme +sur les lignes \fBfile\fP. +.PD +.RE +.PP +Si \fB\-\-verbose\fP a été indiqué deux fois, des colonnes supplémentaires sont +incluses sur la ligne \fBtotals\fP : +.PD 0 +.RS +.IP 10. 4 +Quantité maximale de mémoire (en octets) nécessaire pour décompresser les +fichiers avec cette version de \fBxz\fP. +.IP 11. 4 +\fByes\fP ou \fBno\fP indique si tous les en\-têtes de bloc stockent à la fois la +taille compressée et la taille décompressée. +.PP +\fIDepuis\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Version minimale de \fBxz\fP nécessaire pour décompresser le fichier. +.RE +.PD +.PP +Les versions futures pourront ajouter de nouveaux types de lignes et de +nouvelles colonnes pourront être ajoutées aux types de lignes existants, +mais les colonnes existantes ne seront pas modifiées. +. +.SS "Filters help" +\fBxz \-\-robot \-\-filters\-help\fP prints the supported filters in the following +format: +.PP +\fIfilter\fP\fB:\fP\fIoption\fP\fB=<\fP\fIvalue\fP\fB>,\fP\fIoption\fP\fB=<\fP\fIvalue\fP\fB>\fP... +.TP +\fIfilter\fP +Name of the filter +.TP +\fIoption\fP +Name of a filter specific option +.TP +\fIvalue\fP +Numeric \fIvalue\fP ranges appear as \fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. String +\fIvalue\fP choices are shown within \fB< >\fP and separated by a \fB|\fP +character. +.PP +Each filter is printed on its own line. +. +.SS "Information de limite de mémoire" +\fBxz \-\-robot \-\-info\-memory\fP prints a single line with multiple tab\-separated +columns: +.IP 1. 4 +Total amount of physical memory (RAM) in bytes. +.IP 2. 4 +Memory usage limit for compression in bytes (\fB\-\-memlimit\-compress\fP). A +special value of \fB0\fP indicates the default setting which for +single\-threaded mode is the same as no limit. +.IP 3. 4 +Memory usage limit for decompression in bytes (\fB\-\-memlimit\-decompress\fP). A +special value of \fB0\fP indicates the default setting which for +single\-threaded mode is the same as no limit. +.IP 4. 4 +Since \fBxz\fP 5.3.4alpha: Memory usage for multi\-threaded decompression in +bytes (\fB\-\-memlimit\-mt\-decompress\fP). This is never zero because a +system\-specific default value shown in the column 5 is used if no limit has +been specified explicitly. This is also never greater than the value in the +column 3 even if a larger value has been specified with +\fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Since \fBxz\fP 5.3.4alpha: A system\-specific default memory usage limit that is +used to limit the number of threads when compressing with an automatic +number of threads (\fB\-\-threads=0\fP) and no memory usage limit has been +specified (\fB\-\-memlimit\-compress\fP). This is also used as the default value +for \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Since \fBxz\fP 5.3.4alpha: Number of available processor threads. +.PP +Dans le futur, la sortie de \fBxz \-\-robot \-\-info\-memory\fP pourrait avoir plus +de colonnes, mais jamais plus qu'une ligne unique. +. +.SS Version +\fBxz \-\-robot \-\-version\fP prints the version number of \fBxz\fP and liblzma in +the following format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Version majeure. +.TP +\fIYYY\fP +Version mineure. Les numéros pairs sont stables. Les numéros impairs sont +des versions alpha ou beta. +.TP +\fIZZZ\fP +Niveau de correctif pour les options stables ou juste un compteur pour les +options de développement. +.TP +\fIS\fP +Stabilité. 0 est alpha, 1 est bêta et 2 est stable. \fIS\fP devrait toujours +être 2 quand \fIYYY\fP est pair. +.PP +\fIXYYYZZZS\fP sont identiques sur les deux lignes si \fBxz\fP et liblzma sont +issus de la même version d'utilitaires XZ. +.PP +Exemples : 4.999.9beta est \fB49990091\fP et 5.0.0 est \fB50000002\fP. +. +.SH "STATUT DE SORTIE" +.TP +\fB0\fP +Tout est bon. +.TP +\fB1\fP +Une erreur est survenue. +.TP +\fB2\fP +Quelquechose méritant un avertissement s'est produit, mais aucune erreur +véritable n'est survenue. +.PP +Les notifications (pas les avertissements ou les erreurs) affichées sur +l'erreur standard n'affectent pas le statut de sortie. +. +.SH ENVIRONNEMENT +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP analyse les listes d'options séparées par des espaces à partir des +variables d'environnement \fBXZ_DEFAULTS\fP et \fBXZ_OPT\fP, dans cet ordre, avant +d'analyser les options de la ligne de commandes. Remarquez que seules les +options sont analysées depuis l'environnement des variables ; toutes les +non\-options sont ignorées silencieusement. L'analyse est faite avec +\fBgetopt_long\fP(3) qui est aussi utilisé pour les arguments de la ligne de +commandes. +.PP +\fBWarning:\fP By setting these environment variables, one is effectively +modifying programs and scripts that run \fBxz\fP. Most of the time it is safe +to set memory usage limits, number of threads, and compression options via +the environment variables. However, some options can break scripts. An +obvious example is \fB\-\-help\fP which makes \fBxz\fP show the help text instead of +compressing or decompressing a file. More subtle examples are \fB\-\-quiet\fP +and \fB\-\-verbose\fP. In many cases it works well to enable the progress +indicator using \fB\-\-verbose\fP, but in some situations the extra messages +create problems. The verbosity level also affects the behavior of +\fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +User\-specific or system\-wide default options. Typically this is set in a +shell initialization script to enable \fBxz\fP's memory usage limiter by +default or set the default number of threads. Excluding shell +initialization scripts and similar special cases, scripts should never set +or unset \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +This is for passing options to \fBxz\fP when it is not possible to set the +options directly on the \fBxz\fP command line. This is the case when \fBxz\fP is +run by a script or tool, for example, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Scripts may use \fBXZ_OPT\fP, for example, to set script\-specific default +compression options. It is still recommended to allow users to override +\fBXZ_OPT\fP if that is reasonable. For example, in \fBsh\fP(1) scripts one may +use something like this: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "Compatibilité des utilitaires LZMA" +La syntaxe de la ligne de commande de \fBxz\fP est quasimment un sur\-ensemble +de \fBlzma\fP, \fBunlzma\fP et \fBlzcat\fP comme ils sont trouvés dans les +utilitaires LZMA 4.32.x . Dans la pluspart des cas, il est possible de +remplacer les outils LZMA par les outils XZ sans casser les scripts +existants. Il existe cependant certaines incompatibilités qui peuvent +parfois poser des problèmes. +. +.SS "Niveaux de préréglage de la compression" +La numérotation des préréglages de niveau de compression est différente +entre les outils \fBxz\fP et LZMA. La différence la plus importante est la +manière dont les tailles de dictionnaire sont affectées aux différents +préréglages. La taille de dictionnaire est à peu près égale à celle +d'utilisation de la mémoire de la décompression. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Niveau;xz;Utilitaires LZMA +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Les différences de tailles des dictionnaires affectent aussi l'utilisation +de la mémoire du compresseur, mais il y a quelques autres différences entre +les outils LZMA et les outils XZ, qui rendent la différence encore plus +grande : +.RS +.PP +.TS +tab(;); +c c c +c n n. +Niveau;xz;Utilitaires LZMA 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Le niveau de préréglage par défaut dans les outils LZMA est \fB\-7\fP alors que +pour les outils XZ c'est \fB\-6\fP, les deux utilisent ainsi un dictionnaire de +8 Mio par défaut. +. +.SS "Fichiers .lzma en flux ou non" +The uncompressed size of the file can be stored in the \fB.lzma\fP header. +LZMA Utils does that when compressing regular files. The alternative is to +mark that uncompressed size is unknown and use end\-of\-payload marker to +indicate where the decompressor should stop. LZMA Utils uses this method +when uncompressed size isn't known, which is the case, for example, in +pipes. +.PP +\fBxz\fP prend en charge la décompression des fichiers \fB.lzma\fP avec ou sans +marqueur de fin de charge utile, mais tous les fichiers \fB.lzma\fP créés par +\fBxz\fP utiliseront un marqueur de fin de charge utile et ont la taille non +compréssée marquée comme inconnue dans l'en\-tête \fB.lzma\fP. Cela peut être un +problème dans quelques situations inhabituelles. Par exemple, un +décompresseur \fB.lzma\fP dans un périphérique embarqué pourrait ne fonctionner +qu'avec des fichiers dont la taille non comprimée est connue. Si vous vous +heurtez à ce problème, vous devez utiliser les utilitaires LZMA ou LZMA SDK +pour créer des fichiers \fB.lzma\fP avec une taille non compressée connue. +. +.SS "Fichiers .lzma non pris en charge" +Le format \fB.lzma\fP autorise des valeurs \fIlc\fP jusqu'à 8, et des valeurs +\fIlp\fP jusqu'à 4. Les outils LZMA peuvent décompresser des fichiers avec tous +les \fIlc\fP et \fIlp\fP, mais créez toujours les fichiers avec \fBlc=3\fP et +\fBlp=0\fP. Créer des fichiers avec d'autres valeurs \fIlc\fP et \fIlp\fP est +possible avec \fBxz\fP et avec LZMA SDK. +.PP +L'implémentation du filtre LZMA1 dans liblzma nécessite que la somme de +\fIlc\fP et \fIlp\fP soit inférieure ou égale à 4. Ainsi, les fichiers \fB.lzma\fP +qui excèdent cette limitation ne peuvent pas être décompressés avec \fBxz\fP. +.PP +Les outils LZMA créent seulement des fichiers \fB.lzma\fP qui ont une taille de +dictionnaire de 2^\fIn\fP (une puissance de 2) mais acceptent les fichiers avec +toutes les tailles de dictionnaire. Libzlma n'accepte que les fichiers +\&\fB.lzma\fP qui ont une taille dictionnaire de 2^\fIn\fP ou +2^\fIn\fP + 2^(\fIn\fP\-1). Cela afin de diminuer les faux positifs lors de la +détection des fichiers \fB.lzma\fP. +.PP +Ces limitations ne devraient pas poser problème en pratique, car +pratiquement tous les fichiers \fB.lzma\fP ont été compressés avec des réglages +que liblzma accepte. +. +.SS "Déchets excédentaires" +Lors de la décompession, l'utilitaire LZMA ignore silencieusement tout ce +qui est après le premier flux \fB.lzma\fP. Dans la majorité des situations, +c'est un bogue. Cela veut dire aussi que les outils LZMA ne gèrent pas la +décompression de fichiers \fB.lzma\fP concaténés. +.PP +S'il reste des données après le premier flux \fB.lzma\fP, \fBxz\fP considère que +le fichier est corrompu sauf si \fB\-\-single\-stream\fP a été utilisé. Cela peut +casser des scripts obscurs qui ont supposé que les déchets de fin de ligne +sont ignorés. +. +.SH NOTES +. +.SS "La sortie compressée peut varier" +La sortie compressée exacte produite par les même fichiers non compressés en +entrée peut varier en fonction des différentes versions de l'utilitaire XZ, +même si les options de compression sont identiques. En effet, il est +possible d'améliorer l'encodeur (compression plus rapide ou meilleure) sans +affecter le format du fichier. La sortie peut même varier entre différentes +compilations de la même version d'utilitaire XZ, si des options de +construction différentes sont utilisées. +.PP +Cela signifie qu'une fois que \fB\-\-rsyncable\fP a été implémenté, les fichiers +résultants ne seront pas nécessairement synchronisables avec rsync à moins +que les nouveaux et anciens fichiers n'aient été compressés avec la même +version de xz. Ce problème peut être résolu si une partie de +l'implémentation est gelée pour garantir la stabilité de la sortie rsyncable +à travers les versions de xz. +. +.SS "Décompresseurs .xz embarqués" +Les implémentations de décompresseur embarqué comme XZ Embedded ne gèrent +pas nécessairement les fichiers créés avec d'autres types de \fIvérification\fP +d'intégrité que \fBnone\fP et \fBCRC32\fP. Comme la valeur par défaut est +\fB\-\-check=crc64\fP, vous devez utiliser \fB\-\-check=none\fP ou \fB\-\-check=crc32\fP +lors de la création de fichiers pour les systèmes embarqués. +.PP +En dehors des systèmes embarqués, tous les décompresseurs de format \fB.xz\fP +gèrent tous les types de \fIvérification\fP ou sont au moins capables de +décompresser le fichier sans effectuer la vérification d'intégrité si ce +type de \fIvérification\fP particulière n'est pas pris en charge. +.PP +XZ Embedded prend en charge les filtres BCJ, mais seulement avec le décalage +de départ par défaut. +. +.SH EXEMPLES +. +.SS Bases +Compresser le fichier \fItoto\fP en \fItoto.xz\fP en utilisant le niveau de +compression par défaut (\fB\-6\fP) et supprimer \fItoto\fP si la compression +réussit : +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Décompresser \fIbidule.xz\fP en \fIbidule\fP et ne pas supprimer \fIbidule.xz\fP même +si la compression réussit : +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Create \fIbaz.tar.xz\fP with the preset \fB\-4e\fP (\fB\-4 \-\-extreme\fP), which is +slower than the default \fB\-6\fP, but needs less memory for compression and +decompression (48\ MiB and 5\ MiB, respectively): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Un mélange de fichiers compressés et non compressés peuvent être +décompressés vers la sortie standard avec une simple commande : +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Compression en parallèle de plusieurs fichiers" +Sur GNU et *BSD, \fBfind\fP(1) et \fBxargs\fP(1) peuvent être utilisés pour mettre +en parallèle la compression de plusieurs fichiers : +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +L'option \fBP\fP passée à \fBxargs\fP(1) fixe le nombre de processus \fBxz\fP en +parallèles. La meilleure valeur pour l'option \fBn\fP dépend du nombre de +fichiers à compresser. S\-il n'y a que quelques fichiers, la valeur sera +probablement 1 ; avec des dizaines de milliers de fichiers, 100 ou même plus +serait approprié pour réduire le nombre de processus \fBxz\fP que \fBxargs\fP(1) +créera éventuellement. +.PP +L'option \fB\-T1\fP de \fBxz\fP est là pour le forcer en mode mono\-thread, car +\fBxargs\fP(1) est utilisé pour contrôler la quantité de mise en parallèle. +. +.SS "Mode robot" +Calculer combien d'octets ont été économisés au total après avoir compressé +plusieurs fichiers : +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Un script peut vouloir savoir qu'il utilise une version suffisamment récente +de \fBxz\fP. Le script \fBsh\fP(1) suivant vérifie que le numéro de version de +l'outil \fBxz\fP soit au minimum 5.0.0. Cette méthode est compatible avec les +vieilles versions bêta, qui ne gèrent pas l'option \fB\-\-robot\fP : +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Régler une limite d'utilisation de la mémoire pour la décompression en +utilisant \fBXZ_OPT\fP, mais si une limite a déjà été définie, ne pas +l'augmenter : +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Chaînes de filtres de compresseur personnalisées" +L'utilisation la plus simple des chaînes de filtres personnalisées est la +personnalisation d'un préréglage LZMA2. Cela peut être utile, car les +préréglages ne couvrent qu'un sous\-ensemble des réglages de compression +potentiellement utiles. +.PP +Les colonnes CompCPU des tableaux des descriptions des options \fB\-0\fP à \fB\-9\fP +et \fB\-\-extreme\fP sont utiles lors de la personnalisation des préréglages +LZMA2. Voici les parties pertinentes recueillies à partir de ces deux +tableaux : +.RS +.PP +.TS +tab(;); +c c +n n. +Préréglage;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +If you know that a file requires somewhat big dictionary (for example, 32\ MiB) to compress well, but you want to compress it quicker than \fBxz \-8\fP +would do, a preset with a low CompCPU value (for example, 1) can be +modified to use a bigger dictionary: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Avec certains fichiers, la commande ci\-dessus peut être plus rapide que +\fBxz\-6\fP tout en compressant bien mieux. Cependant, il faut souligner que +seuls certains fichiers bénéficient d'un grand dictionnaire tout en gardant +la valeur de CompCPU faible. La siutation la plus évidente où un gros +dictionnaire peut baucoup aider, est une archive contenant des fichiers très +similaires de quelques megaoctets chacun. La taille de dictionnaire doit +être significativement plus grosse que tout fichier individuel pour +permettre à LZMA2 de tirer pleinement partie des similarités entre des +fichiers consécutifs. +.PP +Si une utilisation de la mémoire élevée pour la compression et décompression +convient, et que le fichier à compresser a une taille de plusieurs centaines +de megaoctets, il peut être utile d'utiliser un plus gros dictionnaire que +celui fourni par \fBxz\-9\fP (64 Mio) : +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Utiliser \fB\-vv\fP (\fB\-\-verbose\-\-verbose\fP) comme dans l'exemple ci\-dessus peut +être utile pour voir les besoins en mémoire du compresseur et du +décompresseur. Rappelez\-vous qu'utiliser un dictionnaire plus gros que la +taille du fichier non compressé est un gachis de mémoire, donc la commande +ci\-dessus n'est pas utile pour les petits fichiers. +.PP +Sometimes the compression time doesn't matter, but the decompressor memory +usage has to be kept low, for example, to make it possible to decompress the +file on an embedded system. The following command uses \fB\-6e\fP (\fB\-6 \-\-extreme\fP) as a base and sets the dictionary to only 64\ KiB. The +resulting file can be decompressed with XZ Embedded (that's why there is +\fB\-\-check=crc32\fP) using about 100\ KiB of memory. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +If you want to squeeze out as many bytes as possible, adjusting the number +of literal context bits (\fIlc\fP) and number of position bits (\fIpb\fP) can +sometimes help. Adjusting the number of literal position bits (\fIlp\fP) +might help too, but usually \fIlc\fP and \fIpb\fP are more important. For +example, a source code archive contains mostly US\-ASCII text, so something +like the following might give slightly (like 0.1\ %) smaller file than \fBxz \-6e\fP (try also without \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Using another filter together with LZMA2 can improve compression with +certain file types. For example, to compress a x86\-32 or x86\-64 shared +library using the x86 BCJ filter: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Notez que l'ordre des options de filtre est significatif. Si \fB\-\-x86\fP est +indiqué après \fB\-\-lzma2\fP, \fBxz\fP donnera une erreur, car il ne peut y avoir +aucun filtre après LZMA2, et aussi parce que le filtre BCJ x86 ne peut pas +être utilisé comme dernier filtre dans la chaîne. +.PP +Le filtre Delta associé à LZMA2 peut donner de bons résultats avec les +images bitmap. Cela devrait habituellement battre PNG, qui a quelques +filtres avancés supplémentaires qu'un simple delta, mais qui utilise Deflate +pour la compression effective. +.PP +The image has to be saved in uncompressed format, for example, as +uncompressed TIFF. The distance parameter of the Delta filter is set to +match the number of bytes per pixel in the image. For example, 24\-bit RGB +bitmap needs \fBdist=3\fP, and it is also good to pass \fBpb=0\fP to LZMA2 to +accommodate the three\-byte alignment: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +If multiple images have been put into a single archive (for example, +\&\fB.tar\fP), the Delta filter will work on that too as long as all images have +the same number of bytes per pixel. +. +.SH "VOIR AUSSI" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/xz.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/xz.1 new file mode 100644 index 0000000000000000000000000000000000000000..297dc7c0d91cc84d9990f8e22984ef3e7be54f5b --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/xz.1 @@ -0,0 +1,2027 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" french translation of XZ Utils man +.\" Copyright (C) 2021 Debian French l10n team +.\" Translator +.\" bubu , 2021. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 2025\-03\-08 Tukaani "Utilitaires XZ" +. +.SH NOM +xz, unxz, xzcat, lzma, unlzma, lzcat \- Compresser ou décompresser des +fichiers .xz et .lzma +. +.SH SYNOPSIS +\fBxz\fP [\fIoption...\fP] [\fIfichier...\fP] +. +.SH "ALIAS DES COMMANDES" +\fBunxz\fP est équivalent à \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP est équivalent à \fBxz \-\-decompress \-\-stdout\fP +.br +\fBlzma\fP est équivalent à \fBxz \-\-format=lzma\fP +.br +\fBunlzma\fP est équivalent à \fBxz \-\-format=lzma \-\-decompress\fP +.br +\fBlzcat\fP est équivalent à \fBxz \-\-format=lzma \-\-decompress \-\- stdout\fP +.PP +Lors de l'écriture de scripts qui nécessitent de décompresser des fichiers, +il est recommandé de toujours utiliser la commande \fBxz\fP avec les arguments +appropriés (\fBxz \-d\fP ou \fBxz \-dc\fP) au lieu des commandes \fBunxz\fP et +\fBxzcat\fP. +. +.SH DESCRIPTION +\fBxz\fP is a general\-purpose data compression tool with command line syntax +similar to \fBgzip\fP(1) and \fBbzip2\fP(1). The native file format is the +\&\fB.xz\fP format, but the legacy \fB.lzma\fP format used by LZMA Utils and raw +compressed streams with no container format headers are also supported. In +addition, decompression of the \fB.lz\fP format used by \fBlzip\fP is supported. +.PP +\fBxz\fP compresse ou décompresse chaque \fIfichier\fP en fonction du mode +d'opération choisi. Si aucun \fIfichier\fP n'est donné ou \fIfichier\fP est \fB\-\fP, +\fBxz\fP lit depuis l'entrée standard et écrit les données traitées sur la +sortie standard. \fBxz\fP refusera (affichera une erreur et ignorera le +\fIfichier\fP) d'écrire les données compressées sur la sortie standard si c'est +un terminal. De même, \fBxz\fP refusera de lire des données compressées depuis +l'entrée standard si c'est un terminal. +.PP +A moins que \fB\-\-sdout\fP ne soit indiqué, les \fIfichiers\fP autres que \fB\-\fP sont +écrits dans un nouveau fichier dont le nom est dérivé du nom de \fIfichier\fP +source : +.IP \(bu 3 +Lors de la compression, le suffixe du format de fichier cible (\fB.xz\fP ou +\&\fB.lzma\fP) est ajouté au nom de fichier source pour obtenir le nom de fichier +cible. +.IP \(bu 3 +When decompressing, the \fB.xz\fP, \fB.lzma\fP, or \fB.lz\fP suffix is removed from +the filename to get the target filename. \fBxz\fP also recognizes the suffixes +\&\fB.txz\fP and \fB.tlz\fP, and replaces them with the \fB.tar\fP suffix. +.PP +Si le fichier cible existe déjà, une erreur est affichée et le \fIfichier\fP +est ignoré. +.PP +Sauf s'il écrit dans la sortie standard, \fBxz\fP affichera un avertissement et +ignorera le \fIfichier\fP dans les cas suivants : +.IP \(bu 3 +\fIfichier\fP n'est pas un fichier normal. Les liens symboliques ne sont pas +suivis et donc ne sont pas considérés comme des fichiers normaux. +.IP \(bu 3 +\fIfichier\fP a plusieurs liens physiques. +.IP \(bu 3 +\fIfichier\fP a un setuid, setgid ou sticky bit positionné. +.IP \(bu 3 +Le mode d'opération est défini pour compresser et le \fIfichier\fP a déjà un +suffixe du format de fichier cible (\fB.xz\fP ou \fB.txz\fP lors d'une compression +en format \fB.xz\fP, et \fB.lzma\fP ou \fB.tlz\fP lors d'une compression en format +\&\fB.lzma\fP). +.IP \(bu 3 +The operation mode is set to decompress and the \fIfile\fP doesn't have a +suffix of any of the supported file formats (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, +\&\fB.tlz\fP, or \fB.lz\fP). +.PP +Après la compression ou la décompression réussie du \fIfichier\fP, \fBxz\fP copie +les permissions du propriétaire, du groupe, la date d'accès, et les +modifications d'heure depuis le \fIfichier\fP source du fichier cible. Si la +copie du groupe échoue, les permissions sont modifiées pour que le fichier +cible ne soit pas accessible aux utilisateurs qui n'ont pas les droits +d'accès au \fIfichier\fP source. \fBxz\fP ne prend actuellement pas en charge la +copie d'autres métadonnées telles que les listes de contrôle d'accès ou les +attributs étendus. +.PP +Once the target file has been successfully closed, the source \fIfile\fP is +removed unless \fB\-\-keep\fP was specified. The source \fIfile\fP is never removed +if the output is written to standard output or if an error occurs. +.PP +Envoyer \fBSIGINFO\fP ou \fBSIGURSR1\fP au processus \fBxz\fP, lui fait afficher +l'information de progression sur l'erreur standard. Cela a un intérêt limité +car lorsque l'erreur standard est un terminal, utiliser \fB\-\-verbose\fP +affichera automatiquement un indicateur de progression du processus. +. +.SS "Utilisation de la mémoire" +L'utilisation de la mémoire par \fBxz\fP varie de quelques centaines de +kilo\-octets à plusieurs gigaoctects en fonction des paramètres de +compression. Les réglages utilisés lors de la compression d'un fichier +déterminent les besoins en mémoire pour la décompression. Habituellement la +décompression nécessite 5\% à 20\% de la quantité de mémoire utilisée pour +la compression du fichier. Par exemple, décompresser un fichier créé avec +\fBxz\-9\fP recquiert habituellement 65\ Mio de mémoire. Bien qu'il soit +possible d'avoir des fichiers \fB.xz\fP nécessitant plusieurs gigaoctets de +mémoire pour être décompressés. +.PP +Especially users of older systems may find the possibility of very large +memory usage annoying. To prevent uncomfortable surprises, \fBxz\fP has a +built\-in memory usage limiter, which is disabled by default. While some +operating systems provide ways to limit the memory usage of processes, +relying on it wasn't deemed to be flexible enough (for example, using +\fBulimit\fP(1) to limit virtual memory tends to cripple \fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +The memory usage limiter can be enabled with the command line option +\fB\-\-memlimit=\fP\fIlimit\fP. Often it is more convenient to enable the limiter +by default by setting the environment variable \fBXZ_DEFAULTS\fP, for example, +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. It is possible to set the limits +separately for compression and decompression by using +\fB\-\-memlimit\-compress=\fP\fIlimit\fP and \fB\-\-memlimit\-decompress=\fP\fIlimit\fP. +Using these two options outside \fBXZ_DEFAULTS\fP is rarely useful because a +single run of \fBxz\fP cannot do both compression and decompression and +\fB\-\-memlimit=\fP\fIlimit\fP (or \fB\-M\fP \fIlimit\fP) is shorter to type on the +command line. +.PP +If the specified memory usage limit is exceeded when decompressing, \fBxz\fP +will display an error and decompressing the file will fail. If the limit is +exceeded when compressing, \fBxz\fP will try to scale the settings down so that +the limit is no longer exceeded (except when using \fB\-\-format=raw\fP or +\fB\-\-no\-adjust\fP). This way the operation won't fail unless the limit is very +small. The scaling of the settings is done in steps that don't match the +compression level presets, for example, if the limit is only slightly less +than the amount required for \fBxz \-9\fP, the settings will be scaled down only +a little, not all the way down to \fBxz \-8\fP. +. +.SS "Concaténation et remplissage avec des fichiers .xz" +Il est possible de concaténer les fichiers \fB.xz\fP tels quel. \fBxz\fP +décompressera de tels fichiers comme s'ils étaient un unique fichier \fB.xz\fP. +.PP +It is possible to insert padding between the concatenated parts or after the +last part. The padding must consist of null bytes and the size of the +padding must be a multiple of four bytes. This can be useful, for example, +if the \fB.xz\fP file is stored on a medium that measures file sizes in +512\-byte blocks. +.PP +La concaténation et le remplissage ne sont pas autorisés avec les fichiers +\&\fB.lzma\fP ou les flux bruts. +. +.SH OPTIONS +. +.SS "Suffixes entiers et valeurs spéciales." +Dans la plupart des endroits où un argument entier est attendu, un suffixe +optionel permet d'indiquer facilement les grands entiers. Il ne doit pas y +avoir d'espace entre l'entier et le suffixe. +.TP +\fBKiB\fP +Multiplier l'entier par 1024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP et \fBKB\fP sont +acceptés comme synonymes de \fBKiB\fP. +.TP +\fBMiB\fP +Multiplier l'entier par 1 048 576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP et \fBMB\fP sont +acceptés comme synonymes de \fBMiB\fP. +.TP +\fBGiB\fP +Multiplier l'entier par 1 073 741 824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP et \fBGB\fP +sont acceptés comme synonymes de \fBGiB\fP. +.PP +La valeur spéciale \fBmax\fP peut être utilisée pour indiquer la valeur +maximale de l'entier prise en charge par l'option. +. +.SS "Mode d'opération" +Si plusieurs options de mode d'opération sont données, la dernière prend +effet. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Compresser. C'est le mode d'opération par défaut lorsque aucune option de +mode opératoire n'est spécifiée ou qu'aucun autre mode d'opération n'est +sous\-entendu par le nom de la commande (par exemple \fBunxz\fP sous\-entend +\fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +After successful compression, the source file is removed unless writing to +standard output or \fB\-\-keep\fP was specified. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Decompress. After successful decompression, the source file is removed +unless writing to standard output or \fB\-\-keep\fP was specified. +.TP +\fB\-t\fP, \fB\-\-test\fP +Tester l'intégrité des \fIfichiers\fP compressés. Cette option est équivalente +à \fB\-\-decompress \-\-stdout\fP sauf que les données décompressées sont rejetées +au lieu d'être écrites sur la sortie standard. Aucun fichier n'est créé ou +supprimé. +.TP +\fB\-l\fP, \fB\-\-list\fP +Afficher l'information sur les \fIfichiers\fP compressés. Aucune sortie +non\-compressée n'est produite et aucun fichier n'est créé ou supprimé. En +mode liste, le programme ne peut pas lire les données compressées depuis +l'entrée standard ou depuis d'autres sources non adressables. +.IP "" +The default listing shows basic information about \fIfiles\fP, one file per +line. To get more detailed information, use also the \fB\-\-verbose\fP option. +For even more information, use \fB\-\-verbose\fP twice, but note that this may be +slow, because getting all the extra information requires many seeks. The +width of verbose output exceeds 80 characters, so piping the output to, for +example, \fBless\ \-S\fP may be convenient if the terminal isn't wide enough. +.IP "" +La sortie exacte peut varier suivant les versions de \fBxz\fP et les différents +paramètres régionaux. Pour une sortie lisible par la machine, utiliser +\fB\-\-robot \-\-list\fP. +. +.SS "Modificateurs d'opération" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Ne pas effacer les fichiers d'entrée. +.IP "" +Since \fBxz\fP 5.2.6, this option also makes \fBxz\fP compress or decompress even +if the input is a symbolic link to a regular file, has more than one hard +link, or has the setuid, setgid, or sticky bit set. The setuid, setgid, and +sticky bits are not copied to the target file. In earlier versions this was +only done with \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Cette option a plusieurs effets : +.RS +.IP \(bu 3 +Si le fichier cible existe déjà, l'effacer avant de compresser ou +décompresser. +.IP \(bu 3 +Compresser ou décompresser même si l'entrée est un lien symbolique vers un +fichier normal, a plus qu'un lien physique, ou a le bit setuid, setgid ou +sticky défini. Les bits setuid, setgid et sticky bits ne sont pas copiés +dans le fichier cible. +.IP \(bu 3 +Lorsque \fBxz\fP est utilisé avec \fB\-\-decompress\fP \fB\-\-stdout\fP et qu'il ne peut +pas reconnaitre le type du fichier source, copier le fichier source tel quel +dans la sortie standard. Celà permet à \fBxzcat\fP \fB\-\-force\fP d'être utilisé +comme \fBcat\fP(1) pour les fichiers qui n'ont pas été compressé avec +\fBxz\fP. Remarquez que dans le futur, \fBxz\fP devrait prendre en charge de +nouveaux formats de fichiers compressés, ce qui permettra à \fBxz\fP de +décompresser plus de types de fichiers au lieu de les copier tels quels dans +la sortie standard. \fB\-\-format=\fP\fIformat\fP peut être utilisé pour contraindre +\fBxz\fP à décompresser seulement un format de fichier. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Écrire les données compressées ou décompressées sur la sortie standard +plutôt que dans un fichier. Cela necessite \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Décompresser seulement le premier flux \fB.xz\fP et ignorer silencieusement les +possibles données d'entrée résiduelles qui suivent le flux. Normalement ces +déchets excédentaires provoquent l'affichage d'une erreur par \fBxz\fP. +.IP "" +\fBxz\fP ne décompresse jamais plus d'un flux à partir de fichiers \fB.lzma\fP ou +de flux bruts, mais cette option fait aussi que \fBxz\fP ignorera les données +résiduelles après le fichier \fB.lzma\fP ou le flux brut. +.IP "" +Cette option n'a aucun effet si le mode d'opération n'est pas +\fB\-\-decompress\fP ou \fB\-\-test\fP. +.IP "" +Since \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP implies \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Désactiver la création de fichiers peu denses. Par défaut, lors de la +décompression en un fichier normal, \fBxz\fP essaie d'en faire un fichier creux +si les données décompressées contiennent de longues séquences de zéros +binaires. Cela fonctionne aussi lors de l'écriture sur la sortie standard +aussi longtemps que la sortie standard est connectée à un fichier normal et +que certaines conditions supplémentaires sont satisfaites pour le faire de +manière sécurisée. Créer des fichiers creux peut épargner de l'espace disque +et accélérer la décompression en réduisant la quantité d'entrées/sorties sur +le disque. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Lors de la compression, utiliser \fB.suf\fP comme suffixe du fichier cible au +lieu de \fB.xz\fP ou \fB.lzma\fP. Si \fBxz\fP n'écrit pas sur la sortie standard et +si le fichier source a déja le suffixe \fB.suf\fP, un avertissement est affiché +et le fichier est ignoré. +.IP "" +When decompressing, recognize files with the suffix \fI.suf\fP in addition to +files with the \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, or \fB.lz\fP suffix. If the +source file has the suffix \fI.suf\fP, the suffix is removed to get the target +filename. +.IP "" +Lors de la compression ou décompression de flux bruts (\fB\-\-fomat=raw\fP), le +suffixe doit toujours être spécifié à moins d'écrire sur la sortie standard, +car il n'y a pas de suffixe par défaut pour les flux bruts. +.TP +\fB\-\-files\fP[\fB=\fP\fIfichier\fP] +Lire les noms de fichier à traiter depuis \fIfichier\fP ; si \fIfichier\fP est +omis , les noms de fichier sont lus sur l'entrée standard. Les noms de +fichier doivent se terminer avec le caractère de nouvelle ligne. Un tiret +(\fB\-\fP) est considéré comme un nom de fichier normal ; ce qui ne signifie pas +entrée standard. Si les noms de fichier sont aussi donnés comme arguments de +ligne de commande, ils sont traités avant les noms de fichier lus depuis +\fIfichier\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIfichier\fP] +Cela est identique à \fB\-\-files\fP[\fB=\fP\fIfichier\fP] sauf que chaque nom de +fichier doit se terminer par le caractère null. +. +.SS "Format de fichier basique et options de compression" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fIformat\fP +Indiquer le \fIformat\fP de fichier à compresser ou décompresser : +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +C'est celui par défaut. Lors de la compression, \fBauto\fP est équivalent à +\fBxz\fP. Lors de la décompression, le format du fichier en entrée est détecté +automatiquement. Notez que les flux bruts (créés avec \fB\-\-format=raw\fP) ne +peuvent pas être détectés automatiquement. +.TP +\fBxz\fP +Compresser dans le format de fichier \fB.xz\fP ou n'accepter que les fichiers +\&\fB.xz\fP à décompresser. +.TP +\fBlzma\fP, \fBalone\fP +Compresser au format de fichier \fB.lzma\fP historique, ou n'accepter que les +fichiers \fB.lzma\fP lors de la décompression. Le nom alternatif \fBalone\fP est +fourni pour la rétrocompatibilité avec les utilitaires LZMA. +.TP +\fBlzip\fP +Accept only \fB.lz\fP files when decompressing. Compression is not supported. +.IP "" +The \fB.lz\fP format versions 0 and 1 are supported. Version 0 files were +produced by \fBlzip\fP 1.3 and older. Such files aren't common but may be +found from file archives as a few source packages were released in this +format. People might have old personal files in this format too. +Decompression support for the format version 0 was removed in \fBlzip\fP 1.18. +\fBlzip\fP 1.4 and later create files in the format version 1. +.TP +\fBraw\fP +Compresser ou décompresser un flux brut (sans en\-têtes). Cela est réservé +seulement aux utilisateurs aguerris. Pour décoder des flux bruts, vous devez +utiliser \fB\-\-format=raw\fP et spécifier explicitement la chaîne de filtre, qui +normalement aurait du être stockée dans les en\-têtes du conteneur. +.RE +.TP +\fB\-C\fP \fIvérif.\fP, \fB\-\-check=\fP\fIvérif.\fP +Spécifier le type d'intégrité à vérifier. La vérification est calculée à +partir des données non\-compressées et stockées dans le fichier \fB.xz\fP. Cette +option n'a effet que si la compression a été faite dans le format \fB.xz\fP ; +le format \fB.lzma\fP ne gère pas les vérifications d'intégrité. Le contrôle +d'intégrité (s'il y en a) est vérifié lorsque le fichier \fB.xz\fP est +décompressé. +.IP "" +Types de \fIvérification\fP pris en charge : +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Ne pas calculer de vérification d'intégrité du tout. C'est généralement une +mauvaise idée. Cela peut être utile lorsque l'intégrité des données est +vérifiée de toute façon par d'autres manières. +.TP +\fBcrc32\fP +Calculer CRC32 en utilisant le polynôme de IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Calculer CRC64 en utilisant le polynôme de ECMA\-182. C'est la manière +utilisée par défaut, car c'est légèrement mieux que CRC32 pour détecter les +fichiers endommagés et la différence de vitesse est négligeable. +.TP +\fBsha256\fP +Calculer SHA\-256. C'est quelque peu plus lent que CRC32 et CRC64. +.RE +.IP "" +L'intégrité des en\-têtes \fB.xz\fP est toujours vérifiée avec CRC32. Il n'est +pas possible de le changer ou de le désactiver. +.TP +\fB\-\-ignore\-check\fP +Ne pas contrôler la vérification d'intégrité des données lors de la +décompression. Les valeurs CRC32 dans les en\-têtes \fB.xz\fP seront normalement +toujours vérifiées. +.IP "" +\fBN'utilisez pas cette option à moins de savoir ce que vous faites.\fP Les +raisons possibles pour utiliser cette option : +.RS +.IP \(bu 3 +Essayer de récupérer des données d'un fichier .xz corrompu. +.IP \(bu 3 +Accélérer la décompression. Cela importe surtout avec SHA\-256 ou avec les +fichiers qui ont été compressés extrêmement bien. Il est recommandé de ne +pas utiliser cette option dans ce but à moins que l'intégrité du fichier ne +soit vérifiée extérieurement d'une autre manière. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Choisir un niveau de compression prédéfini. La valeur par défaut est +\fB6\fP. Si plusieurs niveaux de préréglage sont spécifiés, c'est le dernier +qui sera pris en compte. Si une chaîne de filtres personnalisée a déjà été +choisie, définir un niveau de compression préréglé efface la chaîne de +filtres personnalisée. +.IP "" +Les différences entre les préréglages sont plus significatives qu'avec +\fBgzip\fP(1) et \fBbzip2\fP(1). les réglages de compression sélectionnés +déterminent les exigences en mémoire pour la décompression, ainsi, utiliser +un niveau de préréglage trop élevé peut rendre difficile à décompresser un +fichier sur un vieux système avec peu de RAM. Clairement, \fBce n'est pas une bonne idée d'utiliser \-9 aveuglément pour tout\fP comme ça l'est souvent avec +\fBgzip\fP(1) et \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Ce sont des préréglages relativement rapides. \fB0\fP est parfois plus rapide +que \fBgzip \-9\fP tout en compressant bien mieux. Les réglages plus élevés ont +souvent une rapidité comparable à celle de \fBbzip2\fP(1) avec un taux de +compression comparable ou meilleur, même si les résultats dépendent beaucoup +du genre de données compressées. +.TP +\fB\-4\fP ... \fB\-6\fP +Good to very good compression while keeping decompressor memory usage +reasonable even for old systems. \fB\-6\fP is the default, which is usually a +good choice for distributing files that need to be decompressible even on +systems with only 16\ MiB RAM. (\fB\-5e\fP or \fB\-6e\fP may be worth considering +too. See \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +C'est comme \fB\-6\fP mais avec des besoins en mémoire plus élevés pour la +compression et la décompression. Ce n'est utile que lorsque les fichiers +sont plus gros que 8\ Mio, 16\ Mio et 32\ Mio respectivement. +.RE +.IP "" +Sur le même matériel, la vitesse de décompression est sensiblement un nombre +constant d'octets de données compressées par seconde. En d'autres termes, +meilleure est la compression, plus rapide sera en général la +décompression. Cela signifie aussi que la quantité de sortie non compressée +produite par seconde peut varier beaucoup. +.IP "" +Le tableau suivant résume les caractéristiques des préréglages : +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Préréglage;DictSize;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Descriptions des colonnes : +.RS +.IP \(bu 3 +DictSize est la taille du dictionnaire de LZMA2. Utiliser un dictionnaire +plus gros que la taille du fichier non compressé est un gaspillage de +mémoire. C'est pourquoi il est bon d'éviter d'utiliser les préréglages de +\fB\-7\fP à \fB\-9\fP lorsqu'il n'y en a pas vraiment besoin. A \fB\-6\fP et plus bas, +la quantité de mémoire gaspillée est généralement assez basse pour ne pas +être un problème. +.IP \(bu 3 +CompCPU est une représentation des préréglages de LZMA2 qui affectent la +vitesse de compression. La taille du dictionnaire aussi affecte la vitesse, +alors comme CompCPU est le même pour les niveaux de \fB\-6\fP à \fB\-9\fP, les plus +haut niveaux tendent à être un peu moins rapides. Pour être encore moins +rapide et du coup obtenir peut être une meilleure compression, consultez +\fB\-\-extreme\fP. +.IP \(bu 3 +CompMem contains the compressor memory requirements in the single\-threaded +mode. It may vary slightly between \fBxz\fP versions. +.IP \(bu 3 +DecMem contient les besoins en mémoire du décompresseur. Ce sont les +réglages de la compression qui déterminent les besoins en mémoire de la +décompression. L'exacte utilisation de la mémoire est légèrement supérieure +à la taille du dictionnaire LZMA2, mais les valeurs dans la table ont été +arrondies au prochain Mio supérieur. +.RE +.IP "" +Memory requirements of the multi\-threaded mode are significantly higher than +that of the single\-threaded mode. With the default value of +\fB\-\-block\-size\fP, each thread needs 3*3*DictSize plus CompMem or DecMem. For +example, four threads with preset \fB\-6\fP needs 660\(en670\ MiB of memory. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Utilisez un variant plus lent que les préréglages (\fB\-0\fP à \fB\-9\fP) pour +espérer avoir un taux de compression légèrement meilleur, mais en cas de +malchance cela peut être pire. L'utilisation mémoire du décompresseur n'est +pas affectée, mais l'utilisation mémoire du compresseur augmente un peu aux +niveaux de préréglages de \fB\-0\fP à \fB\-3\fP. +.IP "" +Depuis qu'il y a deux préréglages avec des tailles de dictionnaire de 4\ Mio +et 8 \Mio, les préréglages \fB\-3e\fP et \fB\-5e\fP utilisent des réglages +légèrement plus rapides que \fB\-4e\fP et \fB\-6e\fP, respectivement. De cette +manière, il n'y a pas deux préréglages identiques. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Préréglage;DictSize;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Par exemple, il y a un total de quatre préréglages qui utilisent un +dictionnaire de 8 Mio et qui sont dans l'ordre du plus rapide au plus lent : +\fB\-5\fP, \fB\-6\fP, \fB\-5e\fP et \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Il y a néanmoins des alias trompeurs pour \fB\-0\fP et \fB\-9\fP, +respectivement. Ils ne sont fournis que pour des besoins de +rétro\-compatibilité avec les utilitaires LZMA. Evitez d'utiliser ces +options. +.TP +\fB\-\-block\-size=\fP\fItaille\fP +Lors de la compression dans le format \fB.xz\fP, les données de l'entrée sont +réparties en blocs de \fItaille\fP octets. Les blocs sont compressés +indépendamment les un des autres, ce qui aide avec le mode multithread +(multi\-threading) et rend possible la décompression à accès aléatoire +limité. Cette option est typiquement utilisée pour outrepasser la taille de +bloc en mode multithread, mais cette option peut aussi être utilisée en mode +single\-thread. +.IP "" +In multi\-threaded mode about three times \fIsize\fP bytes will be allocated in +each thread for buffering input and output. The default \fIsize\fP is three +times the LZMA2 dictionary size or 1 MiB, whichever is more. Typically a +good value is 2\(en4 times the size of the LZMA2 dictionary or at least 1 +MiB. Using \fIsize\fP less than the LZMA2 dictionary size is waste of RAM +because then the LZMA2 dictionary buffer will never get fully used. In +multi\-threaded mode, the sizes of the blocks are stored in the block +headers. This size information is required for multi\-threaded +decompression. +.IP "" +In single\-threaded mode no block splitting is done by default. Setting this +option doesn't affect memory usage. No size information is stored in block +headers, thus files created in single\-threaded mode won't be identical to +files created in multi\-threaded mode. The lack of size information also +means that \fBxz\fP won't be able decompress the files in multi\-threaded mode. +.TP +\fB\-\-block\-list=\fP\fIitems\fP +When compressing to the \fB.xz\fP format, start a new block with an optional +custom filter chain after the given intervals of uncompressed data. +.IP "" +The \fIitems\fP are a comma\-separated list. Each item consists of an optional +filter chain number between 0 and 9 followed by a colon (\fB:\fP) and a +required size of uncompressed data. Omitting an item (two or more +consecutive commas) is a shorthand to use the size and filters of the +previous item. +.IP "" +If the input file is bigger than the sum of the sizes in \fIitems\fP, the last +item is repeated until the end of the file. A special value of \fB0\fP may be +used as the last size to indicate that the rest of the file should be +encoded as a single block. +.IP "" +An alternative filter chain for each block can be specified in combination +with the \fB\-\-filters1=\fP\fIfilters\fP \&...\& \fB\-\-filters9=\fP\fIfilters\fP options. +These options define filter chains with an identifier between 1\(en9. +Filter chain 0 can be used to refer to the default filter chain, which is +the same as not specifying a filter chain. The filter chain identifier can +be used before the uncompressed size, followed by a colon (\fB:\fP). For +example, if one specifies \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP +then blocks will be created using: +.RS +.IP \(bu 3 +The filter chain specified by \fB\-\-filters1\fP and 2 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters3\fP and 2 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters2\fP and 4 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters2\fP and 4 MiB input +.IP \(bu 3 +The default filter chain and 2 MiB input +.IP \(bu 3 +The default filter chain and 4 MiB input for every block until end of input. +.RE +.IP "" +If one specifies a size that exceeds the encoder's block size (either the +default value in threaded mode or the value specified with +\fB\-\-block\-size=\fP\fIsize\fP), the encoder will create additional blocks while +keeping the boundaries specified in \fIitems\fP. For example, if one specifies +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP and the +input file is 80 MiB, one will get 11 blocks: 5, 10, 8, 10, 2, 10, 10, 4, +10, 10, and 1 MiB. +.IP "" +En mode multi\-threadé les tailles de blocs sont stockées dans les en\-têtes +du bloc. Cela ne se fait pas en mode mono\-threadé, la sortie encodée ne sera +donc pas identique à celle faite en mode multi\-threadé. +.TP +\fB\-\-flush\-timeout=\fP\fItemps_d'attente\fP +Lors de la compression, si plus que \fItemps_d'attente\fP millisecondes (un +entier positif) se sont écoulées depuis le précédent vidage et que lire plus +de données bloquerait, toutes les données d'entrée en attente sont vidées de +l'encodeur et mises à disposition dans le flux de sortie. Cela peut être +utile si \fBxz\fP est utilisé pour compresser les données qui sont diffusées +sur un réseau. Des petites valeurs de \fItemps_d'attente\fP rendent les données +disponibles à l'extrémité réceptrice avec un léger retard, mais les grandes +valeurs de \fItemps_d'attente\fP donnent un meilleur taux de compression. +.IP "" +Cette option est désactivée par défaut. Si cette option est indiquée plus +d'une fois, la dernière prend effet. La valeur spéciale de +\fItemps_d'attente\fP de \fB0\fP peut être utilisée pour explicitement désactiver +cette option. +.IP "" +Cette option n'est pas disponible sur les systèmes qui ne sont pas POSIX. +.IP "" +.\" FIXME +\fBCette option est encore expérimentale.\fP Actuellement, \fBxz\fP ne convient +pas pour décompresser le flux en temps réel en raison de la façon dont \fBxz\fP +effectue la mise en mémoire tampon. +.TP +\fB\-\-no\-sync\fP +Do not synchronize the target file and its directory to the storage device +before removing the source file. This can improve performance if +compressing or decompressing many small files. However, if the system +crashes soon after the deletion, it is possible that the target file was not +written to the storage device but the delete operation was. In that case +neither the original source file nor the target file is available. +.IP "" +This option has an effect only when \fBxz\fP is going to remove the source +file. In other cases synchronization is never done. +.IP "" +The synchronization and \fB\-\-no\-sync\fP were added in \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIlimite\fP +Indiquer une limite d'utilisation de la mémoire pour la compression. Si +cette option est indiquée plusieurs fois, c'est la dernière qui est prise en +compte. +.IP "" +If the compression settings exceed the \fIlimit\fP, \fBxz\fP will attempt to +adjust the settings downwards so that the limit is no longer exceeded and +display a notice that automatic adjustment was done. The adjustments are +done in this order: reducing the number of threads, switching to +single\-threaded mode if even one thread in multi\-threaded mode exceeds the +\fIlimit\fP, and finally reducing the LZMA2 dictionary size. +.IP "" +When compressing with \fB\-\-format=raw\fP or if \fB\-\-no\-adjust\fP has been +specified, only the number of threads may be reduced since it can be done +without affecting the compressed output. +.IP "" +If the \fIlimit\fP cannot be met even with the adjustments described above, an +error is displayed and \fBxz\fP will exit with exit status 1. +.IP "" +La \fIlimite\fP peut être indiquée de plusieurs façons : +.RS +.IP \(bu 3 +La \fIlimite\fP peut être une valeur absolue en octets. Utiliser un suffixe +d'entier comme \fBMiB\fP peut être utile. Exemple : +\fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +La \fIlimite\fP peut être indiquée sous forme d'un pourcentage de la mémoire +physique totale (RAM). Cela peut être particulièrement utile quand la +variable d'environnement \fBXZ_DEFAULTS\fP est indiquée dans un script +d'initialisation de l'interpréteur partagé entre différents ordinateurs. De +cette façon la limite est automatiquement plus grande sur les systèmes avec +plus de mémoire. Exemple : \fB\-\-memlimit=70%\fP +.IP \(bu 3 +The \fIlimit\fP can be reset back to its default value by setting it to \fB0\fP. +This is currently equivalent to setting the \fIlimit\fP to \fBmax\fP (no memory +usage limit). +.RE +.IP "" +For 32\-bit \fBxz\fP there is a special case: if the \fIlimit\fP would be over +\fB4020\ MiB\fP, the \fIlimit\fP is set to \fB4020\ MiB\fP. On MIPS32 \fB2000\ MiB\fP +is used instead. (The values \fB0\fP and \fBmax\fP aren't affected by this. A +similar feature doesn't exist for decompression.) This can be helpful when +a 32\-bit executable has access to 4\ GiB address space (2 GiB on MIPS32) +while hopefully doing no harm in other situations. +.IP "" +Voir aussi la section \fButilisation de la mémoire\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIlimite\fP +Régler une limite d'utilisation de la mémoire pour la décompression. Cela a +un effet sur le mode \fB\-\-list\fP. Si l'opération n'est pas possible sans +dépasser la \fIlimite\fP, \fBxz\fP affichera une erreur et la décompression +échouera. Voir \fB\-\-memlimit\-compress=\fP\fIlimite\fP pour les manières possibles +d'indiquer la \fIlimite\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimit\fP +Set a memory usage limit for multi\-threaded decompression. This can only +affect the number of threads; this will never make \fBxz\fP refuse to +decompress a file. If \fIlimit\fP is too low to allow any multi\-threading, the +\fIlimit\fP is ignored and \fBxz\fP will continue in single\-threaded mode. Note +that if also \fB\-\-memlimit\-decompress\fP is used, it will always apply to both +single\-threaded and multi\-threaded modes, and so the effective \fIlimit\fP for +multi\-threading will never be higher than the limit set with +\fB\-\-memlimit\-decompress\fP. +.IP "" +In contrast to the other memory usage limit options, +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimit\fP has a system\-specific default +\fIlimit\fP. \fBxz \-\-info\-memory\fP can be used to see the current value. +.IP "" +This option and its default value exist because without any limit the +threaded decompressor could end up allocating an insane amount of memory +with some input files. If the default \fIlimit\fP is too low on your system, +feel free to increase the \fIlimit\fP but never set it to a value larger than +the amount of usable RAM as with appropriate input files \fBxz\fP will attempt +to use that amount of memory even with a low number of threads. Running out +of memory or swapping will not improve decompression performance. +.IP "" +See \fB\-\-memlimit\-compress=\fP\fIlimit\fP for possible ways to specify the +\fIlimit\fP. Setting \fIlimit\fP to \fB0\fP resets the \fIlimit\fP to the default +system\-specific value. +.TP +\fB\-M\fP \fIlimite\fP, \fB\-\-memlimit=\fP\fIlimite\fP, \fB\-\-memory=\fP\fIlimite\fP +This is equivalent to specifying \fB\-\-memlimit\-compress=\fP\fIlimit\fP +\fB\-\-memlimit\-decompress=\fP\fIlimit\fP \fB\-\-memlimit\-mt\-decompress=\fP\fIlimit\fP. +.TP +\fB\-\-no\-adjust\fP +Display an error and exit if the memory usage limit cannot be met without +adjusting settings that affect the compressed output. That is, this +prevents \fBxz\fP from switching the encoder from multi\-threaded mode to +single\-threaded mode and from reducing the LZMA2 dictionary size. Even when +this option is used the number of threads may be reduced to meet the memory +usage limit as that won't affect the compressed output. +.IP "" +Automatic adjusting is always disabled when creating raw streams +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fIthreads\fP, \fB\-\-threads=\fP\fIthreads\fP +Specify the number of worker threads to use. Setting \fIthreads\fP to a +special value \fB0\fP makes \fBxz\fP use up to as many threads as the processor(s) +on the system support. The actual number of threads can be fewer than +\fIthreads\fP if the input file is not big enough for threading with the given +settings or if using more threads would exceed the memory usage limit. +.IP "" +The single\-threaded and multi\-threaded compressors produce different +output. Single\-threaded compressor will give the smallest file size but +only the output from the multi\-threaded compressor can be decompressed using +multiple threads. Setting \fIthreads\fP to \fB1\fP will use the single\-threaded +mode. Setting \fIthreads\fP to any other value, including \fB0\fP, will use the +multi\-threaded compressor even if the system supports only one hardware +thread. (\fBxz\fP 5.2.x used single\-threaded mode in this situation.) +.IP "" +To use multi\-threaded mode with only one thread, set \fIthreads\fP to \fB+1\fP. +The \fB+\fP prefix has no effect with values other than \fB1\fP. A memory usage +limit can still make \fBxz\fP switch to single\-threaded mode unless +\fB\-\-no\-adjust\fP is used. Support for the \fB+\fP prefix was added in \fBxz\fP +5.4.0. +.IP "" +If an automatic number of threads has been requested and no memory usage +limit has been specified, then a system\-specific default soft limit will be +used to possibly limit the number of threads. It is a soft limit in sense +that it is ignored if the number of threads becomes one, thus a soft limit +will never stop \fBxz\fP from compressing or decompressing. This default soft +limit will not make \fBxz\fP switch from multi\-threaded mode to single\-threaded +mode. The active limits can be seen with \fBxz \-\-info\-memory\fP. +.IP "" +Actuellement, la seule méthode de gestion avec des threads consiste à +séparer l'entrée en blocs et de les compresser indépendamment les uns des +autres. La taille par défaut des blocs dépend du niveau de compression et +peut\-être remplacée avec l'option \fB\-\-block\-size=\fP\fItaille\fP. +.IP "" +Threaded decompression only works on files that contain multiple blocks with +size information in block headers. All large enough files compressed in +multi\-threaded mode meet this condition, but files compressed in +single\-threaded mode don't even if \fB\-\-block\-size=\fP\fIsize\fP has been used. +.IP "" +The default value for \fIthreads\fP is \fB0\fP. In \fBxz\fP 5.4.x and older the +default is \fB1\fP. +. +.SS "Chaînes de filtres de compresseur personnalisées" +A custom filter chain allows specifying the compression settings in detail +instead of relying on the settings associated to the presets. When a custom +filter chain is specified, preset options (\fB\-0\fP \&...\& \fB\-9\fP and +\fB\-\-extreme\fP) earlier on the command line are forgotten. If a preset +option is specified after one or more custom filter chain options, the new +preset takes effect and the custom filter chain options specified earlier +are forgotten. +.PP +Une chaîne de filtre est comparable à une redirection (pipe) sur la ligne de +commande. Lors de la compression, les entrées non compressées vont au +premier filtre, dont la sortie va au prochain filtre (s'il y en a). La +sortie du dernier filtre est écrite sur le fichier compressé. Le nombre +maximal de filtres dans la chaîne est quatre, mais habituellement, un chaîne +de filtre n'a qu'un ou deux filtres. +.PP +Beaucoup de filtres ont des limitations sur l'endroit où ils peuvent se +placer dans la chaîne de filtre : quelques filtres ne peuvent fonctionner +qu'en tant que dernier filtre dans la chaîne, quelques uns en tant que non +dernier filtre, et d'autres à n'importe quelle position dans la +chaîne. Suivant le filtre, cette limitation est soit inhérente au profil du +filtre, soit existe pour des raisons de sécurité. +.PP +A custom filter chain can be specified in two different ways. The options +\fB\-\-filters=\fP\fIfilters\fP and \fB\-\-filters1=\fP\fIfilters\fP \&...\& +\fB\-\-filters9=\fP\fIfilters\fP allow specifying an entire filter chain in one +option using the liblzma filter string syntax. Alternatively, a filter +chain can be specified by using one or more individual filter options in the +order they are wanted in the filter chain. That is, the order of the +individual filter options is significant! When decoding raw streams +(\fB\-\-format=raw\fP), the filter chain must be specified in the same order as +it was specified when compressing. Any individual filter or preset options +specified before the full chain option (\fB\-\-filters=\fP\fIfilters\fP) will be +forgotten. Individual filters specified after the full chain option will +reset the filter chain. +.PP +Both the full and individual filter options take filter\-specific \fIoptions\fP +as a comma\-separated list. Extra commas in \fIoptions\fP are ignored. Every +option has a default value, so specify those you want to change. +.PP +Pour voir l'entièreté de la chaîne de filtres et ses \fIoptions\fP, utilisez +\fBxz \-vv\fP (ce qui est comme utiliser \fB\-\-verbose\fP deux fois). Cela +fonctionne aussi pour voir les options de chaîne de filtres utilisées par +les préréglages. +.TP +\fB\-\-filters=\fP\fIfilters\fP +Specify the full filter chain or a preset in a single option. Each filter +can be separated by spaces or two dashes (\fB\-\-\fP). \fIfilters\fP may need to be +quoted on the shell command line so it is parsed as a single option. To +denote \fIoptions\fP, use \fB:\fP or \fB=\fP. A preset can be prefixed with a \fB\-\fP +and followed with zero or more flags. The only supported flag is \fBe\fP to +apply the same options as \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIfilters\fP ... \fB\-\-filters9\fP=\fIfilters\fP +Specify up to nine additional filter chains that can be used with +\fB\-\-block\-list\fP. +.IP "" +For example, when compressing an archive with executable files followed by +text files, the executable part could use a filter chain with a BCJ filter +and the text part only the LZMA2 filter. +.TP +\fB\-\-filters\-help\fP +Display a help message describing how to specify presets and custom filter +chains in the \fB\-\-filters\fP and \fB\-\-filters1=\fP\fIfilters\fP \&...\& +\fB\-\-filters9=\fP\fIfilters\fP options, and exit successfully. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIoptions\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIoptions\fP] +.PD +Ajouter le filtre LZMA1 ou LZMA2 à la chaîne de filtres. Ces filtres ne +peuvent être utilisés que comme dernier filtre dans la chaîne. +.IP "" +LZMA1 est un filtre historique, qui n'est pris en charge presque uniquement +à cause de l'ancien format de fichier \fB.lzma\fP, qui ne prend en charge que +LZMA1. LZMA2 est une version mise à jour de LZMA1 pour régler certains +problèmes pratiques de LZMA1. Le format \fBxz\fP utilise LZMA2 et ne prend pas +du tout en charge LZMA1. Les taux et vitesses de compression de LZMA1 et +LZMA2 sont pratiquement identiques. +.IP "" +LZMA1 et LZMA2 partagent le même ensemble d'\fIoptions\fP : +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIpréréglage\fP +Reset all LZMA1 or LZMA2 \fIoptions\fP to \fIpreset\fP. \fIPreset\fP consist of an +integer, which may be followed by single\-letter preset modifiers. The +integer can be from \fB0\fP to \fB9\fP, matching the command line options \fB\-0\fP +\&...\& \fB\-9\fP. The only supported modifier is currently \fBe\fP, which matches +\fB\-\-extreme\fP. If no \fBpreset\fP is specified, the default values of LZMA1 or +LZMA2 \fIoptions\fP are taken from the preset \fB6\fP. +.TP +\fBdict=\fP\fItaille\fP +La \fItaille\fP du dictionnaire (historique du tampon) indique combien d'octets +des données récement décompressées sont gardés en mémoire. L'algorithme +essaie de trouver les séquences d'octets répétées (identiques) dans les +données décompressées et les remplace par les données actuellement dans le +dictionnaire. Plus gros est le dictionnaire, plus grande est la chance de +trouver une correspondance. Ainsi, l'augmentation de la \fItaille\fP du +dictionnaire augmente habituellement le taux de compression, mais un +dictionnaire plus gros que le fichier non compressé est un gachis de +mémoire. +.IP "" +Généralement la \fItaille\fP du dictionnaire est entre 64\ Kio et 64\ Mio. Le +minimum étant 4\ Kio. La \fItaille\fP maximale pour la compression est +habituellement 1,5\ Gio (1536\ Mio). Le décompresseur prend en charge les +dictionnaires jusqu'à un octet de moins que 4\ Gio, ce qui est le maximum +pour les formats de flux LZMA1 et LZMA2. +.IP "" +La \fItaille\fP du dictionnaire et le chercheur de correspondance (match +finder) (\fImf\fP) déterminent ensemble l'utilisation de la mémoire de +l'encodeur LZMA1 ou LZMA2. La même (ou une plus grosse) \fItaille\fP de +dictionnaire est requise pour décompresser que ce qui a été utilisé pour la +compression, ainsi l'utilisation de la mémoire du décodeur est déterminée +par la taille du dictionnaire utilisée lors de la compression. Les en\-têtes +de \fB.xz\fP stockent la \fItaille\fP de dictionnaire sous la forme 2^\fIn\fP ou +2^\fIn\fP + 2^(\fIn\fP\-1), de sorte que ces \fItailles\fP sont quelque peu préférées +pour la compression. Les autres \fItailles\fP seront arrondies à la hausse +lorsque stockées dans les en\-têtes de \fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Spécifiez le nombre d'octets de contexte littéraux. Le minimum est \fB0\fP et +le maximum est \fB4\fP. La valeur par défaut est \fB3\fP. En plus, la somme de +\fIlc\fP et \fIlp\fP ne doit pas excéder \fB4\fP. +.IP "" +Tous les octets qui ne peuvent pas être codés comme des correspondances sont +codés comme des littéraux. C'est à dire que les littéraux sont simplement +des octets 8 bits encodés un à la fois. +.IP "" +The literal coding makes an assumption that the highest \fIlc\fP bits of the +previous uncompressed byte correlate with the next byte. For example, in +typical English text, an upper\-case letter is often followed by a lower\-case +letter, and a lower\-case letter is usually followed by another lower\-case +letter. In the US\-ASCII character set, the highest three bits are 010 for +upper\-case letters and 011 for lower\-case letters. When \fIlc\fP is at least +3, the literal coding can take advantage of this property in the +uncompressed data. +.IP "" +The default value (3) is usually good. If you want maximum compression, +test \fBlc=4\fP. Sometimes it helps a little, and sometimes it makes +compression worse. If it makes it worse, test \fBlc=2\fP too. +.TP +\fBlp=\fP\fIlp\fP +Indiquer le nombre de bits de position littérale. Le minimum est \fB0\fP et le +maximum \fB4\fP; par défaut c'est \fB0\fP. +.IP "" +\fILp\fP affecte le type d'alignement dans les données décompressées qui est +présumé lors de l'encodage des littéraux. Voir \fIpb\fP ci dessous pour plus +d'information sur l'alignement. +.TP +\fBpb=\fP\fIpb\fP +Indiquer le nombre de bits de position. Le minimum est \fB0\fP et le maximum +\fB4\fP; par défaut \fB2\fP. +.IP "" +\fIPb\fP affecte quel genre d'alignement est présumé en général dans les +données non compressées. Par défaut c'est un alignement de quatre octets +(2^\fIpb\fP=2^2=4), ce qui est généralement un bon choix lorsqu'il n'y a pas de +meilleure estimation. +.IP "" +When the alignment is known, setting \fIpb\fP accordingly may reduce the file +size a little. For example, with text files having one\-byte alignment +(US\-ASCII, ISO\-8859\-*, UTF\-8), setting \fBpb=0\fP can improve compression +slightly. For UTF\-16 text, \fBpb=1\fP is a good choice. If the alignment is +an odd number like 3 bytes, \fBpb=0\fP might be the best choice. +.IP "" +Même si l'alignement présumé peut être ajusté avec \fIpb\fP et \fIlp\fP, LZMA1 et +LZMA2 favorisent toujours légèrement l'alignement sur 16 octets. Il peut +être utile d'en tenir compte lors de la conception de formats de fichiers +susceptibles d'être souvent compressés avec LZMA1 ou LZMA2. +.TP +\fBmf=\fP\fImf\fP +Match finder has a major effect on encoder speed, memory usage, and +compression ratio. Usually Hash Chain match finders are faster than Binary +Tree match finders. The default depends on the \fIpreset\fP: 0 uses \fBhc3\fP, +1\(en3 use \fBhc4\fP, and the rest use \fBbt4\fP. +.IP "" +Les chercheurs de correspondance suivants sont pris en charge. Les formules +d'utilisation de la mémoire ci\-dessous sont des approximations grossières +qui sont les plus proches de la réalité lorsque \fIdict\fP est une puissance de +deux. +.RS +.TP +\fBhc3\fP +Chaîne de hachage avec hachage de 2 et 3 octets +.br +Valeur minimale pour \fInice\fP : \fB3\fP +.br +Utilisation de la mémoire : +.br +\fIdict\fP * 7.5 (if \fIdict\fP <= 16 Mio); +.br +\fIdict\fP * 5.5 + 64 MiB (si \fIdict\fP > 16 Mio) +.TP +\fBhc4\fP +Chaîne de hachage avec hachage de 2, 3 et 4 octets +.br +Valeur minimale pour \fInice\fP : \fB4\fP +.br +Utilisation de la mémoire : +.br +\fIdict\fP * 7.5 (si \fIdict\fP <= 32 Mio); +.br +\fIdict\fP * 6.5 (si \fIdict\fP > 32 Mio) +.TP +\fBbt2\fP +Arbre binaire avec hachage de 2 octets +.br +Valeur minimale pour \fInice\fP : \fB2\fP +.br +Utilisation de la mémoire : \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Arbre binaire avec hachage de 2 et 3 octets +.br +Valeur minimale pour \fInice\fP : \fB3\fP +.br +Utilisation de la mémoire : +.br +\fIdict\fP * 11.5 (si \fIdict\fP <= 16 Mio); +.br +\fIdict\fP * 9.5 + 64 MiB (si \fIdict\fP > 16 Mio) +.TP +\fBbt4\fP +Arbre binaire avec hachage 2, 3 et 4 octets +.br +Valeur minimale pour \fInice\fP : \fB4\fP +.br +Utilisation de la mémoire : +.br +\fIdict\fP * 11.5 (si \fIdict\fP <= 32 Mio); +.br +\fIdict\fP * 10.5 (si \fIdict\fP > 32 Mio) +.RE +.TP +\fBmode=\fP\fImode\fP +Compression \fImode\fP specifies the method to analyze the data produced by the +match finder. Supported \fImodes\fP are \fBfast\fP and \fBnormal\fP. The default is +\fBfast\fP for \fIpresets\fP 0\(en3 and \fBnormal\fP for \fIpresets\fP 4\(en9. +.IP "" +Habituellement, \fBfast\fP est utilisé avec les chercheurs de correspondance de +chaîne de hachage et \fBnormal\fP avec les chercheurs de correspondance d'arbre +binaire. C'est aussi ce que font les \fIpréréglages\fP. +.TP +\fBnice=\fP\fInice\fP +Spécifier ce qui est considéré comme une bonne longueur pour une +correspondance. Une fois que la correspondance d'au moins \fInice\fP octets est +trouvée, l'algorithme arrête de chercher de meilleures correspondances +possibles. +.IP "" +\fINice\fP can be 2\(en273 bytes. Higher values tend to give better +compression ratio at the expense of speed. The default depends on the +\fIpreset\fP. +.TP +\fBdepth=\fP\fIprofondeur\fP +Spécifier la profondeur de recherche maximale dans l'outil de recherche de +correspondances. La valeur par défaut est \fB0\fP, ce qui fait que le +compresseur détermine une \fIprofondeur\fP raisonnable en fonction de \fImf\fP et +\fInice\fP. +.IP "" +Reasonable \fIdepth\fP for Hash Chains is 4\(en100 and 16\(en1000 for Binary +Trees. Using very high values for \fIdepth\fP can make the encoder extremely +slow with some files. Avoid setting the \fIdepth\fP over 1000 unless you are +prepared to interrupt the compression in case it is taking far too long. +.RE +.IP "" +Lors du décodage des flux bruts (\fB\-\-format=raw\fP), LZMA2 nécessite seulement +la \fItaille\fP du dictionnaire. LZMA1 nécessite aussi \fIlc\fP, \fIlp\fP et \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIoptions\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIoptions\fP] +.PD +Ajouter un filtre branch/call/jump (BCJ) à la chaîne de filtres. Ces filtres +ne peuvent être utilisés que s'ils ne sont pas le dernier filtre de la +chaîne de filtrage. +.IP "" +A BCJ filter converts relative addresses in the machine code to their +absolute counterparts. This doesn't change the size of the data but it +increases redundancy, which can help LZMA2 to produce 0\(en15\ % smaller +\&\fB.xz\fP file. The BCJ filters are always reversible, so using a BCJ filter +for wrong type of data doesn't cause any data loss, although it may make the +compression ratio slightly worse. The BCJ filters are very fast and use an +insignificant amount of memory. +.IP "" +Ces filtres BCJ présentent des problèmes connus liés au taux de +compression : +.RS +.IP \(bu 3 +Some types of files containing executable code (for example, object files, +static libraries, and Linux kernel modules) have the addresses in the +instructions filled with filler values. These BCJ filters will still do the +address conversion, which will make the compression worse with these files. +.IP \(bu 3 +If a BCJ filter is applied on an archive, it is possible that it makes the +compression ratio worse than not using a BCJ filter. For example, if there +are similar or even identical executables then filtering will likely make +the files less similar and thus compression is worse. The contents of +non\-executable files in the same archive can matter too. In practice one +has to try with and without a BCJ filter to see which is better in each +situation. +.RE +.IP "" +Different instruction sets have different alignment: the executable file +must be aligned to a multiple of this value in the input data to make the +filter work. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filtre;Alignement;Notes +x86;1;32 bits ou 64 bits x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096\-byte alignment is best +PowerPC;4;Grand boutiste seulement +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Since the BCJ\-filtered data is usually compressed with LZMA2, the +compression ratio may be improved slightly if the LZMA2 options are set to +match the alignment of the selected BCJ filter. Examples: +.RS +.IP \(bu 3 +IA\-64 filter has 16\-byte alignment so \fBpb=4,lp=4,lc=0\fP is good with LZMA2 +(2^4=16). +.IP \(bu 3 +RISC\-V code has 2\-byte or 4\-byte alignment depending on whether the file +contains 16\-bit compressed instructions (the C extension). When 16\-bit +instructions are used, \fBpb=2,lp=1,lc=3\fP or \fBpb=1,lp=1,lc=3\fP is good. When +16\-bit instructions aren't present, \fBpb=2,lp=2,lc=2\fP is the best. +\fBreadelf \-h\fP can be used to check if "RVC" appears on the "Flags" line. +.IP \(bu 3 +ARM64 is always 4\-byte aligned so \fBpb=2,lp=2,lc=2\fP is the best. +.IP \(bu 3 +The x86 filter is an exception. It's usually good to stick to LZMA2's +defaults (\fBpb=2,lp=0,lc=3\fP) when compressing x86 executables. +.RE +.IP "" +Tous les filtres BCJ prennent en charge les mêmes \fIoptions\fP : +.RS +.TP +\fBstart=\fP\fIdécalage\fP +Spécifier le \fIdécalage\fP de départ qui est utilisé lors de la conversion +entre les adresses relatives et absolues. Le \fIdécalage\fP doit être un +multiple de l'alignement du filtre (voir la table ci\-dessus). Sa valeur par +défaut est zéro. En pratique, cette dernière convient ; indiquer un +\fIdécalage\fP personnalisé est la plupart du temps inutile. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIoptions\fP] +Ajouter le filtre Delta à la chaîne de filtres. Le filtre Delta ne peut être +utilisé que s'il n'est pas le dernier filtre dans la chaîne. +.IP "" +Currently only simple byte\-wise delta calculation is supported. It can be +useful when compressing, for example, uncompressed bitmap images or +uncompressed PCM audio. However, special purpose algorithms may give +significantly better results than Delta + LZMA2. This is true especially +with audio, which compresses faster and better, for example, with +\fBflac\fP(1). +.IP "" +\fIoptions\fP prises en charge : +.RS +.TP +\fBdist=\fP\fIdistance\fP +Specify the \fIdistance\fP of the delta calculation in bytes. \fIdistance\fP must +be 1\(en256. The default is 1. +.IP "" +Par exemple, avec \fBdist=2\fP et une entrée huit octets A1 B1 A2 B3 A3 B5 A4 +B7, la sortie sera A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Autres options" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Supprimer les avertissements et les notifications. Indiquer cela deux fois +supprimera aussi les erreurs. Cette option n'a aucun effet sur le statut de +sortie. Cela dit, même si un avertissement était supprimé, le statut de +sortie indiquant un avertissement sera encore utilisé. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Être bavard. Si l'erreur standard est connectée à un terminal, \fBxz\fP +affichera une barre de progression. Indiquer \fB\-\-verbose\fP deux fois donnera +une sortie encore plus bavarde. +.IP "" +La barre de progression montre l'information suivante : +.RS +.IP \(bu 3 +Le pourcentage de complétion est montré si la taille du fichier en entrée +est connue. Néanmoins, le pourcentage ne peut pas être montré en cas de +redirection. +.IP \(bu 3 +Quantité de données compressées produites (compression) ou consommées +(décompression). +.IP \(bu 3 +Quantité de données non compressées consommées (compression) ou produites +(décompression). +.IP \(bu 3 +Le taux de compression, calculé en divisant la quantité de données +compréssées déjà traitées par la quantité de données décompressées déjà +traitées. +.IP \(bu 3 +Vitesse de compression ou de décompression. Elle correspond à la quantité de +données non compressées consommées (compression) ou produites +(décompression) par seconde. Elle apparait quelques secondes après le début +du traitement du fichier par \fBxz\fP. +.IP \(bu 3 +Temps écoulé dans le format M:SS ou H:MM:SS. +.IP \(bu 3 +Estimated remaining time is shown only when the size of the input file is +known and a couple of seconds have already passed since \fBxz\fP started +processing the file. The time is shown in a less precise format which never +has any colons, for example, 2 min 30 s. +.RE +.IP "" +When standard error is not a terminal, \fB\-\-verbose\fP will make \fBxz\fP print +the filename, compressed size, uncompressed size, compression ratio, and +possibly also the speed and elapsed time on a single line to standard error +after compressing or decompressing the file. The speed and elapsed time are +included only when the operation took at least a few seconds. If the +operation didn't finish, for example, due to user interruption, also the +completion percentage is printed if the size of the input file is known. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Ne pas mettre l'état de sortie à \fB2\fP même si une condition méritant un +avertissement a été détectée. Cette option n'affecte pas le niveau de +verbosité, néanmoins, les deux options \fB\-\-quiet\fP et \fB\-\-no\-warn\fP doivent +être utilisées pour ne pas afficher d'avertissements, ni altérer le statut +de sortie. +.TP +\fB\-\-robot\fP +Afficher les messages dans un format analysable par une machine. Ceci est +destiné à faciliter l'écriture des frontaux qui voudraient utiliser \fBxz\fP +plutôt que liblzma, ce qui pourrait être le cas pour différents scripts. La +sortie avec cette option activée est destinée à rester stable sur les +différentes versions de \fBxz\fP. Consulter le paragraphe \fBROBOT MODE\fP pour +les détails. +.TP +\fB\-\-info\-memory\fP +Display, in human\-readable format, how much physical memory (RAM) and how +many processor threads \fBxz\fP thinks the system has and the memory usage +limits for compression and decompression, and exit successfully. +.TP +\fB\-h\fP, \fB\-\-help\fP +Afficher un message d'aide décrivant les options les plus couramment +utilisées et quitter. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Afficher un message d'aide décrivant toutes les options de \fBxz\fP et quitter. +.TP +\fB\-V\fP, \fB\-\-version\fP +Afficher le numéro de version de \fBxz\fP et de liblzma dans un format lisible +par un humain. Pour obtenir une sortie analysable par la machine, spécifiez +\fB\-\-robot\fP avant \fB\-\-version\fP. +. +.SH "MODE ROBOT" +The robot mode is activated with the \fB\-\-robot\fP option. It makes the output +of \fBxz\fP easier to parse by other programs. Currently \fB\-\-robot\fP is +supported only together with \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, +and \fB\-\-version\fP. It will be supported for compression and decompression in +the future. +. +.SS "Mode liste" +\fBxz \-\-robot \-\-list\fP utilise une sortie séparée par des tabulations. La +première colonne de toutes les lignes possède une chaîne qui indique le type +d'information trouvée sur cette ligne : +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +C'est toujours la première ligne au début de la liste d'un fichier. La +seconde colonne de la ligne est le nom de fichier. +.TP +\fBfile\fP +Cette ligne contient l'information globale sur le fichier \fB.xz\fP. Cette +ligne est toujours écrite après la ligne \fBname\fP. +.TP +\fBstream\fP +Ce type de ligne n'est utilisée que lorsque \fB \-\-verbose\fP a été indiquée. Il +y a autant de lignes \fBstream\fP qu'il y a de flux dans le fichier \fB.xz\fP. +.TP +\fBblock\fP +Ce type de ligne n'est utilisé seulement lorsque \fB\-\-verbose\fP a été +indiquée. Il y a autant de lignes \fBblock\fP qu'il y a de blocs dans le +fichier \fB.xz\fP. Les lignes \fBblock\fP sont affichées après toutes les lignes +\fBstream\fP ; les différents types de lignes ne sont pas imbriqués. +.TP +\fBsummary\fP +Ce type de ligne n'est utilisé que lorsque \fB\-\-verbose\fP a été indiqué deux +fois. Cette ligne est affichée après toutes les lignes \fBblock\fP. Comme la +ligne \fBfile\fP, la ligne \fBsummary\fP contient l'information globale sur le +fichier \fB.xz\fP. +.TP +\fBtotals\fP +Cette ligne est toujours la toute dernière ligne de la sortie. Elle affiche +les comptes et les tailles totaux. +.PP +Les colonnes des lignes \fBfile\fP : +.PD 0 +.RS +.IP 2. 4 +Nombre de flux dans le fichier +.IP 3. 4 +Nombre total de blocs dans le ou les flux. +.IP 4. 4 +Taille compressée du fichier +.IP 5. 4 +Taille décompressée du fichier +.IP 6. 4 +Compression ratio, for example, \fB0.123\fP. If ratio is over 9.999, three +dashes (\fB\-\-\-\fP) are displayed instead of the ratio. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Liste de noms de contrôles d'intégrité séparés par des virgules. Les chaînes +suivantes sont utilisées pour les types de vérification connus : \fBNone\fP, +\fBCRC32\fP, \fBCRC64\fP et \fBSHA256\fP. Pour le types de vérification inconnus, +\fBUnknown\-\fP\fIN\fP est utilisé, où \fIN\fP est un identifiant de vérification sous +la forme d'un nombre décimal (un ou deux chiffres). +.IP 8. 4 +Taille totale du remplissage du flux dans le fichier +.RE +.PD +.PP +Les colonnes des lignes \fBstream\fP : +.PD 0 +.RS +.IP 2. 4 +Numéro de flux (le premier flux a le numéro 1) +.IP 3. 4 +Nombre de blocs dans le flux +.IP 4. 4 +Décalage de départ compressé +.IP 5. 4 +Décalage de départ décompressé +.IP 6. 4 +Taille compressée (ne comprend pas le remplissage du flux) +.IP 7. 4 +Taille décompressée +.IP 8. 4 +Taux de compression +.IP 9. 4 +Nom de la vérification d'intégrité +.IP 10. 4 +Taille du remplissage de flux +.RE +.PD +.PP +Les colonnes des lignes \fBblock\fP : +.PD 0 +.RS +.IP 2. 4 +Numéro du flux qui contient ce bloc +.IP 3. 4 +Numéro du bloc relatif au commencement du flux (le premier bloc a pour +numéro 1) +.IP 4. 4 +Numéro du bloc relatif au début du fichier +.IP 5. 4 +Décalage de départ compressé relatif au début du fichier +.IP 6. 4 +Décalage de départ décompressé relatif au début du fichier +.IP 7. 4 +Taille compressée totale du bloc (en\-têtes inclus) +.IP 8. 4 +Taille décompressée +.IP 9. 4 +Taux de compression +.IP 10. 4 +Nom de la vérification d'intégrité +.RE +.PD +.PP +Si \fB\-\-verbose\fP a été indiqué deux fois, les colonnes additionnelles sont +inclues sur les lignes \fBblock\fP. Elles ne sont pas affichées avec un seul +\fB\-\-verbose\fP, car l'obtention de ces informations nécessite de nombreuses +recherches et peut donc être lente : +.PD 0 +.RS +.IP 11. 4 +Valeur de la vérification d'intégrité en hexadécimal +.IP 12. 4 +Taille d'en\-tête de bloc +.IP 13. 4 +Drapeaux du bloc : \fBc\fP indique que la taille compressée est présente, et +\fBu\fP indique que la taille décompréssée est présente. Si le drapeau n'est +pas indiqué, un tiret (\fB\-\fP) est affiché à la place pour que la longueur de +la chaîne reste fixe. De nouveaux drapeaux pourraient être ajoutés à la fin +de la chaîne dans le futur. +.IP 14. 4 +Taille des données effectivement compressées dans le bloc (en excluant +l'en\-tête de bloc, le remplissage de bloc et les champs de vérification). +.IP 15. 4 +Quantité de mémoire (en octets) nécessaire pour décompresser ce bloc avec +cette version de \fBxz\fP. +.IP 16. 4 +Chaîne de filtrage. Remarquez que la plupart des options utilisées au moment +de la compression ne peuvent pas être connues, car seules les options +nécessaires pour la décompression sont stockées dans les en\-têtes \fB.xz\fP. +.RE +.PD +.PP +Les colonnes des lignes \fBsummary\fP : +.PD 0 +.RS +.IP 2. 4 +Quantité de mémoire (en octets) nécessaire pour décompresser ce fichier avec +cette version de \fBxz\fP. +.IP 3. 4 +\fByes\fP ou \fBno\fP indique si tous les en\-têtes de bloc stockent à la fois la +taille compressée et la taille décompressée. +.PP +\fIDepuis\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Version minimale de \fBxz\fP nécessaire pour décompresser le fichier. +.RE +.PD +.PP +Les colonnes de la ligne \fBtotals\fP : +.PD 0 +.RS +.IP 2. 4 +Nombre de flux +.IP 3. 4 +Nombre de blocs +.IP 4. 4 +Taille compressée +.IP 5. 4 +Taille décompressée +.IP 6. 4 +Taux de compression moyen +.IP 7. 4 +Liste séparée par des virgules des noms de vérification d'intégrité qui +étaient présents dans les fichiers +.IP 8. 4 +Taille de remplissage de flux +.IP 9. 4 +Nombre de fichiers. Permet de garder l'ordre des colonnes précédentes comme +sur les lignes \fBfile\fP. +.PD +.RE +.PP +Si \fB\-\-verbose\fP a été indiqué deux fois, des colonnes supplémentaires sont +incluses sur la ligne \fBtotals\fP : +.PD 0 +.RS +.IP 10. 4 +Quantité maximale de mémoire (en octets) nécessaire pour décompresser les +fichiers avec cette version de \fBxz\fP. +.IP 11. 4 +\fByes\fP ou \fBno\fP indique si tous les en\-têtes de bloc stockent à la fois la +taille compressée et la taille décompressée. +.PP +\fIDepuis\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Version minimale de \fBxz\fP nécessaire pour décompresser le fichier. +.RE +.PD +.PP +Les versions futures pourront ajouter de nouveaux types de lignes et de +nouvelles colonnes pourront être ajoutées aux types de lignes existants, +mais les colonnes existantes ne seront pas modifiées. +. +.SS "Filters help" +\fBxz \-\-robot \-\-filters\-help\fP prints the supported filters in the following +format: +.PP +\fIfilter\fP\fB:\fP\fIoption\fP\fB=<\fP\fIvalue\fP\fB>,\fP\fIoption\fP\fB=<\fP\fIvalue\fP\fB>\fP... +.TP +\fIfilter\fP +Name of the filter +.TP +\fIoption\fP +Name of a filter specific option +.TP +\fIvalue\fP +Numeric \fIvalue\fP ranges appear as \fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. String +\fIvalue\fP choices are shown within \fB< >\fP and separated by a \fB|\fP +character. +.PP +Each filter is printed on its own line. +. +.SS "Information de limite de mémoire" +\fBxz \-\-robot \-\-info\-memory\fP prints a single line with multiple tab\-separated +columns: +.IP 1. 4 +Total amount of physical memory (RAM) in bytes. +.IP 2. 4 +Memory usage limit for compression in bytes (\fB\-\-memlimit\-compress\fP). A +special value of \fB0\fP indicates the default setting which for +single\-threaded mode is the same as no limit. +.IP 3. 4 +Memory usage limit for decompression in bytes (\fB\-\-memlimit\-decompress\fP). A +special value of \fB0\fP indicates the default setting which for +single\-threaded mode is the same as no limit. +.IP 4. 4 +Since \fBxz\fP 5.3.4alpha: Memory usage for multi\-threaded decompression in +bytes (\fB\-\-memlimit\-mt\-decompress\fP). This is never zero because a +system\-specific default value shown in the column 5 is used if no limit has +been specified explicitly. This is also never greater than the value in the +column 3 even if a larger value has been specified with +\fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Since \fBxz\fP 5.3.4alpha: A system\-specific default memory usage limit that is +used to limit the number of threads when compressing with an automatic +number of threads (\fB\-\-threads=0\fP) and no memory usage limit has been +specified (\fB\-\-memlimit\-compress\fP). This is also used as the default value +for \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Since \fBxz\fP 5.3.4alpha: Number of available processor threads. +.PP +Dans le futur, la sortie de \fBxz \-\-robot \-\-info\-memory\fP pourrait avoir plus +de colonnes, mais jamais plus qu'une ligne unique. +. +.SS Version +\fBxz \-\-robot \-\-version\fP prints the version number of \fBxz\fP and liblzma in +the following format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Version majeure. +.TP +\fIYYY\fP +Version mineure. Les numéros pairs sont stables. Les numéros impairs sont +des versions alpha ou beta. +.TP +\fIZZZ\fP +Niveau de correctif pour les options stables ou juste un compteur pour les +options de développement. +.TP +\fIS\fP +Stabilité. 0 est alpha, 1 est bêta et 2 est stable. \fIS\fP devrait toujours +être 2 quand \fIYYY\fP est pair. +.PP +\fIXYYYZZZS\fP sont identiques sur les deux lignes si \fBxz\fP et liblzma sont +issus de la même version d'utilitaires XZ. +.PP +Exemples : 4.999.9beta est \fB49990091\fP et 5.0.0 est \fB50000002\fP. +. +.SH "STATUT DE SORTIE" +.TP +\fB0\fP +Tout est bon. +.TP +\fB1\fP +Une erreur est survenue. +.TP +\fB2\fP +Quelquechose méritant un avertissement s'est produit, mais aucune erreur +véritable n'est survenue. +.PP +Les notifications (pas les avertissements ou les erreurs) affichées sur +l'erreur standard n'affectent pas le statut de sortie. +. +.SH ENVIRONNEMENT +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP analyse les listes d'options séparées par des espaces à partir des +variables d'environnement \fBXZ_DEFAULTS\fP et \fBXZ_OPT\fP, dans cet ordre, avant +d'analyser les options de la ligne de commandes. Remarquez que seules les +options sont analysées depuis l'environnement des variables ; toutes les +non\-options sont ignorées silencieusement. L'analyse est faite avec +\fBgetopt_long\fP(3) qui est aussi utilisé pour les arguments de la ligne de +commandes. +.PP +\fBWarning:\fP By setting these environment variables, one is effectively +modifying programs and scripts that run \fBxz\fP. Most of the time it is safe +to set memory usage limits, number of threads, and compression options via +the environment variables. However, some options can break scripts. An +obvious example is \fB\-\-help\fP which makes \fBxz\fP show the help text instead of +compressing or decompressing a file. More subtle examples are \fB\-\-quiet\fP +and \fB\-\-verbose\fP. In many cases it works well to enable the progress +indicator using \fB\-\-verbose\fP, but in some situations the extra messages +create problems. The verbosity level also affects the behavior of +\fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +User\-specific or system\-wide default options. Typically this is set in a +shell initialization script to enable \fBxz\fP's memory usage limiter by +default or set the default number of threads. Excluding shell +initialization scripts and similar special cases, scripts should never set +or unset \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +This is for passing options to \fBxz\fP when it is not possible to set the +options directly on the \fBxz\fP command line. This is the case when \fBxz\fP is +run by a script or tool, for example, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Scripts may use \fBXZ_OPT\fP, for example, to set script\-specific default +compression options. It is still recommended to allow users to override +\fBXZ_OPT\fP if that is reasonable. For example, in \fBsh\fP(1) scripts one may +use something like this: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "Compatibilité des utilitaires LZMA" +La syntaxe de la ligne de commande de \fBxz\fP est quasimment un sur\-ensemble +de \fBlzma\fP, \fBunlzma\fP et \fBlzcat\fP comme ils sont trouvés dans les +utilitaires LZMA 4.32.x . Dans la pluspart des cas, il est possible de +remplacer les outils LZMA par les outils XZ sans casser les scripts +existants. Il existe cependant certaines incompatibilités qui peuvent +parfois poser des problèmes. +. +.SS "Niveaux de préréglage de la compression" +La numérotation des préréglages de niveau de compression est différente +entre les outils \fBxz\fP et LZMA. La différence la plus importante est la +manière dont les tailles de dictionnaire sont affectées aux différents +préréglages. La taille de dictionnaire est à peu près égale à celle +d'utilisation de la mémoire de la décompression. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Niveau;xz;Utilitaires LZMA +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Les différences de tailles des dictionnaires affectent aussi l'utilisation +de la mémoire du compresseur, mais il y a quelques autres différences entre +les outils LZMA et les outils XZ, qui rendent la différence encore plus +grande : +.RS +.PP +.TS +tab(;); +c c c +c n n. +Niveau;xz;Utilitaires LZMA 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Le niveau de préréglage par défaut dans les outils LZMA est \fB\-7\fP alors que +pour les outils XZ c'est \fB\-6\fP, les deux utilisent ainsi un dictionnaire de +8 Mio par défaut. +. +.SS "Fichiers .lzma en flux ou non" +The uncompressed size of the file can be stored in the \fB.lzma\fP header. +LZMA Utils does that when compressing regular files. The alternative is to +mark that uncompressed size is unknown and use end\-of\-payload marker to +indicate where the decompressor should stop. LZMA Utils uses this method +when uncompressed size isn't known, which is the case, for example, in +pipes. +.PP +\fBxz\fP prend en charge la décompression des fichiers \fB.lzma\fP avec ou sans +marqueur de fin de charge utile, mais tous les fichiers \fB.lzma\fP créés par +\fBxz\fP utiliseront un marqueur de fin de charge utile et ont la taille non +compréssée marquée comme inconnue dans l'en\-tête \fB.lzma\fP. Cela peut être un +problème dans quelques situations inhabituelles. Par exemple, un +décompresseur \fB.lzma\fP dans un périphérique embarqué pourrait ne fonctionner +qu'avec des fichiers dont la taille non comprimée est connue. Si vous vous +heurtez à ce problème, vous devez utiliser les utilitaires LZMA ou LZMA SDK +pour créer des fichiers \fB.lzma\fP avec une taille non compressée connue. +. +.SS "Fichiers .lzma non pris en charge" +Le format \fB.lzma\fP autorise des valeurs \fIlc\fP jusqu'à 8, et des valeurs +\fIlp\fP jusqu'à 4. Les outils LZMA peuvent décompresser des fichiers avec tous +les \fIlc\fP et \fIlp\fP, mais créez toujours les fichiers avec \fBlc=3\fP et +\fBlp=0\fP. Créer des fichiers avec d'autres valeurs \fIlc\fP et \fIlp\fP est +possible avec \fBxz\fP et avec LZMA SDK. +.PP +L'implémentation du filtre LZMA1 dans liblzma nécessite que la somme de +\fIlc\fP et \fIlp\fP soit inférieure ou égale à 4. Ainsi, les fichiers \fB.lzma\fP +qui excèdent cette limitation ne peuvent pas être décompressés avec \fBxz\fP. +.PP +Les outils LZMA créent seulement des fichiers \fB.lzma\fP qui ont une taille de +dictionnaire de 2^\fIn\fP (une puissance de 2) mais acceptent les fichiers avec +toutes les tailles de dictionnaire. Libzlma n'accepte que les fichiers +\&\fB.lzma\fP qui ont une taille dictionnaire de 2^\fIn\fP ou +2^\fIn\fP + 2^(\fIn\fP\-1). Cela afin de diminuer les faux positifs lors de la +détection des fichiers \fB.lzma\fP. +.PP +Ces limitations ne devraient pas poser problème en pratique, car +pratiquement tous les fichiers \fB.lzma\fP ont été compressés avec des réglages +que liblzma accepte. +. +.SS "Déchets excédentaires" +Lors de la décompession, l'utilitaire LZMA ignore silencieusement tout ce +qui est après le premier flux \fB.lzma\fP. Dans la majorité des situations, +c'est un bogue. Cela veut dire aussi que les outils LZMA ne gèrent pas la +décompression de fichiers \fB.lzma\fP concaténés. +.PP +S'il reste des données après le premier flux \fB.lzma\fP, \fBxz\fP considère que +le fichier est corrompu sauf si \fB\-\-single\-stream\fP a été utilisé. Cela peut +casser des scripts obscurs qui ont supposé que les déchets de fin de ligne +sont ignorés. +. +.SH NOTES +. +.SS "La sortie compressée peut varier" +La sortie compressée exacte produite par les même fichiers non compressés en +entrée peut varier en fonction des différentes versions de l'utilitaire XZ, +même si les options de compression sont identiques. En effet, il est +possible d'améliorer l'encodeur (compression plus rapide ou meilleure) sans +affecter le format du fichier. La sortie peut même varier entre différentes +compilations de la même version d'utilitaire XZ, si des options de +construction différentes sont utilisées. +.PP +Cela signifie qu'une fois que \fB\-\-rsyncable\fP a été implémenté, les fichiers +résultants ne seront pas nécessairement synchronisables avec rsync à moins +que les nouveaux et anciens fichiers n'aient été compressés avec la même +version de xz. Ce problème peut être résolu si une partie de +l'implémentation est gelée pour garantir la stabilité de la sortie rsyncable +à travers les versions de xz. +. +.SS "Décompresseurs .xz embarqués" +Les implémentations de décompresseur embarqué comme XZ Embedded ne gèrent +pas nécessairement les fichiers créés avec d'autres types de \fIvérification\fP +d'intégrité que \fBnone\fP et \fBCRC32\fP. Comme la valeur par défaut est +\fB\-\-check=crc64\fP, vous devez utiliser \fB\-\-check=none\fP ou \fB\-\-check=crc32\fP +lors de la création de fichiers pour les systèmes embarqués. +.PP +En dehors des systèmes embarqués, tous les décompresseurs de format \fB.xz\fP +gèrent tous les types de \fIvérification\fP ou sont au moins capables de +décompresser le fichier sans effectuer la vérification d'intégrité si ce +type de \fIvérification\fP particulière n'est pas pris en charge. +.PP +XZ Embedded prend en charge les filtres BCJ, mais seulement avec le décalage +de départ par défaut. +. +.SH EXEMPLES +. +.SS Bases +Compresser le fichier \fItoto\fP en \fItoto.xz\fP en utilisant le niveau de +compression par défaut (\fB\-6\fP) et supprimer \fItoto\fP si la compression +réussit : +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Décompresser \fIbidule.xz\fP en \fIbidule\fP et ne pas supprimer \fIbidule.xz\fP même +si la compression réussit : +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Create \fIbaz.tar.xz\fP with the preset \fB\-4e\fP (\fB\-4 \-\-extreme\fP), which is +slower than the default \fB\-6\fP, but needs less memory for compression and +decompression (48\ MiB and 5\ MiB, respectively): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Un mélange de fichiers compressés et non compressés peuvent être +décompressés vers la sortie standard avec une simple commande : +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Compression en parallèle de plusieurs fichiers" +Sur GNU et *BSD, \fBfind\fP(1) et \fBxargs\fP(1) peuvent être utilisés pour mettre +en parallèle la compression de plusieurs fichiers : +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +L'option \fBP\fP passée à \fBxargs\fP(1) fixe le nombre de processus \fBxz\fP en +parallèles. La meilleure valeur pour l'option \fBn\fP dépend du nombre de +fichiers à compresser. S\-il n'y a que quelques fichiers, la valeur sera +probablement 1 ; avec des dizaines de milliers de fichiers, 100 ou même plus +serait approprié pour réduire le nombre de processus \fBxz\fP que \fBxargs\fP(1) +créera éventuellement. +.PP +L'option \fB\-T1\fP de \fBxz\fP est là pour le forcer en mode mono\-thread, car +\fBxargs\fP(1) est utilisé pour contrôler la quantité de mise en parallèle. +. +.SS "Mode robot" +Calculer combien d'octets ont été économisés au total après avoir compressé +plusieurs fichiers : +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Un script peut vouloir savoir qu'il utilise une version suffisamment récente +de \fBxz\fP. Le script \fBsh\fP(1) suivant vérifie que le numéro de version de +l'outil \fBxz\fP soit au minimum 5.0.0. Cette méthode est compatible avec les +vieilles versions bêta, qui ne gèrent pas l'option \fB\-\-robot\fP : +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Régler une limite d'utilisation de la mémoire pour la décompression en +utilisant \fBXZ_OPT\fP, mais si une limite a déjà été définie, ne pas +l'augmenter : +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Chaînes de filtres de compresseur personnalisées" +L'utilisation la plus simple des chaînes de filtres personnalisées est la +personnalisation d'un préréglage LZMA2. Cela peut être utile, car les +préréglages ne couvrent qu'un sous\-ensemble des réglages de compression +potentiellement utiles. +.PP +Les colonnes CompCPU des tableaux des descriptions des options \fB\-0\fP à \fB\-9\fP +et \fB\-\-extreme\fP sont utiles lors de la personnalisation des préréglages +LZMA2. Voici les parties pertinentes recueillies à partir de ces deux +tableaux : +.RS +.PP +.TS +tab(;); +c c +n n. +Préréglage;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +If you know that a file requires somewhat big dictionary (for example, 32\ MiB) to compress well, but you want to compress it quicker than \fBxz \-8\fP +would do, a preset with a low CompCPU value (for example, 1) can be +modified to use a bigger dictionary: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Avec certains fichiers, la commande ci\-dessus peut être plus rapide que +\fBxz\-6\fP tout en compressant bien mieux. Cependant, il faut souligner que +seuls certains fichiers bénéficient d'un grand dictionnaire tout en gardant +la valeur de CompCPU faible. La siutation la plus évidente où un gros +dictionnaire peut baucoup aider, est une archive contenant des fichiers très +similaires de quelques megaoctets chacun. La taille de dictionnaire doit +être significativement plus grosse que tout fichier individuel pour +permettre à LZMA2 de tirer pleinement partie des similarités entre des +fichiers consécutifs. +.PP +Si une utilisation de la mémoire élevée pour la compression et décompression +convient, et que le fichier à compresser a une taille de plusieurs centaines +de megaoctets, il peut être utile d'utiliser un plus gros dictionnaire que +celui fourni par \fBxz\-9\fP (64 Mio) : +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Utiliser \fB\-vv\fP (\fB\-\-verbose\-\-verbose\fP) comme dans l'exemple ci\-dessus peut +être utile pour voir les besoins en mémoire du compresseur et du +décompresseur. Rappelez\-vous qu'utiliser un dictionnaire plus gros que la +taille du fichier non compressé est un gachis de mémoire, donc la commande +ci\-dessus n'est pas utile pour les petits fichiers. +.PP +Sometimes the compression time doesn't matter, but the decompressor memory +usage has to be kept low, for example, to make it possible to decompress the +file on an embedded system. The following command uses \fB\-6e\fP (\fB\-6 \-\-extreme\fP) as a base and sets the dictionary to only 64\ KiB. The +resulting file can be decompressed with XZ Embedded (that's why there is +\fB\-\-check=crc32\fP) using about 100\ KiB of memory. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +If you want to squeeze out as many bytes as possible, adjusting the number +of literal context bits (\fIlc\fP) and number of position bits (\fIpb\fP) can +sometimes help. Adjusting the number of literal position bits (\fIlp\fP) +might help too, but usually \fIlc\fP and \fIpb\fP are more important. For +example, a source code archive contains mostly US\-ASCII text, so something +like the following might give slightly (like 0.1\ %) smaller file than \fBxz \-6e\fP (try also without \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Using another filter together with LZMA2 can improve compression with +certain file types. For example, to compress a x86\-32 or x86\-64 shared +library using the x86 BCJ filter: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Notez que l'ordre des options de filtre est significatif. Si \fB\-\-x86\fP est +indiqué après \fB\-\-lzma2\fP, \fBxz\fP donnera une erreur, car il ne peut y avoir +aucun filtre après LZMA2, et aussi parce que le filtre BCJ x86 ne peut pas +être utilisé comme dernier filtre dans la chaîne. +.PP +Le filtre Delta associé à LZMA2 peut donner de bons résultats avec les +images bitmap. Cela devrait habituellement battre PNG, qui a quelques +filtres avancés supplémentaires qu'un simple delta, mais qui utilise Deflate +pour la compression effective. +.PP +The image has to be saved in uncompressed format, for example, as +uncompressed TIFF. The distance parameter of the Delta filter is set to +match the number of bytes per pixel in the image. For example, 24\-bit RGB +bitmap needs \fBdist=3\fP, and it is also good to pass \fBpb=0\fP to LZMA2 to +accommodate the three\-byte alignment: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +If multiple images have been put into a single archive (for example, +\&\fB.tar\fP), the Delta filter will work on that too as long as all images have +the same number of bytes per pixel. +. +.SH "VOIR AUSSI" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/xzcat.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/xzcat.1 new file mode 100644 index 0000000000000000000000000000000000000000..297dc7c0d91cc84d9990f8e22984ef3e7be54f5b --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/xzcat.1 @@ -0,0 +1,2027 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" french translation of XZ Utils man +.\" Copyright (C) 2021 Debian French l10n team +.\" Translator +.\" bubu , 2021. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 2025\-03\-08 Tukaani "Utilitaires XZ" +. +.SH NOM +xz, unxz, xzcat, lzma, unlzma, lzcat \- Compresser ou décompresser des +fichiers .xz et .lzma +. +.SH SYNOPSIS +\fBxz\fP [\fIoption...\fP] [\fIfichier...\fP] +. +.SH "ALIAS DES COMMANDES" +\fBunxz\fP est équivalent à \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP est équivalent à \fBxz \-\-decompress \-\-stdout\fP +.br +\fBlzma\fP est équivalent à \fBxz \-\-format=lzma\fP +.br +\fBunlzma\fP est équivalent à \fBxz \-\-format=lzma \-\-decompress\fP +.br +\fBlzcat\fP est équivalent à \fBxz \-\-format=lzma \-\-decompress \-\- stdout\fP +.PP +Lors de l'écriture de scripts qui nécessitent de décompresser des fichiers, +il est recommandé de toujours utiliser la commande \fBxz\fP avec les arguments +appropriés (\fBxz \-d\fP ou \fBxz \-dc\fP) au lieu des commandes \fBunxz\fP et +\fBxzcat\fP. +. +.SH DESCRIPTION +\fBxz\fP is a general\-purpose data compression tool with command line syntax +similar to \fBgzip\fP(1) and \fBbzip2\fP(1). The native file format is the +\&\fB.xz\fP format, but the legacy \fB.lzma\fP format used by LZMA Utils and raw +compressed streams with no container format headers are also supported. In +addition, decompression of the \fB.lz\fP format used by \fBlzip\fP is supported. +.PP +\fBxz\fP compresse ou décompresse chaque \fIfichier\fP en fonction du mode +d'opération choisi. Si aucun \fIfichier\fP n'est donné ou \fIfichier\fP est \fB\-\fP, +\fBxz\fP lit depuis l'entrée standard et écrit les données traitées sur la +sortie standard. \fBxz\fP refusera (affichera une erreur et ignorera le +\fIfichier\fP) d'écrire les données compressées sur la sortie standard si c'est +un terminal. De même, \fBxz\fP refusera de lire des données compressées depuis +l'entrée standard si c'est un terminal. +.PP +A moins que \fB\-\-sdout\fP ne soit indiqué, les \fIfichiers\fP autres que \fB\-\fP sont +écrits dans un nouveau fichier dont le nom est dérivé du nom de \fIfichier\fP +source : +.IP \(bu 3 +Lors de la compression, le suffixe du format de fichier cible (\fB.xz\fP ou +\&\fB.lzma\fP) est ajouté au nom de fichier source pour obtenir le nom de fichier +cible. +.IP \(bu 3 +When decompressing, the \fB.xz\fP, \fB.lzma\fP, or \fB.lz\fP suffix is removed from +the filename to get the target filename. \fBxz\fP also recognizes the suffixes +\&\fB.txz\fP and \fB.tlz\fP, and replaces them with the \fB.tar\fP suffix. +.PP +Si le fichier cible existe déjà, une erreur est affichée et le \fIfichier\fP +est ignoré. +.PP +Sauf s'il écrit dans la sortie standard, \fBxz\fP affichera un avertissement et +ignorera le \fIfichier\fP dans les cas suivants : +.IP \(bu 3 +\fIfichier\fP n'est pas un fichier normal. Les liens symboliques ne sont pas +suivis et donc ne sont pas considérés comme des fichiers normaux. +.IP \(bu 3 +\fIfichier\fP a plusieurs liens physiques. +.IP \(bu 3 +\fIfichier\fP a un setuid, setgid ou sticky bit positionné. +.IP \(bu 3 +Le mode d'opération est défini pour compresser et le \fIfichier\fP a déjà un +suffixe du format de fichier cible (\fB.xz\fP ou \fB.txz\fP lors d'une compression +en format \fB.xz\fP, et \fB.lzma\fP ou \fB.tlz\fP lors d'une compression en format +\&\fB.lzma\fP). +.IP \(bu 3 +The operation mode is set to decompress and the \fIfile\fP doesn't have a +suffix of any of the supported file formats (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, +\&\fB.tlz\fP, or \fB.lz\fP). +.PP +Après la compression ou la décompression réussie du \fIfichier\fP, \fBxz\fP copie +les permissions du propriétaire, du groupe, la date d'accès, et les +modifications d'heure depuis le \fIfichier\fP source du fichier cible. Si la +copie du groupe échoue, les permissions sont modifiées pour que le fichier +cible ne soit pas accessible aux utilisateurs qui n'ont pas les droits +d'accès au \fIfichier\fP source. \fBxz\fP ne prend actuellement pas en charge la +copie d'autres métadonnées telles que les listes de contrôle d'accès ou les +attributs étendus. +.PP +Once the target file has been successfully closed, the source \fIfile\fP is +removed unless \fB\-\-keep\fP was specified. The source \fIfile\fP is never removed +if the output is written to standard output or if an error occurs. +.PP +Envoyer \fBSIGINFO\fP ou \fBSIGURSR1\fP au processus \fBxz\fP, lui fait afficher +l'information de progression sur l'erreur standard. Cela a un intérêt limité +car lorsque l'erreur standard est un terminal, utiliser \fB\-\-verbose\fP +affichera automatiquement un indicateur de progression du processus. +. +.SS "Utilisation de la mémoire" +L'utilisation de la mémoire par \fBxz\fP varie de quelques centaines de +kilo\-octets à plusieurs gigaoctects en fonction des paramètres de +compression. Les réglages utilisés lors de la compression d'un fichier +déterminent les besoins en mémoire pour la décompression. Habituellement la +décompression nécessite 5\% à 20\% de la quantité de mémoire utilisée pour +la compression du fichier. Par exemple, décompresser un fichier créé avec +\fBxz\-9\fP recquiert habituellement 65\ Mio de mémoire. Bien qu'il soit +possible d'avoir des fichiers \fB.xz\fP nécessitant plusieurs gigaoctets de +mémoire pour être décompressés. +.PP +Especially users of older systems may find the possibility of very large +memory usage annoying. To prevent uncomfortable surprises, \fBxz\fP has a +built\-in memory usage limiter, which is disabled by default. While some +operating systems provide ways to limit the memory usage of processes, +relying on it wasn't deemed to be flexible enough (for example, using +\fBulimit\fP(1) to limit virtual memory tends to cripple \fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +The memory usage limiter can be enabled with the command line option +\fB\-\-memlimit=\fP\fIlimit\fP. Often it is more convenient to enable the limiter +by default by setting the environment variable \fBXZ_DEFAULTS\fP, for example, +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. It is possible to set the limits +separately for compression and decompression by using +\fB\-\-memlimit\-compress=\fP\fIlimit\fP and \fB\-\-memlimit\-decompress=\fP\fIlimit\fP. +Using these two options outside \fBXZ_DEFAULTS\fP is rarely useful because a +single run of \fBxz\fP cannot do both compression and decompression and +\fB\-\-memlimit=\fP\fIlimit\fP (or \fB\-M\fP \fIlimit\fP) is shorter to type on the +command line. +.PP +If the specified memory usage limit is exceeded when decompressing, \fBxz\fP +will display an error and decompressing the file will fail. If the limit is +exceeded when compressing, \fBxz\fP will try to scale the settings down so that +the limit is no longer exceeded (except when using \fB\-\-format=raw\fP or +\fB\-\-no\-adjust\fP). This way the operation won't fail unless the limit is very +small. The scaling of the settings is done in steps that don't match the +compression level presets, for example, if the limit is only slightly less +than the amount required for \fBxz \-9\fP, the settings will be scaled down only +a little, not all the way down to \fBxz \-8\fP. +. +.SS "Concaténation et remplissage avec des fichiers .xz" +Il est possible de concaténer les fichiers \fB.xz\fP tels quel. \fBxz\fP +décompressera de tels fichiers comme s'ils étaient un unique fichier \fB.xz\fP. +.PP +It is possible to insert padding between the concatenated parts or after the +last part. The padding must consist of null bytes and the size of the +padding must be a multiple of four bytes. This can be useful, for example, +if the \fB.xz\fP file is stored on a medium that measures file sizes in +512\-byte blocks. +.PP +La concaténation et le remplissage ne sont pas autorisés avec les fichiers +\&\fB.lzma\fP ou les flux bruts. +. +.SH OPTIONS +. +.SS "Suffixes entiers et valeurs spéciales." +Dans la plupart des endroits où un argument entier est attendu, un suffixe +optionel permet d'indiquer facilement les grands entiers. Il ne doit pas y +avoir d'espace entre l'entier et le suffixe. +.TP +\fBKiB\fP +Multiplier l'entier par 1024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP et \fBKB\fP sont +acceptés comme synonymes de \fBKiB\fP. +.TP +\fBMiB\fP +Multiplier l'entier par 1 048 576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP et \fBMB\fP sont +acceptés comme synonymes de \fBMiB\fP. +.TP +\fBGiB\fP +Multiplier l'entier par 1 073 741 824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP et \fBGB\fP +sont acceptés comme synonymes de \fBGiB\fP. +.PP +La valeur spéciale \fBmax\fP peut être utilisée pour indiquer la valeur +maximale de l'entier prise en charge par l'option. +. +.SS "Mode d'opération" +Si plusieurs options de mode d'opération sont données, la dernière prend +effet. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Compresser. C'est le mode d'opération par défaut lorsque aucune option de +mode opératoire n'est spécifiée ou qu'aucun autre mode d'opération n'est +sous\-entendu par le nom de la commande (par exemple \fBunxz\fP sous\-entend +\fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +After successful compression, the source file is removed unless writing to +standard output or \fB\-\-keep\fP was specified. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Decompress. After successful decompression, the source file is removed +unless writing to standard output or \fB\-\-keep\fP was specified. +.TP +\fB\-t\fP, \fB\-\-test\fP +Tester l'intégrité des \fIfichiers\fP compressés. Cette option est équivalente +à \fB\-\-decompress \-\-stdout\fP sauf que les données décompressées sont rejetées +au lieu d'être écrites sur la sortie standard. Aucun fichier n'est créé ou +supprimé. +.TP +\fB\-l\fP, \fB\-\-list\fP +Afficher l'information sur les \fIfichiers\fP compressés. Aucune sortie +non\-compressée n'est produite et aucun fichier n'est créé ou supprimé. En +mode liste, le programme ne peut pas lire les données compressées depuis +l'entrée standard ou depuis d'autres sources non adressables. +.IP "" +The default listing shows basic information about \fIfiles\fP, one file per +line. To get more detailed information, use also the \fB\-\-verbose\fP option. +For even more information, use \fB\-\-verbose\fP twice, but note that this may be +slow, because getting all the extra information requires many seeks. The +width of verbose output exceeds 80 characters, so piping the output to, for +example, \fBless\ \-S\fP may be convenient if the terminal isn't wide enough. +.IP "" +La sortie exacte peut varier suivant les versions de \fBxz\fP et les différents +paramètres régionaux. Pour une sortie lisible par la machine, utiliser +\fB\-\-robot \-\-list\fP. +. +.SS "Modificateurs d'opération" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Ne pas effacer les fichiers d'entrée. +.IP "" +Since \fBxz\fP 5.2.6, this option also makes \fBxz\fP compress or decompress even +if the input is a symbolic link to a regular file, has more than one hard +link, or has the setuid, setgid, or sticky bit set. The setuid, setgid, and +sticky bits are not copied to the target file. In earlier versions this was +only done with \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Cette option a plusieurs effets : +.RS +.IP \(bu 3 +Si le fichier cible existe déjà, l'effacer avant de compresser ou +décompresser. +.IP \(bu 3 +Compresser ou décompresser même si l'entrée est un lien symbolique vers un +fichier normal, a plus qu'un lien physique, ou a le bit setuid, setgid ou +sticky défini. Les bits setuid, setgid et sticky bits ne sont pas copiés +dans le fichier cible. +.IP \(bu 3 +Lorsque \fBxz\fP est utilisé avec \fB\-\-decompress\fP \fB\-\-stdout\fP et qu'il ne peut +pas reconnaitre le type du fichier source, copier le fichier source tel quel +dans la sortie standard. Celà permet à \fBxzcat\fP \fB\-\-force\fP d'être utilisé +comme \fBcat\fP(1) pour les fichiers qui n'ont pas été compressé avec +\fBxz\fP. Remarquez que dans le futur, \fBxz\fP devrait prendre en charge de +nouveaux formats de fichiers compressés, ce qui permettra à \fBxz\fP de +décompresser plus de types de fichiers au lieu de les copier tels quels dans +la sortie standard. \fB\-\-format=\fP\fIformat\fP peut être utilisé pour contraindre +\fBxz\fP à décompresser seulement un format de fichier. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Écrire les données compressées ou décompressées sur la sortie standard +plutôt que dans un fichier. Cela necessite \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Décompresser seulement le premier flux \fB.xz\fP et ignorer silencieusement les +possibles données d'entrée résiduelles qui suivent le flux. Normalement ces +déchets excédentaires provoquent l'affichage d'une erreur par \fBxz\fP. +.IP "" +\fBxz\fP ne décompresse jamais plus d'un flux à partir de fichiers \fB.lzma\fP ou +de flux bruts, mais cette option fait aussi que \fBxz\fP ignorera les données +résiduelles après le fichier \fB.lzma\fP ou le flux brut. +.IP "" +Cette option n'a aucun effet si le mode d'opération n'est pas +\fB\-\-decompress\fP ou \fB\-\-test\fP. +.IP "" +Since \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP implies \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Désactiver la création de fichiers peu denses. Par défaut, lors de la +décompression en un fichier normal, \fBxz\fP essaie d'en faire un fichier creux +si les données décompressées contiennent de longues séquences de zéros +binaires. Cela fonctionne aussi lors de l'écriture sur la sortie standard +aussi longtemps que la sortie standard est connectée à un fichier normal et +que certaines conditions supplémentaires sont satisfaites pour le faire de +manière sécurisée. Créer des fichiers creux peut épargner de l'espace disque +et accélérer la décompression en réduisant la quantité d'entrées/sorties sur +le disque. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Lors de la compression, utiliser \fB.suf\fP comme suffixe du fichier cible au +lieu de \fB.xz\fP ou \fB.lzma\fP. Si \fBxz\fP n'écrit pas sur la sortie standard et +si le fichier source a déja le suffixe \fB.suf\fP, un avertissement est affiché +et le fichier est ignoré. +.IP "" +When decompressing, recognize files with the suffix \fI.suf\fP in addition to +files with the \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, or \fB.lz\fP suffix. If the +source file has the suffix \fI.suf\fP, the suffix is removed to get the target +filename. +.IP "" +Lors de la compression ou décompression de flux bruts (\fB\-\-fomat=raw\fP), le +suffixe doit toujours être spécifié à moins d'écrire sur la sortie standard, +car il n'y a pas de suffixe par défaut pour les flux bruts. +.TP +\fB\-\-files\fP[\fB=\fP\fIfichier\fP] +Lire les noms de fichier à traiter depuis \fIfichier\fP ; si \fIfichier\fP est +omis , les noms de fichier sont lus sur l'entrée standard. Les noms de +fichier doivent se terminer avec le caractère de nouvelle ligne. Un tiret +(\fB\-\fP) est considéré comme un nom de fichier normal ; ce qui ne signifie pas +entrée standard. Si les noms de fichier sont aussi donnés comme arguments de +ligne de commande, ils sont traités avant les noms de fichier lus depuis +\fIfichier\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIfichier\fP] +Cela est identique à \fB\-\-files\fP[\fB=\fP\fIfichier\fP] sauf que chaque nom de +fichier doit se terminer par le caractère null. +. +.SS "Format de fichier basique et options de compression" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fIformat\fP +Indiquer le \fIformat\fP de fichier à compresser ou décompresser : +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +C'est celui par défaut. Lors de la compression, \fBauto\fP est équivalent à +\fBxz\fP. Lors de la décompression, le format du fichier en entrée est détecté +automatiquement. Notez que les flux bruts (créés avec \fB\-\-format=raw\fP) ne +peuvent pas être détectés automatiquement. +.TP +\fBxz\fP +Compresser dans le format de fichier \fB.xz\fP ou n'accepter que les fichiers +\&\fB.xz\fP à décompresser. +.TP +\fBlzma\fP, \fBalone\fP +Compresser au format de fichier \fB.lzma\fP historique, ou n'accepter que les +fichiers \fB.lzma\fP lors de la décompression. Le nom alternatif \fBalone\fP est +fourni pour la rétrocompatibilité avec les utilitaires LZMA. +.TP +\fBlzip\fP +Accept only \fB.lz\fP files when decompressing. Compression is not supported. +.IP "" +The \fB.lz\fP format versions 0 and 1 are supported. Version 0 files were +produced by \fBlzip\fP 1.3 and older. Such files aren't common but may be +found from file archives as a few source packages were released in this +format. People might have old personal files in this format too. +Decompression support for the format version 0 was removed in \fBlzip\fP 1.18. +\fBlzip\fP 1.4 and later create files in the format version 1. +.TP +\fBraw\fP +Compresser ou décompresser un flux brut (sans en\-têtes). Cela est réservé +seulement aux utilisateurs aguerris. Pour décoder des flux bruts, vous devez +utiliser \fB\-\-format=raw\fP et spécifier explicitement la chaîne de filtre, qui +normalement aurait du être stockée dans les en\-têtes du conteneur. +.RE +.TP +\fB\-C\fP \fIvérif.\fP, \fB\-\-check=\fP\fIvérif.\fP +Spécifier le type d'intégrité à vérifier. La vérification est calculée à +partir des données non\-compressées et stockées dans le fichier \fB.xz\fP. Cette +option n'a effet que si la compression a été faite dans le format \fB.xz\fP ; +le format \fB.lzma\fP ne gère pas les vérifications d'intégrité. Le contrôle +d'intégrité (s'il y en a) est vérifié lorsque le fichier \fB.xz\fP est +décompressé. +.IP "" +Types de \fIvérification\fP pris en charge : +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Ne pas calculer de vérification d'intégrité du tout. C'est généralement une +mauvaise idée. Cela peut être utile lorsque l'intégrité des données est +vérifiée de toute façon par d'autres manières. +.TP +\fBcrc32\fP +Calculer CRC32 en utilisant le polynôme de IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Calculer CRC64 en utilisant le polynôme de ECMA\-182. C'est la manière +utilisée par défaut, car c'est légèrement mieux que CRC32 pour détecter les +fichiers endommagés et la différence de vitesse est négligeable. +.TP +\fBsha256\fP +Calculer SHA\-256. C'est quelque peu plus lent que CRC32 et CRC64. +.RE +.IP "" +L'intégrité des en\-têtes \fB.xz\fP est toujours vérifiée avec CRC32. Il n'est +pas possible de le changer ou de le désactiver. +.TP +\fB\-\-ignore\-check\fP +Ne pas contrôler la vérification d'intégrité des données lors de la +décompression. Les valeurs CRC32 dans les en\-têtes \fB.xz\fP seront normalement +toujours vérifiées. +.IP "" +\fBN'utilisez pas cette option à moins de savoir ce que vous faites.\fP Les +raisons possibles pour utiliser cette option : +.RS +.IP \(bu 3 +Essayer de récupérer des données d'un fichier .xz corrompu. +.IP \(bu 3 +Accélérer la décompression. Cela importe surtout avec SHA\-256 ou avec les +fichiers qui ont été compressés extrêmement bien. Il est recommandé de ne +pas utiliser cette option dans ce but à moins que l'intégrité du fichier ne +soit vérifiée extérieurement d'une autre manière. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Choisir un niveau de compression prédéfini. La valeur par défaut est +\fB6\fP. Si plusieurs niveaux de préréglage sont spécifiés, c'est le dernier +qui sera pris en compte. Si une chaîne de filtres personnalisée a déjà été +choisie, définir un niveau de compression préréglé efface la chaîne de +filtres personnalisée. +.IP "" +Les différences entre les préréglages sont plus significatives qu'avec +\fBgzip\fP(1) et \fBbzip2\fP(1). les réglages de compression sélectionnés +déterminent les exigences en mémoire pour la décompression, ainsi, utiliser +un niveau de préréglage trop élevé peut rendre difficile à décompresser un +fichier sur un vieux système avec peu de RAM. Clairement, \fBce n'est pas une bonne idée d'utiliser \-9 aveuglément pour tout\fP comme ça l'est souvent avec +\fBgzip\fP(1) et \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Ce sont des préréglages relativement rapides. \fB0\fP est parfois plus rapide +que \fBgzip \-9\fP tout en compressant bien mieux. Les réglages plus élevés ont +souvent une rapidité comparable à celle de \fBbzip2\fP(1) avec un taux de +compression comparable ou meilleur, même si les résultats dépendent beaucoup +du genre de données compressées. +.TP +\fB\-4\fP ... \fB\-6\fP +Good to very good compression while keeping decompressor memory usage +reasonable even for old systems. \fB\-6\fP is the default, which is usually a +good choice for distributing files that need to be decompressible even on +systems with only 16\ MiB RAM. (\fB\-5e\fP or \fB\-6e\fP may be worth considering +too. See \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +C'est comme \fB\-6\fP mais avec des besoins en mémoire plus élevés pour la +compression et la décompression. Ce n'est utile que lorsque les fichiers +sont plus gros que 8\ Mio, 16\ Mio et 32\ Mio respectivement. +.RE +.IP "" +Sur le même matériel, la vitesse de décompression est sensiblement un nombre +constant d'octets de données compressées par seconde. En d'autres termes, +meilleure est la compression, plus rapide sera en général la +décompression. Cela signifie aussi que la quantité de sortie non compressée +produite par seconde peut varier beaucoup. +.IP "" +Le tableau suivant résume les caractéristiques des préréglages : +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Préréglage;DictSize;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Descriptions des colonnes : +.RS +.IP \(bu 3 +DictSize est la taille du dictionnaire de LZMA2. Utiliser un dictionnaire +plus gros que la taille du fichier non compressé est un gaspillage de +mémoire. C'est pourquoi il est bon d'éviter d'utiliser les préréglages de +\fB\-7\fP à \fB\-9\fP lorsqu'il n'y en a pas vraiment besoin. A \fB\-6\fP et plus bas, +la quantité de mémoire gaspillée est généralement assez basse pour ne pas +être un problème. +.IP \(bu 3 +CompCPU est une représentation des préréglages de LZMA2 qui affectent la +vitesse de compression. La taille du dictionnaire aussi affecte la vitesse, +alors comme CompCPU est le même pour les niveaux de \fB\-6\fP à \fB\-9\fP, les plus +haut niveaux tendent à être un peu moins rapides. Pour être encore moins +rapide et du coup obtenir peut être une meilleure compression, consultez +\fB\-\-extreme\fP. +.IP \(bu 3 +CompMem contains the compressor memory requirements in the single\-threaded +mode. It may vary slightly between \fBxz\fP versions. +.IP \(bu 3 +DecMem contient les besoins en mémoire du décompresseur. Ce sont les +réglages de la compression qui déterminent les besoins en mémoire de la +décompression. L'exacte utilisation de la mémoire est légèrement supérieure +à la taille du dictionnaire LZMA2, mais les valeurs dans la table ont été +arrondies au prochain Mio supérieur. +.RE +.IP "" +Memory requirements of the multi\-threaded mode are significantly higher than +that of the single\-threaded mode. With the default value of +\fB\-\-block\-size\fP, each thread needs 3*3*DictSize plus CompMem or DecMem. For +example, four threads with preset \fB\-6\fP needs 660\(en670\ MiB of memory. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Utilisez un variant plus lent que les préréglages (\fB\-0\fP à \fB\-9\fP) pour +espérer avoir un taux de compression légèrement meilleur, mais en cas de +malchance cela peut être pire. L'utilisation mémoire du décompresseur n'est +pas affectée, mais l'utilisation mémoire du compresseur augmente un peu aux +niveaux de préréglages de \fB\-0\fP à \fB\-3\fP. +.IP "" +Depuis qu'il y a deux préréglages avec des tailles de dictionnaire de 4\ Mio +et 8 \Mio, les préréglages \fB\-3e\fP et \fB\-5e\fP utilisent des réglages +légèrement plus rapides que \fB\-4e\fP et \fB\-6e\fP, respectivement. De cette +manière, il n'y a pas deux préréglages identiques. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Préréglage;DictSize;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Par exemple, il y a un total de quatre préréglages qui utilisent un +dictionnaire de 8 Mio et qui sont dans l'ordre du plus rapide au plus lent : +\fB\-5\fP, \fB\-6\fP, \fB\-5e\fP et \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Il y a néanmoins des alias trompeurs pour \fB\-0\fP et \fB\-9\fP, +respectivement. Ils ne sont fournis que pour des besoins de +rétro\-compatibilité avec les utilitaires LZMA. Evitez d'utiliser ces +options. +.TP +\fB\-\-block\-size=\fP\fItaille\fP +Lors de la compression dans le format \fB.xz\fP, les données de l'entrée sont +réparties en blocs de \fItaille\fP octets. Les blocs sont compressés +indépendamment les un des autres, ce qui aide avec le mode multithread +(multi\-threading) et rend possible la décompression à accès aléatoire +limité. Cette option est typiquement utilisée pour outrepasser la taille de +bloc en mode multithread, mais cette option peut aussi être utilisée en mode +single\-thread. +.IP "" +In multi\-threaded mode about three times \fIsize\fP bytes will be allocated in +each thread for buffering input and output. The default \fIsize\fP is three +times the LZMA2 dictionary size or 1 MiB, whichever is more. Typically a +good value is 2\(en4 times the size of the LZMA2 dictionary or at least 1 +MiB. Using \fIsize\fP less than the LZMA2 dictionary size is waste of RAM +because then the LZMA2 dictionary buffer will never get fully used. In +multi\-threaded mode, the sizes of the blocks are stored in the block +headers. This size information is required for multi\-threaded +decompression. +.IP "" +In single\-threaded mode no block splitting is done by default. Setting this +option doesn't affect memory usage. No size information is stored in block +headers, thus files created in single\-threaded mode won't be identical to +files created in multi\-threaded mode. The lack of size information also +means that \fBxz\fP won't be able decompress the files in multi\-threaded mode. +.TP +\fB\-\-block\-list=\fP\fIitems\fP +When compressing to the \fB.xz\fP format, start a new block with an optional +custom filter chain after the given intervals of uncompressed data. +.IP "" +The \fIitems\fP are a comma\-separated list. Each item consists of an optional +filter chain number between 0 and 9 followed by a colon (\fB:\fP) and a +required size of uncompressed data. Omitting an item (two or more +consecutive commas) is a shorthand to use the size and filters of the +previous item. +.IP "" +If the input file is bigger than the sum of the sizes in \fIitems\fP, the last +item is repeated until the end of the file. A special value of \fB0\fP may be +used as the last size to indicate that the rest of the file should be +encoded as a single block. +.IP "" +An alternative filter chain for each block can be specified in combination +with the \fB\-\-filters1=\fP\fIfilters\fP \&...\& \fB\-\-filters9=\fP\fIfilters\fP options. +These options define filter chains with an identifier between 1\(en9. +Filter chain 0 can be used to refer to the default filter chain, which is +the same as not specifying a filter chain. The filter chain identifier can +be used before the uncompressed size, followed by a colon (\fB:\fP). For +example, if one specifies \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP +then blocks will be created using: +.RS +.IP \(bu 3 +The filter chain specified by \fB\-\-filters1\fP and 2 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters3\fP and 2 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters2\fP and 4 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters2\fP and 4 MiB input +.IP \(bu 3 +The default filter chain and 2 MiB input +.IP \(bu 3 +The default filter chain and 4 MiB input for every block until end of input. +.RE +.IP "" +If one specifies a size that exceeds the encoder's block size (either the +default value in threaded mode or the value specified with +\fB\-\-block\-size=\fP\fIsize\fP), the encoder will create additional blocks while +keeping the boundaries specified in \fIitems\fP. For example, if one specifies +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP and the +input file is 80 MiB, one will get 11 blocks: 5, 10, 8, 10, 2, 10, 10, 4, +10, 10, and 1 MiB. +.IP "" +En mode multi\-threadé les tailles de blocs sont stockées dans les en\-têtes +du bloc. Cela ne se fait pas en mode mono\-threadé, la sortie encodée ne sera +donc pas identique à celle faite en mode multi\-threadé. +.TP +\fB\-\-flush\-timeout=\fP\fItemps_d'attente\fP +Lors de la compression, si plus que \fItemps_d'attente\fP millisecondes (un +entier positif) se sont écoulées depuis le précédent vidage et que lire plus +de données bloquerait, toutes les données d'entrée en attente sont vidées de +l'encodeur et mises à disposition dans le flux de sortie. Cela peut être +utile si \fBxz\fP est utilisé pour compresser les données qui sont diffusées +sur un réseau. Des petites valeurs de \fItemps_d'attente\fP rendent les données +disponibles à l'extrémité réceptrice avec un léger retard, mais les grandes +valeurs de \fItemps_d'attente\fP donnent un meilleur taux de compression. +.IP "" +Cette option est désactivée par défaut. Si cette option est indiquée plus +d'une fois, la dernière prend effet. La valeur spéciale de +\fItemps_d'attente\fP de \fB0\fP peut être utilisée pour explicitement désactiver +cette option. +.IP "" +Cette option n'est pas disponible sur les systèmes qui ne sont pas POSIX. +.IP "" +.\" FIXME +\fBCette option est encore expérimentale.\fP Actuellement, \fBxz\fP ne convient +pas pour décompresser le flux en temps réel en raison de la façon dont \fBxz\fP +effectue la mise en mémoire tampon. +.TP +\fB\-\-no\-sync\fP +Do not synchronize the target file and its directory to the storage device +before removing the source file. This can improve performance if +compressing or decompressing many small files. However, if the system +crashes soon after the deletion, it is possible that the target file was not +written to the storage device but the delete operation was. In that case +neither the original source file nor the target file is available. +.IP "" +This option has an effect only when \fBxz\fP is going to remove the source +file. In other cases synchronization is never done. +.IP "" +The synchronization and \fB\-\-no\-sync\fP were added in \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIlimite\fP +Indiquer une limite d'utilisation de la mémoire pour la compression. Si +cette option est indiquée plusieurs fois, c'est la dernière qui est prise en +compte. +.IP "" +If the compression settings exceed the \fIlimit\fP, \fBxz\fP will attempt to +adjust the settings downwards so that the limit is no longer exceeded and +display a notice that automatic adjustment was done. The adjustments are +done in this order: reducing the number of threads, switching to +single\-threaded mode if even one thread in multi\-threaded mode exceeds the +\fIlimit\fP, and finally reducing the LZMA2 dictionary size. +.IP "" +When compressing with \fB\-\-format=raw\fP or if \fB\-\-no\-adjust\fP has been +specified, only the number of threads may be reduced since it can be done +without affecting the compressed output. +.IP "" +If the \fIlimit\fP cannot be met even with the adjustments described above, an +error is displayed and \fBxz\fP will exit with exit status 1. +.IP "" +La \fIlimite\fP peut être indiquée de plusieurs façons : +.RS +.IP \(bu 3 +La \fIlimite\fP peut être une valeur absolue en octets. Utiliser un suffixe +d'entier comme \fBMiB\fP peut être utile. Exemple : +\fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +La \fIlimite\fP peut être indiquée sous forme d'un pourcentage de la mémoire +physique totale (RAM). Cela peut être particulièrement utile quand la +variable d'environnement \fBXZ_DEFAULTS\fP est indiquée dans un script +d'initialisation de l'interpréteur partagé entre différents ordinateurs. De +cette façon la limite est automatiquement plus grande sur les systèmes avec +plus de mémoire. Exemple : \fB\-\-memlimit=70%\fP +.IP \(bu 3 +The \fIlimit\fP can be reset back to its default value by setting it to \fB0\fP. +This is currently equivalent to setting the \fIlimit\fP to \fBmax\fP (no memory +usage limit). +.RE +.IP "" +For 32\-bit \fBxz\fP there is a special case: if the \fIlimit\fP would be over +\fB4020\ MiB\fP, the \fIlimit\fP is set to \fB4020\ MiB\fP. On MIPS32 \fB2000\ MiB\fP +is used instead. (The values \fB0\fP and \fBmax\fP aren't affected by this. A +similar feature doesn't exist for decompression.) This can be helpful when +a 32\-bit executable has access to 4\ GiB address space (2 GiB on MIPS32) +while hopefully doing no harm in other situations. +.IP "" +Voir aussi la section \fButilisation de la mémoire\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIlimite\fP +Régler une limite d'utilisation de la mémoire pour la décompression. Cela a +un effet sur le mode \fB\-\-list\fP. Si l'opération n'est pas possible sans +dépasser la \fIlimite\fP, \fBxz\fP affichera une erreur et la décompression +échouera. Voir \fB\-\-memlimit\-compress=\fP\fIlimite\fP pour les manières possibles +d'indiquer la \fIlimite\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimit\fP +Set a memory usage limit for multi\-threaded decompression. This can only +affect the number of threads; this will never make \fBxz\fP refuse to +decompress a file. If \fIlimit\fP is too low to allow any multi\-threading, the +\fIlimit\fP is ignored and \fBxz\fP will continue in single\-threaded mode. Note +that if also \fB\-\-memlimit\-decompress\fP is used, it will always apply to both +single\-threaded and multi\-threaded modes, and so the effective \fIlimit\fP for +multi\-threading will never be higher than the limit set with +\fB\-\-memlimit\-decompress\fP. +.IP "" +In contrast to the other memory usage limit options, +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimit\fP has a system\-specific default +\fIlimit\fP. \fBxz \-\-info\-memory\fP can be used to see the current value. +.IP "" +This option and its default value exist because without any limit the +threaded decompressor could end up allocating an insane amount of memory +with some input files. If the default \fIlimit\fP is too low on your system, +feel free to increase the \fIlimit\fP but never set it to a value larger than +the amount of usable RAM as with appropriate input files \fBxz\fP will attempt +to use that amount of memory even with a low number of threads. Running out +of memory or swapping will not improve decompression performance. +.IP "" +See \fB\-\-memlimit\-compress=\fP\fIlimit\fP for possible ways to specify the +\fIlimit\fP. Setting \fIlimit\fP to \fB0\fP resets the \fIlimit\fP to the default +system\-specific value. +.TP +\fB\-M\fP \fIlimite\fP, \fB\-\-memlimit=\fP\fIlimite\fP, \fB\-\-memory=\fP\fIlimite\fP +This is equivalent to specifying \fB\-\-memlimit\-compress=\fP\fIlimit\fP +\fB\-\-memlimit\-decompress=\fP\fIlimit\fP \fB\-\-memlimit\-mt\-decompress=\fP\fIlimit\fP. +.TP +\fB\-\-no\-adjust\fP +Display an error and exit if the memory usage limit cannot be met without +adjusting settings that affect the compressed output. That is, this +prevents \fBxz\fP from switching the encoder from multi\-threaded mode to +single\-threaded mode and from reducing the LZMA2 dictionary size. Even when +this option is used the number of threads may be reduced to meet the memory +usage limit as that won't affect the compressed output. +.IP "" +Automatic adjusting is always disabled when creating raw streams +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fIthreads\fP, \fB\-\-threads=\fP\fIthreads\fP +Specify the number of worker threads to use. Setting \fIthreads\fP to a +special value \fB0\fP makes \fBxz\fP use up to as many threads as the processor(s) +on the system support. The actual number of threads can be fewer than +\fIthreads\fP if the input file is not big enough for threading with the given +settings or if using more threads would exceed the memory usage limit. +.IP "" +The single\-threaded and multi\-threaded compressors produce different +output. Single\-threaded compressor will give the smallest file size but +only the output from the multi\-threaded compressor can be decompressed using +multiple threads. Setting \fIthreads\fP to \fB1\fP will use the single\-threaded +mode. Setting \fIthreads\fP to any other value, including \fB0\fP, will use the +multi\-threaded compressor even if the system supports only one hardware +thread. (\fBxz\fP 5.2.x used single\-threaded mode in this situation.) +.IP "" +To use multi\-threaded mode with only one thread, set \fIthreads\fP to \fB+1\fP. +The \fB+\fP prefix has no effect with values other than \fB1\fP. A memory usage +limit can still make \fBxz\fP switch to single\-threaded mode unless +\fB\-\-no\-adjust\fP is used. Support for the \fB+\fP prefix was added in \fBxz\fP +5.4.0. +.IP "" +If an automatic number of threads has been requested and no memory usage +limit has been specified, then a system\-specific default soft limit will be +used to possibly limit the number of threads. It is a soft limit in sense +that it is ignored if the number of threads becomes one, thus a soft limit +will never stop \fBxz\fP from compressing or decompressing. This default soft +limit will not make \fBxz\fP switch from multi\-threaded mode to single\-threaded +mode. The active limits can be seen with \fBxz \-\-info\-memory\fP. +.IP "" +Actuellement, la seule méthode de gestion avec des threads consiste à +séparer l'entrée en blocs et de les compresser indépendamment les uns des +autres. La taille par défaut des blocs dépend du niveau de compression et +peut\-être remplacée avec l'option \fB\-\-block\-size=\fP\fItaille\fP. +.IP "" +Threaded decompression only works on files that contain multiple blocks with +size information in block headers. All large enough files compressed in +multi\-threaded mode meet this condition, but files compressed in +single\-threaded mode don't even if \fB\-\-block\-size=\fP\fIsize\fP has been used. +.IP "" +The default value for \fIthreads\fP is \fB0\fP. In \fBxz\fP 5.4.x and older the +default is \fB1\fP. +. +.SS "Chaînes de filtres de compresseur personnalisées" +A custom filter chain allows specifying the compression settings in detail +instead of relying on the settings associated to the presets. When a custom +filter chain is specified, preset options (\fB\-0\fP \&...\& \fB\-9\fP and +\fB\-\-extreme\fP) earlier on the command line are forgotten. If a preset +option is specified after one or more custom filter chain options, the new +preset takes effect and the custom filter chain options specified earlier +are forgotten. +.PP +Une chaîne de filtre est comparable à une redirection (pipe) sur la ligne de +commande. Lors de la compression, les entrées non compressées vont au +premier filtre, dont la sortie va au prochain filtre (s'il y en a). La +sortie du dernier filtre est écrite sur le fichier compressé. Le nombre +maximal de filtres dans la chaîne est quatre, mais habituellement, un chaîne +de filtre n'a qu'un ou deux filtres. +.PP +Beaucoup de filtres ont des limitations sur l'endroit où ils peuvent se +placer dans la chaîne de filtre : quelques filtres ne peuvent fonctionner +qu'en tant que dernier filtre dans la chaîne, quelques uns en tant que non +dernier filtre, et d'autres à n'importe quelle position dans la +chaîne. Suivant le filtre, cette limitation est soit inhérente au profil du +filtre, soit existe pour des raisons de sécurité. +.PP +A custom filter chain can be specified in two different ways. The options +\fB\-\-filters=\fP\fIfilters\fP and \fB\-\-filters1=\fP\fIfilters\fP \&...\& +\fB\-\-filters9=\fP\fIfilters\fP allow specifying an entire filter chain in one +option using the liblzma filter string syntax. Alternatively, a filter +chain can be specified by using one or more individual filter options in the +order they are wanted in the filter chain. That is, the order of the +individual filter options is significant! When decoding raw streams +(\fB\-\-format=raw\fP), the filter chain must be specified in the same order as +it was specified when compressing. Any individual filter or preset options +specified before the full chain option (\fB\-\-filters=\fP\fIfilters\fP) will be +forgotten. Individual filters specified after the full chain option will +reset the filter chain. +.PP +Both the full and individual filter options take filter\-specific \fIoptions\fP +as a comma\-separated list. Extra commas in \fIoptions\fP are ignored. Every +option has a default value, so specify those you want to change. +.PP +Pour voir l'entièreté de la chaîne de filtres et ses \fIoptions\fP, utilisez +\fBxz \-vv\fP (ce qui est comme utiliser \fB\-\-verbose\fP deux fois). Cela +fonctionne aussi pour voir les options de chaîne de filtres utilisées par +les préréglages. +.TP +\fB\-\-filters=\fP\fIfilters\fP +Specify the full filter chain or a preset in a single option. Each filter +can be separated by spaces or two dashes (\fB\-\-\fP). \fIfilters\fP may need to be +quoted on the shell command line so it is parsed as a single option. To +denote \fIoptions\fP, use \fB:\fP or \fB=\fP. A preset can be prefixed with a \fB\-\fP +and followed with zero or more flags. The only supported flag is \fBe\fP to +apply the same options as \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIfilters\fP ... \fB\-\-filters9\fP=\fIfilters\fP +Specify up to nine additional filter chains that can be used with +\fB\-\-block\-list\fP. +.IP "" +For example, when compressing an archive with executable files followed by +text files, the executable part could use a filter chain with a BCJ filter +and the text part only the LZMA2 filter. +.TP +\fB\-\-filters\-help\fP +Display a help message describing how to specify presets and custom filter +chains in the \fB\-\-filters\fP and \fB\-\-filters1=\fP\fIfilters\fP \&...\& +\fB\-\-filters9=\fP\fIfilters\fP options, and exit successfully. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIoptions\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIoptions\fP] +.PD +Ajouter le filtre LZMA1 ou LZMA2 à la chaîne de filtres. Ces filtres ne +peuvent être utilisés que comme dernier filtre dans la chaîne. +.IP "" +LZMA1 est un filtre historique, qui n'est pris en charge presque uniquement +à cause de l'ancien format de fichier \fB.lzma\fP, qui ne prend en charge que +LZMA1. LZMA2 est une version mise à jour de LZMA1 pour régler certains +problèmes pratiques de LZMA1. Le format \fBxz\fP utilise LZMA2 et ne prend pas +du tout en charge LZMA1. Les taux et vitesses de compression de LZMA1 et +LZMA2 sont pratiquement identiques. +.IP "" +LZMA1 et LZMA2 partagent le même ensemble d'\fIoptions\fP : +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIpréréglage\fP +Reset all LZMA1 or LZMA2 \fIoptions\fP to \fIpreset\fP. \fIPreset\fP consist of an +integer, which may be followed by single\-letter preset modifiers. The +integer can be from \fB0\fP to \fB9\fP, matching the command line options \fB\-0\fP +\&...\& \fB\-9\fP. The only supported modifier is currently \fBe\fP, which matches +\fB\-\-extreme\fP. If no \fBpreset\fP is specified, the default values of LZMA1 or +LZMA2 \fIoptions\fP are taken from the preset \fB6\fP. +.TP +\fBdict=\fP\fItaille\fP +La \fItaille\fP du dictionnaire (historique du tampon) indique combien d'octets +des données récement décompressées sont gardés en mémoire. L'algorithme +essaie de trouver les séquences d'octets répétées (identiques) dans les +données décompressées et les remplace par les données actuellement dans le +dictionnaire. Plus gros est le dictionnaire, plus grande est la chance de +trouver une correspondance. Ainsi, l'augmentation de la \fItaille\fP du +dictionnaire augmente habituellement le taux de compression, mais un +dictionnaire plus gros que le fichier non compressé est un gachis de +mémoire. +.IP "" +Généralement la \fItaille\fP du dictionnaire est entre 64\ Kio et 64\ Mio. Le +minimum étant 4\ Kio. La \fItaille\fP maximale pour la compression est +habituellement 1,5\ Gio (1536\ Mio). Le décompresseur prend en charge les +dictionnaires jusqu'à un octet de moins que 4\ Gio, ce qui est le maximum +pour les formats de flux LZMA1 et LZMA2. +.IP "" +La \fItaille\fP du dictionnaire et le chercheur de correspondance (match +finder) (\fImf\fP) déterminent ensemble l'utilisation de la mémoire de +l'encodeur LZMA1 ou LZMA2. La même (ou une plus grosse) \fItaille\fP de +dictionnaire est requise pour décompresser que ce qui a été utilisé pour la +compression, ainsi l'utilisation de la mémoire du décodeur est déterminée +par la taille du dictionnaire utilisée lors de la compression. Les en\-têtes +de \fB.xz\fP stockent la \fItaille\fP de dictionnaire sous la forme 2^\fIn\fP ou +2^\fIn\fP + 2^(\fIn\fP\-1), de sorte que ces \fItailles\fP sont quelque peu préférées +pour la compression. Les autres \fItailles\fP seront arrondies à la hausse +lorsque stockées dans les en\-têtes de \fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Spécifiez le nombre d'octets de contexte littéraux. Le minimum est \fB0\fP et +le maximum est \fB4\fP. La valeur par défaut est \fB3\fP. En plus, la somme de +\fIlc\fP et \fIlp\fP ne doit pas excéder \fB4\fP. +.IP "" +Tous les octets qui ne peuvent pas être codés comme des correspondances sont +codés comme des littéraux. C'est à dire que les littéraux sont simplement +des octets 8 bits encodés un à la fois. +.IP "" +The literal coding makes an assumption that the highest \fIlc\fP bits of the +previous uncompressed byte correlate with the next byte. For example, in +typical English text, an upper\-case letter is often followed by a lower\-case +letter, and a lower\-case letter is usually followed by another lower\-case +letter. In the US\-ASCII character set, the highest three bits are 010 for +upper\-case letters and 011 for lower\-case letters. When \fIlc\fP is at least +3, the literal coding can take advantage of this property in the +uncompressed data. +.IP "" +The default value (3) is usually good. If you want maximum compression, +test \fBlc=4\fP. Sometimes it helps a little, and sometimes it makes +compression worse. If it makes it worse, test \fBlc=2\fP too. +.TP +\fBlp=\fP\fIlp\fP +Indiquer le nombre de bits de position littérale. Le minimum est \fB0\fP et le +maximum \fB4\fP; par défaut c'est \fB0\fP. +.IP "" +\fILp\fP affecte le type d'alignement dans les données décompressées qui est +présumé lors de l'encodage des littéraux. Voir \fIpb\fP ci dessous pour plus +d'information sur l'alignement. +.TP +\fBpb=\fP\fIpb\fP +Indiquer le nombre de bits de position. Le minimum est \fB0\fP et le maximum +\fB4\fP; par défaut \fB2\fP. +.IP "" +\fIPb\fP affecte quel genre d'alignement est présumé en général dans les +données non compressées. Par défaut c'est un alignement de quatre octets +(2^\fIpb\fP=2^2=4), ce qui est généralement un bon choix lorsqu'il n'y a pas de +meilleure estimation. +.IP "" +When the alignment is known, setting \fIpb\fP accordingly may reduce the file +size a little. For example, with text files having one\-byte alignment +(US\-ASCII, ISO\-8859\-*, UTF\-8), setting \fBpb=0\fP can improve compression +slightly. For UTF\-16 text, \fBpb=1\fP is a good choice. If the alignment is +an odd number like 3 bytes, \fBpb=0\fP might be the best choice. +.IP "" +Même si l'alignement présumé peut être ajusté avec \fIpb\fP et \fIlp\fP, LZMA1 et +LZMA2 favorisent toujours légèrement l'alignement sur 16 octets. Il peut +être utile d'en tenir compte lors de la conception de formats de fichiers +susceptibles d'être souvent compressés avec LZMA1 ou LZMA2. +.TP +\fBmf=\fP\fImf\fP +Match finder has a major effect on encoder speed, memory usage, and +compression ratio. Usually Hash Chain match finders are faster than Binary +Tree match finders. The default depends on the \fIpreset\fP: 0 uses \fBhc3\fP, +1\(en3 use \fBhc4\fP, and the rest use \fBbt4\fP. +.IP "" +Les chercheurs de correspondance suivants sont pris en charge. Les formules +d'utilisation de la mémoire ci\-dessous sont des approximations grossières +qui sont les plus proches de la réalité lorsque \fIdict\fP est une puissance de +deux. +.RS +.TP +\fBhc3\fP +Chaîne de hachage avec hachage de 2 et 3 octets +.br +Valeur minimale pour \fInice\fP : \fB3\fP +.br +Utilisation de la mémoire : +.br +\fIdict\fP * 7.5 (if \fIdict\fP <= 16 Mio); +.br +\fIdict\fP * 5.5 + 64 MiB (si \fIdict\fP > 16 Mio) +.TP +\fBhc4\fP +Chaîne de hachage avec hachage de 2, 3 et 4 octets +.br +Valeur minimale pour \fInice\fP : \fB4\fP +.br +Utilisation de la mémoire : +.br +\fIdict\fP * 7.5 (si \fIdict\fP <= 32 Mio); +.br +\fIdict\fP * 6.5 (si \fIdict\fP > 32 Mio) +.TP +\fBbt2\fP +Arbre binaire avec hachage de 2 octets +.br +Valeur minimale pour \fInice\fP : \fB2\fP +.br +Utilisation de la mémoire : \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Arbre binaire avec hachage de 2 et 3 octets +.br +Valeur minimale pour \fInice\fP : \fB3\fP +.br +Utilisation de la mémoire : +.br +\fIdict\fP * 11.5 (si \fIdict\fP <= 16 Mio); +.br +\fIdict\fP * 9.5 + 64 MiB (si \fIdict\fP > 16 Mio) +.TP +\fBbt4\fP +Arbre binaire avec hachage 2, 3 et 4 octets +.br +Valeur minimale pour \fInice\fP : \fB4\fP +.br +Utilisation de la mémoire : +.br +\fIdict\fP * 11.5 (si \fIdict\fP <= 32 Mio); +.br +\fIdict\fP * 10.5 (si \fIdict\fP > 32 Mio) +.RE +.TP +\fBmode=\fP\fImode\fP +Compression \fImode\fP specifies the method to analyze the data produced by the +match finder. Supported \fImodes\fP are \fBfast\fP and \fBnormal\fP. The default is +\fBfast\fP for \fIpresets\fP 0\(en3 and \fBnormal\fP for \fIpresets\fP 4\(en9. +.IP "" +Habituellement, \fBfast\fP est utilisé avec les chercheurs de correspondance de +chaîne de hachage et \fBnormal\fP avec les chercheurs de correspondance d'arbre +binaire. C'est aussi ce que font les \fIpréréglages\fP. +.TP +\fBnice=\fP\fInice\fP +Spécifier ce qui est considéré comme une bonne longueur pour une +correspondance. Une fois que la correspondance d'au moins \fInice\fP octets est +trouvée, l'algorithme arrête de chercher de meilleures correspondances +possibles. +.IP "" +\fINice\fP can be 2\(en273 bytes. Higher values tend to give better +compression ratio at the expense of speed. The default depends on the +\fIpreset\fP. +.TP +\fBdepth=\fP\fIprofondeur\fP +Spécifier la profondeur de recherche maximale dans l'outil de recherche de +correspondances. La valeur par défaut est \fB0\fP, ce qui fait que le +compresseur détermine une \fIprofondeur\fP raisonnable en fonction de \fImf\fP et +\fInice\fP. +.IP "" +Reasonable \fIdepth\fP for Hash Chains is 4\(en100 and 16\(en1000 for Binary +Trees. Using very high values for \fIdepth\fP can make the encoder extremely +slow with some files. Avoid setting the \fIdepth\fP over 1000 unless you are +prepared to interrupt the compression in case it is taking far too long. +.RE +.IP "" +Lors du décodage des flux bruts (\fB\-\-format=raw\fP), LZMA2 nécessite seulement +la \fItaille\fP du dictionnaire. LZMA1 nécessite aussi \fIlc\fP, \fIlp\fP et \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIoptions\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIoptions\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIoptions\fP] +.PD +Ajouter un filtre branch/call/jump (BCJ) à la chaîne de filtres. Ces filtres +ne peuvent être utilisés que s'ils ne sont pas le dernier filtre de la +chaîne de filtrage. +.IP "" +A BCJ filter converts relative addresses in the machine code to their +absolute counterparts. This doesn't change the size of the data but it +increases redundancy, which can help LZMA2 to produce 0\(en15\ % smaller +\&\fB.xz\fP file. The BCJ filters are always reversible, so using a BCJ filter +for wrong type of data doesn't cause any data loss, although it may make the +compression ratio slightly worse. The BCJ filters are very fast and use an +insignificant amount of memory. +.IP "" +Ces filtres BCJ présentent des problèmes connus liés au taux de +compression : +.RS +.IP \(bu 3 +Some types of files containing executable code (for example, object files, +static libraries, and Linux kernel modules) have the addresses in the +instructions filled with filler values. These BCJ filters will still do the +address conversion, which will make the compression worse with these files. +.IP \(bu 3 +If a BCJ filter is applied on an archive, it is possible that it makes the +compression ratio worse than not using a BCJ filter. For example, if there +are similar or even identical executables then filtering will likely make +the files less similar and thus compression is worse. The contents of +non\-executable files in the same archive can matter too. In practice one +has to try with and without a BCJ filter to see which is better in each +situation. +.RE +.IP "" +Different instruction sets have different alignment: the executable file +must be aligned to a multiple of this value in the input data to make the +filter work. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filtre;Alignement;Notes +x86;1;32 bits ou 64 bits x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096\-byte alignment is best +PowerPC;4;Grand boutiste seulement +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Since the BCJ\-filtered data is usually compressed with LZMA2, the +compression ratio may be improved slightly if the LZMA2 options are set to +match the alignment of the selected BCJ filter. Examples: +.RS +.IP \(bu 3 +IA\-64 filter has 16\-byte alignment so \fBpb=4,lp=4,lc=0\fP is good with LZMA2 +(2^4=16). +.IP \(bu 3 +RISC\-V code has 2\-byte or 4\-byte alignment depending on whether the file +contains 16\-bit compressed instructions (the C extension). When 16\-bit +instructions are used, \fBpb=2,lp=1,lc=3\fP or \fBpb=1,lp=1,lc=3\fP is good. When +16\-bit instructions aren't present, \fBpb=2,lp=2,lc=2\fP is the best. +\fBreadelf \-h\fP can be used to check if "RVC" appears on the "Flags" line. +.IP \(bu 3 +ARM64 is always 4\-byte aligned so \fBpb=2,lp=2,lc=2\fP is the best. +.IP \(bu 3 +The x86 filter is an exception. It's usually good to stick to LZMA2's +defaults (\fBpb=2,lp=0,lc=3\fP) when compressing x86 executables. +.RE +.IP "" +Tous les filtres BCJ prennent en charge les mêmes \fIoptions\fP : +.RS +.TP +\fBstart=\fP\fIdécalage\fP +Spécifier le \fIdécalage\fP de départ qui est utilisé lors de la conversion +entre les adresses relatives et absolues. Le \fIdécalage\fP doit être un +multiple de l'alignement du filtre (voir la table ci\-dessus). Sa valeur par +défaut est zéro. En pratique, cette dernière convient ; indiquer un +\fIdécalage\fP personnalisé est la plupart du temps inutile. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIoptions\fP] +Ajouter le filtre Delta à la chaîne de filtres. Le filtre Delta ne peut être +utilisé que s'il n'est pas le dernier filtre dans la chaîne. +.IP "" +Currently only simple byte\-wise delta calculation is supported. It can be +useful when compressing, for example, uncompressed bitmap images or +uncompressed PCM audio. However, special purpose algorithms may give +significantly better results than Delta + LZMA2. This is true especially +with audio, which compresses faster and better, for example, with +\fBflac\fP(1). +.IP "" +\fIoptions\fP prises en charge : +.RS +.TP +\fBdist=\fP\fIdistance\fP +Specify the \fIdistance\fP of the delta calculation in bytes. \fIdistance\fP must +be 1\(en256. The default is 1. +.IP "" +Par exemple, avec \fBdist=2\fP et une entrée huit octets A1 B1 A2 B3 A3 B5 A4 +B7, la sortie sera A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Autres options" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Supprimer les avertissements et les notifications. Indiquer cela deux fois +supprimera aussi les erreurs. Cette option n'a aucun effet sur le statut de +sortie. Cela dit, même si un avertissement était supprimé, le statut de +sortie indiquant un avertissement sera encore utilisé. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Être bavard. Si l'erreur standard est connectée à un terminal, \fBxz\fP +affichera une barre de progression. Indiquer \fB\-\-verbose\fP deux fois donnera +une sortie encore plus bavarde. +.IP "" +La barre de progression montre l'information suivante : +.RS +.IP \(bu 3 +Le pourcentage de complétion est montré si la taille du fichier en entrée +est connue. Néanmoins, le pourcentage ne peut pas être montré en cas de +redirection. +.IP \(bu 3 +Quantité de données compressées produites (compression) ou consommées +(décompression). +.IP \(bu 3 +Quantité de données non compressées consommées (compression) ou produites +(décompression). +.IP \(bu 3 +Le taux de compression, calculé en divisant la quantité de données +compréssées déjà traitées par la quantité de données décompressées déjà +traitées. +.IP \(bu 3 +Vitesse de compression ou de décompression. Elle correspond à la quantité de +données non compressées consommées (compression) ou produites +(décompression) par seconde. Elle apparait quelques secondes après le début +du traitement du fichier par \fBxz\fP. +.IP \(bu 3 +Temps écoulé dans le format M:SS ou H:MM:SS. +.IP \(bu 3 +Estimated remaining time is shown only when the size of the input file is +known and a couple of seconds have already passed since \fBxz\fP started +processing the file. The time is shown in a less precise format which never +has any colons, for example, 2 min 30 s. +.RE +.IP "" +When standard error is not a terminal, \fB\-\-verbose\fP will make \fBxz\fP print +the filename, compressed size, uncompressed size, compression ratio, and +possibly also the speed and elapsed time on a single line to standard error +after compressing or decompressing the file. The speed and elapsed time are +included only when the operation took at least a few seconds. If the +operation didn't finish, for example, due to user interruption, also the +completion percentage is printed if the size of the input file is known. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Ne pas mettre l'état de sortie à \fB2\fP même si une condition méritant un +avertissement a été détectée. Cette option n'affecte pas le niveau de +verbosité, néanmoins, les deux options \fB\-\-quiet\fP et \fB\-\-no\-warn\fP doivent +être utilisées pour ne pas afficher d'avertissements, ni altérer le statut +de sortie. +.TP +\fB\-\-robot\fP +Afficher les messages dans un format analysable par une machine. Ceci est +destiné à faciliter l'écriture des frontaux qui voudraient utiliser \fBxz\fP +plutôt que liblzma, ce qui pourrait être le cas pour différents scripts. La +sortie avec cette option activée est destinée à rester stable sur les +différentes versions de \fBxz\fP. Consulter le paragraphe \fBROBOT MODE\fP pour +les détails. +.TP +\fB\-\-info\-memory\fP +Display, in human\-readable format, how much physical memory (RAM) and how +many processor threads \fBxz\fP thinks the system has and the memory usage +limits for compression and decompression, and exit successfully. +.TP +\fB\-h\fP, \fB\-\-help\fP +Afficher un message d'aide décrivant les options les plus couramment +utilisées et quitter. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Afficher un message d'aide décrivant toutes les options de \fBxz\fP et quitter. +.TP +\fB\-V\fP, \fB\-\-version\fP +Afficher le numéro de version de \fBxz\fP et de liblzma dans un format lisible +par un humain. Pour obtenir une sortie analysable par la machine, spécifiez +\fB\-\-robot\fP avant \fB\-\-version\fP. +. +.SH "MODE ROBOT" +The robot mode is activated with the \fB\-\-robot\fP option. It makes the output +of \fBxz\fP easier to parse by other programs. Currently \fB\-\-robot\fP is +supported only together with \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, +and \fB\-\-version\fP. It will be supported for compression and decompression in +the future. +. +.SS "Mode liste" +\fBxz \-\-robot \-\-list\fP utilise une sortie séparée par des tabulations. La +première colonne de toutes les lignes possède une chaîne qui indique le type +d'information trouvée sur cette ligne : +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +C'est toujours la première ligne au début de la liste d'un fichier. La +seconde colonne de la ligne est le nom de fichier. +.TP +\fBfile\fP +Cette ligne contient l'information globale sur le fichier \fB.xz\fP. Cette +ligne est toujours écrite après la ligne \fBname\fP. +.TP +\fBstream\fP +Ce type de ligne n'est utilisée que lorsque \fB \-\-verbose\fP a été indiquée. Il +y a autant de lignes \fBstream\fP qu'il y a de flux dans le fichier \fB.xz\fP. +.TP +\fBblock\fP +Ce type de ligne n'est utilisé seulement lorsque \fB\-\-verbose\fP a été +indiquée. Il y a autant de lignes \fBblock\fP qu'il y a de blocs dans le +fichier \fB.xz\fP. Les lignes \fBblock\fP sont affichées après toutes les lignes +\fBstream\fP ; les différents types de lignes ne sont pas imbriqués. +.TP +\fBsummary\fP +Ce type de ligne n'est utilisé que lorsque \fB\-\-verbose\fP a été indiqué deux +fois. Cette ligne est affichée après toutes les lignes \fBblock\fP. Comme la +ligne \fBfile\fP, la ligne \fBsummary\fP contient l'information globale sur le +fichier \fB.xz\fP. +.TP +\fBtotals\fP +Cette ligne est toujours la toute dernière ligne de la sortie. Elle affiche +les comptes et les tailles totaux. +.PP +Les colonnes des lignes \fBfile\fP : +.PD 0 +.RS +.IP 2. 4 +Nombre de flux dans le fichier +.IP 3. 4 +Nombre total de blocs dans le ou les flux. +.IP 4. 4 +Taille compressée du fichier +.IP 5. 4 +Taille décompressée du fichier +.IP 6. 4 +Compression ratio, for example, \fB0.123\fP. If ratio is over 9.999, three +dashes (\fB\-\-\-\fP) are displayed instead of the ratio. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Liste de noms de contrôles d'intégrité séparés par des virgules. Les chaînes +suivantes sont utilisées pour les types de vérification connus : \fBNone\fP, +\fBCRC32\fP, \fBCRC64\fP et \fBSHA256\fP. Pour le types de vérification inconnus, +\fBUnknown\-\fP\fIN\fP est utilisé, où \fIN\fP est un identifiant de vérification sous +la forme d'un nombre décimal (un ou deux chiffres). +.IP 8. 4 +Taille totale du remplissage du flux dans le fichier +.RE +.PD +.PP +Les colonnes des lignes \fBstream\fP : +.PD 0 +.RS +.IP 2. 4 +Numéro de flux (le premier flux a le numéro 1) +.IP 3. 4 +Nombre de blocs dans le flux +.IP 4. 4 +Décalage de départ compressé +.IP 5. 4 +Décalage de départ décompressé +.IP 6. 4 +Taille compressée (ne comprend pas le remplissage du flux) +.IP 7. 4 +Taille décompressée +.IP 8. 4 +Taux de compression +.IP 9. 4 +Nom de la vérification d'intégrité +.IP 10. 4 +Taille du remplissage de flux +.RE +.PD +.PP +Les colonnes des lignes \fBblock\fP : +.PD 0 +.RS +.IP 2. 4 +Numéro du flux qui contient ce bloc +.IP 3. 4 +Numéro du bloc relatif au commencement du flux (le premier bloc a pour +numéro 1) +.IP 4. 4 +Numéro du bloc relatif au début du fichier +.IP 5. 4 +Décalage de départ compressé relatif au début du fichier +.IP 6. 4 +Décalage de départ décompressé relatif au début du fichier +.IP 7. 4 +Taille compressée totale du bloc (en\-têtes inclus) +.IP 8. 4 +Taille décompressée +.IP 9. 4 +Taux de compression +.IP 10. 4 +Nom de la vérification d'intégrité +.RE +.PD +.PP +Si \fB\-\-verbose\fP a été indiqué deux fois, les colonnes additionnelles sont +inclues sur les lignes \fBblock\fP. Elles ne sont pas affichées avec un seul +\fB\-\-verbose\fP, car l'obtention de ces informations nécessite de nombreuses +recherches et peut donc être lente : +.PD 0 +.RS +.IP 11. 4 +Valeur de la vérification d'intégrité en hexadécimal +.IP 12. 4 +Taille d'en\-tête de bloc +.IP 13. 4 +Drapeaux du bloc : \fBc\fP indique que la taille compressée est présente, et +\fBu\fP indique que la taille décompréssée est présente. Si le drapeau n'est +pas indiqué, un tiret (\fB\-\fP) est affiché à la place pour que la longueur de +la chaîne reste fixe. De nouveaux drapeaux pourraient être ajoutés à la fin +de la chaîne dans le futur. +.IP 14. 4 +Taille des données effectivement compressées dans le bloc (en excluant +l'en\-tête de bloc, le remplissage de bloc et les champs de vérification). +.IP 15. 4 +Quantité de mémoire (en octets) nécessaire pour décompresser ce bloc avec +cette version de \fBxz\fP. +.IP 16. 4 +Chaîne de filtrage. Remarquez que la plupart des options utilisées au moment +de la compression ne peuvent pas être connues, car seules les options +nécessaires pour la décompression sont stockées dans les en\-têtes \fB.xz\fP. +.RE +.PD +.PP +Les colonnes des lignes \fBsummary\fP : +.PD 0 +.RS +.IP 2. 4 +Quantité de mémoire (en octets) nécessaire pour décompresser ce fichier avec +cette version de \fBxz\fP. +.IP 3. 4 +\fByes\fP ou \fBno\fP indique si tous les en\-têtes de bloc stockent à la fois la +taille compressée et la taille décompressée. +.PP +\fIDepuis\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Version minimale de \fBxz\fP nécessaire pour décompresser le fichier. +.RE +.PD +.PP +Les colonnes de la ligne \fBtotals\fP : +.PD 0 +.RS +.IP 2. 4 +Nombre de flux +.IP 3. 4 +Nombre de blocs +.IP 4. 4 +Taille compressée +.IP 5. 4 +Taille décompressée +.IP 6. 4 +Taux de compression moyen +.IP 7. 4 +Liste séparée par des virgules des noms de vérification d'intégrité qui +étaient présents dans les fichiers +.IP 8. 4 +Taille de remplissage de flux +.IP 9. 4 +Nombre de fichiers. Permet de garder l'ordre des colonnes précédentes comme +sur les lignes \fBfile\fP. +.PD +.RE +.PP +Si \fB\-\-verbose\fP a été indiqué deux fois, des colonnes supplémentaires sont +incluses sur la ligne \fBtotals\fP : +.PD 0 +.RS +.IP 10. 4 +Quantité maximale de mémoire (en octets) nécessaire pour décompresser les +fichiers avec cette version de \fBxz\fP. +.IP 11. 4 +\fByes\fP ou \fBno\fP indique si tous les en\-têtes de bloc stockent à la fois la +taille compressée et la taille décompressée. +.PP +\fIDepuis\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Version minimale de \fBxz\fP nécessaire pour décompresser le fichier. +.RE +.PD +.PP +Les versions futures pourront ajouter de nouveaux types de lignes et de +nouvelles colonnes pourront être ajoutées aux types de lignes existants, +mais les colonnes existantes ne seront pas modifiées. +. +.SS "Filters help" +\fBxz \-\-robot \-\-filters\-help\fP prints the supported filters in the following +format: +.PP +\fIfilter\fP\fB:\fP\fIoption\fP\fB=<\fP\fIvalue\fP\fB>,\fP\fIoption\fP\fB=<\fP\fIvalue\fP\fB>\fP... +.TP +\fIfilter\fP +Name of the filter +.TP +\fIoption\fP +Name of a filter specific option +.TP +\fIvalue\fP +Numeric \fIvalue\fP ranges appear as \fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. String +\fIvalue\fP choices are shown within \fB< >\fP and separated by a \fB|\fP +character. +.PP +Each filter is printed on its own line. +. +.SS "Information de limite de mémoire" +\fBxz \-\-robot \-\-info\-memory\fP prints a single line with multiple tab\-separated +columns: +.IP 1. 4 +Total amount of physical memory (RAM) in bytes. +.IP 2. 4 +Memory usage limit for compression in bytes (\fB\-\-memlimit\-compress\fP). A +special value of \fB0\fP indicates the default setting which for +single\-threaded mode is the same as no limit. +.IP 3. 4 +Memory usage limit for decompression in bytes (\fB\-\-memlimit\-decompress\fP). A +special value of \fB0\fP indicates the default setting which for +single\-threaded mode is the same as no limit. +.IP 4. 4 +Since \fBxz\fP 5.3.4alpha: Memory usage for multi\-threaded decompression in +bytes (\fB\-\-memlimit\-mt\-decompress\fP). This is never zero because a +system\-specific default value shown in the column 5 is used if no limit has +been specified explicitly. This is also never greater than the value in the +column 3 even if a larger value has been specified with +\fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Since \fBxz\fP 5.3.4alpha: A system\-specific default memory usage limit that is +used to limit the number of threads when compressing with an automatic +number of threads (\fB\-\-threads=0\fP) and no memory usage limit has been +specified (\fB\-\-memlimit\-compress\fP). This is also used as the default value +for \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Since \fBxz\fP 5.3.4alpha: Number of available processor threads. +.PP +Dans le futur, la sortie de \fBxz \-\-robot \-\-info\-memory\fP pourrait avoir plus +de colonnes, mais jamais plus qu'une ligne unique. +. +.SS Version +\fBxz \-\-robot \-\-version\fP prints the version number of \fBxz\fP and liblzma in +the following format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Version majeure. +.TP +\fIYYY\fP +Version mineure. Les numéros pairs sont stables. Les numéros impairs sont +des versions alpha ou beta. +.TP +\fIZZZ\fP +Niveau de correctif pour les options stables ou juste un compteur pour les +options de développement. +.TP +\fIS\fP +Stabilité. 0 est alpha, 1 est bêta et 2 est stable. \fIS\fP devrait toujours +être 2 quand \fIYYY\fP est pair. +.PP +\fIXYYYZZZS\fP sont identiques sur les deux lignes si \fBxz\fP et liblzma sont +issus de la même version d'utilitaires XZ. +.PP +Exemples : 4.999.9beta est \fB49990091\fP et 5.0.0 est \fB50000002\fP. +. +.SH "STATUT DE SORTIE" +.TP +\fB0\fP +Tout est bon. +.TP +\fB1\fP +Une erreur est survenue. +.TP +\fB2\fP +Quelquechose méritant un avertissement s'est produit, mais aucune erreur +véritable n'est survenue. +.PP +Les notifications (pas les avertissements ou les erreurs) affichées sur +l'erreur standard n'affectent pas le statut de sortie. +. +.SH ENVIRONNEMENT +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP analyse les listes d'options séparées par des espaces à partir des +variables d'environnement \fBXZ_DEFAULTS\fP et \fBXZ_OPT\fP, dans cet ordre, avant +d'analyser les options de la ligne de commandes. Remarquez que seules les +options sont analysées depuis l'environnement des variables ; toutes les +non\-options sont ignorées silencieusement. L'analyse est faite avec +\fBgetopt_long\fP(3) qui est aussi utilisé pour les arguments de la ligne de +commandes. +.PP +\fBWarning:\fP By setting these environment variables, one is effectively +modifying programs and scripts that run \fBxz\fP. Most of the time it is safe +to set memory usage limits, number of threads, and compression options via +the environment variables. However, some options can break scripts. An +obvious example is \fB\-\-help\fP which makes \fBxz\fP show the help text instead of +compressing or decompressing a file. More subtle examples are \fB\-\-quiet\fP +and \fB\-\-verbose\fP. In many cases it works well to enable the progress +indicator using \fB\-\-verbose\fP, but in some situations the extra messages +create problems. The verbosity level also affects the behavior of +\fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +User\-specific or system\-wide default options. Typically this is set in a +shell initialization script to enable \fBxz\fP's memory usage limiter by +default or set the default number of threads. Excluding shell +initialization scripts and similar special cases, scripts should never set +or unset \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +This is for passing options to \fBxz\fP when it is not possible to set the +options directly on the \fBxz\fP command line. This is the case when \fBxz\fP is +run by a script or tool, for example, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Scripts may use \fBXZ_OPT\fP, for example, to set script\-specific default +compression options. It is still recommended to allow users to override +\fBXZ_OPT\fP if that is reasonable. For example, in \fBsh\fP(1) scripts one may +use something like this: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "Compatibilité des utilitaires LZMA" +La syntaxe de la ligne de commande de \fBxz\fP est quasimment un sur\-ensemble +de \fBlzma\fP, \fBunlzma\fP et \fBlzcat\fP comme ils sont trouvés dans les +utilitaires LZMA 4.32.x . Dans la pluspart des cas, il est possible de +remplacer les outils LZMA par les outils XZ sans casser les scripts +existants. Il existe cependant certaines incompatibilités qui peuvent +parfois poser des problèmes. +. +.SS "Niveaux de préréglage de la compression" +La numérotation des préréglages de niveau de compression est différente +entre les outils \fBxz\fP et LZMA. La différence la plus importante est la +manière dont les tailles de dictionnaire sont affectées aux différents +préréglages. La taille de dictionnaire est à peu près égale à celle +d'utilisation de la mémoire de la décompression. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Niveau;xz;Utilitaires LZMA +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Les différences de tailles des dictionnaires affectent aussi l'utilisation +de la mémoire du compresseur, mais il y a quelques autres différences entre +les outils LZMA et les outils XZ, qui rendent la différence encore plus +grande : +.RS +.PP +.TS +tab(;); +c c c +c n n. +Niveau;xz;Utilitaires LZMA 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Le niveau de préréglage par défaut dans les outils LZMA est \fB\-7\fP alors que +pour les outils XZ c'est \fB\-6\fP, les deux utilisent ainsi un dictionnaire de +8 Mio par défaut. +. +.SS "Fichiers .lzma en flux ou non" +The uncompressed size of the file can be stored in the \fB.lzma\fP header. +LZMA Utils does that when compressing regular files. The alternative is to +mark that uncompressed size is unknown and use end\-of\-payload marker to +indicate where the decompressor should stop. LZMA Utils uses this method +when uncompressed size isn't known, which is the case, for example, in +pipes. +.PP +\fBxz\fP prend en charge la décompression des fichiers \fB.lzma\fP avec ou sans +marqueur de fin de charge utile, mais tous les fichiers \fB.lzma\fP créés par +\fBxz\fP utiliseront un marqueur de fin de charge utile et ont la taille non +compréssée marquée comme inconnue dans l'en\-tête \fB.lzma\fP. Cela peut être un +problème dans quelques situations inhabituelles. Par exemple, un +décompresseur \fB.lzma\fP dans un périphérique embarqué pourrait ne fonctionner +qu'avec des fichiers dont la taille non comprimée est connue. Si vous vous +heurtez à ce problème, vous devez utiliser les utilitaires LZMA ou LZMA SDK +pour créer des fichiers \fB.lzma\fP avec une taille non compressée connue. +. +.SS "Fichiers .lzma non pris en charge" +Le format \fB.lzma\fP autorise des valeurs \fIlc\fP jusqu'à 8, et des valeurs +\fIlp\fP jusqu'à 4. Les outils LZMA peuvent décompresser des fichiers avec tous +les \fIlc\fP et \fIlp\fP, mais créez toujours les fichiers avec \fBlc=3\fP et +\fBlp=0\fP. Créer des fichiers avec d'autres valeurs \fIlc\fP et \fIlp\fP est +possible avec \fBxz\fP et avec LZMA SDK. +.PP +L'implémentation du filtre LZMA1 dans liblzma nécessite que la somme de +\fIlc\fP et \fIlp\fP soit inférieure ou égale à 4. Ainsi, les fichiers \fB.lzma\fP +qui excèdent cette limitation ne peuvent pas être décompressés avec \fBxz\fP. +.PP +Les outils LZMA créent seulement des fichiers \fB.lzma\fP qui ont une taille de +dictionnaire de 2^\fIn\fP (une puissance de 2) mais acceptent les fichiers avec +toutes les tailles de dictionnaire. Libzlma n'accepte que les fichiers +\&\fB.lzma\fP qui ont une taille dictionnaire de 2^\fIn\fP ou +2^\fIn\fP + 2^(\fIn\fP\-1). Cela afin de diminuer les faux positifs lors de la +détection des fichiers \fB.lzma\fP. +.PP +Ces limitations ne devraient pas poser problème en pratique, car +pratiquement tous les fichiers \fB.lzma\fP ont été compressés avec des réglages +que liblzma accepte. +. +.SS "Déchets excédentaires" +Lors de la décompession, l'utilitaire LZMA ignore silencieusement tout ce +qui est après le premier flux \fB.lzma\fP. Dans la majorité des situations, +c'est un bogue. Cela veut dire aussi que les outils LZMA ne gèrent pas la +décompression de fichiers \fB.lzma\fP concaténés. +.PP +S'il reste des données après le premier flux \fB.lzma\fP, \fBxz\fP considère que +le fichier est corrompu sauf si \fB\-\-single\-stream\fP a été utilisé. Cela peut +casser des scripts obscurs qui ont supposé que les déchets de fin de ligne +sont ignorés. +. +.SH NOTES +. +.SS "La sortie compressée peut varier" +La sortie compressée exacte produite par les même fichiers non compressés en +entrée peut varier en fonction des différentes versions de l'utilitaire XZ, +même si les options de compression sont identiques. En effet, il est +possible d'améliorer l'encodeur (compression plus rapide ou meilleure) sans +affecter le format du fichier. La sortie peut même varier entre différentes +compilations de la même version d'utilitaire XZ, si des options de +construction différentes sont utilisées. +.PP +Cela signifie qu'une fois que \fB\-\-rsyncable\fP a été implémenté, les fichiers +résultants ne seront pas nécessairement synchronisables avec rsync à moins +que les nouveaux et anciens fichiers n'aient été compressés avec la même +version de xz. Ce problème peut être résolu si une partie de +l'implémentation est gelée pour garantir la stabilité de la sortie rsyncable +à travers les versions de xz. +. +.SS "Décompresseurs .xz embarqués" +Les implémentations de décompresseur embarqué comme XZ Embedded ne gèrent +pas nécessairement les fichiers créés avec d'autres types de \fIvérification\fP +d'intégrité que \fBnone\fP et \fBCRC32\fP. Comme la valeur par défaut est +\fB\-\-check=crc64\fP, vous devez utiliser \fB\-\-check=none\fP ou \fB\-\-check=crc32\fP +lors de la création de fichiers pour les systèmes embarqués. +.PP +En dehors des systèmes embarqués, tous les décompresseurs de format \fB.xz\fP +gèrent tous les types de \fIvérification\fP ou sont au moins capables de +décompresser le fichier sans effectuer la vérification d'intégrité si ce +type de \fIvérification\fP particulière n'est pas pris en charge. +.PP +XZ Embedded prend en charge les filtres BCJ, mais seulement avec le décalage +de départ par défaut. +. +.SH EXEMPLES +. +.SS Bases +Compresser le fichier \fItoto\fP en \fItoto.xz\fP en utilisant le niveau de +compression par défaut (\fB\-6\fP) et supprimer \fItoto\fP si la compression +réussit : +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Décompresser \fIbidule.xz\fP en \fIbidule\fP et ne pas supprimer \fIbidule.xz\fP même +si la compression réussit : +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Create \fIbaz.tar.xz\fP with the preset \fB\-4e\fP (\fB\-4 \-\-extreme\fP), which is +slower than the default \fB\-6\fP, but needs less memory for compression and +decompression (48\ MiB and 5\ MiB, respectively): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Un mélange de fichiers compressés et non compressés peuvent être +décompressés vers la sortie standard avec une simple commande : +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Compression en parallèle de plusieurs fichiers" +Sur GNU et *BSD, \fBfind\fP(1) et \fBxargs\fP(1) peuvent être utilisés pour mettre +en parallèle la compression de plusieurs fichiers : +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +L'option \fBP\fP passée à \fBxargs\fP(1) fixe le nombre de processus \fBxz\fP en +parallèles. La meilleure valeur pour l'option \fBn\fP dépend du nombre de +fichiers à compresser. S\-il n'y a que quelques fichiers, la valeur sera +probablement 1 ; avec des dizaines de milliers de fichiers, 100 ou même plus +serait approprié pour réduire le nombre de processus \fBxz\fP que \fBxargs\fP(1) +créera éventuellement. +.PP +L'option \fB\-T1\fP de \fBxz\fP est là pour le forcer en mode mono\-thread, car +\fBxargs\fP(1) est utilisé pour contrôler la quantité de mise en parallèle. +. +.SS "Mode robot" +Calculer combien d'octets ont été économisés au total après avoir compressé +plusieurs fichiers : +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Un script peut vouloir savoir qu'il utilise une version suffisamment récente +de \fBxz\fP. Le script \fBsh\fP(1) suivant vérifie que le numéro de version de +l'outil \fBxz\fP soit au minimum 5.0.0. Cette méthode est compatible avec les +vieilles versions bêta, qui ne gèrent pas l'option \fB\-\-robot\fP : +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Régler une limite d'utilisation de la mémoire pour la décompression en +utilisant \fBXZ_OPT\fP, mais si une limite a déjà été définie, ne pas +l'augmenter : +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Chaînes de filtres de compresseur personnalisées" +L'utilisation la plus simple des chaînes de filtres personnalisées est la +personnalisation d'un préréglage LZMA2. Cela peut être utile, car les +préréglages ne couvrent qu'un sous\-ensemble des réglages de compression +potentiellement utiles. +.PP +Les colonnes CompCPU des tableaux des descriptions des options \fB\-0\fP à \fB\-9\fP +et \fB\-\-extreme\fP sont utiles lors de la personnalisation des préréglages +LZMA2. Voici les parties pertinentes recueillies à partir de ces deux +tableaux : +.RS +.PP +.TS +tab(;); +c c +n n. +Préréglage;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +If you know that a file requires somewhat big dictionary (for example, 32\ MiB) to compress well, but you want to compress it quicker than \fBxz \-8\fP +would do, a preset with a low CompCPU value (for example, 1) can be +modified to use a bigger dictionary: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Avec certains fichiers, la commande ci\-dessus peut être plus rapide que +\fBxz\-6\fP tout en compressant bien mieux. Cependant, il faut souligner que +seuls certains fichiers bénéficient d'un grand dictionnaire tout en gardant +la valeur de CompCPU faible. La siutation la plus évidente où un gros +dictionnaire peut baucoup aider, est une archive contenant des fichiers très +similaires de quelques megaoctets chacun. La taille de dictionnaire doit +être significativement plus grosse que tout fichier individuel pour +permettre à LZMA2 de tirer pleinement partie des similarités entre des +fichiers consécutifs. +.PP +Si une utilisation de la mémoire élevée pour la compression et décompression +convient, et que le fichier à compresser a une taille de plusieurs centaines +de megaoctets, il peut être utile d'utiliser un plus gros dictionnaire que +celui fourni par \fBxz\-9\fP (64 Mio) : +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Utiliser \fB\-vv\fP (\fB\-\-verbose\-\-verbose\fP) comme dans l'exemple ci\-dessus peut +être utile pour voir les besoins en mémoire du compresseur et du +décompresseur. Rappelez\-vous qu'utiliser un dictionnaire plus gros que la +taille du fichier non compressé est un gachis de mémoire, donc la commande +ci\-dessus n'est pas utile pour les petits fichiers. +.PP +Sometimes the compression time doesn't matter, but the decompressor memory +usage has to be kept low, for example, to make it possible to decompress the +file on an embedded system. The following command uses \fB\-6e\fP (\fB\-6 \-\-extreme\fP) as a base and sets the dictionary to only 64\ KiB. The +resulting file can be decompressed with XZ Embedded (that's why there is +\fB\-\-check=crc32\fP) using about 100\ KiB of memory. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +If you want to squeeze out as many bytes as possible, adjusting the number +of literal context bits (\fIlc\fP) and number of position bits (\fIpb\fP) can +sometimes help. Adjusting the number of literal position bits (\fIlp\fP) +might help too, but usually \fIlc\fP and \fIpb\fP are more important. For +example, a source code archive contains mostly US\-ASCII text, so something +like the following might give slightly (like 0.1\ %) smaller file than \fBxz \-6e\fP (try also without \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Using another filter together with LZMA2 can improve compression with +certain file types. For example, to compress a x86\-32 or x86\-64 shared +library using the x86 BCJ filter: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Notez que l'ordre des options de filtre est significatif. Si \fB\-\-x86\fP est +indiqué après \fB\-\-lzma2\fP, \fBxz\fP donnera une erreur, car il ne peut y avoir +aucun filtre après LZMA2, et aussi parce que le filtre BCJ x86 ne peut pas +être utilisé comme dernier filtre dans la chaîne. +.PP +Le filtre Delta associé à LZMA2 peut donner de bons résultats avec les +images bitmap. Cela devrait habituellement battre PNG, qui a quelques +filtres avancés supplémentaires qu'un simple delta, mais qui utilise Deflate +pour la compression effective. +.PP +The image has to be saved in uncompressed format, for example, as +uncompressed TIFF. The distance parameter of the Delta filter is set to +match the number of bytes per pixel in the image. For example, 24\-bit RGB +bitmap needs \fBdist=3\fP, and it is also good to pass \fBpb=0\fP to LZMA2 to +accommodate the three\-byte alignment: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +If multiple images have been put into a single archive (for example, +\&\fB.tar\fP), the Delta filter will work on that too as long as all images have +the same number of bytes per pixel. +. +.SH "VOIR AUSSI" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/xzdec.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/xzdec.1 new file mode 100644 index 0000000000000000000000000000000000000000..cd31d6c9fa4c623de4c5854ab74e2dbc32cbe10d --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/xzdec.1 @@ -0,0 +1,90 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.\" french translation of XZ Utils man +.\" Copyright (C) 2021 Debian French l10n team +.\" Translator +.\" bubu , 2021. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDEC 1 2024\-04\-08 Tukaani "Utilitaires XZ" +.SH NOM +xzdec, lzmadec \- Small .xz et .lzma decompresseurs +.SH SYNOPSIS +\fBxzdec\fP [\fIoption...\fP] [\fIfichier...\fP] +.br +\fBlzmadec\fP [\fIoption...\fP] [\fIfichier...\fP] +.SH DESCRIPTION +\fBxzdec\fP est un outil uniquement de décompression, basé sur liblzma pour les +fichiers \fB.xz\fP (et seulement \fB.xz\fP). \fBxzdec\fP est destiné à remplacer +\fBxz\fP(1) dans les situations les plus courantes où un script a été écrit +pour utiliser \fBxz \-\-decompress \-\-stdout\fP (et possiblement quelques autres +options courantes) pour décompresser des fichiers \fB.xz\fP. \fBlzmadec\fP est +identique à \fBxzdec\fP, sauf que \fBlzmadec\fP prend en charge les fichiers +\&\fB.lzma\fP au lieu des fichiers \fB.xz\fP. +.PP +Pour réduire la taille de l'exécutable, \fBxzdec\fP ne prend en charge ni le +multithreading ni la localisation et ne lit pas les options des variables +d'environnement \fBXZ_DEFAULTS\fP et \fBXZ_OPT\fP. \fBxzdec\fP ne gère pas +l'affichage d'information sur la progression du traitement : envoyer +\fBSIGINFO\fP à \fBxzdec\fP ne fait rien, mais envoyer \fBSIGUSR1\fP termine le +processus au lieu d'afficher de l'information sur la progression. +.SH OPTIONS +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +Ignoré pour la compatibilité avec \fBxz\fP(1), \fBxzdec\fP ne gère que la +décompression. +.TP +\fB\-k\fP, \fB\-\-keep\fP +Ignoré pour la compatibilité avec \fBxz\fP(1), \fBxzdec\fP ne crée ni ne supprime +jamais aucun fichier. +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Ignoré pour la compatibilité avec \fBxz\fP(1), \fBxzdec\fP écrit toujours les +données décompressées sur la sortie standard. +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Spécifier cela une fois ne fait rien, car \fBxzdec\fP n'affiche jamais aucun +avertissement ou notification. Spécifier cela deux fois pour supprimer les +erreurs. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Ignoré pour la compatibilité avec \fBxz\fP(1), \fBxzdec\fP n'utilise jamais le +satut de sortie 2. +.TP +\fB\-h\fP, \fB\-\-help\fP +Afficher un message d'aide et quitter. +.TP +\fB\-V\fP, \fB\-\-version\fP +Afficher le numéro de version de \fBxzdec\fP et liblzma. +.SH "STATUT DE SORTIE" +.TP +\fB0\fP +Tout s'est bien passé. +.TP +\fB1\fP +Une erreur est survenue. +.PP +A la différence de \fBxz\fP(1),\fBxzdec\fP n'a pas de messages d'avertissement, et +donc le statut de sortie 2 n'est pas utilisé par \fBxzdec\fP. +.SH NOTES +Utilisez \fBxz\fP(1) au lieu de \fBxzdec\fP ou \fBlzmadec\fP pour un usage normal de +tous les jours. \fBxzdec\fP ou \fBlzmadec\fP ne sont utiles que pour les +situations où il est important d'avoir un plus petit décompresseur que le +\fBxz\fP(1) complet. +.PP +\fBxzdec\fP et \fBlzmadec\fP ne sont en fait pas vraiment si petits. La taille +peut être encore réduite en abandonnant des fonctionnalités de liblzma au +moment de la compilation, mais cela ne devrait pas être fait pour des +exécutables distribués sur des systèmes d'exploitation classique non +embarqués. Si vous avez besoin d'un décompresseur vraiment petit, pensez à +utiliser XZ Embedded. +.SH "VOIR AUSSI" +\fBxz\fP(1) +.PP +XZ Embedded: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/xzless.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/xzless.1 new file mode 100644 index 0000000000000000000000000000000000000000..797382bd5158fcfdbdf4c3e7076bca088de2c223 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/fr/man1/xzless.1 @@ -0,0 +1,49 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" french translation of XZ Utils man +.\" Copyright (C) 2021 Debian French l10n team +.\" Translator +.\" bubu , 2021. +.\" +.\" (Note that this file is not based on gzip's zless.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZLESS 1 2025\-03\-06 Tukaani "Utilitaires XZ" +.SH NOM +xzless, lzless \- Voir le contenu des fichiers (texte) compressés xz ou lzma +.SH SYNOPSIS +\fBxzless\fP [\fIfichier\fP...] +.br +\fBlzless\fP [\fIfile\fP...] (DEPRECATED) +.SH DESCRIPTION +\fBxzless\fP is a filter that displays text from compressed files to a +terminal. Files supported by \fBxz\fP(1) are decompressed; other files are +assumed to be in uncompressed form already. If no \fIfiles\fP are given, +\fBxzless\fP reads from standard input. +.PP +\fBxzless\fP utilise \fBless\fP(1) pour afficher sa sortie. Contrairement à +\fBxzmore\fP, son choix d'afficheur ne peut pas être modifié en indiquant une +variable d'environnement. Les commandes sont basées sur \fBmore\fP(1) et +\fBvi\fP(1) et permettent des déplacements en avant et en arrière et des +recherches. Voir le manuel de \fBless\fP(1) pour plus d'information. +.PP +The command named \fBlzless\fP is provided for backward compatibility with LZMA +Utils. It is deprecated and will be removed in a future version. +.SH ENVIRONNEMENT +.TP +\fBLESSMETACHARS\fP +Une liste de caractères spéciaux pour l'interpréteur. Définis par \fBxzless\fP +à moins qu'ils ne l'aient déjà été dans l'environnement. +.TP +\fBLESSOPEN\fP +Définir en ligne de commande le décompresseur \fBxz\fP(1) à invoquer pour +préparer les fichiers en entrée pour \fBless\fP(1). +.SH "VOIR AUSSI" +\fBless\fP(1), \fBxz\fP(1), \fBxzmore\fP(1), \fBzless\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzcat.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzcat.1 new file mode 100644 index 0000000000000000000000000000000000000000..53a915947bff84fc5f9cfbb4d4ed88097620e055 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzcat.1 @@ -0,0 +1,2080 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Italian translations for xz-man package +.\" Luca Vercelli , 2024-2025 +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 08/03/2025 Tukaani "XZ Utils" +. +.SH NOME +xz, unxz, xzcat, lzma, unlzma, lzcat \- Comprime o decomprime file .xz e +\&.lzma +. +.SH SINOSSI +\fBxz\fP [\fIOPZIONE...\fP] [\fIFILE...\fP] +. +.SH "ALIAS DEI COMANDI" +\fBunxz\fP è equivalente a \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP è equivalente a \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP è equivalente a \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP è equivalente a \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP è equivalente a \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Quando si scrivono script che richiedono di decomprimere file, si raccomanda +di utilizzare sempre il comando \fBxz\fP con argomenti appropriati (\fBxz \-d\fP o +\fBxz \-dc\fP) al posto degli alias \fBunxz\fP e \fBxzcat\fP. +. +.SH DESCRIZIONE +\fBxz\fP è uno strumento di compressione dati generico con sintassi della riga +di comando simile a \fBgzip\fP(1) e \fBbzip2\fP(1). Il formato file nativo è +\&\fB.xz\fP, ma sono supportati anche il formato tradizionale \fB.lzma\fP usato +dalle LZMA Utils e i flussi grezzi (raw) compressi senza intestazioni di +formato contenitore. In più, è supportata la decompressione del formato +\&\fB.lz\fPusato da \fBlzip\fP. +.PP +\fBxz\fP comprime o decomprime ogni \fIFILE\fP a seconda della modalità di +funzionamento selezionata. Se nessun \fIFILE\fP è indicato o se \fIFILE\fP è \fB\-\fP, +\fBxz\fP legge dallo standard input e scrive i dati processati sullo standard +output. \fBxz\fP si rifiuterà (stamperà un errore e salterà il \fIFILE\fP) di +scrivere dati compressi sullo standard output se è il +terminale. Analogamente, \fBxz\fP si rifiuterà di leggere dati compressi dallo +standard input se è il terminale. +.PP +A meno che non sia specificato \fB\-\-stdout\fP, i \fIFILE\fP diversi da \fB\-\fP +vengono scritti in un nuovo file il cui nome deriva dal nome del \fIFILE\fP +sorgente: +.IP \(bu 3 +Quando si comprime, il suffisso del file destinazione (\fB.xz\fP or \fB.lzma\fP) +viene accodato al nome del file sorgente per ottenere il nome del file +destinazione. +.IP \(bu 3 +Quando si decomprime, i suffissi \fB.xz\fP, \fB.lzma\fP, o \fB.lz\fP vengono rimossi +dal nome del file per ottenere il nome del file destinazione. \fBxz\fP +riconosce anche i suffissi \fB.txz\fP e \fB.tlz\fP, e li sostituisce con il +suffisso \fB.tar\fP. +.PP +Se il file di destinazione esiste già, viene visualizzato un errore e +\fIFILE\fP viene saltato. +.PP +A meno che non si scriva nello standard output, \fBxz\fP visualizzerà un +avvertimento e salterà il \fIFILE\fP se si verifica una delle seguenti +condizioni: +.IP \(bu 3 +\fIFILE\fP non è un file regolare. I collegamenti simbolici non vengono +seguiti, quindi non sono considerati file regolari. +.IP \(bu 3 +\fIFILE\fP ha più di un collegamento "hard". +.IP \(bu 3 +\fIFILE\fP ha impostati i bit setuid, setgid, o sticky. +.IP \(bu 3 +La modalità di funzionamento è impostata sulla compressione e il \fIFILE\fP ha +già un suffisso del formato di file di destinazione (\fB.xz\fP o \fB.txz\fP quando +si comprime nel formato \fB.xz\fP e \fB.lzma\fP o \fB.tlz\fP quando si comprime nel +formato \fB.lzma\fP). +.IP \(bu 3 +La modalità di funzionamento è impostata sulla decompressione e il \fIFILE\fP +non ha un suffisso di nessuno dei formati di file supportati (\fB.xz\fP, +\&\fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, o \fB.lz\fP). +.PP +Dopo aver compresso o decompresso correttamente il \fIFILE\fP, \fBxz\fP copia il +proprietario, il gruppo, le autorizzazioni, l'ora di accesso e l'ora di +modifica dal \fIFILE\fP di origine al file di destinazione. Se la copia del +gruppo fallisce, le autorizzazioni vengono modificate in modo che il file di +destinazione non diventi accessibile agli utenti che non disponevano +dell'autorizzazione per accedere al \fIFILE\fP di origine. \fBxz\fP non supporta +ancora la copia di altri metadati, ad esempio elenchi di controllo degli +accessi o attributi estesi. +.PP +Una volta che il file di destinazione è stato chiuso con successo, il +\fIFILE\fP sorgente viene rimosso, a meno che sia stato specificato +\fB\-\-keep\fP. Il \fIFILE\fP sorgente non viene mai rimosso se l'output è scritto +sullo standard output, né se si verifica un errore. +.PP +L'invio di \fBSIGINFO\fP o \fBSIGUSR1\fP al processo \fBxz\fP comporta la stampa +delle informazioni sullo stato di avanzamento sullo standard error. Questo +ha solo un uso limitato poiché quando lo standard error è un terminale, +utilizzando \fB\-\-verbose\fP verrà visualizzato un indicatore di avanzamento che +si aggiorna automaticamente. +. +.SS "Utilizzo memoria" +L'utilizzo della memoria di \fBxz\fP varia da poche centinaia di kilobyte a +diversi gigabyte a seconda delle impostazioni di compressione. Le +impostazioni utilizzate durante la compressione di un file determinano i +requisiti di memoria del decompressore. In genere il decompressore richiede +dal 5\% al 20\% della quantità di memoria necessaria al compressore durante +la creazione del file. Ad esempio, la decompressione di un file creato con +\fBxz \-9\fP al momento richiede 65\ MiB di memoria. Ancora, è possibile avere +file \fB.xz\fP che richiedono diversi gigabyte di memoria per la +decompressione. +.PP +Soprattutto gli utenti di sistemi più vecchi possono trovare fastidiosa +l'eventualità di un utilizzo molto elevato di memoria. Per evitare +spiacevoli sorprese, \fBxz\fP dispone di un limitatore di utilizzo della +memoria incorporato, che è disabilitato per impostazione predefinita. Anche +se alcuni sistemi operativi forniscono modi per limitare l'utilizzo della +memoria dei processi, fare affidamento su questi non è stato ritenuto +sufficientemente flessibile (ad esempio, l'uso di \fBulimit\fP(1) per limitare +la memoria virtuale tende a paralizzare \fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Il limitatore di utilizzo della memoria può essere abilitato con l'opzione +della riga di comando \fB\-\-memlimit=\fP\fILIMITE\fP. Spesso è più conveniente +abilitare il limitatore per impostazione predefinita impostando la variabile +d'ambiente \fBXZ_DEFAULTS\fP, ad esempio, \fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. È +possibile impostare separatamente i limiti per la compressione e la +decompressione utilizzando \fB\-\-memlimit\-compress=\fP\fILIMITE\fP and +\fB\-\-memlimit\-decompress=\fP\fILIMITE\fP. L'uso di queste due opzioni al di fuori +di \fBXZ_DEFAULTS\fP è raramente utile perché una singola esecuzione di \fBxz\fP +non può eseguire sia la compressione che la decompressione e +\fB\-\-memlimit=\fP\fILIMITE\fP (or \fB\-M\fP \fILIMITE\fP) è più breve da digitare sulla +riga di comando. +.PP +Se il limite di utilizzo della memoria specificato viene superato durante la +decompressione, \fBxz\fP visualizzerà un errore e la decompressione del file +fallirà. Se il limite viene superato durante la compressione, \fBxz\fP tenterà +di ridimensionare le impostazioni in modo che il limite non venga più +superato (tranne quando si usa \fB\-\-format=raw\fP o \fB\-\-no\-adjust\fP). In questo +modo l'operazione non fallirà a meno che il limite sia molto basso. Il +ridimensionamento delle impostazioni viene eseguito in piccole differenze +che non corrispondono ai livelli di compressione preimpostati, ad esempio, +se il limite è solo leggermente inferiore alla quantità richiesta per \fBxz \-9\fP, le impostazioni saranno ridimensionate solo un poco, non proprio fino a +\fBxz \-8\fP. +. +.SS "Concatenazione e padding con file .xz" +È possibile concatenare i file \fB.xz\fP così come sono. \fBxz\fP decomprimerà +tali file come se fossero un singolo file \fB.xz\fP. +.PP +È possibile inserire un padding tra le parti concatenate o dopo l'ultima +parte. Il padding deve essere costituito da byte "null" e la dimensione del +padding deve essere un multiplo di quattro byte. Questo può essere utile, ad +esempio, se il file \fB.xz\fP è memorizzato su un supporto che misura le +dimensioni dei file in blocchi di 512 byte. +.PP +Concatenazione e padding non sono permessi con file \fB.lzma\fP o con flussi +grezzi. +. +.SH OPZIONI +. +.SS "Suffissi interi e valori speciali" +Nella maggior parte dei casi in cui è previsto un argomento intero, è +supportato un suffisso facoltativo per indicare facilmente numeri interi di +grandi dimensioni. Non deve esserci alcuno spazio tra il numero intero e il +suffisso. +.TP +\fBKiB\fP +Moltiplica l'intero per 1024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP, e \fBKB\fP +sono accettati come sinonimi di \fBKiB\fP. +.TP +\fBMiB\fP +Moltiplica l'intero per 1.048.576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP, e \fBMB\fP sono +accettati come sinonimi di \fBMiB\fP. +.TP +\fBGiB\fP +Moltiplica l'intero per 1.073.741.824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP, e \fBGB\fP +sono accettati come sinonimi di \fBGiB\fP. +.PP +Il valore speciale \fBmax\fP può essere utilizzato per indicare il valore +intero massimo supportato dall'opzione. +. +.SS "Modalità operativa" +Se vengono fornite più opzioni di modalità operativa, l'ultima ha effetto. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Compressione. Questa è la modalità operativa predefinita quando non viene +specificata alcuna opzione della modalità operativa e non è determinata +nessun'altra modalità operativa dal nome del comando (ad esempio, \fBunxz\fP +implica \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Dopo che la compressione è terminata con successo, il file origine viene +rimosso a meno che si stia scrivendo su standard output o che venga +specificato \fB\-\-keep\fP. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Decompressione. Dopo che la decompressione è terminata con successo, il file +origine viene rimosso a meno che si stia scrivendo su standard output o che +venga specificato \fB\-\-keep\fP. +.TP +\fB\-t\fP, \fB\-\-test\fP +Testa l'integrità dei \fIFILE\fP compressi. Questa opzione è equivalente a +\fB\-\-decompress \-\-stdout\fP tranne per il fatto che i dati decompressi vengono +scartati invece di essere scritti nello standard output. Nessun file viene +creato o rimosso. +.TP +\fB\-l\fP, \fB\-\-list\fP +Stampa le informazioni sul \fIFILE\fP compresso. Non viene prodotto alcun +output non compresso e non viene creato o rimosso alcun file. In modalità +elenco, il programma non è in grado di leggere i dati compressi dallo +standard input o da altre fonti che non permettano la ricerca. +.IP "" +Il tracciato predefinito mostra le informazioni di base sui \fIFILE\fP, un file +per riga. Per ottenere informazioni più dettagliate, usare anche l'opzione +\fB\-\-verbose\fP. Per avere ancora più informazioni, usare \fB\-\-verbose\fP due +volte, ma si noti che questo può essere lento, perché ottenere tutte le +informazioni extra richiede molte estrazioni. La larghezza dell'output +dettagliato supera gli 80 caratteri, quindi il reindirizzamento dell'output, +ad esempio, a \fBless\ \-S\fP può essere utile se il terminale non è +sufficientemente ampio. +.IP "" +L'output esatto può variare tra le versioni di \fBxz\fP e le diverse +impostazioni locali. Per un output leggibile dalla macchina si dovrebbe +utilizzare \fB\-\-robot \-\-list\fP. +. +.SS "Modificatori dell'operazione" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Non elimina i file input. +.IP "" +A partire da \fBxz\fP 5.2.6, questa opzione fa sì che \fBxz\fP comprima o +decomprima anche se l'input è un collegamento simbolico a un file regolare, +ha più di un collegamento fisico o ha il bit setuid, setgid o sticky +impostato. I bit setuid, setgid e sticky non vengono copiati nel file di +destinazione. Nelle versioni precedenti questo veniva fatto solo con +\fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Questa opzione ha diverse conseguenze: +.RS +.IP \(bu 3 +Se il file di destinazione esiste già, lo elimina prima di comprimere o +decomprimere. +.IP \(bu 3 +Comprime o decomprime anche se l'input è un collegamento simbolico a un file +regolare, ha più di un collegamento "hard", o ha il bit setuid, setgid o +sticky impostato. I bit setuid, setgid e sticky non sono copiati sul file +destinazione. +.IP \(bu 3 +Quando usato con \fB\-\-decompress\fP \fB\-\-stdout\fP e \fBxz\fP non riesce a +riconoscere il tipo di file sorgente, copia il file sorgente così com'è +sullo standard output. Questo permette a \fBxzcat\fP \fB\-\-force\fP di essere usato +come \fBcat\fP(1) per file che non siano stati compressi con \fBxz\fP. Si noti che +in futuro \fBxz\fP potrebbe supportare nuovi formati di file compressi, il che +potrebbe portare \fBxz\fP a decomprimere più tipi di file anziché copiarli come +sono sullo standard output. \fB\-\-format=\fP\fIFORMATO\fP può essere usato per +forzare \fBxz\fP a decomprimere solo un singolo formato di file. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Scrive i dati compressi o decompressi nello standard output anziché in un +file. Implica \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Decomprime solo il primo flusso \fB.xz\fP, e ignora automaticamente i possibili +dati di input rimanenti che seguono il flusso. Normalmente questi dati +sporchi finali portano \fBxz\fP a visualizzare un errore. +.IP "" +\fBxz\fP non decomprime mai più di un flusso dai file \fB.lzma\fP o dai flussi +grezzi, ma questa opzione fa comunque in modo che \fBxz\fP ignori i possibili +dati finali dopo il file \fB.lzma\fP o il flusso grezzo. +.IP "" +Questa opzione non ha effetto se la modalità operativa non è \fB\-\-decompress\fP +o \fB\-\-test\fP. +.IP "" +Dalla versione \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP implica \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Disabilita la creazione di file sparsi. Per impostazione predefinita, se si +esegue la decompressione in un file regolare, \fBxz\fP tenta di rendere il file +sparso se i dati decompressi contengono lunghe sequenze di zeri +binari. Funziona anche quando si scrive su standard output, purché lo +standard output sia collegato a un file regolare e siano soddisfatte alcune +condizioni aggiuntive per renderlo sicuro. La creazione di file sparsi può +risparmiare spazio su disco e velocizzare la decompressione riducendo la +quantità di I/O su disco. +.TP +\fB\-S\fP \fI.SUFFISSO\fP, \fB\-\-suffix=\fP\fI.SUFFISSO\fP +Durante la compressione, utilizzare \fI.suf\fP come suffisso per il file di +destinazione anziché \fB.xz\fP o \fB.lzma\fP. Se non si scrive nello standard +output e il file di origine ha già il suffisso \fI.suf\fP, viene visualizzato +un avvertimento e il file viene ignorato. +.IP "" +Quando si decomprime, accetta i file con suffisso \fI.suf\fP in aggiunta a +quelli con suffisso \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, o \fB.lz\fP. Se il file +sorgente ha suffisso \fI.suf\fP, il suffisso viene rimosso per ottenere il nome +del file destinazione. +.IP "" +Quando si comprimono o decomprimono flussi grezzi (\fB\-\-format=raw\fP), il +suffisso deve sempre essere specificato, a meno che si scriva sullo standard +output, perché non esiste un suffisso predefinito per i flussi grezzi. +.TP +\fB\-\-files\fP[\fB=\fP\fIFILE\fP] +Legge i nomi dei file da processare da \fIFILE\fP; se \fIFILE\fP è omesso, i nomi +dei file vengono letti dallo standard input. I nomi dei file devono essere +terminati da un carattere "a capo". Un trattino (\fB\-\fP) è considerato come un +nome di file regolare; non indica lo standard input. Se vengono forniti +anche dei nomi di file come argomenti della riga di comando, questi sono +processati prima di quelli letti da \fIFILE\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIFILE\fP] +Questo è identico a \fB\-\-files\fP[\fB=\fP\fIFILE\fP] tranne per il fatto che ogni +nome di file deve terminare con il carattere null. +. +.SS "Formato file di base e opzioni di compressione" +.TP +\fB\-F\fP \fIFORMATO\fP, \fB\-\-format=\fP\fIFORMATO\fP +Specifica il \fIFORMATO\fP del file da comprimere o decomprimere: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Questa è l'impostazione predefinita. Quando si comprime, \fBauto\fP è +equivalente a \fBxz\fP. Quando si decomprime, il formato del file input viene +rilevato automaticamente. Si noti che per i flussi grezzi (creati con +\fB\-\-format=raw\fP) non è possibile il rilevamento automatico. +.TP +\fBxz\fP +Comprime nel formato di file \fB.xz\fP, oppure accetta solo file \fB.xz\fP durante +la decompressione. +.TP +\fBlzma\fP, \fBalone\fP +Comprime nel formato tradizionale \fB.lzma\fP, oppure accetta solo file +\&\fB.lzma\fP per la decompressione. Il nome alternativo \fBalone\fP è fornito per +retrocompatibilità con le LZMA Utils. +.TP +\fBlzip\fP +Accetta solo file \fB.lz\fP per la decompressione. La compressione non è +supportata. +.IP "" +Sono supportate le versioni 0 e 1 del formato \fB.lz\fP. I file in versione 0 +sono stati prodotti da \fBlzip\fP 1.3 e precedenti. Questi file non sono +comuni, ma possono essere trovati negli archivi di file, perché alcuni +pacchetti sorgente erano stati rilasciati in questo formato. Qualcuno +potrebbe anche avere vecchi file personali in questo formato. Il supporto +alla decompressione per la versione di formato 0 è stato rimosso in \fBlzip\fP +1.18. \fBlzip\fP 1.4 e successivi creano i file nella versione di formato 1. +.TP +\fBraw\fP +Comprime o decomprime un flusso grezzo (senza intestazione). Questo è inteso +solamente per utenti avanzati. Per decodificare flussi grezzi, occorre usare +\fB\-\-format=raw\fP e specificare esplicitamente la catena dei filtri, che +normalmente sarebbero conservati nell'intestazione. +.RE +.TP +\fB\-C\fP \fICONTROLLO\fP, \fB\-\-check=\fP\fICONTROLLO\fP +Specifica il tipo di controllo di integrità. Il controllo viene calcolato +dai dati non compressi e memorizzato nel file \fB.xz\fP. Questa opzione ha +effetto solo quando si comprime nel formato \fB.xz\fP; il formato \fB.lzma\fP non +supporta i controlli di integrità. Il controllo di integrità (se presente) +viene verificato quando il file \fB.xz\fP viene decompresso. +.IP "" +Tipi di \fICONTROLLI\fP supportati: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Non calcola proprio il controllo di integrità. Questo in genere è una +pessima idea. Può essere utile quando l'integrità dei dati viene comunque +verificata con altri mezzi. +.TP +\fBcrc32\fP +Calcola la firma CRC32 usando il polinomio di IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Calcola la firma CRC64 usando il polinomio di ECMA\-182. Questa è +l'impostazione predefinita, perché è leggermente migliore della CRC32 nel +rilevare i file danneggiati e la differenza di velocità è trascurabile. +.TP +\fBsha256\fP +Calcola la firma SHA\-256. Questo è un po' più lento che CRC32 e CRC64. +.RE +.IP "" +L'integrità delle intestazioni \fB.xz\fP viene sempre verificata con CRC32. Non +è possibile modificarlo o disabilitarlo. +.TP +\fB\-\-ignore\-check\fP +Non verifica il controllo di integrità dei dati compressi durante la +decompressione. Il valore CRC3 nelle intestazioni \fB.xz\fP sarà ancora +verificata normalmente. +.IP "" +\fBNon usare questa opzione se non si è consci di cosa si sta facendo.\fP +Possibili ragioni per utilizzare questa opzione: +.RS +.IP \(bu 3 +Tentativo di recupero dei dati da un file .xz corrotto. +.IP \(bu 3 +Accelerazione della decompressione. Questo è importante soprattutto con +SHA\-256 o con i file che sono stati compressi molto bene. Si consiglia di +non utilizzare questa opzione per questo scopo, a meno che l'integrità del +file non venga verificata esternamente in altro modo. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Selezionare un livello di compressione preimpostato. Il valore predefinito è +\fB\-6\fP. Se vengono specificati più livelli preimpostati, l'ultimo ha +effetto. Se è già stata specificata una catena di filtri personalizzata, +l'impostazione di un livelli preimpostati cancella la catena di filtri +personalizzata. +.IP "" +Le differenze tra i livelli preimpostati sono più significative rispetto a +\fBgzip\fP(1) e \fBbzip2\fP(1). Le impostazioni di compressione selezionate +determinano i requisiti di memoria del decompressore, quindi l'utilizzo di +un livello preimpostato troppo alto potrebbe rendere difficile la +decompressione del file su un vecchio sistema con poca RAM. Specificamente, +\fBnon è una buona idea utilizzare ciecamente \-9 per tutto\fP come spesso +accade per \fBgzip\fP(1) e \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Questi sono livelli preimpostati piuttosto veloci. \fB\-0\-\fP a volte è più +veloce di \fBgzip \-9\fP e comprime molto meglio. Quelli più alti hanno spesso +una velocità paragonabile a \fBbzip2\fP(1) con un rapporto di compressione +comparabile o migliore, anche se i risultati dipendono molto dal tipo di +dati che vengono compressi. +.TP +\fB\-4\fP ... \fB\-6\fP +Compressione da buona a molto buona, mantenendo l'utilizzo della memoria del +decompressore ragionevole anche per vecchi sistemi. \fB\-6\fP è il valore +predefinito, che di solito è una buona scelta per distribuire file che +debbano essere decompressi anche su sistemi con solo 16\ MiB di +RAM. (Potrebbe valere la pena di considerare anche \fB\-5e\fP o \fB\-6e\fP. Si veda +\fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Questi sono come \fB\-6\fP ma con requisiti di memoria di compressore e +decompressore più elevati. Sono utili solo quando si comprimono file di +dimensioni superiori a 8\ MiB, 16\ MiB e 32\ MiB, rispettivamente. +.RE +.IP "" +A parità di hardware, la velocità di decompressione è approssimativamente un +numero costante di byte di dati compressi al secondo. In altre parole, +migliore è la compressione, più veloce sarà di solito la decompressione. Ciò +significa anche che la quantità di output non compresso prodotta al secondo +può variare notevolmente. +.IP "" +La tabella seguente riassume le caratteristiche dei livelli preimpostati: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Livello preimpostato;DictSize;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Descrizioni delle colonne: +.RS +.IP \(bu 3 +DictSize è la dimensione del dizionario LZMA2. È uno spreco di memoria usare +un dizionario più grande della dimensione del file non compresso. Ecco +perché è una buona cosa evitare di usare i livelli preimpostati \fB\-7\fP +\&... \fB\-9\fP quando non c'è reale necessità. Con \fB\-6\fP e inferiori, la quantità +di memoria sprecata in genere è sufficientemente bassa da essere +trascurabile. +.IP \(bu 3 +CompCPU è una rappresentazione semplificata delle impostazioni di LZMA2 che +influenzano la velocità di compressione. Anche la dimensione del dizionario +influenza la velocità, quindi mentre CompCPU è lo stesso per i livelli \fB\-6\fP +\&... \fB\-9\fP, i livelli più alti tendono ancora ad essere un po' più lenti. Per +avere una compressione ancora più lenta e quindi potenzialmente migliore, +utilizzare \fB\-\-extreme\fP. +.IP \(bu 3 +CompMem contiene i requisiti di memoria del compressore in modalità a +singola thread. Può variare leggermente tra le versioni di \fBxz\fP. +.IP \(bu 3 +DecMem contiene i requisiti di memoria del decompressore. In altre parole, +le impostazioni di compressione determinano i requisiti di memoria del +decompressore. L'utilizzo esatto della memoria del decompressore è +leggermente superiore alla dimensione del dizionario LZMA2, ma i valori +nella tabella sono stati arrotondati per eccesso al successivo MiB completo. +.RE +.IP "" +I requisiti di memoria per la modalità a thread multiple sono +significativamente più alti che per la modalità thread singola. Con il +valore predefinito di \fB\-\-block\-size\fP, ogni thread richiede 3*3*dimensione +del dizionario più CompMem oppure DecMem. Ad esempio, 4 thread con il +livello preimpostato \fB\-6\fP hanno bisogno di 660\(en670\ MiB di memoria. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Utilizzare una variante più lenta del livello preimpostato selezionato +(\fB\-0\fP ... \fB\-9\fP) nella speranza di ottenere un rapporto di compressione +leggermente migliore, ma con un po' di sfortuna questo potrebbe anche +renderlo peggiore. L'utilizzo della memoria del decompressore non è +influenzato, ma l'utilizzo della memoria del compressore aumenta leggermente +ai livelli preimpostati \fB\-0\fP ... \fB\-3\fP. +.IP "" +Dal momento che ci sono due livelli preimpostati con dimensione del +dizionario di 4\ MiB e 8\ MiB, i livelli preimpostati \fB\-3e\fP e \fB\-5e\fP usano +impostazioni leggermente più veloci (minore CompCPU) di \fB\-4e\fP e \fB\-6e\fP, +rispettivamente. In questo modo non ci sono due livelli preimpostati +identici. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Livello preimpostato;DictSize;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Ad esempio, ci sono un totale di quattro livelli preimpostati che utilizzano +un dizionario da 8\ MiB, il cui ordine dal più veloce al più lento è \fB\-5\fP, +\fB\-6\fP, \fB\-5e\fP, e \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Questi sono alias in qualche modo fuorvianti per \fB\-0\fP e \fB\-9\fP, +rispettivamente. Sono forniti solo per retrocompatibilità con le LZMA +Utils. Evitare di utilizzare queste opzioni. +.TP +\fB\-\-block\-size=\fP\fIDIMENSIONE\fP +Quando si comprime in formato \fB.xz\fP, divide i dati input in blocchi da +\fIDIMENSIONE\fP byte. I blocchi vengo compressi indipendentemente l'uno +dall'altro, cosa che aiuta con le thread multiple e rende possibile la +decompressione con accessi casuali limitati. Questa opzione viene usata +tipicamente per sovrascrivere la dimensione predefinita dei blocchi in +modalità a thread multiple, ma può essere utilizzata anche in modalità +thread singola. +.IP "" +In modalità a thread multiple verranno allocati circa il triplo di +\fIDIMENSIONE\fP di byte in ogni thread per il buffering dell'input e +dell'output. La \fIDIMENSIONE\fP predefinita è tre volte la dimensione del +dizionario LZMA2 e comunque almeno 1 MiB. Tipicamente un buon valore è +2\(en4 volte la dimensione del dizionario LZMA2 oppure almeno 1 MiB. Usare +una \fIDIMENSIONE\fP inferiore della dimensione del dizionario LZMA2 causa uno +spreco di RAM, in quanto il buffer del dizionario LZMA2 non verrà mai +riempito completamente. In modalità a thread multiple, la dimensione dei +blocchi è conservata nelle intestazioni dei blocchi. L'informazione sulla +dimensione è richiesta per la decompressione a thread multiple. +.IP "" +Nella modalità a thread singola, per impostazione predefinita non viene +eseguita alcuna suddivisione in blocchi. L'impostazione di questa opzione +non influisce sull'utilizzo della memoria. Nessuna informazione sulle +dimensioni viene memorizzata nelle intestazioni di blocco, quindi i file +creati in modalità a thread singola non saranno identici ai file creati in +modalità a thread multiple. La mancanza di informazioni sulle dimensioni +significa anche che \fBxz\fP non sarà in grado di decomprimere i file in +modalità a thread multiple. +.TP +\fB\-\-block\-list=\fP\fIELEMENTI\fP +Quando si comprime nel formato \fB.xz\fP, inizia un nuovo blocco con una catena +di filtri personalizzata dopo gli intervalli indicati di dati non compressi. +.IP "" +Gli \fIELEMENTI\fP sono un elenco separato da virgole. Ogni elemento è +costituito da un numero di catena di filtri opzionale compreso tra 0 e 9 +seguito da due punti (\fB:\fP) e da una dimensione richiesta di dati non +compressi. L'omissione di un elemento (due o più virgole consecutive) è una +scorciatoia per utilizzare le dimensioni e i filtri dell'elemento +precedente. +.IP "" +Se il file di input è più grande della somma delle dimensioni in +\fIELEMENTI\fP, l'ultimo elemento viene ripetuto fino alla fine del file. Il +valore speciale \fB0\fP può essere utilizzato come ultima dimensione per +indicare che il resto del file deve essere codificato come un singolo +blocco. +.IP "" +È possibile specificare una catena di filtri alternativa per ogni blocco in +combinazione con le opzioni \fB\-\-filters1=\fP\fIFILTRI\fP \&...\& +\fB\-\-filters9=\fP\fIFILTRI\fP. Queste opzioni definiscono catene di filtri con un +identificatore compreso tra 1\(en9. La catena di filtri 0 può essere +utilizzata per indicare la catena di filtri predefinita, che equivale a non +specificare una catena di filtri. L'identificatore della catena di filtri +può essere utilizzato prima della dimensione non compressa, seguita da due +punti (\fB:\fP). Ad esempio, se si specifica +\fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP allora i blocchi verranno +creati utilizzando: +.RS +.IP \(bu 3 +La catena dei filtri specificata da \fB\-\-filters1\fP e un input di 2 MiB +.IP \(bu 3 +La catena dei filtri specificata da \fB\-\-filters3\fP e un input di 2 MiB +.IP \(bu 3 +La catena dei filtri specificata da \fB\-\-filters2\fP e un input di 4 MiB +.IP \(bu 3 +La catena dei filtri specificata da \fB\-\-filters2\fP e un input di 4 MiB +.IP \(bu 3 +La catena di filtri predefinita e l'input di 2 MiB +.IP \(bu 3 +La catena di filtri predefinita e l'input di 4 MiB per ogni blocco fino alla +fine dell'input. +.RE +.IP "" +Se si specifica una dimensione che supera la dimensione del blocco del +codificatore (il valore predefinito in modalità thread oppure il valore +specificato con \fB\-\-block\-size=\fP\fIDIMENSIONE\fP), il codificatore creerà +blocchi aggiuntivi mantenendo i limiti specificati in \fIELEMENTI\fP. Ad +esempio, se si indica \fB\-\-block\-size=10MiB\fP +\fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP e il file input è di 80 MiB, si +otterranno 11 blocchi: 5, 10, 8, 10, 2, 10, 10, 4, 10, 10, and 1 MiB. +.IP "" +In modalità a thread multiple, le dimensioni dei blocchi vengono memorizzate +nelle intestazioni dei blocchi. Questo non avviene in modalità thread +singola, quindi l'output codificato non sarà identico a quello della +modalità a thread multiple. +.TP +\fB\-\-flush\-timeout=\fP\fITIMEOUT\fP +Quando si comprime, se sono passati più di \fITIMEOUT\fP millisecondi (un +intero positivo) dallo scaricamento precedente e la lettura di ulteriori +input si bloccherebbe, tutti i dati di input in sospeso vengono scaricati +dal codificatore e resi disponibili nel flusso di output. Questo può essere +utile se \fBxz\fP viene usato per comprimere dati in streaming dalla +rete. Piccoli valori del \fITIMEOUT\fP rendono disponibili i dati al ricevente +con un ritardo minimo, mentre valori di \fITIMEOUT\fP grandi danno un miglior +rapporto di compressione. +.IP "" +Questa funzionalità è disabilitata per impostazione predefinita. Se questa +opzione viene specificata più di una volta, l'ultima ha effetto. Il valore +speciale \fITIMEOUT\fP di \fB0\fP può essere utilizzato per disabilitare +esplicitamente questa funzionalità. +.IP "" +Questa funzionalità non è disponibile sui sistemi non\-POSIX. +.IP "" +.\" FIXME +\fBQuesta funzionalità è sperimentale.\fP Attualmente \fBxz\fP non è adatto per +decomprimere il flusso in tempo reale, a causa di come effettua il +buffering. +.TP +\fB\-\-no\-sync\fP +Non sincronizzare il file target e la sua directory sull'unità di +archiviazione prima di rimuovere il file sorgente. Questo può migliorare le +performance se si sta comprimendo o decomprimendo tanti piccoli +file. Tuttavia, se il sistema dovesse andare in crash subito dopo +l'eliminazione, è possibile che il file destinazione non sia ancora stato +scritto sull'unità di archiviazione mentre l'operazione di eliminazione +sì. In questo caso non saranno più disponibili né il file sorgente originale +né il file di destinazione. +.IP "" +Questa opzione ha effetto solamente quando \fBxz\fP deve rimuovere il file +sorgente. Negli altri casi la sincronizzazione non viene eseguita. +.IP "" +La sincronizzazione e \fB\-\-no\-sync\fP sono stati aggiunti nella versione \fBxz\fP +5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fILIMITE\fP +Imposta un limite di utilizzo della memoria per la compressione. Se questa +opzione viene specificata più volte, ha effetto l'ultima. +.IP "" +Se le impostazioni di compressione superano il valore \fILIMITE\fP, \fBxz\fP +tenterà di regolare le impostazioni verso il basso in modo che il limite non +venga più superato e visualizzerà un avviso che indica che è stata eseguita +una regolazione automatica. Le regolazioni vengono eseguite in questo +ordine: riduzione del numero di thread, passaggio alla modalità a thread +singola se anche un solo thread in modalità a thread multiple supera il +\fILIMITE\fP, e infine riducendo la dimensione del dizionario LZMA2. +.IP "" +Quando si comprime con \fB\-\-format=raw\fP oppure se si è specificato +\fB\-\-no\-adjust\fP, è possibile ridurre solo il numero di thread, poiché questo +può essere fatto senza influire sull'output compresso. +.IP "" +Se non è possibile soddisfare il \fILIMITE\fP anche con le regolazioni sopra +descritte, viene visualizzato un errore e \fBxz\fP uscirà con lo stato di +uscita 1. +.IP "" +Il \fILIMITE\fP può essere specificato in diversi modi: +.RS +.IP \(bu 3 +Il \fILIMITE\fP può essere un valore assoluto in byte. Usare un suffisso intero +come \fBMiB\fP può essere utile. Ad esempio: \fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +Il \fILIMITE\fP può essere specificato come percentuale della memoria fisica +(RAM) totale. Questo può essere utile specialmente quando si imposta la +variabile di ambiente \fBXZ_DEFAULTS\fP in uno script di inizializzazione di +shell che è condiviso tra computer diversi. In questo modo il limite è +automaticamente più grande sui sistemi con più memoria. Ad esempio: +\fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +Il \fILIMITE\fP può essere reimpostato al suo valore predefinito impostandolo a +\fB0\fP.Questo attualmente equivale a impostare il \fILIMITE\fP a \fBmax\fP (nessun +limite nell'utilizzo di memoria). +.RE +.IP "" +Per \fBxz\fP a 32\-bit esiste un caso particolare: se il \fILIMITE\fP fosse oltre +\fB4020\ MiB\fP, il \fILIMITE\fP viene impostato a \fB4020\ MiB\fP. Su MIPS32 invece +viene usato \fB2000\ MiB\fP. (I valori \fB0\fP e \fBmax\fP non sono influenzati da +questo. Un comportamento simile non esiste per la decompressione). Questo +può essere utile quando un eseguibile a 32 bit ha accesso a uno spazio di +indirizzi da 4\ GiB (2 GiB su MIPS32), e si spera che non faccia danni in +altre situazioni. +.IP "" +Vedere anche la sezione \fBUtilizzo memoria\fP +.TP +\fB\-\-memlimit\-decompress=\fP\fILIMITE\fP +Imposta un limite di utilizzo della memoria per la decompressione. Questo +influisce anche sulla modalità \fB\-\-list\fP. Se l'operazione non è possibile +senza oltrepassare il \fILIMITE\fP, \fBxz\fP mostrerà un errore e la +decompressione del file fallirà. Si veda \fB\-\-memlimit\-compress=\fP\fILIMITE\fP +per possibili modi per specificare il \fILIMITE\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fILIMITE\fP +Imposta un limite di utilizzo della memoria per la decompressione +multi\-thread. Questo può influire solo sul numero di thread; non indurrà mai +\fBxz\fP a rifiutarsi di decomprimere un file. Se \fILIMITE\fP è troppo basso per +consentire le thread multiple, il \fILIMITE\fP viene ignorato e \fBxz\fP +continuerà in modalità a thread singola. Si noti che se viene utilizzato +anche \fB\-\-memlimit\-decompress\fP, si applicherà sempre sia alla modalità a +thread singola che a quella a thread multiple, e quindi il \fILIMITE\fP +effettivo per le thread multiple non sarà mai superiore a quello impostato +con \fB\-\-memlimit\-decompress\fP. +.IP "" +In contrasto con le altre opzioni di limite di utilizzo della memoria, +\fB\-\-memlimit\-mt\-decompress=\fP\fILIMITE\fP ha un \fILIMITE\fP predefinito specifico +per il sistema. \fBxz \-\-info\-memory\fP può essere utilizzato per vedere il +valore corrente. +.IP "" +Questa opzione e il suo valore predefinito esistono perché, senza un limite, +il decompressore a thread multiple potrebbe finire per allocare una quantità +folle di memoria per alcuni file input. Se il valore predefinito \fILIMITE\fP è +troppo basso sul proprio sistema, è possibile aumentarlo liberamente, ma non +deve essere mai impostato a un valore più grande della quantità di RAM +utilizzabile, in quanto con file di input appropriati \fBxz\fP cercherà di +utilizzare quella quantità di memoria anche con un basso numero di +thread. Esaurire la memoria o fare swap non migliorerà le performance della +decompressione. +.IP "" +Vedi \fB\-\-memlimit\-compress=\fP\fILIMITE\fP per possibili modi per specificare il +\fILIMITE\fP. Impostando \fILIMITE\fP su \fB0\fP si ripristina il valore predefinito +\fILIMITE\fP specifico del sistema. +.TP +\fB\-M\fP \fILIMITE\fP, \fB\-\-memlimit=\fP\fILIMITE\fP, \fB\-\-memory=\fP\fILIMITE\fP +Questo equivale a specificare \fB\-\-memlimit\-compress=\fP\fILIMITE\fP +\fB\-\-memlimit\-decompress=\fP\fILIMITE\fP \fB\-\-memlimit\-mt\-decompress=\fP\fILIMITE\fP. +.TP +\fB\-\-no\-adjust\fP +Visualizza un errore e esce se non è possibile soddisfare il limite di +utilizzo della memoria senza regolare le impostazioni che influiscono +sull'output compresso. In altre parole, ciò impedisce a \fBxz\fP di passare il +codificatore dalla modalità multi\-thread alla modalità a thread singola e di +ridurre le dimensioni del dizionario LZMA2. Anche quando viene usata questa +opzione, il numero di thread può essere ridotto per soddisfare il limite di +utilizzo della memoria, in quanto ciò non influirà sull'output compresso. +.IP "" +La regolazione automatica è sempre disabilitata quando si creano flussi raw +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fITHREADS\fP, \fB\-\-threads=\fP\fITHREADS\fP +Specifica il numero di thread di lavoro da utilizzare. L'impostazione di +\fITHREADS\fP al valore speciale \fB0\fP fa sì che \fBxz\fP utilizzi fino a un numero +di thread che il processore/i del sistema supportano. Il numero effettivo di +thread può essere inferiore a \fITHREADS\fP se il file di input non è +sufficientemente grande per il threading con le impostazioni specificate o +se l'utilizzo di più thread supera il limite di utilizzo della memoria. +.IP "" +I compressori a thread singola e a thread multiple producono output +diversi. Il compressore a thread singola produrrà la dimensione del file più +piccola, ma solo l'output del compressore a thread multiple può essere +decompresso utilizzando più thread. Impostando \fITHREADS\fP su \fB1\fP verrà +utilizzata la modalità a thread singola. L'impostazione di \fITHREADS\fP su +qualsiasi altro valore, incluso \fB0\fP, utilizzerà il compressore a thread +multiple anche se il sistema supporta un solo thread hardware. (\fBxz\fP 5.2.x +utilizzava la modalità a thread singola in questa situazione.) +.IP "" +Per utilizzare la modalità a thread multiple con un solo thread, impostare +\fITHREADS\fP su \fB+1\fP. Il prefisso \fB+\fP non ha alcun effetto con valori +diversi da \fB1\fP. Un limite di utilizzo della memoria può comunque far +passare \fBxz\fP alla modalità a thread singola a meno che non venga utilizzato +\fB\-\-no\-adjust\fP. Il supporto per il prefisso \fB+\fP è stato aggiunto in \fBxz\fP +5.4.0. +.IP "" +Se è stato richiesto un numero automatico di thread e non è stato +specificato alcun limite di utilizzo della memoria, verrà utilizzato un +limite "soft" predefinito, specifico del sistema, per limitare eventualmente +il numero di thread. È un limite "soft" nel senso che viene ignorato se il +numero di thread diventa uno, quindi un limite soft non impedirà mai a \fBxz\fP +di comprimere o decomprimere. Questo limite soft predefinito non farà +passare \fBxz\fP dalla modalità a thread multiple alla modalità thread +singola. I limiti attivi possono essere visualizzati con \fBxz \-\-info\-memory\fP. +.IP "" +Attualmente l'unico metodo di threading consiste nel dividere l'input in +blocchi e comprimerli indipendentemente l'uno dall'altro. La dimensione +predefinita del blocco dipende dal livello di compressione e può essere +sovrascritta con l'opzione \fB\-\-block\-size=\fP\fIDIMENSIONE\fP. +.IP "" +La decompressione a thread multiple funziona solo su file che contengano più +blocchi con l'informazione della dimensione nelle intestazioni del +blocco. Tutti i file sufficientemente grandi compressi in modalità a thread +multiple soddisfano questa condizione, mentre i file compressi in modalità +thread singola no, neanche se si è utilizzato \fB\-\-block\-size=\fP +\fIDIMENSIONE\fP. +.IP "" +Il valore predefinito per \fITHREADS\fP è \fB0\fP. In \fBxz\fP 5.4.x e precedenti il +valore predefinito era \fB1\fP. +. +.SS "Catene di filtri di compressione personalizzate" +Una catena di filtri personalizzata consente di specificare in dettaglio le +impostazioni di compressione invece di fare affidamento sulle impostazioni +associate ai livelli preimpostati. Quando viene specificata una catena di +filtri personalizzata, le opzioni relative ai livelli preimpostati (\fB\-0\fP +\&...\& \fB\-9\fP e \fB\-\-extreme\fP) specificate in precedenza sulla riga di +comando vengono dimenticate. Se un'opzione livello preimpostato viene +specificata dopo una o più opzioni della catena di filtri personalizzata, il +nuovo livello preimpostato ha effetto e le opzioni della catena di filtri +personalizzate specificate in precedenza vengono dimenticate. +.PP +Una catena di filtri è paragonabile a una pipe sulla riga di +comando. Durante la compressione, l'input non compresso va al primo filtro, +il cui output va al filtro successivo (se presente). L'output dell'ultimo +filtro viene scritto nel file compresso. Il numero massimo di filtri nella +catena è quattro, ma in genere una catena di filtri ha solo uno o due +filtri. +.PP +Molti filtri hanno limitazioni su dove possono trovarsi nella catena di +filtri: alcuni filtri possono funzionare solo come ultimo filtro della +catena, altri solo come filtro non ultimo e alcuni funzionano in qualsiasi +posizione nella catena. A seconda del filtro, questa limitazione è inerente +alla struttura del filtro oppure esiste per evitare problemi di sicurezza. +.PP +Una catena di filtri personalizzata può essere specificata in due modi +diversi. Le opzioni \fB\-\-filters=\fP\fIFILTRI\fP and \fB\-\-filters1=\fP\fIFILTRI\fP +\&...\& \fB\-\-filters9=\fP\fIFILTRI\fP permettono di specificare un'intera catena +di filtri in una opzione utilizzando la sintassi della stringa del filtro di +lzma. In alternativa, una catena di filtri può essere specificata +utilizzando una o più singole opzioni di filtro nell'ordine desiderato nella +catena di filtri. Questo significa che l'ordine delle singole opzioni di +filtro è importante! Quando si decodificano i flussi grezzi +(\fB\-\-format=raw\fP), la catena di filtri deve essere specificata nello stesso +ordine in cui è stata specificata durante la compressione. Qualsiasi filtro +individuale o opzione livello preimpostato specificata prima dell'opzione +della catena completa (\fB\-\-filters=\fP\fIFILTRI\fP) verrà dimenticata. I singoli +filtri specificati dopo l'opzione della catena completa reimposteranno la +catena di filtri. +.PP +Sia l'opzione di filtro completo che quella individuale accettano \fIOPZIONI\fP +specifiche del filtro come un elenco separato da virgole. Virgole in eccesso +nelle \fIOPZIONI\fP vengono ignorate. Ogni opzione ha un valore di default, +quindi occorre specificare solamente quelle che si desidera modificare. +.PP +Per vedere l'intera catena di filtri e \fIOPZIONI\fP, usa \fBxz \-vv\fP (ossia, usa +\fB\-\-verbose\fP due volte). Questo funziona anche per visualizzare le opzioni +della catena di filtri utilizzate dai livelli preimpostati. +.TP +\fB\-\-filters=\fP\fIFILTRI\fP +Specifica l'intera catena dei filtri oppure un livello preimpostato in una +singola opzione. Ogni filtro può essere separato da spazi o da due trattini +(\fB\-\-\fP). Potrebbe essere necessario mettere tra virgolette i \fIFILTRI\fP sulla +riga di comando della shell in modo che vengano analizzati come una singola +opzione. Per indicare \fIOPZIONI\fP, usa \fB:\fP o \fB=\fP. Un livello preimpostato +può essere preceduto da un \fB\-\fP e seguito da zero o più flag. L'unico flag +supportato è \fBe\fP per applicare le stesse opzioni di \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIFILTRI\fP ... \fB\-\-filters9\fP=\fIFILTRI\fP +Specifica fino a nove catene di filtri aggiuntive che possono essere +utilizzate con \fB\-\-block\-list\fP. +.IP "" +Ad esempio, quando si comprime un archivio con file eseguibili seguiti da +file di testo, la parte eseguibile potrebbe utilizzare una catena di filtri +con un filtro BCJ e la parte di testo solo il filtro LZMA2. +.TP +\fB\-\-filters\-help\fP +Mostra un messaggio di aiuto che descrive come specificare livelli +preimpostati e catene di filtri personalizzati nelle opzioni \fB\-\-filters\fP e +\fB\-\-filters1=\fP\fIFILTRI\fP \&...\& \fB\-\-filters9=\fP\fIFILTRI\fP, e termina con +successo. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIOPZIONI\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIOPZIONI\fP] +.PD +Aggiunge un filtro LZMA1 o LZMA2 alla catena dei filtri. Questi filtri +possono essere usati solo come ultimo filtro della catena. +.IP "" +LZMA1 è un filtro obsoleto, supportato quasi esclusivamente a causa del +formato obsoleto di file \fB.lzma\fP, che supporta solo LZMA1. LZMA2 è una +versione aggiornata di LZMA1 che risolve alcuni problemi pratici di +LZMA1. Il formato \fB.xz\fP utilizza LZMA2 e non supporta LZMA1. La velocità e +i rapporti di compressione di LZMA1 e LZMA2 sono praticamente gli stessi. +.IP "" +LZMA1 e LZMA2 condividono lo stesso insieme di \fIOPZIONI\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIPRESET\fP +Reimposta tutte le \fIOPZIONI\fP LZMA1 o LZMA2 a \fIPRESET\fP. Il \fIPRESET\fP +(livello preimpostato) consiste di un numero intero, che può essere seguito +da modificatori costituiti da una singola lettera. Il numero intero può +andare da \fB0\fP a \fB9\fP, corrispondenti alle opzioni della riga di comando +\fB\-0\fP \&...\& \fB\-9\fP. L'unico modificatore attualmente supportato è \fBe\fP, che +corrisponde a \fB\-\-extreme\fP. Se non viene specificato alcun \fIPRESET\fP, i +valori predefiniti delle \fIOPZIONI\fP LZMA1 o LZMA2 sono presi dal livello +preimpostato \fB6\fP. +.TP +\fBdict=\fP\fIDIMENSIONE\fP +La \fIDIMENSIONE\fPdel dizionario (buffer di cronologia) indica quanti byte dei +dati non compressi elaborati di recente vengono mantenuti in +memoria. L'algoritmo tenta di trovare sequenze di byte ripetute +(corrispondenze) nei dati non compressi e di sostituirle con riferimenti ai +dati attualmente presenti nel dizionario. Più grande è il dizionario, +maggiore è la possibilità di trovare una corrispondenza. Quindi, l'aumento +della \fIDIMENSIONE\fP del dizionario di solito migliora il rapporto di +compressione, ma un dizionario più grande del file non compresso è uno +spreco di memoria. +.IP "" +Una \fIDIMENSIONE\fP tipica per un dizionario è da 64\ KiB a 64\ MiB. Il minimo +è 4\ KiB. Il massimo per la compressione è attualmente 1.5\ GiB (1536\ MiB). La decompressione supporta già dizionari fino a 4\ GiB meno 1 byte, +che è il massimo per i formati di flusso LZMA1 e LZMA2. +.IP "" +La \fIDIMENSIONE\fP del dizionario e il cercatore di corrispondenze +(\fICERCATORE\fP) insieme determinano l'utilizzo della memoria del codificatore +LZMA1 o LZMA2. Per la decompressione è necessaria la stessa \fIDIMENSIONE\fP +del dizionario utilizzata durante la compressione (o più grande), quindi +l'utilizzo della memoria del decodificatore è determinato dalla dimensione +del dizionario utilizzato durante la compressione. Le intestazioni \fB.xz\fP +memorizzano la \fIDIMENSIONE\fP del dizionario come 2^\fIn\fP o 2^\fIn\fP + 2^( +\fIn\fP\-1), quindi queste \fIDIMENSIONI\fP sono in qualche modo preferite per la +compressione. Altre \fIDIMENSIONI\fP verranno arrotondate per eccesso quando +memorizzate nelle intestazioni \fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Specificare il numero di bit di contesto letterali. Il minimo è 0 e il +massimo è 4; Il valore predefinito è 3. Inoltre, la somma di \fIlc\fP e \fIlp\fP +non deve superare 4. +.IP "" +Tutti i byte che non possono essere codificati come corrispondenze vengono +codificati come valori letterali. In altre parole, i valori letterali sono +semplicemente byte a 8 bit codificati uno alla volta. +.IP "" +La codifica letterale presuppone che i bit di \fIlc\fP più alti del byte non +compresso precedente siano correlati al byte successivo. Ad esempio, in un +tipico testo inglese, una lettera maiuscola è spesso seguita da una lettera +minuscola e una lettera minuscola è solitamente seguita da un'altra lettera +minuscola. Nel set di caratteri US\-ASCII, i tre bit più alti sono 010 per le +lettere maiuscole e 011 per le lettere minuscole. Quando \fIlc\fP è almeno 3, +la codifica letterale può sfruttare questa proprietà nei dati non compressi. +.IP "" +Il valore predefinito (3) solitamente è buono. Se si desidera la +compressione massima, provare con \fBlc=4\fP. A volte aiuta un po', e a volte +rende la compressione peggiore. Se la rende peggiore, provare anche \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Specificare il numero di bit di posizione letterale. Il minimo è 0 e il +massimo è 4; Il valore predefinito è 0. +.IP "" +Il parametro \fIlp\fP influisce sul tipo di allineamento nei dati non compressi +presunto durante la codifica dei valori letterali. Vedi \fIpb\fP di seguito per +ulteriori informazioni sull'allineamento. +.TP +\fBpb=\fP\fIpb\fP +Specificare il numero di bit di posizione. Il minimo è 0 e il massimo è 4; +Il valore predefinito è 2. +.IP "" +Il parametro \fIpb\fP influisce su quale tipo di allineamento nei dati non +compressi sia assunto in generale. L'impostazione predefinita indica un +allineamento a quattro byte (2^\fIpb\fP =2^2=4), che è spesso una buona scelta +se non c'è un'ipotesi migliore. +.IP "" +Quando l'allineamento è noto, impostare \fIpb\fP concordemente può ridurre un +po' le dimensioni del file. Ad esempio, con file di testo con 1 byte di +allineamento (US\-ASCII, ISO\-8859\-*, UTF\-8), impostare \fBpb=0\fP può migliorare +leggermente la compressione. Per il testo UTF\-16, \fBpb=1\fP è una buona +scelta. Se l'allineamento è un numero dispari, come 3 byte, \fBpb=0\fP potrebbe +essere la scelta migliore. +.IP "" +Anche se l'allineamento assunto può essere regolato con \fIpb\fP e \fIlp\fP, LZMA1 +e LZMA2 favoriscono ancora leggermente l'allineamento a 16 byte. Potrebbe +valere la pena tenerlo in considerazione quando si progettano formati di +file che possono essere spesso compressi con LZMA1 o LZMA2. +.TP +\fBmf=\fP\fICERCATORE\fP +Il cercatore di corrispondenze ha un effetto importante sulla velocità del +codificatore, sull'utilizzo della memoria e sul rapporto di compressione. Di +solito i cercatori di corrispondenze a catena hash sono più veloci dei +cercatori di corrispondenze ad albero binario. Il valore predefinito dipende +da \fIPRESET\fP : 0 usa \fBhc3\fP, 1\(en3 usa \fBhc4\fP e il resto usa \fBbt4\fP. +.IP "" +Sono supportati i seguenti cercatori di corrispondenze. Le formule di +utilizzo della memoria riportate di seguito sono approssimazioni, che sono +le più vicine alla realtà quando \fIDIZIONARIO\fP è una potenza di due. +.RS +.TP +\fBhc3\fP +Catena hash con hashing da 2 e 3 byte +.br +Minimo valore per \fINICE\fP: 3 +.br +Utilizzo memoria: +.br +\fIDIZIONARIO\fP * 7.5 (se \fIDIZIONARIO\fP <= 16 MiB); +.br +\fIDIZIONARIO\fP * 5.5 + 64 MiB (se \fIDIZIONARIO\fP > 16 MiB) +.TP +\fBhc4\fP +Catena hash con hash da 2, 3 e 4 byte +.br +Minimo valore per \fINICE\fP: 4 +.br +Utilizzo memoria: +.br +\fIDIZIONARIO\fP * 7.5 (se \fIDIZIONARIO\fP <= 32 MiB); +.br +\fIDIZIONARIO\fP * 6.5 (se \fIDIZIONARIO\fP > 32 MiB) +.TP +\fBbt2\fP +Albero binario con hashing da 2 byte +.br +Valore minimo per \fINICE\fP: 2 +.br +Utilizzo di memoria: \fIDIZIONARIO\fP * 9.5 +.TP +\fBbt3\fP +Albero binario con hashing da 2 e 3 byte +.br +Minimo valore per \fINICE\fP: 3 +.br +Utilizzo memoria: +.br +\fIDIZIONARIO\fP * 11.5 (se \fIDIZIONARIO\fP <= 16 MiB); +.br +\fIDIZIONARIO\fP * 9.5 + 64 MiB (se \fIDIZIONARIO\fP > 16 MiB) +.TP +\fBbt4\fP +Albero binario con hashing da 2, 3 e 4 byte +.br +Minimo valore per \fINICE\fP: 4 +.br +Utilizzo memoria: +.br +\fIDIZIONARIO\fP * 11.5 (se \fIDIZIONARIO\fP <= 32 MiB); +.br +\fIDIZIONARIO\fP * 10.5 (se \fIDIZIONARIO\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fIMODALITÀ\fP +La \fIMODALITÀ\fP di compressione specifica il metodo per analizzare i dati +prodotti dal cercatore di corrispondenze. Le \fIMODALITÀ\fP supportate sono +\fBfast\fP e \fBnormal\fP. Il predefinito è \fBfast\fP per i \fIPRESET\fP 0\(en3 e +\fBnormal\fP per i \fIPRESET\fP 4\(en9. +.IP "" +Di solito \fBfast\fP viene utilizzato con i cercatori di corrispondenze a +catena hash e \fBnormal\fP con i cercatori di corrispondenze a albero +binario. Questo è anche quello che fanno i \fIPRESET\fP. +.TP +\fBnice=\fP\fINICE\fP +Specifica quella che si considera una lunghezza accettabile ("nice") per una +corrispondenza. Una volta trovata una corrispondenza di almeno \fINICE\fP byte, +l'algoritmo smette di cercare corrispondenze potenzialmente migliori. +.IP "" +\fINICE\fP può valere 2\(en273 byte. Valori più alti tendono a dare un miglior +rapporto di compressione ai danni della velocità. Il valore predefinito +dipende dal \fIPRESET\fP. +.TP +\fBdepth=\fP\fIPROFONDITÀ\fP +Specificare la profondità di ricerca massima nel cercatore di +corrispondenze. Il valore predefinito è il valore speciale 0, che dice al +compressore di determinare una \fIPROFONDITÀ\fP ragionevole da \fICERCATORE\fP e +\fINICE\fP. +.IP "" +Una \fIPROFONDITÀ\fP ragionevole per le catene hash è 4\(en100 e 16\(en1000 per +gli alberi binari. Utilizzando valori di \fIPROFONDITÀ\fP molto alti si può +rendere il codificatore estremamente lento con alcuni file. Evitare di +impostare la \fIPROFONDITÀ\fP oltre 1000 a meno che si sia preparati a +interrompere la compressione nel caso in cui richieda troppo tempo. +.RE +.IP "" +Quando si decomprime un flusso grezzo (\fB\-\-format=raw\fP), LZMA2 ha bisogno +solamente della \fIDIMENSIONE\fP del dizionario. LZMA1 ha anche bisogno di +\fIlc\fP, \fIlp\fP, e \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIOPZIONI\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIOPZIONI\fP] +.PD +Aggiunge un filtro branch/call/jump (BCJ) alla catena dei filtri. Questi +filtri non possono essere utilizzati come ultimo filtro nella catena di +filtri. +.IP "" +Un filtro BCJ converte gli indirizzi relativi in codice macchina nelle loro +controparti assolute. Questo non cambia la dimensione dei dati ma aumenta la +ridondanza, cosa che può aiutare LZMA2 a produrre \fB.xz\fP file 0\(en15\ % più +piccoli. I filtri BCJ sono sempre reversibili, quindi usare un filtro BCJ +per il tipo di dati sbagliato non causa perdita di dati, al massimo può +determinare un rapporto di compressione leggermente peggiore. I filtri BCJ +sono molto veloci e usano una quantità di memoria minima. +.IP "" +Questi filtri BCJ presentano problemi noti relativi al rapporto di +compressione: +.RS +.IP \(bu 3 +Alcuni tipi di file contenenti codice eseguibile (ad esempio, file oggetto, +librerie statiche e moduli del kernel Linux) hanno gli indirizzi nelle +istruzioni riempiti con valori di riempimento. Questi filtri BCJ eseguiranno +comunque la conversione degli indirizzi, il che peggiorerà la compressione +con questi file. +.IP \(bu 3 +Se un filtro BCJ viene applicato a un archivio, è possibile che renda il +rapporto di compressione peggiore rispetto a non usare un filtro BCJ. Ad +esempio, se ci sono eseguibili simili o addirittura identici, il filtraggio +probabilmente renderà i file meno simili e quindi la compressione sarà +peggiore. Anche il contenuto dei file non eseguibili nello stesso archivio +può essere importante. In pratica bisogna provare con e senza filtro BCJ per +vedere quale sia il migliore in ogni situazione. +.RE +.IP "" +Insiemi diversi di istruzioni hanno diversi allineamenti: il file eseguibile +deve essere allineato a un multiplo di questo valore nei dati di input per +far funzionare il filtro. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filtro;Allineamento;Note +x86;1;32\-bit o 64\-bit x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;L'allineamento migliore è a 4096 byte +PowerPC;4;Solo big\-endian +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Dal momento che i dati filtrati da BCJ solitamente sono compressi con LZMA2, +il rapporto di compressione può essere migliorato leggermente se le opzioni +LZMA2 sono impostate in modo che corrispondano all'allineamento del filtro +BCJ selezionato. Esempi: +.RS +.IP \(bu 3 +Il filtro IA\-64 ha un allineamento a 16 byte, quindi \fBpb=4,lp=4,lc=0\fP è una +buona scelta per LZMA2 (2^4=16). +.IP \(bu 3 +Il codice RISC\-V ha un allineamento a 2 o 4 byte a seconda che il file +contenga o meno istruzioni 16 bit compresse (cosiddetta estensione +C). Quando sono usate istruzioni a 16 bit, va bene \fBpb=2,lp=1,lc=3\fP o +\fBpb=1,lp=1,lc=3\fP. Quando le istruzioni a 16 bit non sono presenti, è meglio +\fBpb=2,lp=2,lc=2\fP. Si può usare \fBreadelf \-h\fP per controllare se "RVC" +appare sulla riga del "Flag". +.IP \(bu 3 +ARM64 è sempre allineato a 4 byte, quindi \fBpb=2,lp=2,lc=2\fP è la scelta +migliore. +.IP \(bu 3 +Il filtro x86 è un'eccezione. Di solito è bene attenersi alle impostazioni +predefinite di LZMA2 (\fBpb=2,lp=0,lc=3\fP) quando si comprimono gli eseguibili +x86. +.RE +.IP "" +Tutti i filtri BCJ supportano le stesse \fIOPZIONI\fP: +.RS +.TP +\fBstart=\fP\fIOFFSET\fP +Specifica l'\fIOFFSET\fP iniziale utilizzato per la conversione tra indirizzi +relativi e assoluti. L'\fIOFFSET\fP deve essere un multiplo dell'allineamento +del filtro (vedere la tabella sopra). Il valore predefinito è zero. In +pratica, l'impostazione predefinita è buona; specificare un \fIOFFSET\fP +personalizzato non è quasi mai utile. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIOPZIONI\fP] +Aggiunge un filtro Delta alla catena dei filtri. I filtri Delta non possono +essere utilizzati come ultimo filtro nella catena di filtri. +.IP "" +Al momento è supportato solo un semplice calcolo delta byte\-per\-byte. Può +essere utile quando si comprime, per esempio, immagini bitmap non compresse +o file audio PCM non compressi. Tuttavia, speciali algoritmi ad\-hoc +potrebbero dare risultati significativamente migliori che Delta + +LZMA2. Questo è vero specialmente per l'audio, che comprime più velocemente +e meglio, ad esempio, con \fBflac\fP(1). +.IP "" +\fIOPZIONI\fP supportate: +.RS +.TP +\fBdist=\fP\fIDISTANZA\fP +Specifica la \fIDISTANZA\fP del calcolo delta in byte. \fIDISTANZA\fP deve essere +nel range 1\(en256. Il valore predefinito è 1. +.IP "" +Per esempio, con \fBdist=2\fP e un input di 8 byte A1 B1 A2 B3 A3 B5 A4 B7, +l'output sarà A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Altre opzioni" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Sopprime avvertimenti e avvisi. Specificarlo due volte per eliminare anche +gli errori. Questa opzione non ha alcun effetto sullo stato di uscita. In +altre parole, anche se un avvertimento è stato eliminato, lo stato di uscita +che indica un avvertimento viene comunque utilizzato. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Sii prolisso. Se lo standard error è collegato a un terminale, \fBxz\fP +visualizzerà un indicatore di avanzamento. Specificando \fB\-\-verbose\fP due +volte si otterrà un output ancora più dettagliato. +.IP "" +L'indicatore di avanzamento mostra le seguenti informazioni: +.RS +.IP \(bu 3 +La percentuale di avanzamento è mostrata se la dimensione del file input è +nota. Quindi, la percentuale non può essere mostrata nei pipe. +.IP \(bu 3 +Quantità di dati compressi prodotti (in compressione) o utilizzati (in +decompressione). +.IP \(bu 3 +Quantità di dati non compressi consumati (in compressione) o prodotti (in +decompressione). +.IP \(bu 3 +Rapporto di compressione, calcolato dividendo la quantità di dati compressi +processati finora con la quantità di dati non compressi processati finora. +.IP \(bu 3 +Velocità di compressione o decompressione. Questa è misurata come la +quantità di dati non compressi consumati (in compressione) o prodotti (in +decompressione) al secondo. Viene mostrata dopo che è trascorso qualche +secondo da quando \fBxz\fP ha iniziato a processare il file. +.IP \(bu 3 +Tempo trascorso nel formato M:SS o H:MM:SS. +.IP \(bu 3 +Il tempo residuo stimato è mostrato solo quando la dimensione del file in +ingresso è nota e sono già passati un paio di secondi da quando \fBxz\fP ha +iniziato a processare il file. Il tempo è mostrato in un formato meno +preciso che non ha mai i due punti, ad esempio 2 min 30 s. +.RE +.IP "" +Quando lo standard error non è un terminale, \fB\-\-verbose\fP farà stampare a +\fBxz\fP il nome del file, la dimensione compressa, la dimensione non +compressa, il rapporto di compressione, e potendo anche la velocità e il +tempo trascorso, su una singola riga dello standard error, dopo aver +compresso o decompresso il file. La velocità e il tempo trascorso sono +inclusi solo se l'operazione è durata almeno un paio di secondi. Se +l'operazione non è conclusa, ad esempio a causa dell'interruzione da parte +dell'utente, viene stampata anche la percentuale di completamento, a patto +che la dimensione del file input sia nota. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Non impostare lo stato di uscita a 2 anche se è stata rilevata una +condizione che merita un avvertimento. Questa opzione non influisce sul +livello di dettaglio, quindi sia \fB\-\-quiet\fP che \fB\-\-no\-warn\fP devono essere +utilizzati per non visualizzare avvertimenti e per non alterare lo stato di +uscita. +.TP +\fB\-\-robot\fP +Stampa i messaggi in un formato analizzabile dal computer. Questo ha lo +scopo di facilitare la scrittura dei frontend che vogliono usare \fBxz\fP +invece di liblzma, che potrebbe essere il caso di vari script. Si intende +che con questa opzione abilitata l'output dovrebbe rimanere stabile tra le +versioni di \fBxz\fP. Per ulteriori informazioni, vedere la sezione \fBMODALITÀ ROBOT\fP. +.TP +\fB\-\-info\-memory\fP +Mostra, in un formato leggibile da umani, quanta memoria fisica (RAM) e +quante thread \fBxz\fP pensa che il sistema abbia e i limiti di utilizzo di +memoria per la compressione e la decompressione, quindi termina con +successo. +.TP +\fB\-h\fP, \fB\-\-help\fP +Mostra un messaggio di aiuto che descrive le opzioni usate più comunemente, +e termina con successo. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Mostra un messaggio di aiuto che descrive tutte le funzionalità di \fBxz\fP, e +termina con successo +.TP +\fB\-V\fP, \fB\-\-version\fP +Mostra il numero di versione di \fBxz\fP e liblzma in un formato leggibile +dagli umani. Per ottenere un output analizzabile da una macchina specificare +\fB\-\-robot\fP prima di \fB\-\-version\fP. +. +.SH "MODALITÀ ROBOT" +La "modalità robot" viene attivata con l'opzione \fB\-\-robot\fP. Rende l'output +di \fBxz\fP più facile da analizzare da altri programmi. Attualmente \fB\-\-robot\fP +è supportato solo insieme a \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP e +\fB\-\-version\fP. In futuro sarà supportato per la compressione e la +decompressione. +. +.SS "Modalità stampa" +\fBxz \-\-robot \-\-list\fP usa un output separato da tabulazione. La prima colonna +di ogni riga contiene una stringa che indica il tipo di informazione +contenuta in quella riga: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Questa è sempre la prima riga quando si inizia a elencare un file. La +seconda colonna della riga è il nome del file. +.TP +\fBfile\fP +Questa riga contiene informazioni generali sul file \fB.xz\fP. Questa riga +viene sempre stampata dopo la riga \fBname\fP. +.TP +\fBstream\fP +Questo tipo di riga viene utilizzato solo quando è stato specificato +\fB\-\-verbose\fP. Sono presenti tante righe \fBstream\fP quanti sono i flussi nel +file \fB.xz\fP. +.TP +\fBblock\fP +Questo tipo di riga viene utilizzato solo quando è stato specificato +\fB\-\-verbose\fP. Ci sono tante righe \fBblock\fP quanti sono i blocchi nel file +\&\fB.xz\fP. Le righe \fBblock\fP vengono visualizzate dopo tutte le righe +\fBstream\fP; i diversi tipi di riga non vengono interlacciati. +.TP +\fBsummary\fP +Questo tipo di riga viene utilizzato solo quando \fB\-\-verbose\fP è stato +specificato due volte. Questa riga viene stampata dopo tutte le righe +\fBblock\fP. Come la riga \fBfile\fP, la riga \fBsummary\fP contiene informazioni +generali sul file \fB.xz\fP. +.TP +\fBtotals\fP +Questa riga è sempre l'ultima riga dell'output dell'elenco. Mostra i +conteggi totali e le dimensioni. +.PP +Le colonne delle righe \fBfile\fP: +.PD 0 +.RS +.IP 2. 4 +Numero di flussi nel file +.IP 3. 4 +Numero totale di blocchi nel flusso/i. +.IP 4. 4 +Dimensione compressa del file +.IP 5. 4 +Dimensione non compressa del file +.IP 6. 4 +Rapporto di compressione, es. \fB0.123\fP. Se il rapporto è oltre 9999, al +posto del rapporto vengono mostrati tre trattini (\fB\-\-\-\fP). +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Elenco separato da virgole dei nomi dei controlli di integrità. Le stringhe +seguenti vengono utilizzate per i tipi di controllo conosciuti: \fBNone\fP, +\fBCRC32\fP, \fBCRC64\fP, e \fBSHA\-256\fP. Per i tipi di controllo non conosciuti +viene utilizzato \fBUnknown\-\fP\fIN\fP, dove \fIN\fP è l'ID del controllo come numero +decimale (una o due cifre). +.IP 8. 4 +Dimensione totale del padding del flusso nel file +.RE +.PD +.PP +Le colonne delle righe \fBstream\fP: +.PD 0 +.RS +.IP 2. 4 +Numero di flusso (il primo è 1) +.IP 3. 4 +Numero di blocchi nel flusso +.IP 4. 4 +Offset iniziale compressione +.IP 5. 4 +Offset iniziale decompressione +.IP 6. 4 +Dimensione compressa (non include il padding del flusso) +.IP 7. 4 +Dimensione non compressa +.IP 8. 4 +Rapporto di compressione +.IP 9. 4 +Nome del controllo di integrità +.IP 10. 4 +Dimensione del padding del flusso +.RE +.PD +.PP +Le colonne delle righe \fBblock\fP: +.PD 0 +.RS +.IP 2. 4 +Numero di flussi che contengono questo blocco +.IP 3. 4 +Numero del blocco relativo all'inizio del flusso (il primo blocco è 1) +.IP 4. 4 +Numero del blocco relativo all'inizio del file +.IP 5. 4 +Offset iniziale compressione relativo all'inizio del file +.IP 6. 4 +Offset iniziale decompressione relativo all'inizio del file +.IP 7. 4 +Dimensione totale compressa del blocco (incluse le intestazioni) +.IP 8. 4 +Dimensione non compressa +.IP 9. 4 +Rapporto di compressione +.IP 10. 4 +Nome del controllo di integrità +.RE +.PD +.PP +Se \fB\-\-verbose\fP viene specificato due volte, sono incluse colonne aggiuntive +nelle righe \fBblock\fP. Queste non sono mostrate con un \fB\-\-verbose\fP singolo, +perché recuperare queste informazioni richiede molte ricerche e quindi può +essere lento: +.PD 0 +.RS +.IP 11. 4 +Valore del controllo di integrità in formato esadecimale +.IP 12. 4 +Dimensione intestazione blocco +.IP 13. 4 +Flag del blocco: \fBc\fPindica che è presente la dimensione compressa, \fBu\fP +indica che è presente la dimensione non compressa. Se il flag non è +impostato, viene mostrato un trattino (\fB\-\fP) per mantenere fissa la +lunghezza della stringa. Nuovi flag potrebbero essere aggiunti alla fine +della stringa in futuro. +.IP 14. 4 +Dimensione dei dati compressi effettivi nel blocco (sono esclusi +l'intestazione del blocco, il padding del blocco e i campi di controllo) +.IP 15. 4 +Quantità di memoria (in byte) necessaria per decomprimere questo blocco con +questa versione \fBxz\fP +.IP 16. 4 +Catena di filtri. Si noti che la maggior parte delle opzioni utilizzate al +momento della compressione non è nota, perché solo le opzioni necessarie per +la decompressione sono memorizzate nelle intestazioni \fB.xz\fP. +.RE +.PD +.PP +Le colonne delle righe \fBsummary\fP: +.PD 0 +.RS +.IP 2. 4 +Quantità di memoria (in byte) necessaria per decomprimere questo file con +questa versione \fBxz\fP +.IP 3. 4 +\fByes\fP o \fBno\fP indica se tutte le intestazioni di blocco contengono +all'interno sia dimensioni compresse che dimensioni non compresse +.PP +\fIA partire da\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Versione minima di \fBxz\fP richiesta per decomprimere il file +.RE +.PD +.PP +Le colonne delle righe \fBtotali\fP: +.PD 0 +.RS +.IP 2. 4 +Numero di flussi +.IP 3. 4 +Numero di blocchi +.IP 4. 4 +Dimensione compressa +.IP 5. 4 +Dimensione non compressa +.IP 6. 4 +Rapporto di compressione medio +.IP 7. 4 +Elenco separato da virgole dei nomi dei controlli di integrità presenti nei +file +.IP 8. 4 +Dimensione del padding dello stream +.IP 9. 4 +Numero di file. Questo serve a mantenere l'ordine delle colonne precedenti +uguale a quello delle righe del \fBfile\fP. +.PD +.RE +.PP +Se \fB\-\-verbose\fP viene specificato due volte, sono incluse colonne aggiuntive +nella riga \fBtotali\fP: +.PD 0 +.RS +.IP 10. 4 +Quantità massima di memoria (in byte) necessaria per decomprimere i file con +questa versione \fBxz\fP +.IP 11. 4 +\fByes\fP o \fBno\fP indica se tutte le intestazioni di blocco contengono +all'interno sia dimensioni compresse che dimensioni non compresse +.PP +\fIA partire da\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Versione minima di \fBxz\fP richiesta per decomprimere il file +.RE +.PD +.PP +Versioni future potrebbero aggiungere nuovi tipi di riga e nuove colonne +possono essere aggiunte ai tipi di riga esistenti, ma le colonne esistenti +non verranno modificate. +. +.SS "Aiuto sui filtri" +\fBxz \-\-robot \-\-filters\-help\fP stampa i filtri supportati nel seguente +formato: +.PP +\fIFILTRO\fP\fB:\fP\fIOPZIONE\fP\fB=<\fP\fIVALORE\fP\fB>,\fP\fIOPZIONE\fP\fB=<\fP\fIVALORE\fP\fB>\fP... +.TP +\fIFILTRO\fP +Nome del filtro +.TP +\fIOPZIONE\fP +Nome di un'opzione specifica del filtro +.TP +\fIVALORE\fP +Gli intervalli del \fIVALORE\fP numerico appaiono come +\fB<\fP\fIMIN\fP\fB\-\fP\fIMAX\fP\fB>\fP. Le scelte per i \fIVALORI\fP stringa sono +mostrati in \fB< >\fP e separati dal carattere \fB|\fP. +.PP +Ogni filtro è mostrato su una riga dedicata. +. +.SS "Informazione limite memoria" +\fBxz \-\-robot \-\-info\-memory\fP stampa una singola riga con più colonne separate +da tabulazione: +.IP 1. 4 +Quantità totale di memoria fisica (RAM) in byte. +.IP 2. 4 +Limite utilizzo memoria per la compressione in byte +(\fB\-\-memlimit\-compress\fP). Il valore speciale \fB0\fP indica l'impostazione +predefinita, che in modalità thread singola equivale a nessun limite. +.IP 3. 4 +Limite utilizzo memoria per la decompressione in byte +(\fB\-\-memlimit\-decompress\fP). Il valore speciale \fB0\fP indica l'impostazione +predefinita, che in modalità thread singola equivale a nessun limite. +.IP 4. 4 +A partire da \fBxz\fP 5.3.4alpha: Utilizzo della memoria per la decompressione +a thread multiple in byte (\fB\-\-memlimit\-mt\-decompress\fP). Questo valore non è +mai zero perché viene utilizzato un valore predefinito specifico del sistema +mostrato nella colonna 5, se non è stato specificato alcun limite in modo +esplicito. Inoltre, non è mai maggiore del valore nella colonna 3, anche se +è stato specificato un valore maggiore con \fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +A partire da \fBxz\fP 5.3.4alpha: un limite di utilizzo della memoria +predefinito specifico del sistema, che viene utilizzato per limitare il +numero di thread durante la compressione con un numero automatico di thread +(\fB\-\-threads=0\fP) e non è stato specificato alcun limite di utilizzo della +memoria (\fB\-\-memlimit\-compress\fP). Questo viene utilizzato anche come valore +predefinito per \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +A partire da \fBxz\fP 5.3.4alpha: Numero di thread del processore disponibili. +.PP +In futuro, l'output di \fBxz \-\-robot \-\-info\-memory\fP potrebbe avere più +colonne, ma mai più di una singola riga. +. +.SS Versione +\fBxz \-\-robot \-\-version\fP stampa il numero di versione di \fBxz\fP e liblzma nel +seguente formato: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Versione major. +.TP +\fIYYY\fP +Versione minor. I numeri pari sono stabili. I numeri dispari sono versioni +alfa o beta. +.TP +\fIZZZ\fP +Livello di patch per le versioni stabili o solo un contatore per le versioni +di sviluppo. +.TP +\fIS\fP +Stabilità. 0 è alfa, 1 è beta e 2 è stabile. \fIS\fP dovrebbe essere sempre 2 +quando \fIYYY\fP è pari. +.PP +\fIXYYYZZZS\fP sono uguali su entrambe le righe se \fBxz\fP e liblzma appartengono +allo stesso rilascio delle XZ Utils. +.PP +Esempi: 4.999.9beta è \fB49990091\fP e 5.0.0 è \fB50000002\fP. +. +.SH "CODICE DI USCITA" +.TP +\fB0\fP +Tutto bene. +.TP +\fB1\fP +È avvenuto un errore. +.TP +\fB2\fP +Si è verificato qualcosa che merita un avvertimento, ma non si sono +verificati errori effettivi. +.PP +Gli avvisi (non gli avvertimenti o gli errori) stampati sullo standard error +non influiscono sullo stato di uscita. +. +.SH AMBIENTE +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP analizza elenchi di opzioni separate da spazi dalle variabili +d'ambiente \fBXZ_DEFAULTS\fP e \fBXZ_OPT\fP, in questo ordine, analizzando prima +le opzioni dalla riga di comando. Si noti che solo le opzioni vengono +analizzate dalle variabili d'ambiente; tutte le non\-opzioni vengono ignorate +silenziosamente. L'analisi viene eseguita con \fBgetopt_long\fP(3) che viene +utilizzato anche per gli argomenti della riga di comando. +.PP +\fBAttenzione:\fP Impostando queste variabili di ambiente, si sta di fatto +modificando programmi e script che lanciano \fBxz\fP. La maggior parte delle +volte va bene impostare i limiti di utilizzo della memoria, il numero di +thread e le opzioni di compressione tramite variabili d'ambiente. Tuttavia, +alcune opzioni possono rompere degli script. Un esempio banale è \fB\-\-help\fP +che forza \fBxz\fP a mostrare la pagina di aiuto anziché comprimere o +decomprimere file. Esempi meno ovvi sono \fB\-\-quiet\fP e \fB\-\-verbose\fP. In +molti casi funziona bene abilitare l'indicatore di avanzamento usando +\fB\-\-verbose\fP, ma in alcune situazioni i messaggi extra creano problemi. Il +livello di prolissità influisce anche sul comportamento di \fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Opzioni predefinite specifiche dell'utente o a livello di sistema. In genere +questo viene impostato in uno script di inizializzazione della shell per +abilitare il valore predefinito del limitatore di utilizzo della memoria di +\fBxz\fP, o per impostare il numero di thread predefinito. Escludendo gli +script di inizializzazione della shell e analoghi casi particolari, gli +script non dovrebbero mai impostare o annullare l'impostazione di +\fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Questo serve per passare le opzioni a \fBxz\fP quando non sia possibile +impostare le opzioni direttamente sulla riga di comando di \fBxz\fP. Questo è +il caso quando \fBxz\fP viene eseguito da uno script o da uno strumento, ad +esempio GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Gli script possono usare \fBXZ_OPT\fP, per esempio, per impostare opzioni di +compressione predefinite specifiche per lo script. Si raccomanda comunque di +permettere agli utenti di sovrascrivere \fBXZ_OPT\fPse questo è ragionevole. Ad +esempio, negli script \fBsh\fP(1) si può usare qualcosa come questo: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "COMPATIBILITÀ LZMA UTILS" +La sintassi della riga di comando di \fBxz\fP è essenzialmente un sopra\-insieme +di \fBlzma\fP, \fBunlzma\fP, e \fBlzcat\fP come trovati nelle LZMA Utils +4.32.x. Nella maggior parte dei casi è possibili sostituire le LZMA Utils +con le XZ Utils senza rompere gli script esistenti. Ci sono però alcune +incompatibilità, che in alcuni casi potrebbero causare problemi. +. +.SS "Livelli di compressione preimpostati" +La numerazione dei livelli di compressione preimpostati non è identica in +\fBxz\fP e nelle LZMA Utils. La differenza più importante è il modo in cui le +dimensioni del dizionario vengono mappate sulle diverse preimpostazioni. La +dimensione del dizionario è approssimativamente uguale all'utilizzo della +memoria del decompressore. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Livello;xz;LZMA Utils +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Le differenze di dimensione del dizionario influiscono anche sull'utilizzo +della memoria del compressore, ma ci sono alcune altre differenze tra le +LZMA Utils e le XZ Utils, che rendono la differenza ancora più grande: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Livello;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Il livello preimpostato predefinito nelle LZMA Utils è \fB\-7\fP mentre nelle XZ +Utils è \fB\-6\fP, quindi entrambi utilizzano un dizionario da 8 MiB per +impostazione predefinita. +. +.SS "File .lzma con flussi vs. senza flussi" +La dimensione non compressa del file può essere memorizzata +nell'intestazione \fB.lzma\fP. Le LZMA Utils lo fanno durante la compressione +di file regolari. L'alternativa consiste nel memorizzare che la dimensione +non compressa è sconosciuta e utilizzare l'indicatore di fine carico utile +per indicare il punto in cui il decompressore deve fermarsi. Le LZMA Utils +utilizzano questo metodo quando le dimensioni non compresse non sono note, +come nel caso, ad esempio, delle pipe. +.PP +\fBxz\fP supporta la decompressione di file \fB.lzma\fP con o senza il marcatore +di fine payload, ma tutti i file \fB.lzma\fP creati da \fBxz\fP utilizzeranno il +marcatore di fine payload e avranno dimensioni non compresse contrassegnate +come sconosciute nell'intestazione \fB.lzma\fP. Questo può essere un problema +in alcune situazioni non comuni. Ad esempio, un decompressore \fB.lzma\fP in un +dispositivo embedded potrebbe funzionare solo con file con dimensioni non +compresse note. Se si incorre in questo problema, occorre utilizzare le LZMA +Utils oppure l'LZMA SDK per creare dei file \fB.lzma\fP con dimensioni non +compresse note. +. +.SS "File .lzma non supportati" +Il formato \fB.lzma\fP permette valori \fIlc\fP fino a 8, e valori \fIlp\fP fino a +4. Le LZMA Utils possono decomprimere file con qualunque \fIlc\fP e \fIlp\fP, ma +creeranno sempre file con \fBlc=3\fP e \fBlp=0\fP. Creare file con altri \fIlc\fP e +\fIlp\fP è possibile con \fBxz\fP e con l'LZMA SDK. +.PP +L'implementazione del filtro LZMA1 in liblzma richiede che la somma di \fIlc\fP +e \fIlp\fP non debba superare 4. Pertanto, i file \fB.lzma\fP che superano questa +limitazione non possono essere decompressi con \fBxz\fP. +.PP +Le LZMA Utils creano solo file \fB.lzma\fP con dimensione del dizionario 2^\fIn\fP +(una potenza di 2) ma accettano file con qualsiasi dimensione di +dizionario. liblzma accetta solo file \fB.lzma\fP con dimensione del dizionario +2^\fIn\fP o 2^\fIn\fP + 2^(\fIn\fP\-1). Questo serve a limitare i falsi positivi +quando si cerca di identificare i file \fB.lzma\fP. +.PP +All'atto pratico queste limitazioni non dovrebbero essere un problema, +perché praticamente tutti i file \fB.lzma\fP sono stati compressi con +impostazioni che liblzma accetterà. +. +.SS "Dati sporchi finali" +Quando si decomprime, le LZMA Utils ignorano automaticamente tutto quello +che c'è dopo il primo flusso \fB.lzma\fP. Nella maggior parte delle situazioni +questo è un baco. Questo significa anche che le LZMA Utils non supportano la +decompressione di file \fB.lzma\fP concatenati. +.PP +Se sono rimasti dati dopo il primo flusso \fB.lzma\fP, \fBxz\fP considera il file +corrotto a meno che sia stato utilizzato \fB\-\-single\-stream\fP. Questo può far +rompere script incomprensibili che hanno assunto che i dati sporchi finali +vengano ignorati. +. +.SH NOTE +. +.SS "L'output compresso può variare" +L'esatto output compresso prodotto dallo stesso file di input non compresso +può variare tra le versioni delle XZ Utils, anche se le opzioni di +compressione sono le stesse. Questo perché il codificatore può essere stato +migliorato (compressione più veloce o migliore) senza influire sul formato +del file. L'output può variare anche tra diverse build della stessa versione +delle XZ Utils, se vengono utilizzate opzioni di build differenti. +.PP +Quanto sopra significa che una volta che \fB\-\-rsyncable\fP è stato +implementato, i file risultanti non saranno necessariamente rsync\-abili a +meno che sia i vecchi che i nuovi file non siano stati compressi con la +stessa versione di xz. Questo problema può essere risolto se una parte +dell'implementazione del codificatore viene congelata per mantenere stabile +l'output rsync\-abile tra le versioni di xz. +. +.SS "Abilita i decompressori .xz" +Le implementazioni dei decompressori \fB.xz\fP embedded, come XZ Embedded, non +necessariamente supportano file creati con tipi di integrità \fICONTROLLO\fP +diversi da \fBnone\fP e \fBcrc32\fP. Dal momento che il valore predefinito è +\fB\-\-check=crc64\fP, occorre specificare \fB\-\-check=none\fP o \fB\-\-check=crc32\fP +quando si creano file per sistemi embedded. +.PP +Al di fuori dei sistemi embedded, tutti i decompressori in formato \fB.xz\fP +supportano tutti i tipi di \fICONTROLLO\fP, o almeno sono in grado di +decomprimere il file senza verificare il controllo di integrità se il +particolare \fICONTROLLO\fP non è supportato. +.PP +XZ Embedded supporta i filtri BCJ, ma solo con offset iniziale predefinito. +. +.SH ESEMPI +. +.SS "Informazioni di base" +Comprime il file \fIfoo\fP in \fIfoo.xz\fP utilizzando il livello di compressione +predefinito (\fB\-6\fP) e rimuove \fIfoo\fP se la compressione ha esito positivo: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Decomprime \fIbar.xz\fP in \fIbar\fP e non rimuove \fIbar.xz\fP anche se la +decompressione ha successo: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Crea \fIbaz.tar.xz\fP con il preset \fB\-4e\fP (\fB\-4 \-\-extreme\fP), che è più lenta +della predefinita \fB\-6\fP, ma ha bisogno di meno memoria per la compressione e +decompressione (48\ MiB e 5\ MiB, rispettivamente): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Una combinazione di file compressi e non compressi può essere decompressa +sullo output standard con un singolo comando: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Compressione parallela di più file" +Su GNU e *BSD, \fBfind\fP(1) e \fBxargs\fP(1) possono essere usati per +parallelizzare la compressione di più file: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +L'opzione \fB\-p\fP di \fBxargs\fP(1) imposta il numero di processi \fBxz\fP +paralleli. Il valore migliore per l'opzione \fB\-n\fP dipende dal numero di file +da comprimere. Se sono presenti solo un paio di file, il valore dovrebbe +probabilmente essere 1; con decine di migliaia di file, 100 o anche di più +può essere appropriato per ridurre il numero di processi \fBxz\fP che +\fBxargs\fP(1) alla fine creerà. +.PP +L'opzione \fB\-T1\fP per \fBxz\fP serve a forzare la modalità a thread singola, +perché \fBxargs\fP (1) viene utilizzato per controllare la quantità di +parallelizzazione. +. +.SS "Modalità robot" +Calcola quanti byte sono stati salvati in totale dopo la compressione di più +file: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Uno script potrebbe voler sapere se si sta utilizzando una versione di \fBxz\fP +sufficientemente recente. Il seguente script \fBsh\fP(1) controlla che il +numero di versione dello strumento \fBxz\fP sia almeno 5.0.0. Questo metodo è +compatibile con le vecchie versioni beta, che non supportavano l'opzione +\fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Imposta un limite di utilizzo della memoria per la decompressione +utilizzando \fBXZ_OPT\fP, ma se è già stato impostato un limite, non lo +aumenta: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Catene di filtri di compressione personalizzate" +L'uso più semplice delle catene di filtri personalizzate è la +personalizzazione di un preset di LZMA2. Questo può essere utile, perché i +preset coprono solamente un sottoinsieme di tutte le combinazioni di +impostazioni di compressione potenzialmente utili. +.PP +Le colonne CompCPU delle tabelle dalle descrizioni delle opzioni \fB\-0\fP +\&... \fB\-9\fP e \fB\-\-extreme\fP sono utili quando si personalizzano i preset di +LZMA2. Di seguito sono riportate le parti rilevanti raccolte da queste due +tabelle: +.RS +.PP +.TS +tab(;); +c c +n n. +Livello preimpostato;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Se si sa che un file richiede un dizionario piuttosto grande (ad esempio, +32\ MiB) per essere compresso bene, ma si desidera comprimerlo più +velocemente di quanto farebbe \fBxz \-8\fP, è possibile modificare un preset con +un basso valore CompCPU (ad esempio, 1) per utilizzare un dizionario più +grande: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Con alcuni file, il comando sopra potrebbe essere più veloce di \fBxz \-6\fP e +la compressione significativamente migliore. Tuttavia, si deve sottolineare +che solo alcuni file traggono beneficio da un dizionario grande e mantengono +basso il valore di CompCPU. La situazione più ovvia in cui un dizionario +grande può aiutare molto è un archivio contenente file molto simili di +almeno un paio di megabyte ciascuno. La dimensione del dizionario deve +essere significativamente più grande di ogni singolo file per permettere a +LZMA2 di trarre pieno vantaggio dalle somiglianze tra file consecutivi. +.PP +Se l'utilizzo molto elevato della memoria del compressore e del +decompressore è accettabile, e il file da comprimere è almeno di diverse +centinaia di megabyte, potrebbe essere utile utilizzare un dizionario ancora +più grande dei 64 MiB che \fBxz \-9\fP utilizzerebbe: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +L'uso di \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) come nell'esempio precedente può +essere utile per vedere i requisiti di memoria del compressore e del +decompressore. Tenere presente che l'utilizzo di un dizionario più grande +della dimensione del file non compresso è uno spreco di memoria, quindi il +comando precedente non è utile per i file di piccole dimensioni. +.PP +A volte il tempo di compressione non importa, ma l'utilizzo di memoria del +decompressore deve essere tenuta bassa, per esempio, per permettere di +decomprimere il file in un sistema embedded. Il comando seguente usa \fB\-6e\fP +(\fB\-6 \-\-extreme\fP) come base e imposta il dizionario a soli 64\ KiB. Il file +risultante può essere decompresso con XZ Embedded (ecco perché c'è +\fB\-\-check=crc32\fP) usando circa 100\ KiB di memoria. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Se si desidera spremere il maggior numero possibile di byte, a volte può +essere utile regolare il numero di bit di contesto letterale (\fIlc\fP) e il +numero di bit di posizione (\fIpb\fP). Anche la regolazione del numero di bit +di posizione letterale (\fIlp\fP) potrebbe essere d'aiuto, ma di solito \fIlc\fP e +\fIpb\fP sono più importanti. Per esempio, un archivio di codici sorgente +contiene principalmente testo US\-ASCII, quindi qualcosa come il seguente +potrebbe produrre un file leggermente (0,1\ %) più piccolo di \fBxz \-6e\fP +(provare anche senza \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Usare un altro filtro insieme a LZMA2 può migliorare la compressione per +alcuni tipi di file. Ad esempio, per comprimere una libreria condivisa +x86\-32 o x86\-64 usare il filtro BCJ: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Si noti che l'ordine delle opzioni di filtro è significativo. Se viene +specificato \fB\-\-x86\fP dopo \fB\-\-lzma2\fP, \fBxz\fP darà un errore, perché non può +esserci alcun filtro dopo LZMA2 e anche perché il filtro BCJ x86 non può +essere utilizzato come ultimo filtro della catena. +.PP +Il filtro Delta insieme con LZMA2 può dare buoni risultati sulle immagini +bitmap. Di solito dovrebbe battere il PNG, il quale ha alcuni filtri più +avanzati rispetto al semplice delta ma utilizza Deflate per la compressione +effettiva. +.PP +L'immagine deve essere salvata in un formato non compresso, ad esempio un +TIFF non compresso. Il parametro distanza del filtro Delta è impostato in +modo che corrisponda al numero di byte per pixel nell'immagine. Per esempio, +un bitmap a 24 bit richiede \fBdist=3\fP, e va anche bene passare \fBpb=0\fP a +LZMA2 per adattarsi all'allineamento a tre byte: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Se più immagini sono state inserite in un singolo archivio (ad esempio, +\&\fB.tar\fP), il filtro Delta funzionerà anche su questo purché tutte le +immagini abbiano lo stesso numero di byte per pixel. +. +.SH "VEDERE ANCHE" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzcmp.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzcmp.1 new file mode 100644 index 0000000000000000000000000000000000000000..dc0d9758b78466e415a916cb83cd9c69483cae4d --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzcmp.1 @@ -0,0 +1,55 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Italian translations for xz-man package +.\" Luca Vercelli , 2024-2025 +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 06/03/2025 Tukaani "XZ Utils" +.SH NOME +xzcmp, xzdiff, lzcmp, lzdiff \- confronto tra file compressi +. +.SH SINOSSI +\fBxzcmp\fP [\fIOPZIONE...\fP] \fIFILE1\fP [\fIFILE2\fP] +.br +\fBxzdiff\fP \&... +.br +\fBlzcmp\fP \&... (DEPRECATO) +.br +\fBlzdiff\fP \&... (DEPRECATO) +. +.SH DESCRIZIONE +\fBxzcmp\fP e \fBxzdiff\fP confrontano i contenuti non compressi di due file. I +dati non compressi e le opzioni sono passate a \fBcmp\fP(1) o \fBdiff\fP(1) a +meno che sia specificato \fB\-\-help\fP o \fB\-\-version\fP. +.PP +Se sono indicati sia \fIFILE1\fP che \fIFILE2\fP, essi possono essere file non +compressi oppure file nei formati che \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), +\fBlzop\fP(1), \fBzstd\fP(1), o \fBlz4\fP(1) possono decomprimere. I comandi di +decompressione necessari sono dedotti dai suffissi dei nomi dei file +\fIFILE1\fP e \fIFILE2\fP. Un file con un suffisso non riconosciuto viene +considerato o non compresso oppure in un formato che \fBxz\fP(1) può +decomprimere. +.PP +Se viene fornito un solo nome di file, \fIFILE1\fP deve avere un suffisso di un +formato di compressione supportato e il nome di \fIFILE2\fP si assume che sia +\fIFILE1\fP senza il suffisso del formato di compressione. +.PP +I comandi \fBlzcmp\fP, e \fBlzdiff\fP sono forniti per retrocompatibilità con le +LZMA Utils. Sono deprecati e saranno rimosso in una versione futura. +. +.SH "CODICE DI USCITA" +Se avviene un errore nella decompressione, lo stato di uscita è +\fB2\fP. Altrimenti viene usato lo stato di uscita di \fBcmp\fP(1) o \fBdiff\fP(1) +. +.SH "VEDERE ANCHE" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzdiff.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzdiff.1 new file mode 100644 index 0000000000000000000000000000000000000000..dc0d9758b78466e415a916cb83cd9c69483cae4d --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzdiff.1 @@ -0,0 +1,55 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Italian translations for xz-man package +.\" Luca Vercelli , 2024-2025 +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 06/03/2025 Tukaani "XZ Utils" +.SH NOME +xzcmp, xzdiff, lzcmp, lzdiff \- confronto tra file compressi +. +.SH SINOSSI +\fBxzcmp\fP [\fIOPZIONE...\fP] \fIFILE1\fP [\fIFILE2\fP] +.br +\fBxzdiff\fP \&... +.br +\fBlzcmp\fP \&... (DEPRECATO) +.br +\fBlzdiff\fP \&... (DEPRECATO) +. +.SH DESCRIZIONE +\fBxzcmp\fP e \fBxzdiff\fP confrontano i contenuti non compressi di due file. I +dati non compressi e le opzioni sono passate a \fBcmp\fP(1) o \fBdiff\fP(1) a +meno che sia specificato \fB\-\-help\fP o \fB\-\-version\fP. +.PP +Se sono indicati sia \fIFILE1\fP che \fIFILE2\fP, essi possono essere file non +compressi oppure file nei formati che \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), +\fBlzop\fP(1), \fBzstd\fP(1), o \fBlz4\fP(1) possono decomprimere. I comandi di +decompressione necessari sono dedotti dai suffissi dei nomi dei file +\fIFILE1\fP e \fIFILE2\fP. Un file con un suffisso non riconosciuto viene +considerato o non compresso oppure in un formato che \fBxz\fP(1) può +decomprimere. +.PP +Se viene fornito un solo nome di file, \fIFILE1\fP deve avere un suffisso di un +formato di compressione supportato e il nome di \fIFILE2\fP si assume che sia +\fIFILE1\fP senza il suffisso del formato di compressione. +.PP +I comandi \fBlzcmp\fP, e \fBlzdiff\fP sono forniti per retrocompatibilità con le +LZMA Utils. Sono deprecati e saranno rimosso in una versione futura. +. +.SH "CODICE DI USCITA" +Se avviene un errore nella decompressione, lo stato di uscita è +\fB2\fP. Altrimenti viene usato lo stato di uscita di \fBcmp\fP(1) o \fBdiff\fP(1) +. +.SH "VEDERE ANCHE" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzegrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzegrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..778054dc4c25e481efd7f316a89c121ce2df68af --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzegrep.1 @@ -0,0 +1,94 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Italian translations for xz-man package +.\" Luca Vercelli , 2024-2025 +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 06/03/2025 Tukaani "XZ Utils" +.SH NOME +xzgrep \- Cerca pattern in file potenzialmente compressi +. +.SH SINOSSI +\fBxzgrep\fP [\fIOPZIONE...\fP] [\fILISTA_PATTERN\fP] [\fIFILE...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (DEPRECATO) +.br +\fBlzegrep\fP \&... (DEPRECATO) +.br +\fBlzfgrep\fP \&... (DEPRECATO) +. +.SH DESCRIZIONE +\fBxzgrep\fP invoca \fBgrep\fP(1) sui contenuti non compressi dei file. I formati +dei \fIFILE\fP sono dedotti dai suffissi dei nomi dei file. Sarà decompresso +qualsiasi file con un suffisso supportato da \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), o \fBlz4\fP(1); tutti gli altri file +saranno considerati non compressi. +.PP +Se non sono specificati \fIFILE\fP, o se \fIFILE\fP è \fB\-\fP, viene letto lo +standard input. Quando si legge da standard input vengono decompressi +solamente i file supportati da \fBxz\fP(1). Gli altri file sono considerati già +non compressi. +.PP +Sono supportate la maggior parte delle \fIOPZIONI\fP di \fBgrep\fP(1). Tuttavia, +le opzioni seguenti non sono supportate: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIAZIONE\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIGLOB\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIGLOB\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIFILE\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIGLOB\fP +.PP +\fBxzegrep\fP è un alias per \fBxzgrep \-E\fP. \fBxzfgrep\fP è un alias per \fBxzgrep \-F\fP. +.PP +I comandi \fBlzgrep\fP, \fBlzegrep\fP, e \fBlzfgrep\fP sono forniti per +retrocompatibilità con le LZMA Utils. Sono deprecati e saranno rimosso in +una versione futura. +. +.SH "CODICE DI USCITA" +.TP +0 +Almeno una corrispondenza è stata trovata in almeno uno dei file +input. Nessun errore è avvenuto. +.TP +1 +Non sono state trovate corrispondenze in nessuno dei file di input. Non si +sono verificati errori. +.TP +>1 +Sono avvenuti uno o più errori. Non è noto se sono state trovate delle +corrispondenze. +. +.SH AMBIENTE +.TP +\fBGREP\fP +Se \fBGREP\fP è impostato a un valore non vuoto, verrà usato al posto di +\fBgrep\fP, \fBgrep \-E\fP, o \fBgrep \-F\fP. +. +.SH "VEDERE ANCHE" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzfgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzfgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..778054dc4c25e481efd7f316a89c121ce2df68af --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzfgrep.1 @@ -0,0 +1,94 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Italian translations for xz-man package +.\" Luca Vercelli , 2024-2025 +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 06/03/2025 Tukaani "XZ Utils" +.SH NOME +xzgrep \- Cerca pattern in file potenzialmente compressi +. +.SH SINOSSI +\fBxzgrep\fP [\fIOPZIONE...\fP] [\fILISTA_PATTERN\fP] [\fIFILE...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (DEPRECATO) +.br +\fBlzegrep\fP \&... (DEPRECATO) +.br +\fBlzfgrep\fP \&... (DEPRECATO) +. +.SH DESCRIZIONE +\fBxzgrep\fP invoca \fBgrep\fP(1) sui contenuti non compressi dei file. I formati +dei \fIFILE\fP sono dedotti dai suffissi dei nomi dei file. Sarà decompresso +qualsiasi file con un suffisso supportato da \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), o \fBlz4\fP(1); tutti gli altri file +saranno considerati non compressi. +.PP +Se non sono specificati \fIFILE\fP, o se \fIFILE\fP è \fB\-\fP, viene letto lo +standard input. Quando si legge da standard input vengono decompressi +solamente i file supportati da \fBxz\fP(1). Gli altri file sono considerati già +non compressi. +.PP +Sono supportate la maggior parte delle \fIOPZIONI\fP di \fBgrep\fP(1). Tuttavia, +le opzioni seguenti non sono supportate: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIAZIONE\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIGLOB\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIGLOB\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIFILE\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIGLOB\fP +.PP +\fBxzegrep\fP è un alias per \fBxzgrep \-E\fP. \fBxzfgrep\fP è un alias per \fBxzgrep \-F\fP. +.PP +I comandi \fBlzgrep\fP, \fBlzegrep\fP, e \fBlzfgrep\fP sono forniti per +retrocompatibilità con le LZMA Utils. Sono deprecati e saranno rimosso in +una versione futura. +. +.SH "CODICE DI USCITA" +.TP +0 +Almeno una corrispondenza è stata trovata in almeno uno dei file +input. Nessun errore è avvenuto. +.TP +1 +Non sono state trovate corrispondenze in nessuno dei file di input. Non si +sono verificati errori. +.TP +>1 +Sono avvenuti uno o più errori. Non è noto se sono state trovate delle +corrispondenze. +. +.SH AMBIENTE +.TP +\fBGREP\fP +Se \fBGREP\fP è impostato a un valore non vuoto, verrà usato al posto di +\fBgrep\fP, \fBgrep \-E\fP, o \fBgrep \-F\fP. +. +.SH "VEDERE ANCHE" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..778054dc4c25e481efd7f316a89c121ce2df68af --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzgrep.1 @@ -0,0 +1,94 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Italian translations for xz-man package +.\" Luca Vercelli , 2024-2025 +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 06/03/2025 Tukaani "XZ Utils" +.SH NOME +xzgrep \- Cerca pattern in file potenzialmente compressi +. +.SH SINOSSI +\fBxzgrep\fP [\fIOPZIONE...\fP] [\fILISTA_PATTERN\fP] [\fIFILE...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (DEPRECATO) +.br +\fBlzegrep\fP \&... (DEPRECATO) +.br +\fBlzfgrep\fP \&... (DEPRECATO) +. +.SH DESCRIZIONE +\fBxzgrep\fP invoca \fBgrep\fP(1) sui contenuti non compressi dei file. I formati +dei \fIFILE\fP sono dedotti dai suffissi dei nomi dei file. Sarà decompresso +qualsiasi file con un suffisso supportato da \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), o \fBlz4\fP(1); tutti gli altri file +saranno considerati non compressi. +.PP +Se non sono specificati \fIFILE\fP, o se \fIFILE\fP è \fB\-\fP, viene letto lo +standard input. Quando si legge da standard input vengono decompressi +solamente i file supportati da \fBxz\fP(1). Gli altri file sono considerati già +non compressi. +.PP +Sono supportate la maggior parte delle \fIOPZIONI\fP di \fBgrep\fP(1). Tuttavia, +le opzioni seguenti non sono supportate: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIAZIONE\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIGLOB\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIGLOB\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIFILE\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIGLOB\fP +.PP +\fBxzegrep\fP è un alias per \fBxzgrep \-E\fP. \fBxzfgrep\fP è un alias per \fBxzgrep \-F\fP. +.PP +I comandi \fBlzgrep\fP, \fBlzegrep\fP, e \fBlzfgrep\fP sono forniti per +retrocompatibilità con le LZMA Utils. Sono deprecati e saranno rimosso in +una versione futura. +. +.SH "CODICE DI USCITA" +.TP +0 +Almeno una corrispondenza è stata trovata in almeno uno dei file +input. Nessun errore è avvenuto. +.TP +1 +Non sono state trovate corrispondenze in nessuno dei file di input. Non si +sono verificati errori. +.TP +>1 +Sono avvenuti uno o più errori. Non è noto se sono state trovate delle +corrispondenze. +. +.SH AMBIENTE +.TP +\fBGREP\fP +Se \fBGREP\fP è impostato a un valore non vuoto, verrà usato al posto di +\fBgrep\fP, \fBgrep \-E\fP, o \fBgrep \-F\fP. +. +.SH "VEDERE ANCHE" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzless.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzless.1 new file mode 100644 index 0000000000000000000000000000000000000000..03fcb0de8d8d598d0fa50abb8246952556e4ea3b --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzless.1 @@ -0,0 +1,47 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" Italian translations for xz-man package +.\" Luca Vercelli , 2024-2025 +.\" +.\" (Note that this file is not based on gzip's zless.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZLESS 1 06/03/2025 Tukaani "XZ Utils" +.SH NOME +xzless, lzless \- mostra file (testuali) compressi xz o lzma +.SH SINOSSI +\fBxzless\fP [\fIFILE\fP...] +.br +\fBlzless\fP [\fIFILE\fP...] (DEPRECATO) +.SH DESCRIZIONE +\fBxzless\fP è un filtro che visualizza testo da file compressi a un +terminale. I file supportati da \fBxz\fP(1) vengono decompressi; gli altri +file sono considerati già non compressi. Se non viene dato alcun \fIFILE\fP, +\fBxzless\fP legge dallo standard input. +.PP +\fBxzless\fP usa \fBless\fP(1) per mostrare il suo output. A differenza di +\fBxzmore\fP, la scelta del paginatore non può essere modificata impostando una +variabile d'ambiente. I comandi si basano sia su \fBmore\fP (1) che su \fBvi\fP +(1) e consentono il movimento in avanti e all'indietro e la ricerca. Per +ulteriori informazioni vedere il manuale di \fBless\fP(1). +.PP +Il comando chiamato \fBlzless\fP è fornito per retrocompatibilità con le LZMA +Utils. È deprecato e sarà rimosso in una versione futura. +.SH AMBIENTE +.TP +\fBLESSMETACHARS\fP +Un elenco di caratteri speciali per la shell. Impostato da \fBxzless\fP a meno +che sia già impostato nell'ambiente. +.TP +\fBLESSOPEN\fP +Valorizzare con una riga di comando per lanciare il decompressore \fBxz\fP(1) +per preprocessare i file input per \fBless\fP(1). +.SH "VEDERE ANCHE" +\fBless\fP(1), \fBxz\fP(1), \fBxzmore\fP(1), \fBzless\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzma.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzma.1 new file mode 100644 index 0000000000000000000000000000000000000000..53a915947bff84fc5f9cfbb4d4ed88097620e055 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzma.1 @@ -0,0 +1,2080 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Italian translations for xz-man package +.\" Luca Vercelli , 2024-2025 +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 08/03/2025 Tukaani "XZ Utils" +. +.SH NOME +xz, unxz, xzcat, lzma, unlzma, lzcat \- Comprime o decomprime file .xz e +\&.lzma +. +.SH SINOSSI +\fBxz\fP [\fIOPZIONE...\fP] [\fIFILE...\fP] +. +.SH "ALIAS DEI COMANDI" +\fBunxz\fP è equivalente a \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP è equivalente a \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP è equivalente a \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP è equivalente a \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP è equivalente a \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Quando si scrivono script che richiedono di decomprimere file, si raccomanda +di utilizzare sempre il comando \fBxz\fP con argomenti appropriati (\fBxz \-d\fP o +\fBxz \-dc\fP) al posto degli alias \fBunxz\fP e \fBxzcat\fP. +. +.SH DESCRIZIONE +\fBxz\fP è uno strumento di compressione dati generico con sintassi della riga +di comando simile a \fBgzip\fP(1) e \fBbzip2\fP(1). Il formato file nativo è +\&\fB.xz\fP, ma sono supportati anche il formato tradizionale \fB.lzma\fP usato +dalle LZMA Utils e i flussi grezzi (raw) compressi senza intestazioni di +formato contenitore. In più, è supportata la decompressione del formato +\&\fB.lz\fPusato da \fBlzip\fP. +.PP +\fBxz\fP comprime o decomprime ogni \fIFILE\fP a seconda della modalità di +funzionamento selezionata. Se nessun \fIFILE\fP è indicato o se \fIFILE\fP è \fB\-\fP, +\fBxz\fP legge dallo standard input e scrive i dati processati sullo standard +output. \fBxz\fP si rifiuterà (stamperà un errore e salterà il \fIFILE\fP) di +scrivere dati compressi sullo standard output se è il +terminale. Analogamente, \fBxz\fP si rifiuterà di leggere dati compressi dallo +standard input se è il terminale. +.PP +A meno che non sia specificato \fB\-\-stdout\fP, i \fIFILE\fP diversi da \fB\-\fP +vengono scritti in un nuovo file il cui nome deriva dal nome del \fIFILE\fP +sorgente: +.IP \(bu 3 +Quando si comprime, il suffisso del file destinazione (\fB.xz\fP or \fB.lzma\fP) +viene accodato al nome del file sorgente per ottenere il nome del file +destinazione. +.IP \(bu 3 +Quando si decomprime, i suffissi \fB.xz\fP, \fB.lzma\fP, o \fB.lz\fP vengono rimossi +dal nome del file per ottenere il nome del file destinazione. \fBxz\fP +riconosce anche i suffissi \fB.txz\fP e \fB.tlz\fP, e li sostituisce con il +suffisso \fB.tar\fP. +.PP +Se il file di destinazione esiste già, viene visualizzato un errore e +\fIFILE\fP viene saltato. +.PP +A meno che non si scriva nello standard output, \fBxz\fP visualizzerà un +avvertimento e salterà il \fIFILE\fP se si verifica una delle seguenti +condizioni: +.IP \(bu 3 +\fIFILE\fP non è un file regolare. I collegamenti simbolici non vengono +seguiti, quindi non sono considerati file regolari. +.IP \(bu 3 +\fIFILE\fP ha più di un collegamento "hard". +.IP \(bu 3 +\fIFILE\fP ha impostati i bit setuid, setgid, o sticky. +.IP \(bu 3 +La modalità di funzionamento è impostata sulla compressione e il \fIFILE\fP ha +già un suffisso del formato di file di destinazione (\fB.xz\fP o \fB.txz\fP quando +si comprime nel formato \fB.xz\fP e \fB.lzma\fP o \fB.tlz\fP quando si comprime nel +formato \fB.lzma\fP). +.IP \(bu 3 +La modalità di funzionamento è impostata sulla decompressione e il \fIFILE\fP +non ha un suffisso di nessuno dei formati di file supportati (\fB.xz\fP, +\&\fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, o \fB.lz\fP). +.PP +Dopo aver compresso o decompresso correttamente il \fIFILE\fP, \fBxz\fP copia il +proprietario, il gruppo, le autorizzazioni, l'ora di accesso e l'ora di +modifica dal \fIFILE\fP di origine al file di destinazione. Se la copia del +gruppo fallisce, le autorizzazioni vengono modificate in modo che il file di +destinazione non diventi accessibile agli utenti che non disponevano +dell'autorizzazione per accedere al \fIFILE\fP di origine. \fBxz\fP non supporta +ancora la copia di altri metadati, ad esempio elenchi di controllo degli +accessi o attributi estesi. +.PP +Una volta che il file di destinazione è stato chiuso con successo, il +\fIFILE\fP sorgente viene rimosso, a meno che sia stato specificato +\fB\-\-keep\fP. Il \fIFILE\fP sorgente non viene mai rimosso se l'output è scritto +sullo standard output, né se si verifica un errore. +.PP +L'invio di \fBSIGINFO\fP o \fBSIGUSR1\fP al processo \fBxz\fP comporta la stampa +delle informazioni sullo stato di avanzamento sullo standard error. Questo +ha solo un uso limitato poiché quando lo standard error è un terminale, +utilizzando \fB\-\-verbose\fP verrà visualizzato un indicatore di avanzamento che +si aggiorna automaticamente. +. +.SS "Utilizzo memoria" +L'utilizzo della memoria di \fBxz\fP varia da poche centinaia di kilobyte a +diversi gigabyte a seconda delle impostazioni di compressione. Le +impostazioni utilizzate durante la compressione di un file determinano i +requisiti di memoria del decompressore. In genere il decompressore richiede +dal 5\% al 20\% della quantità di memoria necessaria al compressore durante +la creazione del file. Ad esempio, la decompressione di un file creato con +\fBxz \-9\fP al momento richiede 65\ MiB di memoria. Ancora, è possibile avere +file \fB.xz\fP che richiedono diversi gigabyte di memoria per la +decompressione. +.PP +Soprattutto gli utenti di sistemi più vecchi possono trovare fastidiosa +l'eventualità di un utilizzo molto elevato di memoria. Per evitare +spiacevoli sorprese, \fBxz\fP dispone di un limitatore di utilizzo della +memoria incorporato, che è disabilitato per impostazione predefinita. Anche +se alcuni sistemi operativi forniscono modi per limitare l'utilizzo della +memoria dei processi, fare affidamento su questi non è stato ritenuto +sufficientemente flessibile (ad esempio, l'uso di \fBulimit\fP(1) per limitare +la memoria virtuale tende a paralizzare \fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Il limitatore di utilizzo della memoria può essere abilitato con l'opzione +della riga di comando \fB\-\-memlimit=\fP\fILIMITE\fP. Spesso è più conveniente +abilitare il limitatore per impostazione predefinita impostando la variabile +d'ambiente \fBXZ_DEFAULTS\fP, ad esempio, \fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. È +possibile impostare separatamente i limiti per la compressione e la +decompressione utilizzando \fB\-\-memlimit\-compress=\fP\fILIMITE\fP and +\fB\-\-memlimit\-decompress=\fP\fILIMITE\fP. L'uso di queste due opzioni al di fuori +di \fBXZ_DEFAULTS\fP è raramente utile perché una singola esecuzione di \fBxz\fP +non può eseguire sia la compressione che la decompressione e +\fB\-\-memlimit=\fP\fILIMITE\fP (or \fB\-M\fP \fILIMITE\fP) è più breve da digitare sulla +riga di comando. +.PP +Se il limite di utilizzo della memoria specificato viene superato durante la +decompressione, \fBxz\fP visualizzerà un errore e la decompressione del file +fallirà. Se il limite viene superato durante la compressione, \fBxz\fP tenterà +di ridimensionare le impostazioni in modo che il limite non venga più +superato (tranne quando si usa \fB\-\-format=raw\fP o \fB\-\-no\-adjust\fP). In questo +modo l'operazione non fallirà a meno che il limite sia molto basso. Il +ridimensionamento delle impostazioni viene eseguito in piccole differenze +che non corrispondono ai livelli di compressione preimpostati, ad esempio, +se il limite è solo leggermente inferiore alla quantità richiesta per \fBxz \-9\fP, le impostazioni saranno ridimensionate solo un poco, non proprio fino a +\fBxz \-8\fP. +. +.SS "Concatenazione e padding con file .xz" +È possibile concatenare i file \fB.xz\fP così come sono. \fBxz\fP decomprimerà +tali file come se fossero un singolo file \fB.xz\fP. +.PP +È possibile inserire un padding tra le parti concatenate o dopo l'ultima +parte. Il padding deve essere costituito da byte "null" e la dimensione del +padding deve essere un multiplo di quattro byte. Questo può essere utile, ad +esempio, se il file \fB.xz\fP è memorizzato su un supporto che misura le +dimensioni dei file in blocchi di 512 byte. +.PP +Concatenazione e padding non sono permessi con file \fB.lzma\fP o con flussi +grezzi. +. +.SH OPZIONI +. +.SS "Suffissi interi e valori speciali" +Nella maggior parte dei casi in cui è previsto un argomento intero, è +supportato un suffisso facoltativo per indicare facilmente numeri interi di +grandi dimensioni. Non deve esserci alcuno spazio tra il numero intero e il +suffisso. +.TP +\fBKiB\fP +Moltiplica l'intero per 1024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP, e \fBKB\fP +sono accettati come sinonimi di \fBKiB\fP. +.TP +\fBMiB\fP +Moltiplica l'intero per 1.048.576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP, e \fBMB\fP sono +accettati come sinonimi di \fBMiB\fP. +.TP +\fBGiB\fP +Moltiplica l'intero per 1.073.741.824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP, e \fBGB\fP +sono accettati come sinonimi di \fBGiB\fP. +.PP +Il valore speciale \fBmax\fP può essere utilizzato per indicare il valore +intero massimo supportato dall'opzione. +. +.SS "Modalità operativa" +Se vengono fornite più opzioni di modalità operativa, l'ultima ha effetto. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Compressione. Questa è la modalità operativa predefinita quando non viene +specificata alcuna opzione della modalità operativa e non è determinata +nessun'altra modalità operativa dal nome del comando (ad esempio, \fBunxz\fP +implica \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Dopo che la compressione è terminata con successo, il file origine viene +rimosso a meno che si stia scrivendo su standard output o che venga +specificato \fB\-\-keep\fP. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Decompressione. Dopo che la decompressione è terminata con successo, il file +origine viene rimosso a meno che si stia scrivendo su standard output o che +venga specificato \fB\-\-keep\fP. +.TP +\fB\-t\fP, \fB\-\-test\fP +Testa l'integrità dei \fIFILE\fP compressi. Questa opzione è equivalente a +\fB\-\-decompress \-\-stdout\fP tranne per il fatto che i dati decompressi vengono +scartati invece di essere scritti nello standard output. Nessun file viene +creato o rimosso. +.TP +\fB\-l\fP, \fB\-\-list\fP +Stampa le informazioni sul \fIFILE\fP compresso. Non viene prodotto alcun +output non compresso e non viene creato o rimosso alcun file. In modalità +elenco, il programma non è in grado di leggere i dati compressi dallo +standard input o da altre fonti che non permettano la ricerca. +.IP "" +Il tracciato predefinito mostra le informazioni di base sui \fIFILE\fP, un file +per riga. Per ottenere informazioni più dettagliate, usare anche l'opzione +\fB\-\-verbose\fP. Per avere ancora più informazioni, usare \fB\-\-verbose\fP due +volte, ma si noti che questo può essere lento, perché ottenere tutte le +informazioni extra richiede molte estrazioni. La larghezza dell'output +dettagliato supera gli 80 caratteri, quindi il reindirizzamento dell'output, +ad esempio, a \fBless\ \-S\fP può essere utile se il terminale non è +sufficientemente ampio. +.IP "" +L'output esatto può variare tra le versioni di \fBxz\fP e le diverse +impostazioni locali. Per un output leggibile dalla macchina si dovrebbe +utilizzare \fB\-\-robot \-\-list\fP. +. +.SS "Modificatori dell'operazione" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Non elimina i file input. +.IP "" +A partire da \fBxz\fP 5.2.6, questa opzione fa sì che \fBxz\fP comprima o +decomprima anche se l'input è un collegamento simbolico a un file regolare, +ha più di un collegamento fisico o ha il bit setuid, setgid o sticky +impostato. I bit setuid, setgid e sticky non vengono copiati nel file di +destinazione. Nelle versioni precedenti questo veniva fatto solo con +\fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Questa opzione ha diverse conseguenze: +.RS +.IP \(bu 3 +Se il file di destinazione esiste già, lo elimina prima di comprimere o +decomprimere. +.IP \(bu 3 +Comprime o decomprime anche se l'input è un collegamento simbolico a un file +regolare, ha più di un collegamento "hard", o ha il bit setuid, setgid o +sticky impostato. I bit setuid, setgid e sticky non sono copiati sul file +destinazione. +.IP \(bu 3 +Quando usato con \fB\-\-decompress\fP \fB\-\-stdout\fP e \fBxz\fP non riesce a +riconoscere il tipo di file sorgente, copia il file sorgente così com'è +sullo standard output. Questo permette a \fBxzcat\fP \fB\-\-force\fP di essere usato +come \fBcat\fP(1) per file che non siano stati compressi con \fBxz\fP. Si noti che +in futuro \fBxz\fP potrebbe supportare nuovi formati di file compressi, il che +potrebbe portare \fBxz\fP a decomprimere più tipi di file anziché copiarli come +sono sullo standard output. \fB\-\-format=\fP\fIFORMATO\fP può essere usato per +forzare \fBxz\fP a decomprimere solo un singolo formato di file. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Scrive i dati compressi o decompressi nello standard output anziché in un +file. Implica \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Decomprime solo il primo flusso \fB.xz\fP, e ignora automaticamente i possibili +dati di input rimanenti che seguono il flusso. Normalmente questi dati +sporchi finali portano \fBxz\fP a visualizzare un errore. +.IP "" +\fBxz\fP non decomprime mai più di un flusso dai file \fB.lzma\fP o dai flussi +grezzi, ma questa opzione fa comunque in modo che \fBxz\fP ignori i possibili +dati finali dopo il file \fB.lzma\fP o il flusso grezzo. +.IP "" +Questa opzione non ha effetto se la modalità operativa non è \fB\-\-decompress\fP +o \fB\-\-test\fP. +.IP "" +Dalla versione \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP implica \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Disabilita la creazione di file sparsi. Per impostazione predefinita, se si +esegue la decompressione in un file regolare, \fBxz\fP tenta di rendere il file +sparso se i dati decompressi contengono lunghe sequenze di zeri +binari. Funziona anche quando si scrive su standard output, purché lo +standard output sia collegato a un file regolare e siano soddisfatte alcune +condizioni aggiuntive per renderlo sicuro. La creazione di file sparsi può +risparmiare spazio su disco e velocizzare la decompressione riducendo la +quantità di I/O su disco. +.TP +\fB\-S\fP \fI.SUFFISSO\fP, \fB\-\-suffix=\fP\fI.SUFFISSO\fP +Durante la compressione, utilizzare \fI.suf\fP come suffisso per il file di +destinazione anziché \fB.xz\fP o \fB.lzma\fP. Se non si scrive nello standard +output e il file di origine ha già il suffisso \fI.suf\fP, viene visualizzato +un avvertimento e il file viene ignorato. +.IP "" +Quando si decomprime, accetta i file con suffisso \fI.suf\fP in aggiunta a +quelli con suffisso \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, o \fB.lz\fP. Se il file +sorgente ha suffisso \fI.suf\fP, il suffisso viene rimosso per ottenere il nome +del file destinazione. +.IP "" +Quando si comprimono o decomprimono flussi grezzi (\fB\-\-format=raw\fP), il +suffisso deve sempre essere specificato, a meno che si scriva sullo standard +output, perché non esiste un suffisso predefinito per i flussi grezzi. +.TP +\fB\-\-files\fP[\fB=\fP\fIFILE\fP] +Legge i nomi dei file da processare da \fIFILE\fP; se \fIFILE\fP è omesso, i nomi +dei file vengono letti dallo standard input. I nomi dei file devono essere +terminati da un carattere "a capo". Un trattino (\fB\-\fP) è considerato come un +nome di file regolare; non indica lo standard input. Se vengono forniti +anche dei nomi di file come argomenti della riga di comando, questi sono +processati prima di quelli letti da \fIFILE\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIFILE\fP] +Questo è identico a \fB\-\-files\fP[\fB=\fP\fIFILE\fP] tranne per il fatto che ogni +nome di file deve terminare con il carattere null. +. +.SS "Formato file di base e opzioni di compressione" +.TP +\fB\-F\fP \fIFORMATO\fP, \fB\-\-format=\fP\fIFORMATO\fP +Specifica il \fIFORMATO\fP del file da comprimere o decomprimere: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Questa è l'impostazione predefinita. Quando si comprime, \fBauto\fP è +equivalente a \fBxz\fP. Quando si decomprime, il formato del file input viene +rilevato automaticamente. Si noti che per i flussi grezzi (creati con +\fB\-\-format=raw\fP) non è possibile il rilevamento automatico. +.TP +\fBxz\fP +Comprime nel formato di file \fB.xz\fP, oppure accetta solo file \fB.xz\fP durante +la decompressione. +.TP +\fBlzma\fP, \fBalone\fP +Comprime nel formato tradizionale \fB.lzma\fP, oppure accetta solo file +\&\fB.lzma\fP per la decompressione. Il nome alternativo \fBalone\fP è fornito per +retrocompatibilità con le LZMA Utils. +.TP +\fBlzip\fP +Accetta solo file \fB.lz\fP per la decompressione. La compressione non è +supportata. +.IP "" +Sono supportate le versioni 0 e 1 del formato \fB.lz\fP. I file in versione 0 +sono stati prodotti da \fBlzip\fP 1.3 e precedenti. Questi file non sono +comuni, ma possono essere trovati negli archivi di file, perché alcuni +pacchetti sorgente erano stati rilasciati in questo formato. Qualcuno +potrebbe anche avere vecchi file personali in questo formato. Il supporto +alla decompressione per la versione di formato 0 è stato rimosso in \fBlzip\fP +1.18. \fBlzip\fP 1.4 e successivi creano i file nella versione di formato 1. +.TP +\fBraw\fP +Comprime o decomprime un flusso grezzo (senza intestazione). Questo è inteso +solamente per utenti avanzati. Per decodificare flussi grezzi, occorre usare +\fB\-\-format=raw\fP e specificare esplicitamente la catena dei filtri, che +normalmente sarebbero conservati nell'intestazione. +.RE +.TP +\fB\-C\fP \fICONTROLLO\fP, \fB\-\-check=\fP\fICONTROLLO\fP +Specifica il tipo di controllo di integrità. Il controllo viene calcolato +dai dati non compressi e memorizzato nel file \fB.xz\fP. Questa opzione ha +effetto solo quando si comprime nel formato \fB.xz\fP; il formato \fB.lzma\fP non +supporta i controlli di integrità. Il controllo di integrità (se presente) +viene verificato quando il file \fB.xz\fP viene decompresso. +.IP "" +Tipi di \fICONTROLLI\fP supportati: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Non calcola proprio il controllo di integrità. Questo in genere è una +pessima idea. Può essere utile quando l'integrità dei dati viene comunque +verificata con altri mezzi. +.TP +\fBcrc32\fP +Calcola la firma CRC32 usando il polinomio di IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Calcola la firma CRC64 usando il polinomio di ECMA\-182. Questa è +l'impostazione predefinita, perché è leggermente migliore della CRC32 nel +rilevare i file danneggiati e la differenza di velocità è trascurabile. +.TP +\fBsha256\fP +Calcola la firma SHA\-256. Questo è un po' più lento che CRC32 e CRC64. +.RE +.IP "" +L'integrità delle intestazioni \fB.xz\fP viene sempre verificata con CRC32. Non +è possibile modificarlo o disabilitarlo. +.TP +\fB\-\-ignore\-check\fP +Non verifica il controllo di integrità dei dati compressi durante la +decompressione. Il valore CRC3 nelle intestazioni \fB.xz\fP sarà ancora +verificata normalmente. +.IP "" +\fBNon usare questa opzione se non si è consci di cosa si sta facendo.\fP +Possibili ragioni per utilizzare questa opzione: +.RS +.IP \(bu 3 +Tentativo di recupero dei dati da un file .xz corrotto. +.IP \(bu 3 +Accelerazione della decompressione. Questo è importante soprattutto con +SHA\-256 o con i file che sono stati compressi molto bene. Si consiglia di +non utilizzare questa opzione per questo scopo, a meno che l'integrità del +file non venga verificata esternamente in altro modo. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Selezionare un livello di compressione preimpostato. Il valore predefinito è +\fB\-6\fP. Se vengono specificati più livelli preimpostati, l'ultimo ha +effetto. Se è già stata specificata una catena di filtri personalizzata, +l'impostazione di un livelli preimpostati cancella la catena di filtri +personalizzata. +.IP "" +Le differenze tra i livelli preimpostati sono più significative rispetto a +\fBgzip\fP(1) e \fBbzip2\fP(1). Le impostazioni di compressione selezionate +determinano i requisiti di memoria del decompressore, quindi l'utilizzo di +un livello preimpostato troppo alto potrebbe rendere difficile la +decompressione del file su un vecchio sistema con poca RAM. Specificamente, +\fBnon è una buona idea utilizzare ciecamente \-9 per tutto\fP come spesso +accade per \fBgzip\fP(1) e \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Questi sono livelli preimpostati piuttosto veloci. \fB\-0\-\fP a volte è più +veloce di \fBgzip \-9\fP e comprime molto meglio. Quelli più alti hanno spesso +una velocità paragonabile a \fBbzip2\fP(1) con un rapporto di compressione +comparabile o migliore, anche se i risultati dipendono molto dal tipo di +dati che vengono compressi. +.TP +\fB\-4\fP ... \fB\-6\fP +Compressione da buona a molto buona, mantenendo l'utilizzo della memoria del +decompressore ragionevole anche per vecchi sistemi. \fB\-6\fP è il valore +predefinito, che di solito è una buona scelta per distribuire file che +debbano essere decompressi anche su sistemi con solo 16\ MiB di +RAM. (Potrebbe valere la pena di considerare anche \fB\-5e\fP o \fB\-6e\fP. Si veda +\fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Questi sono come \fB\-6\fP ma con requisiti di memoria di compressore e +decompressore più elevati. Sono utili solo quando si comprimono file di +dimensioni superiori a 8\ MiB, 16\ MiB e 32\ MiB, rispettivamente. +.RE +.IP "" +A parità di hardware, la velocità di decompressione è approssimativamente un +numero costante di byte di dati compressi al secondo. In altre parole, +migliore è la compressione, più veloce sarà di solito la decompressione. Ciò +significa anche che la quantità di output non compresso prodotta al secondo +può variare notevolmente. +.IP "" +La tabella seguente riassume le caratteristiche dei livelli preimpostati: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Livello preimpostato;DictSize;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Descrizioni delle colonne: +.RS +.IP \(bu 3 +DictSize è la dimensione del dizionario LZMA2. È uno spreco di memoria usare +un dizionario più grande della dimensione del file non compresso. Ecco +perché è una buona cosa evitare di usare i livelli preimpostati \fB\-7\fP +\&... \fB\-9\fP quando non c'è reale necessità. Con \fB\-6\fP e inferiori, la quantità +di memoria sprecata in genere è sufficientemente bassa da essere +trascurabile. +.IP \(bu 3 +CompCPU è una rappresentazione semplificata delle impostazioni di LZMA2 che +influenzano la velocità di compressione. Anche la dimensione del dizionario +influenza la velocità, quindi mentre CompCPU è lo stesso per i livelli \fB\-6\fP +\&... \fB\-9\fP, i livelli più alti tendono ancora ad essere un po' più lenti. Per +avere una compressione ancora più lenta e quindi potenzialmente migliore, +utilizzare \fB\-\-extreme\fP. +.IP \(bu 3 +CompMem contiene i requisiti di memoria del compressore in modalità a +singola thread. Può variare leggermente tra le versioni di \fBxz\fP. +.IP \(bu 3 +DecMem contiene i requisiti di memoria del decompressore. In altre parole, +le impostazioni di compressione determinano i requisiti di memoria del +decompressore. L'utilizzo esatto della memoria del decompressore è +leggermente superiore alla dimensione del dizionario LZMA2, ma i valori +nella tabella sono stati arrotondati per eccesso al successivo MiB completo. +.RE +.IP "" +I requisiti di memoria per la modalità a thread multiple sono +significativamente più alti che per la modalità thread singola. Con il +valore predefinito di \fB\-\-block\-size\fP, ogni thread richiede 3*3*dimensione +del dizionario più CompMem oppure DecMem. Ad esempio, 4 thread con il +livello preimpostato \fB\-6\fP hanno bisogno di 660\(en670\ MiB di memoria. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Utilizzare una variante più lenta del livello preimpostato selezionato +(\fB\-0\fP ... \fB\-9\fP) nella speranza di ottenere un rapporto di compressione +leggermente migliore, ma con un po' di sfortuna questo potrebbe anche +renderlo peggiore. L'utilizzo della memoria del decompressore non è +influenzato, ma l'utilizzo della memoria del compressore aumenta leggermente +ai livelli preimpostati \fB\-0\fP ... \fB\-3\fP. +.IP "" +Dal momento che ci sono due livelli preimpostati con dimensione del +dizionario di 4\ MiB e 8\ MiB, i livelli preimpostati \fB\-3e\fP e \fB\-5e\fP usano +impostazioni leggermente più veloci (minore CompCPU) di \fB\-4e\fP e \fB\-6e\fP, +rispettivamente. In questo modo non ci sono due livelli preimpostati +identici. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Livello preimpostato;DictSize;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Ad esempio, ci sono un totale di quattro livelli preimpostati che utilizzano +un dizionario da 8\ MiB, il cui ordine dal più veloce al più lento è \fB\-5\fP, +\fB\-6\fP, \fB\-5e\fP, e \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Questi sono alias in qualche modo fuorvianti per \fB\-0\fP e \fB\-9\fP, +rispettivamente. Sono forniti solo per retrocompatibilità con le LZMA +Utils. Evitare di utilizzare queste opzioni. +.TP +\fB\-\-block\-size=\fP\fIDIMENSIONE\fP +Quando si comprime in formato \fB.xz\fP, divide i dati input in blocchi da +\fIDIMENSIONE\fP byte. I blocchi vengo compressi indipendentemente l'uno +dall'altro, cosa che aiuta con le thread multiple e rende possibile la +decompressione con accessi casuali limitati. Questa opzione viene usata +tipicamente per sovrascrivere la dimensione predefinita dei blocchi in +modalità a thread multiple, ma può essere utilizzata anche in modalità +thread singola. +.IP "" +In modalità a thread multiple verranno allocati circa il triplo di +\fIDIMENSIONE\fP di byte in ogni thread per il buffering dell'input e +dell'output. La \fIDIMENSIONE\fP predefinita è tre volte la dimensione del +dizionario LZMA2 e comunque almeno 1 MiB. Tipicamente un buon valore è +2\(en4 volte la dimensione del dizionario LZMA2 oppure almeno 1 MiB. Usare +una \fIDIMENSIONE\fP inferiore della dimensione del dizionario LZMA2 causa uno +spreco di RAM, in quanto il buffer del dizionario LZMA2 non verrà mai +riempito completamente. In modalità a thread multiple, la dimensione dei +blocchi è conservata nelle intestazioni dei blocchi. L'informazione sulla +dimensione è richiesta per la decompressione a thread multiple. +.IP "" +Nella modalità a thread singola, per impostazione predefinita non viene +eseguita alcuna suddivisione in blocchi. L'impostazione di questa opzione +non influisce sull'utilizzo della memoria. Nessuna informazione sulle +dimensioni viene memorizzata nelle intestazioni di blocco, quindi i file +creati in modalità a thread singola non saranno identici ai file creati in +modalità a thread multiple. La mancanza di informazioni sulle dimensioni +significa anche che \fBxz\fP non sarà in grado di decomprimere i file in +modalità a thread multiple. +.TP +\fB\-\-block\-list=\fP\fIELEMENTI\fP +Quando si comprime nel formato \fB.xz\fP, inizia un nuovo blocco con una catena +di filtri personalizzata dopo gli intervalli indicati di dati non compressi. +.IP "" +Gli \fIELEMENTI\fP sono un elenco separato da virgole. Ogni elemento è +costituito da un numero di catena di filtri opzionale compreso tra 0 e 9 +seguito da due punti (\fB:\fP) e da una dimensione richiesta di dati non +compressi. L'omissione di un elemento (due o più virgole consecutive) è una +scorciatoia per utilizzare le dimensioni e i filtri dell'elemento +precedente. +.IP "" +Se il file di input è più grande della somma delle dimensioni in +\fIELEMENTI\fP, l'ultimo elemento viene ripetuto fino alla fine del file. Il +valore speciale \fB0\fP può essere utilizzato come ultima dimensione per +indicare che il resto del file deve essere codificato come un singolo +blocco. +.IP "" +È possibile specificare una catena di filtri alternativa per ogni blocco in +combinazione con le opzioni \fB\-\-filters1=\fP\fIFILTRI\fP \&...\& +\fB\-\-filters9=\fP\fIFILTRI\fP. Queste opzioni definiscono catene di filtri con un +identificatore compreso tra 1\(en9. La catena di filtri 0 può essere +utilizzata per indicare la catena di filtri predefinita, che equivale a non +specificare una catena di filtri. L'identificatore della catena di filtri +può essere utilizzato prima della dimensione non compressa, seguita da due +punti (\fB:\fP). Ad esempio, se si specifica +\fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP allora i blocchi verranno +creati utilizzando: +.RS +.IP \(bu 3 +La catena dei filtri specificata da \fB\-\-filters1\fP e un input di 2 MiB +.IP \(bu 3 +La catena dei filtri specificata da \fB\-\-filters3\fP e un input di 2 MiB +.IP \(bu 3 +La catena dei filtri specificata da \fB\-\-filters2\fP e un input di 4 MiB +.IP \(bu 3 +La catena dei filtri specificata da \fB\-\-filters2\fP e un input di 4 MiB +.IP \(bu 3 +La catena di filtri predefinita e l'input di 2 MiB +.IP \(bu 3 +La catena di filtri predefinita e l'input di 4 MiB per ogni blocco fino alla +fine dell'input. +.RE +.IP "" +Se si specifica una dimensione che supera la dimensione del blocco del +codificatore (il valore predefinito in modalità thread oppure il valore +specificato con \fB\-\-block\-size=\fP\fIDIMENSIONE\fP), il codificatore creerà +blocchi aggiuntivi mantenendo i limiti specificati in \fIELEMENTI\fP. Ad +esempio, se si indica \fB\-\-block\-size=10MiB\fP +\fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP e il file input è di 80 MiB, si +otterranno 11 blocchi: 5, 10, 8, 10, 2, 10, 10, 4, 10, 10, and 1 MiB. +.IP "" +In modalità a thread multiple, le dimensioni dei blocchi vengono memorizzate +nelle intestazioni dei blocchi. Questo non avviene in modalità thread +singola, quindi l'output codificato non sarà identico a quello della +modalità a thread multiple. +.TP +\fB\-\-flush\-timeout=\fP\fITIMEOUT\fP +Quando si comprime, se sono passati più di \fITIMEOUT\fP millisecondi (un +intero positivo) dallo scaricamento precedente e la lettura di ulteriori +input si bloccherebbe, tutti i dati di input in sospeso vengono scaricati +dal codificatore e resi disponibili nel flusso di output. Questo può essere +utile se \fBxz\fP viene usato per comprimere dati in streaming dalla +rete. Piccoli valori del \fITIMEOUT\fP rendono disponibili i dati al ricevente +con un ritardo minimo, mentre valori di \fITIMEOUT\fP grandi danno un miglior +rapporto di compressione. +.IP "" +Questa funzionalità è disabilitata per impostazione predefinita. Se questa +opzione viene specificata più di una volta, l'ultima ha effetto. Il valore +speciale \fITIMEOUT\fP di \fB0\fP può essere utilizzato per disabilitare +esplicitamente questa funzionalità. +.IP "" +Questa funzionalità non è disponibile sui sistemi non\-POSIX. +.IP "" +.\" FIXME +\fBQuesta funzionalità è sperimentale.\fP Attualmente \fBxz\fP non è adatto per +decomprimere il flusso in tempo reale, a causa di come effettua il +buffering. +.TP +\fB\-\-no\-sync\fP +Non sincronizzare il file target e la sua directory sull'unità di +archiviazione prima di rimuovere il file sorgente. Questo può migliorare le +performance se si sta comprimendo o decomprimendo tanti piccoli +file. Tuttavia, se il sistema dovesse andare in crash subito dopo +l'eliminazione, è possibile che il file destinazione non sia ancora stato +scritto sull'unità di archiviazione mentre l'operazione di eliminazione +sì. In questo caso non saranno più disponibili né il file sorgente originale +né il file di destinazione. +.IP "" +Questa opzione ha effetto solamente quando \fBxz\fP deve rimuovere il file +sorgente. Negli altri casi la sincronizzazione non viene eseguita. +.IP "" +La sincronizzazione e \fB\-\-no\-sync\fP sono stati aggiunti nella versione \fBxz\fP +5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fILIMITE\fP +Imposta un limite di utilizzo della memoria per la compressione. Se questa +opzione viene specificata più volte, ha effetto l'ultima. +.IP "" +Se le impostazioni di compressione superano il valore \fILIMITE\fP, \fBxz\fP +tenterà di regolare le impostazioni verso il basso in modo che il limite non +venga più superato e visualizzerà un avviso che indica che è stata eseguita +una regolazione automatica. Le regolazioni vengono eseguite in questo +ordine: riduzione del numero di thread, passaggio alla modalità a thread +singola se anche un solo thread in modalità a thread multiple supera il +\fILIMITE\fP, e infine riducendo la dimensione del dizionario LZMA2. +.IP "" +Quando si comprime con \fB\-\-format=raw\fP oppure se si è specificato +\fB\-\-no\-adjust\fP, è possibile ridurre solo il numero di thread, poiché questo +può essere fatto senza influire sull'output compresso. +.IP "" +Se non è possibile soddisfare il \fILIMITE\fP anche con le regolazioni sopra +descritte, viene visualizzato un errore e \fBxz\fP uscirà con lo stato di +uscita 1. +.IP "" +Il \fILIMITE\fP può essere specificato in diversi modi: +.RS +.IP \(bu 3 +Il \fILIMITE\fP può essere un valore assoluto in byte. Usare un suffisso intero +come \fBMiB\fP può essere utile. Ad esempio: \fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +Il \fILIMITE\fP può essere specificato come percentuale della memoria fisica +(RAM) totale. Questo può essere utile specialmente quando si imposta la +variabile di ambiente \fBXZ_DEFAULTS\fP in uno script di inizializzazione di +shell che è condiviso tra computer diversi. In questo modo il limite è +automaticamente più grande sui sistemi con più memoria. Ad esempio: +\fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +Il \fILIMITE\fP può essere reimpostato al suo valore predefinito impostandolo a +\fB0\fP.Questo attualmente equivale a impostare il \fILIMITE\fP a \fBmax\fP (nessun +limite nell'utilizzo di memoria). +.RE +.IP "" +Per \fBxz\fP a 32\-bit esiste un caso particolare: se il \fILIMITE\fP fosse oltre +\fB4020\ MiB\fP, il \fILIMITE\fP viene impostato a \fB4020\ MiB\fP. Su MIPS32 invece +viene usato \fB2000\ MiB\fP. (I valori \fB0\fP e \fBmax\fP non sono influenzati da +questo. Un comportamento simile non esiste per la decompressione). Questo +può essere utile quando un eseguibile a 32 bit ha accesso a uno spazio di +indirizzi da 4\ GiB (2 GiB su MIPS32), e si spera che non faccia danni in +altre situazioni. +.IP "" +Vedere anche la sezione \fBUtilizzo memoria\fP +.TP +\fB\-\-memlimit\-decompress=\fP\fILIMITE\fP +Imposta un limite di utilizzo della memoria per la decompressione. Questo +influisce anche sulla modalità \fB\-\-list\fP. Se l'operazione non è possibile +senza oltrepassare il \fILIMITE\fP, \fBxz\fP mostrerà un errore e la +decompressione del file fallirà. Si veda \fB\-\-memlimit\-compress=\fP\fILIMITE\fP +per possibili modi per specificare il \fILIMITE\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fILIMITE\fP +Imposta un limite di utilizzo della memoria per la decompressione +multi\-thread. Questo può influire solo sul numero di thread; non indurrà mai +\fBxz\fP a rifiutarsi di decomprimere un file. Se \fILIMITE\fP è troppo basso per +consentire le thread multiple, il \fILIMITE\fP viene ignorato e \fBxz\fP +continuerà in modalità a thread singola. Si noti che se viene utilizzato +anche \fB\-\-memlimit\-decompress\fP, si applicherà sempre sia alla modalità a +thread singola che a quella a thread multiple, e quindi il \fILIMITE\fP +effettivo per le thread multiple non sarà mai superiore a quello impostato +con \fB\-\-memlimit\-decompress\fP. +.IP "" +In contrasto con le altre opzioni di limite di utilizzo della memoria, +\fB\-\-memlimit\-mt\-decompress=\fP\fILIMITE\fP ha un \fILIMITE\fP predefinito specifico +per il sistema. \fBxz \-\-info\-memory\fP può essere utilizzato per vedere il +valore corrente. +.IP "" +Questa opzione e il suo valore predefinito esistono perché, senza un limite, +il decompressore a thread multiple potrebbe finire per allocare una quantità +folle di memoria per alcuni file input. Se il valore predefinito \fILIMITE\fP è +troppo basso sul proprio sistema, è possibile aumentarlo liberamente, ma non +deve essere mai impostato a un valore più grande della quantità di RAM +utilizzabile, in quanto con file di input appropriati \fBxz\fP cercherà di +utilizzare quella quantità di memoria anche con un basso numero di +thread. Esaurire la memoria o fare swap non migliorerà le performance della +decompressione. +.IP "" +Vedi \fB\-\-memlimit\-compress=\fP\fILIMITE\fP per possibili modi per specificare il +\fILIMITE\fP. Impostando \fILIMITE\fP su \fB0\fP si ripristina il valore predefinito +\fILIMITE\fP specifico del sistema. +.TP +\fB\-M\fP \fILIMITE\fP, \fB\-\-memlimit=\fP\fILIMITE\fP, \fB\-\-memory=\fP\fILIMITE\fP +Questo equivale a specificare \fB\-\-memlimit\-compress=\fP\fILIMITE\fP +\fB\-\-memlimit\-decompress=\fP\fILIMITE\fP \fB\-\-memlimit\-mt\-decompress=\fP\fILIMITE\fP. +.TP +\fB\-\-no\-adjust\fP +Visualizza un errore e esce se non è possibile soddisfare il limite di +utilizzo della memoria senza regolare le impostazioni che influiscono +sull'output compresso. In altre parole, ciò impedisce a \fBxz\fP di passare il +codificatore dalla modalità multi\-thread alla modalità a thread singola e di +ridurre le dimensioni del dizionario LZMA2. Anche quando viene usata questa +opzione, il numero di thread può essere ridotto per soddisfare il limite di +utilizzo della memoria, in quanto ciò non influirà sull'output compresso. +.IP "" +La regolazione automatica è sempre disabilitata quando si creano flussi raw +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fITHREADS\fP, \fB\-\-threads=\fP\fITHREADS\fP +Specifica il numero di thread di lavoro da utilizzare. L'impostazione di +\fITHREADS\fP al valore speciale \fB0\fP fa sì che \fBxz\fP utilizzi fino a un numero +di thread che il processore/i del sistema supportano. Il numero effettivo di +thread può essere inferiore a \fITHREADS\fP se il file di input non è +sufficientemente grande per il threading con le impostazioni specificate o +se l'utilizzo di più thread supera il limite di utilizzo della memoria. +.IP "" +I compressori a thread singola e a thread multiple producono output +diversi. Il compressore a thread singola produrrà la dimensione del file più +piccola, ma solo l'output del compressore a thread multiple può essere +decompresso utilizzando più thread. Impostando \fITHREADS\fP su \fB1\fP verrà +utilizzata la modalità a thread singola. L'impostazione di \fITHREADS\fP su +qualsiasi altro valore, incluso \fB0\fP, utilizzerà il compressore a thread +multiple anche se il sistema supporta un solo thread hardware. (\fBxz\fP 5.2.x +utilizzava la modalità a thread singola in questa situazione.) +.IP "" +Per utilizzare la modalità a thread multiple con un solo thread, impostare +\fITHREADS\fP su \fB+1\fP. Il prefisso \fB+\fP non ha alcun effetto con valori +diversi da \fB1\fP. Un limite di utilizzo della memoria può comunque far +passare \fBxz\fP alla modalità a thread singola a meno che non venga utilizzato +\fB\-\-no\-adjust\fP. Il supporto per il prefisso \fB+\fP è stato aggiunto in \fBxz\fP +5.4.0. +.IP "" +Se è stato richiesto un numero automatico di thread e non è stato +specificato alcun limite di utilizzo della memoria, verrà utilizzato un +limite "soft" predefinito, specifico del sistema, per limitare eventualmente +il numero di thread. È un limite "soft" nel senso che viene ignorato se il +numero di thread diventa uno, quindi un limite soft non impedirà mai a \fBxz\fP +di comprimere o decomprimere. Questo limite soft predefinito non farà +passare \fBxz\fP dalla modalità a thread multiple alla modalità thread +singola. I limiti attivi possono essere visualizzati con \fBxz \-\-info\-memory\fP. +.IP "" +Attualmente l'unico metodo di threading consiste nel dividere l'input in +blocchi e comprimerli indipendentemente l'uno dall'altro. La dimensione +predefinita del blocco dipende dal livello di compressione e può essere +sovrascritta con l'opzione \fB\-\-block\-size=\fP\fIDIMENSIONE\fP. +.IP "" +La decompressione a thread multiple funziona solo su file che contengano più +blocchi con l'informazione della dimensione nelle intestazioni del +blocco. Tutti i file sufficientemente grandi compressi in modalità a thread +multiple soddisfano questa condizione, mentre i file compressi in modalità +thread singola no, neanche se si è utilizzato \fB\-\-block\-size=\fP +\fIDIMENSIONE\fP. +.IP "" +Il valore predefinito per \fITHREADS\fP è \fB0\fP. In \fBxz\fP 5.4.x e precedenti il +valore predefinito era \fB1\fP. +. +.SS "Catene di filtri di compressione personalizzate" +Una catena di filtri personalizzata consente di specificare in dettaglio le +impostazioni di compressione invece di fare affidamento sulle impostazioni +associate ai livelli preimpostati. Quando viene specificata una catena di +filtri personalizzata, le opzioni relative ai livelli preimpostati (\fB\-0\fP +\&...\& \fB\-9\fP e \fB\-\-extreme\fP) specificate in precedenza sulla riga di +comando vengono dimenticate. Se un'opzione livello preimpostato viene +specificata dopo una o più opzioni della catena di filtri personalizzata, il +nuovo livello preimpostato ha effetto e le opzioni della catena di filtri +personalizzate specificate in precedenza vengono dimenticate. +.PP +Una catena di filtri è paragonabile a una pipe sulla riga di +comando. Durante la compressione, l'input non compresso va al primo filtro, +il cui output va al filtro successivo (se presente). L'output dell'ultimo +filtro viene scritto nel file compresso. Il numero massimo di filtri nella +catena è quattro, ma in genere una catena di filtri ha solo uno o due +filtri. +.PP +Molti filtri hanno limitazioni su dove possono trovarsi nella catena di +filtri: alcuni filtri possono funzionare solo come ultimo filtro della +catena, altri solo come filtro non ultimo e alcuni funzionano in qualsiasi +posizione nella catena. A seconda del filtro, questa limitazione è inerente +alla struttura del filtro oppure esiste per evitare problemi di sicurezza. +.PP +Una catena di filtri personalizzata può essere specificata in due modi +diversi. Le opzioni \fB\-\-filters=\fP\fIFILTRI\fP and \fB\-\-filters1=\fP\fIFILTRI\fP +\&...\& \fB\-\-filters9=\fP\fIFILTRI\fP permettono di specificare un'intera catena +di filtri in una opzione utilizzando la sintassi della stringa del filtro di +lzma. In alternativa, una catena di filtri può essere specificata +utilizzando una o più singole opzioni di filtro nell'ordine desiderato nella +catena di filtri. Questo significa che l'ordine delle singole opzioni di +filtro è importante! Quando si decodificano i flussi grezzi +(\fB\-\-format=raw\fP), la catena di filtri deve essere specificata nello stesso +ordine in cui è stata specificata durante la compressione. Qualsiasi filtro +individuale o opzione livello preimpostato specificata prima dell'opzione +della catena completa (\fB\-\-filters=\fP\fIFILTRI\fP) verrà dimenticata. I singoli +filtri specificati dopo l'opzione della catena completa reimposteranno la +catena di filtri. +.PP +Sia l'opzione di filtro completo che quella individuale accettano \fIOPZIONI\fP +specifiche del filtro come un elenco separato da virgole. Virgole in eccesso +nelle \fIOPZIONI\fP vengono ignorate. Ogni opzione ha un valore di default, +quindi occorre specificare solamente quelle che si desidera modificare. +.PP +Per vedere l'intera catena di filtri e \fIOPZIONI\fP, usa \fBxz \-vv\fP (ossia, usa +\fB\-\-verbose\fP due volte). Questo funziona anche per visualizzare le opzioni +della catena di filtri utilizzate dai livelli preimpostati. +.TP +\fB\-\-filters=\fP\fIFILTRI\fP +Specifica l'intera catena dei filtri oppure un livello preimpostato in una +singola opzione. Ogni filtro può essere separato da spazi o da due trattini +(\fB\-\-\fP). Potrebbe essere necessario mettere tra virgolette i \fIFILTRI\fP sulla +riga di comando della shell in modo che vengano analizzati come una singola +opzione. Per indicare \fIOPZIONI\fP, usa \fB:\fP o \fB=\fP. Un livello preimpostato +può essere preceduto da un \fB\-\fP e seguito da zero o più flag. L'unico flag +supportato è \fBe\fP per applicare le stesse opzioni di \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIFILTRI\fP ... \fB\-\-filters9\fP=\fIFILTRI\fP +Specifica fino a nove catene di filtri aggiuntive che possono essere +utilizzate con \fB\-\-block\-list\fP. +.IP "" +Ad esempio, quando si comprime un archivio con file eseguibili seguiti da +file di testo, la parte eseguibile potrebbe utilizzare una catena di filtri +con un filtro BCJ e la parte di testo solo il filtro LZMA2. +.TP +\fB\-\-filters\-help\fP +Mostra un messaggio di aiuto che descrive come specificare livelli +preimpostati e catene di filtri personalizzati nelle opzioni \fB\-\-filters\fP e +\fB\-\-filters1=\fP\fIFILTRI\fP \&...\& \fB\-\-filters9=\fP\fIFILTRI\fP, e termina con +successo. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIOPZIONI\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIOPZIONI\fP] +.PD +Aggiunge un filtro LZMA1 o LZMA2 alla catena dei filtri. Questi filtri +possono essere usati solo come ultimo filtro della catena. +.IP "" +LZMA1 è un filtro obsoleto, supportato quasi esclusivamente a causa del +formato obsoleto di file \fB.lzma\fP, che supporta solo LZMA1. LZMA2 è una +versione aggiornata di LZMA1 che risolve alcuni problemi pratici di +LZMA1. Il formato \fB.xz\fP utilizza LZMA2 e non supporta LZMA1. La velocità e +i rapporti di compressione di LZMA1 e LZMA2 sono praticamente gli stessi. +.IP "" +LZMA1 e LZMA2 condividono lo stesso insieme di \fIOPZIONI\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIPRESET\fP +Reimposta tutte le \fIOPZIONI\fP LZMA1 o LZMA2 a \fIPRESET\fP. Il \fIPRESET\fP +(livello preimpostato) consiste di un numero intero, che può essere seguito +da modificatori costituiti da una singola lettera. Il numero intero può +andare da \fB0\fP a \fB9\fP, corrispondenti alle opzioni della riga di comando +\fB\-0\fP \&...\& \fB\-9\fP. L'unico modificatore attualmente supportato è \fBe\fP, che +corrisponde a \fB\-\-extreme\fP. Se non viene specificato alcun \fIPRESET\fP, i +valori predefiniti delle \fIOPZIONI\fP LZMA1 o LZMA2 sono presi dal livello +preimpostato \fB6\fP. +.TP +\fBdict=\fP\fIDIMENSIONE\fP +La \fIDIMENSIONE\fPdel dizionario (buffer di cronologia) indica quanti byte dei +dati non compressi elaborati di recente vengono mantenuti in +memoria. L'algoritmo tenta di trovare sequenze di byte ripetute +(corrispondenze) nei dati non compressi e di sostituirle con riferimenti ai +dati attualmente presenti nel dizionario. Più grande è il dizionario, +maggiore è la possibilità di trovare una corrispondenza. Quindi, l'aumento +della \fIDIMENSIONE\fP del dizionario di solito migliora il rapporto di +compressione, ma un dizionario più grande del file non compresso è uno +spreco di memoria. +.IP "" +Una \fIDIMENSIONE\fP tipica per un dizionario è da 64\ KiB a 64\ MiB. Il minimo +è 4\ KiB. Il massimo per la compressione è attualmente 1.5\ GiB (1536\ MiB). La decompressione supporta già dizionari fino a 4\ GiB meno 1 byte, +che è il massimo per i formati di flusso LZMA1 e LZMA2. +.IP "" +La \fIDIMENSIONE\fP del dizionario e il cercatore di corrispondenze +(\fICERCATORE\fP) insieme determinano l'utilizzo della memoria del codificatore +LZMA1 o LZMA2. Per la decompressione è necessaria la stessa \fIDIMENSIONE\fP +del dizionario utilizzata durante la compressione (o più grande), quindi +l'utilizzo della memoria del decodificatore è determinato dalla dimensione +del dizionario utilizzato durante la compressione. Le intestazioni \fB.xz\fP +memorizzano la \fIDIMENSIONE\fP del dizionario come 2^\fIn\fP o 2^\fIn\fP + 2^( +\fIn\fP\-1), quindi queste \fIDIMENSIONI\fP sono in qualche modo preferite per la +compressione. Altre \fIDIMENSIONI\fP verranno arrotondate per eccesso quando +memorizzate nelle intestazioni \fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Specificare il numero di bit di contesto letterali. Il minimo è 0 e il +massimo è 4; Il valore predefinito è 3. Inoltre, la somma di \fIlc\fP e \fIlp\fP +non deve superare 4. +.IP "" +Tutti i byte che non possono essere codificati come corrispondenze vengono +codificati come valori letterali. In altre parole, i valori letterali sono +semplicemente byte a 8 bit codificati uno alla volta. +.IP "" +La codifica letterale presuppone che i bit di \fIlc\fP più alti del byte non +compresso precedente siano correlati al byte successivo. Ad esempio, in un +tipico testo inglese, una lettera maiuscola è spesso seguita da una lettera +minuscola e una lettera minuscola è solitamente seguita da un'altra lettera +minuscola. Nel set di caratteri US\-ASCII, i tre bit più alti sono 010 per le +lettere maiuscole e 011 per le lettere minuscole. Quando \fIlc\fP è almeno 3, +la codifica letterale può sfruttare questa proprietà nei dati non compressi. +.IP "" +Il valore predefinito (3) solitamente è buono. Se si desidera la +compressione massima, provare con \fBlc=4\fP. A volte aiuta un po', e a volte +rende la compressione peggiore. Se la rende peggiore, provare anche \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Specificare il numero di bit di posizione letterale. Il minimo è 0 e il +massimo è 4; Il valore predefinito è 0. +.IP "" +Il parametro \fIlp\fP influisce sul tipo di allineamento nei dati non compressi +presunto durante la codifica dei valori letterali. Vedi \fIpb\fP di seguito per +ulteriori informazioni sull'allineamento. +.TP +\fBpb=\fP\fIpb\fP +Specificare il numero di bit di posizione. Il minimo è 0 e il massimo è 4; +Il valore predefinito è 2. +.IP "" +Il parametro \fIpb\fP influisce su quale tipo di allineamento nei dati non +compressi sia assunto in generale. L'impostazione predefinita indica un +allineamento a quattro byte (2^\fIpb\fP =2^2=4), che è spesso una buona scelta +se non c'è un'ipotesi migliore. +.IP "" +Quando l'allineamento è noto, impostare \fIpb\fP concordemente può ridurre un +po' le dimensioni del file. Ad esempio, con file di testo con 1 byte di +allineamento (US\-ASCII, ISO\-8859\-*, UTF\-8), impostare \fBpb=0\fP può migliorare +leggermente la compressione. Per il testo UTF\-16, \fBpb=1\fP è una buona +scelta. Se l'allineamento è un numero dispari, come 3 byte, \fBpb=0\fP potrebbe +essere la scelta migliore. +.IP "" +Anche se l'allineamento assunto può essere regolato con \fIpb\fP e \fIlp\fP, LZMA1 +e LZMA2 favoriscono ancora leggermente l'allineamento a 16 byte. Potrebbe +valere la pena tenerlo in considerazione quando si progettano formati di +file che possono essere spesso compressi con LZMA1 o LZMA2. +.TP +\fBmf=\fP\fICERCATORE\fP +Il cercatore di corrispondenze ha un effetto importante sulla velocità del +codificatore, sull'utilizzo della memoria e sul rapporto di compressione. Di +solito i cercatori di corrispondenze a catena hash sono più veloci dei +cercatori di corrispondenze ad albero binario. Il valore predefinito dipende +da \fIPRESET\fP : 0 usa \fBhc3\fP, 1\(en3 usa \fBhc4\fP e il resto usa \fBbt4\fP. +.IP "" +Sono supportati i seguenti cercatori di corrispondenze. Le formule di +utilizzo della memoria riportate di seguito sono approssimazioni, che sono +le più vicine alla realtà quando \fIDIZIONARIO\fP è una potenza di due. +.RS +.TP +\fBhc3\fP +Catena hash con hashing da 2 e 3 byte +.br +Minimo valore per \fINICE\fP: 3 +.br +Utilizzo memoria: +.br +\fIDIZIONARIO\fP * 7.5 (se \fIDIZIONARIO\fP <= 16 MiB); +.br +\fIDIZIONARIO\fP * 5.5 + 64 MiB (se \fIDIZIONARIO\fP > 16 MiB) +.TP +\fBhc4\fP +Catena hash con hash da 2, 3 e 4 byte +.br +Minimo valore per \fINICE\fP: 4 +.br +Utilizzo memoria: +.br +\fIDIZIONARIO\fP * 7.5 (se \fIDIZIONARIO\fP <= 32 MiB); +.br +\fIDIZIONARIO\fP * 6.5 (se \fIDIZIONARIO\fP > 32 MiB) +.TP +\fBbt2\fP +Albero binario con hashing da 2 byte +.br +Valore minimo per \fINICE\fP: 2 +.br +Utilizzo di memoria: \fIDIZIONARIO\fP * 9.5 +.TP +\fBbt3\fP +Albero binario con hashing da 2 e 3 byte +.br +Minimo valore per \fINICE\fP: 3 +.br +Utilizzo memoria: +.br +\fIDIZIONARIO\fP * 11.5 (se \fIDIZIONARIO\fP <= 16 MiB); +.br +\fIDIZIONARIO\fP * 9.5 + 64 MiB (se \fIDIZIONARIO\fP > 16 MiB) +.TP +\fBbt4\fP +Albero binario con hashing da 2, 3 e 4 byte +.br +Minimo valore per \fINICE\fP: 4 +.br +Utilizzo memoria: +.br +\fIDIZIONARIO\fP * 11.5 (se \fIDIZIONARIO\fP <= 32 MiB); +.br +\fIDIZIONARIO\fP * 10.5 (se \fIDIZIONARIO\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fIMODALITÀ\fP +La \fIMODALITÀ\fP di compressione specifica il metodo per analizzare i dati +prodotti dal cercatore di corrispondenze. Le \fIMODALITÀ\fP supportate sono +\fBfast\fP e \fBnormal\fP. Il predefinito è \fBfast\fP per i \fIPRESET\fP 0\(en3 e +\fBnormal\fP per i \fIPRESET\fP 4\(en9. +.IP "" +Di solito \fBfast\fP viene utilizzato con i cercatori di corrispondenze a +catena hash e \fBnormal\fP con i cercatori di corrispondenze a albero +binario. Questo è anche quello che fanno i \fIPRESET\fP. +.TP +\fBnice=\fP\fINICE\fP +Specifica quella che si considera una lunghezza accettabile ("nice") per una +corrispondenza. Una volta trovata una corrispondenza di almeno \fINICE\fP byte, +l'algoritmo smette di cercare corrispondenze potenzialmente migliori. +.IP "" +\fINICE\fP può valere 2\(en273 byte. Valori più alti tendono a dare un miglior +rapporto di compressione ai danni della velocità. Il valore predefinito +dipende dal \fIPRESET\fP. +.TP +\fBdepth=\fP\fIPROFONDITÀ\fP +Specificare la profondità di ricerca massima nel cercatore di +corrispondenze. Il valore predefinito è il valore speciale 0, che dice al +compressore di determinare una \fIPROFONDITÀ\fP ragionevole da \fICERCATORE\fP e +\fINICE\fP. +.IP "" +Una \fIPROFONDITÀ\fP ragionevole per le catene hash è 4\(en100 e 16\(en1000 per +gli alberi binari. Utilizzando valori di \fIPROFONDITÀ\fP molto alti si può +rendere il codificatore estremamente lento con alcuni file. Evitare di +impostare la \fIPROFONDITÀ\fP oltre 1000 a meno che si sia preparati a +interrompere la compressione nel caso in cui richieda troppo tempo. +.RE +.IP "" +Quando si decomprime un flusso grezzo (\fB\-\-format=raw\fP), LZMA2 ha bisogno +solamente della \fIDIMENSIONE\fP del dizionario. LZMA1 ha anche bisogno di +\fIlc\fP, \fIlp\fP, e \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIOPZIONI\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIOPZIONI\fP] +.PD +Aggiunge un filtro branch/call/jump (BCJ) alla catena dei filtri. Questi +filtri non possono essere utilizzati come ultimo filtro nella catena di +filtri. +.IP "" +Un filtro BCJ converte gli indirizzi relativi in codice macchina nelle loro +controparti assolute. Questo non cambia la dimensione dei dati ma aumenta la +ridondanza, cosa che può aiutare LZMA2 a produrre \fB.xz\fP file 0\(en15\ % più +piccoli. I filtri BCJ sono sempre reversibili, quindi usare un filtro BCJ +per il tipo di dati sbagliato non causa perdita di dati, al massimo può +determinare un rapporto di compressione leggermente peggiore. I filtri BCJ +sono molto veloci e usano una quantità di memoria minima. +.IP "" +Questi filtri BCJ presentano problemi noti relativi al rapporto di +compressione: +.RS +.IP \(bu 3 +Alcuni tipi di file contenenti codice eseguibile (ad esempio, file oggetto, +librerie statiche e moduli del kernel Linux) hanno gli indirizzi nelle +istruzioni riempiti con valori di riempimento. Questi filtri BCJ eseguiranno +comunque la conversione degli indirizzi, il che peggiorerà la compressione +con questi file. +.IP \(bu 3 +Se un filtro BCJ viene applicato a un archivio, è possibile che renda il +rapporto di compressione peggiore rispetto a non usare un filtro BCJ. Ad +esempio, se ci sono eseguibili simili o addirittura identici, il filtraggio +probabilmente renderà i file meno simili e quindi la compressione sarà +peggiore. Anche il contenuto dei file non eseguibili nello stesso archivio +può essere importante. In pratica bisogna provare con e senza filtro BCJ per +vedere quale sia il migliore in ogni situazione. +.RE +.IP "" +Insiemi diversi di istruzioni hanno diversi allineamenti: il file eseguibile +deve essere allineato a un multiplo di questo valore nei dati di input per +far funzionare il filtro. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filtro;Allineamento;Note +x86;1;32\-bit o 64\-bit x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;L'allineamento migliore è a 4096 byte +PowerPC;4;Solo big\-endian +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Dal momento che i dati filtrati da BCJ solitamente sono compressi con LZMA2, +il rapporto di compressione può essere migliorato leggermente se le opzioni +LZMA2 sono impostate in modo che corrispondano all'allineamento del filtro +BCJ selezionato. Esempi: +.RS +.IP \(bu 3 +Il filtro IA\-64 ha un allineamento a 16 byte, quindi \fBpb=4,lp=4,lc=0\fP è una +buona scelta per LZMA2 (2^4=16). +.IP \(bu 3 +Il codice RISC\-V ha un allineamento a 2 o 4 byte a seconda che il file +contenga o meno istruzioni 16 bit compresse (cosiddetta estensione +C). Quando sono usate istruzioni a 16 bit, va bene \fBpb=2,lp=1,lc=3\fP o +\fBpb=1,lp=1,lc=3\fP. Quando le istruzioni a 16 bit non sono presenti, è meglio +\fBpb=2,lp=2,lc=2\fP. Si può usare \fBreadelf \-h\fP per controllare se "RVC" +appare sulla riga del "Flag". +.IP \(bu 3 +ARM64 è sempre allineato a 4 byte, quindi \fBpb=2,lp=2,lc=2\fP è la scelta +migliore. +.IP \(bu 3 +Il filtro x86 è un'eccezione. Di solito è bene attenersi alle impostazioni +predefinite di LZMA2 (\fBpb=2,lp=0,lc=3\fP) quando si comprimono gli eseguibili +x86. +.RE +.IP "" +Tutti i filtri BCJ supportano le stesse \fIOPZIONI\fP: +.RS +.TP +\fBstart=\fP\fIOFFSET\fP +Specifica l'\fIOFFSET\fP iniziale utilizzato per la conversione tra indirizzi +relativi e assoluti. L'\fIOFFSET\fP deve essere un multiplo dell'allineamento +del filtro (vedere la tabella sopra). Il valore predefinito è zero. In +pratica, l'impostazione predefinita è buona; specificare un \fIOFFSET\fP +personalizzato non è quasi mai utile. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIOPZIONI\fP] +Aggiunge un filtro Delta alla catena dei filtri. I filtri Delta non possono +essere utilizzati come ultimo filtro nella catena di filtri. +.IP "" +Al momento è supportato solo un semplice calcolo delta byte\-per\-byte. Può +essere utile quando si comprime, per esempio, immagini bitmap non compresse +o file audio PCM non compressi. Tuttavia, speciali algoritmi ad\-hoc +potrebbero dare risultati significativamente migliori che Delta + +LZMA2. Questo è vero specialmente per l'audio, che comprime più velocemente +e meglio, ad esempio, con \fBflac\fP(1). +.IP "" +\fIOPZIONI\fP supportate: +.RS +.TP +\fBdist=\fP\fIDISTANZA\fP +Specifica la \fIDISTANZA\fP del calcolo delta in byte. \fIDISTANZA\fP deve essere +nel range 1\(en256. Il valore predefinito è 1. +.IP "" +Per esempio, con \fBdist=2\fP e un input di 8 byte A1 B1 A2 B3 A3 B5 A4 B7, +l'output sarà A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Altre opzioni" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Sopprime avvertimenti e avvisi. Specificarlo due volte per eliminare anche +gli errori. Questa opzione non ha alcun effetto sullo stato di uscita. In +altre parole, anche se un avvertimento è stato eliminato, lo stato di uscita +che indica un avvertimento viene comunque utilizzato. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Sii prolisso. Se lo standard error è collegato a un terminale, \fBxz\fP +visualizzerà un indicatore di avanzamento. Specificando \fB\-\-verbose\fP due +volte si otterrà un output ancora più dettagliato. +.IP "" +L'indicatore di avanzamento mostra le seguenti informazioni: +.RS +.IP \(bu 3 +La percentuale di avanzamento è mostrata se la dimensione del file input è +nota. Quindi, la percentuale non può essere mostrata nei pipe. +.IP \(bu 3 +Quantità di dati compressi prodotti (in compressione) o utilizzati (in +decompressione). +.IP \(bu 3 +Quantità di dati non compressi consumati (in compressione) o prodotti (in +decompressione). +.IP \(bu 3 +Rapporto di compressione, calcolato dividendo la quantità di dati compressi +processati finora con la quantità di dati non compressi processati finora. +.IP \(bu 3 +Velocità di compressione o decompressione. Questa è misurata come la +quantità di dati non compressi consumati (in compressione) o prodotti (in +decompressione) al secondo. Viene mostrata dopo che è trascorso qualche +secondo da quando \fBxz\fP ha iniziato a processare il file. +.IP \(bu 3 +Tempo trascorso nel formato M:SS o H:MM:SS. +.IP \(bu 3 +Il tempo residuo stimato è mostrato solo quando la dimensione del file in +ingresso è nota e sono già passati un paio di secondi da quando \fBxz\fP ha +iniziato a processare il file. Il tempo è mostrato in un formato meno +preciso che non ha mai i due punti, ad esempio 2 min 30 s. +.RE +.IP "" +Quando lo standard error non è un terminale, \fB\-\-verbose\fP farà stampare a +\fBxz\fP il nome del file, la dimensione compressa, la dimensione non +compressa, il rapporto di compressione, e potendo anche la velocità e il +tempo trascorso, su una singola riga dello standard error, dopo aver +compresso o decompresso il file. La velocità e il tempo trascorso sono +inclusi solo se l'operazione è durata almeno un paio di secondi. Se +l'operazione non è conclusa, ad esempio a causa dell'interruzione da parte +dell'utente, viene stampata anche la percentuale di completamento, a patto +che la dimensione del file input sia nota. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Non impostare lo stato di uscita a 2 anche se è stata rilevata una +condizione che merita un avvertimento. Questa opzione non influisce sul +livello di dettaglio, quindi sia \fB\-\-quiet\fP che \fB\-\-no\-warn\fP devono essere +utilizzati per non visualizzare avvertimenti e per non alterare lo stato di +uscita. +.TP +\fB\-\-robot\fP +Stampa i messaggi in un formato analizzabile dal computer. Questo ha lo +scopo di facilitare la scrittura dei frontend che vogliono usare \fBxz\fP +invece di liblzma, che potrebbe essere il caso di vari script. Si intende +che con questa opzione abilitata l'output dovrebbe rimanere stabile tra le +versioni di \fBxz\fP. Per ulteriori informazioni, vedere la sezione \fBMODALITÀ ROBOT\fP. +.TP +\fB\-\-info\-memory\fP +Mostra, in un formato leggibile da umani, quanta memoria fisica (RAM) e +quante thread \fBxz\fP pensa che il sistema abbia e i limiti di utilizzo di +memoria per la compressione e la decompressione, quindi termina con +successo. +.TP +\fB\-h\fP, \fB\-\-help\fP +Mostra un messaggio di aiuto che descrive le opzioni usate più comunemente, +e termina con successo. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Mostra un messaggio di aiuto che descrive tutte le funzionalità di \fBxz\fP, e +termina con successo +.TP +\fB\-V\fP, \fB\-\-version\fP +Mostra il numero di versione di \fBxz\fP e liblzma in un formato leggibile +dagli umani. Per ottenere un output analizzabile da una macchina specificare +\fB\-\-robot\fP prima di \fB\-\-version\fP. +. +.SH "MODALITÀ ROBOT" +La "modalità robot" viene attivata con l'opzione \fB\-\-robot\fP. Rende l'output +di \fBxz\fP più facile da analizzare da altri programmi. Attualmente \fB\-\-robot\fP +è supportato solo insieme a \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP e +\fB\-\-version\fP. In futuro sarà supportato per la compressione e la +decompressione. +. +.SS "Modalità stampa" +\fBxz \-\-robot \-\-list\fP usa un output separato da tabulazione. La prima colonna +di ogni riga contiene una stringa che indica il tipo di informazione +contenuta in quella riga: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Questa è sempre la prima riga quando si inizia a elencare un file. La +seconda colonna della riga è il nome del file. +.TP +\fBfile\fP +Questa riga contiene informazioni generali sul file \fB.xz\fP. Questa riga +viene sempre stampata dopo la riga \fBname\fP. +.TP +\fBstream\fP +Questo tipo di riga viene utilizzato solo quando è stato specificato +\fB\-\-verbose\fP. Sono presenti tante righe \fBstream\fP quanti sono i flussi nel +file \fB.xz\fP. +.TP +\fBblock\fP +Questo tipo di riga viene utilizzato solo quando è stato specificato +\fB\-\-verbose\fP. Ci sono tante righe \fBblock\fP quanti sono i blocchi nel file +\&\fB.xz\fP. Le righe \fBblock\fP vengono visualizzate dopo tutte le righe +\fBstream\fP; i diversi tipi di riga non vengono interlacciati. +.TP +\fBsummary\fP +Questo tipo di riga viene utilizzato solo quando \fB\-\-verbose\fP è stato +specificato due volte. Questa riga viene stampata dopo tutte le righe +\fBblock\fP. Come la riga \fBfile\fP, la riga \fBsummary\fP contiene informazioni +generali sul file \fB.xz\fP. +.TP +\fBtotals\fP +Questa riga è sempre l'ultima riga dell'output dell'elenco. Mostra i +conteggi totali e le dimensioni. +.PP +Le colonne delle righe \fBfile\fP: +.PD 0 +.RS +.IP 2. 4 +Numero di flussi nel file +.IP 3. 4 +Numero totale di blocchi nel flusso/i. +.IP 4. 4 +Dimensione compressa del file +.IP 5. 4 +Dimensione non compressa del file +.IP 6. 4 +Rapporto di compressione, es. \fB0.123\fP. Se il rapporto è oltre 9999, al +posto del rapporto vengono mostrati tre trattini (\fB\-\-\-\fP). +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Elenco separato da virgole dei nomi dei controlli di integrità. Le stringhe +seguenti vengono utilizzate per i tipi di controllo conosciuti: \fBNone\fP, +\fBCRC32\fP, \fBCRC64\fP, e \fBSHA\-256\fP. Per i tipi di controllo non conosciuti +viene utilizzato \fBUnknown\-\fP\fIN\fP, dove \fIN\fP è l'ID del controllo come numero +decimale (una o due cifre). +.IP 8. 4 +Dimensione totale del padding del flusso nel file +.RE +.PD +.PP +Le colonne delle righe \fBstream\fP: +.PD 0 +.RS +.IP 2. 4 +Numero di flusso (il primo è 1) +.IP 3. 4 +Numero di blocchi nel flusso +.IP 4. 4 +Offset iniziale compressione +.IP 5. 4 +Offset iniziale decompressione +.IP 6. 4 +Dimensione compressa (non include il padding del flusso) +.IP 7. 4 +Dimensione non compressa +.IP 8. 4 +Rapporto di compressione +.IP 9. 4 +Nome del controllo di integrità +.IP 10. 4 +Dimensione del padding del flusso +.RE +.PD +.PP +Le colonne delle righe \fBblock\fP: +.PD 0 +.RS +.IP 2. 4 +Numero di flussi che contengono questo blocco +.IP 3. 4 +Numero del blocco relativo all'inizio del flusso (il primo blocco è 1) +.IP 4. 4 +Numero del blocco relativo all'inizio del file +.IP 5. 4 +Offset iniziale compressione relativo all'inizio del file +.IP 6. 4 +Offset iniziale decompressione relativo all'inizio del file +.IP 7. 4 +Dimensione totale compressa del blocco (incluse le intestazioni) +.IP 8. 4 +Dimensione non compressa +.IP 9. 4 +Rapporto di compressione +.IP 10. 4 +Nome del controllo di integrità +.RE +.PD +.PP +Se \fB\-\-verbose\fP viene specificato due volte, sono incluse colonne aggiuntive +nelle righe \fBblock\fP. Queste non sono mostrate con un \fB\-\-verbose\fP singolo, +perché recuperare queste informazioni richiede molte ricerche e quindi può +essere lento: +.PD 0 +.RS +.IP 11. 4 +Valore del controllo di integrità in formato esadecimale +.IP 12. 4 +Dimensione intestazione blocco +.IP 13. 4 +Flag del blocco: \fBc\fPindica che è presente la dimensione compressa, \fBu\fP +indica che è presente la dimensione non compressa. Se il flag non è +impostato, viene mostrato un trattino (\fB\-\fP) per mantenere fissa la +lunghezza della stringa. Nuovi flag potrebbero essere aggiunti alla fine +della stringa in futuro. +.IP 14. 4 +Dimensione dei dati compressi effettivi nel blocco (sono esclusi +l'intestazione del blocco, il padding del blocco e i campi di controllo) +.IP 15. 4 +Quantità di memoria (in byte) necessaria per decomprimere questo blocco con +questa versione \fBxz\fP +.IP 16. 4 +Catena di filtri. Si noti che la maggior parte delle opzioni utilizzate al +momento della compressione non è nota, perché solo le opzioni necessarie per +la decompressione sono memorizzate nelle intestazioni \fB.xz\fP. +.RE +.PD +.PP +Le colonne delle righe \fBsummary\fP: +.PD 0 +.RS +.IP 2. 4 +Quantità di memoria (in byte) necessaria per decomprimere questo file con +questa versione \fBxz\fP +.IP 3. 4 +\fByes\fP o \fBno\fP indica se tutte le intestazioni di blocco contengono +all'interno sia dimensioni compresse che dimensioni non compresse +.PP +\fIA partire da\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Versione minima di \fBxz\fP richiesta per decomprimere il file +.RE +.PD +.PP +Le colonne delle righe \fBtotali\fP: +.PD 0 +.RS +.IP 2. 4 +Numero di flussi +.IP 3. 4 +Numero di blocchi +.IP 4. 4 +Dimensione compressa +.IP 5. 4 +Dimensione non compressa +.IP 6. 4 +Rapporto di compressione medio +.IP 7. 4 +Elenco separato da virgole dei nomi dei controlli di integrità presenti nei +file +.IP 8. 4 +Dimensione del padding dello stream +.IP 9. 4 +Numero di file. Questo serve a mantenere l'ordine delle colonne precedenti +uguale a quello delle righe del \fBfile\fP. +.PD +.RE +.PP +Se \fB\-\-verbose\fP viene specificato due volte, sono incluse colonne aggiuntive +nella riga \fBtotali\fP: +.PD 0 +.RS +.IP 10. 4 +Quantità massima di memoria (in byte) necessaria per decomprimere i file con +questa versione \fBxz\fP +.IP 11. 4 +\fByes\fP o \fBno\fP indica se tutte le intestazioni di blocco contengono +all'interno sia dimensioni compresse che dimensioni non compresse +.PP +\fIA partire da\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Versione minima di \fBxz\fP richiesta per decomprimere il file +.RE +.PD +.PP +Versioni future potrebbero aggiungere nuovi tipi di riga e nuove colonne +possono essere aggiunte ai tipi di riga esistenti, ma le colonne esistenti +non verranno modificate. +. +.SS "Aiuto sui filtri" +\fBxz \-\-robot \-\-filters\-help\fP stampa i filtri supportati nel seguente +formato: +.PP +\fIFILTRO\fP\fB:\fP\fIOPZIONE\fP\fB=<\fP\fIVALORE\fP\fB>,\fP\fIOPZIONE\fP\fB=<\fP\fIVALORE\fP\fB>\fP... +.TP +\fIFILTRO\fP +Nome del filtro +.TP +\fIOPZIONE\fP +Nome di un'opzione specifica del filtro +.TP +\fIVALORE\fP +Gli intervalli del \fIVALORE\fP numerico appaiono come +\fB<\fP\fIMIN\fP\fB\-\fP\fIMAX\fP\fB>\fP. Le scelte per i \fIVALORI\fP stringa sono +mostrati in \fB< >\fP e separati dal carattere \fB|\fP. +.PP +Ogni filtro è mostrato su una riga dedicata. +. +.SS "Informazione limite memoria" +\fBxz \-\-robot \-\-info\-memory\fP stampa una singola riga con più colonne separate +da tabulazione: +.IP 1. 4 +Quantità totale di memoria fisica (RAM) in byte. +.IP 2. 4 +Limite utilizzo memoria per la compressione in byte +(\fB\-\-memlimit\-compress\fP). Il valore speciale \fB0\fP indica l'impostazione +predefinita, che in modalità thread singola equivale a nessun limite. +.IP 3. 4 +Limite utilizzo memoria per la decompressione in byte +(\fB\-\-memlimit\-decompress\fP). Il valore speciale \fB0\fP indica l'impostazione +predefinita, che in modalità thread singola equivale a nessun limite. +.IP 4. 4 +A partire da \fBxz\fP 5.3.4alpha: Utilizzo della memoria per la decompressione +a thread multiple in byte (\fB\-\-memlimit\-mt\-decompress\fP). Questo valore non è +mai zero perché viene utilizzato un valore predefinito specifico del sistema +mostrato nella colonna 5, se non è stato specificato alcun limite in modo +esplicito. Inoltre, non è mai maggiore del valore nella colonna 3, anche se +è stato specificato un valore maggiore con \fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +A partire da \fBxz\fP 5.3.4alpha: un limite di utilizzo della memoria +predefinito specifico del sistema, che viene utilizzato per limitare il +numero di thread durante la compressione con un numero automatico di thread +(\fB\-\-threads=0\fP) e non è stato specificato alcun limite di utilizzo della +memoria (\fB\-\-memlimit\-compress\fP). Questo viene utilizzato anche come valore +predefinito per \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +A partire da \fBxz\fP 5.3.4alpha: Numero di thread del processore disponibili. +.PP +In futuro, l'output di \fBxz \-\-robot \-\-info\-memory\fP potrebbe avere più +colonne, ma mai più di una singola riga. +. +.SS Versione +\fBxz \-\-robot \-\-version\fP stampa il numero di versione di \fBxz\fP e liblzma nel +seguente formato: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Versione major. +.TP +\fIYYY\fP +Versione minor. I numeri pari sono stabili. I numeri dispari sono versioni +alfa o beta. +.TP +\fIZZZ\fP +Livello di patch per le versioni stabili o solo un contatore per le versioni +di sviluppo. +.TP +\fIS\fP +Stabilità. 0 è alfa, 1 è beta e 2 è stabile. \fIS\fP dovrebbe essere sempre 2 +quando \fIYYY\fP è pari. +.PP +\fIXYYYZZZS\fP sono uguali su entrambe le righe se \fBxz\fP e liblzma appartengono +allo stesso rilascio delle XZ Utils. +.PP +Esempi: 4.999.9beta è \fB49990091\fP e 5.0.0 è \fB50000002\fP. +. +.SH "CODICE DI USCITA" +.TP +\fB0\fP +Tutto bene. +.TP +\fB1\fP +È avvenuto un errore. +.TP +\fB2\fP +Si è verificato qualcosa che merita un avvertimento, ma non si sono +verificati errori effettivi. +.PP +Gli avvisi (non gli avvertimenti o gli errori) stampati sullo standard error +non influiscono sullo stato di uscita. +. +.SH AMBIENTE +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP analizza elenchi di opzioni separate da spazi dalle variabili +d'ambiente \fBXZ_DEFAULTS\fP e \fBXZ_OPT\fP, in questo ordine, analizzando prima +le opzioni dalla riga di comando. Si noti che solo le opzioni vengono +analizzate dalle variabili d'ambiente; tutte le non\-opzioni vengono ignorate +silenziosamente. L'analisi viene eseguita con \fBgetopt_long\fP(3) che viene +utilizzato anche per gli argomenti della riga di comando. +.PP +\fBAttenzione:\fP Impostando queste variabili di ambiente, si sta di fatto +modificando programmi e script che lanciano \fBxz\fP. La maggior parte delle +volte va bene impostare i limiti di utilizzo della memoria, il numero di +thread e le opzioni di compressione tramite variabili d'ambiente. Tuttavia, +alcune opzioni possono rompere degli script. Un esempio banale è \fB\-\-help\fP +che forza \fBxz\fP a mostrare la pagina di aiuto anziché comprimere o +decomprimere file. Esempi meno ovvi sono \fB\-\-quiet\fP e \fB\-\-verbose\fP. In +molti casi funziona bene abilitare l'indicatore di avanzamento usando +\fB\-\-verbose\fP, ma in alcune situazioni i messaggi extra creano problemi. Il +livello di prolissità influisce anche sul comportamento di \fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Opzioni predefinite specifiche dell'utente o a livello di sistema. In genere +questo viene impostato in uno script di inizializzazione della shell per +abilitare il valore predefinito del limitatore di utilizzo della memoria di +\fBxz\fP, o per impostare il numero di thread predefinito. Escludendo gli +script di inizializzazione della shell e analoghi casi particolari, gli +script non dovrebbero mai impostare o annullare l'impostazione di +\fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Questo serve per passare le opzioni a \fBxz\fP quando non sia possibile +impostare le opzioni direttamente sulla riga di comando di \fBxz\fP. Questo è +il caso quando \fBxz\fP viene eseguito da uno script o da uno strumento, ad +esempio GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Gli script possono usare \fBXZ_OPT\fP, per esempio, per impostare opzioni di +compressione predefinite specifiche per lo script. Si raccomanda comunque di +permettere agli utenti di sovrascrivere \fBXZ_OPT\fPse questo è ragionevole. Ad +esempio, negli script \fBsh\fP(1) si può usare qualcosa come questo: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "COMPATIBILITÀ LZMA UTILS" +La sintassi della riga di comando di \fBxz\fP è essenzialmente un sopra\-insieme +di \fBlzma\fP, \fBunlzma\fP, e \fBlzcat\fP come trovati nelle LZMA Utils +4.32.x. Nella maggior parte dei casi è possibili sostituire le LZMA Utils +con le XZ Utils senza rompere gli script esistenti. Ci sono però alcune +incompatibilità, che in alcuni casi potrebbero causare problemi. +. +.SS "Livelli di compressione preimpostati" +La numerazione dei livelli di compressione preimpostati non è identica in +\fBxz\fP e nelle LZMA Utils. La differenza più importante è il modo in cui le +dimensioni del dizionario vengono mappate sulle diverse preimpostazioni. La +dimensione del dizionario è approssimativamente uguale all'utilizzo della +memoria del decompressore. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Livello;xz;LZMA Utils +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Le differenze di dimensione del dizionario influiscono anche sull'utilizzo +della memoria del compressore, ma ci sono alcune altre differenze tra le +LZMA Utils e le XZ Utils, che rendono la differenza ancora più grande: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Livello;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Il livello preimpostato predefinito nelle LZMA Utils è \fB\-7\fP mentre nelle XZ +Utils è \fB\-6\fP, quindi entrambi utilizzano un dizionario da 8 MiB per +impostazione predefinita. +. +.SS "File .lzma con flussi vs. senza flussi" +La dimensione non compressa del file può essere memorizzata +nell'intestazione \fB.lzma\fP. Le LZMA Utils lo fanno durante la compressione +di file regolari. L'alternativa consiste nel memorizzare che la dimensione +non compressa è sconosciuta e utilizzare l'indicatore di fine carico utile +per indicare il punto in cui il decompressore deve fermarsi. Le LZMA Utils +utilizzano questo metodo quando le dimensioni non compresse non sono note, +come nel caso, ad esempio, delle pipe. +.PP +\fBxz\fP supporta la decompressione di file \fB.lzma\fP con o senza il marcatore +di fine payload, ma tutti i file \fB.lzma\fP creati da \fBxz\fP utilizzeranno il +marcatore di fine payload e avranno dimensioni non compresse contrassegnate +come sconosciute nell'intestazione \fB.lzma\fP. Questo può essere un problema +in alcune situazioni non comuni. Ad esempio, un decompressore \fB.lzma\fP in un +dispositivo embedded potrebbe funzionare solo con file con dimensioni non +compresse note. Se si incorre in questo problema, occorre utilizzare le LZMA +Utils oppure l'LZMA SDK per creare dei file \fB.lzma\fP con dimensioni non +compresse note. +. +.SS "File .lzma non supportati" +Il formato \fB.lzma\fP permette valori \fIlc\fP fino a 8, e valori \fIlp\fP fino a +4. Le LZMA Utils possono decomprimere file con qualunque \fIlc\fP e \fIlp\fP, ma +creeranno sempre file con \fBlc=3\fP e \fBlp=0\fP. Creare file con altri \fIlc\fP e +\fIlp\fP è possibile con \fBxz\fP e con l'LZMA SDK. +.PP +L'implementazione del filtro LZMA1 in liblzma richiede che la somma di \fIlc\fP +e \fIlp\fP non debba superare 4. Pertanto, i file \fB.lzma\fP che superano questa +limitazione non possono essere decompressi con \fBxz\fP. +.PP +Le LZMA Utils creano solo file \fB.lzma\fP con dimensione del dizionario 2^\fIn\fP +(una potenza di 2) ma accettano file con qualsiasi dimensione di +dizionario. liblzma accetta solo file \fB.lzma\fP con dimensione del dizionario +2^\fIn\fP o 2^\fIn\fP + 2^(\fIn\fP\-1). Questo serve a limitare i falsi positivi +quando si cerca di identificare i file \fB.lzma\fP. +.PP +All'atto pratico queste limitazioni non dovrebbero essere un problema, +perché praticamente tutti i file \fB.lzma\fP sono stati compressi con +impostazioni che liblzma accetterà. +. +.SS "Dati sporchi finali" +Quando si decomprime, le LZMA Utils ignorano automaticamente tutto quello +che c'è dopo il primo flusso \fB.lzma\fP. Nella maggior parte delle situazioni +questo è un baco. Questo significa anche che le LZMA Utils non supportano la +decompressione di file \fB.lzma\fP concatenati. +.PP +Se sono rimasti dati dopo il primo flusso \fB.lzma\fP, \fBxz\fP considera il file +corrotto a meno che sia stato utilizzato \fB\-\-single\-stream\fP. Questo può far +rompere script incomprensibili che hanno assunto che i dati sporchi finali +vengano ignorati. +. +.SH NOTE +. +.SS "L'output compresso può variare" +L'esatto output compresso prodotto dallo stesso file di input non compresso +può variare tra le versioni delle XZ Utils, anche se le opzioni di +compressione sono le stesse. Questo perché il codificatore può essere stato +migliorato (compressione più veloce o migliore) senza influire sul formato +del file. L'output può variare anche tra diverse build della stessa versione +delle XZ Utils, se vengono utilizzate opzioni di build differenti. +.PP +Quanto sopra significa che una volta che \fB\-\-rsyncable\fP è stato +implementato, i file risultanti non saranno necessariamente rsync\-abili a +meno che sia i vecchi che i nuovi file non siano stati compressi con la +stessa versione di xz. Questo problema può essere risolto se una parte +dell'implementazione del codificatore viene congelata per mantenere stabile +l'output rsync\-abile tra le versioni di xz. +. +.SS "Abilita i decompressori .xz" +Le implementazioni dei decompressori \fB.xz\fP embedded, come XZ Embedded, non +necessariamente supportano file creati con tipi di integrità \fICONTROLLO\fP +diversi da \fBnone\fP e \fBcrc32\fP. Dal momento che il valore predefinito è +\fB\-\-check=crc64\fP, occorre specificare \fB\-\-check=none\fP o \fB\-\-check=crc32\fP +quando si creano file per sistemi embedded. +.PP +Al di fuori dei sistemi embedded, tutti i decompressori in formato \fB.xz\fP +supportano tutti i tipi di \fICONTROLLO\fP, o almeno sono in grado di +decomprimere il file senza verificare il controllo di integrità se il +particolare \fICONTROLLO\fP non è supportato. +.PP +XZ Embedded supporta i filtri BCJ, ma solo con offset iniziale predefinito. +. +.SH ESEMPI +. +.SS "Informazioni di base" +Comprime il file \fIfoo\fP in \fIfoo.xz\fP utilizzando il livello di compressione +predefinito (\fB\-6\fP) e rimuove \fIfoo\fP se la compressione ha esito positivo: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Decomprime \fIbar.xz\fP in \fIbar\fP e non rimuove \fIbar.xz\fP anche se la +decompressione ha successo: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Crea \fIbaz.tar.xz\fP con il preset \fB\-4e\fP (\fB\-4 \-\-extreme\fP), che è più lenta +della predefinita \fB\-6\fP, ma ha bisogno di meno memoria per la compressione e +decompressione (48\ MiB e 5\ MiB, rispettivamente): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Una combinazione di file compressi e non compressi può essere decompressa +sullo output standard con un singolo comando: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Compressione parallela di più file" +Su GNU e *BSD, \fBfind\fP(1) e \fBxargs\fP(1) possono essere usati per +parallelizzare la compressione di più file: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +L'opzione \fB\-p\fP di \fBxargs\fP(1) imposta il numero di processi \fBxz\fP +paralleli. Il valore migliore per l'opzione \fB\-n\fP dipende dal numero di file +da comprimere. Se sono presenti solo un paio di file, il valore dovrebbe +probabilmente essere 1; con decine di migliaia di file, 100 o anche di più +può essere appropriato per ridurre il numero di processi \fBxz\fP che +\fBxargs\fP(1) alla fine creerà. +.PP +L'opzione \fB\-T1\fP per \fBxz\fP serve a forzare la modalità a thread singola, +perché \fBxargs\fP (1) viene utilizzato per controllare la quantità di +parallelizzazione. +. +.SS "Modalità robot" +Calcola quanti byte sono stati salvati in totale dopo la compressione di più +file: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Uno script potrebbe voler sapere se si sta utilizzando una versione di \fBxz\fP +sufficientemente recente. Il seguente script \fBsh\fP(1) controlla che il +numero di versione dello strumento \fBxz\fP sia almeno 5.0.0. Questo metodo è +compatibile con le vecchie versioni beta, che non supportavano l'opzione +\fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Imposta un limite di utilizzo della memoria per la decompressione +utilizzando \fBXZ_OPT\fP, ma se è già stato impostato un limite, non lo +aumenta: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Catene di filtri di compressione personalizzate" +L'uso più semplice delle catene di filtri personalizzate è la +personalizzazione di un preset di LZMA2. Questo può essere utile, perché i +preset coprono solamente un sottoinsieme di tutte le combinazioni di +impostazioni di compressione potenzialmente utili. +.PP +Le colonne CompCPU delle tabelle dalle descrizioni delle opzioni \fB\-0\fP +\&... \fB\-9\fP e \fB\-\-extreme\fP sono utili quando si personalizzano i preset di +LZMA2. Di seguito sono riportate le parti rilevanti raccolte da queste due +tabelle: +.RS +.PP +.TS +tab(;); +c c +n n. +Livello preimpostato;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Se si sa che un file richiede un dizionario piuttosto grande (ad esempio, +32\ MiB) per essere compresso bene, ma si desidera comprimerlo più +velocemente di quanto farebbe \fBxz \-8\fP, è possibile modificare un preset con +un basso valore CompCPU (ad esempio, 1) per utilizzare un dizionario più +grande: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Con alcuni file, il comando sopra potrebbe essere più veloce di \fBxz \-6\fP e +la compressione significativamente migliore. Tuttavia, si deve sottolineare +che solo alcuni file traggono beneficio da un dizionario grande e mantengono +basso il valore di CompCPU. La situazione più ovvia in cui un dizionario +grande può aiutare molto è un archivio contenente file molto simili di +almeno un paio di megabyte ciascuno. La dimensione del dizionario deve +essere significativamente più grande di ogni singolo file per permettere a +LZMA2 di trarre pieno vantaggio dalle somiglianze tra file consecutivi. +.PP +Se l'utilizzo molto elevato della memoria del compressore e del +decompressore è accettabile, e il file da comprimere è almeno di diverse +centinaia di megabyte, potrebbe essere utile utilizzare un dizionario ancora +più grande dei 64 MiB che \fBxz \-9\fP utilizzerebbe: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +L'uso di \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) come nell'esempio precedente può +essere utile per vedere i requisiti di memoria del compressore e del +decompressore. Tenere presente che l'utilizzo di un dizionario più grande +della dimensione del file non compresso è uno spreco di memoria, quindi il +comando precedente non è utile per i file di piccole dimensioni. +.PP +A volte il tempo di compressione non importa, ma l'utilizzo di memoria del +decompressore deve essere tenuta bassa, per esempio, per permettere di +decomprimere il file in un sistema embedded. Il comando seguente usa \fB\-6e\fP +(\fB\-6 \-\-extreme\fP) come base e imposta il dizionario a soli 64\ KiB. Il file +risultante può essere decompresso con XZ Embedded (ecco perché c'è +\fB\-\-check=crc32\fP) usando circa 100\ KiB di memoria. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Se si desidera spremere il maggior numero possibile di byte, a volte può +essere utile regolare il numero di bit di contesto letterale (\fIlc\fP) e il +numero di bit di posizione (\fIpb\fP). Anche la regolazione del numero di bit +di posizione letterale (\fIlp\fP) potrebbe essere d'aiuto, ma di solito \fIlc\fP e +\fIpb\fP sono più importanti. Per esempio, un archivio di codici sorgente +contiene principalmente testo US\-ASCII, quindi qualcosa come il seguente +potrebbe produrre un file leggermente (0,1\ %) più piccolo di \fBxz \-6e\fP +(provare anche senza \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Usare un altro filtro insieme a LZMA2 può migliorare la compressione per +alcuni tipi di file. Ad esempio, per comprimere una libreria condivisa +x86\-32 o x86\-64 usare il filtro BCJ: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Si noti che l'ordine delle opzioni di filtro è significativo. Se viene +specificato \fB\-\-x86\fP dopo \fB\-\-lzma2\fP, \fBxz\fP darà un errore, perché non può +esserci alcun filtro dopo LZMA2 e anche perché il filtro BCJ x86 non può +essere utilizzato come ultimo filtro della catena. +.PP +Il filtro Delta insieme con LZMA2 può dare buoni risultati sulle immagini +bitmap. Di solito dovrebbe battere il PNG, il quale ha alcuni filtri più +avanzati rispetto al semplice delta ma utilizza Deflate per la compressione +effettiva. +.PP +L'immagine deve essere salvata in un formato non compresso, ad esempio un +TIFF non compresso. Il parametro distanza del filtro Delta è impostato in +modo che corrisponda al numero di byte per pixel nell'immagine. Per esempio, +un bitmap a 24 bit richiede \fBdist=3\fP, e va anche bene passare \fBpb=0\fP a +LZMA2 per adattarsi all'allineamento a tre byte: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Se più immagini sono state inserite in un singolo archivio (ad esempio, +\&\fB.tar\fP), il filtro Delta funzionerà anche su questo purché tutte le +immagini abbiano lo stesso numero di byte per pixel. +. +.SH "VEDERE ANCHE" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzmadec.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzmadec.1 new file mode 100644 index 0000000000000000000000000000000000000000..e3ff6ec043867c79dbe625986377ebe54fbea0ca --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzmadec.1 @@ -0,0 +1,88 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.\" Italian translations for xz-man package +.\" Luca Vercelli , 2024-2025 +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDEC 1 08/04/2024 Tukaani "XZ Utils" +.SH NOME +xzdec, lzmadec \- Piccoli compressori .xz e .lzma +.SH SINOSSI +\fBxzdec\fP [\fIOPZIONE...\fP] [\fIFILE...\fP] +.br +\fBlzmadec\fP [\fIOPZIONE...\fP] [\fIFILE...\fP] +.SH DESCRIZIONE +\fBxzdec\fP è uno strumento di sola decompressione basato su liblzma per i file +\&\fB.xz\fP (e solo \fB.xz\fP). \fBxzdec\fP è destinato a funzionare come sostituto +drop\-in di \fBxz\fP (1) nelle situazioni più comuni in cui è stato scritto uno +script che utilizza \fBxz \-\-decompress \-\-stdout\fP (e possibilmente alcune +altre opzioni di uso comune) per decomprimere i file \fB.xz\fP. \fBlzmadec\fP è +identico a \fBxzdec\fP tranne nel fatto che supporta file \fB.lzma\fP invece di +\&\fB.xz\fP. +.PP +Per ridurre la dimensione dell'eseguibile, \fBxzdec\fP non supporta né il +multi\-thread né la localizzazione, e non legge le opzioni dalle variabili di +ambiente \fBXZ_DEFAULTS\fP e \fBXZ_OPT\fP. \fBxzdec\fP non supporta la +visualizzazione delle informazioni di avanzamento: inviare \fBSIGINFO\fP a +\fBxzdec\fP non fa nulla mentre inviare \fBSIGUSR1\fP termina il processo anziché +mostrare le informazioni di avanzamento. +.SH OPZIONI +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +Ignorato per compatibilità con \fBxz\fP(1). \fBxzdec\fP supporta solo la +decompressione. +.TP +\fB\-k\fP, \fB\-\-keep\fP +Ignorato per compatibilità con \fBxz\fP(1). \fBxzdec\fP non crea né rimuove mai +file. +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Ignorato per compatibilità con \fBxz\fP(1). \fBxzdec\fP scrive sempre i dati +decompressi sullo standard output. +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Specificare questa opzione una sola volta non ha effetto, poiché \fBxzdec\fP +non visualizza mai alcun avvertimento né avviso. Specificare questa opzione +due volte per eliminare gli errori. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Ignorato per compatibilità con \fBxz\fP(1). \fBxzdec\fP non utilizza mai il codice +di uscita 2. +.TP +\fB\-h\fP, \fB\-\-help\fP +Mostra un messaggio di aiuto e termina con successo. +.TP +\fB\-V\fP, \fB\-\-version\fP +Mostra il numero di versione di \fBxzdec\fP e liblzma. +.SH "CODICE DI USCITA" +.TP +\fB0\fP +Andava tutto bene. +.TP +\fB1\fP +È avvenuto un errore. +.PP +\fBxzdec\fP non ha alcun messaggio di avvertimento come \fBxz\fP (1), quindi lo +stato di uscita 2 non viene utilizzato da \fBxzdec\fP. +.SH NOTE +Utilizzare \fBxz\fP(1) al posto di \fBxzdec\fP o \fBlzmadec\fP per l'utilizzo +normale abituale. \fBxzdec\fP e \fBlzmadec\fP sono pensati solo per situazioni in +cui sia importante avere un decompressore più piccolo rispetto a quello con +funzionalità complete \fBxz\fP(1). +.PP +\fBxzdec\fP e \fBlzmadec\fP non sono veramente così piccoli. La dimensione può +essere ridotta ulteriormente eliminando delle funzionalità da liblzma al +momento della compilazione, ma questo di solito non dovrebbe essere fatto +per gli eseguibili distribuiti nelle tipiche distribuzioni di sistemi +operativi non embedded. Se c'è bisogno di un decompressore \fB.xz\fP veramente +piccolo, si consideri l'utilizzo di XZ Embedded. +.SH "VEDERE ANCHE" +\fBxz\fP(1) +.PP +XZ Embedded: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzmainfo.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzmainfo.1 new file mode 100644 index 0000000000000000000000000000000000000000..dadc8a8486bc2290cbf60b959c679deaae7164b9 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzmainfo.1 @@ -0,0 +1,45 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.\" Italian translations for xz-man package +.\" Luca Vercelli , 2024-2025 +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH LZMAINFO 1 30/06/2013 Tukaani "XZ Utils" +.SH NOME +lzmainfo \- mostra le informazioni nell'intestazione di file .lzma +.SH SINOSSI +\fBlzmainfo\fP [\fB\-\-help\fP] [\fB\-\-version\fP] [\fIFILE...\fP] +.SH DESCRIZIONE +\fBlzmainfo\fP mostra le informazioni contenute nell'intestazione del file +\&\fB.lzma\fP. Legge i primi 13 byte del \fIFILE\fP specificato, decodifica +l'intestazione, e la stampa su standard output in formato leggibile +dall'uomo. Se nessun \fIFILE\fP è specificato o se \fIFILE\fP è \fB\-\fP, viene letto +lo standard input. +.PP +Di solito le informazioni più interessanti sono la dimensione non compressa +e la dimensione del dizionario. Le dimensioni non compresse possono essere +visualizzate solo se il file è nella variante di formato \fB.lzma\fP "senza +flussi". La quantità di memoria necessaria per decomprimere il file è di +alcune dozzine di kilobyte più la dimensione del dizionario. +.PP +\fBlzmainfo\fP è incluso nelle XZ Utils principalmente per retrocompatibilità +con le LZMA Utils. +.SH "CODICE DI USCITA" +.TP +\fB0\fP +Tutto bene. +.TP +\fB1\fP +È avvenuto un errore. +.SH BUG +\fBlzmainfo\fP usa \fBMB\fP mentre il suffisso corretto dovrebbe essere \fBMiB\fP +(2^20 byte). Questo serve per rendere l'output compatibile con quello delle +LZMA Utils. +.SH "VEDERE ANCHE" +\fBxz\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzmore.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzmore.1 new file mode 100644 index 0000000000000000000000000000000000000000..60fca91601bf3c6cef290e4c370bb344ffc3f78a --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/lzmore.1 @@ -0,0 +1,50 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" Italian translations for xz-man package +.\" Luca Vercelli , 2024-2025 +.\" +.\" (Note that this file is based on xzless.1 instead of gzip's zmore.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZMORE 1 06/03/2025 Tukaani "XZ Utils" +.SH NOME +xzmore, lzmore \- mostra file (testuali) compressi xz o lzma +. +.SH SINOSSI +\fBxzmore\fP [\fIFILE\fP...] +.br +\fBlzmore\fP [\fIFILE\fP...] (DEPRECATO) +. +.SH DESCRIZIONE +\fBxzmore\fP visualizza il testo da file non compressi a un terminale usando +\fBmore\fP(1). I file supportati da \fBxz\fP(1) vengono decompressi; gli altri +file sono considerati non compressi. Se non viene dato alcun \fIFILE\fP, +\fBxzmore\fP legge dallo standard input. Si veda il manuale di \fBmore\fP(1) per i +comandi da tastiera. +.PP +Si noti che lo scorrimento all'indietro potrebbe non essere possibile a +seconda dell'implementazione di \fBmore\fP(1). Ciò è dovuto al fatto che +\fBxzmore\fP utilizza una pipe per passare i dati decompressi a +\fBmore\fP(1). \fBxzless\fP(1) utilizza \fBless\fP(1) che fornisce funzionalità più +avanzate. +.PP +Il comando \fBlzmore\fP è fornito per retrocompatibilità con le LZMA Utils. È +deprecato e sarà rimosso in una versione futura. +. +.SH AMBIENTE +.TP +.\" TRANSLATORS: Don't translate the uppercase PAGER. +.\" It is a name of an environment variable. +\fBPAGER\fP +Se \fBPAGER\fP è impostato, il suo valore è usato come paginatore al posto di +\fBmore\fP(1). +. +.SH "VEDERE ANCHE" +\fBmore\fP(1), \fBxz\fP(1), \fBxzless\fP(1), \fBzmore\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/unlzma.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/unlzma.1 new file mode 100644 index 0000000000000000000000000000000000000000..53a915947bff84fc5f9cfbb4d4ed88097620e055 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/unlzma.1 @@ -0,0 +1,2080 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Italian translations for xz-man package +.\" Luca Vercelli , 2024-2025 +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 08/03/2025 Tukaani "XZ Utils" +. +.SH NOME +xz, unxz, xzcat, lzma, unlzma, lzcat \- Comprime o decomprime file .xz e +\&.lzma +. +.SH SINOSSI +\fBxz\fP [\fIOPZIONE...\fP] [\fIFILE...\fP] +. +.SH "ALIAS DEI COMANDI" +\fBunxz\fP è equivalente a \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP è equivalente a \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP è equivalente a \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP è equivalente a \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP è equivalente a \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Quando si scrivono script che richiedono di decomprimere file, si raccomanda +di utilizzare sempre il comando \fBxz\fP con argomenti appropriati (\fBxz \-d\fP o +\fBxz \-dc\fP) al posto degli alias \fBunxz\fP e \fBxzcat\fP. +. +.SH DESCRIZIONE +\fBxz\fP è uno strumento di compressione dati generico con sintassi della riga +di comando simile a \fBgzip\fP(1) e \fBbzip2\fP(1). Il formato file nativo è +\&\fB.xz\fP, ma sono supportati anche il formato tradizionale \fB.lzma\fP usato +dalle LZMA Utils e i flussi grezzi (raw) compressi senza intestazioni di +formato contenitore. In più, è supportata la decompressione del formato +\&\fB.lz\fPusato da \fBlzip\fP. +.PP +\fBxz\fP comprime o decomprime ogni \fIFILE\fP a seconda della modalità di +funzionamento selezionata. Se nessun \fIFILE\fP è indicato o se \fIFILE\fP è \fB\-\fP, +\fBxz\fP legge dallo standard input e scrive i dati processati sullo standard +output. \fBxz\fP si rifiuterà (stamperà un errore e salterà il \fIFILE\fP) di +scrivere dati compressi sullo standard output se è il +terminale. Analogamente, \fBxz\fP si rifiuterà di leggere dati compressi dallo +standard input se è il terminale. +.PP +A meno che non sia specificato \fB\-\-stdout\fP, i \fIFILE\fP diversi da \fB\-\fP +vengono scritti in un nuovo file il cui nome deriva dal nome del \fIFILE\fP +sorgente: +.IP \(bu 3 +Quando si comprime, il suffisso del file destinazione (\fB.xz\fP or \fB.lzma\fP) +viene accodato al nome del file sorgente per ottenere il nome del file +destinazione. +.IP \(bu 3 +Quando si decomprime, i suffissi \fB.xz\fP, \fB.lzma\fP, o \fB.lz\fP vengono rimossi +dal nome del file per ottenere il nome del file destinazione. \fBxz\fP +riconosce anche i suffissi \fB.txz\fP e \fB.tlz\fP, e li sostituisce con il +suffisso \fB.tar\fP. +.PP +Se il file di destinazione esiste già, viene visualizzato un errore e +\fIFILE\fP viene saltato. +.PP +A meno che non si scriva nello standard output, \fBxz\fP visualizzerà un +avvertimento e salterà il \fIFILE\fP se si verifica una delle seguenti +condizioni: +.IP \(bu 3 +\fIFILE\fP non è un file regolare. I collegamenti simbolici non vengono +seguiti, quindi non sono considerati file regolari. +.IP \(bu 3 +\fIFILE\fP ha più di un collegamento "hard". +.IP \(bu 3 +\fIFILE\fP ha impostati i bit setuid, setgid, o sticky. +.IP \(bu 3 +La modalità di funzionamento è impostata sulla compressione e il \fIFILE\fP ha +già un suffisso del formato di file di destinazione (\fB.xz\fP o \fB.txz\fP quando +si comprime nel formato \fB.xz\fP e \fB.lzma\fP o \fB.tlz\fP quando si comprime nel +formato \fB.lzma\fP). +.IP \(bu 3 +La modalità di funzionamento è impostata sulla decompressione e il \fIFILE\fP +non ha un suffisso di nessuno dei formati di file supportati (\fB.xz\fP, +\&\fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, o \fB.lz\fP). +.PP +Dopo aver compresso o decompresso correttamente il \fIFILE\fP, \fBxz\fP copia il +proprietario, il gruppo, le autorizzazioni, l'ora di accesso e l'ora di +modifica dal \fIFILE\fP di origine al file di destinazione. Se la copia del +gruppo fallisce, le autorizzazioni vengono modificate in modo che il file di +destinazione non diventi accessibile agli utenti che non disponevano +dell'autorizzazione per accedere al \fIFILE\fP di origine. \fBxz\fP non supporta +ancora la copia di altri metadati, ad esempio elenchi di controllo degli +accessi o attributi estesi. +.PP +Una volta che il file di destinazione è stato chiuso con successo, il +\fIFILE\fP sorgente viene rimosso, a meno che sia stato specificato +\fB\-\-keep\fP. Il \fIFILE\fP sorgente non viene mai rimosso se l'output è scritto +sullo standard output, né se si verifica un errore. +.PP +L'invio di \fBSIGINFO\fP o \fBSIGUSR1\fP al processo \fBxz\fP comporta la stampa +delle informazioni sullo stato di avanzamento sullo standard error. Questo +ha solo un uso limitato poiché quando lo standard error è un terminale, +utilizzando \fB\-\-verbose\fP verrà visualizzato un indicatore di avanzamento che +si aggiorna automaticamente. +. +.SS "Utilizzo memoria" +L'utilizzo della memoria di \fBxz\fP varia da poche centinaia di kilobyte a +diversi gigabyte a seconda delle impostazioni di compressione. Le +impostazioni utilizzate durante la compressione di un file determinano i +requisiti di memoria del decompressore. In genere il decompressore richiede +dal 5\% al 20\% della quantità di memoria necessaria al compressore durante +la creazione del file. Ad esempio, la decompressione di un file creato con +\fBxz \-9\fP al momento richiede 65\ MiB di memoria. Ancora, è possibile avere +file \fB.xz\fP che richiedono diversi gigabyte di memoria per la +decompressione. +.PP +Soprattutto gli utenti di sistemi più vecchi possono trovare fastidiosa +l'eventualità di un utilizzo molto elevato di memoria. Per evitare +spiacevoli sorprese, \fBxz\fP dispone di un limitatore di utilizzo della +memoria incorporato, che è disabilitato per impostazione predefinita. Anche +se alcuni sistemi operativi forniscono modi per limitare l'utilizzo della +memoria dei processi, fare affidamento su questi non è stato ritenuto +sufficientemente flessibile (ad esempio, l'uso di \fBulimit\fP(1) per limitare +la memoria virtuale tende a paralizzare \fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Il limitatore di utilizzo della memoria può essere abilitato con l'opzione +della riga di comando \fB\-\-memlimit=\fP\fILIMITE\fP. Spesso è più conveniente +abilitare il limitatore per impostazione predefinita impostando la variabile +d'ambiente \fBXZ_DEFAULTS\fP, ad esempio, \fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. È +possibile impostare separatamente i limiti per la compressione e la +decompressione utilizzando \fB\-\-memlimit\-compress=\fP\fILIMITE\fP and +\fB\-\-memlimit\-decompress=\fP\fILIMITE\fP. L'uso di queste due opzioni al di fuori +di \fBXZ_DEFAULTS\fP è raramente utile perché una singola esecuzione di \fBxz\fP +non può eseguire sia la compressione che la decompressione e +\fB\-\-memlimit=\fP\fILIMITE\fP (or \fB\-M\fP \fILIMITE\fP) è più breve da digitare sulla +riga di comando. +.PP +Se il limite di utilizzo della memoria specificato viene superato durante la +decompressione, \fBxz\fP visualizzerà un errore e la decompressione del file +fallirà. Se il limite viene superato durante la compressione, \fBxz\fP tenterà +di ridimensionare le impostazioni in modo che il limite non venga più +superato (tranne quando si usa \fB\-\-format=raw\fP o \fB\-\-no\-adjust\fP). In questo +modo l'operazione non fallirà a meno che il limite sia molto basso. Il +ridimensionamento delle impostazioni viene eseguito in piccole differenze +che non corrispondono ai livelli di compressione preimpostati, ad esempio, +se il limite è solo leggermente inferiore alla quantità richiesta per \fBxz \-9\fP, le impostazioni saranno ridimensionate solo un poco, non proprio fino a +\fBxz \-8\fP. +. +.SS "Concatenazione e padding con file .xz" +È possibile concatenare i file \fB.xz\fP così come sono. \fBxz\fP decomprimerà +tali file come se fossero un singolo file \fB.xz\fP. +.PP +È possibile inserire un padding tra le parti concatenate o dopo l'ultima +parte. Il padding deve essere costituito da byte "null" e la dimensione del +padding deve essere un multiplo di quattro byte. Questo può essere utile, ad +esempio, se il file \fB.xz\fP è memorizzato su un supporto che misura le +dimensioni dei file in blocchi di 512 byte. +.PP +Concatenazione e padding non sono permessi con file \fB.lzma\fP o con flussi +grezzi. +. +.SH OPZIONI +. +.SS "Suffissi interi e valori speciali" +Nella maggior parte dei casi in cui è previsto un argomento intero, è +supportato un suffisso facoltativo per indicare facilmente numeri interi di +grandi dimensioni. Non deve esserci alcuno spazio tra il numero intero e il +suffisso. +.TP +\fBKiB\fP +Moltiplica l'intero per 1024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP, e \fBKB\fP +sono accettati come sinonimi di \fBKiB\fP. +.TP +\fBMiB\fP +Moltiplica l'intero per 1.048.576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP, e \fBMB\fP sono +accettati come sinonimi di \fBMiB\fP. +.TP +\fBGiB\fP +Moltiplica l'intero per 1.073.741.824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP, e \fBGB\fP +sono accettati come sinonimi di \fBGiB\fP. +.PP +Il valore speciale \fBmax\fP può essere utilizzato per indicare il valore +intero massimo supportato dall'opzione. +. +.SS "Modalità operativa" +Se vengono fornite più opzioni di modalità operativa, l'ultima ha effetto. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Compressione. Questa è la modalità operativa predefinita quando non viene +specificata alcuna opzione della modalità operativa e non è determinata +nessun'altra modalità operativa dal nome del comando (ad esempio, \fBunxz\fP +implica \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Dopo che la compressione è terminata con successo, il file origine viene +rimosso a meno che si stia scrivendo su standard output o che venga +specificato \fB\-\-keep\fP. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Decompressione. Dopo che la decompressione è terminata con successo, il file +origine viene rimosso a meno che si stia scrivendo su standard output o che +venga specificato \fB\-\-keep\fP. +.TP +\fB\-t\fP, \fB\-\-test\fP +Testa l'integrità dei \fIFILE\fP compressi. Questa opzione è equivalente a +\fB\-\-decompress \-\-stdout\fP tranne per il fatto che i dati decompressi vengono +scartati invece di essere scritti nello standard output. Nessun file viene +creato o rimosso. +.TP +\fB\-l\fP, \fB\-\-list\fP +Stampa le informazioni sul \fIFILE\fP compresso. Non viene prodotto alcun +output non compresso e non viene creato o rimosso alcun file. In modalità +elenco, il programma non è in grado di leggere i dati compressi dallo +standard input o da altre fonti che non permettano la ricerca. +.IP "" +Il tracciato predefinito mostra le informazioni di base sui \fIFILE\fP, un file +per riga. Per ottenere informazioni più dettagliate, usare anche l'opzione +\fB\-\-verbose\fP. Per avere ancora più informazioni, usare \fB\-\-verbose\fP due +volte, ma si noti che questo può essere lento, perché ottenere tutte le +informazioni extra richiede molte estrazioni. La larghezza dell'output +dettagliato supera gli 80 caratteri, quindi il reindirizzamento dell'output, +ad esempio, a \fBless\ \-S\fP può essere utile se il terminale non è +sufficientemente ampio. +.IP "" +L'output esatto può variare tra le versioni di \fBxz\fP e le diverse +impostazioni locali. Per un output leggibile dalla macchina si dovrebbe +utilizzare \fB\-\-robot \-\-list\fP. +. +.SS "Modificatori dell'operazione" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Non elimina i file input. +.IP "" +A partire da \fBxz\fP 5.2.6, questa opzione fa sì che \fBxz\fP comprima o +decomprima anche se l'input è un collegamento simbolico a un file regolare, +ha più di un collegamento fisico o ha il bit setuid, setgid o sticky +impostato. I bit setuid, setgid e sticky non vengono copiati nel file di +destinazione. Nelle versioni precedenti questo veniva fatto solo con +\fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Questa opzione ha diverse conseguenze: +.RS +.IP \(bu 3 +Se il file di destinazione esiste già, lo elimina prima di comprimere o +decomprimere. +.IP \(bu 3 +Comprime o decomprime anche se l'input è un collegamento simbolico a un file +regolare, ha più di un collegamento "hard", o ha il bit setuid, setgid o +sticky impostato. I bit setuid, setgid e sticky non sono copiati sul file +destinazione. +.IP \(bu 3 +Quando usato con \fB\-\-decompress\fP \fB\-\-stdout\fP e \fBxz\fP non riesce a +riconoscere il tipo di file sorgente, copia il file sorgente così com'è +sullo standard output. Questo permette a \fBxzcat\fP \fB\-\-force\fP di essere usato +come \fBcat\fP(1) per file che non siano stati compressi con \fBxz\fP. Si noti che +in futuro \fBxz\fP potrebbe supportare nuovi formati di file compressi, il che +potrebbe portare \fBxz\fP a decomprimere più tipi di file anziché copiarli come +sono sullo standard output. \fB\-\-format=\fP\fIFORMATO\fP può essere usato per +forzare \fBxz\fP a decomprimere solo un singolo formato di file. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Scrive i dati compressi o decompressi nello standard output anziché in un +file. Implica \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Decomprime solo il primo flusso \fB.xz\fP, e ignora automaticamente i possibili +dati di input rimanenti che seguono il flusso. Normalmente questi dati +sporchi finali portano \fBxz\fP a visualizzare un errore. +.IP "" +\fBxz\fP non decomprime mai più di un flusso dai file \fB.lzma\fP o dai flussi +grezzi, ma questa opzione fa comunque in modo che \fBxz\fP ignori i possibili +dati finali dopo il file \fB.lzma\fP o il flusso grezzo. +.IP "" +Questa opzione non ha effetto se la modalità operativa non è \fB\-\-decompress\fP +o \fB\-\-test\fP. +.IP "" +Dalla versione \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP implica \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Disabilita la creazione di file sparsi. Per impostazione predefinita, se si +esegue la decompressione in un file regolare, \fBxz\fP tenta di rendere il file +sparso se i dati decompressi contengono lunghe sequenze di zeri +binari. Funziona anche quando si scrive su standard output, purché lo +standard output sia collegato a un file regolare e siano soddisfatte alcune +condizioni aggiuntive per renderlo sicuro. La creazione di file sparsi può +risparmiare spazio su disco e velocizzare la decompressione riducendo la +quantità di I/O su disco. +.TP +\fB\-S\fP \fI.SUFFISSO\fP, \fB\-\-suffix=\fP\fI.SUFFISSO\fP +Durante la compressione, utilizzare \fI.suf\fP come suffisso per il file di +destinazione anziché \fB.xz\fP o \fB.lzma\fP. Se non si scrive nello standard +output e il file di origine ha già il suffisso \fI.suf\fP, viene visualizzato +un avvertimento e il file viene ignorato. +.IP "" +Quando si decomprime, accetta i file con suffisso \fI.suf\fP in aggiunta a +quelli con suffisso \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, o \fB.lz\fP. Se il file +sorgente ha suffisso \fI.suf\fP, il suffisso viene rimosso per ottenere il nome +del file destinazione. +.IP "" +Quando si comprimono o decomprimono flussi grezzi (\fB\-\-format=raw\fP), il +suffisso deve sempre essere specificato, a meno che si scriva sullo standard +output, perché non esiste un suffisso predefinito per i flussi grezzi. +.TP +\fB\-\-files\fP[\fB=\fP\fIFILE\fP] +Legge i nomi dei file da processare da \fIFILE\fP; se \fIFILE\fP è omesso, i nomi +dei file vengono letti dallo standard input. I nomi dei file devono essere +terminati da un carattere "a capo". Un trattino (\fB\-\fP) è considerato come un +nome di file regolare; non indica lo standard input. Se vengono forniti +anche dei nomi di file come argomenti della riga di comando, questi sono +processati prima di quelli letti da \fIFILE\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIFILE\fP] +Questo è identico a \fB\-\-files\fP[\fB=\fP\fIFILE\fP] tranne per il fatto che ogni +nome di file deve terminare con il carattere null. +. +.SS "Formato file di base e opzioni di compressione" +.TP +\fB\-F\fP \fIFORMATO\fP, \fB\-\-format=\fP\fIFORMATO\fP +Specifica il \fIFORMATO\fP del file da comprimere o decomprimere: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Questa è l'impostazione predefinita. Quando si comprime, \fBauto\fP è +equivalente a \fBxz\fP. Quando si decomprime, il formato del file input viene +rilevato automaticamente. Si noti che per i flussi grezzi (creati con +\fB\-\-format=raw\fP) non è possibile il rilevamento automatico. +.TP +\fBxz\fP +Comprime nel formato di file \fB.xz\fP, oppure accetta solo file \fB.xz\fP durante +la decompressione. +.TP +\fBlzma\fP, \fBalone\fP +Comprime nel formato tradizionale \fB.lzma\fP, oppure accetta solo file +\&\fB.lzma\fP per la decompressione. Il nome alternativo \fBalone\fP è fornito per +retrocompatibilità con le LZMA Utils. +.TP +\fBlzip\fP +Accetta solo file \fB.lz\fP per la decompressione. La compressione non è +supportata. +.IP "" +Sono supportate le versioni 0 e 1 del formato \fB.lz\fP. I file in versione 0 +sono stati prodotti da \fBlzip\fP 1.3 e precedenti. Questi file non sono +comuni, ma possono essere trovati negli archivi di file, perché alcuni +pacchetti sorgente erano stati rilasciati in questo formato. Qualcuno +potrebbe anche avere vecchi file personali in questo formato. Il supporto +alla decompressione per la versione di formato 0 è stato rimosso in \fBlzip\fP +1.18. \fBlzip\fP 1.4 e successivi creano i file nella versione di formato 1. +.TP +\fBraw\fP +Comprime o decomprime un flusso grezzo (senza intestazione). Questo è inteso +solamente per utenti avanzati. Per decodificare flussi grezzi, occorre usare +\fB\-\-format=raw\fP e specificare esplicitamente la catena dei filtri, che +normalmente sarebbero conservati nell'intestazione. +.RE +.TP +\fB\-C\fP \fICONTROLLO\fP, \fB\-\-check=\fP\fICONTROLLO\fP +Specifica il tipo di controllo di integrità. Il controllo viene calcolato +dai dati non compressi e memorizzato nel file \fB.xz\fP. Questa opzione ha +effetto solo quando si comprime nel formato \fB.xz\fP; il formato \fB.lzma\fP non +supporta i controlli di integrità. Il controllo di integrità (se presente) +viene verificato quando il file \fB.xz\fP viene decompresso. +.IP "" +Tipi di \fICONTROLLI\fP supportati: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Non calcola proprio il controllo di integrità. Questo in genere è una +pessima idea. Può essere utile quando l'integrità dei dati viene comunque +verificata con altri mezzi. +.TP +\fBcrc32\fP +Calcola la firma CRC32 usando il polinomio di IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Calcola la firma CRC64 usando il polinomio di ECMA\-182. Questa è +l'impostazione predefinita, perché è leggermente migliore della CRC32 nel +rilevare i file danneggiati e la differenza di velocità è trascurabile. +.TP +\fBsha256\fP +Calcola la firma SHA\-256. Questo è un po' più lento che CRC32 e CRC64. +.RE +.IP "" +L'integrità delle intestazioni \fB.xz\fP viene sempre verificata con CRC32. Non +è possibile modificarlo o disabilitarlo. +.TP +\fB\-\-ignore\-check\fP +Non verifica il controllo di integrità dei dati compressi durante la +decompressione. Il valore CRC3 nelle intestazioni \fB.xz\fP sarà ancora +verificata normalmente. +.IP "" +\fBNon usare questa opzione se non si è consci di cosa si sta facendo.\fP +Possibili ragioni per utilizzare questa opzione: +.RS +.IP \(bu 3 +Tentativo di recupero dei dati da un file .xz corrotto. +.IP \(bu 3 +Accelerazione della decompressione. Questo è importante soprattutto con +SHA\-256 o con i file che sono stati compressi molto bene. Si consiglia di +non utilizzare questa opzione per questo scopo, a meno che l'integrità del +file non venga verificata esternamente in altro modo. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Selezionare un livello di compressione preimpostato. Il valore predefinito è +\fB\-6\fP. Se vengono specificati più livelli preimpostati, l'ultimo ha +effetto. Se è già stata specificata una catena di filtri personalizzata, +l'impostazione di un livelli preimpostati cancella la catena di filtri +personalizzata. +.IP "" +Le differenze tra i livelli preimpostati sono più significative rispetto a +\fBgzip\fP(1) e \fBbzip2\fP(1). Le impostazioni di compressione selezionate +determinano i requisiti di memoria del decompressore, quindi l'utilizzo di +un livello preimpostato troppo alto potrebbe rendere difficile la +decompressione del file su un vecchio sistema con poca RAM. Specificamente, +\fBnon è una buona idea utilizzare ciecamente \-9 per tutto\fP come spesso +accade per \fBgzip\fP(1) e \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Questi sono livelli preimpostati piuttosto veloci. \fB\-0\-\fP a volte è più +veloce di \fBgzip \-9\fP e comprime molto meglio. Quelli più alti hanno spesso +una velocità paragonabile a \fBbzip2\fP(1) con un rapporto di compressione +comparabile o migliore, anche se i risultati dipendono molto dal tipo di +dati che vengono compressi. +.TP +\fB\-4\fP ... \fB\-6\fP +Compressione da buona a molto buona, mantenendo l'utilizzo della memoria del +decompressore ragionevole anche per vecchi sistemi. \fB\-6\fP è il valore +predefinito, che di solito è una buona scelta per distribuire file che +debbano essere decompressi anche su sistemi con solo 16\ MiB di +RAM. (Potrebbe valere la pena di considerare anche \fB\-5e\fP o \fB\-6e\fP. Si veda +\fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Questi sono come \fB\-6\fP ma con requisiti di memoria di compressore e +decompressore più elevati. Sono utili solo quando si comprimono file di +dimensioni superiori a 8\ MiB, 16\ MiB e 32\ MiB, rispettivamente. +.RE +.IP "" +A parità di hardware, la velocità di decompressione è approssimativamente un +numero costante di byte di dati compressi al secondo. In altre parole, +migliore è la compressione, più veloce sarà di solito la decompressione. Ciò +significa anche che la quantità di output non compresso prodotta al secondo +può variare notevolmente. +.IP "" +La tabella seguente riassume le caratteristiche dei livelli preimpostati: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Livello preimpostato;DictSize;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Descrizioni delle colonne: +.RS +.IP \(bu 3 +DictSize è la dimensione del dizionario LZMA2. È uno spreco di memoria usare +un dizionario più grande della dimensione del file non compresso. Ecco +perché è una buona cosa evitare di usare i livelli preimpostati \fB\-7\fP +\&... \fB\-9\fP quando non c'è reale necessità. Con \fB\-6\fP e inferiori, la quantità +di memoria sprecata in genere è sufficientemente bassa da essere +trascurabile. +.IP \(bu 3 +CompCPU è una rappresentazione semplificata delle impostazioni di LZMA2 che +influenzano la velocità di compressione. Anche la dimensione del dizionario +influenza la velocità, quindi mentre CompCPU è lo stesso per i livelli \fB\-6\fP +\&... \fB\-9\fP, i livelli più alti tendono ancora ad essere un po' più lenti. Per +avere una compressione ancora più lenta e quindi potenzialmente migliore, +utilizzare \fB\-\-extreme\fP. +.IP \(bu 3 +CompMem contiene i requisiti di memoria del compressore in modalità a +singola thread. Può variare leggermente tra le versioni di \fBxz\fP. +.IP \(bu 3 +DecMem contiene i requisiti di memoria del decompressore. In altre parole, +le impostazioni di compressione determinano i requisiti di memoria del +decompressore. L'utilizzo esatto della memoria del decompressore è +leggermente superiore alla dimensione del dizionario LZMA2, ma i valori +nella tabella sono stati arrotondati per eccesso al successivo MiB completo. +.RE +.IP "" +I requisiti di memoria per la modalità a thread multiple sono +significativamente più alti che per la modalità thread singola. Con il +valore predefinito di \fB\-\-block\-size\fP, ogni thread richiede 3*3*dimensione +del dizionario più CompMem oppure DecMem. Ad esempio, 4 thread con il +livello preimpostato \fB\-6\fP hanno bisogno di 660\(en670\ MiB di memoria. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Utilizzare una variante più lenta del livello preimpostato selezionato +(\fB\-0\fP ... \fB\-9\fP) nella speranza di ottenere un rapporto di compressione +leggermente migliore, ma con un po' di sfortuna questo potrebbe anche +renderlo peggiore. L'utilizzo della memoria del decompressore non è +influenzato, ma l'utilizzo della memoria del compressore aumenta leggermente +ai livelli preimpostati \fB\-0\fP ... \fB\-3\fP. +.IP "" +Dal momento che ci sono due livelli preimpostati con dimensione del +dizionario di 4\ MiB e 8\ MiB, i livelli preimpostati \fB\-3e\fP e \fB\-5e\fP usano +impostazioni leggermente più veloci (minore CompCPU) di \fB\-4e\fP e \fB\-6e\fP, +rispettivamente. In questo modo non ci sono due livelli preimpostati +identici. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Livello preimpostato;DictSize;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Ad esempio, ci sono un totale di quattro livelli preimpostati che utilizzano +un dizionario da 8\ MiB, il cui ordine dal più veloce al più lento è \fB\-5\fP, +\fB\-6\fP, \fB\-5e\fP, e \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Questi sono alias in qualche modo fuorvianti per \fB\-0\fP e \fB\-9\fP, +rispettivamente. Sono forniti solo per retrocompatibilità con le LZMA +Utils. Evitare di utilizzare queste opzioni. +.TP +\fB\-\-block\-size=\fP\fIDIMENSIONE\fP +Quando si comprime in formato \fB.xz\fP, divide i dati input in blocchi da +\fIDIMENSIONE\fP byte. I blocchi vengo compressi indipendentemente l'uno +dall'altro, cosa che aiuta con le thread multiple e rende possibile la +decompressione con accessi casuali limitati. Questa opzione viene usata +tipicamente per sovrascrivere la dimensione predefinita dei blocchi in +modalità a thread multiple, ma può essere utilizzata anche in modalità +thread singola. +.IP "" +In modalità a thread multiple verranno allocati circa il triplo di +\fIDIMENSIONE\fP di byte in ogni thread per il buffering dell'input e +dell'output. La \fIDIMENSIONE\fP predefinita è tre volte la dimensione del +dizionario LZMA2 e comunque almeno 1 MiB. Tipicamente un buon valore è +2\(en4 volte la dimensione del dizionario LZMA2 oppure almeno 1 MiB. Usare +una \fIDIMENSIONE\fP inferiore della dimensione del dizionario LZMA2 causa uno +spreco di RAM, in quanto il buffer del dizionario LZMA2 non verrà mai +riempito completamente. In modalità a thread multiple, la dimensione dei +blocchi è conservata nelle intestazioni dei blocchi. L'informazione sulla +dimensione è richiesta per la decompressione a thread multiple. +.IP "" +Nella modalità a thread singola, per impostazione predefinita non viene +eseguita alcuna suddivisione in blocchi. L'impostazione di questa opzione +non influisce sull'utilizzo della memoria. Nessuna informazione sulle +dimensioni viene memorizzata nelle intestazioni di blocco, quindi i file +creati in modalità a thread singola non saranno identici ai file creati in +modalità a thread multiple. La mancanza di informazioni sulle dimensioni +significa anche che \fBxz\fP non sarà in grado di decomprimere i file in +modalità a thread multiple. +.TP +\fB\-\-block\-list=\fP\fIELEMENTI\fP +Quando si comprime nel formato \fB.xz\fP, inizia un nuovo blocco con una catena +di filtri personalizzata dopo gli intervalli indicati di dati non compressi. +.IP "" +Gli \fIELEMENTI\fP sono un elenco separato da virgole. Ogni elemento è +costituito da un numero di catena di filtri opzionale compreso tra 0 e 9 +seguito da due punti (\fB:\fP) e da una dimensione richiesta di dati non +compressi. L'omissione di un elemento (due o più virgole consecutive) è una +scorciatoia per utilizzare le dimensioni e i filtri dell'elemento +precedente. +.IP "" +Se il file di input è più grande della somma delle dimensioni in +\fIELEMENTI\fP, l'ultimo elemento viene ripetuto fino alla fine del file. Il +valore speciale \fB0\fP può essere utilizzato come ultima dimensione per +indicare che il resto del file deve essere codificato come un singolo +blocco. +.IP "" +È possibile specificare una catena di filtri alternativa per ogni blocco in +combinazione con le opzioni \fB\-\-filters1=\fP\fIFILTRI\fP \&...\& +\fB\-\-filters9=\fP\fIFILTRI\fP. Queste opzioni definiscono catene di filtri con un +identificatore compreso tra 1\(en9. La catena di filtri 0 può essere +utilizzata per indicare la catena di filtri predefinita, che equivale a non +specificare una catena di filtri. L'identificatore della catena di filtri +può essere utilizzato prima della dimensione non compressa, seguita da due +punti (\fB:\fP). Ad esempio, se si specifica +\fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP allora i blocchi verranno +creati utilizzando: +.RS +.IP \(bu 3 +La catena dei filtri specificata da \fB\-\-filters1\fP e un input di 2 MiB +.IP \(bu 3 +La catena dei filtri specificata da \fB\-\-filters3\fP e un input di 2 MiB +.IP \(bu 3 +La catena dei filtri specificata da \fB\-\-filters2\fP e un input di 4 MiB +.IP \(bu 3 +La catena dei filtri specificata da \fB\-\-filters2\fP e un input di 4 MiB +.IP \(bu 3 +La catena di filtri predefinita e l'input di 2 MiB +.IP \(bu 3 +La catena di filtri predefinita e l'input di 4 MiB per ogni blocco fino alla +fine dell'input. +.RE +.IP "" +Se si specifica una dimensione che supera la dimensione del blocco del +codificatore (il valore predefinito in modalità thread oppure il valore +specificato con \fB\-\-block\-size=\fP\fIDIMENSIONE\fP), il codificatore creerà +blocchi aggiuntivi mantenendo i limiti specificati in \fIELEMENTI\fP. Ad +esempio, se si indica \fB\-\-block\-size=10MiB\fP +\fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP e il file input è di 80 MiB, si +otterranno 11 blocchi: 5, 10, 8, 10, 2, 10, 10, 4, 10, 10, and 1 MiB. +.IP "" +In modalità a thread multiple, le dimensioni dei blocchi vengono memorizzate +nelle intestazioni dei blocchi. Questo non avviene in modalità thread +singola, quindi l'output codificato non sarà identico a quello della +modalità a thread multiple. +.TP +\fB\-\-flush\-timeout=\fP\fITIMEOUT\fP +Quando si comprime, se sono passati più di \fITIMEOUT\fP millisecondi (un +intero positivo) dallo scaricamento precedente e la lettura di ulteriori +input si bloccherebbe, tutti i dati di input in sospeso vengono scaricati +dal codificatore e resi disponibili nel flusso di output. Questo può essere +utile se \fBxz\fP viene usato per comprimere dati in streaming dalla +rete. Piccoli valori del \fITIMEOUT\fP rendono disponibili i dati al ricevente +con un ritardo minimo, mentre valori di \fITIMEOUT\fP grandi danno un miglior +rapporto di compressione. +.IP "" +Questa funzionalità è disabilitata per impostazione predefinita. Se questa +opzione viene specificata più di una volta, l'ultima ha effetto. Il valore +speciale \fITIMEOUT\fP di \fB0\fP può essere utilizzato per disabilitare +esplicitamente questa funzionalità. +.IP "" +Questa funzionalità non è disponibile sui sistemi non\-POSIX. +.IP "" +.\" FIXME +\fBQuesta funzionalità è sperimentale.\fP Attualmente \fBxz\fP non è adatto per +decomprimere il flusso in tempo reale, a causa di come effettua il +buffering. +.TP +\fB\-\-no\-sync\fP +Non sincronizzare il file target e la sua directory sull'unità di +archiviazione prima di rimuovere il file sorgente. Questo può migliorare le +performance se si sta comprimendo o decomprimendo tanti piccoli +file. Tuttavia, se il sistema dovesse andare in crash subito dopo +l'eliminazione, è possibile che il file destinazione non sia ancora stato +scritto sull'unità di archiviazione mentre l'operazione di eliminazione +sì. In questo caso non saranno più disponibili né il file sorgente originale +né il file di destinazione. +.IP "" +Questa opzione ha effetto solamente quando \fBxz\fP deve rimuovere il file +sorgente. Negli altri casi la sincronizzazione non viene eseguita. +.IP "" +La sincronizzazione e \fB\-\-no\-sync\fP sono stati aggiunti nella versione \fBxz\fP +5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fILIMITE\fP +Imposta un limite di utilizzo della memoria per la compressione. Se questa +opzione viene specificata più volte, ha effetto l'ultima. +.IP "" +Se le impostazioni di compressione superano il valore \fILIMITE\fP, \fBxz\fP +tenterà di regolare le impostazioni verso il basso in modo che il limite non +venga più superato e visualizzerà un avviso che indica che è stata eseguita +una regolazione automatica. Le regolazioni vengono eseguite in questo +ordine: riduzione del numero di thread, passaggio alla modalità a thread +singola se anche un solo thread in modalità a thread multiple supera il +\fILIMITE\fP, e infine riducendo la dimensione del dizionario LZMA2. +.IP "" +Quando si comprime con \fB\-\-format=raw\fP oppure se si è specificato +\fB\-\-no\-adjust\fP, è possibile ridurre solo il numero di thread, poiché questo +può essere fatto senza influire sull'output compresso. +.IP "" +Se non è possibile soddisfare il \fILIMITE\fP anche con le regolazioni sopra +descritte, viene visualizzato un errore e \fBxz\fP uscirà con lo stato di +uscita 1. +.IP "" +Il \fILIMITE\fP può essere specificato in diversi modi: +.RS +.IP \(bu 3 +Il \fILIMITE\fP può essere un valore assoluto in byte. Usare un suffisso intero +come \fBMiB\fP può essere utile. Ad esempio: \fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +Il \fILIMITE\fP può essere specificato come percentuale della memoria fisica +(RAM) totale. Questo può essere utile specialmente quando si imposta la +variabile di ambiente \fBXZ_DEFAULTS\fP in uno script di inizializzazione di +shell che è condiviso tra computer diversi. In questo modo il limite è +automaticamente più grande sui sistemi con più memoria. Ad esempio: +\fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +Il \fILIMITE\fP può essere reimpostato al suo valore predefinito impostandolo a +\fB0\fP.Questo attualmente equivale a impostare il \fILIMITE\fP a \fBmax\fP (nessun +limite nell'utilizzo di memoria). +.RE +.IP "" +Per \fBxz\fP a 32\-bit esiste un caso particolare: se il \fILIMITE\fP fosse oltre +\fB4020\ MiB\fP, il \fILIMITE\fP viene impostato a \fB4020\ MiB\fP. Su MIPS32 invece +viene usato \fB2000\ MiB\fP. (I valori \fB0\fP e \fBmax\fP non sono influenzati da +questo. Un comportamento simile non esiste per la decompressione). Questo +può essere utile quando un eseguibile a 32 bit ha accesso a uno spazio di +indirizzi da 4\ GiB (2 GiB su MIPS32), e si spera che non faccia danni in +altre situazioni. +.IP "" +Vedere anche la sezione \fBUtilizzo memoria\fP +.TP +\fB\-\-memlimit\-decompress=\fP\fILIMITE\fP +Imposta un limite di utilizzo della memoria per la decompressione. Questo +influisce anche sulla modalità \fB\-\-list\fP. Se l'operazione non è possibile +senza oltrepassare il \fILIMITE\fP, \fBxz\fP mostrerà un errore e la +decompressione del file fallirà. Si veda \fB\-\-memlimit\-compress=\fP\fILIMITE\fP +per possibili modi per specificare il \fILIMITE\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fILIMITE\fP +Imposta un limite di utilizzo della memoria per la decompressione +multi\-thread. Questo può influire solo sul numero di thread; non indurrà mai +\fBxz\fP a rifiutarsi di decomprimere un file. Se \fILIMITE\fP è troppo basso per +consentire le thread multiple, il \fILIMITE\fP viene ignorato e \fBxz\fP +continuerà in modalità a thread singola. Si noti che se viene utilizzato +anche \fB\-\-memlimit\-decompress\fP, si applicherà sempre sia alla modalità a +thread singola che a quella a thread multiple, e quindi il \fILIMITE\fP +effettivo per le thread multiple non sarà mai superiore a quello impostato +con \fB\-\-memlimit\-decompress\fP. +.IP "" +In contrasto con le altre opzioni di limite di utilizzo della memoria, +\fB\-\-memlimit\-mt\-decompress=\fP\fILIMITE\fP ha un \fILIMITE\fP predefinito specifico +per il sistema. \fBxz \-\-info\-memory\fP può essere utilizzato per vedere il +valore corrente. +.IP "" +Questa opzione e il suo valore predefinito esistono perché, senza un limite, +il decompressore a thread multiple potrebbe finire per allocare una quantità +folle di memoria per alcuni file input. Se il valore predefinito \fILIMITE\fP è +troppo basso sul proprio sistema, è possibile aumentarlo liberamente, ma non +deve essere mai impostato a un valore più grande della quantità di RAM +utilizzabile, in quanto con file di input appropriati \fBxz\fP cercherà di +utilizzare quella quantità di memoria anche con un basso numero di +thread. Esaurire la memoria o fare swap non migliorerà le performance della +decompressione. +.IP "" +Vedi \fB\-\-memlimit\-compress=\fP\fILIMITE\fP per possibili modi per specificare il +\fILIMITE\fP. Impostando \fILIMITE\fP su \fB0\fP si ripristina il valore predefinito +\fILIMITE\fP specifico del sistema. +.TP +\fB\-M\fP \fILIMITE\fP, \fB\-\-memlimit=\fP\fILIMITE\fP, \fB\-\-memory=\fP\fILIMITE\fP +Questo equivale a specificare \fB\-\-memlimit\-compress=\fP\fILIMITE\fP +\fB\-\-memlimit\-decompress=\fP\fILIMITE\fP \fB\-\-memlimit\-mt\-decompress=\fP\fILIMITE\fP. +.TP +\fB\-\-no\-adjust\fP +Visualizza un errore e esce se non è possibile soddisfare il limite di +utilizzo della memoria senza regolare le impostazioni che influiscono +sull'output compresso. In altre parole, ciò impedisce a \fBxz\fP di passare il +codificatore dalla modalità multi\-thread alla modalità a thread singola e di +ridurre le dimensioni del dizionario LZMA2. Anche quando viene usata questa +opzione, il numero di thread può essere ridotto per soddisfare il limite di +utilizzo della memoria, in quanto ciò non influirà sull'output compresso. +.IP "" +La regolazione automatica è sempre disabilitata quando si creano flussi raw +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fITHREADS\fP, \fB\-\-threads=\fP\fITHREADS\fP +Specifica il numero di thread di lavoro da utilizzare. L'impostazione di +\fITHREADS\fP al valore speciale \fB0\fP fa sì che \fBxz\fP utilizzi fino a un numero +di thread che il processore/i del sistema supportano. Il numero effettivo di +thread può essere inferiore a \fITHREADS\fP se il file di input non è +sufficientemente grande per il threading con le impostazioni specificate o +se l'utilizzo di più thread supera il limite di utilizzo della memoria. +.IP "" +I compressori a thread singola e a thread multiple producono output +diversi. Il compressore a thread singola produrrà la dimensione del file più +piccola, ma solo l'output del compressore a thread multiple può essere +decompresso utilizzando più thread. Impostando \fITHREADS\fP su \fB1\fP verrà +utilizzata la modalità a thread singola. L'impostazione di \fITHREADS\fP su +qualsiasi altro valore, incluso \fB0\fP, utilizzerà il compressore a thread +multiple anche se il sistema supporta un solo thread hardware. (\fBxz\fP 5.2.x +utilizzava la modalità a thread singola in questa situazione.) +.IP "" +Per utilizzare la modalità a thread multiple con un solo thread, impostare +\fITHREADS\fP su \fB+1\fP. Il prefisso \fB+\fP non ha alcun effetto con valori +diversi da \fB1\fP. Un limite di utilizzo della memoria può comunque far +passare \fBxz\fP alla modalità a thread singola a meno che non venga utilizzato +\fB\-\-no\-adjust\fP. Il supporto per il prefisso \fB+\fP è stato aggiunto in \fBxz\fP +5.4.0. +.IP "" +Se è stato richiesto un numero automatico di thread e non è stato +specificato alcun limite di utilizzo della memoria, verrà utilizzato un +limite "soft" predefinito, specifico del sistema, per limitare eventualmente +il numero di thread. È un limite "soft" nel senso che viene ignorato se il +numero di thread diventa uno, quindi un limite soft non impedirà mai a \fBxz\fP +di comprimere o decomprimere. Questo limite soft predefinito non farà +passare \fBxz\fP dalla modalità a thread multiple alla modalità thread +singola. I limiti attivi possono essere visualizzati con \fBxz \-\-info\-memory\fP. +.IP "" +Attualmente l'unico metodo di threading consiste nel dividere l'input in +blocchi e comprimerli indipendentemente l'uno dall'altro. La dimensione +predefinita del blocco dipende dal livello di compressione e può essere +sovrascritta con l'opzione \fB\-\-block\-size=\fP\fIDIMENSIONE\fP. +.IP "" +La decompressione a thread multiple funziona solo su file che contengano più +blocchi con l'informazione della dimensione nelle intestazioni del +blocco. Tutti i file sufficientemente grandi compressi in modalità a thread +multiple soddisfano questa condizione, mentre i file compressi in modalità +thread singola no, neanche se si è utilizzato \fB\-\-block\-size=\fP +\fIDIMENSIONE\fP. +.IP "" +Il valore predefinito per \fITHREADS\fP è \fB0\fP. In \fBxz\fP 5.4.x e precedenti il +valore predefinito era \fB1\fP. +. +.SS "Catene di filtri di compressione personalizzate" +Una catena di filtri personalizzata consente di specificare in dettaglio le +impostazioni di compressione invece di fare affidamento sulle impostazioni +associate ai livelli preimpostati. Quando viene specificata una catena di +filtri personalizzata, le opzioni relative ai livelli preimpostati (\fB\-0\fP +\&...\& \fB\-9\fP e \fB\-\-extreme\fP) specificate in precedenza sulla riga di +comando vengono dimenticate. Se un'opzione livello preimpostato viene +specificata dopo una o più opzioni della catena di filtri personalizzata, il +nuovo livello preimpostato ha effetto e le opzioni della catena di filtri +personalizzate specificate in precedenza vengono dimenticate. +.PP +Una catena di filtri è paragonabile a una pipe sulla riga di +comando. Durante la compressione, l'input non compresso va al primo filtro, +il cui output va al filtro successivo (se presente). L'output dell'ultimo +filtro viene scritto nel file compresso. Il numero massimo di filtri nella +catena è quattro, ma in genere una catena di filtri ha solo uno o due +filtri. +.PP +Molti filtri hanno limitazioni su dove possono trovarsi nella catena di +filtri: alcuni filtri possono funzionare solo come ultimo filtro della +catena, altri solo come filtro non ultimo e alcuni funzionano in qualsiasi +posizione nella catena. A seconda del filtro, questa limitazione è inerente +alla struttura del filtro oppure esiste per evitare problemi di sicurezza. +.PP +Una catena di filtri personalizzata può essere specificata in due modi +diversi. Le opzioni \fB\-\-filters=\fP\fIFILTRI\fP and \fB\-\-filters1=\fP\fIFILTRI\fP +\&...\& \fB\-\-filters9=\fP\fIFILTRI\fP permettono di specificare un'intera catena +di filtri in una opzione utilizzando la sintassi della stringa del filtro di +lzma. In alternativa, una catena di filtri può essere specificata +utilizzando una o più singole opzioni di filtro nell'ordine desiderato nella +catena di filtri. Questo significa che l'ordine delle singole opzioni di +filtro è importante! Quando si decodificano i flussi grezzi +(\fB\-\-format=raw\fP), la catena di filtri deve essere specificata nello stesso +ordine in cui è stata specificata durante la compressione. Qualsiasi filtro +individuale o opzione livello preimpostato specificata prima dell'opzione +della catena completa (\fB\-\-filters=\fP\fIFILTRI\fP) verrà dimenticata. I singoli +filtri specificati dopo l'opzione della catena completa reimposteranno la +catena di filtri. +.PP +Sia l'opzione di filtro completo che quella individuale accettano \fIOPZIONI\fP +specifiche del filtro come un elenco separato da virgole. Virgole in eccesso +nelle \fIOPZIONI\fP vengono ignorate. Ogni opzione ha un valore di default, +quindi occorre specificare solamente quelle che si desidera modificare. +.PP +Per vedere l'intera catena di filtri e \fIOPZIONI\fP, usa \fBxz \-vv\fP (ossia, usa +\fB\-\-verbose\fP due volte). Questo funziona anche per visualizzare le opzioni +della catena di filtri utilizzate dai livelli preimpostati. +.TP +\fB\-\-filters=\fP\fIFILTRI\fP +Specifica l'intera catena dei filtri oppure un livello preimpostato in una +singola opzione. Ogni filtro può essere separato da spazi o da due trattini +(\fB\-\-\fP). Potrebbe essere necessario mettere tra virgolette i \fIFILTRI\fP sulla +riga di comando della shell in modo che vengano analizzati come una singola +opzione. Per indicare \fIOPZIONI\fP, usa \fB:\fP o \fB=\fP. Un livello preimpostato +può essere preceduto da un \fB\-\fP e seguito da zero o più flag. L'unico flag +supportato è \fBe\fP per applicare le stesse opzioni di \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIFILTRI\fP ... \fB\-\-filters9\fP=\fIFILTRI\fP +Specifica fino a nove catene di filtri aggiuntive che possono essere +utilizzate con \fB\-\-block\-list\fP. +.IP "" +Ad esempio, quando si comprime un archivio con file eseguibili seguiti da +file di testo, la parte eseguibile potrebbe utilizzare una catena di filtri +con un filtro BCJ e la parte di testo solo il filtro LZMA2. +.TP +\fB\-\-filters\-help\fP +Mostra un messaggio di aiuto che descrive come specificare livelli +preimpostati e catene di filtri personalizzati nelle opzioni \fB\-\-filters\fP e +\fB\-\-filters1=\fP\fIFILTRI\fP \&...\& \fB\-\-filters9=\fP\fIFILTRI\fP, e termina con +successo. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIOPZIONI\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIOPZIONI\fP] +.PD +Aggiunge un filtro LZMA1 o LZMA2 alla catena dei filtri. Questi filtri +possono essere usati solo come ultimo filtro della catena. +.IP "" +LZMA1 è un filtro obsoleto, supportato quasi esclusivamente a causa del +formato obsoleto di file \fB.lzma\fP, che supporta solo LZMA1. LZMA2 è una +versione aggiornata di LZMA1 che risolve alcuni problemi pratici di +LZMA1. Il formato \fB.xz\fP utilizza LZMA2 e non supporta LZMA1. La velocità e +i rapporti di compressione di LZMA1 e LZMA2 sono praticamente gli stessi. +.IP "" +LZMA1 e LZMA2 condividono lo stesso insieme di \fIOPZIONI\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIPRESET\fP +Reimposta tutte le \fIOPZIONI\fP LZMA1 o LZMA2 a \fIPRESET\fP. Il \fIPRESET\fP +(livello preimpostato) consiste di un numero intero, che può essere seguito +da modificatori costituiti da una singola lettera. Il numero intero può +andare da \fB0\fP a \fB9\fP, corrispondenti alle opzioni della riga di comando +\fB\-0\fP \&...\& \fB\-9\fP. L'unico modificatore attualmente supportato è \fBe\fP, che +corrisponde a \fB\-\-extreme\fP. Se non viene specificato alcun \fIPRESET\fP, i +valori predefiniti delle \fIOPZIONI\fP LZMA1 o LZMA2 sono presi dal livello +preimpostato \fB6\fP. +.TP +\fBdict=\fP\fIDIMENSIONE\fP +La \fIDIMENSIONE\fPdel dizionario (buffer di cronologia) indica quanti byte dei +dati non compressi elaborati di recente vengono mantenuti in +memoria. L'algoritmo tenta di trovare sequenze di byte ripetute +(corrispondenze) nei dati non compressi e di sostituirle con riferimenti ai +dati attualmente presenti nel dizionario. Più grande è il dizionario, +maggiore è la possibilità di trovare una corrispondenza. Quindi, l'aumento +della \fIDIMENSIONE\fP del dizionario di solito migliora il rapporto di +compressione, ma un dizionario più grande del file non compresso è uno +spreco di memoria. +.IP "" +Una \fIDIMENSIONE\fP tipica per un dizionario è da 64\ KiB a 64\ MiB. Il minimo +è 4\ KiB. Il massimo per la compressione è attualmente 1.5\ GiB (1536\ MiB). La decompressione supporta già dizionari fino a 4\ GiB meno 1 byte, +che è il massimo per i formati di flusso LZMA1 e LZMA2. +.IP "" +La \fIDIMENSIONE\fP del dizionario e il cercatore di corrispondenze +(\fICERCATORE\fP) insieme determinano l'utilizzo della memoria del codificatore +LZMA1 o LZMA2. Per la decompressione è necessaria la stessa \fIDIMENSIONE\fP +del dizionario utilizzata durante la compressione (o più grande), quindi +l'utilizzo della memoria del decodificatore è determinato dalla dimensione +del dizionario utilizzato durante la compressione. Le intestazioni \fB.xz\fP +memorizzano la \fIDIMENSIONE\fP del dizionario come 2^\fIn\fP o 2^\fIn\fP + 2^( +\fIn\fP\-1), quindi queste \fIDIMENSIONI\fP sono in qualche modo preferite per la +compressione. Altre \fIDIMENSIONI\fP verranno arrotondate per eccesso quando +memorizzate nelle intestazioni \fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Specificare il numero di bit di contesto letterali. Il minimo è 0 e il +massimo è 4; Il valore predefinito è 3. Inoltre, la somma di \fIlc\fP e \fIlp\fP +non deve superare 4. +.IP "" +Tutti i byte che non possono essere codificati come corrispondenze vengono +codificati come valori letterali. In altre parole, i valori letterali sono +semplicemente byte a 8 bit codificati uno alla volta. +.IP "" +La codifica letterale presuppone che i bit di \fIlc\fP più alti del byte non +compresso precedente siano correlati al byte successivo. Ad esempio, in un +tipico testo inglese, una lettera maiuscola è spesso seguita da una lettera +minuscola e una lettera minuscola è solitamente seguita da un'altra lettera +minuscola. Nel set di caratteri US\-ASCII, i tre bit più alti sono 010 per le +lettere maiuscole e 011 per le lettere minuscole. Quando \fIlc\fP è almeno 3, +la codifica letterale può sfruttare questa proprietà nei dati non compressi. +.IP "" +Il valore predefinito (3) solitamente è buono. Se si desidera la +compressione massima, provare con \fBlc=4\fP. A volte aiuta un po', e a volte +rende la compressione peggiore. Se la rende peggiore, provare anche \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Specificare il numero di bit di posizione letterale. Il minimo è 0 e il +massimo è 4; Il valore predefinito è 0. +.IP "" +Il parametro \fIlp\fP influisce sul tipo di allineamento nei dati non compressi +presunto durante la codifica dei valori letterali. Vedi \fIpb\fP di seguito per +ulteriori informazioni sull'allineamento. +.TP +\fBpb=\fP\fIpb\fP +Specificare il numero di bit di posizione. Il minimo è 0 e il massimo è 4; +Il valore predefinito è 2. +.IP "" +Il parametro \fIpb\fP influisce su quale tipo di allineamento nei dati non +compressi sia assunto in generale. L'impostazione predefinita indica un +allineamento a quattro byte (2^\fIpb\fP =2^2=4), che è spesso una buona scelta +se non c'è un'ipotesi migliore. +.IP "" +Quando l'allineamento è noto, impostare \fIpb\fP concordemente può ridurre un +po' le dimensioni del file. Ad esempio, con file di testo con 1 byte di +allineamento (US\-ASCII, ISO\-8859\-*, UTF\-8), impostare \fBpb=0\fP può migliorare +leggermente la compressione. Per il testo UTF\-16, \fBpb=1\fP è una buona +scelta. Se l'allineamento è un numero dispari, come 3 byte, \fBpb=0\fP potrebbe +essere la scelta migliore. +.IP "" +Anche se l'allineamento assunto può essere regolato con \fIpb\fP e \fIlp\fP, LZMA1 +e LZMA2 favoriscono ancora leggermente l'allineamento a 16 byte. Potrebbe +valere la pena tenerlo in considerazione quando si progettano formati di +file che possono essere spesso compressi con LZMA1 o LZMA2. +.TP +\fBmf=\fP\fICERCATORE\fP +Il cercatore di corrispondenze ha un effetto importante sulla velocità del +codificatore, sull'utilizzo della memoria e sul rapporto di compressione. Di +solito i cercatori di corrispondenze a catena hash sono più veloci dei +cercatori di corrispondenze ad albero binario. Il valore predefinito dipende +da \fIPRESET\fP : 0 usa \fBhc3\fP, 1\(en3 usa \fBhc4\fP e il resto usa \fBbt4\fP. +.IP "" +Sono supportati i seguenti cercatori di corrispondenze. Le formule di +utilizzo della memoria riportate di seguito sono approssimazioni, che sono +le più vicine alla realtà quando \fIDIZIONARIO\fP è una potenza di due. +.RS +.TP +\fBhc3\fP +Catena hash con hashing da 2 e 3 byte +.br +Minimo valore per \fINICE\fP: 3 +.br +Utilizzo memoria: +.br +\fIDIZIONARIO\fP * 7.5 (se \fIDIZIONARIO\fP <= 16 MiB); +.br +\fIDIZIONARIO\fP * 5.5 + 64 MiB (se \fIDIZIONARIO\fP > 16 MiB) +.TP +\fBhc4\fP +Catena hash con hash da 2, 3 e 4 byte +.br +Minimo valore per \fINICE\fP: 4 +.br +Utilizzo memoria: +.br +\fIDIZIONARIO\fP * 7.5 (se \fIDIZIONARIO\fP <= 32 MiB); +.br +\fIDIZIONARIO\fP * 6.5 (se \fIDIZIONARIO\fP > 32 MiB) +.TP +\fBbt2\fP +Albero binario con hashing da 2 byte +.br +Valore minimo per \fINICE\fP: 2 +.br +Utilizzo di memoria: \fIDIZIONARIO\fP * 9.5 +.TP +\fBbt3\fP +Albero binario con hashing da 2 e 3 byte +.br +Minimo valore per \fINICE\fP: 3 +.br +Utilizzo memoria: +.br +\fIDIZIONARIO\fP * 11.5 (se \fIDIZIONARIO\fP <= 16 MiB); +.br +\fIDIZIONARIO\fP * 9.5 + 64 MiB (se \fIDIZIONARIO\fP > 16 MiB) +.TP +\fBbt4\fP +Albero binario con hashing da 2, 3 e 4 byte +.br +Minimo valore per \fINICE\fP: 4 +.br +Utilizzo memoria: +.br +\fIDIZIONARIO\fP * 11.5 (se \fIDIZIONARIO\fP <= 32 MiB); +.br +\fIDIZIONARIO\fP * 10.5 (se \fIDIZIONARIO\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fIMODALITÀ\fP +La \fIMODALITÀ\fP di compressione specifica il metodo per analizzare i dati +prodotti dal cercatore di corrispondenze. Le \fIMODALITÀ\fP supportate sono +\fBfast\fP e \fBnormal\fP. Il predefinito è \fBfast\fP per i \fIPRESET\fP 0\(en3 e +\fBnormal\fP per i \fIPRESET\fP 4\(en9. +.IP "" +Di solito \fBfast\fP viene utilizzato con i cercatori di corrispondenze a +catena hash e \fBnormal\fP con i cercatori di corrispondenze a albero +binario. Questo è anche quello che fanno i \fIPRESET\fP. +.TP +\fBnice=\fP\fINICE\fP +Specifica quella che si considera una lunghezza accettabile ("nice") per una +corrispondenza. Una volta trovata una corrispondenza di almeno \fINICE\fP byte, +l'algoritmo smette di cercare corrispondenze potenzialmente migliori. +.IP "" +\fINICE\fP può valere 2\(en273 byte. Valori più alti tendono a dare un miglior +rapporto di compressione ai danni della velocità. Il valore predefinito +dipende dal \fIPRESET\fP. +.TP +\fBdepth=\fP\fIPROFONDITÀ\fP +Specificare la profondità di ricerca massima nel cercatore di +corrispondenze. Il valore predefinito è il valore speciale 0, che dice al +compressore di determinare una \fIPROFONDITÀ\fP ragionevole da \fICERCATORE\fP e +\fINICE\fP. +.IP "" +Una \fIPROFONDITÀ\fP ragionevole per le catene hash è 4\(en100 e 16\(en1000 per +gli alberi binari. Utilizzando valori di \fIPROFONDITÀ\fP molto alti si può +rendere il codificatore estremamente lento con alcuni file. Evitare di +impostare la \fIPROFONDITÀ\fP oltre 1000 a meno che si sia preparati a +interrompere la compressione nel caso in cui richieda troppo tempo. +.RE +.IP "" +Quando si decomprime un flusso grezzo (\fB\-\-format=raw\fP), LZMA2 ha bisogno +solamente della \fIDIMENSIONE\fP del dizionario. LZMA1 ha anche bisogno di +\fIlc\fP, \fIlp\fP, e \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIOPZIONI\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIOPZIONI\fP] +.PD +Aggiunge un filtro branch/call/jump (BCJ) alla catena dei filtri. Questi +filtri non possono essere utilizzati come ultimo filtro nella catena di +filtri. +.IP "" +Un filtro BCJ converte gli indirizzi relativi in codice macchina nelle loro +controparti assolute. Questo non cambia la dimensione dei dati ma aumenta la +ridondanza, cosa che può aiutare LZMA2 a produrre \fB.xz\fP file 0\(en15\ % più +piccoli. I filtri BCJ sono sempre reversibili, quindi usare un filtro BCJ +per il tipo di dati sbagliato non causa perdita di dati, al massimo può +determinare un rapporto di compressione leggermente peggiore. I filtri BCJ +sono molto veloci e usano una quantità di memoria minima. +.IP "" +Questi filtri BCJ presentano problemi noti relativi al rapporto di +compressione: +.RS +.IP \(bu 3 +Alcuni tipi di file contenenti codice eseguibile (ad esempio, file oggetto, +librerie statiche e moduli del kernel Linux) hanno gli indirizzi nelle +istruzioni riempiti con valori di riempimento. Questi filtri BCJ eseguiranno +comunque la conversione degli indirizzi, il che peggiorerà la compressione +con questi file. +.IP \(bu 3 +Se un filtro BCJ viene applicato a un archivio, è possibile che renda il +rapporto di compressione peggiore rispetto a non usare un filtro BCJ. Ad +esempio, se ci sono eseguibili simili o addirittura identici, il filtraggio +probabilmente renderà i file meno simili e quindi la compressione sarà +peggiore. Anche il contenuto dei file non eseguibili nello stesso archivio +può essere importante. In pratica bisogna provare con e senza filtro BCJ per +vedere quale sia il migliore in ogni situazione. +.RE +.IP "" +Insiemi diversi di istruzioni hanno diversi allineamenti: il file eseguibile +deve essere allineato a un multiplo di questo valore nei dati di input per +far funzionare il filtro. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filtro;Allineamento;Note +x86;1;32\-bit o 64\-bit x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;L'allineamento migliore è a 4096 byte +PowerPC;4;Solo big\-endian +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Dal momento che i dati filtrati da BCJ solitamente sono compressi con LZMA2, +il rapporto di compressione può essere migliorato leggermente se le opzioni +LZMA2 sono impostate in modo che corrispondano all'allineamento del filtro +BCJ selezionato. Esempi: +.RS +.IP \(bu 3 +Il filtro IA\-64 ha un allineamento a 16 byte, quindi \fBpb=4,lp=4,lc=0\fP è una +buona scelta per LZMA2 (2^4=16). +.IP \(bu 3 +Il codice RISC\-V ha un allineamento a 2 o 4 byte a seconda che il file +contenga o meno istruzioni 16 bit compresse (cosiddetta estensione +C). Quando sono usate istruzioni a 16 bit, va bene \fBpb=2,lp=1,lc=3\fP o +\fBpb=1,lp=1,lc=3\fP. Quando le istruzioni a 16 bit non sono presenti, è meglio +\fBpb=2,lp=2,lc=2\fP. Si può usare \fBreadelf \-h\fP per controllare se "RVC" +appare sulla riga del "Flag". +.IP \(bu 3 +ARM64 è sempre allineato a 4 byte, quindi \fBpb=2,lp=2,lc=2\fP è la scelta +migliore. +.IP \(bu 3 +Il filtro x86 è un'eccezione. Di solito è bene attenersi alle impostazioni +predefinite di LZMA2 (\fBpb=2,lp=0,lc=3\fP) quando si comprimono gli eseguibili +x86. +.RE +.IP "" +Tutti i filtri BCJ supportano le stesse \fIOPZIONI\fP: +.RS +.TP +\fBstart=\fP\fIOFFSET\fP +Specifica l'\fIOFFSET\fP iniziale utilizzato per la conversione tra indirizzi +relativi e assoluti. L'\fIOFFSET\fP deve essere un multiplo dell'allineamento +del filtro (vedere la tabella sopra). Il valore predefinito è zero. In +pratica, l'impostazione predefinita è buona; specificare un \fIOFFSET\fP +personalizzato non è quasi mai utile. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIOPZIONI\fP] +Aggiunge un filtro Delta alla catena dei filtri. I filtri Delta non possono +essere utilizzati come ultimo filtro nella catena di filtri. +.IP "" +Al momento è supportato solo un semplice calcolo delta byte\-per\-byte. Può +essere utile quando si comprime, per esempio, immagini bitmap non compresse +o file audio PCM non compressi. Tuttavia, speciali algoritmi ad\-hoc +potrebbero dare risultati significativamente migliori che Delta + +LZMA2. Questo è vero specialmente per l'audio, che comprime più velocemente +e meglio, ad esempio, con \fBflac\fP(1). +.IP "" +\fIOPZIONI\fP supportate: +.RS +.TP +\fBdist=\fP\fIDISTANZA\fP +Specifica la \fIDISTANZA\fP del calcolo delta in byte. \fIDISTANZA\fP deve essere +nel range 1\(en256. Il valore predefinito è 1. +.IP "" +Per esempio, con \fBdist=2\fP e un input di 8 byte A1 B1 A2 B3 A3 B5 A4 B7, +l'output sarà A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Altre opzioni" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Sopprime avvertimenti e avvisi. Specificarlo due volte per eliminare anche +gli errori. Questa opzione non ha alcun effetto sullo stato di uscita. In +altre parole, anche se un avvertimento è stato eliminato, lo stato di uscita +che indica un avvertimento viene comunque utilizzato. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Sii prolisso. Se lo standard error è collegato a un terminale, \fBxz\fP +visualizzerà un indicatore di avanzamento. Specificando \fB\-\-verbose\fP due +volte si otterrà un output ancora più dettagliato. +.IP "" +L'indicatore di avanzamento mostra le seguenti informazioni: +.RS +.IP \(bu 3 +La percentuale di avanzamento è mostrata se la dimensione del file input è +nota. Quindi, la percentuale non può essere mostrata nei pipe. +.IP \(bu 3 +Quantità di dati compressi prodotti (in compressione) o utilizzati (in +decompressione). +.IP \(bu 3 +Quantità di dati non compressi consumati (in compressione) o prodotti (in +decompressione). +.IP \(bu 3 +Rapporto di compressione, calcolato dividendo la quantità di dati compressi +processati finora con la quantità di dati non compressi processati finora. +.IP \(bu 3 +Velocità di compressione o decompressione. Questa è misurata come la +quantità di dati non compressi consumati (in compressione) o prodotti (in +decompressione) al secondo. Viene mostrata dopo che è trascorso qualche +secondo da quando \fBxz\fP ha iniziato a processare il file. +.IP \(bu 3 +Tempo trascorso nel formato M:SS o H:MM:SS. +.IP \(bu 3 +Il tempo residuo stimato è mostrato solo quando la dimensione del file in +ingresso è nota e sono già passati un paio di secondi da quando \fBxz\fP ha +iniziato a processare il file. Il tempo è mostrato in un formato meno +preciso che non ha mai i due punti, ad esempio 2 min 30 s. +.RE +.IP "" +Quando lo standard error non è un terminale, \fB\-\-verbose\fP farà stampare a +\fBxz\fP il nome del file, la dimensione compressa, la dimensione non +compressa, il rapporto di compressione, e potendo anche la velocità e il +tempo trascorso, su una singola riga dello standard error, dopo aver +compresso o decompresso il file. La velocità e il tempo trascorso sono +inclusi solo se l'operazione è durata almeno un paio di secondi. Se +l'operazione non è conclusa, ad esempio a causa dell'interruzione da parte +dell'utente, viene stampata anche la percentuale di completamento, a patto +che la dimensione del file input sia nota. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Non impostare lo stato di uscita a 2 anche se è stata rilevata una +condizione che merita un avvertimento. Questa opzione non influisce sul +livello di dettaglio, quindi sia \fB\-\-quiet\fP che \fB\-\-no\-warn\fP devono essere +utilizzati per non visualizzare avvertimenti e per non alterare lo stato di +uscita. +.TP +\fB\-\-robot\fP +Stampa i messaggi in un formato analizzabile dal computer. Questo ha lo +scopo di facilitare la scrittura dei frontend che vogliono usare \fBxz\fP +invece di liblzma, che potrebbe essere il caso di vari script. Si intende +che con questa opzione abilitata l'output dovrebbe rimanere stabile tra le +versioni di \fBxz\fP. Per ulteriori informazioni, vedere la sezione \fBMODALITÀ ROBOT\fP. +.TP +\fB\-\-info\-memory\fP +Mostra, in un formato leggibile da umani, quanta memoria fisica (RAM) e +quante thread \fBxz\fP pensa che il sistema abbia e i limiti di utilizzo di +memoria per la compressione e la decompressione, quindi termina con +successo. +.TP +\fB\-h\fP, \fB\-\-help\fP +Mostra un messaggio di aiuto che descrive le opzioni usate più comunemente, +e termina con successo. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Mostra un messaggio di aiuto che descrive tutte le funzionalità di \fBxz\fP, e +termina con successo +.TP +\fB\-V\fP, \fB\-\-version\fP +Mostra il numero di versione di \fBxz\fP e liblzma in un formato leggibile +dagli umani. Per ottenere un output analizzabile da una macchina specificare +\fB\-\-robot\fP prima di \fB\-\-version\fP. +. +.SH "MODALITÀ ROBOT" +La "modalità robot" viene attivata con l'opzione \fB\-\-robot\fP. Rende l'output +di \fBxz\fP più facile da analizzare da altri programmi. Attualmente \fB\-\-robot\fP +è supportato solo insieme a \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP e +\fB\-\-version\fP. In futuro sarà supportato per la compressione e la +decompressione. +. +.SS "Modalità stampa" +\fBxz \-\-robot \-\-list\fP usa un output separato da tabulazione. La prima colonna +di ogni riga contiene una stringa che indica il tipo di informazione +contenuta in quella riga: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Questa è sempre la prima riga quando si inizia a elencare un file. La +seconda colonna della riga è il nome del file. +.TP +\fBfile\fP +Questa riga contiene informazioni generali sul file \fB.xz\fP. Questa riga +viene sempre stampata dopo la riga \fBname\fP. +.TP +\fBstream\fP +Questo tipo di riga viene utilizzato solo quando è stato specificato +\fB\-\-verbose\fP. Sono presenti tante righe \fBstream\fP quanti sono i flussi nel +file \fB.xz\fP. +.TP +\fBblock\fP +Questo tipo di riga viene utilizzato solo quando è stato specificato +\fB\-\-verbose\fP. Ci sono tante righe \fBblock\fP quanti sono i blocchi nel file +\&\fB.xz\fP. Le righe \fBblock\fP vengono visualizzate dopo tutte le righe +\fBstream\fP; i diversi tipi di riga non vengono interlacciati. +.TP +\fBsummary\fP +Questo tipo di riga viene utilizzato solo quando \fB\-\-verbose\fP è stato +specificato due volte. Questa riga viene stampata dopo tutte le righe +\fBblock\fP. Come la riga \fBfile\fP, la riga \fBsummary\fP contiene informazioni +generali sul file \fB.xz\fP. +.TP +\fBtotals\fP +Questa riga è sempre l'ultima riga dell'output dell'elenco. Mostra i +conteggi totali e le dimensioni. +.PP +Le colonne delle righe \fBfile\fP: +.PD 0 +.RS +.IP 2. 4 +Numero di flussi nel file +.IP 3. 4 +Numero totale di blocchi nel flusso/i. +.IP 4. 4 +Dimensione compressa del file +.IP 5. 4 +Dimensione non compressa del file +.IP 6. 4 +Rapporto di compressione, es. \fB0.123\fP. Se il rapporto è oltre 9999, al +posto del rapporto vengono mostrati tre trattini (\fB\-\-\-\fP). +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Elenco separato da virgole dei nomi dei controlli di integrità. Le stringhe +seguenti vengono utilizzate per i tipi di controllo conosciuti: \fBNone\fP, +\fBCRC32\fP, \fBCRC64\fP, e \fBSHA\-256\fP. Per i tipi di controllo non conosciuti +viene utilizzato \fBUnknown\-\fP\fIN\fP, dove \fIN\fP è l'ID del controllo come numero +decimale (una o due cifre). +.IP 8. 4 +Dimensione totale del padding del flusso nel file +.RE +.PD +.PP +Le colonne delle righe \fBstream\fP: +.PD 0 +.RS +.IP 2. 4 +Numero di flusso (il primo è 1) +.IP 3. 4 +Numero di blocchi nel flusso +.IP 4. 4 +Offset iniziale compressione +.IP 5. 4 +Offset iniziale decompressione +.IP 6. 4 +Dimensione compressa (non include il padding del flusso) +.IP 7. 4 +Dimensione non compressa +.IP 8. 4 +Rapporto di compressione +.IP 9. 4 +Nome del controllo di integrità +.IP 10. 4 +Dimensione del padding del flusso +.RE +.PD +.PP +Le colonne delle righe \fBblock\fP: +.PD 0 +.RS +.IP 2. 4 +Numero di flussi che contengono questo blocco +.IP 3. 4 +Numero del blocco relativo all'inizio del flusso (il primo blocco è 1) +.IP 4. 4 +Numero del blocco relativo all'inizio del file +.IP 5. 4 +Offset iniziale compressione relativo all'inizio del file +.IP 6. 4 +Offset iniziale decompressione relativo all'inizio del file +.IP 7. 4 +Dimensione totale compressa del blocco (incluse le intestazioni) +.IP 8. 4 +Dimensione non compressa +.IP 9. 4 +Rapporto di compressione +.IP 10. 4 +Nome del controllo di integrità +.RE +.PD +.PP +Se \fB\-\-verbose\fP viene specificato due volte, sono incluse colonne aggiuntive +nelle righe \fBblock\fP. Queste non sono mostrate con un \fB\-\-verbose\fP singolo, +perché recuperare queste informazioni richiede molte ricerche e quindi può +essere lento: +.PD 0 +.RS +.IP 11. 4 +Valore del controllo di integrità in formato esadecimale +.IP 12. 4 +Dimensione intestazione blocco +.IP 13. 4 +Flag del blocco: \fBc\fPindica che è presente la dimensione compressa, \fBu\fP +indica che è presente la dimensione non compressa. Se il flag non è +impostato, viene mostrato un trattino (\fB\-\fP) per mantenere fissa la +lunghezza della stringa. Nuovi flag potrebbero essere aggiunti alla fine +della stringa in futuro. +.IP 14. 4 +Dimensione dei dati compressi effettivi nel blocco (sono esclusi +l'intestazione del blocco, il padding del blocco e i campi di controllo) +.IP 15. 4 +Quantità di memoria (in byte) necessaria per decomprimere questo blocco con +questa versione \fBxz\fP +.IP 16. 4 +Catena di filtri. Si noti che la maggior parte delle opzioni utilizzate al +momento della compressione non è nota, perché solo le opzioni necessarie per +la decompressione sono memorizzate nelle intestazioni \fB.xz\fP. +.RE +.PD +.PP +Le colonne delle righe \fBsummary\fP: +.PD 0 +.RS +.IP 2. 4 +Quantità di memoria (in byte) necessaria per decomprimere questo file con +questa versione \fBxz\fP +.IP 3. 4 +\fByes\fP o \fBno\fP indica se tutte le intestazioni di blocco contengono +all'interno sia dimensioni compresse che dimensioni non compresse +.PP +\fIA partire da\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Versione minima di \fBxz\fP richiesta per decomprimere il file +.RE +.PD +.PP +Le colonne delle righe \fBtotali\fP: +.PD 0 +.RS +.IP 2. 4 +Numero di flussi +.IP 3. 4 +Numero di blocchi +.IP 4. 4 +Dimensione compressa +.IP 5. 4 +Dimensione non compressa +.IP 6. 4 +Rapporto di compressione medio +.IP 7. 4 +Elenco separato da virgole dei nomi dei controlli di integrità presenti nei +file +.IP 8. 4 +Dimensione del padding dello stream +.IP 9. 4 +Numero di file. Questo serve a mantenere l'ordine delle colonne precedenti +uguale a quello delle righe del \fBfile\fP. +.PD +.RE +.PP +Se \fB\-\-verbose\fP viene specificato due volte, sono incluse colonne aggiuntive +nella riga \fBtotali\fP: +.PD 0 +.RS +.IP 10. 4 +Quantità massima di memoria (in byte) necessaria per decomprimere i file con +questa versione \fBxz\fP +.IP 11. 4 +\fByes\fP o \fBno\fP indica se tutte le intestazioni di blocco contengono +all'interno sia dimensioni compresse che dimensioni non compresse +.PP +\fIA partire da\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Versione minima di \fBxz\fP richiesta per decomprimere il file +.RE +.PD +.PP +Versioni future potrebbero aggiungere nuovi tipi di riga e nuove colonne +possono essere aggiunte ai tipi di riga esistenti, ma le colonne esistenti +non verranno modificate. +. +.SS "Aiuto sui filtri" +\fBxz \-\-robot \-\-filters\-help\fP stampa i filtri supportati nel seguente +formato: +.PP +\fIFILTRO\fP\fB:\fP\fIOPZIONE\fP\fB=<\fP\fIVALORE\fP\fB>,\fP\fIOPZIONE\fP\fB=<\fP\fIVALORE\fP\fB>\fP... +.TP +\fIFILTRO\fP +Nome del filtro +.TP +\fIOPZIONE\fP +Nome di un'opzione specifica del filtro +.TP +\fIVALORE\fP +Gli intervalli del \fIVALORE\fP numerico appaiono come +\fB<\fP\fIMIN\fP\fB\-\fP\fIMAX\fP\fB>\fP. Le scelte per i \fIVALORI\fP stringa sono +mostrati in \fB< >\fP e separati dal carattere \fB|\fP. +.PP +Ogni filtro è mostrato su una riga dedicata. +. +.SS "Informazione limite memoria" +\fBxz \-\-robot \-\-info\-memory\fP stampa una singola riga con più colonne separate +da tabulazione: +.IP 1. 4 +Quantità totale di memoria fisica (RAM) in byte. +.IP 2. 4 +Limite utilizzo memoria per la compressione in byte +(\fB\-\-memlimit\-compress\fP). Il valore speciale \fB0\fP indica l'impostazione +predefinita, che in modalità thread singola equivale a nessun limite. +.IP 3. 4 +Limite utilizzo memoria per la decompressione in byte +(\fB\-\-memlimit\-decompress\fP). Il valore speciale \fB0\fP indica l'impostazione +predefinita, che in modalità thread singola equivale a nessun limite. +.IP 4. 4 +A partire da \fBxz\fP 5.3.4alpha: Utilizzo della memoria per la decompressione +a thread multiple in byte (\fB\-\-memlimit\-mt\-decompress\fP). Questo valore non è +mai zero perché viene utilizzato un valore predefinito specifico del sistema +mostrato nella colonna 5, se non è stato specificato alcun limite in modo +esplicito. Inoltre, non è mai maggiore del valore nella colonna 3, anche se +è stato specificato un valore maggiore con \fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +A partire da \fBxz\fP 5.3.4alpha: un limite di utilizzo della memoria +predefinito specifico del sistema, che viene utilizzato per limitare il +numero di thread durante la compressione con un numero automatico di thread +(\fB\-\-threads=0\fP) e non è stato specificato alcun limite di utilizzo della +memoria (\fB\-\-memlimit\-compress\fP). Questo viene utilizzato anche come valore +predefinito per \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +A partire da \fBxz\fP 5.3.4alpha: Numero di thread del processore disponibili. +.PP +In futuro, l'output di \fBxz \-\-robot \-\-info\-memory\fP potrebbe avere più +colonne, ma mai più di una singola riga. +. +.SS Versione +\fBxz \-\-robot \-\-version\fP stampa il numero di versione di \fBxz\fP e liblzma nel +seguente formato: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Versione major. +.TP +\fIYYY\fP +Versione minor. I numeri pari sono stabili. I numeri dispari sono versioni +alfa o beta. +.TP +\fIZZZ\fP +Livello di patch per le versioni stabili o solo un contatore per le versioni +di sviluppo. +.TP +\fIS\fP +Stabilità. 0 è alfa, 1 è beta e 2 è stabile. \fIS\fP dovrebbe essere sempre 2 +quando \fIYYY\fP è pari. +.PP +\fIXYYYZZZS\fP sono uguali su entrambe le righe se \fBxz\fP e liblzma appartengono +allo stesso rilascio delle XZ Utils. +.PP +Esempi: 4.999.9beta è \fB49990091\fP e 5.0.0 è \fB50000002\fP. +. +.SH "CODICE DI USCITA" +.TP +\fB0\fP +Tutto bene. +.TP +\fB1\fP +È avvenuto un errore. +.TP +\fB2\fP +Si è verificato qualcosa che merita un avvertimento, ma non si sono +verificati errori effettivi. +.PP +Gli avvisi (non gli avvertimenti o gli errori) stampati sullo standard error +non influiscono sullo stato di uscita. +. +.SH AMBIENTE +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP analizza elenchi di opzioni separate da spazi dalle variabili +d'ambiente \fBXZ_DEFAULTS\fP e \fBXZ_OPT\fP, in questo ordine, analizzando prima +le opzioni dalla riga di comando. Si noti che solo le opzioni vengono +analizzate dalle variabili d'ambiente; tutte le non\-opzioni vengono ignorate +silenziosamente. L'analisi viene eseguita con \fBgetopt_long\fP(3) che viene +utilizzato anche per gli argomenti della riga di comando. +.PP +\fBAttenzione:\fP Impostando queste variabili di ambiente, si sta di fatto +modificando programmi e script che lanciano \fBxz\fP. La maggior parte delle +volte va bene impostare i limiti di utilizzo della memoria, il numero di +thread e le opzioni di compressione tramite variabili d'ambiente. Tuttavia, +alcune opzioni possono rompere degli script. Un esempio banale è \fB\-\-help\fP +che forza \fBxz\fP a mostrare la pagina di aiuto anziché comprimere o +decomprimere file. Esempi meno ovvi sono \fB\-\-quiet\fP e \fB\-\-verbose\fP. In +molti casi funziona bene abilitare l'indicatore di avanzamento usando +\fB\-\-verbose\fP, ma in alcune situazioni i messaggi extra creano problemi. Il +livello di prolissità influisce anche sul comportamento di \fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Opzioni predefinite specifiche dell'utente o a livello di sistema. In genere +questo viene impostato in uno script di inizializzazione della shell per +abilitare il valore predefinito del limitatore di utilizzo della memoria di +\fBxz\fP, o per impostare il numero di thread predefinito. Escludendo gli +script di inizializzazione della shell e analoghi casi particolari, gli +script non dovrebbero mai impostare o annullare l'impostazione di +\fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Questo serve per passare le opzioni a \fBxz\fP quando non sia possibile +impostare le opzioni direttamente sulla riga di comando di \fBxz\fP. Questo è +il caso quando \fBxz\fP viene eseguito da uno script o da uno strumento, ad +esempio GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Gli script possono usare \fBXZ_OPT\fP, per esempio, per impostare opzioni di +compressione predefinite specifiche per lo script. Si raccomanda comunque di +permettere agli utenti di sovrascrivere \fBXZ_OPT\fPse questo è ragionevole. Ad +esempio, negli script \fBsh\fP(1) si può usare qualcosa come questo: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "COMPATIBILITÀ LZMA UTILS" +La sintassi della riga di comando di \fBxz\fP è essenzialmente un sopra\-insieme +di \fBlzma\fP, \fBunlzma\fP, e \fBlzcat\fP come trovati nelle LZMA Utils +4.32.x. Nella maggior parte dei casi è possibili sostituire le LZMA Utils +con le XZ Utils senza rompere gli script esistenti. Ci sono però alcune +incompatibilità, che in alcuni casi potrebbero causare problemi. +. +.SS "Livelli di compressione preimpostati" +La numerazione dei livelli di compressione preimpostati non è identica in +\fBxz\fP e nelle LZMA Utils. La differenza più importante è il modo in cui le +dimensioni del dizionario vengono mappate sulle diverse preimpostazioni. La +dimensione del dizionario è approssimativamente uguale all'utilizzo della +memoria del decompressore. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Livello;xz;LZMA Utils +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Le differenze di dimensione del dizionario influiscono anche sull'utilizzo +della memoria del compressore, ma ci sono alcune altre differenze tra le +LZMA Utils e le XZ Utils, che rendono la differenza ancora più grande: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Livello;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Il livello preimpostato predefinito nelle LZMA Utils è \fB\-7\fP mentre nelle XZ +Utils è \fB\-6\fP, quindi entrambi utilizzano un dizionario da 8 MiB per +impostazione predefinita. +. +.SS "File .lzma con flussi vs. senza flussi" +La dimensione non compressa del file può essere memorizzata +nell'intestazione \fB.lzma\fP. Le LZMA Utils lo fanno durante la compressione +di file regolari. L'alternativa consiste nel memorizzare che la dimensione +non compressa è sconosciuta e utilizzare l'indicatore di fine carico utile +per indicare il punto in cui il decompressore deve fermarsi. Le LZMA Utils +utilizzano questo metodo quando le dimensioni non compresse non sono note, +come nel caso, ad esempio, delle pipe. +.PP +\fBxz\fP supporta la decompressione di file \fB.lzma\fP con o senza il marcatore +di fine payload, ma tutti i file \fB.lzma\fP creati da \fBxz\fP utilizzeranno il +marcatore di fine payload e avranno dimensioni non compresse contrassegnate +come sconosciute nell'intestazione \fB.lzma\fP. Questo può essere un problema +in alcune situazioni non comuni. Ad esempio, un decompressore \fB.lzma\fP in un +dispositivo embedded potrebbe funzionare solo con file con dimensioni non +compresse note. Se si incorre in questo problema, occorre utilizzare le LZMA +Utils oppure l'LZMA SDK per creare dei file \fB.lzma\fP con dimensioni non +compresse note. +. +.SS "File .lzma non supportati" +Il formato \fB.lzma\fP permette valori \fIlc\fP fino a 8, e valori \fIlp\fP fino a +4. Le LZMA Utils possono decomprimere file con qualunque \fIlc\fP e \fIlp\fP, ma +creeranno sempre file con \fBlc=3\fP e \fBlp=0\fP. Creare file con altri \fIlc\fP e +\fIlp\fP è possibile con \fBxz\fP e con l'LZMA SDK. +.PP +L'implementazione del filtro LZMA1 in liblzma richiede che la somma di \fIlc\fP +e \fIlp\fP non debba superare 4. Pertanto, i file \fB.lzma\fP che superano questa +limitazione non possono essere decompressi con \fBxz\fP. +.PP +Le LZMA Utils creano solo file \fB.lzma\fP con dimensione del dizionario 2^\fIn\fP +(una potenza di 2) ma accettano file con qualsiasi dimensione di +dizionario. liblzma accetta solo file \fB.lzma\fP con dimensione del dizionario +2^\fIn\fP o 2^\fIn\fP + 2^(\fIn\fP\-1). Questo serve a limitare i falsi positivi +quando si cerca di identificare i file \fB.lzma\fP. +.PP +All'atto pratico queste limitazioni non dovrebbero essere un problema, +perché praticamente tutti i file \fB.lzma\fP sono stati compressi con +impostazioni che liblzma accetterà. +. +.SS "Dati sporchi finali" +Quando si decomprime, le LZMA Utils ignorano automaticamente tutto quello +che c'è dopo il primo flusso \fB.lzma\fP. Nella maggior parte delle situazioni +questo è un baco. Questo significa anche che le LZMA Utils non supportano la +decompressione di file \fB.lzma\fP concatenati. +.PP +Se sono rimasti dati dopo il primo flusso \fB.lzma\fP, \fBxz\fP considera il file +corrotto a meno che sia stato utilizzato \fB\-\-single\-stream\fP. Questo può far +rompere script incomprensibili che hanno assunto che i dati sporchi finali +vengano ignorati. +. +.SH NOTE +. +.SS "L'output compresso può variare" +L'esatto output compresso prodotto dallo stesso file di input non compresso +può variare tra le versioni delle XZ Utils, anche se le opzioni di +compressione sono le stesse. Questo perché il codificatore può essere stato +migliorato (compressione più veloce o migliore) senza influire sul formato +del file. L'output può variare anche tra diverse build della stessa versione +delle XZ Utils, se vengono utilizzate opzioni di build differenti. +.PP +Quanto sopra significa che una volta che \fB\-\-rsyncable\fP è stato +implementato, i file risultanti non saranno necessariamente rsync\-abili a +meno che sia i vecchi che i nuovi file non siano stati compressi con la +stessa versione di xz. Questo problema può essere risolto se una parte +dell'implementazione del codificatore viene congelata per mantenere stabile +l'output rsync\-abile tra le versioni di xz. +. +.SS "Abilita i decompressori .xz" +Le implementazioni dei decompressori \fB.xz\fP embedded, come XZ Embedded, non +necessariamente supportano file creati con tipi di integrità \fICONTROLLO\fP +diversi da \fBnone\fP e \fBcrc32\fP. Dal momento che il valore predefinito è +\fB\-\-check=crc64\fP, occorre specificare \fB\-\-check=none\fP o \fB\-\-check=crc32\fP +quando si creano file per sistemi embedded. +.PP +Al di fuori dei sistemi embedded, tutti i decompressori in formato \fB.xz\fP +supportano tutti i tipi di \fICONTROLLO\fP, o almeno sono in grado di +decomprimere il file senza verificare il controllo di integrità se il +particolare \fICONTROLLO\fP non è supportato. +.PP +XZ Embedded supporta i filtri BCJ, ma solo con offset iniziale predefinito. +. +.SH ESEMPI +. +.SS "Informazioni di base" +Comprime il file \fIfoo\fP in \fIfoo.xz\fP utilizzando il livello di compressione +predefinito (\fB\-6\fP) e rimuove \fIfoo\fP se la compressione ha esito positivo: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Decomprime \fIbar.xz\fP in \fIbar\fP e non rimuove \fIbar.xz\fP anche se la +decompressione ha successo: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Crea \fIbaz.tar.xz\fP con il preset \fB\-4e\fP (\fB\-4 \-\-extreme\fP), che è più lenta +della predefinita \fB\-6\fP, ma ha bisogno di meno memoria per la compressione e +decompressione (48\ MiB e 5\ MiB, rispettivamente): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Una combinazione di file compressi e non compressi può essere decompressa +sullo output standard con un singolo comando: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Compressione parallela di più file" +Su GNU e *BSD, \fBfind\fP(1) e \fBxargs\fP(1) possono essere usati per +parallelizzare la compressione di più file: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +L'opzione \fB\-p\fP di \fBxargs\fP(1) imposta il numero di processi \fBxz\fP +paralleli. Il valore migliore per l'opzione \fB\-n\fP dipende dal numero di file +da comprimere. Se sono presenti solo un paio di file, il valore dovrebbe +probabilmente essere 1; con decine di migliaia di file, 100 o anche di più +può essere appropriato per ridurre il numero di processi \fBxz\fP che +\fBxargs\fP(1) alla fine creerà. +.PP +L'opzione \fB\-T1\fP per \fBxz\fP serve a forzare la modalità a thread singola, +perché \fBxargs\fP (1) viene utilizzato per controllare la quantità di +parallelizzazione. +. +.SS "Modalità robot" +Calcola quanti byte sono stati salvati in totale dopo la compressione di più +file: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Uno script potrebbe voler sapere se si sta utilizzando una versione di \fBxz\fP +sufficientemente recente. Il seguente script \fBsh\fP(1) controlla che il +numero di versione dello strumento \fBxz\fP sia almeno 5.0.0. Questo metodo è +compatibile con le vecchie versioni beta, che non supportavano l'opzione +\fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Imposta un limite di utilizzo della memoria per la decompressione +utilizzando \fBXZ_OPT\fP, ma se è già stato impostato un limite, non lo +aumenta: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Catene di filtri di compressione personalizzate" +L'uso più semplice delle catene di filtri personalizzate è la +personalizzazione di un preset di LZMA2. Questo può essere utile, perché i +preset coprono solamente un sottoinsieme di tutte le combinazioni di +impostazioni di compressione potenzialmente utili. +.PP +Le colonne CompCPU delle tabelle dalle descrizioni delle opzioni \fB\-0\fP +\&... \fB\-9\fP e \fB\-\-extreme\fP sono utili quando si personalizzano i preset di +LZMA2. Di seguito sono riportate le parti rilevanti raccolte da queste due +tabelle: +.RS +.PP +.TS +tab(;); +c c +n n. +Livello preimpostato;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Se si sa che un file richiede un dizionario piuttosto grande (ad esempio, +32\ MiB) per essere compresso bene, ma si desidera comprimerlo più +velocemente di quanto farebbe \fBxz \-8\fP, è possibile modificare un preset con +un basso valore CompCPU (ad esempio, 1) per utilizzare un dizionario più +grande: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Con alcuni file, il comando sopra potrebbe essere più veloce di \fBxz \-6\fP e +la compressione significativamente migliore. Tuttavia, si deve sottolineare +che solo alcuni file traggono beneficio da un dizionario grande e mantengono +basso il valore di CompCPU. La situazione più ovvia in cui un dizionario +grande può aiutare molto è un archivio contenente file molto simili di +almeno un paio di megabyte ciascuno. La dimensione del dizionario deve +essere significativamente più grande di ogni singolo file per permettere a +LZMA2 di trarre pieno vantaggio dalle somiglianze tra file consecutivi. +.PP +Se l'utilizzo molto elevato della memoria del compressore e del +decompressore è accettabile, e il file da comprimere è almeno di diverse +centinaia di megabyte, potrebbe essere utile utilizzare un dizionario ancora +più grande dei 64 MiB che \fBxz \-9\fP utilizzerebbe: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +L'uso di \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) come nell'esempio precedente può +essere utile per vedere i requisiti di memoria del compressore e del +decompressore. Tenere presente che l'utilizzo di un dizionario più grande +della dimensione del file non compresso è uno spreco di memoria, quindi il +comando precedente non è utile per i file di piccole dimensioni. +.PP +A volte il tempo di compressione non importa, ma l'utilizzo di memoria del +decompressore deve essere tenuta bassa, per esempio, per permettere di +decomprimere il file in un sistema embedded. Il comando seguente usa \fB\-6e\fP +(\fB\-6 \-\-extreme\fP) come base e imposta il dizionario a soli 64\ KiB. Il file +risultante può essere decompresso con XZ Embedded (ecco perché c'è +\fB\-\-check=crc32\fP) usando circa 100\ KiB di memoria. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Se si desidera spremere il maggior numero possibile di byte, a volte può +essere utile regolare il numero di bit di contesto letterale (\fIlc\fP) e il +numero di bit di posizione (\fIpb\fP). Anche la regolazione del numero di bit +di posizione letterale (\fIlp\fP) potrebbe essere d'aiuto, ma di solito \fIlc\fP e +\fIpb\fP sono più importanti. Per esempio, un archivio di codici sorgente +contiene principalmente testo US\-ASCII, quindi qualcosa come il seguente +potrebbe produrre un file leggermente (0,1\ %) più piccolo di \fBxz \-6e\fP +(provare anche senza \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Usare un altro filtro insieme a LZMA2 può migliorare la compressione per +alcuni tipi di file. Ad esempio, per comprimere una libreria condivisa +x86\-32 o x86\-64 usare il filtro BCJ: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Si noti che l'ordine delle opzioni di filtro è significativo. Se viene +specificato \fB\-\-x86\fP dopo \fB\-\-lzma2\fP, \fBxz\fP darà un errore, perché non può +esserci alcun filtro dopo LZMA2 e anche perché il filtro BCJ x86 non può +essere utilizzato come ultimo filtro della catena. +.PP +Il filtro Delta insieme con LZMA2 può dare buoni risultati sulle immagini +bitmap. Di solito dovrebbe battere il PNG, il quale ha alcuni filtri più +avanzati rispetto al semplice delta ma utilizza Deflate per la compressione +effettiva. +.PP +L'immagine deve essere salvata in un formato non compresso, ad esempio un +TIFF non compresso. Il parametro distanza del filtro Delta è impostato in +modo che corrisponda al numero di byte per pixel nell'immagine. Per esempio, +un bitmap a 24 bit richiede \fBdist=3\fP, e va anche bene passare \fBpb=0\fP a +LZMA2 per adattarsi all'allineamento a tre byte: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Se più immagini sono state inserite in un singolo archivio (ad esempio, +\&\fB.tar\fP), il filtro Delta funzionerà anche su questo purché tutte le +immagini abbiano lo stesso numero di byte per pixel. +. +.SH "VEDERE ANCHE" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/unxz.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/unxz.1 new file mode 100644 index 0000000000000000000000000000000000000000..53a915947bff84fc5f9cfbb4d4ed88097620e055 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/unxz.1 @@ -0,0 +1,2080 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Italian translations for xz-man package +.\" Luca Vercelli , 2024-2025 +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 08/03/2025 Tukaani "XZ Utils" +. +.SH NOME +xz, unxz, xzcat, lzma, unlzma, lzcat \- Comprime o decomprime file .xz e +\&.lzma +. +.SH SINOSSI +\fBxz\fP [\fIOPZIONE...\fP] [\fIFILE...\fP] +. +.SH "ALIAS DEI COMANDI" +\fBunxz\fP è equivalente a \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP è equivalente a \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP è equivalente a \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP è equivalente a \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP è equivalente a \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Quando si scrivono script che richiedono di decomprimere file, si raccomanda +di utilizzare sempre il comando \fBxz\fP con argomenti appropriati (\fBxz \-d\fP o +\fBxz \-dc\fP) al posto degli alias \fBunxz\fP e \fBxzcat\fP. +. +.SH DESCRIZIONE +\fBxz\fP è uno strumento di compressione dati generico con sintassi della riga +di comando simile a \fBgzip\fP(1) e \fBbzip2\fP(1). Il formato file nativo è +\&\fB.xz\fP, ma sono supportati anche il formato tradizionale \fB.lzma\fP usato +dalle LZMA Utils e i flussi grezzi (raw) compressi senza intestazioni di +formato contenitore. In più, è supportata la decompressione del formato +\&\fB.lz\fPusato da \fBlzip\fP. +.PP +\fBxz\fP comprime o decomprime ogni \fIFILE\fP a seconda della modalità di +funzionamento selezionata. Se nessun \fIFILE\fP è indicato o se \fIFILE\fP è \fB\-\fP, +\fBxz\fP legge dallo standard input e scrive i dati processati sullo standard +output. \fBxz\fP si rifiuterà (stamperà un errore e salterà il \fIFILE\fP) di +scrivere dati compressi sullo standard output se è il +terminale. Analogamente, \fBxz\fP si rifiuterà di leggere dati compressi dallo +standard input se è il terminale. +.PP +A meno che non sia specificato \fB\-\-stdout\fP, i \fIFILE\fP diversi da \fB\-\fP +vengono scritti in un nuovo file il cui nome deriva dal nome del \fIFILE\fP +sorgente: +.IP \(bu 3 +Quando si comprime, il suffisso del file destinazione (\fB.xz\fP or \fB.lzma\fP) +viene accodato al nome del file sorgente per ottenere il nome del file +destinazione. +.IP \(bu 3 +Quando si decomprime, i suffissi \fB.xz\fP, \fB.lzma\fP, o \fB.lz\fP vengono rimossi +dal nome del file per ottenere il nome del file destinazione. \fBxz\fP +riconosce anche i suffissi \fB.txz\fP e \fB.tlz\fP, e li sostituisce con il +suffisso \fB.tar\fP. +.PP +Se il file di destinazione esiste già, viene visualizzato un errore e +\fIFILE\fP viene saltato. +.PP +A meno che non si scriva nello standard output, \fBxz\fP visualizzerà un +avvertimento e salterà il \fIFILE\fP se si verifica una delle seguenti +condizioni: +.IP \(bu 3 +\fIFILE\fP non è un file regolare. I collegamenti simbolici non vengono +seguiti, quindi non sono considerati file regolari. +.IP \(bu 3 +\fIFILE\fP ha più di un collegamento "hard". +.IP \(bu 3 +\fIFILE\fP ha impostati i bit setuid, setgid, o sticky. +.IP \(bu 3 +La modalità di funzionamento è impostata sulla compressione e il \fIFILE\fP ha +già un suffisso del formato di file di destinazione (\fB.xz\fP o \fB.txz\fP quando +si comprime nel formato \fB.xz\fP e \fB.lzma\fP o \fB.tlz\fP quando si comprime nel +formato \fB.lzma\fP). +.IP \(bu 3 +La modalità di funzionamento è impostata sulla decompressione e il \fIFILE\fP +non ha un suffisso di nessuno dei formati di file supportati (\fB.xz\fP, +\&\fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, o \fB.lz\fP). +.PP +Dopo aver compresso o decompresso correttamente il \fIFILE\fP, \fBxz\fP copia il +proprietario, il gruppo, le autorizzazioni, l'ora di accesso e l'ora di +modifica dal \fIFILE\fP di origine al file di destinazione. Se la copia del +gruppo fallisce, le autorizzazioni vengono modificate in modo che il file di +destinazione non diventi accessibile agli utenti che non disponevano +dell'autorizzazione per accedere al \fIFILE\fP di origine. \fBxz\fP non supporta +ancora la copia di altri metadati, ad esempio elenchi di controllo degli +accessi o attributi estesi. +.PP +Una volta che il file di destinazione è stato chiuso con successo, il +\fIFILE\fP sorgente viene rimosso, a meno che sia stato specificato +\fB\-\-keep\fP. Il \fIFILE\fP sorgente non viene mai rimosso se l'output è scritto +sullo standard output, né se si verifica un errore. +.PP +L'invio di \fBSIGINFO\fP o \fBSIGUSR1\fP al processo \fBxz\fP comporta la stampa +delle informazioni sullo stato di avanzamento sullo standard error. Questo +ha solo un uso limitato poiché quando lo standard error è un terminale, +utilizzando \fB\-\-verbose\fP verrà visualizzato un indicatore di avanzamento che +si aggiorna automaticamente. +. +.SS "Utilizzo memoria" +L'utilizzo della memoria di \fBxz\fP varia da poche centinaia di kilobyte a +diversi gigabyte a seconda delle impostazioni di compressione. Le +impostazioni utilizzate durante la compressione di un file determinano i +requisiti di memoria del decompressore. In genere il decompressore richiede +dal 5\% al 20\% della quantità di memoria necessaria al compressore durante +la creazione del file. Ad esempio, la decompressione di un file creato con +\fBxz \-9\fP al momento richiede 65\ MiB di memoria. Ancora, è possibile avere +file \fB.xz\fP che richiedono diversi gigabyte di memoria per la +decompressione. +.PP +Soprattutto gli utenti di sistemi più vecchi possono trovare fastidiosa +l'eventualità di un utilizzo molto elevato di memoria. Per evitare +spiacevoli sorprese, \fBxz\fP dispone di un limitatore di utilizzo della +memoria incorporato, che è disabilitato per impostazione predefinita. Anche +se alcuni sistemi operativi forniscono modi per limitare l'utilizzo della +memoria dei processi, fare affidamento su questi non è stato ritenuto +sufficientemente flessibile (ad esempio, l'uso di \fBulimit\fP(1) per limitare +la memoria virtuale tende a paralizzare \fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Il limitatore di utilizzo della memoria può essere abilitato con l'opzione +della riga di comando \fB\-\-memlimit=\fP\fILIMITE\fP. Spesso è più conveniente +abilitare il limitatore per impostazione predefinita impostando la variabile +d'ambiente \fBXZ_DEFAULTS\fP, ad esempio, \fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. È +possibile impostare separatamente i limiti per la compressione e la +decompressione utilizzando \fB\-\-memlimit\-compress=\fP\fILIMITE\fP and +\fB\-\-memlimit\-decompress=\fP\fILIMITE\fP. L'uso di queste due opzioni al di fuori +di \fBXZ_DEFAULTS\fP è raramente utile perché una singola esecuzione di \fBxz\fP +non può eseguire sia la compressione che la decompressione e +\fB\-\-memlimit=\fP\fILIMITE\fP (or \fB\-M\fP \fILIMITE\fP) è più breve da digitare sulla +riga di comando. +.PP +Se il limite di utilizzo della memoria specificato viene superato durante la +decompressione, \fBxz\fP visualizzerà un errore e la decompressione del file +fallirà. Se il limite viene superato durante la compressione, \fBxz\fP tenterà +di ridimensionare le impostazioni in modo che il limite non venga più +superato (tranne quando si usa \fB\-\-format=raw\fP o \fB\-\-no\-adjust\fP). In questo +modo l'operazione non fallirà a meno che il limite sia molto basso. Il +ridimensionamento delle impostazioni viene eseguito in piccole differenze +che non corrispondono ai livelli di compressione preimpostati, ad esempio, +se il limite è solo leggermente inferiore alla quantità richiesta per \fBxz \-9\fP, le impostazioni saranno ridimensionate solo un poco, non proprio fino a +\fBxz \-8\fP. +. +.SS "Concatenazione e padding con file .xz" +È possibile concatenare i file \fB.xz\fP così come sono. \fBxz\fP decomprimerà +tali file come se fossero un singolo file \fB.xz\fP. +.PP +È possibile inserire un padding tra le parti concatenate o dopo l'ultima +parte. Il padding deve essere costituito da byte "null" e la dimensione del +padding deve essere un multiplo di quattro byte. Questo può essere utile, ad +esempio, se il file \fB.xz\fP è memorizzato su un supporto che misura le +dimensioni dei file in blocchi di 512 byte. +.PP +Concatenazione e padding non sono permessi con file \fB.lzma\fP o con flussi +grezzi. +. +.SH OPZIONI +. +.SS "Suffissi interi e valori speciali" +Nella maggior parte dei casi in cui è previsto un argomento intero, è +supportato un suffisso facoltativo per indicare facilmente numeri interi di +grandi dimensioni. Non deve esserci alcuno spazio tra il numero intero e il +suffisso. +.TP +\fBKiB\fP +Moltiplica l'intero per 1024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP, e \fBKB\fP +sono accettati come sinonimi di \fBKiB\fP. +.TP +\fBMiB\fP +Moltiplica l'intero per 1.048.576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP, e \fBMB\fP sono +accettati come sinonimi di \fBMiB\fP. +.TP +\fBGiB\fP +Moltiplica l'intero per 1.073.741.824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP, e \fBGB\fP +sono accettati come sinonimi di \fBGiB\fP. +.PP +Il valore speciale \fBmax\fP può essere utilizzato per indicare il valore +intero massimo supportato dall'opzione. +. +.SS "Modalità operativa" +Se vengono fornite più opzioni di modalità operativa, l'ultima ha effetto. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Compressione. Questa è la modalità operativa predefinita quando non viene +specificata alcuna opzione della modalità operativa e non è determinata +nessun'altra modalità operativa dal nome del comando (ad esempio, \fBunxz\fP +implica \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Dopo che la compressione è terminata con successo, il file origine viene +rimosso a meno che si stia scrivendo su standard output o che venga +specificato \fB\-\-keep\fP. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Decompressione. Dopo che la decompressione è terminata con successo, il file +origine viene rimosso a meno che si stia scrivendo su standard output o che +venga specificato \fB\-\-keep\fP. +.TP +\fB\-t\fP, \fB\-\-test\fP +Testa l'integrità dei \fIFILE\fP compressi. Questa opzione è equivalente a +\fB\-\-decompress \-\-stdout\fP tranne per il fatto che i dati decompressi vengono +scartati invece di essere scritti nello standard output. Nessun file viene +creato o rimosso. +.TP +\fB\-l\fP, \fB\-\-list\fP +Stampa le informazioni sul \fIFILE\fP compresso. Non viene prodotto alcun +output non compresso e non viene creato o rimosso alcun file. In modalità +elenco, il programma non è in grado di leggere i dati compressi dallo +standard input o da altre fonti che non permettano la ricerca. +.IP "" +Il tracciato predefinito mostra le informazioni di base sui \fIFILE\fP, un file +per riga. Per ottenere informazioni più dettagliate, usare anche l'opzione +\fB\-\-verbose\fP. Per avere ancora più informazioni, usare \fB\-\-verbose\fP due +volte, ma si noti che questo può essere lento, perché ottenere tutte le +informazioni extra richiede molte estrazioni. La larghezza dell'output +dettagliato supera gli 80 caratteri, quindi il reindirizzamento dell'output, +ad esempio, a \fBless\ \-S\fP può essere utile se il terminale non è +sufficientemente ampio. +.IP "" +L'output esatto può variare tra le versioni di \fBxz\fP e le diverse +impostazioni locali. Per un output leggibile dalla macchina si dovrebbe +utilizzare \fB\-\-robot \-\-list\fP. +. +.SS "Modificatori dell'operazione" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Non elimina i file input. +.IP "" +A partire da \fBxz\fP 5.2.6, questa opzione fa sì che \fBxz\fP comprima o +decomprima anche se l'input è un collegamento simbolico a un file regolare, +ha più di un collegamento fisico o ha il bit setuid, setgid o sticky +impostato. I bit setuid, setgid e sticky non vengono copiati nel file di +destinazione. Nelle versioni precedenti questo veniva fatto solo con +\fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Questa opzione ha diverse conseguenze: +.RS +.IP \(bu 3 +Se il file di destinazione esiste già, lo elimina prima di comprimere o +decomprimere. +.IP \(bu 3 +Comprime o decomprime anche se l'input è un collegamento simbolico a un file +regolare, ha più di un collegamento "hard", o ha il bit setuid, setgid o +sticky impostato. I bit setuid, setgid e sticky non sono copiati sul file +destinazione. +.IP \(bu 3 +Quando usato con \fB\-\-decompress\fP \fB\-\-stdout\fP e \fBxz\fP non riesce a +riconoscere il tipo di file sorgente, copia il file sorgente così com'è +sullo standard output. Questo permette a \fBxzcat\fP \fB\-\-force\fP di essere usato +come \fBcat\fP(1) per file che non siano stati compressi con \fBxz\fP. Si noti che +in futuro \fBxz\fP potrebbe supportare nuovi formati di file compressi, il che +potrebbe portare \fBxz\fP a decomprimere più tipi di file anziché copiarli come +sono sullo standard output. \fB\-\-format=\fP\fIFORMATO\fP può essere usato per +forzare \fBxz\fP a decomprimere solo un singolo formato di file. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Scrive i dati compressi o decompressi nello standard output anziché in un +file. Implica \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Decomprime solo il primo flusso \fB.xz\fP, e ignora automaticamente i possibili +dati di input rimanenti che seguono il flusso. Normalmente questi dati +sporchi finali portano \fBxz\fP a visualizzare un errore. +.IP "" +\fBxz\fP non decomprime mai più di un flusso dai file \fB.lzma\fP o dai flussi +grezzi, ma questa opzione fa comunque in modo che \fBxz\fP ignori i possibili +dati finali dopo il file \fB.lzma\fP o il flusso grezzo. +.IP "" +Questa opzione non ha effetto se la modalità operativa non è \fB\-\-decompress\fP +o \fB\-\-test\fP. +.IP "" +Dalla versione \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP implica \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Disabilita la creazione di file sparsi. Per impostazione predefinita, se si +esegue la decompressione in un file regolare, \fBxz\fP tenta di rendere il file +sparso se i dati decompressi contengono lunghe sequenze di zeri +binari. Funziona anche quando si scrive su standard output, purché lo +standard output sia collegato a un file regolare e siano soddisfatte alcune +condizioni aggiuntive per renderlo sicuro. La creazione di file sparsi può +risparmiare spazio su disco e velocizzare la decompressione riducendo la +quantità di I/O su disco. +.TP +\fB\-S\fP \fI.SUFFISSO\fP, \fB\-\-suffix=\fP\fI.SUFFISSO\fP +Durante la compressione, utilizzare \fI.suf\fP come suffisso per il file di +destinazione anziché \fB.xz\fP o \fB.lzma\fP. Se non si scrive nello standard +output e il file di origine ha già il suffisso \fI.suf\fP, viene visualizzato +un avvertimento e il file viene ignorato. +.IP "" +Quando si decomprime, accetta i file con suffisso \fI.suf\fP in aggiunta a +quelli con suffisso \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, o \fB.lz\fP. Se il file +sorgente ha suffisso \fI.suf\fP, il suffisso viene rimosso per ottenere il nome +del file destinazione. +.IP "" +Quando si comprimono o decomprimono flussi grezzi (\fB\-\-format=raw\fP), il +suffisso deve sempre essere specificato, a meno che si scriva sullo standard +output, perché non esiste un suffisso predefinito per i flussi grezzi. +.TP +\fB\-\-files\fP[\fB=\fP\fIFILE\fP] +Legge i nomi dei file da processare da \fIFILE\fP; se \fIFILE\fP è omesso, i nomi +dei file vengono letti dallo standard input. I nomi dei file devono essere +terminati da un carattere "a capo". Un trattino (\fB\-\fP) è considerato come un +nome di file regolare; non indica lo standard input. Se vengono forniti +anche dei nomi di file come argomenti della riga di comando, questi sono +processati prima di quelli letti da \fIFILE\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIFILE\fP] +Questo è identico a \fB\-\-files\fP[\fB=\fP\fIFILE\fP] tranne per il fatto che ogni +nome di file deve terminare con il carattere null. +. +.SS "Formato file di base e opzioni di compressione" +.TP +\fB\-F\fP \fIFORMATO\fP, \fB\-\-format=\fP\fIFORMATO\fP +Specifica il \fIFORMATO\fP del file da comprimere o decomprimere: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Questa è l'impostazione predefinita. Quando si comprime, \fBauto\fP è +equivalente a \fBxz\fP. Quando si decomprime, il formato del file input viene +rilevato automaticamente. Si noti che per i flussi grezzi (creati con +\fB\-\-format=raw\fP) non è possibile il rilevamento automatico. +.TP +\fBxz\fP +Comprime nel formato di file \fB.xz\fP, oppure accetta solo file \fB.xz\fP durante +la decompressione. +.TP +\fBlzma\fP, \fBalone\fP +Comprime nel formato tradizionale \fB.lzma\fP, oppure accetta solo file +\&\fB.lzma\fP per la decompressione. Il nome alternativo \fBalone\fP è fornito per +retrocompatibilità con le LZMA Utils. +.TP +\fBlzip\fP +Accetta solo file \fB.lz\fP per la decompressione. La compressione non è +supportata. +.IP "" +Sono supportate le versioni 0 e 1 del formato \fB.lz\fP. I file in versione 0 +sono stati prodotti da \fBlzip\fP 1.3 e precedenti. Questi file non sono +comuni, ma possono essere trovati negli archivi di file, perché alcuni +pacchetti sorgente erano stati rilasciati in questo formato. Qualcuno +potrebbe anche avere vecchi file personali in questo formato. Il supporto +alla decompressione per la versione di formato 0 è stato rimosso in \fBlzip\fP +1.18. \fBlzip\fP 1.4 e successivi creano i file nella versione di formato 1. +.TP +\fBraw\fP +Comprime o decomprime un flusso grezzo (senza intestazione). Questo è inteso +solamente per utenti avanzati. Per decodificare flussi grezzi, occorre usare +\fB\-\-format=raw\fP e specificare esplicitamente la catena dei filtri, che +normalmente sarebbero conservati nell'intestazione. +.RE +.TP +\fB\-C\fP \fICONTROLLO\fP, \fB\-\-check=\fP\fICONTROLLO\fP +Specifica il tipo di controllo di integrità. Il controllo viene calcolato +dai dati non compressi e memorizzato nel file \fB.xz\fP. Questa opzione ha +effetto solo quando si comprime nel formato \fB.xz\fP; il formato \fB.lzma\fP non +supporta i controlli di integrità. Il controllo di integrità (se presente) +viene verificato quando il file \fB.xz\fP viene decompresso. +.IP "" +Tipi di \fICONTROLLI\fP supportati: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Non calcola proprio il controllo di integrità. Questo in genere è una +pessima idea. Può essere utile quando l'integrità dei dati viene comunque +verificata con altri mezzi. +.TP +\fBcrc32\fP +Calcola la firma CRC32 usando il polinomio di IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Calcola la firma CRC64 usando il polinomio di ECMA\-182. Questa è +l'impostazione predefinita, perché è leggermente migliore della CRC32 nel +rilevare i file danneggiati e la differenza di velocità è trascurabile. +.TP +\fBsha256\fP +Calcola la firma SHA\-256. Questo è un po' più lento che CRC32 e CRC64. +.RE +.IP "" +L'integrità delle intestazioni \fB.xz\fP viene sempre verificata con CRC32. Non +è possibile modificarlo o disabilitarlo. +.TP +\fB\-\-ignore\-check\fP +Non verifica il controllo di integrità dei dati compressi durante la +decompressione. Il valore CRC3 nelle intestazioni \fB.xz\fP sarà ancora +verificata normalmente. +.IP "" +\fBNon usare questa opzione se non si è consci di cosa si sta facendo.\fP +Possibili ragioni per utilizzare questa opzione: +.RS +.IP \(bu 3 +Tentativo di recupero dei dati da un file .xz corrotto. +.IP \(bu 3 +Accelerazione della decompressione. Questo è importante soprattutto con +SHA\-256 o con i file che sono stati compressi molto bene. Si consiglia di +non utilizzare questa opzione per questo scopo, a meno che l'integrità del +file non venga verificata esternamente in altro modo. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Selezionare un livello di compressione preimpostato. Il valore predefinito è +\fB\-6\fP. Se vengono specificati più livelli preimpostati, l'ultimo ha +effetto. Se è già stata specificata una catena di filtri personalizzata, +l'impostazione di un livelli preimpostati cancella la catena di filtri +personalizzata. +.IP "" +Le differenze tra i livelli preimpostati sono più significative rispetto a +\fBgzip\fP(1) e \fBbzip2\fP(1). Le impostazioni di compressione selezionate +determinano i requisiti di memoria del decompressore, quindi l'utilizzo di +un livello preimpostato troppo alto potrebbe rendere difficile la +decompressione del file su un vecchio sistema con poca RAM. Specificamente, +\fBnon è una buona idea utilizzare ciecamente \-9 per tutto\fP come spesso +accade per \fBgzip\fP(1) e \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Questi sono livelli preimpostati piuttosto veloci. \fB\-0\-\fP a volte è più +veloce di \fBgzip \-9\fP e comprime molto meglio. Quelli più alti hanno spesso +una velocità paragonabile a \fBbzip2\fP(1) con un rapporto di compressione +comparabile o migliore, anche se i risultati dipendono molto dal tipo di +dati che vengono compressi. +.TP +\fB\-4\fP ... \fB\-6\fP +Compressione da buona a molto buona, mantenendo l'utilizzo della memoria del +decompressore ragionevole anche per vecchi sistemi. \fB\-6\fP è il valore +predefinito, che di solito è una buona scelta per distribuire file che +debbano essere decompressi anche su sistemi con solo 16\ MiB di +RAM. (Potrebbe valere la pena di considerare anche \fB\-5e\fP o \fB\-6e\fP. Si veda +\fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Questi sono come \fB\-6\fP ma con requisiti di memoria di compressore e +decompressore più elevati. Sono utili solo quando si comprimono file di +dimensioni superiori a 8\ MiB, 16\ MiB e 32\ MiB, rispettivamente. +.RE +.IP "" +A parità di hardware, la velocità di decompressione è approssimativamente un +numero costante di byte di dati compressi al secondo. In altre parole, +migliore è la compressione, più veloce sarà di solito la decompressione. Ciò +significa anche che la quantità di output non compresso prodotta al secondo +può variare notevolmente. +.IP "" +La tabella seguente riassume le caratteristiche dei livelli preimpostati: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Livello preimpostato;DictSize;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Descrizioni delle colonne: +.RS +.IP \(bu 3 +DictSize è la dimensione del dizionario LZMA2. È uno spreco di memoria usare +un dizionario più grande della dimensione del file non compresso. Ecco +perché è una buona cosa evitare di usare i livelli preimpostati \fB\-7\fP +\&... \fB\-9\fP quando non c'è reale necessità. Con \fB\-6\fP e inferiori, la quantità +di memoria sprecata in genere è sufficientemente bassa da essere +trascurabile. +.IP \(bu 3 +CompCPU è una rappresentazione semplificata delle impostazioni di LZMA2 che +influenzano la velocità di compressione. Anche la dimensione del dizionario +influenza la velocità, quindi mentre CompCPU è lo stesso per i livelli \fB\-6\fP +\&... \fB\-9\fP, i livelli più alti tendono ancora ad essere un po' più lenti. Per +avere una compressione ancora più lenta e quindi potenzialmente migliore, +utilizzare \fB\-\-extreme\fP. +.IP \(bu 3 +CompMem contiene i requisiti di memoria del compressore in modalità a +singola thread. Può variare leggermente tra le versioni di \fBxz\fP. +.IP \(bu 3 +DecMem contiene i requisiti di memoria del decompressore. In altre parole, +le impostazioni di compressione determinano i requisiti di memoria del +decompressore. L'utilizzo esatto della memoria del decompressore è +leggermente superiore alla dimensione del dizionario LZMA2, ma i valori +nella tabella sono stati arrotondati per eccesso al successivo MiB completo. +.RE +.IP "" +I requisiti di memoria per la modalità a thread multiple sono +significativamente più alti che per la modalità thread singola. Con il +valore predefinito di \fB\-\-block\-size\fP, ogni thread richiede 3*3*dimensione +del dizionario più CompMem oppure DecMem. Ad esempio, 4 thread con il +livello preimpostato \fB\-6\fP hanno bisogno di 660\(en670\ MiB di memoria. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Utilizzare una variante più lenta del livello preimpostato selezionato +(\fB\-0\fP ... \fB\-9\fP) nella speranza di ottenere un rapporto di compressione +leggermente migliore, ma con un po' di sfortuna questo potrebbe anche +renderlo peggiore. L'utilizzo della memoria del decompressore non è +influenzato, ma l'utilizzo della memoria del compressore aumenta leggermente +ai livelli preimpostati \fB\-0\fP ... \fB\-3\fP. +.IP "" +Dal momento che ci sono due livelli preimpostati con dimensione del +dizionario di 4\ MiB e 8\ MiB, i livelli preimpostati \fB\-3e\fP e \fB\-5e\fP usano +impostazioni leggermente più veloci (minore CompCPU) di \fB\-4e\fP e \fB\-6e\fP, +rispettivamente. In questo modo non ci sono due livelli preimpostati +identici. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Livello preimpostato;DictSize;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Ad esempio, ci sono un totale di quattro livelli preimpostati che utilizzano +un dizionario da 8\ MiB, il cui ordine dal più veloce al più lento è \fB\-5\fP, +\fB\-6\fP, \fB\-5e\fP, e \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Questi sono alias in qualche modo fuorvianti per \fB\-0\fP e \fB\-9\fP, +rispettivamente. Sono forniti solo per retrocompatibilità con le LZMA +Utils. Evitare di utilizzare queste opzioni. +.TP +\fB\-\-block\-size=\fP\fIDIMENSIONE\fP +Quando si comprime in formato \fB.xz\fP, divide i dati input in blocchi da +\fIDIMENSIONE\fP byte. I blocchi vengo compressi indipendentemente l'uno +dall'altro, cosa che aiuta con le thread multiple e rende possibile la +decompressione con accessi casuali limitati. Questa opzione viene usata +tipicamente per sovrascrivere la dimensione predefinita dei blocchi in +modalità a thread multiple, ma può essere utilizzata anche in modalità +thread singola. +.IP "" +In modalità a thread multiple verranno allocati circa il triplo di +\fIDIMENSIONE\fP di byte in ogni thread per il buffering dell'input e +dell'output. La \fIDIMENSIONE\fP predefinita è tre volte la dimensione del +dizionario LZMA2 e comunque almeno 1 MiB. Tipicamente un buon valore è +2\(en4 volte la dimensione del dizionario LZMA2 oppure almeno 1 MiB. Usare +una \fIDIMENSIONE\fP inferiore della dimensione del dizionario LZMA2 causa uno +spreco di RAM, in quanto il buffer del dizionario LZMA2 non verrà mai +riempito completamente. In modalità a thread multiple, la dimensione dei +blocchi è conservata nelle intestazioni dei blocchi. L'informazione sulla +dimensione è richiesta per la decompressione a thread multiple. +.IP "" +Nella modalità a thread singola, per impostazione predefinita non viene +eseguita alcuna suddivisione in blocchi. L'impostazione di questa opzione +non influisce sull'utilizzo della memoria. Nessuna informazione sulle +dimensioni viene memorizzata nelle intestazioni di blocco, quindi i file +creati in modalità a thread singola non saranno identici ai file creati in +modalità a thread multiple. La mancanza di informazioni sulle dimensioni +significa anche che \fBxz\fP non sarà in grado di decomprimere i file in +modalità a thread multiple. +.TP +\fB\-\-block\-list=\fP\fIELEMENTI\fP +Quando si comprime nel formato \fB.xz\fP, inizia un nuovo blocco con una catena +di filtri personalizzata dopo gli intervalli indicati di dati non compressi. +.IP "" +Gli \fIELEMENTI\fP sono un elenco separato da virgole. Ogni elemento è +costituito da un numero di catena di filtri opzionale compreso tra 0 e 9 +seguito da due punti (\fB:\fP) e da una dimensione richiesta di dati non +compressi. L'omissione di un elemento (due o più virgole consecutive) è una +scorciatoia per utilizzare le dimensioni e i filtri dell'elemento +precedente. +.IP "" +Se il file di input è più grande della somma delle dimensioni in +\fIELEMENTI\fP, l'ultimo elemento viene ripetuto fino alla fine del file. Il +valore speciale \fB0\fP può essere utilizzato come ultima dimensione per +indicare che il resto del file deve essere codificato come un singolo +blocco. +.IP "" +È possibile specificare una catena di filtri alternativa per ogni blocco in +combinazione con le opzioni \fB\-\-filters1=\fP\fIFILTRI\fP \&...\& +\fB\-\-filters9=\fP\fIFILTRI\fP. Queste opzioni definiscono catene di filtri con un +identificatore compreso tra 1\(en9. La catena di filtri 0 può essere +utilizzata per indicare la catena di filtri predefinita, che equivale a non +specificare una catena di filtri. L'identificatore della catena di filtri +può essere utilizzato prima della dimensione non compressa, seguita da due +punti (\fB:\fP). Ad esempio, se si specifica +\fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP allora i blocchi verranno +creati utilizzando: +.RS +.IP \(bu 3 +La catena dei filtri specificata da \fB\-\-filters1\fP e un input di 2 MiB +.IP \(bu 3 +La catena dei filtri specificata da \fB\-\-filters3\fP e un input di 2 MiB +.IP \(bu 3 +La catena dei filtri specificata da \fB\-\-filters2\fP e un input di 4 MiB +.IP \(bu 3 +La catena dei filtri specificata da \fB\-\-filters2\fP e un input di 4 MiB +.IP \(bu 3 +La catena di filtri predefinita e l'input di 2 MiB +.IP \(bu 3 +La catena di filtri predefinita e l'input di 4 MiB per ogni blocco fino alla +fine dell'input. +.RE +.IP "" +Se si specifica una dimensione che supera la dimensione del blocco del +codificatore (il valore predefinito in modalità thread oppure il valore +specificato con \fB\-\-block\-size=\fP\fIDIMENSIONE\fP), il codificatore creerà +blocchi aggiuntivi mantenendo i limiti specificati in \fIELEMENTI\fP. Ad +esempio, se si indica \fB\-\-block\-size=10MiB\fP +\fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP e il file input è di 80 MiB, si +otterranno 11 blocchi: 5, 10, 8, 10, 2, 10, 10, 4, 10, 10, and 1 MiB. +.IP "" +In modalità a thread multiple, le dimensioni dei blocchi vengono memorizzate +nelle intestazioni dei blocchi. Questo non avviene in modalità thread +singola, quindi l'output codificato non sarà identico a quello della +modalità a thread multiple. +.TP +\fB\-\-flush\-timeout=\fP\fITIMEOUT\fP +Quando si comprime, se sono passati più di \fITIMEOUT\fP millisecondi (un +intero positivo) dallo scaricamento precedente e la lettura di ulteriori +input si bloccherebbe, tutti i dati di input in sospeso vengono scaricati +dal codificatore e resi disponibili nel flusso di output. Questo può essere +utile se \fBxz\fP viene usato per comprimere dati in streaming dalla +rete. Piccoli valori del \fITIMEOUT\fP rendono disponibili i dati al ricevente +con un ritardo minimo, mentre valori di \fITIMEOUT\fP grandi danno un miglior +rapporto di compressione. +.IP "" +Questa funzionalità è disabilitata per impostazione predefinita. Se questa +opzione viene specificata più di una volta, l'ultima ha effetto. Il valore +speciale \fITIMEOUT\fP di \fB0\fP può essere utilizzato per disabilitare +esplicitamente questa funzionalità. +.IP "" +Questa funzionalità non è disponibile sui sistemi non\-POSIX. +.IP "" +.\" FIXME +\fBQuesta funzionalità è sperimentale.\fP Attualmente \fBxz\fP non è adatto per +decomprimere il flusso in tempo reale, a causa di come effettua il +buffering. +.TP +\fB\-\-no\-sync\fP +Non sincronizzare il file target e la sua directory sull'unità di +archiviazione prima di rimuovere il file sorgente. Questo può migliorare le +performance se si sta comprimendo o decomprimendo tanti piccoli +file. Tuttavia, se il sistema dovesse andare in crash subito dopo +l'eliminazione, è possibile che il file destinazione non sia ancora stato +scritto sull'unità di archiviazione mentre l'operazione di eliminazione +sì. In questo caso non saranno più disponibili né il file sorgente originale +né il file di destinazione. +.IP "" +Questa opzione ha effetto solamente quando \fBxz\fP deve rimuovere il file +sorgente. Negli altri casi la sincronizzazione non viene eseguita. +.IP "" +La sincronizzazione e \fB\-\-no\-sync\fP sono stati aggiunti nella versione \fBxz\fP +5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fILIMITE\fP +Imposta un limite di utilizzo della memoria per la compressione. Se questa +opzione viene specificata più volte, ha effetto l'ultima. +.IP "" +Se le impostazioni di compressione superano il valore \fILIMITE\fP, \fBxz\fP +tenterà di regolare le impostazioni verso il basso in modo che il limite non +venga più superato e visualizzerà un avviso che indica che è stata eseguita +una regolazione automatica. Le regolazioni vengono eseguite in questo +ordine: riduzione del numero di thread, passaggio alla modalità a thread +singola se anche un solo thread in modalità a thread multiple supera il +\fILIMITE\fP, e infine riducendo la dimensione del dizionario LZMA2. +.IP "" +Quando si comprime con \fB\-\-format=raw\fP oppure se si è specificato +\fB\-\-no\-adjust\fP, è possibile ridurre solo il numero di thread, poiché questo +può essere fatto senza influire sull'output compresso. +.IP "" +Se non è possibile soddisfare il \fILIMITE\fP anche con le regolazioni sopra +descritte, viene visualizzato un errore e \fBxz\fP uscirà con lo stato di +uscita 1. +.IP "" +Il \fILIMITE\fP può essere specificato in diversi modi: +.RS +.IP \(bu 3 +Il \fILIMITE\fP può essere un valore assoluto in byte. Usare un suffisso intero +come \fBMiB\fP può essere utile. Ad esempio: \fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +Il \fILIMITE\fP può essere specificato come percentuale della memoria fisica +(RAM) totale. Questo può essere utile specialmente quando si imposta la +variabile di ambiente \fBXZ_DEFAULTS\fP in uno script di inizializzazione di +shell che è condiviso tra computer diversi. In questo modo il limite è +automaticamente più grande sui sistemi con più memoria. Ad esempio: +\fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +Il \fILIMITE\fP può essere reimpostato al suo valore predefinito impostandolo a +\fB0\fP.Questo attualmente equivale a impostare il \fILIMITE\fP a \fBmax\fP (nessun +limite nell'utilizzo di memoria). +.RE +.IP "" +Per \fBxz\fP a 32\-bit esiste un caso particolare: se il \fILIMITE\fP fosse oltre +\fB4020\ MiB\fP, il \fILIMITE\fP viene impostato a \fB4020\ MiB\fP. Su MIPS32 invece +viene usato \fB2000\ MiB\fP. (I valori \fB0\fP e \fBmax\fP non sono influenzati da +questo. Un comportamento simile non esiste per la decompressione). Questo +può essere utile quando un eseguibile a 32 bit ha accesso a uno spazio di +indirizzi da 4\ GiB (2 GiB su MIPS32), e si spera che non faccia danni in +altre situazioni. +.IP "" +Vedere anche la sezione \fBUtilizzo memoria\fP +.TP +\fB\-\-memlimit\-decompress=\fP\fILIMITE\fP +Imposta un limite di utilizzo della memoria per la decompressione. Questo +influisce anche sulla modalità \fB\-\-list\fP. Se l'operazione non è possibile +senza oltrepassare il \fILIMITE\fP, \fBxz\fP mostrerà un errore e la +decompressione del file fallirà. Si veda \fB\-\-memlimit\-compress=\fP\fILIMITE\fP +per possibili modi per specificare il \fILIMITE\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fILIMITE\fP +Imposta un limite di utilizzo della memoria per la decompressione +multi\-thread. Questo può influire solo sul numero di thread; non indurrà mai +\fBxz\fP a rifiutarsi di decomprimere un file. Se \fILIMITE\fP è troppo basso per +consentire le thread multiple, il \fILIMITE\fP viene ignorato e \fBxz\fP +continuerà in modalità a thread singola. Si noti che se viene utilizzato +anche \fB\-\-memlimit\-decompress\fP, si applicherà sempre sia alla modalità a +thread singola che a quella a thread multiple, e quindi il \fILIMITE\fP +effettivo per le thread multiple non sarà mai superiore a quello impostato +con \fB\-\-memlimit\-decompress\fP. +.IP "" +In contrasto con le altre opzioni di limite di utilizzo della memoria, +\fB\-\-memlimit\-mt\-decompress=\fP\fILIMITE\fP ha un \fILIMITE\fP predefinito specifico +per il sistema. \fBxz \-\-info\-memory\fP può essere utilizzato per vedere il +valore corrente. +.IP "" +Questa opzione e il suo valore predefinito esistono perché, senza un limite, +il decompressore a thread multiple potrebbe finire per allocare una quantità +folle di memoria per alcuni file input. Se il valore predefinito \fILIMITE\fP è +troppo basso sul proprio sistema, è possibile aumentarlo liberamente, ma non +deve essere mai impostato a un valore più grande della quantità di RAM +utilizzabile, in quanto con file di input appropriati \fBxz\fP cercherà di +utilizzare quella quantità di memoria anche con un basso numero di +thread. Esaurire la memoria o fare swap non migliorerà le performance della +decompressione. +.IP "" +Vedi \fB\-\-memlimit\-compress=\fP\fILIMITE\fP per possibili modi per specificare il +\fILIMITE\fP. Impostando \fILIMITE\fP su \fB0\fP si ripristina il valore predefinito +\fILIMITE\fP specifico del sistema. +.TP +\fB\-M\fP \fILIMITE\fP, \fB\-\-memlimit=\fP\fILIMITE\fP, \fB\-\-memory=\fP\fILIMITE\fP +Questo equivale a specificare \fB\-\-memlimit\-compress=\fP\fILIMITE\fP +\fB\-\-memlimit\-decompress=\fP\fILIMITE\fP \fB\-\-memlimit\-mt\-decompress=\fP\fILIMITE\fP. +.TP +\fB\-\-no\-adjust\fP +Visualizza un errore e esce se non è possibile soddisfare il limite di +utilizzo della memoria senza regolare le impostazioni che influiscono +sull'output compresso. In altre parole, ciò impedisce a \fBxz\fP di passare il +codificatore dalla modalità multi\-thread alla modalità a thread singola e di +ridurre le dimensioni del dizionario LZMA2. Anche quando viene usata questa +opzione, il numero di thread può essere ridotto per soddisfare il limite di +utilizzo della memoria, in quanto ciò non influirà sull'output compresso. +.IP "" +La regolazione automatica è sempre disabilitata quando si creano flussi raw +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fITHREADS\fP, \fB\-\-threads=\fP\fITHREADS\fP +Specifica il numero di thread di lavoro da utilizzare. L'impostazione di +\fITHREADS\fP al valore speciale \fB0\fP fa sì che \fBxz\fP utilizzi fino a un numero +di thread che il processore/i del sistema supportano. Il numero effettivo di +thread può essere inferiore a \fITHREADS\fP se il file di input non è +sufficientemente grande per il threading con le impostazioni specificate o +se l'utilizzo di più thread supera il limite di utilizzo della memoria. +.IP "" +I compressori a thread singola e a thread multiple producono output +diversi. Il compressore a thread singola produrrà la dimensione del file più +piccola, ma solo l'output del compressore a thread multiple può essere +decompresso utilizzando più thread. Impostando \fITHREADS\fP su \fB1\fP verrà +utilizzata la modalità a thread singola. L'impostazione di \fITHREADS\fP su +qualsiasi altro valore, incluso \fB0\fP, utilizzerà il compressore a thread +multiple anche se il sistema supporta un solo thread hardware. (\fBxz\fP 5.2.x +utilizzava la modalità a thread singola in questa situazione.) +.IP "" +Per utilizzare la modalità a thread multiple con un solo thread, impostare +\fITHREADS\fP su \fB+1\fP. Il prefisso \fB+\fP non ha alcun effetto con valori +diversi da \fB1\fP. Un limite di utilizzo della memoria può comunque far +passare \fBxz\fP alla modalità a thread singola a meno che non venga utilizzato +\fB\-\-no\-adjust\fP. Il supporto per il prefisso \fB+\fP è stato aggiunto in \fBxz\fP +5.4.0. +.IP "" +Se è stato richiesto un numero automatico di thread e non è stato +specificato alcun limite di utilizzo della memoria, verrà utilizzato un +limite "soft" predefinito, specifico del sistema, per limitare eventualmente +il numero di thread. È un limite "soft" nel senso che viene ignorato se il +numero di thread diventa uno, quindi un limite soft non impedirà mai a \fBxz\fP +di comprimere o decomprimere. Questo limite soft predefinito non farà +passare \fBxz\fP dalla modalità a thread multiple alla modalità thread +singola. I limiti attivi possono essere visualizzati con \fBxz \-\-info\-memory\fP. +.IP "" +Attualmente l'unico metodo di threading consiste nel dividere l'input in +blocchi e comprimerli indipendentemente l'uno dall'altro. La dimensione +predefinita del blocco dipende dal livello di compressione e può essere +sovrascritta con l'opzione \fB\-\-block\-size=\fP\fIDIMENSIONE\fP. +.IP "" +La decompressione a thread multiple funziona solo su file che contengano più +blocchi con l'informazione della dimensione nelle intestazioni del +blocco. Tutti i file sufficientemente grandi compressi in modalità a thread +multiple soddisfano questa condizione, mentre i file compressi in modalità +thread singola no, neanche se si è utilizzato \fB\-\-block\-size=\fP +\fIDIMENSIONE\fP. +.IP "" +Il valore predefinito per \fITHREADS\fP è \fB0\fP. In \fBxz\fP 5.4.x e precedenti il +valore predefinito era \fB1\fP. +. +.SS "Catene di filtri di compressione personalizzate" +Una catena di filtri personalizzata consente di specificare in dettaglio le +impostazioni di compressione invece di fare affidamento sulle impostazioni +associate ai livelli preimpostati. Quando viene specificata una catena di +filtri personalizzata, le opzioni relative ai livelli preimpostati (\fB\-0\fP +\&...\& \fB\-9\fP e \fB\-\-extreme\fP) specificate in precedenza sulla riga di +comando vengono dimenticate. Se un'opzione livello preimpostato viene +specificata dopo una o più opzioni della catena di filtri personalizzata, il +nuovo livello preimpostato ha effetto e le opzioni della catena di filtri +personalizzate specificate in precedenza vengono dimenticate. +.PP +Una catena di filtri è paragonabile a una pipe sulla riga di +comando. Durante la compressione, l'input non compresso va al primo filtro, +il cui output va al filtro successivo (se presente). L'output dell'ultimo +filtro viene scritto nel file compresso. Il numero massimo di filtri nella +catena è quattro, ma in genere una catena di filtri ha solo uno o due +filtri. +.PP +Molti filtri hanno limitazioni su dove possono trovarsi nella catena di +filtri: alcuni filtri possono funzionare solo come ultimo filtro della +catena, altri solo come filtro non ultimo e alcuni funzionano in qualsiasi +posizione nella catena. A seconda del filtro, questa limitazione è inerente +alla struttura del filtro oppure esiste per evitare problemi di sicurezza. +.PP +Una catena di filtri personalizzata può essere specificata in due modi +diversi. Le opzioni \fB\-\-filters=\fP\fIFILTRI\fP and \fB\-\-filters1=\fP\fIFILTRI\fP +\&...\& \fB\-\-filters9=\fP\fIFILTRI\fP permettono di specificare un'intera catena +di filtri in una opzione utilizzando la sintassi della stringa del filtro di +lzma. In alternativa, una catena di filtri può essere specificata +utilizzando una o più singole opzioni di filtro nell'ordine desiderato nella +catena di filtri. Questo significa che l'ordine delle singole opzioni di +filtro è importante! Quando si decodificano i flussi grezzi +(\fB\-\-format=raw\fP), la catena di filtri deve essere specificata nello stesso +ordine in cui è stata specificata durante la compressione. Qualsiasi filtro +individuale o opzione livello preimpostato specificata prima dell'opzione +della catena completa (\fB\-\-filters=\fP\fIFILTRI\fP) verrà dimenticata. I singoli +filtri specificati dopo l'opzione della catena completa reimposteranno la +catena di filtri. +.PP +Sia l'opzione di filtro completo che quella individuale accettano \fIOPZIONI\fP +specifiche del filtro come un elenco separato da virgole. Virgole in eccesso +nelle \fIOPZIONI\fP vengono ignorate. Ogni opzione ha un valore di default, +quindi occorre specificare solamente quelle che si desidera modificare. +.PP +Per vedere l'intera catena di filtri e \fIOPZIONI\fP, usa \fBxz \-vv\fP (ossia, usa +\fB\-\-verbose\fP due volte). Questo funziona anche per visualizzare le opzioni +della catena di filtri utilizzate dai livelli preimpostati. +.TP +\fB\-\-filters=\fP\fIFILTRI\fP +Specifica l'intera catena dei filtri oppure un livello preimpostato in una +singola opzione. Ogni filtro può essere separato da spazi o da due trattini +(\fB\-\-\fP). Potrebbe essere necessario mettere tra virgolette i \fIFILTRI\fP sulla +riga di comando della shell in modo che vengano analizzati come una singola +opzione. Per indicare \fIOPZIONI\fP, usa \fB:\fP o \fB=\fP. Un livello preimpostato +può essere preceduto da un \fB\-\fP e seguito da zero o più flag. L'unico flag +supportato è \fBe\fP per applicare le stesse opzioni di \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIFILTRI\fP ... \fB\-\-filters9\fP=\fIFILTRI\fP +Specifica fino a nove catene di filtri aggiuntive che possono essere +utilizzate con \fB\-\-block\-list\fP. +.IP "" +Ad esempio, quando si comprime un archivio con file eseguibili seguiti da +file di testo, la parte eseguibile potrebbe utilizzare una catena di filtri +con un filtro BCJ e la parte di testo solo il filtro LZMA2. +.TP +\fB\-\-filters\-help\fP +Mostra un messaggio di aiuto che descrive come specificare livelli +preimpostati e catene di filtri personalizzati nelle opzioni \fB\-\-filters\fP e +\fB\-\-filters1=\fP\fIFILTRI\fP \&...\& \fB\-\-filters9=\fP\fIFILTRI\fP, e termina con +successo. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIOPZIONI\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIOPZIONI\fP] +.PD +Aggiunge un filtro LZMA1 o LZMA2 alla catena dei filtri. Questi filtri +possono essere usati solo come ultimo filtro della catena. +.IP "" +LZMA1 è un filtro obsoleto, supportato quasi esclusivamente a causa del +formato obsoleto di file \fB.lzma\fP, che supporta solo LZMA1. LZMA2 è una +versione aggiornata di LZMA1 che risolve alcuni problemi pratici di +LZMA1. Il formato \fB.xz\fP utilizza LZMA2 e non supporta LZMA1. La velocità e +i rapporti di compressione di LZMA1 e LZMA2 sono praticamente gli stessi. +.IP "" +LZMA1 e LZMA2 condividono lo stesso insieme di \fIOPZIONI\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIPRESET\fP +Reimposta tutte le \fIOPZIONI\fP LZMA1 o LZMA2 a \fIPRESET\fP. Il \fIPRESET\fP +(livello preimpostato) consiste di un numero intero, che può essere seguito +da modificatori costituiti da una singola lettera. Il numero intero può +andare da \fB0\fP a \fB9\fP, corrispondenti alle opzioni della riga di comando +\fB\-0\fP \&...\& \fB\-9\fP. L'unico modificatore attualmente supportato è \fBe\fP, che +corrisponde a \fB\-\-extreme\fP. Se non viene specificato alcun \fIPRESET\fP, i +valori predefiniti delle \fIOPZIONI\fP LZMA1 o LZMA2 sono presi dal livello +preimpostato \fB6\fP. +.TP +\fBdict=\fP\fIDIMENSIONE\fP +La \fIDIMENSIONE\fPdel dizionario (buffer di cronologia) indica quanti byte dei +dati non compressi elaborati di recente vengono mantenuti in +memoria. L'algoritmo tenta di trovare sequenze di byte ripetute +(corrispondenze) nei dati non compressi e di sostituirle con riferimenti ai +dati attualmente presenti nel dizionario. Più grande è il dizionario, +maggiore è la possibilità di trovare una corrispondenza. Quindi, l'aumento +della \fIDIMENSIONE\fP del dizionario di solito migliora il rapporto di +compressione, ma un dizionario più grande del file non compresso è uno +spreco di memoria. +.IP "" +Una \fIDIMENSIONE\fP tipica per un dizionario è da 64\ KiB a 64\ MiB. Il minimo +è 4\ KiB. Il massimo per la compressione è attualmente 1.5\ GiB (1536\ MiB). La decompressione supporta già dizionari fino a 4\ GiB meno 1 byte, +che è il massimo per i formati di flusso LZMA1 e LZMA2. +.IP "" +La \fIDIMENSIONE\fP del dizionario e il cercatore di corrispondenze +(\fICERCATORE\fP) insieme determinano l'utilizzo della memoria del codificatore +LZMA1 o LZMA2. Per la decompressione è necessaria la stessa \fIDIMENSIONE\fP +del dizionario utilizzata durante la compressione (o più grande), quindi +l'utilizzo della memoria del decodificatore è determinato dalla dimensione +del dizionario utilizzato durante la compressione. Le intestazioni \fB.xz\fP +memorizzano la \fIDIMENSIONE\fP del dizionario come 2^\fIn\fP o 2^\fIn\fP + 2^( +\fIn\fP\-1), quindi queste \fIDIMENSIONI\fP sono in qualche modo preferite per la +compressione. Altre \fIDIMENSIONI\fP verranno arrotondate per eccesso quando +memorizzate nelle intestazioni \fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Specificare il numero di bit di contesto letterali. Il minimo è 0 e il +massimo è 4; Il valore predefinito è 3. Inoltre, la somma di \fIlc\fP e \fIlp\fP +non deve superare 4. +.IP "" +Tutti i byte che non possono essere codificati come corrispondenze vengono +codificati come valori letterali. In altre parole, i valori letterali sono +semplicemente byte a 8 bit codificati uno alla volta. +.IP "" +La codifica letterale presuppone che i bit di \fIlc\fP più alti del byte non +compresso precedente siano correlati al byte successivo. Ad esempio, in un +tipico testo inglese, una lettera maiuscola è spesso seguita da una lettera +minuscola e una lettera minuscola è solitamente seguita da un'altra lettera +minuscola. Nel set di caratteri US\-ASCII, i tre bit più alti sono 010 per le +lettere maiuscole e 011 per le lettere minuscole. Quando \fIlc\fP è almeno 3, +la codifica letterale può sfruttare questa proprietà nei dati non compressi. +.IP "" +Il valore predefinito (3) solitamente è buono. Se si desidera la +compressione massima, provare con \fBlc=4\fP. A volte aiuta un po', e a volte +rende la compressione peggiore. Se la rende peggiore, provare anche \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Specificare il numero di bit di posizione letterale. Il minimo è 0 e il +massimo è 4; Il valore predefinito è 0. +.IP "" +Il parametro \fIlp\fP influisce sul tipo di allineamento nei dati non compressi +presunto durante la codifica dei valori letterali. Vedi \fIpb\fP di seguito per +ulteriori informazioni sull'allineamento. +.TP +\fBpb=\fP\fIpb\fP +Specificare il numero di bit di posizione. Il minimo è 0 e il massimo è 4; +Il valore predefinito è 2. +.IP "" +Il parametro \fIpb\fP influisce su quale tipo di allineamento nei dati non +compressi sia assunto in generale. L'impostazione predefinita indica un +allineamento a quattro byte (2^\fIpb\fP =2^2=4), che è spesso una buona scelta +se non c'è un'ipotesi migliore. +.IP "" +Quando l'allineamento è noto, impostare \fIpb\fP concordemente può ridurre un +po' le dimensioni del file. Ad esempio, con file di testo con 1 byte di +allineamento (US\-ASCII, ISO\-8859\-*, UTF\-8), impostare \fBpb=0\fP può migliorare +leggermente la compressione. Per il testo UTF\-16, \fBpb=1\fP è una buona +scelta. Se l'allineamento è un numero dispari, come 3 byte, \fBpb=0\fP potrebbe +essere la scelta migliore. +.IP "" +Anche se l'allineamento assunto può essere regolato con \fIpb\fP e \fIlp\fP, LZMA1 +e LZMA2 favoriscono ancora leggermente l'allineamento a 16 byte. Potrebbe +valere la pena tenerlo in considerazione quando si progettano formati di +file che possono essere spesso compressi con LZMA1 o LZMA2. +.TP +\fBmf=\fP\fICERCATORE\fP +Il cercatore di corrispondenze ha un effetto importante sulla velocità del +codificatore, sull'utilizzo della memoria e sul rapporto di compressione. Di +solito i cercatori di corrispondenze a catena hash sono più veloci dei +cercatori di corrispondenze ad albero binario. Il valore predefinito dipende +da \fIPRESET\fP : 0 usa \fBhc3\fP, 1\(en3 usa \fBhc4\fP e il resto usa \fBbt4\fP. +.IP "" +Sono supportati i seguenti cercatori di corrispondenze. Le formule di +utilizzo della memoria riportate di seguito sono approssimazioni, che sono +le più vicine alla realtà quando \fIDIZIONARIO\fP è una potenza di due. +.RS +.TP +\fBhc3\fP +Catena hash con hashing da 2 e 3 byte +.br +Minimo valore per \fINICE\fP: 3 +.br +Utilizzo memoria: +.br +\fIDIZIONARIO\fP * 7.5 (se \fIDIZIONARIO\fP <= 16 MiB); +.br +\fIDIZIONARIO\fP * 5.5 + 64 MiB (se \fIDIZIONARIO\fP > 16 MiB) +.TP +\fBhc4\fP +Catena hash con hash da 2, 3 e 4 byte +.br +Minimo valore per \fINICE\fP: 4 +.br +Utilizzo memoria: +.br +\fIDIZIONARIO\fP * 7.5 (se \fIDIZIONARIO\fP <= 32 MiB); +.br +\fIDIZIONARIO\fP * 6.5 (se \fIDIZIONARIO\fP > 32 MiB) +.TP +\fBbt2\fP +Albero binario con hashing da 2 byte +.br +Valore minimo per \fINICE\fP: 2 +.br +Utilizzo di memoria: \fIDIZIONARIO\fP * 9.5 +.TP +\fBbt3\fP +Albero binario con hashing da 2 e 3 byte +.br +Minimo valore per \fINICE\fP: 3 +.br +Utilizzo memoria: +.br +\fIDIZIONARIO\fP * 11.5 (se \fIDIZIONARIO\fP <= 16 MiB); +.br +\fIDIZIONARIO\fP * 9.5 + 64 MiB (se \fIDIZIONARIO\fP > 16 MiB) +.TP +\fBbt4\fP +Albero binario con hashing da 2, 3 e 4 byte +.br +Minimo valore per \fINICE\fP: 4 +.br +Utilizzo memoria: +.br +\fIDIZIONARIO\fP * 11.5 (se \fIDIZIONARIO\fP <= 32 MiB); +.br +\fIDIZIONARIO\fP * 10.5 (se \fIDIZIONARIO\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fIMODALITÀ\fP +La \fIMODALITÀ\fP di compressione specifica il metodo per analizzare i dati +prodotti dal cercatore di corrispondenze. Le \fIMODALITÀ\fP supportate sono +\fBfast\fP e \fBnormal\fP. Il predefinito è \fBfast\fP per i \fIPRESET\fP 0\(en3 e +\fBnormal\fP per i \fIPRESET\fP 4\(en9. +.IP "" +Di solito \fBfast\fP viene utilizzato con i cercatori di corrispondenze a +catena hash e \fBnormal\fP con i cercatori di corrispondenze a albero +binario. Questo è anche quello che fanno i \fIPRESET\fP. +.TP +\fBnice=\fP\fINICE\fP +Specifica quella che si considera una lunghezza accettabile ("nice") per una +corrispondenza. Una volta trovata una corrispondenza di almeno \fINICE\fP byte, +l'algoritmo smette di cercare corrispondenze potenzialmente migliori. +.IP "" +\fINICE\fP può valere 2\(en273 byte. Valori più alti tendono a dare un miglior +rapporto di compressione ai danni della velocità. Il valore predefinito +dipende dal \fIPRESET\fP. +.TP +\fBdepth=\fP\fIPROFONDITÀ\fP +Specificare la profondità di ricerca massima nel cercatore di +corrispondenze. Il valore predefinito è il valore speciale 0, che dice al +compressore di determinare una \fIPROFONDITÀ\fP ragionevole da \fICERCATORE\fP e +\fINICE\fP. +.IP "" +Una \fIPROFONDITÀ\fP ragionevole per le catene hash è 4\(en100 e 16\(en1000 per +gli alberi binari. Utilizzando valori di \fIPROFONDITÀ\fP molto alti si può +rendere il codificatore estremamente lento con alcuni file. Evitare di +impostare la \fIPROFONDITÀ\fP oltre 1000 a meno che si sia preparati a +interrompere la compressione nel caso in cui richieda troppo tempo. +.RE +.IP "" +Quando si decomprime un flusso grezzo (\fB\-\-format=raw\fP), LZMA2 ha bisogno +solamente della \fIDIMENSIONE\fP del dizionario. LZMA1 ha anche bisogno di +\fIlc\fP, \fIlp\fP, e \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIOPZIONI\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIOPZIONI\fP] +.PD +Aggiunge un filtro branch/call/jump (BCJ) alla catena dei filtri. Questi +filtri non possono essere utilizzati come ultimo filtro nella catena di +filtri. +.IP "" +Un filtro BCJ converte gli indirizzi relativi in codice macchina nelle loro +controparti assolute. Questo non cambia la dimensione dei dati ma aumenta la +ridondanza, cosa che può aiutare LZMA2 a produrre \fB.xz\fP file 0\(en15\ % più +piccoli. I filtri BCJ sono sempre reversibili, quindi usare un filtro BCJ +per il tipo di dati sbagliato non causa perdita di dati, al massimo può +determinare un rapporto di compressione leggermente peggiore. I filtri BCJ +sono molto veloci e usano una quantità di memoria minima. +.IP "" +Questi filtri BCJ presentano problemi noti relativi al rapporto di +compressione: +.RS +.IP \(bu 3 +Alcuni tipi di file contenenti codice eseguibile (ad esempio, file oggetto, +librerie statiche e moduli del kernel Linux) hanno gli indirizzi nelle +istruzioni riempiti con valori di riempimento. Questi filtri BCJ eseguiranno +comunque la conversione degli indirizzi, il che peggiorerà la compressione +con questi file. +.IP \(bu 3 +Se un filtro BCJ viene applicato a un archivio, è possibile che renda il +rapporto di compressione peggiore rispetto a non usare un filtro BCJ. Ad +esempio, se ci sono eseguibili simili o addirittura identici, il filtraggio +probabilmente renderà i file meno simili e quindi la compressione sarà +peggiore. Anche il contenuto dei file non eseguibili nello stesso archivio +può essere importante. In pratica bisogna provare con e senza filtro BCJ per +vedere quale sia il migliore in ogni situazione. +.RE +.IP "" +Insiemi diversi di istruzioni hanno diversi allineamenti: il file eseguibile +deve essere allineato a un multiplo di questo valore nei dati di input per +far funzionare il filtro. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filtro;Allineamento;Note +x86;1;32\-bit o 64\-bit x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;L'allineamento migliore è a 4096 byte +PowerPC;4;Solo big\-endian +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Dal momento che i dati filtrati da BCJ solitamente sono compressi con LZMA2, +il rapporto di compressione può essere migliorato leggermente se le opzioni +LZMA2 sono impostate in modo che corrispondano all'allineamento del filtro +BCJ selezionato. Esempi: +.RS +.IP \(bu 3 +Il filtro IA\-64 ha un allineamento a 16 byte, quindi \fBpb=4,lp=4,lc=0\fP è una +buona scelta per LZMA2 (2^4=16). +.IP \(bu 3 +Il codice RISC\-V ha un allineamento a 2 o 4 byte a seconda che il file +contenga o meno istruzioni 16 bit compresse (cosiddetta estensione +C). Quando sono usate istruzioni a 16 bit, va bene \fBpb=2,lp=1,lc=3\fP o +\fBpb=1,lp=1,lc=3\fP. Quando le istruzioni a 16 bit non sono presenti, è meglio +\fBpb=2,lp=2,lc=2\fP. Si può usare \fBreadelf \-h\fP per controllare se "RVC" +appare sulla riga del "Flag". +.IP \(bu 3 +ARM64 è sempre allineato a 4 byte, quindi \fBpb=2,lp=2,lc=2\fP è la scelta +migliore. +.IP \(bu 3 +Il filtro x86 è un'eccezione. Di solito è bene attenersi alle impostazioni +predefinite di LZMA2 (\fBpb=2,lp=0,lc=3\fP) quando si comprimono gli eseguibili +x86. +.RE +.IP "" +Tutti i filtri BCJ supportano le stesse \fIOPZIONI\fP: +.RS +.TP +\fBstart=\fP\fIOFFSET\fP +Specifica l'\fIOFFSET\fP iniziale utilizzato per la conversione tra indirizzi +relativi e assoluti. L'\fIOFFSET\fP deve essere un multiplo dell'allineamento +del filtro (vedere la tabella sopra). Il valore predefinito è zero. In +pratica, l'impostazione predefinita è buona; specificare un \fIOFFSET\fP +personalizzato non è quasi mai utile. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIOPZIONI\fP] +Aggiunge un filtro Delta alla catena dei filtri. I filtri Delta non possono +essere utilizzati come ultimo filtro nella catena di filtri. +.IP "" +Al momento è supportato solo un semplice calcolo delta byte\-per\-byte. Può +essere utile quando si comprime, per esempio, immagini bitmap non compresse +o file audio PCM non compressi. Tuttavia, speciali algoritmi ad\-hoc +potrebbero dare risultati significativamente migliori che Delta + +LZMA2. Questo è vero specialmente per l'audio, che comprime più velocemente +e meglio, ad esempio, con \fBflac\fP(1). +.IP "" +\fIOPZIONI\fP supportate: +.RS +.TP +\fBdist=\fP\fIDISTANZA\fP +Specifica la \fIDISTANZA\fP del calcolo delta in byte. \fIDISTANZA\fP deve essere +nel range 1\(en256. Il valore predefinito è 1. +.IP "" +Per esempio, con \fBdist=2\fP e un input di 8 byte A1 B1 A2 B3 A3 B5 A4 B7, +l'output sarà A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Altre opzioni" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Sopprime avvertimenti e avvisi. Specificarlo due volte per eliminare anche +gli errori. Questa opzione non ha alcun effetto sullo stato di uscita. In +altre parole, anche se un avvertimento è stato eliminato, lo stato di uscita +che indica un avvertimento viene comunque utilizzato. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Sii prolisso. Se lo standard error è collegato a un terminale, \fBxz\fP +visualizzerà un indicatore di avanzamento. Specificando \fB\-\-verbose\fP due +volte si otterrà un output ancora più dettagliato. +.IP "" +L'indicatore di avanzamento mostra le seguenti informazioni: +.RS +.IP \(bu 3 +La percentuale di avanzamento è mostrata se la dimensione del file input è +nota. Quindi, la percentuale non può essere mostrata nei pipe. +.IP \(bu 3 +Quantità di dati compressi prodotti (in compressione) o utilizzati (in +decompressione). +.IP \(bu 3 +Quantità di dati non compressi consumati (in compressione) o prodotti (in +decompressione). +.IP \(bu 3 +Rapporto di compressione, calcolato dividendo la quantità di dati compressi +processati finora con la quantità di dati non compressi processati finora. +.IP \(bu 3 +Velocità di compressione o decompressione. Questa è misurata come la +quantità di dati non compressi consumati (in compressione) o prodotti (in +decompressione) al secondo. Viene mostrata dopo che è trascorso qualche +secondo da quando \fBxz\fP ha iniziato a processare il file. +.IP \(bu 3 +Tempo trascorso nel formato M:SS o H:MM:SS. +.IP \(bu 3 +Il tempo residuo stimato è mostrato solo quando la dimensione del file in +ingresso è nota e sono già passati un paio di secondi da quando \fBxz\fP ha +iniziato a processare il file. Il tempo è mostrato in un formato meno +preciso che non ha mai i due punti, ad esempio 2 min 30 s. +.RE +.IP "" +Quando lo standard error non è un terminale, \fB\-\-verbose\fP farà stampare a +\fBxz\fP il nome del file, la dimensione compressa, la dimensione non +compressa, il rapporto di compressione, e potendo anche la velocità e il +tempo trascorso, su una singola riga dello standard error, dopo aver +compresso o decompresso il file. La velocità e il tempo trascorso sono +inclusi solo se l'operazione è durata almeno un paio di secondi. Se +l'operazione non è conclusa, ad esempio a causa dell'interruzione da parte +dell'utente, viene stampata anche la percentuale di completamento, a patto +che la dimensione del file input sia nota. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Non impostare lo stato di uscita a 2 anche se è stata rilevata una +condizione che merita un avvertimento. Questa opzione non influisce sul +livello di dettaglio, quindi sia \fB\-\-quiet\fP che \fB\-\-no\-warn\fP devono essere +utilizzati per non visualizzare avvertimenti e per non alterare lo stato di +uscita. +.TP +\fB\-\-robot\fP +Stampa i messaggi in un formato analizzabile dal computer. Questo ha lo +scopo di facilitare la scrittura dei frontend che vogliono usare \fBxz\fP +invece di liblzma, che potrebbe essere il caso di vari script. Si intende +che con questa opzione abilitata l'output dovrebbe rimanere stabile tra le +versioni di \fBxz\fP. Per ulteriori informazioni, vedere la sezione \fBMODALITÀ ROBOT\fP. +.TP +\fB\-\-info\-memory\fP +Mostra, in un formato leggibile da umani, quanta memoria fisica (RAM) e +quante thread \fBxz\fP pensa che il sistema abbia e i limiti di utilizzo di +memoria per la compressione e la decompressione, quindi termina con +successo. +.TP +\fB\-h\fP, \fB\-\-help\fP +Mostra un messaggio di aiuto che descrive le opzioni usate più comunemente, +e termina con successo. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Mostra un messaggio di aiuto che descrive tutte le funzionalità di \fBxz\fP, e +termina con successo +.TP +\fB\-V\fP, \fB\-\-version\fP +Mostra il numero di versione di \fBxz\fP e liblzma in un formato leggibile +dagli umani. Per ottenere un output analizzabile da una macchina specificare +\fB\-\-robot\fP prima di \fB\-\-version\fP. +. +.SH "MODALITÀ ROBOT" +La "modalità robot" viene attivata con l'opzione \fB\-\-robot\fP. Rende l'output +di \fBxz\fP più facile da analizzare da altri programmi. Attualmente \fB\-\-robot\fP +è supportato solo insieme a \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP e +\fB\-\-version\fP. In futuro sarà supportato per la compressione e la +decompressione. +. +.SS "Modalità stampa" +\fBxz \-\-robot \-\-list\fP usa un output separato da tabulazione. La prima colonna +di ogni riga contiene una stringa che indica il tipo di informazione +contenuta in quella riga: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Questa è sempre la prima riga quando si inizia a elencare un file. La +seconda colonna della riga è il nome del file. +.TP +\fBfile\fP +Questa riga contiene informazioni generali sul file \fB.xz\fP. Questa riga +viene sempre stampata dopo la riga \fBname\fP. +.TP +\fBstream\fP +Questo tipo di riga viene utilizzato solo quando è stato specificato +\fB\-\-verbose\fP. Sono presenti tante righe \fBstream\fP quanti sono i flussi nel +file \fB.xz\fP. +.TP +\fBblock\fP +Questo tipo di riga viene utilizzato solo quando è stato specificato +\fB\-\-verbose\fP. Ci sono tante righe \fBblock\fP quanti sono i blocchi nel file +\&\fB.xz\fP. Le righe \fBblock\fP vengono visualizzate dopo tutte le righe +\fBstream\fP; i diversi tipi di riga non vengono interlacciati. +.TP +\fBsummary\fP +Questo tipo di riga viene utilizzato solo quando \fB\-\-verbose\fP è stato +specificato due volte. Questa riga viene stampata dopo tutte le righe +\fBblock\fP. Come la riga \fBfile\fP, la riga \fBsummary\fP contiene informazioni +generali sul file \fB.xz\fP. +.TP +\fBtotals\fP +Questa riga è sempre l'ultima riga dell'output dell'elenco. Mostra i +conteggi totali e le dimensioni. +.PP +Le colonne delle righe \fBfile\fP: +.PD 0 +.RS +.IP 2. 4 +Numero di flussi nel file +.IP 3. 4 +Numero totale di blocchi nel flusso/i. +.IP 4. 4 +Dimensione compressa del file +.IP 5. 4 +Dimensione non compressa del file +.IP 6. 4 +Rapporto di compressione, es. \fB0.123\fP. Se il rapporto è oltre 9999, al +posto del rapporto vengono mostrati tre trattini (\fB\-\-\-\fP). +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Elenco separato da virgole dei nomi dei controlli di integrità. Le stringhe +seguenti vengono utilizzate per i tipi di controllo conosciuti: \fBNone\fP, +\fBCRC32\fP, \fBCRC64\fP, e \fBSHA\-256\fP. Per i tipi di controllo non conosciuti +viene utilizzato \fBUnknown\-\fP\fIN\fP, dove \fIN\fP è l'ID del controllo come numero +decimale (una o due cifre). +.IP 8. 4 +Dimensione totale del padding del flusso nel file +.RE +.PD +.PP +Le colonne delle righe \fBstream\fP: +.PD 0 +.RS +.IP 2. 4 +Numero di flusso (il primo è 1) +.IP 3. 4 +Numero di blocchi nel flusso +.IP 4. 4 +Offset iniziale compressione +.IP 5. 4 +Offset iniziale decompressione +.IP 6. 4 +Dimensione compressa (non include il padding del flusso) +.IP 7. 4 +Dimensione non compressa +.IP 8. 4 +Rapporto di compressione +.IP 9. 4 +Nome del controllo di integrità +.IP 10. 4 +Dimensione del padding del flusso +.RE +.PD +.PP +Le colonne delle righe \fBblock\fP: +.PD 0 +.RS +.IP 2. 4 +Numero di flussi che contengono questo blocco +.IP 3. 4 +Numero del blocco relativo all'inizio del flusso (il primo blocco è 1) +.IP 4. 4 +Numero del blocco relativo all'inizio del file +.IP 5. 4 +Offset iniziale compressione relativo all'inizio del file +.IP 6. 4 +Offset iniziale decompressione relativo all'inizio del file +.IP 7. 4 +Dimensione totale compressa del blocco (incluse le intestazioni) +.IP 8. 4 +Dimensione non compressa +.IP 9. 4 +Rapporto di compressione +.IP 10. 4 +Nome del controllo di integrità +.RE +.PD +.PP +Se \fB\-\-verbose\fP viene specificato due volte, sono incluse colonne aggiuntive +nelle righe \fBblock\fP. Queste non sono mostrate con un \fB\-\-verbose\fP singolo, +perché recuperare queste informazioni richiede molte ricerche e quindi può +essere lento: +.PD 0 +.RS +.IP 11. 4 +Valore del controllo di integrità in formato esadecimale +.IP 12. 4 +Dimensione intestazione blocco +.IP 13. 4 +Flag del blocco: \fBc\fPindica che è presente la dimensione compressa, \fBu\fP +indica che è presente la dimensione non compressa. Se il flag non è +impostato, viene mostrato un trattino (\fB\-\fP) per mantenere fissa la +lunghezza della stringa. Nuovi flag potrebbero essere aggiunti alla fine +della stringa in futuro. +.IP 14. 4 +Dimensione dei dati compressi effettivi nel blocco (sono esclusi +l'intestazione del blocco, il padding del blocco e i campi di controllo) +.IP 15. 4 +Quantità di memoria (in byte) necessaria per decomprimere questo blocco con +questa versione \fBxz\fP +.IP 16. 4 +Catena di filtri. Si noti che la maggior parte delle opzioni utilizzate al +momento della compressione non è nota, perché solo le opzioni necessarie per +la decompressione sono memorizzate nelle intestazioni \fB.xz\fP. +.RE +.PD +.PP +Le colonne delle righe \fBsummary\fP: +.PD 0 +.RS +.IP 2. 4 +Quantità di memoria (in byte) necessaria per decomprimere questo file con +questa versione \fBxz\fP +.IP 3. 4 +\fByes\fP o \fBno\fP indica se tutte le intestazioni di blocco contengono +all'interno sia dimensioni compresse che dimensioni non compresse +.PP +\fIA partire da\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Versione minima di \fBxz\fP richiesta per decomprimere il file +.RE +.PD +.PP +Le colonne delle righe \fBtotali\fP: +.PD 0 +.RS +.IP 2. 4 +Numero di flussi +.IP 3. 4 +Numero di blocchi +.IP 4. 4 +Dimensione compressa +.IP 5. 4 +Dimensione non compressa +.IP 6. 4 +Rapporto di compressione medio +.IP 7. 4 +Elenco separato da virgole dei nomi dei controlli di integrità presenti nei +file +.IP 8. 4 +Dimensione del padding dello stream +.IP 9. 4 +Numero di file. Questo serve a mantenere l'ordine delle colonne precedenti +uguale a quello delle righe del \fBfile\fP. +.PD +.RE +.PP +Se \fB\-\-verbose\fP viene specificato due volte, sono incluse colonne aggiuntive +nella riga \fBtotali\fP: +.PD 0 +.RS +.IP 10. 4 +Quantità massima di memoria (in byte) necessaria per decomprimere i file con +questa versione \fBxz\fP +.IP 11. 4 +\fByes\fP o \fBno\fP indica se tutte le intestazioni di blocco contengono +all'interno sia dimensioni compresse che dimensioni non compresse +.PP +\fIA partire da\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Versione minima di \fBxz\fP richiesta per decomprimere il file +.RE +.PD +.PP +Versioni future potrebbero aggiungere nuovi tipi di riga e nuove colonne +possono essere aggiunte ai tipi di riga esistenti, ma le colonne esistenti +non verranno modificate. +. +.SS "Aiuto sui filtri" +\fBxz \-\-robot \-\-filters\-help\fP stampa i filtri supportati nel seguente +formato: +.PP +\fIFILTRO\fP\fB:\fP\fIOPZIONE\fP\fB=<\fP\fIVALORE\fP\fB>,\fP\fIOPZIONE\fP\fB=<\fP\fIVALORE\fP\fB>\fP... +.TP +\fIFILTRO\fP +Nome del filtro +.TP +\fIOPZIONE\fP +Nome di un'opzione specifica del filtro +.TP +\fIVALORE\fP +Gli intervalli del \fIVALORE\fP numerico appaiono come +\fB<\fP\fIMIN\fP\fB\-\fP\fIMAX\fP\fB>\fP. Le scelte per i \fIVALORI\fP stringa sono +mostrati in \fB< >\fP e separati dal carattere \fB|\fP. +.PP +Ogni filtro è mostrato su una riga dedicata. +. +.SS "Informazione limite memoria" +\fBxz \-\-robot \-\-info\-memory\fP stampa una singola riga con più colonne separate +da tabulazione: +.IP 1. 4 +Quantità totale di memoria fisica (RAM) in byte. +.IP 2. 4 +Limite utilizzo memoria per la compressione in byte +(\fB\-\-memlimit\-compress\fP). Il valore speciale \fB0\fP indica l'impostazione +predefinita, che in modalità thread singola equivale a nessun limite. +.IP 3. 4 +Limite utilizzo memoria per la decompressione in byte +(\fB\-\-memlimit\-decompress\fP). Il valore speciale \fB0\fP indica l'impostazione +predefinita, che in modalità thread singola equivale a nessun limite. +.IP 4. 4 +A partire da \fBxz\fP 5.3.4alpha: Utilizzo della memoria per la decompressione +a thread multiple in byte (\fB\-\-memlimit\-mt\-decompress\fP). Questo valore non è +mai zero perché viene utilizzato un valore predefinito specifico del sistema +mostrato nella colonna 5, se non è stato specificato alcun limite in modo +esplicito. Inoltre, non è mai maggiore del valore nella colonna 3, anche se +è stato specificato un valore maggiore con \fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +A partire da \fBxz\fP 5.3.4alpha: un limite di utilizzo della memoria +predefinito specifico del sistema, che viene utilizzato per limitare il +numero di thread durante la compressione con un numero automatico di thread +(\fB\-\-threads=0\fP) e non è stato specificato alcun limite di utilizzo della +memoria (\fB\-\-memlimit\-compress\fP). Questo viene utilizzato anche come valore +predefinito per \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +A partire da \fBxz\fP 5.3.4alpha: Numero di thread del processore disponibili. +.PP +In futuro, l'output di \fBxz \-\-robot \-\-info\-memory\fP potrebbe avere più +colonne, ma mai più di una singola riga. +. +.SS Versione +\fBxz \-\-robot \-\-version\fP stampa il numero di versione di \fBxz\fP e liblzma nel +seguente formato: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Versione major. +.TP +\fIYYY\fP +Versione minor. I numeri pari sono stabili. I numeri dispari sono versioni +alfa o beta. +.TP +\fIZZZ\fP +Livello di patch per le versioni stabili o solo un contatore per le versioni +di sviluppo. +.TP +\fIS\fP +Stabilità. 0 è alfa, 1 è beta e 2 è stabile. \fIS\fP dovrebbe essere sempre 2 +quando \fIYYY\fP è pari. +.PP +\fIXYYYZZZS\fP sono uguali su entrambe le righe se \fBxz\fP e liblzma appartengono +allo stesso rilascio delle XZ Utils. +.PP +Esempi: 4.999.9beta è \fB49990091\fP e 5.0.0 è \fB50000002\fP. +. +.SH "CODICE DI USCITA" +.TP +\fB0\fP +Tutto bene. +.TP +\fB1\fP +È avvenuto un errore. +.TP +\fB2\fP +Si è verificato qualcosa che merita un avvertimento, ma non si sono +verificati errori effettivi. +.PP +Gli avvisi (non gli avvertimenti o gli errori) stampati sullo standard error +non influiscono sullo stato di uscita. +. +.SH AMBIENTE +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP analizza elenchi di opzioni separate da spazi dalle variabili +d'ambiente \fBXZ_DEFAULTS\fP e \fBXZ_OPT\fP, in questo ordine, analizzando prima +le opzioni dalla riga di comando. Si noti che solo le opzioni vengono +analizzate dalle variabili d'ambiente; tutte le non\-opzioni vengono ignorate +silenziosamente. L'analisi viene eseguita con \fBgetopt_long\fP(3) che viene +utilizzato anche per gli argomenti della riga di comando. +.PP +\fBAttenzione:\fP Impostando queste variabili di ambiente, si sta di fatto +modificando programmi e script che lanciano \fBxz\fP. La maggior parte delle +volte va bene impostare i limiti di utilizzo della memoria, il numero di +thread e le opzioni di compressione tramite variabili d'ambiente. Tuttavia, +alcune opzioni possono rompere degli script. Un esempio banale è \fB\-\-help\fP +che forza \fBxz\fP a mostrare la pagina di aiuto anziché comprimere o +decomprimere file. Esempi meno ovvi sono \fB\-\-quiet\fP e \fB\-\-verbose\fP. In +molti casi funziona bene abilitare l'indicatore di avanzamento usando +\fB\-\-verbose\fP, ma in alcune situazioni i messaggi extra creano problemi. Il +livello di prolissità influisce anche sul comportamento di \fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Opzioni predefinite specifiche dell'utente o a livello di sistema. In genere +questo viene impostato in uno script di inizializzazione della shell per +abilitare il valore predefinito del limitatore di utilizzo della memoria di +\fBxz\fP, o per impostare il numero di thread predefinito. Escludendo gli +script di inizializzazione della shell e analoghi casi particolari, gli +script non dovrebbero mai impostare o annullare l'impostazione di +\fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Questo serve per passare le opzioni a \fBxz\fP quando non sia possibile +impostare le opzioni direttamente sulla riga di comando di \fBxz\fP. Questo è +il caso quando \fBxz\fP viene eseguito da uno script o da uno strumento, ad +esempio GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Gli script possono usare \fBXZ_OPT\fP, per esempio, per impostare opzioni di +compressione predefinite specifiche per lo script. Si raccomanda comunque di +permettere agli utenti di sovrascrivere \fBXZ_OPT\fPse questo è ragionevole. Ad +esempio, negli script \fBsh\fP(1) si può usare qualcosa come questo: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "COMPATIBILITÀ LZMA UTILS" +La sintassi della riga di comando di \fBxz\fP è essenzialmente un sopra\-insieme +di \fBlzma\fP, \fBunlzma\fP, e \fBlzcat\fP come trovati nelle LZMA Utils +4.32.x. Nella maggior parte dei casi è possibili sostituire le LZMA Utils +con le XZ Utils senza rompere gli script esistenti. Ci sono però alcune +incompatibilità, che in alcuni casi potrebbero causare problemi. +. +.SS "Livelli di compressione preimpostati" +La numerazione dei livelli di compressione preimpostati non è identica in +\fBxz\fP e nelle LZMA Utils. La differenza più importante è il modo in cui le +dimensioni del dizionario vengono mappate sulle diverse preimpostazioni. La +dimensione del dizionario è approssimativamente uguale all'utilizzo della +memoria del decompressore. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Livello;xz;LZMA Utils +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Le differenze di dimensione del dizionario influiscono anche sull'utilizzo +della memoria del compressore, ma ci sono alcune altre differenze tra le +LZMA Utils e le XZ Utils, che rendono la differenza ancora più grande: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Livello;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Il livello preimpostato predefinito nelle LZMA Utils è \fB\-7\fP mentre nelle XZ +Utils è \fB\-6\fP, quindi entrambi utilizzano un dizionario da 8 MiB per +impostazione predefinita. +. +.SS "File .lzma con flussi vs. senza flussi" +La dimensione non compressa del file può essere memorizzata +nell'intestazione \fB.lzma\fP. Le LZMA Utils lo fanno durante la compressione +di file regolari. L'alternativa consiste nel memorizzare che la dimensione +non compressa è sconosciuta e utilizzare l'indicatore di fine carico utile +per indicare il punto in cui il decompressore deve fermarsi. Le LZMA Utils +utilizzano questo metodo quando le dimensioni non compresse non sono note, +come nel caso, ad esempio, delle pipe. +.PP +\fBxz\fP supporta la decompressione di file \fB.lzma\fP con o senza il marcatore +di fine payload, ma tutti i file \fB.lzma\fP creati da \fBxz\fP utilizzeranno il +marcatore di fine payload e avranno dimensioni non compresse contrassegnate +come sconosciute nell'intestazione \fB.lzma\fP. Questo può essere un problema +in alcune situazioni non comuni. Ad esempio, un decompressore \fB.lzma\fP in un +dispositivo embedded potrebbe funzionare solo con file con dimensioni non +compresse note. Se si incorre in questo problema, occorre utilizzare le LZMA +Utils oppure l'LZMA SDK per creare dei file \fB.lzma\fP con dimensioni non +compresse note. +. +.SS "File .lzma non supportati" +Il formato \fB.lzma\fP permette valori \fIlc\fP fino a 8, e valori \fIlp\fP fino a +4. Le LZMA Utils possono decomprimere file con qualunque \fIlc\fP e \fIlp\fP, ma +creeranno sempre file con \fBlc=3\fP e \fBlp=0\fP. Creare file con altri \fIlc\fP e +\fIlp\fP è possibile con \fBxz\fP e con l'LZMA SDK. +.PP +L'implementazione del filtro LZMA1 in liblzma richiede che la somma di \fIlc\fP +e \fIlp\fP non debba superare 4. Pertanto, i file \fB.lzma\fP che superano questa +limitazione non possono essere decompressi con \fBxz\fP. +.PP +Le LZMA Utils creano solo file \fB.lzma\fP con dimensione del dizionario 2^\fIn\fP +(una potenza di 2) ma accettano file con qualsiasi dimensione di +dizionario. liblzma accetta solo file \fB.lzma\fP con dimensione del dizionario +2^\fIn\fP o 2^\fIn\fP + 2^(\fIn\fP\-1). Questo serve a limitare i falsi positivi +quando si cerca di identificare i file \fB.lzma\fP. +.PP +All'atto pratico queste limitazioni non dovrebbero essere un problema, +perché praticamente tutti i file \fB.lzma\fP sono stati compressi con +impostazioni che liblzma accetterà. +. +.SS "Dati sporchi finali" +Quando si decomprime, le LZMA Utils ignorano automaticamente tutto quello +che c'è dopo il primo flusso \fB.lzma\fP. Nella maggior parte delle situazioni +questo è un baco. Questo significa anche che le LZMA Utils non supportano la +decompressione di file \fB.lzma\fP concatenati. +.PP +Se sono rimasti dati dopo il primo flusso \fB.lzma\fP, \fBxz\fP considera il file +corrotto a meno che sia stato utilizzato \fB\-\-single\-stream\fP. Questo può far +rompere script incomprensibili che hanno assunto che i dati sporchi finali +vengano ignorati. +. +.SH NOTE +. +.SS "L'output compresso può variare" +L'esatto output compresso prodotto dallo stesso file di input non compresso +può variare tra le versioni delle XZ Utils, anche se le opzioni di +compressione sono le stesse. Questo perché il codificatore può essere stato +migliorato (compressione più veloce o migliore) senza influire sul formato +del file. L'output può variare anche tra diverse build della stessa versione +delle XZ Utils, se vengono utilizzate opzioni di build differenti. +.PP +Quanto sopra significa che una volta che \fB\-\-rsyncable\fP è stato +implementato, i file risultanti non saranno necessariamente rsync\-abili a +meno che sia i vecchi che i nuovi file non siano stati compressi con la +stessa versione di xz. Questo problema può essere risolto se una parte +dell'implementazione del codificatore viene congelata per mantenere stabile +l'output rsync\-abile tra le versioni di xz. +. +.SS "Abilita i decompressori .xz" +Le implementazioni dei decompressori \fB.xz\fP embedded, come XZ Embedded, non +necessariamente supportano file creati con tipi di integrità \fICONTROLLO\fP +diversi da \fBnone\fP e \fBcrc32\fP. Dal momento che il valore predefinito è +\fB\-\-check=crc64\fP, occorre specificare \fB\-\-check=none\fP o \fB\-\-check=crc32\fP +quando si creano file per sistemi embedded. +.PP +Al di fuori dei sistemi embedded, tutti i decompressori in formato \fB.xz\fP +supportano tutti i tipi di \fICONTROLLO\fP, o almeno sono in grado di +decomprimere il file senza verificare il controllo di integrità se il +particolare \fICONTROLLO\fP non è supportato. +.PP +XZ Embedded supporta i filtri BCJ, ma solo con offset iniziale predefinito. +. +.SH ESEMPI +. +.SS "Informazioni di base" +Comprime il file \fIfoo\fP in \fIfoo.xz\fP utilizzando il livello di compressione +predefinito (\fB\-6\fP) e rimuove \fIfoo\fP se la compressione ha esito positivo: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Decomprime \fIbar.xz\fP in \fIbar\fP e non rimuove \fIbar.xz\fP anche se la +decompressione ha successo: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Crea \fIbaz.tar.xz\fP con il preset \fB\-4e\fP (\fB\-4 \-\-extreme\fP), che è più lenta +della predefinita \fB\-6\fP, ma ha bisogno di meno memoria per la compressione e +decompressione (48\ MiB e 5\ MiB, rispettivamente): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Una combinazione di file compressi e non compressi può essere decompressa +sullo output standard con un singolo comando: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Compressione parallela di più file" +Su GNU e *BSD, \fBfind\fP(1) e \fBxargs\fP(1) possono essere usati per +parallelizzare la compressione di più file: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +L'opzione \fB\-p\fP di \fBxargs\fP(1) imposta il numero di processi \fBxz\fP +paralleli. Il valore migliore per l'opzione \fB\-n\fP dipende dal numero di file +da comprimere. Se sono presenti solo un paio di file, il valore dovrebbe +probabilmente essere 1; con decine di migliaia di file, 100 o anche di più +può essere appropriato per ridurre il numero di processi \fBxz\fP che +\fBxargs\fP(1) alla fine creerà. +.PP +L'opzione \fB\-T1\fP per \fBxz\fP serve a forzare la modalità a thread singola, +perché \fBxargs\fP (1) viene utilizzato per controllare la quantità di +parallelizzazione. +. +.SS "Modalità robot" +Calcola quanti byte sono stati salvati in totale dopo la compressione di più +file: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Uno script potrebbe voler sapere se si sta utilizzando una versione di \fBxz\fP +sufficientemente recente. Il seguente script \fBsh\fP(1) controlla che il +numero di versione dello strumento \fBxz\fP sia almeno 5.0.0. Questo metodo è +compatibile con le vecchie versioni beta, che non supportavano l'opzione +\fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Imposta un limite di utilizzo della memoria per la decompressione +utilizzando \fBXZ_OPT\fP, ma se è già stato impostato un limite, non lo +aumenta: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Catene di filtri di compressione personalizzate" +L'uso più semplice delle catene di filtri personalizzate è la +personalizzazione di un preset di LZMA2. Questo può essere utile, perché i +preset coprono solamente un sottoinsieme di tutte le combinazioni di +impostazioni di compressione potenzialmente utili. +.PP +Le colonne CompCPU delle tabelle dalle descrizioni delle opzioni \fB\-0\fP +\&... \fB\-9\fP e \fB\-\-extreme\fP sono utili quando si personalizzano i preset di +LZMA2. Di seguito sono riportate le parti rilevanti raccolte da queste due +tabelle: +.RS +.PP +.TS +tab(;); +c c +n n. +Livello preimpostato;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Se si sa che un file richiede un dizionario piuttosto grande (ad esempio, +32\ MiB) per essere compresso bene, ma si desidera comprimerlo più +velocemente di quanto farebbe \fBxz \-8\fP, è possibile modificare un preset con +un basso valore CompCPU (ad esempio, 1) per utilizzare un dizionario più +grande: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Con alcuni file, il comando sopra potrebbe essere più veloce di \fBxz \-6\fP e +la compressione significativamente migliore. Tuttavia, si deve sottolineare +che solo alcuni file traggono beneficio da un dizionario grande e mantengono +basso il valore di CompCPU. La situazione più ovvia in cui un dizionario +grande può aiutare molto è un archivio contenente file molto simili di +almeno un paio di megabyte ciascuno. La dimensione del dizionario deve +essere significativamente più grande di ogni singolo file per permettere a +LZMA2 di trarre pieno vantaggio dalle somiglianze tra file consecutivi. +.PP +Se l'utilizzo molto elevato della memoria del compressore e del +decompressore è accettabile, e il file da comprimere è almeno di diverse +centinaia di megabyte, potrebbe essere utile utilizzare un dizionario ancora +più grande dei 64 MiB che \fBxz \-9\fP utilizzerebbe: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +L'uso di \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) come nell'esempio precedente può +essere utile per vedere i requisiti di memoria del compressore e del +decompressore. Tenere presente che l'utilizzo di un dizionario più grande +della dimensione del file non compresso è uno spreco di memoria, quindi il +comando precedente non è utile per i file di piccole dimensioni. +.PP +A volte il tempo di compressione non importa, ma l'utilizzo di memoria del +decompressore deve essere tenuta bassa, per esempio, per permettere di +decomprimere il file in un sistema embedded. Il comando seguente usa \fB\-6e\fP +(\fB\-6 \-\-extreme\fP) come base e imposta il dizionario a soli 64\ KiB. Il file +risultante può essere decompresso con XZ Embedded (ecco perché c'è +\fB\-\-check=crc32\fP) usando circa 100\ KiB di memoria. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Se si desidera spremere il maggior numero possibile di byte, a volte può +essere utile regolare il numero di bit di contesto letterale (\fIlc\fP) e il +numero di bit di posizione (\fIpb\fP). Anche la regolazione del numero di bit +di posizione letterale (\fIlp\fP) potrebbe essere d'aiuto, ma di solito \fIlc\fP e +\fIpb\fP sono più importanti. Per esempio, un archivio di codici sorgente +contiene principalmente testo US\-ASCII, quindi qualcosa come il seguente +potrebbe produrre un file leggermente (0,1\ %) più piccolo di \fBxz \-6e\fP +(provare anche senza \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Usare un altro filtro insieme a LZMA2 può migliorare la compressione per +alcuni tipi di file. Ad esempio, per comprimere una libreria condivisa +x86\-32 o x86\-64 usare il filtro BCJ: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Si noti che l'ordine delle opzioni di filtro è significativo. Se viene +specificato \fB\-\-x86\fP dopo \fB\-\-lzma2\fP, \fBxz\fP darà un errore, perché non può +esserci alcun filtro dopo LZMA2 e anche perché il filtro BCJ x86 non può +essere utilizzato come ultimo filtro della catena. +.PP +Il filtro Delta insieme con LZMA2 può dare buoni risultati sulle immagini +bitmap. Di solito dovrebbe battere il PNG, il quale ha alcuni filtri più +avanzati rispetto al semplice delta ma utilizza Deflate per la compressione +effettiva. +.PP +L'immagine deve essere salvata in un formato non compresso, ad esempio un +TIFF non compresso. Il parametro distanza del filtro Delta è impostato in +modo che corrisponda al numero di byte per pixel nell'immagine. Per esempio, +un bitmap a 24 bit richiede \fBdist=3\fP, e va anche bene passare \fBpb=0\fP a +LZMA2 per adattarsi all'allineamento a tre byte: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Se più immagini sono state inserite in un singolo archivio (ad esempio, +\&\fB.tar\fP), il filtro Delta funzionerà anche su questo purché tutte le +immagini abbiano lo stesso numero di byte per pixel. +. +.SH "VEDERE ANCHE" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xz.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xz.1 new file mode 100644 index 0000000000000000000000000000000000000000..53a915947bff84fc5f9cfbb4d4ed88097620e055 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xz.1 @@ -0,0 +1,2080 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Italian translations for xz-man package +.\" Luca Vercelli , 2024-2025 +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 08/03/2025 Tukaani "XZ Utils" +. +.SH NOME +xz, unxz, xzcat, lzma, unlzma, lzcat \- Comprime o decomprime file .xz e +\&.lzma +. +.SH SINOSSI +\fBxz\fP [\fIOPZIONE...\fP] [\fIFILE...\fP] +. +.SH "ALIAS DEI COMANDI" +\fBunxz\fP è equivalente a \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP è equivalente a \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP è equivalente a \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP è equivalente a \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP è equivalente a \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Quando si scrivono script che richiedono di decomprimere file, si raccomanda +di utilizzare sempre il comando \fBxz\fP con argomenti appropriati (\fBxz \-d\fP o +\fBxz \-dc\fP) al posto degli alias \fBunxz\fP e \fBxzcat\fP. +. +.SH DESCRIZIONE +\fBxz\fP è uno strumento di compressione dati generico con sintassi della riga +di comando simile a \fBgzip\fP(1) e \fBbzip2\fP(1). Il formato file nativo è +\&\fB.xz\fP, ma sono supportati anche il formato tradizionale \fB.lzma\fP usato +dalle LZMA Utils e i flussi grezzi (raw) compressi senza intestazioni di +formato contenitore. In più, è supportata la decompressione del formato +\&\fB.lz\fPusato da \fBlzip\fP. +.PP +\fBxz\fP comprime o decomprime ogni \fIFILE\fP a seconda della modalità di +funzionamento selezionata. Se nessun \fIFILE\fP è indicato o se \fIFILE\fP è \fB\-\fP, +\fBxz\fP legge dallo standard input e scrive i dati processati sullo standard +output. \fBxz\fP si rifiuterà (stamperà un errore e salterà il \fIFILE\fP) di +scrivere dati compressi sullo standard output se è il +terminale. Analogamente, \fBxz\fP si rifiuterà di leggere dati compressi dallo +standard input se è il terminale. +.PP +A meno che non sia specificato \fB\-\-stdout\fP, i \fIFILE\fP diversi da \fB\-\fP +vengono scritti in un nuovo file il cui nome deriva dal nome del \fIFILE\fP +sorgente: +.IP \(bu 3 +Quando si comprime, il suffisso del file destinazione (\fB.xz\fP or \fB.lzma\fP) +viene accodato al nome del file sorgente per ottenere il nome del file +destinazione. +.IP \(bu 3 +Quando si decomprime, i suffissi \fB.xz\fP, \fB.lzma\fP, o \fB.lz\fP vengono rimossi +dal nome del file per ottenere il nome del file destinazione. \fBxz\fP +riconosce anche i suffissi \fB.txz\fP e \fB.tlz\fP, e li sostituisce con il +suffisso \fB.tar\fP. +.PP +Se il file di destinazione esiste già, viene visualizzato un errore e +\fIFILE\fP viene saltato. +.PP +A meno che non si scriva nello standard output, \fBxz\fP visualizzerà un +avvertimento e salterà il \fIFILE\fP se si verifica una delle seguenti +condizioni: +.IP \(bu 3 +\fIFILE\fP non è un file regolare. I collegamenti simbolici non vengono +seguiti, quindi non sono considerati file regolari. +.IP \(bu 3 +\fIFILE\fP ha più di un collegamento "hard". +.IP \(bu 3 +\fIFILE\fP ha impostati i bit setuid, setgid, o sticky. +.IP \(bu 3 +La modalità di funzionamento è impostata sulla compressione e il \fIFILE\fP ha +già un suffisso del formato di file di destinazione (\fB.xz\fP o \fB.txz\fP quando +si comprime nel formato \fB.xz\fP e \fB.lzma\fP o \fB.tlz\fP quando si comprime nel +formato \fB.lzma\fP). +.IP \(bu 3 +La modalità di funzionamento è impostata sulla decompressione e il \fIFILE\fP +non ha un suffisso di nessuno dei formati di file supportati (\fB.xz\fP, +\&\fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, o \fB.lz\fP). +.PP +Dopo aver compresso o decompresso correttamente il \fIFILE\fP, \fBxz\fP copia il +proprietario, il gruppo, le autorizzazioni, l'ora di accesso e l'ora di +modifica dal \fIFILE\fP di origine al file di destinazione. Se la copia del +gruppo fallisce, le autorizzazioni vengono modificate in modo che il file di +destinazione non diventi accessibile agli utenti che non disponevano +dell'autorizzazione per accedere al \fIFILE\fP di origine. \fBxz\fP non supporta +ancora la copia di altri metadati, ad esempio elenchi di controllo degli +accessi o attributi estesi. +.PP +Una volta che il file di destinazione è stato chiuso con successo, il +\fIFILE\fP sorgente viene rimosso, a meno che sia stato specificato +\fB\-\-keep\fP. Il \fIFILE\fP sorgente non viene mai rimosso se l'output è scritto +sullo standard output, né se si verifica un errore. +.PP +L'invio di \fBSIGINFO\fP o \fBSIGUSR1\fP al processo \fBxz\fP comporta la stampa +delle informazioni sullo stato di avanzamento sullo standard error. Questo +ha solo un uso limitato poiché quando lo standard error è un terminale, +utilizzando \fB\-\-verbose\fP verrà visualizzato un indicatore di avanzamento che +si aggiorna automaticamente. +. +.SS "Utilizzo memoria" +L'utilizzo della memoria di \fBxz\fP varia da poche centinaia di kilobyte a +diversi gigabyte a seconda delle impostazioni di compressione. Le +impostazioni utilizzate durante la compressione di un file determinano i +requisiti di memoria del decompressore. In genere il decompressore richiede +dal 5\% al 20\% della quantità di memoria necessaria al compressore durante +la creazione del file. Ad esempio, la decompressione di un file creato con +\fBxz \-9\fP al momento richiede 65\ MiB di memoria. Ancora, è possibile avere +file \fB.xz\fP che richiedono diversi gigabyte di memoria per la +decompressione. +.PP +Soprattutto gli utenti di sistemi più vecchi possono trovare fastidiosa +l'eventualità di un utilizzo molto elevato di memoria. Per evitare +spiacevoli sorprese, \fBxz\fP dispone di un limitatore di utilizzo della +memoria incorporato, che è disabilitato per impostazione predefinita. Anche +se alcuni sistemi operativi forniscono modi per limitare l'utilizzo della +memoria dei processi, fare affidamento su questi non è stato ritenuto +sufficientemente flessibile (ad esempio, l'uso di \fBulimit\fP(1) per limitare +la memoria virtuale tende a paralizzare \fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Il limitatore di utilizzo della memoria può essere abilitato con l'opzione +della riga di comando \fB\-\-memlimit=\fP\fILIMITE\fP. Spesso è più conveniente +abilitare il limitatore per impostazione predefinita impostando la variabile +d'ambiente \fBXZ_DEFAULTS\fP, ad esempio, \fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. È +possibile impostare separatamente i limiti per la compressione e la +decompressione utilizzando \fB\-\-memlimit\-compress=\fP\fILIMITE\fP and +\fB\-\-memlimit\-decompress=\fP\fILIMITE\fP. L'uso di queste due opzioni al di fuori +di \fBXZ_DEFAULTS\fP è raramente utile perché una singola esecuzione di \fBxz\fP +non può eseguire sia la compressione che la decompressione e +\fB\-\-memlimit=\fP\fILIMITE\fP (or \fB\-M\fP \fILIMITE\fP) è più breve da digitare sulla +riga di comando. +.PP +Se il limite di utilizzo della memoria specificato viene superato durante la +decompressione, \fBxz\fP visualizzerà un errore e la decompressione del file +fallirà. Se il limite viene superato durante la compressione, \fBxz\fP tenterà +di ridimensionare le impostazioni in modo che il limite non venga più +superato (tranne quando si usa \fB\-\-format=raw\fP o \fB\-\-no\-adjust\fP). In questo +modo l'operazione non fallirà a meno che il limite sia molto basso. Il +ridimensionamento delle impostazioni viene eseguito in piccole differenze +che non corrispondono ai livelli di compressione preimpostati, ad esempio, +se il limite è solo leggermente inferiore alla quantità richiesta per \fBxz \-9\fP, le impostazioni saranno ridimensionate solo un poco, non proprio fino a +\fBxz \-8\fP. +. +.SS "Concatenazione e padding con file .xz" +È possibile concatenare i file \fB.xz\fP così come sono. \fBxz\fP decomprimerà +tali file come se fossero un singolo file \fB.xz\fP. +.PP +È possibile inserire un padding tra le parti concatenate o dopo l'ultima +parte. Il padding deve essere costituito da byte "null" e la dimensione del +padding deve essere un multiplo di quattro byte. Questo può essere utile, ad +esempio, se il file \fB.xz\fP è memorizzato su un supporto che misura le +dimensioni dei file in blocchi di 512 byte. +.PP +Concatenazione e padding non sono permessi con file \fB.lzma\fP o con flussi +grezzi. +. +.SH OPZIONI +. +.SS "Suffissi interi e valori speciali" +Nella maggior parte dei casi in cui è previsto un argomento intero, è +supportato un suffisso facoltativo per indicare facilmente numeri interi di +grandi dimensioni. Non deve esserci alcuno spazio tra il numero intero e il +suffisso. +.TP +\fBKiB\fP +Moltiplica l'intero per 1024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP, e \fBKB\fP +sono accettati come sinonimi di \fBKiB\fP. +.TP +\fBMiB\fP +Moltiplica l'intero per 1.048.576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP, e \fBMB\fP sono +accettati come sinonimi di \fBMiB\fP. +.TP +\fBGiB\fP +Moltiplica l'intero per 1.073.741.824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP, e \fBGB\fP +sono accettati come sinonimi di \fBGiB\fP. +.PP +Il valore speciale \fBmax\fP può essere utilizzato per indicare il valore +intero massimo supportato dall'opzione. +. +.SS "Modalità operativa" +Se vengono fornite più opzioni di modalità operativa, l'ultima ha effetto. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Compressione. Questa è la modalità operativa predefinita quando non viene +specificata alcuna opzione della modalità operativa e non è determinata +nessun'altra modalità operativa dal nome del comando (ad esempio, \fBunxz\fP +implica \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Dopo che la compressione è terminata con successo, il file origine viene +rimosso a meno che si stia scrivendo su standard output o che venga +specificato \fB\-\-keep\fP. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Decompressione. Dopo che la decompressione è terminata con successo, il file +origine viene rimosso a meno che si stia scrivendo su standard output o che +venga specificato \fB\-\-keep\fP. +.TP +\fB\-t\fP, \fB\-\-test\fP +Testa l'integrità dei \fIFILE\fP compressi. Questa opzione è equivalente a +\fB\-\-decompress \-\-stdout\fP tranne per il fatto che i dati decompressi vengono +scartati invece di essere scritti nello standard output. Nessun file viene +creato o rimosso. +.TP +\fB\-l\fP, \fB\-\-list\fP +Stampa le informazioni sul \fIFILE\fP compresso. Non viene prodotto alcun +output non compresso e non viene creato o rimosso alcun file. In modalità +elenco, il programma non è in grado di leggere i dati compressi dallo +standard input o da altre fonti che non permettano la ricerca. +.IP "" +Il tracciato predefinito mostra le informazioni di base sui \fIFILE\fP, un file +per riga. Per ottenere informazioni più dettagliate, usare anche l'opzione +\fB\-\-verbose\fP. Per avere ancora più informazioni, usare \fB\-\-verbose\fP due +volte, ma si noti che questo può essere lento, perché ottenere tutte le +informazioni extra richiede molte estrazioni. La larghezza dell'output +dettagliato supera gli 80 caratteri, quindi il reindirizzamento dell'output, +ad esempio, a \fBless\ \-S\fP può essere utile se il terminale non è +sufficientemente ampio. +.IP "" +L'output esatto può variare tra le versioni di \fBxz\fP e le diverse +impostazioni locali. Per un output leggibile dalla macchina si dovrebbe +utilizzare \fB\-\-robot \-\-list\fP. +. +.SS "Modificatori dell'operazione" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Non elimina i file input. +.IP "" +A partire da \fBxz\fP 5.2.6, questa opzione fa sì che \fBxz\fP comprima o +decomprima anche se l'input è un collegamento simbolico a un file regolare, +ha più di un collegamento fisico o ha il bit setuid, setgid o sticky +impostato. I bit setuid, setgid e sticky non vengono copiati nel file di +destinazione. Nelle versioni precedenti questo veniva fatto solo con +\fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Questa opzione ha diverse conseguenze: +.RS +.IP \(bu 3 +Se il file di destinazione esiste già, lo elimina prima di comprimere o +decomprimere. +.IP \(bu 3 +Comprime o decomprime anche se l'input è un collegamento simbolico a un file +regolare, ha più di un collegamento "hard", o ha il bit setuid, setgid o +sticky impostato. I bit setuid, setgid e sticky non sono copiati sul file +destinazione. +.IP \(bu 3 +Quando usato con \fB\-\-decompress\fP \fB\-\-stdout\fP e \fBxz\fP non riesce a +riconoscere il tipo di file sorgente, copia il file sorgente così com'è +sullo standard output. Questo permette a \fBxzcat\fP \fB\-\-force\fP di essere usato +come \fBcat\fP(1) per file che non siano stati compressi con \fBxz\fP. Si noti che +in futuro \fBxz\fP potrebbe supportare nuovi formati di file compressi, il che +potrebbe portare \fBxz\fP a decomprimere più tipi di file anziché copiarli come +sono sullo standard output. \fB\-\-format=\fP\fIFORMATO\fP può essere usato per +forzare \fBxz\fP a decomprimere solo un singolo formato di file. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Scrive i dati compressi o decompressi nello standard output anziché in un +file. Implica \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Decomprime solo il primo flusso \fB.xz\fP, e ignora automaticamente i possibili +dati di input rimanenti che seguono il flusso. Normalmente questi dati +sporchi finali portano \fBxz\fP a visualizzare un errore. +.IP "" +\fBxz\fP non decomprime mai più di un flusso dai file \fB.lzma\fP o dai flussi +grezzi, ma questa opzione fa comunque in modo che \fBxz\fP ignori i possibili +dati finali dopo il file \fB.lzma\fP o il flusso grezzo. +.IP "" +Questa opzione non ha effetto se la modalità operativa non è \fB\-\-decompress\fP +o \fB\-\-test\fP. +.IP "" +Dalla versione \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP implica \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Disabilita la creazione di file sparsi. Per impostazione predefinita, se si +esegue la decompressione in un file regolare, \fBxz\fP tenta di rendere il file +sparso se i dati decompressi contengono lunghe sequenze di zeri +binari. Funziona anche quando si scrive su standard output, purché lo +standard output sia collegato a un file regolare e siano soddisfatte alcune +condizioni aggiuntive per renderlo sicuro. La creazione di file sparsi può +risparmiare spazio su disco e velocizzare la decompressione riducendo la +quantità di I/O su disco. +.TP +\fB\-S\fP \fI.SUFFISSO\fP, \fB\-\-suffix=\fP\fI.SUFFISSO\fP +Durante la compressione, utilizzare \fI.suf\fP come suffisso per il file di +destinazione anziché \fB.xz\fP o \fB.lzma\fP. Se non si scrive nello standard +output e il file di origine ha già il suffisso \fI.suf\fP, viene visualizzato +un avvertimento e il file viene ignorato. +.IP "" +Quando si decomprime, accetta i file con suffisso \fI.suf\fP in aggiunta a +quelli con suffisso \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, o \fB.lz\fP. Se il file +sorgente ha suffisso \fI.suf\fP, il suffisso viene rimosso per ottenere il nome +del file destinazione. +.IP "" +Quando si comprimono o decomprimono flussi grezzi (\fB\-\-format=raw\fP), il +suffisso deve sempre essere specificato, a meno che si scriva sullo standard +output, perché non esiste un suffisso predefinito per i flussi grezzi. +.TP +\fB\-\-files\fP[\fB=\fP\fIFILE\fP] +Legge i nomi dei file da processare da \fIFILE\fP; se \fIFILE\fP è omesso, i nomi +dei file vengono letti dallo standard input. I nomi dei file devono essere +terminati da un carattere "a capo". Un trattino (\fB\-\fP) è considerato come un +nome di file regolare; non indica lo standard input. Se vengono forniti +anche dei nomi di file come argomenti della riga di comando, questi sono +processati prima di quelli letti da \fIFILE\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIFILE\fP] +Questo è identico a \fB\-\-files\fP[\fB=\fP\fIFILE\fP] tranne per il fatto che ogni +nome di file deve terminare con il carattere null. +. +.SS "Formato file di base e opzioni di compressione" +.TP +\fB\-F\fP \fIFORMATO\fP, \fB\-\-format=\fP\fIFORMATO\fP +Specifica il \fIFORMATO\fP del file da comprimere o decomprimere: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Questa è l'impostazione predefinita. Quando si comprime, \fBauto\fP è +equivalente a \fBxz\fP. Quando si decomprime, il formato del file input viene +rilevato automaticamente. Si noti che per i flussi grezzi (creati con +\fB\-\-format=raw\fP) non è possibile il rilevamento automatico. +.TP +\fBxz\fP +Comprime nel formato di file \fB.xz\fP, oppure accetta solo file \fB.xz\fP durante +la decompressione. +.TP +\fBlzma\fP, \fBalone\fP +Comprime nel formato tradizionale \fB.lzma\fP, oppure accetta solo file +\&\fB.lzma\fP per la decompressione. Il nome alternativo \fBalone\fP è fornito per +retrocompatibilità con le LZMA Utils. +.TP +\fBlzip\fP +Accetta solo file \fB.lz\fP per la decompressione. La compressione non è +supportata. +.IP "" +Sono supportate le versioni 0 e 1 del formato \fB.lz\fP. I file in versione 0 +sono stati prodotti da \fBlzip\fP 1.3 e precedenti. Questi file non sono +comuni, ma possono essere trovati negli archivi di file, perché alcuni +pacchetti sorgente erano stati rilasciati in questo formato. Qualcuno +potrebbe anche avere vecchi file personali in questo formato. Il supporto +alla decompressione per la versione di formato 0 è stato rimosso in \fBlzip\fP +1.18. \fBlzip\fP 1.4 e successivi creano i file nella versione di formato 1. +.TP +\fBraw\fP +Comprime o decomprime un flusso grezzo (senza intestazione). Questo è inteso +solamente per utenti avanzati. Per decodificare flussi grezzi, occorre usare +\fB\-\-format=raw\fP e specificare esplicitamente la catena dei filtri, che +normalmente sarebbero conservati nell'intestazione. +.RE +.TP +\fB\-C\fP \fICONTROLLO\fP, \fB\-\-check=\fP\fICONTROLLO\fP +Specifica il tipo di controllo di integrità. Il controllo viene calcolato +dai dati non compressi e memorizzato nel file \fB.xz\fP. Questa opzione ha +effetto solo quando si comprime nel formato \fB.xz\fP; il formato \fB.lzma\fP non +supporta i controlli di integrità. Il controllo di integrità (se presente) +viene verificato quando il file \fB.xz\fP viene decompresso. +.IP "" +Tipi di \fICONTROLLI\fP supportati: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Non calcola proprio il controllo di integrità. Questo in genere è una +pessima idea. Può essere utile quando l'integrità dei dati viene comunque +verificata con altri mezzi. +.TP +\fBcrc32\fP +Calcola la firma CRC32 usando il polinomio di IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Calcola la firma CRC64 usando il polinomio di ECMA\-182. Questa è +l'impostazione predefinita, perché è leggermente migliore della CRC32 nel +rilevare i file danneggiati e la differenza di velocità è trascurabile. +.TP +\fBsha256\fP +Calcola la firma SHA\-256. Questo è un po' più lento che CRC32 e CRC64. +.RE +.IP "" +L'integrità delle intestazioni \fB.xz\fP viene sempre verificata con CRC32. Non +è possibile modificarlo o disabilitarlo. +.TP +\fB\-\-ignore\-check\fP +Non verifica il controllo di integrità dei dati compressi durante la +decompressione. Il valore CRC3 nelle intestazioni \fB.xz\fP sarà ancora +verificata normalmente. +.IP "" +\fBNon usare questa opzione se non si è consci di cosa si sta facendo.\fP +Possibili ragioni per utilizzare questa opzione: +.RS +.IP \(bu 3 +Tentativo di recupero dei dati da un file .xz corrotto. +.IP \(bu 3 +Accelerazione della decompressione. Questo è importante soprattutto con +SHA\-256 o con i file che sono stati compressi molto bene. Si consiglia di +non utilizzare questa opzione per questo scopo, a meno che l'integrità del +file non venga verificata esternamente in altro modo. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Selezionare un livello di compressione preimpostato. Il valore predefinito è +\fB\-6\fP. Se vengono specificati più livelli preimpostati, l'ultimo ha +effetto. Se è già stata specificata una catena di filtri personalizzata, +l'impostazione di un livelli preimpostati cancella la catena di filtri +personalizzata. +.IP "" +Le differenze tra i livelli preimpostati sono più significative rispetto a +\fBgzip\fP(1) e \fBbzip2\fP(1). Le impostazioni di compressione selezionate +determinano i requisiti di memoria del decompressore, quindi l'utilizzo di +un livello preimpostato troppo alto potrebbe rendere difficile la +decompressione del file su un vecchio sistema con poca RAM. Specificamente, +\fBnon è una buona idea utilizzare ciecamente \-9 per tutto\fP come spesso +accade per \fBgzip\fP(1) e \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Questi sono livelli preimpostati piuttosto veloci. \fB\-0\-\fP a volte è più +veloce di \fBgzip \-9\fP e comprime molto meglio. Quelli più alti hanno spesso +una velocità paragonabile a \fBbzip2\fP(1) con un rapporto di compressione +comparabile o migliore, anche se i risultati dipendono molto dal tipo di +dati che vengono compressi. +.TP +\fB\-4\fP ... \fB\-6\fP +Compressione da buona a molto buona, mantenendo l'utilizzo della memoria del +decompressore ragionevole anche per vecchi sistemi. \fB\-6\fP è il valore +predefinito, che di solito è una buona scelta per distribuire file che +debbano essere decompressi anche su sistemi con solo 16\ MiB di +RAM. (Potrebbe valere la pena di considerare anche \fB\-5e\fP o \fB\-6e\fP. Si veda +\fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Questi sono come \fB\-6\fP ma con requisiti di memoria di compressore e +decompressore più elevati. Sono utili solo quando si comprimono file di +dimensioni superiori a 8\ MiB, 16\ MiB e 32\ MiB, rispettivamente. +.RE +.IP "" +A parità di hardware, la velocità di decompressione è approssimativamente un +numero costante di byte di dati compressi al secondo. In altre parole, +migliore è la compressione, più veloce sarà di solito la decompressione. Ciò +significa anche che la quantità di output non compresso prodotta al secondo +può variare notevolmente. +.IP "" +La tabella seguente riassume le caratteristiche dei livelli preimpostati: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Livello preimpostato;DictSize;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Descrizioni delle colonne: +.RS +.IP \(bu 3 +DictSize è la dimensione del dizionario LZMA2. È uno spreco di memoria usare +un dizionario più grande della dimensione del file non compresso. Ecco +perché è una buona cosa evitare di usare i livelli preimpostati \fB\-7\fP +\&... \fB\-9\fP quando non c'è reale necessità. Con \fB\-6\fP e inferiori, la quantità +di memoria sprecata in genere è sufficientemente bassa da essere +trascurabile. +.IP \(bu 3 +CompCPU è una rappresentazione semplificata delle impostazioni di LZMA2 che +influenzano la velocità di compressione. Anche la dimensione del dizionario +influenza la velocità, quindi mentre CompCPU è lo stesso per i livelli \fB\-6\fP +\&... \fB\-9\fP, i livelli più alti tendono ancora ad essere un po' più lenti. Per +avere una compressione ancora più lenta e quindi potenzialmente migliore, +utilizzare \fB\-\-extreme\fP. +.IP \(bu 3 +CompMem contiene i requisiti di memoria del compressore in modalità a +singola thread. Può variare leggermente tra le versioni di \fBxz\fP. +.IP \(bu 3 +DecMem contiene i requisiti di memoria del decompressore. In altre parole, +le impostazioni di compressione determinano i requisiti di memoria del +decompressore. L'utilizzo esatto della memoria del decompressore è +leggermente superiore alla dimensione del dizionario LZMA2, ma i valori +nella tabella sono stati arrotondati per eccesso al successivo MiB completo. +.RE +.IP "" +I requisiti di memoria per la modalità a thread multiple sono +significativamente più alti che per la modalità thread singola. Con il +valore predefinito di \fB\-\-block\-size\fP, ogni thread richiede 3*3*dimensione +del dizionario più CompMem oppure DecMem. Ad esempio, 4 thread con il +livello preimpostato \fB\-6\fP hanno bisogno di 660\(en670\ MiB di memoria. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Utilizzare una variante più lenta del livello preimpostato selezionato +(\fB\-0\fP ... \fB\-9\fP) nella speranza di ottenere un rapporto di compressione +leggermente migliore, ma con un po' di sfortuna questo potrebbe anche +renderlo peggiore. L'utilizzo della memoria del decompressore non è +influenzato, ma l'utilizzo della memoria del compressore aumenta leggermente +ai livelli preimpostati \fB\-0\fP ... \fB\-3\fP. +.IP "" +Dal momento che ci sono due livelli preimpostati con dimensione del +dizionario di 4\ MiB e 8\ MiB, i livelli preimpostati \fB\-3e\fP e \fB\-5e\fP usano +impostazioni leggermente più veloci (minore CompCPU) di \fB\-4e\fP e \fB\-6e\fP, +rispettivamente. In questo modo non ci sono due livelli preimpostati +identici. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Livello preimpostato;DictSize;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Ad esempio, ci sono un totale di quattro livelli preimpostati che utilizzano +un dizionario da 8\ MiB, il cui ordine dal più veloce al più lento è \fB\-5\fP, +\fB\-6\fP, \fB\-5e\fP, e \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Questi sono alias in qualche modo fuorvianti per \fB\-0\fP e \fB\-9\fP, +rispettivamente. Sono forniti solo per retrocompatibilità con le LZMA +Utils. Evitare di utilizzare queste opzioni. +.TP +\fB\-\-block\-size=\fP\fIDIMENSIONE\fP +Quando si comprime in formato \fB.xz\fP, divide i dati input in blocchi da +\fIDIMENSIONE\fP byte. I blocchi vengo compressi indipendentemente l'uno +dall'altro, cosa che aiuta con le thread multiple e rende possibile la +decompressione con accessi casuali limitati. Questa opzione viene usata +tipicamente per sovrascrivere la dimensione predefinita dei blocchi in +modalità a thread multiple, ma può essere utilizzata anche in modalità +thread singola. +.IP "" +In modalità a thread multiple verranno allocati circa il triplo di +\fIDIMENSIONE\fP di byte in ogni thread per il buffering dell'input e +dell'output. La \fIDIMENSIONE\fP predefinita è tre volte la dimensione del +dizionario LZMA2 e comunque almeno 1 MiB. Tipicamente un buon valore è +2\(en4 volte la dimensione del dizionario LZMA2 oppure almeno 1 MiB. Usare +una \fIDIMENSIONE\fP inferiore della dimensione del dizionario LZMA2 causa uno +spreco di RAM, in quanto il buffer del dizionario LZMA2 non verrà mai +riempito completamente. In modalità a thread multiple, la dimensione dei +blocchi è conservata nelle intestazioni dei blocchi. L'informazione sulla +dimensione è richiesta per la decompressione a thread multiple. +.IP "" +Nella modalità a thread singola, per impostazione predefinita non viene +eseguita alcuna suddivisione in blocchi. L'impostazione di questa opzione +non influisce sull'utilizzo della memoria. Nessuna informazione sulle +dimensioni viene memorizzata nelle intestazioni di blocco, quindi i file +creati in modalità a thread singola non saranno identici ai file creati in +modalità a thread multiple. La mancanza di informazioni sulle dimensioni +significa anche che \fBxz\fP non sarà in grado di decomprimere i file in +modalità a thread multiple. +.TP +\fB\-\-block\-list=\fP\fIELEMENTI\fP +Quando si comprime nel formato \fB.xz\fP, inizia un nuovo blocco con una catena +di filtri personalizzata dopo gli intervalli indicati di dati non compressi. +.IP "" +Gli \fIELEMENTI\fP sono un elenco separato da virgole. Ogni elemento è +costituito da un numero di catena di filtri opzionale compreso tra 0 e 9 +seguito da due punti (\fB:\fP) e da una dimensione richiesta di dati non +compressi. L'omissione di un elemento (due o più virgole consecutive) è una +scorciatoia per utilizzare le dimensioni e i filtri dell'elemento +precedente. +.IP "" +Se il file di input è più grande della somma delle dimensioni in +\fIELEMENTI\fP, l'ultimo elemento viene ripetuto fino alla fine del file. Il +valore speciale \fB0\fP può essere utilizzato come ultima dimensione per +indicare che il resto del file deve essere codificato come un singolo +blocco. +.IP "" +È possibile specificare una catena di filtri alternativa per ogni blocco in +combinazione con le opzioni \fB\-\-filters1=\fP\fIFILTRI\fP \&...\& +\fB\-\-filters9=\fP\fIFILTRI\fP. Queste opzioni definiscono catene di filtri con un +identificatore compreso tra 1\(en9. La catena di filtri 0 può essere +utilizzata per indicare la catena di filtri predefinita, che equivale a non +specificare una catena di filtri. L'identificatore della catena di filtri +può essere utilizzato prima della dimensione non compressa, seguita da due +punti (\fB:\fP). Ad esempio, se si specifica +\fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP allora i blocchi verranno +creati utilizzando: +.RS +.IP \(bu 3 +La catena dei filtri specificata da \fB\-\-filters1\fP e un input di 2 MiB +.IP \(bu 3 +La catena dei filtri specificata da \fB\-\-filters3\fP e un input di 2 MiB +.IP \(bu 3 +La catena dei filtri specificata da \fB\-\-filters2\fP e un input di 4 MiB +.IP \(bu 3 +La catena dei filtri specificata da \fB\-\-filters2\fP e un input di 4 MiB +.IP \(bu 3 +La catena di filtri predefinita e l'input di 2 MiB +.IP \(bu 3 +La catena di filtri predefinita e l'input di 4 MiB per ogni blocco fino alla +fine dell'input. +.RE +.IP "" +Se si specifica una dimensione che supera la dimensione del blocco del +codificatore (il valore predefinito in modalità thread oppure il valore +specificato con \fB\-\-block\-size=\fP\fIDIMENSIONE\fP), il codificatore creerà +blocchi aggiuntivi mantenendo i limiti specificati in \fIELEMENTI\fP. Ad +esempio, se si indica \fB\-\-block\-size=10MiB\fP +\fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP e il file input è di 80 MiB, si +otterranno 11 blocchi: 5, 10, 8, 10, 2, 10, 10, 4, 10, 10, and 1 MiB. +.IP "" +In modalità a thread multiple, le dimensioni dei blocchi vengono memorizzate +nelle intestazioni dei blocchi. Questo non avviene in modalità thread +singola, quindi l'output codificato non sarà identico a quello della +modalità a thread multiple. +.TP +\fB\-\-flush\-timeout=\fP\fITIMEOUT\fP +Quando si comprime, se sono passati più di \fITIMEOUT\fP millisecondi (un +intero positivo) dallo scaricamento precedente e la lettura di ulteriori +input si bloccherebbe, tutti i dati di input in sospeso vengono scaricati +dal codificatore e resi disponibili nel flusso di output. Questo può essere +utile se \fBxz\fP viene usato per comprimere dati in streaming dalla +rete. Piccoli valori del \fITIMEOUT\fP rendono disponibili i dati al ricevente +con un ritardo minimo, mentre valori di \fITIMEOUT\fP grandi danno un miglior +rapporto di compressione. +.IP "" +Questa funzionalità è disabilitata per impostazione predefinita. Se questa +opzione viene specificata più di una volta, l'ultima ha effetto. Il valore +speciale \fITIMEOUT\fP di \fB0\fP può essere utilizzato per disabilitare +esplicitamente questa funzionalità. +.IP "" +Questa funzionalità non è disponibile sui sistemi non\-POSIX. +.IP "" +.\" FIXME +\fBQuesta funzionalità è sperimentale.\fP Attualmente \fBxz\fP non è adatto per +decomprimere il flusso in tempo reale, a causa di come effettua il +buffering. +.TP +\fB\-\-no\-sync\fP +Non sincronizzare il file target e la sua directory sull'unità di +archiviazione prima di rimuovere il file sorgente. Questo può migliorare le +performance se si sta comprimendo o decomprimendo tanti piccoli +file. Tuttavia, se il sistema dovesse andare in crash subito dopo +l'eliminazione, è possibile che il file destinazione non sia ancora stato +scritto sull'unità di archiviazione mentre l'operazione di eliminazione +sì. In questo caso non saranno più disponibili né il file sorgente originale +né il file di destinazione. +.IP "" +Questa opzione ha effetto solamente quando \fBxz\fP deve rimuovere il file +sorgente. Negli altri casi la sincronizzazione non viene eseguita. +.IP "" +La sincronizzazione e \fB\-\-no\-sync\fP sono stati aggiunti nella versione \fBxz\fP +5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fILIMITE\fP +Imposta un limite di utilizzo della memoria per la compressione. Se questa +opzione viene specificata più volte, ha effetto l'ultima. +.IP "" +Se le impostazioni di compressione superano il valore \fILIMITE\fP, \fBxz\fP +tenterà di regolare le impostazioni verso il basso in modo che il limite non +venga più superato e visualizzerà un avviso che indica che è stata eseguita +una regolazione automatica. Le regolazioni vengono eseguite in questo +ordine: riduzione del numero di thread, passaggio alla modalità a thread +singola se anche un solo thread in modalità a thread multiple supera il +\fILIMITE\fP, e infine riducendo la dimensione del dizionario LZMA2. +.IP "" +Quando si comprime con \fB\-\-format=raw\fP oppure se si è specificato +\fB\-\-no\-adjust\fP, è possibile ridurre solo il numero di thread, poiché questo +può essere fatto senza influire sull'output compresso. +.IP "" +Se non è possibile soddisfare il \fILIMITE\fP anche con le regolazioni sopra +descritte, viene visualizzato un errore e \fBxz\fP uscirà con lo stato di +uscita 1. +.IP "" +Il \fILIMITE\fP può essere specificato in diversi modi: +.RS +.IP \(bu 3 +Il \fILIMITE\fP può essere un valore assoluto in byte. Usare un suffisso intero +come \fBMiB\fP può essere utile. Ad esempio: \fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +Il \fILIMITE\fP può essere specificato come percentuale della memoria fisica +(RAM) totale. Questo può essere utile specialmente quando si imposta la +variabile di ambiente \fBXZ_DEFAULTS\fP in uno script di inizializzazione di +shell che è condiviso tra computer diversi. In questo modo il limite è +automaticamente più grande sui sistemi con più memoria. Ad esempio: +\fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +Il \fILIMITE\fP può essere reimpostato al suo valore predefinito impostandolo a +\fB0\fP.Questo attualmente equivale a impostare il \fILIMITE\fP a \fBmax\fP (nessun +limite nell'utilizzo di memoria). +.RE +.IP "" +Per \fBxz\fP a 32\-bit esiste un caso particolare: se il \fILIMITE\fP fosse oltre +\fB4020\ MiB\fP, il \fILIMITE\fP viene impostato a \fB4020\ MiB\fP. Su MIPS32 invece +viene usato \fB2000\ MiB\fP. (I valori \fB0\fP e \fBmax\fP non sono influenzati da +questo. Un comportamento simile non esiste per la decompressione). Questo +può essere utile quando un eseguibile a 32 bit ha accesso a uno spazio di +indirizzi da 4\ GiB (2 GiB su MIPS32), e si spera che non faccia danni in +altre situazioni. +.IP "" +Vedere anche la sezione \fBUtilizzo memoria\fP +.TP +\fB\-\-memlimit\-decompress=\fP\fILIMITE\fP +Imposta un limite di utilizzo della memoria per la decompressione. Questo +influisce anche sulla modalità \fB\-\-list\fP. Se l'operazione non è possibile +senza oltrepassare il \fILIMITE\fP, \fBxz\fP mostrerà un errore e la +decompressione del file fallirà. Si veda \fB\-\-memlimit\-compress=\fP\fILIMITE\fP +per possibili modi per specificare il \fILIMITE\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fILIMITE\fP +Imposta un limite di utilizzo della memoria per la decompressione +multi\-thread. Questo può influire solo sul numero di thread; non indurrà mai +\fBxz\fP a rifiutarsi di decomprimere un file. Se \fILIMITE\fP è troppo basso per +consentire le thread multiple, il \fILIMITE\fP viene ignorato e \fBxz\fP +continuerà in modalità a thread singola. Si noti che se viene utilizzato +anche \fB\-\-memlimit\-decompress\fP, si applicherà sempre sia alla modalità a +thread singola che a quella a thread multiple, e quindi il \fILIMITE\fP +effettivo per le thread multiple non sarà mai superiore a quello impostato +con \fB\-\-memlimit\-decompress\fP. +.IP "" +In contrasto con le altre opzioni di limite di utilizzo della memoria, +\fB\-\-memlimit\-mt\-decompress=\fP\fILIMITE\fP ha un \fILIMITE\fP predefinito specifico +per il sistema. \fBxz \-\-info\-memory\fP può essere utilizzato per vedere il +valore corrente. +.IP "" +Questa opzione e il suo valore predefinito esistono perché, senza un limite, +il decompressore a thread multiple potrebbe finire per allocare una quantità +folle di memoria per alcuni file input. Se il valore predefinito \fILIMITE\fP è +troppo basso sul proprio sistema, è possibile aumentarlo liberamente, ma non +deve essere mai impostato a un valore più grande della quantità di RAM +utilizzabile, in quanto con file di input appropriati \fBxz\fP cercherà di +utilizzare quella quantità di memoria anche con un basso numero di +thread. Esaurire la memoria o fare swap non migliorerà le performance della +decompressione. +.IP "" +Vedi \fB\-\-memlimit\-compress=\fP\fILIMITE\fP per possibili modi per specificare il +\fILIMITE\fP. Impostando \fILIMITE\fP su \fB0\fP si ripristina il valore predefinito +\fILIMITE\fP specifico del sistema. +.TP +\fB\-M\fP \fILIMITE\fP, \fB\-\-memlimit=\fP\fILIMITE\fP, \fB\-\-memory=\fP\fILIMITE\fP +Questo equivale a specificare \fB\-\-memlimit\-compress=\fP\fILIMITE\fP +\fB\-\-memlimit\-decompress=\fP\fILIMITE\fP \fB\-\-memlimit\-mt\-decompress=\fP\fILIMITE\fP. +.TP +\fB\-\-no\-adjust\fP +Visualizza un errore e esce se non è possibile soddisfare il limite di +utilizzo della memoria senza regolare le impostazioni che influiscono +sull'output compresso. In altre parole, ciò impedisce a \fBxz\fP di passare il +codificatore dalla modalità multi\-thread alla modalità a thread singola e di +ridurre le dimensioni del dizionario LZMA2. Anche quando viene usata questa +opzione, il numero di thread può essere ridotto per soddisfare il limite di +utilizzo della memoria, in quanto ciò non influirà sull'output compresso. +.IP "" +La regolazione automatica è sempre disabilitata quando si creano flussi raw +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fITHREADS\fP, \fB\-\-threads=\fP\fITHREADS\fP +Specifica il numero di thread di lavoro da utilizzare. L'impostazione di +\fITHREADS\fP al valore speciale \fB0\fP fa sì che \fBxz\fP utilizzi fino a un numero +di thread che il processore/i del sistema supportano. Il numero effettivo di +thread può essere inferiore a \fITHREADS\fP se il file di input non è +sufficientemente grande per il threading con le impostazioni specificate o +se l'utilizzo di più thread supera il limite di utilizzo della memoria. +.IP "" +I compressori a thread singola e a thread multiple producono output +diversi. Il compressore a thread singola produrrà la dimensione del file più +piccola, ma solo l'output del compressore a thread multiple può essere +decompresso utilizzando più thread. Impostando \fITHREADS\fP su \fB1\fP verrà +utilizzata la modalità a thread singola. L'impostazione di \fITHREADS\fP su +qualsiasi altro valore, incluso \fB0\fP, utilizzerà il compressore a thread +multiple anche se il sistema supporta un solo thread hardware. (\fBxz\fP 5.2.x +utilizzava la modalità a thread singola in questa situazione.) +.IP "" +Per utilizzare la modalità a thread multiple con un solo thread, impostare +\fITHREADS\fP su \fB+1\fP. Il prefisso \fB+\fP non ha alcun effetto con valori +diversi da \fB1\fP. Un limite di utilizzo della memoria può comunque far +passare \fBxz\fP alla modalità a thread singola a meno che non venga utilizzato +\fB\-\-no\-adjust\fP. Il supporto per il prefisso \fB+\fP è stato aggiunto in \fBxz\fP +5.4.0. +.IP "" +Se è stato richiesto un numero automatico di thread e non è stato +specificato alcun limite di utilizzo della memoria, verrà utilizzato un +limite "soft" predefinito, specifico del sistema, per limitare eventualmente +il numero di thread. È un limite "soft" nel senso che viene ignorato se il +numero di thread diventa uno, quindi un limite soft non impedirà mai a \fBxz\fP +di comprimere o decomprimere. Questo limite soft predefinito non farà +passare \fBxz\fP dalla modalità a thread multiple alla modalità thread +singola. I limiti attivi possono essere visualizzati con \fBxz \-\-info\-memory\fP. +.IP "" +Attualmente l'unico metodo di threading consiste nel dividere l'input in +blocchi e comprimerli indipendentemente l'uno dall'altro. La dimensione +predefinita del blocco dipende dal livello di compressione e può essere +sovrascritta con l'opzione \fB\-\-block\-size=\fP\fIDIMENSIONE\fP. +.IP "" +La decompressione a thread multiple funziona solo su file che contengano più +blocchi con l'informazione della dimensione nelle intestazioni del +blocco. Tutti i file sufficientemente grandi compressi in modalità a thread +multiple soddisfano questa condizione, mentre i file compressi in modalità +thread singola no, neanche se si è utilizzato \fB\-\-block\-size=\fP +\fIDIMENSIONE\fP. +.IP "" +Il valore predefinito per \fITHREADS\fP è \fB0\fP. In \fBxz\fP 5.4.x e precedenti il +valore predefinito era \fB1\fP. +. +.SS "Catene di filtri di compressione personalizzate" +Una catena di filtri personalizzata consente di specificare in dettaglio le +impostazioni di compressione invece di fare affidamento sulle impostazioni +associate ai livelli preimpostati. Quando viene specificata una catena di +filtri personalizzata, le opzioni relative ai livelli preimpostati (\fB\-0\fP +\&...\& \fB\-9\fP e \fB\-\-extreme\fP) specificate in precedenza sulla riga di +comando vengono dimenticate. Se un'opzione livello preimpostato viene +specificata dopo una o più opzioni della catena di filtri personalizzata, il +nuovo livello preimpostato ha effetto e le opzioni della catena di filtri +personalizzate specificate in precedenza vengono dimenticate. +.PP +Una catena di filtri è paragonabile a una pipe sulla riga di +comando. Durante la compressione, l'input non compresso va al primo filtro, +il cui output va al filtro successivo (se presente). L'output dell'ultimo +filtro viene scritto nel file compresso. Il numero massimo di filtri nella +catena è quattro, ma in genere una catena di filtri ha solo uno o due +filtri. +.PP +Molti filtri hanno limitazioni su dove possono trovarsi nella catena di +filtri: alcuni filtri possono funzionare solo come ultimo filtro della +catena, altri solo come filtro non ultimo e alcuni funzionano in qualsiasi +posizione nella catena. A seconda del filtro, questa limitazione è inerente +alla struttura del filtro oppure esiste per evitare problemi di sicurezza. +.PP +Una catena di filtri personalizzata può essere specificata in due modi +diversi. Le opzioni \fB\-\-filters=\fP\fIFILTRI\fP and \fB\-\-filters1=\fP\fIFILTRI\fP +\&...\& \fB\-\-filters9=\fP\fIFILTRI\fP permettono di specificare un'intera catena +di filtri in una opzione utilizzando la sintassi della stringa del filtro di +lzma. In alternativa, una catena di filtri può essere specificata +utilizzando una o più singole opzioni di filtro nell'ordine desiderato nella +catena di filtri. Questo significa che l'ordine delle singole opzioni di +filtro è importante! Quando si decodificano i flussi grezzi +(\fB\-\-format=raw\fP), la catena di filtri deve essere specificata nello stesso +ordine in cui è stata specificata durante la compressione. Qualsiasi filtro +individuale o opzione livello preimpostato specificata prima dell'opzione +della catena completa (\fB\-\-filters=\fP\fIFILTRI\fP) verrà dimenticata. I singoli +filtri specificati dopo l'opzione della catena completa reimposteranno la +catena di filtri. +.PP +Sia l'opzione di filtro completo che quella individuale accettano \fIOPZIONI\fP +specifiche del filtro come un elenco separato da virgole. Virgole in eccesso +nelle \fIOPZIONI\fP vengono ignorate. Ogni opzione ha un valore di default, +quindi occorre specificare solamente quelle che si desidera modificare. +.PP +Per vedere l'intera catena di filtri e \fIOPZIONI\fP, usa \fBxz \-vv\fP (ossia, usa +\fB\-\-verbose\fP due volte). Questo funziona anche per visualizzare le opzioni +della catena di filtri utilizzate dai livelli preimpostati. +.TP +\fB\-\-filters=\fP\fIFILTRI\fP +Specifica l'intera catena dei filtri oppure un livello preimpostato in una +singola opzione. Ogni filtro può essere separato da spazi o da due trattini +(\fB\-\-\fP). Potrebbe essere necessario mettere tra virgolette i \fIFILTRI\fP sulla +riga di comando della shell in modo che vengano analizzati come una singola +opzione. Per indicare \fIOPZIONI\fP, usa \fB:\fP o \fB=\fP. Un livello preimpostato +può essere preceduto da un \fB\-\fP e seguito da zero o più flag. L'unico flag +supportato è \fBe\fP per applicare le stesse opzioni di \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIFILTRI\fP ... \fB\-\-filters9\fP=\fIFILTRI\fP +Specifica fino a nove catene di filtri aggiuntive che possono essere +utilizzate con \fB\-\-block\-list\fP. +.IP "" +Ad esempio, quando si comprime un archivio con file eseguibili seguiti da +file di testo, la parte eseguibile potrebbe utilizzare una catena di filtri +con un filtro BCJ e la parte di testo solo il filtro LZMA2. +.TP +\fB\-\-filters\-help\fP +Mostra un messaggio di aiuto che descrive come specificare livelli +preimpostati e catene di filtri personalizzati nelle opzioni \fB\-\-filters\fP e +\fB\-\-filters1=\fP\fIFILTRI\fP \&...\& \fB\-\-filters9=\fP\fIFILTRI\fP, e termina con +successo. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIOPZIONI\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIOPZIONI\fP] +.PD +Aggiunge un filtro LZMA1 o LZMA2 alla catena dei filtri. Questi filtri +possono essere usati solo come ultimo filtro della catena. +.IP "" +LZMA1 è un filtro obsoleto, supportato quasi esclusivamente a causa del +formato obsoleto di file \fB.lzma\fP, che supporta solo LZMA1. LZMA2 è una +versione aggiornata di LZMA1 che risolve alcuni problemi pratici di +LZMA1. Il formato \fB.xz\fP utilizza LZMA2 e non supporta LZMA1. La velocità e +i rapporti di compressione di LZMA1 e LZMA2 sono praticamente gli stessi. +.IP "" +LZMA1 e LZMA2 condividono lo stesso insieme di \fIOPZIONI\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIPRESET\fP +Reimposta tutte le \fIOPZIONI\fP LZMA1 o LZMA2 a \fIPRESET\fP. Il \fIPRESET\fP +(livello preimpostato) consiste di un numero intero, che può essere seguito +da modificatori costituiti da una singola lettera. Il numero intero può +andare da \fB0\fP a \fB9\fP, corrispondenti alle opzioni della riga di comando +\fB\-0\fP \&...\& \fB\-9\fP. L'unico modificatore attualmente supportato è \fBe\fP, che +corrisponde a \fB\-\-extreme\fP. Se non viene specificato alcun \fIPRESET\fP, i +valori predefiniti delle \fIOPZIONI\fP LZMA1 o LZMA2 sono presi dal livello +preimpostato \fB6\fP. +.TP +\fBdict=\fP\fIDIMENSIONE\fP +La \fIDIMENSIONE\fPdel dizionario (buffer di cronologia) indica quanti byte dei +dati non compressi elaborati di recente vengono mantenuti in +memoria. L'algoritmo tenta di trovare sequenze di byte ripetute +(corrispondenze) nei dati non compressi e di sostituirle con riferimenti ai +dati attualmente presenti nel dizionario. Più grande è il dizionario, +maggiore è la possibilità di trovare una corrispondenza. Quindi, l'aumento +della \fIDIMENSIONE\fP del dizionario di solito migliora il rapporto di +compressione, ma un dizionario più grande del file non compresso è uno +spreco di memoria. +.IP "" +Una \fIDIMENSIONE\fP tipica per un dizionario è da 64\ KiB a 64\ MiB. Il minimo +è 4\ KiB. Il massimo per la compressione è attualmente 1.5\ GiB (1536\ MiB). La decompressione supporta già dizionari fino a 4\ GiB meno 1 byte, +che è il massimo per i formati di flusso LZMA1 e LZMA2. +.IP "" +La \fIDIMENSIONE\fP del dizionario e il cercatore di corrispondenze +(\fICERCATORE\fP) insieme determinano l'utilizzo della memoria del codificatore +LZMA1 o LZMA2. Per la decompressione è necessaria la stessa \fIDIMENSIONE\fP +del dizionario utilizzata durante la compressione (o più grande), quindi +l'utilizzo della memoria del decodificatore è determinato dalla dimensione +del dizionario utilizzato durante la compressione. Le intestazioni \fB.xz\fP +memorizzano la \fIDIMENSIONE\fP del dizionario come 2^\fIn\fP o 2^\fIn\fP + 2^( +\fIn\fP\-1), quindi queste \fIDIMENSIONI\fP sono in qualche modo preferite per la +compressione. Altre \fIDIMENSIONI\fP verranno arrotondate per eccesso quando +memorizzate nelle intestazioni \fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Specificare il numero di bit di contesto letterali. Il minimo è 0 e il +massimo è 4; Il valore predefinito è 3. Inoltre, la somma di \fIlc\fP e \fIlp\fP +non deve superare 4. +.IP "" +Tutti i byte che non possono essere codificati come corrispondenze vengono +codificati come valori letterali. In altre parole, i valori letterali sono +semplicemente byte a 8 bit codificati uno alla volta. +.IP "" +La codifica letterale presuppone che i bit di \fIlc\fP più alti del byte non +compresso precedente siano correlati al byte successivo. Ad esempio, in un +tipico testo inglese, una lettera maiuscola è spesso seguita da una lettera +minuscola e una lettera minuscola è solitamente seguita da un'altra lettera +minuscola. Nel set di caratteri US\-ASCII, i tre bit più alti sono 010 per le +lettere maiuscole e 011 per le lettere minuscole. Quando \fIlc\fP è almeno 3, +la codifica letterale può sfruttare questa proprietà nei dati non compressi. +.IP "" +Il valore predefinito (3) solitamente è buono. Se si desidera la +compressione massima, provare con \fBlc=4\fP. A volte aiuta un po', e a volte +rende la compressione peggiore. Se la rende peggiore, provare anche \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Specificare il numero di bit di posizione letterale. Il minimo è 0 e il +massimo è 4; Il valore predefinito è 0. +.IP "" +Il parametro \fIlp\fP influisce sul tipo di allineamento nei dati non compressi +presunto durante la codifica dei valori letterali. Vedi \fIpb\fP di seguito per +ulteriori informazioni sull'allineamento. +.TP +\fBpb=\fP\fIpb\fP +Specificare il numero di bit di posizione. Il minimo è 0 e il massimo è 4; +Il valore predefinito è 2. +.IP "" +Il parametro \fIpb\fP influisce su quale tipo di allineamento nei dati non +compressi sia assunto in generale. L'impostazione predefinita indica un +allineamento a quattro byte (2^\fIpb\fP =2^2=4), che è spesso una buona scelta +se non c'è un'ipotesi migliore. +.IP "" +Quando l'allineamento è noto, impostare \fIpb\fP concordemente può ridurre un +po' le dimensioni del file. Ad esempio, con file di testo con 1 byte di +allineamento (US\-ASCII, ISO\-8859\-*, UTF\-8), impostare \fBpb=0\fP può migliorare +leggermente la compressione. Per il testo UTF\-16, \fBpb=1\fP è una buona +scelta. Se l'allineamento è un numero dispari, come 3 byte, \fBpb=0\fP potrebbe +essere la scelta migliore. +.IP "" +Anche se l'allineamento assunto può essere regolato con \fIpb\fP e \fIlp\fP, LZMA1 +e LZMA2 favoriscono ancora leggermente l'allineamento a 16 byte. Potrebbe +valere la pena tenerlo in considerazione quando si progettano formati di +file che possono essere spesso compressi con LZMA1 o LZMA2. +.TP +\fBmf=\fP\fICERCATORE\fP +Il cercatore di corrispondenze ha un effetto importante sulla velocità del +codificatore, sull'utilizzo della memoria e sul rapporto di compressione. Di +solito i cercatori di corrispondenze a catena hash sono più veloci dei +cercatori di corrispondenze ad albero binario. Il valore predefinito dipende +da \fIPRESET\fP : 0 usa \fBhc3\fP, 1\(en3 usa \fBhc4\fP e il resto usa \fBbt4\fP. +.IP "" +Sono supportati i seguenti cercatori di corrispondenze. Le formule di +utilizzo della memoria riportate di seguito sono approssimazioni, che sono +le più vicine alla realtà quando \fIDIZIONARIO\fP è una potenza di due. +.RS +.TP +\fBhc3\fP +Catena hash con hashing da 2 e 3 byte +.br +Minimo valore per \fINICE\fP: 3 +.br +Utilizzo memoria: +.br +\fIDIZIONARIO\fP * 7.5 (se \fIDIZIONARIO\fP <= 16 MiB); +.br +\fIDIZIONARIO\fP * 5.5 + 64 MiB (se \fIDIZIONARIO\fP > 16 MiB) +.TP +\fBhc4\fP +Catena hash con hash da 2, 3 e 4 byte +.br +Minimo valore per \fINICE\fP: 4 +.br +Utilizzo memoria: +.br +\fIDIZIONARIO\fP * 7.5 (se \fIDIZIONARIO\fP <= 32 MiB); +.br +\fIDIZIONARIO\fP * 6.5 (se \fIDIZIONARIO\fP > 32 MiB) +.TP +\fBbt2\fP +Albero binario con hashing da 2 byte +.br +Valore minimo per \fINICE\fP: 2 +.br +Utilizzo di memoria: \fIDIZIONARIO\fP * 9.5 +.TP +\fBbt3\fP +Albero binario con hashing da 2 e 3 byte +.br +Minimo valore per \fINICE\fP: 3 +.br +Utilizzo memoria: +.br +\fIDIZIONARIO\fP * 11.5 (se \fIDIZIONARIO\fP <= 16 MiB); +.br +\fIDIZIONARIO\fP * 9.5 + 64 MiB (se \fIDIZIONARIO\fP > 16 MiB) +.TP +\fBbt4\fP +Albero binario con hashing da 2, 3 e 4 byte +.br +Minimo valore per \fINICE\fP: 4 +.br +Utilizzo memoria: +.br +\fIDIZIONARIO\fP * 11.5 (se \fIDIZIONARIO\fP <= 32 MiB); +.br +\fIDIZIONARIO\fP * 10.5 (se \fIDIZIONARIO\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fIMODALITÀ\fP +La \fIMODALITÀ\fP di compressione specifica il metodo per analizzare i dati +prodotti dal cercatore di corrispondenze. Le \fIMODALITÀ\fP supportate sono +\fBfast\fP e \fBnormal\fP. Il predefinito è \fBfast\fP per i \fIPRESET\fP 0\(en3 e +\fBnormal\fP per i \fIPRESET\fP 4\(en9. +.IP "" +Di solito \fBfast\fP viene utilizzato con i cercatori di corrispondenze a +catena hash e \fBnormal\fP con i cercatori di corrispondenze a albero +binario. Questo è anche quello che fanno i \fIPRESET\fP. +.TP +\fBnice=\fP\fINICE\fP +Specifica quella che si considera una lunghezza accettabile ("nice") per una +corrispondenza. Una volta trovata una corrispondenza di almeno \fINICE\fP byte, +l'algoritmo smette di cercare corrispondenze potenzialmente migliori. +.IP "" +\fINICE\fP può valere 2\(en273 byte. Valori più alti tendono a dare un miglior +rapporto di compressione ai danni della velocità. Il valore predefinito +dipende dal \fIPRESET\fP. +.TP +\fBdepth=\fP\fIPROFONDITÀ\fP +Specificare la profondità di ricerca massima nel cercatore di +corrispondenze. Il valore predefinito è il valore speciale 0, che dice al +compressore di determinare una \fIPROFONDITÀ\fP ragionevole da \fICERCATORE\fP e +\fINICE\fP. +.IP "" +Una \fIPROFONDITÀ\fP ragionevole per le catene hash è 4\(en100 e 16\(en1000 per +gli alberi binari. Utilizzando valori di \fIPROFONDITÀ\fP molto alti si può +rendere il codificatore estremamente lento con alcuni file. Evitare di +impostare la \fIPROFONDITÀ\fP oltre 1000 a meno che si sia preparati a +interrompere la compressione nel caso in cui richieda troppo tempo. +.RE +.IP "" +Quando si decomprime un flusso grezzo (\fB\-\-format=raw\fP), LZMA2 ha bisogno +solamente della \fIDIMENSIONE\fP del dizionario. LZMA1 ha anche bisogno di +\fIlc\fP, \fIlp\fP, e \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIOPZIONI\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIOPZIONI\fP] +.PD +Aggiunge un filtro branch/call/jump (BCJ) alla catena dei filtri. Questi +filtri non possono essere utilizzati come ultimo filtro nella catena di +filtri. +.IP "" +Un filtro BCJ converte gli indirizzi relativi in codice macchina nelle loro +controparti assolute. Questo non cambia la dimensione dei dati ma aumenta la +ridondanza, cosa che può aiutare LZMA2 a produrre \fB.xz\fP file 0\(en15\ % più +piccoli. I filtri BCJ sono sempre reversibili, quindi usare un filtro BCJ +per il tipo di dati sbagliato non causa perdita di dati, al massimo può +determinare un rapporto di compressione leggermente peggiore. I filtri BCJ +sono molto veloci e usano una quantità di memoria minima. +.IP "" +Questi filtri BCJ presentano problemi noti relativi al rapporto di +compressione: +.RS +.IP \(bu 3 +Alcuni tipi di file contenenti codice eseguibile (ad esempio, file oggetto, +librerie statiche e moduli del kernel Linux) hanno gli indirizzi nelle +istruzioni riempiti con valori di riempimento. Questi filtri BCJ eseguiranno +comunque la conversione degli indirizzi, il che peggiorerà la compressione +con questi file. +.IP \(bu 3 +Se un filtro BCJ viene applicato a un archivio, è possibile che renda il +rapporto di compressione peggiore rispetto a non usare un filtro BCJ. Ad +esempio, se ci sono eseguibili simili o addirittura identici, il filtraggio +probabilmente renderà i file meno simili e quindi la compressione sarà +peggiore. Anche il contenuto dei file non eseguibili nello stesso archivio +può essere importante. In pratica bisogna provare con e senza filtro BCJ per +vedere quale sia il migliore in ogni situazione. +.RE +.IP "" +Insiemi diversi di istruzioni hanno diversi allineamenti: il file eseguibile +deve essere allineato a un multiplo di questo valore nei dati di input per +far funzionare il filtro. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filtro;Allineamento;Note +x86;1;32\-bit o 64\-bit x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;L'allineamento migliore è a 4096 byte +PowerPC;4;Solo big\-endian +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Dal momento che i dati filtrati da BCJ solitamente sono compressi con LZMA2, +il rapporto di compressione può essere migliorato leggermente se le opzioni +LZMA2 sono impostate in modo che corrispondano all'allineamento del filtro +BCJ selezionato. Esempi: +.RS +.IP \(bu 3 +Il filtro IA\-64 ha un allineamento a 16 byte, quindi \fBpb=4,lp=4,lc=0\fP è una +buona scelta per LZMA2 (2^4=16). +.IP \(bu 3 +Il codice RISC\-V ha un allineamento a 2 o 4 byte a seconda che il file +contenga o meno istruzioni 16 bit compresse (cosiddetta estensione +C). Quando sono usate istruzioni a 16 bit, va bene \fBpb=2,lp=1,lc=3\fP o +\fBpb=1,lp=1,lc=3\fP. Quando le istruzioni a 16 bit non sono presenti, è meglio +\fBpb=2,lp=2,lc=2\fP. Si può usare \fBreadelf \-h\fP per controllare se "RVC" +appare sulla riga del "Flag". +.IP \(bu 3 +ARM64 è sempre allineato a 4 byte, quindi \fBpb=2,lp=2,lc=2\fP è la scelta +migliore. +.IP \(bu 3 +Il filtro x86 è un'eccezione. Di solito è bene attenersi alle impostazioni +predefinite di LZMA2 (\fBpb=2,lp=0,lc=3\fP) quando si comprimono gli eseguibili +x86. +.RE +.IP "" +Tutti i filtri BCJ supportano le stesse \fIOPZIONI\fP: +.RS +.TP +\fBstart=\fP\fIOFFSET\fP +Specifica l'\fIOFFSET\fP iniziale utilizzato per la conversione tra indirizzi +relativi e assoluti. L'\fIOFFSET\fP deve essere un multiplo dell'allineamento +del filtro (vedere la tabella sopra). Il valore predefinito è zero. In +pratica, l'impostazione predefinita è buona; specificare un \fIOFFSET\fP +personalizzato non è quasi mai utile. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIOPZIONI\fP] +Aggiunge un filtro Delta alla catena dei filtri. I filtri Delta non possono +essere utilizzati come ultimo filtro nella catena di filtri. +.IP "" +Al momento è supportato solo un semplice calcolo delta byte\-per\-byte. Può +essere utile quando si comprime, per esempio, immagini bitmap non compresse +o file audio PCM non compressi. Tuttavia, speciali algoritmi ad\-hoc +potrebbero dare risultati significativamente migliori che Delta + +LZMA2. Questo è vero specialmente per l'audio, che comprime più velocemente +e meglio, ad esempio, con \fBflac\fP(1). +.IP "" +\fIOPZIONI\fP supportate: +.RS +.TP +\fBdist=\fP\fIDISTANZA\fP +Specifica la \fIDISTANZA\fP del calcolo delta in byte. \fIDISTANZA\fP deve essere +nel range 1\(en256. Il valore predefinito è 1. +.IP "" +Per esempio, con \fBdist=2\fP e un input di 8 byte A1 B1 A2 B3 A3 B5 A4 B7, +l'output sarà A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Altre opzioni" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Sopprime avvertimenti e avvisi. Specificarlo due volte per eliminare anche +gli errori. Questa opzione non ha alcun effetto sullo stato di uscita. In +altre parole, anche se un avvertimento è stato eliminato, lo stato di uscita +che indica un avvertimento viene comunque utilizzato. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Sii prolisso. Se lo standard error è collegato a un terminale, \fBxz\fP +visualizzerà un indicatore di avanzamento. Specificando \fB\-\-verbose\fP due +volte si otterrà un output ancora più dettagliato. +.IP "" +L'indicatore di avanzamento mostra le seguenti informazioni: +.RS +.IP \(bu 3 +La percentuale di avanzamento è mostrata se la dimensione del file input è +nota. Quindi, la percentuale non può essere mostrata nei pipe. +.IP \(bu 3 +Quantità di dati compressi prodotti (in compressione) o utilizzati (in +decompressione). +.IP \(bu 3 +Quantità di dati non compressi consumati (in compressione) o prodotti (in +decompressione). +.IP \(bu 3 +Rapporto di compressione, calcolato dividendo la quantità di dati compressi +processati finora con la quantità di dati non compressi processati finora. +.IP \(bu 3 +Velocità di compressione o decompressione. Questa è misurata come la +quantità di dati non compressi consumati (in compressione) o prodotti (in +decompressione) al secondo. Viene mostrata dopo che è trascorso qualche +secondo da quando \fBxz\fP ha iniziato a processare il file. +.IP \(bu 3 +Tempo trascorso nel formato M:SS o H:MM:SS. +.IP \(bu 3 +Il tempo residuo stimato è mostrato solo quando la dimensione del file in +ingresso è nota e sono già passati un paio di secondi da quando \fBxz\fP ha +iniziato a processare il file. Il tempo è mostrato in un formato meno +preciso che non ha mai i due punti, ad esempio 2 min 30 s. +.RE +.IP "" +Quando lo standard error non è un terminale, \fB\-\-verbose\fP farà stampare a +\fBxz\fP il nome del file, la dimensione compressa, la dimensione non +compressa, il rapporto di compressione, e potendo anche la velocità e il +tempo trascorso, su una singola riga dello standard error, dopo aver +compresso o decompresso il file. La velocità e il tempo trascorso sono +inclusi solo se l'operazione è durata almeno un paio di secondi. Se +l'operazione non è conclusa, ad esempio a causa dell'interruzione da parte +dell'utente, viene stampata anche la percentuale di completamento, a patto +che la dimensione del file input sia nota. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Non impostare lo stato di uscita a 2 anche se è stata rilevata una +condizione che merita un avvertimento. Questa opzione non influisce sul +livello di dettaglio, quindi sia \fB\-\-quiet\fP che \fB\-\-no\-warn\fP devono essere +utilizzati per non visualizzare avvertimenti e per non alterare lo stato di +uscita. +.TP +\fB\-\-robot\fP +Stampa i messaggi in un formato analizzabile dal computer. Questo ha lo +scopo di facilitare la scrittura dei frontend che vogliono usare \fBxz\fP +invece di liblzma, che potrebbe essere il caso di vari script. Si intende +che con questa opzione abilitata l'output dovrebbe rimanere stabile tra le +versioni di \fBxz\fP. Per ulteriori informazioni, vedere la sezione \fBMODALITÀ ROBOT\fP. +.TP +\fB\-\-info\-memory\fP +Mostra, in un formato leggibile da umani, quanta memoria fisica (RAM) e +quante thread \fBxz\fP pensa che il sistema abbia e i limiti di utilizzo di +memoria per la compressione e la decompressione, quindi termina con +successo. +.TP +\fB\-h\fP, \fB\-\-help\fP +Mostra un messaggio di aiuto che descrive le opzioni usate più comunemente, +e termina con successo. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Mostra un messaggio di aiuto che descrive tutte le funzionalità di \fBxz\fP, e +termina con successo +.TP +\fB\-V\fP, \fB\-\-version\fP +Mostra il numero di versione di \fBxz\fP e liblzma in un formato leggibile +dagli umani. Per ottenere un output analizzabile da una macchina specificare +\fB\-\-robot\fP prima di \fB\-\-version\fP. +. +.SH "MODALITÀ ROBOT" +La "modalità robot" viene attivata con l'opzione \fB\-\-robot\fP. Rende l'output +di \fBxz\fP più facile da analizzare da altri programmi. Attualmente \fB\-\-robot\fP +è supportato solo insieme a \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP e +\fB\-\-version\fP. In futuro sarà supportato per la compressione e la +decompressione. +. +.SS "Modalità stampa" +\fBxz \-\-robot \-\-list\fP usa un output separato da tabulazione. La prima colonna +di ogni riga contiene una stringa che indica il tipo di informazione +contenuta in quella riga: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Questa è sempre la prima riga quando si inizia a elencare un file. La +seconda colonna della riga è il nome del file. +.TP +\fBfile\fP +Questa riga contiene informazioni generali sul file \fB.xz\fP. Questa riga +viene sempre stampata dopo la riga \fBname\fP. +.TP +\fBstream\fP +Questo tipo di riga viene utilizzato solo quando è stato specificato +\fB\-\-verbose\fP. Sono presenti tante righe \fBstream\fP quanti sono i flussi nel +file \fB.xz\fP. +.TP +\fBblock\fP +Questo tipo di riga viene utilizzato solo quando è stato specificato +\fB\-\-verbose\fP. Ci sono tante righe \fBblock\fP quanti sono i blocchi nel file +\&\fB.xz\fP. Le righe \fBblock\fP vengono visualizzate dopo tutte le righe +\fBstream\fP; i diversi tipi di riga non vengono interlacciati. +.TP +\fBsummary\fP +Questo tipo di riga viene utilizzato solo quando \fB\-\-verbose\fP è stato +specificato due volte. Questa riga viene stampata dopo tutte le righe +\fBblock\fP. Come la riga \fBfile\fP, la riga \fBsummary\fP contiene informazioni +generali sul file \fB.xz\fP. +.TP +\fBtotals\fP +Questa riga è sempre l'ultima riga dell'output dell'elenco. Mostra i +conteggi totali e le dimensioni. +.PP +Le colonne delle righe \fBfile\fP: +.PD 0 +.RS +.IP 2. 4 +Numero di flussi nel file +.IP 3. 4 +Numero totale di blocchi nel flusso/i. +.IP 4. 4 +Dimensione compressa del file +.IP 5. 4 +Dimensione non compressa del file +.IP 6. 4 +Rapporto di compressione, es. \fB0.123\fP. Se il rapporto è oltre 9999, al +posto del rapporto vengono mostrati tre trattini (\fB\-\-\-\fP). +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Elenco separato da virgole dei nomi dei controlli di integrità. Le stringhe +seguenti vengono utilizzate per i tipi di controllo conosciuti: \fBNone\fP, +\fBCRC32\fP, \fBCRC64\fP, e \fBSHA\-256\fP. Per i tipi di controllo non conosciuti +viene utilizzato \fBUnknown\-\fP\fIN\fP, dove \fIN\fP è l'ID del controllo come numero +decimale (una o due cifre). +.IP 8. 4 +Dimensione totale del padding del flusso nel file +.RE +.PD +.PP +Le colonne delle righe \fBstream\fP: +.PD 0 +.RS +.IP 2. 4 +Numero di flusso (il primo è 1) +.IP 3. 4 +Numero di blocchi nel flusso +.IP 4. 4 +Offset iniziale compressione +.IP 5. 4 +Offset iniziale decompressione +.IP 6. 4 +Dimensione compressa (non include il padding del flusso) +.IP 7. 4 +Dimensione non compressa +.IP 8. 4 +Rapporto di compressione +.IP 9. 4 +Nome del controllo di integrità +.IP 10. 4 +Dimensione del padding del flusso +.RE +.PD +.PP +Le colonne delle righe \fBblock\fP: +.PD 0 +.RS +.IP 2. 4 +Numero di flussi che contengono questo blocco +.IP 3. 4 +Numero del blocco relativo all'inizio del flusso (il primo blocco è 1) +.IP 4. 4 +Numero del blocco relativo all'inizio del file +.IP 5. 4 +Offset iniziale compressione relativo all'inizio del file +.IP 6. 4 +Offset iniziale decompressione relativo all'inizio del file +.IP 7. 4 +Dimensione totale compressa del blocco (incluse le intestazioni) +.IP 8. 4 +Dimensione non compressa +.IP 9. 4 +Rapporto di compressione +.IP 10. 4 +Nome del controllo di integrità +.RE +.PD +.PP +Se \fB\-\-verbose\fP viene specificato due volte, sono incluse colonne aggiuntive +nelle righe \fBblock\fP. Queste non sono mostrate con un \fB\-\-verbose\fP singolo, +perché recuperare queste informazioni richiede molte ricerche e quindi può +essere lento: +.PD 0 +.RS +.IP 11. 4 +Valore del controllo di integrità in formato esadecimale +.IP 12. 4 +Dimensione intestazione blocco +.IP 13. 4 +Flag del blocco: \fBc\fPindica che è presente la dimensione compressa, \fBu\fP +indica che è presente la dimensione non compressa. Se il flag non è +impostato, viene mostrato un trattino (\fB\-\fP) per mantenere fissa la +lunghezza della stringa. Nuovi flag potrebbero essere aggiunti alla fine +della stringa in futuro. +.IP 14. 4 +Dimensione dei dati compressi effettivi nel blocco (sono esclusi +l'intestazione del blocco, il padding del blocco e i campi di controllo) +.IP 15. 4 +Quantità di memoria (in byte) necessaria per decomprimere questo blocco con +questa versione \fBxz\fP +.IP 16. 4 +Catena di filtri. Si noti che la maggior parte delle opzioni utilizzate al +momento della compressione non è nota, perché solo le opzioni necessarie per +la decompressione sono memorizzate nelle intestazioni \fB.xz\fP. +.RE +.PD +.PP +Le colonne delle righe \fBsummary\fP: +.PD 0 +.RS +.IP 2. 4 +Quantità di memoria (in byte) necessaria per decomprimere questo file con +questa versione \fBxz\fP +.IP 3. 4 +\fByes\fP o \fBno\fP indica se tutte le intestazioni di blocco contengono +all'interno sia dimensioni compresse che dimensioni non compresse +.PP +\fIA partire da\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Versione minima di \fBxz\fP richiesta per decomprimere il file +.RE +.PD +.PP +Le colonne delle righe \fBtotali\fP: +.PD 0 +.RS +.IP 2. 4 +Numero di flussi +.IP 3. 4 +Numero di blocchi +.IP 4. 4 +Dimensione compressa +.IP 5. 4 +Dimensione non compressa +.IP 6. 4 +Rapporto di compressione medio +.IP 7. 4 +Elenco separato da virgole dei nomi dei controlli di integrità presenti nei +file +.IP 8. 4 +Dimensione del padding dello stream +.IP 9. 4 +Numero di file. Questo serve a mantenere l'ordine delle colonne precedenti +uguale a quello delle righe del \fBfile\fP. +.PD +.RE +.PP +Se \fB\-\-verbose\fP viene specificato due volte, sono incluse colonne aggiuntive +nella riga \fBtotali\fP: +.PD 0 +.RS +.IP 10. 4 +Quantità massima di memoria (in byte) necessaria per decomprimere i file con +questa versione \fBxz\fP +.IP 11. 4 +\fByes\fP o \fBno\fP indica se tutte le intestazioni di blocco contengono +all'interno sia dimensioni compresse che dimensioni non compresse +.PP +\fIA partire da\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Versione minima di \fBxz\fP richiesta per decomprimere il file +.RE +.PD +.PP +Versioni future potrebbero aggiungere nuovi tipi di riga e nuove colonne +possono essere aggiunte ai tipi di riga esistenti, ma le colonne esistenti +non verranno modificate. +. +.SS "Aiuto sui filtri" +\fBxz \-\-robot \-\-filters\-help\fP stampa i filtri supportati nel seguente +formato: +.PP +\fIFILTRO\fP\fB:\fP\fIOPZIONE\fP\fB=<\fP\fIVALORE\fP\fB>,\fP\fIOPZIONE\fP\fB=<\fP\fIVALORE\fP\fB>\fP... +.TP +\fIFILTRO\fP +Nome del filtro +.TP +\fIOPZIONE\fP +Nome di un'opzione specifica del filtro +.TP +\fIVALORE\fP +Gli intervalli del \fIVALORE\fP numerico appaiono come +\fB<\fP\fIMIN\fP\fB\-\fP\fIMAX\fP\fB>\fP. Le scelte per i \fIVALORI\fP stringa sono +mostrati in \fB< >\fP e separati dal carattere \fB|\fP. +.PP +Ogni filtro è mostrato su una riga dedicata. +. +.SS "Informazione limite memoria" +\fBxz \-\-robot \-\-info\-memory\fP stampa una singola riga con più colonne separate +da tabulazione: +.IP 1. 4 +Quantità totale di memoria fisica (RAM) in byte. +.IP 2. 4 +Limite utilizzo memoria per la compressione in byte +(\fB\-\-memlimit\-compress\fP). Il valore speciale \fB0\fP indica l'impostazione +predefinita, che in modalità thread singola equivale a nessun limite. +.IP 3. 4 +Limite utilizzo memoria per la decompressione in byte +(\fB\-\-memlimit\-decompress\fP). Il valore speciale \fB0\fP indica l'impostazione +predefinita, che in modalità thread singola equivale a nessun limite. +.IP 4. 4 +A partire da \fBxz\fP 5.3.4alpha: Utilizzo della memoria per la decompressione +a thread multiple in byte (\fB\-\-memlimit\-mt\-decompress\fP). Questo valore non è +mai zero perché viene utilizzato un valore predefinito specifico del sistema +mostrato nella colonna 5, se non è stato specificato alcun limite in modo +esplicito. Inoltre, non è mai maggiore del valore nella colonna 3, anche se +è stato specificato un valore maggiore con \fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +A partire da \fBxz\fP 5.3.4alpha: un limite di utilizzo della memoria +predefinito specifico del sistema, che viene utilizzato per limitare il +numero di thread durante la compressione con un numero automatico di thread +(\fB\-\-threads=0\fP) e non è stato specificato alcun limite di utilizzo della +memoria (\fB\-\-memlimit\-compress\fP). Questo viene utilizzato anche come valore +predefinito per \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +A partire da \fBxz\fP 5.3.4alpha: Numero di thread del processore disponibili. +.PP +In futuro, l'output di \fBxz \-\-robot \-\-info\-memory\fP potrebbe avere più +colonne, ma mai più di una singola riga. +. +.SS Versione +\fBxz \-\-robot \-\-version\fP stampa il numero di versione di \fBxz\fP e liblzma nel +seguente formato: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Versione major. +.TP +\fIYYY\fP +Versione minor. I numeri pari sono stabili. I numeri dispari sono versioni +alfa o beta. +.TP +\fIZZZ\fP +Livello di patch per le versioni stabili o solo un contatore per le versioni +di sviluppo. +.TP +\fIS\fP +Stabilità. 0 è alfa, 1 è beta e 2 è stabile. \fIS\fP dovrebbe essere sempre 2 +quando \fIYYY\fP è pari. +.PP +\fIXYYYZZZS\fP sono uguali su entrambe le righe se \fBxz\fP e liblzma appartengono +allo stesso rilascio delle XZ Utils. +.PP +Esempi: 4.999.9beta è \fB49990091\fP e 5.0.0 è \fB50000002\fP. +. +.SH "CODICE DI USCITA" +.TP +\fB0\fP +Tutto bene. +.TP +\fB1\fP +È avvenuto un errore. +.TP +\fB2\fP +Si è verificato qualcosa che merita un avvertimento, ma non si sono +verificati errori effettivi. +.PP +Gli avvisi (non gli avvertimenti o gli errori) stampati sullo standard error +non influiscono sullo stato di uscita. +. +.SH AMBIENTE +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP analizza elenchi di opzioni separate da spazi dalle variabili +d'ambiente \fBXZ_DEFAULTS\fP e \fBXZ_OPT\fP, in questo ordine, analizzando prima +le opzioni dalla riga di comando. Si noti che solo le opzioni vengono +analizzate dalle variabili d'ambiente; tutte le non\-opzioni vengono ignorate +silenziosamente. L'analisi viene eseguita con \fBgetopt_long\fP(3) che viene +utilizzato anche per gli argomenti della riga di comando. +.PP +\fBAttenzione:\fP Impostando queste variabili di ambiente, si sta di fatto +modificando programmi e script che lanciano \fBxz\fP. La maggior parte delle +volte va bene impostare i limiti di utilizzo della memoria, il numero di +thread e le opzioni di compressione tramite variabili d'ambiente. Tuttavia, +alcune opzioni possono rompere degli script. Un esempio banale è \fB\-\-help\fP +che forza \fBxz\fP a mostrare la pagina di aiuto anziché comprimere o +decomprimere file. Esempi meno ovvi sono \fB\-\-quiet\fP e \fB\-\-verbose\fP. In +molti casi funziona bene abilitare l'indicatore di avanzamento usando +\fB\-\-verbose\fP, ma in alcune situazioni i messaggi extra creano problemi. Il +livello di prolissità influisce anche sul comportamento di \fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Opzioni predefinite specifiche dell'utente o a livello di sistema. In genere +questo viene impostato in uno script di inizializzazione della shell per +abilitare il valore predefinito del limitatore di utilizzo della memoria di +\fBxz\fP, o per impostare il numero di thread predefinito. Escludendo gli +script di inizializzazione della shell e analoghi casi particolari, gli +script non dovrebbero mai impostare o annullare l'impostazione di +\fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Questo serve per passare le opzioni a \fBxz\fP quando non sia possibile +impostare le opzioni direttamente sulla riga di comando di \fBxz\fP. Questo è +il caso quando \fBxz\fP viene eseguito da uno script o da uno strumento, ad +esempio GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Gli script possono usare \fBXZ_OPT\fP, per esempio, per impostare opzioni di +compressione predefinite specifiche per lo script. Si raccomanda comunque di +permettere agli utenti di sovrascrivere \fBXZ_OPT\fPse questo è ragionevole. Ad +esempio, negli script \fBsh\fP(1) si può usare qualcosa come questo: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "COMPATIBILITÀ LZMA UTILS" +La sintassi della riga di comando di \fBxz\fP è essenzialmente un sopra\-insieme +di \fBlzma\fP, \fBunlzma\fP, e \fBlzcat\fP come trovati nelle LZMA Utils +4.32.x. Nella maggior parte dei casi è possibili sostituire le LZMA Utils +con le XZ Utils senza rompere gli script esistenti. Ci sono però alcune +incompatibilità, che in alcuni casi potrebbero causare problemi. +. +.SS "Livelli di compressione preimpostati" +La numerazione dei livelli di compressione preimpostati non è identica in +\fBxz\fP e nelle LZMA Utils. La differenza più importante è il modo in cui le +dimensioni del dizionario vengono mappate sulle diverse preimpostazioni. La +dimensione del dizionario è approssimativamente uguale all'utilizzo della +memoria del decompressore. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Livello;xz;LZMA Utils +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Le differenze di dimensione del dizionario influiscono anche sull'utilizzo +della memoria del compressore, ma ci sono alcune altre differenze tra le +LZMA Utils e le XZ Utils, che rendono la differenza ancora più grande: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Livello;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Il livello preimpostato predefinito nelle LZMA Utils è \fB\-7\fP mentre nelle XZ +Utils è \fB\-6\fP, quindi entrambi utilizzano un dizionario da 8 MiB per +impostazione predefinita. +. +.SS "File .lzma con flussi vs. senza flussi" +La dimensione non compressa del file può essere memorizzata +nell'intestazione \fB.lzma\fP. Le LZMA Utils lo fanno durante la compressione +di file regolari. L'alternativa consiste nel memorizzare che la dimensione +non compressa è sconosciuta e utilizzare l'indicatore di fine carico utile +per indicare il punto in cui il decompressore deve fermarsi. Le LZMA Utils +utilizzano questo metodo quando le dimensioni non compresse non sono note, +come nel caso, ad esempio, delle pipe. +.PP +\fBxz\fP supporta la decompressione di file \fB.lzma\fP con o senza il marcatore +di fine payload, ma tutti i file \fB.lzma\fP creati da \fBxz\fP utilizzeranno il +marcatore di fine payload e avranno dimensioni non compresse contrassegnate +come sconosciute nell'intestazione \fB.lzma\fP. Questo può essere un problema +in alcune situazioni non comuni. Ad esempio, un decompressore \fB.lzma\fP in un +dispositivo embedded potrebbe funzionare solo con file con dimensioni non +compresse note. Se si incorre in questo problema, occorre utilizzare le LZMA +Utils oppure l'LZMA SDK per creare dei file \fB.lzma\fP con dimensioni non +compresse note. +. +.SS "File .lzma non supportati" +Il formato \fB.lzma\fP permette valori \fIlc\fP fino a 8, e valori \fIlp\fP fino a +4. Le LZMA Utils possono decomprimere file con qualunque \fIlc\fP e \fIlp\fP, ma +creeranno sempre file con \fBlc=3\fP e \fBlp=0\fP. Creare file con altri \fIlc\fP e +\fIlp\fP è possibile con \fBxz\fP e con l'LZMA SDK. +.PP +L'implementazione del filtro LZMA1 in liblzma richiede che la somma di \fIlc\fP +e \fIlp\fP non debba superare 4. Pertanto, i file \fB.lzma\fP che superano questa +limitazione non possono essere decompressi con \fBxz\fP. +.PP +Le LZMA Utils creano solo file \fB.lzma\fP con dimensione del dizionario 2^\fIn\fP +(una potenza di 2) ma accettano file con qualsiasi dimensione di +dizionario. liblzma accetta solo file \fB.lzma\fP con dimensione del dizionario +2^\fIn\fP o 2^\fIn\fP + 2^(\fIn\fP\-1). Questo serve a limitare i falsi positivi +quando si cerca di identificare i file \fB.lzma\fP. +.PP +All'atto pratico queste limitazioni non dovrebbero essere un problema, +perché praticamente tutti i file \fB.lzma\fP sono stati compressi con +impostazioni che liblzma accetterà. +. +.SS "Dati sporchi finali" +Quando si decomprime, le LZMA Utils ignorano automaticamente tutto quello +che c'è dopo il primo flusso \fB.lzma\fP. Nella maggior parte delle situazioni +questo è un baco. Questo significa anche che le LZMA Utils non supportano la +decompressione di file \fB.lzma\fP concatenati. +.PP +Se sono rimasti dati dopo il primo flusso \fB.lzma\fP, \fBxz\fP considera il file +corrotto a meno che sia stato utilizzato \fB\-\-single\-stream\fP. Questo può far +rompere script incomprensibili che hanno assunto che i dati sporchi finali +vengano ignorati. +. +.SH NOTE +. +.SS "L'output compresso può variare" +L'esatto output compresso prodotto dallo stesso file di input non compresso +può variare tra le versioni delle XZ Utils, anche se le opzioni di +compressione sono le stesse. Questo perché il codificatore può essere stato +migliorato (compressione più veloce o migliore) senza influire sul formato +del file. L'output può variare anche tra diverse build della stessa versione +delle XZ Utils, se vengono utilizzate opzioni di build differenti. +.PP +Quanto sopra significa che una volta che \fB\-\-rsyncable\fP è stato +implementato, i file risultanti non saranno necessariamente rsync\-abili a +meno che sia i vecchi che i nuovi file non siano stati compressi con la +stessa versione di xz. Questo problema può essere risolto se una parte +dell'implementazione del codificatore viene congelata per mantenere stabile +l'output rsync\-abile tra le versioni di xz. +. +.SS "Abilita i decompressori .xz" +Le implementazioni dei decompressori \fB.xz\fP embedded, come XZ Embedded, non +necessariamente supportano file creati con tipi di integrità \fICONTROLLO\fP +diversi da \fBnone\fP e \fBcrc32\fP. Dal momento che il valore predefinito è +\fB\-\-check=crc64\fP, occorre specificare \fB\-\-check=none\fP o \fB\-\-check=crc32\fP +quando si creano file per sistemi embedded. +.PP +Al di fuori dei sistemi embedded, tutti i decompressori in formato \fB.xz\fP +supportano tutti i tipi di \fICONTROLLO\fP, o almeno sono in grado di +decomprimere il file senza verificare il controllo di integrità se il +particolare \fICONTROLLO\fP non è supportato. +.PP +XZ Embedded supporta i filtri BCJ, ma solo con offset iniziale predefinito. +. +.SH ESEMPI +. +.SS "Informazioni di base" +Comprime il file \fIfoo\fP in \fIfoo.xz\fP utilizzando il livello di compressione +predefinito (\fB\-6\fP) e rimuove \fIfoo\fP se la compressione ha esito positivo: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Decomprime \fIbar.xz\fP in \fIbar\fP e non rimuove \fIbar.xz\fP anche se la +decompressione ha successo: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Crea \fIbaz.tar.xz\fP con il preset \fB\-4e\fP (\fB\-4 \-\-extreme\fP), che è più lenta +della predefinita \fB\-6\fP, ma ha bisogno di meno memoria per la compressione e +decompressione (48\ MiB e 5\ MiB, rispettivamente): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Una combinazione di file compressi e non compressi può essere decompressa +sullo output standard con un singolo comando: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Compressione parallela di più file" +Su GNU e *BSD, \fBfind\fP(1) e \fBxargs\fP(1) possono essere usati per +parallelizzare la compressione di più file: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +L'opzione \fB\-p\fP di \fBxargs\fP(1) imposta il numero di processi \fBxz\fP +paralleli. Il valore migliore per l'opzione \fB\-n\fP dipende dal numero di file +da comprimere. Se sono presenti solo un paio di file, il valore dovrebbe +probabilmente essere 1; con decine di migliaia di file, 100 o anche di più +può essere appropriato per ridurre il numero di processi \fBxz\fP che +\fBxargs\fP(1) alla fine creerà. +.PP +L'opzione \fB\-T1\fP per \fBxz\fP serve a forzare la modalità a thread singola, +perché \fBxargs\fP (1) viene utilizzato per controllare la quantità di +parallelizzazione. +. +.SS "Modalità robot" +Calcola quanti byte sono stati salvati in totale dopo la compressione di più +file: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Uno script potrebbe voler sapere se si sta utilizzando una versione di \fBxz\fP +sufficientemente recente. Il seguente script \fBsh\fP(1) controlla che il +numero di versione dello strumento \fBxz\fP sia almeno 5.0.0. Questo metodo è +compatibile con le vecchie versioni beta, che non supportavano l'opzione +\fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Imposta un limite di utilizzo della memoria per la decompressione +utilizzando \fBXZ_OPT\fP, ma se è già stato impostato un limite, non lo +aumenta: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Catene di filtri di compressione personalizzate" +L'uso più semplice delle catene di filtri personalizzate è la +personalizzazione di un preset di LZMA2. Questo può essere utile, perché i +preset coprono solamente un sottoinsieme di tutte le combinazioni di +impostazioni di compressione potenzialmente utili. +.PP +Le colonne CompCPU delle tabelle dalle descrizioni delle opzioni \fB\-0\fP +\&... \fB\-9\fP e \fB\-\-extreme\fP sono utili quando si personalizzano i preset di +LZMA2. Di seguito sono riportate le parti rilevanti raccolte da queste due +tabelle: +.RS +.PP +.TS +tab(;); +c c +n n. +Livello preimpostato;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Se si sa che un file richiede un dizionario piuttosto grande (ad esempio, +32\ MiB) per essere compresso bene, ma si desidera comprimerlo più +velocemente di quanto farebbe \fBxz \-8\fP, è possibile modificare un preset con +un basso valore CompCPU (ad esempio, 1) per utilizzare un dizionario più +grande: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Con alcuni file, il comando sopra potrebbe essere più veloce di \fBxz \-6\fP e +la compressione significativamente migliore. Tuttavia, si deve sottolineare +che solo alcuni file traggono beneficio da un dizionario grande e mantengono +basso il valore di CompCPU. La situazione più ovvia in cui un dizionario +grande può aiutare molto è un archivio contenente file molto simili di +almeno un paio di megabyte ciascuno. La dimensione del dizionario deve +essere significativamente più grande di ogni singolo file per permettere a +LZMA2 di trarre pieno vantaggio dalle somiglianze tra file consecutivi. +.PP +Se l'utilizzo molto elevato della memoria del compressore e del +decompressore è accettabile, e il file da comprimere è almeno di diverse +centinaia di megabyte, potrebbe essere utile utilizzare un dizionario ancora +più grande dei 64 MiB che \fBxz \-9\fP utilizzerebbe: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +L'uso di \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) come nell'esempio precedente può +essere utile per vedere i requisiti di memoria del compressore e del +decompressore. Tenere presente che l'utilizzo di un dizionario più grande +della dimensione del file non compresso è uno spreco di memoria, quindi il +comando precedente non è utile per i file di piccole dimensioni. +.PP +A volte il tempo di compressione non importa, ma l'utilizzo di memoria del +decompressore deve essere tenuta bassa, per esempio, per permettere di +decomprimere il file in un sistema embedded. Il comando seguente usa \fB\-6e\fP +(\fB\-6 \-\-extreme\fP) come base e imposta il dizionario a soli 64\ KiB. Il file +risultante può essere decompresso con XZ Embedded (ecco perché c'è +\fB\-\-check=crc32\fP) usando circa 100\ KiB di memoria. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Se si desidera spremere il maggior numero possibile di byte, a volte può +essere utile regolare il numero di bit di contesto letterale (\fIlc\fP) e il +numero di bit di posizione (\fIpb\fP). Anche la regolazione del numero di bit +di posizione letterale (\fIlp\fP) potrebbe essere d'aiuto, ma di solito \fIlc\fP e +\fIpb\fP sono più importanti. Per esempio, un archivio di codici sorgente +contiene principalmente testo US\-ASCII, quindi qualcosa come il seguente +potrebbe produrre un file leggermente (0,1\ %) più piccolo di \fBxz \-6e\fP +(provare anche senza \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Usare un altro filtro insieme a LZMA2 può migliorare la compressione per +alcuni tipi di file. Ad esempio, per comprimere una libreria condivisa +x86\-32 o x86\-64 usare il filtro BCJ: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Si noti che l'ordine delle opzioni di filtro è significativo. Se viene +specificato \fB\-\-x86\fP dopo \fB\-\-lzma2\fP, \fBxz\fP darà un errore, perché non può +esserci alcun filtro dopo LZMA2 e anche perché il filtro BCJ x86 non può +essere utilizzato come ultimo filtro della catena. +.PP +Il filtro Delta insieme con LZMA2 può dare buoni risultati sulle immagini +bitmap. Di solito dovrebbe battere il PNG, il quale ha alcuni filtri più +avanzati rispetto al semplice delta ma utilizza Deflate per la compressione +effettiva. +.PP +L'immagine deve essere salvata in un formato non compresso, ad esempio un +TIFF non compresso. Il parametro distanza del filtro Delta è impostato in +modo che corrisponda al numero di byte per pixel nell'immagine. Per esempio, +un bitmap a 24 bit richiede \fBdist=3\fP, e va anche bene passare \fBpb=0\fP a +LZMA2 per adattarsi all'allineamento a tre byte: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Se più immagini sono state inserite in un singolo archivio (ad esempio, +\&\fB.tar\fP), il filtro Delta funzionerà anche su questo purché tutte le +immagini abbiano lo stesso numero di byte per pixel. +. +.SH "VEDERE ANCHE" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xzcat.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xzcat.1 new file mode 100644 index 0000000000000000000000000000000000000000..53a915947bff84fc5f9cfbb4d4ed88097620e055 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xzcat.1 @@ -0,0 +1,2080 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Italian translations for xz-man package +.\" Luca Vercelli , 2024-2025 +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 08/03/2025 Tukaani "XZ Utils" +. +.SH NOME +xz, unxz, xzcat, lzma, unlzma, lzcat \- Comprime o decomprime file .xz e +\&.lzma +. +.SH SINOSSI +\fBxz\fP [\fIOPZIONE...\fP] [\fIFILE...\fP] +. +.SH "ALIAS DEI COMANDI" +\fBunxz\fP è equivalente a \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP è equivalente a \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP è equivalente a \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP è equivalente a \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP è equivalente a \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Quando si scrivono script che richiedono di decomprimere file, si raccomanda +di utilizzare sempre il comando \fBxz\fP con argomenti appropriati (\fBxz \-d\fP o +\fBxz \-dc\fP) al posto degli alias \fBunxz\fP e \fBxzcat\fP. +. +.SH DESCRIZIONE +\fBxz\fP è uno strumento di compressione dati generico con sintassi della riga +di comando simile a \fBgzip\fP(1) e \fBbzip2\fP(1). Il formato file nativo è +\&\fB.xz\fP, ma sono supportati anche il formato tradizionale \fB.lzma\fP usato +dalle LZMA Utils e i flussi grezzi (raw) compressi senza intestazioni di +formato contenitore. In più, è supportata la decompressione del formato +\&\fB.lz\fPusato da \fBlzip\fP. +.PP +\fBxz\fP comprime o decomprime ogni \fIFILE\fP a seconda della modalità di +funzionamento selezionata. Se nessun \fIFILE\fP è indicato o se \fIFILE\fP è \fB\-\fP, +\fBxz\fP legge dallo standard input e scrive i dati processati sullo standard +output. \fBxz\fP si rifiuterà (stamperà un errore e salterà il \fIFILE\fP) di +scrivere dati compressi sullo standard output se è il +terminale. Analogamente, \fBxz\fP si rifiuterà di leggere dati compressi dallo +standard input se è il terminale. +.PP +A meno che non sia specificato \fB\-\-stdout\fP, i \fIFILE\fP diversi da \fB\-\fP +vengono scritti in un nuovo file il cui nome deriva dal nome del \fIFILE\fP +sorgente: +.IP \(bu 3 +Quando si comprime, il suffisso del file destinazione (\fB.xz\fP or \fB.lzma\fP) +viene accodato al nome del file sorgente per ottenere il nome del file +destinazione. +.IP \(bu 3 +Quando si decomprime, i suffissi \fB.xz\fP, \fB.lzma\fP, o \fB.lz\fP vengono rimossi +dal nome del file per ottenere il nome del file destinazione. \fBxz\fP +riconosce anche i suffissi \fB.txz\fP e \fB.tlz\fP, e li sostituisce con il +suffisso \fB.tar\fP. +.PP +Se il file di destinazione esiste già, viene visualizzato un errore e +\fIFILE\fP viene saltato. +.PP +A meno che non si scriva nello standard output, \fBxz\fP visualizzerà un +avvertimento e salterà il \fIFILE\fP se si verifica una delle seguenti +condizioni: +.IP \(bu 3 +\fIFILE\fP non è un file regolare. I collegamenti simbolici non vengono +seguiti, quindi non sono considerati file regolari. +.IP \(bu 3 +\fIFILE\fP ha più di un collegamento "hard". +.IP \(bu 3 +\fIFILE\fP ha impostati i bit setuid, setgid, o sticky. +.IP \(bu 3 +La modalità di funzionamento è impostata sulla compressione e il \fIFILE\fP ha +già un suffisso del formato di file di destinazione (\fB.xz\fP o \fB.txz\fP quando +si comprime nel formato \fB.xz\fP e \fB.lzma\fP o \fB.tlz\fP quando si comprime nel +formato \fB.lzma\fP). +.IP \(bu 3 +La modalità di funzionamento è impostata sulla decompressione e il \fIFILE\fP +non ha un suffisso di nessuno dei formati di file supportati (\fB.xz\fP, +\&\fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, o \fB.lz\fP). +.PP +Dopo aver compresso o decompresso correttamente il \fIFILE\fP, \fBxz\fP copia il +proprietario, il gruppo, le autorizzazioni, l'ora di accesso e l'ora di +modifica dal \fIFILE\fP di origine al file di destinazione. Se la copia del +gruppo fallisce, le autorizzazioni vengono modificate in modo che il file di +destinazione non diventi accessibile agli utenti che non disponevano +dell'autorizzazione per accedere al \fIFILE\fP di origine. \fBxz\fP non supporta +ancora la copia di altri metadati, ad esempio elenchi di controllo degli +accessi o attributi estesi. +.PP +Una volta che il file di destinazione è stato chiuso con successo, il +\fIFILE\fP sorgente viene rimosso, a meno che sia stato specificato +\fB\-\-keep\fP. Il \fIFILE\fP sorgente non viene mai rimosso se l'output è scritto +sullo standard output, né se si verifica un errore. +.PP +L'invio di \fBSIGINFO\fP o \fBSIGUSR1\fP al processo \fBxz\fP comporta la stampa +delle informazioni sullo stato di avanzamento sullo standard error. Questo +ha solo un uso limitato poiché quando lo standard error è un terminale, +utilizzando \fB\-\-verbose\fP verrà visualizzato un indicatore di avanzamento che +si aggiorna automaticamente. +. +.SS "Utilizzo memoria" +L'utilizzo della memoria di \fBxz\fP varia da poche centinaia di kilobyte a +diversi gigabyte a seconda delle impostazioni di compressione. Le +impostazioni utilizzate durante la compressione di un file determinano i +requisiti di memoria del decompressore. In genere il decompressore richiede +dal 5\% al 20\% della quantità di memoria necessaria al compressore durante +la creazione del file. Ad esempio, la decompressione di un file creato con +\fBxz \-9\fP al momento richiede 65\ MiB di memoria. Ancora, è possibile avere +file \fB.xz\fP che richiedono diversi gigabyte di memoria per la +decompressione. +.PP +Soprattutto gli utenti di sistemi più vecchi possono trovare fastidiosa +l'eventualità di un utilizzo molto elevato di memoria. Per evitare +spiacevoli sorprese, \fBxz\fP dispone di un limitatore di utilizzo della +memoria incorporato, che è disabilitato per impostazione predefinita. Anche +se alcuni sistemi operativi forniscono modi per limitare l'utilizzo della +memoria dei processi, fare affidamento su questi non è stato ritenuto +sufficientemente flessibile (ad esempio, l'uso di \fBulimit\fP(1) per limitare +la memoria virtuale tende a paralizzare \fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Il limitatore di utilizzo della memoria può essere abilitato con l'opzione +della riga di comando \fB\-\-memlimit=\fP\fILIMITE\fP. Spesso è più conveniente +abilitare il limitatore per impostazione predefinita impostando la variabile +d'ambiente \fBXZ_DEFAULTS\fP, ad esempio, \fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. È +possibile impostare separatamente i limiti per la compressione e la +decompressione utilizzando \fB\-\-memlimit\-compress=\fP\fILIMITE\fP and +\fB\-\-memlimit\-decompress=\fP\fILIMITE\fP. L'uso di queste due opzioni al di fuori +di \fBXZ_DEFAULTS\fP è raramente utile perché una singola esecuzione di \fBxz\fP +non può eseguire sia la compressione che la decompressione e +\fB\-\-memlimit=\fP\fILIMITE\fP (or \fB\-M\fP \fILIMITE\fP) è più breve da digitare sulla +riga di comando. +.PP +Se il limite di utilizzo della memoria specificato viene superato durante la +decompressione, \fBxz\fP visualizzerà un errore e la decompressione del file +fallirà. Se il limite viene superato durante la compressione, \fBxz\fP tenterà +di ridimensionare le impostazioni in modo che il limite non venga più +superato (tranne quando si usa \fB\-\-format=raw\fP o \fB\-\-no\-adjust\fP). In questo +modo l'operazione non fallirà a meno che il limite sia molto basso. Il +ridimensionamento delle impostazioni viene eseguito in piccole differenze +che non corrispondono ai livelli di compressione preimpostati, ad esempio, +se il limite è solo leggermente inferiore alla quantità richiesta per \fBxz \-9\fP, le impostazioni saranno ridimensionate solo un poco, non proprio fino a +\fBxz \-8\fP. +. +.SS "Concatenazione e padding con file .xz" +È possibile concatenare i file \fB.xz\fP così come sono. \fBxz\fP decomprimerà +tali file come se fossero un singolo file \fB.xz\fP. +.PP +È possibile inserire un padding tra le parti concatenate o dopo l'ultima +parte. Il padding deve essere costituito da byte "null" e la dimensione del +padding deve essere un multiplo di quattro byte. Questo può essere utile, ad +esempio, se il file \fB.xz\fP è memorizzato su un supporto che misura le +dimensioni dei file in blocchi di 512 byte. +.PP +Concatenazione e padding non sono permessi con file \fB.lzma\fP o con flussi +grezzi. +. +.SH OPZIONI +. +.SS "Suffissi interi e valori speciali" +Nella maggior parte dei casi in cui è previsto un argomento intero, è +supportato un suffisso facoltativo per indicare facilmente numeri interi di +grandi dimensioni. Non deve esserci alcuno spazio tra il numero intero e il +suffisso. +.TP +\fBKiB\fP +Moltiplica l'intero per 1024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP, e \fBKB\fP +sono accettati come sinonimi di \fBKiB\fP. +.TP +\fBMiB\fP +Moltiplica l'intero per 1.048.576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP, e \fBMB\fP sono +accettati come sinonimi di \fBMiB\fP. +.TP +\fBGiB\fP +Moltiplica l'intero per 1.073.741.824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP, e \fBGB\fP +sono accettati come sinonimi di \fBGiB\fP. +.PP +Il valore speciale \fBmax\fP può essere utilizzato per indicare il valore +intero massimo supportato dall'opzione. +. +.SS "Modalità operativa" +Se vengono fornite più opzioni di modalità operativa, l'ultima ha effetto. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Compressione. Questa è la modalità operativa predefinita quando non viene +specificata alcuna opzione della modalità operativa e non è determinata +nessun'altra modalità operativa dal nome del comando (ad esempio, \fBunxz\fP +implica \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Dopo che la compressione è terminata con successo, il file origine viene +rimosso a meno che si stia scrivendo su standard output o che venga +specificato \fB\-\-keep\fP. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Decompressione. Dopo che la decompressione è terminata con successo, il file +origine viene rimosso a meno che si stia scrivendo su standard output o che +venga specificato \fB\-\-keep\fP. +.TP +\fB\-t\fP, \fB\-\-test\fP +Testa l'integrità dei \fIFILE\fP compressi. Questa opzione è equivalente a +\fB\-\-decompress \-\-stdout\fP tranne per il fatto che i dati decompressi vengono +scartati invece di essere scritti nello standard output. Nessun file viene +creato o rimosso. +.TP +\fB\-l\fP, \fB\-\-list\fP +Stampa le informazioni sul \fIFILE\fP compresso. Non viene prodotto alcun +output non compresso e non viene creato o rimosso alcun file. In modalità +elenco, il programma non è in grado di leggere i dati compressi dallo +standard input o da altre fonti che non permettano la ricerca. +.IP "" +Il tracciato predefinito mostra le informazioni di base sui \fIFILE\fP, un file +per riga. Per ottenere informazioni più dettagliate, usare anche l'opzione +\fB\-\-verbose\fP. Per avere ancora più informazioni, usare \fB\-\-verbose\fP due +volte, ma si noti che questo può essere lento, perché ottenere tutte le +informazioni extra richiede molte estrazioni. La larghezza dell'output +dettagliato supera gli 80 caratteri, quindi il reindirizzamento dell'output, +ad esempio, a \fBless\ \-S\fP può essere utile se il terminale non è +sufficientemente ampio. +.IP "" +L'output esatto può variare tra le versioni di \fBxz\fP e le diverse +impostazioni locali. Per un output leggibile dalla macchina si dovrebbe +utilizzare \fB\-\-robot \-\-list\fP. +. +.SS "Modificatori dell'operazione" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Non elimina i file input. +.IP "" +A partire da \fBxz\fP 5.2.6, questa opzione fa sì che \fBxz\fP comprima o +decomprima anche se l'input è un collegamento simbolico a un file regolare, +ha più di un collegamento fisico o ha il bit setuid, setgid o sticky +impostato. I bit setuid, setgid e sticky non vengono copiati nel file di +destinazione. Nelle versioni precedenti questo veniva fatto solo con +\fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Questa opzione ha diverse conseguenze: +.RS +.IP \(bu 3 +Se il file di destinazione esiste già, lo elimina prima di comprimere o +decomprimere. +.IP \(bu 3 +Comprime o decomprime anche se l'input è un collegamento simbolico a un file +regolare, ha più di un collegamento "hard", o ha il bit setuid, setgid o +sticky impostato. I bit setuid, setgid e sticky non sono copiati sul file +destinazione. +.IP \(bu 3 +Quando usato con \fB\-\-decompress\fP \fB\-\-stdout\fP e \fBxz\fP non riesce a +riconoscere il tipo di file sorgente, copia il file sorgente così com'è +sullo standard output. Questo permette a \fBxzcat\fP \fB\-\-force\fP di essere usato +come \fBcat\fP(1) per file che non siano stati compressi con \fBxz\fP. Si noti che +in futuro \fBxz\fP potrebbe supportare nuovi formati di file compressi, il che +potrebbe portare \fBxz\fP a decomprimere più tipi di file anziché copiarli come +sono sullo standard output. \fB\-\-format=\fP\fIFORMATO\fP può essere usato per +forzare \fBxz\fP a decomprimere solo un singolo formato di file. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Scrive i dati compressi o decompressi nello standard output anziché in un +file. Implica \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Decomprime solo il primo flusso \fB.xz\fP, e ignora automaticamente i possibili +dati di input rimanenti che seguono il flusso. Normalmente questi dati +sporchi finali portano \fBxz\fP a visualizzare un errore. +.IP "" +\fBxz\fP non decomprime mai più di un flusso dai file \fB.lzma\fP o dai flussi +grezzi, ma questa opzione fa comunque in modo che \fBxz\fP ignori i possibili +dati finali dopo il file \fB.lzma\fP o il flusso grezzo. +.IP "" +Questa opzione non ha effetto se la modalità operativa non è \fB\-\-decompress\fP +o \fB\-\-test\fP. +.IP "" +Dalla versione \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP implica \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Disabilita la creazione di file sparsi. Per impostazione predefinita, se si +esegue la decompressione in un file regolare, \fBxz\fP tenta di rendere il file +sparso se i dati decompressi contengono lunghe sequenze di zeri +binari. Funziona anche quando si scrive su standard output, purché lo +standard output sia collegato a un file regolare e siano soddisfatte alcune +condizioni aggiuntive per renderlo sicuro. La creazione di file sparsi può +risparmiare spazio su disco e velocizzare la decompressione riducendo la +quantità di I/O su disco. +.TP +\fB\-S\fP \fI.SUFFISSO\fP, \fB\-\-suffix=\fP\fI.SUFFISSO\fP +Durante la compressione, utilizzare \fI.suf\fP come suffisso per il file di +destinazione anziché \fB.xz\fP o \fB.lzma\fP. Se non si scrive nello standard +output e il file di origine ha già il suffisso \fI.suf\fP, viene visualizzato +un avvertimento e il file viene ignorato. +.IP "" +Quando si decomprime, accetta i file con suffisso \fI.suf\fP in aggiunta a +quelli con suffisso \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, o \fB.lz\fP. Se il file +sorgente ha suffisso \fI.suf\fP, il suffisso viene rimosso per ottenere il nome +del file destinazione. +.IP "" +Quando si comprimono o decomprimono flussi grezzi (\fB\-\-format=raw\fP), il +suffisso deve sempre essere specificato, a meno che si scriva sullo standard +output, perché non esiste un suffisso predefinito per i flussi grezzi. +.TP +\fB\-\-files\fP[\fB=\fP\fIFILE\fP] +Legge i nomi dei file da processare da \fIFILE\fP; se \fIFILE\fP è omesso, i nomi +dei file vengono letti dallo standard input. I nomi dei file devono essere +terminati da un carattere "a capo". Un trattino (\fB\-\fP) è considerato come un +nome di file regolare; non indica lo standard input. Se vengono forniti +anche dei nomi di file come argomenti della riga di comando, questi sono +processati prima di quelli letti da \fIFILE\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIFILE\fP] +Questo è identico a \fB\-\-files\fP[\fB=\fP\fIFILE\fP] tranne per il fatto che ogni +nome di file deve terminare con il carattere null. +. +.SS "Formato file di base e opzioni di compressione" +.TP +\fB\-F\fP \fIFORMATO\fP, \fB\-\-format=\fP\fIFORMATO\fP +Specifica il \fIFORMATO\fP del file da comprimere o decomprimere: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Questa è l'impostazione predefinita. Quando si comprime, \fBauto\fP è +equivalente a \fBxz\fP. Quando si decomprime, il formato del file input viene +rilevato automaticamente. Si noti che per i flussi grezzi (creati con +\fB\-\-format=raw\fP) non è possibile il rilevamento automatico. +.TP +\fBxz\fP +Comprime nel formato di file \fB.xz\fP, oppure accetta solo file \fB.xz\fP durante +la decompressione. +.TP +\fBlzma\fP, \fBalone\fP +Comprime nel formato tradizionale \fB.lzma\fP, oppure accetta solo file +\&\fB.lzma\fP per la decompressione. Il nome alternativo \fBalone\fP è fornito per +retrocompatibilità con le LZMA Utils. +.TP +\fBlzip\fP +Accetta solo file \fB.lz\fP per la decompressione. La compressione non è +supportata. +.IP "" +Sono supportate le versioni 0 e 1 del formato \fB.lz\fP. I file in versione 0 +sono stati prodotti da \fBlzip\fP 1.3 e precedenti. Questi file non sono +comuni, ma possono essere trovati negli archivi di file, perché alcuni +pacchetti sorgente erano stati rilasciati in questo formato. Qualcuno +potrebbe anche avere vecchi file personali in questo formato. Il supporto +alla decompressione per la versione di formato 0 è stato rimosso in \fBlzip\fP +1.18. \fBlzip\fP 1.4 e successivi creano i file nella versione di formato 1. +.TP +\fBraw\fP +Comprime o decomprime un flusso grezzo (senza intestazione). Questo è inteso +solamente per utenti avanzati. Per decodificare flussi grezzi, occorre usare +\fB\-\-format=raw\fP e specificare esplicitamente la catena dei filtri, che +normalmente sarebbero conservati nell'intestazione. +.RE +.TP +\fB\-C\fP \fICONTROLLO\fP, \fB\-\-check=\fP\fICONTROLLO\fP +Specifica il tipo di controllo di integrità. Il controllo viene calcolato +dai dati non compressi e memorizzato nel file \fB.xz\fP. Questa opzione ha +effetto solo quando si comprime nel formato \fB.xz\fP; il formato \fB.lzma\fP non +supporta i controlli di integrità. Il controllo di integrità (se presente) +viene verificato quando il file \fB.xz\fP viene decompresso. +.IP "" +Tipi di \fICONTROLLI\fP supportati: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Non calcola proprio il controllo di integrità. Questo in genere è una +pessima idea. Può essere utile quando l'integrità dei dati viene comunque +verificata con altri mezzi. +.TP +\fBcrc32\fP +Calcola la firma CRC32 usando il polinomio di IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Calcola la firma CRC64 usando il polinomio di ECMA\-182. Questa è +l'impostazione predefinita, perché è leggermente migliore della CRC32 nel +rilevare i file danneggiati e la differenza di velocità è trascurabile. +.TP +\fBsha256\fP +Calcola la firma SHA\-256. Questo è un po' più lento che CRC32 e CRC64. +.RE +.IP "" +L'integrità delle intestazioni \fB.xz\fP viene sempre verificata con CRC32. Non +è possibile modificarlo o disabilitarlo. +.TP +\fB\-\-ignore\-check\fP +Non verifica il controllo di integrità dei dati compressi durante la +decompressione. Il valore CRC3 nelle intestazioni \fB.xz\fP sarà ancora +verificata normalmente. +.IP "" +\fBNon usare questa opzione se non si è consci di cosa si sta facendo.\fP +Possibili ragioni per utilizzare questa opzione: +.RS +.IP \(bu 3 +Tentativo di recupero dei dati da un file .xz corrotto. +.IP \(bu 3 +Accelerazione della decompressione. Questo è importante soprattutto con +SHA\-256 o con i file che sono stati compressi molto bene. Si consiglia di +non utilizzare questa opzione per questo scopo, a meno che l'integrità del +file non venga verificata esternamente in altro modo. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Selezionare un livello di compressione preimpostato. Il valore predefinito è +\fB\-6\fP. Se vengono specificati più livelli preimpostati, l'ultimo ha +effetto. Se è già stata specificata una catena di filtri personalizzata, +l'impostazione di un livelli preimpostati cancella la catena di filtri +personalizzata. +.IP "" +Le differenze tra i livelli preimpostati sono più significative rispetto a +\fBgzip\fP(1) e \fBbzip2\fP(1). Le impostazioni di compressione selezionate +determinano i requisiti di memoria del decompressore, quindi l'utilizzo di +un livello preimpostato troppo alto potrebbe rendere difficile la +decompressione del file su un vecchio sistema con poca RAM. Specificamente, +\fBnon è una buona idea utilizzare ciecamente \-9 per tutto\fP come spesso +accade per \fBgzip\fP(1) e \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Questi sono livelli preimpostati piuttosto veloci. \fB\-0\-\fP a volte è più +veloce di \fBgzip \-9\fP e comprime molto meglio. Quelli più alti hanno spesso +una velocità paragonabile a \fBbzip2\fP(1) con un rapporto di compressione +comparabile o migliore, anche se i risultati dipendono molto dal tipo di +dati che vengono compressi. +.TP +\fB\-4\fP ... \fB\-6\fP +Compressione da buona a molto buona, mantenendo l'utilizzo della memoria del +decompressore ragionevole anche per vecchi sistemi. \fB\-6\fP è il valore +predefinito, che di solito è una buona scelta per distribuire file che +debbano essere decompressi anche su sistemi con solo 16\ MiB di +RAM. (Potrebbe valere la pena di considerare anche \fB\-5e\fP o \fB\-6e\fP. Si veda +\fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Questi sono come \fB\-6\fP ma con requisiti di memoria di compressore e +decompressore più elevati. Sono utili solo quando si comprimono file di +dimensioni superiori a 8\ MiB, 16\ MiB e 32\ MiB, rispettivamente. +.RE +.IP "" +A parità di hardware, la velocità di decompressione è approssimativamente un +numero costante di byte di dati compressi al secondo. In altre parole, +migliore è la compressione, più veloce sarà di solito la decompressione. Ciò +significa anche che la quantità di output non compresso prodotta al secondo +può variare notevolmente. +.IP "" +La tabella seguente riassume le caratteristiche dei livelli preimpostati: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Livello preimpostato;DictSize;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Descrizioni delle colonne: +.RS +.IP \(bu 3 +DictSize è la dimensione del dizionario LZMA2. È uno spreco di memoria usare +un dizionario più grande della dimensione del file non compresso. Ecco +perché è una buona cosa evitare di usare i livelli preimpostati \fB\-7\fP +\&... \fB\-9\fP quando non c'è reale necessità. Con \fB\-6\fP e inferiori, la quantità +di memoria sprecata in genere è sufficientemente bassa da essere +trascurabile. +.IP \(bu 3 +CompCPU è una rappresentazione semplificata delle impostazioni di LZMA2 che +influenzano la velocità di compressione. Anche la dimensione del dizionario +influenza la velocità, quindi mentre CompCPU è lo stesso per i livelli \fB\-6\fP +\&... \fB\-9\fP, i livelli più alti tendono ancora ad essere un po' più lenti. Per +avere una compressione ancora più lenta e quindi potenzialmente migliore, +utilizzare \fB\-\-extreme\fP. +.IP \(bu 3 +CompMem contiene i requisiti di memoria del compressore in modalità a +singola thread. Può variare leggermente tra le versioni di \fBxz\fP. +.IP \(bu 3 +DecMem contiene i requisiti di memoria del decompressore. In altre parole, +le impostazioni di compressione determinano i requisiti di memoria del +decompressore. L'utilizzo esatto della memoria del decompressore è +leggermente superiore alla dimensione del dizionario LZMA2, ma i valori +nella tabella sono stati arrotondati per eccesso al successivo MiB completo. +.RE +.IP "" +I requisiti di memoria per la modalità a thread multiple sono +significativamente più alti che per la modalità thread singola. Con il +valore predefinito di \fB\-\-block\-size\fP, ogni thread richiede 3*3*dimensione +del dizionario più CompMem oppure DecMem. Ad esempio, 4 thread con il +livello preimpostato \fB\-6\fP hanno bisogno di 660\(en670\ MiB di memoria. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Utilizzare una variante più lenta del livello preimpostato selezionato +(\fB\-0\fP ... \fB\-9\fP) nella speranza di ottenere un rapporto di compressione +leggermente migliore, ma con un po' di sfortuna questo potrebbe anche +renderlo peggiore. L'utilizzo della memoria del decompressore non è +influenzato, ma l'utilizzo della memoria del compressore aumenta leggermente +ai livelli preimpostati \fB\-0\fP ... \fB\-3\fP. +.IP "" +Dal momento che ci sono due livelli preimpostati con dimensione del +dizionario di 4\ MiB e 8\ MiB, i livelli preimpostati \fB\-3e\fP e \fB\-5e\fP usano +impostazioni leggermente più veloci (minore CompCPU) di \fB\-4e\fP e \fB\-6e\fP, +rispettivamente. In questo modo non ci sono due livelli preimpostati +identici. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Livello preimpostato;DictSize;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Ad esempio, ci sono un totale di quattro livelli preimpostati che utilizzano +un dizionario da 8\ MiB, il cui ordine dal più veloce al più lento è \fB\-5\fP, +\fB\-6\fP, \fB\-5e\fP, e \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Questi sono alias in qualche modo fuorvianti per \fB\-0\fP e \fB\-9\fP, +rispettivamente. Sono forniti solo per retrocompatibilità con le LZMA +Utils. Evitare di utilizzare queste opzioni. +.TP +\fB\-\-block\-size=\fP\fIDIMENSIONE\fP +Quando si comprime in formato \fB.xz\fP, divide i dati input in blocchi da +\fIDIMENSIONE\fP byte. I blocchi vengo compressi indipendentemente l'uno +dall'altro, cosa che aiuta con le thread multiple e rende possibile la +decompressione con accessi casuali limitati. Questa opzione viene usata +tipicamente per sovrascrivere la dimensione predefinita dei blocchi in +modalità a thread multiple, ma può essere utilizzata anche in modalità +thread singola. +.IP "" +In modalità a thread multiple verranno allocati circa il triplo di +\fIDIMENSIONE\fP di byte in ogni thread per il buffering dell'input e +dell'output. La \fIDIMENSIONE\fP predefinita è tre volte la dimensione del +dizionario LZMA2 e comunque almeno 1 MiB. Tipicamente un buon valore è +2\(en4 volte la dimensione del dizionario LZMA2 oppure almeno 1 MiB. Usare +una \fIDIMENSIONE\fP inferiore della dimensione del dizionario LZMA2 causa uno +spreco di RAM, in quanto il buffer del dizionario LZMA2 non verrà mai +riempito completamente. In modalità a thread multiple, la dimensione dei +blocchi è conservata nelle intestazioni dei blocchi. L'informazione sulla +dimensione è richiesta per la decompressione a thread multiple. +.IP "" +Nella modalità a thread singola, per impostazione predefinita non viene +eseguita alcuna suddivisione in blocchi. L'impostazione di questa opzione +non influisce sull'utilizzo della memoria. Nessuna informazione sulle +dimensioni viene memorizzata nelle intestazioni di blocco, quindi i file +creati in modalità a thread singola non saranno identici ai file creati in +modalità a thread multiple. La mancanza di informazioni sulle dimensioni +significa anche che \fBxz\fP non sarà in grado di decomprimere i file in +modalità a thread multiple. +.TP +\fB\-\-block\-list=\fP\fIELEMENTI\fP +Quando si comprime nel formato \fB.xz\fP, inizia un nuovo blocco con una catena +di filtri personalizzata dopo gli intervalli indicati di dati non compressi. +.IP "" +Gli \fIELEMENTI\fP sono un elenco separato da virgole. Ogni elemento è +costituito da un numero di catena di filtri opzionale compreso tra 0 e 9 +seguito da due punti (\fB:\fP) e da una dimensione richiesta di dati non +compressi. L'omissione di un elemento (due o più virgole consecutive) è una +scorciatoia per utilizzare le dimensioni e i filtri dell'elemento +precedente. +.IP "" +Se il file di input è più grande della somma delle dimensioni in +\fIELEMENTI\fP, l'ultimo elemento viene ripetuto fino alla fine del file. Il +valore speciale \fB0\fP può essere utilizzato come ultima dimensione per +indicare che il resto del file deve essere codificato come un singolo +blocco. +.IP "" +È possibile specificare una catena di filtri alternativa per ogni blocco in +combinazione con le opzioni \fB\-\-filters1=\fP\fIFILTRI\fP \&...\& +\fB\-\-filters9=\fP\fIFILTRI\fP. Queste opzioni definiscono catene di filtri con un +identificatore compreso tra 1\(en9. La catena di filtri 0 può essere +utilizzata per indicare la catena di filtri predefinita, che equivale a non +specificare una catena di filtri. L'identificatore della catena di filtri +può essere utilizzato prima della dimensione non compressa, seguita da due +punti (\fB:\fP). Ad esempio, se si specifica +\fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP allora i blocchi verranno +creati utilizzando: +.RS +.IP \(bu 3 +La catena dei filtri specificata da \fB\-\-filters1\fP e un input di 2 MiB +.IP \(bu 3 +La catena dei filtri specificata da \fB\-\-filters3\fP e un input di 2 MiB +.IP \(bu 3 +La catena dei filtri specificata da \fB\-\-filters2\fP e un input di 4 MiB +.IP \(bu 3 +La catena dei filtri specificata da \fB\-\-filters2\fP e un input di 4 MiB +.IP \(bu 3 +La catena di filtri predefinita e l'input di 2 MiB +.IP \(bu 3 +La catena di filtri predefinita e l'input di 4 MiB per ogni blocco fino alla +fine dell'input. +.RE +.IP "" +Se si specifica una dimensione che supera la dimensione del blocco del +codificatore (il valore predefinito in modalità thread oppure il valore +specificato con \fB\-\-block\-size=\fP\fIDIMENSIONE\fP), il codificatore creerà +blocchi aggiuntivi mantenendo i limiti specificati in \fIELEMENTI\fP. Ad +esempio, se si indica \fB\-\-block\-size=10MiB\fP +\fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP e il file input è di 80 MiB, si +otterranno 11 blocchi: 5, 10, 8, 10, 2, 10, 10, 4, 10, 10, and 1 MiB. +.IP "" +In modalità a thread multiple, le dimensioni dei blocchi vengono memorizzate +nelle intestazioni dei blocchi. Questo non avviene in modalità thread +singola, quindi l'output codificato non sarà identico a quello della +modalità a thread multiple. +.TP +\fB\-\-flush\-timeout=\fP\fITIMEOUT\fP +Quando si comprime, se sono passati più di \fITIMEOUT\fP millisecondi (un +intero positivo) dallo scaricamento precedente e la lettura di ulteriori +input si bloccherebbe, tutti i dati di input in sospeso vengono scaricati +dal codificatore e resi disponibili nel flusso di output. Questo può essere +utile se \fBxz\fP viene usato per comprimere dati in streaming dalla +rete. Piccoli valori del \fITIMEOUT\fP rendono disponibili i dati al ricevente +con un ritardo minimo, mentre valori di \fITIMEOUT\fP grandi danno un miglior +rapporto di compressione. +.IP "" +Questa funzionalità è disabilitata per impostazione predefinita. Se questa +opzione viene specificata più di una volta, l'ultima ha effetto. Il valore +speciale \fITIMEOUT\fP di \fB0\fP può essere utilizzato per disabilitare +esplicitamente questa funzionalità. +.IP "" +Questa funzionalità non è disponibile sui sistemi non\-POSIX. +.IP "" +.\" FIXME +\fBQuesta funzionalità è sperimentale.\fP Attualmente \fBxz\fP non è adatto per +decomprimere il flusso in tempo reale, a causa di come effettua il +buffering. +.TP +\fB\-\-no\-sync\fP +Non sincronizzare il file target e la sua directory sull'unità di +archiviazione prima di rimuovere il file sorgente. Questo può migliorare le +performance se si sta comprimendo o decomprimendo tanti piccoli +file. Tuttavia, se il sistema dovesse andare in crash subito dopo +l'eliminazione, è possibile che il file destinazione non sia ancora stato +scritto sull'unità di archiviazione mentre l'operazione di eliminazione +sì. In questo caso non saranno più disponibili né il file sorgente originale +né il file di destinazione. +.IP "" +Questa opzione ha effetto solamente quando \fBxz\fP deve rimuovere il file +sorgente. Negli altri casi la sincronizzazione non viene eseguita. +.IP "" +La sincronizzazione e \fB\-\-no\-sync\fP sono stati aggiunti nella versione \fBxz\fP +5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fILIMITE\fP +Imposta un limite di utilizzo della memoria per la compressione. Se questa +opzione viene specificata più volte, ha effetto l'ultima. +.IP "" +Se le impostazioni di compressione superano il valore \fILIMITE\fP, \fBxz\fP +tenterà di regolare le impostazioni verso il basso in modo che il limite non +venga più superato e visualizzerà un avviso che indica che è stata eseguita +una regolazione automatica. Le regolazioni vengono eseguite in questo +ordine: riduzione del numero di thread, passaggio alla modalità a thread +singola se anche un solo thread in modalità a thread multiple supera il +\fILIMITE\fP, e infine riducendo la dimensione del dizionario LZMA2. +.IP "" +Quando si comprime con \fB\-\-format=raw\fP oppure se si è specificato +\fB\-\-no\-adjust\fP, è possibile ridurre solo il numero di thread, poiché questo +può essere fatto senza influire sull'output compresso. +.IP "" +Se non è possibile soddisfare il \fILIMITE\fP anche con le regolazioni sopra +descritte, viene visualizzato un errore e \fBxz\fP uscirà con lo stato di +uscita 1. +.IP "" +Il \fILIMITE\fP può essere specificato in diversi modi: +.RS +.IP \(bu 3 +Il \fILIMITE\fP può essere un valore assoluto in byte. Usare un suffisso intero +come \fBMiB\fP può essere utile. Ad esempio: \fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +Il \fILIMITE\fP può essere specificato come percentuale della memoria fisica +(RAM) totale. Questo può essere utile specialmente quando si imposta la +variabile di ambiente \fBXZ_DEFAULTS\fP in uno script di inizializzazione di +shell che è condiviso tra computer diversi. In questo modo il limite è +automaticamente più grande sui sistemi con più memoria. Ad esempio: +\fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +Il \fILIMITE\fP può essere reimpostato al suo valore predefinito impostandolo a +\fB0\fP.Questo attualmente equivale a impostare il \fILIMITE\fP a \fBmax\fP (nessun +limite nell'utilizzo di memoria). +.RE +.IP "" +Per \fBxz\fP a 32\-bit esiste un caso particolare: se il \fILIMITE\fP fosse oltre +\fB4020\ MiB\fP, il \fILIMITE\fP viene impostato a \fB4020\ MiB\fP. Su MIPS32 invece +viene usato \fB2000\ MiB\fP. (I valori \fB0\fP e \fBmax\fP non sono influenzati da +questo. Un comportamento simile non esiste per la decompressione). Questo +può essere utile quando un eseguibile a 32 bit ha accesso a uno spazio di +indirizzi da 4\ GiB (2 GiB su MIPS32), e si spera che non faccia danni in +altre situazioni. +.IP "" +Vedere anche la sezione \fBUtilizzo memoria\fP +.TP +\fB\-\-memlimit\-decompress=\fP\fILIMITE\fP +Imposta un limite di utilizzo della memoria per la decompressione. Questo +influisce anche sulla modalità \fB\-\-list\fP. Se l'operazione non è possibile +senza oltrepassare il \fILIMITE\fP, \fBxz\fP mostrerà un errore e la +decompressione del file fallirà. Si veda \fB\-\-memlimit\-compress=\fP\fILIMITE\fP +per possibili modi per specificare il \fILIMITE\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fILIMITE\fP +Imposta un limite di utilizzo della memoria per la decompressione +multi\-thread. Questo può influire solo sul numero di thread; non indurrà mai +\fBxz\fP a rifiutarsi di decomprimere un file. Se \fILIMITE\fP è troppo basso per +consentire le thread multiple, il \fILIMITE\fP viene ignorato e \fBxz\fP +continuerà in modalità a thread singola. Si noti che se viene utilizzato +anche \fB\-\-memlimit\-decompress\fP, si applicherà sempre sia alla modalità a +thread singola che a quella a thread multiple, e quindi il \fILIMITE\fP +effettivo per le thread multiple non sarà mai superiore a quello impostato +con \fB\-\-memlimit\-decompress\fP. +.IP "" +In contrasto con le altre opzioni di limite di utilizzo della memoria, +\fB\-\-memlimit\-mt\-decompress=\fP\fILIMITE\fP ha un \fILIMITE\fP predefinito specifico +per il sistema. \fBxz \-\-info\-memory\fP può essere utilizzato per vedere il +valore corrente. +.IP "" +Questa opzione e il suo valore predefinito esistono perché, senza un limite, +il decompressore a thread multiple potrebbe finire per allocare una quantità +folle di memoria per alcuni file input. Se il valore predefinito \fILIMITE\fP è +troppo basso sul proprio sistema, è possibile aumentarlo liberamente, ma non +deve essere mai impostato a un valore più grande della quantità di RAM +utilizzabile, in quanto con file di input appropriati \fBxz\fP cercherà di +utilizzare quella quantità di memoria anche con un basso numero di +thread. Esaurire la memoria o fare swap non migliorerà le performance della +decompressione. +.IP "" +Vedi \fB\-\-memlimit\-compress=\fP\fILIMITE\fP per possibili modi per specificare il +\fILIMITE\fP. Impostando \fILIMITE\fP su \fB0\fP si ripristina il valore predefinito +\fILIMITE\fP specifico del sistema. +.TP +\fB\-M\fP \fILIMITE\fP, \fB\-\-memlimit=\fP\fILIMITE\fP, \fB\-\-memory=\fP\fILIMITE\fP +Questo equivale a specificare \fB\-\-memlimit\-compress=\fP\fILIMITE\fP +\fB\-\-memlimit\-decompress=\fP\fILIMITE\fP \fB\-\-memlimit\-mt\-decompress=\fP\fILIMITE\fP. +.TP +\fB\-\-no\-adjust\fP +Visualizza un errore e esce se non è possibile soddisfare il limite di +utilizzo della memoria senza regolare le impostazioni che influiscono +sull'output compresso. In altre parole, ciò impedisce a \fBxz\fP di passare il +codificatore dalla modalità multi\-thread alla modalità a thread singola e di +ridurre le dimensioni del dizionario LZMA2. Anche quando viene usata questa +opzione, il numero di thread può essere ridotto per soddisfare il limite di +utilizzo della memoria, in quanto ciò non influirà sull'output compresso. +.IP "" +La regolazione automatica è sempre disabilitata quando si creano flussi raw +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fITHREADS\fP, \fB\-\-threads=\fP\fITHREADS\fP +Specifica il numero di thread di lavoro da utilizzare. L'impostazione di +\fITHREADS\fP al valore speciale \fB0\fP fa sì che \fBxz\fP utilizzi fino a un numero +di thread che il processore/i del sistema supportano. Il numero effettivo di +thread può essere inferiore a \fITHREADS\fP se il file di input non è +sufficientemente grande per il threading con le impostazioni specificate o +se l'utilizzo di più thread supera il limite di utilizzo della memoria. +.IP "" +I compressori a thread singola e a thread multiple producono output +diversi. Il compressore a thread singola produrrà la dimensione del file più +piccola, ma solo l'output del compressore a thread multiple può essere +decompresso utilizzando più thread. Impostando \fITHREADS\fP su \fB1\fP verrà +utilizzata la modalità a thread singola. L'impostazione di \fITHREADS\fP su +qualsiasi altro valore, incluso \fB0\fP, utilizzerà il compressore a thread +multiple anche se il sistema supporta un solo thread hardware. (\fBxz\fP 5.2.x +utilizzava la modalità a thread singola in questa situazione.) +.IP "" +Per utilizzare la modalità a thread multiple con un solo thread, impostare +\fITHREADS\fP su \fB+1\fP. Il prefisso \fB+\fP non ha alcun effetto con valori +diversi da \fB1\fP. Un limite di utilizzo della memoria può comunque far +passare \fBxz\fP alla modalità a thread singola a meno che non venga utilizzato +\fB\-\-no\-adjust\fP. Il supporto per il prefisso \fB+\fP è stato aggiunto in \fBxz\fP +5.4.0. +.IP "" +Se è stato richiesto un numero automatico di thread e non è stato +specificato alcun limite di utilizzo della memoria, verrà utilizzato un +limite "soft" predefinito, specifico del sistema, per limitare eventualmente +il numero di thread. È un limite "soft" nel senso che viene ignorato se il +numero di thread diventa uno, quindi un limite soft non impedirà mai a \fBxz\fP +di comprimere o decomprimere. Questo limite soft predefinito non farà +passare \fBxz\fP dalla modalità a thread multiple alla modalità thread +singola. I limiti attivi possono essere visualizzati con \fBxz \-\-info\-memory\fP. +.IP "" +Attualmente l'unico metodo di threading consiste nel dividere l'input in +blocchi e comprimerli indipendentemente l'uno dall'altro. La dimensione +predefinita del blocco dipende dal livello di compressione e può essere +sovrascritta con l'opzione \fB\-\-block\-size=\fP\fIDIMENSIONE\fP. +.IP "" +La decompressione a thread multiple funziona solo su file che contengano più +blocchi con l'informazione della dimensione nelle intestazioni del +blocco. Tutti i file sufficientemente grandi compressi in modalità a thread +multiple soddisfano questa condizione, mentre i file compressi in modalità +thread singola no, neanche se si è utilizzato \fB\-\-block\-size=\fP +\fIDIMENSIONE\fP. +.IP "" +Il valore predefinito per \fITHREADS\fP è \fB0\fP. In \fBxz\fP 5.4.x e precedenti il +valore predefinito era \fB1\fP. +. +.SS "Catene di filtri di compressione personalizzate" +Una catena di filtri personalizzata consente di specificare in dettaglio le +impostazioni di compressione invece di fare affidamento sulle impostazioni +associate ai livelli preimpostati. Quando viene specificata una catena di +filtri personalizzata, le opzioni relative ai livelli preimpostati (\fB\-0\fP +\&...\& \fB\-9\fP e \fB\-\-extreme\fP) specificate in precedenza sulla riga di +comando vengono dimenticate. Se un'opzione livello preimpostato viene +specificata dopo una o più opzioni della catena di filtri personalizzata, il +nuovo livello preimpostato ha effetto e le opzioni della catena di filtri +personalizzate specificate in precedenza vengono dimenticate. +.PP +Una catena di filtri è paragonabile a una pipe sulla riga di +comando. Durante la compressione, l'input non compresso va al primo filtro, +il cui output va al filtro successivo (se presente). L'output dell'ultimo +filtro viene scritto nel file compresso. Il numero massimo di filtri nella +catena è quattro, ma in genere una catena di filtri ha solo uno o due +filtri. +.PP +Molti filtri hanno limitazioni su dove possono trovarsi nella catena di +filtri: alcuni filtri possono funzionare solo come ultimo filtro della +catena, altri solo come filtro non ultimo e alcuni funzionano in qualsiasi +posizione nella catena. A seconda del filtro, questa limitazione è inerente +alla struttura del filtro oppure esiste per evitare problemi di sicurezza. +.PP +Una catena di filtri personalizzata può essere specificata in due modi +diversi. Le opzioni \fB\-\-filters=\fP\fIFILTRI\fP and \fB\-\-filters1=\fP\fIFILTRI\fP +\&...\& \fB\-\-filters9=\fP\fIFILTRI\fP permettono di specificare un'intera catena +di filtri in una opzione utilizzando la sintassi della stringa del filtro di +lzma. In alternativa, una catena di filtri può essere specificata +utilizzando una o più singole opzioni di filtro nell'ordine desiderato nella +catena di filtri. Questo significa che l'ordine delle singole opzioni di +filtro è importante! Quando si decodificano i flussi grezzi +(\fB\-\-format=raw\fP), la catena di filtri deve essere specificata nello stesso +ordine in cui è stata specificata durante la compressione. Qualsiasi filtro +individuale o opzione livello preimpostato specificata prima dell'opzione +della catena completa (\fB\-\-filters=\fP\fIFILTRI\fP) verrà dimenticata. I singoli +filtri specificati dopo l'opzione della catena completa reimposteranno la +catena di filtri. +.PP +Sia l'opzione di filtro completo che quella individuale accettano \fIOPZIONI\fP +specifiche del filtro come un elenco separato da virgole. Virgole in eccesso +nelle \fIOPZIONI\fP vengono ignorate. Ogni opzione ha un valore di default, +quindi occorre specificare solamente quelle che si desidera modificare. +.PP +Per vedere l'intera catena di filtri e \fIOPZIONI\fP, usa \fBxz \-vv\fP (ossia, usa +\fB\-\-verbose\fP due volte). Questo funziona anche per visualizzare le opzioni +della catena di filtri utilizzate dai livelli preimpostati. +.TP +\fB\-\-filters=\fP\fIFILTRI\fP +Specifica l'intera catena dei filtri oppure un livello preimpostato in una +singola opzione. Ogni filtro può essere separato da spazi o da due trattini +(\fB\-\-\fP). Potrebbe essere necessario mettere tra virgolette i \fIFILTRI\fP sulla +riga di comando della shell in modo che vengano analizzati come una singola +opzione. Per indicare \fIOPZIONI\fP, usa \fB:\fP o \fB=\fP. Un livello preimpostato +può essere preceduto da un \fB\-\fP e seguito da zero o più flag. L'unico flag +supportato è \fBe\fP per applicare le stesse opzioni di \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIFILTRI\fP ... \fB\-\-filters9\fP=\fIFILTRI\fP +Specifica fino a nove catene di filtri aggiuntive che possono essere +utilizzate con \fB\-\-block\-list\fP. +.IP "" +Ad esempio, quando si comprime un archivio con file eseguibili seguiti da +file di testo, la parte eseguibile potrebbe utilizzare una catena di filtri +con un filtro BCJ e la parte di testo solo il filtro LZMA2. +.TP +\fB\-\-filters\-help\fP +Mostra un messaggio di aiuto che descrive come specificare livelli +preimpostati e catene di filtri personalizzati nelle opzioni \fB\-\-filters\fP e +\fB\-\-filters1=\fP\fIFILTRI\fP \&...\& \fB\-\-filters9=\fP\fIFILTRI\fP, e termina con +successo. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIOPZIONI\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIOPZIONI\fP] +.PD +Aggiunge un filtro LZMA1 o LZMA2 alla catena dei filtri. Questi filtri +possono essere usati solo come ultimo filtro della catena. +.IP "" +LZMA1 è un filtro obsoleto, supportato quasi esclusivamente a causa del +formato obsoleto di file \fB.lzma\fP, che supporta solo LZMA1. LZMA2 è una +versione aggiornata di LZMA1 che risolve alcuni problemi pratici di +LZMA1. Il formato \fB.xz\fP utilizza LZMA2 e non supporta LZMA1. La velocità e +i rapporti di compressione di LZMA1 e LZMA2 sono praticamente gli stessi. +.IP "" +LZMA1 e LZMA2 condividono lo stesso insieme di \fIOPZIONI\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIPRESET\fP +Reimposta tutte le \fIOPZIONI\fP LZMA1 o LZMA2 a \fIPRESET\fP. Il \fIPRESET\fP +(livello preimpostato) consiste di un numero intero, che può essere seguito +da modificatori costituiti da una singola lettera. Il numero intero può +andare da \fB0\fP a \fB9\fP, corrispondenti alle opzioni della riga di comando +\fB\-0\fP \&...\& \fB\-9\fP. L'unico modificatore attualmente supportato è \fBe\fP, che +corrisponde a \fB\-\-extreme\fP. Se non viene specificato alcun \fIPRESET\fP, i +valori predefiniti delle \fIOPZIONI\fP LZMA1 o LZMA2 sono presi dal livello +preimpostato \fB6\fP. +.TP +\fBdict=\fP\fIDIMENSIONE\fP +La \fIDIMENSIONE\fPdel dizionario (buffer di cronologia) indica quanti byte dei +dati non compressi elaborati di recente vengono mantenuti in +memoria. L'algoritmo tenta di trovare sequenze di byte ripetute +(corrispondenze) nei dati non compressi e di sostituirle con riferimenti ai +dati attualmente presenti nel dizionario. Più grande è il dizionario, +maggiore è la possibilità di trovare una corrispondenza. Quindi, l'aumento +della \fIDIMENSIONE\fP del dizionario di solito migliora il rapporto di +compressione, ma un dizionario più grande del file non compresso è uno +spreco di memoria. +.IP "" +Una \fIDIMENSIONE\fP tipica per un dizionario è da 64\ KiB a 64\ MiB. Il minimo +è 4\ KiB. Il massimo per la compressione è attualmente 1.5\ GiB (1536\ MiB). La decompressione supporta già dizionari fino a 4\ GiB meno 1 byte, +che è il massimo per i formati di flusso LZMA1 e LZMA2. +.IP "" +La \fIDIMENSIONE\fP del dizionario e il cercatore di corrispondenze +(\fICERCATORE\fP) insieme determinano l'utilizzo della memoria del codificatore +LZMA1 o LZMA2. Per la decompressione è necessaria la stessa \fIDIMENSIONE\fP +del dizionario utilizzata durante la compressione (o più grande), quindi +l'utilizzo della memoria del decodificatore è determinato dalla dimensione +del dizionario utilizzato durante la compressione. Le intestazioni \fB.xz\fP +memorizzano la \fIDIMENSIONE\fP del dizionario come 2^\fIn\fP o 2^\fIn\fP + 2^( +\fIn\fP\-1), quindi queste \fIDIMENSIONI\fP sono in qualche modo preferite per la +compressione. Altre \fIDIMENSIONI\fP verranno arrotondate per eccesso quando +memorizzate nelle intestazioni \fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Specificare il numero di bit di contesto letterali. Il minimo è 0 e il +massimo è 4; Il valore predefinito è 3. Inoltre, la somma di \fIlc\fP e \fIlp\fP +non deve superare 4. +.IP "" +Tutti i byte che non possono essere codificati come corrispondenze vengono +codificati come valori letterali. In altre parole, i valori letterali sono +semplicemente byte a 8 bit codificati uno alla volta. +.IP "" +La codifica letterale presuppone che i bit di \fIlc\fP più alti del byte non +compresso precedente siano correlati al byte successivo. Ad esempio, in un +tipico testo inglese, una lettera maiuscola è spesso seguita da una lettera +minuscola e una lettera minuscola è solitamente seguita da un'altra lettera +minuscola. Nel set di caratteri US\-ASCII, i tre bit più alti sono 010 per le +lettere maiuscole e 011 per le lettere minuscole. Quando \fIlc\fP è almeno 3, +la codifica letterale può sfruttare questa proprietà nei dati non compressi. +.IP "" +Il valore predefinito (3) solitamente è buono. Se si desidera la +compressione massima, provare con \fBlc=4\fP. A volte aiuta un po', e a volte +rende la compressione peggiore. Se la rende peggiore, provare anche \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Specificare il numero di bit di posizione letterale. Il minimo è 0 e il +massimo è 4; Il valore predefinito è 0. +.IP "" +Il parametro \fIlp\fP influisce sul tipo di allineamento nei dati non compressi +presunto durante la codifica dei valori letterali. Vedi \fIpb\fP di seguito per +ulteriori informazioni sull'allineamento. +.TP +\fBpb=\fP\fIpb\fP +Specificare il numero di bit di posizione. Il minimo è 0 e il massimo è 4; +Il valore predefinito è 2. +.IP "" +Il parametro \fIpb\fP influisce su quale tipo di allineamento nei dati non +compressi sia assunto in generale. L'impostazione predefinita indica un +allineamento a quattro byte (2^\fIpb\fP =2^2=4), che è spesso una buona scelta +se non c'è un'ipotesi migliore. +.IP "" +Quando l'allineamento è noto, impostare \fIpb\fP concordemente può ridurre un +po' le dimensioni del file. Ad esempio, con file di testo con 1 byte di +allineamento (US\-ASCII, ISO\-8859\-*, UTF\-8), impostare \fBpb=0\fP può migliorare +leggermente la compressione. Per il testo UTF\-16, \fBpb=1\fP è una buona +scelta. Se l'allineamento è un numero dispari, come 3 byte, \fBpb=0\fP potrebbe +essere la scelta migliore. +.IP "" +Anche se l'allineamento assunto può essere regolato con \fIpb\fP e \fIlp\fP, LZMA1 +e LZMA2 favoriscono ancora leggermente l'allineamento a 16 byte. Potrebbe +valere la pena tenerlo in considerazione quando si progettano formati di +file che possono essere spesso compressi con LZMA1 o LZMA2. +.TP +\fBmf=\fP\fICERCATORE\fP +Il cercatore di corrispondenze ha un effetto importante sulla velocità del +codificatore, sull'utilizzo della memoria e sul rapporto di compressione. Di +solito i cercatori di corrispondenze a catena hash sono più veloci dei +cercatori di corrispondenze ad albero binario. Il valore predefinito dipende +da \fIPRESET\fP : 0 usa \fBhc3\fP, 1\(en3 usa \fBhc4\fP e il resto usa \fBbt4\fP. +.IP "" +Sono supportati i seguenti cercatori di corrispondenze. Le formule di +utilizzo della memoria riportate di seguito sono approssimazioni, che sono +le più vicine alla realtà quando \fIDIZIONARIO\fP è una potenza di due. +.RS +.TP +\fBhc3\fP +Catena hash con hashing da 2 e 3 byte +.br +Minimo valore per \fINICE\fP: 3 +.br +Utilizzo memoria: +.br +\fIDIZIONARIO\fP * 7.5 (se \fIDIZIONARIO\fP <= 16 MiB); +.br +\fIDIZIONARIO\fP * 5.5 + 64 MiB (se \fIDIZIONARIO\fP > 16 MiB) +.TP +\fBhc4\fP +Catena hash con hash da 2, 3 e 4 byte +.br +Minimo valore per \fINICE\fP: 4 +.br +Utilizzo memoria: +.br +\fIDIZIONARIO\fP * 7.5 (se \fIDIZIONARIO\fP <= 32 MiB); +.br +\fIDIZIONARIO\fP * 6.5 (se \fIDIZIONARIO\fP > 32 MiB) +.TP +\fBbt2\fP +Albero binario con hashing da 2 byte +.br +Valore minimo per \fINICE\fP: 2 +.br +Utilizzo di memoria: \fIDIZIONARIO\fP * 9.5 +.TP +\fBbt3\fP +Albero binario con hashing da 2 e 3 byte +.br +Minimo valore per \fINICE\fP: 3 +.br +Utilizzo memoria: +.br +\fIDIZIONARIO\fP * 11.5 (se \fIDIZIONARIO\fP <= 16 MiB); +.br +\fIDIZIONARIO\fP * 9.5 + 64 MiB (se \fIDIZIONARIO\fP > 16 MiB) +.TP +\fBbt4\fP +Albero binario con hashing da 2, 3 e 4 byte +.br +Minimo valore per \fINICE\fP: 4 +.br +Utilizzo memoria: +.br +\fIDIZIONARIO\fP * 11.5 (se \fIDIZIONARIO\fP <= 32 MiB); +.br +\fIDIZIONARIO\fP * 10.5 (se \fIDIZIONARIO\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fIMODALITÀ\fP +La \fIMODALITÀ\fP di compressione specifica il metodo per analizzare i dati +prodotti dal cercatore di corrispondenze. Le \fIMODALITÀ\fP supportate sono +\fBfast\fP e \fBnormal\fP. Il predefinito è \fBfast\fP per i \fIPRESET\fP 0\(en3 e +\fBnormal\fP per i \fIPRESET\fP 4\(en9. +.IP "" +Di solito \fBfast\fP viene utilizzato con i cercatori di corrispondenze a +catena hash e \fBnormal\fP con i cercatori di corrispondenze a albero +binario. Questo è anche quello che fanno i \fIPRESET\fP. +.TP +\fBnice=\fP\fINICE\fP +Specifica quella che si considera una lunghezza accettabile ("nice") per una +corrispondenza. Una volta trovata una corrispondenza di almeno \fINICE\fP byte, +l'algoritmo smette di cercare corrispondenze potenzialmente migliori. +.IP "" +\fINICE\fP può valere 2\(en273 byte. Valori più alti tendono a dare un miglior +rapporto di compressione ai danni della velocità. Il valore predefinito +dipende dal \fIPRESET\fP. +.TP +\fBdepth=\fP\fIPROFONDITÀ\fP +Specificare la profondità di ricerca massima nel cercatore di +corrispondenze. Il valore predefinito è il valore speciale 0, che dice al +compressore di determinare una \fIPROFONDITÀ\fP ragionevole da \fICERCATORE\fP e +\fINICE\fP. +.IP "" +Una \fIPROFONDITÀ\fP ragionevole per le catene hash è 4\(en100 e 16\(en1000 per +gli alberi binari. Utilizzando valori di \fIPROFONDITÀ\fP molto alti si può +rendere il codificatore estremamente lento con alcuni file. Evitare di +impostare la \fIPROFONDITÀ\fP oltre 1000 a meno che si sia preparati a +interrompere la compressione nel caso in cui richieda troppo tempo. +.RE +.IP "" +Quando si decomprime un flusso grezzo (\fB\-\-format=raw\fP), LZMA2 ha bisogno +solamente della \fIDIMENSIONE\fP del dizionario. LZMA1 ha anche bisogno di +\fIlc\fP, \fIlp\fP, e \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIOPZIONI\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIOPZIONI\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIOPZIONI\fP] +.PD +Aggiunge un filtro branch/call/jump (BCJ) alla catena dei filtri. Questi +filtri non possono essere utilizzati come ultimo filtro nella catena di +filtri. +.IP "" +Un filtro BCJ converte gli indirizzi relativi in codice macchina nelle loro +controparti assolute. Questo non cambia la dimensione dei dati ma aumenta la +ridondanza, cosa che può aiutare LZMA2 a produrre \fB.xz\fP file 0\(en15\ % più +piccoli. I filtri BCJ sono sempre reversibili, quindi usare un filtro BCJ +per il tipo di dati sbagliato non causa perdita di dati, al massimo può +determinare un rapporto di compressione leggermente peggiore. I filtri BCJ +sono molto veloci e usano una quantità di memoria minima. +.IP "" +Questi filtri BCJ presentano problemi noti relativi al rapporto di +compressione: +.RS +.IP \(bu 3 +Alcuni tipi di file contenenti codice eseguibile (ad esempio, file oggetto, +librerie statiche e moduli del kernel Linux) hanno gli indirizzi nelle +istruzioni riempiti con valori di riempimento. Questi filtri BCJ eseguiranno +comunque la conversione degli indirizzi, il che peggiorerà la compressione +con questi file. +.IP \(bu 3 +Se un filtro BCJ viene applicato a un archivio, è possibile che renda il +rapporto di compressione peggiore rispetto a non usare un filtro BCJ. Ad +esempio, se ci sono eseguibili simili o addirittura identici, il filtraggio +probabilmente renderà i file meno simili e quindi la compressione sarà +peggiore. Anche il contenuto dei file non eseguibili nello stesso archivio +può essere importante. In pratica bisogna provare con e senza filtro BCJ per +vedere quale sia il migliore in ogni situazione. +.RE +.IP "" +Insiemi diversi di istruzioni hanno diversi allineamenti: il file eseguibile +deve essere allineato a un multiplo di questo valore nei dati di input per +far funzionare il filtro. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filtro;Allineamento;Note +x86;1;32\-bit o 64\-bit x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;L'allineamento migliore è a 4096 byte +PowerPC;4;Solo big\-endian +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Dal momento che i dati filtrati da BCJ solitamente sono compressi con LZMA2, +il rapporto di compressione può essere migliorato leggermente se le opzioni +LZMA2 sono impostate in modo che corrispondano all'allineamento del filtro +BCJ selezionato. Esempi: +.RS +.IP \(bu 3 +Il filtro IA\-64 ha un allineamento a 16 byte, quindi \fBpb=4,lp=4,lc=0\fP è una +buona scelta per LZMA2 (2^4=16). +.IP \(bu 3 +Il codice RISC\-V ha un allineamento a 2 o 4 byte a seconda che il file +contenga o meno istruzioni 16 bit compresse (cosiddetta estensione +C). Quando sono usate istruzioni a 16 bit, va bene \fBpb=2,lp=1,lc=3\fP o +\fBpb=1,lp=1,lc=3\fP. Quando le istruzioni a 16 bit non sono presenti, è meglio +\fBpb=2,lp=2,lc=2\fP. Si può usare \fBreadelf \-h\fP per controllare se "RVC" +appare sulla riga del "Flag". +.IP \(bu 3 +ARM64 è sempre allineato a 4 byte, quindi \fBpb=2,lp=2,lc=2\fP è la scelta +migliore. +.IP \(bu 3 +Il filtro x86 è un'eccezione. Di solito è bene attenersi alle impostazioni +predefinite di LZMA2 (\fBpb=2,lp=0,lc=3\fP) quando si comprimono gli eseguibili +x86. +.RE +.IP "" +Tutti i filtri BCJ supportano le stesse \fIOPZIONI\fP: +.RS +.TP +\fBstart=\fP\fIOFFSET\fP +Specifica l'\fIOFFSET\fP iniziale utilizzato per la conversione tra indirizzi +relativi e assoluti. L'\fIOFFSET\fP deve essere un multiplo dell'allineamento +del filtro (vedere la tabella sopra). Il valore predefinito è zero. In +pratica, l'impostazione predefinita è buona; specificare un \fIOFFSET\fP +personalizzato non è quasi mai utile. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIOPZIONI\fP] +Aggiunge un filtro Delta alla catena dei filtri. I filtri Delta non possono +essere utilizzati come ultimo filtro nella catena di filtri. +.IP "" +Al momento è supportato solo un semplice calcolo delta byte\-per\-byte. Può +essere utile quando si comprime, per esempio, immagini bitmap non compresse +o file audio PCM non compressi. Tuttavia, speciali algoritmi ad\-hoc +potrebbero dare risultati significativamente migliori che Delta + +LZMA2. Questo è vero specialmente per l'audio, che comprime più velocemente +e meglio, ad esempio, con \fBflac\fP(1). +.IP "" +\fIOPZIONI\fP supportate: +.RS +.TP +\fBdist=\fP\fIDISTANZA\fP +Specifica la \fIDISTANZA\fP del calcolo delta in byte. \fIDISTANZA\fP deve essere +nel range 1\(en256. Il valore predefinito è 1. +.IP "" +Per esempio, con \fBdist=2\fP e un input di 8 byte A1 B1 A2 B3 A3 B5 A4 B7, +l'output sarà A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Altre opzioni" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Sopprime avvertimenti e avvisi. Specificarlo due volte per eliminare anche +gli errori. Questa opzione non ha alcun effetto sullo stato di uscita. In +altre parole, anche se un avvertimento è stato eliminato, lo stato di uscita +che indica un avvertimento viene comunque utilizzato. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Sii prolisso. Se lo standard error è collegato a un terminale, \fBxz\fP +visualizzerà un indicatore di avanzamento. Specificando \fB\-\-verbose\fP due +volte si otterrà un output ancora più dettagliato. +.IP "" +L'indicatore di avanzamento mostra le seguenti informazioni: +.RS +.IP \(bu 3 +La percentuale di avanzamento è mostrata se la dimensione del file input è +nota. Quindi, la percentuale non può essere mostrata nei pipe. +.IP \(bu 3 +Quantità di dati compressi prodotti (in compressione) o utilizzati (in +decompressione). +.IP \(bu 3 +Quantità di dati non compressi consumati (in compressione) o prodotti (in +decompressione). +.IP \(bu 3 +Rapporto di compressione, calcolato dividendo la quantità di dati compressi +processati finora con la quantità di dati non compressi processati finora. +.IP \(bu 3 +Velocità di compressione o decompressione. Questa è misurata come la +quantità di dati non compressi consumati (in compressione) o prodotti (in +decompressione) al secondo. Viene mostrata dopo che è trascorso qualche +secondo da quando \fBxz\fP ha iniziato a processare il file. +.IP \(bu 3 +Tempo trascorso nel formato M:SS o H:MM:SS. +.IP \(bu 3 +Il tempo residuo stimato è mostrato solo quando la dimensione del file in +ingresso è nota e sono già passati un paio di secondi da quando \fBxz\fP ha +iniziato a processare il file. Il tempo è mostrato in un formato meno +preciso che non ha mai i due punti, ad esempio 2 min 30 s. +.RE +.IP "" +Quando lo standard error non è un terminale, \fB\-\-verbose\fP farà stampare a +\fBxz\fP il nome del file, la dimensione compressa, la dimensione non +compressa, il rapporto di compressione, e potendo anche la velocità e il +tempo trascorso, su una singola riga dello standard error, dopo aver +compresso o decompresso il file. La velocità e il tempo trascorso sono +inclusi solo se l'operazione è durata almeno un paio di secondi. Se +l'operazione non è conclusa, ad esempio a causa dell'interruzione da parte +dell'utente, viene stampata anche la percentuale di completamento, a patto +che la dimensione del file input sia nota. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Non impostare lo stato di uscita a 2 anche se è stata rilevata una +condizione che merita un avvertimento. Questa opzione non influisce sul +livello di dettaglio, quindi sia \fB\-\-quiet\fP che \fB\-\-no\-warn\fP devono essere +utilizzati per non visualizzare avvertimenti e per non alterare lo stato di +uscita. +.TP +\fB\-\-robot\fP +Stampa i messaggi in un formato analizzabile dal computer. Questo ha lo +scopo di facilitare la scrittura dei frontend che vogliono usare \fBxz\fP +invece di liblzma, che potrebbe essere il caso di vari script. Si intende +che con questa opzione abilitata l'output dovrebbe rimanere stabile tra le +versioni di \fBxz\fP. Per ulteriori informazioni, vedere la sezione \fBMODALITÀ ROBOT\fP. +.TP +\fB\-\-info\-memory\fP +Mostra, in un formato leggibile da umani, quanta memoria fisica (RAM) e +quante thread \fBxz\fP pensa che il sistema abbia e i limiti di utilizzo di +memoria per la compressione e la decompressione, quindi termina con +successo. +.TP +\fB\-h\fP, \fB\-\-help\fP +Mostra un messaggio di aiuto che descrive le opzioni usate più comunemente, +e termina con successo. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Mostra un messaggio di aiuto che descrive tutte le funzionalità di \fBxz\fP, e +termina con successo +.TP +\fB\-V\fP, \fB\-\-version\fP +Mostra il numero di versione di \fBxz\fP e liblzma in un formato leggibile +dagli umani. Per ottenere un output analizzabile da una macchina specificare +\fB\-\-robot\fP prima di \fB\-\-version\fP. +. +.SH "MODALITÀ ROBOT" +La "modalità robot" viene attivata con l'opzione \fB\-\-robot\fP. Rende l'output +di \fBxz\fP più facile da analizzare da altri programmi. Attualmente \fB\-\-robot\fP +è supportato solo insieme a \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP e +\fB\-\-version\fP. In futuro sarà supportato per la compressione e la +decompressione. +. +.SS "Modalità stampa" +\fBxz \-\-robot \-\-list\fP usa un output separato da tabulazione. La prima colonna +di ogni riga contiene una stringa che indica il tipo di informazione +contenuta in quella riga: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Questa è sempre la prima riga quando si inizia a elencare un file. La +seconda colonna della riga è il nome del file. +.TP +\fBfile\fP +Questa riga contiene informazioni generali sul file \fB.xz\fP. Questa riga +viene sempre stampata dopo la riga \fBname\fP. +.TP +\fBstream\fP +Questo tipo di riga viene utilizzato solo quando è stato specificato +\fB\-\-verbose\fP. Sono presenti tante righe \fBstream\fP quanti sono i flussi nel +file \fB.xz\fP. +.TP +\fBblock\fP +Questo tipo di riga viene utilizzato solo quando è stato specificato +\fB\-\-verbose\fP. Ci sono tante righe \fBblock\fP quanti sono i blocchi nel file +\&\fB.xz\fP. Le righe \fBblock\fP vengono visualizzate dopo tutte le righe +\fBstream\fP; i diversi tipi di riga non vengono interlacciati. +.TP +\fBsummary\fP +Questo tipo di riga viene utilizzato solo quando \fB\-\-verbose\fP è stato +specificato due volte. Questa riga viene stampata dopo tutte le righe +\fBblock\fP. Come la riga \fBfile\fP, la riga \fBsummary\fP contiene informazioni +generali sul file \fB.xz\fP. +.TP +\fBtotals\fP +Questa riga è sempre l'ultima riga dell'output dell'elenco. Mostra i +conteggi totali e le dimensioni. +.PP +Le colonne delle righe \fBfile\fP: +.PD 0 +.RS +.IP 2. 4 +Numero di flussi nel file +.IP 3. 4 +Numero totale di blocchi nel flusso/i. +.IP 4. 4 +Dimensione compressa del file +.IP 5. 4 +Dimensione non compressa del file +.IP 6. 4 +Rapporto di compressione, es. \fB0.123\fP. Se il rapporto è oltre 9999, al +posto del rapporto vengono mostrati tre trattini (\fB\-\-\-\fP). +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Elenco separato da virgole dei nomi dei controlli di integrità. Le stringhe +seguenti vengono utilizzate per i tipi di controllo conosciuti: \fBNone\fP, +\fBCRC32\fP, \fBCRC64\fP, e \fBSHA\-256\fP. Per i tipi di controllo non conosciuti +viene utilizzato \fBUnknown\-\fP\fIN\fP, dove \fIN\fP è l'ID del controllo come numero +decimale (una o due cifre). +.IP 8. 4 +Dimensione totale del padding del flusso nel file +.RE +.PD +.PP +Le colonne delle righe \fBstream\fP: +.PD 0 +.RS +.IP 2. 4 +Numero di flusso (il primo è 1) +.IP 3. 4 +Numero di blocchi nel flusso +.IP 4. 4 +Offset iniziale compressione +.IP 5. 4 +Offset iniziale decompressione +.IP 6. 4 +Dimensione compressa (non include il padding del flusso) +.IP 7. 4 +Dimensione non compressa +.IP 8. 4 +Rapporto di compressione +.IP 9. 4 +Nome del controllo di integrità +.IP 10. 4 +Dimensione del padding del flusso +.RE +.PD +.PP +Le colonne delle righe \fBblock\fP: +.PD 0 +.RS +.IP 2. 4 +Numero di flussi che contengono questo blocco +.IP 3. 4 +Numero del blocco relativo all'inizio del flusso (il primo blocco è 1) +.IP 4. 4 +Numero del blocco relativo all'inizio del file +.IP 5. 4 +Offset iniziale compressione relativo all'inizio del file +.IP 6. 4 +Offset iniziale decompressione relativo all'inizio del file +.IP 7. 4 +Dimensione totale compressa del blocco (incluse le intestazioni) +.IP 8. 4 +Dimensione non compressa +.IP 9. 4 +Rapporto di compressione +.IP 10. 4 +Nome del controllo di integrità +.RE +.PD +.PP +Se \fB\-\-verbose\fP viene specificato due volte, sono incluse colonne aggiuntive +nelle righe \fBblock\fP. Queste non sono mostrate con un \fB\-\-verbose\fP singolo, +perché recuperare queste informazioni richiede molte ricerche e quindi può +essere lento: +.PD 0 +.RS +.IP 11. 4 +Valore del controllo di integrità in formato esadecimale +.IP 12. 4 +Dimensione intestazione blocco +.IP 13. 4 +Flag del blocco: \fBc\fPindica che è presente la dimensione compressa, \fBu\fP +indica che è presente la dimensione non compressa. Se il flag non è +impostato, viene mostrato un trattino (\fB\-\fP) per mantenere fissa la +lunghezza della stringa. Nuovi flag potrebbero essere aggiunti alla fine +della stringa in futuro. +.IP 14. 4 +Dimensione dei dati compressi effettivi nel blocco (sono esclusi +l'intestazione del blocco, il padding del blocco e i campi di controllo) +.IP 15. 4 +Quantità di memoria (in byte) necessaria per decomprimere questo blocco con +questa versione \fBxz\fP +.IP 16. 4 +Catena di filtri. Si noti che la maggior parte delle opzioni utilizzate al +momento della compressione non è nota, perché solo le opzioni necessarie per +la decompressione sono memorizzate nelle intestazioni \fB.xz\fP. +.RE +.PD +.PP +Le colonne delle righe \fBsummary\fP: +.PD 0 +.RS +.IP 2. 4 +Quantità di memoria (in byte) necessaria per decomprimere questo file con +questa versione \fBxz\fP +.IP 3. 4 +\fByes\fP o \fBno\fP indica se tutte le intestazioni di blocco contengono +all'interno sia dimensioni compresse che dimensioni non compresse +.PP +\fIA partire da\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Versione minima di \fBxz\fP richiesta per decomprimere il file +.RE +.PD +.PP +Le colonne delle righe \fBtotali\fP: +.PD 0 +.RS +.IP 2. 4 +Numero di flussi +.IP 3. 4 +Numero di blocchi +.IP 4. 4 +Dimensione compressa +.IP 5. 4 +Dimensione non compressa +.IP 6. 4 +Rapporto di compressione medio +.IP 7. 4 +Elenco separato da virgole dei nomi dei controlli di integrità presenti nei +file +.IP 8. 4 +Dimensione del padding dello stream +.IP 9. 4 +Numero di file. Questo serve a mantenere l'ordine delle colonne precedenti +uguale a quello delle righe del \fBfile\fP. +.PD +.RE +.PP +Se \fB\-\-verbose\fP viene specificato due volte, sono incluse colonne aggiuntive +nella riga \fBtotali\fP: +.PD 0 +.RS +.IP 10. 4 +Quantità massima di memoria (in byte) necessaria per decomprimere i file con +questa versione \fBxz\fP +.IP 11. 4 +\fByes\fP o \fBno\fP indica se tutte le intestazioni di blocco contengono +all'interno sia dimensioni compresse che dimensioni non compresse +.PP +\fIA partire da\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Versione minima di \fBxz\fP richiesta per decomprimere il file +.RE +.PD +.PP +Versioni future potrebbero aggiungere nuovi tipi di riga e nuove colonne +possono essere aggiunte ai tipi di riga esistenti, ma le colonne esistenti +non verranno modificate. +. +.SS "Aiuto sui filtri" +\fBxz \-\-robot \-\-filters\-help\fP stampa i filtri supportati nel seguente +formato: +.PP +\fIFILTRO\fP\fB:\fP\fIOPZIONE\fP\fB=<\fP\fIVALORE\fP\fB>,\fP\fIOPZIONE\fP\fB=<\fP\fIVALORE\fP\fB>\fP... +.TP +\fIFILTRO\fP +Nome del filtro +.TP +\fIOPZIONE\fP +Nome di un'opzione specifica del filtro +.TP +\fIVALORE\fP +Gli intervalli del \fIVALORE\fP numerico appaiono come +\fB<\fP\fIMIN\fP\fB\-\fP\fIMAX\fP\fB>\fP. Le scelte per i \fIVALORI\fP stringa sono +mostrati in \fB< >\fP e separati dal carattere \fB|\fP. +.PP +Ogni filtro è mostrato su una riga dedicata. +. +.SS "Informazione limite memoria" +\fBxz \-\-robot \-\-info\-memory\fP stampa una singola riga con più colonne separate +da tabulazione: +.IP 1. 4 +Quantità totale di memoria fisica (RAM) in byte. +.IP 2. 4 +Limite utilizzo memoria per la compressione in byte +(\fB\-\-memlimit\-compress\fP). Il valore speciale \fB0\fP indica l'impostazione +predefinita, che in modalità thread singola equivale a nessun limite. +.IP 3. 4 +Limite utilizzo memoria per la decompressione in byte +(\fB\-\-memlimit\-decompress\fP). Il valore speciale \fB0\fP indica l'impostazione +predefinita, che in modalità thread singola equivale a nessun limite. +.IP 4. 4 +A partire da \fBxz\fP 5.3.4alpha: Utilizzo della memoria per la decompressione +a thread multiple in byte (\fB\-\-memlimit\-mt\-decompress\fP). Questo valore non è +mai zero perché viene utilizzato un valore predefinito specifico del sistema +mostrato nella colonna 5, se non è stato specificato alcun limite in modo +esplicito. Inoltre, non è mai maggiore del valore nella colonna 3, anche se +è stato specificato un valore maggiore con \fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +A partire da \fBxz\fP 5.3.4alpha: un limite di utilizzo della memoria +predefinito specifico del sistema, che viene utilizzato per limitare il +numero di thread durante la compressione con un numero automatico di thread +(\fB\-\-threads=0\fP) e non è stato specificato alcun limite di utilizzo della +memoria (\fB\-\-memlimit\-compress\fP). Questo viene utilizzato anche come valore +predefinito per \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +A partire da \fBxz\fP 5.3.4alpha: Numero di thread del processore disponibili. +.PP +In futuro, l'output di \fBxz \-\-robot \-\-info\-memory\fP potrebbe avere più +colonne, ma mai più di una singola riga. +. +.SS Versione +\fBxz \-\-robot \-\-version\fP stampa il numero di versione di \fBxz\fP e liblzma nel +seguente formato: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Versione major. +.TP +\fIYYY\fP +Versione minor. I numeri pari sono stabili. I numeri dispari sono versioni +alfa o beta. +.TP +\fIZZZ\fP +Livello di patch per le versioni stabili o solo un contatore per le versioni +di sviluppo. +.TP +\fIS\fP +Stabilità. 0 è alfa, 1 è beta e 2 è stabile. \fIS\fP dovrebbe essere sempre 2 +quando \fIYYY\fP è pari. +.PP +\fIXYYYZZZS\fP sono uguali su entrambe le righe se \fBxz\fP e liblzma appartengono +allo stesso rilascio delle XZ Utils. +.PP +Esempi: 4.999.9beta è \fB49990091\fP e 5.0.0 è \fB50000002\fP. +. +.SH "CODICE DI USCITA" +.TP +\fB0\fP +Tutto bene. +.TP +\fB1\fP +È avvenuto un errore. +.TP +\fB2\fP +Si è verificato qualcosa che merita un avvertimento, ma non si sono +verificati errori effettivi. +.PP +Gli avvisi (non gli avvertimenti o gli errori) stampati sullo standard error +non influiscono sullo stato di uscita. +. +.SH AMBIENTE +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP analizza elenchi di opzioni separate da spazi dalle variabili +d'ambiente \fBXZ_DEFAULTS\fP e \fBXZ_OPT\fP, in questo ordine, analizzando prima +le opzioni dalla riga di comando. Si noti che solo le opzioni vengono +analizzate dalle variabili d'ambiente; tutte le non\-opzioni vengono ignorate +silenziosamente. L'analisi viene eseguita con \fBgetopt_long\fP(3) che viene +utilizzato anche per gli argomenti della riga di comando. +.PP +\fBAttenzione:\fP Impostando queste variabili di ambiente, si sta di fatto +modificando programmi e script che lanciano \fBxz\fP. La maggior parte delle +volte va bene impostare i limiti di utilizzo della memoria, il numero di +thread e le opzioni di compressione tramite variabili d'ambiente. Tuttavia, +alcune opzioni possono rompere degli script. Un esempio banale è \fB\-\-help\fP +che forza \fBxz\fP a mostrare la pagina di aiuto anziché comprimere o +decomprimere file. Esempi meno ovvi sono \fB\-\-quiet\fP e \fB\-\-verbose\fP. In +molti casi funziona bene abilitare l'indicatore di avanzamento usando +\fB\-\-verbose\fP, ma in alcune situazioni i messaggi extra creano problemi. Il +livello di prolissità influisce anche sul comportamento di \fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Opzioni predefinite specifiche dell'utente o a livello di sistema. In genere +questo viene impostato in uno script di inizializzazione della shell per +abilitare il valore predefinito del limitatore di utilizzo della memoria di +\fBxz\fP, o per impostare il numero di thread predefinito. Escludendo gli +script di inizializzazione della shell e analoghi casi particolari, gli +script non dovrebbero mai impostare o annullare l'impostazione di +\fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Questo serve per passare le opzioni a \fBxz\fP quando non sia possibile +impostare le opzioni direttamente sulla riga di comando di \fBxz\fP. Questo è +il caso quando \fBxz\fP viene eseguito da uno script o da uno strumento, ad +esempio GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Gli script possono usare \fBXZ_OPT\fP, per esempio, per impostare opzioni di +compressione predefinite specifiche per lo script. Si raccomanda comunque di +permettere agli utenti di sovrascrivere \fBXZ_OPT\fPse questo è ragionevole. Ad +esempio, negli script \fBsh\fP(1) si può usare qualcosa come questo: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "COMPATIBILITÀ LZMA UTILS" +La sintassi della riga di comando di \fBxz\fP è essenzialmente un sopra\-insieme +di \fBlzma\fP, \fBunlzma\fP, e \fBlzcat\fP come trovati nelle LZMA Utils +4.32.x. Nella maggior parte dei casi è possibili sostituire le LZMA Utils +con le XZ Utils senza rompere gli script esistenti. Ci sono però alcune +incompatibilità, che in alcuni casi potrebbero causare problemi. +. +.SS "Livelli di compressione preimpostati" +La numerazione dei livelli di compressione preimpostati non è identica in +\fBxz\fP e nelle LZMA Utils. La differenza più importante è il modo in cui le +dimensioni del dizionario vengono mappate sulle diverse preimpostazioni. La +dimensione del dizionario è approssimativamente uguale all'utilizzo della +memoria del decompressore. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Livello;xz;LZMA Utils +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Le differenze di dimensione del dizionario influiscono anche sull'utilizzo +della memoria del compressore, ma ci sono alcune altre differenze tra le +LZMA Utils e le XZ Utils, che rendono la differenza ancora più grande: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Livello;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Il livello preimpostato predefinito nelle LZMA Utils è \fB\-7\fP mentre nelle XZ +Utils è \fB\-6\fP, quindi entrambi utilizzano un dizionario da 8 MiB per +impostazione predefinita. +. +.SS "File .lzma con flussi vs. senza flussi" +La dimensione non compressa del file può essere memorizzata +nell'intestazione \fB.lzma\fP. Le LZMA Utils lo fanno durante la compressione +di file regolari. L'alternativa consiste nel memorizzare che la dimensione +non compressa è sconosciuta e utilizzare l'indicatore di fine carico utile +per indicare il punto in cui il decompressore deve fermarsi. Le LZMA Utils +utilizzano questo metodo quando le dimensioni non compresse non sono note, +come nel caso, ad esempio, delle pipe. +.PP +\fBxz\fP supporta la decompressione di file \fB.lzma\fP con o senza il marcatore +di fine payload, ma tutti i file \fB.lzma\fP creati da \fBxz\fP utilizzeranno il +marcatore di fine payload e avranno dimensioni non compresse contrassegnate +come sconosciute nell'intestazione \fB.lzma\fP. Questo può essere un problema +in alcune situazioni non comuni. Ad esempio, un decompressore \fB.lzma\fP in un +dispositivo embedded potrebbe funzionare solo con file con dimensioni non +compresse note. Se si incorre in questo problema, occorre utilizzare le LZMA +Utils oppure l'LZMA SDK per creare dei file \fB.lzma\fP con dimensioni non +compresse note. +. +.SS "File .lzma non supportati" +Il formato \fB.lzma\fP permette valori \fIlc\fP fino a 8, e valori \fIlp\fP fino a +4. Le LZMA Utils possono decomprimere file con qualunque \fIlc\fP e \fIlp\fP, ma +creeranno sempre file con \fBlc=3\fP e \fBlp=0\fP. Creare file con altri \fIlc\fP e +\fIlp\fP è possibile con \fBxz\fP e con l'LZMA SDK. +.PP +L'implementazione del filtro LZMA1 in liblzma richiede che la somma di \fIlc\fP +e \fIlp\fP non debba superare 4. Pertanto, i file \fB.lzma\fP che superano questa +limitazione non possono essere decompressi con \fBxz\fP. +.PP +Le LZMA Utils creano solo file \fB.lzma\fP con dimensione del dizionario 2^\fIn\fP +(una potenza di 2) ma accettano file con qualsiasi dimensione di +dizionario. liblzma accetta solo file \fB.lzma\fP con dimensione del dizionario +2^\fIn\fP o 2^\fIn\fP + 2^(\fIn\fP\-1). Questo serve a limitare i falsi positivi +quando si cerca di identificare i file \fB.lzma\fP. +.PP +All'atto pratico queste limitazioni non dovrebbero essere un problema, +perché praticamente tutti i file \fB.lzma\fP sono stati compressi con +impostazioni che liblzma accetterà. +. +.SS "Dati sporchi finali" +Quando si decomprime, le LZMA Utils ignorano automaticamente tutto quello +che c'è dopo il primo flusso \fB.lzma\fP. Nella maggior parte delle situazioni +questo è un baco. Questo significa anche che le LZMA Utils non supportano la +decompressione di file \fB.lzma\fP concatenati. +.PP +Se sono rimasti dati dopo il primo flusso \fB.lzma\fP, \fBxz\fP considera il file +corrotto a meno che sia stato utilizzato \fB\-\-single\-stream\fP. Questo può far +rompere script incomprensibili che hanno assunto che i dati sporchi finali +vengano ignorati. +. +.SH NOTE +. +.SS "L'output compresso può variare" +L'esatto output compresso prodotto dallo stesso file di input non compresso +può variare tra le versioni delle XZ Utils, anche se le opzioni di +compressione sono le stesse. Questo perché il codificatore può essere stato +migliorato (compressione più veloce o migliore) senza influire sul formato +del file. L'output può variare anche tra diverse build della stessa versione +delle XZ Utils, se vengono utilizzate opzioni di build differenti. +.PP +Quanto sopra significa che una volta che \fB\-\-rsyncable\fP è stato +implementato, i file risultanti non saranno necessariamente rsync\-abili a +meno che sia i vecchi che i nuovi file non siano stati compressi con la +stessa versione di xz. Questo problema può essere risolto se una parte +dell'implementazione del codificatore viene congelata per mantenere stabile +l'output rsync\-abile tra le versioni di xz. +. +.SS "Abilita i decompressori .xz" +Le implementazioni dei decompressori \fB.xz\fP embedded, come XZ Embedded, non +necessariamente supportano file creati con tipi di integrità \fICONTROLLO\fP +diversi da \fBnone\fP e \fBcrc32\fP. Dal momento che il valore predefinito è +\fB\-\-check=crc64\fP, occorre specificare \fB\-\-check=none\fP o \fB\-\-check=crc32\fP +quando si creano file per sistemi embedded. +.PP +Al di fuori dei sistemi embedded, tutti i decompressori in formato \fB.xz\fP +supportano tutti i tipi di \fICONTROLLO\fP, o almeno sono in grado di +decomprimere il file senza verificare il controllo di integrità se il +particolare \fICONTROLLO\fP non è supportato. +.PP +XZ Embedded supporta i filtri BCJ, ma solo con offset iniziale predefinito. +. +.SH ESEMPI +. +.SS "Informazioni di base" +Comprime il file \fIfoo\fP in \fIfoo.xz\fP utilizzando il livello di compressione +predefinito (\fB\-6\fP) e rimuove \fIfoo\fP se la compressione ha esito positivo: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Decomprime \fIbar.xz\fP in \fIbar\fP e non rimuove \fIbar.xz\fP anche se la +decompressione ha successo: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Crea \fIbaz.tar.xz\fP con il preset \fB\-4e\fP (\fB\-4 \-\-extreme\fP), che è più lenta +della predefinita \fB\-6\fP, ma ha bisogno di meno memoria per la compressione e +decompressione (48\ MiB e 5\ MiB, rispettivamente): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Una combinazione di file compressi e non compressi può essere decompressa +sullo output standard con un singolo comando: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Compressione parallela di più file" +Su GNU e *BSD, \fBfind\fP(1) e \fBxargs\fP(1) possono essere usati per +parallelizzare la compressione di più file: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +L'opzione \fB\-p\fP di \fBxargs\fP(1) imposta il numero di processi \fBxz\fP +paralleli. Il valore migliore per l'opzione \fB\-n\fP dipende dal numero di file +da comprimere. Se sono presenti solo un paio di file, il valore dovrebbe +probabilmente essere 1; con decine di migliaia di file, 100 o anche di più +può essere appropriato per ridurre il numero di processi \fBxz\fP che +\fBxargs\fP(1) alla fine creerà. +.PP +L'opzione \fB\-T1\fP per \fBxz\fP serve a forzare la modalità a thread singola, +perché \fBxargs\fP (1) viene utilizzato per controllare la quantità di +parallelizzazione. +. +.SS "Modalità robot" +Calcola quanti byte sono stati salvati in totale dopo la compressione di più +file: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Uno script potrebbe voler sapere se si sta utilizzando una versione di \fBxz\fP +sufficientemente recente. Il seguente script \fBsh\fP(1) controlla che il +numero di versione dello strumento \fBxz\fP sia almeno 5.0.0. Questo metodo è +compatibile con le vecchie versioni beta, che non supportavano l'opzione +\fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Imposta un limite di utilizzo della memoria per la decompressione +utilizzando \fBXZ_OPT\fP, ma se è già stato impostato un limite, non lo +aumenta: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Catene di filtri di compressione personalizzate" +L'uso più semplice delle catene di filtri personalizzate è la +personalizzazione di un preset di LZMA2. Questo può essere utile, perché i +preset coprono solamente un sottoinsieme di tutte le combinazioni di +impostazioni di compressione potenzialmente utili. +.PP +Le colonne CompCPU delle tabelle dalle descrizioni delle opzioni \fB\-0\fP +\&... \fB\-9\fP e \fB\-\-extreme\fP sono utili quando si personalizzano i preset di +LZMA2. Di seguito sono riportate le parti rilevanti raccolte da queste due +tabelle: +.RS +.PP +.TS +tab(;); +c c +n n. +Livello preimpostato;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Se si sa che un file richiede un dizionario piuttosto grande (ad esempio, +32\ MiB) per essere compresso bene, ma si desidera comprimerlo più +velocemente di quanto farebbe \fBxz \-8\fP, è possibile modificare un preset con +un basso valore CompCPU (ad esempio, 1) per utilizzare un dizionario più +grande: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Con alcuni file, il comando sopra potrebbe essere più veloce di \fBxz \-6\fP e +la compressione significativamente migliore. Tuttavia, si deve sottolineare +che solo alcuni file traggono beneficio da un dizionario grande e mantengono +basso il valore di CompCPU. La situazione più ovvia in cui un dizionario +grande può aiutare molto è un archivio contenente file molto simili di +almeno un paio di megabyte ciascuno. La dimensione del dizionario deve +essere significativamente più grande di ogni singolo file per permettere a +LZMA2 di trarre pieno vantaggio dalle somiglianze tra file consecutivi. +.PP +Se l'utilizzo molto elevato della memoria del compressore e del +decompressore è accettabile, e il file da comprimere è almeno di diverse +centinaia di megabyte, potrebbe essere utile utilizzare un dizionario ancora +più grande dei 64 MiB che \fBxz \-9\fP utilizzerebbe: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +L'uso di \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) come nell'esempio precedente può +essere utile per vedere i requisiti di memoria del compressore e del +decompressore. Tenere presente che l'utilizzo di un dizionario più grande +della dimensione del file non compresso è uno spreco di memoria, quindi il +comando precedente non è utile per i file di piccole dimensioni. +.PP +A volte il tempo di compressione non importa, ma l'utilizzo di memoria del +decompressore deve essere tenuta bassa, per esempio, per permettere di +decomprimere il file in un sistema embedded. Il comando seguente usa \fB\-6e\fP +(\fB\-6 \-\-extreme\fP) come base e imposta il dizionario a soli 64\ KiB. Il file +risultante può essere decompresso con XZ Embedded (ecco perché c'è +\fB\-\-check=crc32\fP) usando circa 100\ KiB di memoria. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Se si desidera spremere il maggior numero possibile di byte, a volte può +essere utile regolare il numero di bit di contesto letterale (\fIlc\fP) e il +numero di bit di posizione (\fIpb\fP). Anche la regolazione del numero di bit +di posizione letterale (\fIlp\fP) potrebbe essere d'aiuto, ma di solito \fIlc\fP e +\fIpb\fP sono più importanti. Per esempio, un archivio di codici sorgente +contiene principalmente testo US\-ASCII, quindi qualcosa come il seguente +potrebbe produrre un file leggermente (0,1\ %) più piccolo di \fBxz \-6e\fP +(provare anche senza \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Usare un altro filtro insieme a LZMA2 può migliorare la compressione per +alcuni tipi di file. Ad esempio, per comprimere una libreria condivisa +x86\-32 o x86\-64 usare il filtro BCJ: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Si noti che l'ordine delle opzioni di filtro è significativo. Se viene +specificato \fB\-\-x86\fP dopo \fB\-\-lzma2\fP, \fBxz\fP darà un errore, perché non può +esserci alcun filtro dopo LZMA2 e anche perché il filtro BCJ x86 non può +essere utilizzato come ultimo filtro della catena. +.PP +Il filtro Delta insieme con LZMA2 può dare buoni risultati sulle immagini +bitmap. Di solito dovrebbe battere il PNG, il quale ha alcuni filtri più +avanzati rispetto al semplice delta ma utilizza Deflate per la compressione +effettiva. +.PP +L'immagine deve essere salvata in un formato non compresso, ad esempio un +TIFF non compresso. Il parametro distanza del filtro Delta è impostato in +modo che corrisponda al numero di byte per pixel nell'immagine. Per esempio, +un bitmap a 24 bit richiede \fBdist=3\fP, e va anche bene passare \fBpb=0\fP a +LZMA2 per adattarsi all'allineamento a tre byte: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Se più immagini sono state inserite in un singolo archivio (ad esempio, +\&\fB.tar\fP), il filtro Delta funzionerà anche su questo purché tutte le +immagini abbiano lo stesso numero di byte per pixel. +. +.SH "VEDERE ANCHE" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xzcmp.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xzcmp.1 new file mode 100644 index 0000000000000000000000000000000000000000..dc0d9758b78466e415a916cb83cd9c69483cae4d --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xzcmp.1 @@ -0,0 +1,55 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Italian translations for xz-man package +.\" Luca Vercelli , 2024-2025 +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 06/03/2025 Tukaani "XZ Utils" +.SH NOME +xzcmp, xzdiff, lzcmp, lzdiff \- confronto tra file compressi +. +.SH SINOSSI +\fBxzcmp\fP [\fIOPZIONE...\fP] \fIFILE1\fP [\fIFILE2\fP] +.br +\fBxzdiff\fP \&... +.br +\fBlzcmp\fP \&... (DEPRECATO) +.br +\fBlzdiff\fP \&... (DEPRECATO) +. +.SH DESCRIZIONE +\fBxzcmp\fP e \fBxzdiff\fP confrontano i contenuti non compressi di due file. I +dati non compressi e le opzioni sono passate a \fBcmp\fP(1) o \fBdiff\fP(1) a +meno che sia specificato \fB\-\-help\fP o \fB\-\-version\fP. +.PP +Se sono indicati sia \fIFILE1\fP che \fIFILE2\fP, essi possono essere file non +compressi oppure file nei formati che \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), +\fBlzop\fP(1), \fBzstd\fP(1), o \fBlz4\fP(1) possono decomprimere. I comandi di +decompressione necessari sono dedotti dai suffissi dei nomi dei file +\fIFILE1\fP e \fIFILE2\fP. Un file con un suffisso non riconosciuto viene +considerato o non compresso oppure in un formato che \fBxz\fP(1) può +decomprimere. +.PP +Se viene fornito un solo nome di file, \fIFILE1\fP deve avere un suffisso di un +formato di compressione supportato e il nome di \fIFILE2\fP si assume che sia +\fIFILE1\fP senza il suffisso del formato di compressione. +.PP +I comandi \fBlzcmp\fP, e \fBlzdiff\fP sono forniti per retrocompatibilità con le +LZMA Utils. Sono deprecati e saranno rimosso in una versione futura. +. +.SH "CODICE DI USCITA" +Se avviene un errore nella decompressione, lo stato di uscita è +\fB2\fP. Altrimenti viene usato lo stato di uscita di \fBcmp\fP(1) o \fBdiff\fP(1) +. +.SH "VEDERE ANCHE" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xzdec.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xzdec.1 new file mode 100644 index 0000000000000000000000000000000000000000..e3ff6ec043867c79dbe625986377ebe54fbea0ca --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xzdec.1 @@ -0,0 +1,88 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.\" Italian translations for xz-man package +.\" Luca Vercelli , 2024-2025 +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDEC 1 08/04/2024 Tukaani "XZ Utils" +.SH NOME +xzdec, lzmadec \- Piccoli compressori .xz e .lzma +.SH SINOSSI +\fBxzdec\fP [\fIOPZIONE...\fP] [\fIFILE...\fP] +.br +\fBlzmadec\fP [\fIOPZIONE...\fP] [\fIFILE...\fP] +.SH DESCRIZIONE +\fBxzdec\fP è uno strumento di sola decompressione basato su liblzma per i file +\&\fB.xz\fP (e solo \fB.xz\fP). \fBxzdec\fP è destinato a funzionare come sostituto +drop\-in di \fBxz\fP (1) nelle situazioni più comuni in cui è stato scritto uno +script che utilizza \fBxz \-\-decompress \-\-stdout\fP (e possibilmente alcune +altre opzioni di uso comune) per decomprimere i file \fB.xz\fP. \fBlzmadec\fP è +identico a \fBxzdec\fP tranne nel fatto che supporta file \fB.lzma\fP invece di +\&\fB.xz\fP. +.PP +Per ridurre la dimensione dell'eseguibile, \fBxzdec\fP non supporta né il +multi\-thread né la localizzazione, e non legge le opzioni dalle variabili di +ambiente \fBXZ_DEFAULTS\fP e \fBXZ_OPT\fP. \fBxzdec\fP non supporta la +visualizzazione delle informazioni di avanzamento: inviare \fBSIGINFO\fP a +\fBxzdec\fP non fa nulla mentre inviare \fBSIGUSR1\fP termina il processo anziché +mostrare le informazioni di avanzamento. +.SH OPZIONI +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +Ignorato per compatibilità con \fBxz\fP(1). \fBxzdec\fP supporta solo la +decompressione. +.TP +\fB\-k\fP, \fB\-\-keep\fP +Ignorato per compatibilità con \fBxz\fP(1). \fBxzdec\fP non crea né rimuove mai +file. +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Ignorato per compatibilità con \fBxz\fP(1). \fBxzdec\fP scrive sempre i dati +decompressi sullo standard output. +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Specificare questa opzione una sola volta non ha effetto, poiché \fBxzdec\fP +non visualizza mai alcun avvertimento né avviso. Specificare questa opzione +due volte per eliminare gli errori. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Ignorato per compatibilità con \fBxz\fP(1). \fBxzdec\fP non utilizza mai il codice +di uscita 2. +.TP +\fB\-h\fP, \fB\-\-help\fP +Mostra un messaggio di aiuto e termina con successo. +.TP +\fB\-V\fP, \fB\-\-version\fP +Mostra il numero di versione di \fBxzdec\fP e liblzma. +.SH "CODICE DI USCITA" +.TP +\fB0\fP +Andava tutto bene. +.TP +\fB1\fP +È avvenuto un errore. +.PP +\fBxzdec\fP non ha alcun messaggio di avvertimento come \fBxz\fP (1), quindi lo +stato di uscita 2 non viene utilizzato da \fBxzdec\fP. +.SH NOTE +Utilizzare \fBxz\fP(1) al posto di \fBxzdec\fP o \fBlzmadec\fP per l'utilizzo +normale abituale. \fBxzdec\fP e \fBlzmadec\fP sono pensati solo per situazioni in +cui sia importante avere un decompressore più piccolo rispetto a quello con +funzionalità complete \fBxz\fP(1). +.PP +\fBxzdec\fP e \fBlzmadec\fP non sono veramente così piccoli. La dimensione può +essere ridotta ulteriormente eliminando delle funzionalità da liblzma al +momento della compilazione, ma questo di solito non dovrebbe essere fatto +per gli eseguibili distribuiti nelle tipiche distribuzioni di sistemi +operativi non embedded. Se c'è bisogno di un decompressore \fB.xz\fP veramente +piccolo, si consideri l'utilizzo di XZ Embedded. +.SH "VEDERE ANCHE" +\fBxz\fP(1) +.PP +XZ Embedded: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xzdiff.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xzdiff.1 new file mode 100644 index 0000000000000000000000000000000000000000..dc0d9758b78466e415a916cb83cd9c69483cae4d --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xzdiff.1 @@ -0,0 +1,55 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Italian translations for xz-man package +.\" Luca Vercelli , 2024-2025 +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 06/03/2025 Tukaani "XZ Utils" +.SH NOME +xzcmp, xzdiff, lzcmp, lzdiff \- confronto tra file compressi +. +.SH SINOSSI +\fBxzcmp\fP [\fIOPZIONE...\fP] \fIFILE1\fP [\fIFILE2\fP] +.br +\fBxzdiff\fP \&... +.br +\fBlzcmp\fP \&... (DEPRECATO) +.br +\fBlzdiff\fP \&... (DEPRECATO) +. +.SH DESCRIZIONE +\fBxzcmp\fP e \fBxzdiff\fP confrontano i contenuti non compressi di due file. I +dati non compressi e le opzioni sono passate a \fBcmp\fP(1) o \fBdiff\fP(1) a +meno che sia specificato \fB\-\-help\fP o \fB\-\-version\fP. +.PP +Se sono indicati sia \fIFILE1\fP che \fIFILE2\fP, essi possono essere file non +compressi oppure file nei formati che \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), +\fBlzop\fP(1), \fBzstd\fP(1), o \fBlz4\fP(1) possono decomprimere. I comandi di +decompressione necessari sono dedotti dai suffissi dei nomi dei file +\fIFILE1\fP e \fIFILE2\fP. Un file con un suffisso non riconosciuto viene +considerato o non compresso oppure in un formato che \fBxz\fP(1) può +decomprimere. +.PP +Se viene fornito un solo nome di file, \fIFILE1\fP deve avere un suffisso di un +formato di compressione supportato e il nome di \fIFILE2\fP si assume che sia +\fIFILE1\fP senza il suffisso del formato di compressione. +.PP +I comandi \fBlzcmp\fP, e \fBlzdiff\fP sono forniti per retrocompatibilità con le +LZMA Utils. Sono deprecati e saranno rimosso in una versione futura. +. +.SH "CODICE DI USCITA" +Se avviene un errore nella decompressione, lo stato di uscita è +\fB2\fP. Altrimenti viene usato lo stato di uscita di \fBcmp\fP(1) o \fBdiff\fP(1) +. +.SH "VEDERE ANCHE" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xzegrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xzegrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..778054dc4c25e481efd7f316a89c121ce2df68af --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xzegrep.1 @@ -0,0 +1,94 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Italian translations for xz-man package +.\" Luca Vercelli , 2024-2025 +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 06/03/2025 Tukaani "XZ Utils" +.SH NOME +xzgrep \- Cerca pattern in file potenzialmente compressi +. +.SH SINOSSI +\fBxzgrep\fP [\fIOPZIONE...\fP] [\fILISTA_PATTERN\fP] [\fIFILE...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (DEPRECATO) +.br +\fBlzegrep\fP \&... (DEPRECATO) +.br +\fBlzfgrep\fP \&... (DEPRECATO) +. +.SH DESCRIZIONE +\fBxzgrep\fP invoca \fBgrep\fP(1) sui contenuti non compressi dei file. I formati +dei \fIFILE\fP sono dedotti dai suffissi dei nomi dei file. Sarà decompresso +qualsiasi file con un suffisso supportato da \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), o \fBlz4\fP(1); tutti gli altri file +saranno considerati non compressi. +.PP +Se non sono specificati \fIFILE\fP, o se \fIFILE\fP è \fB\-\fP, viene letto lo +standard input. Quando si legge da standard input vengono decompressi +solamente i file supportati da \fBxz\fP(1). Gli altri file sono considerati già +non compressi. +.PP +Sono supportate la maggior parte delle \fIOPZIONI\fP di \fBgrep\fP(1). Tuttavia, +le opzioni seguenti non sono supportate: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIAZIONE\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIGLOB\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIGLOB\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIFILE\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIGLOB\fP +.PP +\fBxzegrep\fP è un alias per \fBxzgrep \-E\fP. \fBxzfgrep\fP è un alias per \fBxzgrep \-F\fP. +.PP +I comandi \fBlzgrep\fP, \fBlzegrep\fP, e \fBlzfgrep\fP sono forniti per +retrocompatibilità con le LZMA Utils. Sono deprecati e saranno rimosso in +una versione futura. +. +.SH "CODICE DI USCITA" +.TP +0 +Almeno una corrispondenza è stata trovata in almeno uno dei file +input. Nessun errore è avvenuto. +.TP +1 +Non sono state trovate corrispondenze in nessuno dei file di input. Non si +sono verificati errori. +.TP +>1 +Sono avvenuti uno o più errori. Non è noto se sono state trovate delle +corrispondenze. +. +.SH AMBIENTE +.TP +\fBGREP\fP +Se \fBGREP\fP è impostato a un valore non vuoto, verrà usato al posto di +\fBgrep\fP, \fBgrep \-E\fP, o \fBgrep \-F\fP. +. +.SH "VEDERE ANCHE" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xzfgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xzfgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..778054dc4c25e481efd7f316a89c121ce2df68af --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xzfgrep.1 @@ -0,0 +1,94 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Italian translations for xz-man package +.\" Luca Vercelli , 2024-2025 +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 06/03/2025 Tukaani "XZ Utils" +.SH NOME +xzgrep \- Cerca pattern in file potenzialmente compressi +. +.SH SINOSSI +\fBxzgrep\fP [\fIOPZIONE...\fP] [\fILISTA_PATTERN\fP] [\fIFILE...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (DEPRECATO) +.br +\fBlzegrep\fP \&... (DEPRECATO) +.br +\fBlzfgrep\fP \&... (DEPRECATO) +. +.SH DESCRIZIONE +\fBxzgrep\fP invoca \fBgrep\fP(1) sui contenuti non compressi dei file. I formati +dei \fIFILE\fP sono dedotti dai suffissi dei nomi dei file. Sarà decompresso +qualsiasi file con un suffisso supportato da \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), o \fBlz4\fP(1); tutti gli altri file +saranno considerati non compressi. +.PP +Se non sono specificati \fIFILE\fP, o se \fIFILE\fP è \fB\-\fP, viene letto lo +standard input. Quando si legge da standard input vengono decompressi +solamente i file supportati da \fBxz\fP(1). Gli altri file sono considerati già +non compressi. +.PP +Sono supportate la maggior parte delle \fIOPZIONI\fP di \fBgrep\fP(1). Tuttavia, +le opzioni seguenti non sono supportate: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIAZIONE\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIGLOB\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIGLOB\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIFILE\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIGLOB\fP +.PP +\fBxzegrep\fP è un alias per \fBxzgrep \-E\fP. \fBxzfgrep\fP è un alias per \fBxzgrep \-F\fP. +.PP +I comandi \fBlzgrep\fP, \fBlzegrep\fP, e \fBlzfgrep\fP sono forniti per +retrocompatibilità con le LZMA Utils. Sono deprecati e saranno rimosso in +una versione futura. +. +.SH "CODICE DI USCITA" +.TP +0 +Almeno una corrispondenza è stata trovata in almeno uno dei file +input. Nessun errore è avvenuto. +.TP +1 +Non sono state trovate corrispondenze in nessuno dei file di input. Non si +sono verificati errori. +.TP +>1 +Sono avvenuti uno o più errori. Non è noto se sono state trovate delle +corrispondenze. +. +.SH AMBIENTE +.TP +\fBGREP\fP +Se \fBGREP\fP è impostato a un valore non vuoto, verrà usato al posto di +\fBgrep\fP, \fBgrep \-E\fP, o \fBgrep \-F\fP. +. +.SH "VEDERE ANCHE" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xzgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xzgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..778054dc4c25e481efd7f316a89c121ce2df68af --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xzgrep.1 @@ -0,0 +1,94 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Italian translations for xz-man package +.\" Luca Vercelli , 2024-2025 +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 06/03/2025 Tukaani "XZ Utils" +.SH NOME +xzgrep \- Cerca pattern in file potenzialmente compressi +. +.SH SINOSSI +\fBxzgrep\fP [\fIOPZIONE...\fP] [\fILISTA_PATTERN\fP] [\fIFILE...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (DEPRECATO) +.br +\fBlzegrep\fP \&... (DEPRECATO) +.br +\fBlzfgrep\fP \&... (DEPRECATO) +. +.SH DESCRIZIONE +\fBxzgrep\fP invoca \fBgrep\fP(1) sui contenuti non compressi dei file. I formati +dei \fIFILE\fP sono dedotti dai suffissi dei nomi dei file. Sarà decompresso +qualsiasi file con un suffisso supportato da \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), o \fBlz4\fP(1); tutti gli altri file +saranno considerati non compressi. +.PP +Se non sono specificati \fIFILE\fP, o se \fIFILE\fP è \fB\-\fP, viene letto lo +standard input. Quando si legge da standard input vengono decompressi +solamente i file supportati da \fBxz\fP(1). Gli altri file sono considerati già +non compressi. +.PP +Sono supportate la maggior parte delle \fIOPZIONI\fP di \fBgrep\fP(1). Tuttavia, +le opzioni seguenti non sono supportate: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIAZIONE\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIGLOB\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIGLOB\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIFILE\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIGLOB\fP +.PP +\fBxzegrep\fP è un alias per \fBxzgrep \-E\fP. \fBxzfgrep\fP è un alias per \fBxzgrep \-F\fP. +.PP +I comandi \fBlzgrep\fP, \fBlzegrep\fP, e \fBlzfgrep\fP sono forniti per +retrocompatibilità con le LZMA Utils. Sono deprecati e saranno rimosso in +una versione futura. +. +.SH "CODICE DI USCITA" +.TP +0 +Almeno una corrispondenza è stata trovata in almeno uno dei file +input. Nessun errore è avvenuto. +.TP +1 +Non sono state trovate corrispondenze in nessuno dei file di input. Non si +sono verificati errori. +.TP +>1 +Sono avvenuti uno o più errori. Non è noto se sono state trovate delle +corrispondenze. +. +.SH AMBIENTE +.TP +\fBGREP\fP +Se \fBGREP\fP è impostato a un valore non vuoto, verrà usato al posto di +\fBgrep\fP, \fBgrep \-E\fP, o \fBgrep \-F\fP. +. +.SH "VEDERE ANCHE" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xzless.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xzless.1 new file mode 100644 index 0000000000000000000000000000000000000000..03fcb0de8d8d598d0fa50abb8246952556e4ea3b --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xzless.1 @@ -0,0 +1,47 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" Italian translations for xz-man package +.\" Luca Vercelli , 2024-2025 +.\" +.\" (Note that this file is not based on gzip's zless.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZLESS 1 06/03/2025 Tukaani "XZ Utils" +.SH NOME +xzless, lzless \- mostra file (testuali) compressi xz o lzma +.SH SINOSSI +\fBxzless\fP [\fIFILE\fP...] +.br +\fBlzless\fP [\fIFILE\fP...] (DEPRECATO) +.SH DESCRIZIONE +\fBxzless\fP è un filtro che visualizza testo da file compressi a un +terminale. I file supportati da \fBxz\fP(1) vengono decompressi; gli altri +file sono considerati già non compressi. Se non viene dato alcun \fIFILE\fP, +\fBxzless\fP legge dallo standard input. +.PP +\fBxzless\fP usa \fBless\fP(1) per mostrare il suo output. A differenza di +\fBxzmore\fP, la scelta del paginatore non può essere modificata impostando una +variabile d'ambiente. I comandi si basano sia su \fBmore\fP (1) che su \fBvi\fP +(1) e consentono il movimento in avanti e all'indietro e la ricerca. Per +ulteriori informazioni vedere il manuale di \fBless\fP(1). +.PP +Il comando chiamato \fBlzless\fP è fornito per retrocompatibilità con le LZMA +Utils. È deprecato e sarà rimosso in una versione futura. +.SH AMBIENTE +.TP +\fBLESSMETACHARS\fP +Un elenco di caratteri speciali per la shell. Impostato da \fBxzless\fP a meno +che sia già impostato nell'ambiente. +.TP +\fBLESSOPEN\fP +Valorizzare con una riga di comando per lanciare il decompressore \fBxz\fP(1) +per preprocessare i file input per \fBless\fP(1). +.SH "VEDERE ANCHE" +\fBless\fP(1), \fBxz\fP(1), \fBxzmore\fP(1), \fBzless\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xzmore.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xzmore.1 new file mode 100644 index 0000000000000000000000000000000000000000..60fca91601bf3c6cef290e4c370bb344ffc3f78a --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/it/man1/xzmore.1 @@ -0,0 +1,50 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" Italian translations for xz-man package +.\" Luca Vercelli , 2024-2025 +.\" +.\" (Note that this file is based on xzless.1 instead of gzip's zmore.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZMORE 1 06/03/2025 Tukaani "XZ Utils" +.SH NOME +xzmore, lzmore \- mostra file (testuali) compressi xz o lzma +. +.SH SINOSSI +\fBxzmore\fP [\fIFILE\fP...] +.br +\fBlzmore\fP [\fIFILE\fP...] (DEPRECATO) +. +.SH DESCRIZIONE +\fBxzmore\fP visualizza il testo da file non compressi a un terminale usando +\fBmore\fP(1). I file supportati da \fBxz\fP(1) vengono decompressi; gli altri +file sono considerati non compressi. Se non viene dato alcun \fIFILE\fP, +\fBxzmore\fP legge dallo standard input. Si veda il manuale di \fBmore\fP(1) per i +comandi da tastiera. +.PP +Si noti che lo scorrimento all'indietro potrebbe non essere possibile a +seconda dell'implementazione di \fBmore\fP(1). Ciò è dovuto al fatto che +\fBxzmore\fP utilizza una pipe per passare i dati decompressi a +\fBmore\fP(1). \fBxzless\fP(1) utilizza \fBless\fP(1) che fornisce funzionalità più +avanzate. +.PP +Il comando \fBlzmore\fP è fornito per retrocompatibilità con le LZMA Utils. È +deprecato e sarà rimosso in una versione futura. +. +.SH AMBIENTE +.TP +.\" TRANSLATORS: Don't translate the uppercase PAGER. +.\" It is a name of an environment variable. +\fBPAGER\fP +Se \fBPAGER\fP è impostato, il suo valore è usato come paginatore al posto di +\fBmore\fP(1). +. +.SH "VEDERE ANCHE" +\fBmore\fP(1), \fBxz\fP(1), \fBxzless\fP(1), \fBzmore\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzcat.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzcat.1 new file mode 100644 index 0000000000000000000000000000000000000000..631a9a7cc8b58565ff6c9eb7a3610b39d1733d20 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzcat.1 @@ -0,0 +1,1585 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Korean translation for the xz-man +.\" Seong-ho Cho , 2023, 2024. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 2025\-03\-08 Tukaani "XZ 유틸리티" +. +.SH 이름 +xz, unxz, xzcat, lzma, unlzma, lzcat \- .xz 파일과 .lzma 파일을 압축 또는 압축 해제합니다 +. +.SH 요약 +\fBxz\fP [\fI<옵션>...\fP] [\fI<파일>...\fP] +. +.SH "명령 별칭" +\fBunxz\fP 명령은 \fBxz \-\-decompress\fP 명령과 동일합니다. +.br +\fBxzcat\fP 명령은 \fBxz \-\-decompress \-\-stdout\fP 명령과 동일합니다. +.br +\fBlzma\fP 명령은 \fBxz \-\-format=lzma\fP 명령과 동일합니다. +.br +\fBunlzma\fP 명령은 \fBxz \-\-format=lzma \-\-decompress\fP 명령과 동일합니다. +.br +\fBlzcat\fP 명령은 \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP 명령과 동일합니다. +.PP +파일 압축을 해제해야 하는 셸 스크립트를 작성할 때, \fBunxz\fP 와 \fBxzcat\fP 이름 대신 \fBxz\fP 명령과 적절한 인자 +값(\fBxz \-d\fP 또는 \fBxz \-dc\fP)의 사용을 추천드립니다. +. +.SH 설명 +\fBxz\fP는 \fBgzip\fP(1) 과 \fBbzip2\fP(1) 과 비슷한 명령행 문법을 지닌 범용 데이터 압축 도구입니다. 자체 파일 +형식은 \fB.xz\fP 형식이나, LZMA 유틸리티에서 사용하는 예전 \fB.lzma\fP 형식과 형식 헤더가 없는 RAW 압축 스트림도 +지원합니다. 게다가, \fBlzip\fP에서 활용하는 \fB.lz\fP 형식 압축 해제도 지원합니다. +.PP +각 \fI파일\fP 에 대한 \fBxz\fP 압축 또는 압축 해제는 선택 동작 모드에 따릅니다. \fI<파일>\fP 값이 주어졌거나 +\fI<파일>\fP 값이 \fB\-\fP이면, \fBxz\fP 명령에서 표준 입력을 읽고 처리한 데이터를 표준 출력에 기록합니다. +\fBxz\fP 에서는 터미널에서 활용할 경우 압축 데이터를 표준 압축으로 기록하는 동작을 거절(오류를 출력하고 \fI<파일>\fP을 +건너뜀)합니다. 이와 비슷하게, \fBxz\fP 유틸리티를 터미널에서 실행하면 표준 입력의 압축 데이터 읽기를 거절합니다. +.PP +\fB\-\-stdout\fP 을 지정하지 않는 한, \fB\-\fP가 아닌 \fI<파일>\fP을 원본 \fI<파일>\fP 이름에서 +가져온 새 파일 이름으로 기록합니다: +.IP \(bu 3 +압축할 때, 대상 파일 형식의 접미사(\fB.xz\fP or \fB.lzma\fP) 는 원본 파일 이름 뒤에 붙어 대상 파일이름이 됩니다. +.IP \(bu 3 +압축 해제할 때, \fB.xz\fP, \fB.lzma\fP, \fB.lz\fP 접미사를 파일 이름에서 제거하고 대상 파일 이름을 알아냅니다. +\fBxz\fP에서는 \fB.txz\fP, \fB.tlz\fP 접미사도 인식하며, \fB.tar\fP 접미사로 치환합니다. +.PP +대상 파일이 이미 있으면, 오류를 나타내고 \fI<파일>\fP을 건너뜁니다. +.PP +표준 출력으로 기록하기 전에는, \fBxz\fP는 경고를 나타내며, 다음 조건에 만족할 경우 \fI<파일>\fP을 건너뜁니다: +.IP \(bu 3 +\fI<파일>\fP이 일반 파일이 아닐 때. 심볼릭 링크는 따라가지 않기에, 일반 파일로 간주하지 않습니다. +.IP \(bu 3 +\fI<파일>\fP이 하나 이상의 하드 링크일 떄. +.IP \(bu 3 +\fI<파일>\fP에 setuid, setgid, 끈적이 비트 집합이 붙어있을 떄. +.IP \(bu 3 +동작 모드를 압축으로 설정하고, \fI<파일>\fP은 대상 파일 형식의 접미사를 이미 붙였을 때(\fB.xz\fP 형식으로 압축하면 +\&\fB.xz\fP 또는 \fB.txz\fP, \fB.lzma\fP 형식으로 압축하면 \fB.lzma\fP 또는 \fB.tlz\fP). +.IP \(bu 3 +동작 모드를 압축 해제로 설정하고, \fI<파일>\fP에 지원 파일 형식 접미사(\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, +\&\fB.tlz\fP, \fB.lz\fP)를 붙이지 않았을 때. +.PP +\fI<파일>\fP 의 압축 또는 압축 해제를 성공하고 나면, \fBxz\fP는 소유자, 소유그룹, 권한, 접근 시각, 수정 시각 +정보를 원본 \fI<파일>\fP에서 대상 파일로 그대로 복사합니다. 그룹 정보 복사에 실패하면, 권한을 수정하여 원본 +\fI<파일>\fP에 접근 권한이 없는 사용자가 대상 파일로 접근하지 못하게 합니다. \fBxz\fP는 아직 접근 제어 목록이나 +확장 속성 등의 기타 메타데이터를 복사하는 기능은 지원하지 않습니다. +.PP +대상 파일을 온전히 닫고 나면, \fB\-\-keep\fP 옵션을 지원하지 않았을 경우 원본 \fI<파일>\fP을 제거합니다. 원본 +\fI<파일>\fP은 출력을 표준 출력으로 기록했거나 오류가 발생했을 경우 제거하지 않습니다. +.PP +\fBxz\fP 프로세스에 \fBSIGINFO\fP 시그널 또는 \fBSIGUSR1\fP 시그널을 보내면 표준 출력으로 진행 정보를 출력합니다. 표준 +오류가 터미널일 경우일 경우에만 제한하며 \fB\-\-verbose\fP 옵션을 지정하면 진행 표시줄을 자동으로 나타냅니다. +. +.SS "메모리 사용" +\fBxz\fP 메모리 사용은 수백 킬로바이트로 시작하여 수 기가바이트까지 압축 설정에 따라 다릅니다. 압축 해제 프로그램이 필요로 하는 +메모리 공간을 결정하는 파일 압축시에 설정 값을 활용합니다. 보통 압축 해제 프로그램은 파일을 만들 때, 압축 프로그램 메모리 사용량의 +5% 에서 20% 정도 필요합니다. 예를 들면, \fBxz \-9\fP로 압축한 파일 압축 해제시 현재 65MiB 메모리 용량이 필요합니다. +여전하게도, 압축 해제시 수 기가 바이트의 메모리가 필요한 \fB.xz\fP 파일에도 가능한 이야기입니다. +.PP +특히 이전 시스템 사용자의 경우 메모리 사용량이 엄청나게 늘어나는 점에 짜증이 날 수 있습니다. 이런 불편한 상황을 피하기 위해, +\fBxz\fP에 기본적으로 비활성 상태인 내장 메모리 사용 제한 기능을 넣었습니다. 일부 운영체제에서 처리 중 메모리 사용을 제한하는 +수단을 제공하긴 하지만, 여기에 의지하기에는 충분히 유연하지 않습니다(예를 들면, \fBulimit\fP(1)을 사용하면 가상 메모리를 +제한하여 \fBmmap\fP(2)을 먹통으로 만듭니다). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +메모리 사용 제한 기능은 \fB\-\-memlimit=\fP\fI<제한용량>\fP 명령행 옵션으로 사용할 수 있습니다. 종종 +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP와 같이 \fBXZ_DEFAULTS\fP 환경 변수를 설정하여 제한 기능을 켜는게 더 +편합니다. \fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션과 +\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP 옵션을 활용하여 압축 및 압축 해제시 별도로 한계 값을 +설정할 수 있습니다. 이 두 가지 옵션의 \fBXZ_DEFAULTS\fP 환경 변수 밖에서의 사용은, \fBxz\fP를 단일 실행할 때 압축 및 +압축 해제 동작을 동시에 수행하지 않으며, 앞서 언급한 두가지 옵션을 명령행에 입력하기에는 +\fB\-\-memlimit=\fP\fI<제한용량>\fP(또는 \fB\-M\fP \fI<제한용량>\fP)이 더 짧기 때문에 별로 쓸모가 +없습니다. +.PP +압축 해제시 메모리 사용 제한 지정 한계를 초과하면, \fBxz\fP 유틸리티에서 오류를 나타내며 파일 압축 해제는 실패합니다. 압축을 +실행할 때 사용 제한 지정 한계를 넘어서면 \fBxz\fP에서는 설정 값을 줄여서 어쨌든 한계를 넘지 못하게 +합니다(\fB\-\-format=raw\fP 옵션 또는 \fB\-\-no\-adjust\fP 옵션 사용시 제외). 설정 한계 값이 엄청 작지 않은 이상 이 +방식대로 처리하면 어쨌든 실패하지 않습니다. 설정 값조정은 압축 래벨 사전 설정과 일치하지 않을 때 단계적으로 진행하는데, 이를테면, +\fBxz \-9\fP 명령 수행에 필요한 양보다 한계 값이 약간 작으면, 설정 값을 \fBxz \-8\fP에 못미치게 약간 줄여서 진행합니다. +. +.SS ".xz 파일 결합 및 패딩" +\&\fB.xz\fP 파일을 있는 그대로 합칠 수 있습니다. \fBxz\fP는 \fB.xz\fP 파일을 단독 파일일 때 처럼 압축해제합니다. +.PP +결합 부분과 마지막 부분 뒤에 패딩을 추가할 수 있습니다. 패딩은 널 바이트로 구성해야 하며 패딩 길이는 4바이트로 구성해야 합니다. +512 바이트 블록으로 파일 크기를 이루는 매체에 \fB.xz\fP 파일을 저장했을 경우에 요긴할 수 있습니다. +.PP +\&\fB.lzma\fP 파일 또는 원시 스트림의 경우 결합과 패딩을 허용하지 않습니다. +. +.SH 옵션 +. +.SS "정수 접두사와 별도 값" +정수 인자값이 필요한 대부분 위치에서는, 큰 정수값을 나타내기 쉽게 하도록 추가 접미사를 지원합니다. 정수와 접미사 사이에 어떤 공백이 +있으면 안됩니다. +.TP +\fBKiB\fP +1,024 (2^10) 배수 정수값. \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP, \fBKB\fP 단위를 \fBKiB\fP 동의어로 받아들입니다. +.TP +\fBMiB\fP +1,048,576 (2^20) 배수 정수값. \fBMi\fP, \fBm\fP, \fBM\fP, \fBMB\fP 단위를 \fBMiB\fP 동의어로 받아들입니다. +.TP +\fBGiB\fP +1,073,741,824 (2^30) 배수 정수값. \fBGi\fP, \fBg\fP, \fBG\fP, \fBGB\fP 단위를 \fBGiB\fP 동의어로 +받아들입니다. +.PP +특수 값 \fBmax\fP는 옵션에서 지원하는 정수 최대 값을 나타낼 때 사용할 수 있습니다. +. +.SS "동작 모드" +여러 동작 모드를 보여드리겠습니다만, 마지막에 주어진 동작 모드로 동작합니다. +.TP +\fB\-z\fP, \fB\-\-compress\fP +압축합니다. 어떤 동작 모드 옵션도 지정하지 않고 다른 동작 모드를 명령행에 따로 지정하지 않았다면 이 동작 모드는 기본입니다(예: +\fBunxz\fP 는 \fB\-\-decompress\fP를 암시). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +압축을 제대로 끝내고 나면, 표준 출력에 기록하거나 \fB\-\-keep\fP 옵션을 지정하지 않았다면 원본 파일을 제거합니다. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +압축 해제입니다. 압축 해제를 제대로 끝내고 나면, 표준 출력에 기록하거나 \fB\-\-keep\fP 옵션을 지정하지 않았다면 원본 파일을 +제거합니다. +.TP +\fB\-t\fP, \fB\-\-test\fP +압축 \fI<파일>\fP의 무결성을 시험해봅니다. 이 옵션은 압축 해제 데이터를 표준 출력으로 기록하는 대신 버린다는 점을 +제외하고 \fB\-\-decompress \-\-stdout\fP과 동일합니다. 어떤 파일도 만들거나 제거하지 않습니다. +.TP +\fB\-l\fP, \fB\-\-list\fP +압축 \fI<파일>\fP 정보를 출력합니다. 압축 해제 출력을 내보내지 않으며, 어떤 파일도 만들거나 제거하지 않습니다. 이 +조회 모드에서, 프로그램은 표준 입력 또는 기타 탐색 불가능한 원본에서 압축 데이터를 읽을 수 없습니다. +.IP "" +\fI<파일>\fP 기본 정보를 파일 당 한 줄 씩 기본으로 보여줍니다. 더 자세한 정보를 보려면 \fB\-\-verbose\fP +옵션을 사용하십시오. 더 자세한 정보는 \fB\-\-verbose\fP 옵션을 두번 사용하면 되지만, 추가 정보를 더 많이 가져오면서 탐색 +횟수가 늘어나는 문제로 인해 느려질 수 있습니다. 세부 출력 너비는 80 문자를 초과하며, 예를 들어 출력을 파이핑한다면, 터미널이 +충분히 너비가 넓지 못할 경우 \fBless\ \-S\fP 명령이 편리할 수 있습니다. +.IP "" +정확한 출력은 \fBxz\fP 버전과 다른 로캘에 따라 바뀔 수 있습니다. 기계 판독용 출력시 \fB\-\-robot \-\-list\fP 옵션을 +사용합니다. +. +.SS "동작 수정자" +.TP +\fB\-k\fP, \fB\-\-keep\fP +입력 파일을 삭제하지 않습니다. +.IP "" +\fBxz\fP 5.2.6 부터는 이 옵션으로 입력 파일이 일반 파일을 참조하는 심볼릭 링크나 하나 이상의 하드 링크, 내지는 setuid, +setgid, 끈적이 비트 세트를 설정한 상태라도 압축하거나 압축을 풀 수 있습니다. setuid, setgid, 끈적이 비트는 대상 +파일에 복사하지 않습니다. 이전 버전에서는 \fB\-\-force\fP 옵션을 지정했을 때만 가능했습니다. +.TP +\fB\-f\fP, \fB\-\-force\fP +이 옵션은 몇가지 동작에 영향을 줍니다: +.RS +.IP \(bu 3 +대상 파일이 이미 있으면, 압축 또는 압축 해제 전 삭제합니다. +.IP \(bu 3 +입력 파일이 일반 파일을 참조하는 심볼릭 링크나 하나 이상의 하드 링크, 내지는 setuid, setgid, 끈적이 비트 세트를 설정한 +상태라도 압축 또는 압축 해제를 진행합니다. setuid, setgid, 끈적이 비트는 대상 파일에 복사하지 않습니다. +.IP \(bu 3 +\fB\-\-decompress\fP \fB\-\-stdout\fP 옵션을 같이 사용하는 상황에서 \fBxz\fP 명령이 원본 파일의 형식을 알아내지 못할 때, +원본 파일의 사본을 표준 출력으로 보냅니다. 이렇게 하면 \fBxzcat\fP \fB\-\-force\fP 명령을 \fBxz\fP 명령으로 압축하지 않은 +파일에 대해 \fBcat\fP(1) 을 사용하는 것처럼 사용할 수 있습니다. 참고로 나중에, \fBxz\fP에서 \fBxz\fP로 하여금 여러 형식의 +파일을 표준 출력으로 복사하는 대신 압축을 해제하도록 새 압축 파일 형식을 지원할 예정입니다. +\fB\-\-format=\fP\fI<형식>\fP 옵션은 \fBxz\fP 명령에 단일 파일 형식만 압축 해제하도록 제한할 때 사용할 수 +있습니다. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +파일 대신 표준 출력으로 압축 또는 압축 해제한 데이터를 기록합니다. \fB\-\-keep\fP를 생략했습니다. +.TP +\fB\-\-single\-stream\fP +처음 \fB.xz\fP 스트림만 압축 해제하며, 스트림에 뒤따라오는 나머지 입력 데이터는 조용히 무시합니다. 보통 뒤따라오는 쓰레기 값에 +대해서는 \fBxz\fP 에서 오류를 나타냅니다. +.IP "" +\fBxz\fP는 \fB.lzma\fP 파일 또는 원시 스트림에서 온 하나 이상의 스트림에 대해 압축 해제동작을 취하지 않지만, 이 옵션을 사용하면 +\fBxz\fP에서 \fB.lzma\fP 파일 또는 원시 스트림을 처리한 다음에 뒤따라오는 데이터를 무시하도록 합니다. +.IP "" +이 옵션은 동작 모드가 \fB\-\-decompress\fP 또는 \fB\-\-test\fP가 아니면 동작에 아무런 영향을 주지 않습니다. +.IP "" +\fBxz\fP 5.7.1alpha 부터는 \fB\-\-single\-stream\fP 옵션의 동작에 \fB\-\-keep\fP 동작이 들어갑니다. +.TP +\fB\-\-no\-sparse\fP +희소 파일을 만들지 않습니다. 기본적으로 일반 파일로 압축 해제할 경우 \fBxz\fP 에서는 압축 해제한 파일에 이진 0값이 길게 늘어질 +경우 희소 배열 파일을 만들려고 합니다. 표준 출력의 내용 길이만큼 연결한 일반 파일로 기록할 때도 동작하며 희소 파일을 만드는 동안 +아무런 문제가 나타나지 않게 각각의 추가 조건을 만족합니다. 희소 파일을 만들면 디스크 공간을 절약할 수 있으며 디스크 입출력을 줄여 +압축 해제 속도를 올릴 수 있습니다. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +압축할 때, 대상 파일의 접두사를 \fB.xz\fP 또는 \fB.lzma\fP 대신 \fI.suf\fP로 사용하십시오. 표준 출력으로 기록하지 않고 +원본 파일에 \fI.suf\fP 접두사가 붙어있으면, 경고를 나타내고 해당 파일을 건너뜁니다. +.IP "" +압축 해제할 때, \fI.suf\fP 접미사로 파일을 인식하기도 하고, \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, +\&\fB.lz\fP 접미사가 붙은 파일도 인식합니다. 원본 파일에 \fI.suf\fP 접미사가 붙어있으면, 해당 접미사를 제거하여 대상 파일 이름을 +알아냅니다. +.IP "" +원시 스트림 압축 및 압축 해제시(\fB\-\-format=raw\fP) 원시 스트림에 기본 접미사가 없기 때문에, 표준 출력으로 기록하지 않는 +한 접미사를 반드시 지정해야 합니다. +.TP +\fB\-\-files\fP[\fB=\fP\fI<파일>\fP] +\fI<파일>\fP에서 처리할 파일 이름을 읽습니다. \fI<파일>\fP을 생략하면 파일 이름은 표준 입력에서 +불러옵니다. 파일 이름은 개행 문자로 끝나야 합니다. 대시 문자(\fB\-\fP)는 일반 파일 이름으로 취급하며 표준 입력을 의미하지 +않습니다. 파일 이름을 명령행 인자로 지정하면, \fI<파일>\fP에서 파일 이름을 읽어들이기 전 해당 명령행 인자를 먼저 +처리합니다. +.TP +\fB\-\-files0\fP[\fB=\fP\fI<파일>\fP] +각 파일 이름이 널 문자로 끝나야 한다는 점만 제외하면 \fB\-\-files\fP[\fB=\fP\fI<파일>\fP] 옵션과 동일합니다. +. +.SS "기본 파일 형식 및 압축 옵션" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fI<형식>\fP +압축 또는 압축해제 파일 \fI<형식>\fP을 지정합니다: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +기본 값입니다. 압축할 때, \fBauto\fP는 \fBxz\fP의 기본 동작과 동일합니다. 압축을 해제할 때, 입력 파일 형식을 자동으로 +찾습니다. 참고로 원시 스트림(\fB\-\-format=raw\fP)의 경우 자동으로 찾을 수 없습니다. +.TP +\fBxz\fP +\&\fB.xz\fP 파일 형식으로 압축하거나, 압축 해제시 \fB.xz\fP 파일만 받아들입니다. +.TP +\fBlzma\fP, \fBalone\fP +이전 \fB.lzma\fP 파일 형식으로 압축하거나, 압축 해제시 \fB.lzma\fP 파일만 받아들입니다. \fBalone\fP 대체 명령은 LZMA +유틸리티 하위 호환성을 목적으로 제공합니다. +.TP +\fBlzip\fP +압축 해제시 \fB.lz\fP 파일만 받아들입니다. 압축은 지원하지 않습니다. +.IP "" +\&\fB.lz\fP 형식 버전 0과 1을 지원합니다. 버전 0파일은 \fBlzip\fP 1.3 이전에서만 만듭니다. 일반적이진 않지만 일부 파일의 +경우 이 형식의 원본 패키지로 보관한 파일을 찾을 수도 있습니다. 개인적으로 이 형식으로 압축한 오래된 개인 파일을 가지고 있을 수도 +있습니다. 형식 버전 0 압축 해제 지원은 \fBlzip\fP 1.18에서 제거했습니다. \fBlzip\fP 1.4 이후의 버전에서는 버전 1 +형식 파일을 만듭니다. +.TP +\fBraw\fP +원시 스트림으로 압축하거나 압축을 해제합니다(헤더 없음). 고급 사용자 전용입니다. 원시 스트림을 디코딩하려면, +\fB\-\-format=raw\fP 옵션을 사용하고 분명하게 필터 체인을 지정하여 컨테이너 헤더에 필요한 정보를 저장하게 끔 해야합니다. +.RE +.TP +\fB\-C\fP \fI<검사방식>\fP, \fB\-\-check=\fP\fI<검사방식>\fP +무결성 검사 방식을 지정합니다. 검사 방식은 \fB.xz\fP 파일에 저장하며 압축 해제 데이터를 계산합니다. 이 옵션은 \fB.xz\fP +형식으로 압축할 때만 효력이 있습니다: \fB.lzma\fP 형식은 무결성 겁사를 지원하지 않습니다. 무결성 검사는 \fB.xz\fP 파일 압축을 +풀었을 때에 검사합니다. +.IP "" +지원 \fI검사\fP 형식: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +어떤 경우에도 무결성 검사 계산을 수행하지 않습니다. 보통 바람직하지 못한 생각입니다. 데이터 무결성을 다른 방식으로라도 검증해야 +하는 상황이면 쓸만할 수 있습니다. +.TP +\fBcrc32\fP +IEEE\-802.3 (이더넷)의 다항 연산으로 CRC32를 계산합니다. +.TP +\fBcrc64\fP +ECMA\-182의 다항식 연산으로 CRC64를 계산합니다. 이 동작이 기본 동작이기 때문에 CRC32가 깨진 파일을 찾을 때보다는 좀 +낮은 편이며 속도 차이도 거의 없습니다. +.TP +\fBsha256\fP +SHA\-256 해시를 계산합니다. CRC32와 CRC64 보다는 좀 느립니다. +.RE +.IP "" +\&\fB.xz\fP 헤더 무결성은 항상 CRC32로 검증하빈다. 이를 바꾸거나 It is not possible to change or +disable it. +.TP +\fB\-\-ignore\-check\fP +압축 데이터를 압축해제할 경우 압축 데이터의 무결성 검증을 진행하지 않습니다. \fB.xz\fP 헤더의 CRC32 값은 그래도 여전히 보통 +방식으로 검증합니다. +.IP "" +\fB이 옵션이 정확히 무슨 동작을 하는지 알기 전에는 사용하지 마십시오.\fP 이 옵션을 사용하는 타당한 이유로: +.RS +.IP \(bu 3 +깨진 .xz 파일에서 데이터 복구를 시도합니다. +.IP \(bu 3 +압축 해제 속도를 늘립니다. SHA\-256 또는 압축 파일에 들어간 그 무언가를 엄청 빨리 처리합니다. 다른 방식으로 파일 무결성을 +검증해야 하는 목적이 아니라면 이 옵션을 사용하지 않는게 좋습니다. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +압축 사전 설정 수준을 선택합니다. 기본값은 \fB\-6\fP입니다. 다중 수준을 지정하면 가장 마지막 수준 옵션을 적용합니다. 개별 필터 +체인을 이미 지정했다면, 압축 사전 설정 수준 값을 설정할 때 개별 필터 체인을 정리합니다. +.IP "" +사전 설정간 차이는 \fBgzip\fP(1)과 \fBbzip2\fP(1)을 사용할 때보다 더 비중을 차지합니다. 선택한 압축 설정은 압축 해제시 +필요한 메모리 사용량을 셜정하므로 사전 설정 수준 값을 너무 높게 지정하면 RAM 용량이 적은 오래된 시스템에서 파일 압축 해제시 실패할 +수 있습니다. 게다가, \fBgzip\fP(1) 과 \fBbzip2\fP(1)에서 처럼 종종 \fB모든 동작에 \-9를 몰래 활용하는건 바람직하지 않습니다\fP. +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +동작이 빠른 사전 설정 부류입니다. \fB\-0\fP은 때로는 \fBgzip \-9\fP 명령보다 압축율이 훨씬 우수하면서도 더 빠릅니다. 더 큰 +값은 보통 \fBbzip2\fP(1) 명령과 비교했을 떄 압축 결과가 압축 데이터에 따라 달라지더라도, 비교할 법한 속도 또는 더 나은 +압축율을 보입니다. +.TP +\fB\-4\fP ... \fB\-6\fP +오래된 시스템에서 조차도 압축 해제 프로그램의 적절한 메모리 사용량을 보이면서 양호하거나 최적의 압축율을 보여줍니다. \fB\-6\fP 옵션은 +압축 해제시 메모리 사용량이 16MiB 밖에 안되기 때문에 파일을 배포할 때 최적의 선택인 기본 값입니다. (\fB\-5e\fP 또는 +\fB\-6e\fP도 역시 고려할 만합니다. \fB\-\-extreme\fP을 참고하십시오.) +.TP +\fB\-7 ... \-9\fP +\fB\-6\fP과 비슷하지만 압축 및 압축 해제시 요구 메모리 사용량이 더 높습니다. 압축 파일이 각각 8MiB, 16MiB, 32MiB +보다 클 경우에만 쓸만한 옵션입니다. +.RE +.IP "" +동일한 하드웨어에서, 압축 해제 속도는 압축한 데이터의 초당 정적 바이트 처리 수의 어림 평균입니다. 다시 말해, 압축율을 더 올리면, +압축 해제 속도도 역시 올라갑니다. 이는 곧 초당 비압축 데이터 출력 양이 달라질 수 있단 뜻입니다. +.IP "" +다음 표에 사전 설정 기능을 정리했습니다: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Preset;DictSize;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +컬럼 설명: +.RS +.IP \(bu 3 +DictSize는 LZMA2 딕셔너리 크기입니다. 압축 해제 파일의 크기보다 딕셔너리에서 사용하는 낭비 메모리 용량입니다. 실제로 +필요하지 않은 \fB\-7\fP ... \fB\-9\fP 사전 설정값을 피해야 하는 적절한 이유이기도 합니다. \fB\-6\fP 이하에서는 소모 메모리 양이 +충분히 적거나 따로 신경쓸 필요가 없습니다. +.IP \(bu 3 +CompCPU는 압축 속도에 영향을 주는 LZMA2 설정의 단순화 표기 값입니다. 딕셔너리 크기는 속도에도 영향을 주기 때문에 +CompCPU는 \fB\-6\fP ... \fB\-9\fP 수준값과 동일한데, 고수준 값은 여전히 조금 더 느려질 수 있습니다. 느려지는 만큼 +압축율은 가능한 한 더 좋아집니다. \fB\-\-extreme\fP을 참고하십시오. +.IP \(bu 3 +CompMem은 단일\-스레드 모드에서 필요한 압축 프로그램의 메모리 점유 용량입니다. \fBxz\fP 버전에 따라 다를 수 있습니다. +.IP \(bu 3 +DecMem은 압축 해제 프로그램의 메모리 점유용량입니다. 이는 곧, 압축 해제 프로그램에서 필요한 메모리 사용량을 압축 설정에서 +결정한다는 의미가 들어있습니다. 정확한 압축 해제 프로그램의 메모리 사용량은 LZMA2 딕셔너리 크기 보다는 조금 많지만 테이블의 값은 +MiB 용량으로 완전히 반올림한 값입니다. +.RE +.IP "" +다중\-스레드 모드에서 필요한 메모리 용량은 단일\-스레드 모드보단 약간 더 많습니다. \fB\-\-block\-size\fP 기본값에 따라, 각 +스레드에서는 3*3*딕셔녀리_크기 + 압축시_메모리용량 또는 압축_해제시_메모리용량 정도가 필요합니다. 예를 들면, 스레드 넷에 사전 +설정 옵션 \fB\-6\fP을 사용한다면, 660\(en670 MiB 메모리 용량이 필요합니다. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +기대하는 만큼의 좀 더 나은 압축율을 확보하려 선택한 압축 사전 설정 수준의 느린 변형 옵션을 사용하지만, 재수 없는 와중에 골로 가는 +경우가 생기기도 합니다. 압축 해제 프로그램의 메모리 사용에는 영향을 주지 않지만, 압축 프로그램의 메모리 사용량은 \fB\-0\fP +\&... \fB\-3\fP 사전 설정 수준에서 약간 더 올라갈 뿐입니다. +.IP "" +4MiB와 8MiB 두 가지 딕셔너리 용량 설정이 있기 때문에 \fB\-3e\fP 와 \fB\-5e\fP 사전 설정을 (CompCPU 수치를 낮춰서) +각각 \fB\-4e\fP 와 \fB\-6e\fP 보다 약간 더 빠르게 설정할 수 있습니다. 이런 식으로 두 사전 설정이 동일하지 않습니다. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Preset;DictSize;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +예를 들면, 8MiB 딕셔너리를 활용하는 네가지 사전 설정이 있다고 할 때, 빠른 순으로 설정을 나열하자면, \fB\-5\fP, \fB\-6\fP, +\fB\-5e\fP, \fB\-6e\fP 입니다. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +이 옵션은 \fB\-0\fP 과 \fB\-9\fP의 별칭으로 각각 오해할 수 있습니다. LZMA 유틸리티의 하위 호환성을 목적으로 제공합니다. 이 +옵션 사용은 피하십시오. +.TP +\fB\-\-block\-size=\fP\fI<크기>\fP +\&\fB.xz\fP 형식으로 압축할 때, 입력 데이터를 \fI<크기>\fP 바이트 블록으로 입력 데이터를 쪼갭니다. 각각의 블록은 +다중\-스레드 방식으로 처리할 수 있고 임의 접근 압축 해제 가능성을 제한할 수 있게 개별적으로 압축 처리합니다. 이 옵션은 보통 +다중\-스레드 모드에서 기본 블록 크기를 지정할 때 사용하지만, 단일\-스레드 모드에서도 사용할 수 있습니다. +.IP "" +다중\-스레드 모드에서는 약 3배 용량의 \fI<크기>\fP 바이트만큼 각 스레드 별로 입출력 버퍼링용 공간을 할당합니다. 기본 +\fI<크기>\fP는 LZMA2 딕셔너리 크기 또는 1MiB 중 가장 큰 쪽의 세 배입니다. 보통 적절한 값으로 LZMA2 +딕셔너리 크기 또는 최소한 1MiB 용량의 2\(en4배입니다. LZMA2 딕셔너리 크기보다 작은 \fI<크기>\fP는 램의 +소모적 사용 공간으로 할당하는데 LZMA2 딕셔너리 버퍼를 할당한 용량 크기 전체를 다 사용하지 않기 때문입니다. 다중\-스레드 모드에서 +블록 크기는 블록 헤더에 저장하며, 이 크기 정보는 다중\-스레드 압축 해제시 필요합니다. +.IP "" +단일\-스레드 모드에서는 기본적으로 블록 쪼개기를 하지 않습니다. 이 옵션을 설정한다고 해서 메모리 사용에 영향을 주지는 않습니다. +블록 헤더에 크기 정보를 저장하지 않기 때문에 단일\-스레드 모드에서 만든 파일은 다중\-스레드 모드에서 만든 파일과 동일하지 않습니다. +크기 정보의 누락은 또한 \fBxz\fP에서 다중\-스레드 모드로 압축 해제를 진행할 수 없음을 의미하기도 합니다. +.TP +\fB\-\-block\-list=\fP\fI<항목>\fP +\&\fB.xz\fP 형식으로 압축할 때, 압축하지 않은 데이터로 부터 일정 간격 이후에 새 블록 처리를 시작합니다. +.IP "" +\fI<항목>\fP은 쉼표로 구분한 목록으로 지정합니다. 각 항목은 콜론 (\fB:\fP)으로 구분한 0부터 9까지의 추가 필터 +체인 번호 값으로 이루어져 있으며, 압축하지 않은 데이터의 크기 값이 필요합니다. 항목을 생략하면(둘 이상의 쉼표 연속 표기) 이전 +항목의 크기와 필터를 활용하겠다는 함축 의미를 넣을 수 있습니다. +.IP "" +입력 파일이 \fI<항목>\fP 크기의 합보다 크면, 마지막 항목을 파일의 끝까지 반복합니다. 특별히 \fB0\fP 값을 마지막 +값으로 사용하여 파일 나머지 부분을 단일 블록으로 인코딩해야 한다는 의미를 나타낼 수도 있습니다. +.IP "" +\fB\-\-filters1=\fP\fI<필터>\fP \&...\& \fB\-\-filters9=\fP\fI<필터>\fP 옵션 조합으로 +각 블록별 별도 필터 체인을 지정할 수 있습니다. 이 옵션은 1\(en9번 필터 체인을 지정합니다. 필터 체인 0번은 필터 체인을 +지정하지 않았을 때와 동일한 기본 필터 체인으로 참조할 수 있습니다. 필터 체인 식별 번호는 비 압축 크기 앞에 콜론(\fB:\fP)을 붙여 +사용할 수 있습니다. 예를 들면, \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP 옵션을 +지정했을 경우 다음 규칙대로 블록을 만듭니다: +.RS +.IP \(bu 3 +\fB\-\-filters1\fP 필터 체인에서는 2MiB 입력을 +.IP \(bu 3 +\fB\-\-filters3\fP 필터 체인에서는 2MiB 입력을 +.IP \(bu 3 +\fB\-\-filters2\fP 필터 체인에서는 4MiB 입력을 +.IP \(bu 3 +\fB\-\-filters2\fP 필터 체인에서는 4MiB 입력을 +.IP \(bu 3 +기본 필터 체인에서는 2MiB 입력을 +.IP \(bu 3 +입력이 끝나기 전의 모든 블록에는 기본 필터 체인과 4MiB 입력을 적용합니다. +.RE +.IP "" +인코더 블록 크기를 초과하는 크기 값을 지정하면(스레드 모드 기본값 또는 \fB\-\-block\-size=\fP\fI<크기>\fP +옵션으로 지정한 값), 인코더는 \fI<크기>\fP 지정 용량 범위는 유지하면서 추가 블록을 만듭니다. 예를 들면 +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP 옵션을 지정하고 +입력 파일을 80MiB 용량으로 전달하면, 각각 5, 10, 8, 10, 2, 10, 10, 4, 10, 10, 1 MiB 용량을 +차지하는 블록 11개를 결과물로 내줍니다. +.IP "" +다중\-스레드 모드에서 블록 크기는 블록 헤더에 저장합니다. 단일\-스레드 모드에서는 저장하지 않기 때문에 인코딩 처리한 출력은 +다중\-스레드 모드의 출력 결과물과는 다릅니다. +.TP +\fB\-\-flush\-timeout=\fP\fI<제한시간>\fP +압축할 때, 이전 데이터를 소거하고 다음 입력을 블록 단위로 더 읽는데 \fI<제한시간>\fP 밀리초(양의 정수값)가 지났을 +경우, 대기중이던 모든 입력 데이터를 인코더에서 소거한 다음 출력 스트림에 전달합니다. 이런 동작은 네트워크로 스트리밍한 데이터를 +\fBxz\fP로 압축할 때 쓸만합니다. \fI<제한시간>\fP 값을 적게 지정하면 적은 지연 시간에 데이터를 받아낼 수 있지만 +\fI<제한시간>\fP 값을 크게 하면 압축율을 높일 수 있습니다. +.IP "" +이 기능은 기본적으로 꺼져있습니다. 이 옵션을 한번 이상 지정하면, 마지막 옵션의 값대로 동작합니다. 특별히 +\fI<제한시간>\fP 값을 \fB0\fP으로 설정하면 이 설정을 완전히 끌 수 있습니다. +.IP "" +이 기능은 POSIX 시스템이 아닌 곳에서는 사용할 수 없습니다. +.IP "" +.\" FIXME +\fB이 기능은 여전히 시험중입니다\fP. 현재로서는, \fBxz\fP 버퍼링 처리 방식 때문에 \fBxz\fP의 실시간 스트림 압축 해제 기능 활용은 +적절하지 않습니다. +.TP +\fB\-\-no\-sync\fP +원본 파일을 제거하기 전까지는 스토릿지 장치에 대상 파일과 디렉터리를 동기화하지 않습니다. 작은 여러 파일을 압축하거나 압축해제할 때 +성능을 개선할 수 있습니다. 그러나, 삭제 과정을 진행한 다음 시스템이 바로 치명적인 오류가 나타난다면, 대상 파일을 스토릿지 장치에 +저장하지 않았지만 삭제 동작이 이루어졌을 수도 있습니다. 이 경우 원본 파일 뿐만 아니라 대상 파일도 나타나지 않습니다. +.IP "" +이 옵션은 \fBxz\fP 프로그램이 원본 파일을 삭제할 때만 동작합니다. 다른 경우에는 전혀 동기화가 이루어지지 않습니다. +.IP "" +동기화 동작과 \fB\-\-no\-sync\fP 옵션은 \fBxz\fP 5.7.1alpha에 추가했습니다. +.TP +\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP +압축 수행시 메모리 사용 한계를 지정합니다. 이 옵션을 여러번 지정하면 마지막 값을 취합니다. +.IP "" +압축 설정이 \fI<제한용량>\fP을 초과하면, \fBxz\fP는 설정 값의 하향 조정을 시도하여 한계 값을 더이상 넘치지 않게 하고 +자동 조절을 끝냈다는 알림을 표시합니다. 조정은 다음 순서대로 진행합니다. 스레드 수를 줄입니다. 다중\-스레드 모드에서 스레드 하나의 +할당 한계치가 \fI<제한용량>\fP을 넘으면 단일\-스레드 모드로 전환합니다. 그 다음 마지막으로 LZMA2 딕셔너리 크기를 +줄입니다. +.IP "" +\fB\-\-format=raw\fP 또는 \fB\-\-no\-adjust\fP 미지정 상황에서 압축할 때, 압축 데이터 출력에 영향을 주지 않고 스레드 +처리 수만 줄일 수 있습니다. +.IP "" +\fI<제한용량>\fP 값이 아래 설명한 조건에 맞지 않으면, 오류가 나타나고 \fBxz\fP 명령은 종료 상태 1번을 반환하며 +빠져나갑니다. +.IP "" +\fI<제한용량>\fP 값은 여러 방식으로 지정할 수 있습니다: +.RS +.IP \(bu 3 +\fI<제한용량>\fP 값은 바이트 용량 절대값입니다. 정수 값을 사용하되 \fBMiB\fP와 같은 접미사를 사용하는게 좋습니다. +예: \fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +\fI<제한용량>\fP 값은 총 물리 메모리(RAM) 용량의 백분율로 지정할 수도 있습니다. 다른 컴퓨터끼리 공유하는 셸 +초기화 스크립트의 \fBXZ_DEFAULTS\fP 환경 변수에 값을 설정할 때 특히 쓸만합니다. 이런 방식으로 설정하면 시스템의 메모리 설치 +용량에 따라 자동으로 늘어납니다. 예: \fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +\fI<제한용량>\fP 값은 \fB0\fP 기본값으로 설정하여 초기화할 수 있습니다. 현재로서는 \fI<제한용량>\fP +값이 \fImax\fP(최대) (메모리 사용 한계 없음) 인 상태와 동일합니다. +.RE +.IP "" +\fBxz\fP 32비트 버전에서는 몇가지 특별한 경우가 있습니다. \fI<제한용량>\fP 값이 \fB4020MiB\fP를 넘으면 +\fI<제한용량>\fP을 \fB4020MiB\fP로 고정합니다. MIPS32에서는 \fB2000MiB\fP로 대신 고정합니다. +(\fB0\fP과 \fBmax\fP는 이 경우에 해당하지 않습니다. 압축 해제시 비슷한 기능은 없습니다.) 이 경우 32비트 실행 파일이 +4GiB(MIPS32의 경우 2GiB) 주소 영역에 접근할 때 매우 용이하며, 다른 경우에는 원하는대로 문제를 일으키지 않습니다. +.IP "" +\fB메모리 활용\fP 섹션도 참고하십시오. +.TP +\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP +압축 해제시 메모리 사용 한계 용량을 설정합니다. \fB\-\-list\fP 모드에도 영향을 줍니다. \fI<제한용량>\fP을 넘기지 +않고서는 동작이 진행이 안될 경우, \fBxz\fP 에서는 오류를 나타내고 파일 압축 해제를 실패로 +간주합니다. \fI<제한용량>\fP을 지정하는 가능한 방법에 대해서는 +\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션을 참고하십시오. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP +다중\-스레드 모드 압축 해제시 메모리 사용 한계 용량을 설정합니다. 스레드 수에 영향을 줄 수도 있습니다. \fBxz\fP에서 파일 압축 +해제를 거부하게 하진 않습니다. \fI<제한용량>\fP 수치가 다중\-스레드로 처리하기에 너무 낮다면, +\fI<제한용량>\fP 값을 무시하고 \fBxz\fP 동작을 단일\-스레드 모드로 계속 진행합니다. 참고로 +\fB\-\-memlimit\-decompress\fP 옵션도 사용하면, 단일\-스레드 모드와 다중\-스레드 모드 두 경우에 모두 적용하기에, +다중\-스레드 모드에 적용할 \fI<제한용량>\fP 값은 \fB\-\-memlimit\-decompress\fP에 설정하는 제한 값보다 더 +크면 안됩니다. +.IP "" +다른 메모리 사용 용량 제한 옵션과는 달리, \fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP 옵션은 +시스템별 기본 \fI<제한용량>\fP 값을 지닙니다. 현재 설정 값은 \fBxz \-\-info\-memory\fP 명령으로 확인해볼 수 +있습니다. +.IP "" +이 옵션과 기본 값은 한계 값을 주지 않으면 스레드 기반 압축 해제 프로그램이 일부 입력 파일에 대해 정신나간 수준의 메모리 용량을 +할당해서 동작이 끝나버릴 수 있습니다. 기본 \fI<제한용량>\fP이 시스템의 사양에 비해 낮다면, +\fI<제한용량>\fP 값을 자유롭게 올리시되, \fBxz\fP 에서 적은 스레드 수에도 메모리 공간 할당을 시도하는 만큼, 입력 +파일에 적절한 수준으로 가용 RAM 용량을 넘는 큰 값을 설정하지 마십시오. 메모리나 스와핑 영역 공간이 줄어들면 압축해제 성능을 +개선하지 못합니다. +.IP "" +\fI<제한용량>\fP 값을 지정하는 가능한 방법을 보려면 +\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션을 참고하십시오. \fI<제한용량>\fP 값을 +\fB0\fP으로 설정하면 \fI<제한용량>\fP 값이 시스템 지정 기본값으로 바뀝니다. +.TP +\fB\-M\fP \fI<제한용량>\fP, \fB\-\-memlimit=\fP\fI<제한용량>\fP, \fB\-\-memory=\fP\fI<제한용량>\fP +\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP +\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP +\fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP 지정과 동일합니다. +.TP +\fB\-\-no\-adjust\fP +압축 출력 결과에 영향을 주는 설정을 조정하지 않고는 메모리 사용 용량 제한 조건이 맞지 않으면 오류를 표시하고 빠져나갑니다. 이 +옵션은 \fBxz\fP가 다중\-스레드 모드에서 단일\-스레드 모드로 전환하고 LZMA2 딕셔너리 크기를 줄이는 동작을 막아줍니다. 심지어 이 +옵션을 사용하면 메모리 사용 한계를 만족하도록 스레드 수를 줄여 압축 결과물 출력에 영향이 가지 않게 합니다. +.IP "" +원시 스트림(\fB\-\-format=raw\fP)을 만들 떄 자동 조정은 항상 꺼집니다. +.TP +\fB\-T\fP \fI<스레드수>\fP, \fB\-\-threads=\fP\fI<스레드수>\fP +활용할 작업 스레드 수를 지정합니다. \fI<스레드수>\fP 값을 \fB0\fP 값으로 설정하면, \fBxz\fP는 시스템에서 지원하는 +최대 프로세서 스레드 수를 모두 확보합니다. 실제 스레드 수는 입력 파일이 주어진 설정대로 스레드 처리를 할 만큼 그렇게 크지 않을 +경우, 내지는 더 많은 스레드를 사용했을 때 메모리 사용량 한계를 초과할 경우 \fI<스레드수>\fP 보다 적을 수 있습니다. +.IP "" +단일\-스레드와 다중\-스레드 압축 프로그램은 다른 출력 결과물을 냅니다. 단일\-스레드 압축 프로그램은 작은 파일 크기 결과물을 내놓지만, +다중\-스레드 압축 프로그램의 경우 다중\-스레드 압축 프로그램에서 내놓은 결과물은 다중\-스레드로만 압축을 해제할 수 있습니다. +\fI<스레드수>\fP를 \fB1\fP로 설정하면 단일\-스레드 모드를 사용합니다. \fI<스레드수>\fP를 \fB0\fP과 다른 +값으로 설정하면, 시스템에서 실제로 하드웨어 스레드가 1개만 지원한다 하더라도, 다중\-스레드 압축 프로그램을 사용합니다. (\fBxz\fP +5.2.x에서는 이 경우 단일\-스레드 모드를 활용합니다.) +.IP "" +단일\-스레드로 다중\-스레드 모드를 사용하려면, \fI<스레드수>\fP를 \fB+1\fP로 설정하십시오. \fB+\fP 접두사는 \fB1\fP +이외의 값에는 영향을 주지 않습니다. 메모리 사용량 한계 설정은 \fBxz\fP을 \fB\-\-no\-adjust\fP 옵션을 쓰기 전까지는 +단일\-스레드로 전환하게 합니다. \fB+\fP 접두사 지원은 \fBxz\fP 5.4.0에 추가했습니다. +.IP "" +자동 스레드 수를 요청했고 메모리 사용 한계를 지정하지 않았다면, 시스템에 맞게끔 가능한 스레드 수를 제한하는 기본 소프트 제한 값을 +사용합니다. 스레드 수가 한개가 되면 무시하는 이런 개념이 소프트 제한이기에, \fBxz\fP로 하여금 압축 동작 및 압축 해제 동작 수행시 +멈추지 않습니다. 이 가본 소프트 제한 값은 \fBxz\fP 실행 도중 다중\-스레드 모드에서 단일\-스레드 모드로 바뀌게 하지는 않습니다. +활성 제한 값은 \fBxz \-\-info\-memory\fP 명령으로 볼 수 있습니다. +.IP "" +현재 스레딩 처리 방식은 입력을 블록 단위로 쪼개고 각각의 블록을 독립적으로 압축하는 동작을 취합니다. 기본 블록 크기는 압축 수준에 +따라 다르며 \fB\-\-block\-size=\fP\fI<크기>\fP 옵션으로 재지정할 수 있습니다. +.IP "" +스레드 압축 해제 방식은 여러 블록이 블록 헤더에 넣은 크기 정보와 함께 들어간 파일에만 동작합니다. 다중\-스레드 모드에서 압축한 +충분히 큰 모든 파일은 이 조건에 만족하지만, 단일\-스레드 모드에서 압축한 파일은 +\fB\-\-block\-size=\fP\fI<크기>\fP 옵션을 지정하더라도 조건에 만족하지 않습니다. +.IP "" +\fI스레드\fP 기본 값은 \fB0\fP입니다. \fBxz\fP 5.4.x 이전의 기본값은 \fB1\fP입니다. +. +.SS "개별 압축 필터 체인 설정" +개별 필터 체인은 사전 설정에 엮인 설정에 의존하는 대신 압축 설정을 세부적으로 하나하나 설정할 수 있게 합니다. 개별 필터 체인을 +지정하면, 명령행에 앞서 지정한 사전 설정 옵션(\fB\-0\fP \&...\& \fB\-9\fP 과 \fB\-\-extreme\fP)은 무시합니다. 사전 +설정 옵션을 하나 이상의 필터 체인 옵션 다음에 지정하면, 새 사전 설정을 취하며, 앞서 지정한 개별 필터 체인 옵션은 무시합니다. +.PP +필터 체인은 명령행 파이핑에 비교할 수 있습니다. 압축할 때, 압축하지 않은 입력을 첫번째 필터로 놓고, 출력 대상(이 있으면)을 다음 +필터로 지정합니다. 최종 필터의 출력은 압축 파일로 기옥합니다. 체인의 최대 필터 수는 4이지만, 필터 체인상 필터 갯수는 보통 +1~2개입니다. +.PP +수많은 필터가 필터 체인 상에서 제약점을 가지고 있습니다. 일부 필터는 체인의 마지막 필터로만 동작하며, 일부 다른 필터는 마지막이 아닌 +필터로, 어떤 동작은 체인의 어떤 위치에든 둡니다. 필터에 따라, 이 제한은 필터 설계를 따르거나 보안 문제를 막기 위해 존재하기도 +합니다. +.PP +개별 필터 체인은 두가지 방식으로 지정할 수 있습니다. \fB\-\-filters=\fP\fI<필터>\fP와 +\fB\-\-filters1=\fP\fI<필터>\fP \&...\& \fB\-\-filters9=\fP\fI<필터>\fP 옵션으로 +liblzma 필터 문자열 문법에 따라 한가지 옵션을 필터 체인 전체를 지정할 수 있습니다. 대신, 하나 이상의 개별 필터 옵션을 +원하는 필터 체인 순서대로 지정할 수도 있습니다. 이 말인 즉슨, 개별 필터 옵션의 순서가 중요하단 뜻입니다! 원시 스트림을 디코딩할 +때(\fB\-\-format=raw\fP), 압축했을 때 지정했던 필터와 같은 순서로 필터 체인을 지정해야 합니다. 전체 체인 +옵션(\fB\-\-filters=\fP\fI<필터>\fP) 보다 우선 지정한 개별 필터 또는 사전 설정 옵션은 까먹을 수도 있습니다. +전체 체인 옵션 다음에 개별 필터를 지정할 경우 필터 체인의 동작을 무효로 합니다. +.PP +필터는 쉼표로 구분하는 필터별 \fI<옵션>\fP이 있습니다. \fI<옵션>\fP에 추가로 입력한 쉼표는 +무시합니다. 모든 옵션 값에는 기본값이 있어, 값을 바꾸려면 지정해야합니다. +.PP +전체 필터 체인과 \fI<옵션>\fP을 보려면 \fBxz \-vv\fP (\fB\-\-verbose\fP 두 번)명령을 사용하십시오. 이 +명령은 사전 설정이 사용하는 필터 체인 옵션도 볼 수 있습니다. +.TP +\fB\-\-filters=\fP\fI<필터>\fP +전체 필터 체인 또는 사전 설정을 단일 옵션으로 지정합니다. 각 필터는 공백 문자 또는 대시 문자 두번 입력(\fB\-\-\fP)으로 +구분합니다. 셸 명령행에서 \fI필터\fP는 따옴표로 감싸서 단일 옵션으로 해석하도록 해야 합니다. \fI옵션\fP을 표기하려면 \fB:\fP 또는 +\fB=\fP을 활용하십시오. 사전 설정 앞에 \fB\-\fP를 붙일 수 있고 0개 또는 하나 이상의 플래그를 붙일 수 있습니다. 유일하게 +지원하는 플래그는 \fB\-\-extreme\fP과 동일한 \fBe\fP입니다. +.TP +\fB\-\-filters1\fP=\fI<필터>\fP ... \fB\-\-filters9\fP=\fI<필터>\fP +\fB\-\-block\-list\fP와 사용할 수 있는 추가 필터 체인을 최대 9개까지 지정합니다. +.IP "" +예를 들어 텍스트 파일과 실행 파일의 아카이브를 압축할 때 실행 부분에 BCJ 필터 체인을 사용하고 텍스트 부분은 LZMA2 필터를 +사용할 수 있습니다. +.TP +\fB\-\-filters\-help\fP +\fB\-\-filters\fP와 \fB\-\-filters1=\fP\fI<필터>\fP \&...\& +\fB\-\-filters9=\fP\fI<필터>\fP 옵션의 사전 설정 필터와 개별 설정 필터 체인을 지정하는 방법을 설명하는 도움말 +메시지를 출력하고 완전히 빠져나갑니다. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fI<옵션>\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fI<옵션>\fP] +.PD +LZMA1 또는 LZMA2 필터를 필터 체인에 추가합니다. 이 필터는 필터 체인의 마지막 요소로만 사용할 수 있습니다. +.IP "" +LZMA1은 고전 필터로, LZMA1만 지원하는 고전 \fB.lzma\fP 파일 형식에서만 지원합니다. LZMA2는 LZMA1의 업데이트 +버전으로 LZMA1의 실질적 문제를 해결했습니다. \fB.xz\fP 형식은 LZMA2 필터를 사용하며 LZMA1 필터는 전적으로 지원하지 +않습니다. 압축 속도와 압축율은 LZMA1과 LZMA2가 실질적으로 동일합니다. +.IP "" +LZMA1과 LZMA2는 동일한 \fI<옵션>\fP 집합을 공유합니다: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fI<사전설정>\fP +LZMA1 또는 LZMA2의 모든 \fI<옵션>\fP을 \fI<사전설정>\fP으로 +초기화합니다. \fI<사전설정>\fP 값은 정수 값으로 이루어져 있으며, 사전 설정에 변형을 줄 떄 단일 문자가 따라올 수도 +있습니다. 정수 값은 \fB0\fP에서 \fB9\fP 까지이며, 명령행 옵션에서 \fB\-0\fP \&...\& \fB\-9\fP로 대응합니다. 변형 옵션으로 +지원하는 문자는 현재 \fBe\fP 뿐이며, \fB\-\-extreme\fP에 대응합니다. \fI<사전설정>\fP 값을 지정하지 않으면, +LZMA1 또는 LZMA2 기본값을 사전 설정 \fB6\fP에서 가져온 \fI<옵션>\fP으로 취합니다. +.TP +\fBdict=\fP\fI<크기>\fP +딕셔너리(기록 버퍼) \fI<크기>\fP는 최근 처리한 비압축 데이터를 바이트 단위로 메모리에 얼마나 유지하는지 나타냅니다. +알고리즘은 비압축 데이터상 바이트 시퀀스(일치 항목) 반복 탐색을 시도하며, 해당 부분을 딕셔너리의 현재 참조로 치환합니다. 딕셔너리가 +크면 일치하는 항목을 찾을 기회가 더 많아집니다. 따라서, 딕셔너리 \fI<크기>\fP를 더욱 크게 설정하면 압축율을 증가할 +수는 있지만, 압축하지 않은 파일보다 딕셔너리가 크면 메모리 낭비율이 올라갑니다. +.IP "" +보통 딕셔너리 \fI<크기>\fP는 64KiB 에서 64MiB 정도 됩니다. 최소 4KiB 입니다. 압축시 최대 용량은 현재 +1.5GiB(1536MiB)로 나타납니다. 압축 해제 프로그램에도 4GiB 미만으로 딕셔너리 크기를 이미 지원하며 4GiB 라는 수치는 +LZMA1과 LZMA2 스트림 형식의 최대값입니다. +.IP "" +딕셔너리 \fI<크기>\fP와 검색기(\fImf\fP)는 LZMA1 또는 LZMA 인코더의 메모리 사용량을 함께 결정합니다. +동일한(또는 더 큰) 딕셔너리 \fI<크기>\fP가 데이터를 압축했을 때만큼 압축 해제할 떄 필요하기 때문에, 디코더의 메모리 +사용량은 압축할 때의 딕셔너리 크기로 결정합니다. \fB.xz\fP 헤더에는 딕셔너리 \fI<크기>\fP를 2^\fIn\fP 또는 +2^\fIn\fP + 2^(\fIn\fP\-1) 으로 저장하기에, 이 \fI<크기>\fP 값을 압축할 때 선호하는 편입니다. 다른 +\fI<크기>\fP 값은 \fB.xz\fP 헤더에 저장할 때 반올림합니다. +.TP +\fBlc=\fP\fIlc\fP +리터럴 컨텍스트 비트 수를 지정합니다. 최소 값은 0이고 최대 값은 4입니다. 기본 값은 3입니다. 추가로, \fIlc\fP 값과 +\fIlp\fP 값의 합은 4를 넘으면 안됩니다. +.IP "" +조건이 일치하지 않아 인코딩할 수 없는 모든 바이트는 리터럴로 인코딩합니다. 이 말인 즉슨, 간단히 8비트 바이트로서의 리터럴을 한번에 +하나씩 인코딩합니다. +.IP "" +리터럴 코딩을 할 때 이전 비압축 바이트와 다음 바이트와의 관련성을 가진 가장 많은 \fIlc\fP 비트 수를 가정합니다. 예를 들면, 보통 +영문 문장의 경우 대문자 다음에 종종 소문자가 오고, 소문자 다음에 다른 소문자가 따라옵니다. US\-ASCII 문자 세트에서는 가장 긴 +비트 3개는 대문자에 대해 010, 소문자에 대해 011입니다. \fIlc\fP 값이 최소한 3이면, 리터럴 코딩시 비압축 데이터에 대해 +이런 속성의 장점을 취할 수 있습니다. +.IP "" +(어쨌거나) 기본값 (3)은 보통 적절합니다. 최대 압축을 원한다면 \fBlc=4\fP 값을 시험해보십시오. 때로는 약간 도움이 되기도 +하겠지만, 오히려 결과가 안좋을 수도 있습니다. 결과가 엄한 방향으로 간다면, \fBlc=2\fP 값도 시험해보십시오. +.TP +\fBlp=\fP\fIlp\fP +리터럴 위치 비트 수를 지정하빈다. 최소 값은 0이고 최대 값은 4입니다. 기본 값은 0입니다. +.IP "" +\fIlp\fP 값은 리터럴 인코딩 진행시 비압축 데이터 정렬 방식 고려에 영향을 줍니다. 정렬 방식에 대한 자세한 정보는 하단 \fIpb\fP를 +참고하십시오. +.TP +\fBpb=\fP\fIpb\fP +위치 비트 수를 지정합니다. 최소 값은 0이며 최대 값은 4입니다. 기본값은 2입니다. +.IP "" +\fIpb\fP 값은 보통 압축하지 않은 데이터에 어떤 정렬 방식을 고려하느냐에 영향을 줍니다. 기본적으로 4바이트 +정렬(2^\fIpb\fP=2^2=4)을 의미하는데, 이보다 더 나은 추측 값이 없어서 종종 최적의 선택으로 간주합니다. +.IP "" +정렬 상태를 알지 못할 경우, \fIpb\fP 설정 값이 파일 크기를 조금 줄일 수 있습니다. 예를 들면, 텍스트 파일이 단일 바이트 단위로 +정돈된 상태(US\-ASCII, ISO\-8859\-*, UTF\-8)라면, \fBpb=0\fP 설정 값으로 압축율을 조금 개선할 수 있습니다. +UTF\-16 텍스트의 경우, \fBpb=1\fP 설정 값이 좋은 선택입니다. 정렬 바이트가 3 바이트 같은 홀수 바이트일 경우, +\fBpb=0\fP 설정 값이 최적의 선택일지도 모릅니다. +.IP "" +가정 정렬을 \fIpb\fP 값과 \fIlp\fP 값으로 조정하긴 하지만, LZMA1과 LZMA2는 여전히 16바이트 정렬 방식으로 선호합니다. +LZMA1 또는 LZMA2로 종종 압축하는 파일 형식이라고 하면 고려해볼만 합니다. +.TP +\fBmf=\fP\fImf\fP +일치 검색기는 인코더 속도, 메모리 사용량, 압축율에 주된 영향을 줍니다. 보통 해시 체인 검색기는 이진 트리 검색기보다 빠르긴 +합니다. 기본 값은 \fI<사전설정>\fP에 따라 다릅니다. 0은 \fBhc3\fP을, 1\(en3은 \fBhc4\fP를, 나머지는 +\fBbt4\fP를 활용합니다. +.IP "" +다음 검색 필터를 지원합니다. 메모리 사용 공식은 \fIdict\fP 값이 2의 승수일 경우 실제에 가까운 근사치입니다. +.RS +.TP +\fBhc3\fP +2바이트, 3바이트 해싱 체인 +.br +\fInice\fP 최소값: 3 +.br +메모리 사용: +.br +\fIdict\fP * 7.5 (조건: \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 5.5 + 64 MiB (조건: \fIdict\fP > 16 MiB) +.TP +\fBhc4\fP +2바이트, 3바이트, 4바이트 해싱 체인 +.br +\fInice\fP 최소값: 4 +.br +메모리 사용: +.br +\fIdict\fP * 7.5 (조건: \fIdict\fP <= 32 MiB); +.br +\fIdict\fP * 6.5 (조건: \fIdict\fP > 32 MiB) +.TP +\fBbt2\fP +2바이트 해싱 이진 트리 +.br +\fInice\fP 최소값: 2 +.br +메모리 사용: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +2바이트, 3바이트 해싱 이진트리 +.br +\fInice\fP 최소값: 3 +.br +메모리 사용: +.br +\fIdict\fP * 11.5 (조건: \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 9.5 + 64 MiB (조건: \fIdict\fP > 16 MiB) +.TP +\fBbt4\fP +2바이트, 3바이트, 4바이트 해싱 이진 트리 +.br +\fInice\fP 최소값: 4 +.br +메모리 사용: +.br +\fIdict\fP * 11.5 (조건: \fIdict\fP <= 32 MiB); +.br +\fIdict\fP * 10.5 (조건: \fIdict\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fI<모드>\fP +압축 \fI<모드>\fP 값은 일치 검색기에서 생산하는 데이터 분석 방식을 지정합니다. 지원하는 \fI<모드>\fP는 +\fBfast\fP와 \fBnormal\fP 입니다. 기본값은 \fI<사전설정>\fP값 0\(en3에 대해 \fBfast\fP, +\fI<사전설정>\fP값 4\(en9에 대해 \fBnormal\fP입니다. +.IP "" +보통 \fBfast\fP는 해시 체인 검색기에서 사용하며 \fBnormal\fP은 이진 트리 검색기에서 사용합니다. 이 동작은 또한 +\fI<사전설정>\fP 값이 할 일이기도 합니다. +.TP +\fBnice=\fP\fInice\fP +일치하는 nice 길이를 지정합니다. 최소한 \fInice\fP 바이트 정도 일치하면, 알고리즘이 가능한 최선의 부분을 찾는 동작을 +멈춥니다. +.IP "" +\fInice\fP 값은 2\(en273 바이트입니다. 값이 클 수록 속도 면에서는 손해를 보겠지만 압축율은 더욱 올라갑니다. 기본 값은 +\fI<사전설정>\fP값에 따라 다릅니다. +.TP +\fBdepth=\fP\fI<깊이>\fP +일치 검색기에서의 최대 검색 깊이를 지정합니다. 기본값은 특별한 값 0으로 지정하며, 이 값으로 압축 프로그램이 \fImf\fP 와 +\fInice\fP간 적절한 \fI<깊이>\fP 값을 결정합니다. +.IP "" +적절한 해시 체인 \fI<깊이>\fP 값은 이진 트리에서 4\(en100 그리고 16\(en1000 입니다. 상당히 큰 값을 +\fI<깊이>\fP 값으로 사용하면 일부 파일에 대해 인코더가 매우 느리게 동작할 수가 있습니다. 압축 시간이 너무 오래걸려서 +동작을 중간에 끊을 준비가 되지 않은 이상 \fI<깊이>\fP 설정 값은 1000을 넘지 않게하십시오. +.RE +.IP "" +원시 스트림(\fB\-\-format=raw\fP)을 디코딩할 때, LZMA2는 딕셔너리 \fI<크기>\fP만 필요합니다. LZMA1는 +\fIlc\fP, \fIlp\fP, \fIpb\fP 값이 모두 필요합니다. +.TP +\fB\-\-x86\fP[\fB=\fP\fI<옵션>\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIoptions\fP] +.PD +브랜치/호출/점프(BCJ) 필터를 필터 체인에 추가합니다. 이 필터는 필터 체인의 비종결 필터로만 사용할 수 있습니다. +.IP "" +BCJ 필터는 머신 코드의 상대 주소를 절대 주소로 변환합니다. 데이터 크기를 바꾸지는 않지만 LZMA2에서 \fB.xz\fP 파일을 +0\(en15% 정도 줄여주게 하는 중복성이 늘어납니다. BCJ 필터는 언제든 뒤집을 수 있어, 데이터에 적절하지 않은 BCJ 필터 +형식을 활용하면, 그냥 가만히 두면 압축율이 약간 떨어지게 한다 하더라도, 데이터를 잃을 수가 있습니다. BCJ 필터는 굉장히 빠르며 +메모리 공간을 적게 활용합니다. +.IP "" +이 BCJ 필터에는 압축율 관련 몇가지 문제가 있습니다: +.RS +.IP \(bu 3 +실행 코드가 들어있는 몇가지 파일 형식(예: 목적 파일, 정적 라이브러리, 리눅스 커널 모듈)의 경우 필터 값으로 채운 명령 주소가 +있습니다. 여기 BCJ 필터의 경우 파일의 압축율을 떨어뜨리는 주소 변환을 수행합니다. +.IP \(bu 3 +BCJ 필터를 아카이브에 적용하면, BCJ 필터를 사용하지 않았을 때보다 압축율이 떨어질 수가 있습니다. 예를 들면, 유사하거나 동일한 +실행 파일 여럿이 있으면 필터를 사용하여 파일을 덜 비슷하게 만들어 압축율이 떨어지게 합니다. 동일한 아카이브 파일에서 비 실행 파일의 +내용에 대해서도 비슷한 일이 벌어질 수 있습니다. 실제로 하나는 BCJ 필터를 걸고 하나는 제외하여 각 경우에 대해 어떤 경우가 결과가 +우수한 지 살펴보겠습니다. +.RE +.IP "" +다른 명령 세트는 다른 정렬 상태에 놓여있습니다. 실행 파일은 필터가 제대로 동작하게 하려면 입력 데이터에 있는 이 값의 배수로 +정돈해야합니다. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +필터;정렬;참고 +x86;1;32\-bit 또는 64\-bit x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096 바이트 정렬이 가장 좋습니다 +PowerPC;4;빅엔디안 전용 +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +BCJ 필터를 사용한 데이터는 LZMA2로 보통 압축하기 때문에 LZMA2 옵션을 선택한 BCJ 필터의 정렬기준에 맞추도록 설정하면 +압축율을 좀 더 개선할 수 있습니다. 예를 들면: +.RS +.IP \(bu 3 +IA\-64 필터는 16\-바이트 정렬 방식으로 동작하기에 LZMA2 필터에 \fBpb=4,lp=4,lc=0\fP 옵션(2^4=16)을 주는게 +좋습니다. +.IP \(bu 3 +RISC\-V 코드에는 16\-비트 압축 명령(C 확장) 적재 여부에 따라 2\-바이트 또는 4\-바이트 정렬 방식을 채택합니다. 16\-비트 +명령을 사용하면, \fBpb=2,lp=1,lc=3\fP 또는 \fBpb=1,lp=1,lc=3\fP 옵션 값 사용이 바람직합니다. 16\-비트 명령이 +없다면, \fBpb=2,lp=2,lc=2\fP 옵션 값을 활용하는게 좋습니다. "RVC"가 "Flags"행에 나타나는지 확인할 때 +\fBreadelf \-h\fP 명령을 사용할 수 있습니다. +.IP \(bu 3 +ARM64는 항상 4\-바이트 정렬 방식을 택하기에 \fBpb=2,lp=2,lc=2\fP 옵션 값을 활용하는게 좋습니다. +.IP \(bu 3 +x86 필터는 예외입니다. x86 실행 파일을 압축할 경우에는 보통 LZMA2 기본 옵션 값(\fBpb=2,lp=0,lc=3\fP)을 그대로 +사용하는게 좋습니다. +.RE +.IP "" +모든 BCJ 필터는 동일한 \fI옵션\fP을 지원합니다: +.RS +.TP +\fBstart=\fP\fI<오프셋>\fP +상대 주소와 절대 주소를 변환할 때 사용할 시작 \fI<오프셋>\fP을 지정합니다. \fI<오프셋>\fP에는 필터 +정렬 배수여야 합니다(상단 테이블 참조). 기본값은 0입니다. 실제로 기본값이 낫습니다. 개별 \fI<오프셋>\fP 지정 +값은 거의 쓸모가 없습니다. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fI<옵션>\fP] +필터 체인에 델타 필터를 추가합니다. 델타 필터는 필터 체인에서 마지막에 지정하지 않은 필터로만 사용할 수 있습니다. +.IP "" +현재로서는 바이트 단위 단순 델타계산 결과만 보여줍니다. 예를 들면, 압축하지 않은 비트맵 그림 또는 압축하지 않은 PCM 오디오를 +압축할 때 쓸만합니다. 그러나 특별한 목적으로 활용하는 알고리즘은 델타 + LZMA2 보다 더 나은 결과를 가져다 주기도 합니다. +이는 특히 오디오의 경우 맞는 이야기인데, \fBflac\fP(1)의 경우 더 빠르고 우수한 압축율을 보여줍니다. +.IP "" +지원 \fI옵션\fP: +.RS +.TP +\fBdist=\fP\fI<차이>\fP +바이트 단위 델터 계산 \fI<차이>\fP를 지정합니다. \fI<차이>\fP값은 1\(en256 이어야합니다. 기본 +값은 1입니다. +.IP "" +예를 들어, \fBdist=2\fP 옵션과 A1 B1 A2 B3 A3 B5 A4 B7 입력 값을 주면, 출력 값은 A1 B1 01 02 01 +02 01 02 입니다. +.RE +. +.SS "기타 옵션" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +경고 및 알림을 끕니다. 두 번 지정하면 오류 메시지 표시도 끕니다. 이 옵션은 종료 상태에 영향을 주지 않습니다. 경고 표시를 +끄더라도, 종료 상태에서는 여전히 경고가 나타났음을 알려줍니다. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +출력 내용이 많아집니다. 표준 오류를 터미널에 연결했다면 \fBxz\fP는 진행 표시를 나타냅니다. \fB\-\-verbose\fP를 두번 지정하면 +더 많은 내용을 표시합니다. +.IP "" +진행 표시에서는 다음 정보를 나타냅니다: +.RS +.IP \(bu 3 +입력 파일의 크기를 알고 있을 경우 완료 백분율. 파이프 처리시에는 백분율을 나타낼 수 없습니다. +.IP \(bu 3 +산출 압축 데이터 용량 (압축) 또는 소모 공간 용량 (압축 해제). +.IP \(bu 3 +비압축 데이터 소모 용량 (압축) 또는 산출 용량 (압축 해제). +.IP \(bu 3 +압축 데이터 산출 용량을 비압축 데이터 처리 용량으로 나누어 계산한 압축율. +.IP \(bu 3 +압축 또는 압축 해제 속도. 초당 비압축 데이터 소모량(압축) 또는 산출 용량(압축 해제)를 측정한 값입니다. \fBxz\fP에서 파일 +처리를 시작한 몇 초 후 나타납니다. +.IP \(bu 3 +경과 시간 형식은 M:SS 또는 H:MM:SS 입니다. +.IP \(bu 3 +추산 여분 시간은 \fBxz\fP가 파일을 처리하기 시작한 이후 입력 파일의 크기를 알고 몇 초가 지난 후에야 보여줍니다. 시간은 콜론 +문자를 사용하지 않고 덜 자세한 형식으로, 예를 들면, 2분 30초 와 같은 형식으로 보여줍니다. +.RE +.IP "" +표준 오류가 터미널이 아니라면 \fB\-\-verbose\fP는 \fBxz\fP에서 파일 이름, 압축 크기, 압축 해제 용량, 압축율, 그리고 +가능하다면 파일을 압축 또는 압축 해제한 후 표준 오류로 속도와 걸린 시간을 나타내도록 합니다. 속도와 걸린 시간 정보는 동작을 +처리하는데 최소한 몇초 정도 소요했을 경우에만 들어갑니다. 동작이 끝나지 않았다면, 이를테면 사용자의 중단 요청이 있었을 경우 입력 +파일의 크기를 알고 있을 때 압축 백분율 정보도 들어갑니다. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +경고로 알릴 만한 상황을 만났다 하더라도 종료 상태 2번을 설정하지 않습니다. 이 옵션은 출력 수준에 영향을 주지 않기 때문에, +\fB\-\-quiet\fP 옵션과 \fB\-\-no\-warn\fP 옵션을 경고 표시를 막고 종료 상태를 바꾸지 않을 목적으로 사용합니다. +.TP +\fB\-\-robot\fP +머신에서 해석할 형식으로 메시지를 나타냅니다. liblzma 대신 \fBxz\fP를 활용하려는 다양상 스크립트로서의 프론트엔드를 쉽게 +작성하도록 하기 위함입니다. 이 옵션을 지정한 출력은 \fBxz\fP 릴리스가 어떻게 되든 안정 버전이란 의미입니다. 자세한 내용은 +\fB로봇 모드\fP 섹션을 참고하십시오. +.TP +\fB\-\-info\-memory\fP +압축 및 압축 해제시 물리 메모리 용량 (RAM), \fBxz\fP에서 파악하는 프로세서 스레드 갯수, 메모리 사용량 한계를 파악하기 쉬운 +형식으로 나타내고 무사히 나갑니다. +.TP +\fB\-h\fP, \fB\-\-help\fP +보통 사용하는 옵션을 설명하는 도움말 메시지를 출력한 후, 완전히 빠져나갑니다. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +\fBxz\fP의 모든 기능을 설명하는 도움말 메시지를 출력한 후, 완전히 빠져나갑니다 +.TP +\fB\-V\fP, \fB\-\-version\fP +\fBxz\fP와 liblzma 버전 번호를 가독 형식으로 출력합니다. 기계 해석 가능 형식을 가져오려면 \fB\-\-version\fP 앞에 +\fB\-\-robot\fP을 지정하십시오. +. +.SH "로봇 모드" +로봇 모드는 \fB\-\-robot\fP 옵션으로 동작합니다. \fBxz\fP 출력을 다른 프로그램에서 해석하기 쉽게 해줍니다. 현재로서는 +\fB\-\-robot\fP 옵션은 \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, \fB\-\-version\fP +옵션하고만 사용할 수 있습니다. 앞으로는 압축 및 압축 해제 동작에 대해서도 지원합니다. +. +.SS "목록 모드" +\fBxz \-\-robot \-\-list\fP 명령은 탭으로 구분한 출력 형태를 활용합니다. 모든 행의 첫번째 컬럼에는 해당 행에서 찾을 수 +있는 정보의 형식을 나타냅니다: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +이 행은 항상 파일 목록 시작 부분의 첫번째 줄에 있습니다. 이 행의 두번째 컬럼에 파일 이름이 들어있습니다. +.TP +\fBfile\fP +이 행에는 \fB.xz\fP 파일의 전반적인 정보가 들어있습니다. 이 행은 항상 \fBname\fP 행 다음에 있습니다. +.TP +\fBstream\fP +이 행 형식은 \fB\-\-verbose\fP 옵션을 지정했을 때만 사용합니다. \fB.xz\fP 파일의 \fBstream\fP 행 수만큼 나타납니다. +.TP +\fBblock\fP +이 행 형식은 \fB\-\-verbose\fP 옵션을 지정했을 때만 사용합니다. \fB.xz\fP 파일의 블록 수만큼 \fBblock\fP 행이 +나타납니다. \fBblock\fP 행은 모든 \fBstream\fP 행 다음에 나타납니다. 다른 형식의 행이 끼어들지는 않습니다. +.TP +\fBsummary\fP +이 행 형식은 \fB\-\-verbose\fP 옵션을 두번 지정했을 때만 사용합니다. 이 행은 모든 \fBblock\fP 행 다음에 출력합니다. +\fBfile\fP 행과 비슷하게, \fBsummary\fP 행에는 \fB.xz\fP 파일의 전반적인 정보가 담겨있습니다. +.TP +\fBtotals\fP +이 행은 목록 출력의 가장 마지막에 항상 나타납니다. 총 갯수와 크기를 나타냅니다. +.PP +\fBfile\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +파일 스트림 갯수 +.IP 3. 4 +스트림의 블록 총 갯수 +.IP 4. 4 +파일 압축 크기 +.IP 5. 4 +파일 압축 해제 크기 +.IP 6. 4 +예를 들면, \fB0.123\fP과 같은 압축율 입니다. 비율이 9.999라면, 대시 문자 3개 (\fB\-\-\-\fP)를 비율 값 대신 나타냅니다. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +쉼표로 구분한 무결성 검사 이름 목록입니다. \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP, \fBSHA\-256\fP 문자열을 알려진 +검사 형식으로 사용합니다. 알 수 없는 검사 형식에 대해서는 \fBUnknown\-\fP\fIN\fP을 사용하며, 여기서 \fIN\fP은 (한 두자리) +정수형 숫자값으로 이루어진 검사 ID 입니다. +.IP 8. 4 +파일의 스트림 패딩 총 길이 +.RE +.PD +.PP +\fBstream\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +스트림 번호 (첫 스트림은 1번) +.IP 3. 4 +스트림의 블록 총 갯수 +.IP 4. 4 +압축 시작 오프셋 +.IP 5. 4 +비압축 시작 오프셋 +.IP 6. 4 +압축 크기 (스트림 패딩 미포함) +.IP 7. 4 +압축 해제 용량 +.IP 8. 4 +압축율 +.IP 9. 4 +무결성 검사 이름 +.IP 10. 4 +스트림 패딩 길이 +.RE +.PD +.PP +\fBblock\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +이 블록이 들어간 스트림 갯수 +.IP 3. 4 +스트림 시작 부분의 블록 번호 (첫번째 블록은 1번) +.IP 4. 4 +파일 시작 부분의 블록 번호 +.IP 5. 4 +파일 시작 부분의 압축 시작 오프셋 +.IP 6. 4 +파일 시작 부분의 비압축 시작 오프셋 +.IP 7. 4 +총 블록 압축 크기 (헤더 포함) +.IP 8. 4 +압축 해제 용량 +.IP 9. 4 +압축율 +.IP 10. 4 +무결성 검사 이름 +.RE +.PD +.PP +\fB\-\-verbose\fP를 두 번 지정하면, 추가 컬럼을 \fBblock\fP 행에 넣습니다. \fB\-\-verbose\fP 단일 지정시에는 이 +정보를 볼 때 탐색을 여러번 수행해야 하기 때문에 실행 과정이 느려질 수 있어서 나타내지 않습니다: +.PD 0 +.RS +.IP 11. 4 +16진수 무결성 검사값 +.IP 12. 4 +블록 헤더 크기 +.IP 13. 4 +블록 플래그: \fBc\fP는 압축 크기가 현재 값임을 나타내고, \fBu\fP는 압축 전 원본 크기가 현재 값임을 나타냅니다. 플래그를 설정하지 +않았다면, 문자열 길이를 유지할 목적으로 대시 \fB\-\fP 를 대신 나타냅니다. 새 플래그는 나중에 문자열 끝 부분에 추가할 예정입니다. +.IP 14. 4 +블록에 압축 해서 넣은 데이터의 실제 츠기 (블록 헤더, 블록 패딩, 검사 필드 제외) +.IP 15. 4 +이 \fBxz\fP 버전에서 이 블록의 압축을 해제할 때 필요한 (바이트 단위) 메모리 용량 +.IP 16. 4 +필터 체인. 대부분 사용하는 옵션은 압축 해제시 필요한 옵션만을 \fB.xz\fP 헤더에 저장하기 때문에 압축 시간에 알 수 없습니다. +.RE +.PD +.PP +\fBsummary\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +이 \fBxz\fP 버전에서 이 파일 압축을 해제할 때 필요한 (바이트 단위) 메모리 용량 +.IP 3. 4 +모든 블록 헤더에 압축 크기와 압축 전 원본 크기 정보가 들어갔는지 여부를 나타내는 \fByes\fP 또는 \fBno\fP 값 +.PP +\fBxz\fP \fI5.1.2alpha\fP \fI부터:\fP +.IP 4. 4 +파일 압축 해제시 필요한 최소 \fBxz\fP 버전 +.RE +.PD +.PP +\fBtotals\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +스트림 갯수 +.IP 3. 4 +블록 갯수 +.IP 4. 4 +압축 크기 +.IP 5. 4 +압축 해제 용량 +.IP 6. 4 +평균 압축율 +.IP 7. 4 +파일에 들어 있어 쉼표로 구분한 무결성 검사 이름 목록 +.IP 8. 4 +스트림 패딩 길이 +.IP 9. 4 +파일 갯수. \fBfile\fP 행의 컬럼 순서를 따라갑니다. +.PD +.RE +.PP +\fB\-\-verbose\fP 옵션을 두 번 지정하면, \fBtotals\fP 행에 추가 컬럼이 들어갑니다: +.PD 0 +.RS +.IP 10. 4 +이 \fBxz\fP 버전에서 파일 압축을 해제할 떄 필요한 (바이트 단위) 최대 메모리 사용량 +.IP 11. 4 +모든 블록 헤더에 압축 크기와 압축 전 원본 크기 정보가 들어갔는지 여부를 나타내는 \fByes\fP 또는 \fBno\fP 값 +.PP +\fBxz\fP \fI5.1.2alpha\fP \fI부터:\fP +.IP 12. 4 +파일 압축 해제시 필요한 최소 \fBxz\fP 버전 +.RE +.PD +.PP +차후 버전에서는 새 행 형식을 추가하고 기존 행 형식에 추가할 수 있는 새 컬럼을 넣기 까지는 알 수 있겠지만, 기존 컬럼은 바꾸지 않을 +예정입니다. +. +.SS "필터 도움말" +\fBxz \-\-robot \-\-filters\-help\fP 는 다음 형식의 지원 필터 목록을 출력합니다: +.PP +\fI<필터>\fP\fB:\fP\fI<옵션>\fP\fB=<\fP\fI값\fP\fB>,\fP\fI<옵션>\fP\fB=<\fP\fI값\fP\fB>\fP... +.TP +\fI<필터>\fP +필터 이름 +.TP +\fI<옵션>\fP +필터별 옵션 이름 +.TP +\fI<값>\fP +숫자 \fI값\fP 범위는 \fB<\fP\fI최소\fP\fB\-\fP\fI최대\fP\fB>\fP입니다. 문자열 \fI값\fP은 \fB< >\fP 범위 +내에서 선택하며 \fB|\fP 문자로 구분합니다. +.PP +각 필터는 한 줄에 하나씩 출력합니다. +. +.SS "메모리 제한 정보" +\fBxz \-\-robot \-\-info\-memory\fP 명령은 탭으로 나뉜 여러 컬럼을 단일 행으로 나타냅니다: +.IP 1. 4 +물리 메모리(RAM)의 바이트 단위 총량. +.IP 2. 4 +압축 진행시 바이트 단위 메모리 사용 한계값 (\fB\-\-memlimit\-compress\fP). 특수 값 \fB0\fP은 단일\-스레드 모드에서 +제한을 두지 않는 기본 설정임을 나타냅니다. +.IP 3. 4 +압축 해제시 바이트 단위 메모리 사용 한계값 (\fB\-\-memlimit\-decompress\fP). 특수 값 \fB0\fP은 단일\-스레드 모드에서 +제한을 두지 않는 기본 설정임을 나타냅니다. +.IP 4. 4 +\fBxz\fP 5.3.4alpha 이후: 다중\-스레드 기반 압축 해제시 바이트 단위 메모리 +사용량(\fB\-\-memlimit\-mt\-decompress\fP). 분명하게 제한을 걸어두지 않았을 경우 5번째 컬럼에 나타난 시스템별 +기본값을 사용하기 때문에 0 값을 지정하면 안됩니다. 또한 \fB\-\-memlimit\-mt\-decompress\fP로 세번째 컬럼 값보다 더 +크게 지정을 한다 할지라도 이 값이 세번째 컬럼 값보다 크면 안됩니다. +.IP 5. 4 +\fBxz\fP 5.3.4alpha 이후: A system\-specific default memory usage limit that is +used to limit the number of threads when compressing with an automatic +number of threads (\fB\-\-threads=0\fP) and no memory usage limit has been +specified (\fB\-\-memlimit\-compress\fP). This is also used as the default value +for \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +\fBxz\fP 5.3.4alpha 이후: Number of available processor threads. +.PP +차후, \fBxz \-\-robot \-\-info\-memory\fP 출력에는 더 많은 내용이 들어가지만, 한 줄 이상은 넘어가지 않습니다. +. +.SS 버전 +\fBxz \-\-robot \-\-version\fP 은 \fBxz\fP 와 liblzma의 버전 번호를 다음 형식으로 나타냅니다: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +주 버전. +.TP +\fIYYY\fP +부 버전. 짝수가 안정 버전입니다. 홀수는 알파 또는 베타 버전입니다. +.TP +\fIZZZ\fP +안정 릴리스의 패치 수준 또는 개발 릴리스의 횟수입니다. +.TP +\fIS\fP +안정도. 0은 알파 버전, 1은 베타 버전을 나타내며, 2는 안정 버전을 나타냅니다. \fIS\fP는 \fIYYY\fP 값이 짝수라 해도 항상 +2여야 합니다. +.PP +\fBxz\fP 명령과 liblzma이 동일한 XZ 유틸리티 릴리스에서 나왔다면 두 행의 \fIXYYYZZZS\fP 값은 같습니다. +.PP +예제: 4.999.9beta는 \fB49990091\fP이며, 5.0.0은 \fB50000002\fP입니다. +. +.SH "종료 상태" +.TP +\fB0\fP +모든 상태 양호. +.TP +\fB1\fP +오류 발생. +.TP +\fB2\fP +눈여겨볼 경고가 나타났지만, 실제 오류는 일어나지 않음. +.PP +표준 오류에 출력하는 알림(경고 또는 오류 아님)는 종료 상태에 영향을 주지 않습니다. +. +.SH 환경 +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP는 빈칸으로 구분한 옵션 값 목록을 \fBXZ_DEFAULTS\fP, \fBXZ_OPT\fP 환경 변수에서 순서대로, 명령행에서 옵션을 +해석하기 전에 불러옵니다. 참고로 환경 변수에서 옵션만 해석하며, 옵션이 아닌 부분은 조용히 무시합니다. 해석은 +\fBgetopt_long\fP(3)으로 가능하며, 명령행 인자로 활용하기도 합니다. +.PP +\fB경고:\fP 환경 변수를 설정하면, 프로그램과 \fBxz\fP를 실행하는 스크립트의 동작이 바뀝니다. 대부분의 경우 메모리 사용 제한량, +스레드 수, 압축 옵션을 환경 변수로 설정하는게 안전합니다. 그러나 일부 옵션은 스크립트의 동작을 망가뜨릴 수 있습니다. 분명한 +예제로는 \fBxz\fP에서 파일의 압축 및 해제 대신 도움말 내용을 표시하는 \fB\-\-help\fP 옵션이 있습니다. 좀 더 묘한 예제로는 +\fB\-\-quiet\fP 와 \fB\-\-verbose\fP 옵션이 있습니다. 대부분의 경우 \fB\-\-verbose\fP 옵션을 사용하여 프로세스 상황을 +표시하는데 잘 동작하지만, 어떤 경우에는 추가 메시지가 나타나는 문제가 있습니다. 출력 상세 수준은 \fB\-\-list\fP의 동작에도 영향을 +줍니다. +.TP +\fBXZ_DEFAULTS\fP +사용자별, 시스템 범위 기본 옵션입니다. 보통 \fBxz\fP의 메모리 사용량 제한을 기본으로 걸어두거나 기본 스레드 수를 설정할 경우 셸 +초기화 스크립트에 설정합니다. 셸 초기화 스크립트와 별도의 유사한 경우를 제외하고라면, 스크립트에서는 \fBXZ_DEFAULTS\fP 환경 +변수를 설정하지 않거나 설정을 해제해야합니다. +.TP +\fBXZ_OPT\fP +\fBxz\fP 명령행으로 옵션 설정 값을 직접 전달할 수 없을 경우 \fBxz\fP에 옵션을 전달하는 환경 변수입니다. 예를 들어, \fBxz\fP를 +스크립트 또는 도구에서 실행할 경우 GNU \fBtar\fP(1) 라면: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +예를 들면, 스크립트에서 \fBXZ_OPT\fP 를 활용하여, 스크립트별로 기본 압축 옵션을 지정할 수 있습니다. 적절한 이유가 있다면 +\fBXZ_OPT\fP 옵션 값을 사용자가 바꾸는걸 추천합니다. 예를 들면, \fBsh\fP(1) 스크립트에서 다음처럼 활용할 수도 있습니다: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "LZMA 유틸리티 호환성" +\fBxz\fP의 명령행 문법은 실제로 LZMA 유틸리티 4.32.x에서 찾을 수 있는 \fBlzma\fP, \fBunlzma\fP \fBlzcat\fP의 +상위 집합입니다. 대부분의 경우 LZMA 유틸리티를 XZ 유틸리티로 기존에 작성한 스크립트를 깨지 않고도 바꿀 수 있습니다. 몇가지 +비호환성 문제 때문에 문제가 일어날 수는 있습니다. +. +.SS "압축 사전 설정 단계" +압축 수준 사전 설정의 번호 부여 방식은 \fBxz\fP와 LZMA 유틸리티가 동일하지 않습니다. 가장 중요한 차이는 다른 사전 설정에 대해 +딕셔너리 크기를 어떻게 대응했느냐 여부입니다. 딕셔너리 크기는 압축 해제시 메모리 사용량과 거의 비슷합니다. +.RS +.PP +.TS +tab(;); +c c c +c n n. +단계;xz;LZMA 유틸리티 +\-0;256 KiB;없음 +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +딕셔너리 크기 차이는 압축 프로그램 메모리 사용에 영향을 주지만, LZMA 유틸리티와 XZ 유틸리티에서 사용량이 늘어나는 다른 차이점이 +있습니다: +.RS +.PP +.TS +tab(;); +c c c +c n n. +단계;xz;LZMA 유틸리티 4.32.x +\-0;3 MiB;없음 +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +XZ 유틸리티의 기본 사전 설정 수준값은 \fB\-6\fP이지만 LZMA 유틸리티의 기본 사전 설정 수준값은 \fB\-7\fP입니다. 두 프로그램의 +딕셔너리 메모리 기본 사용량은 8MiB입니다. +. +.SS "스트림 vs 비스트림 .lzma 파일" +파일을 압축하지 않은 크기는 \fB.lzma\fP 헤더에 저장합니다. LZMA 유틸리티는 일반 파일을 압축할 때 압축하지 않은 파일의 크기를 +저장합니다. 이 대신 압축하지 않은 크기를 '알 수 없음' 으로 저장하고 압축 해제 프로그램이 멈춰야 할 지점에 +end\-of\-payload 마커를 사용하는 방법도 있습니다. LZMA 유틸리티는 파이프로 들어온 입력과 같이 압축하지 않은 파일의 +크기를 알 수 없을 때 이런 방식을 활용합니다. +.PP +\fBxz\fP는 \fB.lzma\fP 파일을 end\-of\-payload 마커의 유무와 관계없이 압축 해제 방식을 모두 지원하지만, \fBxz\fP로 +만든 모든 \fB.lzma\fP 파일은 end\-of\-payload 마커를 사용하며, \fB.lzma\fP 헤더에 압축하지 않은 파일 크기를 '알 수 +없음'으로 표기합니다. 이 방식은 드문 상황에서 문제를 야기할 수 있습니다. 예를 들면, 임베디드 장치의 \fB.lzma\fP 압축 해제 +프로그램은 압축을 해제했을 때 크기를 알아야 동작합니다. 이 문제를 만나면, LZMA 유틸리티 또는 LZMA SDK를 활용하여 +\&\fB.lzma\fP 파일에 압축 전 파일 크기 정보를 저장해야합니다. +. +.SS "지원하지 않는 .lzma 파일" +\&\fB.lzma\fP 형식은 \fIlc\fP 값을 8까지 받아들이며, \fIlp\fP 값은 4까지 받아들입니다. LZMA 유틸리티는 어떤 \fIlc\fP 값과 +\fIlp\fP 값을 받아들이고도 압축을 해제할 수 있지만, 파일을 만들 때는 늘 \fBlc=3\fP 값과 \fBlp=0\fP 값을 활용합니다. 다른 +\fIlc\fP 값과 \fIlp\fP 값으로의 파일 압축은 \fBxz\fP와 LZMA SDK에서만 가능합니다. +.PP +liblzma의 LZMA1 필터 구현체에서는 \fIlc\fP 값과 \fIlp\fP 값의 합이 4를 넘어가면 안됩니다. 그래서 \fB.lzma\fP +파일의 경우 이 제한을 넘어가면 \fBxz\fP로 압축을 해제할 수 없습니다. +.PP +LZMA 유틸리티는 2^\fIn\fP (2의 승수)크기를 지닌 딕셔너리를 가진 \fB.lzma\fP 파일만 만들지만 받아들이는 파일의 딕셔너리 +크기는 어떤 크기든 상관 없습니다. liblzma에서는 2^\fIn\fP, 2^\fIn\fP + 2^(\fIn\fP\-1) 딕셔너리 크기를 가진 +\&\fB.lzma\fP 파일 만 받아들입니다. 이로 인해 \fB.lzma\fP 파일을 확인할 때 거짓 양성율이 늘어납니다. +.PP +모든 \fB.lzma\fP 파일을 liblzma 에서 받아들일 수 있도록 압축하기 때문에 이 제한이 실제로는 문제가 되지 않습니다. +. +.SS "뒤따라오는 쓰레기 값" +압축 해제할 때, LZMA 유틸리티는 \fB.lzma\fP 스트림 처음 부분 다음 나머지를 다 조용히 무시합니다. 대부분의 경우, +버그입니다. LZMA 유틸리티에서 \fB.lzma\fP 결합 파일 압축 해제를 지원하지 않음을 의미하기도 합니다. +.PP +\&\fB.lzma\fP 스트림 처음부분 바로 다음에 데이터가 남아있을 경우, \fBxz\fP 에서는 \fB\-\-single\-stream\fP 옵션을 사용하지 +않으면 깨진 파일로 간주합니다. 이 동작으로 하여금 뒤따라오는 쓰레기 값을 무시하도록 간주하는 애매한 스크립트 동작을 깰 수가 +있습니다. +. +.SH 참고 +. +.SS "출력 결과물이 달라짐" +압축하지 않은 입력 파일로부터 얻어낸 정확한 압축 출력 결과물은 압축 옵션이 완전히 동일하더라도 XZ 유틸리티의 버전에 따라 달라질 수 +있습니다. 파일 형식에 영향을 주지 않고 인코더 그 자체를 개선(더 빠르게 하거나 더 나은 압축율로)하기 때문입니다. XZ 유틸리티 +버전이 동일하더라도 빌드 옵션을 달리하여 빌드 상태가 제각각인 경우 출력 결과물이 달라질 수 있습니다. +.PP +\fB\-\-rsyncable\fP 기능을 넣었을 경우 동일한 xz 버전에서 이전 파일과 새 파일로 별도로 압축하지 않는 한 결과 파일을 (두 +파일이 서로 다른 파일이 아니므로) rsync 처리할 필요가 없습니다. 이 문제는 인코더 구현체 기능 개발이 끝나서 xz 버전이 +다르더라도 안정적인 rsync 가능한 출력 결과물을 유지할 수 있을 때여야 해결할 수 있습니다. +. +.SS "내장 .xz 압축 해제 프로그램" +XZ 임베디드와 같은 내장 \fB.xz\fP 압축 해제 구현체는 지원 파일의 무결성 \fI검사\fP 형식을 \fInone\fP과 \fIcrc32\fP 이외의 +설정으로 만들 필요가 없습니다. 기본값이 \fB\-\-check=crc64\fP일 경우에만, 임베디드 시스템에서 파일을 만들 때 +\fB\-\-check=none\fP 또는 \fB\-\-check=crc32\fP 옵션을 사용해야합니다. +.PP +임베디드 시스템이 아니라면, 모든 \fB.xz\fP 형식 압축 해제 프로그램에서는 모든 \fI검사\fP 형식을 지원하거나, 일부 \fI검사\fP 방식을 +지원하지 않는다면, 최소한, 무결성 검사로 검증하지 않고 압축을 해제할 수 있습니다. +.PP +XZ 임베디드는 BCJ 필터를 지원하지만, 기본 시작 오프셋만 지정할 수 있습니다. +. +.SH 예제 +. +.SS 기본 +\fIfoo\fP 파일을 기본 압축 수준 (\fB\-6\fP) 으로 \fIfoo.xz\fP 파일에 압축해 넣고, 압축 과정이 무사히 끝나면 \fIfoo\fP를 +삭제합니다: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +\fIbar.xz\fP를 \fIbar\fP 에 압축을 해제한 후 압축 해제가 무사히 끝나도 \fIbar.xz\fP를 삭제하지 않습니다: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +기본 사전 설정 \fB\-6\fP 보다는 느리지만, 압축 및 압축 해제시 메모리를 적게 차지(각각 48\ Mib, 5\MiB)는 \fB\-4e\fP +사전 설정(\fB\-4 \-\-extreme\fP)을 활용하여 \fIbaz.tar.xz\fP 파일을 만듭니다: +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +압축 및 비압축 파일을 단일 명령으로 표준 출력에 압축해제할 수 있습니다: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "다중 파일 병렬 압축" +GNU와 *BSD에서는 \fBfind\fP(1) 명령과 \fBxargs\fP(1) 명령으로 여러 파일의 압축을 병렬 처리할 수 있습니다: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +\fBxargs\fP(1) 의 \fB\-P\fP 옵션으로 \fBxz\fP 프로세스의 병렬 처리 갯수를 지정합니다. \fB\-n\fP 옵션의 최적 값은 압축할 +파일 수에 달려있습니다. 압축할 파일이 몇개밖에 없다면 1이어야합니다. 파일이 수천 수만개 정도 된다면 \fBxargs\fP(1) 이 +어쨌든지간에 만들어낼 \fBxz\fP 프로세스의 겟수를 100으로 하거나 아니면 적당한 값을 지정하여 줄이는게 좋습니다. +.PP +\fBxz\fP에 \fB\-T1\fP옵션을 지정하면 단일\-스레드 모드로 강제합니다. \fBxargs\fP(1) 에서 병렬 처리 갯수를 제어할 수 있기 +때문입니다. +. +.SS "로봇 모드" +여러 파일을 압축한 후 저장할 바이트 용량을 계산합니다: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +이 스크립트에서는 충분히 최신의 \fBxz\fP 명령을 사용하는지 알아보려 합니다. 다음 \fBsh\fP(1) 스크립트에서는 \fBxz\fP 도구의 +버전 번호가 최소한 5.0.0인지 여부를 검사합니다. 이 방식은 \fB\-\-robot\fP 옵션을 지원하지 않는 오래된 베타 버전과도 호환성이 +있습니다: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +\fBXZ_OPT\fP 환경 변수로 압축 해제시 메뢰 사용량 한계를 설정하지만, 한계 값을 이미 설정했다면, 값을 늘리지 않습니다: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "개별 압축 필터 체인 설정" +개별 설정 필터 체인의 초단순 사용방식은 LZMA2 사전 설정 값을 별도로 설정하는 방식입니다. 사전 설정은 잠재적으로 쓸만한 압축 +설정 조합만 다루기 때문에 꽤 쓸모가 있을 수도 있습니다. +.PP +\fB\-0\fP ... \fB\-9\fP 옵션의 설명에서 테이블의 CompCPU 컬럼과 \fB\-\-extreme\fP 옵션은 LZMA2 사전 설정을 +개별적으로 맞췄을 때 쓸만할 수도 있습니다. 여기 관련내용을 테이블 둘로 정리해서 모아보았습니다: +.RS +.PP +.TS +tab(;); +c c +n n. +Preset;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +어떤 파일을 압축할 때 상당히 큰 딕셔너리(예: 32MiB)가 필요 하다는걸 알아채셨지만, \fBxz \-8\fP 명령이 압축할 때보다 더 빠른 +속도로 압축하려 한다면, 더 큰 딕셔너리 사용을 위해 더 낮은 CompCPU 사전 설정 값(예: 1)으로 수정할 수 있습니다: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +각 파일에 대해, 위 명령은 압축율이 더 좋아지면서도 \fBxz \-6\fP보다 더 빨라집니다. 그러나, CompCPU 값을 낮게 유지하는 +대신 큰 딕셔너리에서 일부 파일을 강조해야 합니다. 큰 딕셔너리가 대부분의 도움을 주는 매우 명백한 상황에서는 최소한 몇 메가바이트의 +매우 유사한 각 파일이 아카이브에 들어갑니다. 딕셔너리 크기는 LZMA2가 연속으로 존재하는 각 파일의 유사성으로부터 얻는 장점을 취할 +수 있을 때 일부 개별 파일보다 훨씬 더 커집니다. +.PP +압축 프로그램과 압축 해제 프로그램에서 메모리를 엄청 많이 사용해도 상관 없고, 파일을 수백 메가 바이트 메모리 용량을 활용하여 +압축한다면, \fBxz \-9\fP 명령에 64MiB 용량을 초과하는 딕셔너리를 사용할 수 있게 하는 방법도 쓸만할 지도 모릅니다: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +위 예제에서와 같이 \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) 옵션을 사용하면 압축 및 압축 해제 과정에서 필요한 메모리 +용량을 살펴보는데 요긴할 수 있습니다. 압축 해제한 파일 크기보다 더 큰 딕셔너리를 사용하면 불필요한 메모리 소모량이 발생하여 위 +명령이 작은 파일에는 쓸모 없음을 기억하십시오. +.PP +때로는 압축 시간이 딱히 상관이 없을 수도 있습니다만, 압축 해제시 메모리 사용량을 적게 유지해야 할 수도 있습니다. 예를 들면, +임베디드 시스템에서 파일 압축을 해제할 수도 있습니다. 다음 명령의 경우 \fB\-6e\fP (\fB\-6 \-\-extreme\fP) 옵션을 기반 +옵션을 사용하며 딕셔너리 크기를 64KiB만 사용하도록 제한합니다. 결과 파일은 XZ 임베디드(이게 \fB\-\-check=crc32\fP +옵션이 있는 이유)로 100KiB 메모리 용량을 활용하여 풀어낼 수 있습니다. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +가능한 한 수 바이트를 더 쥐어 짜내고 싶을 때, 리터럴 문맥 비트 수(\fIlc\fP)와 위치 비트 수(\fIpb\fP)를 조정하면 도움이 될 +수도 있습니다. 리터럴 위치 비트 수(\fIlp\fP)를 조금 건드리는 것 또한 도움이 될 지도 모르겠지만 보통 \fIlc\fP 값과 \fIpb\fP +값이 더 중요합니다. 예를 들면, 소스 코드 저장 파일에는 US\-ASCII 텍스트가 대부분이기에, 다음과 같은 경우는 \fBxz \-6e\fP +명령을 실행했을 때부다는 아주 약간(거의 0.1% 수준) 작은 파일을 얻어낼 수도 있습니다(\fBlc=4\fP를 빼고도 시도해보십시오): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +LZMA2와 다른 필터를 함께 사용하면 일부 파일 형식에 대해 압축율을 개선할 수 있습니다. 예를 들면 x86\-32 또는 x86\-64 +공유 라이브러리를 x86 BCJ 필터를 활용하여 압축할 경우: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +참고로 필터 옵션의 순서는 상당히 중요합니다. \fB\-\-x86\fP을 \fB\-\-lzma\fP 이전에 지정하면 \fBxz\fP에서 오류가 나는데, +LZMA2 다음에는 어떤 필터든 설정할 수 없고, 옵션 체인상 마지막 필터로 x86 BCJ 필터를 사용할 수 없기 때문입니다. +.PP +LZMA2와 델타 필터는 비트맵 그림에 최적의 결과를 가져다줄 수 있습니다. PNG에 보통 안성맞춥인데, PNG에는 단순 델타 필터보단 +약간 더 고급진 필터를 사용하지만, 실제 압축을 진행할 때는 Deflate를 사용하기 때문입니다. +.PP +예를 들어 이미지를 압축하지 않은 비압축 TIFF로 저장해야 하는 경우가 있습니다. 델타 필터의 거리 매개변수는 그림에서 픽셀당 바이트 +수에 일치하도록 설정합니다. 예를 들면, 24비트 RGB 비트맵의 경우 \fBdist=3\fP 거리 매개변수 값을 설정해야 하며, LZMA2 +압축시 3바이트 정렬을 따르도록 \fBpb=0\fP 값을 전달하는 방법도 바람직합니다: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +여러 이미지를 단일 아카이브로 넣고 싶다면(예: \fB.tar\fP), 모든 이미지에 대해 동일한 픽셀당 바이트 수가 들어가는 경우에도 델타 +필터가 동작합니다. +. +.SH "추가 참조" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ 유틸리티: +.br +XZ 임베디드: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzcmp.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzcmp.1 new file mode 100644 index 0000000000000000000000000000000000000000..8921034b872e2bef6e5cdcaa1a76d774fe6d8e64 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzcmp.1 @@ -0,0 +1,52 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Korean translation for the xz-man +.\" Seong-ho Cho , 2023, 2024. +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 2025\-03\-06 Tukaani "XZ 유틸리티" +.SH 이름 +xzcmp, xzdiff, lzcmp, lzdiff \- 압축 파일을 비교합니다 +. +.SH 요약 +\fBxzcmp\fP [\fI<옵션>...\fP] \fI<파일1>\fP [\fI<파일2>\fP] +.br +\fBxzdiff\fP \&... +.br +\fBlzcmp\fP \&... (사용 안 함) +.br +\fBlzdiff\fP \&... (사용 안 함) +. +.SH 설명 +\fBxzcmp\fP 와 \fBxzdiff\fP 명령은 압축 해제한 두 파일의 내용을 비교합니다. 압축 해제한 파일의 데이터와 옵션은 +\fB\-\-help\fP 옵션 또는 \fB\-\-version\fP 옵션을 지정하지 않는다면, \fBcmp\fP(1) 또는 \fBdiff\fP(1) 명령으로 +전달합니다. +.PP +\fI<파일1>\fP 과 \fI<파일2>\fP를 모두 지정했다면, 지정한 파일은 이미 압축해제한 파일이거나, +\fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), \fBlz4\fP(1) 명령으로 +압축해제할 수 있는 형식의 파일일 수 있습니다. 필요한 압축 해제 명령은 \fI<파일1>\fP 과 +\fI<파일2>\fP의 파일 이름 확장자로 결정합니다. 알 수 없는 확장자를 지닌 파일은 이미 압축을 해제했거나 +\fBxz\fP(1) 명령으로 압축 해제할 수 있는 형식으로 간주합니다. +.PP +파일 이름을 하나만 지정한다면, \fI<파일1>\fP의 확장자는 지원 압축 형식의 확장자여야 하며, +\fI<파일2>\fP는 \fI<파일1>\fP에서 압축 파일 확장자를 제거한 파일로 간주합니다. +.PP +\fBlzcmp\fP와 \fBlzdiff\fP 명령은 LZMA 유틸리티 하위 호환용으로 제공합니다. 해당 명령은 오래되어 이후 버전에서 +제거합니다. +. +.SH "종료 상태" +압축 해제 오류가 나타나는 경우, 종료 코드는 \fB2\fP입니다. 그렇지 않을 경우 \fBcmp\fP(1) 또는 \fBdiff\fP(1) 명령의 +종료 코드를 활용합니다. +. +.SH "추가 참조" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzdiff.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzdiff.1 new file mode 100644 index 0000000000000000000000000000000000000000..8921034b872e2bef6e5cdcaa1a76d774fe6d8e64 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzdiff.1 @@ -0,0 +1,52 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Korean translation for the xz-man +.\" Seong-ho Cho , 2023, 2024. +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 2025\-03\-06 Tukaani "XZ 유틸리티" +.SH 이름 +xzcmp, xzdiff, lzcmp, lzdiff \- 압축 파일을 비교합니다 +. +.SH 요약 +\fBxzcmp\fP [\fI<옵션>...\fP] \fI<파일1>\fP [\fI<파일2>\fP] +.br +\fBxzdiff\fP \&... +.br +\fBlzcmp\fP \&... (사용 안 함) +.br +\fBlzdiff\fP \&... (사용 안 함) +. +.SH 설명 +\fBxzcmp\fP 와 \fBxzdiff\fP 명령은 압축 해제한 두 파일의 내용을 비교합니다. 압축 해제한 파일의 데이터와 옵션은 +\fB\-\-help\fP 옵션 또는 \fB\-\-version\fP 옵션을 지정하지 않는다면, \fBcmp\fP(1) 또는 \fBdiff\fP(1) 명령으로 +전달합니다. +.PP +\fI<파일1>\fP 과 \fI<파일2>\fP를 모두 지정했다면, 지정한 파일은 이미 압축해제한 파일이거나, +\fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), \fBlz4\fP(1) 명령으로 +압축해제할 수 있는 형식의 파일일 수 있습니다. 필요한 압축 해제 명령은 \fI<파일1>\fP 과 +\fI<파일2>\fP의 파일 이름 확장자로 결정합니다. 알 수 없는 확장자를 지닌 파일은 이미 압축을 해제했거나 +\fBxz\fP(1) 명령으로 압축 해제할 수 있는 형식으로 간주합니다. +.PP +파일 이름을 하나만 지정한다면, \fI<파일1>\fP의 확장자는 지원 압축 형식의 확장자여야 하며, +\fI<파일2>\fP는 \fI<파일1>\fP에서 압축 파일 확장자를 제거한 파일로 간주합니다. +.PP +\fBlzcmp\fP와 \fBlzdiff\fP 명령은 LZMA 유틸리티 하위 호환용으로 제공합니다. 해당 명령은 오래되어 이후 버전에서 +제거합니다. +. +.SH "종료 상태" +압축 해제 오류가 나타나는 경우, 종료 코드는 \fB2\fP입니다. 그렇지 않을 경우 \fBcmp\fP(1) 또는 \fBdiff\fP(1) 명령의 +종료 코드를 활용합니다. +. +.SH "추가 참조" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzegrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzegrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..1953e55b7ca83e45d6ae1adbf39ed80317e913ee --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzegrep.1 @@ -0,0 +1,85 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Korean translation for the xz-man +.\" Seong-ho Cho , 2023, 2024. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 2025\-03\-06 Tukaani "XZ 유틸리티" +.SH 이름 +xzgrep \- 패턴을 활용하여 가능한 방식으로 압축한 파일의 내용을 검색합니다 +. +.SH 요약 +\fBxzgrep\fP [\fI<옵션>...\fP] [\fI<패턴목록>\fP] [\fI<파일>...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (사용 안 함) +.br +\fBlzegrep\fP \&... (사용 안 함) +.br +\fBlzfgrep\fP \&... (사용 안 함) +. +.SH 설명 +\fBxzgrep\fP은 압축 해제한 파일의 내용에 \fBgrep\fP(1)을 실행합니다. \fI<파일>\fP 형식은 파일 이름 확장으로 +결정합니다. \fI<파일>\fP에서 지원하는 확장자는 \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), +\fBlzop\fP(1), \fBzstd\fP(1), \fBlz4\fP(1)로 압축 해제할 수 있는 파일의 확장자입니다. 다른 파일은 이미 압축을 해제한 +파일로 간주합니다. +.PP +지정한 \fI<파일>\fP이 없거나 \fI<파일>\fP 값이 \fB\-\fP이라면 표준 입력을 읽어들입니다. 표준 입력을 +읽어들일 때, \fBxz\fP(1) 방식으로 압축을 해제하는 파일만 지원합니다. 다른 파일은 이미 압축을 해제한 파일로 간주합니다. +.PP +대부분의 \fBgrep\fP(1)의 \fI<옵션>\fP을 지원합니다. 그러나 다음 옵션은 지원하지 않습니다: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIaction\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIfile\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglob\fP +.PP +\fBxzegrep\fP은 \fBxzgrep \-E\fP 명령의 별칭입니다. \fBxzfgrep\fP은 \fBxzgrep \-F\fP 명령의 별칭입니다. +.PP +\fBlzgrep\fP, \fBlzegrep\fP, \fBlzfgrep\fP 명령은 LZMA 유틸리티 하위 호환용으로 제공합니다. 해당 명령은 오래되어 +이후 버전에서 제거합니다. +. +.SH "종료 상태" +.TP +0 +최소한 하나 이상의 파일에서 하나 이상의 일치하는 결과를 찾았습니다. 오류가 없습니다. +.TP +1 +어떤 입력 파일에서든 일치하는 내용이 없습니다. 오류가 없습니다. +.TP +>1 +하나 이상의 오류가 나타납니다. 일치하는 항목을 찾아낼 지 여부는 알 수 없습니다. +. +.SH 환경 +.TP +\fBGREP\fP +\fBGREP\fP 환경변수 값이 비어있지 않으면, \fBgrep\fP, \fBgrep \-E\fP, \fBgrep \-F\fP 명령 대신 활용합니다. +. +.SH "추가 참조" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzfgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzfgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..1953e55b7ca83e45d6ae1adbf39ed80317e913ee --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzfgrep.1 @@ -0,0 +1,85 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Korean translation for the xz-man +.\" Seong-ho Cho , 2023, 2024. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 2025\-03\-06 Tukaani "XZ 유틸리티" +.SH 이름 +xzgrep \- 패턴을 활용하여 가능한 방식으로 압축한 파일의 내용을 검색합니다 +. +.SH 요약 +\fBxzgrep\fP [\fI<옵션>...\fP] [\fI<패턴목록>\fP] [\fI<파일>...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (사용 안 함) +.br +\fBlzegrep\fP \&... (사용 안 함) +.br +\fBlzfgrep\fP \&... (사용 안 함) +. +.SH 설명 +\fBxzgrep\fP은 압축 해제한 파일의 내용에 \fBgrep\fP(1)을 실행합니다. \fI<파일>\fP 형식은 파일 이름 확장으로 +결정합니다. \fI<파일>\fP에서 지원하는 확장자는 \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), +\fBlzop\fP(1), \fBzstd\fP(1), \fBlz4\fP(1)로 압축 해제할 수 있는 파일의 확장자입니다. 다른 파일은 이미 압축을 해제한 +파일로 간주합니다. +.PP +지정한 \fI<파일>\fP이 없거나 \fI<파일>\fP 값이 \fB\-\fP이라면 표준 입력을 읽어들입니다. 표준 입력을 +읽어들일 때, \fBxz\fP(1) 방식으로 압축을 해제하는 파일만 지원합니다. 다른 파일은 이미 압축을 해제한 파일로 간주합니다. +.PP +대부분의 \fBgrep\fP(1)의 \fI<옵션>\fP을 지원합니다. 그러나 다음 옵션은 지원하지 않습니다: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIaction\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIfile\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglob\fP +.PP +\fBxzegrep\fP은 \fBxzgrep \-E\fP 명령의 별칭입니다. \fBxzfgrep\fP은 \fBxzgrep \-F\fP 명령의 별칭입니다. +.PP +\fBlzgrep\fP, \fBlzegrep\fP, \fBlzfgrep\fP 명령은 LZMA 유틸리티 하위 호환용으로 제공합니다. 해당 명령은 오래되어 +이후 버전에서 제거합니다. +. +.SH "종료 상태" +.TP +0 +최소한 하나 이상의 파일에서 하나 이상의 일치하는 결과를 찾았습니다. 오류가 없습니다. +.TP +1 +어떤 입력 파일에서든 일치하는 내용이 없습니다. 오류가 없습니다. +.TP +>1 +하나 이상의 오류가 나타납니다. 일치하는 항목을 찾아낼 지 여부는 알 수 없습니다. +. +.SH 환경 +.TP +\fBGREP\fP +\fBGREP\fP 환경변수 값이 비어있지 않으면, \fBgrep\fP, \fBgrep \-E\fP, \fBgrep \-F\fP 명령 대신 활용합니다. +. +.SH "추가 참조" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..1953e55b7ca83e45d6ae1adbf39ed80317e913ee --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzgrep.1 @@ -0,0 +1,85 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Korean translation for the xz-man +.\" Seong-ho Cho , 2023, 2024. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 2025\-03\-06 Tukaani "XZ 유틸리티" +.SH 이름 +xzgrep \- 패턴을 활용하여 가능한 방식으로 압축한 파일의 내용을 검색합니다 +. +.SH 요약 +\fBxzgrep\fP [\fI<옵션>...\fP] [\fI<패턴목록>\fP] [\fI<파일>...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (사용 안 함) +.br +\fBlzegrep\fP \&... (사용 안 함) +.br +\fBlzfgrep\fP \&... (사용 안 함) +. +.SH 설명 +\fBxzgrep\fP은 압축 해제한 파일의 내용에 \fBgrep\fP(1)을 실행합니다. \fI<파일>\fP 형식은 파일 이름 확장으로 +결정합니다. \fI<파일>\fP에서 지원하는 확장자는 \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), +\fBlzop\fP(1), \fBzstd\fP(1), \fBlz4\fP(1)로 압축 해제할 수 있는 파일의 확장자입니다. 다른 파일은 이미 압축을 해제한 +파일로 간주합니다. +.PP +지정한 \fI<파일>\fP이 없거나 \fI<파일>\fP 값이 \fB\-\fP이라면 표준 입력을 읽어들입니다. 표준 입력을 +읽어들일 때, \fBxz\fP(1) 방식으로 압축을 해제하는 파일만 지원합니다. 다른 파일은 이미 압축을 해제한 파일로 간주합니다. +.PP +대부분의 \fBgrep\fP(1)의 \fI<옵션>\fP을 지원합니다. 그러나 다음 옵션은 지원하지 않습니다: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIaction\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIfile\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglob\fP +.PP +\fBxzegrep\fP은 \fBxzgrep \-E\fP 명령의 별칭입니다. \fBxzfgrep\fP은 \fBxzgrep \-F\fP 명령의 별칭입니다. +.PP +\fBlzgrep\fP, \fBlzegrep\fP, \fBlzfgrep\fP 명령은 LZMA 유틸리티 하위 호환용으로 제공합니다. 해당 명령은 오래되어 +이후 버전에서 제거합니다. +. +.SH "종료 상태" +.TP +0 +최소한 하나 이상의 파일에서 하나 이상의 일치하는 결과를 찾았습니다. 오류가 없습니다. +.TP +1 +어떤 입력 파일에서든 일치하는 내용이 없습니다. 오류가 없습니다. +.TP +>1 +하나 이상의 오류가 나타납니다. 일치하는 항목을 찾아낼 지 여부는 알 수 없습니다. +. +.SH 환경 +.TP +\fBGREP\fP +\fBGREP\fP 환경변수 값이 비어있지 않으면, \fBgrep\fP, \fBgrep \-E\fP, \fBgrep \-F\fP 명령 대신 활용합니다. +. +.SH "추가 참조" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzless.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzless.1 new file mode 100644 index 0000000000000000000000000000000000000000..b439e657feb29c5a3884f6f4fefa17f24dfafdeb --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzless.1 @@ -0,0 +1,41 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" Korean translation for the xz-man +.\" Seong-ho Cho , 2023, 2024. +.\" +.\" (Note that this file is not based on gzip's zless.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZLESS 1 2025\-03\-06 Tukaani "XZ 유틸리티" +.SH 이름 +xzless, lzless \- xz 또는 lzma 압축 (텍스트) 파일을 봅니다 +.SH 요약 +\fBxzless\fP [\fI<파일>\fP...] +.br +\fBlzless\fP [\fIfile\fP...] (사용 안 함) +.SH 설명 +\fBxzless\fP는 압축 파일 내용을 터미널에 나타내는 필터 프로그램입니다. \fBxz\fP(1) 방식으로 압축을 해제하는 파일만 +지원합니다. 다른 파일은 이미 압축을 해제한 파일로 간주합니다. 주어진 \fI<파일>\fP 값이 없다면, \fBxzless\fP는 +표준 입력을 읽어들입니다. +.PP +\fBxzless\fP 는 \fBless\fP(1) 를 사용하여 출력을 막습니다. \fBxzmore\fP 와는 다르게, 환경 변수 설정으로 선택한 +페이저를 바꿀 수 없습니다. 명령은 \fBmore\fP(1) 와 \fBvi\fP(1) 가 기반이며, 앞뒤로 움직이고 검색할 수 있습니다. +자세한 정보는 \fBless\fP(1) 설명서를 참고하십시오. +.PP +\fBlzless\fP 명령은 LZMA 유틸리티 하위 호환용으로 제공합니다. 해당 명령은 오래되어 이후 버전에서 제거합니다. +.SH 환경 +.TP +\fBLESSMETACHARS\fP +셸에서 동작할 수도 있는 특수 문자 목록입니다. 환경에 미리 설정해두지 않았다면 \fBxzless\fP에서 설정합니다. +.TP +\fBLESSOPEN\fP +입력 파일을 \fBless\fP(1) 에 전달하기 전에 \fBxz\fP(1) 압축 해제 프로그램을 실행해서 미리 처리하는 명령행을 설정합니다. +.SH "추가 참조" +\fBless\fP(1), \fBxz\fP(1), \fBxzmore\fP(1), \fBzless\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzma.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzma.1 new file mode 100644 index 0000000000000000000000000000000000000000..631a9a7cc8b58565ff6c9eb7a3610b39d1733d20 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzma.1 @@ -0,0 +1,1585 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Korean translation for the xz-man +.\" Seong-ho Cho , 2023, 2024. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 2025\-03\-08 Tukaani "XZ 유틸리티" +. +.SH 이름 +xz, unxz, xzcat, lzma, unlzma, lzcat \- .xz 파일과 .lzma 파일을 압축 또는 압축 해제합니다 +. +.SH 요약 +\fBxz\fP [\fI<옵션>...\fP] [\fI<파일>...\fP] +. +.SH "명령 별칭" +\fBunxz\fP 명령은 \fBxz \-\-decompress\fP 명령과 동일합니다. +.br +\fBxzcat\fP 명령은 \fBxz \-\-decompress \-\-stdout\fP 명령과 동일합니다. +.br +\fBlzma\fP 명령은 \fBxz \-\-format=lzma\fP 명령과 동일합니다. +.br +\fBunlzma\fP 명령은 \fBxz \-\-format=lzma \-\-decompress\fP 명령과 동일합니다. +.br +\fBlzcat\fP 명령은 \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP 명령과 동일합니다. +.PP +파일 압축을 해제해야 하는 셸 스크립트를 작성할 때, \fBunxz\fP 와 \fBxzcat\fP 이름 대신 \fBxz\fP 명령과 적절한 인자 +값(\fBxz \-d\fP 또는 \fBxz \-dc\fP)의 사용을 추천드립니다. +. +.SH 설명 +\fBxz\fP는 \fBgzip\fP(1) 과 \fBbzip2\fP(1) 과 비슷한 명령행 문법을 지닌 범용 데이터 압축 도구입니다. 자체 파일 +형식은 \fB.xz\fP 형식이나, LZMA 유틸리티에서 사용하는 예전 \fB.lzma\fP 형식과 형식 헤더가 없는 RAW 압축 스트림도 +지원합니다. 게다가, \fBlzip\fP에서 활용하는 \fB.lz\fP 형식 압축 해제도 지원합니다. +.PP +각 \fI파일\fP 에 대한 \fBxz\fP 압축 또는 압축 해제는 선택 동작 모드에 따릅니다. \fI<파일>\fP 값이 주어졌거나 +\fI<파일>\fP 값이 \fB\-\fP이면, \fBxz\fP 명령에서 표준 입력을 읽고 처리한 데이터를 표준 출력에 기록합니다. +\fBxz\fP 에서는 터미널에서 활용할 경우 압축 데이터를 표준 압축으로 기록하는 동작을 거절(오류를 출력하고 \fI<파일>\fP을 +건너뜀)합니다. 이와 비슷하게, \fBxz\fP 유틸리티를 터미널에서 실행하면 표준 입력의 압축 데이터 읽기를 거절합니다. +.PP +\fB\-\-stdout\fP 을 지정하지 않는 한, \fB\-\fP가 아닌 \fI<파일>\fP을 원본 \fI<파일>\fP 이름에서 +가져온 새 파일 이름으로 기록합니다: +.IP \(bu 3 +압축할 때, 대상 파일 형식의 접미사(\fB.xz\fP or \fB.lzma\fP) 는 원본 파일 이름 뒤에 붙어 대상 파일이름이 됩니다. +.IP \(bu 3 +압축 해제할 때, \fB.xz\fP, \fB.lzma\fP, \fB.lz\fP 접미사를 파일 이름에서 제거하고 대상 파일 이름을 알아냅니다. +\fBxz\fP에서는 \fB.txz\fP, \fB.tlz\fP 접미사도 인식하며, \fB.tar\fP 접미사로 치환합니다. +.PP +대상 파일이 이미 있으면, 오류를 나타내고 \fI<파일>\fP을 건너뜁니다. +.PP +표준 출력으로 기록하기 전에는, \fBxz\fP는 경고를 나타내며, 다음 조건에 만족할 경우 \fI<파일>\fP을 건너뜁니다: +.IP \(bu 3 +\fI<파일>\fP이 일반 파일이 아닐 때. 심볼릭 링크는 따라가지 않기에, 일반 파일로 간주하지 않습니다. +.IP \(bu 3 +\fI<파일>\fP이 하나 이상의 하드 링크일 떄. +.IP \(bu 3 +\fI<파일>\fP에 setuid, setgid, 끈적이 비트 집합이 붙어있을 떄. +.IP \(bu 3 +동작 모드를 압축으로 설정하고, \fI<파일>\fP은 대상 파일 형식의 접미사를 이미 붙였을 때(\fB.xz\fP 형식으로 압축하면 +\&\fB.xz\fP 또는 \fB.txz\fP, \fB.lzma\fP 형식으로 압축하면 \fB.lzma\fP 또는 \fB.tlz\fP). +.IP \(bu 3 +동작 모드를 압축 해제로 설정하고, \fI<파일>\fP에 지원 파일 형식 접미사(\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, +\&\fB.tlz\fP, \fB.lz\fP)를 붙이지 않았을 때. +.PP +\fI<파일>\fP 의 압축 또는 압축 해제를 성공하고 나면, \fBxz\fP는 소유자, 소유그룹, 권한, 접근 시각, 수정 시각 +정보를 원본 \fI<파일>\fP에서 대상 파일로 그대로 복사합니다. 그룹 정보 복사에 실패하면, 권한을 수정하여 원본 +\fI<파일>\fP에 접근 권한이 없는 사용자가 대상 파일로 접근하지 못하게 합니다. \fBxz\fP는 아직 접근 제어 목록이나 +확장 속성 등의 기타 메타데이터를 복사하는 기능은 지원하지 않습니다. +.PP +대상 파일을 온전히 닫고 나면, \fB\-\-keep\fP 옵션을 지원하지 않았을 경우 원본 \fI<파일>\fP을 제거합니다. 원본 +\fI<파일>\fP은 출력을 표준 출력으로 기록했거나 오류가 발생했을 경우 제거하지 않습니다. +.PP +\fBxz\fP 프로세스에 \fBSIGINFO\fP 시그널 또는 \fBSIGUSR1\fP 시그널을 보내면 표준 출력으로 진행 정보를 출력합니다. 표준 +오류가 터미널일 경우일 경우에만 제한하며 \fB\-\-verbose\fP 옵션을 지정하면 진행 표시줄을 자동으로 나타냅니다. +. +.SS "메모리 사용" +\fBxz\fP 메모리 사용은 수백 킬로바이트로 시작하여 수 기가바이트까지 압축 설정에 따라 다릅니다. 압축 해제 프로그램이 필요로 하는 +메모리 공간을 결정하는 파일 압축시에 설정 값을 활용합니다. 보통 압축 해제 프로그램은 파일을 만들 때, 압축 프로그램 메모리 사용량의 +5% 에서 20% 정도 필요합니다. 예를 들면, \fBxz \-9\fP로 압축한 파일 압축 해제시 현재 65MiB 메모리 용량이 필요합니다. +여전하게도, 압축 해제시 수 기가 바이트의 메모리가 필요한 \fB.xz\fP 파일에도 가능한 이야기입니다. +.PP +특히 이전 시스템 사용자의 경우 메모리 사용량이 엄청나게 늘어나는 점에 짜증이 날 수 있습니다. 이런 불편한 상황을 피하기 위해, +\fBxz\fP에 기본적으로 비활성 상태인 내장 메모리 사용 제한 기능을 넣었습니다. 일부 운영체제에서 처리 중 메모리 사용을 제한하는 +수단을 제공하긴 하지만, 여기에 의지하기에는 충분히 유연하지 않습니다(예를 들면, \fBulimit\fP(1)을 사용하면 가상 메모리를 +제한하여 \fBmmap\fP(2)을 먹통으로 만듭니다). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +메모리 사용 제한 기능은 \fB\-\-memlimit=\fP\fI<제한용량>\fP 명령행 옵션으로 사용할 수 있습니다. 종종 +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP와 같이 \fBXZ_DEFAULTS\fP 환경 변수를 설정하여 제한 기능을 켜는게 더 +편합니다. \fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션과 +\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP 옵션을 활용하여 압축 및 압축 해제시 별도로 한계 값을 +설정할 수 있습니다. 이 두 가지 옵션의 \fBXZ_DEFAULTS\fP 환경 변수 밖에서의 사용은, \fBxz\fP를 단일 실행할 때 압축 및 +압축 해제 동작을 동시에 수행하지 않으며, 앞서 언급한 두가지 옵션을 명령행에 입력하기에는 +\fB\-\-memlimit=\fP\fI<제한용량>\fP(또는 \fB\-M\fP \fI<제한용량>\fP)이 더 짧기 때문에 별로 쓸모가 +없습니다. +.PP +압축 해제시 메모리 사용 제한 지정 한계를 초과하면, \fBxz\fP 유틸리티에서 오류를 나타내며 파일 압축 해제는 실패합니다. 압축을 +실행할 때 사용 제한 지정 한계를 넘어서면 \fBxz\fP에서는 설정 값을 줄여서 어쨌든 한계를 넘지 못하게 +합니다(\fB\-\-format=raw\fP 옵션 또는 \fB\-\-no\-adjust\fP 옵션 사용시 제외). 설정 한계 값이 엄청 작지 않은 이상 이 +방식대로 처리하면 어쨌든 실패하지 않습니다. 설정 값조정은 압축 래벨 사전 설정과 일치하지 않을 때 단계적으로 진행하는데, 이를테면, +\fBxz \-9\fP 명령 수행에 필요한 양보다 한계 값이 약간 작으면, 설정 값을 \fBxz \-8\fP에 못미치게 약간 줄여서 진행합니다. +. +.SS ".xz 파일 결합 및 패딩" +\&\fB.xz\fP 파일을 있는 그대로 합칠 수 있습니다. \fBxz\fP는 \fB.xz\fP 파일을 단독 파일일 때 처럼 압축해제합니다. +.PP +결합 부분과 마지막 부분 뒤에 패딩을 추가할 수 있습니다. 패딩은 널 바이트로 구성해야 하며 패딩 길이는 4바이트로 구성해야 합니다. +512 바이트 블록으로 파일 크기를 이루는 매체에 \fB.xz\fP 파일을 저장했을 경우에 요긴할 수 있습니다. +.PP +\&\fB.lzma\fP 파일 또는 원시 스트림의 경우 결합과 패딩을 허용하지 않습니다. +. +.SH 옵션 +. +.SS "정수 접두사와 별도 값" +정수 인자값이 필요한 대부분 위치에서는, 큰 정수값을 나타내기 쉽게 하도록 추가 접미사를 지원합니다. 정수와 접미사 사이에 어떤 공백이 +있으면 안됩니다. +.TP +\fBKiB\fP +1,024 (2^10) 배수 정수값. \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP, \fBKB\fP 단위를 \fBKiB\fP 동의어로 받아들입니다. +.TP +\fBMiB\fP +1,048,576 (2^20) 배수 정수값. \fBMi\fP, \fBm\fP, \fBM\fP, \fBMB\fP 단위를 \fBMiB\fP 동의어로 받아들입니다. +.TP +\fBGiB\fP +1,073,741,824 (2^30) 배수 정수값. \fBGi\fP, \fBg\fP, \fBG\fP, \fBGB\fP 단위를 \fBGiB\fP 동의어로 +받아들입니다. +.PP +특수 값 \fBmax\fP는 옵션에서 지원하는 정수 최대 값을 나타낼 때 사용할 수 있습니다. +. +.SS "동작 모드" +여러 동작 모드를 보여드리겠습니다만, 마지막에 주어진 동작 모드로 동작합니다. +.TP +\fB\-z\fP, \fB\-\-compress\fP +압축합니다. 어떤 동작 모드 옵션도 지정하지 않고 다른 동작 모드를 명령행에 따로 지정하지 않았다면 이 동작 모드는 기본입니다(예: +\fBunxz\fP 는 \fB\-\-decompress\fP를 암시). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +압축을 제대로 끝내고 나면, 표준 출력에 기록하거나 \fB\-\-keep\fP 옵션을 지정하지 않았다면 원본 파일을 제거합니다. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +압축 해제입니다. 압축 해제를 제대로 끝내고 나면, 표준 출력에 기록하거나 \fB\-\-keep\fP 옵션을 지정하지 않았다면 원본 파일을 +제거합니다. +.TP +\fB\-t\fP, \fB\-\-test\fP +압축 \fI<파일>\fP의 무결성을 시험해봅니다. 이 옵션은 압축 해제 데이터를 표준 출력으로 기록하는 대신 버린다는 점을 +제외하고 \fB\-\-decompress \-\-stdout\fP과 동일합니다. 어떤 파일도 만들거나 제거하지 않습니다. +.TP +\fB\-l\fP, \fB\-\-list\fP +압축 \fI<파일>\fP 정보를 출력합니다. 압축 해제 출력을 내보내지 않으며, 어떤 파일도 만들거나 제거하지 않습니다. 이 +조회 모드에서, 프로그램은 표준 입력 또는 기타 탐색 불가능한 원본에서 압축 데이터를 읽을 수 없습니다. +.IP "" +\fI<파일>\fP 기본 정보를 파일 당 한 줄 씩 기본으로 보여줍니다. 더 자세한 정보를 보려면 \fB\-\-verbose\fP +옵션을 사용하십시오. 더 자세한 정보는 \fB\-\-verbose\fP 옵션을 두번 사용하면 되지만, 추가 정보를 더 많이 가져오면서 탐색 +횟수가 늘어나는 문제로 인해 느려질 수 있습니다. 세부 출력 너비는 80 문자를 초과하며, 예를 들어 출력을 파이핑한다면, 터미널이 +충분히 너비가 넓지 못할 경우 \fBless\ \-S\fP 명령이 편리할 수 있습니다. +.IP "" +정확한 출력은 \fBxz\fP 버전과 다른 로캘에 따라 바뀔 수 있습니다. 기계 판독용 출력시 \fB\-\-robot \-\-list\fP 옵션을 +사용합니다. +. +.SS "동작 수정자" +.TP +\fB\-k\fP, \fB\-\-keep\fP +입력 파일을 삭제하지 않습니다. +.IP "" +\fBxz\fP 5.2.6 부터는 이 옵션으로 입력 파일이 일반 파일을 참조하는 심볼릭 링크나 하나 이상의 하드 링크, 내지는 setuid, +setgid, 끈적이 비트 세트를 설정한 상태라도 압축하거나 압축을 풀 수 있습니다. setuid, setgid, 끈적이 비트는 대상 +파일에 복사하지 않습니다. 이전 버전에서는 \fB\-\-force\fP 옵션을 지정했을 때만 가능했습니다. +.TP +\fB\-f\fP, \fB\-\-force\fP +이 옵션은 몇가지 동작에 영향을 줍니다: +.RS +.IP \(bu 3 +대상 파일이 이미 있으면, 압축 또는 압축 해제 전 삭제합니다. +.IP \(bu 3 +입력 파일이 일반 파일을 참조하는 심볼릭 링크나 하나 이상의 하드 링크, 내지는 setuid, setgid, 끈적이 비트 세트를 설정한 +상태라도 압축 또는 압축 해제를 진행합니다. setuid, setgid, 끈적이 비트는 대상 파일에 복사하지 않습니다. +.IP \(bu 3 +\fB\-\-decompress\fP \fB\-\-stdout\fP 옵션을 같이 사용하는 상황에서 \fBxz\fP 명령이 원본 파일의 형식을 알아내지 못할 때, +원본 파일의 사본을 표준 출력으로 보냅니다. 이렇게 하면 \fBxzcat\fP \fB\-\-force\fP 명령을 \fBxz\fP 명령으로 압축하지 않은 +파일에 대해 \fBcat\fP(1) 을 사용하는 것처럼 사용할 수 있습니다. 참고로 나중에, \fBxz\fP에서 \fBxz\fP로 하여금 여러 형식의 +파일을 표준 출력으로 복사하는 대신 압축을 해제하도록 새 압축 파일 형식을 지원할 예정입니다. +\fB\-\-format=\fP\fI<형식>\fP 옵션은 \fBxz\fP 명령에 단일 파일 형식만 압축 해제하도록 제한할 때 사용할 수 +있습니다. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +파일 대신 표준 출력으로 압축 또는 압축 해제한 데이터를 기록합니다. \fB\-\-keep\fP를 생략했습니다. +.TP +\fB\-\-single\-stream\fP +처음 \fB.xz\fP 스트림만 압축 해제하며, 스트림에 뒤따라오는 나머지 입력 데이터는 조용히 무시합니다. 보통 뒤따라오는 쓰레기 값에 +대해서는 \fBxz\fP 에서 오류를 나타냅니다. +.IP "" +\fBxz\fP는 \fB.lzma\fP 파일 또는 원시 스트림에서 온 하나 이상의 스트림에 대해 압축 해제동작을 취하지 않지만, 이 옵션을 사용하면 +\fBxz\fP에서 \fB.lzma\fP 파일 또는 원시 스트림을 처리한 다음에 뒤따라오는 데이터를 무시하도록 합니다. +.IP "" +이 옵션은 동작 모드가 \fB\-\-decompress\fP 또는 \fB\-\-test\fP가 아니면 동작에 아무런 영향을 주지 않습니다. +.IP "" +\fBxz\fP 5.7.1alpha 부터는 \fB\-\-single\-stream\fP 옵션의 동작에 \fB\-\-keep\fP 동작이 들어갑니다. +.TP +\fB\-\-no\-sparse\fP +희소 파일을 만들지 않습니다. 기본적으로 일반 파일로 압축 해제할 경우 \fBxz\fP 에서는 압축 해제한 파일에 이진 0값이 길게 늘어질 +경우 희소 배열 파일을 만들려고 합니다. 표준 출력의 내용 길이만큼 연결한 일반 파일로 기록할 때도 동작하며 희소 파일을 만드는 동안 +아무런 문제가 나타나지 않게 각각의 추가 조건을 만족합니다. 희소 파일을 만들면 디스크 공간을 절약할 수 있으며 디스크 입출력을 줄여 +압축 해제 속도를 올릴 수 있습니다. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +압축할 때, 대상 파일의 접두사를 \fB.xz\fP 또는 \fB.lzma\fP 대신 \fI.suf\fP로 사용하십시오. 표준 출력으로 기록하지 않고 +원본 파일에 \fI.suf\fP 접두사가 붙어있으면, 경고를 나타내고 해당 파일을 건너뜁니다. +.IP "" +압축 해제할 때, \fI.suf\fP 접미사로 파일을 인식하기도 하고, \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, +\&\fB.lz\fP 접미사가 붙은 파일도 인식합니다. 원본 파일에 \fI.suf\fP 접미사가 붙어있으면, 해당 접미사를 제거하여 대상 파일 이름을 +알아냅니다. +.IP "" +원시 스트림 압축 및 압축 해제시(\fB\-\-format=raw\fP) 원시 스트림에 기본 접미사가 없기 때문에, 표준 출력으로 기록하지 않는 +한 접미사를 반드시 지정해야 합니다. +.TP +\fB\-\-files\fP[\fB=\fP\fI<파일>\fP] +\fI<파일>\fP에서 처리할 파일 이름을 읽습니다. \fI<파일>\fP을 생략하면 파일 이름은 표준 입력에서 +불러옵니다. 파일 이름은 개행 문자로 끝나야 합니다. 대시 문자(\fB\-\fP)는 일반 파일 이름으로 취급하며 표준 입력을 의미하지 +않습니다. 파일 이름을 명령행 인자로 지정하면, \fI<파일>\fP에서 파일 이름을 읽어들이기 전 해당 명령행 인자를 먼저 +처리합니다. +.TP +\fB\-\-files0\fP[\fB=\fP\fI<파일>\fP] +각 파일 이름이 널 문자로 끝나야 한다는 점만 제외하면 \fB\-\-files\fP[\fB=\fP\fI<파일>\fP] 옵션과 동일합니다. +. +.SS "기본 파일 형식 및 압축 옵션" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fI<형식>\fP +압축 또는 압축해제 파일 \fI<형식>\fP을 지정합니다: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +기본 값입니다. 압축할 때, \fBauto\fP는 \fBxz\fP의 기본 동작과 동일합니다. 압축을 해제할 때, 입력 파일 형식을 자동으로 +찾습니다. 참고로 원시 스트림(\fB\-\-format=raw\fP)의 경우 자동으로 찾을 수 없습니다. +.TP +\fBxz\fP +\&\fB.xz\fP 파일 형식으로 압축하거나, 압축 해제시 \fB.xz\fP 파일만 받아들입니다. +.TP +\fBlzma\fP, \fBalone\fP +이전 \fB.lzma\fP 파일 형식으로 압축하거나, 압축 해제시 \fB.lzma\fP 파일만 받아들입니다. \fBalone\fP 대체 명령은 LZMA +유틸리티 하위 호환성을 목적으로 제공합니다. +.TP +\fBlzip\fP +압축 해제시 \fB.lz\fP 파일만 받아들입니다. 압축은 지원하지 않습니다. +.IP "" +\&\fB.lz\fP 형식 버전 0과 1을 지원합니다. 버전 0파일은 \fBlzip\fP 1.3 이전에서만 만듭니다. 일반적이진 않지만 일부 파일의 +경우 이 형식의 원본 패키지로 보관한 파일을 찾을 수도 있습니다. 개인적으로 이 형식으로 압축한 오래된 개인 파일을 가지고 있을 수도 +있습니다. 형식 버전 0 압축 해제 지원은 \fBlzip\fP 1.18에서 제거했습니다. \fBlzip\fP 1.4 이후의 버전에서는 버전 1 +형식 파일을 만듭니다. +.TP +\fBraw\fP +원시 스트림으로 압축하거나 압축을 해제합니다(헤더 없음). 고급 사용자 전용입니다. 원시 스트림을 디코딩하려면, +\fB\-\-format=raw\fP 옵션을 사용하고 분명하게 필터 체인을 지정하여 컨테이너 헤더에 필요한 정보를 저장하게 끔 해야합니다. +.RE +.TP +\fB\-C\fP \fI<검사방식>\fP, \fB\-\-check=\fP\fI<검사방식>\fP +무결성 검사 방식을 지정합니다. 검사 방식은 \fB.xz\fP 파일에 저장하며 압축 해제 데이터를 계산합니다. 이 옵션은 \fB.xz\fP +형식으로 압축할 때만 효력이 있습니다: \fB.lzma\fP 형식은 무결성 겁사를 지원하지 않습니다. 무결성 검사는 \fB.xz\fP 파일 압축을 +풀었을 때에 검사합니다. +.IP "" +지원 \fI검사\fP 형식: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +어떤 경우에도 무결성 검사 계산을 수행하지 않습니다. 보통 바람직하지 못한 생각입니다. 데이터 무결성을 다른 방식으로라도 검증해야 +하는 상황이면 쓸만할 수 있습니다. +.TP +\fBcrc32\fP +IEEE\-802.3 (이더넷)의 다항 연산으로 CRC32를 계산합니다. +.TP +\fBcrc64\fP +ECMA\-182의 다항식 연산으로 CRC64를 계산합니다. 이 동작이 기본 동작이기 때문에 CRC32가 깨진 파일을 찾을 때보다는 좀 +낮은 편이며 속도 차이도 거의 없습니다. +.TP +\fBsha256\fP +SHA\-256 해시를 계산합니다. CRC32와 CRC64 보다는 좀 느립니다. +.RE +.IP "" +\&\fB.xz\fP 헤더 무결성은 항상 CRC32로 검증하빈다. 이를 바꾸거나 It is not possible to change or +disable it. +.TP +\fB\-\-ignore\-check\fP +압축 데이터를 압축해제할 경우 압축 데이터의 무결성 검증을 진행하지 않습니다. \fB.xz\fP 헤더의 CRC32 값은 그래도 여전히 보통 +방식으로 검증합니다. +.IP "" +\fB이 옵션이 정확히 무슨 동작을 하는지 알기 전에는 사용하지 마십시오.\fP 이 옵션을 사용하는 타당한 이유로: +.RS +.IP \(bu 3 +깨진 .xz 파일에서 데이터 복구를 시도합니다. +.IP \(bu 3 +압축 해제 속도를 늘립니다. SHA\-256 또는 압축 파일에 들어간 그 무언가를 엄청 빨리 처리합니다. 다른 방식으로 파일 무결성을 +검증해야 하는 목적이 아니라면 이 옵션을 사용하지 않는게 좋습니다. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +압축 사전 설정 수준을 선택합니다. 기본값은 \fB\-6\fP입니다. 다중 수준을 지정하면 가장 마지막 수준 옵션을 적용합니다. 개별 필터 +체인을 이미 지정했다면, 압축 사전 설정 수준 값을 설정할 때 개별 필터 체인을 정리합니다. +.IP "" +사전 설정간 차이는 \fBgzip\fP(1)과 \fBbzip2\fP(1)을 사용할 때보다 더 비중을 차지합니다. 선택한 압축 설정은 압축 해제시 +필요한 메모리 사용량을 셜정하므로 사전 설정 수준 값을 너무 높게 지정하면 RAM 용량이 적은 오래된 시스템에서 파일 압축 해제시 실패할 +수 있습니다. 게다가, \fBgzip\fP(1) 과 \fBbzip2\fP(1)에서 처럼 종종 \fB모든 동작에 \-9를 몰래 활용하는건 바람직하지 않습니다\fP. +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +동작이 빠른 사전 설정 부류입니다. \fB\-0\fP은 때로는 \fBgzip \-9\fP 명령보다 압축율이 훨씬 우수하면서도 더 빠릅니다. 더 큰 +값은 보통 \fBbzip2\fP(1) 명령과 비교했을 떄 압축 결과가 압축 데이터에 따라 달라지더라도, 비교할 법한 속도 또는 더 나은 +압축율을 보입니다. +.TP +\fB\-4\fP ... \fB\-6\fP +오래된 시스템에서 조차도 압축 해제 프로그램의 적절한 메모리 사용량을 보이면서 양호하거나 최적의 압축율을 보여줍니다. \fB\-6\fP 옵션은 +압축 해제시 메모리 사용량이 16MiB 밖에 안되기 때문에 파일을 배포할 때 최적의 선택인 기본 값입니다. (\fB\-5e\fP 또는 +\fB\-6e\fP도 역시 고려할 만합니다. \fB\-\-extreme\fP을 참고하십시오.) +.TP +\fB\-7 ... \-9\fP +\fB\-6\fP과 비슷하지만 압축 및 압축 해제시 요구 메모리 사용량이 더 높습니다. 압축 파일이 각각 8MiB, 16MiB, 32MiB +보다 클 경우에만 쓸만한 옵션입니다. +.RE +.IP "" +동일한 하드웨어에서, 압축 해제 속도는 압축한 데이터의 초당 정적 바이트 처리 수의 어림 평균입니다. 다시 말해, 압축율을 더 올리면, +압축 해제 속도도 역시 올라갑니다. 이는 곧 초당 비압축 데이터 출력 양이 달라질 수 있단 뜻입니다. +.IP "" +다음 표에 사전 설정 기능을 정리했습니다: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Preset;DictSize;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +컬럼 설명: +.RS +.IP \(bu 3 +DictSize는 LZMA2 딕셔너리 크기입니다. 압축 해제 파일의 크기보다 딕셔너리에서 사용하는 낭비 메모리 용량입니다. 실제로 +필요하지 않은 \fB\-7\fP ... \fB\-9\fP 사전 설정값을 피해야 하는 적절한 이유이기도 합니다. \fB\-6\fP 이하에서는 소모 메모리 양이 +충분히 적거나 따로 신경쓸 필요가 없습니다. +.IP \(bu 3 +CompCPU는 압축 속도에 영향을 주는 LZMA2 설정의 단순화 표기 값입니다. 딕셔너리 크기는 속도에도 영향을 주기 때문에 +CompCPU는 \fB\-6\fP ... \fB\-9\fP 수준값과 동일한데, 고수준 값은 여전히 조금 더 느려질 수 있습니다. 느려지는 만큼 +압축율은 가능한 한 더 좋아집니다. \fB\-\-extreme\fP을 참고하십시오. +.IP \(bu 3 +CompMem은 단일\-스레드 모드에서 필요한 압축 프로그램의 메모리 점유 용량입니다. \fBxz\fP 버전에 따라 다를 수 있습니다. +.IP \(bu 3 +DecMem은 압축 해제 프로그램의 메모리 점유용량입니다. 이는 곧, 압축 해제 프로그램에서 필요한 메모리 사용량을 압축 설정에서 +결정한다는 의미가 들어있습니다. 정확한 압축 해제 프로그램의 메모리 사용량은 LZMA2 딕셔너리 크기 보다는 조금 많지만 테이블의 값은 +MiB 용량으로 완전히 반올림한 값입니다. +.RE +.IP "" +다중\-스레드 모드에서 필요한 메모리 용량은 단일\-스레드 모드보단 약간 더 많습니다. \fB\-\-block\-size\fP 기본값에 따라, 각 +스레드에서는 3*3*딕셔녀리_크기 + 압축시_메모리용량 또는 압축_해제시_메모리용량 정도가 필요합니다. 예를 들면, 스레드 넷에 사전 +설정 옵션 \fB\-6\fP을 사용한다면, 660\(en670 MiB 메모리 용량이 필요합니다. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +기대하는 만큼의 좀 더 나은 압축율을 확보하려 선택한 압축 사전 설정 수준의 느린 변형 옵션을 사용하지만, 재수 없는 와중에 골로 가는 +경우가 생기기도 합니다. 압축 해제 프로그램의 메모리 사용에는 영향을 주지 않지만, 압축 프로그램의 메모리 사용량은 \fB\-0\fP +\&... \fB\-3\fP 사전 설정 수준에서 약간 더 올라갈 뿐입니다. +.IP "" +4MiB와 8MiB 두 가지 딕셔너리 용량 설정이 있기 때문에 \fB\-3e\fP 와 \fB\-5e\fP 사전 설정을 (CompCPU 수치를 낮춰서) +각각 \fB\-4e\fP 와 \fB\-6e\fP 보다 약간 더 빠르게 설정할 수 있습니다. 이런 식으로 두 사전 설정이 동일하지 않습니다. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Preset;DictSize;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +예를 들면, 8MiB 딕셔너리를 활용하는 네가지 사전 설정이 있다고 할 때, 빠른 순으로 설정을 나열하자면, \fB\-5\fP, \fB\-6\fP, +\fB\-5e\fP, \fB\-6e\fP 입니다. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +이 옵션은 \fB\-0\fP 과 \fB\-9\fP의 별칭으로 각각 오해할 수 있습니다. LZMA 유틸리티의 하위 호환성을 목적으로 제공합니다. 이 +옵션 사용은 피하십시오. +.TP +\fB\-\-block\-size=\fP\fI<크기>\fP +\&\fB.xz\fP 형식으로 압축할 때, 입력 데이터를 \fI<크기>\fP 바이트 블록으로 입력 데이터를 쪼갭니다. 각각의 블록은 +다중\-스레드 방식으로 처리할 수 있고 임의 접근 압축 해제 가능성을 제한할 수 있게 개별적으로 압축 처리합니다. 이 옵션은 보통 +다중\-스레드 모드에서 기본 블록 크기를 지정할 때 사용하지만, 단일\-스레드 모드에서도 사용할 수 있습니다. +.IP "" +다중\-스레드 모드에서는 약 3배 용량의 \fI<크기>\fP 바이트만큼 각 스레드 별로 입출력 버퍼링용 공간을 할당합니다. 기본 +\fI<크기>\fP는 LZMA2 딕셔너리 크기 또는 1MiB 중 가장 큰 쪽의 세 배입니다. 보통 적절한 값으로 LZMA2 +딕셔너리 크기 또는 최소한 1MiB 용량의 2\(en4배입니다. LZMA2 딕셔너리 크기보다 작은 \fI<크기>\fP는 램의 +소모적 사용 공간으로 할당하는데 LZMA2 딕셔너리 버퍼를 할당한 용량 크기 전체를 다 사용하지 않기 때문입니다. 다중\-스레드 모드에서 +블록 크기는 블록 헤더에 저장하며, 이 크기 정보는 다중\-스레드 압축 해제시 필요합니다. +.IP "" +단일\-스레드 모드에서는 기본적으로 블록 쪼개기를 하지 않습니다. 이 옵션을 설정한다고 해서 메모리 사용에 영향을 주지는 않습니다. +블록 헤더에 크기 정보를 저장하지 않기 때문에 단일\-스레드 모드에서 만든 파일은 다중\-스레드 모드에서 만든 파일과 동일하지 않습니다. +크기 정보의 누락은 또한 \fBxz\fP에서 다중\-스레드 모드로 압축 해제를 진행할 수 없음을 의미하기도 합니다. +.TP +\fB\-\-block\-list=\fP\fI<항목>\fP +\&\fB.xz\fP 형식으로 압축할 때, 압축하지 않은 데이터로 부터 일정 간격 이후에 새 블록 처리를 시작합니다. +.IP "" +\fI<항목>\fP은 쉼표로 구분한 목록으로 지정합니다. 각 항목은 콜론 (\fB:\fP)으로 구분한 0부터 9까지의 추가 필터 +체인 번호 값으로 이루어져 있으며, 압축하지 않은 데이터의 크기 값이 필요합니다. 항목을 생략하면(둘 이상의 쉼표 연속 표기) 이전 +항목의 크기와 필터를 활용하겠다는 함축 의미를 넣을 수 있습니다. +.IP "" +입력 파일이 \fI<항목>\fP 크기의 합보다 크면, 마지막 항목을 파일의 끝까지 반복합니다. 특별히 \fB0\fP 값을 마지막 +값으로 사용하여 파일 나머지 부분을 단일 블록으로 인코딩해야 한다는 의미를 나타낼 수도 있습니다. +.IP "" +\fB\-\-filters1=\fP\fI<필터>\fP \&...\& \fB\-\-filters9=\fP\fI<필터>\fP 옵션 조합으로 +각 블록별 별도 필터 체인을 지정할 수 있습니다. 이 옵션은 1\(en9번 필터 체인을 지정합니다. 필터 체인 0번은 필터 체인을 +지정하지 않았을 때와 동일한 기본 필터 체인으로 참조할 수 있습니다. 필터 체인 식별 번호는 비 압축 크기 앞에 콜론(\fB:\fP)을 붙여 +사용할 수 있습니다. 예를 들면, \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP 옵션을 +지정했을 경우 다음 규칙대로 블록을 만듭니다: +.RS +.IP \(bu 3 +\fB\-\-filters1\fP 필터 체인에서는 2MiB 입력을 +.IP \(bu 3 +\fB\-\-filters3\fP 필터 체인에서는 2MiB 입력을 +.IP \(bu 3 +\fB\-\-filters2\fP 필터 체인에서는 4MiB 입력을 +.IP \(bu 3 +\fB\-\-filters2\fP 필터 체인에서는 4MiB 입력을 +.IP \(bu 3 +기본 필터 체인에서는 2MiB 입력을 +.IP \(bu 3 +입력이 끝나기 전의 모든 블록에는 기본 필터 체인과 4MiB 입력을 적용합니다. +.RE +.IP "" +인코더 블록 크기를 초과하는 크기 값을 지정하면(스레드 모드 기본값 또는 \fB\-\-block\-size=\fP\fI<크기>\fP +옵션으로 지정한 값), 인코더는 \fI<크기>\fP 지정 용량 범위는 유지하면서 추가 블록을 만듭니다. 예를 들면 +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP 옵션을 지정하고 +입력 파일을 80MiB 용량으로 전달하면, 각각 5, 10, 8, 10, 2, 10, 10, 4, 10, 10, 1 MiB 용량을 +차지하는 블록 11개를 결과물로 내줍니다. +.IP "" +다중\-스레드 모드에서 블록 크기는 블록 헤더에 저장합니다. 단일\-스레드 모드에서는 저장하지 않기 때문에 인코딩 처리한 출력은 +다중\-스레드 모드의 출력 결과물과는 다릅니다. +.TP +\fB\-\-flush\-timeout=\fP\fI<제한시간>\fP +압축할 때, 이전 데이터를 소거하고 다음 입력을 블록 단위로 더 읽는데 \fI<제한시간>\fP 밀리초(양의 정수값)가 지났을 +경우, 대기중이던 모든 입력 데이터를 인코더에서 소거한 다음 출력 스트림에 전달합니다. 이런 동작은 네트워크로 스트리밍한 데이터를 +\fBxz\fP로 압축할 때 쓸만합니다. \fI<제한시간>\fP 값을 적게 지정하면 적은 지연 시간에 데이터를 받아낼 수 있지만 +\fI<제한시간>\fP 값을 크게 하면 압축율을 높일 수 있습니다. +.IP "" +이 기능은 기본적으로 꺼져있습니다. 이 옵션을 한번 이상 지정하면, 마지막 옵션의 값대로 동작합니다. 특별히 +\fI<제한시간>\fP 값을 \fB0\fP으로 설정하면 이 설정을 완전히 끌 수 있습니다. +.IP "" +이 기능은 POSIX 시스템이 아닌 곳에서는 사용할 수 없습니다. +.IP "" +.\" FIXME +\fB이 기능은 여전히 시험중입니다\fP. 현재로서는, \fBxz\fP 버퍼링 처리 방식 때문에 \fBxz\fP의 실시간 스트림 압축 해제 기능 활용은 +적절하지 않습니다. +.TP +\fB\-\-no\-sync\fP +원본 파일을 제거하기 전까지는 스토릿지 장치에 대상 파일과 디렉터리를 동기화하지 않습니다. 작은 여러 파일을 압축하거나 압축해제할 때 +성능을 개선할 수 있습니다. 그러나, 삭제 과정을 진행한 다음 시스템이 바로 치명적인 오류가 나타난다면, 대상 파일을 스토릿지 장치에 +저장하지 않았지만 삭제 동작이 이루어졌을 수도 있습니다. 이 경우 원본 파일 뿐만 아니라 대상 파일도 나타나지 않습니다. +.IP "" +이 옵션은 \fBxz\fP 프로그램이 원본 파일을 삭제할 때만 동작합니다. 다른 경우에는 전혀 동기화가 이루어지지 않습니다. +.IP "" +동기화 동작과 \fB\-\-no\-sync\fP 옵션은 \fBxz\fP 5.7.1alpha에 추가했습니다. +.TP +\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP +압축 수행시 메모리 사용 한계를 지정합니다. 이 옵션을 여러번 지정하면 마지막 값을 취합니다. +.IP "" +압축 설정이 \fI<제한용량>\fP을 초과하면, \fBxz\fP는 설정 값의 하향 조정을 시도하여 한계 값을 더이상 넘치지 않게 하고 +자동 조절을 끝냈다는 알림을 표시합니다. 조정은 다음 순서대로 진행합니다. 스레드 수를 줄입니다. 다중\-스레드 모드에서 스레드 하나의 +할당 한계치가 \fI<제한용량>\fP을 넘으면 단일\-스레드 모드로 전환합니다. 그 다음 마지막으로 LZMA2 딕셔너리 크기를 +줄입니다. +.IP "" +\fB\-\-format=raw\fP 또는 \fB\-\-no\-adjust\fP 미지정 상황에서 압축할 때, 압축 데이터 출력에 영향을 주지 않고 스레드 +처리 수만 줄일 수 있습니다. +.IP "" +\fI<제한용량>\fP 값이 아래 설명한 조건에 맞지 않으면, 오류가 나타나고 \fBxz\fP 명령은 종료 상태 1번을 반환하며 +빠져나갑니다. +.IP "" +\fI<제한용량>\fP 값은 여러 방식으로 지정할 수 있습니다: +.RS +.IP \(bu 3 +\fI<제한용량>\fP 값은 바이트 용량 절대값입니다. 정수 값을 사용하되 \fBMiB\fP와 같은 접미사를 사용하는게 좋습니다. +예: \fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +\fI<제한용량>\fP 값은 총 물리 메모리(RAM) 용량의 백분율로 지정할 수도 있습니다. 다른 컴퓨터끼리 공유하는 셸 +초기화 스크립트의 \fBXZ_DEFAULTS\fP 환경 변수에 값을 설정할 때 특히 쓸만합니다. 이런 방식으로 설정하면 시스템의 메모리 설치 +용량에 따라 자동으로 늘어납니다. 예: \fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +\fI<제한용량>\fP 값은 \fB0\fP 기본값으로 설정하여 초기화할 수 있습니다. 현재로서는 \fI<제한용량>\fP +값이 \fImax\fP(최대) (메모리 사용 한계 없음) 인 상태와 동일합니다. +.RE +.IP "" +\fBxz\fP 32비트 버전에서는 몇가지 특별한 경우가 있습니다. \fI<제한용량>\fP 값이 \fB4020MiB\fP를 넘으면 +\fI<제한용량>\fP을 \fB4020MiB\fP로 고정합니다. MIPS32에서는 \fB2000MiB\fP로 대신 고정합니다. +(\fB0\fP과 \fBmax\fP는 이 경우에 해당하지 않습니다. 압축 해제시 비슷한 기능은 없습니다.) 이 경우 32비트 실행 파일이 +4GiB(MIPS32의 경우 2GiB) 주소 영역에 접근할 때 매우 용이하며, 다른 경우에는 원하는대로 문제를 일으키지 않습니다. +.IP "" +\fB메모리 활용\fP 섹션도 참고하십시오. +.TP +\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP +압축 해제시 메모리 사용 한계 용량을 설정합니다. \fB\-\-list\fP 모드에도 영향을 줍니다. \fI<제한용량>\fP을 넘기지 +않고서는 동작이 진행이 안될 경우, \fBxz\fP 에서는 오류를 나타내고 파일 압축 해제를 실패로 +간주합니다. \fI<제한용량>\fP을 지정하는 가능한 방법에 대해서는 +\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션을 참고하십시오. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP +다중\-스레드 모드 압축 해제시 메모리 사용 한계 용량을 설정합니다. 스레드 수에 영향을 줄 수도 있습니다. \fBxz\fP에서 파일 압축 +해제를 거부하게 하진 않습니다. \fI<제한용량>\fP 수치가 다중\-스레드로 처리하기에 너무 낮다면, +\fI<제한용량>\fP 값을 무시하고 \fBxz\fP 동작을 단일\-스레드 모드로 계속 진행합니다. 참고로 +\fB\-\-memlimit\-decompress\fP 옵션도 사용하면, 단일\-스레드 모드와 다중\-스레드 모드 두 경우에 모두 적용하기에, +다중\-스레드 모드에 적용할 \fI<제한용량>\fP 값은 \fB\-\-memlimit\-decompress\fP에 설정하는 제한 값보다 더 +크면 안됩니다. +.IP "" +다른 메모리 사용 용량 제한 옵션과는 달리, \fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP 옵션은 +시스템별 기본 \fI<제한용량>\fP 값을 지닙니다. 현재 설정 값은 \fBxz \-\-info\-memory\fP 명령으로 확인해볼 수 +있습니다. +.IP "" +이 옵션과 기본 값은 한계 값을 주지 않으면 스레드 기반 압축 해제 프로그램이 일부 입력 파일에 대해 정신나간 수준의 메모리 용량을 +할당해서 동작이 끝나버릴 수 있습니다. 기본 \fI<제한용량>\fP이 시스템의 사양에 비해 낮다면, +\fI<제한용량>\fP 값을 자유롭게 올리시되, \fBxz\fP 에서 적은 스레드 수에도 메모리 공간 할당을 시도하는 만큼, 입력 +파일에 적절한 수준으로 가용 RAM 용량을 넘는 큰 값을 설정하지 마십시오. 메모리나 스와핑 영역 공간이 줄어들면 압축해제 성능을 +개선하지 못합니다. +.IP "" +\fI<제한용량>\fP 값을 지정하는 가능한 방법을 보려면 +\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션을 참고하십시오. \fI<제한용량>\fP 값을 +\fB0\fP으로 설정하면 \fI<제한용량>\fP 값이 시스템 지정 기본값으로 바뀝니다. +.TP +\fB\-M\fP \fI<제한용량>\fP, \fB\-\-memlimit=\fP\fI<제한용량>\fP, \fB\-\-memory=\fP\fI<제한용량>\fP +\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP +\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP +\fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP 지정과 동일합니다. +.TP +\fB\-\-no\-adjust\fP +압축 출력 결과에 영향을 주는 설정을 조정하지 않고는 메모리 사용 용량 제한 조건이 맞지 않으면 오류를 표시하고 빠져나갑니다. 이 +옵션은 \fBxz\fP가 다중\-스레드 모드에서 단일\-스레드 모드로 전환하고 LZMA2 딕셔너리 크기를 줄이는 동작을 막아줍니다. 심지어 이 +옵션을 사용하면 메모리 사용 한계를 만족하도록 스레드 수를 줄여 압축 결과물 출력에 영향이 가지 않게 합니다. +.IP "" +원시 스트림(\fB\-\-format=raw\fP)을 만들 떄 자동 조정은 항상 꺼집니다. +.TP +\fB\-T\fP \fI<스레드수>\fP, \fB\-\-threads=\fP\fI<스레드수>\fP +활용할 작업 스레드 수를 지정합니다. \fI<스레드수>\fP 값을 \fB0\fP 값으로 설정하면, \fBxz\fP는 시스템에서 지원하는 +최대 프로세서 스레드 수를 모두 확보합니다. 실제 스레드 수는 입력 파일이 주어진 설정대로 스레드 처리를 할 만큼 그렇게 크지 않을 +경우, 내지는 더 많은 스레드를 사용했을 때 메모리 사용량 한계를 초과할 경우 \fI<스레드수>\fP 보다 적을 수 있습니다. +.IP "" +단일\-스레드와 다중\-스레드 압축 프로그램은 다른 출력 결과물을 냅니다. 단일\-스레드 압축 프로그램은 작은 파일 크기 결과물을 내놓지만, +다중\-스레드 압축 프로그램의 경우 다중\-스레드 압축 프로그램에서 내놓은 결과물은 다중\-스레드로만 압축을 해제할 수 있습니다. +\fI<스레드수>\fP를 \fB1\fP로 설정하면 단일\-스레드 모드를 사용합니다. \fI<스레드수>\fP를 \fB0\fP과 다른 +값으로 설정하면, 시스템에서 실제로 하드웨어 스레드가 1개만 지원한다 하더라도, 다중\-스레드 압축 프로그램을 사용합니다. (\fBxz\fP +5.2.x에서는 이 경우 단일\-스레드 모드를 활용합니다.) +.IP "" +단일\-스레드로 다중\-스레드 모드를 사용하려면, \fI<스레드수>\fP를 \fB+1\fP로 설정하십시오. \fB+\fP 접두사는 \fB1\fP +이외의 값에는 영향을 주지 않습니다. 메모리 사용량 한계 설정은 \fBxz\fP을 \fB\-\-no\-adjust\fP 옵션을 쓰기 전까지는 +단일\-스레드로 전환하게 합니다. \fB+\fP 접두사 지원은 \fBxz\fP 5.4.0에 추가했습니다. +.IP "" +자동 스레드 수를 요청했고 메모리 사용 한계를 지정하지 않았다면, 시스템에 맞게끔 가능한 스레드 수를 제한하는 기본 소프트 제한 값을 +사용합니다. 스레드 수가 한개가 되면 무시하는 이런 개념이 소프트 제한이기에, \fBxz\fP로 하여금 압축 동작 및 압축 해제 동작 수행시 +멈추지 않습니다. 이 가본 소프트 제한 값은 \fBxz\fP 실행 도중 다중\-스레드 모드에서 단일\-스레드 모드로 바뀌게 하지는 않습니다. +활성 제한 값은 \fBxz \-\-info\-memory\fP 명령으로 볼 수 있습니다. +.IP "" +현재 스레딩 처리 방식은 입력을 블록 단위로 쪼개고 각각의 블록을 독립적으로 압축하는 동작을 취합니다. 기본 블록 크기는 압축 수준에 +따라 다르며 \fB\-\-block\-size=\fP\fI<크기>\fP 옵션으로 재지정할 수 있습니다. +.IP "" +스레드 압축 해제 방식은 여러 블록이 블록 헤더에 넣은 크기 정보와 함께 들어간 파일에만 동작합니다. 다중\-스레드 모드에서 압축한 +충분히 큰 모든 파일은 이 조건에 만족하지만, 단일\-스레드 모드에서 압축한 파일은 +\fB\-\-block\-size=\fP\fI<크기>\fP 옵션을 지정하더라도 조건에 만족하지 않습니다. +.IP "" +\fI스레드\fP 기본 값은 \fB0\fP입니다. \fBxz\fP 5.4.x 이전의 기본값은 \fB1\fP입니다. +. +.SS "개별 압축 필터 체인 설정" +개별 필터 체인은 사전 설정에 엮인 설정에 의존하는 대신 압축 설정을 세부적으로 하나하나 설정할 수 있게 합니다. 개별 필터 체인을 +지정하면, 명령행에 앞서 지정한 사전 설정 옵션(\fB\-0\fP \&...\& \fB\-9\fP 과 \fB\-\-extreme\fP)은 무시합니다. 사전 +설정 옵션을 하나 이상의 필터 체인 옵션 다음에 지정하면, 새 사전 설정을 취하며, 앞서 지정한 개별 필터 체인 옵션은 무시합니다. +.PP +필터 체인은 명령행 파이핑에 비교할 수 있습니다. 압축할 때, 압축하지 않은 입력을 첫번째 필터로 놓고, 출력 대상(이 있으면)을 다음 +필터로 지정합니다. 최종 필터의 출력은 압축 파일로 기옥합니다. 체인의 최대 필터 수는 4이지만, 필터 체인상 필터 갯수는 보통 +1~2개입니다. +.PP +수많은 필터가 필터 체인 상에서 제약점을 가지고 있습니다. 일부 필터는 체인의 마지막 필터로만 동작하며, 일부 다른 필터는 마지막이 아닌 +필터로, 어떤 동작은 체인의 어떤 위치에든 둡니다. 필터에 따라, 이 제한은 필터 설계를 따르거나 보안 문제를 막기 위해 존재하기도 +합니다. +.PP +개별 필터 체인은 두가지 방식으로 지정할 수 있습니다. \fB\-\-filters=\fP\fI<필터>\fP와 +\fB\-\-filters1=\fP\fI<필터>\fP \&...\& \fB\-\-filters9=\fP\fI<필터>\fP 옵션으로 +liblzma 필터 문자열 문법에 따라 한가지 옵션을 필터 체인 전체를 지정할 수 있습니다. 대신, 하나 이상의 개별 필터 옵션을 +원하는 필터 체인 순서대로 지정할 수도 있습니다. 이 말인 즉슨, 개별 필터 옵션의 순서가 중요하단 뜻입니다! 원시 스트림을 디코딩할 +때(\fB\-\-format=raw\fP), 압축했을 때 지정했던 필터와 같은 순서로 필터 체인을 지정해야 합니다. 전체 체인 +옵션(\fB\-\-filters=\fP\fI<필터>\fP) 보다 우선 지정한 개별 필터 또는 사전 설정 옵션은 까먹을 수도 있습니다. +전체 체인 옵션 다음에 개별 필터를 지정할 경우 필터 체인의 동작을 무효로 합니다. +.PP +필터는 쉼표로 구분하는 필터별 \fI<옵션>\fP이 있습니다. \fI<옵션>\fP에 추가로 입력한 쉼표는 +무시합니다. 모든 옵션 값에는 기본값이 있어, 값을 바꾸려면 지정해야합니다. +.PP +전체 필터 체인과 \fI<옵션>\fP을 보려면 \fBxz \-vv\fP (\fB\-\-verbose\fP 두 번)명령을 사용하십시오. 이 +명령은 사전 설정이 사용하는 필터 체인 옵션도 볼 수 있습니다. +.TP +\fB\-\-filters=\fP\fI<필터>\fP +전체 필터 체인 또는 사전 설정을 단일 옵션으로 지정합니다. 각 필터는 공백 문자 또는 대시 문자 두번 입력(\fB\-\-\fP)으로 +구분합니다. 셸 명령행에서 \fI필터\fP는 따옴표로 감싸서 단일 옵션으로 해석하도록 해야 합니다. \fI옵션\fP을 표기하려면 \fB:\fP 또는 +\fB=\fP을 활용하십시오. 사전 설정 앞에 \fB\-\fP를 붙일 수 있고 0개 또는 하나 이상의 플래그를 붙일 수 있습니다. 유일하게 +지원하는 플래그는 \fB\-\-extreme\fP과 동일한 \fBe\fP입니다. +.TP +\fB\-\-filters1\fP=\fI<필터>\fP ... \fB\-\-filters9\fP=\fI<필터>\fP +\fB\-\-block\-list\fP와 사용할 수 있는 추가 필터 체인을 최대 9개까지 지정합니다. +.IP "" +예를 들어 텍스트 파일과 실행 파일의 아카이브를 압축할 때 실행 부분에 BCJ 필터 체인을 사용하고 텍스트 부분은 LZMA2 필터를 +사용할 수 있습니다. +.TP +\fB\-\-filters\-help\fP +\fB\-\-filters\fP와 \fB\-\-filters1=\fP\fI<필터>\fP \&...\& +\fB\-\-filters9=\fP\fI<필터>\fP 옵션의 사전 설정 필터와 개별 설정 필터 체인을 지정하는 방법을 설명하는 도움말 +메시지를 출력하고 완전히 빠져나갑니다. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fI<옵션>\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fI<옵션>\fP] +.PD +LZMA1 또는 LZMA2 필터를 필터 체인에 추가합니다. 이 필터는 필터 체인의 마지막 요소로만 사용할 수 있습니다. +.IP "" +LZMA1은 고전 필터로, LZMA1만 지원하는 고전 \fB.lzma\fP 파일 형식에서만 지원합니다. LZMA2는 LZMA1의 업데이트 +버전으로 LZMA1의 실질적 문제를 해결했습니다. \fB.xz\fP 형식은 LZMA2 필터를 사용하며 LZMA1 필터는 전적으로 지원하지 +않습니다. 압축 속도와 압축율은 LZMA1과 LZMA2가 실질적으로 동일합니다. +.IP "" +LZMA1과 LZMA2는 동일한 \fI<옵션>\fP 집합을 공유합니다: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fI<사전설정>\fP +LZMA1 또는 LZMA2의 모든 \fI<옵션>\fP을 \fI<사전설정>\fP으로 +초기화합니다. \fI<사전설정>\fP 값은 정수 값으로 이루어져 있으며, 사전 설정에 변형을 줄 떄 단일 문자가 따라올 수도 +있습니다. 정수 값은 \fB0\fP에서 \fB9\fP 까지이며, 명령행 옵션에서 \fB\-0\fP \&...\& \fB\-9\fP로 대응합니다. 변형 옵션으로 +지원하는 문자는 현재 \fBe\fP 뿐이며, \fB\-\-extreme\fP에 대응합니다. \fI<사전설정>\fP 값을 지정하지 않으면, +LZMA1 또는 LZMA2 기본값을 사전 설정 \fB6\fP에서 가져온 \fI<옵션>\fP으로 취합니다. +.TP +\fBdict=\fP\fI<크기>\fP +딕셔너리(기록 버퍼) \fI<크기>\fP는 최근 처리한 비압축 데이터를 바이트 단위로 메모리에 얼마나 유지하는지 나타냅니다. +알고리즘은 비압축 데이터상 바이트 시퀀스(일치 항목) 반복 탐색을 시도하며, 해당 부분을 딕셔너리의 현재 참조로 치환합니다. 딕셔너리가 +크면 일치하는 항목을 찾을 기회가 더 많아집니다. 따라서, 딕셔너리 \fI<크기>\fP를 더욱 크게 설정하면 압축율을 증가할 +수는 있지만, 압축하지 않은 파일보다 딕셔너리가 크면 메모리 낭비율이 올라갑니다. +.IP "" +보통 딕셔너리 \fI<크기>\fP는 64KiB 에서 64MiB 정도 됩니다. 최소 4KiB 입니다. 압축시 최대 용량은 현재 +1.5GiB(1536MiB)로 나타납니다. 압축 해제 프로그램에도 4GiB 미만으로 딕셔너리 크기를 이미 지원하며 4GiB 라는 수치는 +LZMA1과 LZMA2 스트림 형식의 최대값입니다. +.IP "" +딕셔너리 \fI<크기>\fP와 검색기(\fImf\fP)는 LZMA1 또는 LZMA 인코더의 메모리 사용량을 함께 결정합니다. +동일한(또는 더 큰) 딕셔너리 \fI<크기>\fP가 데이터를 압축했을 때만큼 압축 해제할 떄 필요하기 때문에, 디코더의 메모리 +사용량은 압축할 때의 딕셔너리 크기로 결정합니다. \fB.xz\fP 헤더에는 딕셔너리 \fI<크기>\fP를 2^\fIn\fP 또는 +2^\fIn\fP + 2^(\fIn\fP\-1) 으로 저장하기에, 이 \fI<크기>\fP 값을 압축할 때 선호하는 편입니다. 다른 +\fI<크기>\fP 값은 \fB.xz\fP 헤더에 저장할 때 반올림합니다. +.TP +\fBlc=\fP\fIlc\fP +리터럴 컨텍스트 비트 수를 지정합니다. 최소 값은 0이고 최대 값은 4입니다. 기본 값은 3입니다. 추가로, \fIlc\fP 값과 +\fIlp\fP 값의 합은 4를 넘으면 안됩니다. +.IP "" +조건이 일치하지 않아 인코딩할 수 없는 모든 바이트는 리터럴로 인코딩합니다. 이 말인 즉슨, 간단히 8비트 바이트로서의 리터럴을 한번에 +하나씩 인코딩합니다. +.IP "" +리터럴 코딩을 할 때 이전 비압축 바이트와 다음 바이트와의 관련성을 가진 가장 많은 \fIlc\fP 비트 수를 가정합니다. 예를 들면, 보통 +영문 문장의 경우 대문자 다음에 종종 소문자가 오고, 소문자 다음에 다른 소문자가 따라옵니다. US\-ASCII 문자 세트에서는 가장 긴 +비트 3개는 대문자에 대해 010, 소문자에 대해 011입니다. \fIlc\fP 값이 최소한 3이면, 리터럴 코딩시 비압축 데이터에 대해 +이런 속성의 장점을 취할 수 있습니다. +.IP "" +(어쨌거나) 기본값 (3)은 보통 적절합니다. 최대 압축을 원한다면 \fBlc=4\fP 값을 시험해보십시오. 때로는 약간 도움이 되기도 +하겠지만, 오히려 결과가 안좋을 수도 있습니다. 결과가 엄한 방향으로 간다면, \fBlc=2\fP 값도 시험해보십시오. +.TP +\fBlp=\fP\fIlp\fP +리터럴 위치 비트 수를 지정하빈다. 최소 값은 0이고 최대 값은 4입니다. 기본 값은 0입니다. +.IP "" +\fIlp\fP 값은 리터럴 인코딩 진행시 비압축 데이터 정렬 방식 고려에 영향을 줍니다. 정렬 방식에 대한 자세한 정보는 하단 \fIpb\fP를 +참고하십시오. +.TP +\fBpb=\fP\fIpb\fP +위치 비트 수를 지정합니다. 최소 값은 0이며 최대 값은 4입니다. 기본값은 2입니다. +.IP "" +\fIpb\fP 값은 보통 압축하지 않은 데이터에 어떤 정렬 방식을 고려하느냐에 영향을 줍니다. 기본적으로 4바이트 +정렬(2^\fIpb\fP=2^2=4)을 의미하는데, 이보다 더 나은 추측 값이 없어서 종종 최적의 선택으로 간주합니다. +.IP "" +정렬 상태를 알지 못할 경우, \fIpb\fP 설정 값이 파일 크기를 조금 줄일 수 있습니다. 예를 들면, 텍스트 파일이 단일 바이트 단위로 +정돈된 상태(US\-ASCII, ISO\-8859\-*, UTF\-8)라면, \fBpb=0\fP 설정 값으로 압축율을 조금 개선할 수 있습니다. +UTF\-16 텍스트의 경우, \fBpb=1\fP 설정 값이 좋은 선택입니다. 정렬 바이트가 3 바이트 같은 홀수 바이트일 경우, +\fBpb=0\fP 설정 값이 최적의 선택일지도 모릅니다. +.IP "" +가정 정렬을 \fIpb\fP 값과 \fIlp\fP 값으로 조정하긴 하지만, LZMA1과 LZMA2는 여전히 16바이트 정렬 방식으로 선호합니다. +LZMA1 또는 LZMA2로 종종 압축하는 파일 형식이라고 하면 고려해볼만 합니다. +.TP +\fBmf=\fP\fImf\fP +일치 검색기는 인코더 속도, 메모리 사용량, 압축율에 주된 영향을 줍니다. 보통 해시 체인 검색기는 이진 트리 검색기보다 빠르긴 +합니다. 기본 값은 \fI<사전설정>\fP에 따라 다릅니다. 0은 \fBhc3\fP을, 1\(en3은 \fBhc4\fP를, 나머지는 +\fBbt4\fP를 활용합니다. +.IP "" +다음 검색 필터를 지원합니다. 메모리 사용 공식은 \fIdict\fP 값이 2의 승수일 경우 실제에 가까운 근사치입니다. +.RS +.TP +\fBhc3\fP +2바이트, 3바이트 해싱 체인 +.br +\fInice\fP 최소값: 3 +.br +메모리 사용: +.br +\fIdict\fP * 7.5 (조건: \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 5.5 + 64 MiB (조건: \fIdict\fP > 16 MiB) +.TP +\fBhc4\fP +2바이트, 3바이트, 4바이트 해싱 체인 +.br +\fInice\fP 최소값: 4 +.br +메모리 사용: +.br +\fIdict\fP * 7.5 (조건: \fIdict\fP <= 32 MiB); +.br +\fIdict\fP * 6.5 (조건: \fIdict\fP > 32 MiB) +.TP +\fBbt2\fP +2바이트 해싱 이진 트리 +.br +\fInice\fP 최소값: 2 +.br +메모리 사용: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +2바이트, 3바이트 해싱 이진트리 +.br +\fInice\fP 최소값: 3 +.br +메모리 사용: +.br +\fIdict\fP * 11.5 (조건: \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 9.5 + 64 MiB (조건: \fIdict\fP > 16 MiB) +.TP +\fBbt4\fP +2바이트, 3바이트, 4바이트 해싱 이진 트리 +.br +\fInice\fP 최소값: 4 +.br +메모리 사용: +.br +\fIdict\fP * 11.5 (조건: \fIdict\fP <= 32 MiB); +.br +\fIdict\fP * 10.5 (조건: \fIdict\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fI<모드>\fP +압축 \fI<모드>\fP 값은 일치 검색기에서 생산하는 데이터 분석 방식을 지정합니다. 지원하는 \fI<모드>\fP는 +\fBfast\fP와 \fBnormal\fP 입니다. 기본값은 \fI<사전설정>\fP값 0\(en3에 대해 \fBfast\fP, +\fI<사전설정>\fP값 4\(en9에 대해 \fBnormal\fP입니다. +.IP "" +보통 \fBfast\fP는 해시 체인 검색기에서 사용하며 \fBnormal\fP은 이진 트리 검색기에서 사용합니다. 이 동작은 또한 +\fI<사전설정>\fP 값이 할 일이기도 합니다. +.TP +\fBnice=\fP\fInice\fP +일치하는 nice 길이를 지정합니다. 최소한 \fInice\fP 바이트 정도 일치하면, 알고리즘이 가능한 최선의 부분을 찾는 동작을 +멈춥니다. +.IP "" +\fInice\fP 값은 2\(en273 바이트입니다. 값이 클 수록 속도 면에서는 손해를 보겠지만 압축율은 더욱 올라갑니다. 기본 값은 +\fI<사전설정>\fP값에 따라 다릅니다. +.TP +\fBdepth=\fP\fI<깊이>\fP +일치 검색기에서의 최대 검색 깊이를 지정합니다. 기본값은 특별한 값 0으로 지정하며, 이 값으로 압축 프로그램이 \fImf\fP 와 +\fInice\fP간 적절한 \fI<깊이>\fP 값을 결정합니다. +.IP "" +적절한 해시 체인 \fI<깊이>\fP 값은 이진 트리에서 4\(en100 그리고 16\(en1000 입니다. 상당히 큰 값을 +\fI<깊이>\fP 값으로 사용하면 일부 파일에 대해 인코더가 매우 느리게 동작할 수가 있습니다. 압축 시간이 너무 오래걸려서 +동작을 중간에 끊을 준비가 되지 않은 이상 \fI<깊이>\fP 설정 값은 1000을 넘지 않게하십시오. +.RE +.IP "" +원시 스트림(\fB\-\-format=raw\fP)을 디코딩할 때, LZMA2는 딕셔너리 \fI<크기>\fP만 필요합니다. LZMA1는 +\fIlc\fP, \fIlp\fP, \fIpb\fP 값이 모두 필요합니다. +.TP +\fB\-\-x86\fP[\fB=\fP\fI<옵션>\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIoptions\fP] +.PD +브랜치/호출/점프(BCJ) 필터를 필터 체인에 추가합니다. 이 필터는 필터 체인의 비종결 필터로만 사용할 수 있습니다. +.IP "" +BCJ 필터는 머신 코드의 상대 주소를 절대 주소로 변환합니다. 데이터 크기를 바꾸지는 않지만 LZMA2에서 \fB.xz\fP 파일을 +0\(en15% 정도 줄여주게 하는 중복성이 늘어납니다. BCJ 필터는 언제든 뒤집을 수 있어, 데이터에 적절하지 않은 BCJ 필터 +형식을 활용하면, 그냥 가만히 두면 압축율이 약간 떨어지게 한다 하더라도, 데이터를 잃을 수가 있습니다. BCJ 필터는 굉장히 빠르며 +메모리 공간을 적게 활용합니다. +.IP "" +이 BCJ 필터에는 압축율 관련 몇가지 문제가 있습니다: +.RS +.IP \(bu 3 +실행 코드가 들어있는 몇가지 파일 형식(예: 목적 파일, 정적 라이브러리, 리눅스 커널 모듈)의 경우 필터 값으로 채운 명령 주소가 +있습니다. 여기 BCJ 필터의 경우 파일의 압축율을 떨어뜨리는 주소 변환을 수행합니다. +.IP \(bu 3 +BCJ 필터를 아카이브에 적용하면, BCJ 필터를 사용하지 않았을 때보다 압축율이 떨어질 수가 있습니다. 예를 들면, 유사하거나 동일한 +실행 파일 여럿이 있으면 필터를 사용하여 파일을 덜 비슷하게 만들어 압축율이 떨어지게 합니다. 동일한 아카이브 파일에서 비 실행 파일의 +내용에 대해서도 비슷한 일이 벌어질 수 있습니다. 실제로 하나는 BCJ 필터를 걸고 하나는 제외하여 각 경우에 대해 어떤 경우가 결과가 +우수한 지 살펴보겠습니다. +.RE +.IP "" +다른 명령 세트는 다른 정렬 상태에 놓여있습니다. 실행 파일은 필터가 제대로 동작하게 하려면 입력 데이터에 있는 이 값의 배수로 +정돈해야합니다. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +필터;정렬;참고 +x86;1;32\-bit 또는 64\-bit x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096 바이트 정렬이 가장 좋습니다 +PowerPC;4;빅엔디안 전용 +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +BCJ 필터를 사용한 데이터는 LZMA2로 보통 압축하기 때문에 LZMA2 옵션을 선택한 BCJ 필터의 정렬기준에 맞추도록 설정하면 +압축율을 좀 더 개선할 수 있습니다. 예를 들면: +.RS +.IP \(bu 3 +IA\-64 필터는 16\-바이트 정렬 방식으로 동작하기에 LZMA2 필터에 \fBpb=4,lp=4,lc=0\fP 옵션(2^4=16)을 주는게 +좋습니다. +.IP \(bu 3 +RISC\-V 코드에는 16\-비트 압축 명령(C 확장) 적재 여부에 따라 2\-바이트 또는 4\-바이트 정렬 방식을 채택합니다. 16\-비트 +명령을 사용하면, \fBpb=2,lp=1,lc=3\fP 또는 \fBpb=1,lp=1,lc=3\fP 옵션 값 사용이 바람직합니다. 16\-비트 명령이 +없다면, \fBpb=2,lp=2,lc=2\fP 옵션 값을 활용하는게 좋습니다. "RVC"가 "Flags"행에 나타나는지 확인할 때 +\fBreadelf \-h\fP 명령을 사용할 수 있습니다. +.IP \(bu 3 +ARM64는 항상 4\-바이트 정렬 방식을 택하기에 \fBpb=2,lp=2,lc=2\fP 옵션 값을 활용하는게 좋습니다. +.IP \(bu 3 +x86 필터는 예외입니다. x86 실행 파일을 압축할 경우에는 보통 LZMA2 기본 옵션 값(\fBpb=2,lp=0,lc=3\fP)을 그대로 +사용하는게 좋습니다. +.RE +.IP "" +모든 BCJ 필터는 동일한 \fI옵션\fP을 지원합니다: +.RS +.TP +\fBstart=\fP\fI<오프셋>\fP +상대 주소와 절대 주소를 변환할 때 사용할 시작 \fI<오프셋>\fP을 지정합니다. \fI<오프셋>\fP에는 필터 +정렬 배수여야 합니다(상단 테이블 참조). 기본값은 0입니다. 실제로 기본값이 낫습니다. 개별 \fI<오프셋>\fP 지정 +값은 거의 쓸모가 없습니다. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fI<옵션>\fP] +필터 체인에 델타 필터를 추가합니다. 델타 필터는 필터 체인에서 마지막에 지정하지 않은 필터로만 사용할 수 있습니다. +.IP "" +현재로서는 바이트 단위 단순 델타계산 결과만 보여줍니다. 예를 들면, 압축하지 않은 비트맵 그림 또는 압축하지 않은 PCM 오디오를 +압축할 때 쓸만합니다. 그러나 특별한 목적으로 활용하는 알고리즘은 델타 + LZMA2 보다 더 나은 결과를 가져다 주기도 합니다. +이는 특히 오디오의 경우 맞는 이야기인데, \fBflac\fP(1)의 경우 더 빠르고 우수한 압축율을 보여줍니다. +.IP "" +지원 \fI옵션\fP: +.RS +.TP +\fBdist=\fP\fI<차이>\fP +바이트 단위 델터 계산 \fI<차이>\fP를 지정합니다. \fI<차이>\fP값은 1\(en256 이어야합니다. 기본 +값은 1입니다. +.IP "" +예를 들어, \fBdist=2\fP 옵션과 A1 B1 A2 B3 A3 B5 A4 B7 입력 값을 주면, 출력 값은 A1 B1 01 02 01 +02 01 02 입니다. +.RE +. +.SS "기타 옵션" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +경고 및 알림을 끕니다. 두 번 지정하면 오류 메시지 표시도 끕니다. 이 옵션은 종료 상태에 영향을 주지 않습니다. 경고 표시를 +끄더라도, 종료 상태에서는 여전히 경고가 나타났음을 알려줍니다. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +출력 내용이 많아집니다. 표준 오류를 터미널에 연결했다면 \fBxz\fP는 진행 표시를 나타냅니다. \fB\-\-verbose\fP를 두번 지정하면 +더 많은 내용을 표시합니다. +.IP "" +진행 표시에서는 다음 정보를 나타냅니다: +.RS +.IP \(bu 3 +입력 파일의 크기를 알고 있을 경우 완료 백분율. 파이프 처리시에는 백분율을 나타낼 수 없습니다. +.IP \(bu 3 +산출 압축 데이터 용량 (압축) 또는 소모 공간 용량 (압축 해제). +.IP \(bu 3 +비압축 데이터 소모 용량 (압축) 또는 산출 용량 (압축 해제). +.IP \(bu 3 +압축 데이터 산출 용량을 비압축 데이터 처리 용량으로 나누어 계산한 압축율. +.IP \(bu 3 +압축 또는 압축 해제 속도. 초당 비압축 데이터 소모량(압축) 또는 산출 용량(압축 해제)를 측정한 값입니다. \fBxz\fP에서 파일 +처리를 시작한 몇 초 후 나타납니다. +.IP \(bu 3 +경과 시간 형식은 M:SS 또는 H:MM:SS 입니다. +.IP \(bu 3 +추산 여분 시간은 \fBxz\fP가 파일을 처리하기 시작한 이후 입력 파일의 크기를 알고 몇 초가 지난 후에야 보여줍니다. 시간은 콜론 +문자를 사용하지 않고 덜 자세한 형식으로, 예를 들면, 2분 30초 와 같은 형식으로 보여줍니다. +.RE +.IP "" +표준 오류가 터미널이 아니라면 \fB\-\-verbose\fP는 \fBxz\fP에서 파일 이름, 압축 크기, 압축 해제 용량, 압축율, 그리고 +가능하다면 파일을 압축 또는 압축 해제한 후 표준 오류로 속도와 걸린 시간을 나타내도록 합니다. 속도와 걸린 시간 정보는 동작을 +처리하는데 최소한 몇초 정도 소요했을 경우에만 들어갑니다. 동작이 끝나지 않았다면, 이를테면 사용자의 중단 요청이 있었을 경우 입력 +파일의 크기를 알고 있을 때 압축 백분율 정보도 들어갑니다. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +경고로 알릴 만한 상황을 만났다 하더라도 종료 상태 2번을 설정하지 않습니다. 이 옵션은 출력 수준에 영향을 주지 않기 때문에, +\fB\-\-quiet\fP 옵션과 \fB\-\-no\-warn\fP 옵션을 경고 표시를 막고 종료 상태를 바꾸지 않을 목적으로 사용합니다. +.TP +\fB\-\-robot\fP +머신에서 해석할 형식으로 메시지를 나타냅니다. liblzma 대신 \fBxz\fP를 활용하려는 다양상 스크립트로서의 프론트엔드를 쉽게 +작성하도록 하기 위함입니다. 이 옵션을 지정한 출력은 \fBxz\fP 릴리스가 어떻게 되든 안정 버전이란 의미입니다. 자세한 내용은 +\fB로봇 모드\fP 섹션을 참고하십시오. +.TP +\fB\-\-info\-memory\fP +압축 및 압축 해제시 물리 메모리 용량 (RAM), \fBxz\fP에서 파악하는 프로세서 스레드 갯수, 메모리 사용량 한계를 파악하기 쉬운 +형식으로 나타내고 무사히 나갑니다. +.TP +\fB\-h\fP, \fB\-\-help\fP +보통 사용하는 옵션을 설명하는 도움말 메시지를 출력한 후, 완전히 빠져나갑니다. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +\fBxz\fP의 모든 기능을 설명하는 도움말 메시지를 출력한 후, 완전히 빠져나갑니다 +.TP +\fB\-V\fP, \fB\-\-version\fP +\fBxz\fP와 liblzma 버전 번호를 가독 형식으로 출력합니다. 기계 해석 가능 형식을 가져오려면 \fB\-\-version\fP 앞에 +\fB\-\-robot\fP을 지정하십시오. +. +.SH "로봇 모드" +로봇 모드는 \fB\-\-robot\fP 옵션으로 동작합니다. \fBxz\fP 출력을 다른 프로그램에서 해석하기 쉽게 해줍니다. 현재로서는 +\fB\-\-robot\fP 옵션은 \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, \fB\-\-version\fP +옵션하고만 사용할 수 있습니다. 앞으로는 압축 및 압축 해제 동작에 대해서도 지원합니다. +. +.SS "목록 모드" +\fBxz \-\-robot \-\-list\fP 명령은 탭으로 구분한 출력 형태를 활용합니다. 모든 행의 첫번째 컬럼에는 해당 행에서 찾을 수 +있는 정보의 형식을 나타냅니다: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +이 행은 항상 파일 목록 시작 부분의 첫번째 줄에 있습니다. 이 행의 두번째 컬럼에 파일 이름이 들어있습니다. +.TP +\fBfile\fP +이 행에는 \fB.xz\fP 파일의 전반적인 정보가 들어있습니다. 이 행은 항상 \fBname\fP 행 다음에 있습니다. +.TP +\fBstream\fP +이 행 형식은 \fB\-\-verbose\fP 옵션을 지정했을 때만 사용합니다. \fB.xz\fP 파일의 \fBstream\fP 행 수만큼 나타납니다. +.TP +\fBblock\fP +이 행 형식은 \fB\-\-verbose\fP 옵션을 지정했을 때만 사용합니다. \fB.xz\fP 파일의 블록 수만큼 \fBblock\fP 행이 +나타납니다. \fBblock\fP 행은 모든 \fBstream\fP 행 다음에 나타납니다. 다른 형식의 행이 끼어들지는 않습니다. +.TP +\fBsummary\fP +이 행 형식은 \fB\-\-verbose\fP 옵션을 두번 지정했을 때만 사용합니다. 이 행은 모든 \fBblock\fP 행 다음에 출력합니다. +\fBfile\fP 행과 비슷하게, \fBsummary\fP 행에는 \fB.xz\fP 파일의 전반적인 정보가 담겨있습니다. +.TP +\fBtotals\fP +이 행은 목록 출력의 가장 마지막에 항상 나타납니다. 총 갯수와 크기를 나타냅니다. +.PP +\fBfile\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +파일 스트림 갯수 +.IP 3. 4 +스트림의 블록 총 갯수 +.IP 4. 4 +파일 압축 크기 +.IP 5. 4 +파일 압축 해제 크기 +.IP 6. 4 +예를 들면, \fB0.123\fP과 같은 압축율 입니다. 비율이 9.999라면, 대시 문자 3개 (\fB\-\-\-\fP)를 비율 값 대신 나타냅니다. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +쉼표로 구분한 무결성 검사 이름 목록입니다. \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP, \fBSHA\-256\fP 문자열을 알려진 +검사 형식으로 사용합니다. 알 수 없는 검사 형식에 대해서는 \fBUnknown\-\fP\fIN\fP을 사용하며, 여기서 \fIN\fP은 (한 두자리) +정수형 숫자값으로 이루어진 검사 ID 입니다. +.IP 8. 4 +파일의 스트림 패딩 총 길이 +.RE +.PD +.PP +\fBstream\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +스트림 번호 (첫 스트림은 1번) +.IP 3. 4 +스트림의 블록 총 갯수 +.IP 4. 4 +압축 시작 오프셋 +.IP 5. 4 +비압축 시작 오프셋 +.IP 6. 4 +압축 크기 (스트림 패딩 미포함) +.IP 7. 4 +압축 해제 용량 +.IP 8. 4 +압축율 +.IP 9. 4 +무결성 검사 이름 +.IP 10. 4 +스트림 패딩 길이 +.RE +.PD +.PP +\fBblock\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +이 블록이 들어간 스트림 갯수 +.IP 3. 4 +스트림 시작 부분의 블록 번호 (첫번째 블록은 1번) +.IP 4. 4 +파일 시작 부분의 블록 번호 +.IP 5. 4 +파일 시작 부분의 압축 시작 오프셋 +.IP 6. 4 +파일 시작 부분의 비압축 시작 오프셋 +.IP 7. 4 +총 블록 압축 크기 (헤더 포함) +.IP 8. 4 +압축 해제 용량 +.IP 9. 4 +압축율 +.IP 10. 4 +무결성 검사 이름 +.RE +.PD +.PP +\fB\-\-verbose\fP를 두 번 지정하면, 추가 컬럼을 \fBblock\fP 행에 넣습니다. \fB\-\-verbose\fP 단일 지정시에는 이 +정보를 볼 때 탐색을 여러번 수행해야 하기 때문에 실행 과정이 느려질 수 있어서 나타내지 않습니다: +.PD 0 +.RS +.IP 11. 4 +16진수 무결성 검사값 +.IP 12. 4 +블록 헤더 크기 +.IP 13. 4 +블록 플래그: \fBc\fP는 압축 크기가 현재 값임을 나타내고, \fBu\fP는 압축 전 원본 크기가 현재 값임을 나타냅니다. 플래그를 설정하지 +않았다면, 문자열 길이를 유지할 목적으로 대시 \fB\-\fP 를 대신 나타냅니다. 새 플래그는 나중에 문자열 끝 부분에 추가할 예정입니다. +.IP 14. 4 +블록에 압축 해서 넣은 데이터의 실제 츠기 (블록 헤더, 블록 패딩, 검사 필드 제외) +.IP 15. 4 +이 \fBxz\fP 버전에서 이 블록의 압축을 해제할 때 필요한 (바이트 단위) 메모리 용량 +.IP 16. 4 +필터 체인. 대부분 사용하는 옵션은 압축 해제시 필요한 옵션만을 \fB.xz\fP 헤더에 저장하기 때문에 압축 시간에 알 수 없습니다. +.RE +.PD +.PP +\fBsummary\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +이 \fBxz\fP 버전에서 이 파일 압축을 해제할 때 필요한 (바이트 단위) 메모리 용량 +.IP 3. 4 +모든 블록 헤더에 압축 크기와 압축 전 원본 크기 정보가 들어갔는지 여부를 나타내는 \fByes\fP 또는 \fBno\fP 값 +.PP +\fBxz\fP \fI5.1.2alpha\fP \fI부터:\fP +.IP 4. 4 +파일 압축 해제시 필요한 최소 \fBxz\fP 버전 +.RE +.PD +.PP +\fBtotals\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +스트림 갯수 +.IP 3. 4 +블록 갯수 +.IP 4. 4 +압축 크기 +.IP 5. 4 +압축 해제 용량 +.IP 6. 4 +평균 압축율 +.IP 7. 4 +파일에 들어 있어 쉼표로 구분한 무결성 검사 이름 목록 +.IP 8. 4 +스트림 패딩 길이 +.IP 9. 4 +파일 갯수. \fBfile\fP 행의 컬럼 순서를 따라갑니다. +.PD +.RE +.PP +\fB\-\-verbose\fP 옵션을 두 번 지정하면, \fBtotals\fP 행에 추가 컬럼이 들어갑니다: +.PD 0 +.RS +.IP 10. 4 +이 \fBxz\fP 버전에서 파일 압축을 해제할 떄 필요한 (바이트 단위) 최대 메모리 사용량 +.IP 11. 4 +모든 블록 헤더에 압축 크기와 압축 전 원본 크기 정보가 들어갔는지 여부를 나타내는 \fByes\fP 또는 \fBno\fP 값 +.PP +\fBxz\fP \fI5.1.2alpha\fP \fI부터:\fP +.IP 12. 4 +파일 압축 해제시 필요한 최소 \fBxz\fP 버전 +.RE +.PD +.PP +차후 버전에서는 새 행 형식을 추가하고 기존 행 형식에 추가할 수 있는 새 컬럼을 넣기 까지는 알 수 있겠지만, 기존 컬럼은 바꾸지 않을 +예정입니다. +. +.SS "필터 도움말" +\fBxz \-\-robot \-\-filters\-help\fP 는 다음 형식의 지원 필터 목록을 출력합니다: +.PP +\fI<필터>\fP\fB:\fP\fI<옵션>\fP\fB=<\fP\fI값\fP\fB>,\fP\fI<옵션>\fP\fB=<\fP\fI값\fP\fB>\fP... +.TP +\fI<필터>\fP +필터 이름 +.TP +\fI<옵션>\fP +필터별 옵션 이름 +.TP +\fI<값>\fP +숫자 \fI값\fP 범위는 \fB<\fP\fI최소\fP\fB\-\fP\fI최대\fP\fB>\fP입니다. 문자열 \fI값\fP은 \fB< >\fP 범위 +내에서 선택하며 \fB|\fP 문자로 구분합니다. +.PP +각 필터는 한 줄에 하나씩 출력합니다. +. +.SS "메모리 제한 정보" +\fBxz \-\-robot \-\-info\-memory\fP 명령은 탭으로 나뉜 여러 컬럼을 단일 행으로 나타냅니다: +.IP 1. 4 +물리 메모리(RAM)의 바이트 단위 총량. +.IP 2. 4 +압축 진행시 바이트 단위 메모리 사용 한계값 (\fB\-\-memlimit\-compress\fP). 특수 값 \fB0\fP은 단일\-스레드 모드에서 +제한을 두지 않는 기본 설정임을 나타냅니다. +.IP 3. 4 +압축 해제시 바이트 단위 메모리 사용 한계값 (\fB\-\-memlimit\-decompress\fP). 특수 값 \fB0\fP은 단일\-스레드 모드에서 +제한을 두지 않는 기본 설정임을 나타냅니다. +.IP 4. 4 +\fBxz\fP 5.3.4alpha 이후: 다중\-스레드 기반 압축 해제시 바이트 단위 메모리 +사용량(\fB\-\-memlimit\-mt\-decompress\fP). 분명하게 제한을 걸어두지 않았을 경우 5번째 컬럼에 나타난 시스템별 +기본값을 사용하기 때문에 0 값을 지정하면 안됩니다. 또한 \fB\-\-memlimit\-mt\-decompress\fP로 세번째 컬럼 값보다 더 +크게 지정을 한다 할지라도 이 값이 세번째 컬럼 값보다 크면 안됩니다. +.IP 5. 4 +\fBxz\fP 5.3.4alpha 이후: A system\-specific default memory usage limit that is +used to limit the number of threads when compressing with an automatic +number of threads (\fB\-\-threads=0\fP) and no memory usage limit has been +specified (\fB\-\-memlimit\-compress\fP). This is also used as the default value +for \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +\fBxz\fP 5.3.4alpha 이후: Number of available processor threads. +.PP +차후, \fBxz \-\-robot \-\-info\-memory\fP 출력에는 더 많은 내용이 들어가지만, 한 줄 이상은 넘어가지 않습니다. +. +.SS 버전 +\fBxz \-\-robot \-\-version\fP 은 \fBxz\fP 와 liblzma의 버전 번호를 다음 형식으로 나타냅니다: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +주 버전. +.TP +\fIYYY\fP +부 버전. 짝수가 안정 버전입니다. 홀수는 알파 또는 베타 버전입니다. +.TP +\fIZZZ\fP +안정 릴리스의 패치 수준 또는 개발 릴리스의 횟수입니다. +.TP +\fIS\fP +안정도. 0은 알파 버전, 1은 베타 버전을 나타내며, 2는 안정 버전을 나타냅니다. \fIS\fP는 \fIYYY\fP 값이 짝수라 해도 항상 +2여야 합니다. +.PP +\fBxz\fP 명령과 liblzma이 동일한 XZ 유틸리티 릴리스에서 나왔다면 두 행의 \fIXYYYZZZS\fP 값은 같습니다. +.PP +예제: 4.999.9beta는 \fB49990091\fP이며, 5.0.0은 \fB50000002\fP입니다. +. +.SH "종료 상태" +.TP +\fB0\fP +모든 상태 양호. +.TP +\fB1\fP +오류 발생. +.TP +\fB2\fP +눈여겨볼 경고가 나타났지만, 실제 오류는 일어나지 않음. +.PP +표준 오류에 출력하는 알림(경고 또는 오류 아님)는 종료 상태에 영향을 주지 않습니다. +. +.SH 환경 +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP는 빈칸으로 구분한 옵션 값 목록을 \fBXZ_DEFAULTS\fP, \fBXZ_OPT\fP 환경 변수에서 순서대로, 명령행에서 옵션을 +해석하기 전에 불러옵니다. 참고로 환경 변수에서 옵션만 해석하며, 옵션이 아닌 부분은 조용히 무시합니다. 해석은 +\fBgetopt_long\fP(3)으로 가능하며, 명령행 인자로 활용하기도 합니다. +.PP +\fB경고:\fP 환경 변수를 설정하면, 프로그램과 \fBxz\fP를 실행하는 스크립트의 동작이 바뀝니다. 대부분의 경우 메모리 사용 제한량, +스레드 수, 압축 옵션을 환경 변수로 설정하는게 안전합니다. 그러나 일부 옵션은 스크립트의 동작을 망가뜨릴 수 있습니다. 분명한 +예제로는 \fBxz\fP에서 파일의 압축 및 해제 대신 도움말 내용을 표시하는 \fB\-\-help\fP 옵션이 있습니다. 좀 더 묘한 예제로는 +\fB\-\-quiet\fP 와 \fB\-\-verbose\fP 옵션이 있습니다. 대부분의 경우 \fB\-\-verbose\fP 옵션을 사용하여 프로세스 상황을 +표시하는데 잘 동작하지만, 어떤 경우에는 추가 메시지가 나타나는 문제가 있습니다. 출력 상세 수준은 \fB\-\-list\fP의 동작에도 영향을 +줍니다. +.TP +\fBXZ_DEFAULTS\fP +사용자별, 시스템 범위 기본 옵션입니다. 보통 \fBxz\fP의 메모리 사용량 제한을 기본으로 걸어두거나 기본 스레드 수를 설정할 경우 셸 +초기화 스크립트에 설정합니다. 셸 초기화 스크립트와 별도의 유사한 경우를 제외하고라면, 스크립트에서는 \fBXZ_DEFAULTS\fP 환경 +변수를 설정하지 않거나 설정을 해제해야합니다. +.TP +\fBXZ_OPT\fP +\fBxz\fP 명령행으로 옵션 설정 값을 직접 전달할 수 없을 경우 \fBxz\fP에 옵션을 전달하는 환경 변수입니다. 예를 들어, \fBxz\fP를 +스크립트 또는 도구에서 실행할 경우 GNU \fBtar\fP(1) 라면: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +예를 들면, 스크립트에서 \fBXZ_OPT\fP 를 활용하여, 스크립트별로 기본 압축 옵션을 지정할 수 있습니다. 적절한 이유가 있다면 +\fBXZ_OPT\fP 옵션 값을 사용자가 바꾸는걸 추천합니다. 예를 들면, \fBsh\fP(1) 스크립트에서 다음처럼 활용할 수도 있습니다: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "LZMA 유틸리티 호환성" +\fBxz\fP의 명령행 문법은 실제로 LZMA 유틸리티 4.32.x에서 찾을 수 있는 \fBlzma\fP, \fBunlzma\fP \fBlzcat\fP의 +상위 집합입니다. 대부분의 경우 LZMA 유틸리티를 XZ 유틸리티로 기존에 작성한 스크립트를 깨지 않고도 바꿀 수 있습니다. 몇가지 +비호환성 문제 때문에 문제가 일어날 수는 있습니다. +. +.SS "압축 사전 설정 단계" +압축 수준 사전 설정의 번호 부여 방식은 \fBxz\fP와 LZMA 유틸리티가 동일하지 않습니다. 가장 중요한 차이는 다른 사전 설정에 대해 +딕셔너리 크기를 어떻게 대응했느냐 여부입니다. 딕셔너리 크기는 압축 해제시 메모리 사용량과 거의 비슷합니다. +.RS +.PP +.TS +tab(;); +c c c +c n n. +단계;xz;LZMA 유틸리티 +\-0;256 KiB;없음 +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +딕셔너리 크기 차이는 압축 프로그램 메모리 사용에 영향을 주지만, LZMA 유틸리티와 XZ 유틸리티에서 사용량이 늘어나는 다른 차이점이 +있습니다: +.RS +.PP +.TS +tab(;); +c c c +c n n. +단계;xz;LZMA 유틸리티 4.32.x +\-0;3 MiB;없음 +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +XZ 유틸리티의 기본 사전 설정 수준값은 \fB\-6\fP이지만 LZMA 유틸리티의 기본 사전 설정 수준값은 \fB\-7\fP입니다. 두 프로그램의 +딕셔너리 메모리 기본 사용량은 8MiB입니다. +. +.SS "스트림 vs 비스트림 .lzma 파일" +파일을 압축하지 않은 크기는 \fB.lzma\fP 헤더에 저장합니다. LZMA 유틸리티는 일반 파일을 압축할 때 압축하지 않은 파일의 크기를 +저장합니다. 이 대신 압축하지 않은 크기를 '알 수 없음' 으로 저장하고 압축 해제 프로그램이 멈춰야 할 지점에 +end\-of\-payload 마커를 사용하는 방법도 있습니다. LZMA 유틸리티는 파이프로 들어온 입력과 같이 압축하지 않은 파일의 +크기를 알 수 없을 때 이런 방식을 활용합니다. +.PP +\fBxz\fP는 \fB.lzma\fP 파일을 end\-of\-payload 마커의 유무와 관계없이 압축 해제 방식을 모두 지원하지만, \fBxz\fP로 +만든 모든 \fB.lzma\fP 파일은 end\-of\-payload 마커를 사용하며, \fB.lzma\fP 헤더에 압축하지 않은 파일 크기를 '알 수 +없음'으로 표기합니다. 이 방식은 드문 상황에서 문제를 야기할 수 있습니다. 예를 들면, 임베디드 장치의 \fB.lzma\fP 압축 해제 +프로그램은 압축을 해제했을 때 크기를 알아야 동작합니다. 이 문제를 만나면, LZMA 유틸리티 또는 LZMA SDK를 활용하여 +\&\fB.lzma\fP 파일에 압축 전 파일 크기 정보를 저장해야합니다. +. +.SS "지원하지 않는 .lzma 파일" +\&\fB.lzma\fP 형식은 \fIlc\fP 값을 8까지 받아들이며, \fIlp\fP 값은 4까지 받아들입니다. LZMA 유틸리티는 어떤 \fIlc\fP 값과 +\fIlp\fP 값을 받아들이고도 압축을 해제할 수 있지만, 파일을 만들 때는 늘 \fBlc=3\fP 값과 \fBlp=0\fP 값을 활용합니다. 다른 +\fIlc\fP 값과 \fIlp\fP 값으로의 파일 압축은 \fBxz\fP와 LZMA SDK에서만 가능합니다. +.PP +liblzma의 LZMA1 필터 구현체에서는 \fIlc\fP 값과 \fIlp\fP 값의 합이 4를 넘어가면 안됩니다. 그래서 \fB.lzma\fP +파일의 경우 이 제한을 넘어가면 \fBxz\fP로 압축을 해제할 수 없습니다. +.PP +LZMA 유틸리티는 2^\fIn\fP (2의 승수)크기를 지닌 딕셔너리를 가진 \fB.lzma\fP 파일만 만들지만 받아들이는 파일의 딕셔너리 +크기는 어떤 크기든 상관 없습니다. liblzma에서는 2^\fIn\fP, 2^\fIn\fP + 2^(\fIn\fP\-1) 딕셔너리 크기를 가진 +\&\fB.lzma\fP 파일 만 받아들입니다. 이로 인해 \fB.lzma\fP 파일을 확인할 때 거짓 양성율이 늘어납니다. +.PP +모든 \fB.lzma\fP 파일을 liblzma 에서 받아들일 수 있도록 압축하기 때문에 이 제한이 실제로는 문제가 되지 않습니다. +. +.SS "뒤따라오는 쓰레기 값" +압축 해제할 때, LZMA 유틸리티는 \fB.lzma\fP 스트림 처음 부분 다음 나머지를 다 조용히 무시합니다. 대부분의 경우, +버그입니다. LZMA 유틸리티에서 \fB.lzma\fP 결합 파일 압축 해제를 지원하지 않음을 의미하기도 합니다. +.PP +\&\fB.lzma\fP 스트림 처음부분 바로 다음에 데이터가 남아있을 경우, \fBxz\fP 에서는 \fB\-\-single\-stream\fP 옵션을 사용하지 +않으면 깨진 파일로 간주합니다. 이 동작으로 하여금 뒤따라오는 쓰레기 값을 무시하도록 간주하는 애매한 스크립트 동작을 깰 수가 +있습니다. +. +.SH 참고 +. +.SS "출력 결과물이 달라짐" +압축하지 않은 입력 파일로부터 얻어낸 정확한 압축 출력 결과물은 압축 옵션이 완전히 동일하더라도 XZ 유틸리티의 버전에 따라 달라질 수 +있습니다. 파일 형식에 영향을 주지 않고 인코더 그 자체를 개선(더 빠르게 하거나 더 나은 압축율로)하기 때문입니다. XZ 유틸리티 +버전이 동일하더라도 빌드 옵션을 달리하여 빌드 상태가 제각각인 경우 출력 결과물이 달라질 수 있습니다. +.PP +\fB\-\-rsyncable\fP 기능을 넣었을 경우 동일한 xz 버전에서 이전 파일과 새 파일로 별도로 압축하지 않는 한 결과 파일을 (두 +파일이 서로 다른 파일이 아니므로) rsync 처리할 필요가 없습니다. 이 문제는 인코더 구현체 기능 개발이 끝나서 xz 버전이 +다르더라도 안정적인 rsync 가능한 출력 결과물을 유지할 수 있을 때여야 해결할 수 있습니다. +. +.SS "내장 .xz 압축 해제 프로그램" +XZ 임베디드와 같은 내장 \fB.xz\fP 압축 해제 구현체는 지원 파일의 무결성 \fI검사\fP 형식을 \fInone\fP과 \fIcrc32\fP 이외의 +설정으로 만들 필요가 없습니다. 기본값이 \fB\-\-check=crc64\fP일 경우에만, 임베디드 시스템에서 파일을 만들 때 +\fB\-\-check=none\fP 또는 \fB\-\-check=crc32\fP 옵션을 사용해야합니다. +.PP +임베디드 시스템이 아니라면, 모든 \fB.xz\fP 형식 압축 해제 프로그램에서는 모든 \fI검사\fP 형식을 지원하거나, 일부 \fI검사\fP 방식을 +지원하지 않는다면, 최소한, 무결성 검사로 검증하지 않고 압축을 해제할 수 있습니다. +.PP +XZ 임베디드는 BCJ 필터를 지원하지만, 기본 시작 오프셋만 지정할 수 있습니다. +. +.SH 예제 +. +.SS 기본 +\fIfoo\fP 파일을 기본 압축 수준 (\fB\-6\fP) 으로 \fIfoo.xz\fP 파일에 압축해 넣고, 압축 과정이 무사히 끝나면 \fIfoo\fP를 +삭제합니다: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +\fIbar.xz\fP를 \fIbar\fP 에 압축을 해제한 후 압축 해제가 무사히 끝나도 \fIbar.xz\fP를 삭제하지 않습니다: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +기본 사전 설정 \fB\-6\fP 보다는 느리지만, 압축 및 압축 해제시 메모리를 적게 차지(각각 48\ Mib, 5\MiB)는 \fB\-4e\fP +사전 설정(\fB\-4 \-\-extreme\fP)을 활용하여 \fIbaz.tar.xz\fP 파일을 만듭니다: +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +압축 및 비압축 파일을 단일 명령으로 표준 출력에 압축해제할 수 있습니다: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "다중 파일 병렬 압축" +GNU와 *BSD에서는 \fBfind\fP(1) 명령과 \fBxargs\fP(1) 명령으로 여러 파일의 압축을 병렬 처리할 수 있습니다: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +\fBxargs\fP(1) 의 \fB\-P\fP 옵션으로 \fBxz\fP 프로세스의 병렬 처리 갯수를 지정합니다. \fB\-n\fP 옵션의 최적 값은 압축할 +파일 수에 달려있습니다. 압축할 파일이 몇개밖에 없다면 1이어야합니다. 파일이 수천 수만개 정도 된다면 \fBxargs\fP(1) 이 +어쨌든지간에 만들어낼 \fBxz\fP 프로세스의 겟수를 100으로 하거나 아니면 적당한 값을 지정하여 줄이는게 좋습니다. +.PP +\fBxz\fP에 \fB\-T1\fP옵션을 지정하면 단일\-스레드 모드로 강제합니다. \fBxargs\fP(1) 에서 병렬 처리 갯수를 제어할 수 있기 +때문입니다. +. +.SS "로봇 모드" +여러 파일을 압축한 후 저장할 바이트 용량을 계산합니다: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +이 스크립트에서는 충분히 최신의 \fBxz\fP 명령을 사용하는지 알아보려 합니다. 다음 \fBsh\fP(1) 스크립트에서는 \fBxz\fP 도구의 +버전 번호가 최소한 5.0.0인지 여부를 검사합니다. 이 방식은 \fB\-\-robot\fP 옵션을 지원하지 않는 오래된 베타 버전과도 호환성이 +있습니다: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +\fBXZ_OPT\fP 환경 변수로 압축 해제시 메뢰 사용량 한계를 설정하지만, 한계 값을 이미 설정했다면, 값을 늘리지 않습니다: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "개별 압축 필터 체인 설정" +개별 설정 필터 체인의 초단순 사용방식은 LZMA2 사전 설정 값을 별도로 설정하는 방식입니다. 사전 설정은 잠재적으로 쓸만한 압축 +설정 조합만 다루기 때문에 꽤 쓸모가 있을 수도 있습니다. +.PP +\fB\-0\fP ... \fB\-9\fP 옵션의 설명에서 테이블의 CompCPU 컬럼과 \fB\-\-extreme\fP 옵션은 LZMA2 사전 설정을 +개별적으로 맞췄을 때 쓸만할 수도 있습니다. 여기 관련내용을 테이블 둘로 정리해서 모아보았습니다: +.RS +.PP +.TS +tab(;); +c c +n n. +Preset;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +어떤 파일을 압축할 때 상당히 큰 딕셔너리(예: 32MiB)가 필요 하다는걸 알아채셨지만, \fBxz \-8\fP 명령이 압축할 때보다 더 빠른 +속도로 압축하려 한다면, 더 큰 딕셔너리 사용을 위해 더 낮은 CompCPU 사전 설정 값(예: 1)으로 수정할 수 있습니다: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +각 파일에 대해, 위 명령은 압축율이 더 좋아지면서도 \fBxz \-6\fP보다 더 빨라집니다. 그러나, CompCPU 값을 낮게 유지하는 +대신 큰 딕셔너리에서 일부 파일을 강조해야 합니다. 큰 딕셔너리가 대부분의 도움을 주는 매우 명백한 상황에서는 최소한 몇 메가바이트의 +매우 유사한 각 파일이 아카이브에 들어갑니다. 딕셔너리 크기는 LZMA2가 연속으로 존재하는 각 파일의 유사성으로부터 얻는 장점을 취할 +수 있을 때 일부 개별 파일보다 훨씬 더 커집니다. +.PP +압축 프로그램과 압축 해제 프로그램에서 메모리를 엄청 많이 사용해도 상관 없고, 파일을 수백 메가 바이트 메모리 용량을 활용하여 +압축한다면, \fBxz \-9\fP 명령에 64MiB 용량을 초과하는 딕셔너리를 사용할 수 있게 하는 방법도 쓸만할 지도 모릅니다: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +위 예제에서와 같이 \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) 옵션을 사용하면 압축 및 압축 해제 과정에서 필요한 메모리 +용량을 살펴보는데 요긴할 수 있습니다. 압축 해제한 파일 크기보다 더 큰 딕셔너리를 사용하면 불필요한 메모리 소모량이 발생하여 위 +명령이 작은 파일에는 쓸모 없음을 기억하십시오. +.PP +때로는 압축 시간이 딱히 상관이 없을 수도 있습니다만, 압축 해제시 메모리 사용량을 적게 유지해야 할 수도 있습니다. 예를 들면, +임베디드 시스템에서 파일 압축을 해제할 수도 있습니다. 다음 명령의 경우 \fB\-6e\fP (\fB\-6 \-\-extreme\fP) 옵션을 기반 +옵션을 사용하며 딕셔너리 크기를 64KiB만 사용하도록 제한합니다. 결과 파일은 XZ 임베디드(이게 \fB\-\-check=crc32\fP +옵션이 있는 이유)로 100KiB 메모리 용량을 활용하여 풀어낼 수 있습니다. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +가능한 한 수 바이트를 더 쥐어 짜내고 싶을 때, 리터럴 문맥 비트 수(\fIlc\fP)와 위치 비트 수(\fIpb\fP)를 조정하면 도움이 될 +수도 있습니다. 리터럴 위치 비트 수(\fIlp\fP)를 조금 건드리는 것 또한 도움이 될 지도 모르겠지만 보통 \fIlc\fP 값과 \fIpb\fP +값이 더 중요합니다. 예를 들면, 소스 코드 저장 파일에는 US\-ASCII 텍스트가 대부분이기에, 다음과 같은 경우는 \fBxz \-6e\fP +명령을 실행했을 때부다는 아주 약간(거의 0.1% 수준) 작은 파일을 얻어낼 수도 있습니다(\fBlc=4\fP를 빼고도 시도해보십시오): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +LZMA2와 다른 필터를 함께 사용하면 일부 파일 형식에 대해 압축율을 개선할 수 있습니다. 예를 들면 x86\-32 또는 x86\-64 +공유 라이브러리를 x86 BCJ 필터를 활용하여 압축할 경우: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +참고로 필터 옵션의 순서는 상당히 중요합니다. \fB\-\-x86\fP을 \fB\-\-lzma\fP 이전에 지정하면 \fBxz\fP에서 오류가 나는데, +LZMA2 다음에는 어떤 필터든 설정할 수 없고, 옵션 체인상 마지막 필터로 x86 BCJ 필터를 사용할 수 없기 때문입니다. +.PP +LZMA2와 델타 필터는 비트맵 그림에 최적의 결과를 가져다줄 수 있습니다. PNG에 보통 안성맞춥인데, PNG에는 단순 델타 필터보단 +약간 더 고급진 필터를 사용하지만, 실제 압축을 진행할 때는 Deflate를 사용하기 때문입니다. +.PP +예를 들어 이미지를 압축하지 않은 비압축 TIFF로 저장해야 하는 경우가 있습니다. 델타 필터의 거리 매개변수는 그림에서 픽셀당 바이트 +수에 일치하도록 설정합니다. 예를 들면, 24비트 RGB 비트맵의 경우 \fBdist=3\fP 거리 매개변수 값을 설정해야 하며, LZMA2 +압축시 3바이트 정렬을 따르도록 \fBpb=0\fP 값을 전달하는 방법도 바람직합니다: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +여러 이미지를 단일 아카이브로 넣고 싶다면(예: \fB.tar\fP), 모든 이미지에 대해 동일한 픽셀당 바이트 수가 들어가는 경우에도 델타 +필터가 동작합니다. +. +.SH "추가 참조" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ 유틸리티: +.br +XZ 임베디드: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzmadec.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzmadec.1 new file mode 100644 index 0000000000000000000000000000000000000000..a9e112792d46d6999e81a98d7a911d76e36c73e7 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzmadec.1 @@ -0,0 +1,72 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.\" Korean translation for the xz-man +.\" Seong-ho Cho , 2023, 2024. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDEC 1 2024\-04\-08 Tukaani "XZ 유틸리티" +.SH 이름 +xzdec, lzmadec \- .xz와 .lzma용 작은 압축 해제 프로그램 +.SH 요약 +\fBxzdec\fP [\f\fI옵션\fP...\fP] [\fI<파일>...\fP] +.br +\fBlzmadec\fP [\f\fI옵션\fP...\fP] [\fI<파일>...\fP] +.SH 설명 +\fBxzdec\fP은 liblzma 기반 \fB.xz\fP (그리고 \fB.xz\fP 확장자만) 파일 압축 해제 전용 도구 프로그램입니다. +\fBxzdec\fP 은 \fBxz\fP(1) 명령을 활용하여 \fB.xz\fP 파일의 압축을 해제할 때 쓰던 \fBxz \-\-decompress \-\-stdout\fP (그리고 일반적으로 쓰던 몇가지 다른 옵션도 같이) 명령을 작성하던 일상적인 경우를 대신하려 만든 결과물입니다. +\fBlzmadec\fP 는 \fB.xz\fP 파일 대신 \fB.lzma\fP 파일을 지원하는 점만 다르며, 나머지는 \fBxzdec\fP과 동일합니다. +.PP +실행 파일 크기를 줄이려는 목적으로, \fBxzdec\fP 에서는 다중\-스레드 실행 또는 현지 언어 표기를 지원하지 않으며 +\fBXZ_DEFAULTS\fP 환경 변수와 \fBXZ_OPT\fP 환경 변수의 옵션 값을 읽지 않습니다. \fBxzdec\fP은 단계별 진행 정보를 +표시하지 않습니다. \fBxzdec\fP 명령어로 \fBSIGINFO\fP 시그널을 보내면 아무 동작도 취하지 않지만, \fBSIGUSR1\fP 시그널을 +보내면 프 정보를 표시하는 대신 프로세스를 끝냅니다. +.SH 옵션 +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +\fBxz\fP(1) 호환성을 문제로 무시합니다. \fBxzdec\fP은 압축 해제 기능만 지원합니다. +.TP +\fB\-k\fP, \fB\-\-keep\fP +\fBxz\fP(1) 호환성을 문제로 무시합니다. \fBxzdec\fP은 어떤 파일도 만들거나 제거하지 않습니다. +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +\fBxz\fP(1) 호환성을 문제로 무시합니다. \fBxzdec\fP은 항상 압축 해제한 데이터를 표준 출력으로만 기록합니다. +.TP +\fB\-q\fP, \fB\-\-quiet\fP +이 옵션을 한번 지정하면 \fBxzdec\fP에서 어떤 경고나 알림을 표시하지 않기 때문에 아무런 동작도 취하지 않습니다. 오류 메시지를 +표시하지 않으려면 이 옵션을 두번 지정하십시오. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +\fBxz\fP(1) 호환성을 문제로 무시합니다. \fBxzdec\fP은 종료 코드 2번을 사용하지 않습니다. +.TP +\fB\-h\fP, \fB\-\-help\fP +도움말 메시지를 나타내고 무사히 나갑니다. +.TP +\fB\-V\fP, \fB\-\-version\fP +\fBxzdec\fP과 liblzma의 버전 번호를 나타냅니다. +.SH "종료 상태" +.TP +\fB0\fP +모든 상태 양호. +.TP +\fB1\fP +오류 발생. +.PP +\fBxzdec\fP 은 \fBxz\fP에 있는 경고 메시지를 출력하지 않기 때문에 \fBxzdec\fP 에서는 종료 코드 2번을 사용하지 않습니다. +.SH 참고 +보통 매일 사용하실 목적이라면 \fBxzdec\fP 또는 \fBlzmadec\fP 대신 \fBxz\fP 명령을 사용하십시오. \fBxzdec\fP 또는 +\fBlzmadec\fP은 완전한 기능을 갖춘 \fBxz\fP(1) 보다는 작은 압축 해제 프로그램을 사용해야 할 경우에만 사용하라고 있는 +명령입니다. +.PP +\fBxzdec\fP 과 \fBlzmadec\fP 은 실제로 그렇게 작은건 아닙니다. 컴파일 시간에 liblzma에서 얼마나 기능을 떨궈내느냐에 +따라 더 줄어들 수도 있습니다만, 보통 임베디드 운영체제 배포판이 아닌 경우는 이렇게 할 수가 없습니다. 실제로 작은 \fB.xz\fP 압축 +해제 프로그램이 필요하다면 XZ 임베디드 사용을 고려하십시오. +.SH "추가 참조" +\fBxz\fP(1) +.PP +XZ 임베디드: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzmainfo.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzmainfo.1 new file mode 100644 index 0000000000000000000000000000000000000000..718ad0a7c3269efdf46e149e1d1d70096adcac8c --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzmainfo.1 @@ -0,0 +1,38 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.\" Korean translation for the xz-man +.\" Seong-ho Cho , 2023, 2024. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH LZMAINFO 1 2013\-06\-30 Tukaani "XZ 유틸리티" +.SH 이름 +lzmainfo \- .lzma 파일 헤더에 들어있는 정보를 보여줍니다 +.SH 요약 +\fBlzmainfo\fP [\fB\-\-help\fP] [\fB\-\-version\fP] [\fI<파일>...\fP] +.SH 설명 +\fBlzmainfo\fP 는 \fB.lzma\fP 파일 헤더에 들어있는 정보를 보여줍니다. 지정 \fI<파일>\fP에서 13바이트를 +우선 읽어 헤더를 디코딩한 후, 가독 형식으로 표준 출력에 보여줍니다. \fI<파일>\fP을 지정하지 않거나 +\fI<파일>\fP 값이 \fI\-\fP 이면 표준 입력을 읽습니다. +.PP +보통 대부분 관심있는 정보는 압축 해제 용량과 딕서너리 크기입니다. 압축 해제 용량의 경우 파일이 비스트림 \fB.lzma\fP 형식 계열인 +경우에만 나타납니다. 파일 압축 해제 필요 메모리 용량은 수십 킬로바이트에 딕셔너리 크기를 합친 값입니다. +.PP +\fBlzmainfo\fP 는 LZMA 유틸리티 하위 호환성을 목적으로 XZ 유틸리티에 기본으로 들어있습니다. +.SH "종료 상태" +.TP +\fB0\fP +모든 상태 양호. +.TP +\fB1\fP +오류 발생. +.SH 버그 +\fBlzmainfo\fP 프로그램은 \fBMiB\fP (2^20 바이트) 용량 단위인데 (실제로) \fBMB\fP를 사용합니다. LZMA 유틸리티 +출력 호환 유지가 목적입니다. +.SH "추가 참조" +\fBxz\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzmore.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzmore.1 new file mode 100644 index 0000000000000000000000000000000000000000..1c6ab445fefb50b6630f9f8aef0ee8f03ad63de3 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/lzmore.1 @@ -0,0 +1,44 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" Korean translation for the xz-man +.\" Seong-ho Cho , 2023, 2024. +.\" +.\" (Note that this file is based on xzless.1 instead of gzip's zmore.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZMORE 1 2025\-03\-06 Tukaani "XZ 유틸리티" +.SH 이름 +xzmore, lzmore \- xz 압축 (텍스트) 파일 또는 lzma 압축 (텍스트) 파일을 봅니다 +. +.SH 요약 +\fBxzmore\fP [\fI<파일>\fP...] +.br +\fBlzmore\fP [\fIfile\fP...] (사용 안 함) +. +.SH 설명 +\fBxzmore\fP 명령은 압축 파일에 들어있는 텍스트를 \fBmore\fP(1) 명령으로 터미널에 나타냅니다. \fBxz\fP(1) 방식으로 +압축을 해제하는 파일만 지원합니다. 다른 파일은 이미 압축을 해제한 파일로 간주합니다. \fI<파일>\fP을 지정하지 +않으면, \fBxzmore\fP 프로그램에서는 표준 입력을 읽어들입니다. 키보드 명령 정보는 \fBmore\fP(1) 설명서를 참고하십시오. +.PP +참고로 \fBmore\fP(1) 명령 구현체에 따라 반대 방향(윗방향)으로의 스크롤은 못할 수도 있습니다. \fBxzmore\fP 명령이 +\fBmore\fP(1) 명령에 압축 해제한 데이터를 파이프로 전달하기 때문입니다. \fBxzless\fP(1)는 좀 더 나은 기능을 가진 +\fBless\fP(1) 명령을 활용합니다. +.PP +\fBlzmore\fP 명령은 LZMA 유틸리티 하위 호환용으로 제공합니다. 해당 명령은 오래되어 이후 버전에서 제거합니다. +. +.SH 환경 +.TP +.\" TRANSLATORS: Don't translate the uppercase PAGER. +.\" It is a name of an environment variable. +\fBPAGER\fP +\fBPAGER\fP 환경변수 값을 설정했다면, \fBmore\fP(1) 대신 해당 환경변수 값을 화면 표시 프로그램으로 사용합니다. +. +.SH "추가 참조" +\fBmore\fP(1), \fBxz\fP(1), \fBxzless\fP(1), \fBzmore\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/unlzma.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/unlzma.1 new file mode 100644 index 0000000000000000000000000000000000000000..631a9a7cc8b58565ff6c9eb7a3610b39d1733d20 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/unlzma.1 @@ -0,0 +1,1585 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Korean translation for the xz-man +.\" Seong-ho Cho , 2023, 2024. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 2025\-03\-08 Tukaani "XZ 유틸리티" +. +.SH 이름 +xz, unxz, xzcat, lzma, unlzma, lzcat \- .xz 파일과 .lzma 파일을 압축 또는 압축 해제합니다 +. +.SH 요약 +\fBxz\fP [\fI<옵션>...\fP] [\fI<파일>...\fP] +. +.SH "명령 별칭" +\fBunxz\fP 명령은 \fBxz \-\-decompress\fP 명령과 동일합니다. +.br +\fBxzcat\fP 명령은 \fBxz \-\-decompress \-\-stdout\fP 명령과 동일합니다. +.br +\fBlzma\fP 명령은 \fBxz \-\-format=lzma\fP 명령과 동일합니다. +.br +\fBunlzma\fP 명령은 \fBxz \-\-format=lzma \-\-decompress\fP 명령과 동일합니다. +.br +\fBlzcat\fP 명령은 \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP 명령과 동일합니다. +.PP +파일 압축을 해제해야 하는 셸 스크립트를 작성할 때, \fBunxz\fP 와 \fBxzcat\fP 이름 대신 \fBxz\fP 명령과 적절한 인자 +값(\fBxz \-d\fP 또는 \fBxz \-dc\fP)의 사용을 추천드립니다. +. +.SH 설명 +\fBxz\fP는 \fBgzip\fP(1) 과 \fBbzip2\fP(1) 과 비슷한 명령행 문법을 지닌 범용 데이터 압축 도구입니다. 자체 파일 +형식은 \fB.xz\fP 형식이나, LZMA 유틸리티에서 사용하는 예전 \fB.lzma\fP 형식과 형식 헤더가 없는 RAW 압축 스트림도 +지원합니다. 게다가, \fBlzip\fP에서 활용하는 \fB.lz\fP 형식 압축 해제도 지원합니다. +.PP +각 \fI파일\fP 에 대한 \fBxz\fP 압축 또는 압축 해제는 선택 동작 모드에 따릅니다. \fI<파일>\fP 값이 주어졌거나 +\fI<파일>\fP 값이 \fB\-\fP이면, \fBxz\fP 명령에서 표준 입력을 읽고 처리한 데이터를 표준 출력에 기록합니다. +\fBxz\fP 에서는 터미널에서 활용할 경우 압축 데이터를 표준 압축으로 기록하는 동작을 거절(오류를 출력하고 \fI<파일>\fP을 +건너뜀)합니다. 이와 비슷하게, \fBxz\fP 유틸리티를 터미널에서 실행하면 표준 입력의 압축 데이터 읽기를 거절합니다. +.PP +\fB\-\-stdout\fP 을 지정하지 않는 한, \fB\-\fP가 아닌 \fI<파일>\fP을 원본 \fI<파일>\fP 이름에서 +가져온 새 파일 이름으로 기록합니다: +.IP \(bu 3 +압축할 때, 대상 파일 형식의 접미사(\fB.xz\fP or \fB.lzma\fP) 는 원본 파일 이름 뒤에 붙어 대상 파일이름이 됩니다. +.IP \(bu 3 +압축 해제할 때, \fB.xz\fP, \fB.lzma\fP, \fB.lz\fP 접미사를 파일 이름에서 제거하고 대상 파일 이름을 알아냅니다. +\fBxz\fP에서는 \fB.txz\fP, \fB.tlz\fP 접미사도 인식하며, \fB.tar\fP 접미사로 치환합니다. +.PP +대상 파일이 이미 있으면, 오류를 나타내고 \fI<파일>\fP을 건너뜁니다. +.PP +표준 출력으로 기록하기 전에는, \fBxz\fP는 경고를 나타내며, 다음 조건에 만족할 경우 \fI<파일>\fP을 건너뜁니다: +.IP \(bu 3 +\fI<파일>\fP이 일반 파일이 아닐 때. 심볼릭 링크는 따라가지 않기에, 일반 파일로 간주하지 않습니다. +.IP \(bu 3 +\fI<파일>\fP이 하나 이상의 하드 링크일 떄. +.IP \(bu 3 +\fI<파일>\fP에 setuid, setgid, 끈적이 비트 집합이 붙어있을 떄. +.IP \(bu 3 +동작 모드를 압축으로 설정하고, \fI<파일>\fP은 대상 파일 형식의 접미사를 이미 붙였을 때(\fB.xz\fP 형식으로 압축하면 +\&\fB.xz\fP 또는 \fB.txz\fP, \fB.lzma\fP 형식으로 압축하면 \fB.lzma\fP 또는 \fB.tlz\fP). +.IP \(bu 3 +동작 모드를 압축 해제로 설정하고, \fI<파일>\fP에 지원 파일 형식 접미사(\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, +\&\fB.tlz\fP, \fB.lz\fP)를 붙이지 않았을 때. +.PP +\fI<파일>\fP 의 압축 또는 압축 해제를 성공하고 나면, \fBxz\fP는 소유자, 소유그룹, 권한, 접근 시각, 수정 시각 +정보를 원본 \fI<파일>\fP에서 대상 파일로 그대로 복사합니다. 그룹 정보 복사에 실패하면, 권한을 수정하여 원본 +\fI<파일>\fP에 접근 권한이 없는 사용자가 대상 파일로 접근하지 못하게 합니다. \fBxz\fP는 아직 접근 제어 목록이나 +확장 속성 등의 기타 메타데이터를 복사하는 기능은 지원하지 않습니다. +.PP +대상 파일을 온전히 닫고 나면, \fB\-\-keep\fP 옵션을 지원하지 않았을 경우 원본 \fI<파일>\fP을 제거합니다. 원본 +\fI<파일>\fP은 출력을 표준 출력으로 기록했거나 오류가 발생했을 경우 제거하지 않습니다. +.PP +\fBxz\fP 프로세스에 \fBSIGINFO\fP 시그널 또는 \fBSIGUSR1\fP 시그널을 보내면 표준 출력으로 진행 정보를 출력합니다. 표준 +오류가 터미널일 경우일 경우에만 제한하며 \fB\-\-verbose\fP 옵션을 지정하면 진행 표시줄을 자동으로 나타냅니다. +. +.SS "메모리 사용" +\fBxz\fP 메모리 사용은 수백 킬로바이트로 시작하여 수 기가바이트까지 압축 설정에 따라 다릅니다. 압축 해제 프로그램이 필요로 하는 +메모리 공간을 결정하는 파일 압축시에 설정 값을 활용합니다. 보통 압축 해제 프로그램은 파일을 만들 때, 압축 프로그램 메모리 사용량의 +5% 에서 20% 정도 필요합니다. 예를 들면, \fBxz \-9\fP로 압축한 파일 압축 해제시 현재 65MiB 메모리 용량이 필요합니다. +여전하게도, 압축 해제시 수 기가 바이트의 메모리가 필요한 \fB.xz\fP 파일에도 가능한 이야기입니다. +.PP +특히 이전 시스템 사용자의 경우 메모리 사용량이 엄청나게 늘어나는 점에 짜증이 날 수 있습니다. 이런 불편한 상황을 피하기 위해, +\fBxz\fP에 기본적으로 비활성 상태인 내장 메모리 사용 제한 기능을 넣었습니다. 일부 운영체제에서 처리 중 메모리 사용을 제한하는 +수단을 제공하긴 하지만, 여기에 의지하기에는 충분히 유연하지 않습니다(예를 들면, \fBulimit\fP(1)을 사용하면 가상 메모리를 +제한하여 \fBmmap\fP(2)을 먹통으로 만듭니다). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +메모리 사용 제한 기능은 \fB\-\-memlimit=\fP\fI<제한용량>\fP 명령행 옵션으로 사용할 수 있습니다. 종종 +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP와 같이 \fBXZ_DEFAULTS\fP 환경 변수를 설정하여 제한 기능을 켜는게 더 +편합니다. \fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션과 +\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP 옵션을 활용하여 압축 및 압축 해제시 별도로 한계 값을 +설정할 수 있습니다. 이 두 가지 옵션의 \fBXZ_DEFAULTS\fP 환경 변수 밖에서의 사용은, \fBxz\fP를 단일 실행할 때 압축 및 +압축 해제 동작을 동시에 수행하지 않으며, 앞서 언급한 두가지 옵션을 명령행에 입력하기에는 +\fB\-\-memlimit=\fP\fI<제한용량>\fP(또는 \fB\-M\fP \fI<제한용량>\fP)이 더 짧기 때문에 별로 쓸모가 +없습니다. +.PP +압축 해제시 메모리 사용 제한 지정 한계를 초과하면, \fBxz\fP 유틸리티에서 오류를 나타내며 파일 압축 해제는 실패합니다. 압축을 +실행할 때 사용 제한 지정 한계를 넘어서면 \fBxz\fP에서는 설정 값을 줄여서 어쨌든 한계를 넘지 못하게 +합니다(\fB\-\-format=raw\fP 옵션 또는 \fB\-\-no\-adjust\fP 옵션 사용시 제외). 설정 한계 값이 엄청 작지 않은 이상 이 +방식대로 처리하면 어쨌든 실패하지 않습니다. 설정 값조정은 압축 래벨 사전 설정과 일치하지 않을 때 단계적으로 진행하는데, 이를테면, +\fBxz \-9\fP 명령 수행에 필요한 양보다 한계 값이 약간 작으면, 설정 값을 \fBxz \-8\fP에 못미치게 약간 줄여서 진행합니다. +. +.SS ".xz 파일 결합 및 패딩" +\&\fB.xz\fP 파일을 있는 그대로 합칠 수 있습니다. \fBxz\fP는 \fB.xz\fP 파일을 단독 파일일 때 처럼 압축해제합니다. +.PP +결합 부분과 마지막 부분 뒤에 패딩을 추가할 수 있습니다. 패딩은 널 바이트로 구성해야 하며 패딩 길이는 4바이트로 구성해야 합니다. +512 바이트 블록으로 파일 크기를 이루는 매체에 \fB.xz\fP 파일을 저장했을 경우에 요긴할 수 있습니다. +.PP +\&\fB.lzma\fP 파일 또는 원시 스트림의 경우 결합과 패딩을 허용하지 않습니다. +. +.SH 옵션 +. +.SS "정수 접두사와 별도 값" +정수 인자값이 필요한 대부분 위치에서는, 큰 정수값을 나타내기 쉽게 하도록 추가 접미사를 지원합니다. 정수와 접미사 사이에 어떤 공백이 +있으면 안됩니다. +.TP +\fBKiB\fP +1,024 (2^10) 배수 정수값. \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP, \fBKB\fP 단위를 \fBKiB\fP 동의어로 받아들입니다. +.TP +\fBMiB\fP +1,048,576 (2^20) 배수 정수값. \fBMi\fP, \fBm\fP, \fBM\fP, \fBMB\fP 단위를 \fBMiB\fP 동의어로 받아들입니다. +.TP +\fBGiB\fP +1,073,741,824 (2^30) 배수 정수값. \fBGi\fP, \fBg\fP, \fBG\fP, \fBGB\fP 단위를 \fBGiB\fP 동의어로 +받아들입니다. +.PP +특수 값 \fBmax\fP는 옵션에서 지원하는 정수 최대 값을 나타낼 때 사용할 수 있습니다. +. +.SS "동작 모드" +여러 동작 모드를 보여드리겠습니다만, 마지막에 주어진 동작 모드로 동작합니다. +.TP +\fB\-z\fP, \fB\-\-compress\fP +압축합니다. 어떤 동작 모드 옵션도 지정하지 않고 다른 동작 모드를 명령행에 따로 지정하지 않았다면 이 동작 모드는 기본입니다(예: +\fBunxz\fP 는 \fB\-\-decompress\fP를 암시). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +압축을 제대로 끝내고 나면, 표준 출력에 기록하거나 \fB\-\-keep\fP 옵션을 지정하지 않았다면 원본 파일을 제거합니다. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +압축 해제입니다. 압축 해제를 제대로 끝내고 나면, 표준 출력에 기록하거나 \fB\-\-keep\fP 옵션을 지정하지 않았다면 원본 파일을 +제거합니다. +.TP +\fB\-t\fP, \fB\-\-test\fP +압축 \fI<파일>\fP의 무결성을 시험해봅니다. 이 옵션은 압축 해제 데이터를 표준 출력으로 기록하는 대신 버린다는 점을 +제외하고 \fB\-\-decompress \-\-stdout\fP과 동일합니다. 어떤 파일도 만들거나 제거하지 않습니다. +.TP +\fB\-l\fP, \fB\-\-list\fP +압축 \fI<파일>\fP 정보를 출력합니다. 압축 해제 출력을 내보내지 않으며, 어떤 파일도 만들거나 제거하지 않습니다. 이 +조회 모드에서, 프로그램은 표준 입력 또는 기타 탐색 불가능한 원본에서 압축 데이터를 읽을 수 없습니다. +.IP "" +\fI<파일>\fP 기본 정보를 파일 당 한 줄 씩 기본으로 보여줍니다. 더 자세한 정보를 보려면 \fB\-\-verbose\fP +옵션을 사용하십시오. 더 자세한 정보는 \fB\-\-verbose\fP 옵션을 두번 사용하면 되지만, 추가 정보를 더 많이 가져오면서 탐색 +횟수가 늘어나는 문제로 인해 느려질 수 있습니다. 세부 출력 너비는 80 문자를 초과하며, 예를 들어 출력을 파이핑한다면, 터미널이 +충분히 너비가 넓지 못할 경우 \fBless\ \-S\fP 명령이 편리할 수 있습니다. +.IP "" +정확한 출력은 \fBxz\fP 버전과 다른 로캘에 따라 바뀔 수 있습니다. 기계 판독용 출력시 \fB\-\-robot \-\-list\fP 옵션을 +사용합니다. +. +.SS "동작 수정자" +.TP +\fB\-k\fP, \fB\-\-keep\fP +입력 파일을 삭제하지 않습니다. +.IP "" +\fBxz\fP 5.2.6 부터는 이 옵션으로 입력 파일이 일반 파일을 참조하는 심볼릭 링크나 하나 이상의 하드 링크, 내지는 setuid, +setgid, 끈적이 비트 세트를 설정한 상태라도 압축하거나 압축을 풀 수 있습니다. setuid, setgid, 끈적이 비트는 대상 +파일에 복사하지 않습니다. 이전 버전에서는 \fB\-\-force\fP 옵션을 지정했을 때만 가능했습니다. +.TP +\fB\-f\fP, \fB\-\-force\fP +이 옵션은 몇가지 동작에 영향을 줍니다: +.RS +.IP \(bu 3 +대상 파일이 이미 있으면, 압축 또는 압축 해제 전 삭제합니다. +.IP \(bu 3 +입력 파일이 일반 파일을 참조하는 심볼릭 링크나 하나 이상의 하드 링크, 내지는 setuid, setgid, 끈적이 비트 세트를 설정한 +상태라도 압축 또는 압축 해제를 진행합니다. setuid, setgid, 끈적이 비트는 대상 파일에 복사하지 않습니다. +.IP \(bu 3 +\fB\-\-decompress\fP \fB\-\-stdout\fP 옵션을 같이 사용하는 상황에서 \fBxz\fP 명령이 원본 파일의 형식을 알아내지 못할 때, +원본 파일의 사본을 표준 출력으로 보냅니다. 이렇게 하면 \fBxzcat\fP \fB\-\-force\fP 명령을 \fBxz\fP 명령으로 압축하지 않은 +파일에 대해 \fBcat\fP(1) 을 사용하는 것처럼 사용할 수 있습니다. 참고로 나중에, \fBxz\fP에서 \fBxz\fP로 하여금 여러 형식의 +파일을 표준 출력으로 복사하는 대신 압축을 해제하도록 새 압축 파일 형식을 지원할 예정입니다. +\fB\-\-format=\fP\fI<형식>\fP 옵션은 \fBxz\fP 명령에 단일 파일 형식만 압축 해제하도록 제한할 때 사용할 수 +있습니다. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +파일 대신 표준 출력으로 압축 또는 압축 해제한 데이터를 기록합니다. \fB\-\-keep\fP를 생략했습니다. +.TP +\fB\-\-single\-stream\fP +처음 \fB.xz\fP 스트림만 압축 해제하며, 스트림에 뒤따라오는 나머지 입력 데이터는 조용히 무시합니다. 보통 뒤따라오는 쓰레기 값에 +대해서는 \fBxz\fP 에서 오류를 나타냅니다. +.IP "" +\fBxz\fP는 \fB.lzma\fP 파일 또는 원시 스트림에서 온 하나 이상의 스트림에 대해 압축 해제동작을 취하지 않지만, 이 옵션을 사용하면 +\fBxz\fP에서 \fB.lzma\fP 파일 또는 원시 스트림을 처리한 다음에 뒤따라오는 데이터를 무시하도록 합니다. +.IP "" +이 옵션은 동작 모드가 \fB\-\-decompress\fP 또는 \fB\-\-test\fP가 아니면 동작에 아무런 영향을 주지 않습니다. +.IP "" +\fBxz\fP 5.7.1alpha 부터는 \fB\-\-single\-stream\fP 옵션의 동작에 \fB\-\-keep\fP 동작이 들어갑니다. +.TP +\fB\-\-no\-sparse\fP +희소 파일을 만들지 않습니다. 기본적으로 일반 파일로 압축 해제할 경우 \fBxz\fP 에서는 압축 해제한 파일에 이진 0값이 길게 늘어질 +경우 희소 배열 파일을 만들려고 합니다. 표준 출력의 내용 길이만큼 연결한 일반 파일로 기록할 때도 동작하며 희소 파일을 만드는 동안 +아무런 문제가 나타나지 않게 각각의 추가 조건을 만족합니다. 희소 파일을 만들면 디스크 공간을 절약할 수 있으며 디스크 입출력을 줄여 +압축 해제 속도를 올릴 수 있습니다. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +압축할 때, 대상 파일의 접두사를 \fB.xz\fP 또는 \fB.lzma\fP 대신 \fI.suf\fP로 사용하십시오. 표준 출력으로 기록하지 않고 +원본 파일에 \fI.suf\fP 접두사가 붙어있으면, 경고를 나타내고 해당 파일을 건너뜁니다. +.IP "" +압축 해제할 때, \fI.suf\fP 접미사로 파일을 인식하기도 하고, \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, +\&\fB.lz\fP 접미사가 붙은 파일도 인식합니다. 원본 파일에 \fI.suf\fP 접미사가 붙어있으면, 해당 접미사를 제거하여 대상 파일 이름을 +알아냅니다. +.IP "" +원시 스트림 압축 및 압축 해제시(\fB\-\-format=raw\fP) 원시 스트림에 기본 접미사가 없기 때문에, 표준 출력으로 기록하지 않는 +한 접미사를 반드시 지정해야 합니다. +.TP +\fB\-\-files\fP[\fB=\fP\fI<파일>\fP] +\fI<파일>\fP에서 처리할 파일 이름을 읽습니다. \fI<파일>\fP을 생략하면 파일 이름은 표준 입력에서 +불러옵니다. 파일 이름은 개행 문자로 끝나야 합니다. 대시 문자(\fB\-\fP)는 일반 파일 이름으로 취급하며 표준 입력을 의미하지 +않습니다. 파일 이름을 명령행 인자로 지정하면, \fI<파일>\fP에서 파일 이름을 읽어들이기 전 해당 명령행 인자를 먼저 +처리합니다. +.TP +\fB\-\-files0\fP[\fB=\fP\fI<파일>\fP] +각 파일 이름이 널 문자로 끝나야 한다는 점만 제외하면 \fB\-\-files\fP[\fB=\fP\fI<파일>\fP] 옵션과 동일합니다. +. +.SS "기본 파일 형식 및 압축 옵션" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fI<형식>\fP +압축 또는 압축해제 파일 \fI<형식>\fP을 지정합니다: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +기본 값입니다. 압축할 때, \fBauto\fP는 \fBxz\fP의 기본 동작과 동일합니다. 압축을 해제할 때, 입력 파일 형식을 자동으로 +찾습니다. 참고로 원시 스트림(\fB\-\-format=raw\fP)의 경우 자동으로 찾을 수 없습니다. +.TP +\fBxz\fP +\&\fB.xz\fP 파일 형식으로 압축하거나, 압축 해제시 \fB.xz\fP 파일만 받아들입니다. +.TP +\fBlzma\fP, \fBalone\fP +이전 \fB.lzma\fP 파일 형식으로 압축하거나, 압축 해제시 \fB.lzma\fP 파일만 받아들입니다. \fBalone\fP 대체 명령은 LZMA +유틸리티 하위 호환성을 목적으로 제공합니다. +.TP +\fBlzip\fP +압축 해제시 \fB.lz\fP 파일만 받아들입니다. 압축은 지원하지 않습니다. +.IP "" +\&\fB.lz\fP 형식 버전 0과 1을 지원합니다. 버전 0파일은 \fBlzip\fP 1.3 이전에서만 만듭니다. 일반적이진 않지만 일부 파일의 +경우 이 형식의 원본 패키지로 보관한 파일을 찾을 수도 있습니다. 개인적으로 이 형식으로 압축한 오래된 개인 파일을 가지고 있을 수도 +있습니다. 형식 버전 0 압축 해제 지원은 \fBlzip\fP 1.18에서 제거했습니다. \fBlzip\fP 1.4 이후의 버전에서는 버전 1 +형식 파일을 만듭니다. +.TP +\fBraw\fP +원시 스트림으로 압축하거나 압축을 해제합니다(헤더 없음). 고급 사용자 전용입니다. 원시 스트림을 디코딩하려면, +\fB\-\-format=raw\fP 옵션을 사용하고 분명하게 필터 체인을 지정하여 컨테이너 헤더에 필요한 정보를 저장하게 끔 해야합니다. +.RE +.TP +\fB\-C\fP \fI<검사방식>\fP, \fB\-\-check=\fP\fI<검사방식>\fP +무결성 검사 방식을 지정합니다. 검사 방식은 \fB.xz\fP 파일에 저장하며 압축 해제 데이터를 계산합니다. 이 옵션은 \fB.xz\fP +형식으로 압축할 때만 효력이 있습니다: \fB.lzma\fP 형식은 무결성 겁사를 지원하지 않습니다. 무결성 검사는 \fB.xz\fP 파일 압축을 +풀었을 때에 검사합니다. +.IP "" +지원 \fI검사\fP 형식: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +어떤 경우에도 무결성 검사 계산을 수행하지 않습니다. 보통 바람직하지 못한 생각입니다. 데이터 무결성을 다른 방식으로라도 검증해야 +하는 상황이면 쓸만할 수 있습니다. +.TP +\fBcrc32\fP +IEEE\-802.3 (이더넷)의 다항 연산으로 CRC32를 계산합니다. +.TP +\fBcrc64\fP +ECMA\-182의 다항식 연산으로 CRC64를 계산합니다. 이 동작이 기본 동작이기 때문에 CRC32가 깨진 파일을 찾을 때보다는 좀 +낮은 편이며 속도 차이도 거의 없습니다. +.TP +\fBsha256\fP +SHA\-256 해시를 계산합니다. CRC32와 CRC64 보다는 좀 느립니다. +.RE +.IP "" +\&\fB.xz\fP 헤더 무결성은 항상 CRC32로 검증하빈다. 이를 바꾸거나 It is not possible to change or +disable it. +.TP +\fB\-\-ignore\-check\fP +압축 데이터를 압축해제할 경우 압축 데이터의 무결성 검증을 진행하지 않습니다. \fB.xz\fP 헤더의 CRC32 값은 그래도 여전히 보통 +방식으로 검증합니다. +.IP "" +\fB이 옵션이 정확히 무슨 동작을 하는지 알기 전에는 사용하지 마십시오.\fP 이 옵션을 사용하는 타당한 이유로: +.RS +.IP \(bu 3 +깨진 .xz 파일에서 데이터 복구를 시도합니다. +.IP \(bu 3 +압축 해제 속도를 늘립니다. SHA\-256 또는 압축 파일에 들어간 그 무언가를 엄청 빨리 처리합니다. 다른 방식으로 파일 무결성을 +검증해야 하는 목적이 아니라면 이 옵션을 사용하지 않는게 좋습니다. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +압축 사전 설정 수준을 선택합니다. 기본값은 \fB\-6\fP입니다. 다중 수준을 지정하면 가장 마지막 수준 옵션을 적용합니다. 개별 필터 +체인을 이미 지정했다면, 압축 사전 설정 수준 값을 설정할 때 개별 필터 체인을 정리합니다. +.IP "" +사전 설정간 차이는 \fBgzip\fP(1)과 \fBbzip2\fP(1)을 사용할 때보다 더 비중을 차지합니다. 선택한 압축 설정은 압축 해제시 +필요한 메모리 사용량을 셜정하므로 사전 설정 수준 값을 너무 높게 지정하면 RAM 용량이 적은 오래된 시스템에서 파일 압축 해제시 실패할 +수 있습니다. 게다가, \fBgzip\fP(1) 과 \fBbzip2\fP(1)에서 처럼 종종 \fB모든 동작에 \-9를 몰래 활용하는건 바람직하지 않습니다\fP. +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +동작이 빠른 사전 설정 부류입니다. \fB\-0\fP은 때로는 \fBgzip \-9\fP 명령보다 압축율이 훨씬 우수하면서도 더 빠릅니다. 더 큰 +값은 보통 \fBbzip2\fP(1) 명령과 비교했을 떄 압축 결과가 압축 데이터에 따라 달라지더라도, 비교할 법한 속도 또는 더 나은 +압축율을 보입니다. +.TP +\fB\-4\fP ... \fB\-6\fP +오래된 시스템에서 조차도 압축 해제 프로그램의 적절한 메모리 사용량을 보이면서 양호하거나 최적의 압축율을 보여줍니다. \fB\-6\fP 옵션은 +압축 해제시 메모리 사용량이 16MiB 밖에 안되기 때문에 파일을 배포할 때 최적의 선택인 기본 값입니다. (\fB\-5e\fP 또는 +\fB\-6e\fP도 역시 고려할 만합니다. \fB\-\-extreme\fP을 참고하십시오.) +.TP +\fB\-7 ... \-9\fP +\fB\-6\fP과 비슷하지만 압축 및 압축 해제시 요구 메모리 사용량이 더 높습니다. 압축 파일이 각각 8MiB, 16MiB, 32MiB +보다 클 경우에만 쓸만한 옵션입니다. +.RE +.IP "" +동일한 하드웨어에서, 압축 해제 속도는 압축한 데이터의 초당 정적 바이트 처리 수의 어림 평균입니다. 다시 말해, 압축율을 더 올리면, +압축 해제 속도도 역시 올라갑니다. 이는 곧 초당 비압축 데이터 출력 양이 달라질 수 있단 뜻입니다. +.IP "" +다음 표에 사전 설정 기능을 정리했습니다: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Preset;DictSize;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +컬럼 설명: +.RS +.IP \(bu 3 +DictSize는 LZMA2 딕셔너리 크기입니다. 압축 해제 파일의 크기보다 딕셔너리에서 사용하는 낭비 메모리 용량입니다. 실제로 +필요하지 않은 \fB\-7\fP ... \fB\-9\fP 사전 설정값을 피해야 하는 적절한 이유이기도 합니다. \fB\-6\fP 이하에서는 소모 메모리 양이 +충분히 적거나 따로 신경쓸 필요가 없습니다. +.IP \(bu 3 +CompCPU는 압축 속도에 영향을 주는 LZMA2 설정의 단순화 표기 값입니다. 딕셔너리 크기는 속도에도 영향을 주기 때문에 +CompCPU는 \fB\-6\fP ... \fB\-9\fP 수준값과 동일한데, 고수준 값은 여전히 조금 더 느려질 수 있습니다. 느려지는 만큼 +압축율은 가능한 한 더 좋아집니다. \fB\-\-extreme\fP을 참고하십시오. +.IP \(bu 3 +CompMem은 단일\-스레드 모드에서 필요한 압축 프로그램의 메모리 점유 용량입니다. \fBxz\fP 버전에 따라 다를 수 있습니다. +.IP \(bu 3 +DecMem은 압축 해제 프로그램의 메모리 점유용량입니다. 이는 곧, 압축 해제 프로그램에서 필요한 메모리 사용량을 압축 설정에서 +결정한다는 의미가 들어있습니다. 정확한 압축 해제 프로그램의 메모리 사용량은 LZMA2 딕셔너리 크기 보다는 조금 많지만 테이블의 값은 +MiB 용량으로 완전히 반올림한 값입니다. +.RE +.IP "" +다중\-스레드 모드에서 필요한 메모리 용량은 단일\-스레드 모드보단 약간 더 많습니다. \fB\-\-block\-size\fP 기본값에 따라, 각 +스레드에서는 3*3*딕셔녀리_크기 + 압축시_메모리용량 또는 압축_해제시_메모리용량 정도가 필요합니다. 예를 들면, 스레드 넷에 사전 +설정 옵션 \fB\-6\fP을 사용한다면, 660\(en670 MiB 메모리 용량이 필요합니다. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +기대하는 만큼의 좀 더 나은 압축율을 확보하려 선택한 압축 사전 설정 수준의 느린 변형 옵션을 사용하지만, 재수 없는 와중에 골로 가는 +경우가 생기기도 합니다. 압축 해제 프로그램의 메모리 사용에는 영향을 주지 않지만, 압축 프로그램의 메모리 사용량은 \fB\-0\fP +\&... \fB\-3\fP 사전 설정 수준에서 약간 더 올라갈 뿐입니다. +.IP "" +4MiB와 8MiB 두 가지 딕셔너리 용량 설정이 있기 때문에 \fB\-3e\fP 와 \fB\-5e\fP 사전 설정을 (CompCPU 수치를 낮춰서) +각각 \fB\-4e\fP 와 \fB\-6e\fP 보다 약간 더 빠르게 설정할 수 있습니다. 이런 식으로 두 사전 설정이 동일하지 않습니다. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Preset;DictSize;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +예를 들면, 8MiB 딕셔너리를 활용하는 네가지 사전 설정이 있다고 할 때, 빠른 순으로 설정을 나열하자면, \fB\-5\fP, \fB\-6\fP, +\fB\-5e\fP, \fB\-6e\fP 입니다. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +이 옵션은 \fB\-0\fP 과 \fB\-9\fP의 별칭으로 각각 오해할 수 있습니다. LZMA 유틸리티의 하위 호환성을 목적으로 제공합니다. 이 +옵션 사용은 피하십시오. +.TP +\fB\-\-block\-size=\fP\fI<크기>\fP +\&\fB.xz\fP 형식으로 압축할 때, 입력 데이터를 \fI<크기>\fP 바이트 블록으로 입력 데이터를 쪼갭니다. 각각의 블록은 +다중\-스레드 방식으로 처리할 수 있고 임의 접근 압축 해제 가능성을 제한할 수 있게 개별적으로 압축 처리합니다. 이 옵션은 보통 +다중\-스레드 모드에서 기본 블록 크기를 지정할 때 사용하지만, 단일\-스레드 모드에서도 사용할 수 있습니다. +.IP "" +다중\-스레드 모드에서는 약 3배 용량의 \fI<크기>\fP 바이트만큼 각 스레드 별로 입출력 버퍼링용 공간을 할당합니다. 기본 +\fI<크기>\fP는 LZMA2 딕셔너리 크기 또는 1MiB 중 가장 큰 쪽의 세 배입니다. 보통 적절한 값으로 LZMA2 +딕셔너리 크기 또는 최소한 1MiB 용량의 2\(en4배입니다. LZMA2 딕셔너리 크기보다 작은 \fI<크기>\fP는 램의 +소모적 사용 공간으로 할당하는데 LZMA2 딕셔너리 버퍼를 할당한 용량 크기 전체를 다 사용하지 않기 때문입니다. 다중\-스레드 모드에서 +블록 크기는 블록 헤더에 저장하며, 이 크기 정보는 다중\-스레드 압축 해제시 필요합니다. +.IP "" +단일\-스레드 모드에서는 기본적으로 블록 쪼개기를 하지 않습니다. 이 옵션을 설정한다고 해서 메모리 사용에 영향을 주지는 않습니다. +블록 헤더에 크기 정보를 저장하지 않기 때문에 단일\-스레드 모드에서 만든 파일은 다중\-스레드 모드에서 만든 파일과 동일하지 않습니다. +크기 정보의 누락은 또한 \fBxz\fP에서 다중\-스레드 모드로 압축 해제를 진행할 수 없음을 의미하기도 합니다. +.TP +\fB\-\-block\-list=\fP\fI<항목>\fP +\&\fB.xz\fP 형식으로 압축할 때, 압축하지 않은 데이터로 부터 일정 간격 이후에 새 블록 처리를 시작합니다. +.IP "" +\fI<항목>\fP은 쉼표로 구분한 목록으로 지정합니다. 각 항목은 콜론 (\fB:\fP)으로 구분한 0부터 9까지의 추가 필터 +체인 번호 값으로 이루어져 있으며, 압축하지 않은 데이터의 크기 값이 필요합니다. 항목을 생략하면(둘 이상의 쉼표 연속 표기) 이전 +항목의 크기와 필터를 활용하겠다는 함축 의미를 넣을 수 있습니다. +.IP "" +입력 파일이 \fI<항목>\fP 크기의 합보다 크면, 마지막 항목을 파일의 끝까지 반복합니다. 특별히 \fB0\fP 값을 마지막 +값으로 사용하여 파일 나머지 부분을 단일 블록으로 인코딩해야 한다는 의미를 나타낼 수도 있습니다. +.IP "" +\fB\-\-filters1=\fP\fI<필터>\fP \&...\& \fB\-\-filters9=\fP\fI<필터>\fP 옵션 조합으로 +각 블록별 별도 필터 체인을 지정할 수 있습니다. 이 옵션은 1\(en9번 필터 체인을 지정합니다. 필터 체인 0번은 필터 체인을 +지정하지 않았을 때와 동일한 기본 필터 체인으로 참조할 수 있습니다. 필터 체인 식별 번호는 비 압축 크기 앞에 콜론(\fB:\fP)을 붙여 +사용할 수 있습니다. 예를 들면, \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP 옵션을 +지정했을 경우 다음 규칙대로 블록을 만듭니다: +.RS +.IP \(bu 3 +\fB\-\-filters1\fP 필터 체인에서는 2MiB 입력을 +.IP \(bu 3 +\fB\-\-filters3\fP 필터 체인에서는 2MiB 입력을 +.IP \(bu 3 +\fB\-\-filters2\fP 필터 체인에서는 4MiB 입력을 +.IP \(bu 3 +\fB\-\-filters2\fP 필터 체인에서는 4MiB 입력을 +.IP \(bu 3 +기본 필터 체인에서는 2MiB 입력을 +.IP \(bu 3 +입력이 끝나기 전의 모든 블록에는 기본 필터 체인과 4MiB 입력을 적용합니다. +.RE +.IP "" +인코더 블록 크기를 초과하는 크기 값을 지정하면(스레드 모드 기본값 또는 \fB\-\-block\-size=\fP\fI<크기>\fP +옵션으로 지정한 값), 인코더는 \fI<크기>\fP 지정 용량 범위는 유지하면서 추가 블록을 만듭니다. 예를 들면 +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP 옵션을 지정하고 +입력 파일을 80MiB 용량으로 전달하면, 각각 5, 10, 8, 10, 2, 10, 10, 4, 10, 10, 1 MiB 용량을 +차지하는 블록 11개를 결과물로 내줍니다. +.IP "" +다중\-스레드 모드에서 블록 크기는 블록 헤더에 저장합니다. 단일\-스레드 모드에서는 저장하지 않기 때문에 인코딩 처리한 출력은 +다중\-스레드 모드의 출력 결과물과는 다릅니다. +.TP +\fB\-\-flush\-timeout=\fP\fI<제한시간>\fP +압축할 때, 이전 데이터를 소거하고 다음 입력을 블록 단위로 더 읽는데 \fI<제한시간>\fP 밀리초(양의 정수값)가 지났을 +경우, 대기중이던 모든 입력 데이터를 인코더에서 소거한 다음 출력 스트림에 전달합니다. 이런 동작은 네트워크로 스트리밍한 데이터를 +\fBxz\fP로 압축할 때 쓸만합니다. \fI<제한시간>\fP 값을 적게 지정하면 적은 지연 시간에 데이터를 받아낼 수 있지만 +\fI<제한시간>\fP 값을 크게 하면 압축율을 높일 수 있습니다. +.IP "" +이 기능은 기본적으로 꺼져있습니다. 이 옵션을 한번 이상 지정하면, 마지막 옵션의 값대로 동작합니다. 특별히 +\fI<제한시간>\fP 값을 \fB0\fP으로 설정하면 이 설정을 완전히 끌 수 있습니다. +.IP "" +이 기능은 POSIX 시스템이 아닌 곳에서는 사용할 수 없습니다. +.IP "" +.\" FIXME +\fB이 기능은 여전히 시험중입니다\fP. 현재로서는, \fBxz\fP 버퍼링 처리 방식 때문에 \fBxz\fP의 실시간 스트림 압축 해제 기능 활용은 +적절하지 않습니다. +.TP +\fB\-\-no\-sync\fP +원본 파일을 제거하기 전까지는 스토릿지 장치에 대상 파일과 디렉터리를 동기화하지 않습니다. 작은 여러 파일을 압축하거나 압축해제할 때 +성능을 개선할 수 있습니다. 그러나, 삭제 과정을 진행한 다음 시스템이 바로 치명적인 오류가 나타난다면, 대상 파일을 스토릿지 장치에 +저장하지 않았지만 삭제 동작이 이루어졌을 수도 있습니다. 이 경우 원본 파일 뿐만 아니라 대상 파일도 나타나지 않습니다. +.IP "" +이 옵션은 \fBxz\fP 프로그램이 원본 파일을 삭제할 때만 동작합니다. 다른 경우에는 전혀 동기화가 이루어지지 않습니다. +.IP "" +동기화 동작과 \fB\-\-no\-sync\fP 옵션은 \fBxz\fP 5.7.1alpha에 추가했습니다. +.TP +\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP +압축 수행시 메모리 사용 한계를 지정합니다. 이 옵션을 여러번 지정하면 마지막 값을 취합니다. +.IP "" +압축 설정이 \fI<제한용량>\fP을 초과하면, \fBxz\fP는 설정 값의 하향 조정을 시도하여 한계 값을 더이상 넘치지 않게 하고 +자동 조절을 끝냈다는 알림을 표시합니다. 조정은 다음 순서대로 진행합니다. 스레드 수를 줄입니다. 다중\-스레드 모드에서 스레드 하나의 +할당 한계치가 \fI<제한용량>\fP을 넘으면 단일\-스레드 모드로 전환합니다. 그 다음 마지막으로 LZMA2 딕셔너리 크기를 +줄입니다. +.IP "" +\fB\-\-format=raw\fP 또는 \fB\-\-no\-adjust\fP 미지정 상황에서 압축할 때, 압축 데이터 출력에 영향을 주지 않고 스레드 +처리 수만 줄일 수 있습니다. +.IP "" +\fI<제한용량>\fP 값이 아래 설명한 조건에 맞지 않으면, 오류가 나타나고 \fBxz\fP 명령은 종료 상태 1번을 반환하며 +빠져나갑니다. +.IP "" +\fI<제한용량>\fP 값은 여러 방식으로 지정할 수 있습니다: +.RS +.IP \(bu 3 +\fI<제한용량>\fP 값은 바이트 용량 절대값입니다. 정수 값을 사용하되 \fBMiB\fP와 같은 접미사를 사용하는게 좋습니다. +예: \fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +\fI<제한용량>\fP 값은 총 물리 메모리(RAM) 용량의 백분율로 지정할 수도 있습니다. 다른 컴퓨터끼리 공유하는 셸 +초기화 스크립트의 \fBXZ_DEFAULTS\fP 환경 변수에 값을 설정할 때 특히 쓸만합니다. 이런 방식으로 설정하면 시스템의 메모리 설치 +용량에 따라 자동으로 늘어납니다. 예: \fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +\fI<제한용량>\fP 값은 \fB0\fP 기본값으로 설정하여 초기화할 수 있습니다. 현재로서는 \fI<제한용량>\fP +값이 \fImax\fP(최대) (메모리 사용 한계 없음) 인 상태와 동일합니다. +.RE +.IP "" +\fBxz\fP 32비트 버전에서는 몇가지 특별한 경우가 있습니다. \fI<제한용량>\fP 값이 \fB4020MiB\fP를 넘으면 +\fI<제한용량>\fP을 \fB4020MiB\fP로 고정합니다. MIPS32에서는 \fB2000MiB\fP로 대신 고정합니다. +(\fB0\fP과 \fBmax\fP는 이 경우에 해당하지 않습니다. 압축 해제시 비슷한 기능은 없습니다.) 이 경우 32비트 실행 파일이 +4GiB(MIPS32의 경우 2GiB) 주소 영역에 접근할 때 매우 용이하며, 다른 경우에는 원하는대로 문제를 일으키지 않습니다. +.IP "" +\fB메모리 활용\fP 섹션도 참고하십시오. +.TP +\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP +압축 해제시 메모리 사용 한계 용량을 설정합니다. \fB\-\-list\fP 모드에도 영향을 줍니다. \fI<제한용량>\fP을 넘기지 +않고서는 동작이 진행이 안될 경우, \fBxz\fP 에서는 오류를 나타내고 파일 압축 해제를 실패로 +간주합니다. \fI<제한용량>\fP을 지정하는 가능한 방법에 대해서는 +\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션을 참고하십시오. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP +다중\-스레드 모드 압축 해제시 메모리 사용 한계 용량을 설정합니다. 스레드 수에 영향을 줄 수도 있습니다. \fBxz\fP에서 파일 압축 +해제를 거부하게 하진 않습니다. \fI<제한용량>\fP 수치가 다중\-스레드로 처리하기에 너무 낮다면, +\fI<제한용량>\fP 값을 무시하고 \fBxz\fP 동작을 단일\-스레드 모드로 계속 진행합니다. 참고로 +\fB\-\-memlimit\-decompress\fP 옵션도 사용하면, 단일\-스레드 모드와 다중\-스레드 모드 두 경우에 모두 적용하기에, +다중\-스레드 모드에 적용할 \fI<제한용량>\fP 값은 \fB\-\-memlimit\-decompress\fP에 설정하는 제한 값보다 더 +크면 안됩니다. +.IP "" +다른 메모리 사용 용량 제한 옵션과는 달리, \fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP 옵션은 +시스템별 기본 \fI<제한용량>\fP 값을 지닙니다. 현재 설정 값은 \fBxz \-\-info\-memory\fP 명령으로 확인해볼 수 +있습니다. +.IP "" +이 옵션과 기본 값은 한계 값을 주지 않으면 스레드 기반 압축 해제 프로그램이 일부 입력 파일에 대해 정신나간 수준의 메모리 용량을 +할당해서 동작이 끝나버릴 수 있습니다. 기본 \fI<제한용량>\fP이 시스템의 사양에 비해 낮다면, +\fI<제한용량>\fP 값을 자유롭게 올리시되, \fBxz\fP 에서 적은 스레드 수에도 메모리 공간 할당을 시도하는 만큼, 입력 +파일에 적절한 수준으로 가용 RAM 용량을 넘는 큰 값을 설정하지 마십시오. 메모리나 스와핑 영역 공간이 줄어들면 압축해제 성능을 +개선하지 못합니다. +.IP "" +\fI<제한용량>\fP 값을 지정하는 가능한 방법을 보려면 +\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션을 참고하십시오. \fI<제한용량>\fP 값을 +\fB0\fP으로 설정하면 \fI<제한용량>\fP 값이 시스템 지정 기본값으로 바뀝니다. +.TP +\fB\-M\fP \fI<제한용량>\fP, \fB\-\-memlimit=\fP\fI<제한용량>\fP, \fB\-\-memory=\fP\fI<제한용량>\fP +\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP +\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP +\fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP 지정과 동일합니다. +.TP +\fB\-\-no\-adjust\fP +압축 출력 결과에 영향을 주는 설정을 조정하지 않고는 메모리 사용 용량 제한 조건이 맞지 않으면 오류를 표시하고 빠져나갑니다. 이 +옵션은 \fBxz\fP가 다중\-스레드 모드에서 단일\-스레드 모드로 전환하고 LZMA2 딕셔너리 크기를 줄이는 동작을 막아줍니다. 심지어 이 +옵션을 사용하면 메모리 사용 한계를 만족하도록 스레드 수를 줄여 압축 결과물 출력에 영향이 가지 않게 합니다. +.IP "" +원시 스트림(\fB\-\-format=raw\fP)을 만들 떄 자동 조정은 항상 꺼집니다. +.TP +\fB\-T\fP \fI<스레드수>\fP, \fB\-\-threads=\fP\fI<스레드수>\fP +활용할 작업 스레드 수를 지정합니다. \fI<스레드수>\fP 값을 \fB0\fP 값으로 설정하면, \fBxz\fP는 시스템에서 지원하는 +최대 프로세서 스레드 수를 모두 확보합니다. 실제 스레드 수는 입력 파일이 주어진 설정대로 스레드 처리를 할 만큼 그렇게 크지 않을 +경우, 내지는 더 많은 스레드를 사용했을 때 메모리 사용량 한계를 초과할 경우 \fI<스레드수>\fP 보다 적을 수 있습니다. +.IP "" +단일\-스레드와 다중\-스레드 압축 프로그램은 다른 출력 결과물을 냅니다. 단일\-스레드 압축 프로그램은 작은 파일 크기 결과물을 내놓지만, +다중\-스레드 압축 프로그램의 경우 다중\-스레드 압축 프로그램에서 내놓은 결과물은 다중\-스레드로만 압축을 해제할 수 있습니다. +\fI<스레드수>\fP를 \fB1\fP로 설정하면 단일\-스레드 모드를 사용합니다. \fI<스레드수>\fP를 \fB0\fP과 다른 +값으로 설정하면, 시스템에서 실제로 하드웨어 스레드가 1개만 지원한다 하더라도, 다중\-스레드 압축 프로그램을 사용합니다. (\fBxz\fP +5.2.x에서는 이 경우 단일\-스레드 모드를 활용합니다.) +.IP "" +단일\-스레드로 다중\-스레드 모드를 사용하려면, \fI<스레드수>\fP를 \fB+1\fP로 설정하십시오. \fB+\fP 접두사는 \fB1\fP +이외의 값에는 영향을 주지 않습니다. 메모리 사용량 한계 설정은 \fBxz\fP을 \fB\-\-no\-adjust\fP 옵션을 쓰기 전까지는 +단일\-스레드로 전환하게 합니다. \fB+\fP 접두사 지원은 \fBxz\fP 5.4.0에 추가했습니다. +.IP "" +자동 스레드 수를 요청했고 메모리 사용 한계를 지정하지 않았다면, 시스템에 맞게끔 가능한 스레드 수를 제한하는 기본 소프트 제한 값을 +사용합니다. 스레드 수가 한개가 되면 무시하는 이런 개념이 소프트 제한이기에, \fBxz\fP로 하여금 압축 동작 및 압축 해제 동작 수행시 +멈추지 않습니다. 이 가본 소프트 제한 값은 \fBxz\fP 실행 도중 다중\-스레드 모드에서 단일\-스레드 모드로 바뀌게 하지는 않습니다. +활성 제한 값은 \fBxz \-\-info\-memory\fP 명령으로 볼 수 있습니다. +.IP "" +현재 스레딩 처리 방식은 입력을 블록 단위로 쪼개고 각각의 블록을 독립적으로 압축하는 동작을 취합니다. 기본 블록 크기는 압축 수준에 +따라 다르며 \fB\-\-block\-size=\fP\fI<크기>\fP 옵션으로 재지정할 수 있습니다. +.IP "" +스레드 압축 해제 방식은 여러 블록이 블록 헤더에 넣은 크기 정보와 함께 들어간 파일에만 동작합니다. 다중\-스레드 모드에서 압축한 +충분히 큰 모든 파일은 이 조건에 만족하지만, 단일\-스레드 모드에서 압축한 파일은 +\fB\-\-block\-size=\fP\fI<크기>\fP 옵션을 지정하더라도 조건에 만족하지 않습니다. +.IP "" +\fI스레드\fP 기본 값은 \fB0\fP입니다. \fBxz\fP 5.4.x 이전의 기본값은 \fB1\fP입니다. +. +.SS "개별 압축 필터 체인 설정" +개별 필터 체인은 사전 설정에 엮인 설정에 의존하는 대신 압축 설정을 세부적으로 하나하나 설정할 수 있게 합니다. 개별 필터 체인을 +지정하면, 명령행에 앞서 지정한 사전 설정 옵션(\fB\-0\fP \&...\& \fB\-9\fP 과 \fB\-\-extreme\fP)은 무시합니다. 사전 +설정 옵션을 하나 이상의 필터 체인 옵션 다음에 지정하면, 새 사전 설정을 취하며, 앞서 지정한 개별 필터 체인 옵션은 무시합니다. +.PP +필터 체인은 명령행 파이핑에 비교할 수 있습니다. 압축할 때, 압축하지 않은 입력을 첫번째 필터로 놓고, 출력 대상(이 있으면)을 다음 +필터로 지정합니다. 최종 필터의 출력은 압축 파일로 기옥합니다. 체인의 최대 필터 수는 4이지만, 필터 체인상 필터 갯수는 보통 +1~2개입니다. +.PP +수많은 필터가 필터 체인 상에서 제약점을 가지고 있습니다. 일부 필터는 체인의 마지막 필터로만 동작하며, 일부 다른 필터는 마지막이 아닌 +필터로, 어떤 동작은 체인의 어떤 위치에든 둡니다. 필터에 따라, 이 제한은 필터 설계를 따르거나 보안 문제를 막기 위해 존재하기도 +합니다. +.PP +개별 필터 체인은 두가지 방식으로 지정할 수 있습니다. \fB\-\-filters=\fP\fI<필터>\fP와 +\fB\-\-filters1=\fP\fI<필터>\fP \&...\& \fB\-\-filters9=\fP\fI<필터>\fP 옵션으로 +liblzma 필터 문자열 문법에 따라 한가지 옵션을 필터 체인 전체를 지정할 수 있습니다. 대신, 하나 이상의 개별 필터 옵션을 +원하는 필터 체인 순서대로 지정할 수도 있습니다. 이 말인 즉슨, 개별 필터 옵션의 순서가 중요하단 뜻입니다! 원시 스트림을 디코딩할 +때(\fB\-\-format=raw\fP), 압축했을 때 지정했던 필터와 같은 순서로 필터 체인을 지정해야 합니다. 전체 체인 +옵션(\fB\-\-filters=\fP\fI<필터>\fP) 보다 우선 지정한 개별 필터 또는 사전 설정 옵션은 까먹을 수도 있습니다. +전체 체인 옵션 다음에 개별 필터를 지정할 경우 필터 체인의 동작을 무효로 합니다. +.PP +필터는 쉼표로 구분하는 필터별 \fI<옵션>\fP이 있습니다. \fI<옵션>\fP에 추가로 입력한 쉼표는 +무시합니다. 모든 옵션 값에는 기본값이 있어, 값을 바꾸려면 지정해야합니다. +.PP +전체 필터 체인과 \fI<옵션>\fP을 보려면 \fBxz \-vv\fP (\fB\-\-verbose\fP 두 번)명령을 사용하십시오. 이 +명령은 사전 설정이 사용하는 필터 체인 옵션도 볼 수 있습니다. +.TP +\fB\-\-filters=\fP\fI<필터>\fP +전체 필터 체인 또는 사전 설정을 단일 옵션으로 지정합니다. 각 필터는 공백 문자 또는 대시 문자 두번 입력(\fB\-\-\fP)으로 +구분합니다. 셸 명령행에서 \fI필터\fP는 따옴표로 감싸서 단일 옵션으로 해석하도록 해야 합니다. \fI옵션\fP을 표기하려면 \fB:\fP 또는 +\fB=\fP을 활용하십시오. 사전 설정 앞에 \fB\-\fP를 붙일 수 있고 0개 또는 하나 이상의 플래그를 붙일 수 있습니다. 유일하게 +지원하는 플래그는 \fB\-\-extreme\fP과 동일한 \fBe\fP입니다. +.TP +\fB\-\-filters1\fP=\fI<필터>\fP ... \fB\-\-filters9\fP=\fI<필터>\fP +\fB\-\-block\-list\fP와 사용할 수 있는 추가 필터 체인을 최대 9개까지 지정합니다. +.IP "" +예를 들어 텍스트 파일과 실행 파일의 아카이브를 압축할 때 실행 부분에 BCJ 필터 체인을 사용하고 텍스트 부분은 LZMA2 필터를 +사용할 수 있습니다. +.TP +\fB\-\-filters\-help\fP +\fB\-\-filters\fP와 \fB\-\-filters1=\fP\fI<필터>\fP \&...\& +\fB\-\-filters9=\fP\fI<필터>\fP 옵션의 사전 설정 필터와 개별 설정 필터 체인을 지정하는 방법을 설명하는 도움말 +메시지를 출력하고 완전히 빠져나갑니다. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fI<옵션>\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fI<옵션>\fP] +.PD +LZMA1 또는 LZMA2 필터를 필터 체인에 추가합니다. 이 필터는 필터 체인의 마지막 요소로만 사용할 수 있습니다. +.IP "" +LZMA1은 고전 필터로, LZMA1만 지원하는 고전 \fB.lzma\fP 파일 형식에서만 지원합니다. LZMA2는 LZMA1의 업데이트 +버전으로 LZMA1의 실질적 문제를 해결했습니다. \fB.xz\fP 형식은 LZMA2 필터를 사용하며 LZMA1 필터는 전적으로 지원하지 +않습니다. 압축 속도와 압축율은 LZMA1과 LZMA2가 실질적으로 동일합니다. +.IP "" +LZMA1과 LZMA2는 동일한 \fI<옵션>\fP 집합을 공유합니다: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fI<사전설정>\fP +LZMA1 또는 LZMA2의 모든 \fI<옵션>\fP을 \fI<사전설정>\fP으로 +초기화합니다. \fI<사전설정>\fP 값은 정수 값으로 이루어져 있으며, 사전 설정에 변형을 줄 떄 단일 문자가 따라올 수도 +있습니다. 정수 값은 \fB0\fP에서 \fB9\fP 까지이며, 명령행 옵션에서 \fB\-0\fP \&...\& \fB\-9\fP로 대응합니다. 변형 옵션으로 +지원하는 문자는 현재 \fBe\fP 뿐이며, \fB\-\-extreme\fP에 대응합니다. \fI<사전설정>\fP 값을 지정하지 않으면, +LZMA1 또는 LZMA2 기본값을 사전 설정 \fB6\fP에서 가져온 \fI<옵션>\fP으로 취합니다. +.TP +\fBdict=\fP\fI<크기>\fP +딕셔너리(기록 버퍼) \fI<크기>\fP는 최근 처리한 비압축 데이터를 바이트 단위로 메모리에 얼마나 유지하는지 나타냅니다. +알고리즘은 비압축 데이터상 바이트 시퀀스(일치 항목) 반복 탐색을 시도하며, 해당 부분을 딕셔너리의 현재 참조로 치환합니다. 딕셔너리가 +크면 일치하는 항목을 찾을 기회가 더 많아집니다. 따라서, 딕셔너리 \fI<크기>\fP를 더욱 크게 설정하면 압축율을 증가할 +수는 있지만, 압축하지 않은 파일보다 딕셔너리가 크면 메모리 낭비율이 올라갑니다. +.IP "" +보통 딕셔너리 \fI<크기>\fP는 64KiB 에서 64MiB 정도 됩니다. 최소 4KiB 입니다. 압축시 최대 용량은 현재 +1.5GiB(1536MiB)로 나타납니다. 압축 해제 프로그램에도 4GiB 미만으로 딕셔너리 크기를 이미 지원하며 4GiB 라는 수치는 +LZMA1과 LZMA2 스트림 형식의 최대값입니다. +.IP "" +딕셔너리 \fI<크기>\fP와 검색기(\fImf\fP)는 LZMA1 또는 LZMA 인코더의 메모리 사용량을 함께 결정합니다. +동일한(또는 더 큰) 딕셔너리 \fI<크기>\fP가 데이터를 압축했을 때만큼 압축 해제할 떄 필요하기 때문에, 디코더의 메모리 +사용량은 압축할 때의 딕셔너리 크기로 결정합니다. \fB.xz\fP 헤더에는 딕셔너리 \fI<크기>\fP를 2^\fIn\fP 또는 +2^\fIn\fP + 2^(\fIn\fP\-1) 으로 저장하기에, 이 \fI<크기>\fP 값을 압축할 때 선호하는 편입니다. 다른 +\fI<크기>\fP 값은 \fB.xz\fP 헤더에 저장할 때 반올림합니다. +.TP +\fBlc=\fP\fIlc\fP +리터럴 컨텍스트 비트 수를 지정합니다. 최소 값은 0이고 최대 값은 4입니다. 기본 값은 3입니다. 추가로, \fIlc\fP 값과 +\fIlp\fP 값의 합은 4를 넘으면 안됩니다. +.IP "" +조건이 일치하지 않아 인코딩할 수 없는 모든 바이트는 리터럴로 인코딩합니다. 이 말인 즉슨, 간단히 8비트 바이트로서의 리터럴을 한번에 +하나씩 인코딩합니다. +.IP "" +리터럴 코딩을 할 때 이전 비압축 바이트와 다음 바이트와의 관련성을 가진 가장 많은 \fIlc\fP 비트 수를 가정합니다. 예를 들면, 보통 +영문 문장의 경우 대문자 다음에 종종 소문자가 오고, 소문자 다음에 다른 소문자가 따라옵니다. US\-ASCII 문자 세트에서는 가장 긴 +비트 3개는 대문자에 대해 010, 소문자에 대해 011입니다. \fIlc\fP 값이 최소한 3이면, 리터럴 코딩시 비압축 데이터에 대해 +이런 속성의 장점을 취할 수 있습니다. +.IP "" +(어쨌거나) 기본값 (3)은 보통 적절합니다. 최대 압축을 원한다면 \fBlc=4\fP 값을 시험해보십시오. 때로는 약간 도움이 되기도 +하겠지만, 오히려 결과가 안좋을 수도 있습니다. 결과가 엄한 방향으로 간다면, \fBlc=2\fP 값도 시험해보십시오. +.TP +\fBlp=\fP\fIlp\fP +리터럴 위치 비트 수를 지정하빈다. 최소 값은 0이고 최대 값은 4입니다. 기본 값은 0입니다. +.IP "" +\fIlp\fP 값은 리터럴 인코딩 진행시 비압축 데이터 정렬 방식 고려에 영향을 줍니다. 정렬 방식에 대한 자세한 정보는 하단 \fIpb\fP를 +참고하십시오. +.TP +\fBpb=\fP\fIpb\fP +위치 비트 수를 지정합니다. 최소 값은 0이며 최대 값은 4입니다. 기본값은 2입니다. +.IP "" +\fIpb\fP 값은 보통 압축하지 않은 데이터에 어떤 정렬 방식을 고려하느냐에 영향을 줍니다. 기본적으로 4바이트 +정렬(2^\fIpb\fP=2^2=4)을 의미하는데, 이보다 더 나은 추측 값이 없어서 종종 최적의 선택으로 간주합니다. +.IP "" +정렬 상태를 알지 못할 경우, \fIpb\fP 설정 값이 파일 크기를 조금 줄일 수 있습니다. 예를 들면, 텍스트 파일이 단일 바이트 단위로 +정돈된 상태(US\-ASCII, ISO\-8859\-*, UTF\-8)라면, \fBpb=0\fP 설정 값으로 압축율을 조금 개선할 수 있습니다. +UTF\-16 텍스트의 경우, \fBpb=1\fP 설정 값이 좋은 선택입니다. 정렬 바이트가 3 바이트 같은 홀수 바이트일 경우, +\fBpb=0\fP 설정 값이 최적의 선택일지도 모릅니다. +.IP "" +가정 정렬을 \fIpb\fP 값과 \fIlp\fP 값으로 조정하긴 하지만, LZMA1과 LZMA2는 여전히 16바이트 정렬 방식으로 선호합니다. +LZMA1 또는 LZMA2로 종종 압축하는 파일 형식이라고 하면 고려해볼만 합니다. +.TP +\fBmf=\fP\fImf\fP +일치 검색기는 인코더 속도, 메모리 사용량, 압축율에 주된 영향을 줍니다. 보통 해시 체인 검색기는 이진 트리 검색기보다 빠르긴 +합니다. 기본 값은 \fI<사전설정>\fP에 따라 다릅니다. 0은 \fBhc3\fP을, 1\(en3은 \fBhc4\fP를, 나머지는 +\fBbt4\fP를 활용합니다. +.IP "" +다음 검색 필터를 지원합니다. 메모리 사용 공식은 \fIdict\fP 값이 2의 승수일 경우 실제에 가까운 근사치입니다. +.RS +.TP +\fBhc3\fP +2바이트, 3바이트 해싱 체인 +.br +\fInice\fP 최소값: 3 +.br +메모리 사용: +.br +\fIdict\fP * 7.5 (조건: \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 5.5 + 64 MiB (조건: \fIdict\fP > 16 MiB) +.TP +\fBhc4\fP +2바이트, 3바이트, 4바이트 해싱 체인 +.br +\fInice\fP 최소값: 4 +.br +메모리 사용: +.br +\fIdict\fP * 7.5 (조건: \fIdict\fP <= 32 MiB); +.br +\fIdict\fP * 6.5 (조건: \fIdict\fP > 32 MiB) +.TP +\fBbt2\fP +2바이트 해싱 이진 트리 +.br +\fInice\fP 최소값: 2 +.br +메모리 사용: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +2바이트, 3바이트 해싱 이진트리 +.br +\fInice\fP 최소값: 3 +.br +메모리 사용: +.br +\fIdict\fP * 11.5 (조건: \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 9.5 + 64 MiB (조건: \fIdict\fP > 16 MiB) +.TP +\fBbt4\fP +2바이트, 3바이트, 4바이트 해싱 이진 트리 +.br +\fInice\fP 최소값: 4 +.br +메모리 사용: +.br +\fIdict\fP * 11.5 (조건: \fIdict\fP <= 32 MiB); +.br +\fIdict\fP * 10.5 (조건: \fIdict\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fI<모드>\fP +압축 \fI<모드>\fP 값은 일치 검색기에서 생산하는 데이터 분석 방식을 지정합니다. 지원하는 \fI<모드>\fP는 +\fBfast\fP와 \fBnormal\fP 입니다. 기본값은 \fI<사전설정>\fP값 0\(en3에 대해 \fBfast\fP, +\fI<사전설정>\fP값 4\(en9에 대해 \fBnormal\fP입니다. +.IP "" +보통 \fBfast\fP는 해시 체인 검색기에서 사용하며 \fBnormal\fP은 이진 트리 검색기에서 사용합니다. 이 동작은 또한 +\fI<사전설정>\fP 값이 할 일이기도 합니다. +.TP +\fBnice=\fP\fInice\fP +일치하는 nice 길이를 지정합니다. 최소한 \fInice\fP 바이트 정도 일치하면, 알고리즘이 가능한 최선의 부분을 찾는 동작을 +멈춥니다. +.IP "" +\fInice\fP 값은 2\(en273 바이트입니다. 값이 클 수록 속도 면에서는 손해를 보겠지만 압축율은 더욱 올라갑니다. 기본 값은 +\fI<사전설정>\fP값에 따라 다릅니다. +.TP +\fBdepth=\fP\fI<깊이>\fP +일치 검색기에서의 최대 검색 깊이를 지정합니다. 기본값은 특별한 값 0으로 지정하며, 이 값으로 압축 프로그램이 \fImf\fP 와 +\fInice\fP간 적절한 \fI<깊이>\fP 값을 결정합니다. +.IP "" +적절한 해시 체인 \fI<깊이>\fP 값은 이진 트리에서 4\(en100 그리고 16\(en1000 입니다. 상당히 큰 값을 +\fI<깊이>\fP 값으로 사용하면 일부 파일에 대해 인코더가 매우 느리게 동작할 수가 있습니다. 압축 시간이 너무 오래걸려서 +동작을 중간에 끊을 준비가 되지 않은 이상 \fI<깊이>\fP 설정 값은 1000을 넘지 않게하십시오. +.RE +.IP "" +원시 스트림(\fB\-\-format=raw\fP)을 디코딩할 때, LZMA2는 딕셔너리 \fI<크기>\fP만 필요합니다. LZMA1는 +\fIlc\fP, \fIlp\fP, \fIpb\fP 값이 모두 필요합니다. +.TP +\fB\-\-x86\fP[\fB=\fP\fI<옵션>\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIoptions\fP] +.PD +브랜치/호출/점프(BCJ) 필터를 필터 체인에 추가합니다. 이 필터는 필터 체인의 비종결 필터로만 사용할 수 있습니다. +.IP "" +BCJ 필터는 머신 코드의 상대 주소를 절대 주소로 변환합니다. 데이터 크기를 바꾸지는 않지만 LZMA2에서 \fB.xz\fP 파일을 +0\(en15% 정도 줄여주게 하는 중복성이 늘어납니다. BCJ 필터는 언제든 뒤집을 수 있어, 데이터에 적절하지 않은 BCJ 필터 +형식을 활용하면, 그냥 가만히 두면 압축율이 약간 떨어지게 한다 하더라도, 데이터를 잃을 수가 있습니다. BCJ 필터는 굉장히 빠르며 +메모리 공간을 적게 활용합니다. +.IP "" +이 BCJ 필터에는 압축율 관련 몇가지 문제가 있습니다: +.RS +.IP \(bu 3 +실행 코드가 들어있는 몇가지 파일 형식(예: 목적 파일, 정적 라이브러리, 리눅스 커널 모듈)의 경우 필터 값으로 채운 명령 주소가 +있습니다. 여기 BCJ 필터의 경우 파일의 압축율을 떨어뜨리는 주소 변환을 수행합니다. +.IP \(bu 3 +BCJ 필터를 아카이브에 적용하면, BCJ 필터를 사용하지 않았을 때보다 압축율이 떨어질 수가 있습니다. 예를 들면, 유사하거나 동일한 +실행 파일 여럿이 있으면 필터를 사용하여 파일을 덜 비슷하게 만들어 압축율이 떨어지게 합니다. 동일한 아카이브 파일에서 비 실행 파일의 +내용에 대해서도 비슷한 일이 벌어질 수 있습니다. 실제로 하나는 BCJ 필터를 걸고 하나는 제외하여 각 경우에 대해 어떤 경우가 결과가 +우수한 지 살펴보겠습니다. +.RE +.IP "" +다른 명령 세트는 다른 정렬 상태에 놓여있습니다. 실행 파일은 필터가 제대로 동작하게 하려면 입력 데이터에 있는 이 값의 배수로 +정돈해야합니다. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +필터;정렬;참고 +x86;1;32\-bit 또는 64\-bit x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096 바이트 정렬이 가장 좋습니다 +PowerPC;4;빅엔디안 전용 +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +BCJ 필터를 사용한 데이터는 LZMA2로 보통 압축하기 때문에 LZMA2 옵션을 선택한 BCJ 필터의 정렬기준에 맞추도록 설정하면 +압축율을 좀 더 개선할 수 있습니다. 예를 들면: +.RS +.IP \(bu 3 +IA\-64 필터는 16\-바이트 정렬 방식으로 동작하기에 LZMA2 필터에 \fBpb=4,lp=4,lc=0\fP 옵션(2^4=16)을 주는게 +좋습니다. +.IP \(bu 3 +RISC\-V 코드에는 16\-비트 압축 명령(C 확장) 적재 여부에 따라 2\-바이트 또는 4\-바이트 정렬 방식을 채택합니다. 16\-비트 +명령을 사용하면, \fBpb=2,lp=1,lc=3\fP 또는 \fBpb=1,lp=1,lc=3\fP 옵션 값 사용이 바람직합니다. 16\-비트 명령이 +없다면, \fBpb=2,lp=2,lc=2\fP 옵션 값을 활용하는게 좋습니다. "RVC"가 "Flags"행에 나타나는지 확인할 때 +\fBreadelf \-h\fP 명령을 사용할 수 있습니다. +.IP \(bu 3 +ARM64는 항상 4\-바이트 정렬 방식을 택하기에 \fBpb=2,lp=2,lc=2\fP 옵션 값을 활용하는게 좋습니다. +.IP \(bu 3 +x86 필터는 예외입니다. x86 실행 파일을 압축할 경우에는 보통 LZMA2 기본 옵션 값(\fBpb=2,lp=0,lc=3\fP)을 그대로 +사용하는게 좋습니다. +.RE +.IP "" +모든 BCJ 필터는 동일한 \fI옵션\fP을 지원합니다: +.RS +.TP +\fBstart=\fP\fI<오프셋>\fP +상대 주소와 절대 주소를 변환할 때 사용할 시작 \fI<오프셋>\fP을 지정합니다. \fI<오프셋>\fP에는 필터 +정렬 배수여야 합니다(상단 테이블 참조). 기본값은 0입니다. 실제로 기본값이 낫습니다. 개별 \fI<오프셋>\fP 지정 +값은 거의 쓸모가 없습니다. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fI<옵션>\fP] +필터 체인에 델타 필터를 추가합니다. 델타 필터는 필터 체인에서 마지막에 지정하지 않은 필터로만 사용할 수 있습니다. +.IP "" +현재로서는 바이트 단위 단순 델타계산 결과만 보여줍니다. 예를 들면, 압축하지 않은 비트맵 그림 또는 압축하지 않은 PCM 오디오를 +압축할 때 쓸만합니다. 그러나 특별한 목적으로 활용하는 알고리즘은 델타 + LZMA2 보다 더 나은 결과를 가져다 주기도 합니다. +이는 특히 오디오의 경우 맞는 이야기인데, \fBflac\fP(1)의 경우 더 빠르고 우수한 압축율을 보여줍니다. +.IP "" +지원 \fI옵션\fP: +.RS +.TP +\fBdist=\fP\fI<차이>\fP +바이트 단위 델터 계산 \fI<차이>\fP를 지정합니다. \fI<차이>\fP값은 1\(en256 이어야합니다. 기본 +값은 1입니다. +.IP "" +예를 들어, \fBdist=2\fP 옵션과 A1 B1 A2 B3 A3 B5 A4 B7 입력 값을 주면, 출력 값은 A1 B1 01 02 01 +02 01 02 입니다. +.RE +. +.SS "기타 옵션" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +경고 및 알림을 끕니다. 두 번 지정하면 오류 메시지 표시도 끕니다. 이 옵션은 종료 상태에 영향을 주지 않습니다. 경고 표시를 +끄더라도, 종료 상태에서는 여전히 경고가 나타났음을 알려줍니다. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +출력 내용이 많아집니다. 표준 오류를 터미널에 연결했다면 \fBxz\fP는 진행 표시를 나타냅니다. \fB\-\-verbose\fP를 두번 지정하면 +더 많은 내용을 표시합니다. +.IP "" +진행 표시에서는 다음 정보를 나타냅니다: +.RS +.IP \(bu 3 +입력 파일의 크기를 알고 있을 경우 완료 백분율. 파이프 처리시에는 백분율을 나타낼 수 없습니다. +.IP \(bu 3 +산출 압축 데이터 용량 (압축) 또는 소모 공간 용량 (압축 해제). +.IP \(bu 3 +비압축 데이터 소모 용량 (압축) 또는 산출 용량 (압축 해제). +.IP \(bu 3 +압축 데이터 산출 용량을 비압축 데이터 처리 용량으로 나누어 계산한 압축율. +.IP \(bu 3 +압축 또는 압축 해제 속도. 초당 비압축 데이터 소모량(압축) 또는 산출 용량(압축 해제)를 측정한 값입니다. \fBxz\fP에서 파일 +처리를 시작한 몇 초 후 나타납니다. +.IP \(bu 3 +경과 시간 형식은 M:SS 또는 H:MM:SS 입니다. +.IP \(bu 3 +추산 여분 시간은 \fBxz\fP가 파일을 처리하기 시작한 이후 입력 파일의 크기를 알고 몇 초가 지난 후에야 보여줍니다. 시간은 콜론 +문자를 사용하지 않고 덜 자세한 형식으로, 예를 들면, 2분 30초 와 같은 형식으로 보여줍니다. +.RE +.IP "" +표준 오류가 터미널이 아니라면 \fB\-\-verbose\fP는 \fBxz\fP에서 파일 이름, 압축 크기, 압축 해제 용량, 압축율, 그리고 +가능하다면 파일을 압축 또는 압축 해제한 후 표준 오류로 속도와 걸린 시간을 나타내도록 합니다. 속도와 걸린 시간 정보는 동작을 +처리하는데 최소한 몇초 정도 소요했을 경우에만 들어갑니다. 동작이 끝나지 않았다면, 이를테면 사용자의 중단 요청이 있었을 경우 입력 +파일의 크기를 알고 있을 때 압축 백분율 정보도 들어갑니다. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +경고로 알릴 만한 상황을 만났다 하더라도 종료 상태 2번을 설정하지 않습니다. 이 옵션은 출력 수준에 영향을 주지 않기 때문에, +\fB\-\-quiet\fP 옵션과 \fB\-\-no\-warn\fP 옵션을 경고 표시를 막고 종료 상태를 바꾸지 않을 목적으로 사용합니다. +.TP +\fB\-\-robot\fP +머신에서 해석할 형식으로 메시지를 나타냅니다. liblzma 대신 \fBxz\fP를 활용하려는 다양상 스크립트로서의 프론트엔드를 쉽게 +작성하도록 하기 위함입니다. 이 옵션을 지정한 출력은 \fBxz\fP 릴리스가 어떻게 되든 안정 버전이란 의미입니다. 자세한 내용은 +\fB로봇 모드\fP 섹션을 참고하십시오. +.TP +\fB\-\-info\-memory\fP +압축 및 압축 해제시 물리 메모리 용량 (RAM), \fBxz\fP에서 파악하는 프로세서 스레드 갯수, 메모리 사용량 한계를 파악하기 쉬운 +형식으로 나타내고 무사히 나갑니다. +.TP +\fB\-h\fP, \fB\-\-help\fP +보통 사용하는 옵션을 설명하는 도움말 메시지를 출력한 후, 완전히 빠져나갑니다. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +\fBxz\fP의 모든 기능을 설명하는 도움말 메시지를 출력한 후, 완전히 빠져나갑니다 +.TP +\fB\-V\fP, \fB\-\-version\fP +\fBxz\fP와 liblzma 버전 번호를 가독 형식으로 출력합니다. 기계 해석 가능 형식을 가져오려면 \fB\-\-version\fP 앞에 +\fB\-\-robot\fP을 지정하십시오. +. +.SH "로봇 모드" +로봇 모드는 \fB\-\-robot\fP 옵션으로 동작합니다. \fBxz\fP 출력을 다른 프로그램에서 해석하기 쉽게 해줍니다. 현재로서는 +\fB\-\-robot\fP 옵션은 \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, \fB\-\-version\fP +옵션하고만 사용할 수 있습니다. 앞으로는 압축 및 압축 해제 동작에 대해서도 지원합니다. +. +.SS "목록 모드" +\fBxz \-\-robot \-\-list\fP 명령은 탭으로 구분한 출력 형태를 활용합니다. 모든 행의 첫번째 컬럼에는 해당 행에서 찾을 수 +있는 정보의 형식을 나타냅니다: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +이 행은 항상 파일 목록 시작 부분의 첫번째 줄에 있습니다. 이 행의 두번째 컬럼에 파일 이름이 들어있습니다. +.TP +\fBfile\fP +이 행에는 \fB.xz\fP 파일의 전반적인 정보가 들어있습니다. 이 행은 항상 \fBname\fP 행 다음에 있습니다. +.TP +\fBstream\fP +이 행 형식은 \fB\-\-verbose\fP 옵션을 지정했을 때만 사용합니다. \fB.xz\fP 파일의 \fBstream\fP 행 수만큼 나타납니다. +.TP +\fBblock\fP +이 행 형식은 \fB\-\-verbose\fP 옵션을 지정했을 때만 사용합니다. \fB.xz\fP 파일의 블록 수만큼 \fBblock\fP 행이 +나타납니다. \fBblock\fP 행은 모든 \fBstream\fP 행 다음에 나타납니다. 다른 형식의 행이 끼어들지는 않습니다. +.TP +\fBsummary\fP +이 행 형식은 \fB\-\-verbose\fP 옵션을 두번 지정했을 때만 사용합니다. 이 행은 모든 \fBblock\fP 행 다음에 출력합니다. +\fBfile\fP 행과 비슷하게, \fBsummary\fP 행에는 \fB.xz\fP 파일의 전반적인 정보가 담겨있습니다. +.TP +\fBtotals\fP +이 행은 목록 출력의 가장 마지막에 항상 나타납니다. 총 갯수와 크기를 나타냅니다. +.PP +\fBfile\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +파일 스트림 갯수 +.IP 3. 4 +스트림의 블록 총 갯수 +.IP 4. 4 +파일 압축 크기 +.IP 5. 4 +파일 압축 해제 크기 +.IP 6. 4 +예를 들면, \fB0.123\fP과 같은 압축율 입니다. 비율이 9.999라면, 대시 문자 3개 (\fB\-\-\-\fP)를 비율 값 대신 나타냅니다. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +쉼표로 구분한 무결성 검사 이름 목록입니다. \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP, \fBSHA\-256\fP 문자열을 알려진 +검사 형식으로 사용합니다. 알 수 없는 검사 형식에 대해서는 \fBUnknown\-\fP\fIN\fP을 사용하며, 여기서 \fIN\fP은 (한 두자리) +정수형 숫자값으로 이루어진 검사 ID 입니다. +.IP 8. 4 +파일의 스트림 패딩 총 길이 +.RE +.PD +.PP +\fBstream\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +스트림 번호 (첫 스트림은 1번) +.IP 3. 4 +스트림의 블록 총 갯수 +.IP 4. 4 +압축 시작 오프셋 +.IP 5. 4 +비압축 시작 오프셋 +.IP 6. 4 +압축 크기 (스트림 패딩 미포함) +.IP 7. 4 +압축 해제 용량 +.IP 8. 4 +압축율 +.IP 9. 4 +무결성 검사 이름 +.IP 10. 4 +스트림 패딩 길이 +.RE +.PD +.PP +\fBblock\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +이 블록이 들어간 스트림 갯수 +.IP 3. 4 +스트림 시작 부분의 블록 번호 (첫번째 블록은 1번) +.IP 4. 4 +파일 시작 부분의 블록 번호 +.IP 5. 4 +파일 시작 부분의 압축 시작 오프셋 +.IP 6. 4 +파일 시작 부분의 비압축 시작 오프셋 +.IP 7. 4 +총 블록 압축 크기 (헤더 포함) +.IP 8. 4 +압축 해제 용량 +.IP 9. 4 +압축율 +.IP 10. 4 +무결성 검사 이름 +.RE +.PD +.PP +\fB\-\-verbose\fP를 두 번 지정하면, 추가 컬럼을 \fBblock\fP 행에 넣습니다. \fB\-\-verbose\fP 단일 지정시에는 이 +정보를 볼 때 탐색을 여러번 수행해야 하기 때문에 실행 과정이 느려질 수 있어서 나타내지 않습니다: +.PD 0 +.RS +.IP 11. 4 +16진수 무결성 검사값 +.IP 12. 4 +블록 헤더 크기 +.IP 13. 4 +블록 플래그: \fBc\fP는 압축 크기가 현재 값임을 나타내고, \fBu\fP는 압축 전 원본 크기가 현재 값임을 나타냅니다. 플래그를 설정하지 +않았다면, 문자열 길이를 유지할 목적으로 대시 \fB\-\fP 를 대신 나타냅니다. 새 플래그는 나중에 문자열 끝 부분에 추가할 예정입니다. +.IP 14. 4 +블록에 압축 해서 넣은 데이터의 실제 츠기 (블록 헤더, 블록 패딩, 검사 필드 제외) +.IP 15. 4 +이 \fBxz\fP 버전에서 이 블록의 압축을 해제할 때 필요한 (바이트 단위) 메모리 용량 +.IP 16. 4 +필터 체인. 대부분 사용하는 옵션은 압축 해제시 필요한 옵션만을 \fB.xz\fP 헤더에 저장하기 때문에 압축 시간에 알 수 없습니다. +.RE +.PD +.PP +\fBsummary\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +이 \fBxz\fP 버전에서 이 파일 압축을 해제할 때 필요한 (바이트 단위) 메모리 용량 +.IP 3. 4 +모든 블록 헤더에 압축 크기와 압축 전 원본 크기 정보가 들어갔는지 여부를 나타내는 \fByes\fP 또는 \fBno\fP 값 +.PP +\fBxz\fP \fI5.1.2alpha\fP \fI부터:\fP +.IP 4. 4 +파일 압축 해제시 필요한 최소 \fBxz\fP 버전 +.RE +.PD +.PP +\fBtotals\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +스트림 갯수 +.IP 3. 4 +블록 갯수 +.IP 4. 4 +압축 크기 +.IP 5. 4 +압축 해제 용량 +.IP 6. 4 +평균 압축율 +.IP 7. 4 +파일에 들어 있어 쉼표로 구분한 무결성 검사 이름 목록 +.IP 8. 4 +스트림 패딩 길이 +.IP 9. 4 +파일 갯수. \fBfile\fP 행의 컬럼 순서를 따라갑니다. +.PD +.RE +.PP +\fB\-\-verbose\fP 옵션을 두 번 지정하면, \fBtotals\fP 행에 추가 컬럼이 들어갑니다: +.PD 0 +.RS +.IP 10. 4 +이 \fBxz\fP 버전에서 파일 압축을 해제할 떄 필요한 (바이트 단위) 최대 메모리 사용량 +.IP 11. 4 +모든 블록 헤더에 압축 크기와 압축 전 원본 크기 정보가 들어갔는지 여부를 나타내는 \fByes\fP 또는 \fBno\fP 값 +.PP +\fBxz\fP \fI5.1.2alpha\fP \fI부터:\fP +.IP 12. 4 +파일 압축 해제시 필요한 최소 \fBxz\fP 버전 +.RE +.PD +.PP +차후 버전에서는 새 행 형식을 추가하고 기존 행 형식에 추가할 수 있는 새 컬럼을 넣기 까지는 알 수 있겠지만, 기존 컬럼은 바꾸지 않을 +예정입니다. +. +.SS "필터 도움말" +\fBxz \-\-robot \-\-filters\-help\fP 는 다음 형식의 지원 필터 목록을 출력합니다: +.PP +\fI<필터>\fP\fB:\fP\fI<옵션>\fP\fB=<\fP\fI값\fP\fB>,\fP\fI<옵션>\fP\fB=<\fP\fI값\fP\fB>\fP... +.TP +\fI<필터>\fP +필터 이름 +.TP +\fI<옵션>\fP +필터별 옵션 이름 +.TP +\fI<값>\fP +숫자 \fI값\fP 범위는 \fB<\fP\fI최소\fP\fB\-\fP\fI최대\fP\fB>\fP입니다. 문자열 \fI값\fP은 \fB< >\fP 범위 +내에서 선택하며 \fB|\fP 문자로 구분합니다. +.PP +각 필터는 한 줄에 하나씩 출력합니다. +. +.SS "메모리 제한 정보" +\fBxz \-\-robot \-\-info\-memory\fP 명령은 탭으로 나뉜 여러 컬럼을 단일 행으로 나타냅니다: +.IP 1. 4 +물리 메모리(RAM)의 바이트 단위 총량. +.IP 2. 4 +압축 진행시 바이트 단위 메모리 사용 한계값 (\fB\-\-memlimit\-compress\fP). 특수 값 \fB0\fP은 단일\-스레드 모드에서 +제한을 두지 않는 기본 설정임을 나타냅니다. +.IP 3. 4 +압축 해제시 바이트 단위 메모리 사용 한계값 (\fB\-\-memlimit\-decompress\fP). 특수 값 \fB0\fP은 단일\-스레드 모드에서 +제한을 두지 않는 기본 설정임을 나타냅니다. +.IP 4. 4 +\fBxz\fP 5.3.4alpha 이후: 다중\-스레드 기반 압축 해제시 바이트 단위 메모리 +사용량(\fB\-\-memlimit\-mt\-decompress\fP). 분명하게 제한을 걸어두지 않았을 경우 5번째 컬럼에 나타난 시스템별 +기본값을 사용하기 때문에 0 값을 지정하면 안됩니다. 또한 \fB\-\-memlimit\-mt\-decompress\fP로 세번째 컬럼 값보다 더 +크게 지정을 한다 할지라도 이 값이 세번째 컬럼 값보다 크면 안됩니다. +.IP 5. 4 +\fBxz\fP 5.3.4alpha 이후: A system\-specific default memory usage limit that is +used to limit the number of threads when compressing with an automatic +number of threads (\fB\-\-threads=0\fP) and no memory usage limit has been +specified (\fB\-\-memlimit\-compress\fP). This is also used as the default value +for \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +\fBxz\fP 5.3.4alpha 이후: Number of available processor threads. +.PP +차후, \fBxz \-\-robot \-\-info\-memory\fP 출력에는 더 많은 내용이 들어가지만, 한 줄 이상은 넘어가지 않습니다. +. +.SS 버전 +\fBxz \-\-robot \-\-version\fP 은 \fBxz\fP 와 liblzma의 버전 번호를 다음 형식으로 나타냅니다: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +주 버전. +.TP +\fIYYY\fP +부 버전. 짝수가 안정 버전입니다. 홀수는 알파 또는 베타 버전입니다. +.TP +\fIZZZ\fP +안정 릴리스의 패치 수준 또는 개발 릴리스의 횟수입니다. +.TP +\fIS\fP +안정도. 0은 알파 버전, 1은 베타 버전을 나타내며, 2는 안정 버전을 나타냅니다. \fIS\fP는 \fIYYY\fP 값이 짝수라 해도 항상 +2여야 합니다. +.PP +\fBxz\fP 명령과 liblzma이 동일한 XZ 유틸리티 릴리스에서 나왔다면 두 행의 \fIXYYYZZZS\fP 값은 같습니다. +.PP +예제: 4.999.9beta는 \fB49990091\fP이며, 5.0.0은 \fB50000002\fP입니다. +. +.SH "종료 상태" +.TP +\fB0\fP +모든 상태 양호. +.TP +\fB1\fP +오류 발생. +.TP +\fB2\fP +눈여겨볼 경고가 나타났지만, 실제 오류는 일어나지 않음. +.PP +표준 오류에 출력하는 알림(경고 또는 오류 아님)는 종료 상태에 영향을 주지 않습니다. +. +.SH 환경 +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP는 빈칸으로 구분한 옵션 값 목록을 \fBXZ_DEFAULTS\fP, \fBXZ_OPT\fP 환경 변수에서 순서대로, 명령행에서 옵션을 +해석하기 전에 불러옵니다. 참고로 환경 변수에서 옵션만 해석하며, 옵션이 아닌 부분은 조용히 무시합니다. 해석은 +\fBgetopt_long\fP(3)으로 가능하며, 명령행 인자로 활용하기도 합니다. +.PP +\fB경고:\fP 환경 변수를 설정하면, 프로그램과 \fBxz\fP를 실행하는 스크립트의 동작이 바뀝니다. 대부분의 경우 메모리 사용 제한량, +스레드 수, 압축 옵션을 환경 변수로 설정하는게 안전합니다. 그러나 일부 옵션은 스크립트의 동작을 망가뜨릴 수 있습니다. 분명한 +예제로는 \fBxz\fP에서 파일의 압축 및 해제 대신 도움말 내용을 표시하는 \fB\-\-help\fP 옵션이 있습니다. 좀 더 묘한 예제로는 +\fB\-\-quiet\fP 와 \fB\-\-verbose\fP 옵션이 있습니다. 대부분의 경우 \fB\-\-verbose\fP 옵션을 사용하여 프로세스 상황을 +표시하는데 잘 동작하지만, 어떤 경우에는 추가 메시지가 나타나는 문제가 있습니다. 출력 상세 수준은 \fB\-\-list\fP의 동작에도 영향을 +줍니다. +.TP +\fBXZ_DEFAULTS\fP +사용자별, 시스템 범위 기본 옵션입니다. 보통 \fBxz\fP의 메모리 사용량 제한을 기본으로 걸어두거나 기본 스레드 수를 설정할 경우 셸 +초기화 스크립트에 설정합니다. 셸 초기화 스크립트와 별도의 유사한 경우를 제외하고라면, 스크립트에서는 \fBXZ_DEFAULTS\fP 환경 +변수를 설정하지 않거나 설정을 해제해야합니다. +.TP +\fBXZ_OPT\fP +\fBxz\fP 명령행으로 옵션 설정 값을 직접 전달할 수 없을 경우 \fBxz\fP에 옵션을 전달하는 환경 변수입니다. 예를 들어, \fBxz\fP를 +스크립트 또는 도구에서 실행할 경우 GNU \fBtar\fP(1) 라면: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +예를 들면, 스크립트에서 \fBXZ_OPT\fP 를 활용하여, 스크립트별로 기본 압축 옵션을 지정할 수 있습니다. 적절한 이유가 있다면 +\fBXZ_OPT\fP 옵션 값을 사용자가 바꾸는걸 추천합니다. 예를 들면, \fBsh\fP(1) 스크립트에서 다음처럼 활용할 수도 있습니다: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "LZMA 유틸리티 호환성" +\fBxz\fP의 명령행 문법은 실제로 LZMA 유틸리티 4.32.x에서 찾을 수 있는 \fBlzma\fP, \fBunlzma\fP \fBlzcat\fP의 +상위 집합입니다. 대부분의 경우 LZMA 유틸리티를 XZ 유틸리티로 기존에 작성한 스크립트를 깨지 않고도 바꿀 수 있습니다. 몇가지 +비호환성 문제 때문에 문제가 일어날 수는 있습니다. +. +.SS "압축 사전 설정 단계" +압축 수준 사전 설정의 번호 부여 방식은 \fBxz\fP와 LZMA 유틸리티가 동일하지 않습니다. 가장 중요한 차이는 다른 사전 설정에 대해 +딕셔너리 크기를 어떻게 대응했느냐 여부입니다. 딕셔너리 크기는 압축 해제시 메모리 사용량과 거의 비슷합니다. +.RS +.PP +.TS +tab(;); +c c c +c n n. +단계;xz;LZMA 유틸리티 +\-0;256 KiB;없음 +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +딕셔너리 크기 차이는 압축 프로그램 메모리 사용에 영향을 주지만, LZMA 유틸리티와 XZ 유틸리티에서 사용량이 늘어나는 다른 차이점이 +있습니다: +.RS +.PP +.TS +tab(;); +c c c +c n n. +단계;xz;LZMA 유틸리티 4.32.x +\-0;3 MiB;없음 +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +XZ 유틸리티의 기본 사전 설정 수준값은 \fB\-6\fP이지만 LZMA 유틸리티의 기본 사전 설정 수준값은 \fB\-7\fP입니다. 두 프로그램의 +딕셔너리 메모리 기본 사용량은 8MiB입니다. +. +.SS "스트림 vs 비스트림 .lzma 파일" +파일을 압축하지 않은 크기는 \fB.lzma\fP 헤더에 저장합니다. LZMA 유틸리티는 일반 파일을 압축할 때 압축하지 않은 파일의 크기를 +저장합니다. 이 대신 압축하지 않은 크기를 '알 수 없음' 으로 저장하고 압축 해제 프로그램이 멈춰야 할 지점에 +end\-of\-payload 마커를 사용하는 방법도 있습니다. LZMA 유틸리티는 파이프로 들어온 입력과 같이 압축하지 않은 파일의 +크기를 알 수 없을 때 이런 방식을 활용합니다. +.PP +\fBxz\fP는 \fB.lzma\fP 파일을 end\-of\-payload 마커의 유무와 관계없이 압축 해제 방식을 모두 지원하지만, \fBxz\fP로 +만든 모든 \fB.lzma\fP 파일은 end\-of\-payload 마커를 사용하며, \fB.lzma\fP 헤더에 압축하지 않은 파일 크기를 '알 수 +없음'으로 표기합니다. 이 방식은 드문 상황에서 문제를 야기할 수 있습니다. 예를 들면, 임베디드 장치의 \fB.lzma\fP 압축 해제 +프로그램은 압축을 해제했을 때 크기를 알아야 동작합니다. 이 문제를 만나면, LZMA 유틸리티 또는 LZMA SDK를 활용하여 +\&\fB.lzma\fP 파일에 압축 전 파일 크기 정보를 저장해야합니다. +. +.SS "지원하지 않는 .lzma 파일" +\&\fB.lzma\fP 형식은 \fIlc\fP 값을 8까지 받아들이며, \fIlp\fP 값은 4까지 받아들입니다. LZMA 유틸리티는 어떤 \fIlc\fP 값과 +\fIlp\fP 값을 받아들이고도 압축을 해제할 수 있지만, 파일을 만들 때는 늘 \fBlc=3\fP 값과 \fBlp=0\fP 값을 활용합니다. 다른 +\fIlc\fP 값과 \fIlp\fP 값으로의 파일 압축은 \fBxz\fP와 LZMA SDK에서만 가능합니다. +.PP +liblzma의 LZMA1 필터 구현체에서는 \fIlc\fP 값과 \fIlp\fP 값의 합이 4를 넘어가면 안됩니다. 그래서 \fB.lzma\fP +파일의 경우 이 제한을 넘어가면 \fBxz\fP로 압축을 해제할 수 없습니다. +.PP +LZMA 유틸리티는 2^\fIn\fP (2의 승수)크기를 지닌 딕셔너리를 가진 \fB.lzma\fP 파일만 만들지만 받아들이는 파일의 딕셔너리 +크기는 어떤 크기든 상관 없습니다. liblzma에서는 2^\fIn\fP, 2^\fIn\fP + 2^(\fIn\fP\-1) 딕셔너리 크기를 가진 +\&\fB.lzma\fP 파일 만 받아들입니다. 이로 인해 \fB.lzma\fP 파일을 확인할 때 거짓 양성율이 늘어납니다. +.PP +모든 \fB.lzma\fP 파일을 liblzma 에서 받아들일 수 있도록 압축하기 때문에 이 제한이 실제로는 문제가 되지 않습니다. +. +.SS "뒤따라오는 쓰레기 값" +압축 해제할 때, LZMA 유틸리티는 \fB.lzma\fP 스트림 처음 부분 다음 나머지를 다 조용히 무시합니다. 대부분의 경우, +버그입니다. LZMA 유틸리티에서 \fB.lzma\fP 결합 파일 압축 해제를 지원하지 않음을 의미하기도 합니다. +.PP +\&\fB.lzma\fP 스트림 처음부분 바로 다음에 데이터가 남아있을 경우, \fBxz\fP 에서는 \fB\-\-single\-stream\fP 옵션을 사용하지 +않으면 깨진 파일로 간주합니다. 이 동작으로 하여금 뒤따라오는 쓰레기 값을 무시하도록 간주하는 애매한 스크립트 동작을 깰 수가 +있습니다. +. +.SH 참고 +. +.SS "출력 결과물이 달라짐" +압축하지 않은 입력 파일로부터 얻어낸 정확한 압축 출력 결과물은 압축 옵션이 완전히 동일하더라도 XZ 유틸리티의 버전에 따라 달라질 수 +있습니다. 파일 형식에 영향을 주지 않고 인코더 그 자체를 개선(더 빠르게 하거나 더 나은 압축율로)하기 때문입니다. XZ 유틸리티 +버전이 동일하더라도 빌드 옵션을 달리하여 빌드 상태가 제각각인 경우 출력 결과물이 달라질 수 있습니다. +.PP +\fB\-\-rsyncable\fP 기능을 넣었을 경우 동일한 xz 버전에서 이전 파일과 새 파일로 별도로 압축하지 않는 한 결과 파일을 (두 +파일이 서로 다른 파일이 아니므로) rsync 처리할 필요가 없습니다. 이 문제는 인코더 구현체 기능 개발이 끝나서 xz 버전이 +다르더라도 안정적인 rsync 가능한 출력 결과물을 유지할 수 있을 때여야 해결할 수 있습니다. +. +.SS "내장 .xz 압축 해제 프로그램" +XZ 임베디드와 같은 내장 \fB.xz\fP 압축 해제 구현체는 지원 파일의 무결성 \fI검사\fP 형식을 \fInone\fP과 \fIcrc32\fP 이외의 +설정으로 만들 필요가 없습니다. 기본값이 \fB\-\-check=crc64\fP일 경우에만, 임베디드 시스템에서 파일을 만들 때 +\fB\-\-check=none\fP 또는 \fB\-\-check=crc32\fP 옵션을 사용해야합니다. +.PP +임베디드 시스템이 아니라면, 모든 \fB.xz\fP 형식 압축 해제 프로그램에서는 모든 \fI검사\fP 형식을 지원하거나, 일부 \fI검사\fP 방식을 +지원하지 않는다면, 최소한, 무결성 검사로 검증하지 않고 압축을 해제할 수 있습니다. +.PP +XZ 임베디드는 BCJ 필터를 지원하지만, 기본 시작 오프셋만 지정할 수 있습니다. +. +.SH 예제 +. +.SS 기본 +\fIfoo\fP 파일을 기본 압축 수준 (\fB\-6\fP) 으로 \fIfoo.xz\fP 파일에 압축해 넣고, 압축 과정이 무사히 끝나면 \fIfoo\fP를 +삭제합니다: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +\fIbar.xz\fP를 \fIbar\fP 에 압축을 해제한 후 압축 해제가 무사히 끝나도 \fIbar.xz\fP를 삭제하지 않습니다: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +기본 사전 설정 \fB\-6\fP 보다는 느리지만, 압축 및 압축 해제시 메모리를 적게 차지(각각 48\ Mib, 5\MiB)는 \fB\-4e\fP +사전 설정(\fB\-4 \-\-extreme\fP)을 활용하여 \fIbaz.tar.xz\fP 파일을 만듭니다: +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +압축 및 비압축 파일을 단일 명령으로 표준 출력에 압축해제할 수 있습니다: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "다중 파일 병렬 압축" +GNU와 *BSD에서는 \fBfind\fP(1) 명령과 \fBxargs\fP(1) 명령으로 여러 파일의 압축을 병렬 처리할 수 있습니다: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +\fBxargs\fP(1) 의 \fB\-P\fP 옵션으로 \fBxz\fP 프로세스의 병렬 처리 갯수를 지정합니다. \fB\-n\fP 옵션의 최적 값은 압축할 +파일 수에 달려있습니다. 압축할 파일이 몇개밖에 없다면 1이어야합니다. 파일이 수천 수만개 정도 된다면 \fBxargs\fP(1) 이 +어쨌든지간에 만들어낼 \fBxz\fP 프로세스의 겟수를 100으로 하거나 아니면 적당한 값을 지정하여 줄이는게 좋습니다. +.PP +\fBxz\fP에 \fB\-T1\fP옵션을 지정하면 단일\-스레드 모드로 강제합니다. \fBxargs\fP(1) 에서 병렬 처리 갯수를 제어할 수 있기 +때문입니다. +. +.SS "로봇 모드" +여러 파일을 압축한 후 저장할 바이트 용량을 계산합니다: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +이 스크립트에서는 충분히 최신의 \fBxz\fP 명령을 사용하는지 알아보려 합니다. 다음 \fBsh\fP(1) 스크립트에서는 \fBxz\fP 도구의 +버전 번호가 최소한 5.0.0인지 여부를 검사합니다. 이 방식은 \fB\-\-robot\fP 옵션을 지원하지 않는 오래된 베타 버전과도 호환성이 +있습니다: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +\fBXZ_OPT\fP 환경 변수로 압축 해제시 메뢰 사용량 한계를 설정하지만, 한계 값을 이미 설정했다면, 값을 늘리지 않습니다: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "개별 압축 필터 체인 설정" +개별 설정 필터 체인의 초단순 사용방식은 LZMA2 사전 설정 값을 별도로 설정하는 방식입니다. 사전 설정은 잠재적으로 쓸만한 압축 +설정 조합만 다루기 때문에 꽤 쓸모가 있을 수도 있습니다. +.PP +\fB\-0\fP ... \fB\-9\fP 옵션의 설명에서 테이블의 CompCPU 컬럼과 \fB\-\-extreme\fP 옵션은 LZMA2 사전 설정을 +개별적으로 맞췄을 때 쓸만할 수도 있습니다. 여기 관련내용을 테이블 둘로 정리해서 모아보았습니다: +.RS +.PP +.TS +tab(;); +c c +n n. +Preset;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +어떤 파일을 압축할 때 상당히 큰 딕셔너리(예: 32MiB)가 필요 하다는걸 알아채셨지만, \fBxz \-8\fP 명령이 압축할 때보다 더 빠른 +속도로 압축하려 한다면, 더 큰 딕셔너리 사용을 위해 더 낮은 CompCPU 사전 설정 값(예: 1)으로 수정할 수 있습니다: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +각 파일에 대해, 위 명령은 압축율이 더 좋아지면서도 \fBxz \-6\fP보다 더 빨라집니다. 그러나, CompCPU 값을 낮게 유지하는 +대신 큰 딕셔너리에서 일부 파일을 강조해야 합니다. 큰 딕셔너리가 대부분의 도움을 주는 매우 명백한 상황에서는 최소한 몇 메가바이트의 +매우 유사한 각 파일이 아카이브에 들어갑니다. 딕셔너리 크기는 LZMA2가 연속으로 존재하는 각 파일의 유사성으로부터 얻는 장점을 취할 +수 있을 때 일부 개별 파일보다 훨씬 더 커집니다. +.PP +압축 프로그램과 압축 해제 프로그램에서 메모리를 엄청 많이 사용해도 상관 없고, 파일을 수백 메가 바이트 메모리 용량을 활용하여 +압축한다면, \fBxz \-9\fP 명령에 64MiB 용량을 초과하는 딕셔너리를 사용할 수 있게 하는 방법도 쓸만할 지도 모릅니다: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +위 예제에서와 같이 \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) 옵션을 사용하면 압축 및 압축 해제 과정에서 필요한 메모리 +용량을 살펴보는데 요긴할 수 있습니다. 압축 해제한 파일 크기보다 더 큰 딕셔너리를 사용하면 불필요한 메모리 소모량이 발생하여 위 +명령이 작은 파일에는 쓸모 없음을 기억하십시오. +.PP +때로는 압축 시간이 딱히 상관이 없을 수도 있습니다만, 압축 해제시 메모리 사용량을 적게 유지해야 할 수도 있습니다. 예를 들면, +임베디드 시스템에서 파일 압축을 해제할 수도 있습니다. 다음 명령의 경우 \fB\-6e\fP (\fB\-6 \-\-extreme\fP) 옵션을 기반 +옵션을 사용하며 딕셔너리 크기를 64KiB만 사용하도록 제한합니다. 결과 파일은 XZ 임베디드(이게 \fB\-\-check=crc32\fP +옵션이 있는 이유)로 100KiB 메모리 용량을 활용하여 풀어낼 수 있습니다. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +가능한 한 수 바이트를 더 쥐어 짜내고 싶을 때, 리터럴 문맥 비트 수(\fIlc\fP)와 위치 비트 수(\fIpb\fP)를 조정하면 도움이 될 +수도 있습니다. 리터럴 위치 비트 수(\fIlp\fP)를 조금 건드리는 것 또한 도움이 될 지도 모르겠지만 보통 \fIlc\fP 값과 \fIpb\fP +값이 더 중요합니다. 예를 들면, 소스 코드 저장 파일에는 US\-ASCII 텍스트가 대부분이기에, 다음과 같은 경우는 \fBxz \-6e\fP +명령을 실행했을 때부다는 아주 약간(거의 0.1% 수준) 작은 파일을 얻어낼 수도 있습니다(\fBlc=4\fP를 빼고도 시도해보십시오): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +LZMA2와 다른 필터를 함께 사용하면 일부 파일 형식에 대해 압축율을 개선할 수 있습니다. 예를 들면 x86\-32 또는 x86\-64 +공유 라이브러리를 x86 BCJ 필터를 활용하여 압축할 경우: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +참고로 필터 옵션의 순서는 상당히 중요합니다. \fB\-\-x86\fP을 \fB\-\-lzma\fP 이전에 지정하면 \fBxz\fP에서 오류가 나는데, +LZMA2 다음에는 어떤 필터든 설정할 수 없고, 옵션 체인상 마지막 필터로 x86 BCJ 필터를 사용할 수 없기 때문입니다. +.PP +LZMA2와 델타 필터는 비트맵 그림에 최적의 결과를 가져다줄 수 있습니다. PNG에 보통 안성맞춥인데, PNG에는 단순 델타 필터보단 +약간 더 고급진 필터를 사용하지만, 실제 압축을 진행할 때는 Deflate를 사용하기 때문입니다. +.PP +예를 들어 이미지를 압축하지 않은 비압축 TIFF로 저장해야 하는 경우가 있습니다. 델타 필터의 거리 매개변수는 그림에서 픽셀당 바이트 +수에 일치하도록 설정합니다. 예를 들면, 24비트 RGB 비트맵의 경우 \fBdist=3\fP 거리 매개변수 값을 설정해야 하며, LZMA2 +압축시 3바이트 정렬을 따르도록 \fBpb=0\fP 값을 전달하는 방법도 바람직합니다: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +여러 이미지를 단일 아카이브로 넣고 싶다면(예: \fB.tar\fP), 모든 이미지에 대해 동일한 픽셀당 바이트 수가 들어가는 경우에도 델타 +필터가 동작합니다. +. +.SH "추가 참조" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ 유틸리티: +.br +XZ 임베디드: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/unxz.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/unxz.1 new file mode 100644 index 0000000000000000000000000000000000000000..631a9a7cc8b58565ff6c9eb7a3610b39d1733d20 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/unxz.1 @@ -0,0 +1,1585 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Korean translation for the xz-man +.\" Seong-ho Cho , 2023, 2024. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 2025\-03\-08 Tukaani "XZ 유틸리티" +. +.SH 이름 +xz, unxz, xzcat, lzma, unlzma, lzcat \- .xz 파일과 .lzma 파일을 압축 또는 압축 해제합니다 +. +.SH 요약 +\fBxz\fP [\fI<옵션>...\fP] [\fI<파일>...\fP] +. +.SH "명령 별칭" +\fBunxz\fP 명령은 \fBxz \-\-decompress\fP 명령과 동일합니다. +.br +\fBxzcat\fP 명령은 \fBxz \-\-decompress \-\-stdout\fP 명령과 동일합니다. +.br +\fBlzma\fP 명령은 \fBxz \-\-format=lzma\fP 명령과 동일합니다. +.br +\fBunlzma\fP 명령은 \fBxz \-\-format=lzma \-\-decompress\fP 명령과 동일합니다. +.br +\fBlzcat\fP 명령은 \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP 명령과 동일합니다. +.PP +파일 압축을 해제해야 하는 셸 스크립트를 작성할 때, \fBunxz\fP 와 \fBxzcat\fP 이름 대신 \fBxz\fP 명령과 적절한 인자 +값(\fBxz \-d\fP 또는 \fBxz \-dc\fP)의 사용을 추천드립니다. +. +.SH 설명 +\fBxz\fP는 \fBgzip\fP(1) 과 \fBbzip2\fP(1) 과 비슷한 명령행 문법을 지닌 범용 데이터 압축 도구입니다. 자체 파일 +형식은 \fB.xz\fP 형식이나, LZMA 유틸리티에서 사용하는 예전 \fB.lzma\fP 형식과 형식 헤더가 없는 RAW 압축 스트림도 +지원합니다. 게다가, \fBlzip\fP에서 활용하는 \fB.lz\fP 형식 압축 해제도 지원합니다. +.PP +각 \fI파일\fP 에 대한 \fBxz\fP 압축 또는 압축 해제는 선택 동작 모드에 따릅니다. \fI<파일>\fP 값이 주어졌거나 +\fI<파일>\fP 값이 \fB\-\fP이면, \fBxz\fP 명령에서 표준 입력을 읽고 처리한 데이터를 표준 출력에 기록합니다. +\fBxz\fP 에서는 터미널에서 활용할 경우 압축 데이터를 표준 압축으로 기록하는 동작을 거절(오류를 출력하고 \fI<파일>\fP을 +건너뜀)합니다. 이와 비슷하게, \fBxz\fP 유틸리티를 터미널에서 실행하면 표준 입력의 압축 데이터 읽기를 거절합니다. +.PP +\fB\-\-stdout\fP 을 지정하지 않는 한, \fB\-\fP가 아닌 \fI<파일>\fP을 원본 \fI<파일>\fP 이름에서 +가져온 새 파일 이름으로 기록합니다: +.IP \(bu 3 +압축할 때, 대상 파일 형식의 접미사(\fB.xz\fP or \fB.lzma\fP) 는 원본 파일 이름 뒤에 붙어 대상 파일이름이 됩니다. +.IP \(bu 3 +압축 해제할 때, \fB.xz\fP, \fB.lzma\fP, \fB.lz\fP 접미사를 파일 이름에서 제거하고 대상 파일 이름을 알아냅니다. +\fBxz\fP에서는 \fB.txz\fP, \fB.tlz\fP 접미사도 인식하며, \fB.tar\fP 접미사로 치환합니다. +.PP +대상 파일이 이미 있으면, 오류를 나타내고 \fI<파일>\fP을 건너뜁니다. +.PP +표준 출력으로 기록하기 전에는, \fBxz\fP는 경고를 나타내며, 다음 조건에 만족할 경우 \fI<파일>\fP을 건너뜁니다: +.IP \(bu 3 +\fI<파일>\fP이 일반 파일이 아닐 때. 심볼릭 링크는 따라가지 않기에, 일반 파일로 간주하지 않습니다. +.IP \(bu 3 +\fI<파일>\fP이 하나 이상의 하드 링크일 떄. +.IP \(bu 3 +\fI<파일>\fP에 setuid, setgid, 끈적이 비트 집합이 붙어있을 떄. +.IP \(bu 3 +동작 모드를 압축으로 설정하고, \fI<파일>\fP은 대상 파일 형식의 접미사를 이미 붙였을 때(\fB.xz\fP 형식으로 압축하면 +\&\fB.xz\fP 또는 \fB.txz\fP, \fB.lzma\fP 형식으로 압축하면 \fB.lzma\fP 또는 \fB.tlz\fP). +.IP \(bu 3 +동작 모드를 압축 해제로 설정하고, \fI<파일>\fP에 지원 파일 형식 접미사(\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, +\&\fB.tlz\fP, \fB.lz\fP)를 붙이지 않았을 때. +.PP +\fI<파일>\fP 의 압축 또는 압축 해제를 성공하고 나면, \fBxz\fP는 소유자, 소유그룹, 권한, 접근 시각, 수정 시각 +정보를 원본 \fI<파일>\fP에서 대상 파일로 그대로 복사합니다. 그룹 정보 복사에 실패하면, 권한을 수정하여 원본 +\fI<파일>\fP에 접근 권한이 없는 사용자가 대상 파일로 접근하지 못하게 합니다. \fBxz\fP는 아직 접근 제어 목록이나 +확장 속성 등의 기타 메타데이터를 복사하는 기능은 지원하지 않습니다. +.PP +대상 파일을 온전히 닫고 나면, \fB\-\-keep\fP 옵션을 지원하지 않았을 경우 원본 \fI<파일>\fP을 제거합니다. 원본 +\fI<파일>\fP은 출력을 표준 출력으로 기록했거나 오류가 발생했을 경우 제거하지 않습니다. +.PP +\fBxz\fP 프로세스에 \fBSIGINFO\fP 시그널 또는 \fBSIGUSR1\fP 시그널을 보내면 표준 출력으로 진행 정보를 출력합니다. 표준 +오류가 터미널일 경우일 경우에만 제한하며 \fB\-\-verbose\fP 옵션을 지정하면 진행 표시줄을 자동으로 나타냅니다. +. +.SS "메모리 사용" +\fBxz\fP 메모리 사용은 수백 킬로바이트로 시작하여 수 기가바이트까지 압축 설정에 따라 다릅니다. 압축 해제 프로그램이 필요로 하는 +메모리 공간을 결정하는 파일 압축시에 설정 값을 활용합니다. 보통 압축 해제 프로그램은 파일을 만들 때, 압축 프로그램 메모리 사용량의 +5% 에서 20% 정도 필요합니다. 예를 들면, \fBxz \-9\fP로 압축한 파일 압축 해제시 현재 65MiB 메모리 용량이 필요합니다. +여전하게도, 압축 해제시 수 기가 바이트의 메모리가 필요한 \fB.xz\fP 파일에도 가능한 이야기입니다. +.PP +특히 이전 시스템 사용자의 경우 메모리 사용량이 엄청나게 늘어나는 점에 짜증이 날 수 있습니다. 이런 불편한 상황을 피하기 위해, +\fBxz\fP에 기본적으로 비활성 상태인 내장 메모리 사용 제한 기능을 넣었습니다. 일부 운영체제에서 처리 중 메모리 사용을 제한하는 +수단을 제공하긴 하지만, 여기에 의지하기에는 충분히 유연하지 않습니다(예를 들면, \fBulimit\fP(1)을 사용하면 가상 메모리를 +제한하여 \fBmmap\fP(2)을 먹통으로 만듭니다). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +메모리 사용 제한 기능은 \fB\-\-memlimit=\fP\fI<제한용량>\fP 명령행 옵션으로 사용할 수 있습니다. 종종 +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP와 같이 \fBXZ_DEFAULTS\fP 환경 변수를 설정하여 제한 기능을 켜는게 더 +편합니다. \fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션과 +\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP 옵션을 활용하여 압축 및 압축 해제시 별도로 한계 값을 +설정할 수 있습니다. 이 두 가지 옵션의 \fBXZ_DEFAULTS\fP 환경 변수 밖에서의 사용은, \fBxz\fP를 단일 실행할 때 압축 및 +압축 해제 동작을 동시에 수행하지 않으며, 앞서 언급한 두가지 옵션을 명령행에 입력하기에는 +\fB\-\-memlimit=\fP\fI<제한용량>\fP(또는 \fB\-M\fP \fI<제한용량>\fP)이 더 짧기 때문에 별로 쓸모가 +없습니다. +.PP +압축 해제시 메모리 사용 제한 지정 한계를 초과하면, \fBxz\fP 유틸리티에서 오류를 나타내며 파일 압축 해제는 실패합니다. 압축을 +실행할 때 사용 제한 지정 한계를 넘어서면 \fBxz\fP에서는 설정 값을 줄여서 어쨌든 한계를 넘지 못하게 +합니다(\fB\-\-format=raw\fP 옵션 또는 \fB\-\-no\-adjust\fP 옵션 사용시 제외). 설정 한계 값이 엄청 작지 않은 이상 이 +방식대로 처리하면 어쨌든 실패하지 않습니다. 설정 값조정은 압축 래벨 사전 설정과 일치하지 않을 때 단계적으로 진행하는데, 이를테면, +\fBxz \-9\fP 명령 수행에 필요한 양보다 한계 값이 약간 작으면, 설정 값을 \fBxz \-8\fP에 못미치게 약간 줄여서 진행합니다. +. +.SS ".xz 파일 결합 및 패딩" +\&\fB.xz\fP 파일을 있는 그대로 합칠 수 있습니다. \fBxz\fP는 \fB.xz\fP 파일을 단독 파일일 때 처럼 압축해제합니다. +.PP +결합 부분과 마지막 부분 뒤에 패딩을 추가할 수 있습니다. 패딩은 널 바이트로 구성해야 하며 패딩 길이는 4바이트로 구성해야 합니다. +512 바이트 블록으로 파일 크기를 이루는 매체에 \fB.xz\fP 파일을 저장했을 경우에 요긴할 수 있습니다. +.PP +\&\fB.lzma\fP 파일 또는 원시 스트림의 경우 결합과 패딩을 허용하지 않습니다. +. +.SH 옵션 +. +.SS "정수 접두사와 별도 값" +정수 인자값이 필요한 대부분 위치에서는, 큰 정수값을 나타내기 쉽게 하도록 추가 접미사를 지원합니다. 정수와 접미사 사이에 어떤 공백이 +있으면 안됩니다. +.TP +\fBKiB\fP +1,024 (2^10) 배수 정수값. \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP, \fBKB\fP 단위를 \fBKiB\fP 동의어로 받아들입니다. +.TP +\fBMiB\fP +1,048,576 (2^20) 배수 정수값. \fBMi\fP, \fBm\fP, \fBM\fP, \fBMB\fP 단위를 \fBMiB\fP 동의어로 받아들입니다. +.TP +\fBGiB\fP +1,073,741,824 (2^30) 배수 정수값. \fBGi\fP, \fBg\fP, \fBG\fP, \fBGB\fP 단위를 \fBGiB\fP 동의어로 +받아들입니다. +.PP +특수 값 \fBmax\fP는 옵션에서 지원하는 정수 최대 값을 나타낼 때 사용할 수 있습니다. +. +.SS "동작 모드" +여러 동작 모드를 보여드리겠습니다만, 마지막에 주어진 동작 모드로 동작합니다. +.TP +\fB\-z\fP, \fB\-\-compress\fP +압축합니다. 어떤 동작 모드 옵션도 지정하지 않고 다른 동작 모드를 명령행에 따로 지정하지 않았다면 이 동작 모드는 기본입니다(예: +\fBunxz\fP 는 \fB\-\-decompress\fP를 암시). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +압축을 제대로 끝내고 나면, 표준 출력에 기록하거나 \fB\-\-keep\fP 옵션을 지정하지 않았다면 원본 파일을 제거합니다. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +압축 해제입니다. 압축 해제를 제대로 끝내고 나면, 표준 출력에 기록하거나 \fB\-\-keep\fP 옵션을 지정하지 않았다면 원본 파일을 +제거합니다. +.TP +\fB\-t\fP, \fB\-\-test\fP +압축 \fI<파일>\fP의 무결성을 시험해봅니다. 이 옵션은 압축 해제 데이터를 표준 출력으로 기록하는 대신 버린다는 점을 +제외하고 \fB\-\-decompress \-\-stdout\fP과 동일합니다. 어떤 파일도 만들거나 제거하지 않습니다. +.TP +\fB\-l\fP, \fB\-\-list\fP +압축 \fI<파일>\fP 정보를 출력합니다. 압축 해제 출력을 내보내지 않으며, 어떤 파일도 만들거나 제거하지 않습니다. 이 +조회 모드에서, 프로그램은 표준 입력 또는 기타 탐색 불가능한 원본에서 압축 데이터를 읽을 수 없습니다. +.IP "" +\fI<파일>\fP 기본 정보를 파일 당 한 줄 씩 기본으로 보여줍니다. 더 자세한 정보를 보려면 \fB\-\-verbose\fP +옵션을 사용하십시오. 더 자세한 정보는 \fB\-\-verbose\fP 옵션을 두번 사용하면 되지만, 추가 정보를 더 많이 가져오면서 탐색 +횟수가 늘어나는 문제로 인해 느려질 수 있습니다. 세부 출력 너비는 80 문자를 초과하며, 예를 들어 출력을 파이핑한다면, 터미널이 +충분히 너비가 넓지 못할 경우 \fBless\ \-S\fP 명령이 편리할 수 있습니다. +.IP "" +정확한 출력은 \fBxz\fP 버전과 다른 로캘에 따라 바뀔 수 있습니다. 기계 판독용 출력시 \fB\-\-robot \-\-list\fP 옵션을 +사용합니다. +. +.SS "동작 수정자" +.TP +\fB\-k\fP, \fB\-\-keep\fP +입력 파일을 삭제하지 않습니다. +.IP "" +\fBxz\fP 5.2.6 부터는 이 옵션으로 입력 파일이 일반 파일을 참조하는 심볼릭 링크나 하나 이상의 하드 링크, 내지는 setuid, +setgid, 끈적이 비트 세트를 설정한 상태라도 압축하거나 압축을 풀 수 있습니다. setuid, setgid, 끈적이 비트는 대상 +파일에 복사하지 않습니다. 이전 버전에서는 \fB\-\-force\fP 옵션을 지정했을 때만 가능했습니다. +.TP +\fB\-f\fP, \fB\-\-force\fP +이 옵션은 몇가지 동작에 영향을 줍니다: +.RS +.IP \(bu 3 +대상 파일이 이미 있으면, 압축 또는 압축 해제 전 삭제합니다. +.IP \(bu 3 +입력 파일이 일반 파일을 참조하는 심볼릭 링크나 하나 이상의 하드 링크, 내지는 setuid, setgid, 끈적이 비트 세트를 설정한 +상태라도 압축 또는 압축 해제를 진행합니다. setuid, setgid, 끈적이 비트는 대상 파일에 복사하지 않습니다. +.IP \(bu 3 +\fB\-\-decompress\fP \fB\-\-stdout\fP 옵션을 같이 사용하는 상황에서 \fBxz\fP 명령이 원본 파일의 형식을 알아내지 못할 때, +원본 파일의 사본을 표준 출력으로 보냅니다. 이렇게 하면 \fBxzcat\fP \fB\-\-force\fP 명령을 \fBxz\fP 명령으로 압축하지 않은 +파일에 대해 \fBcat\fP(1) 을 사용하는 것처럼 사용할 수 있습니다. 참고로 나중에, \fBxz\fP에서 \fBxz\fP로 하여금 여러 형식의 +파일을 표준 출력으로 복사하는 대신 압축을 해제하도록 새 압축 파일 형식을 지원할 예정입니다. +\fB\-\-format=\fP\fI<형식>\fP 옵션은 \fBxz\fP 명령에 단일 파일 형식만 압축 해제하도록 제한할 때 사용할 수 +있습니다. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +파일 대신 표준 출력으로 압축 또는 압축 해제한 데이터를 기록합니다. \fB\-\-keep\fP를 생략했습니다. +.TP +\fB\-\-single\-stream\fP +처음 \fB.xz\fP 스트림만 압축 해제하며, 스트림에 뒤따라오는 나머지 입력 데이터는 조용히 무시합니다. 보통 뒤따라오는 쓰레기 값에 +대해서는 \fBxz\fP 에서 오류를 나타냅니다. +.IP "" +\fBxz\fP는 \fB.lzma\fP 파일 또는 원시 스트림에서 온 하나 이상의 스트림에 대해 압축 해제동작을 취하지 않지만, 이 옵션을 사용하면 +\fBxz\fP에서 \fB.lzma\fP 파일 또는 원시 스트림을 처리한 다음에 뒤따라오는 데이터를 무시하도록 합니다. +.IP "" +이 옵션은 동작 모드가 \fB\-\-decompress\fP 또는 \fB\-\-test\fP가 아니면 동작에 아무런 영향을 주지 않습니다. +.IP "" +\fBxz\fP 5.7.1alpha 부터는 \fB\-\-single\-stream\fP 옵션의 동작에 \fB\-\-keep\fP 동작이 들어갑니다. +.TP +\fB\-\-no\-sparse\fP +희소 파일을 만들지 않습니다. 기본적으로 일반 파일로 압축 해제할 경우 \fBxz\fP 에서는 압축 해제한 파일에 이진 0값이 길게 늘어질 +경우 희소 배열 파일을 만들려고 합니다. 표준 출력의 내용 길이만큼 연결한 일반 파일로 기록할 때도 동작하며 희소 파일을 만드는 동안 +아무런 문제가 나타나지 않게 각각의 추가 조건을 만족합니다. 희소 파일을 만들면 디스크 공간을 절약할 수 있으며 디스크 입출력을 줄여 +압축 해제 속도를 올릴 수 있습니다. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +압축할 때, 대상 파일의 접두사를 \fB.xz\fP 또는 \fB.lzma\fP 대신 \fI.suf\fP로 사용하십시오. 표준 출력으로 기록하지 않고 +원본 파일에 \fI.suf\fP 접두사가 붙어있으면, 경고를 나타내고 해당 파일을 건너뜁니다. +.IP "" +압축 해제할 때, \fI.suf\fP 접미사로 파일을 인식하기도 하고, \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, +\&\fB.lz\fP 접미사가 붙은 파일도 인식합니다. 원본 파일에 \fI.suf\fP 접미사가 붙어있으면, 해당 접미사를 제거하여 대상 파일 이름을 +알아냅니다. +.IP "" +원시 스트림 압축 및 압축 해제시(\fB\-\-format=raw\fP) 원시 스트림에 기본 접미사가 없기 때문에, 표준 출력으로 기록하지 않는 +한 접미사를 반드시 지정해야 합니다. +.TP +\fB\-\-files\fP[\fB=\fP\fI<파일>\fP] +\fI<파일>\fP에서 처리할 파일 이름을 읽습니다. \fI<파일>\fP을 생략하면 파일 이름은 표준 입력에서 +불러옵니다. 파일 이름은 개행 문자로 끝나야 합니다. 대시 문자(\fB\-\fP)는 일반 파일 이름으로 취급하며 표준 입력을 의미하지 +않습니다. 파일 이름을 명령행 인자로 지정하면, \fI<파일>\fP에서 파일 이름을 읽어들이기 전 해당 명령행 인자를 먼저 +처리합니다. +.TP +\fB\-\-files0\fP[\fB=\fP\fI<파일>\fP] +각 파일 이름이 널 문자로 끝나야 한다는 점만 제외하면 \fB\-\-files\fP[\fB=\fP\fI<파일>\fP] 옵션과 동일합니다. +. +.SS "기본 파일 형식 및 압축 옵션" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fI<형식>\fP +압축 또는 압축해제 파일 \fI<형식>\fP을 지정합니다: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +기본 값입니다. 압축할 때, \fBauto\fP는 \fBxz\fP의 기본 동작과 동일합니다. 압축을 해제할 때, 입력 파일 형식을 자동으로 +찾습니다. 참고로 원시 스트림(\fB\-\-format=raw\fP)의 경우 자동으로 찾을 수 없습니다. +.TP +\fBxz\fP +\&\fB.xz\fP 파일 형식으로 압축하거나, 압축 해제시 \fB.xz\fP 파일만 받아들입니다. +.TP +\fBlzma\fP, \fBalone\fP +이전 \fB.lzma\fP 파일 형식으로 압축하거나, 압축 해제시 \fB.lzma\fP 파일만 받아들입니다. \fBalone\fP 대체 명령은 LZMA +유틸리티 하위 호환성을 목적으로 제공합니다. +.TP +\fBlzip\fP +압축 해제시 \fB.lz\fP 파일만 받아들입니다. 압축은 지원하지 않습니다. +.IP "" +\&\fB.lz\fP 형식 버전 0과 1을 지원합니다. 버전 0파일은 \fBlzip\fP 1.3 이전에서만 만듭니다. 일반적이진 않지만 일부 파일의 +경우 이 형식의 원본 패키지로 보관한 파일을 찾을 수도 있습니다. 개인적으로 이 형식으로 압축한 오래된 개인 파일을 가지고 있을 수도 +있습니다. 형식 버전 0 압축 해제 지원은 \fBlzip\fP 1.18에서 제거했습니다. \fBlzip\fP 1.4 이후의 버전에서는 버전 1 +형식 파일을 만듭니다. +.TP +\fBraw\fP +원시 스트림으로 압축하거나 압축을 해제합니다(헤더 없음). 고급 사용자 전용입니다. 원시 스트림을 디코딩하려면, +\fB\-\-format=raw\fP 옵션을 사용하고 분명하게 필터 체인을 지정하여 컨테이너 헤더에 필요한 정보를 저장하게 끔 해야합니다. +.RE +.TP +\fB\-C\fP \fI<검사방식>\fP, \fB\-\-check=\fP\fI<검사방식>\fP +무결성 검사 방식을 지정합니다. 검사 방식은 \fB.xz\fP 파일에 저장하며 압축 해제 데이터를 계산합니다. 이 옵션은 \fB.xz\fP +형식으로 압축할 때만 효력이 있습니다: \fB.lzma\fP 형식은 무결성 겁사를 지원하지 않습니다. 무결성 검사는 \fB.xz\fP 파일 압축을 +풀었을 때에 검사합니다. +.IP "" +지원 \fI검사\fP 형식: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +어떤 경우에도 무결성 검사 계산을 수행하지 않습니다. 보통 바람직하지 못한 생각입니다. 데이터 무결성을 다른 방식으로라도 검증해야 +하는 상황이면 쓸만할 수 있습니다. +.TP +\fBcrc32\fP +IEEE\-802.3 (이더넷)의 다항 연산으로 CRC32를 계산합니다. +.TP +\fBcrc64\fP +ECMA\-182의 다항식 연산으로 CRC64를 계산합니다. 이 동작이 기본 동작이기 때문에 CRC32가 깨진 파일을 찾을 때보다는 좀 +낮은 편이며 속도 차이도 거의 없습니다. +.TP +\fBsha256\fP +SHA\-256 해시를 계산합니다. CRC32와 CRC64 보다는 좀 느립니다. +.RE +.IP "" +\&\fB.xz\fP 헤더 무결성은 항상 CRC32로 검증하빈다. 이를 바꾸거나 It is not possible to change or +disable it. +.TP +\fB\-\-ignore\-check\fP +압축 데이터를 압축해제할 경우 압축 데이터의 무결성 검증을 진행하지 않습니다. \fB.xz\fP 헤더의 CRC32 값은 그래도 여전히 보통 +방식으로 검증합니다. +.IP "" +\fB이 옵션이 정확히 무슨 동작을 하는지 알기 전에는 사용하지 마십시오.\fP 이 옵션을 사용하는 타당한 이유로: +.RS +.IP \(bu 3 +깨진 .xz 파일에서 데이터 복구를 시도합니다. +.IP \(bu 3 +압축 해제 속도를 늘립니다. SHA\-256 또는 압축 파일에 들어간 그 무언가를 엄청 빨리 처리합니다. 다른 방식으로 파일 무결성을 +검증해야 하는 목적이 아니라면 이 옵션을 사용하지 않는게 좋습니다. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +압축 사전 설정 수준을 선택합니다. 기본값은 \fB\-6\fP입니다. 다중 수준을 지정하면 가장 마지막 수준 옵션을 적용합니다. 개별 필터 +체인을 이미 지정했다면, 압축 사전 설정 수준 값을 설정할 때 개별 필터 체인을 정리합니다. +.IP "" +사전 설정간 차이는 \fBgzip\fP(1)과 \fBbzip2\fP(1)을 사용할 때보다 더 비중을 차지합니다. 선택한 압축 설정은 압축 해제시 +필요한 메모리 사용량을 셜정하므로 사전 설정 수준 값을 너무 높게 지정하면 RAM 용량이 적은 오래된 시스템에서 파일 압축 해제시 실패할 +수 있습니다. 게다가, \fBgzip\fP(1) 과 \fBbzip2\fP(1)에서 처럼 종종 \fB모든 동작에 \-9를 몰래 활용하는건 바람직하지 않습니다\fP. +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +동작이 빠른 사전 설정 부류입니다. \fB\-0\fP은 때로는 \fBgzip \-9\fP 명령보다 압축율이 훨씬 우수하면서도 더 빠릅니다. 더 큰 +값은 보통 \fBbzip2\fP(1) 명령과 비교했을 떄 압축 결과가 압축 데이터에 따라 달라지더라도, 비교할 법한 속도 또는 더 나은 +압축율을 보입니다. +.TP +\fB\-4\fP ... \fB\-6\fP +오래된 시스템에서 조차도 압축 해제 프로그램의 적절한 메모리 사용량을 보이면서 양호하거나 최적의 압축율을 보여줍니다. \fB\-6\fP 옵션은 +압축 해제시 메모리 사용량이 16MiB 밖에 안되기 때문에 파일을 배포할 때 최적의 선택인 기본 값입니다. (\fB\-5e\fP 또는 +\fB\-6e\fP도 역시 고려할 만합니다. \fB\-\-extreme\fP을 참고하십시오.) +.TP +\fB\-7 ... \-9\fP +\fB\-6\fP과 비슷하지만 압축 및 압축 해제시 요구 메모리 사용량이 더 높습니다. 압축 파일이 각각 8MiB, 16MiB, 32MiB +보다 클 경우에만 쓸만한 옵션입니다. +.RE +.IP "" +동일한 하드웨어에서, 압축 해제 속도는 압축한 데이터의 초당 정적 바이트 처리 수의 어림 평균입니다. 다시 말해, 압축율을 더 올리면, +압축 해제 속도도 역시 올라갑니다. 이는 곧 초당 비압축 데이터 출력 양이 달라질 수 있단 뜻입니다. +.IP "" +다음 표에 사전 설정 기능을 정리했습니다: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Preset;DictSize;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +컬럼 설명: +.RS +.IP \(bu 3 +DictSize는 LZMA2 딕셔너리 크기입니다. 압축 해제 파일의 크기보다 딕셔너리에서 사용하는 낭비 메모리 용량입니다. 실제로 +필요하지 않은 \fB\-7\fP ... \fB\-9\fP 사전 설정값을 피해야 하는 적절한 이유이기도 합니다. \fB\-6\fP 이하에서는 소모 메모리 양이 +충분히 적거나 따로 신경쓸 필요가 없습니다. +.IP \(bu 3 +CompCPU는 압축 속도에 영향을 주는 LZMA2 설정의 단순화 표기 값입니다. 딕셔너리 크기는 속도에도 영향을 주기 때문에 +CompCPU는 \fB\-6\fP ... \fB\-9\fP 수준값과 동일한데, 고수준 값은 여전히 조금 더 느려질 수 있습니다. 느려지는 만큼 +압축율은 가능한 한 더 좋아집니다. \fB\-\-extreme\fP을 참고하십시오. +.IP \(bu 3 +CompMem은 단일\-스레드 모드에서 필요한 압축 프로그램의 메모리 점유 용량입니다. \fBxz\fP 버전에 따라 다를 수 있습니다. +.IP \(bu 3 +DecMem은 압축 해제 프로그램의 메모리 점유용량입니다. 이는 곧, 압축 해제 프로그램에서 필요한 메모리 사용량을 압축 설정에서 +결정한다는 의미가 들어있습니다. 정확한 압축 해제 프로그램의 메모리 사용량은 LZMA2 딕셔너리 크기 보다는 조금 많지만 테이블의 값은 +MiB 용량으로 완전히 반올림한 값입니다. +.RE +.IP "" +다중\-스레드 모드에서 필요한 메모리 용량은 단일\-스레드 모드보단 약간 더 많습니다. \fB\-\-block\-size\fP 기본값에 따라, 각 +스레드에서는 3*3*딕셔녀리_크기 + 압축시_메모리용량 또는 압축_해제시_메모리용량 정도가 필요합니다. 예를 들면, 스레드 넷에 사전 +설정 옵션 \fB\-6\fP을 사용한다면, 660\(en670 MiB 메모리 용량이 필요합니다. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +기대하는 만큼의 좀 더 나은 압축율을 확보하려 선택한 압축 사전 설정 수준의 느린 변형 옵션을 사용하지만, 재수 없는 와중에 골로 가는 +경우가 생기기도 합니다. 압축 해제 프로그램의 메모리 사용에는 영향을 주지 않지만, 압축 프로그램의 메모리 사용량은 \fB\-0\fP +\&... \fB\-3\fP 사전 설정 수준에서 약간 더 올라갈 뿐입니다. +.IP "" +4MiB와 8MiB 두 가지 딕셔너리 용량 설정이 있기 때문에 \fB\-3e\fP 와 \fB\-5e\fP 사전 설정을 (CompCPU 수치를 낮춰서) +각각 \fB\-4e\fP 와 \fB\-6e\fP 보다 약간 더 빠르게 설정할 수 있습니다. 이런 식으로 두 사전 설정이 동일하지 않습니다. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Preset;DictSize;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +예를 들면, 8MiB 딕셔너리를 활용하는 네가지 사전 설정이 있다고 할 때, 빠른 순으로 설정을 나열하자면, \fB\-5\fP, \fB\-6\fP, +\fB\-5e\fP, \fB\-6e\fP 입니다. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +이 옵션은 \fB\-0\fP 과 \fB\-9\fP의 별칭으로 각각 오해할 수 있습니다. LZMA 유틸리티의 하위 호환성을 목적으로 제공합니다. 이 +옵션 사용은 피하십시오. +.TP +\fB\-\-block\-size=\fP\fI<크기>\fP +\&\fB.xz\fP 형식으로 압축할 때, 입력 데이터를 \fI<크기>\fP 바이트 블록으로 입력 데이터를 쪼갭니다. 각각의 블록은 +다중\-스레드 방식으로 처리할 수 있고 임의 접근 압축 해제 가능성을 제한할 수 있게 개별적으로 압축 처리합니다. 이 옵션은 보통 +다중\-스레드 모드에서 기본 블록 크기를 지정할 때 사용하지만, 단일\-스레드 모드에서도 사용할 수 있습니다. +.IP "" +다중\-스레드 모드에서는 약 3배 용량의 \fI<크기>\fP 바이트만큼 각 스레드 별로 입출력 버퍼링용 공간을 할당합니다. 기본 +\fI<크기>\fP는 LZMA2 딕셔너리 크기 또는 1MiB 중 가장 큰 쪽의 세 배입니다. 보통 적절한 값으로 LZMA2 +딕셔너리 크기 또는 최소한 1MiB 용량의 2\(en4배입니다. LZMA2 딕셔너리 크기보다 작은 \fI<크기>\fP는 램의 +소모적 사용 공간으로 할당하는데 LZMA2 딕셔너리 버퍼를 할당한 용량 크기 전체를 다 사용하지 않기 때문입니다. 다중\-스레드 모드에서 +블록 크기는 블록 헤더에 저장하며, 이 크기 정보는 다중\-스레드 압축 해제시 필요합니다. +.IP "" +단일\-스레드 모드에서는 기본적으로 블록 쪼개기를 하지 않습니다. 이 옵션을 설정한다고 해서 메모리 사용에 영향을 주지는 않습니다. +블록 헤더에 크기 정보를 저장하지 않기 때문에 단일\-스레드 모드에서 만든 파일은 다중\-스레드 모드에서 만든 파일과 동일하지 않습니다. +크기 정보의 누락은 또한 \fBxz\fP에서 다중\-스레드 모드로 압축 해제를 진행할 수 없음을 의미하기도 합니다. +.TP +\fB\-\-block\-list=\fP\fI<항목>\fP +\&\fB.xz\fP 형식으로 압축할 때, 압축하지 않은 데이터로 부터 일정 간격 이후에 새 블록 처리를 시작합니다. +.IP "" +\fI<항목>\fP은 쉼표로 구분한 목록으로 지정합니다. 각 항목은 콜론 (\fB:\fP)으로 구분한 0부터 9까지의 추가 필터 +체인 번호 값으로 이루어져 있으며, 압축하지 않은 데이터의 크기 값이 필요합니다. 항목을 생략하면(둘 이상의 쉼표 연속 표기) 이전 +항목의 크기와 필터를 활용하겠다는 함축 의미를 넣을 수 있습니다. +.IP "" +입력 파일이 \fI<항목>\fP 크기의 합보다 크면, 마지막 항목을 파일의 끝까지 반복합니다. 특별히 \fB0\fP 값을 마지막 +값으로 사용하여 파일 나머지 부분을 단일 블록으로 인코딩해야 한다는 의미를 나타낼 수도 있습니다. +.IP "" +\fB\-\-filters1=\fP\fI<필터>\fP \&...\& \fB\-\-filters9=\fP\fI<필터>\fP 옵션 조합으로 +각 블록별 별도 필터 체인을 지정할 수 있습니다. 이 옵션은 1\(en9번 필터 체인을 지정합니다. 필터 체인 0번은 필터 체인을 +지정하지 않았을 때와 동일한 기본 필터 체인으로 참조할 수 있습니다. 필터 체인 식별 번호는 비 압축 크기 앞에 콜론(\fB:\fP)을 붙여 +사용할 수 있습니다. 예를 들면, \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP 옵션을 +지정했을 경우 다음 규칙대로 블록을 만듭니다: +.RS +.IP \(bu 3 +\fB\-\-filters1\fP 필터 체인에서는 2MiB 입력을 +.IP \(bu 3 +\fB\-\-filters3\fP 필터 체인에서는 2MiB 입력을 +.IP \(bu 3 +\fB\-\-filters2\fP 필터 체인에서는 4MiB 입력을 +.IP \(bu 3 +\fB\-\-filters2\fP 필터 체인에서는 4MiB 입력을 +.IP \(bu 3 +기본 필터 체인에서는 2MiB 입력을 +.IP \(bu 3 +입력이 끝나기 전의 모든 블록에는 기본 필터 체인과 4MiB 입력을 적용합니다. +.RE +.IP "" +인코더 블록 크기를 초과하는 크기 값을 지정하면(스레드 모드 기본값 또는 \fB\-\-block\-size=\fP\fI<크기>\fP +옵션으로 지정한 값), 인코더는 \fI<크기>\fP 지정 용량 범위는 유지하면서 추가 블록을 만듭니다. 예를 들면 +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP 옵션을 지정하고 +입력 파일을 80MiB 용량으로 전달하면, 각각 5, 10, 8, 10, 2, 10, 10, 4, 10, 10, 1 MiB 용량을 +차지하는 블록 11개를 결과물로 내줍니다. +.IP "" +다중\-스레드 모드에서 블록 크기는 블록 헤더에 저장합니다. 단일\-스레드 모드에서는 저장하지 않기 때문에 인코딩 처리한 출력은 +다중\-스레드 모드의 출력 결과물과는 다릅니다. +.TP +\fB\-\-flush\-timeout=\fP\fI<제한시간>\fP +압축할 때, 이전 데이터를 소거하고 다음 입력을 블록 단위로 더 읽는데 \fI<제한시간>\fP 밀리초(양의 정수값)가 지났을 +경우, 대기중이던 모든 입력 데이터를 인코더에서 소거한 다음 출력 스트림에 전달합니다. 이런 동작은 네트워크로 스트리밍한 데이터를 +\fBxz\fP로 압축할 때 쓸만합니다. \fI<제한시간>\fP 값을 적게 지정하면 적은 지연 시간에 데이터를 받아낼 수 있지만 +\fI<제한시간>\fP 값을 크게 하면 압축율을 높일 수 있습니다. +.IP "" +이 기능은 기본적으로 꺼져있습니다. 이 옵션을 한번 이상 지정하면, 마지막 옵션의 값대로 동작합니다. 특별히 +\fI<제한시간>\fP 값을 \fB0\fP으로 설정하면 이 설정을 완전히 끌 수 있습니다. +.IP "" +이 기능은 POSIX 시스템이 아닌 곳에서는 사용할 수 없습니다. +.IP "" +.\" FIXME +\fB이 기능은 여전히 시험중입니다\fP. 현재로서는, \fBxz\fP 버퍼링 처리 방식 때문에 \fBxz\fP의 실시간 스트림 압축 해제 기능 활용은 +적절하지 않습니다. +.TP +\fB\-\-no\-sync\fP +원본 파일을 제거하기 전까지는 스토릿지 장치에 대상 파일과 디렉터리를 동기화하지 않습니다. 작은 여러 파일을 압축하거나 압축해제할 때 +성능을 개선할 수 있습니다. 그러나, 삭제 과정을 진행한 다음 시스템이 바로 치명적인 오류가 나타난다면, 대상 파일을 스토릿지 장치에 +저장하지 않았지만 삭제 동작이 이루어졌을 수도 있습니다. 이 경우 원본 파일 뿐만 아니라 대상 파일도 나타나지 않습니다. +.IP "" +이 옵션은 \fBxz\fP 프로그램이 원본 파일을 삭제할 때만 동작합니다. 다른 경우에는 전혀 동기화가 이루어지지 않습니다. +.IP "" +동기화 동작과 \fB\-\-no\-sync\fP 옵션은 \fBxz\fP 5.7.1alpha에 추가했습니다. +.TP +\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP +압축 수행시 메모리 사용 한계를 지정합니다. 이 옵션을 여러번 지정하면 마지막 값을 취합니다. +.IP "" +압축 설정이 \fI<제한용량>\fP을 초과하면, \fBxz\fP는 설정 값의 하향 조정을 시도하여 한계 값을 더이상 넘치지 않게 하고 +자동 조절을 끝냈다는 알림을 표시합니다. 조정은 다음 순서대로 진행합니다. 스레드 수를 줄입니다. 다중\-스레드 모드에서 스레드 하나의 +할당 한계치가 \fI<제한용량>\fP을 넘으면 단일\-스레드 모드로 전환합니다. 그 다음 마지막으로 LZMA2 딕셔너리 크기를 +줄입니다. +.IP "" +\fB\-\-format=raw\fP 또는 \fB\-\-no\-adjust\fP 미지정 상황에서 압축할 때, 압축 데이터 출력에 영향을 주지 않고 스레드 +처리 수만 줄일 수 있습니다. +.IP "" +\fI<제한용량>\fP 값이 아래 설명한 조건에 맞지 않으면, 오류가 나타나고 \fBxz\fP 명령은 종료 상태 1번을 반환하며 +빠져나갑니다. +.IP "" +\fI<제한용량>\fP 값은 여러 방식으로 지정할 수 있습니다: +.RS +.IP \(bu 3 +\fI<제한용량>\fP 값은 바이트 용량 절대값입니다. 정수 값을 사용하되 \fBMiB\fP와 같은 접미사를 사용하는게 좋습니다. +예: \fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +\fI<제한용량>\fP 값은 총 물리 메모리(RAM) 용량의 백분율로 지정할 수도 있습니다. 다른 컴퓨터끼리 공유하는 셸 +초기화 스크립트의 \fBXZ_DEFAULTS\fP 환경 변수에 값을 설정할 때 특히 쓸만합니다. 이런 방식으로 설정하면 시스템의 메모리 설치 +용량에 따라 자동으로 늘어납니다. 예: \fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +\fI<제한용량>\fP 값은 \fB0\fP 기본값으로 설정하여 초기화할 수 있습니다. 현재로서는 \fI<제한용량>\fP +값이 \fImax\fP(최대) (메모리 사용 한계 없음) 인 상태와 동일합니다. +.RE +.IP "" +\fBxz\fP 32비트 버전에서는 몇가지 특별한 경우가 있습니다. \fI<제한용량>\fP 값이 \fB4020MiB\fP를 넘으면 +\fI<제한용량>\fP을 \fB4020MiB\fP로 고정합니다. MIPS32에서는 \fB2000MiB\fP로 대신 고정합니다. +(\fB0\fP과 \fBmax\fP는 이 경우에 해당하지 않습니다. 압축 해제시 비슷한 기능은 없습니다.) 이 경우 32비트 실행 파일이 +4GiB(MIPS32의 경우 2GiB) 주소 영역에 접근할 때 매우 용이하며, 다른 경우에는 원하는대로 문제를 일으키지 않습니다. +.IP "" +\fB메모리 활용\fP 섹션도 참고하십시오. +.TP +\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP +압축 해제시 메모리 사용 한계 용량을 설정합니다. \fB\-\-list\fP 모드에도 영향을 줍니다. \fI<제한용량>\fP을 넘기지 +않고서는 동작이 진행이 안될 경우, \fBxz\fP 에서는 오류를 나타내고 파일 압축 해제를 실패로 +간주합니다. \fI<제한용량>\fP을 지정하는 가능한 방법에 대해서는 +\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션을 참고하십시오. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP +다중\-스레드 모드 압축 해제시 메모리 사용 한계 용량을 설정합니다. 스레드 수에 영향을 줄 수도 있습니다. \fBxz\fP에서 파일 압축 +해제를 거부하게 하진 않습니다. \fI<제한용량>\fP 수치가 다중\-스레드로 처리하기에 너무 낮다면, +\fI<제한용량>\fP 값을 무시하고 \fBxz\fP 동작을 단일\-스레드 모드로 계속 진행합니다. 참고로 +\fB\-\-memlimit\-decompress\fP 옵션도 사용하면, 단일\-스레드 모드와 다중\-스레드 모드 두 경우에 모두 적용하기에, +다중\-스레드 모드에 적용할 \fI<제한용량>\fP 값은 \fB\-\-memlimit\-decompress\fP에 설정하는 제한 값보다 더 +크면 안됩니다. +.IP "" +다른 메모리 사용 용량 제한 옵션과는 달리, \fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP 옵션은 +시스템별 기본 \fI<제한용량>\fP 값을 지닙니다. 현재 설정 값은 \fBxz \-\-info\-memory\fP 명령으로 확인해볼 수 +있습니다. +.IP "" +이 옵션과 기본 값은 한계 값을 주지 않으면 스레드 기반 압축 해제 프로그램이 일부 입력 파일에 대해 정신나간 수준의 메모리 용량을 +할당해서 동작이 끝나버릴 수 있습니다. 기본 \fI<제한용량>\fP이 시스템의 사양에 비해 낮다면, +\fI<제한용량>\fP 값을 자유롭게 올리시되, \fBxz\fP 에서 적은 스레드 수에도 메모리 공간 할당을 시도하는 만큼, 입력 +파일에 적절한 수준으로 가용 RAM 용량을 넘는 큰 값을 설정하지 마십시오. 메모리나 스와핑 영역 공간이 줄어들면 압축해제 성능을 +개선하지 못합니다. +.IP "" +\fI<제한용량>\fP 값을 지정하는 가능한 방법을 보려면 +\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션을 참고하십시오. \fI<제한용량>\fP 값을 +\fB0\fP으로 설정하면 \fI<제한용량>\fP 값이 시스템 지정 기본값으로 바뀝니다. +.TP +\fB\-M\fP \fI<제한용량>\fP, \fB\-\-memlimit=\fP\fI<제한용량>\fP, \fB\-\-memory=\fP\fI<제한용량>\fP +\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP +\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP +\fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP 지정과 동일합니다. +.TP +\fB\-\-no\-adjust\fP +압축 출력 결과에 영향을 주는 설정을 조정하지 않고는 메모리 사용 용량 제한 조건이 맞지 않으면 오류를 표시하고 빠져나갑니다. 이 +옵션은 \fBxz\fP가 다중\-스레드 모드에서 단일\-스레드 모드로 전환하고 LZMA2 딕셔너리 크기를 줄이는 동작을 막아줍니다. 심지어 이 +옵션을 사용하면 메모리 사용 한계를 만족하도록 스레드 수를 줄여 압축 결과물 출력에 영향이 가지 않게 합니다. +.IP "" +원시 스트림(\fB\-\-format=raw\fP)을 만들 떄 자동 조정은 항상 꺼집니다. +.TP +\fB\-T\fP \fI<스레드수>\fP, \fB\-\-threads=\fP\fI<스레드수>\fP +활용할 작업 스레드 수를 지정합니다. \fI<스레드수>\fP 값을 \fB0\fP 값으로 설정하면, \fBxz\fP는 시스템에서 지원하는 +최대 프로세서 스레드 수를 모두 확보합니다. 실제 스레드 수는 입력 파일이 주어진 설정대로 스레드 처리를 할 만큼 그렇게 크지 않을 +경우, 내지는 더 많은 스레드를 사용했을 때 메모리 사용량 한계를 초과할 경우 \fI<스레드수>\fP 보다 적을 수 있습니다. +.IP "" +단일\-스레드와 다중\-스레드 압축 프로그램은 다른 출력 결과물을 냅니다. 단일\-스레드 압축 프로그램은 작은 파일 크기 결과물을 내놓지만, +다중\-스레드 압축 프로그램의 경우 다중\-스레드 압축 프로그램에서 내놓은 결과물은 다중\-스레드로만 압축을 해제할 수 있습니다. +\fI<스레드수>\fP를 \fB1\fP로 설정하면 단일\-스레드 모드를 사용합니다. \fI<스레드수>\fP를 \fB0\fP과 다른 +값으로 설정하면, 시스템에서 실제로 하드웨어 스레드가 1개만 지원한다 하더라도, 다중\-스레드 압축 프로그램을 사용합니다. (\fBxz\fP +5.2.x에서는 이 경우 단일\-스레드 모드를 활용합니다.) +.IP "" +단일\-스레드로 다중\-스레드 모드를 사용하려면, \fI<스레드수>\fP를 \fB+1\fP로 설정하십시오. \fB+\fP 접두사는 \fB1\fP +이외의 값에는 영향을 주지 않습니다. 메모리 사용량 한계 설정은 \fBxz\fP을 \fB\-\-no\-adjust\fP 옵션을 쓰기 전까지는 +단일\-스레드로 전환하게 합니다. \fB+\fP 접두사 지원은 \fBxz\fP 5.4.0에 추가했습니다. +.IP "" +자동 스레드 수를 요청했고 메모리 사용 한계를 지정하지 않았다면, 시스템에 맞게끔 가능한 스레드 수를 제한하는 기본 소프트 제한 값을 +사용합니다. 스레드 수가 한개가 되면 무시하는 이런 개념이 소프트 제한이기에, \fBxz\fP로 하여금 압축 동작 및 압축 해제 동작 수행시 +멈추지 않습니다. 이 가본 소프트 제한 값은 \fBxz\fP 실행 도중 다중\-스레드 모드에서 단일\-스레드 모드로 바뀌게 하지는 않습니다. +활성 제한 값은 \fBxz \-\-info\-memory\fP 명령으로 볼 수 있습니다. +.IP "" +현재 스레딩 처리 방식은 입력을 블록 단위로 쪼개고 각각의 블록을 독립적으로 압축하는 동작을 취합니다. 기본 블록 크기는 압축 수준에 +따라 다르며 \fB\-\-block\-size=\fP\fI<크기>\fP 옵션으로 재지정할 수 있습니다. +.IP "" +스레드 압축 해제 방식은 여러 블록이 블록 헤더에 넣은 크기 정보와 함께 들어간 파일에만 동작합니다. 다중\-스레드 모드에서 압축한 +충분히 큰 모든 파일은 이 조건에 만족하지만, 단일\-스레드 모드에서 압축한 파일은 +\fB\-\-block\-size=\fP\fI<크기>\fP 옵션을 지정하더라도 조건에 만족하지 않습니다. +.IP "" +\fI스레드\fP 기본 값은 \fB0\fP입니다. \fBxz\fP 5.4.x 이전의 기본값은 \fB1\fP입니다. +. +.SS "개별 압축 필터 체인 설정" +개별 필터 체인은 사전 설정에 엮인 설정에 의존하는 대신 압축 설정을 세부적으로 하나하나 설정할 수 있게 합니다. 개별 필터 체인을 +지정하면, 명령행에 앞서 지정한 사전 설정 옵션(\fB\-0\fP \&...\& \fB\-9\fP 과 \fB\-\-extreme\fP)은 무시합니다. 사전 +설정 옵션을 하나 이상의 필터 체인 옵션 다음에 지정하면, 새 사전 설정을 취하며, 앞서 지정한 개별 필터 체인 옵션은 무시합니다. +.PP +필터 체인은 명령행 파이핑에 비교할 수 있습니다. 압축할 때, 압축하지 않은 입력을 첫번째 필터로 놓고, 출력 대상(이 있으면)을 다음 +필터로 지정합니다. 최종 필터의 출력은 압축 파일로 기옥합니다. 체인의 최대 필터 수는 4이지만, 필터 체인상 필터 갯수는 보통 +1~2개입니다. +.PP +수많은 필터가 필터 체인 상에서 제약점을 가지고 있습니다. 일부 필터는 체인의 마지막 필터로만 동작하며, 일부 다른 필터는 마지막이 아닌 +필터로, 어떤 동작은 체인의 어떤 위치에든 둡니다. 필터에 따라, 이 제한은 필터 설계를 따르거나 보안 문제를 막기 위해 존재하기도 +합니다. +.PP +개별 필터 체인은 두가지 방식으로 지정할 수 있습니다. \fB\-\-filters=\fP\fI<필터>\fP와 +\fB\-\-filters1=\fP\fI<필터>\fP \&...\& \fB\-\-filters9=\fP\fI<필터>\fP 옵션으로 +liblzma 필터 문자열 문법에 따라 한가지 옵션을 필터 체인 전체를 지정할 수 있습니다. 대신, 하나 이상의 개별 필터 옵션을 +원하는 필터 체인 순서대로 지정할 수도 있습니다. 이 말인 즉슨, 개별 필터 옵션의 순서가 중요하단 뜻입니다! 원시 스트림을 디코딩할 +때(\fB\-\-format=raw\fP), 압축했을 때 지정했던 필터와 같은 순서로 필터 체인을 지정해야 합니다. 전체 체인 +옵션(\fB\-\-filters=\fP\fI<필터>\fP) 보다 우선 지정한 개별 필터 또는 사전 설정 옵션은 까먹을 수도 있습니다. +전체 체인 옵션 다음에 개별 필터를 지정할 경우 필터 체인의 동작을 무효로 합니다. +.PP +필터는 쉼표로 구분하는 필터별 \fI<옵션>\fP이 있습니다. \fI<옵션>\fP에 추가로 입력한 쉼표는 +무시합니다. 모든 옵션 값에는 기본값이 있어, 값을 바꾸려면 지정해야합니다. +.PP +전체 필터 체인과 \fI<옵션>\fP을 보려면 \fBxz \-vv\fP (\fB\-\-verbose\fP 두 번)명령을 사용하십시오. 이 +명령은 사전 설정이 사용하는 필터 체인 옵션도 볼 수 있습니다. +.TP +\fB\-\-filters=\fP\fI<필터>\fP +전체 필터 체인 또는 사전 설정을 단일 옵션으로 지정합니다. 각 필터는 공백 문자 또는 대시 문자 두번 입력(\fB\-\-\fP)으로 +구분합니다. 셸 명령행에서 \fI필터\fP는 따옴표로 감싸서 단일 옵션으로 해석하도록 해야 합니다. \fI옵션\fP을 표기하려면 \fB:\fP 또는 +\fB=\fP을 활용하십시오. 사전 설정 앞에 \fB\-\fP를 붙일 수 있고 0개 또는 하나 이상의 플래그를 붙일 수 있습니다. 유일하게 +지원하는 플래그는 \fB\-\-extreme\fP과 동일한 \fBe\fP입니다. +.TP +\fB\-\-filters1\fP=\fI<필터>\fP ... \fB\-\-filters9\fP=\fI<필터>\fP +\fB\-\-block\-list\fP와 사용할 수 있는 추가 필터 체인을 최대 9개까지 지정합니다. +.IP "" +예를 들어 텍스트 파일과 실행 파일의 아카이브를 압축할 때 실행 부분에 BCJ 필터 체인을 사용하고 텍스트 부분은 LZMA2 필터를 +사용할 수 있습니다. +.TP +\fB\-\-filters\-help\fP +\fB\-\-filters\fP와 \fB\-\-filters1=\fP\fI<필터>\fP \&...\& +\fB\-\-filters9=\fP\fI<필터>\fP 옵션의 사전 설정 필터와 개별 설정 필터 체인을 지정하는 방법을 설명하는 도움말 +메시지를 출력하고 완전히 빠져나갑니다. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fI<옵션>\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fI<옵션>\fP] +.PD +LZMA1 또는 LZMA2 필터를 필터 체인에 추가합니다. 이 필터는 필터 체인의 마지막 요소로만 사용할 수 있습니다. +.IP "" +LZMA1은 고전 필터로, LZMA1만 지원하는 고전 \fB.lzma\fP 파일 형식에서만 지원합니다. LZMA2는 LZMA1의 업데이트 +버전으로 LZMA1의 실질적 문제를 해결했습니다. \fB.xz\fP 형식은 LZMA2 필터를 사용하며 LZMA1 필터는 전적으로 지원하지 +않습니다. 압축 속도와 압축율은 LZMA1과 LZMA2가 실질적으로 동일합니다. +.IP "" +LZMA1과 LZMA2는 동일한 \fI<옵션>\fP 집합을 공유합니다: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fI<사전설정>\fP +LZMA1 또는 LZMA2의 모든 \fI<옵션>\fP을 \fI<사전설정>\fP으로 +초기화합니다. \fI<사전설정>\fP 값은 정수 값으로 이루어져 있으며, 사전 설정에 변형을 줄 떄 단일 문자가 따라올 수도 +있습니다. 정수 값은 \fB0\fP에서 \fB9\fP 까지이며, 명령행 옵션에서 \fB\-0\fP \&...\& \fB\-9\fP로 대응합니다. 변형 옵션으로 +지원하는 문자는 현재 \fBe\fP 뿐이며, \fB\-\-extreme\fP에 대응합니다. \fI<사전설정>\fP 값을 지정하지 않으면, +LZMA1 또는 LZMA2 기본값을 사전 설정 \fB6\fP에서 가져온 \fI<옵션>\fP으로 취합니다. +.TP +\fBdict=\fP\fI<크기>\fP +딕셔너리(기록 버퍼) \fI<크기>\fP는 최근 처리한 비압축 데이터를 바이트 단위로 메모리에 얼마나 유지하는지 나타냅니다. +알고리즘은 비압축 데이터상 바이트 시퀀스(일치 항목) 반복 탐색을 시도하며, 해당 부분을 딕셔너리의 현재 참조로 치환합니다. 딕셔너리가 +크면 일치하는 항목을 찾을 기회가 더 많아집니다. 따라서, 딕셔너리 \fI<크기>\fP를 더욱 크게 설정하면 압축율을 증가할 +수는 있지만, 압축하지 않은 파일보다 딕셔너리가 크면 메모리 낭비율이 올라갑니다. +.IP "" +보통 딕셔너리 \fI<크기>\fP는 64KiB 에서 64MiB 정도 됩니다. 최소 4KiB 입니다. 압축시 최대 용량은 현재 +1.5GiB(1536MiB)로 나타납니다. 압축 해제 프로그램에도 4GiB 미만으로 딕셔너리 크기를 이미 지원하며 4GiB 라는 수치는 +LZMA1과 LZMA2 스트림 형식의 최대값입니다. +.IP "" +딕셔너리 \fI<크기>\fP와 검색기(\fImf\fP)는 LZMA1 또는 LZMA 인코더의 메모리 사용량을 함께 결정합니다. +동일한(또는 더 큰) 딕셔너리 \fI<크기>\fP가 데이터를 압축했을 때만큼 압축 해제할 떄 필요하기 때문에, 디코더의 메모리 +사용량은 압축할 때의 딕셔너리 크기로 결정합니다. \fB.xz\fP 헤더에는 딕셔너리 \fI<크기>\fP를 2^\fIn\fP 또는 +2^\fIn\fP + 2^(\fIn\fP\-1) 으로 저장하기에, 이 \fI<크기>\fP 값을 압축할 때 선호하는 편입니다. 다른 +\fI<크기>\fP 값은 \fB.xz\fP 헤더에 저장할 때 반올림합니다. +.TP +\fBlc=\fP\fIlc\fP +리터럴 컨텍스트 비트 수를 지정합니다. 최소 값은 0이고 최대 값은 4입니다. 기본 값은 3입니다. 추가로, \fIlc\fP 값과 +\fIlp\fP 값의 합은 4를 넘으면 안됩니다. +.IP "" +조건이 일치하지 않아 인코딩할 수 없는 모든 바이트는 리터럴로 인코딩합니다. 이 말인 즉슨, 간단히 8비트 바이트로서의 리터럴을 한번에 +하나씩 인코딩합니다. +.IP "" +리터럴 코딩을 할 때 이전 비압축 바이트와 다음 바이트와의 관련성을 가진 가장 많은 \fIlc\fP 비트 수를 가정합니다. 예를 들면, 보통 +영문 문장의 경우 대문자 다음에 종종 소문자가 오고, 소문자 다음에 다른 소문자가 따라옵니다. US\-ASCII 문자 세트에서는 가장 긴 +비트 3개는 대문자에 대해 010, 소문자에 대해 011입니다. \fIlc\fP 값이 최소한 3이면, 리터럴 코딩시 비압축 데이터에 대해 +이런 속성의 장점을 취할 수 있습니다. +.IP "" +(어쨌거나) 기본값 (3)은 보통 적절합니다. 최대 압축을 원한다면 \fBlc=4\fP 값을 시험해보십시오. 때로는 약간 도움이 되기도 +하겠지만, 오히려 결과가 안좋을 수도 있습니다. 결과가 엄한 방향으로 간다면, \fBlc=2\fP 값도 시험해보십시오. +.TP +\fBlp=\fP\fIlp\fP +리터럴 위치 비트 수를 지정하빈다. 최소 값은 0이고 최대 값은 4입니다. 기본 값은 0입니다. +.IP "" +\fIlp\fP 값은 리터럴 인코딩 진행시 비압축 데이터 정렬 방식 고려에 영향을 줍니다. 정렬 방식에 대한 자세한 정보는 하단 \fIpb\fP를 +참고하십시오. +.TP +\fBpb=\fP\fIpb\fP +위치 비트 수를 지정합니다. 최소 값은 0이며 최대 값은 4입니다. 기본값은 2입니다. +.IP "" +\fIpb\fP 값은 보통 압축하지 않은 데이터에 어떤 정렬 방식을 고려하느냐에 영향을 줍니다. 기본적으로 4바이트 +정렬(2^\fIpb\fP=2^2=4)을 의미하는데, 이보다 더 나은 추측 값이 없어서 종종 최적의 선택으로 간주합니다. +.IP "" +정렬 상태를 알지 못할 경우, \fIpb\fP 설정 값이 파일 크기를 조금 줄일 수 있습니다. 예를 들면, 텍스트 파일이 단일 바이트 단위로 +정돈된 상태(US\-ASCII, ISO\-8859\-*, UTF\-8)라면, \fBpb=0\fP 설정 값으로 압축율을 조금 개선할 수 있습니다. +UTF\-16 텍스트의 경우, \fBpb=1\fP 설정 값이 좋은 선택입니다. 정렬 바이트가 3 바이트 같은 홀수 바이트일 경우, +\fBpb=0\fP 설정 값이 최적의 선택일지도 모릅니다. +.IP "" +가정 정렬을 \fIpb\fP 값과 \fIlp\fP 값으로 조정하긴 하지만, LZMA1과 LZMA2는 여전히 16바이트 정렬 방식으로 선호합니다. +LZMA1 또는 LZMA2로 종종 압축하는 파일 형식이라고 하면 고려해볼만 합니다. +.TP +\fBmf=\fP\fImf\fP +일치 검색기는 인코더 속도, 메모리 사용량, 압축율에 주된 영향을 줍니다. 보통 해시 체인 검색기는 이진 트리 검색기보다 빠르긴 +합니다. 기본 값은 \fI<사전설정>\fP에 따라 다릅니다. 0은 \fBhc3\fP을, 1\(en3은 \fBhc4\fP를, 나머지는 +\fBbt4\fP를 활용합니다. +.IP "" +다음 검색 필터를 지원합니다. 메모리 사용 공식은 \fIdict\fP 값이 2의 승수일 경우 실제에 가까운 근사치입니다. +.RS +.TP +\fBhc3\fP +2바이트, 3바이트 해싱 체인 +.br +\fInice\fP 최소값: 3 +.br +메모리 사용: +.br +\fIdict\fP * 7.5 (조건: \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 5.5 + 64 MiB (조건: \fIdict\fP > 16 MiB) +.TP +\fBhc4\fP +2바이트, 3바이트, 4바이트 해싱 체인 +.br +\fInice\fP 최소값: 4 +.br +메모리 사용: +.br +\fIdict\fP * 7.5 (조건: \fIdict\fP <= 32 MiB); +.br +\fIdict\fP * 6.5 (조건: \fIdict\fP > 32 MiB) +.TP +\fBbt2\fP +2바이트 해싱 이진 트리 +.br +\fInice\fP 최소값: 2 +.br +메모리 사용: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +2바이트, 3바이트 해싱 이진트리 +.br +\fInice\fP 최소값: 3 +.br +메모리 사용: +.br +\fIdict\fP * 11.5 (조건: \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 9.5 + 64 MiB (조건: \fIdict\fP > 16 MiB) +.TP +\fBbt4\fP +2바이트, 3바이트, 4바이트 해싱 이진 트리 +.br +\fInice\fP 최소값: 4 +.br +메모리 사용: +.br +\fIdict\fP * 11.5 (조건: \fIdict\fP <= 32 MiB); +.br +\fIdict\fP * 10.5 (조건: \fIdict\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fI<모드>\fP +압축 \fI<모드>\fP 값은 일치 검색기에서 생산하는 데이터 분석 방식을 지정합니다. 지원하는 \fI<모드>\fP는 +\fBfast\fP와 \fBnormal\fP 입니다. 기본값은 \fI<사전설정>\fP값 0\(en3에 대해 \fBfast\fP, +\fI<사전설정>\fP값 4\(en9에 대해 \fBnormal\fP입니다. +.IP "" +보통 \fBfast\fP는 해시 체인 검색기에서 사용하며 \fBnormal\fP은 이진 트리 검색기에서 사용합니다. 이 동작은 또한 +\fI<사전설정>\fP 값이 할 일이기도 합니다. +.TP +\fBnice=\fP\fInice\fP +일치하는 nice 길이를 지정합니다. 최소한 \fInice\fP 바이트 정도 일치하면, 알고리즘이 가능한 최선의 부분을 찾는 동작을 +멈춥니다. +.IP "" +\fInice\fP 값은 2\(en273 바이트입니다. 값이 클 수록 속도 면에서는 손해를 보겠지만 압축율은 더욱 올라갑니다. 기본 값은 +\fI<사전설정>\fP값에 따라 다릅니다. +.TP +\fBdepth=\fP\fI<깊이>\fP +일치 검색기에서의 최대 검색 깊이를 지정합니다. 기본값은 특별한 값 0으로 지정하며, 이 값으로 압축 프로그램이 \fImf\fP 와 +\fInice\fP간 적절한 \fI<깊이>\fP 값을 결정합니다. +.IP "" +적절한 해시 체인 \fI<깊이>\fP 값은 이진 트리에서 4\(en100 그리고 16\(en1000 입니다. 상당히 큰 값을 +\fI<깊이>\fP 값으로 사용하면 일부 파일에 대해 인코더가 매우 느리게 동작할 수가 있습니다. 압축 시간이 너무 오래걸려서 +동작을 중간에 끊을 준비가 되지 않은 이상 \fI<깊이>\fP 설정 값은 1000을 넘지 않게하십시오. +.RE +.IP "" +원시 스트림(\fB\-\-format=raw\fP)을 디코딩할 때, LZMA2는 딕셔너리 \fI<크기>\fP만 필요합니다. LZMA1는 +\fIlc\fP, \fIlp\fP, \fIpb\fP 값이 모두 필요합니다. +.TP +\fB\-\-x86\fP[\fB=\fP\fI<옵션>\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIoptions\fP] +.PD +브랜치/호출/점프(BCJ) 필터를 필터 체인에 추가합니다. 이 필터는 필터 체인의 비종결 필터로만 사용할 수 있습니다. +.IP "" +BCJ 필터는 머신 코드의 상대 주소를 절대 주소로 변환합니다. 데이터 크기를 바꾸지는 않지만 LZMA2에서 \fB.xz\fP 파일을 +0\(en15% 정도 줄여주게 하는 중복성이 늘어납니다. BCJ 필터는 언제든 뒤집을 수 있어, 데이터에 적절하지 않은 BCJ 필터 +형식을 활용하면, 그냥 가만히 두면 압축율이 약간 떨어지게 한다 하더라도, 데이터를 잃을 수가 있습니다. BCJ 필터는 굉장히 빠르며 +메모리 공간을 적게 활용합니다. +.IP "" +이 BCJ 필터에는 압축율 관련 몇가지 문제가 있습니다: +.RS +.IP \(bu 3 +실행 코드가 들어있는 몇가지 파일 형식(예: 목적 파일, 정적 라이브러리, 리눅스 커널 모듈)의 경우 필터 값으로 채운 명령 주소가 +있습니다. 여기 BCJ 필터의 경우 파일의 압축율을 떨어뜨리는 주소 변환을 수행합니다. +.IP \(bu 3 +BCJ 필터를 아카이브에 적용하면, BCJ 필터를 사용하지 않았을 때보다 압축율이 떨어질 수가 있습니다. 예를 들면, 유사하거나 동일한 +실행 파일 여럿이 있으면 필터를 사용하여 파일을 덜 비슷하게 만들어 압축율이 떨어지게 합니다. 동일한 아카이브 파일에서 비 실행 파일의 +내용에 대해서도 비슷한 일이 벌어질 수 있습니다. 실제로 하나는 BCJ 필터를 걸고 하나는 제외하여 각 경우에 대해 어떤 경우가 결과가 +우수한 지 살펴보겠습니다. +.RE +.IP "" +다른 명령 세트는 다른 정렬 상태에 놓여있습니다. 실행 파일은 필터가 제대로 동작하게 하려면 입력 데이터에 있는 이 값의 배수로 +정돈해야합니다. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +필터;정렬;참고 +x86;1;32\-bit 또는 64\-bit x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096 바이트 정렬이 가장 좋습니다 +PowerPC;4;빅엔디안 전용 +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +BCJ 필터를 사용한 데이터는 LZMA2로 보통 압축하기 때문에 LZMA2 옵션을 선택한 BCJ 필터의 정렬기준에 맞추도록 설정하면 +압축율을 좀 더 개선할 수 있습니다. 예를 들면: +.RS +.IP \(bu 3 +IA\-64 필터는 16\-바이트 정렬 방식으로 동작하기에 LZMA2 필터에 \fBpb=4,lp=4,lc=0\fP 옵션(2^4=16)을 주는게 +좋습니다. +.IP \(bu 3 +RISC\-V 코드에는 16\-비트 압축 명령(C 확장) 적재 여부에 따라 2\-바이트 또는 4\-바이트 정렬 방식을 채택합니다. 16\-비트 +명령을 사용하면, \fBpb=2,lp=1,lc=3\fP 또는 \fBpb=1,lp=1,lc=3\fP 옵션 값 사용이 바람직합니다. 16\-비트 명령이 +없다면, \fBpb=2,lp=2,lc=2\fP 옵션 값을 활용하는게 좋습니다. "RVC"가 "Flags"행에 나타나는지 확인할 때 +\fBreadelf \-h\fP 명령을 사용할 수 있습니다. +.IP \(bu 3 +ARM64는 항상 4\-바이트 정렬 방식을 택하기에 \fBpb=2,lp=2,lc=2\fP 옵션 값을 활용하는게 좋습니다. +.IP \(bu 3 +x86 필터는 예외입니다. x86 실행 파일을 압축할 경우에는 보통 LZMA2 기본 옵션 값(\fBpb=2,lp=0,lc=3\fP)을 그대로 +사용하는게 좋습니다. +.RE +.IP "" +모든 BCJ 필터는 동일한 \fI옵션\fP을 지원합니다: +.RS +.TP +\fBstart=\fP\fI<오프셋>\fP +상대 주소와 절대 주소를 변환할 때 사용할 시작 \fI<오프셋>\fP을 지정합니다. \fI<오프셋>\fP에는 필터 +정렬 배수여야 합니다(상단 테이블 참조). 기본값은 0입니다. 실제로 기본값이 낫습니다. 개별 \fI<오프셋>\fP 지정 +값은 거의 쓸모가 없습니다. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fI<옵션>\fP] +필터 체인에 델타 필터를 추가합니다. 델타 필터는 필터 체인에서 마지막에 지정하지 않은 필터로만 사용할 수 있습니다. +.IP "" +현재로서는 바이트 단위 단순 델타계산 결과만 보여줍니다. 예를 들면, 압축하지 않은 비트맵 그림 또는 압축하지 않은 PCM 오디오를 +압축할 때 쓸만합니다. 그러나 특별한 목적으로 활용하는 알고리즘은 델타 + LZMA2 보다 더 나은 결과를 가져다 주기도 합니다. +이는 특히 오디오의 경우 맞는 이야기인데, \fBflac\fP(1)의 경우 더 빠르고 우수한 압축율을 보여줍니다. +.IP "" +지원 \fI옵션\fP: +.RS +.TP +\fBdist=\fP\fI<차이>\fP +바이트 단위 델터 계산 \fI<차이>\fP를 지정합니다. \fI<차이>\fP값은 1\(en256 이어야합니다. 기본 +값은 1입니다. +.IP "" +예를 들어, \fBdist=2\fP 옵션과 A1 B1 A2 B3 A3 B5 A4 B7 입력 값을 주면, 출력 값은 A1 B1 01 02 01 +02 01 02 입니다. +.RE +. +.SS "기타 옵션" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +경고 및 알림을 끕니다. 두 번 지정하면 오류 메시지 표시도 끕니다. 이 옵션은 종료 상태에 영향을 주지 않습니다. 경고 표시를 +끄더라도, 종료 상태에서는 여전히 경고가 나타났음을 알려줍니다. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +출력 내용이 많아집니다. 표준 오류를 터미널에 연결했다면 \fBxz\fP는 진행 표시를 나타냅니다. \fB\-\-verbose\fP를 두번 지정하면 +더 많은 내용을 표시합니다. +.IP "" +진행 표시에서는 다음 정보를 나타냅니다: +.RS +.IP \(bu 3 +입력 파일의 크기를 알고 있을 경우 완료 백분율. 파이프 처리시에는 백분율을 나타낼 수 없습니다. +.IP \(bu 3 +산출 압축 데이터 용량 (압축) 또는 소모 공간 용량 (압축 해제). +.IP \(bu 3 +비압축 데이터 소모 용량 (압축) 또는 산출 용량 (압축 해제). +.IP \(bu 3 +압축 데이터 산출 용량을 비압축 데이터 처리 용량으로 나누어 계산한 압축율. +.IP \(bu 3 +압축 또는 압축 해제 속도. 초당 비압축 데이터 소모량(압축) 또는 산출 용량(압축 해제)를 측정한 값입니다. \fBxz\fP에서 파일 +처리를 시작한 몇 초 후 나타납니다. +.IP \(bu 3 +경과 시간 형식은 M:SS 또는 H:MM:SS 입니다. +.IP \(bu 3 +추산 여분 시간은 \fBxz\fP가 파일을 처리하기 시작한 이후 입력 파일의 크기를 알고 몇 초가 지난 후에야 보여줍니다. 시간은 콜론 +문자를 사용하지 않고 덜 자세한 형식으로, 예를 들면, 2분 30초 와 같은 형식으로 보여줍니다. +.RE +.IP "" +표준 오류가 터미널이 아니라면 \fB\-\-verbose\fP는 \fBxz\fP에서 파일 이름, 압축 크기, 압축 해제 용량, 압축율, 그리고 +가능하다면 파일을 압축 또는 압축 해제한 후 표준 오류로 속도와 걸린 시간을 나타내도록 합니다. 속도와 걸린 시간 정보는 동작을 +처리하는데 최소한 몇초 정도 소요했을 경우에만 들어갑니다. 동작이 끝나지 않았다면, 이를테면 사용자의 중단 요청이 있었을 경우 입력 +파일의 크기를 알고 있을 때 압축 백분율 정보도 들어갑니다. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +경고로 알릴 만한 상황을 만났다 하더라도 종료 상태 2번을 설정하지 않습니다. 이 옵션은 출력 수준에 영향을 주지 않기 때문에, +\fB\-\-quiet\fP 옵션과 \fB\-\-no\-warn\fP 옵션을 경고 표시를 막고 종료 상태를 바꾸지 않을 목적으로 사용합니다. +.TP +\fB\-\-robot\fP +머신에서 해석할 형식으로 메시지를 나타냅니다. liblzma 대신 \fBxz\fP를 활용하려는 다양상 스크립트로서의 프론트엔드를 쉽게 +작성하도록 하기 위함입니다. 이 옵션을 지정한 출력은 \fBxz\fP 릴리스가 어떻게 되든 안정 버전이란 의미입니다. 자세한 내용은 +\fB로봇 모드\fP 섹션을 참고하십시오. +.TP +\fB\-\-info\-memory\fP +압축 및 압축 해제시 물리 메모리 용량 (RAM), \fBxz\fP에서 파악하는 프로세서 스레드 갯수, 메모리 사용량 한계를 파악하기 쉬운 +형식으로 나타내고 무사히 나갑니다. +.TP +\fB\-h\fP, \fB\-\-help\fP +보통 사용하는 옵션을 설명하는 도움말 메시지를 출력한 후, 완전히 빠져나갑니다. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +\fBxz\fP의 모든 기능을 설명하는 도움말 메시지를 출력한 후, 완전히 빠져나갑니다 +.TP +\fB\-V\fP, \fB\-\-version\fP +\fBxz\fP와 liblzma 버전 번호를 가독 형식으로 출력합니다. 기계 해석 가능 형식을 가져오려면 \fB\-\-version\fP 앞에 +\fB\-\-robot\fP을 지정하십시오. +. +.SH "로봇 모드" +로봇 모드는 \fB\-\-robot\fP 옵션으로 동작합니다. \fBxz\fP 출력을 다른 프로그램에서 해석하기 쉽게 해줍니다. 현재로서는 +\fB\-\-robot\fP 옵션은 \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, \fB\-\-version\fP +옵션하고만 사용할 수 있습니다. 앞으로는 압축 및 압축 해제 동작에 대해서도 지원합니다. +. +.SS "목록 모드" +\fBxz \-\-robot \-\-list\fP 명령은 탭으로 구분한 출력 형태를 활용합니다. 모든 행의 첫번째 컬럼에는 해당 행에서 찾을 수 +있는 정보의 형식을 나타냅니다: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +이 행은 항상 파일 목록 시작 부분의 첫번째 줄에 있습니다. 이 행의 두번째 컬럼에 파일 이름이 들어있습니다. +.TP +\fBfile\fP +이 행에는 \fB.xz\fP 파일의 전반적인 정보가 들어있습니다. 이 행은 항상 \fBname\fP 행 다음에 있습니다. +.TP +\fBstream\fP +이 행 형식은 \fB\-\-verbose\fP 옵션을 지정했을 때만 사용합니다. \fB.xz\fP 파일의 \fBstream\fP 행 수만큼 나타납니다. +.TP +\fBblock\fP +이 행 형식은 \fB\-\-verbose\fP 옵션을 지정했을 때만 사용합니다. \fB.xz\fP 파일의 블록 수만큼 \fBblock\fP 행이 +나타납니다. \fBblock\fP 행은 모든 \fBstream\fP 행 다음에 나타납니다. 다른 형식의 행이 끼어들지는 않습니다. +.TP +\fBsummary\fP +이 행 형식은 \fB\-\-verbose\fP 옵션을 두번 지정했을 때만 사용합니다. 이 행은 모든 \fBblock\fP 행 다음에 출력합니다. +\fBfile\fP 행과 비슷하게, \fBsummary\fP 행에는 \fB.xz\fP 파일의 전반적인 정보가 담겨있습니다. +.TP +\fBtotals\fP +이 행은 목록 출력의 가장 마지막에 항상 나타납니다. 총 갯수와 크기를 나타냅니다. +.PP +\fBfile\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +파일 스트림 갯수 +.IP 3. 4 +스트림의 블록 총 갯수 +.IP 4. 4 +파일 압축 크기 +.IP 5. 4 +파일 압축 해제 크기 +.IP 6. 4 +예를 들면, \fB0.123\fP과 같은 압축율 입니다. 비율이 9.999라면, 대시 문자 3개 (\fB\-\-\-\fP)를 비율 값 대신 나타냅니다. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +쉼표로 구분한 무결성 검사 이름 목록입니다. \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP, \fBSHA\-256\fP 문자열을 알려진 +검사 형식으로 사용합니다. 알 수 없는 검사 형식에 대해서는 \fBUnknown\-\fP\fIN\fP을 사용하며, 여기서 \fIN\fP은 (한 두자리) +정수형 숫자값으로 이루어진 검사 ID 입니다. +.IP 8. 4 +파일의 스트림 패딩 총 길이 +.RE +.PD +.PP +\fBstream\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +스트림 번호 (첫 스트림은 1번) +.IP 3. 4 +스트림의 블록 총 갯수 +.IP 4. 4 +압축 시작 오프셋 +.IP 5. 4 +비압축 시작 오프셋 +.IP 6. 4 +압축 크기 (스트림 패딩 미포함) +.IP 7. 4 +압축 해제 용량 +.IP 8. 4 +압축율 +.IP 9. 4 +무결성 검사 이름 +.IP 10. 4 +스트림 패딩 길이 +.RE +.PD +.PP +\fBblock\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +이 블록이 들어간 스트림 갯수 +.IP 3. 4 +스트림 시작 부분의 블록 번호 (첫번째 블록은 1번) +.IP 4. 4 +파일 시작 부분의 블록 번호 +.IP 5. 4 +파일 시작 부분의 압축 시작 오프셋 +.IP 6. 4 +파일 시작 부분의 비압축 시작 오프셋 +.IP 7. 4 +총 블록 압축 크기 (헤더 포함) +.IP 8. 4 +압축 해제 용량 +.IP 9. 4 +압축율 +.IP 10. 4 +무결성 검사 이름 +.RE +.PD +.PP +\fB\-\-verbose\fP를 두 번 지정하면, 추가 컬럼을 \fBblock\fP 행에 넣습니다. \fB\-\-verbose\fP 단일 지정시에는 이 +정보를 볼 때 탐색을 여러번 수행해야 하기 때문에 실행 과정이 느려질 수 있어서 나타내지 않습니다: +.PD 0 +.RS +.IP 11. 4 +16진수 무결성 검사값 +.IP 12. 4 +블록 헤더 크기 +.IP 13. 4 +블록 플래그: \fBc\fP는 압축 크기가 현재 값임을 나타내고, \fBu\fP는 압축 전 원본 크기가 현재 값임을 나타냅니다. 플래그를 설정하지 +않았다면, 문자열 길이를 유지할 목적으로 대시 \fB\-\fP 를 대신 나타냅니다. 새 플래그는 나중에 문자열 끝 부분에 추가할 예정입니다. +.IP 14. 4 +블록에 압축 해서 넣은 데이터의 실제 츠기 (블록 헤더, 블록 패딩, 검사 필드 제외) +.IP 15. 4 +이 \fBxz\fP 버전에서 이 블록의 압축을 해제할 때 필요한 (바이트 단위) 메모리 용량 +.IP 16. 4 +필터 체인. 대부분 사용하는 옵션은 압축 해제시 필요한 옵션만을 \fB.xz\fP 헤더에 저장하기 때문에 압축 시간에 알 수 없습니다. +.RE +.PD +.PP +\fBsummary\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +이 \fBxz\fP 버전에서 이 파일 압축을 해제할 때 필요한 (바이트 단위) 메모리 용량 +.IP 3. 4 +모든 블록 헤더에 압축 크기와 압축 전 원본 크기 정보가 들어갔는지 여부를 나타내는 \fByes\fP 또는 \fBno\fP 값 +.PP +\fBxz\fP \fI5.1.2alpha\fP \fI부터:\fP +.IP 4. 4 +파일 압축 해제시 필요한 최소 \fBxz\fP 버전 +.RE +.PD +.PP +\fBtotals\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +스트림 갯수 +.IP 3. 4 +블록 갯수 +.IP 4. 4 +압축 크기 +.IP 5. 4 +압축 해제 용량 +.IP 6. 4 +평균 압축율 +.IP 7. 4 +파일에 들어 있어 쉼표로 구분한 무결성 검사 이름 목록 +.IP 8. 4 +스트림 패딩 길이 +.IP 9. 4 +파일 갯수. \fBfile\fP 행의 컬럼 순서를 따라갑니다. +.PD +.RE +.PP +\fB\-\-verbose\fP 옵션을 두 번 지정하면, \fBtotals\fP 행에 추가 컬럼이 들어갑니다: +.PD 0 +.RS +.IP 10. 4 +이 \fBxz\fP 버전에서 파일 압축을 해제할 떄 필요한 (바이트 단위) 최대 메모리 사용량 +.IP 11. 4 +모든 블록 헤더에 압축 크기와 압축 전 원본 크기 정보가 들어갔는지 여부를 나타내는 \fByes\fP 또는 \fBno\fP 값 +.PP +\fBxz\fP \fI5.1.2alpha\fP \fI부터:\fP +.IP 12. 4 +파일 압축 해제시 필요한 최소 \fBxz\fP 버전 +.RE +.PD +.PP +차후 버전에서는 새 행 형식을 추가하고 기존 행 형식에 추가할 수 있는 새 컬럼을 넣기 까지는 알 수 있겠지만, 기존 컬럼은 바꾸지 않을 +예정입니다. +. +.SS "필터 도움말" +\fBxz \-\-robot \-\-filters\-help\fP 는 다음 형식의 지원 필터 목록을 출력합니다: +.PP +\fI<필터>\fP\fB:\fP\fI<옵션>\fP\fB=<\fP\fI값\fP\fB>,\fP\fI<옵션>\fP\fB=<\fP\fI값\fP\fB>\fP... +.TP +\fI<필터>\fP +필터 이름 +.TP +\fI<옵션>\fP +필터별 옵션 이름 +.TP +\fI<값>\fP +숫자 \fI값\fP 범위는 \fB<\fP\fI최소\fP\fB\-\fP\fI최대\fP\fB>\fP입니다. 문자열 \fI값\fP은 \fB< >\fP 범위 +내에서 선택하며 \fB|\fP 문자로 구분합니다. +.PP +각 필터는 한 줄에 하나씩 출력합니다. +. +.SS "메모리 제한 정보" +\fBxz \-\-robot \-\-info\-memory\fP 명령은 탭으로 나뉜 여러 컬럼을 단일 행으로 나타냅니다: +.IP 1. 4 +물리 메모리(RAM)의 바이트 단위 총량. +.IP 2. 4 +압축 진행시 바이트 단위 메모리 사용 한계값 (\fB\-\-memlimit\-compress\fP). 특수 값 \fB0\fP은 단일\-스레드 모드에서 +제한을 두지 않는 기본 설정임을 나타냅니다. +.IP 3. 4 +압축 해제시 바이트 단위 메모리 사용 한계값 (\fB\-\-memlimit\-decompress\fP). 특수 값 \fB0\fP은 단일\-스레드 모드에서 +제한을 두지 않는 기본 설정임을 나타냅니다. +.IP 4. 4 +\fBxz\fP 5.3.4alpha 이후: 다중\-스레드 기반 압축 해제시 바이트 단위 메모리 +사용량(\fB\-\-memlimit\-mt\-decompress\fP). 분명하게 제한을 걸어두지 않았을 경우 5번째 컬럼에 나타난 시스템별 +기본값을 사용하기 때문에 0 값을 지정하면 안됩니다. 또한 \fB\-\-memlimit\-mt\-decompress\fP로 세번째 컬럼 값보다 더 +크게 지정을 한다 할지라도 이 값이 세번째 컬럼 값보다 크면 안됩니다. +.IP 5. 4 +\fBxz\fP 5.3.4alpha 이후: A system\-specific default memory usage limit that is +used to limit the number of threads when compressing with an automatic +number of threads (\fB\-\-threads=0\fP) and no memory usage limit has been +specified (\fB\-\-memlimit\-compress\fP). This is also used as the default value +for \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +\fBxz\fP 5.3.4alpha 이후: Number of available processor threads. +.PP +차후, \fBxz \-\-robot \-\-info\-memory\fP 출력에는 더 많은 내용이 들어가지만, 한 줄 이상은 넘어가지 않습니다. +. +.SS 버전 +\fBxz \-\-robot \-\-version\fP 은 \fBxz\fP 와 liblzma의 버전 번호를 다음 형식으로 나타냅니다: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +주 버전. +.TP +\fIYYY\fP +부 버전. 짝수가 안정 버전입니다. 홀수는 알파 또는 베타 버전입니다. +.TP +\fIZZZ\fP +안정 릴리스의 패치 수준 또는 개발 릴리스의 횟수입니다. +.TP +\fIS\fP +안정도. 0은 알파 버전, 1은 베타 버전을 나타내며, 2는 안정 버전을 나타냅니다. \fIS\fP는 \fIYYY\fP 값이 짝수라 해도 항상 +2여야 합니다. +.PP +\fBxz\fP 명령과 liblzma이 동일한 XZ 유틸리티 릴리스에서 나왔다면 두 행의 \fIXYYYZZZS\fP 값은 같습니다. +.PP +예제: 4.999.9beta는 \fB49990091\fP이며, 5.0.0은 \fB50000002\fP입니다. +. +.SH "종료 상태" +.TP +\fB0\fP +모든 상태 양호. +.TP +\fB1\fP +오류 발생. +.TP +\fB2\fP +눈여겨볼 경고가 나타났지만, 실제 오류는 일어나지 않음. +.PP +표준 오류에 출력하는 알림(경고 또는 오류 아님)는 종료 상태에 영향을 주지 않습니다. +. +.SH 환경 +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP는 빈칸으로 구분한 옵션 값 목록을 \fBXZ_DEFAULTS\fP, \fBXZ_OPT\fP 환경 변수에서 순서대로, 명령행에서 옵션을 +해석하기 전에 불러옵니다. 참고로 환경 변수에서 옵션만 해석하며, 옵션이 아닌 부분은 조용히 무시합니다. 해석은 +\fBgetopt_long\fP(3)으로 가능하며, 명령행 인자로 활용하기도 합니다. +.PP +\fB경고:\fP 환경 변수를 설정하면, 프로그램과 \fBxz\fP를 실행하는 스크립트의 동작이 바뀝니다. 대부분의 경우 메모리 사용 제한량, +스레드 수, 압축 옵션을 환경 변수로 설정하는게 안전합니다. 그러나 일부 옵션은 스크립트의 동작을 망가뜨릴 수 있습니다. 분명한 +예제로는 \fBxz\fP에서 파일의 압축 및 해제 대신 도움말 내용을 표시하는 \fB\-\-help\fP 옵션이 있습니다. 좀 더 묘한 예제로는 +\fB\-\-quiet\fP 와 \fB\-\-verbose\fP 옵션이 있습니다. 대부분의 경우 \fB\-\-verbose\fP 옵션을 사용하여 프로세스 상황을 +표시하는데 잘 동작하지만, 어떤 경우에는 추가 메시지가 나타나는 문제가 있습니다. 출력 상세 수준은 \fB\-\-list\fP의 동작에도 영향을 +줍니다. +.TP +\fBXZ_DEFAULTS\fP +사용자별, 시스템 범위 기본 옵션입니다. 보통 \fBxz\fP의 메모리 사용량 제한을 기본으로 걸어두거나 기본 스레드 수를 설정할 경우 셸 +초기화 스크립트에 설정합니다. 셸 초기화 스크립트와 별도의 유사한 경우를 제외하고라면, 스크립트에서는 \fBXZ_DEFAULTS\fP 환경 +변수를 설정하지 않거나 설정을 해제해야합니다. +.TP +\fBXZ_OPT\fP +\fBxz\fP 명령행으로 옵션 설정 값을 직접 전달할 수 없을 경우 \fBxz\fP에 옵션을 전달하는 환경 변수입니다. 예를 들어, \fBxz\fP를 +스크립트 또는 도구에서 실행할 경우 GNU \fBtar\fP(1) 라면: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +예를 들면, 스크립트에서 \fBXZ_OPT\fP 를 활용하여, 스크립트별로 기본 압축 옵션을 지정할 수 있습니다. 적절한 이유가 있다면 +\fBXZ_OPT\fP 옵션 값을 사용자가 바꾸는걸 추천합니다. 예를 들면, \fBsh\fP(1) 스크립트에서 다음처럼 활용할 수도 있습니다: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "LZMA 유틸리티 호환성" +\fBxz\fP의 명령행 문법은 실제로 LZMA 유틸리티 4.32.x에서 찾을 수 있는 \fBlzma\fP, \fBunlzma\fP \fBlzcat\fP의 +상위 집합입니다. 대부분의 경우 LZMA 유틸리티를 XZ 유틸리티로 기존에 작성한 스크립트를 깨지 않고도 바꿀 수 있습니다. 몇가지 +비호환성 문제 때문에 문제가 일어날 수는 있습니다. +. +.SS "압축 사전 설정 단계" +압축 수준 사전 설정의 번호 부여 방식은 \fBxz\fP와 LZMA 유틸리티가 동일하지 않습니다. 가장 중요한 차이는 다른 사전 설정에 대해 +딕셔너리 크기를 어떻게 대응했느냐 여부입니다. 딕셔너리 크기는 압축 해제시 메모리 사용량과 거의 비슷합니다. +.RS +.PP +.TS +tab(;); +c c c +c n n. +단계;xz;LZMA 유틸리티 +\-0;256 KiB;없음 +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +딕셔너리 크기 차이는 압축 프로그램 메모리 사용에 영향을 주지만, LZMA 유틸리티와 XZ 유틸리티에서 사용량이 늘어나는 다른 차이점이 +있습니다: +.RS +.PP +.TS +tab(;); +c c c +c n n. +단계;xz;LZMA 유틸리티 4.32.x +\-0;3 MiB;없음 +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +XZ 유틸리티의 기본 사전 설정 수준값은 \fB\-6\fP이지만 LZMA 유틸리티의 기본 사전 설정 수준값은 \fB\-7\fP입니다. 두 프로그램의 +딕셔너리 메모리 기본 사용량은 8MiB입니다. +. +.SS "스트림 vs 비스트림 .lzma 파일" +파일을 압축하지 않은 크기는 \fB.lzma\fP 헤더에 저장합니다. LZMA 유틸리티는 일반 파일을 압축할 때 압축하지 않은 파일의 크기를 +저장합니다. 이 대신 압축하지 않은 크기를 '알 수 없음' 으로 저장하고 압축 해제 프로그램이 멈춰야 할 지점에 +end\-of\-payload 마커를 사용하는 방법도 있습니다. LZMA 유틸리티는 파이프로 들어온 입력과 같이 압축하지 않은 파일의 +크기를 알 수 없을 때 이런 방식을 활용합니다. +.PP +\fBxz\fP는 \fB.lzma\fP 파일을 end\-of\-payload 마커의 유무와 관계없이 압축 해제 방식을 모두 지원하지만, \fBxz\fP로 +만든 모든 \fB.lzma\fP 파일은 end\-of\-payload 마커를 사용하며, \fB.lzma\fP 헤더에 압축하지 않은 파일 크기를 '알 수 +없음'으로 표기합니다. 이 방식은 드문 상황에서 문제를 야기할 수 있습니다. 예를 들면, 임베디드 장치의 \fB.lzma\fP 압축 해제 +프로그램은 압축을 해제했을 때 크기를 알아야 동작합니다. 이 문제를 만나면, LZMA 유틸리티 또는 LZMA SDK를 활용하여 +\&\fB.lzma\fP 파일에 압축 전 파일 크기 정보를 저장해야합니다. +. +.SS "지원하지 않는 .lzma 파일" +\&\fB.lzma\fP 형식은 \fIlc\fP 값을 8까지 받아들이며, \fIlp\fP 값은 4까지 받아들입니다. LZMA 유틸리티는 어떤 \fIlc\fP 값과 +\fIlp\fP 값을 받아들이고도 압축을 해제할 수 있지만, 파일을 만들 때는 늘 \fBlc=3\fP 값과 \fBlp=0\fP 값을 활용합니다. 다른 +\fIlc\fP 값과 \fIlp\fP 값으로의 파일 압축은 \fBxz\fP와 LZMA SDK에서만 가능합니다. +.PP +liblzma의 LZMA1 필터 구현체에서는 \fIlc\fP 값과 \fIlp\fP 값의 합이 4를 넘어가면 안됩니다. 그래서 \fB.lzma\fP +파일의 경우 이 제한을 넘어가면 \fBxz\fP로 압축을 해제할 수 없습니다. +.PP +LZMA 유틸리티는 2^\fIn\fP (2의 승수)크기를 지닌 딕셔너리를 가진 \fB.lzma\fP 파일만 만들지만 받아들이는 파일의 딕셔너리 +크기는 어떤 크기든 상관 없습니다. liblzma에서는 2^\fIn\fP, 2^\fIn\fP + 2^(\fIn\fP\-1) 딕셔너리 크기를 가진 +\&\fB.lzma\fP 파일 만 받아들입니다. 이로 인해 \fB.lzma\fP 파일을 확인할 때 거짓 양성율이 늘어납니다. +.PP +모든 \fB.lzma\fP 파일을 liblzma 에서 받아들일 수 있도록 압축하기 때문에 이 제한이 실제로는 문제가 되지 않습니다. +. +.SS "뒤따라오는 쓰레기 값" +압축 해제할 때, LZMA 유틸리티는 \fB.lzma\fP 스트림 처음 부분 다음 나머지를 다 조용히 무시합니다. 대부분의 경우, +버그입니다. LZMA 유틸리티에서 \fB.lzma\fP 결합 파일 압축 해제를 지원하지 않음을 의미하기도 합니다. +.PP +\&\fB.lzma\fP 스트림 처음부분 바로 다음에 데이터가 남아있을 경우, \fBxz\fP 에서는 \fB\-\-single\-stream\fP 옵션을 사용하지 +않으면 깨진 파일로 간주합니다. 이 동작으로 하여금 뒤따라오는 쓰레기 값을 무시하도록 간주하는 애매한 스크립트 동작을 깰 수가 +있습니다. +. +.SH 참고 +. +.SS "출력 결과물이 달라짐" +압축하지 않은 입력 파일로부터 얻어낸 정확한 압축 출력 결과물은 압축 옵션이 완전히 동일하더라도 XZ 유틸리티의 버전에 따라 달라질 수 +있습니다. 파일 형식에 영향을 주지 않고 인코더 그 자체를 개선(더 빠르게 하거나 더 나은 압축율로)하기 때문입니다. XZ 유틸리티 +버전이 동일하더라도 빌드 옵션을 달리하여 빌드 상태가 제각각인 경우 출력 결과물이 달라질 수 있습니다. +.PP +\fB\-\-rsyncable\fP 기능을 넣었을 경우 동일한 xz 버전에서 이전 파일과 새 파일로 별도로 압축하지 않는 한 결과 파일을 (두 +파일이 서로 다른 파일이 아니므로) rsync 처리할 필요가 없습니다. 이 문제는 인코더 구현체 기능 개발이 끝나서 xz 버전이 +다르더라도 안정적인 rsync 가능한 출력 결과물을 유지할 수 있을 때여야 해결할 수 있습니다. +. +.SS "내장 .xz 압축 해제 프로그램" +XZ 임베디드와 같은 내장 \fB.xz\fP 압축 해제 구현체는 지원 파일의 무결성 \fI검사\fP 형식을 \fInone\fP과 \fIcrc32\fP 이외의 +설정으로 만들 필요가 없습니다. 기본값이 \fB\-\-check=crc64\fP일 경우에만, 임베디드 시스템에서 파일을 만들 때 +\fB\-\-check=none\fP 또는 \fB\-\-check=crc32\fP 옵션을 사용해야합니다. +.PP +임베디드 시스템이 아니라면, 모든 \fB.xz\fP 형식 압축 해제 프로그램에서는 모든 \fI검사\fP 형식을 지원하거나, 일부 \fI검사\fP 방식을 +지원하지 않는다면, 최소한, 무결성 검사로 검증하지 않고 압축을 해제할 수 있습니다. +.PP +XZ 임베디드는 BCJ 필터를 지원하지만, 기본 시작 오프셋만 지정할 수 있습니다. +. +.SH 예제 +. +.SS 기본 +\fIfoo\fP 파일을 기본 압축 수준 (\fB\-6\fP) 으로 \fIfoo.xz\fP 파일에 압축해 넣고, 압축 과정이 무사히 끝나면 \fIfoo\fP를 +삭제합니다: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +\fIbar.xz\fP를 \fIbar\fP 에 압축을 해제한 후 압축 해제가 무사히 끝나도 \fIbar.xz\fP를 삭제하지 않습니다: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +기본 사전 설정 \fB\-6\fP 보다는 느리지만, 압축 및 압축 해제시 메모리를 적게 차지(각각 48\ Mib, 5\MiB)는 \fB\-4e\fP +사전 설정(\fB\-4 \-\-extreme\fP)을 활용하여 \fIbaz.tar.xz\fP 파일을 만듭니다: +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +압축 및 비압축 파일을 단일 명령으로 표준 출력에 압축해제할 수 있습니다: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "다중 파일 병렬 압축" +GNU와 *BSD에서는 \fBfind\fP(1) 명령과 \fBxargs\fP(1) 명령으로 여러 파일의 압축을 병렬 처리할 수 있습니다: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +\fBxargs\fP(1) 의 \fB\-P\fP 옵션으로 \fBxz\fP 프로세스의 병렬 처리 갯수를 지정합니다. \fB\-n\fP 옵션의 최적 값은 압축할 +파일 수에 달려있습니다. 압축할 파일이 몇개밖에 없다면 1이어야합니다. 파일이 수천 수만개 정도 된다면 \fBxargs\fP(1) 이 +어쨌든지간에 만들어낼 \fBxz\fP 프로세스의 겟수를 100으로 하거나 아니면 적당한 값을 지정하여 줄이는게 좋습니다. +.PP +\fBxz\fP에 \fB\-T1\fP옵션을 지정하면 단일\-스레드 모드로 강제합니다. \fBxargs\fP(1) 에서 병렬 처리 갯수를 제어할 수 있기 +때문입니다. +. +.SS "로봇 모드" +여러 파일을 압축한 후 저장할 바이트 용량을 계산합니다: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +이 스크립트에서는 충분히 최신의 \fBxz\fP 명령을 사용하는지 알아보려 합니다. 다음 \fBsh\fP(1) 스크립트에서는 \fBxz\fP 도구의 +버전 번호가 최소한 5.0.0인지 여부를 검사합니다. 이 방식은 \fB\-\-robot\fP 옵션을 지원하지 않는 오래된 베타 버전과도 호환성이 +있습니다: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +\fBXZ_OPT\fP 환경 변수로 압축 해제시 메뢰 사용량 한계를 설정하지만, 한계 값을 이미 설정했다면, 값을 늘리지 않습니다: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "개별 압축 필터 체인 설정" +개별 설정 필터 체인의 초단순 사용방식은 LZMA2 사전 설정 값을 별도로 설정하는 방식입니다. 사전 설정은 잠재적으로 쓸만한 압축 +설정 조합만 다루기 때문에 꽤 쓸모가 있을 수도 있습니다. +.PP +\fB\-0\fP ... \fB\-9\fP 옵션의 설명에서 테이블의 CompCPU 컬럼과 \fB\-\-extreme\fP 옵션은 LZMA2 사전 설정을 +개별적으로 맞췄을 때 쓸만할 수도 있습니다. 여기 관련내용을 테이블 둘로 정리해서 모아보았습니다: +.RS +.PP +.TS +tab(;); +c c +n n. +Preset;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +어떤 파일을 압축할 때 상당히 큰 딕셔너리(예: 32MiB)가 필요 하다는걸 알아채셨지만, \fBxz \-8\fP 명령이 압축할 때보다 더 빠른 +속도로 압축하려 한다면, 더 큰 딕셔너리 사용을 위해 더 낮은 CompCPU 사전 설정 값(예: 1)으로 수정할 수 있습니다: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +각 파일에 대해, 위 명령은 압축율이 더 좋아지면서도 \fBxz \-6\fP보다 더 빨라집니다. 그러나, CompCPU 값을 낮게 유지하는 +대신 큰 딕셔너리에서 일부 파일을 강조해야 합니다. 큰 딕셔너리가 대부분의 도움을 주는 매우 명백한 상황에서는 최소한 몇 메가바이트의 +매우 유사한 각 파일이 아카이브에 들어갑니다. 딕셔너리 크기는 LZMA2가 연속으로 존재하는 각 파일의 유사성으로부터 얻는 장점을 취할 +수 있을 때 일부 개별 파일보다 훨씬 더 커집니다. +.PP +압축 프로그램과 압축 해제 프로그램에서 메모리를 엄청 많이 사용해도 상관 없고, 파일을 수백 메가 바이트 메모리 용량을 활용하여 +압축한다면, \fBxz \-9\fP 명령에 64MiB 용량을 초과하는 딕셔너리를 사용할 수 있게 하는 방법도 쓸만할 지도 모릅니다: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +위 예제에서와 같이 \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) 옵션을 사용하면 압축 및 압축 해제 과정에서 필요한 메모리 +용량을 살펴보는데 요긴할 수 있습니다. 압축 해제한 파일 크기보다 더 큰 딕셔너리를 사용하면 불필요한 메모리 소모량이 발생하여 위 +명령이 작은 파일에는 쓸모 없음을 기억하십시오. +.PP +때로는 압축 시간이 딱히 상관이 없을 수도 있습니다만, 압축 해제시 메모리 사용량을 적게 유지해야 할 수도 있습니다. 예를 들면, +임베디드 시스템에서 파일 압축을 해제할 수도 있습니다. 다음 명령의 경우 \fB\-6e\fP (\fB\-6 \-\-extreme\fP) 옵션을 기반 +옵션을 사용하며 딕셔너리 크기를 64KiB만 사용하도록 제한합니다. 결과 파일은 XZ 임베디드(이게 \fB\-\-check=crc32\fP +옵션이 있는 이유)로 100KiB 메모리 용량을 활용하여 풀어낼 수 있습니다. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +가능한 한 수 바이트를 더 쥐어 짜내고 싶을 때, 리터럴 문맥 비트 수(\fIlc\fP)와 위치 비트 수(\fIpb\fP)를 조정하면 도움이 될 +수도 있습니다. 리터럴 위치 비트 수(\fIlp\fP)를 조금 건드리는 것 또한 도움이 될 지도 모르겠지만 보통 \fIlc\fP 값과 \fIpb\fP +값이 더 중요합니다. 예를 들면, 소스 코드 저장 파일에는 US\-ASCII 텍스트가 대부분이기에, 다음과 같은 경우는 \fBxz \-6e\fP +명령을 실행했을 때부다는 아주 약간(거의 0.1% 수준) 작은 파일을 얻어낼 수도 있습니다(\fBlc=4\fP를 빼고도 시도해보십시오): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +LZMA2와 다른 필터를 함께 사용하면 일부 파일 형식에 대해 압축율을 개선할 수 있습니다. 예를 들면 x86\-32 또는 x86\-64 +공유 라이브러리를 x86 BCJ 필터를 활용하여 압축할 경우: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +참고로 필터 옵션의 순서는 상당히 중요합니다. \fB\-\-x86\fP을 \fB\-\-lzma\fP 이전에 지정하면 \fBxz\fP에서 오류가 나는데, +LZMA2 다음에는 어떤 필터든 설정할 수 없고, 옵션 체인상 마지막 필터로 x86 BCJ 필터를 사용할 수 없기 때문입니다. +.PP +LZMA2와 델타 필터는 비트맵 그림에 최적의 결과를 가져다줄 수 있습니다. PNG에 보통 안성맞춥인데, PNG에는 단순 델타 필터보단 +약간 더 고급진 필터를 사용하지만, 실제 압축을 진행할 때는 Deflate를 사용하기 때문입니다. +.PP +예를 들어 이미지를 압축하지 않은 비압축 TIFF로 저장해야 하는 경우가 있습니다. 델타 필터의 거리 매개변수는 그림에서 픽셀당 바이트 +수에 일치하도록 설정합니다. 예를 들면, 24비트 RGB 비트맵의 경우 \fBdist=3\fP 거리 매개변수 값을 설정해야 하며, LZMA2 +압축시 3바이트 정렬을 따르도록 \fBpb=0\fP 값을 전달하는 방법도 바람직합니다: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +여러 이미지를 단일 아카이브로 넣고 싶다면(예: \fB.tar\fP), 모든 이미지에 대해 동일한 픽셀당 바이트 수가 들어가는 경우에도 델타 +필터가 동작합니다. +. +.SH "추가 참조" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ 유틸리티: +.br +XZ 임베디드: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xz.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xz.1 new file mode 100644 index 0000000000000000000000000000000000000000..631a9a7cc8b58565ff6c9eb7a3610b39d1733d20 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xz.1 @@ -0,0 +1,1585 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Korean translation for the xz-man +.\" Seong-ho Cho , 2023, 2024. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 2025\-03\-08 Tukaani "XZ 유틸리티" +. +.SH 이름 +xz, unxz, xzcat, lzma, unlzma, lzcat \- .xz 파일과 .lzma 파일을 압축 또는 압축 해제합니다 +. +.SH 요약 +\fBxz\fP [\fI<옵션>...\fP] [\fI<파일>...\fP] +. +.SH "명령 별칭" +\fBunxz\fP 명령은 \fBxz \-\-decompress\fP 명령과 동일합니다. +.br +\fBxzcat\fP 명령은 \fBxz \-\-decompress \-\-stdout\fP 명령과 동일합니다. +.br +\fBlzma\fP 명령은 \fBxz \-\-format=lzma\fP 명령과 동일합니다. +.br +\fBunlzma\fP 명령은 \fBxz \-\-format=lzma \-\-decompress\fP 명령과 동일합니다. +.br +\fBlzcat\fP 명령은 \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP 명령과 동일합니다. +.PP +파일 압축을 해제해야 하는 셸 스크립트를 작성할 때, \fBunxz\fP 와 \fBxzcat\fP 이름 대신 \fBxz\fP 명령과 적절한 인자 +값(\fBxz \-d\fP 또는 \fBxz \-dc\fP)의 사용을 추천드립니다. +. +.SH 설명 +\fBxz\fP는 \fBgzip\fP(1) 과 \fBbzip2\fP(1) 과 비슷한 명령행 문법을 지닌 범용 데이터 압축 도구입니다. 자체 파일 +형식은 \fB.xz\fP 형식이나, LZMA 유틸리티에서 사용하는 예전 \fB.lzma\fP 형식과 형식 헤더가 없는 RAW 압축 스트림도 +지원합니다. 게다가, \fBlzip\fP에서 활용하는 \fB.lz\fP 형식 압축 해제도 지원합니다. +.PP +각 \fI파일\fP 에 대한 \fBxz\fP 압축 또는 압축 해제는 선택 동작 모드에 따릅니다. \fI<파일>\fP 값이 주어졌거나 +\fI<파일>\fP 값이 \fB\-\fP이면, \fBxz\fP 명령에서 표준 입력을 읽고 처리한 데이터를 표준 출력에 기록합니다. +\fBxz\fP 에서는 터미널에서 활용할 경우 압축 데이터를 표준 압축으로 기록하는 동작을 거절(오류를 출력하고 \fI<파일>\fP을 +건너뜀)합니다. 이와 비슷하게, \fBxz\fP 유틸리티를 터미널에서 실행하면 표준 입력의 압축 데이터 읽기를 거절합니다. +.PP +\fB\-\-stdout\fP 을 지정하지 않는 한, \fB\-\fP가 아닌 \fI<파일>\fP을 원본 \fI<파일>\fP 이름에서 +가져온 새 파일 이름으로 기록합니다: +.IP \(bu 3 +압축할 때, 대상 파일 형식의 접미사(\fB.xz\fP or \fB.lzma\fP) 는 원본 파일 이름 뒤에 붙어 대상 파일이름이 됩니다. +.IP \(bu 3 +압축 해제할 때, \fB.xz\fP, \fB.lzma\fP, \fB.lz\fP 접미사를 파일 이름에서 제거하고 대상 파일 이름을 알아냅니다. +\fBxz\fP에서는 \fB.txz\fP, \fB.tlz\fP 접미사도 인식하며, \fB.tar\fP 접미사로 치환합니다. +.PP +대상 파일이 이미 있으면, 오류를 나타내고 \fI<파일>\fP을 건너뜁니다. +.PP +표준 출력으로 기록하기 전에는, \fBxz\fP는 경고를 나타내며, 다음 조건에 만족할 경우 \fI<파일>\fP을 건너뜁니다: +.IP \(bu 3 +\fI<파일>\fP이 일반 파일이 아닐 때. 심볼릭 링크는 따라가지 않기에, 일반 파일로 간주하지 않습니다. +.IP \(bu 3 +\fI<파일>\fP이 하나 이상의 하드 링크일 떄. +.IP \(bu 3 +\fI<파일>\fP에 setuid, setgid, 끈적이 비트 집합이 붙어있을 떄. +.IP \(bu 3 +동작 모드를 압축으로 설정하고, \fI<파일>\fP은 대상 파일 형식의 접미사를 이미 붙였을 때(\fB.xz\fP 형식으로 압축하면 +\&\fB.xz\fP 또는 \fB.txz\fP, \fB.lzma\fP 형식으로 압축하면 \fB.lzma\fP 또는 \fB.tlz\fP). +.IP \(bu 3 +동작 모드를 압축 해제로 설정하고, \fI<파일>\fP에 지원 파일 형식 접미사(\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, +\&\fB.tlz\fP, \fB.lz\fP)를 붙이지 않았을 때. +.PP +\fI<파일>\fP 의 압축 또는 압축 해제를 성공하고 나면, \fBxz\fP는 소유자, 소유그룹, 권한, 접근 시각, 수정 시각 +정보를 원본 \fI<파일>\fP에서 대상 파일로 그대로 복사합니다. 그룹 정보 복사에 실패하면, 권한을 수정하여 원본 +\fI<파일>\fP에 접근 권한이 없는 사용자가 대상 파일로 접근하지 못하게 합니다. \fBxz\fP는 아직 접근 제어 목록이나 +확장 속성 등의 기타 메타데이터를 복사하는 기능은 지원하지 않습니다. +.PP +대상 파일을 온전히 닫고 나면, \fB\-\-keep\fP 옵션을 지원하지 않았을 경우 원본 \fI<파일>\fP을 제거합니다. 원본 +\fI<파일>\fP은 출력을 표준 출력으로 기록했거나 오류가 발생했을 경우 제거하지 않습니다. +.PP +\fBxz\fP 프로세스에 \fBSIGINFO\fP 시그널 또는 \fBSIGUSR1\fP 시그널을 보내면 표준 출력으로 진행 정보를 출력합니다. 표준 +오류가 터미널일 경우일 경우에만 제한하며 \fB\-\-verbose\fP 옵션을 지정하면 진행 표시줄을 자동으로 나타냅니다. +. +.SS "메모리 사용" +\fBxz\fP 메모리 사용은 수백 킬로바이트로 시작하여 수 기가바이트까지 압축 설정에 따라 다릅니다. 압축 해제 프로그램이 필요로 하는 +메모리 공간을 결정하는 파일 압축시에 설정 값을 활용합니다. 보통 압축 해제 프로그램은 파일을 만들 때, 압축 프로그램 메모리 사용량의 +5% 에서 20% 정도 필요합니다. 예를 들면, \fBxz \-9\fP로 압축한 파일 압축 해제시 현재 65MiB 메모리 용량이 필요합니다. +여전하게도, 압축 해제시 수 기가 바이트의 메모리가 필요한 \fB.xz\fP 파일에도 가능한 이야기입니다. +.PP +특히 이전 시스템 사용자의 경우 메모리 사용량이 엄청나게 늘어나는 점에 짜증이 날 수 있습니다. 이런 불편한 상황을 피하기 위해, +\fBxz\fP에 기본적으로 비활성 상태인 내장 메모리 사용 제한 기능을 넣었습니다. 일부 운영체제에서 처리 중 메모리 사용을 제한하는 +수단을 제공하긴 하지만, 여기에 의지하기에는 충분히 유연하지 않습니다(예를 들면, \fBulimit\fP(1)을 사용하면 가상 메모리를 +제한하여 \fBmmap\fP(2)을 먹통으로 만듭니다). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +메모리 사용 제한 기능은 \fB\-\-memlimit=\fP\fI<제한용량>\fP 명령행 옵션으로 사용할 수 있습니다. 종종 +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP와 같이 \fBXZ_DEFAULTS\fP 환경 변수를 설정하여 제한 기능을 켜는게 더 +편합니다. \fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션과 +\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP 옵션을 활용하여 압축 및 압축 해제시 별도로 한계 값을 +설정할 수 있습니다. 이 두 가지 옵션의 \fBXZ_DEFAULTS\fP 환경 변수 밖에서의 사용은, \fBxz\fP를 단일 실행할 때 압축 및 +압축 해제 동작을 동시에 수행하지 않으며, 앞서 언급한 두가지 옵션을 명령행에 입력하기에는 +\fB\-\-memlimit=\fP\fI<제한용량>\fP(또는 \fB\-M\fP \fI<제한용량>\fP)이 더 짧기 때문에 별로 쓸모가 +없습니다. +.PP +압축 해제시 메모리 사용 제한 지정 한계를 초과하면, \fBxz\fP 유틸리티에서 오류를 나타내며 파일 압축 해제는 실패합니다. 압축을 +실행할 때 사용 제한 지정 한계를 넘어서면 \fBxz\fP에서는 설정 값을 줄여서 어쨌든 한계를 넘지 못하게 +합니다(\fB\-\-format=raw\fP 옵션 또는 \fB\-\-no\-adjust\fP 옵션 사용시 제외). 설정 한계 값이 엄청 작지 않은 이상 이 +방식대로 처리하면 어쨌든 실패하지 않습니다. 설정 값조정은 압축 래벨 사전 설정과 일치하지 않을 때 단계적으로 진행하는데, 이를테면, +\fBxz \-9\fP 명령 수행에 필요한 양보다 한계 값이 약간 작으면, 설정 값을 \fBxz \-8\fP에 못미치게 약간 줄여서 진행합니다. +. +.SS ".xz 파일 결합 및 패딩" +\&\fB.xz\fP 파일을 있는 그대로 합칠 수 있습니다. \fBxz\fP는 \fB.xz\fP 파일을 단독 파일일 때 처럼 압축해제합니다. +.PP +결합 부분과 마지막 부분 뒤에 패딩을 추가할 수 있습니다. 패딩은 널 바이트로 구성해야 하며 패딩 길이는 4바이트로 구성해야 합니다. +512 바이트 블록으로 파일 크기를 이루는 매체에 \fB.xz\fP 파일을 저장했을 경우에 요긴할 수 있습니다. +.PP +\&\fB.lzma\fP 파일 또는 원시 스트림의 경우 결합과 패딩을 허용하지 않습니다. +. +.SH 옵션 +. +.SS "정수 접두사와 별도 값" +정수 인자값이 필요한 대부분 위치에서는, 큰 정수값을 나타내기 쉽게 하도록 추가 접미사를 지원합니다. 정수와 접미사 사이에 어떤 공백이 +있으면 안됩니다. +.TP +\fBKiB\fP +1,024 (2^10) 배수 정수값. \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP, \fBKB\fP 단위를 \fBKiB\fP 동의어로 받아들입니다. +.TP +\fBMiB\fP +1,048,576 (2^20) 배수 정수값. \fBMi\fP, \fBm\fP, \fBM\fP, \fBMB\fP 단위를 \fBMiB\fP 동의어로 받아들입니다. +.TP +\fBGiB\fP +1,073,741,824 (2^30) 배수 정수값. \fBGi\fP, \fBg\fP, \fBG\fP, \fBGB\fP 단위를 \fBGiB\fP 동의어로 +받아들입니다. +.PP +특수 값 \fBmax\fP는 옵션에서 지원하는 정수 최대 값을 나타낼 때 사용할 수 있습니다. +. +.SS "동작 모드" +여러 동작 모드를 보여드리겠습니다만, 마지막에 주어진 동작 모드로 동작합니다. +.TP +\fB\-z\fP, \fB\-\-compress\fP +압축합니다. 어떤 동작 모드 옵션도 지정하지 않고 다른 동작 모드를 명령행에 따로 지정하지 않았다면 이 동작 모드는 기본입니다(예: +\fBunxz\fP 는 \fB\-\-decompress\fP를 암시). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +압축을 제대로 끝내고 나면, 표준 출력에 기록하거나 \fB\-\-keep\fP 옵션을 지정하지 않았다면 원본 파일을 제거합니다. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +압축 해제입니다. 압축 해제를 제대로 끝내고 나면, 표준 출력에 기록하거나 \fB\-\-keep\fP 옵션을 지정하지 않았다면 원본 파일을 +제거합니다. +.TP +\fB\-t\fP, \fB\-\-test\fP +압축 \fI<파일>\fP의 무결성을 시험해봅니다. 이 옵션은 압축 해제 데이터를 표준 출력으로 기록하는 대신 버린다는 점을 +제외하고 \fB\-\-decompress \-\-stdout\fP과 동일합니다. 어떤 파일도 만들거나 제거하지 않습니다. +.TP +\fB\-l\fP, \fB\-\-list\fP +압축 \fI<파일>\fP 정보를 출력합니다. 압축 해제 출력을 내보내지 않으며, 어떤 파일도 만들거나 제거하지 않습니다. 이 +조회 모드에서, 프로그램은 표준 입력 또는 기타 탐색 불가능한 원본에서 압축 데이터를 읽을 수 없습니다. +.IP "" +\fI<파일>\fP 기본 정보를 파일 당 한 줄 씩 기본으로 보여줍니다. 더 자세한 정보를 보려면 \fB\-\-verbose\fP +옵션을 사용하십시오. 더 자세한 정보는 \fB\-\-verbose\fP 옵션을 두번 사용하면 되지만, 추가 정보를 더 많이 가져오면서 탐색 +횟수가 늘어나는 문제로 인해 느려질 수 있습니다. 세부 출력 너비는 80 문자를 초과하며, 예를 들어 출력을 파이핑한다면, 터미널이 +충분히 너비가 넓지 못할 경우 \fBless\ \-S\fP 명령이 편리할 수 있습니다. +.IP "" +정확한 출력은 \fBxz\fP 버전과 다른 로캘에 따라 바뀔 수 있습니다. 기계 판독용 출력시 \fB\-\-robot \-\-list\fP 옵션을 +사용합니다. +. +.SS "동작 수정자" +.TP +\fB\-k\fP, \fB\-\-keep\fP +입력 파일을 삭제하지 않습니다. +.IP "" +\fBxz\fP 5.2.6 부터는 이 옵션으로 입력 파일이 일반 파일을 참조하는 심볼릭 링크나 하나 이상의 하드 링크, 내지는 setuid, +setgid, 끈적이 비트 세트를 설정한 상태라도 압축하거나 압축을 풀 수 있습니다. setuid, setgid, 끈적이 비트는 대상 +파일에 복사하지 않습니다. 이전 버전에서는 \fB\-\-force\fP 옵션을 지정했을 때만 가능했습니다. +.TP +\fB\-f\fP, \fB\-\-force\fP +이 옵션은 몇가지 동작에 영향을 줍니다: +.RS +.IP \(bu 3 +대상 파일이 이미 있으면, 압축 또는 압축 해제 전 삭제합니다. +.IP \(bu 3 +입력 파일이 일반 파일을 참조하는 심볼릭 링크나 하나 이상의 하드 링크, 내지는 setuid, setgid, 끈적이 비트 세트를 설정한 +상태라도 압축 또는 압축 해제를 진행합니다. setuid, setgid, 끈적이 비트는 대상 파일에 복사하지 않습니다. +.IP \(bu 3 +\fB\-\-decompress\fP \fB\-\-stdout\fP 옵션을 같이 사용하는 상황에서 \fBxz\fP 명령이 원본 파일의 형식을 알아내지 못할 때, +원본 파일의 사본을 표준 출력으로 보냅니다. 이렇게 하면 \fBxzcat\fP \fB\-\-force\fP 명령을 \fBxz\fP 명령으로 압축하지 않은 +파일에 대해 \fBcat\fP(1) 을 사용하는 것처럼 사용할 수 있습니다. 참고로 나중에, \fBxz\fP에서 \fBxz\fP로 하여금 여러 형식의 +파일을 표준 출력으로 복사하는 대신 압축을 해제하도록 새 압축 파일 형식을 지원할 예정입니다. +\fB\-\-format=\fP\fI<형식>\fP 옵션은 \fBxz\fP 명령에 단일 파일 형식만 압축 해제하도록 제한할 때 사용할 수 +있습니다. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +파일 대신 표준 출력으로 압축 또는 압축 해제한 데이터를 기록합니다. \fB\-\-keep\fP를 생략했습니다. +.TP +\fB\-\-single\-stream\fP +처음 \fB.xz\fP 스트림만 압축 해제하며, 스트림에 뒤따라오는 나머지 입력 데이터는 조용히 무시합니다. 보통 뒤따라오는 쓰레기 값에 +대해서는 \fBxz\fP 에서 오류를 나타냅니다. +.IP "" +\fBxz\fP는 \fB.lzma\fP 파일 또는 원시 스트림에서 온 하나 이상의 스트림에 대해 압축 해제동작을 취하지 않지만, 이 옵션을 사용하면 +\fBxz\fP에서 \fB.lzma\fP 파일 또는 원시 스트림을 처리한 다음에 뒤따라오는 데이터를 무시하도록 합니다. +.IP "" +이 옵션은 동작 모드가 \fB\-\-decompress\fP 또는 \fB\-\-test\fP가 아니면 동작에 아무런 영향을 주지 않습니다. +.IP "" +\fBxz\fP 5.7.1alpha 부터는 \fB\-\-single\-stream\fP 옵션의 동작에 \fB\-\-keep\fP 동작이 들어갑니다. +.TP +\fB\-\-no\-sparse\fP +희소 파일을 만들지 않습니다. 기본적으로 일반 파일로 압축 해제할 경우 \fBxz\fP 에서는 압축 해제한 파일에 이진 0값이 길게 늘어질 +경우 희소 배열 파일을 만들려고 합니다. 표준 출력의 내용 길이만큼 연결한 일반 파일로 기록할 때도 동작하며 희소 파일을 만드는 동안 +아무런 문제가 나타나지 않게 각각의 추가 조건을 만족합니다. 희소 파일을 만들면 디스크 공간을 절약할 수 있으며 디스크 입출력을 줄여 +압축 해제 속도를 올릴 수 있습니다. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +압축할 때, 대상 파일의 접두사를 \fB.xz\fP 또는 \fB.lzma\fP 대신 \fI.suf\fP로 사용하십시오. 표준 출력으로 기록하지 않고 +원본 파일에 \fI.suf\fP 접두사가 붙어있으면, 경고를 나타내고 해당 파일을 건너뜁니다. +.IP "" +압축 해제할 때, \fI.suf\fP 접미사로 파일을 인식하기도 하고, \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, +\&\fB.lz\fP 접미사가 붙은 파일도 인식합니다. 원본 파일에 \fI.suf\fP 접미사가 붙어있으면, 해당 접미사를 제거하여 대상 파일 이름을 +알아냅니다. +.IP "" +원시 스트림 압축 및 압축 해제시(\fB\-\-format=raw\fP) 원시 스트림에 기본 접미사가 없기 때문에, 표준 출력으로 기록하지 않는 +한 접미사를 반드시 지정해야 합니다. +.TP +\fB\-\-files\fP[\fB=\fP\fI<파일>\fP] +\fI<파일>\fP에서 처리할 파일 이름을 읽습니다. \fI<파일>\fP을 생략하면 파일 이름은 표준 입력에서 +불러옵니다. 파일 이름은 개행 문자로 끝나야 합니다. 대시 문자(\fB\-\fP)는 일반 파일 이름으로 취급하며 표준 입력을 의미하지 +않습니다. 파일 이름을 명령행 인자로 지정하면, \fI<파일>\fP에서 파일 이름을 읽어들이기 전 해당 명령행 인자를 먼저 +처리합니다. +.TP +\fB\-\-files0\fP[\fB=\fP\fI<파일>\fP] +각 파일 이름이 널 문자로 끝나야 한다는 점만 제외하면 \fB\-\-files\fP[\fB=\fP\fI<파일>\fP] 옵션과 동일합니다. +. +.SS "기본 파일 형식 및 압축 옵션" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fI<형식>\fP +압축 또는 압축해제 파일 \fI<형식>\fP을 지정합니다: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +기본 값입니다. 압축할 때, \fBauto\fP는 \fBxz\fP의 기본 동작과 동일합니다. 압축을 해제할 때, 입력 파일 형식을 자동으로 +찾습니다. 참고로 원시 스트림(\fB\-\-format=raw\fP)의 경우 자동으로 찾을 수 없습니다. +.TP +\fBxz\fP +\&\fB.xz\fP 파일 형식으로 압축하거나, 압축 해제시 \fB.xz\fP 파일만 받아들입니다. +.TP +\fBlzma\fP, \fBalone\fP +이전 \fB.lzma\fP 파일 형식으로 압축하거나, 압축 해제시 \fB.lzma\fP 파일만 받아들입니다. \fBalone\fP 대체 명령은 LZMA +유틸리티 하위 호환성을 목적으로 제공합니다. +.TP +\fBlzip\fP +압축 해제시 \fB.lz\fP 파일만 받아들입니다. 압축은 지원하지 않습니다. +.IP "" +\&\fB.lz\fP 형식 버전 0과 1을 지원합니다. 버전 0파일은 \fBlzip\fP 1.3 이전에서만 만듭니다. 일반적이진 않지만 일부 파일의 +경우 이 형식의 원본 패키지로 보관한 파일을 찾을 수도 있습니다. 개인적으로 이 형식으로 압축한 오래된 개인 파일을 가지고 있을 수도 +있습니다. 형식 버전 0 압축 해제 지원은 \fBlzip\fP 1.18에서 제거했습니다. \fBlzip\fP 1.4 이후의 버전에서는 버전 1 +형식 파일을 만듭니다. +.TP +\fBraw\fP +원시 스트림으로 압축하거나 압축을 해제합니다(헤더 없음). 고급 사용자 전용입니다. 원시 스트림을 디코딩하려면, +\fB\-\-format=raw\fP 옵션을 사용하고 분명하게 필터 체인을 지정하여 컨테이너 헤더에 필요한 정보를 저장하게 끔 해야합니다. +.RE +.TP +\fB\-C\fP \fI<검사방식>\fP, \fB\-\-check=\fP\fI<검사방식>\fP +무결성 검사 방식을 지정합니다. 검사 방식은 \fB.xz\fP 파일에 저장하며 압축 해제 데이터를 계산합니다. 이 옵션은 \fB.xz\fP +형식으로 압축할 때만 효력이 있습니다: \fB.lzma\fP 형식은 무결성 겁사를 지원하지 않습니다. 무결성 검사는 \fB.xz\fP 파일 압축을 +풀었을 때에 검사합니다. +.IP "" +지원 \fI검사\fP 형식: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +어떤 경우에도 무결성 검사 계산을 수행하지 않습니다. 보통 바람직하지 못한 생각입니다. 데이터 무결성을 다른 방식으로라도 검증해야 +하는 상황이면 쓸만할 수 있습니다. +.TP +\fBcrc32\fP +IEEE\-802.3 (이더넷)의 다항 연산으로 CRC32를 계산합니다. +.TP +\fBcrc64\fP +ECMA\-182의 다항식 연산으로 CRC64를 계산합니다. 이 동작이 기본 동작이기 때문에 CRC32가 깨진 파일을 찾을 때보다는 좀 +낮은 편이며 속도 차이도 거의 없습니다. +.TP +\fBsha256\fP +SHA\-256 해시를 계산합니다. CRC32와 CRC64 보다는 좀 느립니다. +.RE +.IP "" +\&\fB.xz\fP 헤더 무결성은 항상 CRC32로 검증하빈다. 이를 바꾸거나 It is not possible to change or +disable it. +.TP +\fB\-\-ignore\-check\fP +압축 데이터를 압축해제할 경우 압축 데이터의 무결성 검증을 진행하지 않습니다. \fB.xz\fP 헤더의 CRC32 값은 그래도 여전히 보통 +방식으로 검증합니다. +.IP "" +\fB이 옵션이 정확히 무슨 동작을 하는지 알기 전에는 사용하지 마십시오.\fP 이 옵션을 사용하는 타당한 이유로: +.RS +.IP \(bu 3 +깨진 .xz 파일에서 데이터 복구를 시도합니다. +.IP \(bu 3 +압축 해제 속도를 늘립니다. SHA\-256 또는 압축 파일에 들어간 그 무언가를 엄청 빨리 처리합니다. 다른 방식으로 파일 무결성을 +검증해야 하는 목적이 아니라면 이 옵션을 사용하지 않는게 좋습니다. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +압축 사전 설정 수준을 선택합니다. 기본값은 \fB\-6\fP입니다. 다중 수준을 지정하면 가장 마지막 수준 옵션을 적용합니다. 개별 필터 +체인을 이미 지정했다면, 압축 사전 설정 수준 값을 설정할 때 개별 필터 체인을 정리합니다. +.IP "" +사전 설정간 차이는 \fBgzip\fP(1)과 \fBbzip2\fP(1)을 사용할 때보다 더 비중을 차지합니다. 선택한 압축 설정은 압축 해제시 +필요한 메모리 사용량을 셜정하므로 사전 설정 수준 값을 너무 높게 지정하면 RAM 용량이 적은 오래된 시스템에서 파일 압축 해제시 실패할 +수 있습니다. 게다가, \fBgzip\fP(1) 과 \fBbzip2\fP(1)에서 처럼 종종 \fB모든 동작에 \-9를 몰래 활용하는건 바람직하지 않습니다\fP. +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +동작이 빠른 사전 설정 부류입니다. \fB\-0\fP은 때로는 \fBgzip \-9\fP 명령보다 압축율이 훨씬 우수하면서도 더 빠릅니다. 더 큰 +값은 보통 \fBbzip2\fP(1) 명령과 비교했을 떄 압축 결과가 압축 데이터에 따라 달라지더라도, 비교할 법한 속도 또는 더 나은 +압축율을 보입니다. +.TP +\fB\-4\fP ... \fB\-6\fP +오래된 시스템에서 조차도 압축 해제 프로그램의 적절한 메모리 사용량을 보이면서 양호하거나 최적의 압축율을 보여줍니다. \fB\-6\fP 옵션은 +압축 해제시 메모리 사용량이 16MiB 밖에 안되기 때문에 파일을 배포할 때 최적의 선택인 기본 값입니다. (\fB\-5e\fP 또는 +\fB\-6e\fP도 역시 고려할 만합니다. \fB\-\-extreme\fP을 참고하십시오.) +.TP +\fB\-7 ... \-9\fP +\fB\-6\fP과 비슷하지만 압축 및 압축 해제시 요구 메모리 사용량이 더 높습니다. 압축 파일이 각각 8MiB, 16MiB, 32MiB +보다 클 경우에만 쓸만한 옵션입니다. +.RE +.IP "" +동일한 하드웨어에서, 압축 해제 속도는 압축한 데이터의 초당 정적 바이트 처리 수의 어림 평균입니다. 다시 말해, 압축율을 더 올리면, +압축 해제 속도도 역시 올라갑니다. 이는 곧 초당 비압축 데이터 출력 양이 달라질 수 있단 뜻입니다. +.IP "" +다음 표에 사전 설정 기능을 정리했습니다: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Preset;DictSize;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +컬럼 설명: +.RS +.IP \(bu 3 +DictSize는 LZMA2 딕셔너리 크기입니다. 압축 해제 파일의 크기보다 딕셔너리에서 사용하는 낭비 메모리 용량입니다. 실제로 +필요하지 않은 \fB\-7\fP ... \fB\-9\fP 사전 설정값을 피해야 하는 적절한 이유이기도 합니다. \fB\-6\fP 이하에서는 소모 메모리 양이 +충분히 적거나 따로 신경쓸 필요가 없습니다. +.IP \(bu 3 +CompCPU는 압축 속도에 영향을 주는 LZMA2 설정의 단순화 표기 값입니다. 딕셔너리 크기는 속도에도 영향을 주기 때문에 +CompCPU는 \fB\-6\fP ... \fB\-9\fP 수준값과 동일한데, 고수준 값은 여전히 조금 더 느려질 수 있습니다. 느려지는 만큼 +압축율은 가능한 한 더 좋아집니다. \fB\-\-extreme\fP을 참고하십시오. +.IP \(bu 3 +CompMem은 단일\-스레드 모드에서 필요한 압축 프로그램의 메모리 점유 용량입니다. \fBxz\fP 버전에 따라 다를 수 있습니다. +.IP \(bu 3 +DecMem은 압축 해제 프로그램의 메모리 점유용량입니다. 이는 곧, 압축 해제 프로그램에서 필요한 메모리 사용량을 압축 설정에서 +결정한다는 의미가 들어있습니다. 정확한 압축 해제 프로그램의 메모리 사용량은 LZMA2 딕셔너리 크기 보다는 조금 많지만 테이블의 값은 +MiB 용량으로 완전히 반올림한 값입니다. +.RE +.IP "" +다중\-스레드 모드에서 필요한 메모리 용량은 단일\-스레드 모드보단 약간 더 많습니다. \fB\-\-block\-size\fP 기본값에 따라, 각 +스레드에서는 3*3*딕셔녀리_크기 + 압축시_메모리용량 또는 압축_해제시_메모리용량 정도가 필요합니다. 예를 들면, 스레드 넷에 사전 +설정 옵션 \fB\-6\fP을 사용한다면, 660\(en670 MiB 메모리 용량이 필요합니다. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +기대하는 만큼의 좀 더 나은 압축율을 확보하려 선택한 압축 사전 설정 수준의 느린 변형 옵션을 사용하지만, 재수 없는 와중에 골로 가는 +경우가 생기기도 합니다. 압축 해제 프로그램의 메모리 사용에는 영향을 주지 않지만, 압축 프로그램의 메모리 사용량은 \fB\-0\fP +\&... \fB\-3\fP 사전 설정 수준에서 약간 더 올라갈 뿐입니다. +.IP "" +4MiB와 8MiB 두 가지 딕셔너리 용량 설정이 있기 때문에 \fB\-3e\fP 와 \fB\-5e\fP 사전 설정을 (CompCPU 수치를 낮춰서) +각각 \fB\-4e\fP 와 \fB\-6e\fP 보다 약간 더 빠르게 설정할 수 있습니다. 이런 식으로 두 사전 설정이 동일하지 않습니다. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Preset;DictSize;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +예를 들면, 8MiB 딕셔너리를 활용하는 네가지 사전 설정이 있다고 할 때, 빠른 순으로 설정을 나열하자면, \fB\-5\fP, \fB\-6\fP, +\fB\-5e\fP, \fB\-6e\fP 입니다. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +이 옵션은 \fB\-0\fP 과 \fB\-9\fP의 별칭으로 각각 오해할 수 있습니다. LZMA 유틸리티의 하위 호환성을 목적으로 제공합니다. 이 +옵션 사용은 피하십시오. +.TP +\fB\-\-block\-size=\fP\fI<크기>\fP +\&\fB.xz\fP 형식으로 압축할 때, 입력 데이터를 \fI<크기>\fP 바이트 블록으로 입력 데이터를 쪼갭니다. 각각의 블록은 +다중\-스레드 방식으로 처리할 수 있고 임의 접근 압축 해제 가능성을 제한할 수 있게 개별적으로 압축 처리합니다. 이 옵션은 보통 +다중\-스레드 모드에서 기본 블록 크기를 지정할 때 사용하지만, 단일\-스레드 모드에서도 사용할 수 있습니다. +.IP "" +다중\-스레드 모드에서는 약 3배 용량의 \fI<크기>\fP 바이트만큼 각 스레드 별로 입출력 버퍼링용 공간을 할당합니다. 기본 +\fI<크기>\fP는 LZMA2 딕셔너리 크기 또는 1MiB 중 가장 큰 쪽의 세 배입니다. 보통 적절한 값으로 LZMA2 +딕셔너리 크기 또는 최소한 1MiB 용량의 2\(en4배입니다. LZMA2 딕셔너리 크기보다 작은 \fI<크기>\fP는 램의 +소모적 사용 공간으로 할당하는데 LZMA2 딕셔너리 버퍼를 할당한 용량 크기 전체를 다 사용하지 않기 때문입니다. 다중\-스레드 모드에서 +블록 크기는 블록 헤더에 저장하며, 이 크기 정보는 다중\-스레드 압축 해제시 필요합니다. +.IP "" +단일\-스레드 모드에서는 기본적으로 블록 쪼개기를 하지 않습니다. 이 옵션을 설정한다고 해서 메모리 사용에 영향을 주지는 않습니다. +블록 헤더에 크기 정보를 저장하지 않기 때문에 단일\-스레드 모드에서 만든 파일은 다중\-스레드 모드에서 만든 파일과 동일하지 않습니다. +크기 정보의 누락은 또한 \fBxz\fP에서 다중\-스레드 모드로 압축 해제를 진행할 수 없음을 의미하기도 합니다. +.TP +\fB\-\-block\-list=\fP\fI<항목>\fP +\&\fB.xz\fP 형식으로 압축할 때, 압축하지 않은 데이터로 부터 일정 간격 이후에 새 블록 처리를 시작합니다. +.IP "" +\fI<항목>\fP은 쉼표로 구분한 목록으로 지정합니다. 각 항목은 콜론 (\fB:\fP)으로 구분한 0부터 9까지의 추가 필터 +체인 번호 값으로 이루어져 있으며, 압축하지 않은 데이터의 크기 값이 필요합니다. 항목을 생략하면(둘 이상의 쉼표 연속 표기) 이전 +항목의 크기와 필터를 활용하겠다는 함축 의미를 넣을 수 있습니다. +.IP "" +입력 파일이 \fI<항목>\fP 크기의 합보다 크면, 마지막 항목을 파일의 끝까지 반복합니다. 특별히 \fB0\fP 값을 마지막 +값으로 사용하여 파일 나머지 부분을 단일 블록으로 인코딩해야 한다는 의미를 나타낼 수도 있습니다. +.IP "" +\fB\-\-filters1=\fP\fI<필터>\fP \&...\& \fB\-\-filters9=\fP\fI<필터>\fP 옵션 조합으로 +각 블록별 별도 필터 체인을 지정할 수 있습니다. 이 옵션은 1\(en9번 필터 체인을 지정합니다. 필터 체인 0번은 필터 체인을 +지정하지 않았을 때와 동일한 기본 필터 체인으로 참조할 수 있습니다. 필터 체인 식별 번호는 비 압축 크기 앞에 콜론(\fB:\fP)을 붙여 +사용할 수 있습니다. 예를 들면, \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP 옵션을 +지정했을 경우 다음 규칙대로 블록을 만듭니다: +.RS +.IP \(bu 3 +\fB\-\-filters1\fP 필터 체인에서는 2MiB 입력을 +.IP \(bu 3 +\fB\-\-filters3\fP 필터 체인에서는 2MiB 입력을 +.IP \(bu 3 +\fB\-\-filters2\fP 필터 체인에서는 4MiB 입력을 +.IP \(bu 3 +\fB\-\-filters2\fP 필터 체인에서는 4MiB 입력을 +.IP \(bu 3 +기본 필터 체인에서는 2MiB 입력을 +.IP \(bu 3 +입력이 끝나기 전의 모든 블록에는 기본 필터 체인과 4MiB 입력을 적용합니다. +.RE +.IP "" +인코더 블록 크기를 초과하는 크기 값을 지정하면(스레드 모드 기본값 또는 \fB\-\-block\-size=\fP\fI<크기>\fP +옵션으로 지정한 값), 인코더는 \fI<크기>\fP 지정 용량 범위는 유지하면서 추가 블록을 만듭니다. 예를 들면 +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP 옵션을 지정하고 +입력 파일을 80MiB 용량으로 전달하면, 각각 5, 10, 8, 10, 2, 10, 10, 4, 10, 10, 1 MiB 용량을 +차지하는 블록 11개를 결과물로 내줍니다. +.IP "" +다중\-스레드 모드에서 블록 크기는 블록 헤더에 저장합니다. 단일\-스레드 모드에서는 저장하지 않기 때문에 인코딩 처리한 출력은 +다중\-스레드 모드의 출력 결과물과는 다릅니다. +.TP +\fB\-\-flush\-timeout=\fP\fI<제한시간>\fP +압축할 때, 이전 데이터를 소거하고 다음 입력을 블록 단위로 더 읽는데 \fI<제한시간>\fP 밀리초(양의 정수값)가 지났을 +경우, 대기중이던 모든 입력 데이터를 인코더에서 소거한 다음 출력 스트림에 전달합니다. 이런 동작은 네트워크로 스트리밍한 데이터를 +\fBxz\fP로 압축할 때 쓸만합니다. \fI<제한시간>\fP 값을 적게 지정하면 적은 지연 시간에 데이터를 받아낼 수 있지만 +\fI<제한시간>\fP 값을 크게 하면 압축율을 높일 수 있습니다. +.IP "" +이 기능은 기본적으로 꺼져있습니다. 이 옵션을 한번 이상 지정하면, 마지막 옵션의 값대로 동작합니다. 특별히 +\fI<제한시간>\fP 값을 \fB0\fP으로 설정하면 이 설정을 완전히 끌 수 있습니다. +.IP "" +이 기능은 POSIX 시스템이 아닌 곳에서는 사용할 수 없습니다. +.IP "" +.\" FIXME +\fB이 기능은 여전히 시험중입니다\fP. 현재로서는, \fBxz\fP 버퍼링 처리 방식 때문에 \fBxz\fP의 실시간 스트림 압축 해제 기능 활용은 +적절하지 않습니다. +.TP +\fB\-\-no\-sync\fP +원본 파일을 제거하기 전까지는 스토릿지 장치에 대상 파일과 디렉터리를 동기화하지 않습니다. 작은 여러 파일을 압축하거나 압축해제할 때 +성능을 개선할 수 있습니다. 그러나, 삭제 과정을 진행한 다음 시스템이 바로 치명적인 오류가 나타난다면, 대상 파일을 스토릿지 장치에 +저장하지 않았지만 삭제 동작이 이루어졌을 수도 있습니다. 이 경우 원본 파일 뿐만 아니라 대상 파일도 나타나지 않습니다. +.IP "" +이 옵션은 \fBxz\fP 프로그램이 원본 파일을 삭제할 때만 동작합니다. 다른 경우에는 전혀 동기화가 이루어지지 않습니다. +.IP "" +동기화 동작과 \fB\-\-no\-sync\fP 옵션은 \fBxz\fP 5.7.1alpha에 추가했습니다. +.TP +\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP +압축 수행시 메모리 사용 한계를 지정합니다. 이 옵션을 여러번 지정하면 마지막 값을 취합니다. +.IP "" +압축 설정이 \fI<제한용량>\fP을 초과하면, \fBxz\fP는 설정 값의 하향 조정을 시도하여 한계 값을 더이상 넘치지 않게 하고 +자동 조절을 끝냈다는 알림을 표시합니다. 조정은 다음 순서대로 진행합니다. 스레드 수를 줄입니다. 다중\-스레드 모드에서 스레드 하나의 +할당 한계치가 \fI<제한용량>\fP을 넘으면 단일\-스레드 모드로 전환합니다. 그 다음 마지막으로 LZMA2 딕셔너리 크기를 +줄입니다. +.IP "" +\fB\-\-format=raw\fP 또는 \fB\-\-no\-adjust\fP 미지정 상황에서 압축할 때, 압축 데이터 출력에 영향을 주지 않고 스레드 +처리 수만 줄일 수 있습니다. +.IP "" +\fI<제한용량>\fP 값이 아래 설명한 조건에 맞지 않으면, 오류가 나타나고 \fBxz\fP 명령은 종료 상태 1번을 반환하며 +빠져나갑니다. +.IP "" +\fI<제한용량>\fP 값은 여러 방식으로 지정할 수 있습니다: +.RS +.IP \(bu 3 +\fI<제한용량>\fP 값은 바이트 용량 절대값입니다. 정수 값을 사용하되 \fBMiB\fP와 같은 접미사를 사용하는게 좋습니다. +예: \fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +\fI<제한용량>\fP 값은 총 물리 메모리(RAM) 용량의 백분율로 지정할 수도 있습니다. 다른 컴퓨터끼리 공유하는 셸 +초기화 스크립트의 \fBXZ_DEFAULTS\fP 환경 변수에 값을 설정할 때 특히 쓸만합니다. 이런 방식으로 설정하면 시스템의 메모리 설치 +용량에 따라 자동으로 늘어납니다. 예: \fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +\fI<제한용량>\fP 값은 \fB0\fP 기본값으로 설정하여 초기화할 수 있습니다. 현재로서는 \fI<제한용량>\fP +값이 \fImax\fP(최대) (메모리 사용 한계 없음) 인 상태와 동일합니다. +.RE +.IP "" +\fBxz\fP 32비트 버전에서는 몇가지 특별한 경우가 있습니다. \fI<제한용량>\fP 값이 \fB4020MiB\fP를 넘으면 +\fI<제한용량>\fP을 \fB4020MiB\fP로 고정합니다. MIPS32에서는 \fB2000MiB\fP로 대신 고정합니다. +(\fB0\fP과 \fBmax\fP는 이 경우에 해당하지 않습니다. 압축 해제시 비슷한 기능은 없습니다.) 이 경우 32비트 실행 파일이 +4GiB(MIPS32의 경우 2GiB) 주소 영역에 접근할 때 매우 용이하며, 다른 경우에는 원하는대로 문제를 일으키지 않습니다. +.IP "" +\fB메모리 활용\fP 섹션도 참고하십시오. +.TP +\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP +압축 해제시 메모리 사용 한계 용량을 설정합니다. \fB\-\-list\fP 모드에도 영향을 줍니다. \fI<제한용량>\fP을 넘기지 +않고서는 동작이 진행이 안될 경우, \fBxz\fP 에서는 오류를 나타내고 파일 압축 해제를 실패로 +간주합니다. \fI<제한용량>\fP을 지정하는 가능한 방법에 대해서는 +\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션을 참고하십시오. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP +다중\-스레드 모드 압축 해제시 메모리 사용 한계 용량을 설정합니다. 스레드 수에 영향을 줄 수도 있습니다. \fBxz\fP에서 파일 압축 +해제를 거부하게 하진 않습니다. \fI<제한용량>\fP 수치가 다중\-스레드로 처리하기에 너무 낮다면, +\fI<제한용량>\fP 값을 무시하고 \fBxz\fP 동작을 단일\-스레드 모드로 계속 진행합니다. 참고로 +\fB\-\-memlimit\-decompress\fP 옵션도 사용하면, 단일\-스레드 모드와 다중\-스레드 모드 두 경우에 모두 적용하기에, +다중\-스레드 모드에 적용할 \fI<제한용량>\fP 값은 \fB\-\-memlimit\-decompress\fP에 설정하는 제한 값보다 더 +크면 안됩니다. +.IP "" +다른 메모리 사용 용량 제한 옵션과는 달리, \fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP 옵션은 +시스템별 기본 \fI<제한용량>\fP 값을 지닙니다. 현재 설정 값은 \fBxz \-\-info\-memory\fP 명령으로 확인해볼 수 +있습니다. +.IP "" +이 옵션과 기본 값은 한계 값을 주지 않으면 스레드 기반 압축 해제 프로그램이 일부 입력 파일에 대해 정신나간 수준의 메모리 용량을 +할당해서 동작이 끝나버릴 수 있습니다. 기본 \fI<제한용량>\fP이 시스템의 사양에 비해 낮다면, +\fI<제한용량>\fP 값을 자유롭게 올리시되, \fBxz\fP 에서 적은 스레드 수에도 메모리 공간 할당을 시도하는 만큼, 입력 +파일에 적절한 수준으로 가용 RAM 용량을 넘는 큰 값을 설정하지 마십시오. 메모리나 스와핑 영역 공간이 줄어들면 압축해제 성능을 +개선하지 못합니다. +.IP "" +\fI<제한용량>\fP 값을 지정하는 가능한 방법을 보려면 +\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션을 참고하십시오. \fI<제한용량>\fP 값을 +\fB0\fP으로 설정하면 \fI<제한용량>\fP 값이 시스템 지정 기본값으로 바뀝니다. +.TP +\fB\-M\fP \fI<제한용량>\fP, \fB\-\-memlimit=\fP\fI<제한용량>\fP, \fB\-\-memory=\fP\fI<제한용량>\fP +\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP +\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP +\fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP 지정과 동일합니다. +.TP +\fB\-\-no\-adjust\fP +압축 출력 결과에 영향을 주는 설정을 조정하지 않고는 메모리 사용 용량 제한 조건이 맞지 않으면 오류를 표시하고 빠져나갑니다. 이 +옵션은 \fBxz\fP가 다중\-스레드 모드에서 단일\-스레드 모드로 전환하고 LZMA2 딕셔너리 크기를 줄이는 동작을 막아줍니다. 심지어 이 +옵션을 사용하면 메모리 사용 한계를 만족하도록 스레드 수를 줄여 압축 결과물 출력에 영향이 가지 않게 합니다. +.IP "" +원시 스트림(\fB\-\-format=raw\fP)을 만들 떄 자동 조정은 항상 꺼집니다. +.TP +\fB\-T\fP \fI<스레드수>\fP, \fB\-\-threads=\fP\fI<스레드수>\fP +활용할 작업 스레드 수를 지정합니다. \fI<스레드수>\fP 값을 \fB0\fP 값으로 설정하면, \fBxz\fP는 시스템에서 지원하는 +최대 프로세서 스레드 수를 모두 확보합니다. 실제 스레드 수는 입력 파일이 주어진 설정대로 스레드 처리를 할 만큼 그렇게 크지 않을 +경우, 내지는 더 많은 스레드를 사용했을 때 메모리 사용량 한계를 초과할 경우 \fI<스레드수>\fP 보다 적을 수 있습니다. +.IP "" +단일\-스레드와 다중\-스레드 압축 프로그램은 다른 출력 결과물을 냅니다. 단일\-스레드 압축 프로그램은 작은 파일 크기 결과물을 내놓지만, +다중\-스레드 압축 프로그램의 경우 다중\-스레드 압축 프로그램에서 내놓은 결과물은 다중\-스레드로만 압축을 해제할 수 있습니다. +\fI<스레드수>\fP를 \fB1\fP로 설정하면 단일\-스레드 모드를 사용합니다. \fI<스레드수>\fP를 \fB0\fP과 다른 +값으로 설정하면, 시스템에서 실제로 하드웨어 스레드가 1개만 지원한다 하더라도, 다중\-스레드 압축 프로그램을 사용합니다. (\fBxz\fP +5.2.x에서는 이 경우 단일\-스레드 모드를 활용합니다.) +.IP "" +단일\-스레드로 다중\-스레드 모드를 사용하려면, \fI<스레드수>\fP를 \fB+1\fP로 설정하십시오. \fB+\fP 접두사는 \fB1\fP +이외의 값에는 영향을 주지 않습니다. 메모리 사용량 한계 설정은 \fBxz\fP을 \fB\-\-no\-adjust\fP 옵션을 쓰기 전까지는 +단일\-스레드로 전환하게 합니다. \fB+\fP 접두사 지원은 \fBxz\fP 5.4.0에 추가했습니다. +.IP "" +자동 스레드 수를 요청했고 메모리 사용 한계를 지정하지 않았다면, 시스템에 맞게끔 가능한 스레드 수를 제한하는 기본 소프트 제한 값을 +사용합니다. 스레드 수가 한개가 되면 무시하는 이런 개념이 소프트 제한이기에, \fBxz\fP로 하여금 압축 동작 및 압축 해제 동작 수행시 +멈추지 않습니다. 이 가본 소프트 제한 값은 \fBxz\fP 실행 도중 다중\-스레드 모드에서 단일\-스레드 모드로 바뀌게 하지는 않습니다. +활성 제한 값은 \fBxz \-\-info\-memory\fP 명령으로 볼 수 있습니다. +.IP "" +현재 스레딩 처리 방식은 입력을 블록 단위로 쪼개고 각각의 블록을 독립적으로 압축하는 동작을 취합니다. 기본 블록 크기는 압축 수준에 +따라 다르며 \fB\-\-block\-size=\fP\fI<크기>\fP 옵션으로 재지정할 수 있습니다. +.IP "" +스레드 압축 해제 방식은 여러 블록이 블록 헤더에 넣은 크기 정보와 함께 들어간 파일에만 동작합니다. 다중\-스레드 모드에서 압축한 +충분히 큰 모든 파일은 이 조건에 만족하지만, 단일\-스레드 모드에서 압축한 파일은 +\fB\-\-block\-size=\fP\fI<크기>\fP 옵션을 지정하더라도 조건에 만족하지 않습니다. +.IP "" +\fI스레드\fP 기본 값은 \fB0\fP입니다. \fBxz\fP 5.4.x 이전의 기본값은 \fB1\fP입니다. +. +.SS "개별 압축 필터 체인 설정" +개별 필터 체인은 사전 설정에 엮인 설정에 의존하는 대신 압축 설정을 세부적으로 하나하나 설정할 수 있게 합니다. 개별 필터 체인을 +지정하면, 명령행에 앞서 지정한 사전 설정 옵션(\fB\-0\fP \&...\& \fB\-9\fP 과 \fB\-\-extreme\fP)은 무시합니다. 사전 +설정 옵션을 하나 이상의 필터 체인 옵션 다음에 지정하면, 새 사전 설정을 취하며, 앞서 지정한 개별 필터 체인 옵션은 무시합니다. +.PP +필터 체인은 명령행 파이핑에 비교할 수 있습니다. 압축할 때, 압축하지 않은 입력을 첫번째 필터로 놓고, 출력 대상(이 있으면)을 다음 +필터로 지정합니다. 최종 필터의 출력은 압축 파일로 기옥합니다. 체인의 최대 필터 수는 4이지만, 필터 체인상 필터 갯수는 보통 +1~2개입니다. +.PP +수많은 필터가 필터 체인 상에서 제약점을 가지고 있습니다. 일부 필터는 체인의 마지막 필터로만 동작하며, 일부 다른 필터는 마지막이 아닌 +필터로, 어떤 동작은 체인의 어떤 위치에든 둡니다. 필터에 따라, 이 제한은 필터 설계를 따르거나 보안 문제를 막기 위해 존재하기도 +합니다. +.PP +개별 필터 체인은 두가지 방식으로 지정할 수 있습니다. \fB\-\-filters=\fP\fI<필터>\fP와 +\fB\-\-filters1=\fP\fI<필터>\fP \&...\& \fB\-\-filters9=\fP\fI<필터>\fP 옵션으로 +liblzma 필터 문자열 문법에 따라 한가지 옵션을 필터 체인 전체를 지정할 수 있습니다. 대신, 하나 이상의 개별 필터 옵션을 +원하는 필터 체인 순서대로 지정할 수도 있습니다. 이 말인 즉슨, 개별 필터 옵션의 순서가 중요하단 뜻입니다! 원시 스트림을 디코딩할 +때(\fB\-\-format=raw\fP), 압축했을 때 지정했던 필터와 같은 순서로 필터 체인을 지정해야 합니다. 전체 체인 +옵션(\fB\-\-filters=\fP\fI<필터>\fP) 보다 우선 지정한 개별 필터 또는 사전 설정 옵션은 까먹을 수도 있습니다. +전체 체인 옵션 다음에 개별 필터를 지정할 경우 필터 체인의 동작을 무효로 합니다. +.PP +필터는 쉼표로 구분하는 필터별 \fI<옵션>\fP이 있습니다. \fI<옵션>\fP에 추가로 입력한 쉼표는 +무시합니다. 모든 옵션 값에는 기본값이 있어, 값을 바꾸려면 지정해야합니다. +.PP +전체 필터 체인과 \fI<옵션>\fP을 보려면 \fBxz \-vv\fP (\fB\-\-verbose\fP 두 번)명령을 사용하십시오. 이 +명령은 사전 설정이 사용하는 필터 체인 옵션도 볼 수 있습니다. +.TP +\fB\-\-filters=\fP\fI<필터>\fP +전체 필터 체인 또는 사전 설정을 단일 옵션으로 지정합니다. 각 필터는 공백 문자 또는 대시 문자 두번 입력(\fB\-\-\fP)으로 +구분합니다. 셸 명령행에서 \fI필터\fP는 따옴표로 감싸서 단일 옵션으로 해석하도록 해야 합니다. \fI옵션\fP을 표기하려면 \fB:\fP 또는 +\fB=\fP을 활용하십시오. 사전 설정 앞에 \fB\-\fP를 붙일 수 있고 0개 또는 하나 이상의 플래그를 붙일 수 있습니다. 유일하게 +지원하는 플래그는 \fB\-\-extreme\fP과 동일한 \fBe\fP입니다. +.TP +\fB\-\-filters1\fP=\fI<필터>\fP ... \fB\-\-filters9\fP=\fI<필터>\fP +\fB\-\-block\-list\fP와 사용할 수 있는 추가 필터 체인을 최대 9개까지 지정합니다. +.IP "" +예를 들어 텍스트 파일과 실행 파일의 아카이브를 압축할 때 실행 부분에 BCJ 필터 체인을 사용하고 텍스트 부분은 LZMA2 필터를 +사용할 수 있습니다. +.TP +\fB\-\-filters\-help\fP +\fB\-\-filters\fP와 \fB\-\-filters1=\fP\fI<필터>\fP \&...\& +\fB\-\-filters9=\fP\fI<필터>\fP 옵션의 사전 설정 필터와 개별 설정 필터 체인을 지정하는 방법을 설명하는 도움말 +메시지를 출력하고 완전히 빠져나갑니다. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fI<옵션>\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fI<옵션>\fP] +.PD +LZMA1 또는 LZMA2 필터를 필터 체인에 추가합니다. 이 필터는 필터 체인의 마지막 요소로만 사용할 수 있습니다. +.IP "" +LZMA1은 고전 필터로, LZMA1만 지원하는 고전 \fB.lzma\fP 파일 형식에서만 지원합니다. LZMA2는 LZMA1의 업데이트 +버전으로 LZMA1의 실질적 문제를 해결했습니다. \fB.xz\fP 형식은 LZMA2 필터를 사용하며 LZMA1 필터는 전적으로 지원하지 +않습니다. 압축 속도와 압축율은 LZMA1과 LZMA2가 실질적으로 동일합니다. +.IP "" +LZMA1과 LZMA2는 동일한 \fI<옵션>\fP 집합을 공유합니다: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fI<사전설정>\fP +LZMA1 또는 LZMA2의 모든 \fI<옵션>\fP을 \fI<사전설정>\fP으로 +초기화합니다. \fI<사전설정>\fP 값은 정수 값으로 이루어져 있으며, 사전 설정에 변형을 줄 떄 단일 문자가 따라올 수도 +있습니다. 정수 값은 \fB0\fP에서 \fB9\fP 까지이며, 명령행 옵션에서 \fB\-0\fP \&...\& \fB\-9\fP로 대응합니다. 변형 옵션으로 +지원하는 문자는 현재 \fBe\fP 뿐이며, \fB\-\-extreme\fP에 대응합니다. \fI<사전설정>\fP 값을 지정하지 않으면, +LZMA1 또는 LZMA2 기본값을 사전 설정 \fB6\fP에서 가져온 \fI<옵션>\fP으로 취합니다. +.TP +\fBdict=\fP\fI<크기>\fP +딕셔너리(기록 버퍼) \fI<크기>\fP는 최근 처리한 비압축 데이터를 바이트 단위로 메모리에 얼마나 유지하는지 나타냅니다. +알고리즘은 비압축 데이터상 바이트 시퀀스(일치 항목) 반복 탐색을 시도하며, 해당 부분을 딕셔너리의 현재 참조로 치환합니다. 딕셔너리가 +크면 일치하는 항목을 찾을 기회가 더 많아집니다. 따라서, 딕셔너리 \fI<크기>\fP를 더욱 크게 설정하면 압축율을 증가할 +수는 있지만, 압축하지 않은 파일보다 딕셔너리가 크면 메모리 낭비율이 올라갑니다. +.IP "" +보통 딕셔너리 \fI<크기>\fP는 64KiB 에서 64MiB 정도 됩니다. 최소 4KiB 입니다. 압축시 최대 용량은 현재 +1.5GiB(1536MiB)로 나타납니다. 압축 해제 프로그램에도 4GiB 미만으로 딕셔너리 크기를 이미 지원하며 4GiB 라는 수치는 +LZMA1과 LZMA2 스트림 형식의 최대값입니다. +.IP "" +딕셔너리 \fI<크기>\fP와 검색기(\fImf\fP)는 LZMA1 또는 LZMA 인코더의 메모리 사용량을 함께 결정합니다. +동일한(또는 더 큰) 딕셔너리 \fI<크기>\fP가 데이터를 압축했을 때만큼 압축 해제할 떄 필요하기 때문에, 디코더의 메모리 +사용량은 압축할 때의 딕셔너리 크기로 결정합니다. \fB.xz\fP 헤더에는 딕셔너리 \fI<크기>\fP를 2^\fIn\fP 또는 +2^\fIn\fP + 2^(\fIn\fP\-1) 으로 저장하기에, 이 \fI<크기>\fP 값을 압축할 때 선호하는 편입니다. 다른 +\fI<크기>\fP 값은 \fB.xz\fP 헤더에 저장할 때 반올림합니다. +.TP +\fBlc=\fP\fIlc\fP +리터럴 컨텍스트 비트 수를 지정합니다. 최소 값은 0이고 최대 값은 4입니다. 기본 값은 3입니다. 추가로, \fIlc\fP 값과 +\fIlp\fP 값의 합은 4를 넘으면 안됩니다. +.IP "" +조건이 일치하지 않아 인코딩할 수 없는 모든 바이트는 리터럴로 인코딩합니다. 이 말인 즉슨, 간단히 8비트 바이트로서의 리터럴을 한번에 +하나씩 인코딩합니다. +.IP "" +리터럴 코딩을 할 때 이전 비압축 바이트와 다음 바이트와의 관련성을 가진 가장 많은 \fIlc\fP 비트 수를 가정합니다. 예를 들면, 보통 +영문 문장의 경우 대문자 다음에 종종 소문자가 오고, 소문자 다음에 다른 소문자가 따라옵니다. US\-ASCII 문자 세트에서는 가장 긴 +비트 3개는 대문자에 대해 010, 소문자에 대해 011입니다. \fIlc\fP 값이 최소한 3이면, 리터럴 코딩시 비압축 데이터에 대해 +이런 속성의 장점을 취할 수 있습니다. +.IP "" +(어쨌거나) 기본값 (3)은 보통 적절합니다. 최대 압축을 원한다면 \fBlc=4\fP 값을 시험해보십시오. 때로는 약간 도움이 되기도 +하겠지만, 오히려 결과가 안좋을 수도 있습니다. 결과가 엄한 방향으로 간다면, \fBlc=2\fP 값도 시험해보십시오. +.TP +\fBlp=\fP\fIlp\fP +리터럴 위치 비트 수를 지정하빈다. 최소 값은 0이고 최대 값은 4입니다. 기본 값은 0입니다. +.IP "" +\fIlp\fP 값은 리터럴 인코딩 진행시 비압축 데이터 정렬 방식 고려에 영향을 줍니다. 정렬 방식에 대한 자세한 정보는 하단 \fIpb\fP를 +참고하십시오. +.TP +\fBpb=\fP\fIpb\fP +위치 비트 수를 지정합니다. 최소 값은 0이며 최대 값은 4입니다. 기본값은 2입니다. +.IP "" +\fIpb\fP 값은 보통 압축하지 않은 데이터에 어떤 정렬 방식을 고려하느냐에 영향을 줍니다. 기본적으로 4바이트 +정렬(2^\fIpb\fP=2^2=4)을 의미하는데, 이보다 더 나은 추측 값이 없어서 종종 최적의 선택으로 간주합니다. +.IP "" +정렬 상태를 알지 못할 경우, \fIpb\fP 설정 값이 파일 크기를 조금 줄일 수 있습니다. 예를 들면, 텍스트 파일이 단일 바이트 단위로 +정돈된 상태(US\-ASCII, ISO\-8859\-*, UTF\-8)라면, \fBpb=0\fP 설정 값으로 압축율을 조금 개선할 수 있습니다. +UTF\-16 텍스트의 경우, \fBpb=1\fP 설정 값이 좋은 선택입니다. 정렬 바이트가 3 바이트 같은 홀수 바이트일 경우, +\fBpb=0\fP 설정 값이 최적의 선택일지도 모릅니다. +.IP "" +가정 정렬을 \fIpb\fP 값과 \fIlp\fP 값으로 조정하긴 하지만, LZMA1과 LZMA2는 여전히 16바이트 정렬 방식으로 선호합니다. +LZMA1 또는 LZMA2로 종종 압축하는 파일 형식이라고 하면 고려해볼만 합니다. +.TP +\fBmf=\fP\fImf\fP +일치 검색기는 인코더 속도, 메모리 사용량, 압축율에 주된 영향을 줍니다. 보통 해시 체인 검색기는 이진 트리 검색기보다 빠르긴 +합니다. 기본 값은 \fI<사전설정>\fP에 따라 다릅니다. 0은 \fBhc3\fP을, 1\(en3은 \fBhc4\fP를, 나머지는 +\fBbt4\fP를 활용합니다. +.IP "" +다음 검색 필터를 지원합니다. 메모리 사용 공식은 \fIdict\fP 값이 2의 승수일 경우 실제에 가까운 근사치입니다. +.RS +.TP +\fBhc3\fP +2바이트, 3바이트 해싱 체인 +.br +\fInice\fP 최소값: 3 +.br +메모리 사용: +.br +\fIdict\fP * 7.5 (조건: \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 5.5 + 64 MiB (조건: \fIdict\fP > 16 MiB) +.TP +\fBhc4\fP +2바이트, 3바이트, 4바이트 해싱 체인 +.br +\fInice\fP 최소값: 4 +.br +메모리 사용: +.br +\fIdict\fP * 7.5 (조건: \fIdict\fP <= 32 MiB); +.br +\fIdict\fP * 6.5 (조건: \fIdict\fP > 32 MiB) +.TP +\fBbt2\fP +2바이트 해싱 이진 트리 +.br +\fInice\fP 최소값: 2 +.br +메모리 사용: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +2바이트, 3바이트 해싱 이진트리 +.br +\fInice\fP 최소값: 3 +.br +메모리 사용: +.br +\fIdict\fP * 11.5 (조건: \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 9.5 + 64 MiB (조건: \fIdict\fP > 16 MiB) +.TP +\fBbt4\fP +2바이트, 3바이트, 4바이트 해싱 이진 트리 +.br +\fInice\fP 최소값: 4 +.br +메모리 사용: +.br +\fIdict\fP * 11.5 (조건: \fIdict\fP <= 32 MiB); +.br +\fIdict\fP * 10.5 (조건: \fIdict\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fI<모드>\fP +압축 \fI<모드>\fP 값은 일치 검색기에서 생산하는 데이터 분석 방식을 지정합니다. 지원하는 \fI<모드>\fP는 +\fBfast\fP와 \fBnormal\fP 입니다. 기본값은 \fI<사전설정>\fP값 0\(en3에 대해 \fBfast\fP, +\fI<사전설정>\fP값 4\(en9에 대해 \fBnormal\fP입니다. +.IP "" +보통 \fBfast\fP는 해시 체인 검색기에서 사용하며 \fBnormal\fP은 이진 트리 검색기에서 사용합니다. 이 동작은 또한 +\fI<사전설정>\fP 값이 할 일이기도 합니다. +.TP +\fBnice=\fP\fInice\fP +일치하는 nice 길이를 지정합니다. 최소한 \fInice\fP 바이트 정도 일치하면, 알고리즘이 가능한 최선의 부분을 찾는 동작을 +멈춥니다. +.IP "" +\fInice\fP 값은 2\(en273 바이트입니다. 값이 클 수록 속도 면에서는 손해를 보겠지만 압축율은 더욱 올라갑니다. 기본 값은 +\fI<사전설정>\fP값에 따라 다릅니다. +.TP +\fBdepth=\fP\fI<깊이>\fP +일치 검색기에서의 최대 검색 깊이를 지정합니다. 기본값은 특별한 값 0으로 지정하며, 이 값으로 압축 프로그램이 \fImf\fP 와 +\fInice\fP간 적절한 \fI<깊이>\fP 값을 결정합니다. +.IP "" +적절한 해시 체인 \fI<깊이>\fP 값은 이진 트리에서 4\(en100 그리고 16\(en1000 입니다. 상당히 큰 값을 +\fI<깊이>\fP 값으로 사용하면 일부 파일에 대해 인코더가 매우 느리게 동작할 수가 있습니다. 압축 시간이 너무 오래걸려서 +동작을 중간에 끊을 준비가 되지 않은 이상 \fI<깊이>\fP 설정 값은 1000을 넘지 않게하십시오. +.RE +.IP "" +원시 스트림(\fB\-\-format=raw\fP)을 디코딩할 때, LZMA2는 딕셔너리 \fI<크기>\fP만 필요합니다. LZMA1는 +\fIlc\fP, \fIlp\fP, \fIpb\fP 값이 모두 필요합니다. +.TP +\fB\-\-x86\fP[\fB=\fP\fI<옵션>\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIoptions\fP] +.PD +브랜치/호출/점프(BCJ) 필터를 필터 체인에 추가합니다. 이 필터는 필터 체인의 비종결 필터로만 사용할 수 있습니다. +.IP "" +BCJ 필터는 머신 코드의 상대 주소를 절대 주소로 변환합니다. 데이터 크기를 바꾸지는 않지만 LZMA2에서 \fB.xz\fP 파일을 +0\(en15% 정도 줄여주게 하는 중복성이 늘어납니다. BCJ 필터는 언제든 뒤집을 수 있어, 데이터에 적절하지 않은 BCJ 필터 +형식을 활용하면, 그냥 가만히 두면 압축율이 약간 떨어지게 한다 하더라도, 데이터를 잃을 수가 있습니다. BCJ 필터는 굉장히 빠르며 +메모리 공간을 적게 활용합니다. +.IP "" +이 BCJ 필터에는 압축율 관련 몇가지 문제가 있습니다: +.RS +.IP \(bu 3 +실행 코드가 들어있는 몇가지 파일 형식(예: 목적 파일, 정적 라이브러리, 리눅스 커널 모듈)의 경우 필터 값으로 채운 명령 주소가 +있습니다. 여기 BCJ 필터의 경우 파일의 압축율을 떨어뜨리는 주소 변환을 수행합니다. +.IP \(bu 3 +BCJ 필터를 아카이브에 적용하면, BCJ 필터를 사용하지 않았을 때보다 압축율이 떨어질 수가 있습니다. 예를 들면, 유사하거나 동일한 +실행 파일 여럿이 있으면 필터를 사용하여 파일을 덜 비슷하게 만들어 압축율이 떨어지게 합니다. 동일한 아카이브 파일에서 비 실행 파일의 +내용에 대해서도 비슷한 일이 벌어질 수 있습니다. 실제로 하나는 BCJ 필터를 걸고 하나는 제외하여 각 경우에 대해 어떤 경우가 결과가 +우수한 지 살펴보겠습니다. +.RE +.IP "" +다른 명령 세트는 다른 정렬 상태에 놓여있습니다. 실행 파일은 필터가 제대로 동작하게 하려면 입력 데이터에 있는 이 값의 배수로 +정돈해야합니다. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +필터;정렬;참고 +x86;1;32\-bit 또는 64\-bit x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096 바이트 정렬이 가장 좋습니다 +PowerPC;4;빅엔디안 전용 +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +BCJ 필터를 사용한 데이터는 LZMA2로 보통 압축하기 때문에 LZMA2 옵션을 선택한 BCJ 필터의 정렬기준에 맞추도록 설정하면 +압축율을 좀 더 개선할 수 있습니다. 예를 들면: +.RS +.IP \(bu 3 +IA\-64 필터는 16\-바이트 정렬 방식으로 동작하기에 LZMA2 필터에 \fBpb=4,lp=4,lc=0\fP 옵션(2^4=16)을 주는게 +좋습니다. +.IP \(bu 3 +RISC\-V 코드에는 16\-비트 압축 명령(C 확장) 적재 여부에 따라 2\-바이트 또는 4\-바이트 정렬 방식을 채택합니다. 16\-비트 +명령을 사용하면, \fBpb=2,lp=1,lc=3\fP 또는 \fBpb=1,lp=1,lc=3\fP 옵션 값 사용이 바람직합니다. 16\-비트 명령이 +없다면, \fBpb=2,lp=2,lc=2\fP 옵션 값을 활용하는게 좋습니다. "RVC"가 "Flags"행에 나타나는지 확인할 때 +\fBreadelf \-h\fP 명령을 사용할 수 있습니다. +.IP \(bu 3 +ARM64는 항상 4\-바이트 정렬 방식을 택하기에 \fBpb=2,lp=2,lc=2\fP 옵션 값을 활용하는게 좋습니다. +.IP \(bu 3 +x86 필터는 예외입니다. x86 실행 파일을 압축할 경우에는 보통 LZMA2 기본 옵션 값(\fBpb=2,lp=0,lc=3\fP)을 그대로 +사용하는게 좋습니다. +.RE +.IP "" +모든 BCJ 필터는 동일한 \fI옵션\fP을 지원합니다: +.RS +.TP +\fBstart=\fP\fI<오프셋>\fP +상대 주소와 절대 주소를 변환할 때 사용할 시작 \fI<오프셋>\fP을 지정합니다. \fI<오프셋>\fP에는 필터 +정렬 배수여야 합니다(상단 테이블 참조). 기본값은 0입니다. 실제로 기본값이 낫습니다. 개별 \fI<오프셋>\fP 지정 +값은 거의 쓸모가 없습니다. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fI<옵션>\fP] +필터 체인에 델타 필터를 추가합니다. 델타 필터는 필터 체인에서 마지막에 지정하지 않은 필터로만 사용할 수 있습니다. +.IP "" +현재로서는 바이트 단위 단순 델타계산 결과만 보여줍니다. 예를 들면, 압축하지 않은 비트맵 그림 또는 압축하지 않은 PCM 오디오를 +압축할 때 쓸만합니다. 그러나 특별한 목적으로 활용하는 알고리즘은 델타 + LZMA2 보다 더 나은 결과를 가져다 주기도 합니다. +이는 특히 오디오의 경우 맞는 이야기인데, \fBflac\fP(1)의 경우 더 빠르고 우수한 압축율을 보여줍니다. +.IP "" +지원 \fI옵션\fP: +.RS +.TP +\fBdist=\fP\fI<차이>\fP +바이트 단위 델터 계산 \fI<차이>\fP를 지정합니다. \fI<차이>\fP값은 1\(en256 이어야합니다. 기본 +값은 1입니다. +.IP "" +예를 들어, \fBdist=2\fP 옵션과 A1 B1 A2 B3 A3 B5 A4 B7 입력 값을 주면, 출력 값은 A1 B1 01 02 01 +02 01 02 입니다. +.RE +. +.SS "기타 옵션" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +경고 및 알림을 끕니다. 두 번 지정하면 오류 메시지 표시도 끕니다. 이 옵션은 종료 상태에 영향을 주지 않습니다. 경고 표시를 +끄더라도, 종료 상태에서는 여전히 경고가 나타났음을 알려줍니다. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +출력 내용이 많아집니다. 표준 오류를 터미널에 연결했다면 \fBxz\fP는 진행 표시를 나타냅니다. \fB\-\-verbose\fP를 두번 지정하면 +더 많은 내용을 표시합니다. +.IP "" +진행 표시에서는 다음 정보를 나타냅니다: +.RS +.IP \(bu 3 +입력 파일의 크기를 알고 있을 경우 완료 백분율. 파이프 처리시에는 백분율을 나타낼 수 없습니다. +.IP \(bu 3 +산출 압축 데이터 용량 (압축) 또는 소모 공간 용량 (압축 해제). +.IP \(bu 3 +비압축 데이터 소모 용량 (압축) 또는 산출 용량 (압축 해제). +.IP \(bu 3 +압축 데이터 산출 용량을 비압축 데이터 처리 용량으로 나누어 계산한 압축율. +.IP \(bu 3 +압축 또는 압축 해제 속도. 초당 비압축 데이터 소모량(압축) 또는 산출 용량(압축 해제)를 측정한 값입니다. \fBxz\fP에서 파일 +처리를 시작한 몇 초 후 나타납니다. +.IP \(bu 3 +경과 시간 형식은 M:SS 또는 H:MM:SS 입니다. +.IP \(bu 3 +추산 여분 시간은 \fBxz\fP가 파일을 처리하기 시작한 이후 입력 파일의 크기를 알고 몇 초가 지난 후에야 보여줍니다. 시간은 콜론 +문자를 사용하지 않고 덜 자세한 형식으로, 예를 들면, 2분 30초 와 같은 형식으로 보여줍니다. +.RE +.IP "" +표준 오류가 터미널이 아니라면 \fB\-\-verbose\fP는 \fBxz\fP에서 파일 이름, 압축 크기, 압축 해제 용량, 압축율, 그리고 +가능하다면 파일을 압축 또는 압축 해제한 후 표준 오류로 속도와 걸린 시간을 나타내도록 합니다. 속도와 걸린 시간 정보는 동작을 +처리하는데 최소한 몇초 정도 소요했을 경우에만 들어갑니다. 동작이 끝나지 않았다면, 이를테면 사용자의 중단 요청이 있었을 경우 입력 +파일의 크기를 알고 있을 때 압축 백분율 정보도 들어갑니다. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +경고로 알릴 만한 상황을 만났다 하더라도 종료 상태 2번을 설정하지 않습니다. 이 옵션은 출력 수준에 영향을 주지 않기 때문에, +\fB\-\-quiet\fP 옵션과 \fB\-\-no\-warn\fP 옵션을 경고 표시를 막고 종료 상태를 바꾸지 않을 목적으로 사용합니다. +.TP +\fB\-\-robot\fP +머신에서 해석할 형식으로 메시지를 나타냅니다. liblzma 대신 \fBxz\fP를 활용하려는 다양상 스크립트로서의 프론트엔드를 쉽게 +작성하도록 하기 위함입니다. 이 옵션을 지정한 출력은 \fBxz\fP 릴리스가 어떻게 되든 안정 버전이란 의미입니다. 자세한 내용은 +\fB로봇 모드\fP 섹션을 참고하십시오. +.TP +\fB\-\-info\-memory\fP +압축 및 압축 해제시 물리 메모리 용량 (RAM), \fBxz\fP에서 파악하는 프로세서 스레드 갯수, 메모리 사용량 한계를 파악하기 쉬운 +형식으로 나타내고 무사히 나갑니다. +.TP +\fB\-h\fP, \fB\-\-help\fP +보통 사용하는 옵션을 설명하는 도움말 메시지를 출력한 후, 완전히 빠져나갑니다. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +\fBxz\fP의 모든 기능을 설명하는 도움말 메시지를 출력한 후, 완전히 빠져나갑니다 +.TP +\fB\-V\fP, \fB\-\-version\fP +\fBxz\fP와 liblzma 버전 번호를 가독 형식으로 출력합니다. 기계 해석 가능 형식을 가져오려면 \fB\-\-version\fP 앞에 +\fB\-\-robot\fP을 지정하십시오. +. +.SH "로봇 모드" +로봇 모드는 \fB\-\-robot\fP 옵션으로 동작합니다. \fBxz\fP 출력을 다른 프로그램에서 해석하기 쉽게 해줍니다. 현재로서는 +\fB\-\-robot\fP 옵션은 \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, \fB\-\-version\fP +옵션하고만 사용할 수 있습니다. 앞으로는 압축 및 압축 해제 동작에 대해서도 지원합니다. +. +.SS "목록 모드" +\fBxz \-\-robot \-\-list\fP 명령은 탭으로 구분한 출력 형태를 활용합니다. 모든 행의 첫번째 컬럼에는 해당 행에서 찾을 수 +있는 정보의 형식을 나타냅니다: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +이 행은 항상 파일 목록 시작 부분의 첫번째 줄에 있습니다. 이 행의 두번째 컬럼에 파일 이름이 들어있습니다. +.TP +\fBfile\fP +이 행에는 \fB.xz\fP 파일의 전반적인 정보가 들어있습니다. 이 행은 항상 \fBname\fP 행 다음에 있습니다. +.TP +\fBstream\fP +이 행 형식은 \fB\-\-verbose\fP 옵션을 지정했을 때만 사용합니다. \fB.xz\fP 파일의 \fBstream\fP 행 수만큼 나타납니다. +.TP +\fBblock\fP +이 행 형식은 \fB\-\-verbose\fP 옵션을 지정했을 때만 사용합니다. \fB.xz\fP 파일의 블록 수만큼 \fBblock\fP 행이 +나타납니다. \fBblock\fP 행은 모든 \fBstream\fP 행 다음에 나타납니다. 다른 형식의 행이 끼어들지는 않습니다. +.TP +\fBsummary\fP +이 행 형식은 \fB\-\-verbose\fP 옵션을 두번 지정했을 때만 사용합니다. 이 행은 모든 \fBblock\fP 행 다음에 출력합니다. +\fBfile\fP 행과 비슷하게, \fBsummary\fP 행에는 \fB.xz\fP 파일의 전반적인 정보가 담겨있습니다. +.TP +\fBtotals\fP +이 행은 목록 출력의 가장 마지막에 항상 나타납니다. 총 갯수와 크기를 나타냅니다. +.PP +\fBfile\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +파일 스트림 갯수 +.IP 3. 4 +스트림의 블록 총 갯수 +.IP 4. 4 +파일 압축 크기 +.IP 5. 4 +파일 압축 해제 크기 +.IP 6. 4 +예를 들면, \fB0.123\fP과 같은 압축율 입니다. 비율이 9.999라면, 대시 문자 3개 (\fB\-\-\-\fP)를 비율 값 대신 나타냅니다. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +쉼표로 구분한 무결성 검사 이름 목록입니다. \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP, \fBSHA\-256\fP 문자열을 알려진 +검사 형식으로 사용합니다. 알 수 없는 검사 형식에 대해서는 \fBUnknown\-\fP\fIN\fP을 사용하며, 여기서 \fIN\fP은 (한 두자리) +정수형 숫자값으로 이루어진 검사 ID 입니다. +.IP 8. 4 +파일의 스트림 패딩 총 길이 +.RE +.PD +.PP +\fBstream\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +스트림 번호 (첫 스트림은 1번) +.IP 3. 4 +스트림의 블록 총 갯수 +.IP 4. 4 +압축 시작 오프셋 +.IP 5. 4 +비압축 시작 오프셋 +.IP 6. 4 +압축 크기 (스트림 패딩 미포함) +.IP 7. 4 +압축 해제 용량 +.IP 8. 4 +압축율 +.IP 9. 4 +무결성 검사 이름 +.IP 10. 4 +스트림 패딩 길이 +.RE +.PD +.PP +\fBblock\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +이 블록이 들어간 스트림 갯수 +.IP 3. 4 +스트림 시작 부분의 블록 번호 (첫번째 블록은 1번) +.IP 4. 4 +파일 시작 부분의 블록 번호 +.IP 5. 4 +파일 시작 부분의 압축 시작 오프셋 +.IP 6. 4 +파일 시작 부분의 비압축 시작 오프셋 +.IP 7. 4 +총 블록 압축 크기 (헤더 포함) +.IP 8. 4 +압축 해제 용량 +.IP 9. 4 +압축율 +.IP 10. 4 +무결성 검사 이름 +.RE +.PD +.PP +\fB\-\-verbose\fP를 두 번 지정하면, 추가 컬럼을 \fBblock\fP 행에 넣습니다. \fB\-\-verbose\fP 단일 지정시에는 이 +정보를 볼 때 탐색을 여러번 수행해야 하기 때문에 실행 과정이 느려질 수 있어서 나타내지 않습니다: +.PD 0 +.RS +.IP 11. 4 +16진수 무결성 검사값 +.IP 12. 4 +블록 헤더 크기 +.IP 13. 4 +블록 플래그: \fBc\fP는 압축 크기가 현재 값임을 나타내고, \fBu\fP는 압축 전 원본 크기가 현재 값임을 나타냅니다. 플래그를 설정하지 +않았다면, 문자열 길이를 유지할 목적으로 대시 \fB\-\fP 를 대신 나타냅니다. 새 플래그는 나중에 문자열 끝 부분에 추가할 예정입니다. +.IP 14. 4 +블록에 압축 해서 넣은 데이터의 실제 츠기 (블록 헤더, 블록 패딩, 검사 필드 제외) +.IP 15. 4 +이 \fBxz\fP 버전에서 이 블록의 압축을 해제할 때 필요한 (바이트 단위) 메모리 용량 +.IP 16. 4 +필터 체인. 대부분 사용하는 옵션은 압축 해제시 필요한 옵션만을 \fB.xz\fP 헤더에 저장하기 때문에 압축 시간에 알 수 없습니다. +.RE +.PD +.PP +\fBsummary\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +이 \fBxz\fP 버전에서 이 파일 압축을 해제할 때 필요한 (바이트 단위) 메모리 용량 +.IP 3. 4 +모든 블록 헤더에 압축 크기와 압축 전 원본 크기 정보가 들어갔는지 여부를 나타내는 \fByes\fP 또는 \fBno\fP 값 +.PP +\fBxz\fP \fI5.1.2alpha\fP \fI부터:\fP +.IP 4. 4 +파일 압축 해제시 필요한 최소 \fBxz\fP 버전 +.RE +.PD +.PP +\fBtotals\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +스트림 갯수 +.IP 3. 4 +블록 갯수 +.IP 4. 4 +압축 크기 +.IP 5. 4 +압축 해제 용량 +.IP 6. 4 +평균 압축율 +.IP 7. 4 +파일에 들어 있어 쉼표로 구분한 무결성 검사 이름 목록 +.IP 8. 4 +스트림 패딩 길이 +.IP 9. 4 +파일 갯수. \fBfile\fP 행의 컬럼 순서를 따라갑니다. +.PD +.RE +.PP +\fB\-\-verbose\fP 옵션을 두 번 지정하면, \fBtotals\fP 행에 추가 컬럼이 들어갑니다: +.PD 0 +.RS +.IP 10. 4 +이 \fBxz\fP 버전에서 파일 압축을 해제할 떄 필요한 (바이트 단위) 최대 메모리 사용량 +.IP 11. 4 +모든 블록 헤더에 압축 크기와 압축 전 원본 크기 정보가 들어갔는지 여부를 나타내는 \fByes\fP 또는 \fBno\fP 값 +.PP +\fBxz\fP \fI5.1.2alpha\fP \fI부터:\fP +.IP 12. 4 +파일 압축 해제시 필요한 최소 \fBxz\fP 버전 +.RE +.PD +.PP +차후 버전에서는 새 행 형식을 추가하고 기존 행 형식에 추가할 수 있는 새 컬럼을 넣기 까지는 알 수 있겠지만, 기존 컬럼은 바꾸지 않을 +예정입니다. +. +.SS "필터 도움말" +\fBxz \-\-robot \-\-filters\-help\fP 는 다음 형식의 지원 필터 목록을 출력합니다: +.PP +\fI<필터>\fP\fB:\fP\fI<옵션>\fP\fB=<\fP\fI값\fP\fB>,\fP\fI<옵션>\fP\fB=<\fP\fI값\fP\fB>\fP... +.TP +\fI<필터>\fP +필터 이름 +.TP +\fI<옵션>\fP +필터별 옵션 이름 +.TP +\fI<값>\fP +숫자 \fI값\fP 범위는 \fB<\fP\fI최소\fP\fB\-\fP\fI최대\fP\fB>\fP입니다. 문자열 \fI값\fP은 \fB< >\fP 범위 +내에서 선택하며 \fB|\fP 문자로 구분합니다. +.PP +각 필터는 한 줄에 하나씩 출력합니다. +. +.SS "메모리 제한 정보" +\fBxz \-\-robot \-\-info\-memory\fP 명령은 탭으로 나뉜 여러 컬럼을 단일 행으로 나타냅니다: +.IP 1. 4 +물리 메모리(RAM)의 바이트 단위 총량. +.IP 2. 4 +압축 진행시 바이트 단위 메모리 사용 한계값 (\fB\-\-memlimit\-compress\fP). 특수 값 \fB0\fP은 단일\-스레드 모드에서 +제한을 두지 않는 기본 설정임을 나타냅니다. +.IP 3. 4 +압축 해제시 바이트 단위 메모리 사용 한계값 (\fB\-\-memlimit\-decompress\fP). 특수 값 \fB0\fP은 단일\-스레드 모드에서 +제한을 두지 않는 기본 설정임을 나타냅니다. +.IP 4. 4 +\fBxz\fP 5.3.4alpha 이후: 다중\-스레드 기반 압축 해제시 바이트 단위 메모리 +사용량(\fB\-\-memlimit\-mt\-decompress\fP). 분명하게 제한을 걸어두지 않았을 경우 5번째 컬럼에 나타난 시스템별 +기본값을 사용하기 때문에 0 값을 지정하면 안됩니다. 또한 \fB\-\-memlimit\-mt\-decompress\fP로 세번째 컬럼 값보다 더 +크게 지정을 한다 할지라도 이 값이 세번째 컬럼 값보다 크면 안됩니다. +.IP 5. 4 +\fBxz\fP 5.3.4alpha 이후: A system\-specific default memory usage limit that is +used to limit the number of threads when compressing with an automatic +number of threads (\fB\-\-threads=0\fP) and no memory usage limit has been +specified (\fB\-\-memlimit\-compress\fP). This is also used as the default value +for \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +\fBxz\fP 5.3.4alpha 이후: Number of available processor threads. +.PP +차후, \fBxz \-\-robot \-\-info\-memory\fP 출력에는 더 많은 내용이 들어가지만, 한 줄 이상은 넘어가지 않습니다. +. +.SS 버전 +\fBxz \-\-robot \-\-version\fP 은 \fBxz\fP 와 liblzma의 버전 번호를 다음 형식으로 나타냅니다: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +주 버전. +.TP +\fIYYY\fP +부 버전. 짝수가 안정 버전입니다. 홀수는 알파 또는 베타 버전입니다. +.TP +\fIZZZ\fP +안정 릴리스의 패치 수준 또는 개발 릴리스의 횟수입니다. +.TP +\fIS\fP +안정도. 0은 알파 버전, 1은 베타 버전을 나타내며, 2는 안정 버전을 나타냅니다. \fIS\fP는 \fIYYY\fP 값이 짝수라 해도 항상 +2여야 합니다. +.PP +\fBxz\fP 명령과 liblzma이 동일한 XZ 유틸리티 릴리스에서 나왔다면 두 행의 \fIXYYYZZZS\fP 값은 같습니다. +.PP +예제: 4.999.9beta는 \fB49990091\fP이며, 5.0.0은 \fB50000002\fP입니다. +. +.SH "종료 상태" +.TP +\fB0\fP +모든 상태 양호. +.TP +\fB1\fP +오류 발생. +.TP +\fB2\fP +눈여겨볼 경고가 나타났지만, 실제 오류는 일어나지 않음. +.PP +표준 오류에 출력하는 알림(경고 또는 오류 아님)는 종료 상태에 영향을 주지 않습니다. +. +.SH 환경 +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP는 빈칸으로 구분한 옵션 값 목록을 \fBXZ_DEFAULTS\fP, \fBXZ_OPT\fP 환경 변수에서 순서대로, 명령행에서 옵션을 +해석하기 전에 불러옵니다. 참고로 환경 변수에서 옵션만 해석하며, 옵션이 아닌 부분은 조용히 무시합니다. 해석은 +\fBgetopt_long\fP(3)으로 가능하며, 명령행 인자로 활용하기도 합니다. +.PP +\fB경고:\fP 환경 변수를 설정하면, 프로그램과 \fBxz\fP를 실행하는 스크립트의 동작이 바뀝니다. 대부분의 경우 메모리 사용 제한량, +스레드 수, 압축 옵션을 환경 변수로 설정하는게 안전합니다. 그러나 일부 옵션은 스크립트의 동작을 망가뜨릴 수 있습니다. 분명한 +예제로는 \fBxz\fP에서 파일의 압축 및 해제 대신 도움말 내용을 표시하는 \fB\-\-help\fP 옵션이 있습니다. 좀 더 묘한 예제로는 +\fB\-\-quiet\fP 와 \fB\-\-verbose\fP 옵션이 있습니다. 대부분의 경우 \fB\-\-verbose\fP 옵션을 사용하여 프로세스 상황을 +표시하는데 잘 동작하지만, 어떤 경우에는 추가 메시지가 나타나는 문제가 있습니다. 출력 상세 수준은 \fB\-\-list\fP의 동작에도 영향을 +줍니다. +.TP +\fBXZ_DEFAULTS\fP +사용자별, 시스템 범위 기본 옵션입니다. 보통 \fBxz\fP의 메모리 사용량 제한을 기본으로 걸어두거나 기본 스레드 수를 설정할 경우 셸 +초기화 스크립트에 설정합니다. 셸 초기화 스크립트와 별도의 유사한 경우를 제외하고라면, 스크립트에서는 \fBXZ_DEFAULTS\fP 환경 +변수를 설정하지 않거나 설정을 해제해야합니다. +.TP +\fBXZ_OPT\fP +\fBxz\fP 명령행으로 옵션 설정 값을 직접 전달할 수 없을 경우 \fBxz\fP에 옵션을 전달하는 환경 변수입니다. 예를 들어, \fBxz\fP를 +스크립트 또는 도구에서 실행할 경우 GNU \fBtar\fP(1) 라면: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +예를 들면, 스크립트에서 \fBXZ_OPT\fP 를 활용하여, 스크립트별로 기본 압축 옵션을 지정할 수 있습니다. 적절한 이유가 있다면 +\fBXZ_OPT\fP 옵션 값을 사용자가 바꾸는걸 추천합니다. 예를 들면, \fBsh\fP(1) 스크립트에서 다음처럼 활용할 수도 있습니다: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "LZMA 유틸리티 호환성" +\fBxz\fP의 명령행 문법은 실제로 LZMA 유틸리티 4.32.x에서 찾을 수 있는 \fBlzma\fP, \fBunlzma\fP \fBlzcat\fP의 +상위 집합입니다. 대부분의 경우 LZMA 유틸리티를 XZ 유틸리티로 기존에 작성한 스크립트를 깨지 않고도 바꿀 수 있습니다. 몇가지 +비호환성 문제 때문에 문제가 일어날 수는 있습니다. +. +.SS "압축 사전 설정 단계" +압축 수준 사전 설정의 번호 부여 방식은 \fBxz\fP와 LZMA 유틸리티가 동일하지 않습니다. 가장 중요한 차이는 다른 사전 설정에 대해 +딕셔너리 크기를 어떻게 대응했느냐 여부입니다. 딕셔너리 크기는 압축 해제시 메모리 사용량과 거의 비슷합니다. +.RS +.PP +.TS +tab(;); +c c c +c n n. +단계;xz;LZMA 유틸리티 +\-0;256 KiB;없음 +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +딕셔너리 크기 차이는 압축 프로그램 메모리 사용에 영향을 주지만, LZMA 유틸리티와 XZ 유틸리티에서 사용량이 늘어나는 다른 차이점이 +있습니다: +.RS +.PP +.TS +tab(;); +c c c +c n n. +단계;xz;LZMA 유틸리티 4.32.x +\-0;3 MiB;없음 +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +XZ 유틸리티의 기본 사전 설정 수준값은 \fB\-6\fP이지만 LZMA 유틸리티의 기본 사전 설정 수준값은 \fB\-7\fP입니다. 두 프로그램의 +딕셔너리 메모리 기본 사용량은 8MiB입니다. +. +.SS "스트림 vs 비스트림 .lzma 파일" +파일을 압축하지 않은 크기는 \fB.lzma\fP 헤더에 저장합니다. LZMA 유틸리티는 일반 파일을 압축할 때 압축하지 않은 파일의 크기를 +저장합니다. 이 대신 압축하지 않은 크기를 '알 수 없음' 으로 저장하고 압축 해제 프로그램이 멈춰야 할 지점에 +end\-of\-payload 마커를 사용하는 방법도 있습니다. LZMA 유틸리티는 파이프로 들어온 입력과 같이 압축하지 않은 파일의 +크기를 알 수 없을 때 이런 방식을 활용합니다. +.PP +\fBxz\fP는 \fB.lzma\fP 파일을 end\-of\-payload 마커의 유무와 관계없이 압축 해제 방식을 모두 지원하지만, \fBxz\fP로 +만든 모든 \fB.lzma\fP 파일은 end\-of\-payload 마커를 사용하며, \fB.lzma\fP 헤더에 압축하지 않은 파일 크기를 '알 수 +없음'으로 표기합니다. 이 방식은 드문 상황에서 문제를 야기할 수 있습니다. 예를 들면, 임베디드 장치의 \fB.lzma\fP 압축 해제 +프로그램은 압축을 해제했을 때 크기를 알아야 동작합니다. 이 문제를 만나면, LZMA 유틸리티 또는 LZMA SDK를 활용하여 +\&\fB.lzma\fP 파일에 압축 전 파일 크기 정보를 저장해야합니다. +. +.SS "지원하지 않는 .lzma 파일" +\&\fB.lzma\fP 형식은 \fIlc\fP 값을 8까지 받아들이며, \fIlp\fP 값은 4까지 받아들입니다. LZMA 유틸리티는 어떤 \fIlc\fP 값과 +\fIlp\fP 값을 받아들이고도 압축을 해제할 수 있지만, 파일을 만들 때는 늘 \fBlc=3\fP 값과 \fBlp=0\fP 값을 활용합니다. 다른 +\fIlc\fP 값과 \fIlp\fP 값으로의 파일 압축은 \fBxz\fP와 LZMA SDK에서만 가능합니다. +.PP +liblzma의 LZMA1 필터 구현체에서는 \fIlc\fP 값과 \fIlp\fP 값의 합이 4를 넘어가면 안됩니다. 그래서 \fB.lzma\fP +파일의 경우 이 제한을 넘어가면 \fBxz\fP로 압축을 해제할 수 없습니다. +.PP +LZMA 유틸리티는 2^\fIn\fP (2의 승수)크기를 지닌 딕셔너리를 가진 \fB.lzma\fP 파일만 만들지만 받아들이는 파일의 딕셔너리 +크기는 어떤 크기든 상관 없습니다. liblzma에서는 2^\fIn\fP, 2^\fIn\fP + 2^(\fIn\fP\-1) 딕셔너리 크기를 가진 +\&\fB.lzma\fP 파일 만 받아들입니다. 이로 인해 \fB.lzma\fP 파일을 확인할 때 거짓 양성율이 늘어납니다. +.PP +모든 \fB.lzma\fP 파일을 liblzma 에서 받아들일 수 있도록 압축하기 때문에 이 제한이 실제로는 문제가 되지 않습니다. +. +.SS "뒤따라오는 쓰레기 값" +압축 해제할 때, LZMA 유틸리티는 \fB.lzma\fP 스트림 처음 부분 다음 나머지를 다 조용히 무시합니다. 대부분의 경우, +버그입니다. LZMA 유틸리티에서 \fB.lzma\fP 결합 파일 압축 해제를 지원하지 않음을 의미하기도 합니다. +.PP +\&\fB.lzma\fP 스트림 처음부분 바로 다음에 데이터가 남아있을 경우, \fBxz\fP 에서는 \fB\-\-single\-stream\fP 옵션을 사용하지 +않으면 깨진 파일로 간주합니다. 이 동작으로 하여금 뒤따라오는 쓰레기 값을 무시하도록 간주하는 애매한 스크립트 동작을 깰 수가 +있습니다. +. +.SH 참고 +. +.SS "출력 결과물이 달라짐" +압축하지 않은 입력 파일로부터 얻어낸 정확한 압축 출력 결과물은 압축 옵션이 완전히 동일하더라도 XZ 유틸리티의 버전에 따라 달라질 수 +있습니다. 파일 형식에 영향을 주지 않고 인코더 그 자체를 개선(더 빠르게 하거나 더 나은 압축율로)하기 때문입니다. XZ 유틸리티 +버전이 동일하더라도 빌드 옵션을 달리하여 빌드 상태가 제각각인 경우 출력 결과물이 달라질 수 있습니다. +.PP +\fB\-\-rsyncable\fP 기능을 넣었을 경우 동일한 xz 버전에서 이전 파일과 새 파일로 별도로 압축하지 않는 한 결과 파일을 (두 +파일이 서로 다른 파일이 아니므로) rsync 처리할 필요가 없습니다. 이 문제는 인코더 구현체 기능 개발이 끝나서 xz 버전이 +다르더라도 안정적인 rsync 가능한 출력 결과물을 유지할 수 있을 때여야 해결할 수 있습니다. +. +.SS "내장 .xz 압축 해제 프로그램" +XZ 임베디드와 같은 내장 \fB.xz\fP 압축 해제 구현체는 지원 파일의 무결성 \fI검사\fP 형식을 \fInone\fP과 \fIcrc32\fP 이외의 +설정으로 만들 필요가 없습니다. 기본값이 \fB\-\-check=crc64\fP일 경우에만, 임베디드 시스템에서 파일을 만들 때 +\fB\-\-check=none\fP 또는 \fB\-\-check=crc32\fP 옵션을 사용해야합니다. +.PP +임베디드 시스템이 아니라면, 모든 \fB.xz\fP 형식 압축 해제 프로그램에서는 모든 \fI검사\fP 형식을 지원하거나, 일부 \fI검사\fP 방식을 +지원하지 않는다면, 최소한, 무결성 검사로 검증하지 않고 압축을 해제할 수 있습니다. +.PP +XZ 임베디드는 BCJ 필터를 지원하지만, 기본 시작 오프셋만 지정할 수 있습니다. +. +.SH 예제 +. +.SS 기본 +\fIfoo\fP 파일을 기본 압축 수준 (\fB\-6\fP) 으로 \fIfoo.xz\fP 파일에 압축해 넣고, 압축 과정이 무사히 끝나면 \fIfoo\fP를 +삭제합니다: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +\fIbar.xz\fP를 \fIbar\fP 에 압축을 해제한 후 압축 해제가 무사히 끝나도 \fIbar.xz\fP를 삭제하지 않습니다: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +기본 사전 설정 \fB\-6\fP 보다는 느리지만, 압축 및 압축 해제시 메모리를 적게 차지(각각 48\ Mib, 5\MiB)는 \fB\-4e\fP +사전 설정(\fB\-4 \-\-extreme\fP)을 활용하여 \fIbaz.tar.xz\fP 파일을 만듭니다: +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +압축 및 비압축 파일을 단일 명령으로 표준 출력에 압축해제할 수 있습니다: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "다중 파일 병렬 압축" +GNU와 *BSD에서는 \fBfind\fP(1) 명령과 \fBxargs\fP(1) 명령으로 여러 파일의 압축을 병렬 처리할 수 있습니다: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +\fBxargs\fP(1) 의 \fB\-P\fP 옵션으로 \fBxz\fP 프로세스의 병렬 처리 갯수를 지정합니다. \fB\-n\fP 옵션의 최적 값은 압축할 +파일 수에 달려있습니다. 압축할 파일이 몇개밖에 없다면 1이어야합니다. 파일이 수천 수만개 정도 된다면 \fBxargs\fP(1) 이 +어쨌든지간에 만들어낼 \fBxz\fP 프로세스의 겟수를 100으로 하거나 아니면 적당한 값을 지정하여 줄이는게 좋습니다. +.PP +\fBxz\fP에 \fB\-T1\fP옵션을 지정하면 단일\-스레드 모드로 강제합니다. \fBxargs\fP(1) 에서 병렬 처리 갯수를 제어할 수 있기 +때문입니다. +. +.SS "로봇 모드" +여러 파일을 압축한 후 저장할 바이트 용량을 계산합니다: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +이 스크립트에서는 충분히 최신의 \fBxz\fP 명령을 사용하는지 알아보려 합니다. 다음 \fBsh\fP(1) 스크립트에서는 \fBxz\fP 도구의 +버전 번호가 최소한 5.0.0인지 여부를 검사합니다. 이 방식은 \fB\-\-robot\fP 옵션을 지원하지 않는 오래된 베타 버전과도 호환성이 +있습니다: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +\fBXZ_OPT\fP 환경 변수로 압축 해제시 메뢰 사용량 한계를 설정하지만, 한계 값을 이미 설정했다면, 값을 늘리지 않습니다: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "개별 압축 필터 체인 설정" +개별 설정 필터 체인의 초단순 사용방식은 LZMA2 사전 설정 값을 별도로 설정하는 방식입니다. 사전 설정은 잠재적으로 쓸만한 압축 +설정 조합만 다루기 때문에 꽤 쓸모가 있을 수도 있습니다. +.PP +\fB\-0\fP ... \fB\-9\fP 옵션의 설명에서 테이블의 CompCPU 컬럼과 \fB\-\-extreme\fP 옵션은 LZMA2 사전 설정을 +개별적으로 맞췄을 때 쓸만할 수도 있습니다. 여기 관련내용을 테이블 둘로 정리해서 모아보았습니다: +.RS +.PP +.TS +tab(;); +c c +n n. +Preset;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +어떤 파일을 압축할 때 상당히 큰 딕셔너리(예: 32MiB)가 필요 하다는걸 알아채셨지만, \fBxz \-8\fP 명령이 압축할 때보다 더 빠른 +속도로 압축하려 한다면, 더 큰 딕셔너리 사용을 위해 더 낮은 CompCPU 사전 설정 값(예: 1)으로 수정할 수 있습니다: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +각 파일에 대해, 위 명령은 압축율이 더 좋아지면서도 \fBxz \-6\fP보다 더 빨라집니다. 그러나, CompCPU 값을 낮게 유지하는 +대신 큰 딕셔너리에서 일부 파일을 강조해야 합니다. 큰 딕셔너리가 대부분의 도움을 주는 매우 명백한 상황에서는 최소한 몇 메가바이트의 +매우 유사한 각 파일이 아카이브에 들어갑니다. 딕셔너리 크기는 LZMA2가 연속으로 존재하는 각 파일의 유사성으로부터 얻는 장점을 취할 +수 있을 때 일부 개별 파일보다 훨씬 더 커집니다. +.PP +압축 프로그램과 압축 해제 프로그램에서 메모리를 엄청 많이 사용해도 상관 없고, 파일을 수백 메가 바이트 메모리 용량을 활용하여 +압축한다면, \fBxz \-9\fP 명령에 64MiB 용량을 초과하는 딕셔너리를 사용할 수 있게 하는 방법도 쓸만할 지도 모릅니다: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +위 예제에서와 같이 \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) 옵션을 사용하면 압축 및 압축 해제 과정에서 필요한 메모리 +용량을 살펴보는데 요긴할 수 있습니다. 압축 해제한 파일 크기보다 더 큰 딕셔너리를 사용하면 불필요한 메모리 소모량이 발생하여 위 +명령이 작은 파일에는 쓸모 없음을 기억하십시오. +.PP +때로는 압축 시간이 딱히 상관이 없을 수도 있습니다만, 압축 해제시 메모리 사용량을 적게 유지해야 할 수도 있습니다. 예를 들면, +임베디드 시스템에서 파일 압축을 해제할 수도 있습니다. 다음 명령의 경우 \fB\-6e\fP (\fB\-6 \-\-extreme\fP) 옵션을 기반 +옵션을 사용하며 딕셔너리 크기를 64KiB만 사용하도록 제한합니다. 결과 파일은 XZ 임베디드(이게 \fB\-\-check=crc32\fP +옵션이 있는 이유)로 100KiB 메모리 용량을 활용하여 풀어낼 수 있습니다. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +가능한 한 수 바이트를 더 쥐어 짜내고 싶을 때, 리터럴 문맥 비트 수(\fIlc\fP)와 위치 비트 수(\fIpb\fP)를 조정하면 도움이 될 +수도 있습니다. 리터럴 위치 비트 수(\fIlp\fP)를 조금 건드리는 것 또한 도움이 될 지도 모르겠지만 보통 \fIlc\fP 값과 \fIpb\fP +값이 더 중요합니다. 예를 들면, 소스 코드 저장 파일에는 US\-ASCII 텍스트가 대부분이기에, 다음과 같은 경우는 \fBxz \-6e\fP +명령을 실행했을 때부다는 아주 약간(거의 0.1% 수준) 작은 파일을 얻어낼 수도 있습니다(\fBlc=4\fP를 빼고도 시도해보십시오): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +LZMA2와 다른 필터를 함께 사용하면 일부 파일 형식에 대해 압축율을 개선할 수 있습니다. 예를 들면 x86\-32 또는 x86\-64 +공유 라이브러리를 x86 BCJ 필터를 활용하여 압축할 경우: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +참고로 필터 옵션의 순서는 상당히 중요합니다. \fB\-\-x86\fP을 \fB\-\-lzma\fP 이전에 지정하면 \fBxz\fP에서 오류가 나는데, +LZMA2 다음에는 어떤 필터든 설정할 수 없고, 옵션 체인상 마지막 필터로 x86 BCJ 필터를 사용할 수 없기 때문입니다. +.PP +LZMA2와 델타 필터는 비트맵 그림에 최적의 결과를 가져다줄 수 있습니다. PNG에 보통 안성맞춥인데, PNG에는 단순 델타 필터보단 +약간 더 고급진 필터를 사용하지만, 실제 압축을 진행할 때는 Deflate를 사용하기 때문입니다. +.PP +예를 들어 이미지를 압축하지 않은 비압축 TIFF로 저장해야 하는 경우가 있습니다. 델타 필터의 거리 매개변수는 그림에서 픽셀당 바이트 +수에 일치하도록 설정합니다. 예를 들면, 24비트 RGB 비트맵의 경우 \fBdist=3\fP 거리 매개변수 값을 설정해야 하며, LZMA2 +압축시 3바이트 정렬을 따르도록 \fBpb=0\fP 값을 전달하는 방법도 바람직합니다: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +여러 이미지를 단일 아카이브로 넣고 싶다면(예: \fB.tar\fP), 모든 이미지에 대해 동일한 픽셀당 바이트 수가 들어가는 경우에도 델타 +필터가 동작합니다. +. +.SH "추가 참조" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ 유틸리티: +.br +XZ 임베디드: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xzcat.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xzcat.1 new file mode 100644 index 0000000000000000000000000000000000000000..631a9a7cc8b58565ff6c9eb7a3610b39d1733d20 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xzcat.1 @@ -0,0 +1,1585 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Korean translation for the xz-man +.\" Seong-ho Cho , 2023, 2024. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 2025\-03\-08 Tukaani "XZ 유틸리티" +. +.SH 이름 +xz, unxz, xzcat, lzma, unlzma, lzcat \- .xz 파일과 .lzma 파일을 압축 또는 압축 해제합니다 +. +.SH 요약 +\fBxz\fP [\fI<옵션>...\fP] [\fI<파일>...\fP] +. +.SH "명령 별칭" +\fBunxz\fP 명령은 \fBxz \-\-decompress\fP 명령과 동일합니다. +.br +\fBxzcat\fP 명령은 \fBxz \-\-decompress \-\-stdout\fP 명령과 동일합니다. +.br +\fBlzma\fP 명령은 \fBxz \-\-format=lzma\fP 명령과 동일합니다. +.br +\fBunlzma\fP 명령은 \fBxz \-\-format=lzma \-\-decompress\fP 명령과 동일합니다. +.br +\fBlzcat\fP 명령은 \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP 명령과 동일합니다. +.PP +파일 압축을 해제해야 하는 셸 스크립트를 작성할 때, \fBunxz\fP 와 \fBxzcat\fP 이름 대신 \fBxz\fP 명령과 적절한 인자 +값(\fBxz \-d\fP 또는 \fBxz \-dc\fP)의 사용을 추천드립니다. +. +.SH 설명 +\fBxz\fP는 \fBgzip\fP(1) 과 \fBbzip2\fP(1) 과 비슷한 명령행 문법을 지닌 범용 데이터 압축 도구입니다. 자체 파일 +형식은 \fB.xz\fP 형식이나, LZMA 유틸리티에서 사용하는 예전 \fB.lzma\fP 형식과 형식 헤더가 없는 RAW 압축 스트림도 +지원합니다. 게다가, \fBlzip\fP에서 활용하는 \fB.lz\fP 형식 압축 해제도 지원합니다. +.PP +각 \fI파일\fP 에 대한 \fBxz\fP 압축 또는 압축 해제는 선택 동작 모드에 따릅니다. \fI<파일>\fP 값이 주어졌거나 +\fI<파일>\fP 값이 \fB\-\fP이면, \fBxz\fP 명령에서 표준 입력을 읽고 처리한 데이터를 표준 출력에 기록합니다. +\fBxz\fP 에서는 터미널에서 활용할 경우 압축 데이터를 표준 압축으로 기록하는 동작을 거절(오류를 출력하고 \fI<파일>\fP을 +건너뜀)합니다. 이와 비슷하게, \fBxz\fP 유틸리티를 터미널에서 실행하면 표준 입력의 압축 데이터 읽기를 거절합니다. +.PP +\fB\-\-stdout\fP 을 지정하지 않는 한, \fB\-\fP가 아닌 \fI<파일>\fP을 원본 \fI<파일>\fP 이름에서 +가져온 새 파일 이름으로 기록합니다: +.IP \(bu 3 +압축할 때, 대상 파일 형식의 접미사(\fB.xz\fP or \fB.lzma\fP) 는 원본 파일 이름 뒤에 붙어 대상 파일이름이 됩니다. +.IP \(bu 3 +압축 해제할 때, \fB.xz\fP, \fB.lzma\fP, \fB.lz\fP 접미사를 파일 이름에서 제거하고 대상 파일 이름을 알아냅니다. +\fBxz\fP에서는 \fB.txz\fP, \fB.tlz\fP 접미사도 인식하며, \fB.tar\fP 접미사로 치환합니다. +.PP +대상 파일이 이미 있으면, 오류를 나타내고 \fI<파일>\fP을 건너뜁니다. +.PP +표준 출력으로 기록하기 전에는, \fBxz\fP는 경고를 나타내며, 다음 조건에 만족할 경우 \fI<파일>\fP을 건너뜁니다: +.IP \(bu 3 +\fI<파일>\fP이 일반 파일이 아닐 때. 심볼릭 링크는 따라가지 않기에, 일반 파일로 간주하지 않습니다. +.IP \(bu 3 +\fI<파일>\fP이 하나 이상의 하드 링크일 떄. +.IP \(bu 3 +\fI<파일>\fP에 setuid, setgid, 끈적이 비트 집합이 붙어있을 떄. +.IP \(bu 3 +동작 모드를 압축으로 설정하고, \fI<파일>\fP은 대상 파일 형식의 접미사를 이미 붙였을 때(\fB.xz\fP 형식으로 압축하면 +\&\fB.xz\fP 또는 \fB.txz\fP, \fB.lzma\fP 형식으로 압축하면 \fB.lzma\fP 또는 \fB.tlz\fP). +.IP \(bu 3 +동작 모드를 압축 해제로 설정하고, \fI<파일>\fP에 지원 파일 형식 접미사(\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, +\&\fB.tlz\fP, \fB.lz\fP)를 붙이지 않았을 때. +.PP +\fI<파일>\fP 의 압축 또는 압축 해제를 성공하고 나면, \fBxz\fP는 소유자, 소유그룹, 권한, 접근 시각, 수정 시각 +정보를 원본 \fI<파일>\fP에서 대상 파일로 그대로 복사합니다. 그룹 정보 복사에 실패하면, 권한을 수정하여 원본 +\fI<파일>\fP에 접근 권한이 없는 사용자가 대상 파일로 접근하지 못하게 합니다. \fBxz\fP는 아직 접근 제어 목록이나 +확장 속성 등의 기타 메타데이터를 복사하는 기능은 지원하지 않습니다. +.PP +대상 파일을 온전히 닫고 나면, \fB\-\-keep\fP 옵션을 지원하지 않았을 경우 원본 \fI<파일>\fP을 제거합니다. 원본 +\fI<파일>\fP은 출력을 표준 출력으로 기록했거나 오류가 발생했을 경우 제거하지 않습니다. +.PP +\fBxz\fP 프로세스에 \fBSIGINFO\fP 시그널 또는 \fBSIGUSR1\fP 시그널을 보내면 표준 출력으로 진행 정보를 출력합니다. 표준 +오류가 터미널일 경우일 경우에만 제한하며 \fB\-\-verbose\fP 옵션을 지정하면 진행 표시줄을 자동으로 나타냅니다. +. +.SS "메모리 사용" +\fBxz\fP 메모리 사용은 수백 킬로바이트로 시작하여 수 기가바이트까지 압축 설정에 따라 다릅니다. 압축 해제 프로그램이 필요로 하는 +메모리 공간을 결정하는 파일 압축시에 설정 값을 활용합니다. 보통 압축 해제 프로그램은 파일을 만들 때, 압축 프로그램 메모리 사용량의 +5% 에서 20% 정도 필요합니다. 예를 들면, \fBxz \-9\fP로 압축한 파일 압축 해제시 현재 65MiB 메모리 용량이 필요합니다. +여전하게도, 압축 해제시 수 기가 바이트의 메모리가 필요한 \fB.xz\fP 파일에도 가능한 이야기입니다. +.PP +특히 이전 시스템 사용자의 경우 메모리 사용량이 엄청나게 늘어나는 점에 짜증이 날 수 있습니다. 이런 불편한 상황을 피하기 위해, +\fBxz\fP에 기본적으로 비활성 상태인 내장 메모리 사용 제한 기능을 넣었습니다. 일부 운영체제에서 처리 중 메모리 사용을 제한하는 +수단을 제공하긴 하지만, 여기에 의지하기에는 충분히 유연하지 않습니다(예를 들면, \fBulimit\fP(1)을 사용하면 가상 메모리를 +제한하여 \fBmmap\fP(2)을 먹통으로 만듭니다). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +메모리 사용 제한 기능은 \fB\-\-memlimit=\fP\fI<제한용량>\fP 명령행 옵션으로 사용할 수 있습니다. 종종 +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP와 같이 \fBXZ_DEFAULTS\fP 환경 변수를 설정하여 제한 기능을 켜는게 더 +편합니다. \fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션과 +\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP 옵션을 활용하여 압축 및 압축 해제시 별도로 한계 값을 +설정할 수 있습니다. 이 두 가지 옵션의 \fBXZ_DEFAULTS\fP 환경 변수 밖에서의 사용은, \fBxz\fP를 단일 실행할 때 압축 및 +압축 해제 동작을 동시에 수행하지 않으며, 앞서 언급한 두가지 옵션을 명령행에 입력하기에는 +\fB\-\-memlimit=\fP\fI<제한용량>\fP(또는 \fB\-M\fP \fI<제한용량>\fP)이 더 짧기 때문에 별로 쓸모가 +없습니다. +.PP +압축 해제시 메모리 사용 제한 지정 한계를 초과하면, \fBxz\fP 유틸리티에서 오류를 나타내며 파일 압축 해제는 실패합니다. 압축을 +실행할 때 사용 제한 지정 한계를 넘어서면 \fBxz\fP에서는 설정 값을 줄여서 어쨌든 한계를 넘지 못하게 +합니다(\fB\-\-format=raw\fP 옵션 또는 \fB\-\-no\-adjust\fP 옵션 사용시 제외). 설정 한계 값이 엄청 작지 않은 이상 이 +방식대로 처리하면 어쨌든 실패하지 않습니다. 설정 값조정은 압축 래벨 사전 설정과 일치하지 않을 때 단계적으로 진행하는데, 이를테면, +\fBxz \-9\fP 명령 수행에 필요한 양보다 한계 값이 약간 작으면, 설정 값을 \fBxz \-8\fP에 못미치게 약간 줄여서 진행합니다. +. +.SS ".xz 파일 결합 및 패딩" +\&\fB.xz\fP 파일을 있는 그대로 합칠 수 있습니다. \fBxz\fP는 \fB.xz\fP 파일을 단독 파일일 때 처럼 압축해제합니다. +.PP +결합 부분과 마지막 부분 뒤에 패딩을 추가할 수 있습니다. 패딩은 널 바이트로 구성해야 하며 패딩 길이는 4바이트로 구성해야 합니다. +512 바이트 블록으로 파일 크기를 이루는 매체에 \fB.xz\fP 파일을 저장했을 경우에 요긴할 수 있습니다. +.PP +\&\fB.lzma\fP 파일 또는 원시 스트림의 경우 결합과 패딩을 허용하지 않습니다. +. +.SH 옵션 +. +.SS "정수 접두사와 별도 값" +정수 인자값이 필요한 대부분 위치에서는, 큰 정수값을 나타내기 쉽게 하도록 추가 접미사를 지원합니다. 정수와 접미사 사이에 어떤 공백이 +있으면 안됩니다. +.TP +\fBKiB\fP +1,024 (2^10) 배수 정수값. \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP, \fBKB\fP 단위를 \fBKiB\fP 동의어로 받아들입니다. +.TP +\fBMiB\fP +1,048,576 (2^20) 배수 정수값. \fBMi\fP, \fBm\fP, \fBM\fP, \fBMB\fP 단위를 \fBMiB\fP 동의어로 받아들입니다. +.TP +\fBGiB\fP +1,073,741,824 (2^30) 배수 정수값. \fBGi\fP, \fBg\fP, \fBG\fP, \fBGB\fP 단위를 \fBGiB\fP 동의어로 +받아들입니다. +.PP +특수 값 \fBmax\fP는 옵션에서 지원하는 정수 최대 값을 나타낼 때 사용할 수 있습니다. +. +.SS "동작 모드" +여러 동작 모드를 보여드리겠습니다만, 마지막에 주어진 동작 모드로 동작합니다. +.TP +\fB\-z\fP, \fB\-\-compress\fP +압축합니다. 어떤 동작 모드 옵션도 지정하지 않고 다른 동작 모드를 명령행에 따로 지정하지 않았다면 이 동작 모드는 기본입니다(예: +\fBunxz\fP 는 \fB\-\-decompress\fP를 암시). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +압축을 제대로 끝내고 나면, 표준 출력에 기록하거나 \fB\-\-keep\fP 옵션을 지정하지 않았다면 원본 파일을 제거합니다. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +압축 해제입니다. 압축 해제를 제대로 끝내고 나면, 표준 출력에 기록하거나 \fB\-\-keep\fP 옵션을 지정하지 않았다면 원본 파일을 +제거합니다. +.TP +\fB\-t\fP, \fB\-\-test\fP +압축 \fI<파일>\fP의 무결성을 시험해봅니다. 이 옵션은 압축 해제 데이터를 표준 출력으로 기록하는 대신 버린다는 점을 +제외하고 \fB\-\-decompress \-\-stdout\fP과 동일합니다. 어떤 파일도 만들거나 제거하지 않습니다. +.TP +\fB\-l\fP, \fB\-\-list\fP +압축 \fI<파일>\fP 정보를 출력합니다. 압축 해제 출력을 내보내지 않으며, 어떤 파일도 만들거나 제거하지 않습니다. 이 +조회 모드에서, 프로그램은 표준 입력 또는 기타 탐색 불가능한 원본에서 압축 데이터를 읽을 수 없습니다. +.IP "" +\fI<파일>\fP 기본 정보를 파일 당 한 줄 씩 기본으로 보여줍니다. 더 자세한 정보를 보려면 \fB\-\-verbose\fP +옵션을 사용하십시오. 더 자세한 정보는 \fB\-\-verbose\fP 옵션을 두번 사용하면 되지만, 추가 정보를 더 많이 가져오면서 탐색 +횟수가 늘어나는 문제로 인해 느려질 수 있습니다. 세부 출력 너비는 80 문자를 초과하며, 예를 들어 출력을 파이핑한다면, 터미널이 +충분히 너비가 넓지 못할 경우 \fBless\ \-S\fP 명령이 편리할 수 있습니다. +.IP "" +정확한 출력은 \fBxz\fP 버전과 다른 로캘에 따라 바뀔 수 있습니다. 기계 판독용 출력시 \fB\-\-robot \-\-list\fP 옵션을 +사용합니다. +. +.SS "동작 수정자" +.TP +\fB\-k\fP, \fB\-\-keep\fP +입력 파일을 삭제하지 않습니다. +.IP "" +\fBxz\fP 5.2.6 부터는 이 옵션으로 입력 파일이 일반 파일을 참조하는 심볼릭 링크나 하나 이상의 하드 링크, 내지는 setuid, +setgid, 끈적이 비트 세트를 설정한 상태라도 압축하거나 압축을 풀 수 있습니다. setuid, setgid, 끈적이 비트는 대상 +파일에 복사하지 않습니다. 이전 버전에서는 \fB\-\-force\fP 옵션을 지정했을 때만 가능했습니다. +.TP +\fB\-f\fP, \fB\-\-force\fP +이 옵션은 몇가지 동작에 영향을 줍니다: +.RS +.IP \(bu 3 +대상 파일이 이미 있으면, 압축 또는 압축 해제 전 삭제합니다. +.IP \(bu 3 +입력 파일이 일반 파일을 참조하는 심볼릭 링크나 하나 이상의 하드 링크, 내지는 setuid, setgid, 끈적이 비트 세트를 설정한 +상태라도 압축 또는 압축 해제를 진행합니다. setuid, setgid, 끈적이 비트는 대상 파일에 복사하지 않습니다. +.IP \(bu 3 +\fB\-\-decompress\fP \fB\-\-stdout\fP 옵션을 같이 사용하는 상황에서 \fBxz\fP 명령이 원본 파일의 형식을 알아내지 못할 때, +원본 파일의 사본을 표준 출력으로 보냅니다. 이렇게 하면 \fBxzcat\fP \fB\-\-force\fP 명령을 \fBxz\fP 명령으로 압축하지 않은 +파일에 대해 \fBcat\fP(1) 을 사용하는 것처럼 사용할 수 있습니다. 참고로 나중에, \fBxz\fP에서 \fBxz\fP로 하여금 여러 형식의 +파일을 표준 출력으로 복사하는 대신 압축을 해제하도록 새 압축 파일 형식을 지원할 예정입니다. +\fB\-\-format=\fP\fI<형식>\fP 옵션은 \fBxz\fP 명령에 단일 파일 형식만 압축 해제하도록 제한할 때 사용할 수 +있습니다. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +파일 대신 표준 출력으로 압축 또는 압축 해제한 데이터를 기록합니다. \fB\-\-keep\fP를 생략했습니다. +.TP +\fB\-\-single\-stream\fP +처음 \fB.xz\fP 스트림만 압축 해제하며, 스트림에 뒤따라오는 나머지 입력 데이터는 조용히 무시합니다. 보통 뒤따라오는 쓰레기 값에 +대해서는 \fBxz\fP 에서 오류를 나타냅니다. +.IP "" +\fBxz\fP는 \fB.lzma\fP 파일 또는 원시 스트림에서 온 하나 이상의 스트림에 대해 압축 해제동작을 취하지 않지만, 이 옵션을 사용하면 +\fBxz\fP에서 \fB.lzma\fP 파일 또는 원시 스트림을 처리한 다음에 뒤따라오는 데이터를 무시하도록 합니다. +.IP "" +이 옵션은 동작 모드가 \fB\-\-decompress\fP 또는 \fB\-\-test\fP가 아니면 동작에 아무런 영향을 주지 않습니다. +.IP "" +\fBxz\fP 5.7.1alpha 부터는 \fB\-\-single\-stream\fP 옵션의 동작에 \fB\-\-keep\fP 동작이 들어갑니다. +.TP +\fB\-\-no\-sparse\fP +희소 파일을 만들지 않습니다. 기본적으로 일반 파일로 압축 해제할 경우 \fBxz\fP 에서는 압축 해제한 파일에 이진 0값이 길게 늘어질 +경우 희소 배열 파일을 만들려고 합니다. 표준 출력의 내용 길이만큼 연결한 일반 파일로 기록할 때도 동작하며 희소 파일을 만드는 동안 +아무런 문제가 나타나지 않게 각각의 추가 조건을 만족합니다. 희소 파일을 만들면 디스크 공간을 절약할 수 있으며 디스크 입출력을 줄여 +압축 해제 속도를 올릴 수 있습니다. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +압축할 때, 대상 파일의 접두사를 \fB.xz\fP 또는 \fB.lzma\fP 대신 \fI.suf\fP로 사용하십시오. 표준 출력으로 기록하지 않고 +원본 파일에 \fI.suf\fP 접두사가 붙어있으면, 경고를 나타내고 해당 파일을 건너뜁니다. +.IP "" +압축 해제할 때, \fI.suf\fP 접미사로 파일을 인식하기도 하고, \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, +\&\fB.lz\fP 접미사가 붙은 파일도 인식합니다. 원본 파일에 \fI.suf\fP 접미사가 붙어있으면, 해당 접미사를 제거하여 대상 파일 이름을 +알아냅니다. +.IP "" +원시 스트림 압축 및 압축 해제시(\fB\-\-format=raw\fP) 원시 스트림에 기본 접미사가 없기 때문에, 표준 출력으로 기록하지 않는 +한 접미사를 반드시 지정해야 합니다. +.TP +\fB\-\-files\fP[\fB=\fP\fI<파일>\fP] +\fI<파일>\fP에서 처리할 파일 이름을 읽습니다. \fI<파일>\fP을 생략하면 파일 이름은 표준 입력에서 +불러옵니다. 파일 이름은 개행 문자로 끝나야 합니다. 대시 문자(\fB\-\fP)는 일반 파일 이름으로 취급하며 표준 입력을 의미하지 +않습니다. 파일 이름을 명령행 인자로 지정하면, \fI<파일>\fP에서 파일 이름을 읽어들이기 전 해당 명령행 인자를 먼저 +처리합니다. +.TP +\fB\-\-files0\fP[\fB=\fP\fI<파일>\fP] +각 파일 이름이 널 문자로 끝나야 한다는 점만 제외하면 \fB\-\-files\fP[\fB=\fP\fI<파일>\fP] 옵션과 동일합니다. +. +.SS "기본 파일 형식 및 압축 옵션" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fI<형식>\fP +압축 또는 압축해제 파일 \fI<형식>\fP을 지정합니다: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +기본 값입니다. 압축할 때, \fBauto\fP는 \fBxz\fP의 기본 동작과 동일합니다. 압축을 해제할 때, 입력 파일 형식을 자동으로 +찾습니다. 참고로 원시 스트림(\fB\-\-format=raw\fP)의 경우 자동으로 찾을 수 없습니다. +.TP +\fBxz\fP +\&\fB.xz\fP 파일 형식으로 압축하거나, 압축 해제시 \fB.xz\fP 파일만 받아들입니다. +.TP +\fBlzma\fP, \fBalone\fP +이전 \fB.lzma\fP 파일 형식으로 압축하거나, 압축 해제시 \fB.lzma\fP 파일만 받아들입니다. \fBalone\fP 대체 명령은 LZMA +유틸리티 하위 호환성을 목적으로 제공합니다. +.TP +\fBlzip\fP +압축 해제시 \fB.lz\fP 파일만 받아들입니다. 압축은 지원하지 않습니다. +.IP "" +\&\fB.lz\fP 형식 버전 0과 1을 지원합니다. 버전 0파일은 \fBlzip\fP 1.3 이전에서만 만듭니다. 일반적이진 않지만 일부 파일의 +경우 이 형식의 원본 패키지로 보관한 파일을 찾을 수도 있습니다. 개인적으로 이 형식으로 압축한 오래된 개인 파일을 가지고 있을 수도 +있습니다. 형식 버전 0 압축 해제 지원은 \fBlzip\fP 1.18에서 제거했습니다. \fBlzip\fP 1.4 이후의 버전에서는 버전 1 +형식 파일을 만듭니다. +.TP +\fBraw\fP +원시 스트림으로 압축하거나 압축을 해제합니다(헤더 없음). 고급 사용자 전용입니다. 원시 스트림을 디코딩하려면, +\fB\-\-format=raw\fP 옵션을 사용하고 분명하게 필터 체인을 지정하여 컨테이너 헤더에 필요한 정보를 저장하게 끔 해야합니다. +.RE +.TP +\fB\-C\fP \fI<검사방식>\fP, \fB\-\-check=\fP\fI<검사방식>\fP +무결성 검사 방식을 지정합니다. 검사 방식은 \fB.xz\fP 파일에 저장하며 압축 해제 데이터를 계산합니다. 이 옵션은 \fB.xz\fP +형식으로 압축할 때만 효력이 있습니다: \fB.lzma\fP 형식은 무결성 겁사를 지원하지 않습니다. 무결성 검사는 \fB.xz\fP 파일 압축을 +풀었을 때에 검사합니다. +.IP "" +지원 \fI검사\fP 형식: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +어떤 경우에도 무결성 검사 계산을 수행하지 않습니다. 보통 바람직하지 못한 생각입니다. 데이터 무결성을 다른 방식으로라도 검증해야 +하는 상황이면 쓸만할 수 있습니다. +.TP +\fBcrc32\fP +IEEE\-802.3 (이더넷)의 다항 연산으로 CRC32를 계산합니다. +.TP +\fBcrc64\fP +ECMA\-182의 다항식 연산으로 CRC64를 계산합니다. 이 동작이 기본 동작이기 때문에 CRC32가 깨진 파일을 찾을 때보다는 좀 +낮은 편이며 속도 차이도 거의 없습니다. +.TP +\fBsha256\fP +SHA\-256 해시를 계산합니다. CRC32와 CRC64 보다는 좀 느립니다. +.RE +.IP "" +\&\fB.xz\fP 헤더 무결성은 항상 CRC32로 검증하빈다. 이를 바꾸거나 It is not possible to change or +disable it. +.TP +\fB\-\-ignore\-check\fP +압축 데이터를 압축해제할 경우 압축 데이터의 무결성 검증을 진행하지 않습니다. \fB.xz\fP 헤더의 CRC32 값은 그래도 여전히 보통 +방식으로 검증합니다. +.IP "" +\fB이 옵션이 정확히 무슨 동작을 하는지 알기 전에는 사용하지 마십시오.\fP 이 옵션을 사용하는 타당한 이유로: +.RS +.IP \(bu 3 +깨진 .xz 파일에서 데이터 복구를 시도합니다. +.IP \(bu 3 +압축 해제 속도를 늘립니다. SHA\-256 또는 압축 파일에 들어간 그 무언가를 엄청 빨리 처리합니다. 다른 방식으로 파일 무결성을 +검증해야 하는 목적이 아니라면 이 옵션을 사용하지 않는게 좋습니다. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +압축 사전 설정 수준을 선택합니다. 기본값은 \fB\-6\fP입니다. 다중 수준을 지정하면 가장 마지막 수준 옵션을 적용합니다. 개별 필터 +체인을 이미 지정했다면, 압축 사전 설정 수준 값을 설정할 때 개별 필터 체인을 정리합니다. +.IP "" +사전 설정간 차이는 \fBgzip\fP(1)과 \fBbzip2\fP(1)을 사용할 때보다 더 비중을 차지합니다. 선택한 압축 설정은 압축 해제시 +필요한 메모리 사용량을 셜정하므로 사전 설정 수준 값을 너무 높게 지정하면 RAM 용량이 적은 오래된 시스템에서 파일 압축 해제시 실패할 +수 있습니다. 게다가, \fBgzip\fP(1) 과 \fBbzip2\fP(1)에서 처럼 종종 \fB모든 동작에 \-9를 몰래 활용하는건 바람직하지 않습니다\fP. +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +동작이 빠른 사전 설정 부류입니다. \fB\-0\fP은 때로는 \fBgzip \-9\fP 명령보다 압축율이 훨씬 우수하면서도 더 빠릅니다. 더 큰 +값은 보통 \fBbzip2\fP(1) 명령과 비교했을 떄 압축 결과가 압축 데이터에 따라 달라지더라도, 비교할 법한 속도 또는 더 나은 +압축율을 보입니다. +.TP +\fB\-4\fP ... \fB\-6\fP +오래된 시스템에서 조차도 압축 해제 프로그램의 적절한 메모리 사용량을 보이면서 양호하거나 최적의 압축율을 보여줍니다. \fB\-6\fP 옵션은 +압축 해제시 메모리 사용량이 16MiB 밖에 안되기 때문에 파일을 배포할 때 최적의 선택인 기본 값입니다. (\fB\-5e\fP 또는 +\fB\-6e\fP도 역시 고려할 만합니다. \fB\-\-extreme\fP을 참고하십시오.) +.TP +\fB\-7 ... \-9\fP +\fB\-6\fP과 비슷하지만 압축 및 압축 해제시 요구 메모리 사용량이 더 높습니다. 압축 파일이 각각 8MiB, 16MiB, 32MiB +보다 클 경우에만 쓸만한 옵션입니다. +.RE +.IP "" +동일한 하드웨어에서, 압축 해제 속도는 압축한 데이터의 초당 정적 바이트 처리 수의 어림 평균입니다. 다시 말해, 압축율을 더 올리면, +압축 해제 속도도 역시 올라갑니다. 이는 곧 초당 비압축 데이터 출력 양이 달라질 수 있단 뜻입니다. +.IP "" +다음 표에 사전 설정 기능을 정리했습니다: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Preset;DictSize;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +컬럼 설명: +.RS +.IP \(bu 3 +DictSize는 LZMA2 딕셔너리 크기입니다. 압축 해제 파일의 크기보다 딕셔너리에서 사용하는 낭비 메모리 용량입니다. 실제로 +필요하지 않은 \fB\-7\fP ... \fB\-9\fP 사전 설정값을 피해야 하는 적절한 이유이기도 합니다. \fB\-6\fP 이하에서는 소모 메모리 양이 +충분히 적거나 따로 신경쓸 필요가 없습니다. +.IP \(bu 3 +CompCPU는 압축 속도에 영향을 주는 LZMA2 설정의 단순화 표기 값입니다. 딕셔너리 크기는 속도에도 영향을 주기 때문에 +CompCPU는 \fB\-6\fP ... \fB\-9\fP 수준값과 동일한데, 고수준 값은 여전히 조금 더 느려질 수 있습니다. 느려지는 만큼 +압축율은 가능한 한 더 좋아집니다. \fB\-\-extreme\fP을 참고하십시오. +.IP \(bu 3 +CompMem은 단일\-스레드 모드에서 필요한 압축 프로그램의 메모리 점유 용량입니다. \fBxz\fP 버전에 따라 다를 수 있습니다. +.IP \(bu 3 +DecMem은 압축 해제 프로그램의 메모리 점유용량입니다. 이는 곧, 압축 해제 프로그램에서 필요한 메모리 사용량을 압축 설정에서 +결정한다는 의미가 들어있습니다. 정확한 압축 해제 프로그램의 메모리 사용량은 LZMA2 딕셔너리 크기 보다는 조금 많지만 테이블의 값은 +MiB 용량으로 완전히 반올림한 값입니다. +.RE +.IP "" +다중\-스레드 모드에서 필요한 메모리 용량은 단일\-스레드 모드보단 약간 더 많습니다. \fB\-\-block\-size\fP 기본값에 따라, 각 +스레드에서는 3*3*딕셔녀리_크기 + 압축시_메모리용량 또는 압축_해제시_메모리용량 정도가 필요합니다. 예를 들면, 스레드 넷에 사전 +설정 옵션 \fB\-6\fP을 사용한다면, 660\(en670 MiB 메모리 용량이 필요합니다. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +기대하는 만큼의 좀 더 나은 압축율을 확보하려 선택한 압축 사전 설정 수준의 느린 변형 옵션을 사용하지만, 재수 없는 와중에 골로 가는 +경우가 생기기도 합니다. 압축 해제 프로그램의 메모리 사용에는 영향을 주지 않지만, 압축 프로그램의 메모리 사용량은 \fB\-0\fP +\&... \fB\-3\fP 사전 설정 수준에서 약간 더 올라갈 뿐입니다. +.IP "" +4MiB와 8MiB 두 가지 딕셔너리 용량 설정이 있기 때문에 \fB\-3e\fP 와 \fB\-5e\fP 사전 설정을 (CompCPU 수치를 낮춰서) +각각 \fB\-4e\fP 와 \fB\-6e\fP 보다 약간 더 빠르게 설정할 수 있습니다. 이런 식으로 두 사전 설정이 동일하지 않습니다. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Preset;DictSize;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +예를 들면, 8MiB 딕셔너리를 활용하는 네가지 사전 설정이 있다고 할 때, 빠른 순으로 설정을 나열하자면, \fB\-5\fP, \fB\-6\fP, +\fB\-5e\fP, \fB\-6e\fP 입니다. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +이 옵션은 \fB\-0\fP 과 \fB\-9\fP의 별칭으로 각각 오해할 수 있습니다. LZMA 유틸리티의 하위 호환성을 목적으로 제공합니다. 이 +옵션 사용은 피하십시오. +.TP +\fB\-\-block\-size=\fP\fI<크기>\fP +\&\fB.xz\fP 형식으로 압축할 때, 입력 데이터를 \fI<크기>\fP 바이트 블록으로 입력 데이터를 쪼갭니다. 각각의 블록은 +다중\-스레드 방식으로 처리할 수 있고 임의 접근 압축 해제 가능성을 제한할 수 있게 개별적으로 압축 처리합니다. 이 옵션은 보통 +다중\-스레드 모드에서 기본 블록 크기를 지정할 때 사용하지만, 단일\-스레드 모드에서도 사용할 수 있습니다. +.IP "" +다중\-스레드 모드에서는 약 3배 용량의 \fI<크기>\fP 바이트만큼 각 스레드 별로 입출력 버퍼링용 공간을 할당합니다. 기본 +\fI<크기>\fP는 LZMA2 딕셔너리 크기 또는 1MiB 중 가장 큰 쪽의 세 배입니다. 보통 적절한 값으로 LZMA2 +딕셔너리 크기 또는 최소한 1MiB 용량의 2\(en4배입니다. LZMA2 딕셔너리 크기보다 작은 \fI<크기>\fP는 램의 +소모적 사용 공간으로 할당하는데 LZMA2 딕셔너리 버퍼를 할당한 용량 크기 전체를 다 사용하지 않기 때문입니다. 다중\-스레드 모드에서 +블록 크기는 블록 헤더에 저장하며, 이 크기 정보는 다중\-스레드 압축 해제시 필요합니다. +.IP "" +단일\-스레드 모드에서는 기본적으로 블록 쪼개기를 하지 않습니다. 이 옵션을 설정한다고 해서 메모리 사용에 영향을 주지는 않습니다. +블록 헤더에 크기 정보를 저장하지 않기 때문에 단일\-스레드 모드에서 만든 파일은 다중\-스레드 모드에서 만든 파일과 동일하지 않습니다. +크기 정보의 누락은 또한 \fBxz\fP에서 다중\-스레드 모드로 압축 해제를 진행할 수 없음을 의미하기도 합니다. +.TP +\fB\-\-block\-list=\fP\fI<항목>\fP +\&\fB.xz\fP 형식으로 압축할 때, 압축하지 않은 데이터로 부터 일정 간격 이후에 새 블록 처리를 시작합니다. +.IP "" +\fI<항목>\fP은 쉼표로 구분한 목록으로 지정합니다. 각 항목은 콜론 (\fB:\fP)으로 구분한 0부터 9까지의 추가 필터 +체인 번호 값으로 이루어져 있으며, 압축하지 않은 데이터의 크기 값이 필요합니다. 항목을 생략하면(둘 이상의 쉼표 연속 표기) 이전 +항목의 크기와 필터를 활용하겠다는 함축 의미를 넣을 수 있습니다. +.IP "" +입력 파일이 \fI<항목>\fP 크기의 합보다 크면, 마지막 항목을 파일의 끝까지 반복합니다. 특별히 \fB0\fP 값을 마지막 +값으로 사용하여 파일 나머지 부분을 단일 블록으로 인코딩해야 한다는 의미를 나타낼 수도 있습니다. +.IP "" +\fB\-\-filters1=\fP\fI<필터>\fP \&...\& \fB\-\-filters9=\fP\fI<필터>\fP 옵션 조합으로 +각 블록별 별도 필터 체인을 지정할 수 있습니다. 이 옵션은 1\(en9번 필터 체인을 지정합니다. 필터 체인 0번은 필터 체인을 +지정하지 않았을 때와 동일한 기본 필터 체인으로 참조할 수 있습니다. 필터 체인 식별 번호는 비 압축 크기 앞에 콜론(\fB:\fP)을 붙여 +사용할 수 있습니다. 예를 들면, \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP 옵션을 +지정했을 경우 다음 규칙대로 블록을 만듭니다: +.RS +.IP \(bu 3 +\fB\-\-filters1\fP 필터 체인에서는 2MiB 입력을 +.IP \(bu 3 +\fB\-\-filters3\fP 필터 체인에서는 2MiB 입력을 +.IP \(bu 3 +\fB\-\-filters2\fP 필터 체인에서는 4MiB 입력을 +.IP \(bu 3 +\fB\-\-filters2\fP 필터 체인에서는 4MiB 입력을 +.IP \(bu 3 +기본 필터 체인에서는 2MiB 입력을 +.IP \(bu 3 +입력이 끝나기 전의 모든 블록에는 기본 필터 체인과 4MiB 입력을 적용합니다. +.RE +.IP "" +인코더 블록 크기를 초과하는 크기 값을 지정하면(스레드 모드 기본값 또는 \fB\-\-block\-size=\fP\fI<크기>\fP +옵션으로 지정한 값), 인코더는 \fI<크기>\fP 지정 용량 범위는 유지하면서 추가 블록을 만듭니다. 예를 들면 +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP 옵션을 지정하고 +입력 파일을 80MiB 용량으로 전달하면, 각각 5, 10, 8, 10, 2, 10, 10, 4, 10, 10, 1 MiB 용량을 +차지하는 블록 11개를 결과물로 내줍니다. +.IP "" +다중\-스레드 모드에서 블록 크기는 블록 헤더에 저장합니다. 단일\-스레드 모드에서는 저장하지 않기 때문에 인코딩 처리한 출력은 +다중\-스레드 모드의 출력 결과물과는 다릅니다. +.TP +\fB\-\-flush\-timeout=\fP\fI<제한시간>\fP +압축할 때, 이전 데이터를 소거하고 다음 입력을 블록 단위로 더 읽는데 \fI<제한시간>\fP 밀리초(양의 정수값)가 지났을 +경우, 대기중이던 모든 입력 데이터를 인코더에서 소거한 다음 출력 스트림에 전달합니다. 이런 동작은 네트워크로 스트리밍한 데이터를 +\fBxz\fP로 압축할 때 쓸만합니다. \fI<제한시간>\fP 값을 적게 지정하면 적은 지연 시간에 데이터를 받아낼 수 있지만 +\fI<제한시간>\fP 값을 크게 하면 압축율을 높일 수 있습니다. +.IP "" +이 기능은 기본적으로 꺼져있습니다. 이 옵션을 한번 이상 지정하면, 마지막 옵션의 값대로 동작합니다. 특별히 +\fI<제한시간>\fP 값을 \fB0\fP으로 설정하면 이 설정을 완전히 끌 수 있습니다. +.IP "" +이 기능은 POSIX 시스템이 아닌 곳에서는 사용할 수 없습니다. +.IP "" +.\" FIXME +\fB이 기능은 여전히 시험중입니다\fP. 현재로서는, \fBxz\fP 버퍼링 처리 방식 때문에 \fBxz\fP의 실시간 스트림 압축 해제 기능 활용은 +적절하지 않습니다. +.TP +\fB\-\-no\-sync\fP +원본 파일을 제거하기 전까지는 스토릿지 장치에 대상 파일과 디렉터리를 동기화하지 않습니다. 작은 여러 파일을 압축하거나 압축해제할 때 +성능을 개선할 수 있습니다. 그러나, 삭제 과정을 진행한 다음 시스템이 바로 치명적인 오류가 나타난다면, 대상 파일을 스토릿지 장치에 +저장하지 않았지만 삭제 동작이 이루어졌을 수도 있습니다. 이 경우 원본 파일 뿐만 아니라 대상 파일도 나타나지 않습니다. +.IP "" +이 옵션은 \fBxz\fP 프로그램이 원본 파일을 삭제할 때만 동작합니다. 다른 경우에는 전혀 동기화가 이루어지지 않습니다. +.IP "" +동기화 동작과 \fB\-\-no\-sync\fP 옵션은 \fBxz\fP 5.7.1alpha에 추가했습니다. +.TP +\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP +압축 수행시 메모리 사용 한계를 지정합니다. 이 옵션을 여러번 지정하면 마지막 값을 취합니다. +.IP "" +압축 설정이 \fI<제한용량>\fP을 초과하면, \fBxz\fP는 설정 값의 하향 조정을 시도하여 한계 값을 더이상 넘치지 않게 하고 +자동 조절을 끝냈다는 알림을 표시합니다. 조정은 다음 순서대로 진행합니다. 스레드 수를 줄입니다. 다중\-스레드 모드에서 스레드 하나의 +할당 한계치가 \fI<제한용량>\fP을 넘으면 단일\-스레드 모드로 전환합니다. 그 다음 마지막으로 LZMA2 딕셔너리 크기를 +줄입니다. +.IP "" +\fB\-\-format=raw\fP 또는 \fB\-\-no\-adjust\fP 미지정 상황에서 압축할 때, 압축 데이터 출력에 영향을 주지 않고 스레드 +처리 수만 줄일 수 있습니다. +.IP "" +\fI<제한용량>\fP 값이 아래 설명한 조건에 맞지 않으면, 오류가 나타나고 \fBxz\fP 명령은 종료 상태 1번을 반환하며 +빠져나갑니다. +.IP "" +\fI<제한용량>\fP 값은 여러 방식으로 지정할 수 있습니다: +.RS +.IP \(bu 3 +\fI<제한용량>\fP 값은 바이트 용량 절대값입니다. 정수 값을 사용하되 \fBMiB\fP와 같은 접미사를 사용하는게 좋습니다. +예: \fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +\fI<제한용량>\fP 값은 총 물리 메모리(RAM) 용량의 백분율로 지정할 수도 있습니다. 다른 컴퓨터끼리 공유하는 셸 +초기화 스크립트의 \fBXZ_DEFAULTS\fP 환경 변수에 값을 설정할 때 특히 쓸만합니다. 이런 방식으로 설정하면 시스템의 메모리 설치 +용량에 따라 자동으로 늘어납니다. 예: \fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +\fI<제한용량>\fP 값은 \fB0\fP 기본값으로 설정하여 초기화할 수 있습니다. 현재로서는 \fI<제한용량>\fP +값이 \fImax\fP(최대) (메모리 사용 한계 없음) 인 상태와 동일합니다. +.RE +.IP "" +\fBxz\fP 32비트 버전에서는 몇가지 특별한 경우가 있습니다. \fI<제한용량>\fP 값이 \fB4020MiB\fP를 넘으면 +\fI<제한용량>\fP을 \fB4020MiB\fP로 고정합니다. MIPS32에서는 \fB2000MiB\fP로 대신 고정합니다. +(\fB0\fP과 \fBmax\fP는 이 경우에 해당하지 않습니다. 압축 해제시 비슷한 기능은 없습니다.) 이 경우 32비트 실행 파일이 +4GiB(MIPS32의 경우 2GiB) 주소 영역에 접근할 때 매우 용이하며, 다른 경우에는 원하는대로 문제를 일으키지 않습니다. +.IP "" +\fB메모리 활용\fP 섹션도 참고하십시오. +.TP +\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP +압축 해제시 메모리 사용 한계 용량을 설정합니다. \fB\-\-list\fP 모드에도 영향을 줍니다. \fI<제한용량>\fP을 넘기지 +않고서는 동작이 진행이 안될 경우, \fBxz\fP 에서는 오류를 나타내고 파일 압축 해제를 실패로 +간주합니다. \fI<제한용량>\fP을 지정하는 가능한 방법에 대해서는 +\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션을 참고하십시오. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP +다중\-스레드 모드 압축 해제시 메모리 사용 한계 용량을 설정합니다. 스레드 수에 영향을 줄 수도 있습니다. \fBxz\fP에서 파일 압축 +해제를 거부하게 하진 않습니다. \fI<제한용량>\fP 수치가 다중\-스레드로 처리하기에 너무 낮다면, +\fI<제한용량>\fP 값을 무시하고 \fBxz\fP 동작을 단일\-스레드 모드로 계속 진행합니다. 참고로 +\fB\-\-memlimit\-decompress\fP 옵션도 사용하면, 단일\-스레드 모드와 다중\-스레드 모드 두 경우에 모두 적용하기에, +다중\-스레드 모드에 적용할 \fI<제한용량>\fP 값은 \fB\-\-memlimit\-decompress\fP에 설정하는 제한 값보다 더 +크면 안됩니다. +.IP "" +다른 메모리 사용 용량 제한 옵션과는 달리, \fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP 옵션은 +시스템별 기본 \fI<제한용량>\fP 값을 지닙니다. 현재 설정 값은 \fBxz \-\-info\-memory\fP 명령으로 확인해볼 수 +있습니다. +.IP "" +이 옵션과 기본 값은 한계 값을 주지 않으면 스레드 기반 압축 해제 프로그램이 일부 입력 파일에 대해 정신나간 수준의 메모리 용량을 +할당해서 동작이 끝나버릴 수 있습니다. 기본 \fI<제한용량>\fP이 시스템의 사양에 비해 낮다면, +\fI<제한용량>\fP 값을 자유롭게 올리시되, \fBxz\fP 에서 적은 스레드 수에도 메모리 공간 할당을 시도하는 만큼, 입력 +파일에 적절한 수준으로 가용 RAM 용량을 넘는 큰 값을 설정하지 마십시오. 메모리나 스와핑 영역 공간이 줄어들면 압축해제 성능을 +개선하지 못합니다. +.IP "" +\fI<제한용량>\fP 값을 지정하는 가능한 방법을 보려면 +\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP 옵션을 참고하십시오. \fI<제한용량>\fP 값을 +\fB0\fP으로 설정하면 \fI<제한용량>\fP 값이 시스템 지정 기본값으로 바뀝니다. +.TP +\fB\-M\fP \fI<제한용량>\fP, \fB\-\-memlimit=\fP\fI<제한용량>\fP, \fB\-\-memory=\fP\fI<제한용량>\fP +\fB\-\-memlimit\-compress=\fP\fI<제한용량>\fP +\fB\-\-memlimit\-decompress=\fP\fI<제한용량>\fP +\fB\-\-memlimit\-mt\-decompress=\fP\fI<제한용량>\fP 지정과 동일합니다. +.TP +\fB\-\-no\-adjust\fP +압축 출력 결과에 영향을 주는 설정을 조정하지 않고는 메모리 사용 용량 제한 조건이 맞지 않으면 오류를 표시하고 빠져나갑니다. 이 +옵션은 \fBxz\fP가 다중\-스레드 모드에서 단일\-스레드 모드로 전환하고 LZMA2 딕셔너리 크기를 줄이는 동작을 막아줍니다. 심지어 이 +옵션을 사용하면 메모리 사용 한계를 만족하도록 스레드 수를 줄여 압축 결과물 출력에 영향이 가지 않게 합니다. +.IP "" +원시 스트림(\fB\-\-format=raw\fP)을 만들 떄 자동 조정은 항상 꺼집니다. +.TP +\fB\-T\fP \fI<스레드수>\fP, \fB\-\-threads=\fP\fI<스레드수>\fP +활용할 작업 스레드 수를 지정합니다. \fI<스레드수>\fP 값을 \fB0\fP 값으로 설정하면, \fBxz\fP는 시스템에서 지원하는 +최대 프로세서 스레드 수를 모두 확보합니다. 실제 스레드 수는 입력 파일이 주어진 설정대로 스레드 처리를 할 만큼 그렇게 크지 않을 +경우, 내지는 더 많은 스레드를 사용했을 때 메모리 사용량 한계를 초과할 경우 \fI<스레드수>\fP 보다 적을 수 있습니다. +.IP "" +단일\-스레드와 다중\-스레드 압축 프로그램은 다른 출력 결과물을 냅니다. 단일\-스레드 압축 프로그램은 작은 파일 크기 결과물을 내놓지만, +다중\-스레드 압축 프로그램의 경우 다중\-스레드 압축 프로그램에서 내놓은 결과물은 다중\-스레드로만 압축을 해제할 수 있습니다. +\fI<스레드수>\fP를 \fB1\fP로 설정하면 단일\-스레드 모드를 사용합니다. \fI<스레드수>\fP를 \fB0\fP과 다른 +값으로 설정하면, 시스템에서 실제로 하드웨어 스레드가 1개만 지원한다 하더라도, 다중\-스레드 압축 프로그램을 사용합니다. (\fBxz\fP +5.2.x에서는 이 경우 단일\-스레드 모드를 활용합니다.) +.IP "" +단일\-스레드로 다중\-스레드 모드를 사용하려면, \fI<스레드수>\fP를 \fB+1\fP로 설정하십시오. \fB+\fP 접두사는 \fB1\fP +이외의 값에는 영향을 주지 않습니다. 메모리 사용량 한계 설정은 \fBxz\fP을 \fB\-\-no\-adjust\fP 옵션을 쓰기 전까지는 +단일\-스레드로 전환하게 합니다. \fB+\fP 접두사 지원은 \fBxz\fP 5.4.0에 추가했습니다. +.IP "" +자동 스레드 수를 요청했고 메모리 사용 한계를 지정하지 않았다면, 시스템에 맞게끔 가능한 스레드 수를 제한하는 기본 소프트 제한 값을 +사용합니다. 스레드 수가 한개가 되면 무시하는 이런 개념이 소프트 제한이기에, \fBxz\fP로 하여금 압축 동작 및 압축 해제 동작 수행시 +멈추지 않습니다. 이 가본 소프트 제한 값은 \fBxz\fP 실행 도중 다중\-스레드 모드에서 단일\-스레드 모드로 바뀌게 하지는 않습니다. +활성 제한 값은 \fBxz \-\-info\-memory\fP 명령으로 볼 수 있습니다. +.IP "" +현재 스레딩 처리 방식은 입력을 블록 단위로 쪼개고 각각의 블록을 독립적으로 압축하는 동작을 취합니다. 기본 블록 크기는 압축 수준에 +따라 다르며 \fB\-\-block\-size=\fP\fI<크기>\fP 옵션으로 재지정할 수 있습니다. +.IP "" +스레드 압축 해제 방식은 여러 블록이 블록 헤더에 넣은 크기 정보와 함께 들어간 파일에만 동작합니다. 다중\-스레드 모드에서 압축한 +충분히 큰 모든 파일은 이 조건에 만족하지만, 단일\-스레드 모드에서 압축한 파일은 +\fB\-\-block\-size=\fP\fI<크기>\fP 옵션을 지정하더라도 조건에 만족하지 않습니다. +.IP "" +\fI스레드\fP 기본 값은 \fB0\fP입니다. \fBxz\fP 5.4.x 이전의 기본값은 \fB1\fP입니다. +. +.SS "개별 압축 필터 체인 설정" +개별 필터 체인은 사전 설정에 엮인 설정에 의존하는 대신 압축 설정을 세부적으로 하나하나 설정할 수 있게 합니다. 개별 필터 체인을 +지정하면, 명령행에 앞서 지정한 사전 설정 옵션(\fB\-0\fP \&...\& \fB\-9\fP 과 \fB\-\-extreme\fP)은 무시합니다. 사전 +설정 옵션을 하나 이상의 필터 체인 옵션 다음에 지정하면, 새 사전 설정을 취하며, 앞서 지정한 개별 필터 체인 옵션은 무시합니다. +.PP +필터 체인은 명령행 파이핑에 비교할 수 있습니다. 압축할 때, 압축하지 않은 입력을 첫번째 필터로 놓고, 출력 대상(이 있으면)을 다음 +필터로 지정합니다. 최종 필터의 출력은 압축 파일로 기옥합니다. 체인의 최대 필터 수는 4이지만, 필터 체인상 필터 갯수는 보통 +1~2개입니다. +.PP +수많은 필터가 필터 체인 상에서 제약점을 가지고 있습니다. 일부 필터는 체인의 마지막 필터로만 동작하며, 일부 다른 필터는 마지막이 아닌 +필터로, 어떤 동작은 체인의 어떤 위치에든 둡니다. 필터에 따라, 이 제한은 필터 설계를 따르거나 보안 문제를 막기 위해 존재하기도 +합니다. +.PP +개별 필터 체인은 두가지 방식으로 지정할 수 있습니다. \fB\-\-filters=\fP\fI<필터>\fP와 +\fB\-\-filters1=\fP\fI<필터>\fP \&...\& \fB\-\-filters9=\fP\fI<필터>\fP 옵션으로 +liblzma 필터 문자열 문법에 따라 한가지 옵션을 필터 체인 전체를 지정할 수 있습니다. 대신, 하나 이상의 개별 필터 옵션을 +원하는 필터 체인 순서대로 지정할 수도 있습니다. 이 말인 즉슨, 개별 필터 옵션의 순서가 중요하단 뜻입니다! 원시 스트림을 디코딩할 +때(\fB\-\-format=raw\fP), 압축했을 때 지정했던 필터와 같은 순서로 필터 체인을 지정해야 합니다. 전체 체인 +옵션(\fB\-\-filters=\fP\fI<필터>\fP) 보다 우선 지정한 개별 필터 또는 사전 설정 옵션은 까먹을 수도 있습니다. +전체 체인 옵션 다음에 개별 필터를 지정할 경우 필터 체인의 동작을 무효로 합니다. +.PP +필터는 쉼표로 구분하는 필터별 \fI<옵션>\fP이 있습니다. \fI<옵션>\fP에 추가로 입력한 쉼표는 +무시합니다. 모든 옵션 값에는 기본값이 있어, 값을 바꾸려면 지정해야합니다. +.PP +전체 필터 체인과 \fI<옵션>\fP을 보려면 \fBxz \-vv\fP (\fB\-\-verbose\fP 두 번)명령을 사용하십시오. 이 +명령은 사전 설정이 사용하는 필터 체인 옵션도 볼 수 있습니다. +.TP +\fB\-\-filters=\fP\fI<필터>\fP +전체 필터 체인 또는 사전 설정을 단일 옵션으로 지정합니다. 각 필터는 공백 문자 또는 대시 문자 두번 입력(\fB\-\-\fP)으로 +구분합니다. 셸 명령행에서 \fI필터\fP는 따옴표로 감싸서 단일 옵션으로 해석하도록 해야 합니다. \fI옵션\fP을 표기하려면 \fB:\fP 또는 +\fB=\fP을 활용하십시오. 사전 설정 앞에 \fB\-\fP를 붙일 수 있고 0개 또는 하나 이상의 플래그를 붙일 수 있습니다. 유일하게 +지원하는 플래그는 \fB\-\-extreme\fP과 동일한 \fBe\fP입니다. +.TP +\fB\-\-filters1\fP=\fI<필터>\fP ... \fB\-\-filters9\fP=\fI<필터>\fP +\fB\-\-block\-list\fP와 사용할 수 있는 추가 필터 체인을 최대 9개까지 지정합니다. +.IP "" +예를 들어 텍스트 파일과 실행 파일의 아카이브를 압축할 때 실행 부분에 BCJ 필터 체인을 사용하고 텍스트 부분은 LZMA2 필터를 +사용할 수 있습니다. +.TP +\fB\-\-filters\-help\fP +\fB\-\-filters\fP와 \fB\-\-filters1=\fP\fI<필터>\fP \&...\& +\fB\-\-filters9=\fP\fI<필터>\fP 옵션의 사전 설정 필터와 개별 설정 필터 체인을 지정하는 방법을 설명하는 도움말 +메시지를 출력하고 완전히 빠져나갑니다. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fI<옵션>\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fI<옵션>\fP] +.PD +LZMA1 또는 LZMA2 필터를 필터 체인에 추가합니다. 이 필터는 필터 체인의 마지막 요소로만 사용할 수 있습니다. +.IP "" +LZMA1은 고전 필터로, LZMA1만 지원하는 고전 \fB.lzma\fP 파일 형식에서만 지원합니다. LZMA2는 LZMA1의 업데이트 +버전으로 LZMA1의 실질적 문제를 해결했습니다. \fB.xz\fP 형식은 LZMA2 필터를 사용하며 LZMA1 필터는 전적으로 지원하지 +않습니다. 압축 속도와 압축율은 LZMA1과 LZMA2가 실질적으로 동일합니다. +.IP "" +LZMA1과 LZMA2는 동일한 \fI<옵션>\fP 집합을 공유합니다: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fI<사전설정>\fP +LZMA1 또는 LZMA2의 모든 \fI<옵션>\fP을 \fI<사전설정>\fP으로 +초기화합니다. \fI<사전설정>\fP 값은 정수 값으로 이루어져 있으며, 사전 설정에 변형을 줄 떄 단일 문자가 따라올 수도 +있습니다. 정수 값은 \fB0\fP에서 \fB9\fP 까지이며, 명령행 옵션에서 \fB\-0\fP \&...\& \fB\-9\fP로 대응합니다. 변형 옵션으로 +지원하는 문자는 현재 \fBe\fP 뿐이며, \fB\-\-extreme\fP에 대응합니다. \fI<사전설정>\fP 값을 지정하지 않으면, +LZMA1 또는 LZMA2 기본값을 사전 설정 \fB6\fP에서 가져온 \fI<옵션>\fP으로 취합니다. +.TP +\fBdict=\fP\fI<크기>\fP +딕셔너리(기록 버퍼) \fI<크기>\fP는 최근 처리한 비압축 데이터를 바이트 단위로 메모리에 얼마나 유지하는지 나타냅니다. +알고리즘은 비압축 데이터상 바이트 시퀀스(일치 항목) 반복 탐색을 시도하며, 해당 부분을 딕셔너리의 현재 참조로 치환합니다. 딕셔너리가 +크면 일치하는 항목을 찾을 기회가 더 많아집니다. 따라서, 딕셔너리 \fI<크기>\fP를 더욱 크게 설정하면 압축율을 증가할 +수는 있지만, 압축하지 않은 파일보다 딕셔너리가 크면 메모리 낭비율이 올라갑니다. +.IP "" +보통 딕셔너리 \fI<크기>\fP는 64KiB 에서 64MiB 정도 됩니다. 최소 4KiB 입니다. 압축시 최대 용량은 현재 +1.5GiB(1536MiB)로 나타납니다. 압축 해제 프로그램에도 4GiB 미만으로 딕셔너리 크기를 이미 지원하며 4GiB 라는 수치는 +LZMA1과 LZMA2 스트림 형식의 최대값입니다. +.IP "" +딕셔너리 \fI<크기>\fP와 검색기(\fImf\fP)는 LZMA1 또는 LZMA 인코더의 메모리 사용량을 함께 결정합니다. +동일한(또는 더 큰) 딕셔너리 \fI<크기>\fP가 데이터를 압축했을 때만큼 압축 해제할 떄 필요하기 때문에, 디코더의 메모리 +사용량은 압축할 때의 딕셔너리 크기로 결정합니다. \fB.xz\fP 헤더에는 딕셔너리 \fI<크기>\fP를 2^\fIn\fP 또는 +2^\fIn\fP + 2^(\fIn\fP\-1) 으로 저장하기에, 이 \fI<크기>\fP 값을 압축할 때 선호하는 편입니다. 다른 +\fI<크기>\fP 값은 \fB.xz\fP 헤더에 저장할 때 반올림합니다. +.TP +\fBlc=\fP\fIlc\fP +리터럴 컨텍스트 비트 수를 지정합니다. 최소 값은 0이고 최대 값은 4입니다. 기본 값은 3입니다. 추가로, \fIlc\fP 값과 +\fIlp\fP 값의 합은 4를 넘으면 안됩니다. +.IP "" +조건이 일치하지 않아 인코딩할 수 없는 모든 바이트는 리터럴로 인코딩합니다. 이 말인 즉슨, 간단히 8비트 바이트로서의 리터럴을 한번에 +하나씩 인코딩합니다. +.IP "" +리터럴 코딩을 할 때 이전 비압축 바이트와 다음 바이트와의 관련성을 가진 가장 많은 \fIlc\fP 비트 수를 가정합니다. 예를 들면, 보통 +영문 문장의 경우 대문자 다음에 종종 소문자가 오고, 소문자 다음에 다른 소문자가 따라옵니다. US\-ASCII 문자 세트에서는 가장 긴 +비트 3개는 대문자에 대해 010, 소문자에 대해 011입니다. \fIlc\fP 값이 최소한 3이면, 리터럴 코딩시 비압축 데이터에 대해 +이런 속성의 장점을 취할 수 있습니다. +.IP "" +(어쨌거나) 기본값 (3)은 보통 적절합니다. 최대 압축을 원한다면 \fBlc=4\fP 값을 시험해보십시오. 때로는 약간 도움이 되기도 +하겠지만, 오히려 결과가 안좋을 수도 있습니다. 결과가 엄한 방향으로 간다면, \fBlc=2\fP 값도 시험해보십시오. +.TP +\fBlp=\fP\fIlp\fP +리터럴 위치 비트 수를 지정하빈다. 최소 값은 0이고 최대 값은 4입니다. 기본 값은 0입니다. +.IP "" +\fIlp\fP 값은 리터럴 인코딩 진행시 비압축 데이터 정렬 방식 고려에 영향을 줍니다. 정렬 방식에 대한 자세한 정보는 하단 \fIpb\fP를 +참고하십시오. +.TP +\fBpb=\fP\fIpb\fP +위치 비트 수를 지정합니다. 최소 값은 0이며 최대 값은 4입니다. 기본값은 2입니다. +.IP "" +\fIpb\fP 값은 보통 압축하지 않은 데이터에 어떤 정렬 방식을 고려하느냐에 영향을 줍니다. 기본적으로 4바이트 +정렬(2^\fIpb\fP=2^2=4)을 의미하는데, 이보다 더 나은 추측 값이 없어서 종종 최적의 선택으로 간주합니다. +.IP "" +정렬 상태를 알지 못할 경우, \fIpb\fP 설정 값이 파일 크기를 조금 줄일 수 있습니다. 예를 들면, 텍스트 파일이 단일 바이트 단위로 +정돈된 상태(US\-ASCII, ISO\-8859\-*, UTF\-8)라면, \fBpb=0\fP 설정 값으로 압축율을 조금 개선할 수 있습니다. +UTF\-16 텍스트의 경우, \fBpb=1\fP 설정 값이 좋은 선택입니다. 정렬 바이트가 3 바이트 같은 홀수 바이트일 경우, +\fBpb=0\fP 설정 값이 최적의 선택일지도 모릅니다. +.IP "" +가정 정렬을 \fIpb\fP 값과 \fIlp\fP 값으로 조정하긴 하지만, LZMA1과 LZMA2는 여전히 16바이트 정렬 방식으로 선호합니다. +LZMA1 또는 LZMA2로 종종 압축하는 파일 형식이라고 하면 고려해볼만 합니다. +.TP +\fBmf=\fP\fImf\fP +일치 검색기는 인코더 속도, 메모리 사용량, 압축율에 주된 영향을 줍니다. 보통 해시 체인 검색기는 이진 트리 검색기보다 빠르긴 +합니다. 기본 값은 \fI<사전설정>\fP에 따라 다릅니다. 0은 \fBhc3\fP을, 1\(en3은 \fBhc4\fP를, 나머지는 +\fBbt4\fP를 활용합니다. +.IP "" +다음 검색 필터를 지원합니다. 메모리 사용 공식은 \fIdict\fP 값이 2의 승수일 경우 실제에 가까운 근사치입니다. +.RS +.TP +\fBhc3\fP +2바이트, 3바이트 해싱 체인 +.br +\fInice\fP 최소값: 3 +.br +메모리 사용: +.br +\fIdict\fP * 7.5 (조건: \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 5.5 + 64 MiB (조건: \fIdict\fP > 16 MiB) +.TP +\fBhc4\fP +2바이트, 3바이트, 4바이트 해싱 체인 +.br +\fInice\fP 최소값: 4 +.br +메모리 사용: +.br +\fIdict\fP * 7.5 (조건: \fIdict\fP <= 32 MiB); +.br +\fIdict\fP * 6.5 (조건: \fIdict\fP > 32 MiB) +.TP +\fBbt2\fP +2바이트 해싱 이진 트리 +.br +\fInice\fP 최소값: 2 +.br +메모리 사용: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +2바이트, 3바이트 해싱 이진트리 +.br +\fInice\fP 최소값: 3 +.br +메모리 사용: +.br +\fIdict\fP * 11.5 (조건: \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 9.5 + 64 MiB (조건: \fIdict\fP > 16 MiB) +.TP +\fBbt4\fP +2바이트, 3바이트, 4바이트 해싱 이진 트리 +.br +\fInice\fP 최소값: 4 +.br +메모리 사용: +.br +\fIdict\fP * 11.5 (조건: \fIdict\fP <= 32 MiB); +.br +\fIdict\fP * 10.5 (조건: \fIdict\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fI<모드>\fP +압축 \fI<모드>\fP 값은 일치 검색기에서 생산하는 데이터 분석 방식을 지정합니다. 지원하는 \fI<모드>\fP는 +\fBfast\fP와 \fBnormal\fP 입니다. 기본값은 \fI<사전설정>\fP값 0\(en3에 대해 \fBfast\fP, +\fI<사전설정>\fP값 4\(en9에 대해 \fBnormal\fP입니다. +.IP "" +보통 \fBfast\fP는 해시 체인 검색기에서 사용하며 \fBnormal\fP은 이진 트리 검색기에서 사용합니다. 이 동작은 또한 +\fI<사전설정>\fP 값이 할 일이기도 합니다. +.TP +\fBnice=\fP\fInice\fP +일치하는 nice 길이를 지정합니다. 최소한 \fInice\fP 바이트 정도 일치하면, 알고리즘이 가능한 최선의 부분을 찾는 동작을 +멈춥니다. +.IP "" +\fInice\fP 값은 2\(en273 바이트입니다. 값이 클 수록 속도 면에서는 손해를 보겠지만 압축율은 더욱 올라갑니다. 기본 값은 +\fI<사전설정>\fP값에 따라 다릅니다. +.TP +\fBdepth=\fP\fI<깊이>\fP +일치 검색기에서의 최대 검색 깊이를 지정합니다. 기본값은 특별한 값 0으로 지정하며, 이 값으로 압축 프로그램이 \fImf\fP 와 +\fInice\fP간 적절한 \fI<깊이>\fP 값을 결정합니다. +.IP "" +적절한 해시 체인 \fI<깊이>\fP 값은 이진 트리에서 4\(en100 그리고 16\(en1000 입니다. 상당히 큰 값을 +\fI<깊이>\fP 값으로 사용하면 일부 파일에 대해 인코더가 매우 느리게 동작할 수가 있습니다. 압축 시간이 너무 오래걸려서 +동작을 중간에 끊을 준비가 되지 않은 이상 \fI<깊이>\fP 설정 값은 1000을 넘지 않게하십시오. +.RE +.IP "" +원시 스트림(\fB\-\-format=raw\fP)을 디코딩할 때, LZMA2는 딕셔너리 \fI<크기>\fP만 필요합니다. LZMA1는 +\fIlc\fP, \fIlp\fP, \fIpb\fP 값이 모두 필요합니다. +.TP +\fB\-\-x86\fP[\fB=\fP\fI<옵션>\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fI<옵션>\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIoptions\fP] +.PD +브랜치/호출/점프(BCJ) 필터를 필터 체인에 추가합니다. 이 필터는 필터 체인의 비종결 필터로만 사용할 수 있습니다. +.IP "" +BCJ 필터는 머신 코드의 상대 주소를 절대 주소로 변환합니다. 데이터 크기를 바꾸지는 않지만 LZMA2에서 \fB.xz\fP 파일을 +0\(en15% 정도 줄여주게 하는 중복성이 늘어납니다. BCJ 필터는 언제든 뒤집을 수 있어, 데이터에 적절하지 않은 BCJ 필터 +형식을 활용하면, 그냥 가만히 두면 압축율이 약간 떨어지게 한다 하더라도, 데이터를 잃을 수가 있습니다. BCJ 필터는 굉장히 빠르며 +메모리 공간을 적게 활용합니다. +.IP "" +이 BCJ 필터에는 압축율 관련 몇가지 문제가 있습니다: +.RS +.IP \(bu 3 +실행 코드가 들어있는 몇가지 파일 형식(예: 목적 파일, 정적 라이브러리, 리눅스 커널 모듈)의 경우 필터 값으로 채운 명령 주소가 +있습니다. 여기 BCJ 필터의 경우 파일의 압축율을 떨어뜨리는 주소 변환을 수행합니다. +.IP \(bu 3 +BCJ 필터를 아카이브에 적용하면, BCJ 필터를 사용하지 않았을 때보다 압축율이 떨어질 수가 있습니다. 예를 들면, 유사하거나 동일한 +실행 파일 여럿이 있으면 필터를 사용하여 파일을 덜 비슷하게 만들어 압축율이 떨어지게 합니다. 동일한 아카이브 파일에서 비 실행 파일의 +내용에 대해서도 비슷한 일이 벌어질 수 있습니다. 실제로 하나는 BCJ 필터를 걸고 하나는 제외하여 각 경우에 대해 어떤 경우가 결과가 +우수한 지 살펴보겠습니다. +.RE +.IP "" +다른 명령 세트는 다른 정렬 상태에 놓여있습니다. 실행 파일은 필터가 제대로 동작하게 하려면 입력 데이터에 있는 이 값의 배수로 +정돈해야합니다. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +필터;정렬;참고 +x86;1;32\-bit 또는 64\-bit x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096 바이트 정렬이 가장 좋습니다 +PowerPC;4;빅엔디안 전용 +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +BCJ 필터를 사용한 데이터는 LZMA2로 보통 압축하기 때문에 LZMA2 옵션을 선택한 BCJ 필터의 정렬기준에 맞추도록 설정하면 +압축율을 좀 더 개선할 수 있습니다. 예를 들면: +.RS +.IP \(bu 3 +IA\-64 필터는 16\-바이트 정렬 방식으로 동작하기에 LZMA2 필터에 \fBpb=4,lp=4,lc=0\fP 옵션(2^4=16)을 주는게 +좋습니다. +.IP \(bu 3 +RISC\-V 코드에는 16\-비트 압축 명령(C 확장) 적재 여부에 따라 2\-바이트 또는 4\-바이트 정렬 방식을 채택합니다. 16\-비트 +명령을 사용하면, \fBpb=2,lp=1,lc=3\fP 또는 \fBpb=1,lp=1,lc=3\fP 옵션 값 사용이 바람직합니다. 16\-비트 명령이 +없다면, \fBpb=2,lp=2,lc=2\fP 옵션 값을 활용하는게 좋습니다. "RVC"가 "Flags"행에 나타나는지 확인할 때 +\fBreadelf \-h\fP 명령을 사용할 수 있습니다. +.IP \(bu 3 +ARM64는 항상 4\-바이트 정렬 방식을 택하기에 \fBpb=2,lp=2,lc=2\fP 옵션 값을 활용하는게 좋습니다. +.IP \(bu 3 +x86 필터는 예외입니다. x86 실행 파일을 압축할 경우에는 보통 LZMA2 기본 옵션 값(\fBpb=2,lp=0,lc=3\fP)을 그대로 +사용하는게 좋습니다. +.RE +.IP "" +모든 BCJ 필터는 동일한 \fI옵션\fP을 지원합니다: +.RS +.TP +\fBstart=\fP\fI<오프셋>\fP +상대 주소와 절대 주소를 변환할 때 사용할 시작 \fI<오프셋>\fP을 지정합니다. \fI<오프셋>\fP에는 필터 +정렬 배수여야 합니다(상단 테이블 참조). 기본값은 0입니다. 실제로 기본값이 낫습니다. 개별 \fI<오프셋>\fP 지정 +값은 거의 쓸모가 없습니다. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fI<옵션>\fP] +필터 체인에 델타 필터를 추가합니다. 델타 필터는 필터 체인에서 마지막에 지정하지 않은 필터로만 사용할 수 있습니다. +.IP "" +현재로서는 바이트 단위 단순 델타계산 결과만 보여줍니다. 예를 들면, 압축하지 않은 비트맵 그림 또는 압축하지 않은 PCM 오디오를 +압축할 때 쓸만합니다. 그러나 특별한 목적으로 활용하는 알고리즘은 델타 + LZMA2 보다 더 나은 결과를 가져다 주기도 합니다. +이는 특히 오디오의 경우 맞는 이야기인데, \fBflac\fP(1)의 경우 더 빠르고 우수한 압축율을 보여줍니다. +.IP "" +지원 \fI옵션\fP: +.RS +.TP +\fBdist=\fP\fI<차이>\fP +바이트 단위 델터 계산 \fI<차이>\fP를 지정합니다. \fI<차이>\fP값은 1\(en256 이어야합니다. 기본 +값은 1입니다. +.IP "" +예를 들어, \fBdist=2\fP 옵션과 A1 B1 A2 B3 A3 B5 A4 B7 입력 값을 주면, 출력 값은 A1 B1 01 02 01 +02 01 02 입니다. +.RE +. +.SS "기타 옵션" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +경고 및 알림을 끕니다. 두 번 지정하면 오류 메시지 표시도 끕니다. 이 옵션은 종료 상태에 영향을 주지 않습니다. 경고 표시를 +끄더라도, 종료 상태에서는 여전히 경고가 나타났음을 알려줍니다. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +출력 내용이 많아집니다. 표준 오류를 터미널에 연결했다면 \fBxz\fP는 진행 표시를 나타냅니다. \fB\-\-verbose\fP를 두번 지정하면 +더 많은 내용을 표시합니다. +.IP "" +진행 표시에서는 다음 정보를 나타냅니다: +.RS +.IP \(bu 3 +입력 파일의 크기를 알고 있을 경우 완료 백분율. 파이프 처리시에는 백분율을 나타낼 수 없습니다. +.IP \(bu 3 +산출 압축 데이터 용량 (압축) 또는 소모 공간 용량 (압축 해제). +.IP \(bu 3 +비압축 데이터 소모 용량 (압축) 또는 산출 용량 (압축 해제). +.IP \(bu 3 +압축 데이터 산출 용량을 비압축 데이터 처리 용량으로 나누어 계산한 압축율. +.IP \(bu 3 +압축 또는 압축 해제 속도. 초당 비압축 데이터 소모량(압축) 또는 산출 용량(압축 해제)를 측정한 값입니다. \fBxz\fP에서 파일 +처리를 시작한 몇 초 후 나타납니다. +.IP \(bu 3 +경과 시간 형식은 M:SS 또는 H:MM:SS 입니다. +.IP \(bu 3 +추산 여분 시간은 \fBxz\fP가 파일을 처리하기 시작한 이후 입력 파일의 크기를 알고 몇 초가 지난 후에야 보여줍니다. 시간은 콜론 +문자를 사용하지 않고 덜 자세한 형식으로, 예를 들면, 2분 30초 와 같은 형식으로 보여줍니다. +.RE +.IP "" +표준 오류가 터미널이 아니라면 \fB\-\-verbose\fP는 \fBxz\fP에서 파일 이름, 압축 크기, 압축 해제 용량, 압축율, 그리고 +가능하다면 파일을 압축 또는 압축 해제한 후 표준 오류로 속도와 걸린 시간을 나타내도록 합니다. 속도와 걸린 시간 정보는 동작을 +처리하는데 최소한 몇초 정도 소요했을 경우에만 들어갑니다. 동작이 끝나지 않았다면, 이를테면 사용자의 중단 요청이 있었을 경우 입력 +파일의 크기를 알고 있을 때 압축 백분율 정보도 들어갑니다. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +경고로 알릴 만한 상황을 만났다 하더라도 종료 상태 2번을 설정하지 않습니다. 이 옵션은 출력 수준에 영향을 주지 않기 때문에, +\fB\-\-quiet\fP 옵션과 \fB\-\-no\-warn\fP 옵션을 경고 표시를 막고 종료 상태를 바꾸지 않을 목적으로 사용합니다. +.TP +\fB\-\-robot\fP +머신에서 해석할 형식으로 메시지를 나타냅니다. liblzma 대신 \fBxz\fP를 활용하려는 다양상 스크립트로서의 프론트엔드를 쉽게 +작성하도록 하기 위함입니다. 이 옵션을 지정한 출력은 \fBxz\fP 릴리스가 어떻게 되든 안정 버전이란 의미입니다. 자세한 내용은 +\fB로봇 모드\fP 섹션을 참고하십시오. +.TP +\fB\-\-info\-memory\fP +압축 및 압축 해제시 물리 메모리 용량 (RAM), \fBxz\fP에서 파악하는 프로세서 스레드 갯수, 메모리 사용량 한계를 파악하기 쉬운 +형식으로 나타내고 무사히 나갑니다. +.TP +\fB\-h\fP, \fB\-\-help\fP +보통 사용하는 옵션을 설명하는 도움말 메시지를 출력한 후, 완전히 빠져나갑니다. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +\fBxz\fP의 모든 기능을 설명하는 도움말 메시지를 출력한 후, 완전히 빠져나갑니다 +.TP +\fB\-V\fP, \fB\-\-version\fP +\fBxz\fP와 liblzma 버전 번호를 가독 형식으로 출력합니다. 기계 해석 가능 형식을 가져오려면 \fB\-\-version\fP 앞에 +\fB\-\-robot\fP을 지정하십시오. +. +.SH "로봇 모드" +로봇 모드는 \fB\-\-robot\fP 옵션으로 동작합니다. \fBxz\fP 출력을 다른 프로그램에서 해석하기 쉽게 해줍니다. 현재로서는 +\fB\-\-robot\fP 옵션은 \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, \fB\-\-version\fP +옵션하고만 사용할 수 있습니다. 앞으로는 압축 및 압축 해제 동작에 대해서도 지원합니다. +. +.SS "목록 모드" +\fBxz \-\-robot \-\-list\fP 명령은 탭으로 구분한 출력 형태를 활용합니다. 모든 행의 첫번째 컬럼에는 해당 행에서 찾을 수 +있는 정보의 형식을 나타냅니다: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +이 행은 항상 파일 목록 시작 부분의 첫번째 줄에 있습니다. 이 행의 두번째 컬럼에 파일 이름이 들어있습니다. +.TP +\fBfile\fP +이 행에는 \fB.xz\fP 파일의 전반적인 정보가 들어있습니다. 이 행은 항상 \fBname\fP 행 다음에 있습니다. +.TP +\fBstream\fP +이 행 형식은 \fB\-\-verbose\fP 옵션을 지정했을 때만 사용합니다. \fB.xz\fP 파일의 \fBstream\fP 행 수만큼 나타납니다. +.TP +\fBblock\fP +이 행 형식은 \fB\-\-verbose\fP 옵션을 지정했을 때만 사용합니다. \fB.xz\fP 파일의 블록 수만큼 \fBblock\fP 행이 +나타납니다. \fBblock\fP 행은 모든 \fBstream\fP 행 다음에 나타납니다. 다른 형식의 행이 끼어들지는 않습니다. +.TP +\fBsummary\fP +이 행 형식은 \fB\-\-verbose\fP 옵션을 두번 지정했을 때만 사용합니다. 이 행은 모든 \fBblock\fP 행 다음에 출력합니다. +\fBfile\fP 행과 비슷하게, \fBsummary\fP 행에는 \fB.xz\fP 파일의 전반적인 정보가 담겨있습니다. +.TP +\fBtotals\fP +이 행은 목록 출력의 가장 마지막에 항상 나타납니다. 총 갯수와 크기를 나타냅니다. +.PP +\fBfile\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +파일 스트림 갯수 +.IP 3. 4 +스트림의 블록 총 갯수 +.IP 4. 4 +파일 압축 크기 +.IP 5. 4 +파일 압축 해제 크기 +.IP 6. 4 +예를 들면, \fB0.123\fP과 같은 압축율 입니다. 비율이 9.999라면, 대시 문자 3개 (\fB\-\-\-\fP)를 비율 값 대신 나타냅니다. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +쉼표로 구분한 무결성 검사 이름 목록입니다. \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP, \fBSHA\-256\fP 문자열을 알려진 +검사 형식으로 사용합니다. 알 수 없는 검사 형식에 대해서는 \fBUnknown\-\fP\fIN\fP을 사용하며, 여기서 \fIN\fP은 (한 두자리) +정수형 숫자값으로 이루어진 검사 ID 입니다. +.IP 8. 4 +파일의 스트림 패딩 총 길이 +.RE +.PD +.PP +\fBstream\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +스트림 번호 (첫 스트림은 1번) +.IP 3. 4 +스트림의 블록 총 갯수 +.IP 4. 4 +압축 시작 오프셋 +.IP 5. 4 +비압축 시작 오프셋 +.IP 6. 4 +압축 크기 (스트림 패딩 미포함) +.IP 7. 4 +압축 해제 용량 +.IP 8. 4 +압축율 +.IP 9. 4 +무결성 검사 이름 +.IP 10. 4 +스트림 패딩 길이 +.RE +.PD +.PP +\fBblock\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +이 블록이 들어간 스트림 갯수 +.IP 3. 4 +스트림 시작 부분의 블록 번호 (첫번째 블록은 1번) +.IP 4. 4 +파일 시작 부분의 블록 번호 +.IP 5. 4 +파일 시작 부분의 압축 시작 오프셋 +.IP 6. 4 +파일 시작 부분의 비압축 시작 오프셋 +.IP 7. 4 +총 블록 압축 크기 (헤더 포함) +.IP 8. 4 +압축 해제 용량 +.IP 9. 4 +압축율 +.IP 10. 4 +무결성 검사 이름 +.RE +.PD +.PP +\fB\-\-verbose\fP를 두 번 지정하면, 추가 컬럼을 \fBblock\fP 행에 넣습니다. \fB\-\-verbose\fP 단일 지정시에는 이 +정보를 볼 때 탐색을 여러번 수행해야 하기 때문에 실행 과정이 느려질 수 있어서 나타내지 않습니다: +.PD 0 +.RS +.IP 11. 4 +16진수 무결성 검사값 +.IP 12. 4 +블록 헤더 크기 +.IP 13. 4 +블록 플래그: \fBc\fP는 압축 크기가 현재 값임을 나타내고, \fBu\fP는 압축 전 원본 크기가 현재 값임을 나타냅니다. 플래그를 설정하지 +않았다면, 문자열 길이를 유지할 목적으로 대시 \fB\-\fP 를 대신 나타냅니다. 새 플래그는 나중에 문자열 끝 부분에 추가할 예정입니다. +.IP 14. 4 +블록에 압축 해서 넣은 데이터의 실제 츠기 (블록 헤더, 블록 패딩, 검사 필드 제외) +.IP 15. 4 +이 \fBxz\fP 버전에서 이 블록의 압축을 해제할 때 필요한 (바이트 단위) 메모리 용량 +.IP 16. 4 +필터 체인. 대부분 사용하는 옵션은 압축 해제시 필요한 옵션만을 \fB.xz\fP 헤더에 저장하기 때문에 압축 시간에 알 수 없습니다. +.RE +.PD +.PP +\fBsummary\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +이 \fBxz\fP 버전에서 이 파일 압축을 해제할 때 필요한 (바이트 단위) 메모리 용량 +.IP 3. 4 +모든 블록 헤더에 압축 크기와 압축 전 원본 크기 정보가 들어갔는지 여부를 나타내는 \fByes\fP 또는 \fBno\fP 값 +.PP +\fBxz\fP \fI5.1.2alpha\fP \fI부터:\fP +.IP 4. 4 +파일 압축 해제시 필요한 최소 \fBxz\fP 버전 +.RE +.PD +.PP +\fBtotals\fP 행 컬럼: +.PD 0 +.RS +.IP 2. 4 +스트림 갯수 +.IP 3. 4 +블록 갯수 +.IP 4. 4 +압축 크기 +.IP 5. 4 +압축 해제 용량 +.IP 6. 4 +평균 압축율 +.IP 7. 4 +파일에 들어 있어 쉼표로 구분한 무결성 검사 이름 목록 +.IP 8. 4 +스트림 패딩 길이 +.IP 9. 4 +파일 갯수. \fBfile\fP 행의 컬럼 순서를 따라갑니다. +.PD +.RE +.PP +\fB\-\-verbose\fP 옵션을 두 번 지정하면, \fBtotals\fP 행에 추가 컬럼이 들어갑니다: +.PD 0 +.RS +.IP 10. 4 +이 \fBxz\fP 버전에서 파일 압축을 해제할 떄 필요한 (바이트 단위) 최대 메모리 사용량 +.IP 11. 4 +모든 블록 헤더에 압축 크기와 압축 전 원본 크기 정보가 들어갔는지 여부를 나타내는 \fByes\fP 또는 \fBno\fP 값 +.PP +\fBxz\fP \fI5.1.2alpha\fP \fI부터:\fP +.IP 12. 4 +파일 압축 해제시 필요한 최소 \fBxz\fP 버전 +.RE +.PD +.PP +차후 버전에서는 새 행 형식을 추가하고 기존 행 형식에 추가할 수 있는 새 컬럼을 넣기 까지는 알 수 있겠지만, 기존 컬럼은 바꾸지 않을 +예정입니다. +. +.SS "필터 도움말" +\fBxz \-\-robot \-\-filters\-help\fP 는 다음 형식의 지원 필터 목록을 출력합니다: +.PP +\fI<필터>\fP\fB:\fP\fI<옵션>\fP\fB=<\fP\fI값\fP\fB>,\fP\fI<옵션>\fP\fB=<\fP\fI값\fP\fB>\fP... +.TP +\fI<필터>\fP +필터 이름 +.TP +\fI<옵션>\fP +필터별 옵션 이름 +.TP +\fI<값>\fP +숫자 \fI값\fP 범위는 \fB<\fP\fI최소\fP\fB\-\fP\fI최대\fP\fB>\fP입니다. 문자열 \fI값\fP은 \fB< >\fP 범위 +내에서 선택하며 \fB|\fP 문자로 구분합니다. +.PP +각 필터는 한 줄에 하나씩 출력합니다. +. +.SS "메모리 제한 정보" +\fBxz \-\-robot \-\-info\-memory\fP 명령은 탭으로 나뉜 여러 컬럼을 단일 행으로 나타냅니다: +.IP 1. 4 +물리 메모리(RAM)의 바이트 단위 총량. +.IP 2. 4 +압축 진행시 바이트 단위 메모리 사용 한계값 (\fB\-\-memlimit\-compress\fP). 특수 값 \fB0\fP은 단일\-스레드 모드에서 +제한을 두지 않는 기본 설정임을 나타냅니다. +.IP 3. 4 +압축 해제시 바이트 단위 메모리 사용 한계값 (\fB\-\-memlimit\-decompress\fP). 특수 값 \fB0\fP은 단일\-스레드 모드에서 +제한을 두지 않는 기본 설정임을 나타냅니다. +.IP 4. 4 +\fBxz\fP 5.3.4alpha 이후: 다중\-스레드 기반 압축 해제시 바이트 단위 메모리 +사용량(\fB\-\-memlimit\-mt\-decompress\fP). 분명하게 제한을 걸어두지 않았을 경우 5번째 컬럼에 나타난 시스템별 +기본값을 사용하기 때문에 0 값을 지정하면 안됩니다. 또한 \fB\-\-memlimit\-mt\-decompress\fP로 세번째 컬럼 값보다 더 +크게 지정을 한다 할지라도 이 값이 세번째 컬럼 값보다 크면 안됩니다. +.IP 5. 4 +\fBxz\fP 5.3.4alpha 이후: A system\-specific default memory usage limit that is +used to limit the number of threads when compressing with an automatic +number of threads (\fB\-\-threads=0\fP) and no memory usage limit has been +specified (\fB\-\-memlimit\-compress\fP). This is also used as the default value +for \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +\fBxz\fP 5.3.4alpha 이후: Number of available processor threads. +.PP +차후, \fBxz \-\-robot \-\-info\-memory\fP 출력에는 더 많은 내용이 들어가지만, 한 줄 이상은 넘어가지 않습니다. +. +.SS 버전 +\fBxz \-\-robot \-\-version\fP 은 \fBxz\fP 와 liblzma의 버전 번호를 다음 형식으로 나타냅니다: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +주 버전. +.TP +\fIYYY\fP +부 버전. 짝수가 안정 버전입니다. 홀수는 알파 또는 베타 버전입니다. +.TP +\fIZZZ\fP +안정 릴리스의 패치 수준 또는 개발 릴리스의 횟수입니다. +.TP +\fIS\fP +안정도. 0은 알파 버전, 1은 베타 버전을 나타내며, 2는 안정 버전을 나타냅니다. \fIS\fP는 \fIYYY\fP 값이 짝수라 해도 항상 +2여야 합니다. +.PP +\fBxz\fP 명령과 liblzma이 동일한 XZ 유틸리티 릴리스에서 나왔다면 두 행의 \fIXYYYZZZS\fP 값은 같습니다. +.PP +예제: 4.999.9beta는 \fB49990091\fP이며, 5.0.0은 \fB50000002\fP입니다. +. +.SH "종료 상태" +.TP +\fB0\fP +모든 상태 양호. +.TP +\fB1\fP +오류 발생. +.TP +\fB2\fP +눈여겨볼 경고가 나타났지만, 실제 오류는 일어나지 않음. +.PP +표준 오류에 출력하는 알림(경고 또는 오류 아님)는 종료 상태에 영향을 주지 않습니다. +. +.SH 환경 +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP는 빈칸으로 구분한 옵션 값 목록을 \fBXZ_DEFAULTS\fP, \fBXZ_OPT\fP 환경 변수에서 순서대로, 명령행에서 옵션을 +해석하기 전에 불러옵니다. 참고로 환경 변수에서 옵션만 해석하며, 옵션이 아닌 부분은 조용히 무시합니다. 해석은 +\fBgetopt_long\fP(3)으로 가능하며, 명령행 인자로 활용하기도 합니다. +.PP +\fB경고:\fP 환경 변수를 설정하면, 프로그램과 \fBxz\fP를 실행하는 스크립트의 동작이 바뀝니다. 대부분의 경우 메모리 사용 제한량, +스레드 수, 압축 옵션을 환경 변수로 설정하는게 안전합니다. 그러나 일부 옵션은 스크립트의 동작을 망가뜨릴 수 있습니다. 분명한 +예제로는 \fBxz\fP에서 파일의 압축 및 해제 대신 도움말 내용을 표시하는 \fB\-\-help\fP 옵션이 있습니다. 좀 더 묘한 예제로는 +\fB\-\-quiet\fP 와 \fB\-\-verbose\fP 옵션이 있습니다. 대부분의 경우 \fB\-\-verbose\fP 옵션을 사용하여 프로세스 상황을 +표시하는데 잘 동작하지만, 어떤 경우에는 추가 메시지가 나타나는 문제가 있습니다. 출력 상세 수준은 \fB\-\-list\fP의 동작에도 영향을 +줍니다. +.TP +\fBXZ_DEFAULTS\fP +사용자별, 시스템 범위 기본 옵션입니다. 보통 \fBxz\fP의 메모리 사용량 제한을 기본으로 걸어두거나 기본 스레드 수를 설정할 경우 셸 +초기화 스크립트에 설정합니다. 셸 초기화 스크립트와 별도의 유사한 경우를 제외하고라면, 스크립트에서는 \fBXZ_DEFAULTS\fP 환경 +변수를 설정하지 않거나 설정을 해제해야합니다. +.TP +\fBXZ_OPT\fP +\fBxz\fP 명령행으로 옵션 설정 값을 직접 전달할 수 없을 경우 \fBxz\fP에 옵션을 전달하는 환경 변수입니다. 예를 들어, \fBxz\fP를 +스크립트 또는 도구에서 실행할 경우 GNU \fBtar\fP(1) 라면: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +예를 들면, 스크립트에서 \fBXZ_OPT\fP 를 활용하여, 스크립트별로 기본 압축 옵션을 지정할 수 있습니다. 적절한 이유가 있다면 +\fBXZ_OPT\fP 옵션 값을 사용자가 바꾸는걸 추천합니다. 예를 들면, \fBsh\fP(1) 스크립트에서 다음처럼 활용할 수도 있습니다: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "LZMA 유틸리티 호환성" +\fBxz\fP의 명령행 문법은 실제로 LZMA 유틸리티 4.32.x에서 찾을 수 있는 \fBlzma\fP, \fBunlzma\fP \fBlzcat\fP의 +상위 집합입니다. 대부분의 경우 LZMA 유틸리티를 XZ 유틸리티로 기존에 작성한 스크립트를 깨지 않고도 바꿀 수 있습니다. 몇가지 +비호환성 문제 때문에 문제가 일어날 수는 있습니다. +. +.SS "압축 사전 설정 단계" +압축 수준 사전 설정의 번호 부여 방식은 \fBxz\fP와 LZMA 유틸리티가 동일하지 않습니다. 가장 중요한 차이는 다른 사전 설정에 대해 +딕셔너리 크기를 어떻게 대응했느냐 여부입니다. 딕셔너리 크기는 압축 해제시 메모리 사용량과 거의 비슷합니다. +.RS +.PP +.TS +tab(;); +c c c +c n n. +단계;xz;LZMA 유틸리티 +\-0;256 KiB;없음 +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +딕셔너리 크기 차이는 압축 프로그램 메모리 사용에 영향을 주지만, LZMA 유틸리티와 XZ 유틸리티에서 사용량이 늘어나는 다른 차이점이 +있습니다: +.RS +.PP +.TS +tab(;); +c c c +c n n. +단계;xz;LZMA 유틸리티 4.32.x +\-0;3 MiB;없음 +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +XZ 유틸리티의 기본 사전 설정 수준값은 \fB\-6\fP이지만 LZMA 유틸리티의 기본 사전 설정 수준값은 \fB\-7\fP입니다. 두 프로그램의 +딕셔너리 메모리 기본 사용량은 8MiB입니다. +. +.SS "스트림 vs 비스트림 .lzma 파일" +파일을 압축하지 않은 크기는 \fB.lzma\fP 헤더에 저장합니다. LZMA 유틸리티는 일반 파일을 압축할 때 압축하지 않은 파일의 크기를 +저장합니다. 이 대신 압축하지 않은 크기를 '알 수 없음' 으로 저장하고 압축 해제 프로그램이 멈춰야 할 지점에 +end\-of\-payload 마커를 사용하는 방법도 있습니다. LZMA 유틸리티는 파이프로 들어온 입력과 같이 압축하지 않은 파일의 +크기를 알 수 없을 때 이런 방식을 활용합니다. +.PP +\fBxz\fP는 \fB.lzma\fP 파일을 end\-of\-payload 마커의 유무와 관계없이 압축 해제 방식을 모두 지원하지만, \fBxz\fP로 +만든 모든 \fB.lzma\fP 파일은 end\-of\-payload 마커를 사용하며, \fB.lzma\fP 헤더에 압축하지 않은 파일 크기를 '알 수 +없음'으로 표기합니다. 이 방식은 드문 상황에서 문제를 야기할 수 있습니다. 예를 들면, 임베디드 장치의 \fB.lzma\fP 압축 해제 +프로그램은 압축을 해제했을 때 크기를 알아야 동작합니다. 이 문제를 만나면, LZMA 유틸리티 또는 LZMA SDK를 활용하여 +\&\fB.lzma\fP 파일에 압축 전 파일 크기 정보를 저장해야합니다. +. +.SS "지원하지 않는 .lzma 파일" +\&\fB.lzma\fP 형식은 \fIlc\fP 값을 8까지 받아들이며, \fIlp\fP 값은 4까지 받아들입니다. LZMA 유틸리티는 어떤 \fIlc\fP 값과 +\fIlp\fP 값을 받아들이고도 압축을 해제할 수 있지만, 파일을 만들 때는 늘 \fBlc=3\fP 값과 \fBlp=0\fP 값을 활용합니다. 다른 +\fIlc\fP 값과 \fIlp\fP 값으로의 파일 압축은 \fBxz\fP와 LZMA SDK에서만 가능합니다. +.PP +liblzma의 LZMA1 필터 구현체에서는 \fIlc\fP 값과 \fIlp\fP 값의 합이 4를 넘어가면 안됩니다. 그래서 \fB.lzma\fP +파일의 경우 이 제한을 넘어가면 \fBxz\fP로 압축을 해제할 수 없습니다. +.PP +LZMA 유틸리티는 2^\fIn\fP (2의 승수)크기를 지닌 딕셔너리를 가진 \fB.lzma\fP 파일만 만들지만 받아들이는 파일의 딕셔너리 +크기는 어떤 크기든 상관 없습니다. liblzma에서는 2^\fIn\fP, 2^\fIn\fP + 2^(\fIn\fP\-1) 딕셔너리 크기를 가진 +\&\fB.lzma\fP 파일 만 받아들입니다. 이로 인해 \fB.lzma\fP 파일을 확인할 때 거짓 양성율이 늘어납니다. +.PP +모든 \fB.lzma\fP 파일을 liblzma 에서 받아들일 수 있도록 압축하기 때문에 이 제한이 실제로는 문제가 되지 않습니다. +. +.SS "뒤따라오는 쓰레기 값" +압축 해제할 때, LZMA 유틸리티는 \fB.lzma\fP 스트림 처음 부분 다음 나머지를 다 조용히 무시합니다. 대부분의 경우, +버그입니다. LZMA 유틸리티에서 \fB.lzma\fP 결합 파일 압축 해제를 지원하지 않음을 의미하기도 합니다. +.PP +\&\fB.lzma\fP 스트림 처음부분 바로 다음에 데이터가 남아있을 경우, \fBxz\fP 에서는 \fB\-\-single\-stream\fP 옵션을 사용하지 +않으면 깨진 파일로 간주합니다. 이 동작으로 하여금 뒤따라오는 쓰레기 값을 무시하도록 간주하는 애매한 스크립트 동작을 깰 수가 +있습니다. +. +.SH 참고 +. +.SS "출력 결과물이 달라짐" +압축하지 않은 입력 파일로부터 얻어낸 정확한 압축 출력 결과물은 압축 옵션이 완전히 동일하더라도 XZ 유틸리티의 버전에 따라 달라질 수 +있습니다. 파일 형식에 영향을 주지 않고 인코더 그 자체를 개선(더 빠르게 하거나 더 나은 압축율로)하기 때문입니다. XZ 유틸리티 +버전이 동일하더라도 빌드 옵션을 달리하여 빌드 상태가 제각각인 경우 출력 결과물이 달라질 수 있습니다. +.PP +\fB\-\-rsyncable\fP 기능을 넣었을 경우 동일한 xz 버전에서 이전 파일과 새 파일로 별도로 압축하지 않는 한 결과 파일을 (두 +파일이 서로 다른 파일이 아니므로) rsync 처리할 필요가 없습니다. 이 문제는 인코더 구현체 기능 개발이 끝나서 xz 버전이 +다르더라도 안정적인 rsync 가능한 출력 결과물을 유지할 수 있을 때여야 해결할 수 있습니다. +. +.SS "내장 .xz 압축 해제 프로그램" +XZ 임베디드와 같은 내장 \fB.xz\fP 압축 해제 구현체는 지원 파일의 무결성 \fI검사\fP 형식을 \fInone\fP과 \fIcrc32\fP 이외의 +설정으로 만들 필요가 없습니다. 기본값이 \fB\-\-check=crc64\fP일 경우에만, 임베디드 시스템에서 파일을 만들 때 +\fB\-\-check=none\fP 또는 \fB\-\-check=crc32\fP 옵션을 사용해야합니다. +.PP +임베디드 시스템이 아니라면, 모든 \fB.xz\fP 형식 압축 해제 프로그램에서는 모든 \fI검사\fP 형식을 지원하거나, 일부 \fI검사\fP 방식을 +지원하지 않는다면, 최소한, 무결성 검사로 검증하지 않고 압축을 해제할 수 있습니다. +.PP +XZ 임베디드는 BCJ 필터를 지원하지만, 기본 시작 오프셋만 지정할 수 있습니다. +. +.SH 예제 +. +.SS 기본 +\fIfoo\fP 파일을 기본 압축 수준 (\fB\-6\fP) 으로 \fIfoo.xz\fP 파일에 압축해 넣고, 압축 과정이 무사히 끝나면 \fIfoo\fP를 +삭제합니다: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +\fIbar.xz\fP를 \fIbar\fP 에 압축을 해제한 후 압축 해제가 무사히 끝나도 \fIbar.xz\fP를 삭제하지 않습니다: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +기본 사전 설정 \fB\-6\fP 보다는 느리지만, 압축 및 압축 해제시 메모리를 적게 차지(각각 48\ Mib, 5\MiB)는 \fB\-4e\fP +사전 설정(\fB\-4 \-\-extreme\fP)을 활용하여 \fIbaz.tar.xz\fP 파일을 만듭니다: +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +압축 및 비압축 파일을 단일 명령으로 표준 출력에 압축해제할 수 있습니다: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "다중 파일 병렬 압축" +GNU와 *BSD에서는 \fBfind\fP(1) 명령과 \fBxargs\fP(1) 명령으로 여러 파일의 압축을 병렬 처리할 수 있습니다: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +\fBxargs\fP(1) 의 \fB\-P\fP 옵션으로 \fBxz\fP 프로세스의 병렬 처리 갯수를 지정합니다. \fB\-n\fP 옵션의 최적 값은 압축할 +파일 수에 달려있습니다. 압축할 파일이 몇개밖에 없다면 1이어야합니다. 파일이 수천 수만개 정도 된다면 \fBxargs\fP(1) 이 +어쨌든지간에 만들어낼 \fBxz\fP 프로세스의 겟수를 100으로 하거나 아니면 적당한 값을 지정하여 줄이는게 좋습니다. +.PP +\fBxz\fP에 \fB\-T1\fP옵션을 지정하면 단일\-스레드 모드로 강제합니다. \fBxargs\fP(1) 에서 병렬 처리 갯수를 제어할 수 있기 +때문입니다. +. +.SS "로봇 모드" +여러 파일을 압축한 후 저장할 바이트 용량을 계산합니다: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +이 스크립트에서는 충분히 최신의 \fBxz\fP 명령을 사용하는지 알아보려 합니다. 다음 \fBsh\fP(1) 스크립트에서는 \fBxz\fP 도구의 +버전 번호가 최소한 5.0.0인지 여부를 검사합니다. 이 방식은 \fB\-\-robot\fP 옵션을 지원하지 않는 오래된 베타 버전과도 호환성이 +있습니다: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +\fBXZ_OPT\fP 환경 변수로 압축 해제시 메뢰 사용량 한계를 설정하지만, 한계 값을 이미 설정했다면, 값을 늘리지 않습니다: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "개별 압축 필터 체인 설정" +개별 설정 필터 체인의 초단순 사용방식은 LZMA2 사전 설정 값을 별도로 설정하는 방식입니다. 사전 설정은 잠재적으로 쓸만한 압축 +설정 조합만 다루기 때문에 꽤 쓸모가 있을 수도 있습니다. +.PP +\fB\-0\fP ... \fB\-9\fP 옵션의 설명에서 테이블의 CompCPU 컬럼과 \fB\-\-extreme\fP 옵션은 LZMA2 사전 설정을 +개별적으로 맞췄을 때 쓸만할 수도 있습니다. 여기 관련내용을 테이블 둘로 정리해서 모아보았습니다: +.RS +.PP +.TS +tab(;); +c c +n n. +Preset;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +어떤 파일을 압축할 때 상당히 큰 딕셔너리(예: 32MiB)가 필요 하다는걸 알아채셨지만, \fBxz \-8\fP 명령이 압축할 때보다 더 빠른 +속도로 압축하려 한다면, 더 큰 딕셔너리 사용을 위해 더 낮은 CompCPU 사전 설정 값(예: 1)으로 수정할 수 있습니다: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +각 파일에 대해, 위 명령은 압축율이 더 좋아지면서도 \fBxz \-6\fP보다 더 빨라집니다. 그러나, CompCPU 값을 낮게 유지하는 +대신 큰 딕셔너리에서 일부 파일을 강조해야 합니다. 큰 딕셔너리가 대부분의 도움을 주는 매우 명백한 상황에서는 최소한 몇 메가바이트의 +매우 유사한 각 파일이 아카이브에 들어갑니다. 딕셔너리 크기는 LZMA2가 연속으로 존재하는 각 파일의 유사성으로부터 얻는 장점을 취할 +수 있을 때 일부 개별 파일보다 훨씬 더 커집니다. +.PP +압축 프로그램과 압축 해제 프로그램에서 메모리를 엄청 많이 사용해도 상관 없고, 파일을 수백 메가 바이트 메모리 용량을 활용하여 +압축한다면, \fBxz \-9\fP 명령에 64MiB 용량을 초과하는 딕셔너리를 사용할 수 있게 하는 방법도 쓸만할 지도 모릅니다: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +위 예제에서와 같이 \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) 옵션을 사용하면 압축 및 압축 해제 과정에서 필요한 메모리 +용량을 살펴보는데 요긴할 수 있습니다. 압축 해제한 파일 크기보다 더 큰 딕셔너리를 사용하면 불필요한 메모리 소모량이 발생하여 위 +명령이 작은 파일에는 쓸모 없음을 기억하십시오. +.PP +때로는 압축 시간이 딱히 상관이 없을 수도 있습니다만, 압축 해제시 메모리 사용량을 적게 유지해야 할 수도 있습니다. 예를 들면, +임베디드 시스템에서 파일 압축을 해제할 수도 있습니다. 다음 명령의 경우 \fB\-6e\fP (\fB\-6 \-\-extreme\fP) 옵션을 기반 +옵션을 사용하며 딕셔너리 크기를 64KiB만 사용하도록 제한합니다. 결과 파일은 XZ 임베디드(이게 \fB\-\-check=crc32\fP +옵션이 있는 이유)로 100KiB 메모리 용량을 활용하여 풀어낼 수 있습니다. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +가능한 한 수 바이트를 더 쥐어 짜내고 싶을 때, 리터럴 문맥 비트 수(\fIlc\fP)와 위치 비트 수(\fIpb\fP)를 조정하면 도움이 될 +수도 있습니다. 리터럴 위치 비트 수(\fIlp\fP)를 조금 건드리는 것 또한 도움이 될 지도 모르겠지만 보통 \fIlc\fP 값과 \fIpb\fP +값이 더 중요합니다. 예를 들면, 소스 코드 저장 파일에는 US\-ASCII 텍스트가 대부분이기에, 다음과 같은 경우는 \fBxz \-6e\fP +명령을 실행했을 때부다는 아주 약간(거의 0.1% 수준) 작은 파일을 얻어낼 수도 있습니다(\fBlc=4\fP를 빼고도 시도해보십시오): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +LZMA2와 다른 필터를 함께 사용하면 일부 파일 형식에 대해 압축율을 개선할 수 있습니다. 예를 들면 x86\-32 또는 x86\-64 +공유 라이브러리를 x86 BCJ 필터를 활용하여 압축할 경우: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +참고로 필터 옵션의 순서는 상당히 중요합니다. \fB\-\-x86\fP을 \fB\-\-lzma\fP 이전에 지정하면 \fBxz\fP에서 오류가 나는데, +LZMA2 다음에는 어떤 필터든 설정할 수 없고, 옵션 체인상 마지막 필터로 x86 BCJ 필터를 사용할 수 없기 때문입니다. +.PP +LZMA2와 델타 필터는 비트맵 그림에 최적의 결과를 가져다줄 수 있습니다. PNG에 보통 안성맞춥인데, PNG에는 단순 델타 필터보단 +약간 더 고급진 필터를 사용하지만, 실제 압축을 진행할 때는 Deflate를 사용하기 때문입니다. +.PP +예를 들어 이미지를 압축하지 않은 비압축 TIFF로 저장해야 하는 경우가 있습니다. 델타 필터의 거리 매개변수는 그림에서 픽셀당 바이트 +수에 일치하도록 설정합니다. 예를 들면, 24비트 RGB 비트맵의 경우 \fBdist=3\fP 거리 매개변수 값을 설정해야 하며, LZMA2 +압축시 3바이트 정렬을 따르도록 \fBpb=0\fP 값을 전달하는 방법도 바람직합니다: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +여러 이미지를 단일 아카이브로 넣고 싶다면(예: \fB.tar\fP), 모든 이미지에 대해 동일한 픽셀당 바이트 수가 들어가는 경우에도 델타 +필터가 동작합니다. +. +.SH "추가 참조" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ 유틸리티: +.br +XZ 임베디드: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xzcmp.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xzcmp.1 new file mode 100644 index 0000000000000000000000000000000000000000..8921034b872e2bef6e5cdcaa1a76d774fe6d8e64 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xzcmp.1 @@ -0,0 +1,52 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Korean translation for the xz-man +.\" Seong-ho Cho , 2023, 2024. +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 2025\-03\-06 Tukaani "XZ 유틸리티" +.SH 이름 +xzcmp, xzdiff, lzcmp, lzdiff \- 압축 파일을 비교합니다 +. +.SH 요약 +\fBxzcmp\fP [\fI<옵션>...\fP] \fI<파일1>\fP [\fI<파일2>\fP] +.br +\fBxzdiff\fP \&... +.br +\fBlzcmp\fP \&... (사용 안 함) +.br +\fBlzdiff\fP \&... (사용 안 함) +. +.SH 설명 +\fBxzcmp\fP 와 \fBxzdiff\fP 명령은 압축 해제한 두 파일의 내용을 비교합니다. 압축 해제한 파일의 데이터와 옵션은 +\fB\-\-help\fP 옵션 또는 \fB\-\-version\fP 옵션을 지정하지 않는다면, \fBcmp\fP(1) 또는 \fBdiff\fP(1) 명령으로 +전달합니다. +.PP +\fI<파일1>\fP 과 \fI<파일2>\fP를 모두 지정했다면, 지정한 파일은 이미 압축해제한 파일이거나, +\fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), \fBlz4\fP(1) 명령으로 +압축해제할 수 있는 형식의 파일일 수 있습니다. 필요한 압축 해제 명령은 \fI<파일1>\fP 과 +\fI<파일2>\fP의 파일 이름 확장자로 결정합니다. 알 수 없는 확장자를 지닌 파일은 이미 압축을 해제했거나 +\fBxz\fP(1) 명령으로 압축 해제할 수 있는 형식으로 간주합니다. +.PP +파일 이름을 하나만 지정한다면, \fI<파일1>\fP의 확장자는 지원 압축 형식의 확장자여야 하며, +\fI<파일2>\fP는 \fI<파일1>\fP에서 압축 파일 확장자를 제거한 파일로 간주합니다. +.PP +\fBlzcmp\fP와 \fBlzdiff\fP 명령은 LZMA 유틸리티 하위 호환용으로 제공합니다. 해당 명령은 오래되어 이후 버전에서 +제거합니다. +. +.SH "종료 상태" +압축 해제 오류가 나타나는 경우, 종료 코드는 \fB2\fP입니다. 그렇지 않을 경우 \fBcmp\fP(1) 또는 \fBdiff\fP(1) 명령의 +종료 코드를 활용합니다. +. +.SH "추가 참조" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xzdec.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xzdec.1 new file mode 100644 index 0000000000000000000000000000000000000000..a9e112792d46d6999e81a98d7a911d76e36c73e7 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xzdec.1 @@ -0,0 +1,72 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.\" Korean translation for the xz-man +.\" Seong-ho Cho , 2023, 2024. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDEC 1 2024\-04\-08 Tukaani "XZ 유틸리티" +.SH 이름 +xzdec, lzmadec \- .xz와 .lzma용 작은 압축 해제 프로그램 +.SH 요약 +\fBxzdec\fP [\f\fI옵션\fP...\fP] [\fI<파일>...\fP] +.br +\fBlzmadec\fP [\f\fI옵션\fP...\fP] [\fI<파일>...\fP] +.SH 설명 +\fBxzdec\fP은 liblzma 기반 \fB.xz\fP (그리고 \fB.xz\fP 확장자만) 파일 압축 해제 전용 도구 프로그램입니다. +\fBxzdec\fP 은 \fBxz\fP(1) 명령을 활용하여 \fB.xz\fP 파일의 압축을 해제할 때 쓰던 \fBxz \-\-decompress \-\-stdout\fP (그리고 일반적으로 쓰던 몇가지 다른 옵션도 같이) 명령을 작성하던 일상적인 경우를 대신하려 만든 결과물입니다. +\fBlzmadec\fP 는 \fB.xz\fP 파일 대신 \fB.lzma\fP 파일을 지원하는 점만 다르며, 나머지는 \fBxzdec\fP과 동일합니다. +.PP +실행 파일 크기를 줄이려는 목적으로, \fBxzdec\fP 에서는 다중\-스레드 실행 또는 현지 언어 표기를 지원하지 않으며 +\fBXZ_DEFAULTS\fP 환경 변수와 \fBXZ_OPT\fP 환경 변수의 옵션 값을 읽지 않습니다. \fBxzdec\fP은 단계별 진행 정보를 +표시하지 않습니다. \fBxzdec\fP 명령어로 \fBSIGINFO\fP 시그널을 보내면 아무 동작도 취하지 않지만, \fBSIGUSR1\fP 시그널을 +보내면 프 정보를 표시하는 대신 프로세스를 끝냅니다. +.SH 옵션 +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +\fBxz\fP(1) 호환성을 문제로 무시합니다. \fBxzdec\fP은 압축 해제 기능만 지원합니다. +.TP +\fB\-k\fP, \fB\-\-keep\fP +\fBxz\fP(1) 호환성을 문제로 무시합니다. \fBxzdec\fP은 어떤 파일도 만들거나 제거하지 않습니다. +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +\fBxz\fP(1) 호환성을 문제로 무시합니다. \fBxzdec\fP은 항상 압축 해제한 데이터를 표준 출력으로만 기록합니다. +.TP +\fB\-q\fP, \fB\-\-quiet\fP +이 옵션을 한번 지정하면 \fBxzdec\fP에서 어떤 경고나 알림을 표시하지 않기 때문에 아무런 동작도 취하지 않습니다. 오류 메시지를 +표시하지 않으려면 이 옵션을 두번 지정하십시오. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +\fBxz\fP(1) 호환성을 문제로 무시합니다. \fBxzdec\fP은 종료 코드 2번을 사용하지 않습니다. +.TP +\fB\-h\fP, \fB\-\-help\fP +도움말 메시지를 나타내고 무사히 나갑니다. +.TP +\fB\-V\fP, \fB\-\-version\fP +\fBxzdec\fP과 liblzma의 버전 번호를 나타냅니다. +.SH "종료 상태" +.TP +\fB0\fP +모든 상태 양호. +.TP +\fB1\fP +오류 발생. +.PP +\fBxzdec\fP 은 \fBxz\fP에 있는 경고 메시지를 출력하지 않기 때문에 \fBxzdec\fP 에서는 종료 코드 2번을 사용하지 않습니다. +.SH 참고 +보통 매일 사용하실 목적이라면 \fBxzdec\fP 또는 \fBlzmadec\fP 대신 \fBxz\fP 명령을 사용하십시오. \fBxzdec\fP 또는 +\fBlzmadec\fP은 완전한 기능을 갖춘 \fBxz\fP(1) 보다는 작은 압축 해제 프로그램을 사용해야 할 경우에만 사용하라고 있는 +명령입니다. +.PP +\fBxzdec\fP 과 \fBlzmadec\fP 은 실제로 그렇게 작은건 아닙니다. 컴파일 시간에 liblzma에서 얼마나 기능을 떨궈내느냐에 +따라 더 줄어들 수도 있습니다만, 보통 임베디드 운영체제 배포판이 아닌 경우는 이렇게 할 수가 없습니다. 실제로 작은 \fB.xz\fP 압축 +해제 프로그램이 필요하다면 XZ 임베디드 사용을 고려하십시오. +.SH "추가 참조" +\fBxz\fP(1) +.PP +XZ 임베디드: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xzdiff.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xzdiff.1 new file mode 100644 index 0000000000000000000000000000000000000000..8921034b872e2bef6e5cdcaa1a76d774fe6d8e64 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xzdiff.1 @@ -0,0 +1,52 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Korean translation for the xz-man +.\" Seong-ho Cho , 2023, 2024. +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 2025\-03\-06 Tukaani "XZ 유틸리티" +.SH 이름 +xzcmp, xzdiff, lzcmp, lzdiff \- 압축 파일을 비교합니다 +. +.SH 요약 +\fBxzcmp\fP [\fI<옵션>...\fP] \fI<파일1>\fP [\fI<파일2>\fP] +.br +\fBxzdiff\fP \&... +.br +\fBlzcmp\fP \&... (사용 안 함) +.br +\fBlzdiff\fP \&... (사용 안 함) +. +.SH 설명 +\fBxzcmp\fP 와 \fBxzdiff\fP 명령은 압축 해제한 두 파일의 내용을 비교합니다. 압축 해제한 파일의 데이터와 옵션은 +\fB\-\-help\fP 옵션 또는 \fB\-\-version\fP 옵션을 지정하지 않는다면, \fBcmp\fP(1) 또는 \fBdiff\fP(1) 명령으로 +전달합니다. +.PP +\fI<파일1>\fP 과 \fI<파일2>\fP를 모두 지정했다면, 지정한 파일은 이미 압축해제한 파일이거나, +\fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), \fBlz4\fP(1) 명령으로 +압축해제할 수 있는 형식의 파일일 수 있습니다. 필요한 압축 해제 명령은 \fI<파일1>\fP 과 +\fI<파일2>\fP의 파일 이름 확장자로 결정합니다. 알 수 없는 확장자를 지닌 파일은 이미 압축을 해제했거나 +\fBxz\fP(1) 명령으로 압축 해제할 수 있는 형식으로 간주합니다. +.PP +파일 이름을 하나만 지정한다면, \fI<파일1>\fP의 확장자는 지원 압축 형식의 확장자여야 하며, +\fI<파일2>\fP는 \fI<파일1>\fP에서 압축 파일 확장자를 제거한 파일로 간주합니다. +.PP +\fBlzcmp\fP와 \fBlzdiff\fP 명령은 LZMA 유틸리티 하위 호환용으로 제공합니다. 해당 명령은 오래되어 이후 버전에서 +제거합니다. +. +.SH "종료 상태" +압축 해제 오류가 나타나는 경우, 종료 코드는 \fB2\fP입니다. 그렇지 않을 경우 \fBcmp\fP(1) 또는 \fBdiff\fP(1) 명령의 +종료 코드를 활용합니다. +. +.SH "추가 참조" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xzegrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xzegrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..1953e55b7ca83e45d6ae1adbf39ed80317e913ee --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xzegrep.1 @@ -0,0 +1,85 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Korean translation for the xz-man +.\" Seong-ho Cho , 2023, 2024. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 2025\-03\-06 Tukaani "XZ 유틸리티" +.SH 이름 +xzgrep \- 패턴을 활용하여 가능한 방식으로 압축한 파일의 내용을 검색합니다 +. +.SH 요약 +\fBxzgrep\fP [\fI<옵션>...\fP] [\fI<패턴목록>\fP] [\fI<파일>...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (사용 안 함) +.br +\fBlzegrep\fP \&... (사용 안 함) +.br +\fBlzfgrep\fP \&... (사용 안 함) +. +.SH 설명 +\fBxzgrep\fP은 압축 해제한 파일의 내용에 \fBgrep\fP(1)을 실행합니다. \fI<파일>\fP 형식은 파일 이름 확장으로 +결정합니다. \fI<파일>\fP에서 지원하는 확장자는 \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), +\fBlzop\fP(1), \fBzstd\fP(1), \fBlz4\fP(1)로 압축 해제할 수 있는 파일의 확장자입니다. 다른 파일은 이미 압축을 해제한 +파일로 간주합니다. +.PP +지정한 \fI<파일>\fP이 없거나 \fI<파일>\fP 값이 \fB\-\fP이라면 표준 입력을 읽어들입니다. 표준 입력을 +읽어들일 때, \fBxz\fP(1) 방식으로 압축을 해제하는 파일만 지원합니다. 다른 파일은 이미 압축을 해제한 파일로 간주합니다. +.PP +대부분의 \fBgrep\fP(1)의 \fI<옵션>\fP을 지원합니다. 그러나 다음 옵션은 지원하지 않습니다: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIaction\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIfile\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglob\fP +.PP +\fBxzegrep\fP은 \fBxzgrep \-E\fP 명령의 별칭입니다. \fBxzfgrep\fP은 \fBxzgrep \-F\fP 명령의 별칭입니다. +.PP +\fBlzgrep\fP, \fBlzegrep\fP, \fBlzfgrep\fP 명령은 LZMA 유틸리티 하위 호환용으로 제공합니다. 해당 명령은 오래되어 +이후 버전에서 제거합니다. +. +.SH "종료 상태" +.TP +0 +최소한 하나 이상의 파일에서 하나 이상의 일치하는 결과를 찾았습니다. 오류가 없습니다. +.TP +1 +어떤 입력 파일에서든 일치하는 내용이 없습니다. 오류가 없습니다. +.TP +>1 +하나 이상의 오류가 나타납니다. 일치하는 항목을 찾아낼 지 여부는 알 수 없습니다. +. +.SH 환경 +.TP +\fBGREP\fP +\fBGREP\fP 환경변수 값이 비어있지 않으면, \fBgrep\fP, \fBgrep \-E\fP, \fBgrep \-F\fP 명령 대신 활용합니다. +. +.SH "추가 참조" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xzfgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xzfgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..1953e55b7ca83e45d6ae1adbf39ed80317e913ee --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xzfgrep.1 @@ -0,0 +1,85 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Korean translation for the xz-man +.\" Seong-ho Cho , 2023, 2024. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 2025\-03\-06 Tukaani "XZ 유틸리티" +.SH 이름 +xzgrep \- 패턴을 활용하여 가능한 방식으로 압축한 파일의 내용을 검색합니다 +. +.SH 요약 +\fBxzgrep\fP [\fI<옵션>...\fP] [\fI<패턴목록>\fP] [\fI<파일>...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (사용 안 함) +.br +\fBlzegrep\fP \&... (사용 안 함) +.br +\fBlzfgrep\fP \&... (사용 안 함) +. +.SH 설명 +\fBxzgrep\fP은 압축 해제한 파일의 내용에 \fBgrep\fP(1)을 실행합니다. \fI<파일>\fP 형식은 파일 이름 확장으로 +결정합니다. \fI<파일>\fP에서 지원하는 확장자는 \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), +\fBlzop\fP(1), \fBzstd\fP(1), \fBlz4\fP(1)로 압축 해제할 수 있는 파일의 확장자입니다. 다른 파일은 이미 압축을 해제한 +파일로 간주합니다. +.PP +지정한 \fI<파일>\fP이 없거나 \fI<파일>\fP 값이 \fB\-\fP이라면 표준 입력을 읽어들입니다. 표준 입력을 +읽어들일 때, \fBxz\fP(1) 방식으로 압축을 해제하는 파일만 지원합니다. 다른 파일은 이미 압축을 해제한 파일로 간주합니다. +.PP +대부분의 \fBgrep\fP(1)의 \fI<옵션>\fP을 지원합니다. 그러나 다음 옵션은 지원하지 않습니다: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIaction\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIfile\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglob\fP +.PP +\fBxzegrep\fP은 \fBxzgrep \-E\fP 명령의 별칭입니다. \fBxzfgrep\fP은 \fBxzgrep \-F\fP 명령의 별칭입니다. +.PP +\fBlzgrep\fP, \fBlzegrep\fP, \fBlzfgrep\fP 명령은 LZMA 유틸리티 하위 호환용으로 제공합니다. 해당 명령은 오래되어 +이후 버전에서 제거합니다. +. +.SH "종료 상태" +.TP +0 +최소한 하나 이상의 파일에서 하나 이상의 일치하는 결과를 찾았습니다. 오류가 없습니다. +.TP +1 +어떤 입력 파일에서든 일치하는 내용이 없습니다. 오류가 없습니다. +.TP +>1 +하나 이상의 오류가 나타납니다. 일치하는 항목을 찾아낼 지 여부는 알 수 없습니다. +. +.SH 환경 +.TP +\fBGREP\fP +\fBGREP\fP 환경변수 값이 비어있지 않으면, \fBgrep\fP, \fBgrep \-E\fP, \fBgrep \-F\fP 명령 대신 활용합니다. +. +.SH "추가 참조" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xzgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xzgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..1953e55b7ca83e45d6ae1adbf39ed80317e913ee --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xzgrep.1 @@ -0,0 +1,85 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Korean translation for the xz-man +.\" Seong-ho Cho , 2023, 2024. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 2025\-03\-06 Tukaani "XZ 유틸리티" +.SH 이름 +xzgrep \- 패턴을 활용하여 가능한 방식으로 압축한 파일의 내용을 검색합니다 +. +.SH 요약 +\fBxzgrep\fP [\fI<옵션>...\fP] [\fI<패턴목록>\fP] [\fI<파일>...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (사용 안 함) +.br +\fBlzegrep\fP \&... (사용 안 함) +.br +\fBlzfgrep\fP \&... (사용 안 함) +. +.SH 설명 +\fBxzgrep\fP은 압축 해제한 파일의 내용에 \fBgrep\fP(1)을 실행합니다. \fI<파일>\fP 형식은 파일 이름 확장으로 +결정합니다. \fI<파일>\fP에서 지원하는 확장자는 \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), +\fBlzop\fP(1), \fBzstd\fP(1), \fBlz4\fP(1)로 압축 해제할 수 있는 파일의 확장자입니다. 다른 파일은 이미 압축을 해제한 +파일로 간주합니다. +.PP +지정한 \fI<파일>\fP이 없거나 \fI<파일>\fP 값이 \fB\-\fP이라면 표준 입력을 읽어들입니다. 표준 입력을 +읽어들일 때, \fBxz\fP(1) 방식으로 압축을 해제하는 파일만 지원합니다. 다른 파일은 이미 압축을 해제한 파일로 간주합니다. +.PP +대부분의 \fBgrep\fP(1)의 \fI<옵션>\fP을 지원합니다. 그러나 다음 옵션은 지원하지 않습니다: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIaction\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIfile\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglob\fP +.PP +\fBxzegrep\fP은 \fBxzgrep \-E\fP 명령의 별칭입니다. \fBxzfgrep\fP은 \fBxzgrep \-F\fP 명령의 별칭입니다. +.PP +\fBlzgrep\fP, \fBlzegrep\fP, \fBlzfgrep\fP 명령은 LZMA 유틸리티 하위 호환용으로 제공합니다. 해당 명령은 오래되어 +이후 버전에서 제거합니다. +. +.SH "종료 상태" +.TP +0 +최소한 하나 이상의 파일에서 하나 이상의 일치하는 결과를 찾았습니다. 오류가 없습니다. +.TP +1 +어떤 입력 파일에서든 일치하는 내용이 없습니다. 오류가 없습니다. +.TP +>1 +하나 이상의 오류가 나타납니다. 일치하는 항목을 찾아낼 지 여부는 알 수 없습니다. +. +.SH 환경 +.TP +\fBGREP\fP +\fBGREP\fP 환경변수 값이 비어있지 않으면, \fBgrep\fP, \fBgrep \-E\fP, \fBgrep \-F\fP 명령 대신 활용합니다. +. +.SH "추가 참조" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xzless.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xzless.1 new file mode 100644 index 0000000000000000000000000000000000000000..b439e657feb29c5a3884f6f4fefa17f24dfafdeb --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xzless.1 @@ -0,0 +1,41 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" Korean translation for the xz-man +.\" Seong-ho Cho , 2023, 2024. +.\" +.\" (Note that this file is not based on gzip's zless.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZLESS 1 2025\-03\-06 Tukaani "XZ 유틸리티" +.SH 이름 +xzless, lzless \- xz 또는 lzma 압축 (텍스트) 파일을 봅니다 +.SH 요약 +\fBxzless\fP [\fI<파일>\fP...] +.br +\fBlzless\fP [\fIfile\fP...] (사용 안 함) +.SH 설명 +\fBxzless\fP는 압축 파일 내용을 터미널에 나타내는 필터 프로그램입니다. \fBxz\fP(1) 방식으로 압축을 해제하는 파일만 +지원합니다. 다른 파일은 이미 압축을 해제한 파일로 간주합니다. 주어진 \fI<파일>\fP 값이 없다면, \fBxzless\fP는 +표준 입력을 읽어들입니다. +.PP +\fBxzless\fP 는 \fBless\fP(1) 를 사용하여 출력을 막습니다. \fBxzmore\fP 와는 다르게, 환경 변수 설정으로 선택한 +페이저를 바꿀 수 없습니다. 명령은 \fBmore\fP(1) 와 \fBvi\fP(1) 가 기반이며, 앞뒤로 움직이고 검색할 수 있습니다. +자세한 정보는 \fBless\fP(1) 설명서를 참고하십시오. +.PP +\fBlzless\fP 명령은 LZMA 유틸리티 하위 호환용으로 제공합니다. 해당 명령은 오래되어 이후 버전에서 제거합니다. +.SH 환경 +.TP +\fBLESSMETACHARS\fP +셸에서 동작할 수도 있는 특수 문자 목록입니다. 환경에 미리 설정해두지 않았다면 \fBxzless\fP에서 설정합니다. +.TP +\fBLESSOPEN\fP +입력 파일을 \fBless\fP(1) 에 전달하기 전에 \fBxz\fP(1) 압축 해제 프로그램을 실행해서 미리 처리하는 명령행을 설정합니다. +.SH "추가 참조" +\fBless\fP(1), \fBxz\fP(1), \fBxzmore\fP(1), \fBzless\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xzmore.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xzmore.1 new file mode 100644 index 0000000000000000000000000000000000000000..1c6ab445fefb50b6630f9f8aef0ee8f03ad63de3 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ko/man1/xzmore.1 @@ -0,0 +1,44 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" Korean translation for the xz-man +.\" Seong-ho Cho , 2023, 2024. +.\" +.\" (Note that this file is based on xzless.1 instead of gzip's zmore.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZMORE 1 2025\-03\-06 Tukaani "XZ 유틸리티" +.SH 이름 +xzmore, lzmore \- xz 압축 (텍스트) 파일 또는 lzma 압축 (텍스트) 파일을 봅니다 +. +.SH 요약 +\fBxzmore\fP [\fI<파일>\fP...] +.br +\fBlzmore\fP [\fIfile\fP...] (사용 안 함) +. +.SH 설명 +\fBxzmore\fP 명령은 압축 파일에 들어있는 텍스트를 \fBmore\fP(1) 명령으로 터미널에 나타냅니다. \fBxz\fP(1) 방식으로 +압축을 해제하는 파일만 지원합니다. 다른 파일은 이미 압축을 해제한 파일로 간주합니다. \fI<파일>\fP을 지정하지 +않으면, \fBxzmore\fP 프로그램에서는 표준 입력을 읽어들입니다. 키보드 명령 정보는 \fBmore\fP(1) 설명서를 참고하십시오. +.PP +참고로 \fBmore\fP(1) 명령 구현체에 따라 반대 방향(윗방향)으로의 스크롤은 못할 수도 있습니다. \fBxzmore\fP 명령이 +\fBmore\fP(1) 명령에 압축 해제한 데이터를 파이프로 전달하기 때문입니다. \fBxzless\fP(1)는 좀 더 나은 기능을 가진 +\fBless\fP(1) 명령을 활용합니다. +.PP +\fBlzmore\fP 명령은 LZMA 유틸리티 하위 호환용으로 제공합니다. 해당 명령은 오래되어 이후 버전에서 제거합니다. +. +.SH 환경 +.TP +.\" TRANSLATORS: Don't translate the uppercase PAGER. +.\" It is a name of an environment variable. +\fBPAGER\fP +\fBPAGER\fP 환경변수 값을 설정했다면, \fBmore\fP(1) 대신 해당 환경변수 값을 화면 표시 프로그램으로 사용합니다. +. +.SH "추가 참조" +\fBmore\fP(1), \fBxz\fP(1), \fBxzless\fP(1), \fBzmore\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzcat.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzcat.1 new file mode 100644 index 0000000000000000000000000000000000000000..6e37b426a3b5c85552cf006f388c9a71d4ad5685 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzcat.1 @@ -0,0 +1,3264 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.TH XZ 1 "2025-03-08" "Tukaani" "XZ Utils" +. +.SH NAME +xz, unxz, xzcat, lzma, unlzma, lzcat \- Compress or decompress .xz and .lzma files +. +.SH SYNOPSIS +.B xz +.RI [ option... ] +.RI [ file... ] +. +.SH COMMAND ALIASES +.B unxz +is equivalent to +.BR "xz \-\-decompress" . +.br +.B xzcat +is equivalent to +.BR "xz \-\-decompress \-\-stdout" . +.br +.B lzma +is equivalent to +.BR "xz \-\-format=lzma" . +.br +.B unlzma +is equivalent to +.BR "xz \-\-format=lzma \-\-decompress" . +.br +.B lzcat +is equivalent to +.BR "xz \-\-format=lzma \-\-decompress \-\-stdout" . +.PP +When writing scripts that need to decompress files, +it is recommended to always use the name +.B xz +with appropriate arguments +.RB ( "xz \-d" +or +.BR "xz \-dc" ) +instead of the names +.B unxz +and +.BR xzcat . +. +.SH DESCRIPTION +.B xz +is a general-purpose data compression tool with +command line syntax similar to +.BR gzip (1) +and +.BR bzip2 (1). +The native file format is the +.B .xz +format, but the legacy +.B .lzma +format used by LZMA Utils and +raw compressed streams with no container format headers +are also supported. +In addition, decompression of the +.B .lz +format used by +.B lzip +is supported. +.PP +.B xz +compresses or decompresses each +.I file +according to the selected operation mode. +If no +.I files +are given or +.I file +is +.BR \- , +.B xz +reads from standard input and writes the processed data +to standard output. +.B xz +will refuse (display an error and skip the +.IR file ) +to write compressed data to standard output if it is a terminal. +Similarly, +.B xz +will refuse to read compressed data +from standard input if it is a terminal. +.PP +Unless +.B \-\-stdout +is specified, +.I files +other than +.B \- +are written to a new file whose name is derived from the source +.I file +name: +.IP \(bu 3 +When compressing, the suffix of the target file format +.RB ( .xz +or +.BR .lzma ) +is appended to the source filename to get the target filename. +.IP \(bu 3 +When decompressing, the +.BR .xz , +.BR .lzma , +or +.B .lz +suffix is removed from the filename to get the target filename. +.B xz +also recognizes the suffixes +.B .txz +and +.BR .tlz , +and replaces them with the +.B .tar +suffix. +.PP +If the target file already exists, an error is displayed and the +.I file +is skipped. +.PP +Unless writing to standard output, +.B xz +will display a warning and skip the +.I file +if any of the following applies: +.IP \(bu 3 +.I File +is not a regular file. +Symbolic links are not followed, +and thus they are not considered to be regular files. +.IP \(bu 3 +.I File +has more than one hard link. +.IP \(bu 3 +.I File +has setuid, setgid, or sticky bit set. +.IP \(bu 3 +The operation mode is set to compress and the +.I file +already has a suffix of the target file format +.RB ( .xz +or +.B .txz +when compressing to the +.B .xz +format, and +.B .lzma +or +.B .tlz +when compressing to the +.B .lzma +format). +.IP \(bu 3 +The operation mode is set to decompress and the +.I file +doesn't have a suffix of any of the supported file formats +.RB ( .xz , +.BR .txz , +.BR .lzma , +.BR .tlz , +or +.BR .lz ). +.PP +After successfully compressing or decompressing the +.IR file , +.B xz +copies the owner, group, permissions, access time, +and modification time from the source +.I file +to the target file. +If copying the group fails, the permissions are modified +so that the target file doesn't become accessible to users +who didn't have permission to access the source +.IR file . +.B xz +doesn't support copying other metadata like access control lists +or extended attributes yet. +.PP +Once the target file has been successfully closed, the source +.I file +is removed unless +.B \-\-keep +was specified. +The source +.I file +is never removed if the output is written to standard output +or if an error occurs. +.PP +Sending +.B SIGINFO +or +.B SIGUSR1 +to the +.B xz +process makes it print progress information to standard error. +This has only limited use since when standard error +is a terminal, using +.B \-\-verbose +will display an automatically updating progress indicator. +. +.SS "Memory usage" +The memory usage of +.B xz +varies from a few hundred kilobytes to several gigabytes +depending on the compression settings. +The settings used when compressing a file determine +the memory requirements of the decompressor. +Typically the decompressor needs 5\ % to 20\ % of +the amount of memory that the compressor needed when +creating the file. +For example, decompressing a file created with +.B xz \-9 +currently requires 65\ MiB of memory. +Still, it is possible to have +.B .xz +files that require several gigabytes of memory to decompress. +.PP +Especially users of older systems may find +the possibility of very large memory usage annoying. +To prevent uncomfortable surprises, +.B xz +has a built-in memory usage limiter, which is disabled by default. +While some operating systems provide ways to limit +the memory usage of processes, relying on it +wasn't deemed to be flexible enough (for example, using +.BR ulimit (1) +to limit virtual memory tends to cripple +.BR mmap (2)). +.PP +The memory usage limiter can be enabled with +the command line option \fB\-\-memlimit=\fIlimit\fR. +Often it is more convenient to enable the limiter +by default by setting the environment variable +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +.BR XZ_DEFAULTS , +for example, +.BR XZ_DEFAULTS=\-\-memlimit=150MiB . +It is possible to set the limits separately +for compression and decompression by using +.BI \-\-memlimit\-compress= limit +and \fB\-\-memlimit\-decompress=\fIlimit\fR. +Using these two options outside +.B XZ_DEFAULTS +is rarely useful because a single run of +.B xz +cannot do both compression and decompression and +.BI \-\-memlimit= limit +(or +.B \-M +.IR limit ) +is shorter to type on the command line. +.PP +If the specified memory usage limit is exceeded when decompressing, +.B xz +will display an error and decompressing the file will fail. +If the limit is exceeded when compressing, +.B xz +will try to scale the settings down so that the limit +is no longer exceeded (except when using +.B \-\-format=raw +or +.BR \-\-no\-adjust ). +This way the operation won't fail unless the limit is very small. +The scaling of the settings is done in steps that don't +match the compression level presets, for example, if the limit is +only slightly less than the amount required for +.BR "xz \-9" , +the settings will be scaled down only a little, +not all the way down to +.BR "xz \-8" . +. +.SS "Concatenation and padding with .xz files" +It is possible to concatenate +.B .xz +files as is. +.B xz +will decompress such files as if they were a single +.B .xz +file. +.PP +It is possible to insert padding between the concatenated parts +or after the last part. +The padding must consist of null bytes and the size +of the padding must be a multiple of four bytes. +This can be useful, for example, if the +.B .xz +file is stored on a medium that measures file sizes +in 512-byte blocks. +.PP +Concatenation and padding are not allowed with +.B .lzma +files or raw streams. +. +.SH OPTIONS +. +.SS "Integer suffixes and special values" +In most places where an integer argument is expected, +an optional suffix is supported to easily indicate large integers. +There must be no space between the integer and the suffix. +.TP +.B KiB +Multiply the integer by 1,024 (2^10). +.BR Ki , +.BR k , +.BR kB , +.BR K , +and +.B KB +are accepted as synonyms for +.BR KiB . +.TP +.B MiB +Multiply the integer by 1,048,576 (2^20). +.BR Mi , +.BR m , +.BR M , +and +.B MB +are accepted as synonyms for +.BR MiB . +.TP +.B GiB +Multiply the integer by 1,073,741,824 (2^30). +.BR Gi , +.BR g , +.BR G , +and +.B GB +are accepted as synonyms for +.BR GiB . +.PP +The special value +.B max +can be used to indicate the maximum integer value +supported by the option. +. +.SS "Operation mode" +If multiple operation mode options are given, +the last one takes effect. +.TP +.BR \-z ", " \-\-compress +Compress. +This is the default operation mode when no operation mode option +is specified and no other operation mode is implied from +the command name (for example, +.B unxz +implies +.BR \-\-decompress ). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +After successful compression, the source file is removed +unless writing to standard output or +.B \-\-keep +was specified. +.TP +.BR \-d ", " \-\-decompress ", " \-\-uncompress +Decompress. +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +After successful decompression, the source file is removed +unless writing to standard output or +.B \-\-keep +was specified. +.TP +.BR \-t ", " \-\-test +Test the integrity of compressed +.IR files . +This option is equivalent to +.B "\-\-decompress \-\-stdout" +except that the decompressed data is discarded instead of being +written to standard output. +No files are created or removed. +.TP +.BR \-l ", " \-\-list +Print information about compressed +.IR files . +No uncompressed output is produced, +and no files are created or removed. +In list mode, the program cannot read +the compressed data from standard +input or from other unseekable sources. +.IP "" +The default listing shows basic information about +.IR files , +one file per line. +To get more detailed information, use also the +.B \-\-verbose +option. +For even more information, use +.B \-\-verbose +twice, but note that this may be slow, because getting all the extra +information requires many seeks. +The width of verbose output exceeds +80 characters, so piping the output to, for example, +.B "less\ \-S" +may be convenient if the terminal isn't wide enough. +.IP "" +The exact output may vary between +.B xz +versions and different locales. +For machine-readable output, +.B \-\-robot \-\-list +should be used. +. +.SS "Operation modifiers" +.TP +.BR \-k ", " \-\-keep +Don't delete the input files. +.IP "" +Since +.B xz +5.2.6, +this option also makes +.B xz +compress or decompress even if the input is +a symbolic link to a regular file, +has more than one hard link, +or has the setuid, setgid, or sticky bit set. +The setuid, setgid, and sticky bits are not copied +to the target file. +In earlier versions this was only done with +.BR \-\-force . +.TP +.BR \-f ", " \-\-force +This option has several effects: +.RS +.IP \(bu 3 +If the target file already exists, +delete it before compressing or decompressing. +.IP \(bu 3 +Compress or decompress even if the input is +a symbolic link to a regular file, +has more than one hard link, +or has the setuid, setgid, or sticky bit set. +The setuid, setgid, and sticky bits are not copied +to the target file. +.IP \(bu 3 +When used with +.B \-\-decompress +.B \-\-stdout +and +.B xz +cannot recognize the type of the source file, +copy the source file as is to standard output. +This allows +.B xzcat +.B \-\-force +to be used like +.BR cat (1) +for files that have not been compressed with +.BR xz . +Note that in future, +.B xz +might support new compressed file formats, which may make +.B xz +decompress more types of files instead of copying them as is to +standard output. +.BI \-\-format= format +can be used to restrict +.B xz +to decompress only a single file format. +.RE +.TP +.BR \-c ", " \-\-stdout ", " \-\-to\-stdout +Write the compressed or decompressed data to +standard output instead of a file. +This implies +.BR \-\-keep . +.TP +.B \-\-single\-stream +Decompress only the first +.B .xz +stream, and +silently ignore possible remaining input data following the stream. +Normally such trailing garbage makes +.B xz +display an error. +.IP "" +.B xz +never decompresses more than one stream from +.B .lzma +files or raw streams, but this option still makes +.B xz +ignore the possible trailing data after the +.B .lzma +file or raw stream. +.IP "" +This option has no effect if the operation mode is not +.B \-\-decompress +or +.BR \-\-test . +.IP "" +Since +.B xz +5.7.1alpha, +.B \-\-single\-stream +implies +.BR \-\-keep . +.TP +.B \-\-no\-sparse +Disable creation of sparse files. +By default, if decompressing into a regular file, +.B xz +tries to make the file sparse if the decompressed data contains +long sequences of binary zeros. +It also works when writing to standard output +as long as standard output is connected to a regular file +and certain additional conditions are met to make it safe. +Creating sparse files may save disk space and speed up +the decompression by reducing the amount of disk I/O. +.TP +\fB\-S\fR \fI.suf\fR, \fB\-\-suffix=\fI.suf +When compressing, use +.I .suf +as the suffix for the target file instead of +.B .xz +or +.BR .lzma . +If not writing to standard output and +the source file already has the suffix +.IR .suf , +a warning is displayed and the file is skipped. +.IP "" +When decompressing, recognize files with the suffix +.I .suf +in addition to files with the +.BR .xz , +.BR .txz , +.BR .lzma , +.BR .tlz , +or +.B .lz +suffix. +If the source file has the suffix +.IR .suf , +the suffix is removed to get the target filename. +.IP "" +When compressing or decompressing raw streams +.RB ( \-\-format=raw ), +the suffix must always be specified unless +writing to standard output, +because there is no default suffix for raw streams. +.TP +\fB\-\-files\fR[\fB=\fIfile\fR] +Read the filenames to process from +.IR file ; +if +.I file +is omitted, filenames are read from standard input. +Filenames must be terminated with the newline character. +A dash +.RB ( \- ) +is taken as a regular filename; it doesn't mean standard input. +If filenames are given also as command line arguments, they are +processed before the filenames read from +.IR file . +.TP +\fB\-\-files0\fR[\fB=\fIfile\fR] +This is identical to \fB\-\-files\fR[\fB=\fIfile\fR] except +that each filename must be terminated with the null character. +. +.SS "Basic file format and compression options" +.TP +\fB\-F\fR \fIformat\fR, \fB\-\-format=\fIformat +Specify the file +.I format +to compress or decompress: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +.B auto +This is the default. +When compressing, +.B auto +is equivalent to +.BR xz . +When decompressing, +the format of the input file is automatically detected. +Note that raw streams (created with +.BR \-\-format=raw ) +cannot be auto-detected. +.TP +.B xz +Compress to the +.B .xz +file format, or accept only +.B .xz +files when decompressing. +.TP +.BR lzma ", " alone +Compress to the legacy +.B .lzma +file format, or accept only +.B .lzma +files when decompressing. +The alternative name +.B alone +is provided for backwards compatibility with LZMA Utils. +.TP +.B lzip +Accept only +.B .lz +files when decompressing. +Compression is not supported. +.IP "" +The +.B .lz +format versions 0 and 1 are supported. +Version 0 files were produced by +.B lzip +1.3 and older. +Such files aren't common but may be found from file archives +as a few source packages were released in this format. +People might have old personal files in this format too. +Decompression support for the format version 0 was removed in +.B lzip +1.18. +.B lzip +1.4 and later create files in the format version 1. +.TP +.B raw +Compress or uncompress a raw stream (no headers). +This is meant for advanced users only. +To decode raw streams, you need use +.B \-\-format=raw +and explicitly specify the filter chain, +which normally would have been stored in the container headers. +.RE +.TP +\fB\-C\fR \fIcheck\fR, \fB\-\-check=\fIcheck +Specify the type of the integrity check. +The check is calculated from the uncompressed data and +stored in the +.B .xz +file. +This option has an effect only when compressing into the +.B .xz +format; the +.B .lzma +format doesn't support integrity checks. +The integrity check (if any) is verified when the +.B .xz +file is decompressed. +.IP "" +Supported +.I check +types: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +.B none +Don't calculate an integrity check at all. +This is usually a bad idea. +This can be useful when integrity of the data is verified +by other means anyway. +.TP +.B crc32 +Calculate CRC32 using the polynomial from IEEE-802.3 (Ethernet). +.TP +.B crc64 +Calculate CRC64 using the polynomial from ECMA-182. +This is the default, since it is slightly better than CRC32 +at detecting damaged files and the speed difference is negligible. +.TP +.B sha256 +Calculate SHA-256. +This is somewhat slower than CRC32 and CRC64. +.RE +.IP "" +Integrity of the +.B .xz +headers is always verified with CRC32. +It is not possible to change or disable it. +.TP +.B \-\-ignore\-check +Don't verify the integrity check of the compressed data when decompressing. +The CRC32 values in the +.B .xz +headers will still be verified normally. +.IP "" +.B "Do not use this option unless you know what you are doing." +Possible reasons to use this option: +.RS +.IP \(bu 3 +Trying to recover data from a corrupt .xz file. +.IP \(bu 3 +Speeding up decompression. +This matters mostly with SHA-256 or +with files that have compressed extremely well. +It's recommended to not use this option for this purpose +unless the file integrity is verified externally in some other way. +.RE +.TP +.BR \-0 " ... " \-9 +Select a compression preset level. +The default is +.BR \-6 . +If multiple preset levels are specified, +the last one takes effect. +If a custom filter chain was already specified, setting +a compression preset level clears the custom filter chain. +.IP "" +The differences between the presets are more significant than with +.BR gzip (1) +and +.BR bzip2 (1). +The selected compression settings determine +the memory requirements of the decompressor, +thus using a too high preset level might make it painful +to decompress the file on an old system with little RAM. +Specifically, +.B "it's not a good idea to blindly use \-9 for everything" +like it often is with +.BR gzip (1) +and +.BR bzip2 (1). +.RS +.TP +.BR "\-0" " ... " "\-3" +These are somewhat fast presets. +.B \-0 +is sometimes faster than +.B "gzip \-9" +while compressing much better. +The higher ones often have speed comparable to +.BR bzip2 (1) +with comparable or better compression ratio, +although the results +depend a lot on the type of data being compressed. +.TP +.BR "\-4" " ... " "\-6" +Good to very good compression while keeping +decompressor memory usage reasonable even for old systems. +.B \-6 +is the default, which is usually a good choice +for distributing files that need to be decompressible +even on systems with only 16\ MiB RAM. +.RB ( \-5e +or +.B \-6e +may be worth considering too. +See +.BR \-\-extreme .) +.TP +.B "\-7 ... \-9" +These are like +.B \-6 +but with higher compressor and decompressor memory requirements. +These are useful only when compressing files bigger than +8\ MiB, 16\ MiB, and 32\ MiB, respectively. +.RE +.IP "" +On the same hardware, the decompression speed is approximately +a constant number of bytes of compressed data per second. +In other words, the better the compression, +the faster the decompression will usually be. +This also means that the amount of uncompressed output +produced per second can vary a lot. +.IP "" +The following table summarises the features of the presets: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Preset;DictSize;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Column descriptions: +.RS +.IP \(bu 3 +DictSize is the LZMA2 dictionary size. +It is waste of memory to use a dictionary bigger than +the size of the uncompressed file. +This is why it is good to avoid using the presets +.BR \-7 " ... " \-9 +when there's no real need for them. +At +.B \-6 +and lower, the amount of memory wasted is +usually low enough to not matter. +.IP \(bu 3 +CompCPU is a simplified representation of the LZMA2 settings +that affect compression speed. +The dictionary size affects speed too, +so while CompCPU is the same for levels +.BR \-6 " ... " \-9 , +higher levels still tend to be a little slower. +To get even slower and thus possibly better compression, see +.BR \-\-extreme . +.IP \(bu 3 +CompMem contains the compressor memory requirements +in the single-threaded mode. +It may vary slightly between +.B xz +versions. +.IP \(bu 3 +DecMem contains the decompressor memory requirements. +That is, the compression settings determine +the memory requirements of the decompressor. +The exact decompressor memory usage is slightly more than +the LZMA2 dictionary size, but the values in the table +have been rounded up to the next full MiB. +.RE +.IP "" +Memory requirements of the multi-threaded mode are +significantly higher than that of the single-threaded mode. +With the default value of +.BR \-\-block\-size , +each thread needs 3*3*DictSize plus CompMem or DecMem. +For example, four threads with preset +.B \-6 +needs 660\(en670\ MiB of memory. +.TP +.BR \-e ", " \-\-extreme +Use a slower variant of the selected compression preset level +.RB ( \-0 " ... " \-9 ) +to hopefully get a little bit better compression ratio, +but with bad luck this can also make it worse. +Decompressor memory usage is not affected, +but compressor memory usage increases a little at preset levels +.BR \-0 " ... " \-3 . +.IP "" +Since there are two presets with dictionary sizes +4\ MiB and 8\ MiB, the presets +.B \-3e +and +.B \-5e +use slightly faster settings (lower CompCPU) than +.B \-4e +and +.BR \-6e , +respectively. +That way no two presets are identical. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Preset;DictSize;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +For example, there are a total of four presets that use +8\ MiB dictionary, whose order from the fastest to the slowest is +.BR \-5 , +.BR \-6 , +.BR \-5e , +and +.BR \-6e . +.TP +.B \-\-fast +.PD 0 +.TP +.B \-\-best +.PD +These are somewhat misleading aliases for +.B \-0 +and +.BR \-9 , +respectively. +These are provided only for backwards compatibility +with LZMA Utils. +Avoid using these options. +.TP +.BI \-\-block\-size= size +When compressing to the +.B .xz +format, split the input data into blocks of +.I size +bytes. +The blocks are compressed independently from each other, +which helps with multi-threading and +makes limited random-access decompression possible. +This option is typically used to override the default +block size in multi-threaded mode, +but this option can be used in single-threaded mode too. +.IP "" +In multi-threaded mode about three times +.I size +bytes will be allocated in each thread for buffering input and output. +The default +.I size +is three times the LZMA2 dictionary size or 1 MiB, +whichever is more. +Typically a good value is 2\(en4 times +the size of the LZMA2 dictionary or at least 1 MiB. +Using +.I size +less than the LZMA2 dictionary size is waste of RAM +because then the LZMA2 dictionary buffer will never get fully used. +In multi-threaded mode, +the sizes of the blocks are stored in the block headers. +This size information is required for multi-threaded decompression. +.IP "" +In single-threaded mode no block splitting is done by default. +Setting this option doesn't affect memory usage. +No size information is stored in block headers, +thus files created in single-threaded mode +won't be identical to files created in multi-threaded mode. +The lack of size information also means that +.B xz +won't be able decompress the files in multi-threaded mode. +.TP +.BI \-\-block\-list= items +When compressing to the +.B .xz +format, start a new block with an optional custom filter chain after +the given intervals of uncompressed data. +.IP "" +The +.I items +are a comma-separated list. +Each item consists of an optional filter chain number +between 0 and 9 followed by a colon +.RB ( : ) +and a required size of uncompressed data. +Omitting an item (two or more consecutive commas) is a +shorthand to use the size and filters of the previous item. +.IP "" +If the input file is bigger than the sum of +the sizes in +.IR items , +the last item is repeated until the end of the file. +A special value of +.B 0 +may be used as the last size to indicate that +the rest of the file should be encoded as a single block. +.IP "" +An alternative filter chain for each block can be +specified in combination with the +.BI \-\-filters1= filters +\&...\& +.BI \-\-filters9= filters +options. +These options define filter chains with an identifier +between 1\(en9. +Filter chain 0 can be used to refer to the default filter chain, +which is the same as not specifying a filter chain. +The filter chain identifier can be used before the uncompressed +size, followed by a colon +.RB ( : ). +For example, if one specifies +.B \-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB +then blocks will be created using: +.RS +.IP \(bu 3 +The filter chain specified by +.B \-\-filters1 +and 2 MiB input +.IP \(bu 3 +The filter chain specified by +.B \-\-filters3 +and 2 MiB input +.IP \(bu 3 +The filter chain specified by +.B \-\-filters2 +and 4 MiB input +.IP \(bu 3 +The filter chain specified by +.B \-\-filters2 +and 4 MiB input +.IP \(bu 3 +The default filter chain and 2 MiB input +.IP \(bu 3 +The default filter chain and 4 MiB input for every block until +end of input. +.RE +.IP "" +If one specifies a size that exceeds the encoder's block size +(either the default value in threaded mode or +the value specified with \fB\-\-block\-size=\fIsize\fR), +the encoder will create additional blocks while +keeping the boundaries specified in +.IR items . +For example, if one specifies +.B \-\-block\-size=10MiB +.B \-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB +and the input file is 80 MiB, +one will get 11 blocks: +5, 10, 8, 10, 2, 10, 10, 4, 10, 10, and 1 MiB. +.IP "" +In multi-threaded mode the sizes of the blocks +are stored in the block headers. +This isn't done in single-threaded mode, +so the encoded output won't be +identical to that of the multi-threaded mode. +.TP +.BI \-\-flush\-timeout= timeout +When compressing, if more than +.I timeout +milliseconds (a positive integer) has passed since the previous flush and +reading more input would block, +all the pending input data is flushed from the encoder and +made available in the output stream. +This can be useful if +.B xz +is used to compress data that is streamed over a network. +Small +.I timeout +values make the data available at the receiving end +with a small delay, but large +.I timeout +values give better compression ratio. +.IP "" +This feature is disabled by default. +If this option is specified more than once, the last one takes effect. +The special +.I timeout +value of +.B 0 +can be used to explicitly disable this feature. +.IP "" +This feature is not available on non-POSIX systems. +.IP "" +.\" FIXME +.B "This feature is still experimental." +Currently +.B xz +is unsuitable for decompressing the stream in real time due to how +.B xz +does buffering. +.TP +.B \-\-no\-sync +Do not synchronize the target file and its directory +to the storage device before removing the source file. +This can improve performance if compressing or decompressing +many small files. +However, if the system crashes soon after the deletion, +it is possible that the target file was not written +to the storage device but the delete operation was. +In that case neither the original source file +nor the target file is available. +.IP "" +This option has an effect only when +.B xz +is going to remove the source file. +In other cases synchronization is never done. +.IP "" +The synchronization and +.B \-\-no\-sync +were added in +.B xz +5.7.1alpha. +.TP +.BI \-\-memlimit\-compress= limit +Set a memory usage limit for compression. +If this option is specified multiple times, +the last one takes effect. +.IP "" +If the compression settings exceed the +.IR limit , +.B xz +will attempt to adjust the settings downwards so that +the limit is no longer exceeded and display a notice that +automatic adjustment was done. +The adjustments are done in this order: +reducing the number of threads, +switching to single-threaded mode +if even one thread in multi-threaded mode exceeds the +.IR limit , +and finally reducing the LZMA2 dictionary size. +.IP "" +When compressing with +.B \-\-format=raw +or if +.B \-\-no\-adjust +has been specified, +only the number of threads may be reduced +since it can be done without affecting the compressed output. +.IP "" +If the +.I limit +cannot be met even with the adjustments described above, +an error is displayed and +.B xz +will exit with exit status 1. +.IP "" +The +.I limit +can be specified in multiple ways: +.RS +.IP \(bu 3 +The +.I limit +can be an absolute value in bytes. +Using an integer suffix like +.B MiB +can be useful. +Example: +.B "\-\-memlimit\-compress=80MiB" +.IP \(bu 3 +The +.I limit +can be specified as a percentage of total physical memory (RAM). +This can be useful especially when setting the +.B XZ_DEFAULTS +environment variable in a shell initialization script +that is shared between different computers. +That way the limit is automatically bigger +on systems with more memory. +Example: +.B "\-\-memlimit\-compress=70%" +.IP \(bu 3 +The +.I limit +can be reset back to its default value by setting it to +.BR 0 . +This is currently equivalent to setting the +.I limit +to +.B max +(no memory usage limit). +.RE +.IP "" +For 32-bit +.B xz +there is a special case: if the +.I limit +would be over +.BR "4020\ MiB" , +the +.I limit +is set to +.BR "4020\ MiB" . +On MIPS32 +.B "2000\ MiB" +is used instead. +(The values +.B 0 +and +.B max +aren't affected by this. +A similar feature doesn't exist for decompression.) +This can be helpful when a 32-bit executable has access +to 4\ GiB address space (2 GiB on MIPS32) +while hopefully doing no harm in other situations. +.IP "" +See also the section +.BR "Memory usage" . +.TP +.BI \-\-memlimit\-decompress= limit +Set a memory usage limit for decompression. +This also affects the +.B \-\-list +mode. +If the operation is not possible without exceeding the +.IR limit , +.B xz +will display an error and decompressing the file will fail. +See +.BI \-\-memlimit\-compress= limit +for possible ways to specify the +.IR limit . +.TP +.BI \-\-memlimit\-mt\-decompress= limit +Set a memory usage limit for multi-threaded decompression. +This can only affect the number of threads; +this will never make +.B xz +refuse to decompress a file. +If +.I limit +is too low to allow any multi-threading, the +.I limit +is ignored and +.B xz +will continue in single-threaded mode. +Note that if also +.B \-\-memlimit\-decompress +is used, +it will always apply to both single-threaded and multi-threaded modes, +and so the effective +.I limit +for multi-threading will never be higher than the limit set with +.BR \-\-memlimit\-decompress . +.IP "" +In contrast to the other memory usage limit options, +.BI \-\-memlimit\-mt\-decompress= limit +has a system-specific default +.IR limit . +.B "xz \-\-info\-memory" +can be used to see the current value. +.IP "" +This option and its default value exist +because without any limit the threaded decompressor +could end up allocating an insane amount of memory with some input files. +If the default +.I limit +is too low on your system, +feel free to increase the +.I limit +but never set it to a value larger than the amount of usable RAM +as with appropriate input files +.B xz +will attempt to use that amount of memory +even with a low number of threads. +Running out of memory or swapping +will not improve decompression performance. +.IP "" +See +.BI \-\-memlimit\-compress= limit +for possible ways to specify the +.IR limit . +Setting +.I limit +to +.B 0 +resets the +.I limit +to the default system-specific value. +.TP +\fB\-M\fR \fIlimit\fR, \fB\-\-memlimit=\fIlimit\fR, \fB\-\-memory=\fIlimit +This is equivalent to specifying +.BI \-\-memlimit\-compress= limit +.BI \-\-memlimit-decompress= limit +\fB\-\-memlimit\-mt\-decompress=\fIlimit\fR. +.TP +.B \-\-no\-adjust +Display an error and exit if the memory usage limit cannot be +met without adjusting settings that affect the compressed output. +That is, this prevents +.B xz +from switching the encoder from multi-threaded mode to single-threaded mode +and from reducing the LZMA2 dictionary size. +Even when this option is used the number of threads may be reduced +to meet the memory usage limit as that won't affect the compressed output. +.IP "" +Automatic adjusting is always disabled when creating raw streams +.RB ( \-\-format=raw ). +.TP +\fB\-T\fR \fIthreads\fR, \fB\-\-threads=\fIthreads +Specify the number of worker threads to use. +Setting +.I threads +to a special value +.B 0 +makes +.B xz +use up to as many threads as the processor(s) on the system support. +The actual number of threads can be fewer than +.I threads +if the input file is not big enough +for threading with the given settings or +if using more threads would exceed the memory usage limit. +.IP "" +The single-threaded and multi-threaded compressors produce different output. +Single-threaded compressor will give the smallest file size but +only the output from the multi-threaded compressor can be decompressed +using multiple threads. +Setting +.I threads +to +.B 1 +will use the single-threaded mode. +Setting +.I threads +to any other value, including +.BR 0 , +will use the multi-threaded compressor +even if the system supports only one hardware thread. +.RB ( xz +5.2.x +used single-threaded mode in this situation.) +.IP "" +To use multi-threaded mode with only one thread, set +.I threads +to +.BR +1 . +The +.B + +prefix has no effect with values other than +.BR 1 . +A memory usage limit can still make +.B xz +switch to single-threaded mode unless +.B \-\-no\-adjust +is used. +Support for the +.B + +prefix was added in +.B xz +5.4.0. +.IP "" +If an automatic number of threads has been requested and +no memory usage limit has been specified, +then a system-specific default soft limit will be used to possibly +limit the number of threads. +It is a soft limit in sense that it is ignored +if the number of threads becomes one, +thus a soft limit will never stop +.B xz +from compressing or decompressing. +This default soft limit will not make +.B xz +switch from multi-threaded mode to single-threaded mode. +The active limits can be seen with +.BR "xz \-\-info\-memory" . +.IP "" +Currently the only threading method is to split the input into +blocks and compress them independently from each other. +The default block size depends on the compression level and +can be overridden with the +.BI \-\-block\-size= size +option. +.IP "" +Threaded decompression only works on files that contain +multiple blocks with size information in block headers. +All large enough files compressed in multi-threaded mode +meet this condition, +but files compressed in single-threaded mode don't even if +.BI \-\-block\-size= size +has been used. +.IP "" +The default value for +.I threads +is +.BR 0 . +In +.B xz +5.4.x and older the default is +.BR 1 . +. +.SS "Custom compressor filter chains" +A custom filter chain allows specifying +the compression settings in detail instead of relying on +the settings associated to the presets. +When a custom filter chain is specified, +preset options +.RB ( \-0 +\&...\& +.B \-9 +and +.BR \-\-extreme ) +earlier on the command line are forgotten. +If a preset option is specified +after one or more custom filter chain options, +the new preset takes effect and +the custom filter chain options specified earlier are forgotten. +.PP +A filter chain is comparable to piping on the command line. +When compressing, the uncompressed input goes to the first filter, +whose output goes to the next filter (if any). +The output of the last filter gets written to the compressed file. +The maximum number of filters in the chain is four, +but typically a filter chain has only one or two filters. +.PP +Many filters have limitations on where they can be +in the filter chain: +some filters can work only as the last filter in the chain, +some only as a non-last filter, and some work in any position +in the chain. +Depending on the filter, this limitation is either inherent to +the filter design or exists to prevent security issues. +.PP +A custom filter chain can be specified in two different ways. +The options +.BI \-\-filters= filters +and +.BI \-\-filters1= filters +\&...\& +.BI \-\-filters9= filters +allow specifying an entire filter chain in one option using the +liblzma filter string syntax. +Alternatively, a filter chain can be specified by using one or more +individual filter options in the order they are wanted in the filter chain. +That is, the order of the individual filter options is significant! +When decoding raw streams +.RB ( \-\-format=raw ), +the filter chain must be specified in the same order as +it was specified when compressing. +Any individual filter or preset options specified before the full +chain option +(\fB\-\-filters=\fIfilters\fR) +will be forgotten. +Individual filters specified after the full chain option will reset the +filter chain. +.PP +Both the full and individual filter options take filter-specific +.I options +as a comma-separated list. +Extra commas in +.I options +are ignored. +Every option has a default value, so +specify those you want to change. +.PP +To see the whole filter chain and +.IR options , +use +.B "xz \-vv" +(that is, use +.B \-\-verbose +twice). +This works also for viewing the filter chain options used by presets. +.TP +.BI \-\-filters= filters +Specify the full filter chain or a preset in a single option. +Each filter can be separated by spaces or two dashes +.RB ( \-\- ). +.I filters +may need to be quoted on the shell command line so it is +parsed as a single option. +To denote +.IR options , +use +.B : +or +.BR = . +A preset can be prefixed with a +.B \- +and followed with zero or more flags. +The only supported flag is +.B e +to apply the same options as +.BR \-\-extreme . +.TP +\fB\-\-filters1\fR=\fIfilters\fR ... \fB\-\-filters9\fR=\fIfilters +Specify up to nine additional filter chains that can be used with +.BR \-\-block\-list . +.IP "" +For example, when compressing an archive with executable files +followed by text files, the executable part could use a filter +chain with a BCJ filter and the text part only the LZMA2 filter. +.TP +.B \-\-filters-help +Display a help message describing how to specify presets and +custom filter chains in the +.B \-\-filters +and +.BI \-\-filters1= filters +\&...\& +.BI \-\-filters9= filters +options, and exit successfully. +.TP +\fB\-\-lzma1\fR[\fB=\fIoptions\fR] +.PD 0 +.TP +\fB\-\-lzma2\fR[\fB=\fIoptions\fR] +.PD +Add LZMA1 or LZMA2 filter to the filter chain. +These filters can be used only as the last filter in the chain. +.IP "" +LZMA1 is a legacy filter, +which is supported almost solely due to the legacy +.B .lzma +file format, which supports only LZMA1. +LZMA2 is an updated +version of LZMA1 to fix some practical issues of LZMA1. +The +.B .xz +format uses LZMA2 and doesn't support LZMA1 at all. +Compression speed and ratios of LZMA1 and LZMA2 +are practically the same. +.IP "" +LZMA1 and LZMA2 share the same set of +.IR options : +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +.BI preset= preset +Reset all LZMA1 or LZMA2 +.I options +to +.IR preset . +.I Preset +consist of an integer, which may be followed by single-letter +preset modifiers. +The integer can be from +.B 0 +to +.BR 9 , +matching the command line options +.B \-0 +\&...\& +.BR \-9 . +The only supported modifier is currently +.BR e , +which matches +.BR \-\-extreme . +If no +.B preset +is specified, the default values of LZMA1 or LZMA2 +.I options +are taken from the preset +.BR 6 . +.TP +.BI dict= size +Dictionary (history buffer) +.I size +indicates how many bytes of the recently processed +uncompressed data is kept in memory. +The algorithm tries to find repeating byte sequences (matches) in +the uncompressed data, and replace them with references +to the data currently in the dictionary. +The bigger the dictionary, the higher is the chance +to find a match. +Thus, increasing dictionary +.I size +usually improves compression ratio, but +a dictionary bigger than the uncompressed file is waste of memory. +.IP "" +Typical dictionary +.I size +is from 64\ KiB to 64\ MiB. +The minimum is 4\ KiB. +The maximum for compression is currently 1.5\ GiB (1536\ MiB). +The decompressor already supports dictionaries up to +one byte less than 4\ GiB, which is the maximum for +the LZMA1 and LZMA2 stream formats. +.IP "" +Dictionary +.I size +and match finder +.RI ( mf ) +together determine the memory usage of the LZMA1 or LZMA2 encoder. +The same (or bigger) dictionary +.I size +is required for decompressing that was used when compressing, +thus the memory usage of the decoder is determined +by the dictionary size used when compressing. +The +.B .xz +headers store the dictionary +.I size +either as +.RI "2^" n +or +.RI "2^" n " + 2^(" n "\-1)," +so these +.I sizes +are somewhat preferred for compression. +Other +.I sizes +will get rounded up when stored in the +.B .xz +headers. +.TP +.BI lc= lc +Specify the number of literal context bits. +The minimum is 0 and the maximum is 4; the default is 3. +In addition, the sum of +.I lc +and +.I lp +must not exceed 4. +.IP "" +All bytes that cannot be encoded as matches +are encoded as literals. +That is, literals are simply 8-bit bytes +that are encoded one at a time. +.IP "" +The literal coding makes an assumption that the highest +.I lc +bits of the previous uncompressed byte correlate +with the next byte. +For example, in typical English text, an upper-case letter is +often followed by a lower-case letter, and a lower-case +letter is usually followed by another lower-case letter. +In the US-ASCII character set, the highest three bits are 010 +for upper-case letters and 011 for lower-case letters. +When +.I lc +is at least 3, the literal coding can take advantage of +this property in the uncompressed data. +.IP "" +The default value (3) is usually good. +If you want maximum compression, test +.BR lc=4 . +Sometimes it helps a little, and +sometimes it makes compression worse. +If it makes it worse, test +.B lc=2 +too. +.TP +.BI lp= lp +Specify the number of literal position bits. +The minimum is 0 and the maximum is 4; the default is 0. +.IP "" +.I Lp +affects what kind of alignment in the uncompressed data is +assumed when encoding literals. +See +.I pb +below for more information about alignment. +.TP +.BI pb= pb +Specify the number of position bits. +The minimum is 0 and the maximum is 4; the default is 2. +.IP "" +.I Pb +affects what kind of alignment in the uncompressed data is +assumed in general. +The default means four-byte alignment +.RI (2^ pb =2^2=4), +which is often a good choice when there's no better guess. +.IP "" +When the alignment is known, setting +.I pb +accordingly may reduce the file size a little. +For example, with text files having one-byte +alignment (US-ASCII, ISO-8859-*, UTF-8), setting +.B pb=0 +can improve compression slightly. +For UTF-16 text, +.B pb=1 +is a good choice. +If the alignment is an odd number like 3 bytes, +.B pb=0 +might be the best choice. +.IP "" +Even though the assumed alignment can be adjusted with +.I pb +and +.IR lp , +LZMA1 and LZMA2 still slightly favor 16-byte alignment. +It might be worth taking into account when designing file formats +that are likely to be often compressed with LZMA1 or LZMA2. +.TP +.BI mf= mf +Match finder has a major effect on encoder speed, +memory usage, and compression ratio. +Usually Hash Chain match finders are faster than Binary Tree +match finders. +The default depends on the +.IR preset : +0 uses +.BR hc3 , +1\(en3 +use +.BR hc4 , +and the rest use +.BR bt4 . +.IP "" +The following match finders are supported. +The memory usage formulas below are rough approximations, +which are closest to the reality when +.I dict +is a power of two. +.RS +.TP +.B hc3 +Hash Chain with 2- and 3-byte hashing +.br +Minimum value for +.IR nice : +3 +.br +Memory usage: +.br +.I dict +* 7.5 (if +.I dict +<= 16 MiB); +.br +.I dict +* 5.5 + 64 MiB (if +.I dict +> 16 MiB) +.TP +.B hc4 +Hash Chain with 2-, 3-, and 4-byte hashing +.br +Minimum value for +.IR nice : +4 +.br +Memory usage: +.br +.I dict +* 7.5 (if +.I dict +<= 32 MiB); +.br +.I dict +* 6.5 (if +.I dict +> 32 MiB) +.TP +.B bt2 +Binary Tree with 2-byte hashing +.br +Minimum value for +.IR nice : +2 +.br +Memory usage: +.I dict +* 9.5 +.TP +.B bt3 +Binary Tree with 2- and 3-byte hashing +.br +Minimum value for +.IR nice : +3 +.br +Memory usage: +.br +.I dict +* 11.5 (if +.I dict +<= 16 MiB); +.br +.I dict +* 9.5 + 64 MiB (if +.I dict +> 16 MiB) +.TP +.B bt4 +Binary Tree with 2-, 3-, and 4-byte hashing +.br +Minimum value for +.IR nice : +4 +.br +Memory usage: +.br +.I dict +* 11.5 (if +.I dict +<= 32 MiB); +.br +.I dict +* 10.5 (if +.I dict +> 32 MiB) +.RE +.TP +.BI mode= mode +Compression +.I mode +specifies the method to analyze +the data produced by the match finder. +Supported +.I modes +are +.B fast +and +.BR normal . +The default is +.B fast +for +.I presets +0\(en3 and +.B normal +for +.I presets +4\(en9. +.IP "" +Usually +.B fast +is used with Hash Chain match finders and +.B normal +with Binary Tree match finders. +This is also what the +.I presets +do. +.TP +.BI nice= nice +Specify what is considered to be a nice length for a match. +Once a match of at least +.I nice +bytes is found, the algorithm stops +looking for possibly better matches. +.IP "" +.I Nice +can be 2\(en273 bytes. +Higher values tend to give better compression ratio +at the expense of speed. +The default depends on the +.IR preset . +.TP +.BI depth= depth +Specify the maximum search depth in the match finder. +The default is the special value of 0, +which makes the compressor determine a reasonable +.I depth +from +.I mf +and +.IR nice . +.IP "" +Reasonable +.I depth +for Hash Chains is 4\(en100 and 16\(en1000 for Binary Trees. +Using very high values for +.I depth +can make the encoder extremely slow with some files. +Avoid setting the +.I depth +over 1000 unless you are prepared to interrupt +the compression in case it is taking far too long. +.RE +.IP "" +When decoding raw streams +.RB ( \-\-format=raw ), +LZMA2 needs only the dictionary +.IR size . +LZMA1 needs also +.IR lc , +.IR lp , +and +.IR pb . +.TP +\fB\-\-x86\fR[\fB=\fIoptions\fR] +.PD 0 +.TP +\fB\-\-arm\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-armthumb\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-arm64\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-powerpc\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-ia64\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-sparc\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-riscv\fR[\fB=\fIoptions\fR] +.PD +Add a branch/call/jump (BCJ) filter to the filter chain. +These filters can be used only as a non-last filter +in the filter chain. +.IP "" +A BCJ filter converts relative addresses in +the machine code to their absolute counterparts. +This doesn't change the size of the data +but it increases redundancy, +which can help LZMA2 to produce 0\(en15\ % smaller +.B .xz +file. +The BCJ filters are always reversible, +so using a BCJ filter for wrong type of data +doesn't cause any data loss, although it may make +the compression ratio slightly worse. +The BCJ filters are very fast and +use an insignificant amount of memory. +.IP "" +These BCJ filters have known problems related to +the compression ratio: +.RS +.IP \(bu 3 +Some types of files containing executable code +(for example, object files, static libraries, and Linux kernel modules) +have the addresses in the instructions filled with filler values. +These BCJ filters will still do the address conversion, +which will make the compression worse with these files. +.IP \(bu 3 +If a BCJ filter is applied on an archive, +it is possible that it makes the compression ratio +worse than not using a BCJ filter. +For example, if there are similar or even identical executables +then filtering will likely make the files less similar +and thus compression is worse. +The contents of non-executable files in the same archive can matter too. +In practice one has to try with and without a BCJ filter to see +which is better in each situation. +.RE +.IP "" +Different instruction sets have different alignment: +the executable file must be aligned to a multiple of +this value in the input data to make the filter work. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filter;Alignment;Notes +x86;1;32-bit or 64-bit x86 +ARM;4; +ARM-Thumb;2; +ARM64;4;4096-byte alignment is best +PowerPC;4;Big endian only +IA-64;16;Itanium +SPARC;4; +RISC-V;2; +.TE +.RE +.RE +.IP "" +Since the BCJ-filtered data is usually compressed with LZMA2, +the compression ratio may be improved slightly if +the LZMA2 options are set to match the +alignment of the selected BCJ filter. +Examples: +.RS +.IP \(bu 3 +IA-64 filter has 16-byte alignment so +.B pb=4,lp=4,lc=0 +is good +with LZMA2 (2^4=16). +.IP \(bu 3 +RISC-V code has 2-byte or 4-byte alignment +depending on whether the file contains +16-bit compressed instructions (the C extension). +When 16-bit instructions are used, +.B pb=2,lp=1,lc=3 +or +.B pb=1,lp=1,lc=3 +is good. +When 16-bit instructions aren't present, +.B pb=2,lp=2,lc=2 +is the best. +.B readelf \-h +can be used to check if "RVC" +appears on the "Flags" line. +.IP \(bu 3 +ARM64 is always 4-byte aligned so +.B pb=2,lp=2,lc=2 +is the best. +.IP \(bu 3 +The x86 filter is an exception. +It's usually good to stick to LZMA2's defaults +.RB ( pb=2,lp=0,lc=3 ) +when compressing x86 executables. +.RE +.IP "" +All BCJ filters support the same +.IR options : +.RS +.TP +.BI start= offset +Specify the start +.I offset +that is used when converting between relative +and absolute addresses. +The +.I offset +must be a multiple of the alignment of the filter +(see the table above). +The default is zero. +In practice, the default is good; specifying a custom +.I offset +is almost never useful. +.RE +.TP +\fB\-\-delta\fR[\fB=\fIoptions\fR] +Add the Delta filter to the filter chain. +The Delta filter can be only used as a non-last filter +in the filter chain. +.IP "" +Currently only simple byte-wise delta calculation is supported. +It can be useful when compressing, for example, uncompressed bitmap images +or uncompressed PCM audio. +However, special purpose algorithms may give significantly better +results than Delta + LZMA2. +This is true especially with audio, +which compresses faster and better, for example, with +.BR flac (1). +.IP "" +Supported +.IR options : +.RS +.TP +.BI dist= distance +Specify the +.I distance +of the delta calculation in bytes. +.I distance +must be 1\(en256. +The default is 1. +.IP "" +For example, with +.B dist=2 +and eight-byte input A1 B1 A2 B3 A3 B5 A4 B7, the output will be +A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Other options" +.TP +.BR \-q ", " \-\-quiet +Suppress warnings and notices. +Specify this twice to suppress errors too. +This option has no effect on the exit status. +That is, even if a warning was suppressed, +the exit status to indicate a warning is still used. +.TP +.BR \-v ", " \-\-verbose +Be verbose. +If standard error is connected to a terminal, +.B xz +will display a progress indicator. +Specifying +.B \-\-verbose +twice will give even more verbose output. +.IP "" +The progress indicator shows the following information: +.RS +.IP \(bu 3 +Completion percentage is shown +if the size of the input file is known. +That is, the percentage cannot be shown in pipes. +.IP \(bu 3 +Amount of compressed data produced (compressing) +or consumed (decompressing). +.IP \(bu 3 +Amount of uncompressed data consumed (compressing) +or produced (decompressing). +.IP \(bu 3 +Compression ratio, which is calculated by dividing +the amount of compressed data processed so far by +the amount of uncompressed data processed so far. +.IP \(bu 3 +Compression or decompression speed. +This is measured as the amount of uncompressed data consumed +(compression) or produced (decompression) per second. +It is shown after a few seconds have passed since +.B xz +started processing the file. +.IP \(bu 3 +Elapsed time in the format M:SS or H:MM:SS. +.IP \(bu 3 +Estimated remaining time is shown +only when the size of the input file is +known and a couple of seconds have already passed since +.B xz +started processing the file. +The time is shown in a less precise format which +never has any colons, for example, 2 min 30 s. +.RE +.IP "" +When standard error is not a terminal, +.B \-\-verbose +will make +.B xz +print the filename, compressed size, uncompressed size, +compression ratio, and possibly also the speed and elapsed time +on a single line to standard error after compressing or +decompressing the file. +The speed and elapsed time are included only when +the operation took at least a few seconds. +If the operation didn't finish, for example, due to user interruption, +also the completion percentage is printed +if the size of the input file is known. +.TP +.BR \-Q ", " \-\-no\-warn +Don't set the exit status to 2 +even if a condition worth a warning was detected. +This option doesn't affect the verbosity level, thus both +.B \-\-quiet +and +.B \-\-no\-warn +have to be used to not display warnings and +to not alter the exit status. +.TP +.B \-\-robot +Print messages in a machine-parsable format. +This is intended to ease writing frontends that want to use +.B xz +instead of liblzma, which may be the case with various scripts. +The output with this option enabled is meant to be stable across +.B xz +releases. +See the section +.B "ROBOT MODE" +for details. +.TP +.B \-\-info\-memory +Display, in human-readable format, how much physical memory (RAM) +and how many processor threads +.B xz +thinks the system has and the memory usage limits for compression +and decompression, and exit successfully. +.TP +.BR \-h ", " \-\-help +Display a help message describing the most commonly used options, +and exit successfully. +.TP +.BR \-H ", " \-\-long\-help +Display a help message describing all features of +.BR xz , +and exit successfully +.TP +.BR \-V ", " \-\-version +Display the version number of +.B xz +and liblzma in human readable format. +To get machine-parsable output, specify +.B \-\-robot +before +.BR \-\-version . +. +.SH "ROBOT MODE" +The robot mode is activated with the +.B \-\-robot +option. +It makes the output of +.B xz +easier to parse by other programs. +Currently +.B \-\-robot +is supported only together with +.BR \-\-list , +.BR \-\-filters\-help , +.BR \-\-info\-memory , +and +.BR \-\-version . +It will be supported for compression and +decompression in the future. +. +.SS "List mode" +.B "xz \-\-robot \-\-list" +uses tab-separated output. +The first column of every line has a string +that indicates the type of the information found on that line: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +.B name +This is always the first line when starting to list a file. +The second column on the line is the filename. +.TP +.B file +This line contains overall information about the +.B .xz +file. +This line is always printed after the +.B name +line. +.TP +.B stream +This line type is used only when +.B \-\-verbose +was specified. +There are as many +.B stream +lines as there are streams in the +.B .xz +file. +.TP +.B block +This line type is used only when +.B \-\-verbose +was specified. +There are as many +.B block +lines as there are blocks in the +.B .xz +file. +The +.B block +lines are shown after all the +.B stream +lines; different line types are not interleaved. +.TP +.B summary +This line type is used only when +.B \-\-verbose +was specified twice. +This line is printed after all +.B block +lines. +Like the +.B file +line, the +.B summary +line contains overall information about the +.B .xz +file. +.TP +.B totals +This line is always the very last line of the list output. +It shows the total counts and sizes. +.PP +The columns of the +.B file +lines: +.PD 0 +.RS +.IP 2. 4 +Number of streams in the file +.IP 3. 4 +Total number of blocks in the stream(s) +.IP 4. 4 +Compressed size of the file +.IP 5. 4 +Uncompressed size of the file +.IP 6. 4 +Compression ratio, for example, +.BR 0.123 . +If ratio is over 9.999, three dashes +.RB ( \-\-\- ) +are displayed instead of the ratio. +.IP 7. 4 +Comma-separated list of integrity check names. +The following strings are used for the known check types: +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +.BR None , +.BR CRC32 , +.BR CRC64 , +and +.BR SHA\-256 . +For unknown check types, +.BI Unknown\- N +is used, where +.I N +is the Check ID as a decimal number (one or two digits). +.IP 8. 4 +Total size of stream padding in the file +.RE +.PD +.PP +The columns of the +.B stream +lines: +.PD 0 +.RS +.IP 2. 4 +Stream number (the first stream is 1) +.IP 3. 4 +Number of blocks in the stream +.IP 4. 4 +Compressed start offset +.IP 5. 4 +Uncompressed start offset +.IP 6. 4 +Compressed size (does not include stream padding) +.IP 7. 4 +Uncompressed size +.IP 8. 4 +Compression ratio +.IP 9. 4 +Name of the integrity check +.IP 10. 4 +Size of stream padding +.RE +.PD +.PP +The columns of the +.B block +lines: +.PD 0 +.RS +.IP 2. 4 +Number of the stream containing this block +.IP 3. 4 +Block number relative to the beginning of the stream +(the first block is 1) +.IP 4. 4 +Block number relative to the beginning of the file +.IP 5. 4 +Compressed start offset relative to the beginning of the file +.IP 6. 4 +Uncompressed start offset relative to the beginning of the file +.IP 7. 4 +Total compressed size of the block (includes headers) +.IP 8. 4 +Uncompressed size +.IP 9. 4 +Compression ratio +.IP 10. 4 +Name of the integrity check +.RE +.PD +.PP +If +.B \-\-verbose +was specified twice, additional columns are included on the +.B block +lines. +These are not displayed with a single +.BR \-\-verbose , +because getting this information requires many seeks +and can thus be slow: +.PD 0 +.RS +.IP 11. 4 +Value of the integrity check in hexadecimal +.IP 12. 4 +Block header size +.IP 13. 4 +Block flags: +.B c +indicates that compressed size is present, and +.B u +indicates that uncompressed size is present. +If the flag is not set, a dash +.RB ( \- ) +is shown instead to keep the string length fixed. +New flags may be added to the end of the string in the future. +.IP 14. 4 +Size of the actual compressed data in the block (this excludes +the block header, block padding, and check fields) +.IP 15. 4 +Amount of memory (in bytes) required to decompress +this block with this +.B xz +version +.IP 16. 4 +Filter chain. +Note that most of the options used at compression time +cannot be known, because only the options +that are needed for decompression are stored in the +.B .xz +headers. +.RE +.PD +.PP +The columns of the +.B summary +lines: +.PD 0 +.RS +.IP 2. 4 +Amount of memory (in bytes) required to decompress +this file with this +.B xz +version +.IP 3. 4 +.B yes +or +.B no +indicating if all block headers have both compressed size and +uncompressed size stored in them +.PP +.I Since +.B xz +.I 5.1.2alpha: +.IP 4. 4 +Minimum +.B xz +version required to decompress the file +.RE +.PD +.PP +The columns of the +.B totals +line: +.PD 0 +.RS +.IP 2. 4 +Number of streams +.IP 3. 4 +Number of blocks +.IP 4. 4 +Compressed size +.IP 5. 4 +Uncompressed size +.IP 6. 4 +Average compression ratio +.IP 7. 4 +Comma-separated list of integrity check names +that were present in the files +.IP 8. 4 +Stream padding size +.IP 9. 4 +Number of files. +This is here to +keep the order of the earlier columns the same as on +.B file +lines. +.PD +.RE +.PP +If +.B \-\-verbose +was specified twice, additional columns are included on the +.B totals +line: +.PD 0 +.RS +.IP 10. 4 +Maximum amount of memory (in bytes) required to decompress +the files with this +.B xz +version +.IP 11. 4 +.B yes +or +.B no +indicating if all block headers have both compressed size and +uncompressed size stored in them +.PP +.I Since +.B xz +.I 5.1.2alpha: +.IP 12. 4 +Minimum +.B xz +version required to decompress the file +.RE +.PD +.PP +Future versions may add new line types and +new columns can be added to the existing line types, +but the existing columns won't be changed. +. +.SS "Filters help" +.B "xz \-\-robot \-\-filters-help" +prints the supported filters in the following format: +.PP +\fIfilter\fB:\fIoption\fB=<\fIvalue\fB>,\fIoption\fB=<\fIvalue\fB>\fR... +.TP +.I filter +Name of the filter +.TP +.I option +Name of a filter specific option +.TP +.I value +Numeric +.I value +ranges appear as +\fB<\fImin\fB\-\fImax\fB>\fR. +String +.I value +choices are shown within +.B "< >" +and separated by a +.B | +character. +.PP +Each filter is printed on its own line. +. +.SS "Memory limit information" +.B "xz \-\-robot \-\-info\-memory" +prints a single line with multiple tab-separated columns: +.IP 1. 4 +Total amount of physical memory (RAM) in bytes. +.IP 2. 4 +Memory usage limit for compression in bytes +.RB ( \-\-memlimit\-compress ). +A special value of +.B 0 +indicates the default setting +which for single-threaded mode is the same as no limit. +.IP 3. 4 +Memory usage limit for decompression in bytes +.RB ( \-\-memlimit\-decompress ). +A special value of +.B 0 +indicates the default setting +which for single-threaded mode is the same as no limit. +.IP 4. 4 +Since +.B xz +5.3.4alpha: +Memory usage for multi-threaded decompression in bytes +.RB ( \-\-memlimit\-mt\-decompress ). +This is never zero because a system-specific default value +shown in the column 5 +is used if no limit has been specified explicitly. +This is also never greater than the value in the column 3 +even if a larger value has been specified with +.BR \-\-memlimit\-mt\-decompress . +.IP 5. 4 +Since +.B xz +5.3.4alpha: +A system-specific default memory usage limit +that is used to limit the number of threads +when compressing with an automatic number of threads +.RB ( \-\-threads=0 ) +and no memory usage limit has been specified +.RB ( \-\-memlimit\-compress ). +This is also used as the default value for +.BR \-\-memlimit\-mt\-decompress . +.IP 6. 4 +Since +.B xz +5.3.4alpha: +Number of available processor threads. +.PP +In the future, the output of +.B "xz \-\-robot \-\-info\-memory" +may have more columns, but never more than a single line. +. +.SS Version +.B "xz \-\-robot \-\-version" +prints the version number of +.B xz +and liblzma in the following format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +.BI XZ_VERSION= XYYYZZZS +.br +.BI LIBLZMA_VERSION= XYYYZZZS +.TP +.I X +Major version. +.TP +.I YYY +Minor version. +Even numbers are stable. +Odd numbers are alpha or beta versions. +.TP +.I ZZZ +Patch level for stable releases or +just a counter for development releases. +.TP +.I S +Stability. +0 is alpha, 1 is beta, and 2 is stable. +.I S +should be always 2 when +.I YYY +is even. +.PP +.I XYYYZZZS +are the same on both lines if +.B xz +and liblzma are from the same XZ Utils release. +.PP +Examples: 4.999.9beta is +.B 49990091 +and +5.0.0 is +.BR 50000002 . +. +.SH "EXIT STATUS" +.TP +.B 0 +All is good. +.TP +.B 1 +An error occurred. +.TP +.B 2 +Something worth a warning occurred, +but no actual errors occurred. +.PP +Notices (not warnings or errors) printed on standard error +don't affect the exit status. +. +.SH ENVIRONMENT +.B xz +parses space-separated lists of options +from the environment variables +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +.B XZ_DEFAULTS +and +.BR XZ_OPT , +in this order, before parsing the options from the command line. +Note that only options are parsed from the environment variables; +all non-options are silently ignored. +Parsing is done with +.BR getopt_long (3) +which is used also for the command line arguments. +.PP +.B Warning: +By setting these environment variables, +one is effectively modifying programs and scripts that run +.BR xz . +Most of the time it is safe to set memory usage limits, number of threads, +and compression options via the environment variables. +However, some options can break scripts. +An obvious example is +.B \-\-help +which makes +.B xz +show the help text instead of compressing or decompressing a file. +More subtle examples are +.B \-\-quiet +and +.BR \-\-verbose . +In many cases it works well to enable the progress indicator using +.BR \-\-verbose , +but in some situations the extra messages create problems. +The verbosity level also affects the behavior of +.BR \-\-list . +.TP +.B XZ_DEFAULTS +User-specific or system-wide default options. +Typically this is set in a shell initialization script to enable +.BR xz 's +memory usage limiter by default or set the default number of threads. +Excluding shell initialization scripts +and similar special cases, scripts should never set or unset +.BR XZ_DEFAULTS . +.TP +.B XZ_OPT +This is for passing options to +.B xz +when it is not possible to set the options directly on the +.B xz +command line. +This is the case when +.B xz +is run by a script or tool, for example, GNU +.BR tar (1): +.RS +.RS +.PP +.nf +.ft CR +XZ_OPT=\-2v tar caf foo.tar.xz foo +.ft R +.fi +.RE +.RE +.IP "" +Scripts may use +.BR XZ_OPT , +for example, to set script-specific default compression options. +It is still recommended to allow users to override +.B XZ_OPT +if that is reasonable. +For example, in +.BR sh (1) +scripts one may use something like this: +.RS +.RS +.PP +.nf +.ft CR +XZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT +.ft R +.fi +.RE +.RE +. +.SH "LZMA UTILS COMPATIBILITY" +The command line syntax of +.B xz +is practically a superset of +.BR lzma , +.BR unlzma , +and +.B lzcat +as found from LZMA Utils 4.32.x. +In most cases, it is possible to replace +LZMA Utils with XZ Utils without breaking existing scripts. +There are some incompatibilities though, +which may sometimes cause problems. +. +.SS "Compression preset levels" +The numbering of the compression level presets is not identical in +.B xz +and LZMA Utils. +The most important difference is how dictionary sizes +are mapped to different presets. +Dictionary size is roughly equal to the decompressor memory usage. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Level;xz;LZMA Utils +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +The dictionary size differences affect +the compressor memory usage too, +but there are some other differences between +LZMA Utils and XZ Utils, which +make the difference even bigger: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Level;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +The default preset level in LZMA Utils is +.B \-7 +while in XZ Utils it is +.BR \-6 , +so both use an 8 MiB dictionary by default. +. +.SS "Streamed vs. non-streamed .lzma files" +The uncompressed size of the file can be stored in the +.B .lzma +header. +LZMA Utils does that when compressing regular files. +The alternative is to mark that uncompressed size is unknown +and use end-of-payload marker to indicate +where the decompressor should stop. +LZMA Utils uses this method when uncompressed size isn't known, +which is the case, for example, in pipes. +.PP +.B xz +supports decompressing +.B .lzma +files with or without end-of-payload marker, but all +.B .lzma +files created by +.B xz +will use end-of-payload marker and have uncompressed size +marked as unknown in the +.B .lzma +header. +This may be a problem in some uncommon situations. +For example, a +.B .lzma +decompressor in an embedded device might work +only with files that have known uncompressed size. +If you hit this problem, you need to use LZMA Utils +or LZMA SDK to create +.B .lzma +files with known uncompressed size. +. +.SS "Unsupported .lzma files" +The +.B .lzma +format allows +.I lc +values up to 8, and +.I lp +values up to 4. +LZMA Utils can decompress files with any +.I lc +and +.IR lp , +but always creates files with +.B lc=3 +and +.BR lp=0 . +Creating files with other +.I lc +and +.I lp +is possible with +.B xz +and with LZMA SDK. +.PP +The implementation of the LZMA1 filter in liblzma +requires that the sum of +.I lc +and +.I lp +must not exceed 4. +Thus, +.B .lzma +files, which exceed this limitation, cannot be decompressed with +.BR xz . +.PP +LZMA Utils creates only +.B .lzma +files which have a dictionary size of +.RI "2^" n +(a power of 2) but accepts files with any dictionary size. +liblzma accepts only +.B .lzma +files which have a dictionary size of +.RI "2^" n +or +.RI "2^" n " + 2^(" n "\-1)." +This is to decrease false positives when detecting +.B .lzma +files. +.PP +These limitations shouldn't be a problem in practice, +since practically all +.B .lzma +files have been compressed with settings that liblzma will accept. +. +.SS "Trailing garbage" +When decompressing, +LZMA Utils silently ignore everything after the first +.B .lzma +stream. +In most situations, this is a bug. +This also means that LZMA Utils +don't support decompressing concatenated +.B .lzma +files. +.PP +If there is data left after the first +.B .lzma +stream, +.B xz +considers the file to be corrupt unless +.B \-\-single\-stream +was used. +This may break obscure scripts which have +assumed that trailing garbage is ignored. +. +.SH NOTES +. +.SS "Compressed output may vary" +The exact compressed output produced from +the same uncompressed input file +may vary between XZ Utils versions even if +compression options are identical. +This is because the encoder can be improved +(faster or better compression) +without affecting the file format. +The output can vary even between different +builds of the same XZ Utils version, +if different build options are used. +.PP +The above means that once +.B \-\-rsyncable +has been implemented, +the resulting files won't necessarily be rsyncable +unless both old and new files have been compressed +with the same xz version. +This problem can be fixed if a part of the encoder +implementation is frozen to keep rsyncable output +stable across xz versions. +. +.SS "Embedded .xz decompressors" +Embedded +.B .xz +decompressor implementations like XZ Embedded don't necessarily +support files created with integrity +.I check +types other than +.B none +and +.BR crc32 . +Since the default is +.BR \-\-check=crc64 , +you must use +.B \-\-check=none +or +.B \-\-check=crc32 +when creating files for embedded systems. +.PP +Outside embedded systems, all +.B .xz +format decompressors support all the +.I check +types, or at least are able to decompress +the file without verifying the +integrity check if the particular +.I check +is not supported. +.PP +XZ Embedded supports BCJ filters, +but only with the default start offset. +. +.SH EXAMPLES +. +.SS Basics +Compress the file +.I foo +into +.I foo.xz +using the default compression level +.RB ( \-6 ), +and remove +.I foo +if compression is successful: +.RS +.PP +.nf +.ft CR +xz foo +.ft R +.fi +.RE +.PP +Decompress +.I bar.xz +into +.I bar +and don't remove +.I bar.xz +even if decompression is successful: +.RS +.PP +.nf +.ft CR +xz \-dk bar.xz +.ft R +.fi +.RE +.PP +Create +.I baz.tar.xz +with the preset +.B \-4e +.RB ( "\-4 \-\-extreme" ), +which is slower than the default +.BR \-6 , +but needs less memory for compression and decompression (48\ MiB +and 5\ MiB, respectively): +.RS +.PP +.nf +.ft CR +tar cf \- baz | xz \-4e > baz.tar.xz +.ft R +.fi +.RE +.PP +A mix of compressed and uncompressed files can be decompressed +to standard output with a single command: +.RS +.PP +.nf +.ft CR +xz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt +.ft R +.fi +.RE +. +.SS "Parallel compression of many files" +On GNU and *BSD, +.BR find (1) +and +.BR xargs (1) +can be used to parallelize compression of many files: +.RS +.PP +.nf +.ft CR +find . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1 +.ft R +.fi +.RE +.PP +The +.B \-P +option to +.BR xargs (1) +sets the number of parallel +.B xz +processes. +The best value for the +.B \-n +option depends on how many files there are to be compressed. +If there are only a couple of files, +the value should probably be 1; +with tens of thousands of files, +100 or even more may be appropriate to reduce the number of +.B xz +processes that +.BR xargs (1) +will eventually create. +.PP +The option +.B \-T1 +for +.B xz +is there to force it to single-threaded mode, because +.BR xargs (1) +is used to control the amount of parallelization. +. +.SS "Robot mode" +Calculate how many bytes have been saved in total +after compressing multiple files: +.RS +.PP +.nf +.ft CR +xz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}' +.ft R +.fi +.RE +.PP +A script may want to know that it is using new enough +.BR xz . +The following +.BR sh (1) +script checks that the version number of the +.B xz +tool is at least 5.0.0. +This method is compatible with old beta versions, +which didn't support the +.B \-\-robot +option: +.RS +.PP +.nf +.ft CR +if ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION +.ft R +.fi +.RE +.PP +Set a memory usage limit for decompression using +.BR XZ_OPT , +but if a limit has already been set, don't increase it: +.RS +.PP +.nf +.ft CR +NEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi +.ft R +.fi +.RE +. +.SS "Custom compressor filter chains" +The simplest use for custom filter chains is +customizing a LZMA2 preset. +This can be useful, +because the presets cover only a subset of the +potentially useful combinations of compression settings. +.PP +The CompCPU columns of the tables +from the descriptions of the options +.BR "\-0" " ... " "\-9" +and +.B \-\-extreme +are useful when customizing LZMA2 presets. +Here are the relevant parts collected from those two tables: +.RS +.PP +.TS +tab(;); +c c +n n. +Preset;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +If you know that a file requires +somewhat big dictionary (for example, 32\ MiB) to compress well, +but you want to compress it quicker than +.B "xz \-8" +would do, a preset with a low CompCPU value (for example, 1) +can be modified to use a bigger dictionary: +.RS +.PP +.nf +.ft CR +xz \-\-lzma2=preset=1,dict=32MiB foo.tar +.ft R +.fi +.RE +.PP +With certain files, the above command may be faster than +.B "xz \-6" +while compressing significantly better. +However, it must be emphasized that only some files benefit from +a big dictionary while keeping the CompCPU value low. +The most obvious situation, +where a big dictionary can help a lot, +is an archive containing very similar files +of at least a few megabytes each. +The dictionary size has to be significantly bigger +than any individual file to allow LZMA2 to take +full advantage of the similarities between consecutive files. +.PP +If very high compressor and decompressor memory usage is fine, +and the file being compressed is +at least several hundred megabytes, it may be useful +to use an even bigger dictionary than the 64 MiB that +.B "xz \-9" +would use: +.RS +.PP +.nf +.ft CR +xz \-vv \-\-lzma2=dict=192MiB big_foo.tar +.ft R +.fi +.RE +.PP +Using +.B \-vv +.RB ( "\-\-verbose \-\-verbose" ) +like in the above example can be useful +to see the memory requirements +of the compressor and decompressor. +Remember that using a dictionary bigger than +the size of the uncompressed file is waste of memory, +so the above command isn't useful for small files. +.PP +Sometimes the compression time doesn't matter, +but the decompressor memory usage has to be kept low, for example, +to make it possible to decompress the file on an embedded system. +The following command uses +.B \-6e +.RB ( "\-6 \-\-extreme" ) +as a base and sets the dictionary to only 64\ KiB. +The resulting file can be decompressed with XZ Embedded +(that's why there is +.BR \-\-check=crc32 ) +using about 100\ KiB of memory. +.RS +.PP +.nf +.ft CR +xz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo +.ft R +.fi +.RE +.PP +If you want to squeeze out as many bytes as possible, +adjusting the number of literal context bits +.RI ( lc ) +and number of position bits +.RI ( pb ) +can sometimes help. +Adjusting the number of literal position bits +.RI ( lp ) +might help too, but usually +.I lc +and +.I pb +are more important. +For example, a source code archive contains mostly US-ASCII text, +so something like the following might give +slightly (like 0.1\ %) smaller file than +.B "xz \-6e" +(try also without +.BR lc=4 ): +.RS +.PP +.nf +.ft CR +xz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar +.ft R +.fi +.RE +.PP +Using another filter together with LZMA2 can improve +compression with certain file types. +For example, to compress a x86-32 or x86-64 shared library +using the x86 BCJ filter: +.RS +.PP +.nf +.ft CR +xz \-\-x86 \-\-lzma2 libfoo.so +.ft R +.fi +.RE +.PP +Note that the order of the filter options is significant. +If +.B \-\-x86 +is specified after +.BR \-\-lzma2 , +.B xz +will give an error, +because there cannot be any filter after LZMA2, +and also because the x86 BCJ filter cannot be used +as the last filter in the chain. +.PP +The Delta filter together with LZMA2 +can give good results with bitmap images. +It should usually beat PNG, +which has a few more advanced filters than simple +delta but uses Deflate for the actual compression. +.PP +The image has to be saved in uncompressed format, +for example, as uncompressed TIFF. +The distance parameter of the Delta filter is set +to match the number of bytes per pixel in the image. +For example, 24-bit RGB bitmap needs +.BR dist=3 , +and it is also good to pass +.B pb=0 +to LZMA2 to accommodate the three-byte alignment: +.RS +.PP +.nf +.ft CR +xz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff +.ft R +.fi +.RE +.PP +If multiple images have been put into a single archive (for example, +.BR .tar ), +the Delta filter will work on that too as long as all images +have the same number of bytes per pixel. +. +.SH "SEE ALSO" +.BR xzdec (1), +.BR xzdiff (1), +.BR xzgrep (1), +.BR xzless (1), +.BR xzmore (1), +.BR gzip (1), +.BR bzip2 (1), +.BR 7z (1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzcmp.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzcmp.1 new file mode 100644 index 0000000000000000000000000000000000000000..9d2608e50b429ed61e60c7cc5686886ccf073011 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzcmp.1 @@ -0,0 +1,99 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.TH XZDIFF 1 "2025-03-06" "Tukaani" "XZ Utils" +.SH NAME +xzcmp, xzdiff, lzcmp, lzdiff \- compare compressed files +. +.SH SYNOPSIS +.B xzcmp +.RI [ option... ] +.I file1 +.RI [ file2 ] +.br +.B xzdiff +\&... +.br +.B lzcmp +\&... +(DEPRECATED) +.br +.B lzdiff +\&... +(DEPRECATED) +. +.SH DESCRIPTION +.B xzcmp +and +.B xzdiff +compare uncompressed contents of two files. +Uncompressed data and options are passed to +.BR cmp (1) +or +.BR diff (1) +unless +.B \-\-help +or +.B \-\-version +is specified. +.PP +If both +.I file1 +and +.I file2 +are specified, they can be uncompressed files or files in formats that +.BR xz (1), +.BR gzip (1), +.BR bzip2 (1), +.BR lzop (1), +.BR zstd (1), +or +.BR lz4 (1) +can decompress. +The required decompression commands are determined from +the filename suffixes of +.I file1 +and +.IR file2 . +A file with an unknown suffix is assumed to be either uncompressed +or in a format that +.BR xz (1) +can decompress. +.PP +If only one filename is provided, +.I file1 +must have a suffix of a supported compression format and the name for +.I file2 +is assumed to be +.I file1 +with the compression format suffix removed. +.PP +The commands +.B lzcmp +and +.B lzdiff +are provided for backward compatibility with LZMA Utils. +They are deprecated and will be removed in a future version. +. +.SH EXIT STATUS +If a decompression error occurs, the exit status is +.BR 2 . +Otherwise the exit status of +.BR cmp (1) +or +.BR diff (1) +is used. +. +.SH "SEE ALSO" +.BR cmp (1), +.BR diff (1), +.BR xz (1), +.BR gzip (1), +.BR bzip2 (1), +.BR lzop (1), +.BR zstd (1), +.BR lz4 (1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzdiff.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzdiff.1 new file mode 100644 index 0000000000000000000000000000000000000000..9d2608e50b429ed61e60c7cc5686886ccf073011 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzdiff.1 @@ -0,0 +1,99 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.TH XZDIFF 1 "2025-03-06" "Tukaani" "XZ Utils" +.SH NAME +xzcmp, xzdiff, lzcmp, lzdiff \- compare compressed files +. +.SH SYNOPSIS +.B xzcmp +.RI [ option... ] +.I file1 +.RI [ file2 ] +.br +.B xzdiff +\&... +.br +.B lzcmp +\&... +(DEPRECATED) +.br +.B lzdiff +\&... +(DEPRECATED) +. +.SH DESCRIPTION +.B xzcmp +and +.B xzdiff +compare uncompressed contents of two files. +Uncompressed data and options are passed to +.BR cmp (1) +or +.BR diff (1) +unless +.B \-\-help +or +.B \-\-version +is specified. +.PP +If both +.I file1 +and +.I file2 +are specified, they can be uncompressed files or files in formats that +.BR xz (1), +.BR gzip (1), +.BR bzip2 (1), +.BR lzop (1), +.BR zstd (1), +or +.BR lz4 (1) +can decompress. +The required decompression commands are determined from +the filename suffixes of +.I file1 +and +.IR file2 . +A file with an unknown suffix is assumed to be either uncompressed +or in a format that +.BR xz (1) +can decompress. +.PP +If only one filename is provided, +.I file1 +must have a suffix of a supported compression format and the name for +.I file2 +is assumed to be +.I file1 +with the compression format suffix removed. +.PP +The commands +.B lzcmp +and +.B lzdiff +are provided for backward compatibility with LZMA Utils. +They are deprecated and will be removed in a future version. +. +.SH EXIT STATUS +If a decompression error occurs, the exit status is +.BR 2 . +Otherwise the exit status of +.BR cmp (1) +or +.BR diff (1) +is used. +. +.SH "SEE ALSO" +.BR cmp (1), +.BR diff (1), +.BR xz (1), +.BR gzip (1), +.BR bzip2 (1), +.BR lzop (1), +.BR zstd (1), +.BR lz4 (1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzegrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzegrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..c6bb0eb41f130d412ecd183a8b41369121ae872d --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzegrep.1 @@ -0,0 +1,148 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.TH XZGREP 1 "2025-03-06" "Tukaani" "XZ Utils" +.SH NAME +xzgrep \- search possibly-compressed files for patterns +. +.SH SYNOPSIS +.B xzgrep +.RI [ option... ] +.RI [ pattern_list ] +.RI [ file... ] +.br +.B xzegrep +\&... +.br +.B xzfgrep +\&... +.br +.B lzgrep +\&... +(DEPRECATED) +.br +.B lzegrep +\&... +(DEPRECATED) +.br +.B lzfgrep +\&... +(DEPRECATED) +. +.SH DESCRIPTION +.B xzgrep +invokes +.BR grep (1) +on uncompressed contents of files. +The formats of the +.I files +are determined from the filename suffixes. +Any +.I file +with a suffix supported by +.BR xz (1), +.BR gzip (1), +.BR bzip2 (1), +.BR lzop (1), +.BR zstd (1), +or +.BR lz4 (1) +will be decompressed; +all other files are assumed to be uncompressed. +.PP +If no +.I files +are specified or +.I file +is +.B \- +then standard input is read. +When reading from standard input, only files supported by +.BR xz (1) +are decompressed. +Other files are assumed to be in uncompressed form already. +.PP +Most +.I options +of +.BR grep (1) +are supported. +However, the following options are not supported: +.IP "" 4 +.BR \-r , +.B \-\-recursive +.IP "" 4 +.BR \-R , +.B \-\-dereference\-recursive +.IP "" 4 +.BR \-d , +.BI \-\-directories= action +.IP "" 4 +.BR \-Z , +.B \-\-null +.IP "" 4 +.BR \-z , +.B \-\-null\-data +.IP "" 4 +.BI \-\-include= glob +.IP "" 4 +.BI \-\-exclude= glob +.IP "" 4 +.BI \-\-exclude\-from= file +.IP "" 4 +.BI \-\-exclude\-dir= glob +.PP +.B xzegrep +is an alias for +.BR "xzgrep \-E" . +.B xzfgrep +is an alias for +.BR "xzgrep \-F" . +.PP +The commands +.BR lzgrep , +.BR lzegrep , +and +.B lzfgrep +are provided for backward compatibility with LZMA Utils. +They are deprecated and will be removed in a future version. +. +.SH EXIT STATUS +.TP +0 +At least one match was found from at least one of the input files. +No errors occurred. +.TP +1 +No matches were found from any of the input files. +No errors occurred. +.TP +>1 +One or more errors occurred. +It is unknown if matches were found. +. +.SH ENVIRONMENT +.TP +.B GREP +If +.B GREP +is set to a non-empty value, +it is used instead of +.BR "grep" , +.BR "grep \-E" , +or +.BR "grep \-F" . +. +.SH "SEE ALSO" +.BR grep (1), +.BR xz (1), +.BR gzip (1), +.BR bzip2 (1), +.BR lzop (1), +.BR zstd (1), +.BR lz4 (1), +.BR zgrep (1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzfgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzfgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..c6bb0eb41f130d412ecd183a8b41369121ae872d --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzfgrep.1 @@ -0,0 +1,148 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.TH XZGREP 1 "2025-03-06" "Tukaani" "XZ Utils" +.SH NAME +xzgrep \- search possibly-compressed files for patterns +. +.SH SYNOPSIS +.B xzgrep +.RI [ option... ] +.RI [ pattern_list ] +.RI [ file... ] +.br +.B xzegrep +\&... +.br +.B xzfgrep +\&... +.br +.B lzgrep +\&... +(DEPRECATED) +.br +.B lzegrep +\&... +(DEPRECATED) +.br +.B lzfgrep +\&... +(DEPRECATED) +. +.SH DESCRIPTION +.B xzgrep +invokes +.BR grep (1) +on uncompressed contents of files. +The formats of the +.I files +are determined from the filename suffixes. +Any +.I file +with a suffix supported by +.BR xz (1), +.BR gzip (1), +.BR bzip2 (1), +.BR lzop (1), +.BR zstd (1), +or +.BR lz4 (1) +will be decompressed; +all other files are assumed to be uncompressed. +.PP +If no +.I files +are specified or +.I file +is +.B \- +then standard input is read. +When reading from standard input, only files supported by +.BR xz (1) +are decompressed. +Other files are assumed to be in uncompressed form already. +.PP +Most +.I options +of +.BR grep (1) +are supported. +However, the following options are not supported: +.IP "" 4 +.BR \-r , +.B \-\-recursive +.IP "" 4 +.BR \-R , +.B \-\-dereference\-recursive +.IP "" 4 +.BR \-d , +.BI \-\-directories= action +.IP "" 4 +.BR \-Z , +.B \-\-null +.IP "" 4 +.BR \-z , +.B \-\-null\-data +.IP "" 4 +.BI \-\-include= glob +.IP "" 4 +.BI \-\-exclude= glob +.IP "" 4 +.BI \-\-exclude\-from= file +.IP "" 4 +.BI \-\-exclude\-dir= glob +.PP +.B xzegrep +is an alias for +.BR "xzgrep \-E" . +.B xzfgrep +is an alias for +.BR "xzgrep \-F" . +.PP +The commands +.BR lzgrep , +.BR lzegrep , +and +.B lzfgrep +are provided for backward compatibility with LZMA Utils. +They are deprecated and will be removed in a future version. +. +.SH EXIT STATUS +.TP +0 +At least one match was found from at least one of the input files. +No errors occurred. +.TP +1 +No matches were found from any of the input files. +No errors occurred. +.TP +>1 +One or more errors occurred. +It is unknown if matches were found. +. +.SH ENVIRONMENT +.TP +.B GREP +If +.B GREP +is set to a non-empty value, +it is used instead of +.BR "grep" , +.BR "grep \-E" , +or +.BR "grep \-F" . +. +.SH "SEE ALSO" +.BR grep (1), +.BR xz (1), +.BR gzip (1), +.BR bzip2 (1), +.BR lzop (1), +.BR zstd (1), +.BR lz4 (1), +.BR zgrep (1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..c6bb0eb41f130d412ecd183a8b41369121ae872d --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzgrep.1 @@ -0,0 +1,148 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.TH XZGREP 1 "2025-03-06" "Tukaani" "XZ Utils" +.SH NAME +xzgrep \- search possibly-compressed files for patterns +. +.SH SYNOPSIS +.B xzgrep +.RI [ option... ] +.RI [ pattern_list ] +.RI [ file... ] +.br +.B xzegrep +\&... +.br +.B xzfgrep +\&... +.br +.B lzgrep +\&... +(DEPRECATED) +.br +.B lzegrep +\&... +(DEPRECATED) +.br +.B lzfgrep +\&... +(DEPRECATED) +. +.SH DESCRIPTION +.B xzgrep +invokes +.BR grep (1) +on uncompressed contents of files. +The formats of the +.I files +are determined from the filename suffixes. +Any +.I file +with a suffix supported by +.BR xz (1), +.BR gzip (1), +.BR bzip2 (1), +.BR lzop (1), +.BR zstd (1), +or +.BR lz4 (1) +will be decompressed; +all other files are assumed to be uncompressed. +.PP +If no +.I files +are specified or +.I file +is +.B \- +then standard input is read. +When reading from standard input, only files supported by +.BR xz (1) +are decompressed. +Other files are assumed to be in uncompressed form already. +.PP +Most +.I options +of +.BR grep (1) +are supported. +However, the following options are not supported: +.IP "" 4 +.BR \-r , +.B \-\-recursive +.IP "" 4 +.BR \-R , +.B \-\-dereference\-recursive +.IP "" 4 +.BR \-d , +.BI \-\-directories= action +.IP "" 4 +.BR \-Z , +.B \-\-null +.IP "" 4 +.BR \-z , +.B \-\-null\-data +.IP "" 4 +.BI \-\-include= glob +.IP "" 4 +.BI \-\-exclude= glob +.IP "" 4 +.BI \-\-exclude\-from= file +.IP "" 4 +.BI \-\-exclude\-dir= glob +.PP +.B xzegrep +is an alias for +.BR "xzgrep \-E" . +.B xzfgrep +is an alias for +.BR "xzgrep \-F" . +.PP +The commands +.BR lzgrep , +.BR lzegrep , +and +.B lzfgrep +are provided for backward compatibility with LZMA Utils. +They are deprecated and will be removed in a future version. +. +.SH EXIT STATUS +.TP +0 +At least one match was found from at least one of the input files. +No errors occurred. +.TP +1 +No matches were found from any of the input files. +No errors occurred. +.TP +>1 +One or more errors occurred. +It is unknown if matches were found. +. +.SH ENVIRONMENT +.TP +.B GREP +If +.B GREP +is set to a non-empty value, +it is used instead of +.BR "grep" , +.BR "grep \-E" , +or +.BR "grep \-F" . +. +.SH "SEE ALSO" +.BR grep (1), +.BR xz (1), +.BR gzip (1), +.BR bzip2 (1), +.BR lzop (1), +.BR zstd (1), +.BR lz4 (1), +.BR zgrep (1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzless.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzless.1 new file mode 100644 index 0000000000000000000000000000000000000000..17118b9b85cf485e4da4f9230f8a1c2d893c4d2b --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzless.1 @@ -0,0 +1,69 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" (Note that this file is not based on gzip's zless.1.) +.\" +.TH XZLESS 1 "2025-03-06" "Tukaani" "XZ Utils" +.SH NAME +xzless, lzless \- view xz or lzma compressed (text) files +.SH SYNOPSIS +.B xzless +.RI [ file ...] +.br +.B lzless +.RI [ file ...] +(DEPRECATED) +.SH DESCRIPTION +.B xzless +is a filter that displays text from compressed files to a terminal. +Files supported by +.BR xz (1) +are decompressed; +other files are assumed to be in uncompressed form already. +If no +.I files +are given, +.B xzless +reads from standard input. +.PP +.B xzless +uses +.BR less (1) +to present its output. +Unlike +.BR xzmore , +its choice of pager cannot be altered by +setting an environment variable. +Commands are based on both +.BR more (1) +and +.BR vi (1) +and allow back and forth movement and searching. +See the +.BR less (1) +manual for more information. +.PP +The command named +.B lzless +is provided for backward compatibility with LZMA Utils. +It is deprecated and will be removed in a future version. +.SH ENVIRONMENT +.TP +.B LESSMETACHARS +A list of characters special to the shell. +Set by +.B xzless +unless it is already set in the environment. +.TP +.B LESSOPEN +Set to a command line to invoke the +.BR xz (1) +decompressor for preprocessing the input files to +.BR less (1). +.SH "SEE ALSO" +.BR less (1), +.BR xz (1), +.BR xzmore (1), +.BR zless (1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzma.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzma.1 new file mode 100644 index 0000000000000000000000000000000000000000..6e37b426a3b5c85552cf006f388c9a71d4ad5685 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzma.1 @@ -0,0 +1,3264 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.TH XZ 1 "2025-03-08" "Tukaani" "XZ Utils" +. +.SH NAME +xz, unxz, xzcat, lzma, unlzma, lzcat \- Compress or decompress .xz and .lzma files +. +.SH SYNOPSIS +.B xz +.RI [ option... ] +.RI [ file... ] +. +.SH COMMAND ALIASES +.B unxz +is equivalent to +.BR "xz \-\-decompress" . +.br +.B xzcat +is equivalent to +.BR "xz \-\-decompress \-\-stdout" . +.br +.B lzma +is equivalent to +.BR "xz \-\-format=lzma" . +.br +.B unlzma +is equivalent to +.BR "xz \-\-format=lzma \-\-decompress" . +.br +.B lzcat +is equivalent to +.BR "xz \-\-format=lzma \-\-decompress \-\-stdout" . +.PP +When writing scripts that need to decompress files, +it is recommended to always use the name +.B xz +with appropriate arguments +.RB ( "xz \-d" +or +.BR "xz \-dc" ) +instead of the names +.B unxz +and +.BR xzcat . +. +.SH DESCRIPTION +.B xz +is a general-purpose data compression tool with +command line syntax similar to +.BR gzip (1) +and +.BR bzip2 (1). +The native file format is the +.B .xz +format, but the legacy +.B .lzma +format used by LZMA Utils and +raw compressed streams with no container format headers +are also supported. +In addition, decompression of the +.B .lz +format used by +.B lzip +is supported. +.PP +.B xz +compresses or decompresses each +.I file +according to the selected operation mode. +If no +.I files +are given or +.I file +is +.BR \- , +.B xz +reads from standard input and writes the processed data +to standard output. +.B xz +will refuse (display an error and skip the +.IR file ) +to write compressed data to standard output if it is a terminal. +Similarly, +.B xz +will refuse to read compressed data +from standard input if it is a terminal. +.PP +Unless +.B \-\-stdout +is specified, +.I files +other than +.B \- +are written to a new file whose name is derived from the source +.I file +name: +.IP \(bu 3 +When compressing, the suffix of the target file format +.RB ( .xz +or +.BR .lzma ) +is appended to the source filename to get the target filename. +.IP \(bu 3 +When decompressing, the +.BR .xz , +.BR .lzma , +or +.B .lz +suffix is removed from the filename to get the target filename. +.B xz +also recognizes the suffixes +.B .txz +and +.BR .tlz , +and replaces them with the +.B .tar +suffix. +.PP +If the target file already exists, an error is displayed and the +.I file +is skipped. +.PP +Unless writing to standard output, +.B xz +will display a warning and skip the +.I file +if any of the following applies: +.IP \(bu 3 +.I File +is not a regular file. +Symbolic links are not followed, +and thus they are not considered to be regular files. +.IP \(bu 3 +.I File +has more than one hard link. +.IP \(bu 3 +.I File +has setuid, setgid, or sticky bit set. +.IP \(bu 3 +The operation mode is set to compress and the +.I file +already has a suffix of the target file format +.RB ( .xz +or +.B .txz +when compressing to the +.B .xz +format, and +.B .lzma +or +.B .tlz +when compressing to the +.B .lzma +format). +.IP \(bu 3 +The operation mode is set to decompress and the +.I file +doesn't have a suffix of any of the supported file formats +.RB ( .xz , +.BR .txz , +.BR .lzma , +.BR .tlz , +or +.BR .lz ). +.PP +After successfully compressing or decompressing the +.IR file , +.B xz +copies the owner, group, permissions, access time, +and modification time from the source +.I file +to the target file. +If copying the group fails, the permissions are modified +so that the target file doesn't become accessible to users +who didn't have permission to access the source +.IR file . +.B xz +doesn't support copying other metadata like access control lists +or extended attributes yet. +.PP +Once the target file has been successfully closed, the source +.I file +is removed unless +.B \-\-keep +was specified. +The source +.I file +is never removed if the output is written to standard output +or if an error occurs. +.PP +Sending +.B SIGINFO +or +.B SIGUSR1 +to the +.B xz +process makes it print progress information to standard error. +This has only limited use since when standard error +is a terminal, using +.B \-\-verbose +will display an automatically updating progress indicator. +. +.SS "Memory usage" +The memory usage of +.B xz +varies from a few hundred kilobytes to several gigabytes +depending on the compression settings. +The settings used when compressing a file determine +the memory requirements of the decompressor. +Typically the decompressor needs 5\ % to 20\ % of +the amount of memory that the compressor needed when +creating the file. +For example, decompressing a file created with +.B xz \-9 +currently requires 65\ MiB of memory. +Still, it is possible to have +.B .xz +files that require several gigabytes of memory to decompress. +.PP +Especially users of older systems may find +the possibility of very large memory usage annoying. +To prevent uncomfortable surprises, +.B xz +has a built-in memory usage limiter, which is disabled by default. +While some operating systems provide ways to limit +the memory usage of processes, relying on it +wasn't deemed to be flexible enough (for example, using +.BR ulimit (1) +to limit virtual memory tends to cripple +.BR mmap (2)). +.PP +The memory usage limiter can be enabled with +the command line option \fB\-\-memlimit=\fIlimit\fR. +Often it is more convenient to enable the limiter +by default by setting the environment variable +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +.BR XZ_DEFAULTS , +for example, +.BR XZ_DEFAULTS=\-\-memlimit=150MiB . +It is possible to set the limits separately +for compression and decompression by using +.BI \-\-memlimit\-compress= limit +and \fB\-\-memlimit\-decompress=\fIlimit\fR. +Using these two options outside +.B XZ_DEFAULTS +is rarely useful because a single run of +.B xz +cannot do both compression and decompression and +.BI \-\-memlimit= limit +(or +.B \-M +.IR limit ) +is shorter to type on the command line. +.PP +If the specified memory usage limit is exceeded when decompressing, +.B xz +will display an error and decompressing the file will fail. +If the limit is exceeded when compressing, +.B xz +will try to scale the settings down so that the limit +is no longer exceeded (except when using +.B \-\-format=raw +or +.BR \-\-no\-adjust ). +This way the operation won't fail unless the limit is very small. +The scaling of the settings is done in steps that don't +match the compression level presets, for example, if the limit is +only slightly less than the amount required for +.BR "xz \-9" , +the settings will be scaled down only a little, +not all the way down to +.BR "xz \-8" . +. +.SS "Concatenation and padding with .xz files" +It is possible to concatenate +.B .xz +files as is. +.B xz +will decompress such files as if they were a single +.B .xz +file. +.PP +It is possible to insert padding between the concatenated parts +or after the last part. +The padding must consist of null bytes and the size +of the padding must be a multiple of four bytes. +This can be useful, for example, if the +.B .xz +file is stored on a medium that measures file sizes +in 512-byte blocks. +.PP +Concatenation and padding are not allowed with +.B .lzma +files or raw streams. +. +.SH OPTIONS +. +.SS "Integer suffixes and special values" +In most places where an integer argument is expected, +an optional suffix is supported to easily indicate large integers. +There must be no space between the integer and the suffix. +.TP +.B KiB +Multiply the integer by 1,024 (2^10). +.BR Ki , +.BR k , +.BR kB , +.BR K , +and +.B KB +are accepted as synonyms for +.BR KiB . +.TP +.B MiB +Multiply the integer by 1,048,576 (2^20). +.BR Mi , +.BR m , +.BR M , +and +.B MB +are accepted as synonyms for +.BR MiB . +.TP +.B GiB +Multiply the integer by 1,073,741,824 (2^30). +.BR Gi , +.BR g , +.BR G , +and +.B GB +are accepted as synonyms for +.BR GiB . +.PP +The special value +.B max +can be used to indicate the maximum integer value +supported by the option. +. +.SS "Operation mode" +If multiple operation mode options are given, +the last one takes effect. +.TP +.BR \-z ", " \-\-compress +Compress. +This is the default operation mode when no operation mode option +is specified and no other operation mode is implied from +the command name (for example, +.B unxz +implies +.BR \-\-decompress ). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +After successful compression, the source file is removed +unless writing to standard output or +.B \-\-keep +was specified. +.TP +.BR \-d ", " \-\-decompress ", " \-\-uncompress +Decompress. +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +After successful decompression, the source file is removed +unless writing to standard output or +.B \-\-keep +was specified. +.TP +.BR \-t ", " \-\-test +Test the integrity of compressed +.IR files . +This option is equivalent to +.B "\-\-decompress \-\-stdout" +except that the decompressed data is discarded instead of being +written to standard output. +No files are created or removed. +.TP +.BR \-l ", " \-\-list +Print information about compressed +.IR files . +No uncompressed output is produced, +and no files are created or removed. +In list mode, the program cannot read +the compressed data from standard +input or from other unseekable sources. +.IP "" +The default listing shows basic information about +.IR files , +one file per line. +To get more detailed information, use also the +.B \-\-verbose +option. +For even more information, use +.B \-\-verbose +twice, but note that this may be slow, because getting all the extra +information requires many seeks. +The width of verbose output exceeds +80 characters, so piping the output to, for example, +.B "less\ \-S" +may be convenient if the terminal isn't wide enough. +.IP "" +The exact output may vary between +.B xz +versions and different locales. +For machine-readable output, +.B \-\-robot \-\-list +should be used. +. +.SS "Operation modifiers" +.TP +.BR \-k ", " \-\-keep +Don't delete the input files. +.IP "" +Since +.B xz +5.2.6, +this option also makes +.B xz +compress or decompress even if the input is +a symbolic link to a regular file, +has more than one hard link, +or has the setuid, setgid, or sticky bit set. +The setuid, setgid, and sticky bits are not copied +to the target file. +In earlier versions this was only done with +.BR \-\-force . +.TP +.BR \-f ", " \-\-force +This option has several effects: +.RS +.IP \(bu 3 +If the target file already exists, +delete it before compressing or decompressing. +.IP \(bu 3 +Compress or decompress even if the input is +a symbolic link to a regular file, +has more than one hard link, +or has the setuid, setgid, or sticky bit set. +The setuid, setgid, and sticky bits are not copied +to the target file. +.IP \(bu 3 +When used with +.B \-\-decompress +.B \-\-stdout +and +.B xz +cannot recognize the type of the source file, +copy the source file as is to standard output. +This allows +.B xzcat +.B \-\-force +to be used like +.BR cat (1) +for files that have not been compressed with +.BR xz . +Note that in future, +.B xz +might support new compressed file formats, which may make +.B xz +decompress more types of files instead of copying them as is to +standard output. +.BI \-\-format= format +can be used to restrict +.B xz +to decompress only a single file format. +.RE +.TP +.BR \-c ", " \-\-stdout ", " \-\-to\-stdout +Write the compressed or decompressed data to +standard output instead of a file. +This implies +.BR \-\-keep . +.TP +.B \-\-single\-stream +Decompress only the first +.B .xz +stream, and +silently ignore possible remaining input data following the stream. +Normally such trailing garbage makes +.B xz +display an error. +.IP "" +.B xz +never decompresses more than one stream from +.B .lzma +files or raw streams, but this option still makes +.B xz +ignore the possible trailing data after the +.B .lzma +file or raw stream. +.IP "" +This option has no effect if the operation mode is not +.B \-\-decompress +or +.BR \-\-test . +.IP "" +Since +.B xz +5.7.1alpha, +.B \-\-single\-stream +implies +.BR \-\-keep . +.TP +.B \-\-no\-sparse +Disable creation of sparse files. +By default, if decompressing into a regular file, +.B xz +tries to make the file sparse if the decompressed data contains +long sequences of binary zeros. +It also works when writing to standard output +as long as standard output is connected to a regular file +and certain additional conditions are met to make it safe. +Creating sparse files may save disk space and speed up +the decompression by reducing the amount of disk I/O. +.TP +\fB\-S\fR \fI.suf\fR, \fB\-\-suffix=\fI.suf +When compressing, use +.I .suf +as the suffix for the target file instead of +.B .xz +or +.BR .lzma . +If not writing to standard output and +the source file already has the suffix +.IR .suf , +a warning is displayed and the file is skipped. +.IP "" +When decompressing, recognize files with the suffix +.I .suf +in addition to files with the +.BR .xz , +.BR .txz , +.BR .lzma , +.BR .tlz , +or +.B .lz +suffix. +If the source file has the suffix +.IR .suf , +the suffix is removed to get the target filename. +.IP "" +When compressing or decompressing raw streams +.RB ( \-\-format=raw ), +the suffix must always be specified unless +writing to standard output, +because there is no default suffix for raw streams. +.TP +\fB\-\-files\fR[\fB=\fIfile\fR] +Read the filenames to process from +.IR file ; +if +.I file +is omitted, filenames are read from standard input. +Filenames must be terminated with the newline character. +A dash +.RB ( \- ) +is taken as a regular filename; it doesn't mean standard input. +If filenames are given also as command line arguments, they are +processed before the filenames read from +.IR file . +.TP +\fB\-\-files0\fR[\fB=\fIfile\fR] +This is identical to \fB\-\-files\fR[\fB=\fIfile\fR] except +that each filename must be terminated with the null character. +. +.SS "Basic file format and compression options" +.TP +\fB\-F\fR \fIformat\fR, \fB\-\-format=\fIformat +Specify the file +.I format +to compress or decompress: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +.B auto +This is the default. +When compressing, +.B auto +is equivalent to +.BR xz . +When decompressing, +the format of the input file is automatically detected. +Note that raw streams (created with +.BR \-\-format=raw ) +cannot be auto-detected. +.TP +.B xz +Compress to the +.B .xz +file format, or accept only +.B .xz +files when decompressing. +.TP +.BR lzma ", " alone +Compress to the legacy +.B .lzma +file format, or accept only +.B .lzma +files when decompressing. +The alternative name +.B alone +is provided for backwards compatibility with LZMA Utils. +.TP +.B lzip +Accept only +.B .lz +files when decompressing. +Compression is not supported. +.IP "" +The +.B .lz +format versions 0 and 1 are supported. +Version 0 files were produced by +.B lzip +1.3 and older. +Such files aren't common but may be found from file archives +as a few source packages were released in this format. +People might have old personal files in this format too. +Decompression support for the format version 0 was removed in +.B lzip +1.18. +.B lzip +1.4 and later create files in the format version 1. +.TP +.B raw +Compress or uncompress a raw stream (no headers). +This is meant for advanced users only. +To decode raw streams, you need use +.B \-\-format=raw +and explicitly specify the filter chain, +which normally would have been stored in the container headers. +.RE +.TP +\fB\-C\fR \fIcheck\fR, \fB\-\-check=\fIcheck +Specify the type of the integrity check. +The check is calculated from the uncompressed data and +stored in the +.B .xz +file. +This option has an effect only when compressing into the +.B .xz +format; the +.B .lzma +format doesn't support integrity checks. +The integrity check (if any) is verified when the +.B .xz +file is decompressed. +.IP "" +Supported +.I check +types: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +.B none +Don't calculate an integrity check at all. +This is usually a bad idea. +This can be useful when integrity of the data is verified +by other means anyway. +.TP +.B crc32 +Calculate CRC32 using the polynomial from IEEE-802.3 (Ethernet). +.TP +.B crc64 +Calculate CRC64 using the polynomial from ECMA-182. +This is the default, since it is slightly better than CRC32 +at detecting damaged files and the speed difference is negligible. +.TP +.B sha256 +Calculate SHA-256. +This is somewhat slower than CRC32 and CRC64. +.RE +.IP "" +Integrity of the +.B .xz +headers is always verified with CRC32. +It is not possible to change or disable it. +.TP +.B \-\-ignore\-check +Don't verify the integrity check of the compressed data when decompressing. +The CRC32 values in the +.B .xz +headers will still be verified normally. +.IP "" +.B "Do not use this option unless you know what you are doing." +Possible reasons to use this option: +.RS +.IP \(bu 3 +Trying to recover data from a corrupt .xz file. +.IP \(bu 3 +Speeding up decompression. +This matters mostly with SHA-256 or +with files that have compressed extremely well. +It's recommended to not use this option for this purpose +unless the file integrity is verified externally in some other way. +.RE +.TP +.BR \-0 " ... " \-9 +Select a compression preset level. +The default is +.BR \-6 . +If multiple preset levels are specified, +the last one takes effect. +If a custom filter chain was already specified, setting +a compression preset level clears the custom filter chain. +.IP "" +The differences between the presets are more significant than with +.BR gzip (1) +and +.BR bzip2 (1). +The selected compression settings determine +the memory requirements of the decompressor, +thus using a too high preset level might make it painful +to decompress the file on an old system with little RAM. +Specifically, +.B "it's not a good idea to blindly use \-9 for everything" +like it often is with +.BR gzip (1) +and +.BR bzip2 (1). +.RS +.TP +.BR "\-0" " ... " "\-3" +These are somewhat fast presets. +.B \-0 +is sometimes faster than +.B "gzip \-9" +while compressing much better. +The higher ones often have speed comparable to +.BR bzip2 (1) +with comparable or better compression ratio, +although the results +depend a lot on the type of data being compressed. +.TP +.BR "\-4" " ... " "\-6" +Good to very good compression while keeping +decompressor memory usage reasonable even for old systems. +.B \-6 +is the default, which is usually a good choice +for distributing files that need to be decompressible +even on systems with only 16\ MiB RAM. +.RB ( \-5e +or +.B \-6e +may be worth considering too. +See +.BR \-\-extreme .) +.TP +.B "\-7 ... \-9" +These are like +.B \-6 +but with higher compressor and decompressor memory requirements. +These are useful only when compressing files bigger than +8\ MiB, 16\ MiB, and 32\ MiB, respectively. +.RE +.IP "" +On the same hardware, the decompression speed is approximately +a constant number of bytes of compressed data per second. +In other words, the better the compression, +the faster the decompression will usually be. +This also means that the amount of uncompressed output +produced per second can vary a lot. +.IP "" +The following table summarises the features of the presets: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Preset;DictSize;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Column descriptions: +.RS +.IP \(bu 3 +DictSize is the LZMA2 dictionary size. +It is waste of memory to use a dictionary bigger than +the size of the uncompressed file. +This is why it is good to avoid using the presets +.BR \-7 " ... " \-9 +when there's no real need for them. +At +.B \-6 +and lower, the amount of memory wasted is +usually low enough to not matter. +.IP \(bu 3 +CompCPU is a simplified representation of the LZMA2 settings +that affect compression speed. +The dictionary size affects speed too, +so while CompCPU is the same for levels +.BR \-6 " ... " \-9 , +higher levels still tend to be a little slower. +To get even slower and thus possibly better compression, see +.BR \-\-extreme . +.IP \(bu 3 +CompMem contains the compressor memory requirements +in the single-threaded mode. +It may vary slightly between +.B xz +versions. +.IP \(bu 3 +DecMem contains the decompressor memory requirements. +That is, the compression settings determine +the memory requirements of the decompressor. +The exact decompressor memory usage is slightly more than +the LZMA2 dictionary size, but the values in the table +have been rounded up to the next full MiB. +.RE +.IP "" +Memory requirements of the multi-threaded mode are +significantly higher than that of the single-threaded mode. +With the default value of +.BR \-\-block\-size , +each thread needs 3*3*DictSize plus CompMem or DecMem. +For example, four threads with preset +.B \-6 +needs 660\(en670\ MiB of memory. +.TP +.BR \-e ", " \-\-extreme +Use a slower variant of the selected compression preset level +.RB ( \-0 " ... " \-9 ) +to hopefully get a little bit better compression ratio, +but with bad luck this can also make it worse. +Decompressor memory usage is not affected, +but compressor memory usage increases a little at preset levels +.BR \-0 " ... " \-3 . +.IP "" +Since there are two presets with dictionary sizes +4\ MiB and 8\ MiB, the presets +.B \-3e +and +.B \-5e +use slightly faster settings (lower CompCPU) than +.B \-4e +and +.BR \-6e , +respectively. +That way no two presets are identical. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Preset;DictSize;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +For example, there are a total of four presets that use +8\ MiB dictionary, whose order from the fastest to the slowest is +.BR \-5 , +.BR \-6 , +.BR \-5e , +and +.BR \-6e . +.TP +.B \-\-fast +.PD 0 +.TP +.B \-\-best +.PD +These are somewhat misleading aliases for +.B \-0 +and +.BR \-9 , +respectively. +These are provided only for backwards compatibility +with LZMA Utils. +Avoid using these options. +.TP +.BI \-\-block\-size= size +When compressing to the +.B .xz +format, split the input data into blocks of +.I size +bytes. +The blocks are compressed independently from each other, +which helps with multi-threading and +makes limited random-access decompression possible. +This option is typically used to override the default +block size in multi-threaded mode, +but this option can be used in single-threaded mode too. +.IP "" +In multi-threaded mode about three times +.I size +bytes will be allocated in each thread for buffering input and output. +The default +.I size +is three times the LZMA2 dictionary size or 1 MiB, +whichever is more. +Typically a good value is 2\(en4 times +the size of the LZMA2 dictionary or at least 1 MiB. +Using +.I size +less than the LZMA2 dictionary size is waste of RAM +because then the LZMA2 dictionary buffer will never get fully used. +In multi-threaded mode, +the sizes of the blocks are stored in the block headers. +This size information is required for multi-threaded decompression. +.IP "" +In single-threaded mode no block splitting is done by default. +Setting this option doesn't affect memory usage. +No size information is stored in block headers, +thus files created in single-threaded mode +won't be identical to files created in multi-threaded mode. +The lack of size information also means that +.B xz +won't be able decompress the files in multi-threaded mode. +.TP +.BI \-\-block\-list= items +When compressing to the +.B .xz +format, start a new block with an optional custom filter chain after +the given intervals of uncompressed data. +.IP "" +The +.I items +are a comma-separated list. +Each item consists of an optional filter chain number +between 0 and 9 followed by a colon +.RB ( : ) +and a required size of uncompressed data. +Omitting an item (two or more consecutive commas) is a +shorthand to use the size and filters of the previous item. +.IP "" +If the input file is bigger than the sum of +the sizes in +.IR items , +the last item is repeated until the end of the file. +A special value of +.B 0 +may be used as the last size to indicate that +the rest of the file should be encoded as a single block. +.IP "" +An alternative filter chain for each block can be +specified in combination with the +.BI \-\-filters1= filters +\&...\& +.BI \-\-filters9= filters +options. +These options define filter chains with an identifier +between 1\(en9. +Filter chain 0 can be used to refer to the default filter chain, +which is the same as not specifying a filter chain. +The filter chain identifier can be used before the uncompressed +size, followed by a colon +.RB ( : ). +For example, if one specifies +.B \-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB +then blocks will be created using: +.RS +.IP \(bu 3 +The filter chain specified by +.B \-\-filters1 +and 2 MiB input +.IP \(bu 3 +The filter chain specified by +.B \-\-filters3 +and 2 MiB input +.IP \(bu 3 +The filter chain specified by +.B \-\-filters2 +and 4 MiB input +.IP \(bu 3 +The filter chain specified by +.B \-\-filters2 +and 4 MiB input +.IP \(bu 3 +The default filter chain and 2 MiB input +.IP \(bu 3 +The default filter chain and 4 MiB input for every block until +end of input. +.RE +.IP "" +If one specifies a size that exceeds the encoder's block size +(either the default value in threaded mode or +the value specified with \fB\-\-block\-size=\fIsize\fR), +the encoder will create additional blocks while +keeping the boundaries specified in +.IR items . +For example, if one specifies +.B \-\-block\-size=10MiB +.B \-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB +and the input file is 80 MiB, +one will get 11 blocks: +5, 10, 8, 10, 2, 10, 10, 4, 10, 10, and 1 MiB. +.IP "" +In multi-threaded mode the sizes of the blocks +are stored in the block headers. +This isn't done in single-threaded mode, +so the encoded output won't be +identical to that of the multi-threaded mode. +.TP +.BI \-\-flush\-timeout= timeout +When compressing, if more than +.I timeout +milliseconds (a positive integer) has passed since the previous flush and +reading more input would block, +all the pending input data is flushed from the encoder and +made available in the output stream. +This can be useful if +.B xz +is used to compress data that is streamed over a network. +Small +.I timeout +values make the data available at the receiving end +with a small delay, but large +.I timeout +values give better compression ratio. +.IP "" +This feature is disabled by default. +If this option is specified more than once, the last one takes effect. +The special +.I timeout +value of +.B 0 +can be used to explicitly disable this feature. +.IP "" +This feature is not available on non-POSIX systems. +.IP "" +.\" FIXME +.B "This feature is still experimental." +Currently +.B xz +is unsuitable for decompressing the stream in real time due to how +.B xz +does buffering. +.TP +.B \-\-no\-sync +Do not synchronize the target file and its directory +to the storage device before removing the source file. +This can improve performance if compressing or decompressing +many small files. +However, if the system crashes soon after the deletion, +it is possible that the target file was not written +to the storage device but the delete operation was. +In that case neither the original source file +nor the target file is available. +.IP "" +This option has an effect only when +.B xz +is going to remove the source file. +In other cases synchronization is never done. +.IP "" +The synchronization and +.B \-\-no\-sync +were added in +.B xz +5.7.1alpha. +.TP +.BI \-\-memlimit\-compress= limit +Set a memory usage limit for compression. +If this option is specified multiple times, +the last one takes effect. +.IP "" +If the compression settings exceed the +.IR limit , +.B xz +will attempt to adjust the settings downwards so that +the limit is no longer exceeded and display a notice that +automatic adjustment was done. +The adjustments are done in this order: +reducing the number of threads, +switching to single-threaded mode +if even one thread in multi-threaded mode exceeds the +.IR limit , +and finally reducing the LZMA2 dictionary size. +.IP "" +When compressing with +.B \-\-format=raw +or if +.B \-\-no\-adjust +has been specified, +only the number of threads may be reduced +since it can be done without affecting the compressed output. +.IP "" +If the +.I limit +cannot be met even with the adjustments described above, +an error is displayed and +.B xz +will exit with exit status 1. +.IP "" +The +.I limit +can be specified in multiple ways: +.RS +.IP \(bu 3 +The +.I limit +can be an absolute value in bytes. +Using an integer suffix like +.B MiB +can be useful. +Example: +.B "\-\-memlimit\-compress=80MiB" +.IP \(bu 3 +The +.I limit +can be specified as a percentage of total physical memory (RAM). +This can be useful especially when setting the +.B XZ_DEFAULTS +environment variable in a shell initialization script +that is shared between different computers. +That way the limit is automatically bigger +on systems with more memory. +Example: +.B "\-\-memlimit\-compress=70%" +.IP \(bu 3 +The +.I limit +can be reset back to its default value by setting it to +.BR 0 . +This is currently equivalent to setting the +.I limit +to +.B max +(no memory usage limit). +.RE +.IP "" +For 32-bit +.B xz +there is a special case: if the +.I limit +would be over +.BR "4020\ MiB" , +the +.I limit +is set to +.BR "4020\ MiB" . +On MIPS32 +.B "2000\ MiB" +is used instead. +(The values +.B 0 +and +.B max +aren't affected by this. +A similar feature doesn't exist for decompression.) +This can be helpful when a 32-bit executable has access +to 4\ GiB address space (2 GiB on MIPS32) +while hopefully doing no harm in other situations. +.IP "" +See also the section +.BR "Memory usage" . +.TP +.BI \-\-memlimit\-decompress= limit +Set a memory usage limit for decompression. +This also affects the +.B \-\-list +mode. +If the operation is not possible without exceeding the +.IR limit , +.B xz +will display an error and decompressing the file will fail. +See +.BI \-\-memlimit\-compress= limit +for possible ways to specify the +.IR limit . +.TP +.BI \-\-memlimit\-mt\-decompress= limit +Set a memory usage limit for multi-threaded decompression. +This can only affect the number of threads; +this will never make +.B xz +refuse to decompress a file. +If +.I limit +is too low to allow any multi-threading, the +.I limit +is ignored and +.B xz +will continue in single-threaded mode. +Note that if also +.B \-\-memlimit\-decompress +is used, +it will always apply to both single-threaded and multi-threaded modes, +and so the effective +.I limit +for multi-threading will never be higher than the limit set with +.BR \-\-memlimit\-decompress . +.IP "" +In contrast to the other memory usage limit options, +.BI \-\-memlimit\-mt\-decompress= limit +has a system-specific default +.IR limit . +.B "xz \-\-info\-memory" +can be used to see the current value. +.IP "" +This option and its default value exist +because without any limit the threaded decompressor +could end up allocating an insane amount of memory with some input files. +If the default +.I limit +is too low on your system, +feel free to increase the +.I limit +but never set it to a value larger than the amount of usable RAM +as with appropriate input files +.B xz +will attempt to use that amount of memory +even with a low number of threads. +Running out of memory or swapping +will not improve decompression performance. +.IP "" +See +.BI \-\-memlimit\-compress= limit +for possible ways to specify the +.IR limit . +Setting +.I limit +to +.B 0 +resets the +.I limit +to the default system-specific value. +.TP +\fB\-M\fR \fIlimit\fR, \fB\-\-memlimit=\fIlimit\fR, \fB\-\-memory=\fIlimit +This is equivalent to specifying +.BI \-\-memlimit\-compress= limit +.BI \-\-memlimit-decompress= limit +\fB\-\-memlimit\-mt\-decompress=\fIlimit\fR. +.TP +.B \-\-no\-adjust +Display an error and exit if the memory usage limit cannot be +met without adjusting settings that affect the compressed output. +That is, this prevents +.B xz +from switching the encoder from multi-threaded mode to single-threaded mode +and from reducing the LZMA2 dictionary size. +Even when this option is used the number of threads may be reduced +to meet the memory usage limit as that won't affect the compressed output. +.IP "" +Automatic adjusting is always disabled when creating raw streams +.RB ( \-\-format=raw ). +.TP +\fB\-T\fR \fIthreads\fR, \fB\-\-threads=\fIthreads +Specify the number of worker threads to use. +Setting +.I threads +to a special value +.B 0 +makes +.B xz +use up to as many threads as the processor(s) on the system support. +The actual number of threads can be fewer than +.I threads +if the input file is not big enough +for threading with the given settings or +if using more threads would exceed the memory usage limit. +.IP "" +The single-threaded and multi-threaded compressors produce different output. +Single-threaded compressor will give the smallest file size but +only the output from the multi-threaded compressor can be decompressed +using multiple threads. +Setting +.I threads +to +.B 1 +will use the single-threaded mode. +Setting +.I threads +to any other value, including +.BR 0 , +will use the multi-threaded compressor +even if the system supports only one hardware thread. +.RB ( xz +5.2.x +used single-threaded mode in this situation.) +.IP "" +To use multi-threaded mode with only one thread, set +.I threads +to +.BR +1 . +The +.B + +prefix has no effect with values other than +.BR 1 . +A memory usage limit can still make +.B xz +switch to single-threaded mode unless +.B \-\-no\-adjust +is used. +Support for the +.B + +prefix was added in +.B xz +5.4.0. +.IP "" +If an automatic number of threads has been requested and +no memory usage limit has been specified, +then a system-specific default soft limit will be used to possibly +limit the number of threads. +It is a soft limit in sense that it is ignored +if the number of threads becomes one, +thus a soft limit will never stop +.B xz +from compressing or decompressing. +This default soft limit will not make +.B xz +switch from multi-threaded mode to single-threaded mode. +The active limits can be seen with +.BR "xz \-\-info\-memory" . +.IP "" +Currently the only threading method is to split the input into +blocks and compress them independently from each other. +The default block size depends on the compression level and +can be overridden with the +.BI \-\-block\-size= size +option. +.IP "" +Threaded decompression only works on files that contain +multiple blocks with size information in block headers. +All large enough files compressed in multi-threaded mode +meet this condition, +but files compressed in single-threaded mode don't even if +.BI \-\-block\-size= size +has been used. +.IP "" +The default value for +.I threads +is +.BR 0 . +In +.B xz +5.4.x and older the default is +.BR 1 . +. +.SS "Custom compressor filter chains" +A custom filter chain allows specifying +the compression settings in detail instead of relying on +the settings associated to the presets. +When a custom filter chain is specified, +preset options +.RB ( \-0 +\&...\& +.B \-9 +and +.BR \-\-extreme ) +earlier on the command line are forgotten. +If a preset option is specified +after one or more custom filter chain options, +the new preset takes effect and +the custom filter chain options specified earlier are forgotten. +.PP +A filter chain is comparable to piping on the command line. +When compressing, the uncompressed input goes to the first filter, +whose output goes to the next filter (if any). +The output of the last filter gets written to the compressed file. +The maximum number of filters in the chain is four, +but typically a filter chain has only one or two filters. +.PP +Many filters have limitations on where they can be +in the filter chain: +some filters can work only as the last filter in the chain, +some only as a non-last filter, and some work in any position +in the chain. +Depending on the filter, this limitation is either inherent to +the filter design or exists to prevent security issues. +.PP +A custom filter chain can be specified in two different ways. +The options +.BI \-\-filters= filters +and +.BI \-\-filters1= filters +\&...\& +.BI \-\-filters9= filters +allow specifying an entire filter chain in one option using the +liblzma filter string syntax. +Alternatively, a filter chain can be specified by using one or more +individual filter options in the order they are wanted in the filter chain. +That is, the order of the individual filter options is significant! +When decoding raw streams +.RB ( \-\-format=raw ), +the filter chain must be specified in the same order as +it was specified when compressing. +Any individual filter or preset options specified before the full +chain option +(\fB\-\-filters=\fIfilters\fR) +will be forgotten. +Individual filters specified after the full chain option will reset the +filter chain. +.PP +Both the full and individual filter options take filter-specific +.I options +as a comma-separated list. +Extra commas in +.I options +are ignored. +Every option has a default value, so +specify those you want to change. +.PP +To see the whole filter chain and +.IR options , +use +.B "xz \-vv" +(that is, use +.B \-\-verbose +twice). +This works also for viewing the filter chain options used by presets. +.TP +.BI \-\-filters= filters +Specify the full filter chain or a preset in a single option. +Each filter can be separated by spaces or two dashes +.RB ( \-\- ). +.I filters +may need to be quoted on the shell command line so it is +parsed as a single option. +To denote +.IR options , +use +.B : +or +.BR = . +A preset can be prefixed with a +.B \- +and followed with zero or more flags. +The only supported flag is +.B e +to apply the same options as +.BR \-\-extreme . +.TP +\fB\-\-filters1\fR=\fIfilters\fR ... \fB\-\-filters9\fR=\fIfilters +Specify up to nine additional filter chains that can be used with +.BR \-\-block\-list . +.IP "" +For example, when compressing an archive with executable files +followed by text files, the executable part could use a filter +chain with a BCJ filter and the text part only the LZMA2 filter. +.TP +.B \-\-filters-help +Display a help message describing how to specify presets and +custom filter chains in the +.B \-\-filters +and +.BI \-\-filters1= filters +\&...\& +.BI \-\-filters9= filters +options, and exit successfully. +.TP +\fB\-\-lzma1\fR[\fB=\fIoptions\fR] +.PD 0 +.TP +\fB\-\-lzma2\fR[\fB=\fIoptions\fR] +.PD +Add LZMA1 or LZMA2 filter to the filter chain. +These filters can be used only as the last filter in the chain. +.IP "" +LZMA1 is a legacy filter, +which is supported almost solely due to the legacy +.B .lzma +file format, which supports only LZMA1. +LZMA2 is an updated +version of LZMA1 to fix some practical issues of LZMA1. +The +.B .xz +format uses LZMA2 and doesn't support LZMA1 at all. +Compression speed and ratios of LZMA1 and LZMA2 +are practically the same. +.IP "" +LZMA1 and LZMA2 share the same set of +.IR options : +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +.BI preset= preset +Reset all LZMA1 or LZMA2 +.I options +to +.IR preset . +.I Preset +consist of an integer, which may be followed by single-letter +preset modifiers. +The integer can be from +.B 0 +to +.BR 9 , +matching the command line options +.B \-0 +\&...\& +.BR \-9 . +The only supported modifier is currently +.BR e , +which matches +.BR \-\-extreme . +If no +.B preset +is specified, the default values of LZMA1 or LZMA2 +.I options +are taken from the preset +.BR 6 . +.TP +.BI dict= size +Dictionary (history buffer) +.I size +indicates how many bytes of the recently processed +uncompressed data is kept in memory. +The algorithm tries to find repeating byte sequences (matches) in +the uncompressed data, and replace them with references +to the data currently in the dictionary. +The bigger the dictionary, the higher is the chance +to find a match. +Thus, increasing dictionary +.I size +usually improves compression ratio, but +a dictionary bigger than the uncompressed file is waste of memory. +.IP "" +Typical dictionary +.I size +is from 64\ KiB to 64\ MiB. +The minimum is 4\ KiB. +The maximum for compression is currently 1.5\ GiB (1536\ MiB). +The decompressor already supports dictionaries up to +one byte less than 4\ GiB, which is the maximum for +the LZMA1 and LZMA2 stream formats. +.IP "" +Dictionary +.I size +and match finder +.RI ( mf ) +together determine the memory usage of the LZMA1 or LZMA2 encoder. +The same (or bigger) dictionary +.I size +is required for decompressing that was used when compressing, +thus the memory usage of the decoder is determined +by the dictionary size used when compressing. +The +.B .xz +headers store the dictionary +.I size +either as +.RI "2^" n +or +.RI "2^" n " + 2^(" n "\-1)," +so these +.I sizes +are somewhat preferred for compression. +Other +.I sizes +will get rounded up when stored in the +.B .xz +headers. +.TP +.BI lc= lc +Specify the number of literal context bits. +The minimum is 0 and the maximum is 4; the default is 3. +In addition, the sum of +.I lc +and +.I lp +must not exceed 4. +.IP "" +All bytes that cannot be encoded as matches +are encoded as literals. +That is, literals are simply 8-bit bytes +that are encoded one at a time. +.IP "" +The literal coding makes an assumption that the highest +.I lc +bits of the previous uncompressed byte correlate +with the next byte. +For example, in typical English text, an upper-case letter is +often followed by a lower-case letter, and a lower-case +letter is usually followed by another lower-case letter. +In the US-ASCII character set, the highest three bits are 010 +for upper-case letters and 011 for lower-case letters. +When +.I lc +is at least 3, the literal coding can take advantage of +this property in the uncompressed data. +.IP "" +The default value (3) is usually good. +If you want maximum compression, test +.BR lc=4 . +Sometimes it helps a little, and +sometimes it makes compression worse. +If it makes it worse, test +.B lc=2 +too. +.TP +.BI lp= lp +Specify the number of literal position bits. +The minimum is 0 and the maximum is 4; the default is 0. +.IP "" +.I Lp +affects what kind of alignment in the uncompressed data is +assumed when encoding literals. +See +.I pb +below for more information about alignment. +.TP +.BI pb= pb +Specify the number of position bits. +The minimum is 0 and the maximum is 4; the default is 2. +.IP "" +.I Pb +affects what kind of alignment in the uncompressed data is +assumed in general. +The default means four-byte alignment +.RI (2^ pb =2^2=4), +which is often a good choice when there's no better guess. +.IP "" +When the alignment is known, setting +.I pb +accordingly may reduce the file size a little. +For example, with text files having one-byte +alignment (US-ASCII, ISO-8859-*, UTF-8), setting +.B pb=0 +can improve compression slightly. +For UTF-16 text, +.B pb=1 +is a good choice. +If the alignment is an odd number like 3 bytes, +.B pb=0 +might be the best choice. +.IP "" +Even though the assumed alignment can be adjusted with +.I pb +and +.IR lp , +LZMA1 and LZMA2 still slightly favor 16-byte alignment. +It might be worth taking into account when designing file formats +that are likely to be often compressed with LZMA1 or LZMA2. +.TP +.BI mf= mf +Match finder has a major effect on encoder speed, +memory usage, and compression ratio. +Usually Hash Chain match finders are faster than Binary Tree +match finders. +The default depends on the +.IR preset : +0 uses +.BR hc3 , +1\(en3 +use +.BR hc4 , +and the rest use +.BR bt4 . +.IP "" +The following match finders are supported. +The memory usage formulas below are rough approximations, +which are closest to the reality when +.I dict +is a power of two. +.RS +.TP +.B hc3 +Hash Chain with 2- and 3-byte hashing +.br +Minimum value for +.IR nice : +3 +.br +Memory usage: +.br +.I dict +* 7.5 (if +.I dict +<= 16 MiB); +.br +.I dict +* 5.5 + 64 MiB (if +.I dict +> 16 MiB) +.TP +.B hc4 +Hash Chain with 2-, 3-, and 4-byte hashing +.br +Minimum value for +.IR nice : +4 +.br +Memory usage: +.br +.I dict +* 7.5 (if +.I dict +<= 32 MiB); +.br +.I dict +* 6.5 (if +.I dict +> 32 MiB) +.TP +.B bt2 +Binary Tree with 2-byte hashing +.br +Minimum value for +.IR nice : +2 +.br +Memory usage: +.I dict +* 9.5 +.TP +.B bt3 +Binary Tree with 2- and 3-byte hashing +.br +Minimum value for +.IR nice : +3 +.br +Memory usage: +.br +.I dict +* 11.5 (if +.I dict +<= 16 MiB); +.br +.I dict +* 9.5 + 64 MiB (if +.I dict +> 16 MiB) +.TP +.B bt4 +Binary Tree with 2-, 3-, and 4-byte hashing +.br +Minimum value for +.IR nice : +4 +.br +Memory usage: +.br +.I dict +* 11.5 (if +.I dict +<= 32 MiB); +.br +.I dict +* 10.5 (if +.I dict +> 32 MiB) +.RE +.TP +.BI mode= mode +Compression +.I mode +specifies the method to analyze +the data produced by the match finder. +Supported +.I modes +are +.B fast +and +.BR normal . +The default is +.B fast +for +.I presets +0\(en3 and +.B normal +for +.I presets +4\(en9. +.IP "" +Usually +.B fast +is used with Hash Chain match finders and +.B normal +with Binary Tree match finders. +This is also what the +.I presets +do. +.TP +.BI nice= nice +Specify what is considered to be a nice length for a match. +Once a match of at least +.I nice +bytes is found, the algorithm stops +looking for possibly better matches. +.IP "" +.I Nice +can be 2\(en273 bytes. +Higher values tend to give better compression ratio +at the expense of speed. +The default depends on the +.IR preset . +.TP +.BI depth= depth +Specify the maximum search depth in the match finder. +The default is the special value of 0, +which makes the compressor determine a reasonable +.I depth +from +.I mf +and +.IR nice . +.IP "" +Reasonable +.I depth +for Hash Chains is 4\(en100 and 16\(en1000 for Binary Trees. +Using very high values for +.I depth +can make the encoder extremely slow with some files. +Avoid setting the +.I depth +over 1000 unless you are prepared to interrupt +the compression in case it is taking far too long. +.RE +.IP "" +When decoding raw streams +.RB ( \-\-format=raw ), +LZMA2 needs only the dictionary +.IR size . +LZMA1 needs also +.IR lc , +.IR lp , +and +.IR pb . +.TP +\fB\-\-x86\fR[\fB=\fIoptions\fR] +.PD 0 +.TP +\fB\-\-arm\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-armthumb\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-arm64\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-powerpc\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-ia64\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-sparc\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-riscv\fR[\fB=\fIoptions\fR] +.PD +Add a branch/call/jump (BCJ) filter to the filter chain. +These filters can be used only as a non-last filter +in the filter chain. +.IP "" +A BCJ filter converts relative addresses in +the machine code to their absolute counterparts. +This doesn't change the size of the data +but it increases redundancy, +which can help LZMA2 to produce 0\(en15\ % smaller +.B .xz +file. +The BCJ filters are always reversible, +so using a BCJ filter for wrong type of data +doesn't cause any data loss, although it may make +the compression ratio slightly worse. +The BCJ filters are very fast and +use an insignificant amount of memory. +.IP "" +These BCJ filters have known problems related to +the compression ratio: +.RS +.IP \(bu 3 +Some types of files containing executable code +(for example, object files, static libraries, and Linux kernel modules) +have the addresses in the instructions filled with filler values. +These BCJ filters will still do the address conversion, +which will make the compression worse with these files. +.IP \(bu 3 +If a BCJ filter is applied on an archive, +it is possible that it makes the compression ratio +worse than not using a BCJ filter. +For example, if there are similar or even identical executables +then filtering will likely make the files less similar +and thus compression is worse. +The contents of non-executable files in the same archive can matter too. +In practice one has to try with and without a BCJ filter to see +which is better in each situation. +.RE +.IP "" +Different instruction sets have different alignment: +the executable file must be aligned to a multiple of +this value in the input data to make the filter work. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filter;Alignment;Notes +x86;1;32-bit or 64-bit x86 +ARM;4; +ARM-Thumb;2; +ARM64;4;4096-byte alignment is best +PowerPC;4;Big endian only +IA-64;16;Itanium +SPARC;4; +RISC-V;2; +.TE +.RE +.RE +.IP "" +Since the BCJ-filtered data is usually compressed with LZMA2, +the compression ratio may be improved slightly if +the LZMA2 options are set to match the +alignment of the selected BCJ filter. +Examples: +.RS +.IP \(bu 3 +IA-64 filter has 16-byte alignment so +.B pb=4,lp=4,lc=0 +is good +with LZMA2 (2^4=16). +.IP \(bu 3 +RISC-V code has 2-byte or 4-byte alignment +depending on whether the file contains +16-bit compressed instructions (the C extension). +When 16-bit instructions are used, +.B pb=2,lp=1,lc=3 +or +.B pb=1,lp=1,lc=3 +is good. +When 16-bit instructions aren't present, +.B pb=2,lp=2,lc=2 +is the best. +.B readelf \-h +can be used to check if "RVC" +appears on the "Flags" line. +.IP \(bu 3 +ARM64 is always 4-byte aligned so +.B pb=2,lp=2,lc=2 +is the best. +.IP \(bu 3 +The x86 filter is an exception. +It's usually good to stick to LZMA2's defaults +.RB ( pb=2,lp=0,lc=3 ) +when compressing x86 executables. +.RE +.IP "" +All BCJ filters support the same +.IR options : +.RS +.TP +.BI start= offset +Specify the start +.I offset +that is used when converting between relative +and absolute addresses. +The +.I offset +must be a multiple of the alignment of the filter +(see the table above). +The default is zero. +In practice, the default is good; specifying a custom +.I offset +is almost never useful. +.RE +.TP +\fB\-\-delta\fR[\fB=\fIoptions\fR] +Add the Delta filter to the filter chain. +The Delta filter can be only used as a non-last filter +in the filter chain. +.IP "" +Currently only simple byte-wise delta calculation is supported. +It can be useful when compressing, for example, uncompressed bitmap images +or uncompressed PCM audio. +However, special purpose algorithms may give significantly better +results than Delta + LZMA2. +This is true especially with audio, +which compresses faster and better, for example, with +.BR flac (1). +.IP "" +Supported +.IR options : +.RS +.TP +.BI dist= distance +Specify the +.I distance +of the delta calculation in bytes. +.I distance +must be 1\(en256. +The default is 1. +.IP "" +For example, with +.B dist=2 +and eight-byte input A1 B1 A2 B3 A3 B5 A4 B7, the output will be +A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Other options" +.TP +.BR \-q ", " \-\-quiet +Suppress warnings and notices. +Specify this twice to suppress errors too. +This option has no effect on the exit status. +That is, even if a warning was suppressed, +the exit status to indicate a warning is still used. +.TP +.BR \-v ", " \-\-verbose +Be verbose. +If standard error is connected to a terminal, +.B xz +will display a progress indicator. +Specifying +.B \-\-verbose +twice will give even more verbose output. +.IP "" +The progress indicator shows the following information: +.RS +.IP \(bu 3 +Completion percentage is shown +if the size of the input file is known. +That is, the percentage cannot be shown in pipes. +.IP \(bu 3 +Amount of compressed data produced (compressing) +or consumed (decompressing). +.IP \(bu 3 +Amount of uncompressed data consumed (compressing) +or produced (decompressing). +.IP \(bu 3 +Compression ratio, which is calculated by dividing +the amount of compressed data processed so far by +the amount of uncompressed data processed so far. +.IP \(bu 3 +Compression or decompression speed. +This is measured as the amount of uncompressed data consumed +(compression) or produced (decompression) per second. +It is shown after a few seconds have passed since +.B xz +started processing the file. +.IP \(bu 3 +Elapsed time in the format M:SS or H:MM:SS. +.IP \(bu 3 +Estimated remaining time is shown +only when the size of the input file is +known and a couple of seconds have already passed since +.B xz +started processing the file. +The time is shown in a less precise format which +never has any colons, for example, 2 min 30 s. +.RE +.IP "" +When standard error is not a terminal, +.B \-\-verbose +will make +.B xz +print the filename, compressed size, uncompressed size, +compression ratio, and possibly also the speed and elapsed time +on a single line to standard error after compressing or +decompressing the file. +The speed and elapsed time are included only when +the operation took at least a few seconds. +If the operation didn't finish, for example, due to user interruption, +also the completion percentage is printed +if the size of the input file is known. +.TP +.BR \-Q ", " \-\-no\-warn +Don't set the exit status to 2 +even if a condition worth a warning was detected. +This option doesn't affect the verbosity level, thus both +.B \-\-quiet +and +.B \-\-no\-warn +have to be used to not display warnings and +to not alter the exit status. +.TP +.B \-\-robot +Print messages in a machine-parsable format. +This is intended to ease writing frontends that want to use +.B xz +instead of liblzma, which may be the case with various scripts. +The output with this option enabled is meant to be stable across +.B xz +releases. +See the section +.B "ROBOT MODE" +for details. +.TP +.B \-\-info\-memory +Display, in human-readable format, how much physical memory (RAM) +and how many processor threads +.B xz +thinks the system has and the memory usage limits for compression +and decompression, and exit successfully. +.TP +.BR \-h ", " \-\-help +Display a help message describing the most commonly used options, +and exit successfully. +.TP +.BR \-H ", " \-\-long\-help +Display a help message describing all features of +.BR xz , +and exit successfully +.TP +.BR \-V ", " \-\-version +Display the version number of +.B xz +and liblzma in human readable format. +To get machine-parsable output, specify +.B \-\-robot +before +.BR \-\-version . +. +.SH "ROBOT MODE" +The robot mode is activated with the +.B \-\-robot +option. +It makes the output of +.B xz +easier to parse by other programs. +Currently +.B \-\-robot +is supported only together with +.BR \-\-list , +.BR \-\-filters\-help , +.BR \-\-info\-memory , +and +.BR \-\-version . +It will be supported for compression and +decompression in the future. +. +.SS "List mode" +.B "xz \-\-robot \-\-list" +uses tab-separated output. +The first column of every line has a string +that indicates the type of the information found on that line: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +.B name +This is always the first line when starting to list a file. +The second column on the line is the filename. +.TP +.B file +This line contains overall information about the +.B .xz +file. +This line is always printed after the +.B name +line. +.TP +.B stream +This line type is used only when +.B \-\-verbose +was specified. +There are as many +.B stream +lines as there are streams in the +.B .xz +file. +.TP +.B block +This line type is used only when +.B \-\-verbose +was specified. +There are as many +.B block +lines as there are blocks in the +.B .xz +file. +The +.B block +lines are shown after all the +.B stream +lines; different line types are not interleaved. +.TP +.B summary +This line type is used only when +.B \-\-verbose +was specified twice. +This line is printed after all +.B block +lines. +Like the +.B file +line, the +.B summary +line contains overall information about the +.B .xz +file. +.TP +.B totals +This line is always the very last line of the list output. +It shows the total counts and sizes. +.PP +The columns of the +.B file +lines: +.PD 0 +.RS +.IP 2. 4 +Number of streams in the file +.IP 3. 4 +Total number of blocks in the stream(s) +.IP 4. 4 +Compressed size of the file +.IP 5. 4 +Uncompressed size of the file +.IP 6. 4 +Compression ratio, for example, +.BR 0.123 . +If ratio is over 9.999, three dashes +.RB ( \-\-\- ) +are displayed instead of the ratio. +.IP 7. 4 +Comma-separated list of integrity check names. +The following strings are used for the known check types: +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +.BR None , +.BR CRC32 , +.BR CRC64 , +and +.BR SHA\-256 . +For unknown check types, +.BI Unknown\- N +is used, where +.I N +is the Check ID as a decimal number (one or two digits). +.IP 8. 4 +Total size of stream padding in the file +.RE +.PD +.PP +The columns of the +.B stream +lines: +.PD 0 +.RS +.IP 2. 4 +Stream number (the first stream is 1) +.IP 3. 4 +Number of blocks in the stream +.IP 4. 4 +Compressed start offset +.IP 5. 4 +Uncompressed start offset +.IP 6. 4 +Compressed size (does not include stream padding) +.IP 7. 4 +Uncompressed size +.IP 8. 4 +Compression ratio +.IP 9. 4 +Name of the integrity check +.IP 10. 4 +Size of stream padding +.RE +.PD +.PP +The columns of the +.B block +lines: +.PD 0 +.RS +.IP 2. 4 +Number of the stream containing this block +.IP 3. 4 +Block number relative to the beginning of the stream +(the first block is 1) +.IP 4. 4 +Block number relative to the beginning of the file +.IP 5. 4 +Compressed start offset relative to the beginning of the file +.IP 6. 4 +Uncompressed start offset relative to the beginning of the file +.IP 7. 4 +Total compressed size of the block (includes headers) +.IP 8. 4 +Uncompressed size +.IP 9. 4 +Compression ratio +.IP 10. 4 +Name of the integrity check +.RE +.PD +.PP +If +.B \-\-verbose +was specified twice, additional columns are included on the +.B block +lines. +These are not displayed with a single +.BR \-\-verbose , +because getting this information requires many seeks +and can thus be slow: +.PD 0 +.RS +.IP 11. 4 +Value of the integrity check in hexadecimal +.IP 12. 4 +Block header size +.IP 13. 4 +Block flags: +.B c +indicates that compressed size is present, and +.B u +indicates that uncompressed size is present. +If the flag is not set, a dash +.RB ( \- ) +is shown instead to keep the string length fixed. +New flags may be added to the end of the string in the future. +.IP 14. 4 +Size of the actual compressed data in the block (this excludes +the block header, block padding, and check fields) +.IP 15. 4 +Amount of memory (in bytes) required to decompress +this block with this +.B xz +version +.IP 16. 4 +Filter chain. +Note that most of the options used at compression time +cannot be known, because only the options +that are needed for decompression are stored in the +.B .xz +headers. +.RE +.PD +.PP +The columns of the +.B summary +lines: +.PD 0 +.RS +.IP 2. 4 +Amount of memory (in bytes) required to decompress +this file with this +.B xz +version +.IP 3. 4 +.B yes +or +.B no +indicating if all block headers have both compressed size and +uncompressed size stored in them +.PP +.I Since +.B xz +.I 5.1.2alpha: +.IP 4. 4 +Minimum +.B xz +version required to decompress the file +.RE +.PD +.PP +The columns of the +.B totals +line: +.PD 0 +.RS +.IP 2. 4 +Number of streams +.IP 3. 4 +Number of blocks +.IP 4. 4 +Compressed size +.IP 5. 4 +Uncompressed size +.IP 6. 4 +Average compression ratio +.IP 7. 4 +Comma-separated list of integrity check names +that were present in the files +.IP 8. 4 +Stream padding size +.IP 9. 4 +Number of files. +This is here to +keep the order of the earlier columns the same as on +.B file +lines. +.PD +.RE +.PP +If +.B \-\-verbose +was specified twice, additional columns are included on the +.B totals +line: +.PD 0 +.RS +.IP 10. 4 +Maximum amount of memory (in bytes) required to decompress +the files with this +.B xz +version +.IP 11. 4 +.B yes +or +.B no +indicating if all block headers have both compressed size and +uncompressed size stored in them +.PP +.I Since +.B xz +.I 5.1.2alpha: +.IP 12. 4 +Minimum +.B xz +version required to decompress the file +.RE +.PD +.PP +Future versions may add new line types and +new columns can be added to the existing line types, +but the existing columns won't be changed. +. +.SS "Filters help" +.B "xz \-\-robot \-\-filters-help" +prints the supported filters in the following format: +.PP +\fIfilter\fB:\fIoption\fB=<\fIvalue\fB>,\fIoption\fB=<\fIvalue\fB>\fR... +.TP +.I filter +Name of the filter +.TP +.I option +Name of a filter specific option +.TP +.I value +Numeric +.I value +ranges appear as +\fB<\fImin\fB\-\fImax\fB>\fR. +String +.I value +choices are shown within +.B "< >" +and separated by a +.B | +character. +.PP +Each filter is printed on its own line. +. +.SS "Memory limit information" +.B "xz \-\-robot \-\-info\-memory" +prints a single line with multiple tab-separated columns: +.IP 1. 4 +Total amount of physical memory (RAM) in bytes. +.IP 2. 4 +Memory usage limit for compression in bytes +.RB ( \-\-memlimit\-compress ). +A special value of +.B 0 +indicates the default setting +which for single-threaded mode is the same as no limit. +.IP 3. 4 +Memory usage limit for decompression in bytes +.RB ( \-\-memlimit\-decompress ). +A special value of +.B 0 +indicates the default setting +which for single-threaded mode is the same as no limit. +.IP 4. 4 +Since +.B xz +5.3.4alpha: +Memory usage for multi-threaded decompression in bytes +.RB ( \-\-memlimit\-mt\-decompress ). +This is never zero because a system-specific default value +shown in the column 5 +is used if no limit has been specified explicitly. +This is also never greater than the value in the column 3 +even if a larger value has been specified with +.BR \-\-memlimit\-mt\-decompress . +.IP 5. 4 +Since +.B xz +5.3.4alpha: +A system-specific default memory usage limit +that is used to limit the number of threads +when compressing with an automatic number of threads +.RB ( \-\-threads=0 ) +and no memory usage limit has been specified +.RB ( \-\-memlimit\-compress ). +This is also used as the default value for +.BR \-\-memlimit\-mt\-decompress . +.IP 6. 4 +Since +.B xz +5.3.4alpha: +Number of available processor threads. +.PP +In the future, the output of +.B "xz \-\-robot \-\-info\-memory" +may have more columns, but never more than a single line. +. +.SS Version +.B "xz \-\-robot \-\-version" +prints the version number of +.B xz +and liblzma in the following format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +.BI XZ_VERSION= XYYYZZZS +.br +.BI LIBLZMA_VERSION= XYYYZZZS +.TP +.I X +Major version. +.TP +.I YYY +Minor version. +Even numbers are stable. +Odd numbers are alpha or beta versions. +.TP +.I ZZZ +Patch level for stable releases or +just a counter for development releases. +.TP +.I S +Stability. +0 is alpha, 1 is beta, and 2 is stable. +.I S +should be always 2 when +.I YYY +is even. +.PP +.I XYYYZZZS +are the same on both lines if +.B xz +and liblzma are from the same XZ Utils release. +.PP +Examples: 4.999.9beta is +.B 49990091 +and +5.0.0 is +.BR 50000002 . +. +.SH "EXIT STATUS" +.TP +.B 0 +All is good. +.TP +.B 1 +An error occurred. +.TP +.B 2 +Something worth a warning occurred, +but no actual errors occurred. +.PP +Notices (not warnings or errors) printed on standard error +don't affect the exit status. +. +.SH ENVIRONMENT +.B xz +parses space-separated lists of options +from the environment variables +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +.B XZ_DEFAULTS +and +.BR XZ_OPT , +in this order, before parsing the options from the command line. +Note that only options are parsed from the environment variables; +all non-options are silently ignored. +Parsing is done with +.BR getopt_long (3) +which is used also for the command line arguments. +.PP +.B Warning: +By setting these environment variables, +one is effectively modifying programs and scripts that run +.BR xz . +Most of the time it is safe to set memory usage limits, number of threads, +and compression options via the environment variables. +However, some options can break scripts. +An obvious example is +.B \-\-help +which makes +.B xz +show the help text instead of compressing or decompressing a file. +More subtle examples are +.B \-\-quiet +and +.BR \-\-verbose . +In many cases it works well to enable the progress indicator using +.BR \-\-verbose , +but in some situations the extra messages create problems. +The verbosity level also affects the behavior of +.BR \-\-list . +.TP +.B XZ_DEFAULTS +User-specific or system-wide default options. +Typically this is set in a shell initialization script to enable +.BR xz 's +memory usage limiter by default or set the default number of threads. +Excluding shell initialization scripts +and similar special cases, scripts should never set or unset +.BR XZ_DEFAULTS . +.TP +.B XZ_OPT +This is for passing options to +.B xz +when it is not possible to set the options directly on the +.B xz +command line. +This is the case when +.B xz +is run by a script or tool, for example, GNU +.BR tar (1): +.RS +.RS +.PP +.nf +.ft CR +XZ_OPT=\-2v tar caf foo.tar.xz foo +.ft R +.fi +.RE +.RE +.IP "" +Scripts may use +.BR XZ_OPT , +for example, to set script-specific default compression options. +It is still recommended to allow users to override +.B XZ_OPT +if that is reasonable. +For example, in +.BR sh (1) +scripts one may use something like this: +.RS +.RS +.PP +.nf +.ft CR +XZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT +.ft R +.fi +.RE +.RE +. +.SH "LZMA UTILS COMPATIBILITY" +The command line syntax of +.B xz +is practically a superset of +.BR lzma , +.BR unlzma , +and +.B lzcat +as found from LZMA Utils 4.32.x. +In most cases, it is possible to replace +LZMA Utils with XZ Utils without breaking existing scripts. +There are some incompatibilities though, +which may sometimes cause problems. +. +.SS "Compression preset levels" +The numbering of the compression level presets is not identical in +.B xz +and LZMA Utils. +The most important difference is how dictionary sizes +are mapped to different presets. +Dictionary size is roughly equal to the decompressor memory usage. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Level;xz;LZMA Utils +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +The dictionary size differences affect +the compressor memory usage too, +but there are some other differences between +LZMA Utils and XZ Utils, which +make the difference even bigger: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Level;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +The default preset level in LZMA Utils is +.B \-7 +while in XZ Utils it is +.BR \-6 , +so both use an 8 MiB dictionary by default. +. +.SS "Streamed vs. non-streamed .lzma files" +The uncompressed size of the file can be stored in the +.B .lzma +header. +LZMA Utils does that when compressing regular files. +The alternative is to mark that uncompressed size is unknown +and use end-of-payload marker to indicate +where the decompressor should stop. +LZMA Utils uses this method when uncompressed size isn't known, +which is the case, for example, in pipes. +.PP +.B xz +supports decompressing +.B .lzma +files with or without end-of-payload marker, but all +.B .lzma +files created by +.B xz +will use end-of-payload marker and have uncompressed size +marked as unknown in the +.B .lzma +header. +This may be a problem in some uncommon situations. +For example, a +.B .lzma +decompressor in an embedded device might work +only with files that have known uncompressed size. +If you hit this problem, you need to use LZMA Utils +or LZMA SDK to create +.B .lzma +files with known uncompressed size. +. +.SS "Unsupported .lzma files" +The +.B .lzma +format allows +.I lc +values up to 8, and +.I lp +values up to 4. +LZMA Utils can decompress files with any +.I lc +and +.IR lp , +but always creates files with +.B lc=3 +and +.BR lp=0 . +Creating files with other +.I lc +and +.I lp +is possible with +.B xz +and with LZMA SDK. +.PP +The implementation of the LZMA1 filter in liblzma +requires that the sum of +.I lc +and +.I lp +must not exceed 4. +Thus, +.B .lzma +files, which exceed this limitation, cannot be decompressed with +.BR xz . +.PP +LZMA Utils creates only +.B .lzma +files which have a dictionary size of +.RI "2^" n +(a power of 2) but accepts files with any dictionary size. +liblzma accepts only +.B .lzma +files which have a dictionary size of +.RI "2^" n +or +.RI "2^" n " + 2^(" n "\-1)." +This is to decrease false positives when detecting +.B .lzma +files. +.PP +These limitations shouldn't be a problem in practice, +since practically all +.B .lzma +files have been compressed with settings that liblzma will accept. +. +.SS "Trailing garbage" +When decompressing, +LZMA Utils silently ignore everything after the first +.B .lzma +stream. +In most situations, this is a bug. +This also means that LZMA Utils +don't support decompressing concatenated +.B .lzma +files. +.PP +If there is data left after the first +.B .lzma +stream, +.B xz +considers the file to be corrupt unless +.B \-\-single\-stream +was used. +This may break obscure scripts which have +assumed that trailing garbage is ignored. +. +.SH NOTES +. +.SS "Compressed output may vary" +The exact compressed output produced from +the same uncompressed input file +may vary between XZ Utils versions even if +compression options are identical. +This is because the encoder can be improved +(faster or better compression) +without affecting the file format. +The output can vary even between different +builds of the same XZ Utils version, +if different build options are used. +.PP +The above means that once +.B \-\-rsyncable +has been implemented, +the resulting files won't necessarily be rsyncable +unless both old and new files have been compressed +with the same xz version. +This problem can be fixed if a part of the encoder +implementation is frozen to keep rsyncable output +stable across xz versions. +. +.SS "Embedded .xz decompressors" +Embedded +.B .xz +decompressor implementations like XZ Embedded don't necessarily +support files created with integrity +.I check +types other than +.B none +and +.BR crc32 . +Since the default is +.BR \-\-check=crc64 , +you must use +.B \-\-check=none +or +.B \-\-check=crc32 +when creating files for embedded systems. +.PP +Outside embedded systems, all +.B .xz +format decompressors support all the +.I check +types, or at least are able to decompress +the file without verifying the +integrity check if the particular +.I check +is not supported. +.PP +XZ Embedded supports BCJ filters, +but only with the default start offset. +. +.SH EXAMPLES +. +.SS Basics +Compress the file +.I foo +into +.I foo.xz +using the default compression level +.RB ( \-6 ), +and remove +.I foo +if compression is successful: +.RS +.PP +.nf +.ft CR +xz foo +.ft R +.fi +.RE +.PP +Decompress +.I bar.xz +into +.I bar +and don't remove +.I bar.xz +even if decompression is successful: +.RS +.PP +.nf +.ft CR +xz \-dk bar.xz +.ft R +.fi +.RE +.PP +Create +.I baz.tar.xz +with the preset +.B \-4e +.RB ( "\-4 \-\-extreme" ), +which is slower than the default +.BR \-6 , +but needs less memory for compression and decompression (48\ MiB +and 5\ MiB, respectively): +.RS +.PP +.nf +.ft CR +tar cf \- baz | xz \-4e > baz.tar.xz +.ft R +.fi +.RE +.PP +A mix of compressed and uncompressed files can be decompressed +to standard output with a single command: +.RS +.PP +.nf +.ft CR +xz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt +.ft R +.fi +.RE +. +.SS "Parallel compression of many files" +On GNU and *BSD, +.BR find (1) +and +.BR xargs (1) +can be used to parallelize compression of many files: +.RS +.PP +.nf +.ft CR +find . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1 +.ft R +.fi +.RE +.PP +The +.B \-P +option to +.BR xargs (1) +sets the number of parallel +.B xz +processes. +The best value for the +.B \-n +option depends on how many files there are to be compressed. +If there are only a couple of files, +the value should probably be 1; +with tens of thousands of files, +100 or even more may be appropriate to reduce the number of +.B xz +processes that +.BR xargs (1) +will eventually create. +.PP +The option +.B \-T1 +for +.B xz +is there to force it to single-threaded mode, because +.BR xargs (1) +is used to control the amount of parallelization. +. +.SS "Robot mode" +Calculate how many bytes have been saved in total +after compressing multiple files: +.RS +.PP +.nf +.ft CR +xz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}' +.ft R +.fi +.RE +.PP +A script may want to know that it is using new enough +.BR xz . +The following +.BR sh (1) +script checks that the version number of the +.B xz +tool is at least 5.0.0. +This method is compatible with old beta versions, +which didn't support the +.B \-\-robot +option: +.RS +.PP +.nf +.ft CR +if ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION +.ft R +.fi +.RE +.PP +Set a memory usage limit for decompression using +.BR XZ_OPT , +but if a limit has already been set, don't increase it: +.RS +.PP +.nf +.ft CR +NEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi +.ft R +.fi +.RE +. +.SS "Custom compressor filter chains" +The simplest use for custom filter chains is +customizing a LZMA2 preset. +This can be useful, +because the presets cover only a subset of the +potentially useful combinations of compression settings. +.PP +The CompCPU columns of the tables +from the descriptions of the options +.BR "\-0" " ... " "\-9" +and +.B \-\-extreme +are useful when customizing LZMA2 presets. +Here are the relevant parts collected from those two tables: +.RS +.PP +.TS +tab(;); +c c +n n. +Preset;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +If you know that a file requires +somewhat big dictionary (for example, 32\ MiB) to compress well, +but you want to compress it quicker than +.B "xz \-8" +would do, a preset with a low CompCPU value (for example, 1) +can be modified to use a bigger dictionary: +.RS +.PP +.nf +.ft CR +xz \-\-lzma2=preset=1,dict=32MiB foo.tar +.ft R +.fi +.RE +.PP +With certain files, the above command may be faster than +.B "xz \-6" +while compressing significantly better. +However, it must be emphasized that only some files benefit from +a big dictionary while keeping the CompCPU value low. +The most obvious situation, +where a big dictionary can help a lot, +is an archive containing very similar files +of at least a few megabytes each. +The dictionary size has to be significantly bigger +than any individual file to allow LZMA2 to take +full advantage of the similarities between consecutive files. +.PP +If very high compressor and decompressor memory usage is fine, +and the file being compressed is +at least several hundred megabytes, it may be useful +to use an even bigger dictionary than the 64 MiB that +.B "xz \-9" +would use: +.RS +.PP +.nf +.ft CR +xz \-vv \-\-lzma2=dict=192MiB big_foo.tar +.ft R +.fi +.RE +.PP +Using +.B \-vv +.RB ( "\-\-verbose \-\-verbose" ) +like in the above example can be useful +to see the memory requirements +of the compressor and decompressor. +Remember that using a dictionary bigger than +the size of the uncompressed file is waste of memory, +so the above command isn't useful for small files. +.PP +Sometimes the compression time doesn't matter, +but the decompressor memory usage has to be kept low, for example, +to make it possible to decompress the file on an embedded system. +The following command uses +.B \-6e +.RB ( "\-6 \-\-extreme" ) +as a base and sets the dictionary to only 64\ KiB. +The resulting file can be decompressed with XZ Embedded +(that's why there is +.BR \-\-check=crc32 ) +using about 100\ KiB of memory. +.RS +.PP +.nf +.ft CR +xz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo +.ft R +.fi +.RE +.PP +If you want to squeeze out as many bytes as possible, +adjusting the number of literal context bits +.RI ( lc ) +and number of position bits +.RI ( pb ) +can sometimes help. +Adjusting the number of literal position bits +.RI ( lp ) +might help too, but usually +.I lc +and +.I pb +are more important. +For example, a source code archive contains mostly US-ASCII text, +so something like the following might give +slightly (like 0.1\ %) smaller file than +.B "xz \-6e" +(try also without +.BR lc=4 ): +.RS +.PP +.nf +.ft CR +xz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar +.ft R +.fi +.RE +.PP +Using another filter together with LZMA2 can improve +compression with certain file types. +For example, to compress a x86-32 or x86-64 shared library +using the x86 BCJ filter: +.RS +.PP +.nf +.ft CR +xz \-\-x86 \-\-lzma2 libfoo.so +.ft R +.fi +.RE +.PP +Note that the order of the filter options is significant. +If +.B \-\-x86 +is specified after +.BR \-\-lzma2 , +.B xz +will give an error, +because there cannot be any filter after LZMA2, +and also because the x86 BCJ filter cannot be used +as the last filter in the chain. +.PP +The Delta filter together with LZMA2 +can give good results with bitmap images. +It should usually beat PNG, +which has a few more advanced filters than simple +delta but uses Deflate for the actual compression. +.PP +The image has to be saved in uncompressed format, +for example, as uncompressed TIFF. +The distance parameter of the Delta filter is set +to match the number of bytes per pixel in the image. +For example, 24-bit RGB bitmap needs +.BR dist=3 , +and it is also good to pass +.B pb=0 +to LZMA2 to accommodate the three-byte alignment: +.RS +.PP +.nf +.ft CR +xz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff +.ft R +.fi +.RE +.PP +If multiple images have been put into a single archive (for example, +.BR .tar ), +the Delta filter will work on that too as long as all images +have the same number of bytes per pixel. +. +.SH "SEE ALSO" +.BR xzdec (1), +.BR xzdiff (1), +.BR xzgrep (1), +.BR xzless (1), +.BR xzmore (1), +.BR gzip (1), +.BR bzip2 (1), +.BR 7z (1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzmadec.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzmadec.1 new file mode 100644 index 0000000000000000000000000000000000000000..5198efb4612e2b87a6be58623390538e7d52abce --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzmadec.1 @@ -0,0 +1,144 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.TH XZDEC 1 "2024-04-08" "Tukaani" "XZ Utils" +.SH NAME +xzdec, lzmadec \- Small .xz and .lzma decompressors +.SH SYNOPSIS +.B xzdec +.RI [ option... ] +.RI [ file... ] +.br +.B lzmadec +.RI [ option... ] +.RI [ file... ] +.SH DESCRIPTION +.B xzdec +is a liblzma-based decompression-only tool for +.B .xz +(and only +.BR .xz ) +files. +.B xzdec +is intended to work as a drop-in replacement for +.BR xz (1) +in the most common situations where a script +has been written to use +.B "xz \-\-decompress \-\-stdout" +(and possibly a few other commonly used options) to decompress +.B .xz +files. +.B lzmadec +is identical to +.B xzdec +except that +.B lzmadec +supports +.B .lzma +files instead of +.B .xz +files. +.PP +To reduce the size of the executable, +.B xzdec +doesn't support multithreading or localization, +and doesn't read options from +.B XZ_DEFAULTS +and +.B XZ_OPT +environment variables. +.B xzdec +doesn't support displaying intermediate progress information: sending +.B SIGINFO +to +.B xzdec +does nothing, but sending +.B SIGUSR1 +terminates the process instead of displaying progress information. +.SH OPTIONS +.TP +.BR \-d ", " \-\-decompress ", " \-\-uncompress +Ignored for +.BR xz (1) +compatibility. +.B xzdec +supports only decompression. +.TP +.BR \-k ", " \-\-keep +Ignored for +.BR xz (1) +compatibility. +.B xzdec +never creates or removes any files. +.TP +.BR \-c ", " \-\-stdout ", " \-\-to-stdout +Ignored for +.BR xz (1) +compatibility. +.B xzdec +always writes the decompressed data to standard output. +.TP +.BR \-q ", " \-\-quiet +Specifying this once does nothing since +.B xzdec +never displays any warnings or notices. +Specify this twice to suppress errors. +.TP +.BR \-Q ", " \-\-no-warn +Ignored for +.BR xz (1) +compatibility. +.B xzdec +never uses the exit status 2. +.TP +.BR \-h ", " \-\-help +Display a help message and exit successfully. +.TP +.BR \-V ", " \-\-version +Display the version number of +.B xzdec +and liblzma. +.SH "EXIT STATUS" +.TP +.B 0 +All was good. +.TP +.B 1 +An error occurred. +.PP +.B xzdec +doesn't have any warning messages like +.BR xz (1) +has, thus the exit status 2 is not used by +.BR xzdec . +.SH NOTES +Use +.BR xz (1) +instead of +.B xzdec +or +.B lzmadec +for normal everyday use. +.B xzdec +or +.B lzmadec +are meant only for situations where it is important to have +a smaller decompressor than the full-featured +.BR xz (1). +.PP +.B xzdec +and +.B lzmadec +are not really that small. +The size can be reduced further by dropping +features from liblzma at compile time, +but that shouldn't usually be done for executables distributed +in typical non-embedded operating system distributions. +If you need a truly small +.B .xz +decompressor, consider using XZ Embedded. +.SH "SEE ALSO" +.BR xz (1) +.PP +XZ Embedded: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzmainfo.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzmainfo.1 new file mode 100644 index 0000000000000000000000000000000000000000..114e0f30ca6ecc1debd116ebcb7dee303d2a8d3b --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzmainfo.1 @@ -0,0 +1,58 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.TH LZMAINFO 1 "2013-06-30" "Tukaani" "XZ Utils" +.SH NAME +lzmainfo \- show information stored in the .lzma file header +.SH SYNOPSIS +.B lzmainfo +.RB [ \-\-help ] +.RB [ \-\-version ] +.RI [ file... ] +.SH DESCRIPTION +.B lzmainfo +shows information stored in the +.B .lzma +file header. +It reads the first 13 bytes from the specified +.IR file , +decodes the header, and prints it to standard output in human +readable format. +If no +.I files +are given or +.I file +is +.BR \- , +standard input is read. +.PP +Usually the most interesting information is +the uncompressed size and the dictionary size. +Uncompressed size can be shown only if +the file is in the non-streamed +.B .lzma +format variant. +The amount of memory required to decompress the file is +a few dozen kilobytes plus the dictionary size. +.PP +.B lzmainfo +is included in XZ Utils primarily for +backward compatibility with LZMA Utils. +.SH "EXIT STATUS" +.TP +.B 0 +All is good. +.TP +.B 1 +An error occurred. +.SH BUGS +.B lzmainfo +uses +.B MB +while the correct suffix would be +.B MiB +(2^20 bytes). +This is to keep the output compatible with LZMA Utils. +.SH "SEE ALSO" +.BR xz (1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzmore.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzmore.1 new file mode 100644 index 0000000000000000000000000000000000000000..8a0e21c9e166417ebd6ec8e6e64568236c52f79f --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/lzmore.1 @@ -0,0 +1,69 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" (Note that this file is based on xzless.1 instead of gzip's zmore.1.) +.\" +.TH XZMORE 1 "2025-03-06" "Tukaani" "XZ Utils" +.SH NAME +xzmore, lzmore \- view xz or lzma compressed (text) files +. +.SH SYNOPSIS +.B xzmore +.RI [ file ...] +.br +.B lzmore +.RI [ file ...] +(DEPRECATED) +. +.SH DESCRIPTION +.B xzmore +displays text from compressed files to a terminal using +.BR more (1). +Files supported by +.BR xz (1) +are decompressed; +other files are assumed to be in uncompressed form already. +If no +.I files +are given, +.B xzmore +reads from standard input. +See the +.BR more (1) +manual for the keyboard commands. +.PP +Note that scrolling backwards might not be possible +depending on the implementation of +.BR more (1). +This is because +.B xzmore +uses a pipe to pass the decompressed data to +.BR more (1). +.BR xzless (1) +uses +.BR less (1) +which provides more advanced features. +.PP +The command +.B lzmore +is provided for backward compatibility with LZMA Utils. +It is deprecated and will be removed in a future version. +. +.SH ENVIRONMENT +.TP +.\" TRANSLATORS: Don't translate the uppercase PAGER. +.\" It is a name of an environment variable. +.B PAGER +If +.B PAGER +is set, +its value is used as the pager instead of +.BR more (1). +. +.SH "SEE ALSO" +.BR more (1), +.BR xz (1), +.BR xzless (1), +.BR zmore (1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/unlzma.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/unlzma.1 new file mode 100644 index 0000000000000000000000000000000000000000..6e37b426a3b5c85552cf006f388c9a71d4ad5685 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/unlzma.1 @@ -0,0 +1,3264 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.TH XZ 1 "2025-03-08" "Tukaani" "XZ Utils" +. +.SH NAME +xz, unxz, xzcat, lzma, unlzma, lzcat \- Compress or decompress .xz and .lzma files +. +.SH SYNOPSIS +.B xz +.RI [ option... ] +.RI [ file... ] +. +.SH COMMAND ALIASES +.B unxz +is equivalent to +.BR "xz \-\-decompress" . +.br +.B xzcat +is equivalent to +.BR "xz \-\-decompress \-\-stdout" . +.br +.B lzma +is equivalent to +.BR "xz \-\-format=lzma" . +.br +.B unlzma +is equivalent to +.BR "xz \-\-format=lzma \-\-decompress" . +.br +.B lzcat +is equivalent to +.BR "xz \-\-format=lzma \-\-decompress \-\-stdout" . +.PP +When writing scripts that need to decompress files, +it is recommended to always use the name +.B xz +with appropriate arguments +.RB ( "xz \-d" +or +.BR "xz \-dc" ) +instead of the names +.B unxz +and +.BR xzcat . +. +.SH DESCRIPTION +.B xz +is a general-purpose data compression tool with +command line syntax similar to +.BR gzip (1) +and +.BR bzip2 (1). +The native file format is the +.B .xz +format, but the legacy +.B .lzma +format used by LZMA Utils and +raw compressed streams with no container format headers +are also supported. +In addition, decompression of the +.B .lz +format used by +.B lzip +is supported. +.PP +.B xz +compresses or decompresses each +.I file +according to the selected operation mode. +If no +.I files +are given or +.I file +is +.BR \- , +.B xz +reads from standard input and writes the processed data +to standard output. +.B xz +will refuse (display an error and skip the +.IR file ) +to write compressed data to standard output if it is a terminal. +Similarly, +.B xz +will refuse to read compressed data +from standard input if it is a terminal. +.PP +Unless +.B \-\-stdout +is specified, +.I files +other than +.B \- +are written to a new file whose name is derived from the source +.I file +name: +.IP \(bu 3 +When compressing, the suffix of the target file format +.RB ( .xz +or +.BR .lzma ) +is appended to the source filename to get the target filename. +.IP \(bu 3 +When decompressing, the +.BR .xz , +.BR .lzma , +or +.B .lz +suffix is removed from the filename to get the target filename. +.B xz +also recognizes the suffixes +.B .txz +and +.BR .tlz , +and replaces them with the +.B .tar +suffix. +.PP +If the target file already exists, an error is displayed and the +.I file +is skipped. +.PP +Unless writing to standard output, +.B xz +will display a warning and skip the +.I file +if any of the following applies: +.IP \(bu 3 +.I File +is not a regular file. +Symbolic links are not followed, +and thus they are not considered to be regular files. +.IP \(bu 3 +.I File +has more than one hard link. +.IP \(bu 3 +.I File +has setuid, setgid, or sticky bit set. +.IP \(bu 3 +The operation mode is set to compress and the +.I file +already has a suffix of the target file format +.RB ( .xz +or +.B .txz +when compressing to the +.B .xz +format, and +.B .lzma +or +.B .tlz +when compressing to the +.B .lzma +format). +.IP \(bu 3 +The operation mode is set to decompress and the +.I file +doesn't have a suffix of any of the supported file formats +.RB ( .xz , +.BR .txz , +.BR .lzma , +.BR .tlz , +or +.BR .lz ). +.PP +After successfully compressing or decompressing the +.IR file , +.B xz +copies the owner, group, permissions, access time, +and modification time from the source +.I file +to the target file. +If copying the group fails, the permissions are modified +so that the target file doesn't become accessible to users +who didn't have permission to access the source +.IR file . +.B xz +doesn't support copying other metadata like access control lists +or extended attributes yet. +.PP +Once the target file has been successfully closed, the source +.I file +is removed unless +.B \-\-keep +was specified. +The source +.I file +is never removed if the output is written to standard output +or if an error occurs. +.PP +Sending +.B SIGINFO +or +.B SIGUSR1 +to the +.B xz +process makes it print progress information to standard error. +This has only limited use since when standard error +is a terminal, using +.B \-\-verbose +will display an automatically updating progress indicator. +. +.SS "Memory usage" +The memory usage of +.B xz +varies from a few hundred kilobytes to several gigabytes +depending on the compression settings. +The settings used when compressing a file determine +the memory requirements of the decompressor. +Typically the decompressor needs 5\ % to 20\ % of +the amount of memory that the compressor needed when +creating the file. +For example, decompressing a file created with +.B xz \-9 +currently requires 65\ MiB of memory. +Still, it is possible to have +.B .xz +files that require several gigabytes of memory to decompress. +.PP +Especially users of older systems may find +the possibility of very large memory usage annoying. +To prevent uncomfortable surprises, +.B xz +has a built-in memory usage limiter, which is disabled by default. +While some operating systems provide ways to limit +the memory usage of processes, relying on it +wasn't deemed to be flexible enough (for example, using +.BR ulimit (1) +to limit virtual memory tends to cripple +.BR mmap (2)). +.PP +The memory usage limiter can be enabled with +the command line option \fB\-\-memlimit=\fIlimit\fR. +Often it is more convenient to enable the limiter +by default by setting the environment variable +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +.BR XZ_DEFAULTS , +for example, +.BR XZ_DEFAULTS=\-\-memlimit=150MiB . +It is possible to set the limits separately +for compression and decompression by using +.BI \-\-memlimit\-compress= limit +and \fB\-\-memlimit\-decompress=\fIlimit\fR. +Using these two options outside +.B XZ_DEFAULTS +is rarely useful because a single run of +.B xz +cannot do both compression and decompression and +.BI \-\-memlimit= limit +(or +.B \-M +.IR limit ) +is shorter to type on the command line. +.PP +If the specified memory usage limit is exceeded when decompressing, +.B xz +will display an error and decompressing the file will fail. +If the limit is exceeded when compressing, +.B xz +will try to scale the settings down so that the limit +is no longer exceeded (except when using +.B \-\-format=raw +or +.BR \-\-no\-adjust ). +This way the operation won't fail unless the limit is very small. +The scaling of the settings is done in steps that don't +match the compression level presets, for example, if the limit is +only slightly less than the amount required for +.BR "xz \-9" , +the settings will be scaled down only a little, +not all the way down to +.BR "xz \-8" . +. +.SS "Concatenation and padding with .xz files" +It is possible to concatenate +.B .xz +files as is. +.B xz +will decompress such files as if they were a single +.B .xz +file. +.PP +It is possible to insert padding between the concatenated parts +or after the last part. +The padding must consist of null bytes and the size +of the padding must be a multiple of four bytes. +This can be useful, for example, if the +.B .xz +file is stored on a medium that measures file sizes +in 512-byte blocks. +.PP +Concatenation and padding are not allowed with +.B .lzma +files or raw streams. +. +.SH OPTIONS +. +.SS "Integer suffixes and special values" +In most places where an integer argument is expected, +an optional suffix is supported to easily indicate large integers. +There must be no space between the integer and the suffix. +.TP +.B KiB +Multiply the integer by 1,024 (2^10). +.BR Ki , +.BR k , +.BR kB , +.BR K , +and +.B KB +are accepted as synonyms for +.BR KiB . +.TP +.B MiB +Multiply the integer by 1,048,576 (2^20). +.BR Mi , +.BR m , +.BR M , +and +.B MB +are accepted as synonyms for +.BR MiB . +.TP +.B GiB +Multiply the integer by 1,073,741,824 (2^30). +.BR Gi , +.BR g , +.BR G , +and +.B GB +are accepted as synonyms for +.BR GiB . +.PP +The special value +.B max +can be used to indicate the maximum integer value +supported by the option. +. +.SS "Operation mode" +If multiple operation mode options are given, +the last one takes effect. +.TP +.BR \-z ", " \-\-compress +Compress. +This is the default operation mode when no operation mode option +is specified and no other operation mode is implied from +the command name (for example, +.B unxz +implies +.BR \-\-decompress ). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +After successful compression, the source file is removed +unless writing to standard output or +.B \-\-keep +was specified. +.TP +.BR \-d ", " \-\-decompress ", " \-\-uncompress +Decompress. +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +After successful decompression, the source file is removed +unless writing to standard output or +.B \-\-keep +was specified. +.TP +.BR \-t ", " \-\-test +Test the integrity of compressed +.IR files . +This option is equivalent to +.B "\-\-decompress \-\-stdout" +except that the decompressed data is discarded instead of being +written to standard output. +No files are created or removed. +.TP +.BR \-l ", " \-\-list +Print information about compressed +.IR files . +No uncompressed output is produced, +and no files are created or removed. +In list mode, the program cannot read +the compressed data from standard +input or from other unseekable sources. +.IP "" +The default listing shows basic information about +.IR files , +one file per line. +To get more detailed information, use also the +.B \-\-verbose +option. +For even more information, use +.B \-\-verbose +twice, but note that this may be slow, because getting all the extra +information requires many seeks. +The width of verbose output exceeds +80 characters, so piping the output to, for example, +.B "less\ \-S" +may be convenient if the terminal isn't wide enough. +.IP "" +The exact output may vary between +.B xz +versions and different locales. +For machine-readable output, +.B \-\-robot \-\-list +should be used. +. +.SS "Operation modifiers" +.TP +.BR \-k ", " \-\-keep +Don't delete the input files. +.IP "" +Since +.B xz +5.2.6, +this option also makes +.B xz +compress or decompress even if the input is +a symbolic link to a regular file, +has more than one hard link, +or has the setuid, setgid, or sticky bit set. +The setuid, setgid, and sticky bits are not copied +to the target file. +In earlier versions this was only done with +.BR \-\-force . +.TP +.BR \-f ", " \-\-force +This option has several effects: +.RS +.IP \(bu 3 +If the target file already exists, +delete it before compressing or decompressing. +.IP \(bu 3 +Compress or decompress even if the input is +a symbolic link to a regular file, +has more than one hard link, +or has the setuid, setgid, or sticky bit set. +The setuid, setgid, and sticky bits are not copied +to the target file. +.IP \(bu 3 +When used with +.B \-\-decompress +.B \-\-stdout +and +.B xz +cannot recognize the type of the source file, +copy the source file as is to standard output. +This allows +.B xzcat +.B \-\-force +to be used like +.BR cat (1) +for files that have not been compressed with +.BR xz . +Note that in future, +.B xz +might support new compressed file formats, which may make +.B xz +decompress more types of files instead of copying them as is to +standard output. +.BI \-\-format= format +can be used to restrict +.B xz +to decompress only a single file format. +.RE +.TP +.BR \-c ", " \-\-stdout ", " \-\-to\-stdout +Write the compressed or decompressed data to +standard output instead of a file. +This implies +.BR \-\-keep . +.TP +.B \-\-single\-stream +Decompress only the first +.B .xz +stream, and +silently ignore possible remaining input data following the stream. +Normally such trailing garbage makes +.B xz +display an error. +.IP "" +.B xz +never decompresses more than one stream from +.B .lzma +files or raw streams, but this option still makes +.B xz +ignore the possible trailing data after the +.B .lzma +file or raw stream. +.IP "" +This option has no effect if the operation mode is not +.B \-\-decompress +or +.BR \-\-test . +.IP "" +Since +.B xz +5.7.1alpha, +.B \-\-single\-stream +implies +.BR \-\-keep . +.TP +.B \-\-no\-sparse +Disable creation of sparse files. +By default, if decompressing into a regular file, +.B xz +tries to make the file sparse if the decompressed data contains +long sequences of binary zeros. +It also works when writing to standard output +as long as standard output is connected to a regular file +and certain additional conditions are met to make it safe. +Creating sparse files may save disk space and speed up +the decompression by reducing the amount of disk I/O. +.TP +\fB\-S\fR \fI.suf\fR, \fB\-\-suffix=\fI.suf +When compressing, use +.I .suf +as the suffix for the target file instead of +.B .xz +or +.BR .lzma . +If not writing to standard output and +the source file already has the suffix +.IR .suf , +a warning is displayed and the file is skipped. +.IP "" +When decompressing, recognize files with the suffix +.I .suf +in addition to files with the +.BR .xz , +.BR .txz , +.BR .lzma , +.BR .tlz , +or +.B .lz +suffix. +If the source file has the suffix +.IR .suf , +the suffix is removed to get the target filename. +.IP "" +When compressing or decompressing raw streams +.RB ( \-\-format=raw ), +the suffix must always be specified unless +writing to standard output, +because there is no default suffix for raw streams. +.TP +\fB\-\-files\fR[\fB=\fIfile\fR] +Read the filenames to process from +.IR file ; +if +.I file +is omitted, filenames are read from standard input. +Filenames must be terminated with the newline character. +A dash +.RB ( \- ) +is taken as a regular filename; it doesn't mean standard input. +If filenames are given also as command line arguments, they are +processed before the filenames read from +.IR file . +.TP +\fB\-\-files0\fR[\fB=\fIfile\fR] +This is identical to \fB\-\-files\fR[\fB=\fIfile\fR] except +that each filename must be terminated with the null character. +. +.SS "Basic file format and compression options" +.TP +\fB\-F\fR \fIformat\fR, \fB\-\-format=\fIformat +Specify the file +.I format +to compress or decompress: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +.B auto +This is the default. +When compressing, +.B auto +is equivalent to +.BR xz . +When decompressing, +the format of the input file is automatically detected. +Note that raw streams (created with +.BR \-\-format=raw ) +cannot be auto-detected. +.TP +.B xz +Compress to the +.B .xz +file format, or accept only +.B .xz +files when decompressing. +.TP +.BR lzma ", " alone +Compress to the legacy +.B .lzma +file format, or accept only +.B .lzma +files when decompressing. +The alternative name +.B alone +is provided for backwards compatibility with LZMA Utils. +.TP +.B lzip +Accept only +.B .lz +files when decompressing. +Compression is not supported. +.IP "" +The +.B .lz +format versions 0 and 1 are supported. +Version 0 files were produced by +.B lzip +1.3 and older. +Such files aren't common but may be found from file archives +as a few source packages were released in this format. +People might have old personal files in this format too. +Decompression support for the format version 0 was removed in +.B lzip +1.18. +.B lzip +1.4 and later create files in the format version 1. +.TP +.B raw +Compress or uncompress a raw stream (no headers). +This is meant for advanced users only. +To decode raw streams, you need use +.B \-\-format=raw +and explicitly specify the filter chain, +which normally would have been stored in the container headers. +.RE +.TP +\fB\-C\fR \fIcheck\fR, \fB\-\-check=\fIcheck +Specify the type of the integrity check. +The check is calculated from the uncompressed data and +stored in the +.B .xz +file. +This option has an effect only when compressing into the +.B .xz +format; the +.B .lzma +format doesn't support integrity checks. +The integrity check (if any) is verified when the +.B .xz +file is decompressed. +.IP "" +Supported +.I check +types: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +.B none +Don't calculate an integrity check at all. +This is usually a bad idea. +This can be useful when integrity of the data is verified +by other means anyway. +.TP +.B crc32 +Calculate CRC32 using the polynomial from IEEE-802.3 (Ethernet). +.TP +.B crc64 +Calculate CRC64 using the polynomial from ECMA-182. +This is the default, since it is slightly better than CRC32 +at detecting damaged files and the speed difference is negligible. +.TP +.B sha256 +Calculate SHA-256. +This is somewhat slower than CRC32 and CRC64. +.RE +.IP "" +Integrity of the +.B .xz +headers is always verified with CRC32. +It is not possible to change or disable it. +.TP +.B \-\-ignore\-check +Don't verify the integrity check of the compressed data when decompressing. +The CRC32 values in the +.B .xz +headers will still be verified normally. +.IP "" +.B "Do not use this option unless you know what you are doing." +Possible reasons to use this option: +.RS +.IP \(bu 3 +Trying to recover data from a corrupt .xz file. +.IP \(bu 3 +Speeding up decompression. +This matters mostly with SHA-256 or +with files that have compressed extremely well. +It's recommended to not use this option for this purpose +unless the file integrity is verified externally in some other way. +.RE +.TP +.BR \-0 " ... " \-9 +Select a compression preset level. +The default is +.BR \-6 . +If multiple preset levels are specified, +the last one takes effect. +If a custom filter chain was already specified, setting +a compression preset level clears the custom filter chain. +.IP "" +The differences between the presets are more significant than with +.BR gzip (1) +and +.BR bzip2 (1). +The selected compression settings determine +the memory requirements of the decompressor, +thus using a too high preset level might make it painful +to decompress the file on an old system with little RAM. +Specifically, +.B "it's not a good idea to blindly use \-9 for everything" +like it often is with +.BR gzip (1) +and +.BR bzip2 (1). +.RS +.TP +.BR "\-0" " ... " "\-3" +These are somewhat fast presets. +.B \-0 +is sometimes faster than +.B "gzip \-9" +while compressing much better. +The higher ones often have speed comparable to +.BR bzip2 (1) +with comparable or better compression ratio, +although the results +depend a lot on the type of data being compressed. +.TP +.BR "\-4" " ... " "\-6" +Good to very good compression while keeping +decompressor memory usage reasonable even for old systems. +.B \-6 +is the default, which is usually a good choice +for distributing files that need to be decompressible +even on systems with only 16\ MiB RAM. +.RB ( \-5e +or +.B \-6e +may be worth considering too. +See +.BR \-\-extreme .) +.TP +.B "\-7 ... \-9" +These are like +.B \-6 +but with higher compressor and decompressor memory requirements. +These are useful only when compressing files bigger than +8\ MiB, 16\ MiB, and 32\ MiB, respectively. +.RE +.IP "" +On the same hardware, the decompression speed is approximately +a constant number of bytes of compressed data per second. +In other words, the better the compression, +the faster the decompression will usually be. +This also means that the amount of uncompressed output +produced per second can vary a lot. +.IP "" +The following table summarises the features of the presets: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Preset;DictSize;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Column descriptions: +.RS +.IP \(bu 3 +DictSize is the LZMA2 dictionary size. +It is waste of memory to use a dictionary bigger than +the size of the uncompressed file. +This is why it is good to avoid using the presets +.BR \-7 " ... " \-9 +when there's no real need for them. +At +.B \-6 +and lower, the amount of memory wasted is +usually low enough to not matter. +.IP \(bu 3 +CompCPU is a simplified representation of the LZMA2 settings +that affect compression speed. +The dictionary size affects speed too, +so while CompCPU is the same for levels +.BR \-6 " ... " \-9 , +higher levels still tend to be a little slower. +To get even slower and thus possibly better compression, see +.BR \-\-extreme . +.IP \(bu 3 +CompMem contains the compressor memory requirements +in the single-threaded mode. +It may vary slightly between +.B xz +versions. +.IP \(bu 3 +DecMem contains the decompressor memory requirements. +That is, the compression settings determine +the memory requirements of the decompressor. +The exact decompressor memory usage is slightly more than +the LZMA2 dictionary size, but the values in the table +have been rounded up to the next full MiB. +.RE +.IP "" +Memory requirements of the multi-threaded mode are +significantly higher than that of the single-threaded mode. +With the default value of +.BR \-\-block\-size , +each thread needs 3*3*DictSize plus CompMem or DecMem. +For example, four threads with preset +.B \-6 +needs 660\(en670\ MiB of memory. +.TP +.BR \-e ", " \-\-extreme +Use a slower variant of the selected compression preset level +.RB ( \-0 " ... " \-9 ) +to hopefully get a little bit better compression ratio, +but with bad luck this can also make it worse. +Decompressor memory usage is not affected, +but compressor memory usage increases a little at preset levels +.BR \-0 " ... " \-3 . +.IP "" +Since there are two presets with dictionary sizes +4\ MiB and 8\ MiB, the presets +.B \-3e +and +.B \-5e +use slightly faster settings (lower CompCPU) than +.B \-4e +and +.BR \-6e , +respectively. +That way no two presets are identical. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Preset;DictSize;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +For example, there are a total of four presets that use +8\ MiB dictionary, whose order from the fastest to the slowest is +.BR \-5 , +.BR \-6 , +.BR \-5e , +and +.BR \-6e . +.TP +.B \-\-fast +.PD 0 +.TP +.B \-\-best +.PD +These are somewhat misleading aliases for +.B \-0 +and +.BR \-9 , +respectively. +These are provided only for backwards compatibility +with LZMA Utils. +Avoid using these options. +.TP +.BI \-\-block\-size= size +When compressing to the +.B .xz +format, split the input data into blocks of +.I size +bytes. +The blocks are compressed independently from each other, +which helps with multi-threading and +makes limited random-access decompression possible. +This option is typically used to override the default +block size in multi-threaded mode, +but this option can be used in single-threaded mode too. +.IP "" +In multi-threaded mode about three times +.I size +bytes will be allocated in each thread for buffering input and output. +The default +.I size +is three times the LZMA2 dictionary size or 1 MiB, +whichever is more. +Typically a good value is 2\(en4 times +the size of the LZMA2 dictionary or at least 1 MiB. +Using +.I size +less than the LZMA2 dictionary size is waste of RAM +because then the LZMA2 dictionary buffer will never get fully used. +In multi-threaded mode, +the sizes of the blocks are stored in the block headers. +This size information is required for multi-threaded decompression. +.IP "" +In single-threaded mode no block splitting is done by default. +Setting this option doesn't affect memory usage. +No size information is stored in block headers, +thus files created in single-threaded mode +won't be identical to files created in multi-threaded mode. +The lack of size information also means that +.B xz +won't be able decompress the files in multi-threaded mode. +.TP +.BI \-\-block\-list= items +When compressing to the +.B .xz +format, start a new block with an optional custom filter chain after +the given intervals of uncompressed data. +.IP "" +The +.I items +are a comma-separated list. +Each item consists of an optional filter chain number +between 0 and 9 followed by a colon +.RB ( : ) +and a required size of uncompressed data. +Omitting an item (two or more consecutive commas) is a +shorthand to use the size and filters of the previous item. +.IP "" +If the input file is bigger than the sum of +the sizes in +.IR items , +the last item is repeated until the end of the file. +A special value of +.B 0 +may be used as the last size to indicate that +the rest of the file should be encoded as a single block. +.IP "" +An alternative filter chain for each block can be +specified in combination with the +.BI \-\-filters1= filters +\&...\& +.BI \-\-filters9= filters +options. +These options define filter chains with an identifier +between 1\(en9. +Filter chain 0 can be used to refer to the default filter chain, +which is the same as not specifying a filter chain. +The filter chain identifier can be used before the uncompressed +size, followed by a colon +.RB ( : ). +For example, if one specifies +.B \-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB +then blocks will be created using: +.RS +.IP \(bu 3 +The filter chain specified by +.B \-\-filters1 +and 2 MiB input +.IP \(bu 3 +The filter chain specified by +.B \-\-filters3 +and 2 MiB input +.IP \(bu 3 +The filter chain specified by +.B \-\-filters2 +and 4 MiB input +.IP \(bu 3 +The filter chain specified by +.B \-\-filters2 +and 4 MiB input +.IP \(bu 3 +The default filter chain and 2 MiB input +.IP \(bu 3 +The default filter chain and 4 MiB input for every block until +end of input. +.RE +.IP "" +If one specifies a size that exceeds the encoder's block size +(either the default value in threaded mode or +the value specified with \fB\-\-block\-size=\fIsize\fR), +the encoder will create additional blocks while +keeping the boundaries specified in +.IR items . +For example, if one specifies +.B \-\-block\-size=10MiB +.B \-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB +and the input file is 80 MiB, +one will get 11 blocks: +5, 10, 8, 10, 2, 10, 10, 4, 10, 10, and 1 MiB. +.IP "" +In multi-threaded mode the sizes of the blocks +are stored in the block headers. +This isn't done in single-threaded mode, +so the encoded output won't be +identical to that of the multi-threaded mode. +.TP +.BI \-\-flush\-timeout= timeout +When compressing, if more than +.I timeout +milliseconds (a positive integer) has passed since the previous flush and +reading more input would block, +all the pending input data is flushed from the encoder and +made available in the output stream. +This can be useful if +.B xz +is used to compress data that is streamed over a network. +Small +.I timeout +values make the data available at the receiving end +with a small delay, but large +.I timeout +values give better compression ratio. +.IP "" +This feature is disabled by default. +If this option is specified more than once, the last one takes effect. +The special +.I timeout +value of +.B 0 +can be used to explicitly disable this feature. +.IP "" +This feature is not available on non-POSIX systems. +.IP "" +.\" FIXME +.B "This feature is still experimental." +Currently +.B xz +is unsuitable for decompressing the stream in real time due to how +.B xz +does buffering. +.TP +.B \-\-no\-sync +Do not synchronize the target file and its directory +to the storage device before removing the source file. +This can improve performance if compressing or decompressing +many small files. +However, if the system crashes soon after the deletion, +it is possible that the target file was not written +to the storage device but the delete operation was. +In that case neither the original source file +nor the target file is available. +.IP "" +This option has an effect only when +.B xz +is going to remove the source file. +In other cases synchronization is never done. +.IP "" +The synchronization and +.B \-\-no\-sync +were added in +.B xz +5.7.1alpha. +.TP +.BI \-\-memlimit\-compress= limit +Set a memory usage limit for compression. +If this option is specified multiple times, +the last one takes effect. +.IP "" +If the compression settings exceed the +.IR limit , +.B xz +will attempt to adjust the settings downwards so that +the limit is no longer exceeded and display a notice that +automatic adjustment was done. +The adjustments are done in this order: +reducing the number of threads, +switching to single-threaded mode +if even one thread in multi-threaded mode exceeds the +.IR limit , +and finally reducing the LZMA2 dictionary size. +.IP "" +When compressing with +.B \-\-format=raw +or if +.B \-\-no\-adjust +has been specified, +only the number of threads may be reduced +since it can be done without affecting the compressed output. +.IP "" +If the +.I limit +cannot be met even with the adjustments described above, +an error is displayed and +.B xz +will exit with exit status 1. +.IP "" +The +.I limit +can be specified in multiple ways: +.RS +.IP \(bu 3 +The +.I limit +can be an absolute value in bytes. +Using an integer suffix like +.B MiB +can be useful. +Example: +.B "\-\-memlimit\-compress=80MiB" +.IP \(bu 3 +The +.I limit +can be specified as a percentage of total physical memory (RAM). +This can be useful especially when setting the +.B XZ_DEFAULTS +environment variable in a shell initialization script +that is shared between different computers. +That way the limit is automatically bigger +on systems with more memory. +Example: +.B "\-\-memlimit\-compress=70%" +.IP \(bu 3 +The +.I limit +can be reset back to its default value by setting it to +.BR 0 . +This is currently equivalent to setting the +.I limit +to +.B max +(no memory usage limit). +.RE +.IP "" +For 32-bit +.B xz +there is a special case: if the +.I limit +would be over +.BR "4020\ MiB" , +the +.I limit +is set to +.BR "4020\ MiB" . +On MIPS32 +.B "2000\ MiB" +is used instead. +(The values +.B 0 +and +.B max +aren't affected by this. +A similar feature doesn't exist for decompression.) +This can be helpful when a 32-bit executable has access +to 4\ GiB address space (2 GiB on MIPS32) +while hopefully doing no harm in other situations. +.IP "" +See also the section +.BR "Memory usage" . +.TP +.BI \-\-memlimit\-decompress= limit +Set a memory usage limit for decompression. +This also affects the +.B \-\-list +mode. +If the operation is not possible without exceeding the +.IR limit , +.B xz +will display an error and decompressing the file will fail. +See +.BI \-\-memlimit\-compress= limit +for possible ways to specify the +.IR limit . +.TP +.BI \-\-memlimit\-mt\-decompress= limit +Set a memory usage limit for multi-threaded decompression. +This can only affect the number of threads; +this will never make +.B xz +refuse to decompress a file. +If +.I limit +is too low to allow any multi-threading, the +.I limit +is ignored and +.B xz +will continue in single-threaded mode. +Note that if also +.B \-\-memlimit\-decompress +is used, +it will always apply to both single-threaded and multi-threaded modes, +and so the effective +.I limit +for multi-threading will never be higher than the limit set with +.BR \-\-memlimit\-decompress . +.IP "" +In contrast to the other memory usage limit options, +.BI \-\-memlimit\-mt\-decompress= limit +has a system-specific default +.IR limit . +.B "xz \-\-info\-memory" +can be used to see the current value. +.IP "" +This option and its default value exist +because without any limit the threaded decompressor +could end up allocating an insane amount of memory with some input files. +If the default +.I limit +is too low on your system, +feel free to increase the +.I limit +but never set it to a value larger than the amount of usable RAM +as with appropriate input files +.B xz +will attempt to use that amount of memory +even with a low number of threads. +Running out of memory or swapping +will not improve decompression performance. +.IP "" +See +.BI \-\-memlimit\-compress= limit +for possible ways to specify the +.IR limit . +Setting +.I limit +to +.B 0 +resets the +.I limit +to the default system-specific value. +.TP +\fB\-M\fR \fIlimit\fR, \fB\-\-memlimit=\fIlimit\fR, \fB\-\-memory=\fIlimit +This is equivalent to specifying +.BI \-\-memlimit\-compress= limit +.BI \-\-memlimit-decompress= limit +\fB\-\-memlimit\-mt\-decompress=\fIlimit\fR. +.TP +.B \-\-no\-adjust +Display an error and exit if the memory usage limit cannot be +met without adjusting settings that affect the compressed output. +That is, this prevents +.B xz +from switching the encoder from multi-threaded mode to single-threaded mode +and from reducing the LZMA2 dictionary size. +Even when this option is used the number of threads may be reduced +to meet the memory usage limit as that won't affect the compressed output. +.IP "" +Automatic adjusting is always disabled when creating raw streams +.RB ( \-\-format=raw ). +.TP +\fB\-T\fR \fIthreads\fR, \fB\-\-threads=\fIthreads +Specify the number of worker threads to use. +Setting +.I threads +to a special value +.B 0 +makes +.B xz +use up to as many threads as the processor(s) on the system support. +The actual number of threads can be fewer than +.I threads +if the input file is not big enough +for threading with the given settings or +if using more threads would exceed the memory usage limit. +.IP "" +The single-threaded and multi-threaded compressors produce different output. +Single-threaded compressor will give the smallest file size but +only the output from the multi-threaded compressor can be decompressed +using multiple threads. +Setting +.I threads +to +.B 1 +will use the single-threaded mode. +Setting +.I threads +to any other value, including +.BR 0 , +will use the multi-threaded compressor +even if the system supports only one hardware thread. +.RB ( xz +5.2.x +used single-threaded mode in this situation.) +.IP "" +To use multi-threaded mode with only one thread, set +.I threads +to +.BR +1 . +The +.B + +prefix has no effect with values other than +.BR 1 . +A memory usage limit can still make +.B xz +switch to single-threaded mode unless +.B \-\-no\-adjust +is used. +Support for the +.B + +prefix was added in +.B xz +5.4.0. +.IP "" +If an automatic number of threads has been requested and +no memory usage limit has been specified, +then a system-specific default soft limit will be used to possibly +limit the number of threads. +It is a soft limit in sense that it is ignored +if the number of threads becomes one, +thus a soft limit will never stop +.B xz +from compressing or decompressing. +This default soft limit will not make +.B xz +switch from multi-threaded mode to single-threaded mode. +The active limits can be seen with +.BR "xz \-\-info\-memory" . +.IP "" +Currently the only threading method is to split the input into +blocks and compress them independently from each other. +The default block size depends on the compression level and +can be overridden with the +.BI \-\-block\-size= size +option. +.IP "" +Threaded decompression only works on files that contain +multiple blocks with size information in block headers. +All large enough files compressed in multi-threaded mode +meet this condition, +but files compressed in single-threaded mode don't even if +.BI \-\-block\-size= size +has been used. +.IP "" +The default value for +.I threads +is +.BR 0 . +In +.B xz +5.4.x and older the default is +.BR 1 . +. +.SS "Custom compressor filter chains" +A custom filter chain allows specifying +the compression settings in detail instead of relying on +the settings associated to the presets. +When a custom filter chain is specified, +preset options +.RB ( \-0 +\&...\& +.B \-9 +and +.BR \-\-extreme ) +earlier on the command line are forgotten. +If a preset option is specified +after one or more custom filter chain options, +the new preset takes effect and +the custom filter chain options specified earlier are forgotten. +.PP +A filter chain is comparable to piping on the command line. +When compressing, the uncompressed input goes to the first filter, +whose output goes to the next filter (if any). +The output of the last filter gets written to the compressed file. +The maximum number of filters in the chain is four, +but typically a filter chain has only one or two filters. +.PP +Many filters have limitations on where they can be +in the filter chain: +some filters can work only as the last filter in the chain, +some only as a non-last filter, and some work in any position +in the chain. +Depending on the filter, this limitation is either inherent to +the filter design or exists to prevent security issues. +.PP +A custom filter chain can be specified in two different ways. +The options +.BI \-\-filters= filters +and +.BI \-\-filters1= filters +\&...\& +.BI \-\-filters9= filters +allow specifying an entire filter chain in one option using the +liblzma filter string syntax. +Alternatively, a filter chain can be specified by using one or more +individual filter options in the order they are wanted in the filter chain. +That is, the order of the individual filter options is significant! +When decoding raw streams +.RB ( \-\-format=raw ), +the filter chain must be specified in the same order as +it was specified when compressing. +Any individual filter or preset options specified before the full +chain option +(\fB\-\-filters=\fIfilters\fR) +will be forgotten. +Individual filters specified after the full chain option will reset the +filter chain. +.PP +Both the full and individual filter options take filter-specific +.I options +as a comma-separated list. +Extra commas in +.I options +are ignored. +Every option has a default value, so +specify those you want to change. +.PP +To see the whole filter chain and +.IR options , +use +.B "xz \-vv" +(that is, use +.B \-\-verbose +twice). +This works also for viewing the filter chain options used by presets. +.TP +.BI \-\-filters= filters +Specify the full filter chain or a preset in a single option. +Each filter can be separated by spaces or two dashes +.RB ( \-\- ). +.I filters +may need to be quoted on the shell command line so it is +parsed as a single option. +To denote +.IR options , +use +.B : +or +.BR = . +A preset can be prefixed with a +.B \- +and followed with zero or more flags. +The only supported flag is +.B e +to apply the same options as +.BR \-\-extreme . +.TP +\fB\-\-filters1\fR=\fIfilters\fR ... \fB\-\-filters9\fR=\fIfilters +Specify up to nine additional filter chains that can be used with +.BR \-\-block\-list . +.IP "" +For example, when compressing an archive with executable files +followed by text files, the executable part could use a filter +chain with a BCJ filter and the text part only the LZMA2 filter. +.TP +.B \-\-filters-help +Display a help message describing how to specify presets and +custom filter chains in the +.B \-\-filters +and +.BI \-\-filters1= filters +\&...\& +.BI \-\-filters9= filters +options, and exit successfully. +.TP +\fB\-\-lzma1\fR[\fB=\fIoptions\fR] +.PD 0 +.TP +\fB\-\-lzma2\fR[\fB=\fIoptions\fR] +.PD +Add LZMA1 or LZMA2 filter to the filter chain. +These filters can be used only as the last filter in the chain. +.IP "" +LZMA1 is a legacy filter, +which is supported almost solely due to the legacy +.B .lzma +file format, which supports only LZMA1. +LZMA2 is an updated +version of LZMA1 to fix some practical issues of LZMA1. +The +.B .xz +format uses LZMA2 and doesn't support LZMA1 at all. +Compression speed and ratios of LZMA1 and LZMA2 +are practically the same. +.IP "" +LZMA1 and LZMA2 share the same set of +.IR options : +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +.BI preset= preset +Reset all LZMA1 or LZMA2 +.I options +to +.IR preset . +.I Preset +consist of an integer, which may be followed by single-letter +preset modifiers. +The integer can be from +.B 0 +to +.BR 9 , +matching the command line options +.B \-0 +\&...\& +.BR \-9 . +The only supported modifier is currently +.BR e , +which matches +.BR \-\-extreme . +If no +.B preset +is specified, the default values of LZMA1 or LZMA2 +.I options +are taken from the preset +.BR 6 . +.TP +.BI dict= size +Dictionary (history buffer) +.I size +indicates how many bytes of the recently processed +uncompressed data is kept in memory. +The algorithm tries to find repeating byte sequences (matches) in +the uncompressed data, and replace them with references +to the data currently in the dictionary. +The bigger the dictionary, the higher is the chance +to find a match. +Thus, increasing dictionary +.I size +usually improves compression ratio, but +a dictionary bigger than the uncompressed file is waste of memory. +.IP "" +Typical dictionary +.I size +is from 64\ KiB to 64\ MiB. +The minimum is 4\ KiB. +The maximum for compression is currently 1.5\ GiB (1536\ MiB). +The decompressor already supports dictionaries up to +one byte less than 4\ GiB, which is the maximum for +the LZMA1 and LZMA2 stream formats. +.IP "" +Dictionary +.I size +and match finder +.RI ( mf ) +together determine the memory usage of the LZMA1 or LZMA2 encoder. +The same (or bigger) dictionary +.I size +is required for decompressing that was used when compressing, +thus the memory usage of the decoder is determined +by the dictionary size used when compressing. +The +.B .xz +headers store the dictionary +.I size +either as +.RI "2^" n +or +.RI "2^" n " + 2^(" n "\-1)," +so these +.I sizes +are somewhat preferred for compression. +Other +.I sizes +will get rounded up when stored in the +.B .xz +headers. +.TP +.BI lc= lc +Specify the number of literal context bits. +The minimum is 0 and the maximum is 4; the default is 3. +In addition, the sum of +.I lc +and +.I lp +must not exceed 4. +.IP "" +All bytes that cannot be encoded as matches +are encoded as literals. +That is, literals are simply 8-bit bytes +that are encoded one at a time. +.IP "" +The literal coding makes an assumption that the highest +.I lc +bits of the previous uncompressed byte correlate +with the next byte. +For example, in typical English text, an upper-case letter is +often followed by a lower-case letter, and a lower-case +letter is usually followed by another lower-case letter. +In the US-ASCII character set, the highest three bits are 010 +for upper-case letters and 011 for lower-case letters. +When +.I lc +is at least 3, the literal coding can take advantage of +this property in the uncompressed data. +.IP "" +The default value (3) is usually good. +If you want maximum compression, test +.BR lc=4 . +Sometimes it helps a little, and +sometimes it makes compression worse. +If it makes it worse, test +.B lc=2 +too. +.TP +.BI lp= lp +Specify the number of literal position bits. +The minimum is 0 and the maximum is 4; the default is 0. +.IP "" +.I Lp +affects what kind of alignment in the uncompressed data is +assumed when encoding literals. +See +.I pb +below for more information about alignment. +.TP +.BI pb= pb +Specify the number of position bits. +The minimum is 0 and the maximum is 4; the default is 2. +.IP "" +.I Pb +affects what kind of alignment in the uncompressed data is +assumed in general. +The default means four-byte alignment +.RI (2^ pb =2^2=4), +which is often a good choice when there's no better guess. +.IP "" +When the alignment is known, setting +.I pb +accordingly may reduce the file size a little. +For example, with text files having one-byte +alignment (US-ASCII, ISO-8859-*, UTF-8), setting +.B pb=0 +can improve compression slightly. +For UTF-16 text, +.B pb=1 +is a good choice. +If the alignment is an odd number like 3 bytes, +.B pb=0 +might be the best choice. +.IP "" +Even though the assumed alignment can be adjusted with +.I pb +and +.IR lp , +LZMA1 and LZMA2 still slightly favor 16-byte alignment. +It might be worth taking into account when designing file formats +that are likely to be often compressed with LZMA1 or LZMA2. +.TP +.BI mf= mf +Match finder has a major effect on encoder speed, +memory usage, and compression ratio. +Usually Hash Chain match finders are faster than Binary Tree +match finders. +The default depends on the +.IR preset : +0 uses +.BR hc3 , +1\(en3 +use +.BR hc4 , +and the rest use +.BR bt4 . +.IP "" +The following match finders are supported. +The memory usage formulas below are rough approximations, +which are closest to the reality when +.I dict +is a power of two. +.RS +.TP +.B hc3 +Hash Chain with 2- and 3-byte hashing +.br +Minimum value for +.IR nice : +3 +.br +Memory usage: +.br +.I dict +* 7.5 (if +.I dict +<= 16 MiB); +.br +.I dict +* 5.5 + 64 MiB (if +.I dict +> 16 MiB) +.TP +.B hc4 +Hash Chain with 2-, 3-, and 4-byte hashing +.br +Minimum value for +.IR nice : +4 +.br +Memory usage: +.br +.I dict +* 7.5 (if +.I dict +<= 32 MiB); +.br +.I dict +* 6.5 (if +.I dict +> 32 MiB) +.TP +.B bt2 +Binary Tree with 2-byte hashing +.br +Minimum value for +.IR nice : +2 +.br +Memory usage: +.I dict +* 9.5 +.TP +.B bt3 +Binary Tree with 2- and 3-byte hashing +.br +Minimum value for +.IR nice : +3 +.br +Memory usage: +.br +.I dict +* 11.5 (if +.I dict +<= 16 MiB); +.br +.I dict +* 9.5 + 64 MiB (if +.I dict +> 16 MiB) +.TP +.B bt4 +Binary Tree with 2-, 3-, and 4-byte hashing +.br +Minimum value for +.IR nice : +4 +.br +Memory usage: +.br +.I dict +* 11.5 (if +.I dict +<= 32 MiB); +.br +.I dict +* 10.5 (if +.I dict +> 32 MiB) +.RE +.TP +.BI mode= mode +Compression +.I mode +specifies the method to analyze +the data produced by the match finder. +Supported +.I modes +are +.B fast +and +.BR normal . +The default is +.B fast +for +.I presets +0\(en3 and +.B normal +for +.I presets +4\(en9. +.IP "" +Usually +.B fast +is used with Hash Chain match finders and +.B normal +with Binary Tree match finders. +This is also what the +.I presets +do. +.TP +.BI nice= nice +Specify what is considered to be a nice length for a match. +Once a match of at least +.I nice +bytes is found, the algorithm stops +looking for possibly better matches. +.IP "" +.I Nice +can be 2\(en273 bytes. +Higher values tend to give better compression ratio +at the expense of speed. +The default depends on the +.IR preset . +.TP +.BI depth= depth +Specify the maximum search depth in the match finder. +The default is the special value of 0, +which makes the compressor determine a reasonable +.I depth +from +.I mf +and +.IR nice . +.IP "" +Reasonable +.I depth +for Hash Chains is 4\(en100 and 16\(en1000 for Binary Trees. +Using very high values for +.I depth +can make the encoder extremely slow with some files. +Avoid setting the +.I depth +over 1000 unless you are prepared to interrupt +the compression in case it is taking far too long. +.RE +.IP "" +When decoding raw streams +.RB ( \-\-format=raw ), +LZMA2 needs only the dictionary +.IR size . +LZMA1 needs also +.IR lc , +.IR lp , +and +.IR pb . +.TP +\fB\-\-x86\fR[\fB=\fIoptions\fR] +.PD 0 +.TP +\fB\-\-arm\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-armthumb\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-arm64\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-powerpc\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-ia64\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-sparc\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-riscv\fR[\fB=\fIoptions\fR] +.PD +Add a branch/call/jump (BCJ) filter to the filter chain. +These filters can be used only as a non-last filter +in the filter chain. +.IP "" +A BCJ filter converts relative addresses in +the machine code to their absolute counterparts. +This doesn't change the size of the data +but it increases redundancy, +which can help LZMA2 to produce 0\(en15\ % smaller +.B .xz +file. +The BCJ filters are always reversible, +so using a BCJ filter for wrong type of data +doesn't cause any data loss, although it may make +the compression ratio slightly worse. +The BCJ filters are very fast and +use an insignificant amount of memory. +.IP "" +These BCJ filters have known problems related to +the compression ratio: +.RS +.IP \(bu 3 +Some types of files containing executable code +(for example, object files, static libraries, and Linux kernel modules) +have the addresses in the instructions filled with filler values. +These BCJ filters will still do the address conversion, +which will make the compression worse with these files. +.IP \(bu 3 +If a BCJ filter is applied on an archive, +it is possible that it makes the compression ratio +worse than not using a BCJ filter. +For example, if there are similar or even identical executables +then filtering will likely make the files less similar +and thus compression is worse. +The contents of non-executable files in the same archive can matter too. +In practice one has to try with and without a BCJ filter to see +which is better in each situation. +.RE +.IP "" +Different instruction sets have different alignment: +the executable file must be aligned to a multiple of +this value in the input data to make the filter work. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filter;Alignment;Notes +x86;1;32-bit or 64-bit x86 +ARM;4; +ARM-Thumb;2; +ARM64;4;4096-byte alignment is best +PowerPC;4;Big endian only +IA-64;16;Itanium +SPARC;4; +RISC-V;2; +.TE +.RE +.RE +.IP "" +Since the BCJ-filtered data is usually compressed with LZMA2, +the compression ratio may be improved slightly if +the LZMA2 options are set to match the +alignment of the selected BCJ filter. +Examples: +.RS +.IP \(bu 3 +IA-64 filter has 16-byte alignment so +.B pb=4,lp=4,lc=0 +is good +with LZMA2 (2^4=16). +.IP \(bu 3 +RISC-V code has 2-byte or 4-byte alignment +depending on whether the file contains +16-bit compressed instructions (the C extension). +When 16-bit instructions are used, +.B pb=2,lp=1,lc=3 +or +.B pb=1,lp=1,lc=3 +is good. +When 16-bit instructions aren't present, +.B pb=2,lp=2,lc=2 +is the best. +.B readelf \-h +can be used to check if "RVC" +appears on the "Flags" line. +.IP \(bu 3 +ARM64 is always 4-byte aligned so +.B pb=2,lp=2,lc=2 +is the best. +.IP \(bu 3 +The x86 filter is an exception. +It's usually good to stick to LZMA2's defaults +.RB ( pb=2,lp=0,lc=3 ) +when compressing x86 executables. +.RE +.IP "" +All BCJ filters support the same +.IR options : +.RS +.TP +.BI start= offset +Specify the start +.I offset +that is used when converting between relative +and absolute addresses. +The +.I offset +must be a multiple of the alignment of the filter +(see the table above). +The default is zero. +In practice, the default is good; specifying a custom +.I offset +is almost never useful. +.RE +.TP +\fB\-\-delta\fR[\fB=\fIoptions\fR] +Add the Delta filter to the filter chain. +The Delta filter can be only used as a non-last filter +in the filter chain. +.IP "" +Currently only simple byte-wise delta calculation is supported. +It can be useful when compressing, for example, uncompressed bitmap images +or uncompressed PCM audio. +However, special purpose algorithms may give significantly better +results than Delta + LZMA2. +This is true especially with audio, +which compresses faster and better, for example, with +.BR flac (1). +.IP "" +Supported +.IR options : +.RS +.TP +.BI dist= distance +Specify the +.I distance +of the delta calculation in bytes. +.I distance +must be 1\(en256. +The default is 1. +.IP "" +For example, with +.B dist=2 +and eight-byte input A1 B1 A2 B3 A3 B5 A4 B7, the output will be +A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Other options" +.TP +.BR \-q ", " \-\-quiet +Suppress warnings and notices. +Specify this twice to suppress errors too. +This option has no effect on the exit status. +That is, even if a warning was suppressed, +the exit status to indicate a warning is still used. +.TP +.BR \-v ", " \-\-verbose +Be verbose. +If standard error is connected to a terminal, +.B xz +will display a progress indicator. +Specifying +.B \-\-verbose +twice will give even more verbose output. +.IP "" +The progress indicator shows the following information: +.RS +.IP \(bu 3 +Completion percentage is shown +if the size of the input file is known. +That is, the percentage cannot be shown in pipes. +.IP \(bu 3 +Amount of compressed data produced (compressing) +or consumed (decompressing). +.IP \(bu 3 +Amount of uncompressed data consumed (compressing) +or produced (decompressing). +.IP \(bu 3 +Compression ratio, which is calculated by dividing +the amount of compressed data processed so far by +the amount of uncompressed data processed so far. +.IP \(bu 3 +Compression or decompression speed. +This is measured as the amount of uncompressed data consumed +(compression) or produced (decompression) per second. +It is shown after a few seconds have passed since +.B xz +started processing the file. +.IP \(bu 3 +Elapsed time in the format M:SS or H:MM:SS. +.IP \(bu 3 +Estimated remaining time is shown +only when the size of the input file is +known and a couple of seconds have already passed since +.B xz +started processing the file. +The time is shown in a less precise format which +never has any colons, for example, 2 min 30 s. +.RE +.IP "" +When standard error is not a terminal, +.B \-\-verbose +will make +.B xz +print the filename, compressed size, uncompressed size, +compression ratio, and possibly also the speed and elapsed time +on a single line to standard error after compressing or +decompressing the file. +The speed and elapsed time are included only when +the operation took at least a few seconds. +If the operation didn't finish, for example, due to user interruption, +also the completion percentage is printed +if the size of the input file is known. +.TP +.BR \-Q ", " \-\-no\-warn +Don't set the exit status to 2 +even if a condition worth a warning was detected. +This option doesn't affect the verbosity level, thus both +.B \-\-quiet +and +.B \-\-no\-warn +have to be used to not display warnings and +to not alter the exit status. +.TP +.B \-\-robot +Print messages in a machine-parsable format. +This is intended to ease writing frontends that want to use +.B xz +instead of liblzma, which may be the case with various scripts. +The output with this option enabled is meant to be stable across +.B xz +releases. +See the section +.B "ROBOT MODE" +for details. +.TP +.B \-\-info\-memory +Display, in human-readable format, how much physical memory (RAM) +and how many processor threads +.B xz +thinks the system has and the memory usage limits for compression +and decompression, and exit successfully. +.TP +.BR \-h ", " \-\-help +Display a help message describing the most commonly used options, +and exit successfully. +.TP +.BR \-H ", " \-\-long\-help +Display a help message describing all features of +.BR xz , +and exit successfully +.TP +.BR \-V ", " \-\-version +Display the version number of +.B xz +and liblzma in human readable format. +To get machine-parsable output, specify +.B \-\-robot +before +.BR \-\-version . +. +.SH "ROBOT MODE" +The robot mode is activated with the +.B \-\-robot +option. +It makes the output of +.B xz +easier to parse by other programs. +Currently +.B \-\-robot +is supported only together with +.BR \-\-list , +.BR \-\-filters\-help , +.BR \-\-info\-memory , +and +.BR \-\-version . +It will be supported for compression and +decompression in the future. +. +.SS "List mode" +.B "xz \-\-robot \-\-list" +uses tab-separated output. +The first column of every line has a string +that indicates the type of the information found on that line: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +.B name +This is always the first line when starting to list a file. +The second column on the line is the filename. +.TP +.B file +This line contains overall information about the +.B .xz +file. +This line is always printed after the +.B name +line. +.TP +.B stream +This line type is used only when +.B \-\-verbose +was specified. +There are as many +.B stream +lines as there are streams in the +.B .xz +file. +.TP +.B block +This line type is used only when +.B \-\-verbose +was specified. +There are as many +.B block +lines as there are blocks in the +.B .xz +file. +The +.B block +lines are shown after all the +.B stream +lines; different line types are not interleaved. +.TP +.B summary +This line type is used only when +.B \-\-verbose +was specified twice. +This line is printed after all +.B block +lines. +Like the +.B file +line, the +.B summary +line contains overall information about the +.B .xz +file. +.TP +.B totals +This line is always the very last line of the list output. +It shows the total counts and sizes. +.PP +The columns of the +.B file +lines: +.PD 0 +.RS +.IP 2. 4 +Number of streams in the file +.IP 3. 4 +Total number of blocks in the stream(s) +.IP 4. 4 +Compressed size of the file +.IP 5. 4 +Uncompressed size of the file +.IP 6. 4 +Compression ratio, for example, +.BR 0.123 . +If ratio is over 9.999, three dashes +.RB ( \-\-\- ) +are displayed instead of the ratio. +.IP 7. 4 +Comma-separated list of integrity check names. +The following strings are used for the known check types: +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +.BR None , +.BR CRC32 , +.BR CRC64 , +and +.BR SHA\-256 . +For unknown check types, +.BI Unknown\- N +is used, where +.I N +is the Check ID as a decimal number (one or two digits). +.IP 8. 4 +Total size of stream padding in the file +.RE +.PD +.PP +The columns of the +.B stream +lines: +.PD 0 +.RS +.IP 2. 4 +Stream number (the first stream is 1) +.IP 3. 4 +Number of blocks in the stream +.IP 4. 4 +Compressed start offset +.IP 5. 4 +Uncompressed start offset +.IP 6. 4 +Compressed size (does not include stream padding) +.IP 7. 4 +Uncompressed size +.IP 8. 4 +Compression ratio +.IP 9. 4 +Name of the integrity check +.IP 10. 4 +Size of stream padding +.RE +.PD +.PP +The columns of the +.B block +lines: +.PD 0 +.RS +.IP 2. 4 +Number of the stream containing this block +.IP 3. 4 +Block number relative to the beginning of the stream +(the first block is 1) +.IP 4. 4 +Block number relative to the beginning of the file +.IP 5. 4 +Compressed start offset relative to the beginning of the file +.IP 6. 4 +Uncompressed start offset relative to the beginning of the file +.IP 7. 4 +Total compressed size of the block (includes headers) +.IP 8. 4 +Uncompressed size +.IP 9. 4 +Compression ratio +.IP 10. 4 +Name of the integrity check +.RE +.PD +.PP +If +.B \-\-verbose +was specified twice, additional columns are included on the +.B block +lines. +These are not displayed with a single +.BR \-\-verbose , +because getting this information requires many seeks +and can thus be slow: +.PD 0 +.RS +.IP 11. 4 +Value of the integrity check in hexadecimal +.IP 12. 4 +Block header size +.IP 13. 4 +Block flags: +.B c +indicates that compressed size is present, and +.B u +indicates that uncompressed size is present. +If the flag is not set, a dash +.RB ( \- ) +is shown instead to keep the string length fixed. +New flags may be added to the end of the string in the future. +.IP 14. 4 +Size of the actual compressed data in the block (this excludes +the block header, block padding, and check fields) +.IP 15. 4 +Amount of memory (in bytes) required to decompress +this block with this +.B xz +version +.IP 16. 4 +Filter chain. +Note that most of the options used at compression time +cannot be known, because only the options +that are needed for decompression are stored in the +.B .xz +headers. +.RE +.PD +.PP +The columns of the +.B summary +lines: +.PD 0 +.RS +.IP 2. 4 +Amount of memory (in bytes) required to decompress +this file with this +.B xz +version +.IP 3. 4 +.B yes +or +.B no +indicating if all block headers have both compressed size and +uncompressed size stored in them +.PP +.I Since +.B xz +.I 5.1.2alpha: +.IP 4. 4 +Minimum +.B xz +version required to decompress the file +.RE +.PD +.PP +The columns of the +.B totals +line: +.PD 0 +.RS +.IP 2. 4 +Number of streams +.IP 3. 4 +Number of blocks +.IP 4. 4 +Compressed size +.IP 5. 4 +Uncompressed size +.IP 6. 4 +Average compression ratio +.IP 7. 4 +Comma-separated list of integrity check names +that were present in the files +.IP 8. 4 +Stream padding size +.IP 9. 4 +Number of files. +This is here to +keep the order of the earlier columns the same as on +.B file +lines. +.PD +.RE +.PP +If +.B \-\-verbose +was specified twice, additional columns are included on the +.B totals +line: +.PD 0 +.RS +.IP 10. 4 +Maximum amount of memory (in bytes) required to decompress +the files with this +.B xz +version +.IP 11. 4 +.B yes +or +.B no +indicating if all block headers have both compressed size and +uncompressed size stored in them +.PP +.I Since +.B xz +.I 5.1.2alpha: +.IP 12. 4 +Minimum +.B xz +version required to decompress the file +.RE +.PD +.PP +Future versions may add new line types and +new columns can be added to the existing line types, +but the existing columns won't be changed. +. +.SS "Filters help" +.B "xz \-\-robot \-\-filters-help" +prints the supported filters in the following format: +.PP +\fIfilter\fB:\fIoption\fB=<\fIvalue\fB>,\fIoption\fB=<\fIvalue\fB>\fR... +.TP +.I filter +Name of the filter +.TP +.I option +Name of a filter specific option +.TP +.I value +Numeric +.I value +ranges appear as +\fB<\fImin\fB\-\fImax\fB>\fR. +String +.I value +choices are shown within +.B "< >" +and separated by a +.B | +character. +.PP +Each filter is printed on its own line. +. +.SS "Memory limit information" +.B "xz \-\-robot \-\-info\-memory" +prints a single line with multiple tab-separated columns: +.IP 1. 4 +Total amount of physical memory (RAM) in bytes. +.IP 2. 4 +Memory usage limit for compression in bytes +.RB ( \-\-memlimit\-compress ). +A special value of +.B 0 +indicates the default setting +which for single-threaded mode is the same as no limit. +.IP 3. 4 +Memory usage limit for decompression in bytes +.RB ( \-\-memlimit\-decompress ). +A special value of +.B 0 +indicates the default setting +which for single-threaded mode is the same as no limit. +.IP 4. 4 +Since +.B xz +5.3.4alpha: +Memory usage for multi-threaded decompression in bytes +.RB ( \-\-memlimit\-mt\-decompress ). +This is never zero because a system-specific default value +shown in the column 5 +is used if no limit has been specified explicitly. +This is also never greater than the value in the column 3 +even if a larger value has been specified with +.BR \-\-memlimit\-mt\-decompress . +.IP 5. 4 +Since +.B xz +5.3.4alpha: +A system-specific default memory usage limit +that is used to limit the number of threads +when compressing with an automatic number of threads +.RB ( \-\-threads=0 ) +and no memory usage limit has been specified +.RB ( \-\-memlimit\-compress ). +This is also used as the default value for +.BR \-\-memlimit\-mt\-decompress . +.IP 6. 4 +Since +.B xz +5.3.4alpha: +Number of available processor threads. +.PP +In the future, the output of +.B "xz \-\-robot \-\-info\-memory" +may have more columns, but never more than a single line. +. +.SS Version +.B "xz \-\-robot \-\-version" +prints the version number of +.B xz +and liblzma in the following format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +.BI XZ_VERSION= XYYYZZZS +.br +.BI LIBLZMA_VERSION= XYYYZZZS +.TP +.I X +Major version. +.TP +.I YYY +Minor version. +Even numbers are stable. +Odd numbers are alpha or beta versions. +.TP +.I ZZZ +Patch level for stable releases or +just a counter for development releases. +.TP +.I S +Stability. +0 is alpha, 1 is beta, and 2 is stable. +.I S +should be always 2 when +.I YYY +is even. +.PP +.I XYYYZZZS +are the same on both lines if +.B xz +and liblzma are from the same XZ Utils release. +.PP +Examples: 4.999.9beta is +.B 49990091 +and +5.0.0 is +.BR 50000002 . +. +.SH "EXIT STATUS" +.TP +.B 0 +All is good. +.TP +.B 1 +An error occurred. +.TP +.B 2 +Something worth a warning occurred, +but no actual errors occurred. +.PP +Notices (not warnings or errors) printed on standard error +don't affect the exit status. +. +.SH ENVIRONMENT +.B xz +parses space-separated lists of options +from the environment variables +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +.B XZ_DEFAULTS +and +.BR XZ_OPT , +in this order, before parsing the options from the command line. +Note that only options are parsed from the environment variables; +all non-options are silently ignored. +Parsing is done with +.BR getopt_long (3) +which is used also for the command line arguments. +.PP +.B Warning: +By setting these environment variables, +one is effectively modifying programs and scripts that run +.BR xz . +Most of the time it is safe to set memory usage limits, number of threads, +and compression options via the environment variables. +However, some options can break scripts. +An obvious example is +.B \-\-help +which makes +.B xz +show the help text instead of compressing or decompressing a file. +More subtle examples are +.B \-\-quiet +and +.BR \-\-verbose . +In many cases it works well to enable the progress indicator using +.BR \-\-verbose , +but in some situations the extra messages create problems. +The verbosity level also affects the behavior of +.BR \-\-list . +.TP +.B XZ_DEFAULTS +User-specific or system-wide default options. +Typically this is set in a shell initialization script to enable +.BR xz 's +memory usage limiter by default or set the default number of threads. +Excluding shell initialization scripts +and similar special cases, scripts should never set or unset +.BR XZ_DEFAULTS . +.TP +.B XZ_OPT +This is for passing options to +.B xz +when it is not possible to set the options directly on the +.B xz +command line. +This is the case when +.B xz +is run by a script or tool, for example, GNU +.BR tar (1): +.RS +.RS +.PP +.nf +.ft CR +XZ_OPT=\-2v tar caf foo.tar.xz foo +.ft R +.fi +.RE +.RE +.IP "" +Scripts may use +.BR XZ_OPT , +for example, to set script-specific default compression options. +It is still recommended to allow users to override +.B XZ_OPT +if that is reasonable. +For example, in +.BR sh (1) +scripts one may use something like this: +.RS +.RS +.PP +.nf +.ft CR +XZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT +.ft R +.fi +.RE +.RE +. +.SH "LZMA UTILS COMPATIBILITY" +The command line syntax of +.B xz +is practically a superset of +.BR lzma , +.BR unlzma , +and +.B lzcat +as found from LZMA Utils 4.32.x. +In most cases, it is possible to replace +LZMA Utils with XZ Utils without breaking existing scripts. +There are some incompatibilities though, +which may sometimes cause problems. +. +.SS "Compression preset levels" +The numbering of the compression level presets is not identical in +.B xz +and LZMA Utils. +The most important difference is how dictionary sizes +are mapped to different presets. +Dictionary size is roughly equal to the decompressor memory usage. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Level;xz;LZMA Utils +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +The dictionary size differences affect +the compressor memory usage too, +but there are some other differences between +LZMA Utils and XZ Utils, which +make the difference even bigger: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Level;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +The default preset level in LZMA Utils is +.B \-7 +while in XZ Utils it is +.BR \-6 , +so both use an 8 MiB dictionary by default. +. +.SS "Streamed vs. non-streamed .lzma files" +The uncompressed size of the file can be stored in the +.B .lzma +header. +LZMA Utils does that when compressing regular files. +The alternative is to mark that uncompressed size is unknown +and use end-of-payload marker to indicate +where the decompressor should stop. +LZMA Utils uses this method when uncompressed size isn't known, +which is the case, for example, in pipes. +.PP +.B xz +supports decompressing +.B .lzma +files with or without end-of-payload marker, but all +.B .lzma +files created by +.B xz +will use end-of-payload marker and have uncompressed size +marked as unknown in the +.B .lzma +header. +This may be a problem in some uncommon situations. +For example, a +.B .lzma +decompressor in an embedded device might work +only with files that have known uncompressed size. +If you hit this problem, you need to use LZMA Utils +or LZMA SDK to create +.B .lzma +files with known uncompressed size. +. +.SS "Unsupported .lzma files" +The +.B .lzma +format allows +.I lc +values up to 8, and +.I lp +values up to 4. +LZMA Utils can decompress files with any +.I lc +and +.IR lp , +but always creates files with +.B lc=3 +and +.BR lp=0 . +Creating files with other +.I lc +and +.I lp +is possible with +.B xz +and with LZMA SDK. +.PP +The implementation of the LZMA1 filter in liblzma +requires that the sum of +.I lc +and +.I lp +must not exceed 4. +Thus, +.B .lzma +files, which exceed this limitation, cannot be decompressed with +.BR xz . +.PP +LZMA Utils creates only +.B .lzma +files which have a dictionary size of +.RI "2^" n +(a power of 2) but accepts files with any dictionary size. +liblzma accepts only +.B .lzma +files which have a dictionary size of +.RI "2^" n +or +.RI "2^" n " + 2^(" n "\-1)." +This is to decrease false positives when detecting +.B .lzma +files. +.PP +These limitations shouldn't be a problem in practice, +since practically all +.B .lzma +files have been compressed with settings that liblzma will accept. +. +.SS "Trailing garbage" +When decompressing, +LZMA Utils silently ignore everything after the first +.B .lzma +stream. +In most situations, this is a bug. +This also means that LZMA Utils +don't support decompressing concatenated +.B .lzma +files. +.PP +If there is data left after the first +.B .lzma +stream, +.B xz +considers the file to be corrupt unless +.B \-\-single\-stream +was used. +This may break obscure scripts which have +assumed that trailing garbage is ignored. +. +.SH NOTES +. +.SS "Compressed output may vary" +The exact compressed output produced from +the same uncompressed input file +may vary between XZ Utils versions even if +compression options are identical. +This is because the encoder can be improved +(faster or better compression) +without affecting the file format. +The output can vary even between different +builds of the same XZ Utils version, +if different build options are used. +.PP +The above means that once +.B \-\-rsyncable +has been implemented, +the resulting files won't necessarily be rsyncable +unless both old and new files have been compressed +with the same xz version. +This problem can be fixed if a part of the encoder +implementation is frozen to keep rsyncable output +stable across xz versions. +. +.SS "Embedded .xz decompressors" +Embedded +.B .xz +decompressor implementations like XZ Embedded don't necessarily +support files created with integrity +.I check +types other than +.B none +and +.BR crc32 . +Since the default is +.BR \-\-check=crc64 , +you must use +.B \-\-check=none +or +.B \-\-check=crc32 +when creating files for embedded systems. +.PP +Outside embedded systems, all +.B .xz +format decompressors support all the +.I check +types, or at least are able to decompress +the file without verifying the +integrity check if the particular +.I check +is not supported. +.PP +XZ Embedded supports BCJ filters, +but only with the default start offset. +. +.SH EXAMPLES +. +.SS Basics +Compress the file +.I foo +into +.I foo.xz +using the default compression level +.RB ( \-6 ), +and remove +.I foo +if compression is successful: +.RS +.PP +.nf +.ft CR +xz foo +.ft R +.fi +.RE +.PP +Decompress +.I bar.xz +into +.I bar +and don't remove +.I bar.xz +even if decompression is successful: +.RS +.PP +.nf +.ft CR +xz \-dk bar.xz +.ft R +.fi +.RE +.PP +Create +.I baz.tar.xz +with the preset +.B \-4e +.RB ( "\-4 \-\-extreme" ), +which is slower than the default +.BR \-6 , +but needs less memory for compression and decompression (48\ MiB +and 5\ MiB, respectively): +.RS +.PP +.nf +.ft CR +tar cf \- baz | xz \-4e > baz.tar.xz +.ft R +.fi +.RE +.PP +A mix of compressed and uncompressed files can be decompressed +to standard output with a single command: +.RS +.PP +.nf +.ft CR +xz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt +.ft R +.fi +.RE +. +.SS "Parallel compression of many files" +On GNU and *BSD, +.BR find (1) +and +.BR xargs (1) +can be used to parallelize compression of many files: +.RS +.PP +.nf +.ft CR +find . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1 +.ft R +.fi +.RE +.PP +The +.B \-P +option to +.BR xargs (1) +sets the number of parallel +.B xz +processes. +The best value for the +.B \-n +option depends on how many files there are to be compressed. +If there are only a couple of files, +the value should probably be 1; +with tens of thousands of files, +100 or even more may be appropriate to reduce the number of +.B xz +processes that +.BR xargs (1) +will eventually create. +.PP +The option +.B \-T1 +for +.B xz +is there to force it to single-threaded mode, because +.BR xargs (1) +is used to control the amount of parallelization. +. +.SS "Robot mode" +Calculate how many bytes have been saved in total +after compressing multiple files: +.RS +.PP +.nf +.ft CR +xz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}' +.ft R +.fi +.RE +.PP +A script may want to know that it is using new enough +.BR xz . +The following +.BR sh (1) +script checks that the version number of the +.B xz +tool is at least 5.0.0. +This method is compatible with old beta versions, +which didn't support the +.B \-\-robot +option: +.RS +.PP +.nf +.ft CR +if ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION +.ft R +.fi +.RE +.PP +Set a memory usage limit for decompression using +.BR XZ_OPT , +but if a limit has already been set, don't increase it: +.RS +.PP +.nf +.ft CR +NEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi +.ft R +.fi +.RE +. +.SS "Custom compressor filter chains" +The simplest use for custom filter chains is +customizing a LZMA2 preset. +This can be useful, +because the presets cover only a subset of the +potentially useful combinations of compression settings. +.PP +The CompCPU columns of the tables +from the descriptions of the options +.BR "\-0" " ... " "\-9" +and +.B \-\-extreme +are useful when customizing LZMA2 presets. +Here are the relevant parts collected from those two tables: +.RS +.PP +.TS +tab(;); +c c +n n. +Preset;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +If you know that a file requires +somewhat big dictionary (for example, 32\ MiB) to compress well, +but you want to compress it quicker than +.B "xz \-8" +would do, a preset with a low CompCPU value (for example, 1) +can be modified to use a bigger dictionary: +.RS +.PP +.nf +.ft CR +xz \-\-lzma2=preset=1,dict=32MiB foo.tar +.ft R +.fi +.RE +.PP +With certain files, the above command may be faster than +.B "xz \-6" +while compressing significantly better. +However, it must be emphasized that only some files benefit from +a big dictionary while keeping the CompCPU value low. +The most obvious situation, +where a big dictionary can help a lot, +is an archive containing very similar files +of at least a few megabytes each. +The dictionary size has to be significantly bigger +than any individual file to allow LZMA2 to take +full advantage of the similarities between consecutive files. +.PP +If very high compressor and decompressor memory usage is fine, +and the file being compressed is +at least several hundred megabytes, it may be useful +to use an even bigger dictionary than the 64 MiB that +.B "xz \-9" +would use: +.RS +.PP +.nf +.ft CR +xz \-vv \-\-lzma2=dict=192MiB big_foo.tar +.ft R +.fi +.RE +.PP +Using +.B \-vv +.RB ( "\-\-verbose \-\-verbose" ) +like in the above example can be useful +to see the memory requirements +of the compressor and decompressor. +Remember that using a dictionary bigger than +the size of the uncompressed file is waste of memory, +so the above command isn't useful for small files. +.PP +Sometimes the compression time doesn't matter, +but the decompressor memory usage has to be kept low, for example, +to make it possible to decompress the file on an embedded system. +The following command uses +.B \-6e +.RB ( "\-6 \-\-extreme" ) +as a base and sets the dictionary to only 64\ KiB. +The resulting file can be decompressed with XZ Embedded +(that's why there is +.BR \-\-check=crc32 ) +using about 100\ KiB of memory. +.RS +.PP +.nf +.ft CR +xz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo +.ft R +.fi +.RE +.PP +If you want to squeeze out as many bytes as possible, +adjusting the number of literal context bits +.RI ( lc ) +and number of position bits +.RI ( pb ) +can sometimes help. +Adjusting the number of literal position bits +.RI ( lp ) +might help too, but usually +.I lc +and +.I pb +are more important. +For example, a source code archive contains mostly US-ASCII text, +so something like the following might give +slightly (like 0.1\ %) smaller file than +.B "xz \-6e" +(try also without +.BR lc=4 ): +.RS +.PP +.nf +.ft CR +xz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar +.ft R +.fi +.RE +.PP +Using another filter together with LZMA2 can improve +compression with certain file types. +For example, to compress a x86-32 or x86-64 shared library +using the x86 BCJ filter: +.RS +.PP +.nf +.ft CR +xz \-\-x86 \-\-lzma2 libfoo.so +.ft R +.fi +.RE +.PP +Note that the order of the filter options is significant. +If +.B \-\-x86 +is specified after +.BR \-\-lzma2 , +.B xz +will give an error, +because there cannot be any filter after LZMA2, +and also because the x86 BCJ filter cannot be used +as the last filter in the chain. +.PP +The Delta filter together with LZMA2 +can give good results with bitmap images. +It should usually beat PNG, +which has a few more advanced filters than simple +delta but uses Deflate for the actual compression. +.PP +The image has to be saved in uncompressed format, +for example, as uncompressed TIFF. +The distance parameter of the Delta filter is set +to match the number of bytes per pixel in the image. +For example, 24-bit RGB bitmap needs +.BR dist=3 , +and it is also good to pass +.B pb=0 +to LZMA2 to accommodate the three-byte alignment: +.RS +.PP +.nf +.ft CR +xz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff +.ft R +.fi +.RE +.PP +If multiple images have been put into a single archive (for example, +.BR .tar ), +the Delta filter will work on that too as long as all images +have the same number of bytes per pixel. +. +.SH "SEE ALSO" +.BR xzdec (1), +.BR xzdiff (1), +.BR xzgrep (1), +.BR xzless (1), +.BR xzmore (1), +.BR gzip (1), +.BR bzip2 (1), +.BR 7z (1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/unxz.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/unxz.1 new file mode 100644 index 0000000000000000000000000000000000000000..6e37b426a3b5c85552cf006f388c9a71d4ad5685 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/unxz.1 @@ -0,0 +1,3264 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.TH XZ 1 "2025-03-08" "Tukaani" "XZ Utils" +. +.SH NAME +xz, unxz, xzcat, lzma, unlzma, lzcat \- Compress or decompress .xz and .lzma files +. +.SH SYNOPSIS +.B xz +.RI [ option... ] +.RI [ file... ] +. +.SH COMMAND ALIASES +.B unxz +is equivalent to +.BR "xz \-\-decompress" . +.br +.B xzcat +is equivalent to +.BR "xz \-\-decompress \-\-stdout" . +.br +.B lzma +is equivalent to +.BR "xz \-\-format=lzma" . +.br +.B unlzma +is equivalent to +.BR "xz \-\-format=lzma \-\-decompress" . +.br +.B lzcat +is equivalent to +.BR "xz \-\-format=lzma \-\-decompress \-\-stdout" . +.PP +When writing scripts that need to decompress files, +it is recommended to always use the name +.B xz +with appropriate arguments +.RB ( "xz \-d" +or +.BR "xz \-dc" ) +instead of the names +.B unxz +and +.BR xzcat . +. +.SH DESCRIPTION +.B xz +is a general-purpose data compression tool with +command line syntax similar to +.BR gzip (1) +and +.BR bzip2 (1). +The native file format is the +.B .xz +format, but the legacy +.B .lzma +format used by LZMA Utils and +raw compressed streams with no container format headers +are also supported. +In addition, decompression of the +.B .lz +format used by +.B lzip +is supported. +.PP +.B xz +compresses or decompresses each +.I file +according to the selected operation mode. +If no +.I files +are given or +.I file +is +.BR \- , +.B xz +reads from standard input and writes the processed data +to standard output. +.B xz +will refuse (display an error and skip the +.IR file ) +to write compressed data to standard output if it is a terminal. +Similarly, +.B xz +will refuse to read compressed data +from standard input if it is a terminal. +.PP +Unless +.B \-\-stdout +is specified, +.I files +other than +.B \- +are written to a new file whose name is derived from the source +.I file +name: +.IP \(bu 3 +When compressing, the suffix of the target file format +.RB ( .xz +or +.BR .lzma ) +is appended to the source filename to get the target filename. +.IP \(bu 3 +When decompressing, the +.BR .xz , +.BR .lzma , +or +.B .lz +suffix is removed from the filename to get the target filename. +.B xz +also recognizes the suffixes +.B .txz +and +.BR .tlz , +and replaces them with the +.B .tar +suffix. +.PP +If the target file already exists, an error is displayed and the +.I file +is skipped. +.PP +Unless writing to standard output, +.B xz +will display a warning and skip the +.I file +if any of the following applies: +.IP \(bu 3 +.I File +is not a regular file. +Symbolic links are not followed, +and thus they are not considered to be regular files. +.IP \(bu 3 +.I File +has more than one hard link. +.IP \(bu 3 +.I File +has setuid, setgid, or sticky bit set. +.IP \(bu 3 +The operation mode is set to compress and the +.I file +already has a suffix of the target file format +.RB ( .xz +or +.B .txz +when compressing to the +.B .xz +format, and +.B .lzma +or +.B .tlz +when compressing to the +.B .lzma +format). +.IP \(bu 3 +The operation mode is set to decompress and the +.I file +doesn't have a suffix of any of the supported file formats +.RB ( .xz , +.BR .txz , +.BR .lzma , +.BR .tlz , +or +.BR .lz ). +.PP +After successfully compressing or decompressing the +.IR file , +.B xz +copies the owner, group, permissions, access time, +and modification time from the source +.I file +to the target file. +If copying the group fails, the permissions are modified +so that the target file doesn't become accessible to users +who didn't have permission to access the source +.IR file . +.B xz +doesn't support copying other metadata like access control lists +or extended attributes yet. +.PP +Once the target file has been successfully closed, the source +.I file +is removed unless +.B \-\-keep +was specified. +The source +.I file +is never removed if the output is written to standard output +or if an error occurs. +.PP +Sending +.B SIGINFO +or +.B SIGUSR1 +to the +.B xz +process makes it print progress information to standard error. +This has only limited use since when standard error +is a terminal, using +.B \-\-verbose +will display an automatically updating progress indicator. +. +.SS "Memory usage" +The memory usage of +.B xz +varies from a few hundred kilobytes to several gigabytes +depending on the compression settings. +The settings used when compressing a file determine +the memory requirements of the decompressor. +Typically the decompressor needs 5\ % to 20\ % of +the amount of memory that the compressor needed when +creating the file. +For example, decompressing a file created with +.B xz \-9 +currently requires 65\ MiB of memory. +Still, it is possible to have +.B .xz +files that require several gigabytes of memory to decompress. +.PP +Especially users of older systems may find +the possibility of very large memory usage annoying. +To prevent uncomfortable surprises, +.B xz +has a built-in memory usage limiter, which is disabled by default. +While some operating systems provide ways to limit +the memory usage of processes, relying on it +wasn't deemed to be flexible enough (for example, using +.BR ulimit (1) +to limit virtual memory tends to cripple +.BR mmap (2)). +.PP +The memory usage limiter can be enabled with +the command line option \fB\-\-memlimit=\fIlimit\fR. +Often it is more convenient to enable the limiter +by default by setting the environment variable +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +.BR XZ_DEFAULTS , +for example, +.BR XZ_DEFAULTS=\-\-memlimit=150MiB . +It is possible to set the limits separately +for compression and decompression by using +.BI \-\-memlimit\-compress= limit +and \fB\-\-memlimit\-decompress=\fIlimit\fR. +Using these two options outside +.B XZ_DEFAULTS +is rarely useful because a single run of +.B xz +cannot do both compression and decompression and +.BI \-\-memlimit= limit +(or +.B \-M +.IR limit ) +is shorter to type on the command line. +.PP +If the specified memory usage limit is exceeded when decompressing, +.B xz +will display an error and decompressing the file will fail. +If the limit is exceeded when compressing, +.B xz +will try to scale the settings down so that the limit +is no longer exceeded (except when using +.B \-\-format=raw +or +.BR \-\-no\-adjust ). +This way the operation won't fail unless the limit is very small. +The scaling of the settings is done in steps that don't +match the compression level presets, for example, if the limit is +only slightly less than the amount required for +.BR "xz \-9" , +the settings will be scaled down only a little, +not all the way down to +.BR "xz \-8" . +. +.SS "Concatenation and padding with .xz files" +It is possible to concatenate +.B .xz +files as is. +.B xz +will decompress such files as if they were a single +.B .xz +file. +.PP +It is possible to insert padding between the concatenated parts +or after the last part. +The padding must consist of null bytes and the size +of the padding must be a multiple of four bytes. +This can be useful, for example, if the +.B .xz +file is stored on a medium that measures file sizes +in 512-byte blocks. +.PP +Concatenation and padding are not allowed with +.B .lzma +files or raw streams. +. +.SH OPTIONS +. +.SS "Integer suffixes and special values" +In most places where an integer argument is expected, +an optional suffix is supported to easily indicate large integers. +There must be no space between the integer and the suffix. +.TP +.B KiB +Multiply the integer by 1,024 (2^10). +.BR Ki , +.BR k , +.BR kB , +.BR K , +and +.B KB +are accepted as synonyms for +.BR KiB . +.TP +.B MiB +Multiply the integer by 1,048,576 (2^20). +.BR Mi , +.BR m , +.BR M , +and +.B MB +are accepted as synonyms for +.BR MiB . +.TP +.B GiB +Multiply the integer by 1,073,741,824 (2^30). +.BR Gi , +.BR g , +.BR G , +and +.B GB +are accepted as synonyms for +.BR GiB . +.PP +The special value +.B max +can be used to indicate the maximum integer value +supported by the option. +. +.SS "Operation mode" +If multiple operation mode options are given, +the last one takes effect. +.TP +.BR \-z ", " \-\-compress +Compress. +This is the default operation mode when no operation mode option +is specified and no other operation mode is implied from +the command name (for example, +.B unxz +implies +.BR \-\-decompress ). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +After successful compression, the source file is removed +unless writing to standard output or +.B \-\-keep +was specified. +.TP +.BR \-d ", " \-\-decompress ", " \-\-uncompress +Decompress. +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +After successful decompression, the source file is removed +unless writing to standard output or +.B \-\-keep +was specified. +.TP +.BR \-t ", " \-\-test +Test the integrity of compressed +.IR files . +This option is equivalent to +.B "\-\-decompress \-\-stdout" +except that the decompressed data is discarded instead of being +written to standard output. +No files are created or removed. +.TP +.BR \-l ", " \-\-list +Print information about compressed +.IR files . +No uncompressed output is produced, +and no files are created or removed. +In list mode, the program cannot read +the compressed data from standard +input or from other unseekable sources. +.IP "" +The default listing shows basic information about +.IR files , +one file per line. +To get more detailed information, use also the +.B \-\-verbose +option. +For even more information, use +.B \-\-verbose +twice, but note that this may be slow, because getting all the extra +information requires many seeks. +The width of verbose output exceeds +80 characters, so piping the output to, for example, +.B "less\ \-S" +may be convenient if the terminal isn't wide enough. +.IP "" +The exact output may vary between +.B xz +versions and different locales. +For machine-readable output, +.B \-\-robot \-\-list +should be used. +. +.SS "Operation modifiers" +.TP +.BR \-k ", " \-\-keep +Don't delete the input files. +.IP "" +Since +.B xz +5.2.6, +this option also makes +.B xz +compress or decompress even if the input is +a symbolic link to a regular file, +has more than one hard link, +or has the setuid, setgid, or sticky bit set. +The setuid, setgid, and sticky bits are not copied +to the target file. +In earlier versions this was only done with +.BR \-\-force . +.TP +.BR \-f ", " \-\-force +This option has several effects: +.RS +.IP \(bu 3 +If the target file already exists, +delete it before compressing or decompressing. +.IP \(bu 3 +Compress or decompress even if the input is +a symbolic link to a regular file, +has more than one hard link, +or has the setuid, setgid, or sticky bit set. +The setuid, setgid, and sticky bits are not copied +to the target file. +.IP \(bu 3 +When used with +.B \-\-decompress +.B \-\-stdout +and +.B xz +cannot recognize the type of the source file, +copy the source file as is to standard output. +This allows +.B xzcat +.B \-\-force +to be used like +.BR cat (1) +for files that have not been compressed with +.BR xz . +Note that in future, +.B xz +might support new compressed file formats, which may make +.B xz +decompress more types of files instead of copying them as is to +standard output. +.BI \-\-format= format +can be used to restrict +.B xz +to decompress only a single file format. +.RE +.TP +.BR \-c ", " \-\-stdout ", " \-\-to\-stdout +Write the compressed or decompressed data to +standard output instead of a file. +This implies +.BR \-\-keep . +.TP +.B \-\-single\-stream +Decompress only the first +.B .xz +stream, and +silently ignore possible remaining input data following the stream. +Normally such trailing garbage makes +.B xz +display an error. +.IP "" +.B xz +never decompresses more than one stream from +.B .lzma +files or raw streams, but this option still makes +.B xz +ignore the possible trailing data after the +.B .lzma +file or raw stream. +.IP "" +This option has no effect if the operation mode is not +.B \-\-decompress +or +.BR \-\-test . +.IP "" +Since +.B xz +5.7.1alpha, +.B \-\-single\-stream +implies +.BR \-\-keep . +.TP +.B \-\-no\-sparse +Disable creation of sparse files. +By default, if decompressing into a regular file, +.B xz +tries to make the file sparse if the decompressed data contains +long sequences of binary zeros. +It also works when writing to standard output +as long as standard output is connected to a regular file +and certain additional conditions are met to make it safe. +Creating sparse files may save disk space and speed up +the decompression by reducing the amount of disk I/O. +.TP +\fB\-S\fR \fI.suf\fR, \fB\-\-suffix=\fI.suf +When compressing, use +.I .suf +as the suffix for the target file instead of +.B .xz +or +.BR .lzma . +If not writing to standard output and +the source file already has the suffix +.IR .suf , +a warning is displayed and the file is skipped. +.IP "" +When decompressing, recognize files with the suffix +.I .suf +in addition to files with the +.BR .xz , +.BR .txz , +.BR .lzma , +.BR .tlz , +or +.B .lz +suffix. +If the source file has the suffix +.IR .suf , +the suffix is removed to get the target filename. +.IP "" +When compressing or decompressing raw streams +.RB ( \-\-format=raw ), +the suffix must always be specified unless +writing to standard output, +because there is no default suffix for raw streams. +.TP +\fB\-\-files\fR[\fB=\fIfile\fR] +Read the filenames to process from +.IR file ; +if +.I file +is omitted, filenames are read from standard input. +Filenames must be terminated with the newline character. +A dash +.RB ( \- ) +is taken as a regular filename; it doesn't mean standard input. +If filenames are given also as command line arguments, they are +processed before the filenames read from +.IR file . +.TP +\fB\-\-files0\fR[\fB=\fIfile\fR] +This is identical to \fB\-\-files\fR[\fB=\fIfile\fR] except +that each filename must be terminated with the null character. +. +.SS "Basic file format and compression options" +.TP +\fB\-F\fR \fIformat\fR, \fB\-\-format=\fIformat +Specify the file +.I format +to compress or decompress: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +.B auto +This is the default. +When compressing, +.B auto +is equivalent to +.BR xz . +When decompressing, +the format of the input file is automatically detected. +Note that raw streams (created with +.BR \-\-format=raw ) +cannot be auto-detected. +.TP +.B xz +Compress to the +.B .xz +file format, or accept only +.B .xz +files when decompressing. +.TP +.BR lzma ", " alone +Compress to the legacy +.B .lzma +file format, or accept only +.B .lzma +files when decompressing. +The alternative name +.B alone +is provided for backwards compatibility with LZMA Utils. +.TP +.B lzip +Accept only +.B .lz +files when decompressing. +Compression is not supported. +.IP "" +The +.B .lz +format versions 0 and 1 are supported. +Version 0 files were produced by +.B lzip +1.3 and older. +Such files aren't common but may be found from file archives +as a few source packages were released in this format. +People might have old personal files in this format too. +Decompression support for the format version 0 was removed in +.B lzip +1.18. +.B lzip +1.4 and later create files in the format version 1. +.TP +.B raw +Compress or uncompress a raw stream (no headers). +This is meant for advanced users only. +To decode raw streams, you need use +.B \-\-format=raw +and explicitly specify the filter chain, +which normally would have been stored in the container headers. +.RE +.TP +\fB\-C\fR \fIcheck\fR, \fB\-\-check=\fIcheck +Specify the type of the integrity check. +The check is calculated from the uncompressed data and +stored in the +.B .xz +file. +This option has an effect only when compressing into the +.B .xz +format; the +.B .lzma +format doesn't support integrity checks. +The integrity check (if any) is verified when the +.B .xz +file is decompressed. +.IP "" +Supported +.I check +types: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +.B none +Don't calculate an integrity check at all. +This is usually a bad idea. +This can be useful when integrity of the data is verified +by other means anyway. +.TP +.B crc32 +Calculate CRC32 using the polynomial from IEEE-802.3 (Ethernet). +.TP +.B crc64 +Calculate CRC64 using the polynomial from ECMA-182. +This is the default, since it is slightly better than CRC32 +at detecting damaged files and the speed difference is negligible. +.TP +.B sha256 +Calculate SHA-256. +This is somewhat slower than CRC32 and CRC64. +.RE +.IP "" +Integrity of the +.B .xz +headers is always verified with CRC32. +It is not possible to change or disable it. +.TP +.B \-\-ignore\-check +Don't verify the integrity check of the compressed data when decompressing. +The CRC32 values in the +.B .xz +headers will still be verified normally. +.IP "" +.B "Do not use this option unless you know what you are doing." +Possible reasons to use this option: +.RS +.IP \(bu 3 +Trying to recover data from a corrupt .xz file. +.IP \(bu 3 +Speeding up decompression. +This matters mostly with SHA-256 or +with files that have compressed extremely well. +It's recommended to not use this option for this purpose +unless the file integrity is verified externally in some other way. +.RE +.TP +.BR \-0 " ... " \-9 +Select a compression preset level. +The default is +.BR \-6 . +If multiple preset levels are specified, +the last one takes effect. +If a custom filter chain was already specified, setting +a compression preset level clears the custom filter chain. +.IP "" +The differences between the presets are more significant than with +.BR gzip (1) +and +.BR bzip2 (1). +The selected compression settings determine +the memory requirements of the decompressor, +thus using a too high preset level might make it painful +to decompress the file on an old system with little RAM. +Specifically, +.B "it's not a good idea to blindly use \-9 for everything" +like it often is with +.BR gzip (1) +and +.BR bzip2 (1). +.RS +.TP +.BR "\-0" " ... " "\-3" +These are somewhat fast presets. +.B \-0 +is sometimes faster than +.B "gzip \-9" +while compressing much better. +The higher ones often have speed comparable to +.BR bzip2 (1) +with comparable or better compression ratio, +although the results +depend a lot on the type of data being compressed. +.TP +.BR "\-4" " ... " "\-6" +Good to very good compression while keeping +decompressor memory usage reasonable even for old systems. +.B \-6 +is the default, which is usually a good choice +for distributing files that need to be decompressible +even on systems with only 16\ MiB RAM. +.RB ( \-5e +or +.B \-6e +may be worth considering too. +See +.BR \-\-extreme .) +.TP +.B "\-7 ... \-9" +These are like +.B \-6 +but with higher compressor and decompressor memory requirements. +These are useful only when compressing files bigger than +8\ MiB, 16\ MiB, and 32\ MiB, respectively. +.RE +.IP "" +On the same hardware, the decompression speed is approximately +a constant number of bytes of compressed data per second. +In other words, the better the compression, +the faster the decompression will usually be. +This also means that the amount of uncompressed output +produced per second can vary a lot. +.IP "" +The following table summarises the features of the presets: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Preset;DictSize;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Column descriptions: +.RS +.IP \(bu 3 +DictSize is the LZMA2 dictionary size. +It is waste of memory to use a dictionary bigger than +the size of the uncompressed file. +This is why it is good to avoid using the presets +.BR \-7 " ... " \-9 +when there's no real need for them. +At +.B \-6 +and lower, the amount of memory wasted is +usually low enough to not matter. +.IP \(bu 3 +CompCPU is a simplified representation of the LZMA2 settings +that affect compression speed. +The dictionary size affects speed too, +so while CompCPU is the same for levels +.BR \-6 " ... " \-9 , +higher levels still tend to be a little slower. +To get even slower and thus possibly better compression, see +.BR \-\-extreme . +.IP \(bu 3 +CompMem contains the compressor memory requirements +in the single-threaded mode. +It may vary slightly between +.B xz +versions. +.IP \(bu 3 +DecMem contains the decompressor memory requirements. +That is, the compression settings determine +the memory requirements of the decompressor. +The exact decompressor memory usage is slightly more than +the LZMA2 dictionary size, but the values in the table +have been rounded up to the next full MiB. +.RE +.IP "" +Memory requirements of the multi-threaded mode are +significantly higher than that of the single-threaded mode. +With the default value of +.BR \-\-block\-size , +each thread needs 3*3*DictSize plus CompMem or DecMem. +For example, four threads with preset +.B \-6 +needs 660\(en670\ MiB of memory. +.TP +.BR \-e ", " \-\-extreme +Use a slower variant of the selected compression preset level +.RB ( \-0 " ... " \-9 ) +to hopefully get a little bit better compression ratio, +but with bad luck this can also make it worse. +Decompressor memory usage is not affected, +but compressor memory usage increases a little at preset levels +.BR \-0 " ... " \-3 . +.IP "" +Since there are two presets with dictionary sizes +4\ MiB and 8\ MiB, the presets +.B \-3e +and +.B \-5e +use slightly faster settings (lower CompCPU) than +.B \-4e +and +.BR \-6e , +respectively. +That way no two presets are identical. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Preset;DictSize;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +For example, there are a total of four presets that use +8\ MiB dictionary, whose order from the fastest to the slowest is +.BR \-5 , +.BR \-6 , +.BR \-5e , +and +.BR \-6e . +.TP +.B \-\-fast +.PD 0 +.TP +.B \-\-best +.PD +These are somewhat misleading aliases for +.B \-0 +and +.BR \-9 , +respectively. +These are provided only for backwards compatibility +with LZMA Utils. +Avoid using these options. +.TP +.BI \-\-block\-size= size +When compressing to the +.B .xz +format, split the input data into blocks of +.I size +bytes. +The blocks are compressed independently from each other, +which helps with multi-threading and +makes limited random-access decompression possible. +This option is typically used to override the default +block size in multi-threaded mode, +but this option can be used in single-threaded mode too. +.IP "" +In multi-threaded mode about three times +.I size +bytes will be allocated in each thread for buffering input and output. +The default +.I size +is three times the LZMA2 dictionary size or 1 MiB, +whichever is more. +Typically a good value is 2\(en4 times +the size of the LZMA2 dictionary or at least 1 MiB. +Using +.I size +less than the LZMA2 dictionary size is waste of RAM +because then the LZMA2 dictionary buffer will never get fully used. +In multi-threaded mode, +the sizes of the blocks are stored in the block headers. +This size information is required for multi-threaded decompression. +.IP "" +In single-threaded mode no block splitting is done by default. +Setting this option doesn't affect memory usage. +No size information is stored in block headers, +thus files created in single-threaded mode +won't be identical to files created in multi-threaded mode. +The lack of size information also means that +.B xz +won't be able decompress the files in multi-threaded mode. +.TP +.BI \-\-block\-list= items +When compressing to the +.B .xz +format, start a new block with an optional custom filter chain after +the given intervals of uncompressed data. +.IP "" +The +.I items +are a comma-separated list. +Each item consists of an optional filter chain number +between 0 and 9 followed by a colon +.RB ( : ) +and a required size of uncompressed data. +Omitting an item (two or more consecutive commas) is a +shorthand to use the size and filters of the previous item. +.IP "" +If the input file is bigger than the sum of +the sizes in +.IR items , +the last item is repeated until the end of the file. +A special value of +.B 0 +may be used as the last size to indicate that +the rest of the file should be encoded as a single block. +.IP "" +An alternative filter chain for each block can be +specified in combination with the +.BI \-\-filters1= filters +\&...\& +.BI \-\-filters9= filters +options. +These options define filter chains with an identifier +between 1\(en9. +Filter chain 0 can be used to refer to the default filter chain, +which is the same as not specifying a filter chain. +The filter chain identifier can be used before the uncompressed +size, followed by a colon +.RB ( : ). +For example, if one specifies +.B \-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB +then blocks will be created using: +.RS +.IP \(bu 3 +The filter chain specified by +.B \-\-filters1 +and 2 MiB input +.IP \(bu 3 +The filter chain specified by +.B \-\-filters3 +and 2 MiB input +.IP \(bu 3 +The filter chain specified by +.B \-\-filters2 +and 4 MiB input +.IP \(bu 3 +The filter chain specified by +.B \-\-filters2 +and 4 MiB input +.IP \(bu 3 +The default filter chain and 2 MiB input +.IP \(bu 3 +The default filter chain and 4 MiB input for every block until +end of input. +.RE +.IP "" +If one specifies a size that exceeds the encoder's block size +(either the default value in threaded mode or +the value specified with \fB\-\-block\-size=\fIsize\fR), +the encoder will create additional blocks while +keeping the boundaries specified in +.IR items . +For example, if one specifies +.B \-\-block\-size=10MiB +.B \-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB +and the input file is 80 MiB, +one will get 11 blocks: +5, 10, 8, 10, 2, 10, 10, 4, 10, 10, and 1 MiB. +.IP "" +In multi-threaded mode the sizes of the blocks +are stored in the block headers. +This isn't done in single-threaded mode, +so the encoded output won't be +identical to that of the multi-threaded mode. +.TP +.BI \-\-flush\-timeout= timeout +When compressing, if more than +.I timeout +milliseconds (a positive integer) has passed since the previous flush and +reading more input would block, +all the pending input data is flushed from the encoder and +made available in the output stream. +This can be useful if +.B xz +is used to compress data that is streamed over a network. +Small +.I timeout +values make the data available at the receiving end +with a small delay, but large +.I timeout +values give better compression ratio. +.IP "" +This feature is disabled by default. +If this option is specified more than once, the last one takes effect. +The special +.I timeout +value of +.B 0 +can be used to explicitly disable this feature. +.IP "" +This feature is not available on non-POSIX systems. +.IP "" +.\" FIXME +.B "This feature is still experimental." +Currently +.B xz +is unsuitable for decompressing the stream in real time due to how +.B xz +does buffering. +.TP +.B \-\-no\-sync +Do not synchronize the target file and its directory +to the storage device before removing the source file. +This can improve performance if compressing or decompressing +many small files. +However, if the system crashes soon after the deletion, +it is possible that the target file was not written +to the storage device but the delete operation was. +In that case neither the original source file +nor the target file is available. +.IP "" +This option has an effect only when +.B xz +is going to remove the source file. +In other cases synchronization is never done. +.IP "" +The synchronization and +.B \-\-no\-sync +were added in +.B xz +5.7.1alpha. +.TP +.BI \-\-memlimit\-compress= limit +Set a memory usage limit for compression. +If this option is specified multiple times, +the last one takes effect. +.IP "" +If the compression settings exceed the +.IR limit , +.B xz +will attempt to adjust the settings downwards so that +the limit is no longer exceeded and display a notice that +automatic adjustment was done. +The adjustments are done in this order: +reducing the number of threads, +switching to single-threaded mode +if even one thread in multi-threaded mode exceeds the +.IR limit , +and finally reducing the LZMA2 dictionary size. +.IP "" +When compressing with +.B \-\-format=raw +or if +.B \-\-no\-adjust +has been specified, +only the number of threads may be reduced +since it can be done without affecting the compressed output. +.IP "" +If the +.I limit +cannot be met even with the adjustments described above, +an error is displayed and +.B xz +will exit with exit status 1. +.IP "" +The +.I limit +can be specified in multiple ways: +.RS +.IP \(bu 3 +The +.I limit +can be an absolute value in bytes. +Using an integer suffix like +.B MiB +can be useful. +Example: +.B "\-\-memlimit\-compress=80MiB" +.IP \(bu 3 +The +.I limit +can be specified as a percentage of total physical memory (RAM). +This can be useful especially when setting the +.B XZ_DEFAULTS +environment variable in a shell initialization script +that is shared between different computers. +That way the limit is automatically bigger +on systems with more memory. +Example: +.B "\-\-memlimit\-compress=70%" +.IP \(bu 3 +The +.I limit +can be reset back to its default value by setting it to +.BR 0 . +This is currently equivalent to setting the +.I limit +to +.B max +(no memory usage limit). +.RE +.IP "" +For 32-bit +.B xz +there is a special case: if the +.I limit +would be over +.BR "4020\ MiB" , +the +.I limit +is set to +.BR "4020\ MiB" . +On MIPS32 +.B "2000\ MiB" +is used instead. +(The values +.B 0 +and +.B max +aren't affected by this. +A similar feature doesn't exist for decompression.) +This can be helpful when a 32-bit executable has access +to 4\ GiB address space (2 GiB on MIPS32) +while hopefully doing no harm in other situations. +.IP "" +See also the section +.BR "Memory usage" . +.TP +.BI \-\-memlimit\-decompress= limit +Set a memory usage limit for decompression. +This also affects the +.B \-\-list +mode. +If the operation is not possible without exceeding the +.IR limit , +.B xz +will display an error and decompressing the file will fail. +See +.BI \-\-memlimit\-compress= limit +for possible ways to specify the +.IR limit . +.TP +.BI \-\-memlimit\-mt\-decompress= limit +Set a memory usage limit for multi-threaded decompression. +This can only affect the number of threads; +this will never make +.B xz +refuse to decompress a file. +If +.I limit +is too low to allow any multi-threading, the +.I limit +is ignored and +.B xz +will continue in single-threaded mode. +Note that if also +.B \-\-memlimit\-decompress +is used, +it will always apply to both single-threaded and multi-threaded modes, +and so the effective +.I limit +for multi-threading will never be higher than the limit set with +.BR \-\-memlimit\-decompress . +.IP "" +In contrast to the other memory usage limit options, +.BI \-\-memlimit\-mt\-decompress= limit +has a system-specific default +.IR limit . +.B "xz \-\-info\-memory" +can be used to see the current value. +.IP "" +This option and its default value exist +because without any limit the threaded decompressor +could end up allocating an insane amount of memory with some input files. +If the default +.I limit +is too low on your system, +feel free to increase the +.I limit +but never set it to a value larger than the amount of usable RAM +as with appropriate input files +.B xz +will attempt to use that amount of memory +even with a low number of threads. +Running out of memory or swapping +will not improve decompression performance. +.IP "" +See +.BI \-\-memlimit\-compress= limit +for possible ways to specify the +.IR limit . +Setting +.I limit +to +.B 0 +resets the +.I limit +to the default system-specific value. +.TP +\fB\-M\fR \fIlimit\fR, \fB\-\-memlimit=\fIlimit\fR, \fB\-\-memory=\fIlimit +This is equivalent to specifying +.BI \-\-memlimit\-compress= limit +.BI \-\-memlimit-decompress= limit +\fB\-\-memlimit\-mt\-decompress=\fIlimit\fR. +.TP +.B \-\-no\-adjust +Display an error and exit if the memory usage limit cannot be +met without adjusting settings that affect the compressed output. +That is, this prevents +.B xz +from switching the encoder from multi-threaded mode to single-threaded mode +and from reducing the LZMA2 dictionary size. +Even when this option is used the number of threads may be reduced +to meet the memory usage limit as that won't affect the compressed output. +.IP "" +Automatic adjusting is always disabled when creating raw streams +.RB ( \-\-format=raw ). +.TP +\fB\-T\fR \fIthreads\fR, \fB\-\-threads=\fIthreads +Specify the number of worker threads to use. +Setting +.I threads +to a special value +.B 0 +makes +.B xz +use up to as many threads as the processor(s) on the system support. +The actual number of threads can be fewer than +.I threads +if the input file is not big enough +for threading with the given settings or +if using more threads would exceed the memory usage limit. +.IP "" +The single-threaded and multi-threaded compressors produce different output. +Single-threaded compressor will give the smallest file size but +only the output from the multi-threaded compressor can be decompressed +using multiple threads. +Setting +.I threads +to +.B 1 +will use the single-threaded mode. +Setting +.I threads +to any other value, including +.BR 0 , +will use the multi-threaded compressor +even if the system supports only one hardware thread. +.RB ( xz +5.2.x +used single-threaded mode in this situation.) +.IP "" +To use multi-threaded mode with only one thread, set +.I threads +to +.BR +1 . +The +.B + +prefix has no effect with values other than +.BR 1 . +A memory usage limit can still make +.B xz +switch to single-threaded mode unless +.B \-\-no\-adjust +is used. +Support for the +.B + +prefix was added in +.B xz +5.4.0. +.IP "" +If an automatic number of threads has been requested and +no memory usage limit has been specified, +then a system-specific default soft limit will be used to possibly +limit the number of threads. +It is a soft limit in sense that it is ignored +if the number of threads becomes one, +thus a soft limit will never stop +.B xz +from compressing or decompressing. +This default soft limit will not make +.B xz +switch from multi-threaded mode to single-threaded mode. +The active limits can be seen with +.BR "xz \-\-info\-memory" . +.IP "" +Currently the only threading method is to split the input into +blocks and compress them independently from each other. +The default block size depends on the compression level and +can be overridden with the +.BI \-\-block\-size= size +option. +.IP "" +Threaded decompression only works on files that contain +multiple blocks with size information in block headers. +All large enough files compressed in multi-threaded mode +meet this condition, +but files compressed in single-threaded mode don't even if +.BI \-\-block\-size= size +has been used. +.IP "" +The default value for +.I threads +is +.BR 0 . +In +.B xz +5.4.x and older the default is +.BR 1 . +. +.SS "Custom compressor filter chains" +A custom filter chain allows specifying +the compression settings in detail instead of relying on +the settings associated to the presets. +When a custom filter chain is specified, +preset options +.RB ( \-0 +\&...\& +.B \-9 +and +.BR \-\-extreme ) +earlier on the command line are forgotten. +If a preset option is specified +after one or more custom filter chain options, +the new preset takes effect and +the custom filter chain options specified earlier are forgotten. +.PP +A filter chain is comparable to piping on the command line. +When compressing, the uncompressed input goes to the first filter, +whose output goes to the next filter (if any). +The output of the last filter gets written to the compressed file. +The maximum number of filters in the chain is four, +but typically a filter chain has only one or two filters. +.PP +Many filters have limitations on where they can be +in the filter chain: +some filters can work only as the last filter in the chain, +some only as a non-last filter, and some work in any position +in the chain. +Depending on the filter, this limitation is either inherent to +the filter design or exists to prevent security issues. +.PP +A custom filter chain can be specified in two different ways. +The options +.BI \-\-filters= filters +and +.BI \-\-filters1= filters +\&...\& +.BI \-\-filters9= filters +allow specifying an entire filter chain in one option using the +liblzma filter string syntax. +Alternatively, a filter chain can be specified by using one or more +individual filter options in the order they are wanted in the filter chain. +That is, the order of the individual filter options is significant! +When decoding raw streams +.RB ( \-\-format=raw ), +the filter chain must be specified in the same order as +it was specified when compressing. +Any individual filter or preset options specified before the full +chain option +(\fB\-\-filters=\fIfilters\fR) +will be forgotten. +Individual filters specified after the full chain option will reset the +filter chain. +.PP +Both the full and individual filter options take filter-specific +.I options +as a comma-separated list. +Extra commas in +.I options +are ignored. +Every option has a default value, so +specify those you want to change. +.PP +To see the whole filter chain and +.IR options , +use +.B "xz \-vv" +(that is, use +.B \-\-verbose +twice). +This works also for viewing the filter chain options used by presets. +.TP +.BI \-\-filters= filters +Specify the full filter chain or a preset in a single option. +Each filter can be separated by spaces or two dashes +.RB ( \-\- ). +.I filters +may need to be quoted on the shell command line so it is +parsed as a single option. +To denote +.IR options , +use +.B : +or +.BR = . +A preset can be prefixed with a +.B \- +and followed with zero or more flags. +The only supported flag is +.B e +to apply the same options as +.BR \-\-extreme . +.TP +\fB\-\-filters1\fR=\fIfilters\fR ... \fB\-\-filters9\fR=\fIfilters +Specify up to nine additional filter chains that can be used with +.BR \-\-block\-list . +.IP "" +For example, when compressing an archive with executable files +followed by text files, the executable part could use a filter +chain with a BCJ filter and the text part only the LZMA2 filter. +.TP +.B \-\-filters-help +Display a help message describing how to specify presets and +custom filter chains in the +.B \-\-filters +and +.BI \-\-filters1= filters +\&...\& +.BI \-\-filters9= filters +options, and exit successfully. +.TP +\fB\-\-lzma1\fR[\fB=\fIoptions\fR] +.PD 0 +.TP +\fB\-\-lzma2\fR[\fB=\fIoptions\fR] +.PD +Add LZMA1 or LZMA2 filter to the filter chain. +These filters can be used only as the last filter in the chain. +.IP "" +LZMA1 is a legacy filter, +which is supported almost solely due to the legacy +.B .lzma +file format, which supports only LZMA1. +LZMA2 is an updated +version of LZMA1 to fix some practical issues of LZMA1. +The +.B .xz +format uses LZMA2 and doesn't support LZMA1 at all. +Compression speed and ratios of LZMA1 and LZMA2 +are practically the same. +.IP "" +LZMA1 and LZMA2 share the same set of +.IR options : +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +.BI preset= preset +Reset all LZMA1 or LZMA2 +.I options +to +.IR preset . +.I Preset +consist of an integer, which may be followed by single-letter +preset modifiers. +The integer can be from +.B 0 +to +.BR 9 , +matching the command line options +.B \-0 +\&...\& +.BR \-9 . +The only supported modifier is currently +.BR e , +which matches +.BR \-\-extreme . +If no +.B preset +is specified, the default values of LZMA1 or LZMA2 +.I options +are taken from the preset +.BR 6 . +.TP +.BI dict= size +Dictionary (history buffer) +.I size +indicates how many bytes of the recently processed +uncompressed data is kept in memory. +The algorithm tries to find repeating byte sequences (matches) in +the uncompressed data, and replace them with references +to the data currently in the dictionary. +The bigger the dictionary, the higher is the chance +to find a match. +Thus, increasing dictionary +.I size +usually improves compression ratio, but +a dictionary bigger than the uncompressed file is waste of memory. +.IP "" +Typical dictionary +.I size +is from 64\ KiB to 64\ MiB. +The minimum is 4\ KiB. +The maximum for compression is currently 1.5\ GiB (1536\ MiB). +The decompressor already supports dictionaries up to +one byte less than 4\ GiB, which is the maximum for +the LZMA1 and LZMA2 stream formats. +.IP "" +Dictionary +.I size +and match finder +.RI ( mf ) +together determine the memory usage of the LZMA1 or LZMA2 encoder. +The same (or bigger) dictionary +.I size +is required for decompressing that was used when compressing, +thus the memory usage of the decoder is determined +by the dictionary size used when compressing. +The +.B .xz +headers store the dictionary +.I size +either as +.RI "2^" n +or +.RI "2^" n " + 2^(" n "\-1)," +so these +.I sizes +are somewhat preferred for compression. +Other +.I sizes +will get rounded up when stored in the +.B .xz +headers. +.TP +.BI lc= lc +Specify the number of literal context bits. +The minimum is 0 and the maximum is 4; the default is 3. +In addition, the sum of +.I lc +and +.I lp +must not exceed 4. +.IP "" +All bytes that cannot be encoded as matches +are encoded as literals. +That is, literals are simply 8-bit bytes +that are encoded one at a time. +.IP "" +The literal coding makes an assumption that the highest +.I lc +bits of the previous uncompressed byte correlate +with the next byte. +For example, in typical English text, an upper-case letter is +often followed by a lower-case letter, and a lower-case +letter is usually followed by another lower-case letter. +In the US-ASCII character set, the highest three bits are 010 +for upper-case letters and 011 for lower-case letters. +When +.I lc +is at least 3, the literal coding can take advantage of +this property in the uncompressed data. +.IP "" +The default value (3) is usually good. +If you want maximum compression, test +.BR lc=4 . +Sometimes it helps a little, and +sometimes it makes compression worse. +If it makes it worse, test +.B lc=2 +too. +.TP +.BI lp= lp +Specify the number of literal position bits. +The minimum is 0 and the maximum is 4; the default is 0. +.IP "" +.I Lp +affects what kind of alignment in the uncompressed data is +assumed when encoding literals. +See +.I pb +below for more information about alignment. +.TP +.BI pb= pb +Specify the number of position bits. +The minimum is 0 and the maximum is 4; the default is 2. +.IP "" +.I Pb +affects what kind of alignment in the uncompressed data is +assumed in general. +The default means four-byte alignment +.RI (2^ pb =2^2=4), +which is often a good choice when there's no better guess. +.IP "" +When the alignment is known, setting +.I pb +accordingly may reduce the file size a little. +For example, with text files having one-byte +alignment (US-ASCII, ISO-8859-*, UTF-8), setting +.B pb=0 +can improve compression slightly. +For UTF-16 text, +.B pb=1 +is a good choice. +If the alignment is an odd number like 3 bytes, +.B pb=0 +might be the best choice. +.IP "" +Even though the assumed alignment can be adjusted with +.I pb +and +.IR lp , +LZMA1 and LZMA2 still slightly favor 16-byte alignment. +It might be worth taking into account when designing file formats +that are likely to be often compressed with LZMA1 or LZMA2. +.TP +.BI mf= mf +Match finder has a major effect on encoder speed, +memory usage, and compression ratio. +Usually Hash Chain match finders are faster than Binary Tree +match finders. +The default depends on the +.IR preset : +0 uses +.BR hc3 , +1\(en3 +use +.BR hc4 , +and the rest use +.BR bt4 . +.IP "" +The following match finders are supported. +The memory usage formulas below are rough approximations, +which are closest to the reality when +.I dict +is a power of two. +.RS +.TP +.B hc3 +Hash Chain with 2- and 3-byte hashing +.br +Minimum value for +.IR nice : +3 +.br +Memory usage: +.br +.I dict +* 7.5 (if +.I dict +<= 16 MiB); +.br +.I dict +* 5.5 + 64 MiB (if +.I dict +> 16 MiB) +.TP +.B hc4 +Hash Chain with 2-, 3-, and 4-byte hashing +.br +Minimum value for +.IR nice : +4 +.br +Memory usage: +.br +.I dict +* 7.5 (if +.I dict +<= 32 MiB); +.br +.I dict +* 6.5 (if +.I dict +> 32 MiB) +.TP +.B bt2 +Binary Tree with 2-byte hashing +.br +Minimum value for +.IR nice : +2 +.br +Memory usage: +.I dict +* 9.5 +.TP +.B bt3 +Binary Tree with 2- and 3-byte hashing +.br +Minimum value for +.IR nice : +3 +.br +Memory usage: +.br +.I dict +* 11.5 (if +.I dict +<= 16 MiB); +.br +.I dict +* 9.5 + 64 MiB (if +.I dict +> 16 MiB) +.TP +.B bt4 +Binary Tree with 2-, 3-, and 4-byte hashing +.br +Minimum value for +.IR nice : +4 +.br +Memory usage: +.br +.I dict +* 11.5 (if +.I dict +<= 32 MiB); +.br +.I dict +* 10.5 (if +.I dict +> 32 MiB) +.RE +.TP +.BI mode= mode +Compression +.I mode +specifies the method to analyze +the data produced by the match finder. +Supported +.I modes +are +.B fast +and +.BR normal . +The default is +.B fast +for +.I presets +0\(en3 and +.B normal +for +.I presets +4\(en9. +.IP "" +Usually +.B fast +is used with Hash Chain match finders and +.B normal +with Binary Tree match finders. +This is also what the +.I presets +do. +.TP +.BI nice= nice +Specify what is considered to be a nice length for a match. +Once a match of at least +.I nice +bytes is found, the algorithm stops +looking for possibly better matches. +.IP "" +.I Nice +can be 2\(en273 bytes. +Higher values tend to give better compression ratio +at the expense of speed. +The default depends on the +.IR preset . +.TP +.BI depth= depth +Specify the maximum search depth in the match finder. +The default is the special value of 0, +which makes the compressor determine a reasonable +.I depth +from +.I mf +and +.IR nice . +.IP "" +Reasonable +.I depth +for Hash Chains is 4\(en100 and 16\(en1000 for Binary Trees. +Using very high values for +.I depth +can make the encoder extremely slow with some files. +Avoid setting the +.I depth +over 1000 unless you are prepared to interrupt +the compression in case it is taking far too long. +.RE +.IP "" +When decoding raw streams +.RB ( \-\-format=raw ), +LZMA2 needs only the dictionary +.IR size . +LZMA1 needs also +.IR lc , +.IR lp , +and +.IR pb . +.TP +\fB\-\-x86\fR[\fB=\fIoptions\fR] +.PD 0 +.TP +\fB\-\-arm\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-armthumb\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-arm64\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-powerpc\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-ia64\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-sparc\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-riscv\fR[\fB=\fIoptions\fR] +.PD +Add a branch/call/jump (BCJ) filter to the filter chain. +These filters can be used only as a non-last filter +in the filter chain. +.IP "" +A BCJ filter converts relative addresses in +the machine code to their absolute counterparts. +This doesn't change the size of the data +but it increases redundancy, +which can help LZMA2 to produce 0\(en15\ % smaller +.B .xz +file. +The BCJ filters are always reversible, +so using a BCJ filter for wrong type of data +doesn't cause any data loss, although it may make +the compression ratio slightly worse. +The BCJ filters are very fast and +use an insignificant amount of memory. +.IP "" +These BCJ filters have known problems related to +the compression ratio: +.RS +.IP \(bu 3 +Some types of files containing executable code +(for example, object files, static libraries, and Linux kernel modules) +have the addresses in the instructions filled with filler values. +These BCJ filters will still do the address conversion, +which will make the compression worse with these files. +.IP \(bu 3 +If a BCJ filter is applied on an archive, +it is possible that it makes the compression ratio +worse than not using a BCJ filter. +For example, if there are similar or even identical executables +then filtering will likely make the files less similar +and thus compression is worse. +The contents of non-executable files in the same archive can matter too. +In practice one has to try with and without a BCJ filter to see +which is better in each situation. +.RE +.IP "" +Different instruction sets have different alignment: +the executable file must be aligned to a multiple of +this value in the input data to make the filter work. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filter;Alignment;Notes +x86;1;32-bit or 64-bit x86 +ARM;4; +ARM-Thumb;2; +ARM64;4;4096-byte alignment is best +PowerPC;4;Big endian only +IA-64;16;Itanium +SPARC;4; +RISC-V;2; +.TE +.RE +.RE +.IP "" +Since the BCJ-filtered data is usually compressed with LZMA2, +the compression ratio may be improved slightly if +the LZMA2 options are set to match the +alignment of the selected BCJ filter. +Examples: +.RS +.IP \(bu 3 +IA-64 filter has 16-byte alignment so +.B pb=4,lp=4,lc=0 +is good +with LZMA2 (2^4=16). +.IP \(bu 3 +RISC-V code has 2-byte or 4-byte alignment +depending on whether the file contains +16-bit compressed instructions (the C extension). +When 16-bit instructions are used, +.B pb=2,lp=1,lc=3 +or +.B pb=1,lp=1,lc=3 +is good. +When 16-bit instructions aren't present, +.B pb=2,lp=2,lc=2 +is the best. +.B readelf \-h +can be used to check if "RVC" +appears on the "Flags" line. +.IP \(bu 3 +ARM64 is always 4-byte aligned so +.B pb=2,lp=2,lc=2 +is the best. +.IP \(bu 3 +The x86 filter is an exception. +It's usually good to stick to LZMA2's defaults +.RB ( pb=2,lp=0,lc=3 ) +when compressing x86 executables. +.RE +.IP "" +All BCJ filters support the same +.IR options : +.RS +.TP +.BI start= offset +Specify the start +.I offset +that is used when converting between relative +and absolute addresses. +The +.I offset +must be a multiple of the alignment of the filter +(see the table above). +The default is zero. +In practice, the default is good; specifying a custom +.I offset +is almost never useful. +.RE +.TP +\fB\-\-delta\fR[\fB=\fIoptions\fR] +Add the Delta filter to the filter chain. +The Delta filter can be only used as a non-last filter +in the filter chain. +.IP "" +Currently only simple byte-wise delta calculation is supported. +It can be useful when compressing, for example, uncompressed bitmap images +or uncompressed PCM audio. +However, special purpose algorithms may give significantly better +results than Delta + LZMA2. +This is true especially with audio, +which compresses faster and better, for example, with +.BR flac (1). +.IP "" +Supported +.IR options : +.RS +.TP +.BI dist= distance +Specify the +.I distance +of the delta calculation in bytes. +.I distance +must be 1\(en256. +The default is 1. +.IP "" +For example, with +.B dist=2 +and eight-byte input A1 B1 A2 B3 A3 B5 A4 B7, the output will be +A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Other options" +.TP +.BR \-q ", " \-\-quiet +Suppress warnings and notices. +Specify this twice to suppress errors too. +This option has no effect on the exit status. +That is, even if a warning was suppressed, +the exit status to indicate a warning is still used. +.TP +.BR \-v ", " \-\-verbose +Be verbose. +If standard error is connected to a terminal, +.B xz +will display a progress indicator. +Specifying +.B \-\-verbose +twice will give even more verbose output. +.IP "" +The progress indicator shows the following information: +.RS +.IP \(bu 3 +Completion percentage is shown +if the size of the input file is known. +That is, the percentage cannot be shown in pipes. +.IP \(bu 3 +Amount of compressed data produced (compressing) +or consumed (decompressing). +.IP \(bu 3 +Amount of uncompressed data consumed (compressing) +or produced (decompressing). +.IP \(bu 3 +Compression ratio, which is calculated by dividing +the amount of compressed data processed so far by +the amount of uncompressed data processed so far. +.IP \(bu 3 +Compression or decompression speed. +This is measured as the amount of uncompressed data consumed +(compression) or produced (decompression) per second. +It is shown after a few seconds have passed since +.B xz +started processing the file. +.IP \(bu 3 +Elapsed time in the format M:SS or H:MM:SS. +.IP \(bu 3 +Estimated remaining time is shown +only when the size of the input file is +known and a couple of seconds have already passed since +.B xz +started processing the file. +The time is shown in a less precise format which +never has any colons, for example, 2 min 30 s. +.RE +.IP "" +When standard error is not a terminal, +.B \-\-verbose +will make +.B xz +print the filename, compressed size, uncompressed size, +compression ratio, and possibly also the speed and elapsed time +on a single line to standard error after compressing or +decompressing the file. +The speed and elapsed time are included only when +the operation took at least a few seconds. +If the operation didn't finish, for example, due to user interruption, +also the completion percentage is printed +if the size of the input file is known. +.TP +.BR \-Q ", " \-\-no\-warn +Don't set the exit status to 2 +even if a condition worth a warning was detected. +This option doesn't affect the verbosity level, thus both +.B \-\-quiet +and +.B \-\-no\-warn +have to be used to not display warnings and +to not alter the exit status. +.TP +.B \-\-robot +Print messages in a machine-parsable format. +This is intended to ease writing frontends that want to use +.B xz +instead of liblzma, which may be the case with various scripts. +The output with this option enabled is meant to be stable across +.B xz +releases. +See the section +.B "ROBOT MODE" +for details. +.TP +.B \-\-info\-memory +Display, in human-readable format, how much physical memory (RAM) +and how many processor threads +.B xz +thinks the system has and the memory usage limits for compression +and decompression, and exit successfully. +.TP +.BR \-h ", " \-\-help +Display a help message describing the most commonly used options, +and exit successfully. +.TP +.BR \-H ", " \-\-long\-help +Display a help message describing all features of +.BR xz , +and exit successfully +.TP +.BR \-V ", " \-\-version +Display the version number of +.B xz +and liblzma in human readable format. +To get machine-parsable output, specify +.B \-\-robot +before +.BR \-\-version . +. +.SH "ROBOT MODE" +The robot mode is activated with the +.B \-\-robot +option. +It makes the output of +.B xz +easier to parse by other programs. +Currently +.B \-\-robot +is supported only together with +.BR \-\-list , +.BR \-\-filters\-help , +.BR \-\-info\-memory , +and +.BR \-\-version . +It will be supported for compression and +decompression in the future. +. +.SS "List mode" +.B "xz \-\-robot \-\-list" +uses tab-separated output. +The first column of every line has a string +that indicates the type of the information found on that line: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +.B name +This is always the first line when starting to list a file. +The second column on the line is the filename. +.TP +.B file +This line contains overall information about the +.B .xz +file. +This line is always printed after the +.B name +line. +.TP +.B stream +This line type is used only when +.B \-\-verbose +was specified. +There are as many +.B stream +lines as there are streams in the +.B .xz +file. +.TP +.B block +This line type is used only when +.B \-\-verbose +was specified. +There are as many +.B block +lines as there are blocks in the +.B .xz +file. +The +.B block +lines are shown after all the +.B stream +lines; different line types are not interleaved. +.TP +.B summary +This line type is used only when +.B \-\-verbose +was specified twice. +This line is printed after all +.B block +lines. +Like the +.B file +line, the +.B summary +line contains overall information about the +.B .xz +file. +.TP +.B totals +This line is always the very last line of the list output. +It shows the total counts and sizes. +.PP +The columns of the +.B file +lines: +.PD 0 +.RS +.IP 2. 4 +Number of streams in the file +.IP 3. 4 +Total number of blocks in the stream(s) +.IP 4. 4 +Compressed size of the file +.IP 5. 4 +Uncompressed size of the file +.IP 6. 4 +Compression ratio, for example, +.BR 0.123 . +If ratio is over 9.999, three dashes +.RB ( \-\-\- ) +are displayed instead of the ratio. +.IP 7. 4 +Comma-separated list of integrity check names. +The following strings are used for the known check types: +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +.BR None , +.BR CRC32 , +.BR CRC64 , +and +.BR SHA\-256 . +For unknown check types, +.BI Unknown\- N +is used, where +.I N +is the Check ID as a decimal number (one or two digits). +.IP 8. 4 +Total size of stream padding in the file +.RE +.PD +.PP +The columns of the +.B stream +lines: +.PD 0 +.RS +.IP 2. 4 +Stream number (the first stream is 1) +.IP 3. 4 +Number of blocks in the stream +.IP 4. 4 +Compressed start offset +.IP 5. 4 +Uncompressed start offset +.IP 6. 4 +Compressed size (does not include stream padding) +.IP 7. 4 +Uncompressed size +.IP 8. 4 +Compression ratio +.IP 9. 4 +Name of the integrity check +.IP 10. 4 +Size of stream padding +.RE +.PD +.PP +The columns of the +.B block +lines: +.PD 0 +.RS +.IP 2. 4 +Number of the stream containing this block +.IP 3. 4 +Block number relative to the beginning of the stream +(the first block is 1) +.IP 4. 4 +Block number relative to the beginning of the file +.IP 5. 4 +Compressed start offset relative to the beginning of the file +.IP 6. 4 +Uncompressed start offset relative to the beginning of the file +.IP 7. 4 +Total compressed size of the block (includes headers) +.IP 8. 4 +Uncompressed size +.IP 9. 4 +Compression ratio +.IP 10. 4 +Name of the integrity check +.RE +.PD +.PP +If +.B \-\-verbose +was specified twice, additional columns are included on the +.B block +lines. +These are not displayed with a single +.BR \-\-verbose , +because getting this information requires many seeks +and can thus be slow: +.PD 0 +.RS +.IP 11. 4 +Value of the integrity check in hexadecimal +.IP 12. 4 +Block header size +.IP 13. 4 +Block flags: +.B c +indicates that compressed size is present, and +.B u +indicates that uncompressed size is present. +If the flag is not set, a dash +.RB ( \- ) +is shown instead to keep the string length fixed. +New flags may be added to the end of the string in the future. +.IP 14. 4 +Size of the actual compressed data in the block (this excludes +the block header, block padding, and check fields) +.IP 15. 4 +Amount of memory (in bytes) required to decompress +this block with this +.B xz +version +.IP 16. 4 +Filter chain. +Note that most of the options used at compression time +cannot be known, because only the options +that are needed for decompression are stored in the +.B .xz +headers. +.RE +.PD +.PP +The columns of the +.B summary +lines: +.PD 0 +.RS +.IP 2. 4 +Amount of memory (in bytes) required to decompress +this file with this +.B xz +version +.IP 3. 4 +.B yes +or +.B no +indicating if all block headers have both compressed size and +uncompressed size stored in them +.PP +.I Since +.B xz +.I 5.1.2alpha: +.IP 4. 4 +Minimum +.B xz +version required to decompress the file +.RE +.PD +.PP +The columns of the +.B totals +line: +.PD 0 +.RS +.IP 2. 4 +Number of streams +.IP 3. 4 +Number of blocks +.IP 4. 4 +Compressed size +.IP 5. 4 +Uncompressed size +.IP 6. 4 +Average compression ratio +.IP 7. 4 +Comma-separated list of integrity check names +that were present in the files +.IP 8. 4 +Stream padding size +.IP 9. 4 +Number of files. +This is here to +keep the order of the earlier columns the same as on +.B file +lines. +.PD +.RE +.PP +If +.B \-\-verbose +was specified twice, additional columns are included on the +.B totals +line: +.PD 0 +.RS +.IP 10. 4 +Maximum amount of memory (in bytes) required to decompress +the files with this +.B xz +version +.IP 11. 4 +.B yes +or +.B no +indicating if all block headers have both compressed size and +uncompressed size stored in them +.PP +.I Since +.B xz +.I 5.1.2alpha: +.IP 12. 4 +Minimum +.B xz +version required to decompress the file +.RE +.PD +.PP +Future versions may add new line types and +new columns can be added to the existing line types, +but the existing columns won't be changed. +. +.SS "Filters help" +.B "xz \-\-robot \-\-filters-help" +prints the supported filters in the following format: +.PP +\fIfilter\fB:\fIoption\fB=<\fIvalue\fB>,\fIoption\fB=<\fIvalue\fB>\fR... +.TP +.I filter +Name of the filter +.TP +.I option +Name of a filter specific option +.TP +.I value +Numeric +.I value +ranges appear as +\fB<\fImin\fB\-\fImax\fB>\fR. +String +.I value +choices are shown within +.B "< >" +and separated by a +.B | +character. +.PP +Each filter is printed on its own line. +. +.SS "Memory limit information" +.B "xz \-\-robot \-\-info\-memory" +prints a single line with multiple tab-separated columns: +.IP 1. 4 +Total amount of physical memory (RAM) in bytes. +.IP 2. 4 +Memory usage limit for compression in bytes +.RB ( \-\-memlimit\-compress ). +A special value of +.B 0 +indicates the default setting +which for single-threaded mode is the same as no limit. +.IP 3. 4 +Memory usage limit for decompression in bytes +.RB ( \-\-memlimit\-decompress ). +A special value of +.B 0 +indicates the default setting +which for single-threaded mode is the same as no limit. +.IP 4. 4 +Since +.B xz +5.3.4alpha: +Memory usage for multi-threaded decompression in bytes +.RB ( \-\-memlimit\-mt\-decompress ). +This is never zero because a system-specific default value +shown in the column 5 +is used if no limit has been specified explicitly. +This is also never greater than the value in the column 3 +even if a larger value has been specified with +.BR \-\-memlimit\-mt\-decompress . +.IP 5. 4 +Since +.B xz +5.3.4alpha: +A system-specific default memory usage limit +that is used to limit the number of threads +when compressing with an automatic number of threads +.RB ( \-\-threads=0 ) +and no memory usage limit has been specified +.RB ( \-\-memlimit\-compress ). +This is also used as the default value for +.BR \-\-memlimit\-mt\-decompress . +.IP 6. 4 +Since +.B xz +5.3.4alpha: +Number of available processor threads. +.PP +In the future, the output of +.B "xz \-\-robot \-\-info\-memory" +may have more columns, but never more than a single line. +. +.SS Version +.B "xz \-\-robot \-\-version" +prints the version number of +.B xz +and liblzma in the following format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +.BI XZ_VERSION= XYYYZZZS +.br +.BI LIBLZMA_VERSION= XYYYZZZS +.TP +.I X +Major version. +.TP +.I YYY +Minor version. +Even numbers are stable. +Odd numbers are alpha or beta versions. +.TP +.I ZZZ +Patch level for stable releases or +just a counter for development releases. +.TP +.I S +Stability. +0 is alpha, 1 is beta, and 2 is stable. +.I S +should be always 2 when +.I YYY +is even. +.PP +.I XYYYZZZS +are the same on both lines if +.B xz +and liblzma are from the same XZ Utils release. +.PP +Examples: 4.999.9beta is +.B 49990091 +and +5.0.0 is +.BR 50000002 . +. +.SH "EXIT STATUS" +.TP +.B 0 +All is good. +.TP +.B 1 +An error occurred. +.TP +.B 2 +Something worth a warning occurred, +but no actual errors occurred. +.PP +Notices (not warnings or errors) printed on standard error +don't affect the exit status. +. +.SH ENVIRONMENT +.B xz +parses space-separated lists of options +from the environment variables +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +.B XZ_DEFAULTS +and +.BR XZ_OPT , +in this order, before parsing the options from the command line. +Note that only options are parsed from the environment variables; +all non-options are silently ignored. +Parsing is done with +.BR getopt_long (3) +which is used also for the command line arguments. +.PP +.B Warning: +By setting these environment variables, +one is effectively modifying programs and scripts that run +.BR xz . +Most of the time it is safe to set memory usage limits, number of threads, +and compression options via the environment variables. +However, some options can break scripts. +An obvious example is +.B \-\-help +which makes +.B xz +show the help text instead of compressing or decompressing a file. +More subtle examples are +.B \-\-quiet +and +.BR \-\-verbose . +In many cases it works well to enable the progress indicator using +.BR \-\-verbose , +but in some situations the extra messages create problems. +The verbosity level also affects the behavior of +.BR \-\-list . +.TP +.B XZ_DEFAULTS +User-specific or system-wide default options. +Typically this is set in a shell initialization script to enable +.BR xz 's +memory usage limiter by default or set the default number of threads. +Excluding shell initialization scripts +and similar special cases, scripts should never set or unset +.BR XZ_DEFAULTS . +.TP +.B XZ_OPT +This is for passing options to +.B xz +when it is not possible to set the options directly on the +.B xz +command line. +This is the case when +.B xz +is run by a script or tool, for example, GNU +.BR tar (1): +.RS +.RS +.PP +.nf +.ft CR +XZ_OPT=\-2v tar caf foo.tar.xz foo +.ft R +.fi +.RE +.RE +.IP "" +Scripts may use +.BR XZ_OPT , +for example, to set script-specific default compression options. +It is still recommended to allow users to override +.B XZ_OPT +if that is reasonable. +For example, in +.BR sh (1) +scripts one may use something like this: +.RS +.RS +.PP +.nf +.ft CR +XZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT +.ft R +.fi +.RE +.RE +. +.SH "LZMA UTILS COMPATIBILITY" +The command line syntax of +.B xz +is practically a superset of +.BR lzma , +.BR unlzma , +and +.B lzcat +as found from LZMA Utils 4.32.x. +In most cases, it is possible to replace +LZMA Utils with XZ Utils without breaking existing scripts. +There are some incompatibilities though, +which may sometimes cause problems. +. +.SS "Compression preset levels" +The numbering of the compression level presets is not identical in +.B xz +and LZMA Utils. +The most important difference is how dictionary sizes +are mapped to different presets. +Dictionary size is roughly equal to the decompressor memory usage. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Level;xz;LZMA Utils +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +The dictionary size differences affect +the compressor memory usage too, +but there are some other differences between +LZMA Utils and XZ Utils, which +make the difference even bigger: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Level;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +The default preset level in LZMA Utils is +.B \-7 +while in XZ Utils it is +.BR \-6 , +so both use an 8 MiB dictionary by default. +. +.SS "Streamed vs. non-streamed .lzma files" +The uncompressed size of the file can be stored in the +.B .lzma +header. +LZMA Utils does that when compressing regular files. +The alternative is to mark that uncompressed size is unknown +and use end-of-payload marker to indicate +where the decompressor should stop. +LZMA Utils uses this method when uncompressed size isn't known, +which is the case, for example, in pipes. +.PP +.B xz +supports decompressing +.B .lzma +files with or without end-of-payload marker, but all +.B .lzma +files created by +.B xz +will use end-of-payload marker and have uncompressed size +marked as unknown in the +.B .lzma +header. +This may be a problem in some uncommon situations. +For example, a +.B .lzma +decompressor in an embedded device might work +only with files that have known uncompressed size. +If you hit this problem, you need to use LZMA Utils +or LZMA SDK to create +.B .lzma +files with known uncompressed size. +. +.SS "Unsupported .lzma files" +The +.B .lzma +format allows +.I lc +values up to 8, and +.I lp +values up to 4. +LZMA Utils can decompress files with any +.I lc +and +.IR lp , +but always creates files with +.B lc=3 +and +.BR lp=0 . +Creating files with other +.I lc +and +.I lp +is possible with +.B xz +and with LZMA SDK. +.PP +The implementation of the LZMA1 filter in liblzma +requires that the sum of +.I lc +and +.I lp +must not exceed 4. +Thus, +.B .lzma +files, which exceed this limitation, cannot be decompressed with +.BR xz . +.PP +LZMA Utils creates only +.B .lzma +files which have a dictionary size of +.RI "2^" n +(a power of 2) but accepts files with any dictionary size. +liblzma accepts only +.B .lzma +files which have a dictionary size of +.RI "2^" n +or +.RI "2^" n " + 2^(" n "\-1)." +This is to decrease false positives when detecting +.B .lzma +files. +.PP +These limitations shouldn't be a problem in practice, +since practically all +.B .lzma +files have been compressed with settings that liblzma will accept. +. +.SS "Trailing garbage" +When decompressing, +LZMA Utils silently ignore everything after the first +.B .lzma +stream. +In most situations, this is a bug. +This also means that LZMA Utils +don't support decompressing concatenated +.B .lzma +files. +.PP +If there is data left after the first +.B .lzma +stream, +.B xz +considers the file to be corrupt unless +.B \-\-single\-stream +was used. +This may break obscure scripts which have +assumed that trailing garbage is ignored. +. +.SH NOTES +. +.SS "Compressed output may vary" +The exact compressed output produced from +the same uncompressed input file +may vary between XZ Utils versions even if +compression options are identical. +This is because the encoder can be improved +(faster or better compression) +without affecting the file format. +The output can vary even between different +builds of the same XZ Utils version, +if different build options are used. +.PP +The above means that once +.B \-\-rsyncable +has been implemented, +the resulting files won't necessarily be rsyncable +unless both old and new files have been compressed +with the same xz version. +This problem can be fixed if a part of the encoder +implementation is frozen to keep rsyncable output +stable across xz versions. +. +.SS "Embedded .xz decompressors" +Embedded +.B .xz +decompressor implementations like XZ Embedded don't necessarily +support files created with integrity +.I check +types other than +.B none +and +.BR crc32 . +Since the default is +.BR \-\-check=crc64 , +you must use +.B \-\-check=none +or +.B \-\-check=crc32 +when creating files for embedded systems. +.PP +Outside embedded systems, all +.B .xz +format decompressors support all the +.I check +types, or at least are able to decompress +the file without verifying the +integrity check if the particular +.I check +is not supported. +.PP +XZ Embedded supports BCJ filters, +but only with the default start offset. +. +.SH EXAMPLES +. +.SS Basics +Compress the file +.I foo +into +.I foo.xz +using the default compression level +.RB ( \-6 ), +and remove +.I foo +if compression is successful: +.RS +.PP +.nf +.ft CR +xz foo +.ft R +.fi +.RE +.PP +Decompress +.I bar.xz +into +.I bar +and don't remove +.I bar.xz +even if decompression is successful: +.RS +.PP +.nf +.ft CR +xz \-dk bar.xz +.ft R +.fi +.RE +.PP +Create +.I baz.tar.xz +with the preset +.B \-4e +.RB ( "\-4 \-\-extreme" ), +which is slower than the default +.BR \-6 , +but needs less memory for compression and decompression (48\ MiB +and 5\ MiB, respectively): +.RS +.PP +.nf +.ft CR +tar cf \- baz | xz \-4e > baz.tar.xz +.ft R +.fi +.RE +.PP +A mix of compressed and uncompressed files can be decompressed +to standard output with a single command: +.RS +.PP +.nf +.ft CR +xz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt +.ft R +.fi +.RE +. +.SS "Parallel compression of many files" +On GNU and *BSD, +.BR find (1) +and +.BR xargs (1) +can be used to parallelize compression of many files: +.RS +.PP +.nf +.ft CR +find . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1 +.ft R +.fi +.RE +.PP +The +.B \-P +option to +.BR xargs (1) +sets the number of parallel +.B xz +processes. +The best value for the +.B \-n +option depends on how many files there are to be compressed. +If there are only a couple of files, +the value should probably be 1; +with tens of thousands of files, +100 or even more may be appropriate to reduce the number of +.B xz +processes that +.BR xargs (1) +will eventually create. +.PP +The option +.B \-T1 +for +.B xz +is there to force it to single-threaded mode, because +.BR xargs (1) +is used to control the amount of parallelization. +. +.SS "Robot mode" +Calculate how many bytes have been saved in total +after compressing multiple files: +.RS +.PP +.nf +.ft CR +xz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}' +.ft R +.fi +.RE +.PP +A script may want to know that it is using new enough +.BR xz . +The following +.BR sh (1) +script checks that the version number of the +.B xz +tool is at least 5.0.0. +This method is compatible with old beta versions, +which didn't support the +.B \-\-robot +option: +.RS +.PP +.nf +.ft CR +if ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION +.ft R +.fi +.RE +.PP +Set a memory usage limit for decompression using +.BR XZ_OPT , +but if a limit has already been set, don't increase it: +.RS +.PP +.nf +.ft CR +NEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi +.ft R +.fi +.RE +. +.SS "Custom compressor filter chains" +The simplest use for custom filter chains is +customizing a LZMA2 preset. +This can be useful, +because the presets cover only a subset of the +potentially useful combinations of compression settings. +.PP +The CompCPU columns of the tables +from the descriptions of the options +.BR "\-0" " ... " "\-9" +and +.B \-\-extreme +are useful when customizing LZMA2 presets. +Here are the relevant parts collected from those two tables: +.RS +.PP +.TS +tab(;); +c c +n n. +Preset;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +If you know that a file requires +somewhat big dictionary (for example, 32\ MiB) to compress well, +but you want to compress it quicker than +.B "xz \-8" +would do, a preset with a low CompCPU value (for example, 1) +can be modified to use a bigger dictionary: +.RS +.PP +.nf +.ft CR +xz \-\-lzma2=preset=1,dict=32MiB foo.tar +.ft R +.fi +.RE +.PP +With certain files, the above command may be faster than +.B "xz \-6" +while compressing significantly better. +However, it must be emphasized that only some files benefit from +a big dictionary while keeping the CompCPU value low. +The most obvious situation, +where a big dictionary can help a lot, +is an archive containing very similar files +of at least a few megabytes each. +The dictionary size has to be significantly bigger +than any individual file to allow LZMA2 to take +full advantage of the similarities between consecutive files. +.PP +If very high compressor and decompressor memory usage is fine, +and the file being compressed is +at least several hundred megabytes, it may be useful +to use an even bigger dictionary than the 64 MiB that +.B "xz \-9" +would use: +.RS +.PP +.nf +.ft CR +xz \-vv \-\-lzma2=dict=192MiB big_foo.tar +.ft R +.fi +.RE +.PP +Using +.B \-vv +.RB ( "\-\-verbose \-\-verbose" ) +like in the above example can be useful +to see the memory requirements +of the compressor and decompressor. +Remember that using a dictionary bigger than +the size of the uncompressed file is waste of memory, +so the above command isn't useful for small files. +.PP +Sometimes the compression time doesn't matter, +but the decompressor memory usage has to be kept low, for example, +to make it possible to decompress the file on an embedded system. +The following command uses +.B \-6e +.RB ( "\-6 \-\-extreme" ) +as a base and sets the dictionary to only 64\ KiB. +The resulting file can be decompressed with XZ Embedded +(that's why there is +.BR \-\-check=crc32 ) +using about 100\ KiB of memory. +.RS +.PP +.nf +.ft CR +xz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo +.ft R +.fi +.RE +.PP +If you want to squeeze out as many bytes as possible, +adjusting the number of literal context bits +.RI ( lc ) +and number of position bits +.RI ( pb ) +can sometimes help. +Adjusting the number of literal position bits +.RI ( lp ) +might help too, but usually +.I lc +and +.I pb +are more important. +For example, a source code archive contains mostly US-ASCII text, +so something like the following might give +slightly (like 0.1\ %) smaller file than +.B "xz \-6e" +(try also without +.BR lc=4 ): +.RS +.PP +.nf +.ft CR +xz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar +.ft R +.fi +.RE +.PP +Using another filter together with LZMA2 can improve +compression with certain file types. +For example, to compress a x86-32 or x86-64 shared library +using the x86 BCJ filter: +.RS +.PP +.nf +.ft CR +xz \-\-x86 \-\-lzma2 libfoo.so +.ft R +.fi +.RE +.PP +Note that the order of the filter options is significant. +If +.B \-\-x86 +is specified after +.BR \-\-lzma2 , +.B xz +will give an error, +because there cannot be any filter after LZMA2, +and also because the x86 BCJ filter cannot be used +as the last filter in the chain. +.PP +The Delta filter together with LZMA2 +can give good results with bitmap images. +It should usually beat PNG, +which has a few more advanced filters than simple +delta but uses Deflate for the actual compression. +.PP +The image has to be saved in uncompressed format, +for example, as uncompressed TIFF. +The distance parameter of the Delta filter is set +to match the number of bytes per pixel in the image. +For example, 24-bit RGB bitmap needs +.BR dist=3 , +and it is also good to pass +.B pb=0 +to LZMA2 to accommodate the three-byte alignment: +.RS +.PP +.nf +.ft CR +xz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff +.ft R +.fi +.RE +.PP +If multiple images have been put into a single archive (for example, +.BR .tar ), +the Delta filter will work on that too as long as all images +have the same number of bytes per pixel. +. +.SH "SEE ALSO" +.BR xzdec (1), +.BR xzdiff (1), +.BR xzgrep (1), +.BR xzless (1), +.BR xzmore (1), +.BR gzip (1), +.BR bzip2 (1), +.BR 7z (1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xz.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xz.1 new file mode 100644 index 0000000000000000000000000000000000000000..6e37b426a3b5c85552cf006f388c9a71d4ad5685 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xz.1 @@ -0,0 +1,3264 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.TH XZ 1 "2025-03-08" "Tukaani" "XZ Utils" +. +.SH NAME +xz, unxz, xzcat, lzma, unlzma, lzcat \- Compress or decompress .xz and .lzma files +. +.SH SYNOPSIS +.B xz +.RI [ option... ] +.RI [ file... ] +. +.SH COMMAND ALIASES +.B unxz +is equivalent to +.BR "xz \-\-decompress" . +.br +.B xzcat +is equivalent to +.BR "xz \-\-decompress \-\-stdout" . +.br +.B lzma +is equivalent to +.BR "xz \-\-format=lzma" . +.br +.B unlzma +is equivalent to +.BR "xz \-\-format=lzma \-\-decompress" . +.br +.B lzcat +is equivalent to +.BR "xz \-\-format=lzma \-\-decompress \-\-stdout" . +.PP +When writing scripts that need to decompress files, +it is recommended to always use the name +.B xz +with appropriate arguments +.RB ( "xz \-d" +or +.BR "xz \-dc" ) +instead of the names +.B unxz +and +.BR xzcat . +. +.SH DESCRIPTION +.B xz +is a general-purpose data compression tool with +command line syntax similar to +.BR gzip (1) +and +.BR bzip2 (1). +The native file format is the +.B .xz +format, but the legacy +.B .lzma +format used by LZMA Utils and +raw compressed streams with no container format headers +are also supported. +In addition, decompression of the +.B .lz +format used by +.B lzip +is supported. +.PP +.B xz +compresses or decompresses each +.I file +according to the selected operation mode. +If no +.I files +are given or +.I file +is +.BR \- , +.B xz +reads from standard input and writes the processed data +to standard output. +.B xz +will refuse (display an error and skip the +.IR file ) +to write compressed data to standard output if it is a terminal. +Similarly, +.B xz +will refuse to read compressed data +from standard input if it is a terminal. +.PP +Unless +.B \-\-stdout +is specified, +.I files +other than +.B \- +are written to a new file whose name is derived from the source +.I file +name: +.IP \(bu 3 +When compressing, the suffix of the target file format +.RB ( .xz +or +.BR .lzma ) +is appended to the source filename to get the target filename. +.IP \(bu 3 +When decompressing, the +.BR .xz , +.BR .lzma , +or +.B .lz +suffix is removed from the filename to get the target filename. +.B xz +also recognizes the suffixes +.B .txz +and +.BR .tlz , +and replaces them with the +.B .tar +suffix. +.PP +If the target file already exists, an error is displayed and the +.I file +is skipped. +.PP +Unless writing to standard output, +.B xz +will display a warning and skip the +.I file +if any of the following applies: +.IP \(bu 3 +.I File +is not a regular file. +Symbolic links are not followed, +and thus they are not considered to be regular files. +.IP \(bu 3 +.I File +has more than one hard link. +.IP \(bu 3 +.I File +has setuid, setgid, or sticky bit set. +.IP \(bu 3 +The operation mode is set to compress and the +.I file +already has a suffix of the target file format +.RB ( .xz +or +.B .txz +when compressing to the +.B .xz +format, and +.B .lzma +or +.B .tlz +when compressing to the +.B .lzma +format). +.IP \(bu 3 +The operation mode is set to decompress and the +.I file +doesn't have a suffix of any of the supported file formats +.RB ( .xz , +.BR .txz , +.BR .lzma , +.BR .tlz , +or +.BR .lz ). +.PP +After successfully compressing or decompressing the +.IR file , +.B xz +copies the owner, group, permissions, access time, +and modification time from the source +.I file +to the target file. +If copying the group fails, the permissions are modified +so that the target file doesn't become accessible to users +who didn't have permission to access the source +.IR file . +.B xz +doesn't support copying other metadata like access control lists +or extended attributes yet. +.PP +Once the target file has been successfully closed, the source +.I file +is removed unless +.B \-\-keep +was specified. +The source +.I file +is never removed if the output is written to standard output +or if an error occurs. +.PP +Sending +.B SIGINFO +or +.B SIGUSR1 +to the +.B xz +process makes it print progress information to standard error. +This has only limited use since when standard error +is a terminal, using +.B \-\-verbose +will display an automatically updating progress indicator. +. +.SS "Memory usage" +The memory usage of +.B xz +varies from a few hundred kilobytes to several gigabytes +depending on the compression settings. +The settings used when compressing a file determine +the memory requirements of the decompressor. +Typically the decompressor needs 5\ % to 20\ % of +the amount of memory that the compressor needed when +creating the file. +For example, decompressing a file created with +.B xz \-9 +currently requires 65\ MiB of memory. +Still, it is possible to have +.B .xz +files that require several gigabytes of memory to decompress. +.PP +Especially users of older systems may find +the possibility of very large memory usage annoying. +To prevent uncomfortable surprises, +.B xz +has a built-in memory usage limiter, which is disabled by default. +While some operating systems provide ways to limit +the memory usage of processes, relying on it +wasn't deemed to be flexible enough (for example, using +.BR ulimit (1) +to limit virtual memory tends to cripple +.BR mmap (2)). +.PP +The memory usage limiter can be enabled with +the command line option \fB\-\-memlimit=\fIlimit\fR. +Often it is more convenient to enable the limiter +by default by setting the environment variable +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +.BR XZ_DEFAULTS , +for example, +.BR XZ_DEFAULTS=\-\-memlimit=150MiB . +It is possible to set the limits separately +for compression and decompression by using +.BI \-\-memlimit\-compress= limit +and \fB\-\-memlimit\-decompress=\fIlimit\fR. +Using these two options outside +.B XZ_DEFAULTS +is rarely useful because a single run of +.B xz +cannot do both compression and decompression and +.BI \-\-memlimit= limit +(or +.B \-M +.IR limit ) +is shorter to type on the command line. +.PP +If the specified memory usage limit is exceeded when decompressing, +.B xz +will display an error and decompressing the file will fail. +If the limit is exceeded when compressing, +.B xz +will try to scale the settings down so that the limit +is no longer exceeded (except when using +.B \-\-format=raw +or +.BR \-\-no\-adjust ). +This way the operation won't fail unless the limit is very small. +The scaling of the settings is done in steps that don't +match the compression level presets, for example, if the limit is +only slightly less than the amount required for +.BR "xz \-9" , +the settings will be scaled down only a little, +not all the way down to +.BR "xz \-8" . +. +.SS "Concatenation and padding with .xz files" +It is possible to concatenate +.B .xz +files as is. +.B xz +will decompress such files as if they were a single +.B .xz +file. +.PP +It is possible to insert padding between the concatenated parts +or after the last part. +The padding must consist of null bytes and the size +of the padding must be a multiple of four bytes. +This can be useful, for example, if the +.B .xz +file is stored on a medium that measures file sizes +in 512-byte blocks. +.PP +Concatenation and padding are not allowed with +.B .lzma +files or raw streams. +. +.SH OPTIONS +. +.SS "Integer suffixes and special values" +In most places where an integer argument is expected, +an optional suffix is supported to easily indicate large integers. +There must be no space between the integer and the suffix. +.TP +.B KiB +Multiply the integer by 1,024 (2^10). +.BR Ki , +.BR k , +.BR kB , +.BR K , +and +.B KB +are accepted as synonyms for +.BR KiB . +.TP +.B MiB +Multiply the integer by 1,048,576 (2^20). +.BR Mi , +.BR m , +.BR M , +and +.B MB +are accepted as synonyms for +.BR MiB . +.TP +.B GiB +Multiply the integer by 1,073,741,824 (2^30). +.BR Gi , +.BR g , +.BR G , +and +.B GB +are accepted as synonyms for +.BR GiB . +.PP +The special value +.B max +can be used to indicate the maximum integer value +supported by the option. +. +.SS "Operation mode" +If multiple operation mode options are given, +the last one takes effect. +.TP +.BR \-z ", " \-\-compress +Compress. +This is the default operation mode when no operation mode option +is specified and no other operation mode is implied from +the command name (for example, +.B unxz +implies +.BR \-\-decompress ). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +After successful compression, the source file is removed +unless writing to standard output or +.B \-\-keep +was specified. +.TP +.BR \-d ", " \-\-decompress ", " \-\-uncompress +Decompress. +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +After successful decompression, the source file is removed +unless writing to standard output or +.B \-\-keep +was specified. +.TP +.BR \-t ", " \-\-test +Test the integrity of compressed +.IR files . +This option is equivalent to +.B "\-\-decompress \-\-stdout" +except that the decompressed data is discarded instead of being +written to standard output. +No files are created or removed. +.TP +.BR \-l ", " \-\-list +Print information about compressed +.IR files . +No uncompressed output is produced, +and no files are created or removed. +In list mode, the program cannot read +the compressed data from standard +input or from other unseekable sources. +.IP "" +The default listing shows basic information about +.IR files , +one file per line. +To get more detailed information, use also the +.B \-\-verbose +option. +For even more information, use +.B \-\-verbose +twice, but note that this may be slow, because getting all the extra +information requires many seeks. +The width of verbose output exceeds +80 characters, so piping the output to, for example, +.B "less\ \-S" +may be convenient if the terminal isn't wide enough. +.IP "" +The exact output may vary between +.B xz +versions and different locales. +For machine-readable output, +.B \-\-robot \-\-list +should be used. +. +.SS "Operation modifiers" +.TP +.BR \-k ", " \-\-keep +Don't delete the input files. +.IP "" +Since +.B xz +5.2.6, +this option also makes +.B xz +compress or decompress even if the input is +a symbolic link to a regular file, +has more than one hard link, +or has the setuid, setgid, or sticky bit set. +The setuid, setgid, and sticky bits are not copied +to the target file. +In earlier versions this was only done with +.BR \-\-force . +.TP +.BR \-f ", " \-\-force +This option has several effects: +.RS +.IP \(bu 3 +If the target file already exists, +delete it before compressing or decompressing. +.IP \(bu 3 +Compress or decompress even if the input is +a symbolic link to a regular file, +has more than one hard link, +or has the setuid, setgid, or sticky bit set. +The setuid, setgid, and sticky bits are not copied +to the target file. +.IP \(bu 3 +When used with +.B \-\-decompress +.B \-\-stdout +and +.B xz +cannot recognize the type of the source file, +copy the source file as is to standard output. +This allows +.B xzcat +.B \-\-force +to be used like +.BR cat (1) +for files that have not been compressed with +.BR xz . +Note that in future, +.B xz +might support new compressed file formats, which may make +.B xz +decompress more types of files instead of copying them as is to +standard output. +.BI \-\-format= format +can be used to restrict +.B xz +to decompress only a single file format. +.RE +.TP +.BR \-c ", " \-\-stdout ", " \-\-to\-stdout +Write the compressed or decompressed data to +standard output instead of a file. +This implies +.BR \-\-keep . +.TP +.B \-\-single\-stream +Decompress only the first +.B .xz +stream, and +silently ignore possible remaining input data following the stream. +Normally such trailing garbage makes +.B xz +display an error. +.IP "" +.B xz +never decompresses more than one stream from +.B .lzma +files or raw streams, but this option still makes +.B xz +ignore the possible trailing data after the +.B .lzma +file or raw stream. +.IP "" +This option has no effect if the operation mode is not +.B \-\-decompress +or +.BR \-\-test . +.IP "" +Since +.B xz +5.7.1alpha, +.B \-\-single\-stream +implies +.BR \-\-keep . +.TP +.B \-\-no\-sparse +Disable creation of sparse files. +By default, if decompressing into a regular file, +.B xz +tries to make the file sparse if the decompressed data contains +long sequences of binary zeros. +It also works when writing to standard output +as long as standard output is connected to a regular file +and certain additional conditions are met to make it safe. +Creating sparse files may save disk space and speed up +the decompression by reducing the amount of disk I/O. +.TP +\fB\-S\fR \fI.suf\fR, \fB\-\-suffix=\fI.suf +When compressing, use +.I .suf +as the suffix for the target file instead of +.B .xz +or +.BR .lzma . +If not writing to standard output and +the source file already has the suffix +.IR .suf , +a warning is displayed and the file is skipped. +.IP "" +When decompressing, recognize files with the suffix +.I .suf +in addition to files with the +.BR .xz , +.BR .txz , +.BR .lzma , +.BR .tlz , +or +.B .lz +suffix. +If the source file has the suffix +.IR .suf , +the suffix is removed to get the target filename. +.IP "" +When compressing or decompressing raw streams +.RB ( \-\-format=raw ), +the suffix must always be specified unless +writing to standard output, +because there is no default suffix for raw streams. +.TP +\fB\-\-files\fR[\fB=\fIfile\fR] +Read the filenames to process from +.IR file ; +if +.I file +is omitted, filenames are read from standard input. +Filenames must be terminated with the newline character. +A dash +.RB ( \- ) +is taken as a regular filename; it doesn't mean standard input. +If filenames are given also as command line arguments, they are +processed before the filenames read from +.IR file . +.TP +\fB\-\-files0\fR[\fB=\fIfile\fR] +This is identical to \fB\-\-files\fR[\fB=\fIfile\fR] except +that each filename must be terminated with the null character. +. +.SS "Basic file format and compression options" +.TP +\fB\-F\fR \fIformat\fR, \fB\-\-format=\fIformat +Specify the file +.I format +to compress or decompress: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +.B auto +This is the default. +When compressing, +.B auto +is equivalent to +.BR xz . +When decompressing, +the format of the input file is automatically detected. +Note that raw streams (created with +.BR \-\-format=raw ) +cannot be auto-detected. +.TP +.B xz +Compress to the +.B .xz +file format, or accept only +.B .xz +files when decompressing. +.TP +.BR lzma ", " alone +Compress to the legacy +.B .lzma +file format, or accept only +.B .lzma +files when decompressing. +The alternative name +.B alone +is provided for backwards compatibility with LZMA Utils. +.TP +.B lzip +Accept only +.B .lz +files when decompressing. +Compression is not supported. +.IP "" +The +.B .lz +format versions 0 and 1 are supported. +Version 0 files were produced by +.B lzip +1.3 and older. +Such files aren't common but may be found from file archives +as a few source packages were released in this format. +People might have old personal files in this format too. +Decompression support for the format version 0 was removed in +.B lzip +1.18. +.B lzip +1.4 and later create files in the format version 1. +.TP +.B raw +Compress or uncompress a raw stream (no headers). +This is meant for advanced users only. +To decode raw streams, you need use +.B \-\-format=raw +and explicitly specify the filter chain, +which normally would have been stored in the container headers. +.RE +.TP +\fB\-C\fR \fIcheck\fR, \fB\-\-check=\fIcheck +Specify the type of the integrity check. +The check is calculated from the uncompressed data and +stored in the +.B .xz +file. +This option has an effect only when compressing into the +.B .xz +format; the +.B .lzma +format doesn't support integrity checks. +The integrity check (if any) is verified when the +.B .xz +file is decompressed. +.IP "" +Supported +.I check +types: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +.B none +Don't calculate an integrity check at all. +This is usually a bad idea. +This can be useful when integrity of the data is verified +by other means anyway. +.TP +.B crc32 +Calculate CRC32 using the polynomial from IEEE-802.3 (Ethernet). +.TP +.B crc64 +Calculate CRC64 using the polynomial from ECMA-182. +This is the default, since it is slightly better than CRC32 +at detecting damaged files and the speed difference is negligible. +.TP +.B sha256 +Calculate SHA-256. +This is somewhat slower than CRC32 and CRC64. +.RE +.IP "" +Integrity of the +.B .xz +headers is always verified with CRC32. +It is not possible to change or disable it. +.TP +.B \-\-ignore\-check +Don't verify the integrity check of the compressed data when decompressing. +The CRC32 values in the +.B .xz +headers will still be verified normally. +.IP "" +.B "Do not use this option unless you know what you are doing." +Possible reasons to use this option: +.RS +.IP \(bu 3 +Trying to recover data from a corrupt .xz file. +.IP \(bu 3 +Speeding up decompression. +This matters mostly with SHA-256 or +with files that have compressed extremely well. +It's recommended to not use this option for this purpose +unless the file integrity is verified externally in some other way. +.RE +.TP +.BR \-0 " ... " \-9 +Select a compression preset level. +The default is +.BR \-6 . +If multiple preset levels are specified, +the last one takes effect. +If a custom filter chain was already specified, setting +a compression preset level clears the custom filter chain. +.IP "" +The differences between the presets are more significant than with +.BR gzip (1) +and +.BR bzip2 (1). +The selected compression settings determine +the memory requirements of the decompressor, +thus using a too high preset level might make it painful +to decompress the file on an old system with little RAM. +Specifically, +.B "it's not a good idea to blindly use \-9 for everything" +like it often is with +.BR gzip (1) +and +.BR bzip2 (1). +.RS +.TP +.BR "\-0" " ... " "\-3" +These are somewhat fast presets. +.B \-0 +is sometimes faster than +.B "gzip \-9" +while compressing much better. +The higher ones often have speed comparable to +.BR bzip2 (1) +with comparable or better compression ratio, +although the results +depend a lot on the type of data being compressed. +.TP +.BR "\-4" " ... " "\-6" +Good to very good compression while keeping +decompressor memory usage reasonable even for old systems. +.B \-6 +is the default, which is usually a good choice +for distributing files that need to be decompressible +even on systems with only 16\ MiB RAM. +.RB ( \-5e +or +.B \-6e +may be worth considering too. +See +.BR \-\-extreme .) +.TP +.B "\-7 ... \-9" +These are like +.B \-6 +but with higher compressor and decompressor memory requirements. +These are useful only when compressing files bigger than +8\ MiB, 16\ MiB, and 32\ MiB, respectively. +.RE +.IP "" +On the same hardware, the decompression speed is approximately +a constant number of bytes of compressed data per second. +In other words, the better the compression, +the faster the decompression will usually be. +This also means that the amount of uncompressed output +produced per second can vary a lot. +.IP "" +The following table summarises the features of the presets: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Preset;DictSize;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Column descriptions: +.RS +.IP \(bu 3 +DictSize is the LZMA2 dictionary size. +It is waste of memory to use a dictionary bigger than +the size of the uncompressed file. +This is why it is good to avoid using the presets +.BR \-7 " ... " \-9 +when there's no real need for them. +At +.B \-6 +and lower, the amount of memory wasted is +usually low enough to not matter. +.IP \(bu 3 +CompCPU is a simplified representation of the LZMA2 settings +that affect compression speed. +The dictionary size affects speed too, +so while CompCPU is the same for levels +.BR \-6 " ... " \-9 , +higher levels still tend to be a little slower. +To get even slower and thus possibly better compression, see +.BR \-\-extreme . +.IP \(bu 3 +CompMem contains the compressor memory requirements +in the single-threaded mode. +It may vary slightly between +.B xz +versions. +.IP \(bu 3 +DecMem contains the decompressor memory requirements. +That is, the compression settings determine +the memory requirements of the decompressor. +The exact decompressor memory usage is slightly more than +the LZMA2 dictionary size, but the values in the table +have been rounded up to the next full MiB. +.RE +.IP "" +Memory requirements of the multi-threaded mode are +significantly higher than that of the single-threaded mode. +With the default value of +.BR \-\-block\-size , +each thread needs 3*3*DictSize plus CompMem or DecMem. +For example, four threads with preset +.B \-6 +needs 660\(en670\ MiB of memory. +.TP +.BR \-e ", " \-\-extreme +Use a slower variant of the selected compression preset level +.RB ( \-0 " ... " \-9 ) +to hopefully get a little bit better compression ratio, +but with bad luck this can also make it worse. +Decompressor memory usage is not affected, +but compressor memory usage increases a little at preset levels +.BR \-0 " ... " \-3 . +.IP "" +Since there are two presets with dictionary sizes +4\ MiB and 8\ MiB, the presets +.B \-3e +and +.B \-5e +use slightly faster settings (lower CompCPU) than +.B \-4e +and +.BR \-6e , +respectively. +That way no two presets are identical. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Preset;DictSize;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +For example, there are a total of four presets that use +8\ MiB dictionary, whose order from the fastest to the slowest is +.BR \-5 , +.BR \-6 , +.BR \-5e , +and +.BR \-6e . +.TP +.B \-\-fast +.PD 0 +.TP +.B \-\-best +.PD +These are somewhat misleading aliases for +.B \-0 +and +.BR \-9 , +respectively. +These are provided only for backwards compatibility +with LZMA Utils. +Avoid using these options. +.TP +.BI \-\-block\-size= size +When compressing to the +.B .xz +format, split the input data into blocks of +.I size +bytes. +The blocks are compressed independently from each other, +which helps with multi-threading and +makes limited random-access decompression possible. +This option is typically used to override the default +block size in multi-threaded mode, +but this option can be used in single-threaded mode too. +.IP "" +In multi-threaded mode about three times +.I size +bytes will be allocated in each thread for buffering input and output. +The default +.I size +is three times the LZMA2 dictionary size or 1 MiB, +whichever is more. +Typically a good value is 2\(en4 times +the size of the LZMA2 dictionary or at least 1 MiB. +Using +.I size +less than the LZMA2 dictionary size is waste of RAM +because then the LZMA2 dictionary buffer will never get fully used. +In multi-threaded mode, +the sizes of the blocks are stored in the block headers. +This size information is required for multi-threaded decompression. +.IP "" +In single-threaded mode no block splitting is done by default. +Setting this option doesn't affect memory usage. +No size information is stored in block headers, +thus files created in single-threaded mode +won't be identical to files created in multi-threaded mode. +The lack of size information also means that +.B xz +won't be able decompress the files in multi-threaded mode. +.TP +.BI \-\-block\-list= items +When compressing to the +.B .xz +format, start a new block with an optional custom filter chain after +the given intervals of uncompressed data. +.IP "" +The +.I items +are a comma-separated list. +Each item consists of an optional filter chain number +between 0 and 9 followed by a colon +.RB ( : ) +and a required size of uncompressed data. +Omitting an item (two or more consecutive commas) is a +shorthand to use the size and filters of the previous item. +.IP "" +If the input file is bigger than the sum of +the sizes in +.IR items , +the last item is repeated until the end of the file. +A special value of +.B 0 +may be used as the last size to indicate that +the rest of the file should be encoded as a single block. +.IP "" +An alternative filter chain for each block can be +specified in combination with the +.BI \-\-filters1= filters +\&...\& +.BI \-\-filters9= filters +options. +These options define filter chains with an identifier +between 1\(en9. +Filter chain 0 can be used to refer to the default filter chain, +which is the same as not specifying a filter chain. +The filter chain identifier can be used before the uncompressed +size, followed by a colon +.RB ( : ). +For example, if one specifies +.B \-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB +then blocks will be created using: +.RS +.IP \(bu 3 +The filter chain specified by +.B \-\-filters1 +and 2 MiB input +.IP \(bu 3 +The filter chain specified by +.B \-\-filters3 +and 2 MiB input +.IP \(bu 3 +The filter chain specified by +.B \-\-filters2 +and 4 MiB input +.IP \(bu 3 +The filter chain specified by +.B \-\-filters2 +and 4 MiB input +.IP \(bu 3 +The default filter chain and 2 MiB input +.IP \(bu 3 +The default filter chain and 4 MiB input for every block until +end of input. +.RE +.IP "" +If one specifies a size that exceeds the encoder's block size +(either the default value in threaded mode or +the value specified with \fB\-\-block\-size=\fIsize\fR), +the encoder will create additional blocks while +keeping the boundaries specified in +.IR items . +For example, if one specifies +.B \-\-block\-size=10MiB +.B \-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB +and the input file is 80 MiB, +one will get 11 blocks: +5, 10, 8, 10, 2, 10, 10, 4, 10, 10, and 1 MiB. +.IP "" +In multi-threaded mode the sizes of the blocks +are stored in the block headers. +This isn't done in single-threaded mode, +so the encoded output won't be +identical to that of the multi-threaded mode. +.TP +.BI \-\-flush\-timeout= timeout +When compressing, if more than +.I timeout +milliseconds (a positive integer) has passed since the previous flush and +reading more input would block, +all the pending input data is flushed from the encoder and +made available in the output stream. +This can be useful if +.B xz +is used to compress data that is streamed over a network. +Small +.I timeout +values make the data available at the receiving end +with a small delay, but large +.I timeout +values give better compression ratio. +.IP "" +This feature is disabled by default. +If this option is specified more than once, the last one takes effect. +The special +.I timeout +value of +.B 0 +can be used to explicitly disable this feature. +.IP "" +This feature is not available on non-POSIX systems. +.IP "" +.\" FIXME +.B "This feature is still experimental." +Currently +.B xz +is unsuitable for decompressing the stream in real time due to how +.B xz +does buffering. +.TP +.B \-\-no\-sync +Do not synchronize the target file and its directory +to the storage device before removing the source file. +This can improve performance if compressing or decompressing +many small files. +However, if the system crashes soon after the deletion, +it is possible that the target file was not written +to the storage device but the delete operation was. +In that case neither the original source file +nor the target file is available. +.IP "" +This option has an effect only when +.B xz +is going to remove the source file. +In other cases synchronization is never done. +.IP "" +The synchronization and +.B \-\-no\-sync +were added in +.B xz +5.7.1alpha. +.TP +.BI \-\-memlimit\-compress= limit +Set a memory usage limit for compression. +If this option is specified multiple times, +the last one takes effect. +.IP "" +If the compression settings exceed the +.IR limit , +.B xz +will attempt to adjust the settings downwards so that +the limit is no longer exceeded and display a notice that +automatic adjustment was done. +The adjustments are done in this order: +reducing the number of threads, +switching to single-threaded mode +if even one thread in multi-threaded mode exceeds the +.IR limit , +and finally reducing the LZMA2 dictionary size. +.IP "" +When compressing with +.B \-\-format=raw +or if +.B \-\-no\-adjust +has been specified, +only the number of threads may be reduced +since it can be done without affecting the compressed output. +.IP "" +If the +.I limit +cannot be met even with the adjustments described above, +an error is displayed and +.B xz +will exit with exit status 1. +.IP "" +The +.I limit +can be specified in multiple ways: +.RS +.IP \(bu 3 +The +.I limit +can be an absolute value in bytes. +Using an integer suffix like +.B MiB +can be useful. +Example: +.B "\-\-memlimit\-compress=80MiB" +.IP \(bu 3 +The +.I limit +can be specified as a percentage of total physical memory (RAM). +This can be useful especially when setting the +.B XZ_DEFAULTS +environment variable in a shell initialization script +that is shared between different computers. +That way the limit is automatically bigger +on systems with more memory. +Example: +.B "\-\-memlimit\-compress=70%" +.IP \(bu 3 +The +.I limit +can be reset back to its default value by setting it to +.BR 0 . +This is currently equivalent to setting the +.I limit +to +.B max +(no memory usage limit). +.RE +.IP "" +For 32-bit +.B xz +there is a special case: if the +.I limit +would be over +.BR "4020\ MiB" , +the +.I limit +is set to +.BR "4020\ MiB" . +On MIPS32 +.B "2000\ MiB" +is used instead. +(The values +.B 0 +and +.B max +aren't affected by this. +A similar feature doesn't exist for decompression.) +This can be helpful when a 32-bit executable has access +to 4\ GiB address space (2 GiB on MIPS32) +while hopefully doing no harm in other situations. +.IP "" +See also the section +.BR "Memory usage" . +.TP +.BI \-\-memlimit\-decompress= limit +Set a memory usage limit for decompression. +This also affects the +.B \-\-list +mode. +If the operation is not possible without exceeding the +.IR limit , +.B xz +will display an error and decompressing the file will fail. +See +.BI \-\-memlimit\-compress= limit +for possible ways to specify the +.IR limit . +.TP +.BI \-\-memlimit\-mt\-decompress= limit +Set a memory usage limit for multi-threaded decompression. +This can only affect the number of threads; +this will never make +.B xz +refuse to decompress a file. +If +.I limit +is too low to allow any multi-threading, the +.I limit +is ignored and +.B xz +will continue in single-threaded mode. +Note that if also +.B \-\-memlimit\-decompress +is used, +it will always apply to both single-threaded and multi-threaded modes, +and so the effective +.I limit +for multi-threading will never be higher than the limit set with +.BR \-\-memlimit\-decompress . +.IP "" +In contrast to the other memory usage limit options, +.BI \-\-memlimit\-mt\-decompress= limit +has a system-specific default +.IR limit . +.B "xz \-\-info\-memory" +can be used to see the current value. +.IP "" +This option and its default value exist +because without any limit the threaded decompressor +could end up allocating an insane amount of memory with some input files. +If the default +.I limit +is too low on your system, +feel free to increase the +.I limit +but never set it to a value larger than the amount of usable RAM +as with appropriate input files +.B xz +will attempt to use that amount of memory +even with a low number of threads. +Running out of memory or swapping +will not improve decompression performance. +.IP "" +See +.BI \-\-memlimit\-compress= limit +for possible ways to specify the +.IR limit . +Setting +.I limit +to +.B 0 +resets the +.I limit +to the default system-specific value. +.TP +\fB\-M\fR \fIlimit\fR, \fB\-\-memlimit=\fIlimit\fR, \fB\-\-memory=\fIlimit +This is equivalent to specifying +.BI \-\-memlimit\-compress= limit +.BI \-\-memlimit-decompress= limit +\fB\-\-memlimit\-mt\-decompress=\fIlimit\fR. +.TP +.B \-\-no\-adjust +Display an error and exit if the memory usage limit cannot be +met without adjusting settings that affect the compressed output. +That is, this prevents +.B xz +from switching the encoder from multi-threaded mode to single-threaded mode +and from reducing the LZMA2 dictionary size. +Even when this option is used the number of threads may be reduced +to meet the memory usage limit as that won't affect the compressed output. +.IP "" +Automatic adjusting is always disabled when creating raw streams +.RB ( \-\-format=raw ). +.TP +\fB\-T\fR \fIthreads\fR, \fB\-\-threads=\fIthreads +Specify the number of worker threads to use. +Setting +.I threads +to a special value +.B 0 +makes +.B xz +use up to as many threads as the processor(s) on the system support. +The actual number of threads can be fewer than +.I threads +if the input file is not big enough +for threading with the given settings or +if using more threads would exceed the memory usage limit. +.IP "" +The single-threaded and multi-threaded compressors produce different output. +Single-threaded compressor will give the smallest file size but +only the output from the multi-threaded compressor can be decompressed +using multiple threads. +Setting +.I threads +to +.B 1 +will use the single-threaded mode. +Setting +.I threads +to any other value, including +.BR 0 , +will use the multi-threaded compressor +even if the system supports only one hardware thread. +.RB ( xz +5.2.x +used single-threaded mode in this situation.) +.IP "" +To use multi-threaded mode with only one thread, set +.I threads +to +.BR +1 . +The +.B + +prefix has no effect with values other than +.BR 1 . +A memory usage limit can still make +.B xz +switch to single-threaded mode unless +.B \-\-no\-adjust +is used. +Support for the +.B + +prefix was added in +.B xz +5.4.0. +.IP "" +If an automatic number of threads has been requested and +no memory usage limit has been specified, +then a system-specific default soft limit will be used to possibly +limit the number of threads. +It is a soft limit in sense that it is ignored +if the number of threads becomes one, +thus a soft limit will never stop +.B xz +from compressing or decompressing. +This default soft limit will not make +.B xz +switch from multi-threaded mode to single-threaded mode. +The active limits can be seen with +.BR "xz \-\-info\-memory" . +.IP "" +Currently the only threading method is to split the input into +blocks and compress them independently from each other. +The default block size depends on the compression level and +can be overridden with the +.BI \-\-block\-size= size +option. +.IP "" +Threaded decompression only works on files that contain +multiple blocks with size information in block headers. +All large enough files compressed in multi-threaded mode +meet this condition, +but files compressed in single-threaded mode don't even if +.BI \-\-block\-size= size +has been used. +.IP "" +The default value for +.I threads +is +.BR 0 . +In +.B xz +5.4.x and older the default is +.BR 1 . +. +.SS "Custom compressor filter chains" +A custom filter chain allows specifying +the compression settings in detail instead of relying on +the settings associated to the presets. +When a custom filter chain is specified, +preset options +.RB ( \-0 +\&...\& +.B \-9 +and +.BR \-\-extreme ) +earlier on the command line are forgotten. +If a preset option is specified +after one or more custom filter chain options, +the new preset takes effect and +the custom filter chain options specified earlier are forgotten. +.PP +A filter chain is comparable to piping on the command line. +When compressing, the uncompressed input goes to the first filter, +whose output goes to the next filter (if any). +The output of the last filter gets written to the compressed file. +The maximum number of filters in the chain is four, +but typically a filter chain has only one or two filters. +.PP +Many filters have limitations on where they can be +in the filter chain: +some filters can work only as the last filter in the chain, +some only as a non-last filter, and some work in any position +in the chain. +Depending on the filter, this limitation is either inherent to +the filter design or exists to prevent security issues. +.PP +A custom filter chain can be specified in two different ways. +The options +.BI \-\-filters= filters +and +.BI \-\-filters1= filters +\&...\& +.BI \-\-filters9= filters +allow specifying an entire filter chain in one option using the +liblzma filter string syntax. +Alternatively, a filter chain can be specified by using one or more +individual filter options in the order they are wanted in the filter chain. +That is, the order of the individual filter options is significant! +When decoding raw streams +.RB ( \-\-format=raw ), +the filter chain must be specified in the same order as +it was specified when compressing. +Any individual filter or preset options specified before the full +chain option +(\fB\-\-filters=\fIfilters\fR) +will be forgotten. +Individual filters specified after the full chain option will reset the +filter chain. +.PP +Both the full and individual filter options take filter-specific +.I options +as a comma-separated list. +Extra commas in +.I options +are ignored. +Every option has a default value, so +specify those you want to change. +.PP +To see the whole filter chain and +.IR options , +use +.B "xz \-vv" +(that is, use +.B \-\-verbose +twice). +This works also for viewing the filter chain options used by presets. +.TP +.BI \-\-filters= filters +Specify the full filter chain or a preset in a single option. +Each filter can be separated by spaces or two dashes +.RB ( \-\- ). +.I filters +may need to be quoted on the shell command line so it is +parsed as a single option. +To denote +.IR options , +use +.B : +or +.BR = . +A preset can be prefixed with a +.B \- +and followed with zero or more flags. +The only supported flag is +.B e +to apply the same options as +.BR \-\-extreme . +.TP +\fB\-\-filters1\fR=\fIfilters\fR ... \fB\-\-filters9\fR=\fIfilters +Specify up to nine additional filter chains that can be used with +.BR \-\-block\-list . +.IP "" +For example, when compressing an archive with executable files +followed by text files, the executable part could use a filter +chain with a BCJ filter and the text part only the LZMA2 filter. +.TP +.B \-\-filters-help +Display a help message describing how to specify presets and +custom filter chains in the +.B \-\-filters +and +.BI \-\-filters1= filters +\&...\& +.BI \-\-filters9= filters +options, and exit successfully. +.TP +\fB\-\-lzma1\fR[\fB=\fIoptions\fR] +.PD 0 +.TP +\fB\-\-lzma2\fR[\fB=\fIoptions\fR] +.PD +Add LZMA1 or LZMA2 filter to the filter chain. +These filters can be used only as the last filter in the chain. +.IP "" +LZMA1 is a legacy filter, +which is supported almost solely due to the legacy +.B .lzma +file format, which supports only LZMA1. +LZMA2 is an updated +version of LZMA1 to fix some practical issues of LZMA1. +The +.B .xz +format uses LZMA2 and doesn't support LZMA1 at all. +Compression speed and ratios of LZMA1 and LZMA2 +are practically the same. +.IP "" +LZMA1 and LZMA2 share the same set of +.IR options : +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +.BI preset= preset +Reset all LZMA1 or LZMA2 +.I options +to +.IR preset . +.I Preset +consist of an integer, which may be followed by single-letter +preset modifiers. +The integer can be from +.B 0 +to +.BR 9 , +matching the command line options +.B \-0 +\&...\& +.BR \-9 . +The only supported modifier is currently +.BR e , +which matches +.BR \-\-extreme . +If no +.B preset +is specified, the default values of LZMA1 or LZMA2 +.I options +are taken from the preset +.BR 6 . +.TP +.BI dict= size +Dictionary (history buffer) +.I size +indicates how many bytes of the recently processed +uncompressed data is kept in memory. +The algorithm tries to find repeating byte sequences (matches) in +the uncompressed data, and replace them with references +to the data currently in the dictionary. +The bigger the dictionary, the higher is the chance +to find a match. +Thus, increasing dictionary +.I size +usually improves compression ratio, but +a dictionary bigger than the uncompressed file is waste of memory. +.IP "" +Typical dictionary +.I size +is from 64\ KiB to 64\ MiB. +The minimum is 4\ KiB. +The maximum for compression is currently 1.5\ GiB (1536\ MiB). +The decompressor already supports dictionaries up to +one byte less than 4\ GiB, which is the maximum for +the LZMA1 and LZMA2 stream formats. +.IP "" +Dictionary +.I size +and match finder +.RI ( mf ) +together determine the memory usage of the LZMA1 or LZMA2 encoder. +The same (or bigger) dictionary +.I size +is required for decompressing that was used when compressing, +thus the memory usage of the decoder is determined +by the dictionary size used when compressing. +The +.B .xz +headers store the dictionary +.I size +either as +.RI "2^" n +or +.RI "2^" n " + 2^(" n "\-1)," +so these +.I sizes +are somewhat preferred for compression. +Other +.I sizes +will get rounded up when stored in the +.B .xz +headers. +.TP +.BI lc= lc +Specify the number of literal context bits. +The minimum is 0 and the maximum is 4; the default is 3. +In addition, the sum of +.I lc +and +.I lp +must not exceed 4. +.IP "" +All bytes that cannot be encoded as matches +are encoded as literals. +That is, literals are simply 8-bit bytes +that are encoded one at a time. +.IP "" +The literal coding makes an assumption that the highest +.I lc +bits of the previous uncompressed byte correlate +with the next byte. +For example, in typical English text, an upper-case letter is +often followed by a lower-case letter, and a lower-case +letter is usually followed by another lower-case letter. +In the US-ASCII character set, the highest three bits are 010 +for upper-case letters and 011 for lower-case letters. +When +.I lc +is at least 3, the literal coding can take advantage of +this property in the uncompressed data. +.IP "" +The default value (3) is usually good. +If you want maximum compression, test +.BR lc=4 . +Sometimes it helps a little, and +sometimes it makes compression worse. +If it makes it worse, test +.B lc=2 +too. +.TP +.BI lp= lp +Specify the number of literal position bits. +The minimum is 0 and the maximum is 4; the default is 0. +.IP "" +.I Lp +affects what kind of alignment in the uncompressed data is +assumed when encoding literals. +See +.I pb +below for more information about alignment. +.TP +.BI pb= pb +Specify the number of position bits. +The minimum is 0 and the maximum is 4; the default is 2. +.IP "" +.I Pb +affects what kind of alignment in the uncompressed data is +assumed in general. +The default means four-byte alignment +.RI (2^ pb =2^2=4), +which is often a good choice when there's no better guess. +.IP "" +When the alignment is known, setting +.I pb +accordingly may reduce the file size a little. +For example, with text files having one-byte +alignment (US-ASCII, ISO-8859-*, UTF-8), setting +.B pb=0 +can improve compression slightly. +For UTF-16 text, +.B pb=1 +is a good choice. +If the alignment is an odd number like 3 bytes, +.B pb=0 +might be the best choice. +.IP "" +Even though the assumed alignment can be adjusted with +.I pb +and +.IR lp , +LZMA1 and LZMA2 still slightly favor 16-byte alignment. +It might be worth taking into account when designing file formats +that are likely to be often compressed with LZMA1 or LZMA2. +.TP +.BI mf= mf +Match finder has a major effect on encoder speed, +memory usage, and compression ratio. +Usually Hash Chain match finders are faster than Binary Tree +match finders. +The default depends on the +.IR preset : +0 uses +.BR hc3 , +1\(en3 +use +.BR hc4 , +and the rest use +.BR bt4 . +.IP "" +The following match finders are supported. +The memory usage formulas below are rough approximations, +which are closest to the reality when +.I dict +is a power of two. +.RS +.TP +.B hc3 +Hash Chain with 2- and 3-byte hashing +.br +Minimum value for +.IR nice : +3 +.br +Memory usage: +.br +.I dict +* 7.5 (if +.I dict +<= 16 MiB); +.br +.I dict +* 5.5 + 64 MiB (if +.I dict +> 16 MiB) +.TP +.B hc4 +Hash Chain with 2-, 3-, and 4-byte hashing +.br +Minimum value for +.IR nice : +4 +.br +Memory usage: +.br +.I dict +* 7.5 (if +.I dict +<= 32 MiB); +.br +.I dict +* 6.5 (if +.I dict +> 32 MiB) +.TP +.B bt2 +Binary Tree with 2-byte hashing +.br +Minimum value for +.IR nice : +2 +.br +Memory usage: +.I dict +* 9.5 +.TP +.B bt3 +Binary Tree with 2- and 3-byte hashing +.br +Minimum value for +.IR nice : +3 +.br +Memory usage: +.br +.I dict +* 11.5 (if +.I dict +<= 16 MiB); +.br +.I dict +* 9.5 + 64 MiB (if +.I dict +> 16 MiB) +.TP +.B bt4 +Binary Tree with 2-, 3-, and 4-byte hashing +.br +Minimum value for +.IR nice : +4 +.br +Memory usage: +.br +.I dict +* 11.5 (if +.I dict +<= 32 MiB); +.br +.I dict +* 10.5 (if +.I dict +> 32 MiB) +.RE +.TP +.BI mode= mode +Compression +.I mode +specifies the method to analyze +the data produced by the match finder. +Supported +.I modes +are +.B fast +and +.BR normal . +The default is +.B fast +for +.I presets +0\(en3 and +.B normal +for +.I presets +4\(en9. +.IP "" +Usually +.B fast +is used with Hash Chain match finders and +.B normal +with Binary Tree match finders. +This is also what the +.I presets +do. +.TP +.BI nice= nice +Specify what is considered to be a nice length for a match. +Once a match of at least +.I nice +bytes is found, the algorithm stops +looking for possibly better matches. +.IP "" +.I Nice +can be 2\(en273 bytes. +Higher values tend to give better compression ratio +at the expense of speed. +The default depends on the +.IR preset . +.TP +.BI depth= depth +Specify the maximum search depth in the match finder. +The default is the special value of 0, +which makes the compressor determine a reasonable +.I depth +from +.I mf +and +.IR nice . +.IP "" +Reasonable +.I depth +for Hash Chains is 4\(en100 and 16\(en1000 for Binary Trees. +Using very high values for +.I depth +can make the encoder extremely slow with some files. +Avoid setting the +.I depth +over 1000 unless you are prepared to interrupt +the compression in case it is taking far too long. +.RE +.IP "" +When decoding raw streams +.RB ( \-\-format=raw ), +LZMA2 needs only the dictionary +.IR size . +LZMA1 needs also +.IR lc , +.IR lp , +and +.IR pb . +.TP +\fB\-\-x86\fR[\fB=\fIoptions\fR] +.PD 0 +.TP +\fB\-\-arm\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-armthumb\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-arm64\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-powerpc\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-ia64\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-sparc\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-riscv\fR[\fB=\fIoptions\fR] +.PD +Add a branch/call/jump (BCJ) filter to the filter chain. +These filters can be used only as a non-last filter +in the filter chain. +.IP "" +A BCJ filter converts relative addresses in +the machine code to their absolute counterparts. +This doesn't change the size of the data +but it increases redundancy, +which can help LZMA2 to produce 0\(en15\ % smaller +.B .xz +file. +The BCJ filters are always reversible, +so using a BCJ filter for wrong type of data +doesn't cause any data loss, although it may make +the compression ratio slightly worse. +The BCJ filters are very fast and +use an insignificant amount of memory. +.IP "" +These BCJ filters have known problems related to +the compression ratio: +.RS +.IP \(bu 3 +Some types of files containing executable code +(for example, object files, static libraries, and Linux kernel modules) +have the addresses in the instructions filled with filler values. +These BCJ filters will still do the address conversion, +which will make the compression worse with these files. +.IP \(bu 3 +If a BCJ filter is applied on an archive, +it is possible that it makes the compression ratio +worse than not using a BCJ filter. +For example, if there are similar or even identical executables +then filtering will likely make the files less similar +and thus compression is worse. +The contents of non-executable files in the same archive can matter too. +In practice one has to try with and without a BCJ filter to see +which is better in each situation. +.RE +.IP "" +Different instruction sets have different alignment: +the executable file must be aligned to a multiple of +this value in the input data to make the filter work. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filter;Alignment;Notes +x86;1;32-bit or 64-bit x86 +ARM;4; +ARM-Thumb;2; +ARM64;4;4096-byte alignment is best +PowerPC;4;Big endian only +IA-64;16;Itanium +SPARC;4; +RISC-V;2; +.TE +.RE +.RE +.IP "" +Since the BCJ-filtered data is usually compressed with LZMA2, +the compression ratio may be improved slightly if +the LZMA2 options are set to match the +alignment of the selected BCJ filter. +Examples: +.RS +.IP \(bu 3 +IA-64 filter has 16-byte alignment so +.B pb=4,lp=4,lc=0 +is good +with LZMA2 (2^4=16). +.IP \(bu 3 +RISC-V code has 2-byte or 4-byte alignment +depending on whether the file contains +16-bit compressed instructions (the C extension). +When 16-bit instructions are used, +.B pb=2,lp=1,lc=3 +or +.B pb=1,lp=1,lc=3 +is good. +When 16-bit instructions aren't present, +.B pb=2,lp=2,lc=2 +is the best. +.B readelf \-h +can be used to check if "RVC" +appears on the "Flags" line. +.IP \(bu 3 +ARM64 is always 4-byte aligned so +.B pb=2,lp=2,lc=2 +is the best. +.IP \(bu 3 +The x86 filter is an exception. +It's usually good to stick to LZMA2's defaults +.RB ( pb=2,lp=0,lc=3 ) +when compressing x86 executables. +.RE +.IP "" +All BCJ filters support the same +.IR options : +.RS +.TP +.BI start= offset +Specify the start +.I offset +that is used when converting between relative +and absolute addresses. +The +.I offset +must be a multiple of the alignment of the filter +(see the table above). +The default is zero. +In practice, the default is good; specifying a custom +.I offset +is almost never useful. +.RE +.TP +\fB\-\-delta\fR[\fB=\fIoptions\fR] +Add the Delta filter to the filter chain. +The Delta filter can be only used as a non-last filter +in the filter chain. +.IP "" +Currently only simple byte-wise delta calculation is supported. +It can be useful when compressing, for example, uncompressed bitmap images +or uncompressed PCM audio. +However, special purpose algorithms may give significantly better +results than Delta + LZMA2. +This is true especially with audio, +which compresses faster and better, for example, with +.BR flac (1). +.IP "" +Supported +.IR options : +.RS +.TP +.BI dist= distance +Specify the +.I distance +of the delta calculation in bytes. +.I distance +must be 1\(en256. +The default is 1. +.IP "" +For example, with +.B dist=2 +and eight-byte input A1 B1 A2 B3 A3 B5 A4 B7, the output will be +A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Other options" +.TP +.BR \-q ", " \-\-quiet +Suppress warnings and notices. +Specify this twice to suppress errors too. +This option has no effect on the exit status. +That is, even if a warning was suppressed, +the exit status to indicate a warning is still used. +.TP +.BR \-v ", " \-\-verbose +Be verbose. +If standard error is connected to a terminal, +.B xz +will display a progress indicator. +Specifying +.B \-\-verbose +twice will give even more verbose output. +.IP "" +The progress indicator shows the following information: +.RS +.IP \(bu 3 +Completion percentage is shown +if the size of the input file is known. +That is, the percentage cannot be shown in pipes. +.IP \(bu 3 +Amount of compressed data produced (compressing) +or consumed (decompressing). +.IP \(bu 3 +Amount of uncompressed data consumed (compressing) +or produced (decompressing). +.IP \(bu 3 +Compression ratio, which is calculated by dividing +the amount of compressed data processed so far by +the amount of uncompressed data processed so far. +.IP \(bu 3 +Compression or decompression speed. +This is measured as the amount of uncompressed data consumed +(compression) or produced (decompression) per second. +It is shown after a few seconds have passed since +.B xz +started processing the file. +.IP \(bu 3 +Elapsed time in the format M:SS or H:MM:SS. +.IP \(bu 3 +Estimated remaining time is shown +only when the size of the input file is +known and a couple of seconds have already passed since +.B xz +started processing the file. +The time is shown in a less precise format which +never has any colons, for example, 2 min 30 s. +.RE +.IP "" +When standard error is not a terminal, +.B \-\-verbose +will make +.B xz +print the filename, compressed size, uncompressed size, +compression ratio, and possibly also the speed and elapsed time +on a single line to standard error after compressing or +decompressing the file. +The speed and elapsed time are included only when +the operation took at least a few seconds. +If the operation didn't finish, for example, due to user interruption, +also the completion percentage is printed +if the size of the input file is known. +.TP +.BR \-Q ", " \-\-no\-warn +Don't set the exit status to 2 +even if a condition worth a warning was detected. +This option doesn't affect the verbosity level, thus both +.B \-\-quiet +and +.B \-\-no\-warn +have to be used to not display warnings and +to not alter the exit status. +.TP +.B \-\-robot +Print messages in a machine-parsable format. +This is intended to ease writing frontends that want to use +.B xz +instead of liblzma, which may be the case with various scripts. +The output with this option enabled is meant to be stable across +.B xz +releases. +See the section +.B "ROBOT MODE" +for details. +.TP +.B \-\-info\-memory +Display, in human-readable format, how much physical memory (RAM) +and how many processor threads +.B xz +thinks the system has and the memory usage limits for compression +and decompression, and exit successfully. +.TP +.BR \-h ", " \-\-help +Display a help message describing the most commonly used options, +and exit successfully. +.TP +.BR \-H ", " \-\-long\-help +Display a help message describing all features of +.BR xz , +and exit successfully +.TP +.BR \-V ", " \-\-version +Display the version number of +.B xz +and liblzma in human readable format. +To get machine-parsable output, specify +.B \-\-robot +before +.BR \-\-version . +. +.SH "ROBOT MODE" +The robot mode is activated with the +.B \-\-robot +option. +It makes the output of +.B xz +easier to parse by other programs. +Currently +.B \-\-robot +is supported only together with +.BR \-\-list , +.BR \-\-filters\-help , +.BR \-\-info\-memory , +and +.BR \-\-version . +It will be supported for compression and +decompression in the future. +. +.SS "List mode" +.B "xz \-\-robot \-\-list" +uses tab-separated output. +The first column of every line has a string +that indicates the type of the information found on that line: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +.B name +This is always the first line when starting to list a file. +The second column on the line is the filename. +.TP +.B file +This line contains overall information about the +.B .xz +file. +This line is always printed after the +.B name +line. +.TP +.B stream +This line type is used only when +.B \-\-verbose +was specified. +There are as many +.B stream +lines as there are streams in the +.B .xz +file. +.TP +.B block +This line type is used only when +.B \-\-verbose +was specified. +There are as many +.B block +lines as there are blocks in the +.B .xz +file. +The +.B block +lines are shown after all the +.B stream +lines; different line types are not interleaved. +.TP +.B summary +This line type is used only when +.B \-\-verbose +was specified twice. +This line is printed after all +.B block +lines. +Like the +.B file +line, the +.B summary +line contains overall information about the +.B .xz +file. +.TP +.B totals +This line is always the very last line of the list output. +It shows the total counts and sizes. +.PP +The columns of the +.B file +lines: +.PD 0 +.RS +.IP 2. 4 +Number of streams in the file +.IP 3. 4 +Total number of blocks in the stream(s) +.IP 4. 4 +Compressed size of the file +.IP 5. 4 +Uncompressed size of the file +.IP 6. 4 +Compression ratio, for example, +.BR 0.123 . +If ratio is over 9.999, three dashes +.RB ( \-\-\- ) +are displayed instead of the ratio. +.IP 7. 4 +Comma-separated list of integrity check names. +The following strings are used for the known check types: +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +.BR None , +.BR CRC32 , +.BR CRC64 , +and +.BR SHA\-256 . +For unknown check types, +.BI Unknown\- N +is used, where +.I N +is the Check ID as a decimal number (one or two digits). +.IP 8. 4 +Total size of stream padding in the file +.RE +.PD +.PP +The columns of the +.B stream +lines: +.PD 0 +.RS +.IP 2. 4 +Stream number (the first stream is 1) +.IP 3. 4 +Number of blocks in the stream +.IP 4. 4 +Compressed start offset +.IP 5. 4 +Uncompressed start offset +.IP 6. 4 +Compressed size (does not include stream padding) +.IP 7. 4 +Uncompressed size +.IP 8. 4 +Compression ratio +.IP 9. 4 +Name of the integrity check +.IP 10. 4 +Size of stream padding +.RE +.PD +.PP +The columns of the +.B block +lines: +.PD 0 +.RS +.IP 2. 4 +Number of the stream containing this block +.IP 3. 4 +Block number relative to the beginning of the stream +(the first block is 1) +.IP 4. 4 +Block number relative to the beginning of the file +.IP 5. 4 +Compressed start offset relative to the beginning of the file +.IP 6. 4 +Uncompressed start offset relative to the beginning of the file +.IP 7. 4 +Total compressed size of the block (includes headers) +.IP 8. 4 +Uncompressed size +.IP 9. 4 +Compression ratio +.IP 10. 4 +Name of the integrity check +.RE +.PD +.PP +If +.B \-\-verbose +was specified twice, additional columns are included on the +.B block +lines. +These are not displayed with a single +.BR \-\-verbose , +because getting this information requires many seeks +and can thus be slow: +.PD 0 +.RS +.IP 11. 4 +Value of the integrity check in hexadecimal +.IP 12. 4 +Block header size +.IP 13. 4 +Block flags: +.B c +indicates that compressed size is present, and +.B u +indicates that uncompressed size is present. +If the flag is not set, a dash +.RB ( \- ) +is shown instead to keep the string length fixed. +New flags may be added to the end of the string in the future. +.IP 14. 4 +Size of the actual compressed data in the block (this excludes +the block header, block padding, and check fields) +.IP 15. 4 +Amount of memory (in bytes) required to decompress +this block with this +.B xz +version +.IP 16. 4 +Filter chain. +Note that most of the options used at compression time +cannot be known, because only the options +that are needed for decompression are stored in the +.B .xz +headers. +.RE +.PD +.PP +The columns of the +.B summary +lines: +.PD 0 +.RS +.IP 2. 4 +Amount of memory (in bytes) required to decompress +this file with this +.B xz +version +.IP 3. 4 +.B yes +or +.B no +indicating if all block headers have both compressed size and +uncompressed size stored in them +.PP +.I Since +.B xz +.I 5.1.2alpha: +.IP 4. 4 +Minimum +.B xz +version required to decompress the file +.RE +.PD +.PP +The columns of the +.B totals +line: +.PD 0 +.RS +.IP 2. 4 +Number of streams +.IP 3. 4 +Number of blocks +.IP 4. 4 +Compressed size +.IP 5. 4 +Uncompressed size +.IP 6. 4 +Average compression ratio +.IP 7. 4 +Comma-separated list of integrity check names +that were present in the files +.IP 8. 4 +Stream padding size +.IP 9. 4 +Number of files. +This is here to +keep the order of the earlier columns the same as on +.B file +lines. +.PD +.RE +.PP +If +.B \-\-verbose +was specified twice, additional columns are included on the +.B totals +line: +.PD 0 +.RS +.IP 10. 4 +Maximum amount of memory (in bytes) required to decompress +the files with this +.B xz +version +.IP 11. 4 +.B yes +or +.B no +indicating if all block headers have both compressed size and +uncompressed size stored in them +.PP +.I Since +.B xz +.I 5.1.2alpha: +.IP 12. 4 +Minimum +.B xz +version required to decompress the file +.RE +.PD +.PP +Future versions may add new line types and +new columns can be added to the existing line types, +but the existing columns won't be changed. +. +.SS "Filters help" +.B "xz \-\-robot \-\-filters-help" +prints the supported filters in the following format: +.PP +\fIfilter\fB:\fIoption\fB=<\fIvalue\fB>,\fIoption\fB=<\fIvalue\fB>\fR... +.TP +.I filter +Name of the filter +.TP +.I option +Name of a filter specific option +.TP +.I value +Numeric +.I value +ranges appear as +\fB<\fImin\fB\-\fImax\fB>\fR. +String +.I value +choices are shown within +.B "< >" +and separated by a +.B | +character. +.PP +Each filter is printed on its own line. +. +.SS "Memory limit information" +.B "xz \-\-robot \-\-info\-memory" +prints a single line with multiple tab-separated columns: +.IP 1. 4 +Total amount of physical memory (RAM) in bytes. +.IP 2. 4 +Memory usage limit for compression in bytes +.RB ( \-\-memlimit\-compress ). +A special value of +.B 0 +indicates the default setting +which for single-threaded mode is the same as no limit. +.IP 3. 4 +Memory usage limit for decompression in bytes +.RB ( \-\-memlimit\-decompress ). +A special value of +.B 0 +indicates the default setting +which for single-threaded mode is the same as no limit. +.IP 4. 4 +Since +.B xz +5.3.4alpha: +Memory usage for multi-threaded decompression in bytes +.RB ( \-\-memlimit\-mt\-decompress ). +This is never zero because a system-specific default value +shown in the column 5 +is used if no limit has been specified explicitly. +This is also never greater than the value in the column 3 +even if a larger value has been specified with +.BR \-\-memlimit\-mt\-decompress . +.IP 5. 4 +Since +.B xz +5.3.4alpha: +A system-specific default memory usage limit +that is used to limit the number of threads +when compressing with an automatic number of threads +.RB ( \-\-threads=0 ) +and no memory usage limit has been specified +.RB ( \-\-memlimit\-compress ). +This is also used as the default value for +.BR \-\-memlimit\-mt\-decompress . +.IP 6. 4 +Since +.B xz +5.3.4alpha: +Number of available processor threads. +.PP +In the future, the output of +.B "xz \-\-robot \-\-info\-memory" +may have more columns, but never more than a single line. +. +.SS Version +.B "xz \-\-robot \-\-version" +prints the version number of +.B xz +and liblzma in the following format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +.BI XZ_VERSION= XYYYZZZS +.br +.BI LIBLZMA_VERSION= XYYYZZZS +.TP +.I X +Major version. +.TP +.I YYY +Minor version. +Even numbers are stable. +Odd numbers are alpha or beta versions. +.TP +.I ZZZ +Patch level for stable releases or +just a counter for development releases. +.TP +.I S +Stability. +0 is alpha, 1 is beta, and 2 is stable. +.I S +should be always 2 when +.I YYY +is even. +.PP +.I XYYYZZZS +are the same on both lines if +.B xz +and liblzma are from the same XZ Utils release. +.PP +Examples: 4.999.9beta is +.B 49990091 +and +5.0.0 is +.BR 50000002 . +. +.SH "EXIT STATUS" +.TP +.B 0 +All is good. +.TP +.B 1 +An error occurred. +.TP +.B 2 +Something worth a warning occurred, +but no actual errors occurred. +.PP +Notices (not warnings or errors) printed on standard error +don't affect the exit status. +. +.SH ENVIRONMENT +.B xz +parses space-separated lists of options +from the environment variables +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +.B XZ_DEFAULTS +and +.BR XZ_OPT , +in this order, before parsing the options from the command line. +Note that only options are parsed from the environment variables; +all non-options are silently ignored. +Parsing is done with +.BR getopt_long (3) +which is used also for the command line arguments. +.PP +.B Warning: +By setting these environment variables, +one is effectively modifying programs and scripts that run +.BR xz . +Most of the time it is safe to set memory usage limits, number of threads, +and compression options via the environment variables. +However, some options can break scripts. +An obvious example is +.B \-\-help +which makes +.B xz +show the help text instead of compressing or decompressing a file. +More subtle examples are +.B \-\-quiet +and +.BR \-\-verbose . +In many cases it works well to enable the progress indicator using +.BR \-\-verbose , +but in some situations the extra messages create problems. +The verbosity level also affects the behavior of +.BR \-\-list . +.TP +.B XZ_DEFAULTS +User-specific or system-wide default options. +Typically this is set in a shell initialization script to enable +.BR xz 's +memory usage limiter by default or set the default number of threads. +Excluding shell initialization scripts +and similar special cases, scripts should never set or unset +.BR XZ_DEFAULTS . +.TP +.B XZ_OPT +This is for passing options to +.B xz +when it is not possible to set the options directly on the +.B xz +command line. +This is the case when +.B xz +is run by a script or tool, for example, GNU +.BR tar (1): +.RS +.RS +.PP +.nf +.ft CR +XZ_OPT=\-2v tar caf foo.tar.xz foo +.ft R +.fi +.RE +.RE +.IP "" +Scripts may use +.BR XZ_OPT , +for example, to set script-specific default compression options. +It is still recommended to allow users to override +.B XZ_OPT +if that is reasonable. +For example, in +.BR sh (1) +scripts one may use something like this: +.RS +.RS +.PP +.nf +.ft CR +XZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT +.ft R +.fi +.RE +.RE +. +.SH "LZMA UTILS COMPATIBILITY" +The command line syntax of +.B xz +is practically a superset of +.BR lzma , +.BR unlzma , +and +.B lzcat +as found from LZMA Utils 4.32.x. +In most cases, it is possible to replace +LZMA Utils with XZ Utils without breaking existing scripts. +There are some incompatibilities though, +which may sometimes cause problems. +. +.SS "Compression preset levels" +The numbering of the compression level presets is not identical in +.B xz +and LZMA Utils. +The most important difference is how dictionary sizes +are mapped to different presets. +Dictionary size is roughly equal to the decompressor memory usage. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Level;xz;LZMA Utils +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +The dictionary size differences affect +the compressor memory usage too, +but there are some other differences between +LZMA Utils and XZ Utils, which +make the difference even bigger: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Level;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +The default preset level in LZMA Utils is +.B \-7 +while in XZ Utils it is +.BR \-6 , +so both use an 8 MiB dictionary by default. +. +.SS "Streamed vs. non-streamed .lzma files" +The uncompressed size of the file can be stored in the +.B .lzma +header. +LZMA Utils does that when compressing regular files. +The alternative is to mark that uncompressed size is unknown +and use end-of-payload marker to indicate +where the decompressor should stop. +LZMA Utils uses this method when uncompressed size isn't known, +which is the case, for example, in pipes. +.PP +.B xz +supports decompressing +.B .lzma +files with or without end-of-payload marker, but all +.B .lzma +files created by +.B xz +will use end-of-payload marker and have uncompressed size +marked as unknown in the +.B .lzma +header. +This may be a problem in some uncommon situations. +For example, a +.B .lzma +decompressor in an embedded device might work +only with files that have known uncompressed size. +If you hit this problem, you need to use LZMA Utils +or LZMA SDK to create +.B .lzma +files with known uncompressed size. +. +.SS "Unsupported .lzma files" +The +.B .lzma +format allows +.I lc +values up to 8, and +.I lp +values up to 4. +LZMA Utils can decompress files with any +.I lc +and +.IR lp , +but always creates files with +.B lc=3 +and +.BR lp=0 . +Creating files with other +.I lc +and +.I lp +is possible with +.B xz +and with LZMA SDK. +.PP +The implementation of the LZMA1 filter in liblzma +requires that the sum of +.I lc +and +.I lp +must not exceed 4. +Thus, +.B .lzma +files, which exceed this limitation, cannot be decompressed with +.BR xz . +.PP +LZMA Utils creates only +.B .lzma +files which have a dictionary size of +.RI "2^" n +(a power of 2) but accepts files with any dictionary size. +liblzma accepts only +.B .lzma +files which have a dictionary size of +.RI "2^" n +or +.RI "2^" n " + 2^(" n "\-1)." +This is to decrease false positives when detecting +.B .lzma +files. +.PP +These limitations shouldn't be a problem in practice, +since practically all +.B .lzma +files have been compressed with settings that liblzma will accept. +. +.SS "Trailing garbage" +When decompressing, +LZMA Utils silently ignore everything after the first +.B .lzma +stream. +In most situations, this is a bug. +This also means that LZMA Utils +don't support decompressing concatenated +.B .lzma +files. +.PP +If there is data left after the first +.B .lzma +stream, +.B xz +considers the file to be corrupt unless +.B \-\-single\-stream +was used. +This may break obscure scripts which have +assumed that trailing garbage is ignored. +. +.SH NOTES +. +.SS "Compressed output may vary" +The exact compressed output produced from +the same uncompressed input file +may vary between XZ Utils versions even if +compression options are identical. +This is because the encoder can be improved +(faster or better compression) +without affecting the file format. +The output can vary even between different +builds of the same XZ Utils version, +if different build options are used. +.PP +The above means that once +.B \-\-rsyncable +has been implemented, +the resulting files won't necessarily be rsyncable +unless both old and new files have been compressed +with the same xz version. +This problem can be fixed if a part of the encoder +implementation is frozen to keep rsyncable output +stable across xz versions. +. +.SS "Embedded .xz decompressors" +Embedded +.B .xz +decompressor implementations like XZ Embedded don't necessarily +support files created with integrity +.I check +types other than +.B none +and +.BR crc32 . +Since the default is +.BR \-\-check=crc64 , +you must use +.B \-\-check=none +or +.B \-\-check=crc32 +when creating files for embedded systems. +.PP +Outside embedded systems, all +.B .xz +format decompressors support all the +.I check +types, or at least are able to decompress +the file without verifying the +integrity check if the particular +.I check +is not supported. +.PP +XZ Embedded supports BCJ filters, +but only with the default start offset. +. +.SH EXAMPLES +. +.SS Basics +Compress the file +.I foo +into +.I foo.xz +using the default compression level +.RB ( \-6 ), +and remove +.I foo +if compression is successful: +.RS +.PP +.nf +.ft CR +xz foo +.ft R +.fi +.RE +.PP +Decompress +.I bar.xz +into +.I bar +and don't remove +.I bar.xz +even if decompression is successful: +.RS +.PP +.nf +.ft CR +xz \-dk bar.xz +.ft R +.fi +.RE +.PP +Create +.I baz.tar.xz +with the preset +.B \-4e +.RB ( "\-4 \-\-extreme" ), +which is slower than the default +.BR \-6 , +but needs less memory for compression and decompression (48\ MiB +and 5\ MiB, respectively): +.RS +.PP +.nf +.ft CR +tar cf \- baz | xz \-4e > baz.tar.xz +.ft R +.fi +.RE +.PP +A mix of compressed and uncompressed files can be decompressed +to standard output with a single command: +.RS +.PP +.nf +.ft CR +xz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt +.ft R +.fi +.RE +. +.SS "Parallel compression of many files" +On GNU and *BSD, +.BR find (1) +and +.BR xargs (1) +can be used to parallelize compression of many files: +.RS +.PP +.nf +.ft CR +find . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1 +.ft R +.fi +.RE +.PP +The +.B \-P +option to +.BR xargs (1) +sets the number of parallel +.B xz +processes. +The best value for the +.B \-n +option depends on how many files there are to be compressed. +If there are only a couple of files, +the value should probably be 1; +with tens of thousands of files, +100 or even more may be appropriate to reduce the number of +.B xz +processes that +.BR xargs (1) +will eventually create. +.PP +The option +.B \-T1 +for +.B xz +is there to force it to single-threaded mode, because +.BR xargs (1) +is used to control the amount of parallelization. +. +.SS "Robot mode" +Calculate how many bytes have been saved in total +after compressing multiple files: +.RS +.PP +.nf +.ft CR +xz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}' +.ft R +.fi +.RE +.PP +A script may want to know that it is using new enough +.BR xz . +The following +.BR sh (1) +script checks that the version number of the +.B xz +tool is at least 5.0.0. +This method is compatible with old beta versions, +which didn't support the +.B \-\-robot +option: +.RS +.PP +.nf +.ft CR +if ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION +.ft R +.fi +.RE +.PP +Set a memory usage limit for decompression using +.BR XZ_OPT , +but if a limit has already been set, don't increase it: +.RS +.PP +.nf +.ft CR +NEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi +.ft R +.fi +.RE +. +.SS "Custom compressor filter chains" +The simplest use for custom filter chains is +customizing a LZMA2 preset. +This can be useful, +because the presets cover only a subset of the +potentially useful combinations of compression settings. +.PP +The CompCPU columns of the tables +from the descriptions of the options +.BR "\-0" " ... " "\-9" +and +.B \-\-extreme +are useful when customizing LZMA2 presets. +Here are the relevant parts collected from those two tables: +.RS +.PP +.TS +tab(;); +c c +n n. +Preset;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +If you know that a file requires +somewhat big dictionary (for example, 32\ MiB) to compress well, +but you want to compress it quicker than +.B "xz \-8" +would do, a preset with a low CompCPU value (for example, 1) +can be modified to use a bigger dictionary: +.RS +.PP +.nf +.ft CR +xz \-\-lzma2=preset=1,dict=32MiB foo.tar +.ft R +.fi +.RE +.PP +With certain files, the above command may be faster than +.B "xz \-6" +while compressing significantly better. +However, it must be emphasized that only some files benefit from +a big dictionary while keeping the CompCPU value low. +The most obvious situation, +where a big dictionary can help a lot, +is an archive containing very similar files +of at least a few megabytes each. +The dictionary size has to be significantly bigger +than any individual file to allow LZMA2 to take +full advantage of the similarities between consecutive files. +.PP +If very high compressor and decompressor memory usage is fine, +and the file being compressed is +at least several hundred megabytes, it may be useful +to use an even bigger dictionary than the 64 MiB that +.B "xz \-9" +would use: +.RS +.PP +.nf +.ft CR +xz \-vv \-\-lzma2=dict=192MiB big_foo.tar +.ft R +.fi +.RE +.PP +Using +.B \-vv +.RB ( "\-\-verbose \-\-verbose" ) +like in the above example can be useful +to see the memory requirements +of the compressor and decompressor. +Remember that using a dictionary bigger than +the size of the uncompressed file is waste of memory, +so the above command isn't useful for small files. +.PP +Sometimes the compression time doesn't matter, +but the decompressor memory usage has to be kept low, for example, +to make it possible to decompress the file on an embedded system. +The following command uses +.B \-6e +.RB ( "\-6 \-\-extreme" ) +as a base and sets the dictionary to only 64\ KiB. +The resulting file can be decompressed with XZ Embedded +(that's why there is +.BR \-\-check=crc32 ) +using about 100\ KiB of memory. +.RS +.PP +.nf +.ft CR +xz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo +.ft R +.fi +.RE +.PP +If you want to squeeze out as many bytes as possible, +adjusting the number of literal context bits +.RI ( lc ) +and number of position bits +.RI ( pb ) +can sometimes help. +Adjusting the number of literal position bits +.RI ( lp ) +might help too, but usually +.I lc +and +.I pb +are more important. +For example, a source code archive contains mostly US-ASCII text, +so something like the following might give +slightly (like 0.1\ %) smaller file than +.B "xz \-6e" +(try also without +.BR lc=4 ): +.RS +.PP +.nf +.ft CR +xz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar +.ft R +.fi +.RE +.PP +Using another filter together with LZMA2 can improve +compression with certain file types. +For example, to compress a x86-32 or x86-64 shared library +using the x86 BCJ filter: +.RS +.PP +.nf +.ft CR +xz \-\-x86 \-\-lzma2 libfoo.so +.ft R +.fi +.RE +.PP +Note that the order of the filter options is significant. +If +.B \-\-x86 +is specified after +.BR \-\-lzma2 , +.B xz +will give an error, +because there cannot be any filter after LZMA2, +and also because the x86 BCJ filter cannot be used +as the last filter in the chain. +.PP +The Delta filter together with LZMA2 +can give good results with bitmap images. +It should usually beat PNG, +which has a few more advanced filters than simple +delta but uses Deflate for the actual compression. +.PP +The image has to be saved in uncompressed format, +for example, as uncompressed TIFF. +The distance parameter of the Delta filter is set +to match the number of bytes per pixel in the image. +For example, 24-bit RGB bitmap needs +.BR dist=3 , +and it is also good to pass +.B pb=0 +to LZMA2 to accommodate the three-byte alignment: +.RS +.PP +.nf +.ft CR +xz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff +.ft R +.fi +.RE +.PP +If multiple images have been put into a single archive (for example, +.BR .tar ), +the Delta filter will work on that too as long as all images +have the same number of bytes per pixel. +. +.SH "SEE ALSO" +.BR xzdec (1), +.BR xzdiff (1), +.BR xzgrep (1), +.BR xzless (1), +.BR xzmore (1), +.BR gzip (1), +.BR bzip2 (1), +.BR 7z (1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xzcat.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xzcat.1 new file mode 100644 index 0000000000000000000000000000000000000000..6e37b426a3b5c85552cf006f388c9a71d4ad5685 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xzcat.1 @@ -0,0 +1,3264 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.TH XZ 1 "2025-03-08" "Tukaani" "XZ Utils" +. +.SH NAME +xz, unxz, xzcat, lzma, unlzma, lzcat \- Compress or decompress .xz and .lzma files +. +.SH SYNOPSIS +.B xz +.RI [ option... ] +.RI [ file... ] +. +.SH COMMAND ALIASES +.B unxz +is equivalent to +.BR "xz \-\-decompress" . +.br +.B xzcat +is equivalent to +.BR "xz \-\-decompress \-\-stdout" . +.br +.B lzma +is equivalent to +.BR "xz \-\-format=lzma" . +.br +.B unlzma +is equivalent to +.BR "xz \-\-format=lzma \-\-decompress" . +.br +.B lzcat +is equivalent to +.BR "xz \-\-format=lzma \-\-decompress \-\-stdout" . +.PP +When writing scripts that need to decompress files, +it is recommended to always use the name +.B xz +with appropriate arguments +.RB ( "xz \-d" +or +.BR "xz \-dc" ) +instead of the names +.B unxz +and +.BR xzcat . +. +.SH DESCRIPTION +.B xz +is a general-purpose data compression tool with +command line syntax similar to +.BR gzip (1) +and +.BR bzip2 (1). +The native file format is the +.B .xz +format, but the legacy +.B .lzma +format used by LZMA Utils and +raw compressed streams with no container format headers +are also supported. +In addition, decompression of the +.B .lz +format used by +.B lzip +is supported. +.PP +.B xz +compresses or decompresses each +.I file +according to the selected operation mode. +If no +.I files +are given or +.I file +is +.BR \- , +.B xz +reads from standard input and writes the processed data +to standard output. +.B xz +will refuse (display an error and skip the +.IR file ) +to write compressed data to standard output if it is a terminal. +Similarly, +.B xz +will refuse to read compressed data +from standard input if it is a terminal. +.PP +Unless +.B \-\-stdout +is specified, +.I files +other than +.B \- +are written to a new file whose name is derived from the source +.I file +name: +.IP \(bu 3 +When compressing, the suffix of the target file format +.RB ( .xz +or +.BR .lzma ) +is appended to the source filename to get the target filename. +.IP \(bu 3 +When decompressing, the +.BR .xz , +.BR .lzma , +or +.B .lz +suffix is removed from the filename to get the target filename. +.B xz +also recognizes the suffixes +.B .txz +and +.BR .tlz , +and replaces them with the +.B .tar +suffix. +.PP +If the target file already exists, an error is displayed and the +.I file +is skipped. +.PP +Unless writing to standard output, +.B xz +will display a warning and skip the +.I file +if any of the following applies: +.IP \(bu 3 +.I File +is not a regular file. +Symbolic links are not followed, +and thus they are not considered to be regular files. +.IP \(bu 3 +.I File +has more than one hard link. +.IP \(bu 3 +.I File +has setuid, setgid, or sticky bit set. +.IP \(bu 3 +The operation mode is set to compress and the +.I file +already has a suffix of the target file format +.RB ( .xz +or +.B .txz +when compressing to the +.B .xz +format, and +.B .lzma +or +.B .tlz +when compressing to the +.B .lzma +format). +.IP \(bu 3 +The operation mode is set to decompress and the +.I file +doesn't have a suffix of any of the supported file formats +.RB ( .xz , +.BR .txz , +.BR .lzma , +.BR .tlz , +or +.BR .lz ). +.PP +After successfully compressing or decompressing the +.IR file , +.B xz +copies the owner, group, permissions, access time, +and modification time from the source +.I file +to the target file. +If copying the group fails, the permissions are modified +so that the target file doesn't become accessible to users +who didn't have permission to access the source +.IR file . +.B xz +doesn't support copying other metadata like access control lists +or extended attributes yet. +.PP +Once the target file has been successfully closed, the source +.I file +is removed unless +.B \-\-keep +was specified. +The source +.I file +is never removed if the output is written to standard output +or if an error occurs. +.PP +Sending +.B SIGINFO +or +.B SIGUSR1 +to the +.B xz +process makes it print progress information to standard error. +This has only limited use since when standard error +is a terminal, using +.B \-\-verbose +will display an automatically updating progress indicator. +. +.SS "Memory usage" +The memory usage of +.B xz +varies from a few hundred kilobytes to several gigabytes +depending on the compression settings. +The settings used when compressing a file determine +the memory requirements of the decompressor. +Typically the decompressor needs 5\ % to 20\ % of +the amount of memory that the compressor needed when +creating the file. +For example, decompressing a file created with +.B xz \-9 +currently requires 65\ MiB of memory. +Still, it is possible to have +.B .xz +files that require several gigabytes of memory to decompress. +.PP +Especially users of older systems may find +the possibility of very large memory usage annoying. +To prevent uncomfortable surprises, +.B xz +has a built-in memory usage limiter, which is disabled by default. +While some operating systems provide ways to limit +the memory usage of processes, relying on it +wasn't deemed to be flexible enough (for example, using +.BR ulimit (1) +to limit virtual memory tends to cripple +.BR mmap (2)). +.PP +The memory usage limiter can be enabled with +the command line option \fB\-\-memlimit=\fIlimit\fR. +Often it is more convenient to enable the limiter +by default by setting the environment variable +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +.BR XZ_DEFAULTS , +for example, +.BR XZ_DEFAULTS=\-\-memlimit=150MiB . +It is possible to set the limits separately +for compression and decompression by using +.BI \-\-memlimit\-compress= limit +and \fB\-\-memlimit\-decompress=\fIlimit\fR. +Using these two options outside +.B XZ_DEFAULTS +is rarely useful because a single run of +.B xz +cannot do both compression and decompression and +.BI \-\-memlimit= limit +(or +.B \-M +.IR limit ) +is shorter to type on the command line. +.PP +If the specified memory usage limit is exceeded when decompressing, +.B xz +will display an error and decompressing the file will fail. +If the limit is exceeded when compressing, +.B xz +will try to scale the settings down so that the limit +is no longer exceeded (except when using +.B \-\-format=raw +or +.BR \-\-no\-adjust ). +This way the operation won't fail unless the limit is very small. +The scaling of the settings is done in steps that don't +match the compression level presets, for example, if the limit is +only slightly less than the amount required for +.BR "xz \-9" , +the settings will be scaled down only a little, +not all the way down to +.BR "xz \-8" . +. +.SS "Concatenation and padding with .xz files" +It is possible to concatenate +.B .xz +files as is. +.B xz +will decompress such files as if they were a single +.B .xz +file. +.PP +It is possible to insert padding between the concatenated parts +or after the last part. +The padding must consist of null bytes and the size +of the padding must be a multiple of four bytes. +This can be useful, for example, if the +.B .xz +file is stored on a medium that measures file sizes +in 512-byte blocks. +.PP +Concatenation and padding are not allowed with +.B .lzma +files or raw streams. +. +.SH OPTIONS +. +.SS "Integer suffixes and special values" +In most places where an integer argument is expected, +an optional suffix is supported to easily indicate large integers. +There must be no space between the integer and the suffix. +.TP +.B KiB +Multiply the integer by 1,024 (2^10). +.BR Ki , +.BR k , +.BR kB , +.BR K , +and +.B KB +are accepted as synonyms for +.BR KiB . +.TP +.B MiB +Multiply the integer by 1,048,576 (2^20). +.BR Mi , +.BR m , +.BR M , +and +.B MB +are accepted as synonyms for +.BR MiB . +.TP +.B GiB +Multiply the integer by 1,073,741,824 (2^30). +.BR Gi , +.BR g , +.BR G , +and +.B GB +are accepted as synonyms for +.BR GiB . +.PP +The special value +.B max +can be used to indicate the maximum integer value +supported by the option. +. +.SS "Operation mode" +If multiple operation mode options are given, +the last one takes effect. +.TP +.BR \-z ", " \-\-compress +Compress. +This is the default operation mode when no operation mode option +is specified and no other operation mode is implied from +the command name (for example, +.B unxz +implies +.BR \-\-decompress ). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +After successful compression, the source file is removed +unless writing to standard output or +.B \-\-keep +was specified. +.TP +.BR \-d ", " \-\-decompress ", " \-\-uncompress +Decompress. +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +After successful decompression, the source file is removed +unless writing to standard output or +.B \-\-keep +was specified. +.TP +.BR \-t ", " \-\-test +Test the integrity of compressed +.IR files . +This option is equivalent to +.B "\-\-decompress \-\-stdout" +except that the decompressed data is discarded instead of being +written to standard output. +No files are created or removed. +.TP +.BR \-l ", " \-\-list +Print information about compressed +.IR files . +No uncompressed output is produced, +and no files are created or removed. +In list mode, the program cannot read +the compressed data from standard +input or from other unseekable sources. +.IP "" +The default listing shows basic information about +.IR files , +one file per line. +To get more detailed information, use also the +.B \-\-verbose +option. +For even more information, use +.B \-\-verbose +twice, but note that this may be slow, because getting all the extra +information requires many seeks. +The width of verbose output exceeds +80 characters, so piping the output to, for example, +.B "less\ \-S" +may be convenient if the terminal isn't wide enough. +.IP "" +The exact output may vary between +.B xz +versions and different locales. +For machine-readable output, +.B \-\-robot \-\-list +should be used. +. +.SS "Operation modifiers" +.TP +.BR \-k ", " \-\-keep +Don't delete the input files. +.IP "" +Since +.B xz +5.2.6, +this option also makes +.B xz +compress or decompress even if the input is +a symbolic link to a regular file, +has more than one hard link, +or has the setuid, setgid, or sticky bit set. +The setuid, setgid, and sticky bits are not copied +to the target file. +In earlier versions this was only done with +.BR \-\-force . +.TP +.BR \-f ", " \-\-force +This option has several effects: +.RS +.IP \(bu 3 +If the target file already exists, +delete it before compressing or decompressing. +.IP \(bu 3 +Compress or decompress even if the input is +a symbolic link to a regular file, +has more than one hard link, +or has the setuid, setgid, or sticky bit set. +The setuid, setgid, and sticky bits are not copied +to the target file. +.IP \(bu 3 +When used with +.B \-\-decompress +.B \-\-stdout +and +.B xz +cannot recognize the type of the source file, +copy the source file as is to standard output. +This allows +.B xzcat +.B \-\-force +to be used like +.BR cat (1) +for files that have not been compressed with +.BR xz . +Note that in future, +.B xz +might support new compressed file formats, which may make +.B xz +decompress more types of files instead of copying them as is to +standard output. +.BI \-\-format= format +can be used to restrict +.B xz +to decompress only a single file format. +.RE +.TP +.BR \-c ", " \-\-stdout ", " \-\-to\-stdout +Write the compressed or decompressed data to +standard output instead of a file. +This implies +.BR \-\-keep . +.TP +.B \-\-single\-stream +Decompress only the first +.B .xz +stream, and +silently ignore possible remaining input data following the stream. +Normally such trailing garbage makes +.B xz +display an error. +.IP "" +.B xz +never decompresses more than one stream from +.B .lzma +files or raw streams, but this option still makes +.B xz +ignore the possible trailing data after the +.B .lzma +file or raw stream. +.IP "" +This option has no effect if the operation mode is not +.B \-\-decompress +or +.BR \-\-test . +.IP "" +Since +.B xz +5.7.1alpha, +.B \-\-single\-stream +implies +.BR \-\-keep . +.TP +.B \-\-no\-sparse +Disable creation of sparse files. +By default, if decompressing into a regular file, +.B xz +tries to make the file sparse if the decompressed data contains +long sequences of binary zeros. +It also works when writing to standard output +as long as standard output is connected to a regular file +and certain additional conditions are met to make it safe. +Creating sparse files may save disk space and speed up +the decompression by reducing the amount of disk I/O. +.TP +\fB\-S\fR \fI.suf\fR, \fB\-\-suffix=\fI.suf +When compressing, use +.I .suf +as the suffix for the target file instead of +.B .xz +or +.BR .lzma . +If not writing to standard output and +the source file already has the suffix +.IR .suf , +a warning is displayed and the file is skipped. +.IP "" +When decompressing, recognize files with the suffix +.I .suf +in addition to files with the +.BR .xz , +.BR .txz , +.BR .lzma , +.BR .tlz , +or +.B .lz +suffix. +If the source file has the suffix +.IR .suf , +the suffix is removed to get the target filename. +.IP "" +When compressing or decompressing raw streams +.RB ( \-\-format=raw ), +the suffix must always be specified unless +writing to standard output, +because there is no default suffix for raw streams. +.TP +\fB\-\-files\fR[\fB=\fIfile\fR] +Read the filenames to process from +.IR file ; +if +.I file +is omitted, filenames are read from standard input. +Filenames must be terminated with the newline character. +A dash +.RB ( \- ) +is taken as a regular filename; it doesn't mean standard input. +If filenames are given also as command line arguments, they are +processed before the filenames read from +.IR file . +.TP +\fB\-\-files0\fR[\fB=\fIfile\fR] +This is identical to \fB\-\-files\fR[\fB=\fIfile\fR] except +that each filename must be terminated with the null character. +. +.SS "Basic file format and compression options" +.TP +\fB\-F\fR \fIformat\fR, \fB\-\-format=\fIformat +Specify the file +.I format +to compress or decompress: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +.B auto +This is the default. +When compressing, +.B auto +is equivalent to +.BR xz . +When decompressing, +the format of the input file is automatically detected. +Note that raw streams (created with +.BR \-\-format=raw ) +cannot be auto-detected. +.TP +.B xz +Compress to the +.B .xz +file format, or accept only +.B .xz +files when decompressing. +.TP +.BR lzma ", " alone +Compress to the legacy +.B .lzma +file format, or accept only +.B .lzma +files when decompressing. +The alternative name +.B alone +is provided for backwards compatibility with LZMA Utils. +.TP +.B lzip +Accept only +.B .lz +files when decompressing. +Compression is not supported. +.IP "" +The +.B .lz +format versions 0 and 1 are supported. +Version 0 files were produced by +.B lzip +1.3 and older. +Such files aren't common but may be found from file archives +as a few source packages were released in this format. +People might have old personal files in this format too. +Decompression support for the format version 0 was removed in +.B lzip +1.18. +.B lzip +1.4 and later create files in the format version 1. +.TP +.B raw +Compress or uncompress a raw stream (no headers). +This is meant for advanced users only. +To decode raw streams, you need use +.B \-\-format=raw +and explicitly specify the filter chain, +which normally would have been stored in the container headers. +.RE +.TP +\fB\-C\fR \fIcheck\fR, \fB\-\-check=\fIcheck +Specify the type of the integrity check. +The check is calculated from the uncompressed data and +stored in the +.B .xz +file. +This option has an effect only when compressing into the +.B .xz +format; the +.B .lzma +format doesn't support integrity checks. +The integrity check (if any) is verified when the +.B .xz +file is decompressed. +.IP "" +Supported +.I check +types: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +.B none +Don't calculate an integrity check at all. +This is usually a bad idea. +This can be useful when integrity of the data is verified +by other means anyway. +.TP +.B crc32 +Calculate CRC32 using the polynomial from IEEE-802.3 (Ethernet). +.TP +.B crc64 +Calculate CRC64 using the polynomial from ECMA-182. +This is the default, since it is slightly better than CRC32 +at detecting damaged files and the speed difference is negligible. +.TP +.B sha256 +Calculate SHA-256. +This is somewhat slower than CRC32 and CRC64. +.RE +.IP "" +Integrity of the +.B .xz +headers is always verified with CRC32. +It is not possible to change or disable it. +.TP +.B \-\-ignore\-check +Don't verify the integrity check of the compressed data when decompressing. +The CRC32 values in the +.B .xz +headers will still be verified normally. +.IP "" +.B "Do not use this option unless you know what you are doing." +Possible reasons to use this option: +.RS +.IP \(bu 3 +Trying to recover data from a corrupt .xz file. +.IP \(bu 3 +Speeding up decompression. +This matters mostly with SHA-256 or +with files that have compressed extremely well. +It's recommended to not use this option for this purpose +unless the file integrity is verified externally in some other way. +.RE +.TP +.BR \-0 " ... " \-9 +Select a compression preset level. +The default is +.BR \-6 . +If multiple preset levels are specified, +the last one takes effect. +If a custom filter chain was already specified, setting +a compression preset level clears the custom filter chain. +.IP "" +The differences between the presets are more significant than with +.BR gzip (1) +and +.BR bzip2 (1). +The selected compression settings determine +the memory requirements of the decompressor, +thus using a too high preset level might make it painful +to decompress the file on an old system with little RAM. +Specifically, +.B "it's not a good idea to blindly use \-9 for everything" +like it often is with +.BR gzip (1) +and +.BR bzip2 (1). +.RS +.TP +.BR "\-0" " ... " "\-3" +These are somewhat fast presets. +.B \-0 +is sometimes faster than +.B "gzip \-9" +while compressing much better. +The higher ones often have speed comparable to +.BR bzip2 (1) +with comparable or better compression ratio, +although the results +depend a lot on the type of data being compressed. +.TP +.BR "\-4" " ... " "\-6" +Good to very good compression while keeping +decompressor memory usage reasonable even for old systems. +.B \-6 +is the default, which is usually a good choice +for distributing files that need to be decompressible +even on systems with only 16\ MiB RAM. +.RB ( \-5e +or +.B \-6e +may be worth considering too. +See +.BR \-\-extreme .) +.TP +.B "\-7 ... \-9" +These are like +.B \-6 +but with higher compressor and decompressor memory requirements. +These are useful only when compressing files bigger than +8\ MiB, 16\ MiB, and 32\ MiB, respectively. +.RE +.IP "" +On the same hardware, the decompression speed is approximately +a constant number of bytes of compressed data per second. +In other words, the better the compression, +the faster the decompression will usually be. +This also means that the amount of uncompressed output +produced per second can vary a lot. +.IP "" +The following table summarises the features of the presets: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Preset;DictSize;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Column descriptions: +.RS +.IP \(bu 3 +DictSize is the LZMA2 dictionary size. +It is waste of memory to use a dictionary bigger than +the size of the uncompressed file. +This is why it is good to avoid using the presets +.BR \-7 " ... " \-9 +when there's no real need for them. +At +.B \-6 +and lower, the amount of memory wasted is +usually low enough to not matter. +.IP \(bu 3 +CompCPU is a simplified representation of the LZMA2 settings +that affect compression speed. +The dictionary size affects speed too, +so while CompCPU is the same for levels +.BR \-6 " ... " \-9 , +higher levels still tend to be a little slower. +To get even slower and thus possibly better compression, see +.BR \-\-extreme . +.IP \(bu 3 +CompMem contains the compressor memory requirements +in the single-threaded mode. +It may vary slightly between +.B xz +versions. +.IP \(bu 3 +DecMem contains the decompressor memory requirements. +That is, the compression settings determine +the memory requirements of the decompressor. +The exact decompressor memory usage is slightly more than +the LZMA2 dictionary size, but the values in the table +have been rounded up to the next full MiB. +.RE +.IP "" +Memory requirements of the multi-threaded mode are +significantly higher than that of the single-threaded mode. +With the default value of +.BR \-\-block\-size , +each thread needs 3*3*DictSize plus CompMem or DecMem. +For example, four threads with preset +.B \-6 +needs 660\(en670\ MiB of memory. +.TP +.BR \-e ", " \-\-extreme +Use a slower variant of the selected compression preset level +.RB ( \-0 " ... " \-9 ) +to hopefully get a little bit better compression ratio, +but with bad luck this can also make it worse. +Decompressor memory usage is not affected, +but compressor memory usage increases a little at preset levels +.BR \-0 " ... " \-3 . +.IP "" +Since there are two presets with dictionary sizes +4\ MiB and 8\ MiB, the presets +.B \-3e +and +.B \-5e +use slightly faster settings (lower CompCPU) than +.B \-4e +and +.BR \-6e , +respectively. +That way no two presets are identical. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Preset;DictSize;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +For example, there are a total of four presets that use +8\ MiB dictionary, whose order from the fastest to the slowest is +.BR \-5 , +.BR \-6 , +.BR \-5e , +and +.BR \-6e . +.TP +.B \-\-fast +.PD 0 +.TP +.B \-\-best +.PD +These are somewhat misleading aliases for +.B \-0 +and +.BR \-9 , +respectively. +These are provided only for backwards compatibility +with LZMA Utils. +Avoid using these options. +.TP +.BI \-\-block\-size= size +When compressing to the +.B .xz +format, split the input data into blocks of +.I size +bytes. +The blocks are compressed independently from each other, +which helps with multi-threading and +makes limited random-access decompression possible. +This option is typically used to override the default +block size in multi-threaded mode, +but this option can be used in single-threaded mode too. +.IP "" +In multi-threaded mode about three times +.I size +bytes will be allocated in each thread for buffering input and output. +The default +.I size +is three times the LZMA2 dictionary size or 1 MiB, +whichever is more. +Typically a good value is 2\(en4 times +the size of the LZMA2 dictionary or at least 1 MiB. +Using +.I size +less than the LZMA2 dictionary size is waste of RAM +because then the LZMA2 dictionary buffer will never get fully used. +In multi-threaded mode, +the sizes of the blocks are stored in the block headers. +This size information is required for multi-threaded decompression. +.IP "" +In single-threaded mode no block splitting is done by default. +Setting this option doesn't affect memory usage. +No size information is stored in block headers, +thus files created in single-threaded mode +won't be identical to files created in multi-threaded mode. +The lack of size information also means that +.B xz +won't be able decompress the files in multi-threaded mode. +.TP +.BI \-\-block\-list= items +When compressing to the +.B .xz +format, start a new block with an optional custom filter chain after +the given intervals of uncompressed data. +.IP "" +The +.I items +are a comma-separated list. +Each item consists of an optional filter chain number +between 0 and 9 followed by a colon +.RB ( : ) +and a required size of uncompressed data. +Omitting an item (two or more consecutive commas) is a +shorthand to use the size and filters of the previous item. +.IP "" +If the input file is bigger than the sum of +the sizes in +.IR items , +the last item is repeated until the end of the file. +A special value of +.B 0 +may be used as the last size to indicate that +the rest of the file should be encoded as a single block. +.IP "" +An alternative filter chain for each block can be +specified in combination with the +.BI \-\-filters1= filters +\&...\& +.BI \-\-filters9= filters +options. +These options define filter chains with an identifier +between 1\(en9. +Filter chain 0 can be used to refer to the default filter chain, +which is the same as not specifying a filter chain. +The filter chain identifier can be used before the uncompressed +size, followed by a colon +.RB ( : ). +For example, if one specifies +.B \-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB +then blocks will be created using: +.RS +.IP \(bu 3 +The filter chain specified by +.B \-\-filters1 +and 2 MiB input +.IP \(bu 3 +The filter chain specified by +.B \-\-filters3 +and 2 MiB input +.IP \(bu 3 +The filter chain specified by +.B \-\-filters2 +and 4 MiB input +.IP \(bu 3 +The filter chain specified by +.B \-\-filters2 +and 4 MiB input +.IP \(bu 3 +The default filter chain and 2 MiB input +.IP \(bu 3 +The default filter chain and 4 MiB input for every block until +end of input. +.RE +.IP "" +If one specifies a size that exceeds the encoder's block size +(either the default value in threaded mode or +the value specified with \fB\-\-block\-size=\fIsize\fR), +the encoder will create additional blocks while +keeping the boundaries specified in +.IR items . +For example, if one specifies +.B \-\-block\-size=10MiB +.B \-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB +and the input file is 80 MiB, +one will get 11 blocks: +5, 10, 8, 10, 2, 10, 10, 4, 10, 10, and 1 MiB. +.IP "" +In multi-threaded mode the sizes of the blocks +are stored in the block headers. +This isn't done in single-threaded mode, +so the encoded output won't be +identical to that of the multi-threaded mode. +.TP +.BI \-\-flush\-timeout= timeout +When compressing, if more than +.I timeout +milliseconds (a positive integer) has passed since the previous flush and +reading more input would block, +all the pending input data is flushed from the encoder and +made available in the output stream. +This can be useful if +.B xz +is used to compress data that is streamed over a network. +Small +.I timeout +values make the data available at the receiving end +with a small delay, but large +.I timeout +values give better compression ratio. +.IP "" +This feature is disabled by default. +If this option is specified more than once, the last one takes effect. +The special +.I timeout +value of +.B 0 +can be used to explicitly disable this feature. +.IP "" +This feature is not available on non-POSIX systems. +.IP "" +.\" FIXME +.B "This feature is still experimental." +Currently +.B xz +is unsuitable for decompressing the stream in real time due to how +.B xz +does buffering. +.TP +.B \-\-no\-sync +Do not synchronize the target file and its directory +to the storage device before removing the source file. +This can improve performance if compressing or decompressing +many small files. +However, if the system crashes soon after the deletion, +it is possible that the target file was not written +to the storage device but the delete operation was. +In that case neither the original source file +nor the target file is available. +.IP "" +This option has an effect only when +.B xz +is going to remove the source file. +In other cases synchronization is never done. +.IP "" +The synchronization and +.B \-\-no\-sync +were added in +.B xz +5.7.1alpha. +.TP +.BI \-\-memlimit\-compress= limit +Set a memory usage limit for compression. +If this option is specified multiple times, +the last one takes effect. +.IP "" +If the compression settings exceed the +.IR limit , +.B xz +will attempt to adjust the settings downwards so that +the limit is no longer exceeded and display a notice that +automatic adjustment was done. +The adjustments are done in this order: +reducing the number of threads, +switching to single-threaded mode +if even one thread in multi-threaded mode exceeds the +.IR limit , +and finally reducing the LZMA2 dictionary size. +.IP "" +When compressing with +.B \-\-format=raw +or if +.B \-\-no\-adjust +has been specified, +only the number of threads may be reduced +since it can be done without affecting the compressed output. +.IP "" +If the +.I limit +cannot be met even with the adjustments described above, +an error is displayed and +.B xz +will exit with exit status 1. +.IP "" +The +.I limit +can be specified in multiple ways: +.RS +.IP \(bu 3 +The +.I limit +can be an absolute value in bytes. +Using an integer suffix like +.B MiB +can be useful. +Example: +.B "\-\-memlimit\-compress=80MiB" +.IP \(bu 3 +The +.I limit +can be specified as a percentage of total physical memory (RAM). +This can be useful especially when setting the +.B XZ_DEFAULTS +environment variable in a shell initialization script +that is shared between different computers. +That way the limit is automatically bigger +on systems with more memory. +Example: +.B "\-\-memlimit\-compress=70%" +.IP \(bu 3 +The +.I limit +can be reset back to its default value by setting it to +.BR 0 . +This is currently equivalent to setting the +.I limit +to +.B max +(no memory usage limit). +.RE +.IP "" +For 32-bit +.B xz +there is a special case: if the +.I limit +would be over +.BR "4020\ MiB" , +the +.I limit +is set to +.BR "4020\ MiB" . +On MIPS32 +.B "2000\ MiB" +is used instead. +(The values +.B 0 +and +.B max +aren't affected by this. +A similar feature doesn't exist for decompression.) +This can be helpful when a 32-bit executable has access +to 4\ GiB address space (2 GiB on MIPS32) +while hopefully doing no harm in other situations. +.IP "" +See also the section +.BR "Memory usage" . +.TP +.BI \-\-memlimit\-decompress= limit +Set a memory usage limit for decompression. +This also affects the +.B \-\-list +mode. +If the operation is not possible without exceeding the +.IR limit , +.B xz +will display an error and decompressing the file will fail. +See +.BI \-\-memlimit\-compress= limit +for possible ways to specify the +.IR limit . +.TP +.BI \-\-memlimit\-mt\-decompress= limit +Set a memory usage limit for multi-threaded decompression. +This can only affect the number of threads; +this will never make +.B xz +refuse to decompress a file. +If +.I limit +is too low to allow any multi-threading, the +.I limit +is ignored and +.B xz +will continue in single-threaded mode. +Note that if also +.B \-\-memlimit\-decompress +is used, +it will always apply to both single-threaded and multi-threaded modes, +and so the effective +.I limit +for multi-threading will never be higher than the limit set with +.BR \-\-memlimit\-decompress . +.IP "" +In contrast to the other memory usage limit options, +.BI \-\-memlimit\-mt\-decompress= limit +has a system-specific default +.IR limit . +.B "xz \-\-info\-memory" +can be used to see the current value. +.IP "" +This option and its default value exist +because without any limit the threaded decompressor +could end up allocating an insane amount of memory with some input files. +If the default +.I limit +is too low on your system, +feel free to increase the +.I limit +but never set it to a value larger than the amount of usable RAM +as with appropriate input files +.B xz +will attempt to use that amount of memory +even with a low number of threads. +Running out of memory or swapping +will not improve decompression performance. +.IP "" +See +.BI \-\-memlimit\-compress= limit +for possible ways to specify the +.IR limit . +Setting +.I limit +to +.B 0 +resets the +.I limit +to the default system-specific value. +.TP +\fB\-M\fR \fIlimit\fR, \fB\-\-memlimit=\fIlimit\fR, \fB\-\-memory=\fIlimit +This is equivalent to specifying +.BI \-\-memlimit\-compress= limit +.BI \-\-memlimit-decompress= limit +\fB\-\-memlimit\-mt\-decompress=\fIlimit\fR. +.TP +.B \-\-no\-adjust +Display an error and exit if the memory usage limit cannot be +met without adjusting settings that affect the compressed output. +That is, this prevents +.B xz +from switching the encoder from multi-threaded mode to single-threaded mode +and from reducing the LZMA2 dictionary size. +Even when this option is used the number of threads may be reduced +to meet the memory usage limit as that won't affect the compressed output. +.IP "" +Automatic adjusting is always disabled when creating raw streams +.RB ( \-\-format=raw ). +.TP +\fB\-T\fR \fIthreads\fR, \fB\-\-threads=\fIthreads +Specify the number of worker threads to use. +Setting +.I threads +to a special value +.B 0 +makes +.B xz +use up to as many threads as the processor(s) on the system support. +The actual number of threads can be fewer than +.I threads +if the input file is not big enough +for threading with the given settings or +if using more threads would exceed the memory usage limit. +.IP "" +The single-threaded and multi-threaded compressors produce different output. +Single-threaded compressor will give the smallest file size but +only the output from the multi-threaded compressor can be decompressed +using multiple threads. +Setting +.I threads +to +.B 1 +will use the single-threaded mode. +Setting +.I threads +to any other value, including +.BR 0 , +will use the multi-threaded compressor +even if the system supports only one hardware thread. +.RB ( xz +5.2.x +used single-threaded mode in this situation.) +.IP "" +To use multi-threaded mode with only one thread, set +.I threads +to +.BR +1 . +The +.B + +prefix has no effect with values other than +.BR 1 . +A memory usage limit can still make +.B xz +switch to single-threaded mode unless +.B \-\-no\-adjust +is used. +Support for the +.B + +prefix was added in +.B xz +5.4.0. +.IP "" +If an automatic number of threads has been requested and +no memory usage limit has been specified, +then a system-specific default soft limit will be used to possibly +limit the number of threads. +It is a soft limit in sense that it is ignored +if the number of threads becomes one, +thus a soft limit will never stop +.B xz +from compressing or decompressing. +This default soft limit will not make +.B xz +switch from multi-threaded mode to single-threaded mode. +The active limits can be seen with +.BR "xz \-\-info\-memory" . +.IP "" +Currently the only threading method is to split the input into +blocks and compress them independently from each other. +The default block size depends on the compression level and +can be overridden with the +.BI \-\-block\-size= size +option. +.IP "" +Threaded decompression only works on files that contain +multiple blocks with size information in block headers. +All large enough files compressed in multi-threaded mode +meet this condition, +but files compressed in single-threaded mode don't even if +.BI \-\-block\-size= size +has been used. +.IP "" +The default value for +.I threads +is +.BR 0 . +In +.B xz +5.4.x and older the default is +.BR 1 . +. +.SS "Custom compressor filter chains" +A custom filter chain allows specifying +the compression settings in detail instead of relying on +the settings associated to the presets. +When a custom filter chain is specified, +preset options +.RB ( \-0 +\&...\& +.B \-9 +and +.BR \-\-extreme ) +earlier on the command line are forgotten. +If a preset option is specified +after one or more custom filter chain options, +the new preset takes effect and +the custom filter chain options specified earlier are forgotten. +.PP +A filter chain is comparable to piping on the command line. +When compressing, the uncompressed input goes to the first filter, +whose output goes to the next filter (if any). +The output of the last filter gets written to the compressed file. +The maximum number of filters in the chain is four, +but typically a filter chain has only one or two filters. +.PP +Many filters have limitations on where they can be +in the filter chain: +some filters can work only as the last filter in the chain, +some only as a non-last filter, and some work in any position +in the chain. +Depending on the filter, this limitation is either inherent to +the filter design or exists to prevent security issues. +.PP +A custom filter chain can be specified in two different ways. +The options +.BI \-\-filters= filters +and +.BI \-\-filters1= filters +\&...\& +.BI \-\-filters9= filters +allow specifying an entire filter chain in one option using the +liblzma filter string syntax. +Alternatively, a filter chain can be specified by using one or more +individual filter options in the order they are wanted in the filter chain. +That is, the order of the individual filter options is significant! +When decoding raw streams +.RB ( \-\-format=raw ), +the filter chain must be specified in the same order as +it was specified when compressing. +Any individual filter or preset options specified before the full +chain option +(\fB\-\-filters=\fIfilters\fR) +will be forgotten. +Individual filters specified after the full chain option will reset the +filter chain. +.PP +Both the full and individual filter options take filter-specific +.I options +as a comma-separated list. +Extra commas in +.I options +are ignored. +Every option has a default value, so +specify those you want to change. +.PP +To see the whole filter chain and +.IR options , +use +.B "xz \-vv" +(that is, use +.B \-\-verbose +twice). +This works also for viewing the filter chain options used by presets. +.TP +.BI \-\-filters= filters +Specify the full filter chain or a preset in a single option. +Each filter can be separated by spaces or two dashes +.RB ( \-\- ). +.I filters +may need to be quoted on the shell command line so it is +parsed as a single option. +To denote +.IR options , +use +.B : +or +.BR = . +A preset can be prefixed with a +.B \- +and followed with zero or more flags. +The only supported flag is +.B e +to apply the same options as +.BR \-\-extreme . +.TP +\fB\-\-filters1\fR=\fIfilters\fR ... \fB\-\-filters9\fR=\fIfilters +Specify up to nine additional filter chains that can be used with +.BR \-\-block\-list . +.IP "" +For example, when compressing an archive with executable files +followed by text files, the executable part could use a filter +chain with a BCJ filter and the text part only the LZMA2 filter. +.TP +.B \-\-filters-help +Display a help message describing how to specify presets and +custom filter chains in the +.B \-\-filters +and +.BI \-\-filters1= filters +\&...\& +.BI \-\-filters9= filters +options, and exit successfully. +.TP +\fB\-\-lzma1\fR[\fB=\fIoptions\fR] +.PD 0 +.TP +\fB\-\-lzma2\fR[\fB=\fIoptions\fR] +.PD +Add LZMA1 or LZMA2 filter to the filter chain. +These filters can be used only as the last filter in the chain. +.IP "" +LZMA1 is a legacy filter, +which is supported almost solely due to the legacy +.B .lzma +file format, which supports only LZMA1. +LZMA2 is an updated +version of LZMA1 to fix some practical issues of LZMA1. +The +.B .xz +format uses LZMA2 and doesn't support LZMA1 at all. +Compression speed and ratios of LZMA1 and LZMA2 +are practically the same. +.IP "" +LZMA1 and LZMA2 share the same set of +.IR options : +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +.BI preset= preset +Reset all LZMA1 or LZMA2 +.I options +to +.IR preset . +.I Preset +consist of an integer, which may be followed by single-letter +preset modifiers. +The integer can be from +.B 0 +to +.BR 9 , +matching the command line options +.B \-0 +\&...\& +.BR \-9 . +The only supported modifier is currently +.BR e , +which matches +.BR \-\-extreme . +If no +.B preset +is specified, the default values of LZMA1 or LZMA2 +.I options +are taken from the preset +.BR 6 . +.TP +.BI dict= size +Dictionary (history buffer) +.I size +indicates how many bytes of the recently processed +uncompressed data is kept in memory. +The algorithm tries to find repeating byte sequences (matches) in +the uncompressed data, and replace them with references +to the data currently in the dictionary. +The bigger the dictionary, the higher is the chance +to find a match. +Thus, increasing dictionary +.I size +usually improves compression ratio, but +a dictionary bigger than the uncompressed file is waste of memory. +.IP "" +Typical dictionary +.I size +is from 64\ KiB to 64\ MiB. +The minimum is 4\ KiB. +The maximum for compression is currently 1.5\ GiB (1536\ MiB). +The decompressor already supports dictionaries up to +one byte less than 4\ GiB, which is the maximum for +the LZMA1 and LZMA2 stream formats. +.IP "" +Dictionary +.I size +and match finder +.RI ( mf ) +together determine the memory usage of the LZMA1 or LZMA2 encoder. +The same (or bigger) dictionary +.I size +is required for decompressing that was used when compressing, +thus the memory usage of the decoder is determined +by the dictionary size used when compressing. +The +.B .xz +headers store the dictionary +.I size +either as +.RI "2^" n +or +.RI "2^" n " + 2^(" n "\-1)," +so these +.I sizes +are somewhat preferred for compression. +Other +.I sizes +will get rounded up when stored in the +.B .xz +headers. +.TP +.BI lc= lc +Specify the number of literal context bits. +The minimum is 0 and the maximum is 4; the default is 3. +In addition, the sum of +.I lc +and +.I lp +must not exceed 4. +.IP "" +All bytes that cannot be encoded as matches +are encoded as literals. +That is, literals are simply 8-bit bytes +that are encoded one at a time. +.IP "" +The literal coding makes an assumption that the highest +.I lc +bits of the previous uncompressed byte correlate +with the next byte. +For example, in typical English text, an upper-case letter is +often followed by a lower-case letter, and a lower-case +letter is usually followed by another lower-case letter. +In the US-ASCII character set, the highest three bits are 010 +for upper-case letters and 011 for lower-case letters. +When +.I lc +is at least 3, the literal coding can take advantage of +this property in the uncompressed data. +.IP "" +The default value (3) is usually good. +If you want maximum compression, test +.BR lc=4 . +Sometimes it helps a little, and +sometimes it makes compression worse. +If it makes it worse, test +.B lc=2 +too. +.TP +.BI lp= lp +Specify the number of literal position bits. +The minimum is 0 and the maximum is 4; the default is 0. +.IP "" +.I Lp +affects what kind of alignment in the uncompressed data is +assumed when encoding literals. +See +.I pb +below for more information about alignment. +.TP +.BI pb= pb +Specify the number of position bits. +The minimum is 0 and the maximum is 4; the default is 2. +.IP "" +.I Pb +affects what kind of alignment in the uncompressed data is +assumed in general. +The default means four-byte alignment +.RI (2^ pb =2^2=4), +which is often a good choice when there's no better guess. +.IP "" +When the alignment is known, setting +.I pb +accordingly may reduce the file size a little. +For example, with text files having one-byte +alignment (US-ASCII, ISO-8859-*, UTF-8), setting +.B pb=0 +can improve compression slightly. +For UTF-16 text, +.B pb=1 +is a good choice. +If the alignment is an odd number like 3 bytes, +.B pb=0 +might be the best choice. +.IP "" +Even though the assumed alignment can be adjusted with +.I pb +and +.IR lp , +LZMA1 and LZMA2 still slightly favor 16-byte alignment. +It might be worth taking into account when designing file formats +that are likely to be often compressed with LZMA1 or LZMA2. +.TP +.BI mf= mf +Match finder has a major effect on encoder speed, +memory usage, and compression ratio. +Usually Hash Chain match finders are faster than Binary Tree +match finders. +The default depends on the +.IR preset : +0 uses +.BR hc3 , +1\(en3 +use +.BR hc4 , +and the rest use +.BR bt4 . +.IP "" +The following match finders are supported. +The memory usage formulas below are rough approximations, +which are closest to the reality when +.I dict +is a power of two. +.RS +.TP +.B hc3 +Hash Chain with 2- and 3-byte hashing +.br +Minimum value for +.IR nice : +3 +.br +Memory usage: +.br +.I dict +* 7.5 (if +.I dict +<= 16 MiB); +.br +.I dict +* 5.5 + 64 MiB (if +.I dict +> 16 MiB) +.TP +.B hc4 +Hash Chain with 2-, 3-, and 4-byte hashing +.br +Minimum value for +.IR nice : +4 +.br +Memory usage: +.br +.I dict +* 7.5 (if +.I dict +<= 32 MiB); +.br +.I dict +* 6.5 (if +.I dict +> 32 MiB) +.TP +.B bt2 +Binary Tree with 2-byte hashing +.br +Minimum value for +.IR nice : +2 +.br +Memory usage: +.I dict +* 9.5 +.TP +.B bt3 +Binary Tree with 2- and 3-byte hashing +.br +Minimum value for +.IR nice : +3 +.br +Memory usage: +.br +.I dict +* 11.5 (if +.I dict +<= 16 MiB); +.br +.I dict +* 9.5 + 64 MiB (if +.I dict +> 16 MiB) +.TP +.B bt4 +Binary Tree with 2-, 3-, and 4-byte hashing +.br +Minimum value for +.IR nice : +4 +.br +Memory usage: +.br +.I dict +* 11.5 (if +.I dict +<= 32 MiB); +.br +.I dict +* 10.5 (if +.I dict +> 32 MiB) +.RE +.TP +.BI mode= mode +Compression +.I mode +specifies the method to analyze +the data produced by the match finder. +Supported +.I modes +are +.B fast +and +.BR normal . +The default is +.B fast +for +.I presets +0\(en3 and +.B normal +for +.I presets +4\(en9. +.IP "" +Usually +.B fast +is used with Hash Chain match finders and +.B normal +with Binary Tree match finders. +This is also what the +.I presets +do. +.TP +.BI nice= nice +Specify what is considered to be a nice length for a match. +Once a match of at least +.I nice +bytes is found, the algorithm stops +looking for possibly better matches. +.IP "" +.I Nice +can be 2\(en273 bytes. +Higher values tend to give better compression ratio +at the expense of speed. +The default depends on the +.IR preset . +.TP +.BI depth= depth +Specify the maximum search depth in the match finder. +The default is the special value of 0, +which makes the compressor determine a reasonable +.I depth +from +.I mf +and +.IR nice . +.IP "" +Reasonable +.I depth +for Hash Chains is 4\(en100 and 16\(en1000 for Binary Trees. +Using very high values for +.I depth +can make the encoder extremely slow with some files. +Avoid setting the +.I depth +over 1000 unless you are prepared to interrupt +the compression in case it is taking far too long. +.RE +.IP "" +When decoding raw streams +.RB ( \-\-format=raw ), +LZMA2 needs only the dictionary +.IR size . +LZMA1 needs also +.IR lc , +.IR lp , +and +.IR pb . +.TP +\fB\-\-x86\fR[\fB=\fIoptions\fR] +.PD 0 +.TP +\fB\-\-arm\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-armthumb\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-arm64\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-powerpc\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-ia64\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-sparc\fR[\fB=\fIoptions\fR] +.TP +\fB\-\-riscv\fR[\fB=\fIoptions\fR] +.PD +Add a branch/call/jump (BCJ) filter to the filter chain. +These filters can be used only as a non-last filter +in the filter chain. +.IP "" +A BCJ filter converts relative addresses in +the machine code to their absolute counterparts. +This doesn't change the size of the data +but it increases redundancy, +which can help LZMA2 to produce 0\(en15\ % smaller +.B .xz +file. +The BCJ filters are always reversible, +so using a BCJ filter for wrong type of data +doesn't cause any data loss, although it may make +the compression ratio slightly worse. +The BCJ filters are very fast and +use an insignificant amount of memory. +.IP "" +These BCJ filters have known problems related to +the compression ratio: +.RS +.IP \(bu 3 +Some types of files containing executable code +(for example, object files, static libraries, and Linux kernel modules) +have the addresses in the instructions filled with filler values. +These BCJ filters will still do the address conversion, +which will make the compression worse with these files. +.IP \(bu 3 +If a BCJ filter is applied on an archive, +it is possible that it makes the compression ratio +worse than not using a BCJ filter. +For example, if there are similar or even identical executables +then filtering will likely make the files less similar +and thus compression is worse. +The contents of non-executable files in the same archive can matter too. +In practice one has to try with and without a BCJ filter to see +which is better in each situation. +.RE +.IP "" +Different instruction sets have different alignment: +the executable file must be aligned to a multiple of +this value in the input data to make the filter work. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filter;Alignment;Notes +x86;1;32-bit or 64-bit x86 +ARM;4; +ARM-Thumb;2; +ARM64;4;4096-byte alignment is best +PowerPC;4;Big endian only +IA-64;16;Itanium +SPARC;4; +RISC-V;2; +.TE +.RE +.RE +.IP "" +Since the BCJ-filtered data is usually compressed with LZMA2, +the compression ratio may be improved slightly if +the LZMA2 options are set to match the +alignment of the selected BCJ filter. +Examples: +.RS +.IP \(bu 3 +IA-64 filter has 16-byte alignment so +.B pb=4,lp=4,lc=0 +is good +with LZMA2 (2^4=16). +.IP \(bu 3 +RISC-V code has 2-byte or 4-byte alignment +depending on whether the file contains +16-bit compressed instructions (the C extension). +When 16-bit instructions are used, +.B pb=2,lp=1,lc=3 +or +.B pb=1,lp=1,lc=3 +is good. +When 16-bit instructions aren't present, +.B pb=2,lp=2,lc=2 +is the best. +.B readelf \-h +can be used to check if "RVC" +appears on the "Flags" line. +.IP \(bu 3 +ARM64 is always 4-byte aligned so +.B pb=2,lp=2,lc=2 +is the best. +.IP \(bu 3 +The x86 filter is an exception. +It's usually good to stick to LZMA2's defaults +.RB ( pb=2,lp=0,lc=3 ) +when compressing x86 executables. +.RE +.IP "" +All BCJ filters support the same +.IR options : +.RS +.TP +.BI start= offset +Specify the start +.I offset +that is used when converting between relative +and absolute addresses. +The +.I offset +must be a multiple of the alignment of the filter +(see the table above). +The default is zero. +In practice, the default is good; specifying a custom +.I offset +is almost never useful. +.RE +.TP +\fB\-\-delta\fR[\fB=\fIoptions\fR] +Add the Delta filter to the filter chain. +The Delta filter can be only used as a non-last filter +in the filter chain. +.IP "" +Currently only simple byte-wise delta calculation is supported. +It can be useful when compressing, for example, uncompressed bitmap images +or uncompressed PCM audio. +However, special purpose algorithms may give significantly better +results than Delta + LZMA2. +This is true especially with audio, +which compresses faster and better, for example, with +.BR flac (1). +.IP "" +Supported +.IR options : +.RS +.TP +.BI dist= distance +Specify the +.I distance +of the delta calculation in bytes. +.I distance +must be 1\(en256. +The default is 1. +.IP "" +For example, with +.B dist=2 +and eight-byte input A1 B1 A2 B3 A3 B5 A4 B7, the output will be +A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Other options" +.TP +.BR \-q ", " \-\-quiet +Suppress warnings and notices. +Specify this twice to suppress errors too. +This option has no effect on the exit status. +That is, even if a warning was suppressed, +the exit status to indicate a warning is still used. +.TP +.BR \-v ", " \-\-verbose +Be verbose. +If standard error is connected to a terminal, +.B xz +will display a progress indicator. +Specifying +.B \-\-verbose +twice will give even more verbose output. +.IP "" +The progress indicator shows the following information: +.RS +.IP \(bu 3 +Completion percentage is shown +if the size of the input file is known. +That is, the percentage cannot be shown in pipes. +.IP \(bu 3 +Amount of compressed data produced (compressing) +or consumed (decompressing). +.IP \(bu 3 +Amount of uncompressed data consumed (compressing) +or produced (decompressing). +.IP \(bu 3 +Compression ratio, which is calculated by dividing +the amount of compressed data processed so far by +the amount of uncompressed data processed so far. +.IP \(bu 3 +Compression or decompression speed. +This is measured as the amount of uncompressed data consumed +(compression) or produced (decompression) per second. +It is shown after a few seconds have passed since +.B xz +started processing the file. +.IP \(bu 3 +Elapsed time in the format M:SS or H:MM:SS. +.IP \(bu 3 +Estimated remaining time is shown +only when the size of the input file is +known and a couple of seconds have already passed since +.B xz +started processing the file. +The time is shown in a less precise format which +never has any colons, for example, 2 min 30 s. +.RE +.IP "" +When standard error is not a terminal, +.B \-\-verbose +will make +.B xz +print the filename, compressed size, uncompressed size, +compression ratio, and possibly also the speed and elapsed time +on a single line to standard error after compressing or +decompressing the file. +The speed and elapsed time are included only when +the operation took at least a few seconds. +If the operation didn't finish, for example, due to user interruption, +also the completion percentage is printed +if the size of the input file is known. +.TP +.BR \-Q ", " \-\-no\-warn +Don't set the exit status to 2 +even if a condition worth a warning was detected. +This option doesn't affect the verbosity level, thus both +.B \-\-quiet +and +.B \-\-no\-warn +have to be used to not display warnings and +to not alter the exit status. +.TP +.B \-\-robot +Print messages in a machine-parsable format. +This is intended to ease writing frontends that want to use +.B xz +instead of liblzma, which may be the case with various scripts. +The output with this option enabled is meant to be stable across +.B xz +releases. +See the section +.B "ROBOT MODE" +for details. +.TP +.B \-\-info\-memory +Display, in human-readable format, how much physical memory (RAM) +and how many processor threads +.B xz +thinks the system has and the memory usage limits for compression +and decompression, and exit successfully. +.TP +.BR \-h ", " \-\-help +Display a help message describing the most commonly used options, +and exit successfully. +.TP +.BR \-H ", " \-\-long\-help +Display a help message describing all features of +.BR xz , +and exit successfully +.TP +.BR \-V ", " \-\-version +Display the version number of +.B xz +and liblzma in human readable format. +To get machine-parsable output, specify +.B \-\-robot +before +.BR \-\-version . +. +.SH "ROBOT MODE" +The robot mode is activated with the +.B \-\-robot +option. +It makes the output of +.B xz +easier to parse by other programs. +Currently +.B \-\-robot +is supported only together with +.BR \-\-list , +.BR \-\-filters\-help , +.BR \-\-info\-memory , +and +.BR \-\-version . +It will be supported for compression and +decompression in the future. +. +.SS "List mode" +.B "xz \-\-robot \-\-list" +uses tab-separated output. +The first column of every line has a string +that indicates the type of the information found on that line: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +.B name +This is always the first line when starting to list a file. +The second column on the line is the filename. +.TP +.B file +This line contains overall information about the +.B .xz +file. +This line is always printed after the +.B name +line. +.TP +.B stream +This line type is used only when +.B \-\-verbose +was specified. +There are as many +.B stream +lines as there are streams in the +.B .xz +file. +.TP +.B block +This line type is used only when +.B \-\-verbose +was specified. +There are as many +.B block +lines as there are blocks in the +.B .xz +file. +The +.B block +lines are shown after all the +.B stream +lines; different line types are not interleaved. +.TP +.B summary +This line type is used only when +.B \-\-verbose +was specified twice. +This line is printed after all +.B block +lines. +Like the +.B file +line, the +.B summary +line contains overall information about the +.B .xz +file. +.TP +.B totals +This line is always the very last line of the list output. +It shows the total counts and sizes. +.PP +The columns of the +.B file +lines: +.PD 0 +.RS +.IP 2. 4 +Number of streams in the file +.IP 3. 4 +Total number of blocks in the stream(s) +.IP 4. 4 +Compressed size of the file +.IP 5. 4 +Uncompressed size of the file +.IP 6. 4 +Compression ratio, for example, +.BR 0.123 . +If ratio is over 9.999, three dashes +.RB ( \-\-\- ) +are displayed instead of the ratio. +.IP 7. 4 +Comma-separated list of integrity check names. +The following strings are used for the known check types: +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +.BR None , +.BR CRC32 , +.BR CRC64 , +and +.BR SHA\-256 . +For unknown check types, +.BI Unknown\- N +is used, where +.I N +is the Check ID as a decimal number (one or two digits). +.IP 8. 4 +Total size of stream padding in the file +.RE +.PD +.PP +The columns of the +.B stream +lines: +.PD 0 +.RS +.IP 2. 4 +Stream number (the first stream is 1) +.IP 3. 4 +Number of blocks in the stream +.IP 4. 4 +Compressed start offset +.IP 5. 4 +Uncompressed start offset +.IP 6. 4 +Compressed size (does not include stream padding) +.IP 7. 4 +Uncompressed size +.IP 8. 4 +Compression ratio +.IP 9. 4 +Name of the integrity check +.IP 10. 4 +Size of stream padding +.RE +.PD +.PP +The columns of the +.B block +lines: +.PD 0 +.RS +.IP 2. 4 +Number of the stream containing this block +.IP 3. 4 +Block number relative to the beginning of the stream +(the first block is 1) +.IP 4. 4 +Block number relative to the beginning of the file +.IP 5. 4 +Compressed start offset relative to the beginning of the file +.IP 6. 4 +Uncompressed start offset relative to the beginning of the file +.IP 7. 4 +Total compressed size of the block (includes headers) +.IP 8. 4 +Uncompressed size +.IP 9. 4 +Compression ratio +.IP 10. 4 +Name of the integrity check +.RE +.PD +.PP +If +.B \-\-verbose +was specified twice, additional columns are included on the +.B block +lines. +These are not displayed with a single +.BR \-\-verbose , +because getting this information requires many seeks +and can thus be slow: +.PD 0 +.RS +.IP 11. 4 +Value of the integrity check in hexadecimal +.IP 12. 4 +Block header size +.IP 13. 4 +Block flags: +.B c +indicates that compressed size is present, and +.B u +indicates that uncompressed size is present. +If the flag is not set, a dash +.RB ( \- ) +is shown instead to keep the string length fixed. +New flags may be added to the end of the string in the future. +.IP 14. 4 +Size of the actual compressed data in the block (this excludes +the block header, block padding, and check fields) +.IP 15. 4 +Amount of memory (in bytes) required to decompress +this block with this +.B xz +version +.IP 16. 4 +Filter chain. +Note that most of the options used at compression time +cannot be known, because only the options +that are needed for decompression are stored in the +.B .xz +headers. +.RE +.PD +.PP +The columns of the +.B summary +lines: +.PD 0 +.RS +.IP 2. 4 +Amount of memory (in bytes) required to decompress +this file with this +.B xz +version +.IP 3. 4 +.B yes +or +.B no +indicating if all block headers have both compressed size and +uncompressed size stored in them +.PP +.I Since +.B xz +.I 5.1.2alpha: +.IP 4. 4 +Minimum +.B xz +version required to decompress the file +.RE +.PD +.PP +The columns of the +.B totals +line: +.PD 0 +.RS +.IP 2. 4 +Number of streams +.IP 3. 4 +Number of blocks +.IP 4. 4 +Compressed size +.IP 5. 4 +Uncompressed size +.IP 6. 4 +Average compression ratio +.IP 7. 4 +Comma-separated list of integrity check names +that were present in the files +.IP 8. 4 +Stream padding size +.IP 9. 4 +Number of files. +This is here to +keep the order of the earlier columns the same as on +.B file +lines. +.PD +.RE +.PP +If +.B \-\-verbose +was specified twice, additional columns are included on the +.B totals +line: +.PD 0 +.RS +.IP 10. 4 +Maximum amount of memory (in bytes) required to decompress +the files with this +.B xz +version +.IP 11. 4 +.B yes +or +.B no +indicating if all block headers have both compressed size and +uncompressed size stored in them +.PP +.I Since +.B xz +.I 5.1.2alpha: +.IP 12. 4 +Minimum +.B xz +version required to decompress the file +.RE +.PD +.PP +Future versions may add new line types and +new columns can be added to the existing line types, +but the existing columns won't be changed. +. +.SS "Filters help" +.B "xz \-\-robot \-\-filters-help" +prints the supported filters in the following format: +.PP +\fIfilter\fB:\fIoption\fB=<\fIvalue\fB>,\fIoption\fB=<\fIvalue\fB>\fR... +.TP +.I filter +Name of the filter +.TP +.I option +Name of a filter specific option +.TP +.I value +Numeric +.I value +ranges appear as +\fB<\fImin\fB\-\fImax\fB>\fR. +String +.I value +choices are shown within +.B "< >" +and separated by a +.B | +character. +.PP +Each filter is printed on its own line. +. +.SS "Memory limit information" +.B "xz \-\-robot \-\-info\-memory" +prints a single line with multiple tab-separated columns: +.IP 1. 4 +Total amount of physical memory (RAM) in bytes. +.IP 2. 4 +Memory usage limit for compression in bytes +.RB ( \-\-memlimit\-compress ). +A special value of +.B 0 +indicates the default setting +which for single-threaded mode is the same as no limit. +.IP 3. 4 +Memory usage limit for decompression in bytes +.RB ( \-\-memlimit\-decompress ). +A special value of +.B 0 +indicates the default setting +which for single-threaded mode is the same as no limit. +.IP 4. 4 +Since +.B xz +5.3.4alpha: +Memory usage for multi-threaded decompression in bytes +.RB ( \-\-memlimit\-mt\-decompress ). +This is never zero because a system-specific default value +shown in the column 5 +is used if no limit has been specified explicitly. +This is also never greater than the value in the column 3 +even if a larger value has been specified with +.BR \-\-memlimit\-mt\-decompress . +.IP 5. 4 +Since +.B xz +5.3.4alpha: +A system-specific default memory usage limit +that is used to limit the number of threads +when compressing with an automatic number of threads +.RB ( \-\-threads=0 ) +and no memory usage limit has been specified +.RB ( \-\-memlimit\-compress ). +This is also used as the default value for +.BR \-\-memlimit\-mt\-decompress . +.IP 6. 4 +Since +.B xz +5.3.4alpha: +Number of available processor threads. +.PP +In the future, the output of +.B "xz \-\-robot \-\-info\-memory" +may have more columns, but never more than a single line. +. +.SS Version +.B "xz \-\-robot \-\-version" +prints the version number of +.B xz +and liblzma in the following format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +.BI XZ_VERSION= XYYYZZZS +.br +.BI LIBLZMA_VERSION= XYYYZZZS +.TP +.I X +Major version. +.TP +.I YYY +Minor version. +Even numbers are stable. +Odd numbers are alpha or beta versions. +.TP +.I ZZZ +Patch level for stable releases or +just a counter for development releases. +.TP +.I S +Stability. +0 is alpha, 1 is beta, and 2 is stable. +.I S +should be always 2 when +.I YYY +is even. +.PP +.I XYYYZZZS +are the same on both lines if +.B xz +and liblzma are from the same XZ Utils release. +.PP +Examples: 4.999.9beta is +.B 49990091 +and +5.0.0 is +.BR 50000002 . +. +.SH "EXIT STATUS" +.TP +.B 0 +All is good. +.TP +.B 1 +An error occurred. +.TP +.B 2 +Something worth a warning occurred, +but no actual errors occurred. +.PP +Notices (not warnings or errors) printed on standard error +don't affect the exit status. +. +.SH ENVIRONMENT +.B xz +parses space-separated lists of options +from the environment variables +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +.B XZ_DEFAULTS +and +.BR XZ_OPT , +in this order, before parsing the options from the command line. +Note that only options are parsed from the environment variables; +all non-options are silently ignored. +Parsing is done with +.BR getopt_long (3) +which is used also for the command line arguments. +.PP +.B Warning: +By setting these environment variables, +one is effectively modifying programs and scripts that run +.BR xz . +Most of the time it is safe to set memory usage limits, number of threads, +and compression options via the environment variables. +However, some options can break scripts. +An obvious example is +.B \-\-help +which makes +.B xz +show the help text instead of compressing or decompressing a file. +More subtle examples are +.B \-\-quiet +and +.BR \-\-verbose . +In many cases it works well to enable the progress indicator using +.BR \-\-verbose , +but in some situations the extra messages create problems. +The verbosity level also affects the behavior of +.BR \-\-list . +.TP +.B XZ_DEFAULTS +User-specific or system-wide default options. +Typically this is set in a shell initialization script to enable +.BR xz 's +memory usage limiter by default or set the default number of threads. +Excluding shell initialization scripts +and similar special cases, scripts should never set or unset +.BR XZ_DEFAULTS . +.TP +.B XZ_OPT +This is for passing options to +.B xz +when it is not possible to set the options directly on the +.B xz +command line. +This is the case when +.B xz +is run by a script or tool, for example, GNU +.BR tar (1): +.RS +.RS +.PP +.nf +.ft CR +XZ_OPT=\-2v tar caf foo.tar.xz foo +.ft R +.fi +.RE +.RE +.IP "" +Scripts may use +.BR XZ_OPT , +for example, to set script-specific default compression options. +It is still recommended to allow users to override +.B XZ_OPT +if that is reasonable. +For example, in +.BR sh (1) +scripts one may use something like this: +.RS +.RS +.PP +.nf +.ft CR +XZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT +.ft R +.fi +.RE +.RE +. +.SH "LZMA UTILS COMPATIBILITY" +The command line syntax of +.B xz +is practically a superset of +.BR lzma , +.BR unlzma , +and +.B lzcat +as found from LZMA Utils 4.32.x. +In most cases, it is possible to replace +LZMA Utils with XZ Utils without breaking existing scripts. +There are some incompatibilities though, +which may sometimes cause problems. +. +.SS "Compression preset levels" +The numbering of the compression level presets is not identical in +.B xz +and LZMA Utils. +The most important difference is how dictionary sizes +are mapped to different presets. +Dictionary size is roughly equal to the decompressor memory usage. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Level;xz;LZMA Utils +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +The dictionary size differences affect +the compressor memory usage too, +but there are some other differences between +LZMA Utils and XZ Utils, which +make the difference even bigger: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Level;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +The default preset level in LZMA Utils is +.B \-7 +while in XZ Utils it is +.BR \-6 , +so both use an 8 MiB dictionary by default. +. +.SS "Streamed vs. non-streamed .lzma files" +The uncompressed size of the file can be stored in the +.B .lzma +header. +LZMA Utils does that when compressing regular files. +The alternative is to mark that uncompressed size is unknown +and use end-of-payload marker to indicate +where the decompressor should stop. +LZMA Utils uses this method when uncompressed size isn't known, +which is the case, for example, in pipes. +.PP +.B xz +supports decompressing +.B .lzma +files with or without end-of-payload marker, but all +.B .lzma +files created by +.B xz +will use end-of-payload marker and have uncompressed size +marked as unknown in the +.B .lzma +header. +This may be a problem in some uncommon situations. +For example, a +.B .lzma +decompressor in an embedded device might work +only with files that have known uncompressed size. +If you hit this problem, you need to use LZMA Utils +or LZMA SDK to create +.B .lzma +files with known uncompressed size. +. +.SS "Unsupported .lzma files" +The +.B .lzma +format allows +.I lc +values up to 8, and +.I lp +values up to 4. +LZMA Utils can decompress files with any +.I lc +and +.IR lp , +but always creates files with +.B lc=3 +and +.BR lp=0 . +Creating files with other +.I lc +and +.I lp +is possible with +.B xz +and with LZMA SDK. +.PP +The implementation of the LZMA1 filter in liblzma +requires that the sum of +.I lc +and +.I lp +must not exceed 4. +Thus, +.B .lzma +files, which exceed this limitation, cannot be decompressed with +.BR xz . +.PP +LZMA Utils creates only +.B .lzma +files which have a dictionary size of +.RI "2^" n +(a power of 2) but accepts files with any dictionary size. +liblzma accepts only +.B .lzma +files which have a dictionary size of +.RI "2^" n +or +.RI "2^" n " + 2^(" n "\-1)." +This is to decrease false positives when detecting +.B .lzma +files. +.PP +These limitations shouldn't be a problem in practice, +since practically all +.B .lzma +files have been compressed with settings that liblzma will accept. +. +.SS "Trailing garbage" +When decompressing, +LZMA Utils silently ignore everything after the first +.B .lzma +stream. +In most situations, this is a bug. +This also means that LZMA Utils +don't support decompressing concatenated +.B .lzma +files. +.PP +If there is data left after the first +.B .lzma +stream, +.B xz +considers the file to be corrupt unless +.B \-\-single\-stream +was used. +This may break obscure scripts which have +assumed that trailing garbage is ignored. +. +.SH NOTES +. +.SS "Compressed output may vary" +The exact compressed output produced from +the same uncompressed input file +may vary between XZ Utils versions even if +compression options are identical. +This is because the encoder can be improved +(faster or better compression) +without affecting the file format. +The output can vary even between different +builds of the same XZ Utils version, +if different build options are used. +.PP +The above means that once +.B \-\-rsyncable +has been implemented, +the resulting files won't necessarily be rsyncable +unless both old and new files have been compressed +with the same xz version. +This problem can be fixed if a part of the encoder +implementation is frozen to keep rsyncable output +stable across xz versions. +. +.SS "Embedded .xz decompressors" +Embedded +.B .xz +decompressor implementations like XZ Embedded don't necessarily +support files created with integrity +.I check +types other than +.B none +and +.BR crc32 . +Since the default is +.BR \-\-check=crc64 , +you must use +.B \-\-check=none +or +.B \-\-check=crc32 +when creating files for embedded systems. +.PP +Outside embedded systems, all +.B .xz +format decompressors support all the +.I check +types, or at least are able to decompress +the file without verifying the +integrity check if the particular +.I check +is not supported. +.PP +XZ Embedded supports BCJ filters, +but only with the default start offset. +. +.SH EXAMPLES +. +.SS Basics +Compress the file +.I foo +into +.I foo.xz +using the default compression level +.RB ( \-6 ), +and remove +.I foo +if compression is successful: +.RS +.PP +.nf +.ft CR +xz foo +.ft R +.fi +.RE +.PP +Decompress +.I bar.xz +into +.I bar +and don't remove +.I bar.xz +even if decompression is successful: +.RS +.PP +.nf +.ft CR +xz \-dk bar.xz +.ft R +.fi +.RE +.PP +Create +.I baz.tar.xz +with the preset +.B \-4e +.RB ( "\-4 \-\-extreme" ), +which is slower than the default +.BR \-6 , +but needs less memory for compression and decompression (48\ MiB +and 5\ MiB, respectively): +.RS +.PP +.nf +.ft CR +tar cf \- baz | xz \-4e > baz.tar.xz +.ft R +.fi +.RE +.PP +A mix of compressed and uncompressed files can be decompressed +to standard output with a single command: +.RS +.PP +.nf +.ft CR +xz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt +.ft R +.fi +.RE +. +.SS "Parallel compression of many files" +On GNU and *BSD, +.BR find (1) +and +.BR xargs (1) +can be used to parallelize compression of many files: +.RS +.PP +.nf +.ft CR +find . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1 +.ft R +.fi +.RE +.PP +The +.B \-P +option to +.BR xargs (1) +sets the number of parallel +.B xz +processes. +The best value for the +.B \-n +option depends on how many files there are to be compressed. +If there are only a couple of files, +the value should probably be 1; +with tens of thousands of files, +100 or even more may be appropriate to reduce the number of +.B xz +processes that +.BR xargs (1) +will eventually create. +.PP +The option +.B \-T1 +for +.B xz +is there to force it to single-threaded mode, because +.BR xargs (1) +is used to control the amount of parallelization. +. +.SS "Robot mode" +Calculate how many bytes have been saved in total +after compressing multiple files: +.RS +.PP +.nf +.ft CR +xz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}' +.ft R +.fi +.RE +.PP +A script may want to know that it is using new enough +.BR xz . +The following +.BR sh (1) +script checks that the version number of the +.B xz +tool is at least 5.0.0. +This method is compatible with old beta versions, +which didn't support the +.B \-\-robot +option: +.RS +.PP +.nf +.ft CR +if ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION +.ft R +.fi +.RE +.PP +Set a memory usage limit for decompression using +.BR XZ_OPT , +but if a limit has already been set, don't increase it: +.RS +.PP +.nf +.ft CR +NEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi +.ft R +.fi +.RE +. +.SS "Custom compressor filter chains" +The simplest use for custom filter chains is +customizing a LZMA2 preset. +This can be useful, +because the presets cover only a subset of the +potentially useful combinations of compression settings. +.PP +The CompCPU columns of the tables +from the descriptions of the options +.BR "\-0" " ... " "\-9" +and +.B \-\-extreme +are useful when customizing LZMA2 presets. +Here are the relevant parts collected from those two tables: +.RS +.PP +.TS +tab(;); +c c +n n. +Preset;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +If you know that a file requires +somewhat big dictionary (for example, 32\ MiB) to compress well, +but you want to compress it quicker than +.B "xz \-8" +would do, a preset with a low CompCPU value (for example, 1) +can be modified to use a bigger dictionary: +.RS +.PP +.nf +.ft CR +xz \-\-lzma2=preset=1,dict=32MiB foo.tar +.ft R +.fi +.RE +.PP +With certain files, the above command may be faster than +.B "xz \-6" +while compressing significantly better. +However, it must be emphasized that only some files benefit from +a big dictionary while keeping the CompCPU value low. +The most obvious situation, +where a big dictionary can help a lot, +is an archive containing very similar files +of at least a few megabytes each. +The dictionary size has to be significantly bigger +than any individual file to allow LZMA2 to take +full advantage of the similarities between consecutive files. +.PP +If very high compressor and decompressor memory usage is fine, +and the file being compressed is +at least several hundred megabytes, it may be useful +to use an even bigger dictionary than the 64 MiB that +.B "xz \-9" +would use: +.RS +.PP +.nf +.ft CR +xz \-vv \-\-lzma2=dict=192MiB big_foo.tar +.ft R +.fi +.RE +.PP +Using +.B \-vv +.RB ( "\-\-verbose \-\-verbose" ) +like in the above example can be useful +to see the memory requirements +of the compressor and decompressor. +Remember that using a dictionary bigger than +the size of the uncompressed file is waste of memory, +so the above command isn't useful for small files. +.PP +Sometimes the compression time doesn't matter, +but the decompressor memory usage has to be kept low, for example, +to make it possible to decompress the file on an embedded system. +The following command uses +.B \-6e +.RB ( "\-6 \-\-extreme" ) +as a base and sets the dictionary to only 64\ KiB. +The resulting file can be decompressed with XZ Embedded +(that's why there is +.BR \-\-check=crc32 ) +using about 100\ KiB of memory. +.RS +.PP +.nf +.ft CR +xz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo +.ft R +.fi +.RE +.PP +If you want to squeeze out as many bytes as possible, +adjusting the number of literal context bits +.RI ( lc ) +and number of position bits +.RI ( pb ) +can sometimes help. +Adjusting the number of literal position bits +.RI ( lp ) +might help too, but usually +.I lc +and +.I pb +are more important. +For example, a source code archive contains mostly US-ASCII text, +so something like the following might give +slightly (like 0.1\ %) smaller file than +.B "xz \-6e" +(try also without +.BR lc=4 ): +.RS +.PP +.nf +.ft CR +xz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar +.ft R +.fi +.RE +.PP +Using another filter together with LZMA2 can improve +compression with certain file types. +For example, to compress a x86-32 or x86-64 shared library +using the x86 BCJ filter: +.RS +.PP +.nf +.ft CR +xz \-\-x86 \-\-lzma2 libfoo.so +.ft R +.fi +.RE +.PP +Note that the order of the filter options is significant. +If +.B \-\-x86 +is specified after +.BR \-\-lzma2 , +.B xz +will give an error, +because there cannot be any filter after LZMA2, +and also because the x86 BCJ filter cannot be used +as the last filter in the chain. +.PP +The Delta filter together with LZMA2 +can give good results with bitmap images. +It should usually beat PNG, +which has a few more advanced filters than simple +delta but uses Deflate for the actual compression. +.PP +The image has to be saved in uncompressed format, +for example, as uncompressed TIFF. +The distance parameter of the Delta filter is set +to match the number of bytes per pixel in the image. +For example, 24-bit RGB bitmap needs +.BR dist=3 , +and it is also good to pass +.B pb=0 +to LZMA2 to accommodate the three-byte alignment: +.RS +.PP +.nf +.ft CR +xz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff +.ft R +.fi +.RE +.PP +If multiple images have been put into a single archive (for example, +.BR .tar ), +the Delta filter will work on that too as long as all images +have the same number of bytes per pixel. +. +.SH "SEE ALSO" +.BR xzdec (1), +.BR xzdiff (1), +.BR xzgrep (1), +.BR xzless (1), +.BR xzmore (1), +.BR gzip (1), +.BR bzip2 (1), +.BR 7z (1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xzcmp.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xzcmp.1 new file mode 100644 index 0000000000000000000000000000000000000000..9d2608e50b429ed61e60c7cc5686886ccf073011 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xzcmp.1 @@ -0,0 +1,99 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.TH XZDIFF 1 "2025-03-06" "Tukaani" "XZ Utils" +.SH NAME +xzcmp, xzdiff, lzcmp, lzdiff \- compare compressed files +. +.SH SYNOPSIS +.B xzcmp +.RI [ option... ] +.I file1 +.RI [ file2 ] +.br +.B xzdiff +\&... +.br +.B lzcmp +\&... +(DEPRECATED) +.br +.B lzdiff +\&... +(DEPRECATED) +. +.SH DESCRIPTION +.B xzcmp +and +.B xzdiff +compare uncompressed contents of two files. +Uncompressed data and options are passed to +.BR cmp (1) +or +.BR diff (1) +unless +.B \-\-help +or +.B \-\-version +is specified. +.PP +If both +.I file1 +and +.I file2 +are specified, they can be uncompressed files or files in formats that +.BR xz (1), +.BR gzip (1), +.BR bzip2 (1), +.BR lzop (1), +.BR zstd (1), +or +.BR lz4 (1) +can decompress. +The required decompression commands are determined from +the filename suffixes of +.I file1 +and +.IR file2 . +A file with an unknown suffix is assumed to be either uncompressed +or in a format that +.BR xz (1) +can decompress. +.PP +If only one filename is provided, +.I file1 +must have a suffix of a supported compression format and the name for +.I file2 +is assumed to be +.I file1 +with the compression format suffix removed. +.PP +The commands +.B lzcmp +and +.B lzdiff +are provided for backward compatibility with LZMA Utils. +They are deprecated and will be removed in a future version. +. +.SH EXIT STATUS +If a decompression error occurs, the exit status is +.BR 2 . +Otherwise the exit status of +.BR cmp (1) +or +.BR diff (1) +is used. +. +.SH "SEE ALSO" +.BR cmp (1), +.BR diff (1), +.BR xz (1), +.BR gzip (1), +.BR bzip2 (1), +.BR lzop (1), +.BR zstd (1), +.BR lz4 (1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xzdec.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xzdec.1 new file mode 100644 index 0000000000000000000000000000000000000000..5198efb4612e2b87a6be58623390538e7d52abce --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xzdec.1 @@ -0,0 +1,144 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.TH XZDEC 1 "2024-04-08" "Tukaani" "XZ Utils" +.SH NAME +xzdec, lzmadec \- Small .xz and .lzma decompressors +.SH SYNOPSIS +.B xzdec +.RI [ option... ] +.RI [ file... ] +.br +.B lzmadec +.RI [ option... ] +.RI [ file... ] +.SH DESCRIPTION +.B xzdec +is a liblzma-based decompression-only tool for +.B .xz +(and only +.BR .xz ) +files. +.B xzdec +is intended to work as a drop-in replacement for +.BR xz (1) +in the most common situations where a script +has been written to use +.B "xz \-\-decompress \-\-stdout" +(and possibly a few other commonly used options) to decompress +.B .xz +files. +.B lzmadec +is identical to +.B xzdec +except that +.B lzmadec +supports +.B .lzma +files instead of +.B .xz +files. +.PP +To reduce the size of the executable, +.B xzdec +doesn't support multithreading or localization, +and doesn't read options from +.B XZ_DEFAULTS +and +.B XZ_OPT +environment variables. +.B xzdec +doesn't support displaying intermediate progress information: sending +.B SIGINFO +to +.B xzdec +does nothing, but sending +.B SIGUSR1 +terminates the process instead of displaying progress information. +.SH OPTIONS +.TP +.BR \-d ", " \-\-decompress ", " \-\-uncompress +Ignored for +.BR xz (1) +compatibility. +.B xzdec +supports only decompression. +.TP +.BR \-k ", " \-\-keep +Ignored for +.BR xz (1) +compatibility. +.B xzdec +never creates or removes any files. +.TP +.BR \-c ", " \-\-stdout ", " \-\-to-stdout +Ignored for +.BR xz (1) +compatibility. +.B xzdec +always writes the decompressed data to standard output. +.TP +.BR \-q ", " \-\-quiet +Specifying this once does nothing since +.B xzdec +never displays any warnings or notices. +Specify this twice to suppress errors. +.TP +.BR \-Q ", " \-\-no-warn +Ignored for +.BR xz (1) +compatibility. +.B xzdec +never uses the exit status 2. +.TP +.BR \-h ", " \-\-help +Display a help message and exit successfully. +.TP +.BR \-V ", " \-\-version +Display the version number of +.B xzdec +and liblzma. +.SH "EXIT STATUS" +.TP +.B 0 +All was good. +.TP +.B 1 +An error occurred. +.PP +.B xzdec +doesn't have any warning messages like +.BR xz (1) +has, thus the exit status 2 is not used by +.BR xzdec . +.SH NOTES +Use +.BR xz (1) +instead of +.B xzdec +or +.B lzmadec +for normal everyday use. +.B xzdec +or +.B lzmadec +are meant only for situations where it is important to have +a smaller decompressor than the full-featured +.BR xz (1). +.PP +.B xzdec +and +.B lzmadec +are not really that small. +The size can be reduced further by dropping +features from liblzma at compile time, +but that shouldn't usually be done for executables distributed +in typical non-embedded operating system distributions. +If you need a truly small +.B .xz +decompressor, consider using XZ Embedded. +.SH "SEE ALSO" +.BR xz (1) +.PP +XZ Embedded: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xzdiff.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xzdiff.1 new file mode 100644 index 0000000000000000000000000000000000000000..9d2608e50b429ed61e60c7cc5686886ccf073011 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xzdiff.1 @@ -0,0 +1,99 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.TH XZDIFF 1 "2025-03-06" "Tukaani" "XZ Utils" +.SH NAME +xzcmp, xzdiff, lzcmp, lzdiff \- compare compressed files +. +.SH SYNOPSIS +.B xzcmp +.RI [ option... ] +.I file1 +.RI [ file2 ] +.br +.B xzdiff +\&... +.br +.B lzcmp +\&... +(DEPRECATED) +.br +.B lzdiff +\&... +(DEPRECATED) +. +.SH DESCRIPTION +.B xzcmp +and +.B xzdiff +compare uncompressed contents of two files. +Uncompressed data and options are passed to +.BR cmp (1) +or +.BR diff (1) +unless +.B \-\-help +or +.B \-\-version +is specified. +.PP +If both +.I file1 +and +.I file2 +are specified, they can be uncompressed files or files in formats that +.BR xz (1), +.BR gzip (1), +.BR bzip2 (1), +.BR lzop (1), +.BR zstd (1), +or +.BR lz4 (1) +can decompress. +The required decompression commands are determined from +the filename suffixes of +.I file1 +and +.IR file2 . +A file with an unknown suffix is assumed to be either uncompressed +or in a format that +.BR xz (1) +can decompress. +.PP +If only one filename is provided, +.I file1 +must have a suffix of a supported compression format and the name for +.I file2 +is assumed to be +.I file1 +with the compression format suffix removed. +.PP +The commands +.B lzcmp +and +.B lzdiff +are provided for backward compatibility with LZMA Utils. +They are deprecated and will be removed in a future version. +. +.SH EXIT STATUS +If a decompression error occurs, the exit status is +.BR 2 . +Otherwise the exit status of +.BR cmp (1) +or +.BR diff (1) +is used. +. +.SH "SEE ALSO" +.BR cmp (1), +.BR diff (1), +.BR xz (1), +.BR gzip (1), +.BR bzip2 (1), +.BR lzop (1), +.BR zstd (1), +.BR lz4 (1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xzegrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xzegrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..c6bb0eb41f130d412ecd183a8b41369121ae872d --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xzegrep.1 @@ -0,0 +1,148 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.TH XZGREP 1 "2025-03-06" "Tukaani" "XZ Utils" +.SH NAME +xzgrep \- search possibly-compressed files for patterns +. +.SH SYNOPSIS +.B xzgrep +.RI [ option... ] +.RI [ pattern_list ] +.RI [ file... ] +.br +.B xzegrep +\&... +.br +.B xzfgrep +\&... +.br +.B lzgrep +\&... +(DEPRECATED) +.br +.B lzegrep +\&... +(DEPRECATED) +.br +.B lzfgrep +\&... +(DEPRECATED) +. +.SH DESCRIPTION +.B xzgrep +invokes +.BR grep (1) +on uncompressed contents of files. +The formats of the +.I files +are determined from the filename suffixes. +Any +.I file +with a suffix supported by +.BR xz (1), +.BR gzip (1), +.BR bzip2 (1), +.BR lzop (1), +.BR zstd (1), +or +.BR lz4 (1) +will be decompressed; +all other files are assumed to be uncompressed. +.PP +If no +.I files +are specified or +.I file +is +.B \- +then standard input is read. +When reading from standard input, only files supported by +.BR xz (1) +are decompressed. +Other files are assumed to be in uncompressed form already. +.PP +Most +.I options +of +.BR grep (1) +are supported. +However, the following options are not supported: +.IP "" 4 +.BR \-r , +.B \-\-recursive +.IP "" 4 +.BR \-R , +.B \-\-dereference\-recursive +.IP "" 4 +.BR \-d , +.BI \-\-directories= action +.IP "" 4 +.BR \-Z , +.B \-\-null +.IP "" 4 +.BR \-z , +.B \-\-null\-data +.IP "" 4 +.BI \-\-include= glob +.IP "" 4 +.BI \-\-exclude= glob +.IP "" 4 +.BI \-\-exclude\-from= file +.IP "" 4 +.BI \-\-exclude\-dir= glob +.PP +.B xzegrep +is an alias for +.BR "xzgrep \-E" . +.B xzfgrep +is an alias for +.BR "xzgrep \-F" . +.PP +The commands +.BR lzgrep , +.BR lzegrep , +and +.B lzfgrep +are provided for backward compatibility with LZMA Utils. +They are deprecated and will be removed in a future version. +. +.SH EXIT STATUS +.TP +0 +At least one match was found from at least one of the input files. +No errors occurred. +.TP +1 +No matches were found from any of the input files. +No errors occurred. +.TP +>1 +One or more errors occurred. +It is unknown if matches were found. +. +.SH ENVIRONMENT +.TP +.B GREP +If +.B GREP +is set to a non-empty value, +it is used instead of +.BR "grep" , +.BR "grep \-E" , +or +.BR "grep \-F" . +. +.SH "SEE ALSO" +.BR grep (1), +.BR xz (1), +.BR gzip (1), +.BR bzip2 (1), +.BR lzop (1), +.BR zstd (1), +.BR lz4 (1), +.BR zgrep (1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xzfgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xzfgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..c6bb0eb41f130d412ecd183a8b41369121ae872d --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xzfgrep.1 @@ -0,0 +1,148 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.TH XZGREP 1 "2025-03-06" "Tukaani" "XZ Utils" +.SH NAME +xzgrep \- search possibly-compressed files for patterns +. +.SH SYNOPSIS +.B xzgrep +.RI [ option... ] +.RI [ pattern_list ] +.RI [ file... ] +.br +.B xzegrep +\&... +.br +.B xzfgrep +\&... +.br +.B lzgrep +\&... +(DEPRECATED) +.br +.B lzegrep +\&... +(DEPRECATED) +.br +.B lzfgrep +\&... +(DEPRECATED) +. +.SH DESCRIPTION +.B xzgrep +invokes +.BR grep (1) +on uncompressed contents of files. +The formats of the +.I files +are determined from the filename suffixes. +Any +.I file +with a suffix supported by +.BR xz (1), +.BR gzip (1), +.BR bzip2 (1), +.BR lzop (1), +.BR zstd (1), +or +.BR lz4 (1) +will be decompressed; +all other files are assumed to be uncompressed. +.PP +If no +.I files +are specified or +.I file +is +.B \- +then standard input is read. +When reading from standard input, only files supported by +.BR xz (1) +are decompressed. +Other files are assumed to be in uncompressed form already. +.PP +Most +.I options +of +.BR grep (1) +are supported. +However, the following options are not supported: +.IP "" 4 +.BR \-r , +.B \-\-recursive +.IP "" 4 +.BR \-R , +.B \-\-dereference\-recursive +.IP "" 4 +.BR \-d , +.BI \-\-directories= action +.IP "" 4 +.BR \-Z , +.B \-\-null +.IP "" 4 +.BR \-z , +.B \-\-null\-data +.IP "" 4 +.BI \-\-include= glob +.IP "" 4 +.BI \-\-exclude= glob +.IP "" 4 +.BI \-\-exclude\-from= file +.IP "" 4 +.BI \-\-exclude\-dir= glob +.PP +.B xzegrep +is an alias for +.BR "xzgrep \-E" . +.B xzfgrep +is an alias for +.BR "xzgrep \-F" . +.PP +The commands +.BR lzgrep , +.BR lzegrep , +and +.B lzfgrep +are provided for backward compatibility with LZMA Utils. +They are deprecated and will be removed in a future version. +. +.SH EXIT STATUS +.TP +0 +At least one match was found from at least one of the input files. +No errors occurred. +.TP +1 +No matches were found from any of the input files. +No errors occurred. +.TP +>1 +One or more errors occurred. +It is unknown if matches were found. +. +.SH ENVIRONMENT +.TP +.B GREP +If +.B GREP +is set to a non-empty value, +it is used instead of +.BR "grep" , +.BR "grep \-E" , +or +.BR "grep \-F" . +. +.SH "SEE ALSO" +.BR grep (1), +.BR xz (1), +.BR gzip (1), +.BR bzip2 (1), +.BR lzop (1), +.BR zstd (1), +.BR lz4 (1), +.BR zgrep (1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xzgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xzgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..c6bb0eb41f130d412ecd183a8b41369121ae872d --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xzgrep.1 @@ -0,0 +1,148 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.TH XZGREP 1 "2025-03-06" "Tukaani" "XZ Utils" +.SH NAME +xzgrep \- search possibly-compressed files for patterns +. +.SH SYNOPSIS +.B xzgrep +.RI [ option... ] +.RI [ pattern_list ] +.RI [ file... ] +.br +.B xzegrep +\&... +.br +.B xzfgrep +\&... +.br +.B lzgrep +\&... +(DEPRECATED) +.br +.B lzegrep +\&... +(DEPRECATED) +.br +.B lzfgrep +\&... +(DEPRECATED) +. +.SH DESCRIPTION +.B xzgrep +invokes +.BR grep (1) +on uncompressed contents of files. +The formats of the +.I files +are determined from the filename suffixes. +Any +.I file +with a suffix supported by +.BR xz (1), +.BR gzip (1), +.BR bzip2 (1), +.BR lzop (1), +.BR zstd (1), +or +.BR lz4 (1) +will be decompressed; +all other files are assumed to be uncompressed. +.PP +If no +.I files +are specified or +.I file +is +.B \- +then standard input is read. +When reading from standard input, only files supported by +.BR xz (1) +are decompressed. +Other files are assumed to be in uncompressed form already. +.PP +Most +.I options +of +.BR grep (1) +are supported. +However, the following options are not supported: +.IP "" 4 +.BR \-r , +.B \-\-recursive +.IP "" 4 +.BR \-R , +.B \-\-dereference\-recursive +.IP "" 4 +.BR \-d , +.BI \-\-directories= action +.IP "" 4 +.BR \-Z , +.B \-\-null +.IP "" 4 +.BR \-z , +.B \-\-null\-data +.IP "" 4 +.BI \-\-include= glob +.IP "" 4 +.BI \-\-exclude= glob +.IP "" 4 +.BI \-\-exclude\-from= file +.IP "" 4 +.BI \-\-exclude\-dir= glob +.PP +.B xzegrep +is an alias for +.BR "xzgrep \-E" . +.B xzfgrep +is an alias for +.BR "xzgrep \-F" . +.PP +The commands +.BR lzgrep , +.BR lzegrep , +and +.B lzfgrep +are provided for backward compatibility with LZMA Utils. +They are deprecated and will be removed in a future version. +. +.SH EXIT STATUS +.TP +0 +At least one match was found from at least one of the input files. +No errors occurred. +.TP +1 +No matches were found from any of the input files. +No errors occurred. +.TP +>1 +One or more errors occurred. +It is unknown if matches were found. +. +.SH ENVIRONMENT +.TP +.B GREP +If +.B GREP +is set to a non-empty value, +it is used instead of +.BR "grep" , +.BR "grep \-E" , +or +.BR "grep \-F" . +. +.SH "SEE ALSO" +.BR grep (1), +.BR xz (1), +.BR gzip (1), +.BR bzip2 (1), +.BR lzop (1), +.BR zstd (1), +.BR lz4 (1), +.BR zgrep (1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xzless.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xzless.1 new file mode 100644 index 0000000000000000000000000000000000000000..17118b9b85cf485e4da4f9230f8a1c2d893c4d2b --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xzless.1 @@ -0,0 +1,69 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" (Note that this file is not based on gzip's zless.1.) +.\" +.TH XZLESS 1 "2025-03-06" "Tukaani" "XZ Utils" +.SH NAME +xzless, lzless \- view xz or lzma compressed (text) files +.SH SYNOPSIS +.B xzless +.RI [ file ...] +.br +.B lzless +.RI [ file ...] +(DEPRECATED) +.SH DESCRIPTION +.B xzless +is a filter that displays text from compressed files to a terminal. +Files supported by +.BR xz (1) +are decompressed; +other files are assumed to be in uncompressed form already. +If no +.I files +are given, +.B xzless +reads from standard input. +.PP +.B xzless +uses +.BR less (1) +to present its output. +Unlike +.BR xzmore , +its choice of pager cannot be altered by +setting an environment variable. +Commands are based on both +.BR more (1) +and +.BR vi (1) +and allow back and forth movement and searching. +See the +.BR less (1) +manual for more information. +.PP +The command named +.B lzless +is provided for backward compatibility with LZMA Utils. +It is deprecated and will be removed in a future version. +.SH ENVIRONMENT +.TP +.B LESSMETACHARS +A list of characters special to the shell. +Set by +.B xzless +unless it is already set in the environment. +.TP +.B LESSOPEN +Set to a command line to invoke the +.BR xz (1) +decompressor for preprocessing the input files to +.BR less (1). +.SH "SEE ALSO" +.BR less (1), +.BR xz (1), +.BR xzmore (1), +.BR zless (1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xzmore.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xzmore.1 new file mode 100644 index 0000000000000000000000000000000000000000..8a0e21c9e166417ebd6ec8e6e64568236c52f79f --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/man1/xzmore.1 @@ -0,0 +1,69 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" (Note that this file is based on xzless.1 instead of gzip's zmore.1.) +.\" +.TH XZMORE 1 "2025-03-06" "Tukaani" "XZ Utils" +.SH NAME +xzmore, lzmore \- view xz or lzma compressed (text) files +. +.SH SYNOPSIS +.B xzmore +.RI [ file ...] +.br +.B lzmore +.RI [ file ...] +(DEPRECATED) +. +.SH DESCRIPTION +.B xzmore +displays text from compressed files to a terminal using +.BR more (1). +Files supported by +.BR xz (1) +are decompressed; +other files are assumed to be in uncompressed form already. +If no +.I files +are given, +.B xzmore +reads from standard input. +See the +.BR more (1) +manual for the keyboard commands. +.PP +Note that scrolling backwards might not be possible +depending on the implementation of +.BR more (1). +This is because +.B xzmore +uses a pipe to pass the decompressed data to +.BR more (1). +.BR xzless (1) +uses +.BR less (1) +which provides more advanced features. +.PP +The command +.B lzmore +is provided for backward compatibility with LZMA Utils. +It is deprecated and will be removed in a future version. +. +.SH ENVIRONMENT +.TP +.\" TRANSLATORS: Don't translate the uppercase PAGER. +.\" It is a name of an environment variable. +.B PAGER +If +.B PAGER +is set, +its value is used as the pager instead of +.BR more (1). +. +.SH "SEE ALSO" +.BR more (1), +.BR xz (1), +.BR xzless (1), +.BR zmore (1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/lzcat.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/lzcat.1 new file mode 100644 index 0000000000000000000000000000000000000000..0f85fc96ac66488096221e723d837e7d28ff6bc2 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/lzcat.1 @@ -0,0 +1,1994 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Brazilian Portuguese translations for xz package +.\" Traduções em português brasileiro para o pacote xz. +.\" Rafael Fontenelle , 2022-2023. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 2025\-03\-08 Tukaani "XZ Utils" +. +.SH NOME +xz, unxz, xzcat, lzma, unlzma, lzcat \- Compacta ou descompacta arquivos .xz +e .lzma +. +.SH SINOPSE +\fBxz\fP [\fIopção...\fP] [\fIarquivo...\fP] +. +.SH "COMANDOS APELIDOS" +\fBunxz\fP é equivalente a \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP é equivalente a \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP é equivalente a \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP é equivalente a \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP é equivalente a \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Ao escrever scripts que precisam descompactar arquivos, é recomendável +sempre usar o nome \fBxz\fP com os argumentos apropriados (\fBxz \-d\fP ou \fBxz \-dc\fP) em vez dos nomes \fBunxz\fP e \fBxzcat\fP. +. +.SH DESCRIÇÃO +\fBxz\fP é uma ferramenta de compactação de dados de uso geral com sintaxe de +linha de comando semelhante ao \fBgzip\fP(1) e ao \fBbzip2\fP(1). O formato de +arquivo nativo é o formato \fB.xz\fP, mas o formato legado \fB.lzma\fP usado por +LZMA Utils e fluxos compactados brutos sem cabeçalhos de formato de +contêiner também são suportados. Além disso, a descompactação do formato +\&\fB.lz\fP usado por \fBlzip\fP é suportada. +.PP +\fBxz\fP compacta ou descompacta cada \fIarquivo\fP de acordo com o modo de +operação selecionado. Se nenhum \fIarquivo\fP for fornecido ou \fIarquivo\fP for +\fB\-\fP, \fBxz\fP lê da entrada padrão e grava os dados processados na saída +padrão. \fBxz\fP recusará (exibirá um erro e ignorará o \fIarquivo\fP) para gravar +dados compactados na saída padrão se for um terminal. Da mesma forma, \fBxz\fP +se recusará a ler dados compactados da entrada padrão se for um terminal. +.PP +A menos que \fB\-\-stdout\fP seja especificado, \fIarquivos\fP diferentes de \fB\-\fP +são gravados em um novo arquivo cujo nome é derivado do nome \fIarquivo\fP de +origem: +.IP \(bu 3 +Ao compactar, o sufixo do formato de arquivo de destino (\fB.xz\fP ou \fB.lzma\fP) +é anexado ao nome do arquivo de origem para obter o nome do arquivo de +destino. +.IP \(bu 3 +Ao descompactar, o sufixo \fB.xz\fP, \fB.lzma\fP ou \fB.lz\fP é removido do nome do +arquivo para obter o nome do arquivo de destino. \fBxz\fP também reconhece os +sufixos \fB.txz\fP e \fB.tlz\fP e os substitui pelo sufixo \fB.tar\fP. +.PP +Se o arquivo de destino já existir, um erro será exibido e \fIarquivo\fP será +ignorado. +.PP +A menos que grave na saída padrão, \fBxz\fP exibirá um aviso e pulará o +\fIarquivo\fP se qualquer um dos seguintes se aplicar: +.IP \(bu 3 +\fIArquivo\fP não é um arquivo normal. Links simbólicos não são seguidos e, +portanto, não são considerados arquivos comuns. +.IP \(bu 3 +\fIArquivo\fP tem mais de um link físico. +.IP \(bu 3 +\fIFile\fP tem setuid, setgid ou sticky bit definido. +.IP \(bu 3 +O modo de operação está definido para compactar e o \fIarquivo\fP já possui um +sufixo do formato de arquivo de destino (\fB.xz\fP ou \fB.txz\fP ao compactar para +o formato \fB.xz\fP e \fB.lzma \fP ou \fB.tlz\fP ao compactar para o formato +\&\fB.lzma\fP). +.IP \(bu 3 +O modo de operação está definido para descompactar e o \fIarquivo\fP não possui +um sufixo de nenhum dos formatos de arquivo suportados (\fB.xz\fP, \fB.txz\fP, +\&\fB.lzma\fP, \fB.tlz\fP , ou \fB.lz\fP). +.PP +Depois de compactar ou descompactar com êxito o \fIarquivo\fP, o \fBxz\fP copia o +dono, grupo, permissões, horário de acesso e horário de modificação do +\fIarquivo\fP de origem para o arquivo de destino. Se a cópia do grupo falhar, +as permissões serão modificadas para que o arquivo de destino não se torne +acessível a usuários que não têm permissão para acessar o \fIarquivo\fP de +origem. \fBxz\fP ainda não oferece suporte à cópia de outros metadados, como +listas de controle de acesso ou atributos estendidos. +.PP +Depois que o arquivo de destino for fechado com êxito, o \fIarquivo\fP de +origem será removido, a menos que \fB\-\-keep\fP tenha sido especificado. O +\fIarquivo\fP de origem nunca é removido se a saída for gravada na saída padrão +ou se ocorrer um erro. +.PP +O envio de \fBSIGINFO\fP ou \fBSIGUSR1\fP para o processo do \fBxz\fP faz com que ele +imprima informações de andamento para erro padrão. Isso tem uso limitado, +pois quando o erro padrão é um terminal, usar \fB\-\-verbose\fP exibirá um +indicador de progresso de atualização automática. +. +.SS "Uso de memória" +O uso de memória de \fBxz\fP varia de algumas centenas de kilobytes a vários +gigabytes, dependendo das configurações de compactação. As configurações +usadas ao compactar um arquivo determinam os requisitos de memória do +descompactador. Normalmente, o descompactador precisa de 5\ % a 20\ % da +quantidade de memória que o compactador precisou ao criar o arquivo. Por +exemplo, descompactar um arquivo criado com \fBxz \-9\fP atualmente requer 65\ MiB de memória. Ainda assim, é possível ter arquivos \fB.xz\fP que requerem +vários gigabytes de memória para descompactar. +.PP +Especialmente os usuários de sistemas mais antigos podem achar irritante a +possibilidade de uso de memória muito grande. Para evitar surpresas +desconfortáveis, o \fBxz\fP possui um limitador de uso de memória embutido, que +está desabilitado por padrão. Embora alguns sistemas operacionais forneçam +maneiras de limitar o uso de memória dos processos, confiar nele não foi +considerado flexível o suficiente (por exemplo, usar \fBulimit\fP(1) para +limitar a memória virtual tende a prejudicar \fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +O limitador de uso de memória pode ser ativado com a opção de linha de +comando \fB\-\-memlimit=\fP\fIlimite\fP. Geralmente é mais conveniente habilitar o +limitador por padrão definindo a variável de ambiente \fBXZ_DEFAULTS\fP, por +exemplo, \fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. É possível definir os limites +separadamente para compactação e descompactação usando +\fB\-\-memlimit\-compress=\fP\fIlimite\fP e \fB\-\-memlimit\-decompress=\fP\fIlimite\fP. Usar +essas duas opções fora de \fBXZ_DEFAULTS\fP raramente é útil porque uma única +execução de \fBxz\fP não pode fazer compactação e descompactação e +\fB\-\-memlimit=\fP\fIlimite\fP (ou \fB\-M\fP \fIlimite\fP ) é mais curto para digitar na +linha de comando. +.PP +Se o limite de uso de memória especificado for excedido durante a +descompactação, \fBxz\fP exibirá um erro e a descompactação do arquivo +falhará. Se o limite for excedido durante a compactação, \fBxz\fP tentará +reduzir as configurações para que o limite não seja mais excedido (exceto ao +usar \fB\-\-format=raw\fP ou \fB\-\-no\-adjust\fP). Dessa forma, a operação não +falhará, a menos que o limite seja muito pequeno. A escala das configurações +é feita em etapas que não correspondem às predefinições do nível de +compactação, por exemplo, se o limite for apenas um pouco menor que o valor +necessário para \fBxz \-9\fP, as configurações serão reduzidas apenas um pouco , +não até \fBxz \-8\fP. +. +.SS "Concatenação e preenchimento com arquivos .xz" +É possível concatenar arquivos \fB.xz\fP como estão. \fBxz\fP irá descompactar +tais arquivos como se fossem um único arquivo \fB.xz\fP. +.PP +É possível inserir preenchimento entre as partes concatenadas ou após a +última parte. O preenchimento deve consistir em bytes nulos e o tamanho do +preenchimento deve ser um múltiplo de quatro bytes. Isso pode ser útil, por +exemplo, se o arquivo \fB.xz\fP for armazenado em uma mídia que mede tamanhos +de arquivo em blocos de 512 bytes. +.PP +Concatenação e preenchimento não são permitidos com arquivos \fB.lzma\fP ou +fluxos brutos. +. +.SH OPÇÕES +. +.SS "Sufixos inteiros e valores especiais" +Na maioria dos lugares onde um argumento inteiro é esperado, um sufixo +opcional é suportado para indicar facilmente números inteiros grandes. Não +deve haver espaço entre o número inteiro e o sufixo. +.TP +\fBKiB\fP +Multiplica o inteiro por 1.024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP e \fBKB\fP são +aceitos como sinônimos de \fBKiB\fP. +.TP +\fBMiB\fP +Multiplica o número inteiro por 1.048.576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP e \fBMB\fP +são aceitos como sinônimos de \fBMiB\fP. +.TP +\fBGiB\fP +Multiplica o número inteiro por 1.073.741.824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP e +\fBGB\fP são aceitos como sinônimos de \fBGiB\fP. +.PP +O valor especial \fBmax\fP pode ser usado para indicar o valor inteiro máximo +suportado pela opção. +. +.SS "Modo de operação" +Se várias opções de modo de operação forem dadas, a última entrará em vigor. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Compacta. Este é o modo de operação padrão quando nenhuma opção de modo de +operação é especificada e nenhum outro modo de operação está implícito no +nome do comando (por exemplo, \fBunxz\fP implica em \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +After successful compression, the source file is removed unless writing to +standard output or \fB\-\-keep\fP was specified. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Decompress. After successful decompression, the source file is removed +unless writing to standard output or \fB\-\-keep\fP was specified. +.TP +\fB\-t\fP, \fB\-\-test\fP +Testa a integridade de \fIarquivos\fP compactados. Esta opção é equivalente a +\fB\-\-decompress \-\-stdout\fP exceto que os dados descompactados são descartados +em vez de serem gravados na saída padrão. Nenhum arquivo é criado ou +removido. +.TP +\fB\-l\fP, \fB\-\-list\fP +Imprime informações sobre \fIarquivos\fP compactados. Nenhuma saída +descompactada é produzida e nenhum arquivo é criado ou removido. No modo de +lista, o programa não pode ler os dados compactados da entrada padrão ou de +outras fontes não pesquisáveis. +.IP "" +A listagem padrão mostra informações básicas sobre \fIarquivos\fP, um arquivo +por linha. Para obter informações mais detalhadas, use também a opção +\fB\-\-verbose\fP. Para obter ainda mais informações, use \fB\-\-verbose\fP duas +vezes, mas observe que isso pode ser lento, porque obter todas as +informações extras requer muitas buscas. A largura da saída detalhada excede +80 caracteres, portanto, canalizar a saída para, por exemplo, \fBless\ \-S\fP +pode ser conveniente se o terminal não tiver largura o suficiente. +.IP "" +A saída exata pode variar entre versões \fBxz\fP e localidades diferentes. Para +saída legível por máquina, \fB\-\-robot \-\-list\fP deve ser usado. +. +.SS "Modificadores de operação" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Não exclui os arquivos de entrada. +.IP "" +Desde \fBxz\fP 5.2.6, esta opção também faz \fBxz\fP compactar ou descompactar +mesmo se a entrada for um link simbólico para um arquivo comum, tiver mais +de um link físico ou tiver o setuid, setgid ou sticky bit definir. Os bits +setuid, setgid e sticky não são copiados para o arquivo de destino. Nas +versões anteriores, isso era feito apenas com \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Esta opção tem vários efeitos: +.RS +.IP \(bu 3 +Se o arquivo de destino já existir, o exclui antes de compactar ou +descompactar. +.IP \(bu 3 +Compacta ou descompacta, mesmo que a entrada seja um link simbólico para um +arquivo normal, tenha mais de um link físico ou tenha setuid, setgid ou +sticky bit definido. Os bits setuid, setgid e sticky não são copiados para o +arquivo de destino. +.IP \(bu 3 +Quando usado com \fB\-\-decompress\fP \fB\-\-stdout\fP e \fBxz\fP não consegue reconhecer +o tipo do arquivo de origem, copia o arquivo de origem como está na saída +padrão. Isso permite que \fBxzcat\fP \fB\-\-force\fP seja usado como \fBcat\fP(1) para +arquivos que não foram compactados com \fBxz\fP. Observe que, no futuro, o +\fBxz\fP pode oferecer suporte a novos formatos de arquivo compactado, o que +pode fazer com que o \fBxz\fP descompacte mais tipos de arquivos em vez de +copiá\-los como na saída padrão. \fB\-\-format=\fP\fIformato\fP pode ser usado para +restringir \fBxz\fP para descompactar apenas um único formato de arquivo. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Grava os dados compactados ou descompactados na saída padrão em vez de em um +arquivo. Isso implica em \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Descompacta apenas o primeiro fluxo de \fB.xz\fP e ignora silenciosamente +possíveis dados de entrada restantes após o fluxo. Normalmente, esse +restante posterior sem uso faz com que \fBxz\fP exiba um erro. +.IP "" +\fBxz\fP nunca descompacta mais de um fluxo de arquivos \fB.lzma\fP ou fluxos +brutos, mas esta opção ainda faz \fBxz\fP ignorar os possíveis dados +posteriores após o arquivo \fB.lzma\fP ou fluxo bruto. +.IP "" +Esta opção não tem efeito se o modo de operação não for \fB\-\-decompress\fP ou +\fB\-\-test\fP. +.IP "" +Since \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP implies \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Desativa a criação de arquivos esparsos. Por padrão, ao descompactar em um +arquivo normal, \fBxz\fP tenta tornar o arquivo esparso se os dados +descompactados contiverem longas sequências de zeros binários. Ele também +funciona ao gravar na saída padrão, desde que a saída padrão esteja +conectada a um arquivo normal e certas condições adicionais sejam atendidas +para torná\-la segura. A criação de arquivos esparsos pode economizar espaço +em disco e acelerar a descompactação, reduzindo a quantidade de E/S do +disco. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Ao compactar, usa \fI.suf\fP como sufixo para o arquivo de destino em vez de +\&\fB.xz\fP ou \fB.lzma\fP. Se não estiver gravando na saída padrão e o arquivo de +origem já tiver o sufixo \fI.suf\fP, um aviso será exibido e o arquivo será +ignorado. +.IP "" +Ao descompactar, reconhece arquivos com o sufixo \fI.suf\fP além de arquivos +com o sufixo \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP ou \fB.lz\fP . Se o arquivo de +origem tiver o sufixo \fI.suf\fP, o sufixo será removido para obter o nome do +arquivo de destino. +.IP "" +Ao compactar ou descompactar fluxos brutos (\fB\-\-format=raw\fP), o sufixo +sempre deve ser especificado, a menos que seja gravado na saída padrão, +porque não há sufixo padrão para fluxos brutos. +.TP +\fB\-\-files\fP[\fB=\fP\fIarquivo\fP] +Lê os nomes dos arquivos a serem processados em \fIarquivo\fP; se \fIarquivo\fP +for omitido, os nomes dos arquivos serão lidos da entrada padrão. Os nomes +de arquivo devem terminar com o caractere de nova linha. Um traço (\fB\-\fP) é +considerado um nome de arquivo regular; não significa entrada padrão. Se os +nomes de arquivo forem fornecidos também como argumentos de linha de +comando, eles serão processados antes da leitura dos nomes de arquivo de +\fIarquivo\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIarquivo\fP] +Isso é idêntico a \fB\-\-files\fP[\fB=\fP\fIarquivo\fP], exceto que cada nome de +arquivo deve ser finalizado com o caractere nulo. +. +.SS "Opções básicas de formato de arquivo e de compactação" +.TP +\fB\-F\fP \fIformato\fP, \fB\-\-format=\fP\fIformato\fP +Especifica o \fIformato\fP de arquivo para compactar ou descompactar: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Este é o padrão. Ao compactar, \fBauto\fP é equivalente a \fBxz\fP. Ao +descompactar, o formato do arquivo de entrada é detectado +automaticamente. Observe que os fluxos brutos (criados com \fB\-\-format=raw\fP) +não podem ser detectados automaticamente. +.TP +\fBxz\fP +Compacta no formato de arquivo \fB.xz\fP ou aceite apenas arquivos \fB.xz\fP ao +descompactar. +.TP +\fBlzma\fP, \fBalone\fP +Compacta no formato de arquivo legado \fB.lzma\fP ou aceite apenas arquivos +\&\fB.lzma\fP ao descompactar. O nome alternativo \fBalone\fP é fornecido para +compatibilidade com versões anteriores do LZMA Utils. +.TP +\fBlzip\fP +Aceita apenas arquivos \fB.lz\fP ao descompactar. Sem suporte a compactação. +.IP "" +The \fB.lz\fP format versions 0 and 1 are supported. Version 0 files were +produced by \fBlzip\fP 1.3 and older. Such files aren't common but may be +found from file archives as a few source packages were released in this +format. People might have old personal files in this format too. +Decompression support for the format version 0 was removed in \fBlzip\fP 1.18. +\fBlzip\fP 1.4 and later create files in the format version 1. +.TP +\fBraw\fP +Compacta ou descompacta um fluxo bruto (sem cabeçalhos). Isso é destinado +apenas a usuários avançados. Para decodificar fluxos brutos, você precisa +usar \fB\-\-format=raw\fP e especificar explicitamente a cadeia de filtros, que +normalmente seria armazenada nos cabeçalhos do contêiner. +.RE +.TP +\fB\-C\fP \fIverificação\fP, \fB\-\-check=\fP\fIverificação\fP +Especifica o tipo de verificação de integridade. A verificação é calculada a +partir dos dados descompactados e armazenados no arquivo \fB.xz\fP. Esta opção +tem efeito somente ao compactar no formato \fB.xz\fP; o formato \fB.lzma\fP não +oferece suporte a verificações de integridade. A verificação de integridade +(se for o caso) é verificada quando o arquivo \fB.xz\fP é descompactado. +.IP "" +Tipos de \fIverificação\fP suportados: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Não calcula uma verificação de integridade. Isso geralmente é uma má +ideia. Pode ser útil quando a integridade dos dados é verificada por outros +meios. +.TP +\fBcrc32\fP +Calcula CRC32 usando o polinômio do IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Calcula CRC64 usando o polinômio de ECMA\-182. Este é o padrão, pois é um +pouco melhor que o CRC32 na detecção de arquivos danificados e a diferença +de velocidade é insignificante. +.TP +\fBsha256\fP +Calcula SHA\-256. Isso é um pouco mais lento do que CRC32 e CRC64. +.RE +.IP "" +A integridade dos cabeçalhos de \fB.xz\fP é sempre verificada com CRC32. Não é +possível alterá\-la ou desativá\-la. +.TP +\fB\-\-ignore\-check\fP +Não confere a verificação de integridade dos dados compactados ao +descompactar. Os valores CRC32 nos cabeçalhos \fB.xz\fP ainda serão conferidos +normalmente. +.IP "" +\fBNão use esta opção a menos que saiba o que está fazendo.\fP Possíveis razões +para usar esta opção: +.RS +.IP \(bu 3 +Tentativa de recuperar dados de um arquivo .xz corrompido. +.IP \(bu 3 +Acelerar a descompactação. Isso é importante principalmente com SHA\-256 ou +com arquivos extremamente bem compactados. É recomendável não usar essa +opção para essa finalidade, a menos que a integridade do arquivo seja +verificada externamente de alguma outra forma. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Seleciona um nível de predefinição de compactação. O padrão é \fB\-6\fP. Se +vários níveis de predefinição forem especificados, o último terá efeito. Se +uma cadeia de filtro personalizada já foi especificada, especificar um nível +de predefinição de compactação limpa a cadeia de filtro personalizada. +.IP "" +As diferenças entre as predefinições são mais significativas do que com +\fBgzip\fP(1) e \fBbzip2\fP(1). As configurações de compactação selecionadas +determinam os requisitos de memória do descompactador, portanto, usar um +nível de predefinição muito alto pode dificultar a descompactação do arquivo +em um sistema antigo com pouca RAM. Especificamente, \fBnão é uma boa ideia usar cegamente \-9 para tudo\fP como costuma acontecer com \fBgzip\fP(1) e +\fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Estas são predefinições um tanto rápidas. \fB\-0\fP às vezes é mais rápida que +\fBgzip \-9\fP ao mesmo tempo que compacta muito melhor. As mais altas +geralmente têm velocidade comparável ao \fBbzip2\fP(1) com taxa de compactação +comparável ou melhor, embora os resultados dependam muito do tipo de dados +que estão sendo compactados. +.TP +\fB\-4\fP ... \fB\-6\fP +Compactação boa a muito boa, mantendo o uso de memória do descompactador +razoável mesmo para sistemas antigos. \fB\-6\fP é o padrão, que geralmente é uma +boa escolha para distribuir arquivos que precisam ser descompactáveis, mesmo +em sistemas com apenas 16\ MiB de RAM. (\fB\-5e\fP ou \fB\-6e\fP também vale a pena +considerar. Veja \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Eles são como \fB\-6\fP, mas com requisitos de memória de compressor e +descompressor mais altos. Eles são úteis apenas ao compactar arquivos +maiores que 8\ MiB, 16\ MiB e 32\ MiB, respectivamente. +.RE +.IP "" +No mesmo hardware, a velocidade de descompactação é aproximadamente um +número constante de bytes de dados compactados por segundo. Em outras +palavras, quanto melhor a compactação, mais rápida será a +descompactação. Isso também significa que a quantidade de saída não +compactada produzida por segundo pode variar muito. +.IP "" +A tabela a seguir resume os recursos das predefinições: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Predefinição;DicTam;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Descrições das colunas: +.RS +.IP \(bu 3 +DicTam é o tamanho do dicionário LZMA2. É desperdício de memória usar um +dicionário maior que o tamanho do arquivo descompactado. É por isso que é +bom evitar usar as predefinições \fB\-7\fP ... \fB\-9\fP quando não há real +necessidade deles. Em \fB\-6\fP e inferior, a quantidade de memória desperdiçada +geralmente é baixa o suficiente para não importar. +.IP \(bu 3 +CompCPU é uma representação simplificada das configurações LZMA2 que afetam +a velocidade de compactação. O tamanho do dicionário também afeta a +velocidade, portanto, embora o CompCPU seja o mesmo para os níveis \fB\-6\fP +\&... \fB\-9\fP, níveis mais altos ainda tendem a ser um pouco mais lentos. Para +obter uma compactação ainda mais lenta e possivelmente melhor, consulte +\fB\-\-extreme\fP. +.IP \(bu 3 +CompMem contains the compressor memory requirements in the single\-threaded +mode. It may vary slightly between \fBxz\fP versions. +.IP \(bu 3 +DecMem contém os requisitos de memória do descompactador. Ou seja, as +configurações de compactação determinam os requisitos de memória do +descompactador. O uso exato da memória do descompactador é um pouco maior do +que o tamanho do dicionário LZMA2, mas os valores na tabela foram +arredondados para o próximo MiB completo. +.RE +.IP "" +Memory requirements of the multi\-threaded mode are significantly higher than +that of the single\-threaded mode. With the default value of +\fB\-\-block\-size\fP, each thread needs 3*3*DictSize plus CompMem or DecMem. For +example, four threads with preset \fB\-6\fP needs 660\(en670\ MiB of memory. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Usa uma variante mais lenta do nível de predefinição de compactação +selecionado (\fB\-0\fP ... \fB\-9\fP) para obter uma taxa de compactação um pouco +melhor, mas, com azar, isso também pode piorar. O uso da memória do +descompressor não é afetado, mas o uso da memória do compactador aumenta um +pouco nos níveis de predefinição \fB\-0\fP ... \fB\-3\fP. +.IP "" +Como existem duas predefinições com tamanhos de dicionário 4\ MiB e 8\ MiB, +as predefinições \fB\-3e\fP e \fB\-5e\fP usam configurações um pouco mais rápidas +(CompCPU inferior) do que \fB\-4e\fP e \fB\-6e\fP, respectivamente. Dessa forma, não +há duas predefinições idênticas. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Predefinição;DicTam;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Por exemplo, há um total de quatro predefinições que usam o dicionário 8\ MiB, cuja ordem do mais rápido ao mais lento é \fB\-5\fP, \fB\-6\fP, \fB\-5e\fP e +\fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Esses são apelidos um tanto enganosos para \fB\-0\fP e \fB\-9\fP, +respectivamente. Eles são fornecidos apenas para compatibilidade com versões +anteriores do LZMA Utils. Evite usar essas opções. +.TP +\fB\-\-block\-size=\fP\fItamanho\fP +Ao compactar para o formato \fB.xz\fP, divida os dados de entrada em blocos de +\fItamanho\fP bytes. Os blocos são compactados independentemente uns dos +outros, o que ajuda no multi\-threading e torna possível a descompactação +limitada de acesso aleatório. Essa opção normalmente é usada para substituir +o tamanho de bloco padrão no modo multi\-thread, mas também pode ser usada em +thread única. +.IP "" +In multi\-threaded mode about three times \fIsize\fP bytes will be allocated in +each thread for buffering input and output. The default \fIsize\fP is three +times the LZMA2 dictionary size or 1 MiB, whichever is more. Typically a +good value is 2\(en4 times the size of the LZMA2 dictionary or at least 1 +MiB. Using \fIsize\fP less than the LZMA2 dictionary size is waste of RAM +because then the LZMA2 dictionary buffer will never get fully used. In +multi\-threaded mode, the sizes of the blocks are stored in the block +headers. This size information is required for multi\-threaded +decompression. +.IP "" +In single\-threaded mode no block splitting is done by default. Setting this +option doesn't affect memory usage. No size information is stored in block +headers, thus files created in single\-threaded mode won't be identical to +files created in multi\-threaded mode. The lack of size information also +means that \fBxz\fP won't be able decompress the files in multi\-threaded mode. +.TP +\fB\-\-block\-list=\fP\fIitems\fP +When compressing to the \fB.xz\fP format, start a new block with an optional +custom filter chain after the given intervals of uncompressed data. +.IP "" +The \fIitems\fP are a comma\-separated list. Each item consists of an optional +filter chain number between 0 and 9 followed by a colon (\fB:\fP) and a +required size of uncompressed data. Omitting an item (two or more +consecutive commas) is a shorthand to use the size and filters of the +previous item. +.IP "" +If the input file is bigger than the sum of the sizes in \fIitems\fP, the last +item is repeated until the end of the file. A special value of \fB0\fP may be +used as the last size to indicate that the rest of the file should be +encoded as a single block. +.IP "" +An alternative filter chain for each block can be specified in combination +with the \fB\-\-filters1=\fP\fIfilters\fP \&...\& \fB\-\-filters9=\fP\fIfilters\fP options. +These options define filter chains with an identifier between 1\(en9. +Filter chain 0 can be used to refer to the default filter chain, which is +the same as not specifying a filter chain. The filter chain identifier can +be used before the uncompressed size, followed by a colon (\fB:\fP). For +example, if one specifies \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP +then blocks will be created using: +.RS +.IP \(bu 3 +The filter chain specified by \fB\-\-filters1\fP and 2 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters3\fP and 2 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters2\fP and 4 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters2\fP and 4 MiB input +.IP \(bu 3 +The default filter chain and 2 MiB input +.IP \(bu 3 +The default filter chain and 4 MiB input for every block until end of input. +.RE +.IP "" +If one specifies a size that exceeds the encoder's block size (either the +default value in threaded mode or the value specified with +\fB\-\-block\-size=\fP\fIsize\fP), the encoder will create additional blocks while +keeping the boundaries specified in \fIitems\fP. For example, if one specifies +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP and the +input file is 80 MiB, one will get 11 blocks: 5, 10, 8, 10, 2, 10, 10, 4, +10, 10, and 1 MiB. +.IP "" +No modo multi\-thread, os tamanhos dos blocos são armazenados nos cabeçalhos +dos blocos. Isso não é feito no modo de thread única, portanto, a saída +codificada não será idêntica à do modo multi\-thread. +.TP +\fB\-\-flush\-timeout=\fP\fItempo_limite\fP +Ao compactar, se mais de \fItempo_limite\fP milissegundos (um número inteiro +positivo) se passaram desde a liberação anterior e a leitura de mais entrada +seria bloqueada, todos os dados de entrada pendentes serão liberados do +codificador e disponibilizados no fluxo de saída. Isso pode ser útil se +\fBxz\fP for usado para compactar dados transmitidos por uma rede. Valores +\fItempo_limite\fP pequenos tornam os dados disponíveis na extremidade +receptora com um pequeno atraso, mas valores \fItempo_limite\fP grandes +oferecem melhor taxa de compactação. +.IP "" +Esse recurso está desabilitado por padrão. Se esta opção for especificada +mais de uma vez, a última terá efeito. O valor especial \fItempo_limite\fP de +\fB0\fP pode ser usado para desabilitar explicitamente esse recurso. +.IP "" +Este recurso não está disponível em sistemas não\-POSIX. +.IP "" +.\" FIXME +\fBEste recurso ainda é experimental.\fP Atualmente, \fBxz\fP não é adequado para +descompactar o fluxo em tempo real devido à forma como \fBxz\fP faz o buffer. +.TP +\fB\-\-no\-sync\fP +Do not synchronize the target file and its directory to the storage device +before removing the source file. This can improve performance if +compressing or decompressing many small files. However, if the system +crashes soon after the deletion, it is possible that the target file was not +written to the storage device but the delete operation was. In that case +neither the original source file nor the target file is available. +.IP "" +This option has an effect only when \fBxz\fP is going to remove the source +file. In other cases synchronization is never done. +.IP "" +The synchronization and \fB\-\-no\-sync\fP were added in \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIlimite\fP +Define um limite de uso de memória para compactação. Se esta opção for +especificada várias vezes, a última entrará em vigor. +.IP "" +Se as configurações de compactação excederem o \fIlimite\fP, \fBxz\fP tentará +ajustar as configurações para baixo para que o limite não seja mais excedido +e exibirá um aviso de que o ajuste automático foi feito. Os ajustes são +feitos nesta ordem: reduzindo o número de encadeamentos, alternando para o +modo sigle\-thread se até mesmo uma thread no modo multi\-thread exceder o +\fIlimite\fP e, finalmente, reduzindo o tamanho do dicionário LZMA2. +.IP "" +Ao compactar com \fB\-\-format=raw\fP ou se \fB\-\-no\-adjust\fP tiver sido +especificado, apenas o número de threads pode ser reduzido, pois isso pode +ser feito sem afetar a saída compactada. +.IP "" +Se o \fIlimite\fP não puder ser alcançado mesmo com os ajustes descritos acima, +um erro será exibido e \fBxz\fP sairá com status de saída 1. +.IP "" +O \fIlimite\fP pode ser especificado de várias maneiras: +.RS +.IP \(bu 3 +O \fIlimite\fP pode ser um valor absoluto em bytes. Usar um sufixo inteiro como +\fBMiB\fP pode ser útil. Exemplo: \fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +O \fIlimite\fP pode ser especificado como uma porcentagem da memória física +total (RAM). Isso pode ser útil especialmente ao definir a variável de +ambiente \fBXZ_DEFAULTS\fP em um script de inicialização de shell que é +compartilhado entre diferentes computadores. Dessa forma o limite é +automaticamente maior em sistemas com mais memória. Exemplo: +\fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +O \fIlimite\fP pode ser redefinido para seu valor padrão, definindo\-o como +\fB0\fP. Atualmente, isso equivale a definir \fIlimite\fP como \fBmax\fP (sem limite +de uso de memória). +.RE +.IP "" +Para \fBxz\fP de 32 bits, há um caso especial: se o \fIlimite\fP estiver acima de +\fB4020\ MiB\fP, o \fIlimite\fP é definido como \fB4020\ MiB\fP. No MIPS32 \fB2000\ MiB\fP é usado em seu lugar. (Os valores \fB0\fP e \fBmax\fP não são afetados por +isso. Um recurso semelhante não existe para descompactação.) Isso pode ser +útil quando um executável de 32 bits tem acesso a espaço de endereço de 4\ GiB (2 GiB no MIPS32) enquanto espero não causar danos em outras situações. +.IP "" +Consulte também a seção \fBUso de memória\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIlimite\fP +Define um limite de uso de memória para descompactação. Isso também afeta o +modo \fB\-\-list\fP. Se a operação não for possível sem exceder o \fIlimite\fP, +\fBxz\fP exibirá um erro e a descompactação do arquivo falhará. Consulte +\fB\-\-memlimit\-compress=\fP\fIlimite\fP para possíveis maneiras de especificar o +\fIlimite\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimite\fP +Define um limite de uso de memória para descompactação multi\-thread. Isso +pode afetar apenas o número de threads; isso nunca fará com que \fBxz\fP se +recuse a descompactar um arquivo. Se \fIlimite\fP for muito baixo para permitir +qualquer multi\-thread, o \fIlimite\fP será ignorado e \fBxz\fP continuará no modo +de thread única. Observe que se \fB\-\-memlimit\-decompress\fP também for usado, +ele sempre se aplicará aos modos de thread única e multi\-thread e, portanto, +o \fIlimite\fP efetivo para multi\-threading nunca será maior que o limite +definido com \fB\-\-memlimit\-decompress\fP. +.IP "" +Em contraste com as outras opções de limite de uso de memória, +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimite\fP tem um padrão \fIlimite\fP específico do +sistema. \fBxz \-\-info\-memory\fP pode ser usado para ver o valor atual. +.IP "" +Esta opção e seu valor padrão existem porque, sem qualquer limite, o +descompactador usando threads pode acabar alocando uma quantidade insana de +memória com alguns arquivos de entrada. Se o \fIlimite\fP padrão for muito +baixo em seu sistema, sinta\-se à vontade para aumentar o \fIlimite\fP, mas +nunca defina\-o para um valor maior que a quantidade de RAM utilizável, pois +com os arquivos de entrada apropriados \fBxz\fP tentará usar essa quantidade de +memória mesmo com um baixo número de threads. Ficar sem memória ou trocar +não melhorará o desempenho da descompactação. +.IP "" +Consulte \fB\-\-memlimit\-compress=\fP\fIlimite\fP para possíveis maneiras de +especificar o \fIlimite\fP. Definir \fIlimite\fP como \fB0\fP redefine \fIlimite\fP para +o valor padrão específico do sistema. +.TP +\fB\-M\fP \fIlimite\fP, \fB\-\-memlimit=\fP\fIlimite\fP, \fB\-\-memory=\fP\fIlimite\fP +Isso é equivalente a especificar \fB\-\-memlimit\-compress=\fP\fIlimite\fP +\fB\-\-memlimit\-decompress=\fP\fIlimite\fP \fB\-\-memlimit\-mt\-decompress=\fP\fIlimite\fP. +.TP +\fB\-\-no\-adjust\fP +Exibe um erro e saia se o limite de uso de memória não puder ser atendido +sem ajustar as configurações que afetam a saída compactada. Ou seja, isso +evita que \fBxz\fP alterne o codificador do modo multi\-thread para o modo +encadeado único e reduza o tamanho do dicionário LZMA2. Mesmo quando esta +opção é usada, o número de threads pode ser reduzido para atender ao limite +de uso de memória, pois isso não afetará a saída compactada. +.IP "" +O ajuste automático é sempre desativado ao criar fluxos brutos +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fIthreads\fP, \fB\-\-threads=\fP\fIthreads\fP +Especifica o número de threads de trabalho a serem usados. Definir +\fIthreads\fP para um valor especial \fB0\fP faz com que \fBxz\fP use tantos threads +quanto o(s) processador(es) no suporte do sistema. O número real de +encadeamentos pode ser menor que \fIthreads\fP se o arquivo de entrada não for +grande o suficiente para subdividir em threads com as configurações +fornecidas ou se o uso de mais threads exceder o limite de uso de memória. +.IP "" +Os compactadores usando thread única e várias threads produzem saídas +diferentes. O compactador de thread única fornecerá o menor tamanho de +arquivo, mas apenas a saída do compactador de várias threads pode ser +descompactada usando várias threads. Definir \fIthreads\fP como \fB1\fP usará o +modo de thread única. Definir \fIthreads\fP para qualquer outro valor, +incluindo \fB0\fP, usará o compressor de várias threads, mesmo que o sistema +tenha suporte a apenas uma thread de hardware. (\fBxz\fP 5.2.x usou o modo de +thread única nesta situação.) +.IP "" +Para usar o modo de várias threads com apenas uma thread, defina \fIthreads\fP +como \fB+1\fP. O prefixo \fB+\fP não tem efeito com valores diferentes de \fB1\fP. Um +limite de uso de memória ainda pode fazer \fBxz\fP alternar para o modo de +thread única, a menos que \fB\-\-no\-adjust\fP seja usado. O suporte para o +prefixo \fB+\fP foi adicionado no \fBxz\fP 5.4.0. +.IP "" +Se um número automático de threads foi solicitado e nenhum limite de uso de +memória foi especificado, um limite flexível padrão específico do sistema +será usado para possivelmente limitar o número de threads. É um limite +flexível no sentido de que é ignorado se o número de threads se tornar um, +portanto, um limite flexível nunca impedirá \fBxz\fP de compactar ou +descompactar. Este limite flexível padrão não fará com que \fBxz\fP alterne do +modo de várias threads para o modo de thread única. Os limites ativos podem +ser vistos com \fBxz \-\-info\-memory\fP. +.IP "" +Atualmente, o único método de threading é dividir a entrada em blocos e +comprimi\-los independentemente um do outro. O tamanho padrão do bloco +depende do nível de compactação e pode ser substituído com a opção +\fB\-\-block\-size=\fP\fItamanho\fP. +.IP "" +A descompactação em threads funciona apenas em arquivos que contêm vários +blocos com informações de tamanho nos cabeçalhos dos blocos. Todos os +arquivos grandes o suficiente compactados no modo de várias thread atendem a +essa condição, mas os arquivos compactados no modo de thread única não +atendem, mesmo se \fB\-\-block\-size=\fP\fItamanho\fP tiver sido usado. +.IP "" +The default value for \fIthreads\fP is \fB0\fP. In \fBxz\fP 5.4.x and older the +default is \fB1\fP. +. +.SS "Cadeias de filtro de compressor personalizadas" +Uma cadeia de filtro personalizada permite especificar as configurações de +compactação em detalhes, em vez de confiar nas configurações associadas às +predefinições. Quando uma cadeia de filtro personalizada é especificada, as +opções predefinidas (\fB\-0\fP \&...\& \fB\-9\fP e \fB\-\-extreme\fP) anteriores na linha +de comando são esquecidas. Se uma opção predefinida for especificada após +uma ou mais opções de cadeia de filtros personalizados, a nova predefinição +entrará em vigor e as opções de cadeia de filtros personalizados +especificadas anteriormente serão esquecidas. +.PP +Uma cadeia de filtro é comparável à tubulação na linha de comando. Ao +compactar, a entrada descompactada vai para o primeiro filtro, cuja saída +vai para o próximo filtro (se houver). A saída do último filtro é gravada no +arquivo compactado. O número máximo de filtros na cadeia é quatro, mas +normalmente uma cadeia de filtros tem apenas um ou dois filtros. +.PP +Muitos filtros têm limitações sobre onde podem estar na cadeia de filtros: +alguns filtros podem funcionar apenas como o último filtro na cadeia, alguns +apenas como filtro não\-último e alguns funcionam em qualquer posição na +cadeia. Dependendo do filtro, essa limitação é inerente ao projeto do filtro +ou existe para evitar problemas de segurança. +.PP +A custom filter chain can be specified in two different ways. The options +\fB\-\-filters=\fP\fIfilters\fP and \fB\-\-filters1=\fP\fIfilters\fP \&...\& +\fB\-\-filters9=\fP\fIfilters\fP allow specifying an entire filter chain in one +option using the liblzma filter string syntax. Alternatively, a filter +chain can be specified by using one or more individual filter options in the +order they are wanted in the filter chain. That is, the order of the +individual filter options is significant! When decoding raw streams +(\fB\-\-format=raw\fP), the filter chain must be specified in the same order as +it was specified when compressing. Any individual filter or preset options +specified before the full chain option (\fB\-\-filters=\fP\fIfilters\fP) will be +forgotten. Individual filters specified after the full chain option will +reset the filter chain. +.PP +Both the full and individual filter options take filter\-specific \fIoptions\fP +as a comma\-separated list. Extra commas in \fIoptions\fP are ignored. Every +option has a default value, so specify those you want to change. +.PP +Para ver toda a cadeia de filtros e \fIopções\fP, use \fBxz \-vv\fP (isto é, use +\fB\-\-verbose\fP duas vezes). Isso também funciona para visualizar as opções da +cadeia de filtros usadas pelas predefinições. +.TP +\fB\-\-filters=\fP\fIfilters\fP +Specify the full filter chain or a preset in a single option. Each filter +can be separated by spaces or two dashes (\fB\-\-\fP). \fIfilters\fP may need to be +quoted on the shell command line so it is parsed as a single option. To +denote \fIoptions\fP, use \fB:\fP or \fB=\fP. A preset can be prefixed with a \fB\-\fP +and followed with zero or more flags. The only supported flag is \fBe\fP to +apply the same options as \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIfilters\fP ... \fB\-\-filters9\fP=\fIfilters\fP +Specify up to nine additional filter chains that can be used with +\fB\-\-block\-list\fP. +.IP "" +For example, when compressing an archive with executable files followed by +text files, the executable part could use a filter chain with a BCJ filter +and the text part only the LZMA2 filter. +.TP +\fB\-\-filters\-help\fP +Display a help message describing how to specify presets and custom filter +chains in the \fB\-\-filters\fP and \fB\-\-filters1=\fP\fIfilters\fP \&...\& +\fB\-\-filters9=\fP\fIfilters\fP options, and exit successfully. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIopções\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIopções\fP] +.PD +Adiciona o filtro LZMA1 ou LZMA2 à cadeia de filtros. Esses filtros podem +ser usados apenas como o último filtro na cadeia. +.IP "" +LZMA1 é um filtro legado, que é suportado quase exclusivamente devido ao +formato de arquivo legado \fB.lzma\fP, que suporta apenas LZMA1. LZMA2 é uma +versão atualizada do LZMA1 para corrigir alguns problemas práticos do +LZMA1. O formato \fB.xz\fP usa LZMA2 e não suporta LZMA1. A velocidade de +compactação e as proporções de LZMA1 e LZMA2 são praticamente as mesmas. +.IP "" +LZMA1 e LZMA2 compartilham o mesmo conjunto de \fIopções\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIpredefinição\fP +Redefine todas as \fIopções\fP de LZMA1 ou LZMA2 para +\fIpredefinição\fP. \fIPredefinição\fP consiste em um número inteiro, que pode ser +seguido por modificadores de predefinição de uma única letra. O inteiro pode +ser de \fB0\fP a \fB9\fP, correspondendo às opções de linha de comando \fB\-0\fP +\&...\& \fB\-9\fP. O único modificador suportado atualmente é \fBe\fP, que +corresponde a \fB\-\-extreme\fP. Se nenhum \fBpreset\fP for especificado, os valores +padrão das \fIopções\fP LZMA1 ou LZMA2 serão obtidos da predefinição \fB6\fP. +.TP +\fBdict=\fP\fItamanho\fP +O \fItamanho\fP do dicionário (buffer de histórico) indica quantos bytes dos +dados não compactados processados recentemente são mantidos na memória. O +algoritmo tenta encontrar sequências de bytes repetidos (correspondências) +nos dados não compactados e substituí\-los por referências aos dados +atualmente no dicionário. Quanto maior o dicionário, maior a chance de +encontrar uma correspondência. Portanto, aumentar o dicionário \fItamanho\fP +geralmente melhora a taxa de compactação, mas um dicionário maior que o +arquivo não compactado é um desperdício de memória. +.IP "" +Um \fItamanho\fP de dicionário típico é de 64\ KiB a 64\ MiB. O mínimo é 4\ KiB. O máximo para compactação é atualmente 1,5\ GiB (1536\ MiB). O +descompactador já oferece suporte a dicionários de até um byte a menos de 4\ GiB, que é o máximo para os formatos de fluxo LZMA1 e LZMA2. +.IP "" +O \fItamanho\fP de dicionário e o localizador de correspondência (\fImf\fP) juntos +determinam o uso de memória do codificador LZMA1 ou LZMA2. O mesmo (ou +maior) \fItamanho\fP de dicionário é necessário para descompactar que foi usado +durante a compactação, portanto, o uso de memória do decodificador é +determinado pelo tamanho do dicionário usado durante a compactação. Os +cabeçalhos \fB.xz\fP armazenam o \fItamanho\fP de dicionário como 2^\fIn\fP ou 2^\fIn\fP ++ 2^(\fIn\fP\-1), então esses \fItamanhos\fP são um tanto preferidos para +compactação. Outros \fItamanhos\fP serão arredondados quando armazenados nos +cabeçalhos \fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Especifica o número de bits de contexto literais. O mínimo é 0 e o máximo é +4; o padrão é 3. Além disso, a soma de \fIlc\fP e \fIlp\fP não deve exceder 4. +.IP "" +Todos os bytes que não podem ser codificados como correspondências são +codificados como literais. Ou seja, literais são simplesmente bytes de 8 +bits que são codificados um de cada vez. +.IP "" +A codificação literal assume que os bits \fIlc\fP mais altos do byte não +compactado anterior se correlacionam com o próximo byte. Por exemplo, em um +texto típico em inglês, uma letra maiúscula geralmente é seguida por uma +letra minúscula, e uma letra minúscula geralmente é seguida por outra letra +minúscula. No conjunto de caracteres US\-ASCII, os três bits mais altos são +010 para letras maiúsculas e 011 para letras minúsculas. Quando \fIlc\fP é pelo +menos 3, a codificação literal pode aproveitar essa propriedade nos dados +não compactados. +.IP "" +O valor padrão (3) geralmente é bom. Se você deseja compactação máxima, +experimente \fBlc=4\fP. Às vezes ajuda um pouco, às vezes piora a +compactação. Se piorar, experimente \fBlc=2\fP também. +.TP +\fBlp=\fP\fIlp\fP +Especifica o número de bits de posição literal. O mínimo é 0 e o máximo é 4; +o padrão é 0. +.IP "" +\fILp\fP afeta que tipo de alinhamento nos dados não compactados é assumido ao +codificar literais. Consulte \fIpb\fP abaixo para obter mais informações sobre +alinhamento. +.TP +\fBpb=\fP\fIpb\fP +Especifica o número de bits de posição. O mínimo é 0 e o máximo é 4; o +padrão é 2. +.IP "" +\fIPb\fP afeta que tipo de alinhamento nos dados não compactados é assumido em +geral. O padrão significa alinhamento de quatro bytes (2^\fIpb\fP=2^2=4), que +geralmente é uma boa escolha quando não há melhor estimativa. +.IP "" +Quando o alinhamento é conhecido, definir \fIpb\fP adequadamente pode reduzir +um pouco o tamanho do arquivo. Por exemplo, com arquivos de texto com +alinhamento de um byte (US\-ASCII, ISO\-8859\-*, UTF\-8), a configuração \fBpb=0\fP +pode melhorar um pouco a compactação. Para texto UTF\-16, \fBpb=1\fP é uma boa +escolha. Se o alinhamento for um número ímpar como 3 bytes, \fBpb=0\fP pode ser +a melhor escolha. +.IP "" +Embora o alinhamento assumido possa ser ajustado com \fIpb\fP e \fIlp\fP, LZMA1 e +LZMA2 ainda favorecem ligeiramente o alinhamento de 16 bytes. Pode valer a +pena levar em consideração ao projetar formatos de arquivo que provavelmente +serão compactados com LZMA1 ou LZMA2. +.TP +\fBmf=\fP\fImf\fP +O localizador de correspondência tem um efeito importante na velocidade do +codificador, uso de memória e taxa de compactação. Normalmente, os +localizadores de correspondência de Hash Chain são mais rápidos do que os +localizadores de correspondência de árvore binária. O padrão depende do +\fIpredefinição\fP: 0 usa \fBhc3\fP, 1\(en3 usa \fBhc4\fP e o resto usa \fBbt4\fP. +.IP "" +Os seguintes localizadores de correspondência são suportados. As fórmulas de +uso de memória abaixo são aproximações aproximadas, que estão mais próximas +da realidade quando \fIdict\fP é uma potência de dois. +.RS +.TP +\fBhc3\fP +Cadeia de hashs com hashing de 2 e 3 bytes +.br +Valor mínimo para \fInice\fP: 3 +.br +Uso de memória: +.br +\fIdict\fP * 7.5 (if \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 5.5 + 64 MiB (if \fIdict\fP > 16 MiB) +.TP +\fBhc4\fP +Cadeia de hashs com hashing de 2, 3 e 4 bytes +.br +Valor mínimo para \fInice\fP: 4 +.br +Uso de memória: +.br +\fIdict\fP * 7.5 (if \fIdict\fP <= 32 MiB); +.br +\fIdict\fP * 6.5 (if \fIdict\fP > 32 MiB) +.TP +\fBbt2\fP +Árvore binária com hashing de 2 bytes +.br +Valor mínimo para \fInice\fP: 2 +.br +Uso de memória: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Árvore binária com hashing de 2 e 3 bytes +.br +Valor mínimo para \fInice\fP: 3 +.br +Uso de memória: +.br +\fIdict\fP * 11.5 (if \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 9.5 + 64 MiB (if \fIdict\fP > 16 MiB) +.TP +\fBbt4\fP +Árvore binária com hashing de 2, 3 e 4 bytes +.br +Valor mínimo para \fInice\fP: 4 +.br +Uso de memória: +.br +\fIdict\fP * 11.5 (if \fIdict\fP <= 32 MiB); +.br +\fIdict\fP * 10.5 (if \fIdict\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fImodo\fP +O \fImodo\fP de compactação especifica o método para analisar os dados +produzidos pelo localizador de correspondência. Os \fImodos\fP suportados são +\fBfast\fP e \fBnormal\fP. O padrão é \fBfast\fP para \fIpredefinições\fP 0\(en3 e +\fBnormal\fP para \fIpredefinições\fP 4\(en9. +.IP "" +Normalmente, \fBfast\fP é usado com localizadores de correspondência cadeia de +hashs e \fBnormal\fP com localizadores de correspondência de árvore +binária. Isso também é o que os \fIpredefinições\fP fazem. +.TP +\fBnice=\fP\fInice\fP +Especifica o que é considerado um bom comprimento para uma +correspondência. Uma vez que uma correspondência de pelo menos \fInice\fP bytes +é encontrada, o algoritmo para de procurar correspondências possivelmente +melhores. +.IP "" +\fINice\fP pode ser 2\(en273 bytes. Valores mais altos tendem a fornecer melhor +taxa de compactação em detrimento da velocidade. O padrão depende do +\fIpredefinição\fP. +.TP +\fBdepth=\fP\fIprofundidade\fP +Especifica a profundidade máxima de pesquisa no localizador de +correspondências. O padrão é o valor especial de 0, que faz com que o +compressor determine um \fIprofundidade\fP razoável de \fImf\fP e \fInice\fP. +.IP "" +Uma \fIprofundidade\fP razoável para cadeias de hash é 4\(en100 e 16\(en1000 +para árvores binárias. Usar valores muito altos para \fIprofundidade\fP pode +tornar o codificador extremamente lento com alguns arquivos. Evite definir +\fIprofundidade\fP acima de 1000 a menos que você esteja preparado para +interromper a compactação caso ela esteja demorando muito. +.RE +.IP "" +Ao decodificar fluxos brutos (\fB\-\-format=raw\fP), o LZMA2 precisa apenas do +dicionário \fItamanho\fP. LZMA1 também precisa de \fIlc\fP, \fIlp\fP e \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIopções\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIopções\fP] +.PD +Adiciona um filtro de ramificação/chamada/salto (BCJ) à cadeia de +filtros. Esses filtros podem ser usados apenas como um filtro não último na +cadeia de filtros. +.IP "" +Um filtro BCJ converte endereços relativos no código de máquina em suas +contrapartes absolutas. Isso não altera o tamanho dos dados, mas aumenta a +redundância, o que pode ajudar o LZMA2 a produzir um arquivo \fB.xz\fP 0\(en15\ % menor. Os filtros BCJ são sempre reversíveis, portanto, usar um filtro BCJ +para o tipo errado de dados não causa nenhuma perda de dados, embora possa +piorar um pouco a taxa de compactação.Os filtros BCJ são muito rápidos e +usam uma quantidade insignificante de memória. +.IP "" +Esses filtros BCJ têm problemas conhecidos relacionados à taxa de +compactação: +.RS +.IP \(bu 3 +Alguns tipos de arquivos contendo código executável (por exemplo, arquivos +de objeto, bibliotecas estáticas e módulos do kernel do Linux) têm os +endereços nas instruções preenchidos com valores de preenchimento. Esses +filtros BCJ ainda vão fazer a conversão de endereço, o que vai piorar a +compactação desses arquivos. +.IP \(bu 3 +Se um filtro BCJ for aplicado em um arquivo, é possível que isso torne a +taxa de compactação pior do que não usar um filtro BCJ. Por exemplo, se +houver executáveis semelhantes ou mesmo idênticos, a filtragem provavelmente +tornará os arquivos menos semelhantes e, portanto, a compactação será +pior. O conteúdo de arquivos não executáveis no mesmo arquivo também pode +ser importante. Na prática tem que tentar com e sem filtro BCJ para ver qual +é melhor em cada situação. +.RE +.IP "" +Conjuntos de instruções diferentes têm alinhamento diferente: o arquivo +executável deve ser alinhado a um múltiplo desse valor nos dados de entrada +para fazer o filtro funcionar. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filtro;Alinhamento;Observações +x86;1;x86 32 bits ou 64 bits +ARM;4; +ARM\-Thumb;2; +ARM64;4;Alinhamento de 4096 bytes +;;é melhor +PowerPC;4;Somente big endian +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Since the BCJ\-filtered data is usually compressed with LZMA2, the +compression ratio may be improved slightly if the LZMA2 options are set to +match the alignment of the selected BCJ filter. Examples: +.RS +.IP \(bu 3 +IA\-64 filter has 16\-byte alignment so \fBpb=4,lp=4,lc=0\fP is good with LZMA2 +(2^4=16). +.IP \(bu 3 +RISC\-V code has 2\-byte or 4\-byte alignment depending on whether the file +contains 16\-bit compressed instructions (the C extension). When 16\-bit +instructions are used, \fBpb=2,lp=1,lc=3\fP or \fBpb=1,lp=1,lc=3\fP is good. When +16\-bit instructions aren't present, \fBpb=2,lp=2,lc=2\fP is the best. +\fBreadelf \-h\fP can be used to check if "RVC" appears on the "Flags" line. +.IP \(bu 3 +ARM64 is always 4\-byte aligned so \fBpb=2,lp=2,lc=2\fP is the best. +.IP \(bu 3 +The x86 filter is an exception. It's usually good to stick to LZMA2's +defaults (\fBpb=2,lp=0,lc=3\fP) when compressing x86 executables. +.RE +.IP "" +Todos os filtros BCJ suportam as mesmas \fIopções\fP: +.RS +.TP +\fBstart=\fP\fIdeslocamento\fP +Especifica o \fIdeslocamento\fP inicial que é usado na conversão entre +endereços relativos e absolutos. O \fIdeslocamento\fP deve ser um múltiplo do +alinhamento do filtro (ver tabela acima). O padrão é zero. Na prática, o +padrão é bom; especificar um \fIdeslocamento\fP personalizado quase nunca é +útil. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIopções\fP] +Adiciona o filtro Delta à cadeia de filtros. O filtro Delta só pode ser +usado como filtro não\-último na cadeia de filtros. +.IP "" +Atualmente, apenas o cálculo simples de delta byte a byte é suportado. Pode +ser útil ao compactar, por exemplo, imagens bitmap não compactadas ou áudio +PCM não compactado. No entanto, algoritmos de propósito especial podem +fornecer resultados significativamente melhores do que Delta + LZMA2. Isso é +verdade especialmente com áudio, que compacta mais rápido e melhor, por +exemplo, com \fBflac\fP(1). +.IP "" +\fIOpções\fP suportadas: +.RS +.TP +\fBdist=\fP\fIdistância\fP +Especifica a \fIdistância\fP do cálculo delta em bytes. \fIdistância\fP deve ser +1\(en256. O padrão é 1. +.IP "" +Por exemplo, com \fBdist=2\fP e entrada de oito bytes A1 B1 A2 B3 A3 B5 A4 B7, +a saída será A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Outras opções" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Suprime avisos e avisos. Especifique isso duas vezes para suprimir erros +também. Esta opção não tem efeito no status de saída. Ou seja, mesmo que um +aviso tenha sido suprimido, o status de saída para indicar um aviso ainda é +usado. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Ser detalhado. Se o erro padrão estiver conectado a um terminal, \fBxz\fP +exibirá um indicador de progresso. Especifique \fB\-\-verbose\fP duas vezes dará +uma saída ainda mais detalhada. +.IP "" +O indicador de progresso mostra as seguintes informações: +.RS +.IP \(bu 3 +A porcentagem de conclusão é mostrada se o tamanho do arquivo de entrada for +conhecido. Ou seja, a porcentagem não pode ser mostrada em encadeamentos +(pipe). +.IP \(bu 3 +Quantidade de dados compactados produzidos (compactando) ou consumidos +(descompactando). +.IP \(bu 3 +Quantidade de dados não compactados consumidos (compactação) ou produzidos +(descompactação). +.IP \(bu 3 +Taxa de compactação, que é calculada dividindo a quantidade de dados +compactados processados até o momento pela quantidade de dados não +compactados processados até o momento. +.IP \(bu 3 +Velocidade de compactação ou descompactação. Isso é medido como a quantidade +de dados não compactados consumidos (compactação) ou produzidos +(descompactação) por segundo. É mostrado após alguns segundos desde que +\fBxz\fP começou a processar o arquivo. +.IP \(bu 3 +Tempo decorrido no formato M:SS ou H:MM:SS. +.IP \(bu 3 +O tempo restante estimado é mostrado apenas quando o tamanho do arquivo de +entrada é conhecido e alguns segundos já se passaram desde que \fBxz\fP começou +a processar o arquivo. A hora é mostrada em um formato menos preciso que +nunca tem dois pontos, por exemplo, 2 min 30 s. +.RE +.IP "" +Quando o erro padrão não é um terminal, \fB\-\-verbose\fP fará com que \fBxz\fP +imprima o nome do arquivo, tamanho compactado, tamanho não compactado, taxa +de compactação e possivelmente também a velocidade e o tempo decorrido em +uma única linha para o erro padrão após a compactação ou descompactando o +arquivo. A velocidade e o tempo decorrido são incluídos apenas quando a +operação leva pelo menos alguns segundos. Se a operação não foi concluída, +por exemplo, devido à interrupção do usuário, também é impressa a +porcentagem de conclusão se o tamanho do arquivo de entrada for conhecido. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Não define o status de saída como 2, mesmo que uma condição digna de um +aviso tenha sido detectada. Esta opção não afeta o nível de detalhamento, +portanto, tanto \fB\-\-quiet\fP quanto \fB\-\-no\-warn\fP devem ser usados para não +exibir avisos e não alterar o status de saída. +.TP +\fB\-\-robot\fP +Imprime mensagens em um formato analisável por máquina. Isso visa facilitar +a criação de frontends que desejam usar \fBxz\fP em vez de liblzma, o que pode +ser o caso de vários scripts. A saída com esta opção habilitada deve ser +estável em versões \fBxz\fP. Consulte a seção \fBMODO ROBÔ\fP para obter detalhes. +.TP +\fB\-\-info\-memory\fP +Exibe, em formato legível por humanos, quanta memória física (RAM) e quantos +threads de processador \fBxz\fP acredita que o sistema possui e os limites de +uso de memória para compactação e descompactação e saia com êxito. +.TP +\fB\-h\fP, \fB\-\-help\fP +Exibe uma mensagem de ajuda descrevendo as opções mais usadas e sai com +sucesso. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Exibe uma mensagem de ajuda descrevendo todos os recursos de \fBxz\fP e sai com +sucesso +.TP +\fB\-V\fP, \fB\-\-version\fP +Exibe o número da versão de \fBxz\fP e liblzma em formato legível por +humanos. Para obter uma saída analisável por máquina, especifique \fB\-\-robot\fP +antes de \fB\-\-version\fP. +. +.SH "MODO ROBÔ" +The robot mode is activated with the \fB\-\-robot\fP option. It makes the output +of \fBxz\fP easier to parse by other programs. Currently \fB\-\-robot\fP is +supported only together with \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, +and \fB\-\-version\fP. It will be supported for compression and decompression in +the future. +. +.SS "Modo lista" +\fBxz \-\-robot \-\-list\fP usa saída separada por tabulações. A primeira coluna de +cada linha possui uma string que indica o tipo de informação encontrada +naquela linha: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Esta é sempre a primeira linha ao começar a listar um arquivo. A segunda +coluna na linha é o nome do arquivo. +.TP +\fBfile\fP +Esta linha contém informações gerais sobre o arquivo \fB.xz\fP. Esta linha é +sempre impressa após a linha \fBname\fP. +.TP +\fBstream\fP +Este tipo de linha é usado somente quando \fB\-\-verbose\fP foi +especificado. Existem tantas linhas de \fBstream\fP quanto fluxos no arquivo +\&\fB.xz\fP. +.TP +\fBblock\fP +Este tipo de linha é usado somente quando \fB\-\-verbose\fP foi +especificado. Existem tantas linhas \fBblock\fP quanto blocos no arquivo +\&\fB.xz\fP. As linhas \fBblock\fP são mostradas após todas as linhas \fBstream\fP; +diferentes tipos de linha não são intercalados. +.TP +\fBsummary\fP +Este tipo de linha é usado apenas quando \fB\-\-verbose\fP foi especificado duas +vezes. Esta linha é impressa após todas as linhas de \fBblock\fP. Assim como a +linha \fBarquivo\fP, a linha \fBsummary\fP contém informações gerais sobre o +arquivo \fB.xz\fP. +.TP +\fBtotals\fP +Esta linha é sempre a última linha da saída da lista. Ele mostra as +contagens totais e tamanhos. +.PP +As colunas das linhas \fBfile\fP: +.PD 0 +.RS +.IP 2. 4 +Número de fluxos no arquivo +.IP 3. 4 +Número total de blocos no(s) fluxo(s) +.IP 4. 4 +Tamanho compactado do arquivo +.IP 5. 4 +Uncompressed size of the file +.IP 6. 4 +Taxa de compactação, por exemplo, \fB0.123\fP. Se a proporção for superior a +9.999, serão exibidos três traços (\fB\-\-\-\fP) em vez da proporção. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Lista separada por vírgulas de nomes de verificação de integridade. As +seguintes strings são usadas para os tipos de verificação conhecidos: +\fBNone\fP, \fBCRC32\fP, \fBCRC64\fP e \fBSHA\-256\fP. Para tipos de verificações +desconhecidos, \fBUnknown\-\fP\fIN\fP é usado, onde \fIN\fP é o ID do cheque como um +número decimal (um ou dois dígitos). +.IP 8. 4 +Tamanho total do preenchimento de fluxo no arquivo +.RE +.PD +.PP +As colunas das linhas \fBstream\fP: +.PD 0 +.RS +.IP 2. 4 +Número do fluxo (o primeiro fluxo é 1) +.IP 3. 4 +Número de blocos no fluxo +.IP 4. 4 +Deslocamento inicial compactado +.IP 5. 4 +Deslocamento inicial descompactado +.IP 6. 4 +Tamanho compactado (não inclui preenchimento de fluxo) +.IP 7. 4 +Tamanho descompactado +.IP 8. 4 +Taxa de compactação +.IP 9. 4 +Nome da verificação de integridade +.IP 10. 4 +Tamanho do preenchimento do fluxo +.RE +.PD +.PP +As colunas das linhas \fBblock\fP: +.PD 0 +.RS +.IP 2. 4 +Número do fluxo que contém este bloco +.IP 3. 4 +Número do bloco relativo ao início do fluxo (o primeiro bloco é 1) +.IP 4. 4 +Número do bloco relativo ao início do arquivo +.IP 5. 4 +Deslocamento inicial compactado em relação ao início do arquivo +.IP 6. 4 +Deslocamento inicial descompactado em relação ao início do arquivo +.IP 7. 4 +Tamanho total compactado do bloco (inclui cabeçalhos) +.IP 8. 4 +Tamanho descompactado +.IP 9. 4 +Taxa de compactação +.IP 10. 4 +Nome da verificação de integridade +.RE +.PD +.PP +Se \fB\-\-verbose\fP for especificado duas vezes, colunas adicionais serão +incluídas nas linhas \fBblock\fP. Eles não são exibidos com um único +\fB\-\-verbose\fP, porque obter essas informações requer muitas buscas e, +portanto, pode ser lento: +.PD 0 +.RS +.IP 11. 4 +Valor da verificação de integridade em hexadecimal +.IP 12. 4 +Tamanho do cabeçalho do bloco +.IP 13. 4 +Sinalizadores de bloco: \fBc\fP indica que o tamanho compactado está presente e +\fBu\fP indica que o tamanho não compactado está presente. Se o sinalizador não +estiver definido, um traço (\fB\-\fP) será exibido para manter o comprimento da +string fixo. Novos sinalizadores podem ser adicionados ao final da string no +futuro. +.IP 14. 4 +Tamanho dos dados reais compactados no bloco (isso exclui o cabeçalho do +bloco, o preenchimento do bloco e os campos de verificação) +.IP 15. 4 +Quantidade de memória (em bytes) necessária para descompactar este bloco com +esta versão \fBxz\fP +.IP 16. 4 +Cadeia de filtro. Observe que a maioria das opções usadas no momento da +compactação não pode ser conhecida, pois apenas as opções necessárias para a +descompactação são armazenadas nos cabeçalhos \fB.xz\fP. +.RE +.PD +.PP +As colunas das linhas \fBsummary\fP: +.PD 0 +.RS +.IP 2. 4 +Quantidade de memória (em bytes) necessária para descompactar este arquivo +com esta versão do \fBxz\fP +.IP 3. 4 +\fByes\fP ou \fBno\fP indicando se todos os cabeçalhos de bloco têm tamanho +compactado e tamanho não compactado armazenados neles +.PP +\fIDesde\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Versão mínima do \fBxz\fP necessária para descompactar o arquivo +.RE +.PD +.PP +As colunas da linha \fBtotals\fP: +.PD 0 +.RS +.IP 2. 4 +Número de fluxos +.IP 3. 4 +Número de blocos +.IP 4. 4 +Tamanho compactado +.IP 5. 4 +Tamanho descompactado +.IP 6. 4 +Taxa de compactação média +.IP 7. 4 +Lista separada por vírgulas de nomes de verificação de integridade que +estavam presentes nos arquivos +.IP 8. 4 +Tamanho do preenchimento do fluxo +.IP 9. 4 +Número de arquivos. Isso está aqui para manter a ordem das colunas +anteriores a mesma das linhas \fBfile\fP. +.PD +.RE +.PP +Se \fB\-\-verbose\fP for especificado duas vezes, colunas adicionais serão +incluídas na linha \fBtotals\fP: +.PD 0 +.RS +.IP 10. 4 +Quantidade máxima de memória (em bytes) necessária para descompactar os +arquivos com esta versão do \fBxz\fP +.IP 11. 4 +\fByes\fP ou \fBno\fP indicando se todos os cabeçalhos de bloco têm tamanho +compactado e tamanho não compactado armazenados neles +.PP +\fIDesde\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Versão mínima do \fBxz\fP necessária para descompactar o arquivo +.RE +.PD +.PP +Versões futuras podem adicionar novos tipos de linha e novas colunas podem +ser adicionadas aos tipos de linha existentes, mas as colunas existentes não +serão alteradas. +. +.SS "Filters help" +\fBxz \-\-robot \-\-filters\-help\fP prints the supported filters in the following +format: +.PP +\fIfilter\fP\fB:\fP\fIoption\fP\fB=<\fP\fIvalue\fP\fB>,\fP\fIoption\fP\fB=<\fP\fIvalue\fP\fB>\fP... +.TP +\fIfilter\fP +Name of the filter +.TP +\fIoption\fP +Name of a filter specific option +.TP +\fIvalue\fP +Numeric \fIvalue\fP ranges appear as \fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. String +\fIvalue\fP choices are shown within \fB< >\fP and separated by a \fB|\fP +character. +.PP +Each filter is printed on its own line. +. +.SS "Informações de limite de memória" +\fBxz \-\-robot \-\-info\-memory\fP prints a single line with multiple tab\-separated +columns: +.IP 1. 4 +Quantidade total de memória física (RAM) em bytes. +.IP 2. 4 +Limite de uso de memória para compactação em bytes +(\fB\-\-memlimit\-compress\fP). Um valor especial de \fB0\fP indica a configuração +padrão que para o modo de thread única é o mesmo que sem limite. +.IP 3. 4 +Limite de uso de memória para descompactação em bytes +(\fB\-\-memlimit\-decompress\fP). Um valor especial de \fB0\fP indica a configuração +padrão que para o modo de thread única é o mesmo que sem limite. +.IP 4. 4 +Desde \fBxz\fP 5.3.4alpha: Uso de memória para descompactação com várias thread +em bytes (\fB\-\-memlimit\-mt\-decompress\fP). Isso nunca é zero porque um valor +padrão específico do sistema mostrado na coluna 5 é usado se nenhum limite +for especificado explicitamente. Isso também nunca é maior que o valor na +coluna 3, mesmo que um valor maior tenha sido especificado com +\fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Desde \fBxz\fP 5.3.4alpha: Um limite de uso de memória padrão específico do +sistema que é usado para limitar o número de threads ao compactar com um +número automático de threads (\fB\-\-threads=0\fP) e nenhum limite de uso de +memória foi especificado (\fB\-\-memlimit\-compress\fP). Isso também é usado como +o valor padrão para \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Desde \fBxz\fP 5.3.4alpha: Número de threads de processador disponíveis. +.PP +No futuro, a saída de \fBxz \-\-robot \-\-info\-memory\fP pode ter mais colunas, mas +nunca mais do que uma única linha. +. +.SS Versão +\fBxz \-\-robot \-\-version\fP prints the version number of \fBxz\fP and liblzma in +the following format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Versão principal. +.TP +\fIYYY\fP +Versão menor. Números pares são estáveis. Os números ímpares são versões +alfa ou beta. +.TP +\fIZZZ\fP +Nível de patch para versões estáveis ou apenas um contador para versões de +desenvolvimento. +.TP +\fIS\fP +Estabilidade. 0 é alfa, 1 é beta e 2 é estável. \fIS\fP deve ser sempre 2 +quando \fIYYY\fP for par. +.PP +\fIXYYYZZZS\fP são iguais em ambas as linhas se \fBxz\fP e liblzma forem da mesma +versão do XZ Utils. +.PP +Exemplos: 4.999.9beta é \fB49990091\fP e 5.0.0 é \fB50000002\fP. +. +.SH "STATUS DE SAÍDA" +.TP +\fB0\fP +Está tudo bem. +.TP +\fB1\fP +Ocorreu um erro. +.TP +\fB2\fP +Algo digno de um aviso ocorreu, mas ocorreu nenhum erro real. +.PP +Observações (não avisos ou erros) impressas no erro padrão não afetam o +status de saída. +. +.SH AMBIENTE +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP analisa listas de opções separadas por espaços das variáveis de +ambiente \fBXZ_DEFAULTS\fP e \fBXZ_OPT\fP, nesta ordem, antes de analisar as +opções da linha de comando. Observe que apenas as opções são analisadas a +partir das variáveis de ambiente; todas as não opções são silenciosamente +ignoradas. A análise é feita com \fBgetopt_long\fP(3) que também é usado para +os argumentos da linha de comando. +.PP +\fBWarning:\fP By setting these environment variables, one is effectively +modifying programs and scripts that run \fBxz\fP. Most of the time it is safe +to set memory usage limits, number of threads, and compression options via +the environment variables. However, some options can break scripts. An +obvious example is \fB\-\-help\fP which makes \fBxz\fP show the help text instead of +compressing or decompressing a file. More subtle examples are \fB\-\-quiet\fP +and \fB\-\-verbose\fP. In many cases it works well to enable the progress +indicator using \fB\-\-verbose\fP, but in some situations the extra messages +create problems. The verbosity level also affects the behavior of +\fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +User\-specific or system\-wide default options. Typically this is set in a +shell initialization script to enable \fBxz\fP's memory usage limiter by +default or set the default number of threads. Excluding shell +initialization scripts and similar special cases, scripts should never set +or unset \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Isso é para passar opções para \fBxz\fP quando não é possível definir as opções +diretamente na linha de comando \fBxz\fP. Este é o caso quando \fBxz\fP é +executado por um script ou ferramenta, por exemplo, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Os scripts podem usar \fBXZ_OPT\fP, por exemplo, para definir opções de +compactação padrão específicas do script. Ainda é recomendável permitir que +os usuários substituam \fBXZ_OPT\fP se isso for razoável. Por exemplo, em +scripts \fBsh\fP(1) pode\-se usar algo assim: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "COMPATIBILIDADE COM LZMA UTILS" +A sintaxe da linha de comando do \fBxz\fP é praticamente um superconjunto de +\fBlzma\fP, \fBunlzma\fP e \fBlzcat\fP conforme encontrado no LZMA Utils 4.32.x. Na +maioria dos casos, é possível substituir LZMA Utils por XZ Utils sem +interromper os scripts existentes. Existem algumas incompatibilidades, +porém, que às vezes podem causar problemas. +. +.SS "Níveis de predefinição de compactação" +A numeração das predefinições de nível de compactação não é idêntica em +\fBxz\fP e LZMA Utils. A diferença mais importante é como os tamanhos dos +dicionários são mapeados para diferentes predefinições. O tamanho do +dicionário é aproximadamente igual ao uso de memória do descompactador. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nível;xz;LZMA Utils +\-0;256 KiB;N/D +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +As diferenças de tamanho do dicionário também afetam o uso da memória do +compressor, mas existem algumas outras diferenças entre LZMA Utils e XZ +Utils, que tornam a diferença ainda maior: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nível;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/D +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +O nível de predefinição padrão no LZMA Utils é \fB\-7\fP enquanto no XZ Utils é +\fB\-6\fP, então ambos usam um dicionário de 8 MiB por padrão. +. +.SS "Arquivos .lzma em um fluxo versus sem ser em um fluxo" +O tamanho descompactado do arquivo pode ser armazenado no cabeçalho de +\&\fB.lzma\fP. O LZMA Utils faz isso ao compactar arquivos comuns. A alternativa +é marcar que o tamanho não compactado é desconhecido e usar o marcador de +fim de carga útil para indicar onde o descompactador deve parar. O LZMA +Utils usa este método quando o tamanho não compactado não é conhecido, como +é o caso, por exemplo, de encadeamentos (pipes). +.PP +\fBxz\fP oferece suporte à descompactação de arquivos \fB.lzma\fP com ou sem +marcador de fim de carga útil, mas todos os arquivos \fB.lzma\fP criados por +\fBxz\fP usarão marcador de fim de carga útil e terão o tamanho descompactado +marcado como desconhecido no cabeçalho de \fB.lzma\fP. Isso pode ser um +problema em algumas situações incomuns. Por exemplo, um descompactador de +\&\fB.lzma\fP em um dispositivo embarcado pode funcionar apenas com arquivos que +tenham tamanho descompactado conhecido. Se você encontrar esse problema, +precisará usar o LZMA Utils ou o LZMA SDK para criar arquivos \fB.lzma\fP com +tamanho descompactado conhecido. +. +.SS "Arquivos .lzma não suportados" +O formato \fB.lzma\fP permite valores \fIlc\fP até 8 e valores \fIlp\fP até 4. LZMA +Utils pode descompactar arquivos com qualquer \fIlc\fP e \fIlp\fP, mas sempre cria +arquivos com \fBlc=3\fP e \fBlp=0\fP. Criar arquivos com outros \fIlc\fP e \fIlp\fP é +possível com \fBxz\fP e com LZMA SDK. +.PP +A implementação do filtro LZMA1 em liblzma requer que a soma de \fIlc\fP e +\fIlp\fP não exceda 4. Assim, arquivos \fB.lzma\fP, que excedam esta limitação, +não podem ser descompactados com \fBxz\fP. +.PP +LZMA Utils cria apenas arquivos \fB.lzma\fP que possuem um tamanho de +dicionário de 2^\fIn\fP (uma potência de 2), mas aceita arquivos com qualquer +tamanho de dicionário. liblzma aceita apenas arquivos \fB.lzma\fP que tenham um +tamanho de dicionário de 2^\fIn\fP ou 2^\fIn\fP + 2^(\fIn\fP\-1). Isso é para diminuir +os falsos positivos ao detectar arquivos \fB.lzma\fP. +.PP +Essas limitações não devem ser um problema na prática, já que praticamente +todos os arquivos \fB.lzma\fP foram compactados com configurações que o liblzma +aceitará. +. +.SS "Lixo à direita" +Ao descompactar, o LZMA Utils silenciosamente ignora tudo após o primeiro +fluxo \fB.lzma\fP. Na maioria das situações, isso é um bug. Isso também +significa que o LZMA Utils não oferece suporte a descompactação de arquivos +\&\fB.lzma\fP concatenados. +.PP +Se houver dados restantes após o primeiro fluxo de \fB.lzma\fP, \fBxz\fP considera +o arquivo corrompido, a menos que \fB\-\-single\-stream\fP tenha sido usado. Isso +pode quebrar scripts obscuros que presumiram que o lixo à direita é +ignorado. +. +.SH NOTAS +. +.SS "A saída compactada pode variar" +A saída compactada exata produzida a partir do mesmo arquivo de entrada não +compactado pode variar entre as versões do XZ Utils, mesmo se as opções de +compactação forem idênticas. Isso ocorre porque o codificador pode ser +aprimorado (compactação mais rápida ou melhor) sem afetar o formato do +arquivo. A saída pode variar mesmo entre diferentes compilações da mesma +versão do XZ Utils, se diferentes opções de compilação forem usadas. +.PP +A informação acima significa que, uma vez que \fB\-\-rsyncable\fP tenha sido +implementado, os arquivos resultantes não serão necessariamente +"rsyncáveis", a menos que os arquivos antigos e novos tenham sido +compactados com a mesma versão xz. Esse problema pode ser corrigido se uma +parte da implementação do codificador for congelada para manter a saída de +rsyncable estável nas versões do xz. +. +.SS "Descompactadores .xz embarcados" +As implementações do descompactador \fB.xz\fP embarcados, como o XZ Embedded, +não oferecem necessariamente suporte a arquivos criados com tipos de +\fIverificações\fP de integridade diferentes de \fBnone\fP e \fBcrc32\fP. Como o +padrão é \fB\-\-check=crc64\fP, você deve usar \fB\-\-check=none\fP ou +\fB\-\-check=crc32\fP ao criar arquivos para sistemas embarcados. +.PP +Fora dos sistemas embarcados, todos os descompactadores de formato \fB.xz\fP +oferecem suporte a todos os tipos de \fIverificação\fP ou, pelo menos, são +capazes de descompactar o arquivo sem verificar a verificação de integridade +se a \fIverificação\fP específica não for suportada. +.PP +XZ Embedded oferece suporte a filtros BCJ, mas apenas com o deslocamento +inicial padrão. +. +.SH EXEMPLOS +. +.SS Básico +Compactar o arquivo \fIfoo\fP em \fIfoo.xz\fP usando o nível de compactação padrão +(\fB\-6\fP) e remover \fIfoo\fP se a compactação for bem\-sucedida: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Descompactar \fIbar.xz\fP em \fIbar\fP e não remover \fIbar.xz\fP mesmo se a +descompactação for bem\-sucedida: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Criar \fIbaz.tar.xz\fP com a predefinição \fB\-4e\fP (\fB\-4 \-\-extreme\fP), que é mais +lenta que o padrão \fB\-6\fP, mas precisa de menos memória para compactação e +descompactação (48 \ MiB e 5\ MiB, respectivamente): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Uma mistura de arquivos compactados e descompactados pode ser descompactada +para a saída padrão com um único comando: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Compactação paralela de muitos arquivos" +No GNU e *BSD, \fBfind\fP(1) e \fBxargs\fP(1) podem ser usados para paralelizar a +compactação de muitos arquivos: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +A opção \fB\-P\fP para \fBxargs\fP(1) define o número de processos paralelos do +\fBxz\fP. O melhor valor para a opção \fB\-n\fP depende de quantos arquivos devem +ser compactados. Se houver apenas alguns arquivos, o valor provavelmente +deve ser 1; com dezenas de milhares de arquivos, 100 ou até mais podem ser +apropriados para reduzir o número de processos de \fBxz\fP que \fBxargs\fP(1) +eventualmente criará. +.PP +A opção \fB\-T1\fP para \fBxz\fP existe para forçá\-lo ao modo de thread única, +porque \fBxargs\fP(1) é usado para controlar a quantidade de paralelização. +. +.SS "Modo robô" +Calcular quantos bytes foram salvos no total depois de compactar vários +arquivos: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Um script pode querer saber que está usando \fBxz\fP novo o suficiente. O +seguinte script \fBsh\fP(1) verifica se o número da versão da ferramenta \fBxz\fP +é pelo menos 5.0.0. Este método é compatível com versões beta antigas, que +não suportavam a opção \fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Definir um limite de uso de memória para descompactação usando \fBXZ_OPT\fP, +mas se um limite já tiver sido definido, não o aumentar: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Cadeias de filtro de compressor personalizadas" +O uso mais simples para cadeias de filtro personalizadas é personalizar uma +predefinição LZMA2. Isso pode ser útil, porque as predefinições abrangem +apenas um subconjunto das combinações potencialmente úteis de configurações +de compactação. +.PP +As colunas CompCPU das tabelas das descrições das opções \fB\-0\fP ... \fB\-9\fP e +\fB\-\-extreme\fP são úteis ao personalizar as predefinições LZMA2. Aqui estão as +partes relevantes coletadas dessas duas tabelas: +.RS +.PP +.TS +tab(;); +c c +n n. +Predefinição;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Se você sabe que um arquivo requer um dicionário um tanto grande (por +exemplo, 32\ MiB) para compactar bem, mas deseja comprimi\-lo mais +rapidamente do que \fBxz \-8\fP faria, uma predefinição com um valor CompCPU +baixo (por exemplo, 1) pode ser modificado para usar um dicionário maior: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Com certos arquivos, o comando acima pode ser mais rápido que \fBxz \-6\fP +enquanto compacta significativamente melhor. No entanto, deve\-se enfatizar +que apenas alguns arquivos se beneficiam de um grande dicionário, mantendo o +valor CompCPU baixo. A situação mais óbvia, onde um grande dicionário pode +ajudar muito, é um arquivo contendo arquivos muito semelhantes de pelo menos +alguns megabytes cada. O tamanho do dicionário deve ser significativamente +maior do que qualquer arquivo individual para permitir que o LZMA2 aproveite +ao máximo as semelhanças entre arquivos consecutivos. +.PP +Se o uso muito alto de memória do compactador e do descompactador for bom e +o arquivo que está sendo compactado tiver pelo menos várias centenas de +megabytes, pode ser útil usar um dicionário ainda maior do que os 64 MiB que +o \fBxz \-9\fP usaria: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Usar \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) como no exemplo acima pode ser útil +para ver os requisitos de memória do compactador e do +descompactador. Lembre\-se que usar um dicionário maior que o tamanho do +arquivo descompactado é desperdício de memória, então o comando acima não é +útil para arquivos pequenos. +.PP +Às vezes, o tempo de compactação não importa, mas o uso de memória do +descompactador deve ser mantido baixo, por exemplo, para possibilitar a +descompactação do arquivo em um sistema embarcado. O comando a seguir usa +\fB\-6e\fP (\fB\-6 \-\-extreme\fP) como base e define o dicionário como apenas 64\ KiB. O arquivo resultante pode ser descompactado com XZ Embedded (é por isso +que existe \fB\-\-check=crc32\fP) usando cerca de 100\ KiB de memória. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Se você deseja espremer o máximo de bytes possível, ajustar o número de bits +de contexto literal (\fIlc\fP) e o número de bits de posição (\fIpb\fP) às vezes +pode ajudar. Ajustar o número de bits de posição literal (\fIlp\fP) também pode +ajudar, mas geralmente \fIlc\fP e \fIpb\fP são mais importantes. Por exemplo, um +arquivo de código\-fonte contém principalmente texto US\-ASCII, então algo +como o seguinte pode fornecer um arquivo ligeiramente (como 0,1\ %) menor +que \fBxz \-6e\fP (tente também sem \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +O uso de outro filtro junto com o LZMA2 pode melhorar a compactação com +determinados tipos de arquivo. Por exemplo, para compactar uma biblioteca +compartilhada x86\-32 ou x86\-64 usando o filtro x86 BCJ: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Observe que a ordem das opções de filtro é significativa. Se \fB\-\-x86\fP for +especificado após \fB\-\-lzma2\fP, \fBxz\fP dará um erro, porque não pode haver +nenhum filtro após LZMA2 e também porque o filtro x86 BCJ não pode ser usado +como o último filtro em a corrente. +.PP +O filtro Delta junto com LZMA2 pode dar bons resultados com imagens +bitmap. Ele geralmente deve superar o PNG, que possui alguns filtros mais +avançados do que o delta simples, mas usa Deflate para a compactação real. +.PP +A imagem deve ser salva em formato não compactado, por exemplo, como TIFF +não compactado. O parâmetro de distância do filtro Delta é definido para +corresponder ao número de bytes por pixel na imagem. Por exemplo, bitmap RGB +de 24 bits precisa de \fBdist=3\fP, e também é bom passar \fBpb=0\fP para LZMA2 +para acomodar o alinhamento de três bytes: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Se várias imagens foram colocadas em um único arquivo (por exemplo, +\&\fB.tar\fP), o filtro Delta também funcionará, desde que todas as imagens +tenham o mesmo número de bytes por pixel. +. +.SH "VEJA TAMBÉM" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/lzless.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/lzless.1 new file mode 100644 index 0000000000000000000000000000000000000000..a39dabb94a2bcc67dfe99963c489e76222de6af8 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/lzless.1 @@ -0,0 +1,48 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" Brazilian Portuguese translations for xz package +.\" Traduções em português brasileiro para o pacote xz. +.\" Rafael Fontenelle , 2022-2023. +.\" +.\" (Note that this file is not based on gzip's zless.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZLESS 1 2025\-03\-06 Tukaani "XZ Utils" +.SH NOME +xzless, lzless \- visualiza arquivos (texto) compactados em xz ou lzma +.SH SINOPSE +\fBxzless\fP [\fIarquivo\fP...] +.br +\fBlzless\fP [\fIfile\fP...] (DEPRECATED) +.SH DESCRIÇÃO +\fBxzless\fP is a filter that displays text from compressed files to a +terminal. Files supported by \fBxz\fP(1) are decompressed; other files are +assumed to be in uncompressed form already. If no \fIfiles\fP are given, +\fBxzless\fP reads from standard input. +.PP +\fBxzless\fP usa \fBless\fP(1) para apresentar sua saída. Ao contrário de +\fBxzmore\fP, sua escolha de pager não pode ser alterada pela configuração de +uma variável de ambiente. Os comandos são baseados em \fBmore\fP(1) e \fBvi\fP(1) +e permitem movimento e busca para frente e para trás. Consulte o manual +\fBless\fP(1) para obter mais informações. +.PP +The command named \fBlzless\fP is provided for backward compatibility with LZMA +Utils. It is deprecated and will be removed in a future version. +.SH AMBIENTE +.TP +\fBLESSMETACHARS\fP +Uma lista de caracteres especiais para o shell. Definido por \fBxzless\fP a +menos que já esteja definido no ambiente. +.TP +\fBLESSOPEN\fP +Defina como uma linha de comando para invocar o descompactador \fBxz\fP(1) para +pré\-processar os arquivos de entrada para \fBless\fP(1). +.SH "VEJA TAMBÉM" +\fBless\fP(1), \fBxz\fP(1), \fBxzmore\fP(1), \fBzless\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/lzma.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/lzma.1 new file mode 100644 index 0000000000000000000000000000000000000000..0f85fc96ac66488096221e723d837e7d28ff6bc2 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/lzma.1 @@ -0,0 +1,1994 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Brazilian Portuguese translations for xz package +.\" Traduções em português brasileiro para o pacote xz. +.\" Rafael Fontenelle , 2022-2023. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 2025\-03\-08 Tukaani "XZ Utils" +. +.SH NOME +xz, unxz, xzcat, lzma, unlzma, lzcat \- Compacta ou descompacta arquivos .xz +e .lzma +. +.SH SINOPSE +\fBxz\fP [\fIopção...\fP] [\fIarquivo...\fP] +. +.SH "COMANDOS APELIDOS" +\fBunxz\fP é equivalente a \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP é equivalente a \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP é equivalente a \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP é equivalente a \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP é equivalente a \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Ao escrever scripts que precisam descompactar arquivos, é recomendável +sempre usar o nome \fBxz\fP com os argumentos apropriados (\fBxz \-d\fP ou \fBxz \-dc\fP) em vez dos nomes \fBunxz\fP e \fBxzcat\fP. +. +.SH DESCRIÇÃO +\fBxz\fP é uma ferramenta de compactação de dados de uso geral com sintaxe de +linha de comando semelhante ao \fBgzip\fP(1) e ao \fBbzip2\fP(1). O formato de +arquivo nativo é o formato \fB.xz\fP, mas o formato legado \fB.lzma\fP usado por +LZMA Utils e fluxos compactados brutos sem cabeçalhos de formato de +contêiner também são suportados. Além disso, a descompactação do formato +\&\fB.lz\fP usado por \fBlzip\fP é suportada. +.PP +\fBxz\fP compacta ou descompacta cada \fIarquivo\fP de acordo com o modo de +operação selecionado. Se nenhum \fIarquivo\fP for fornecido ou \fIarquivo\fP for +\fB\-\fP, \fBxz\fP lê da entrada padrão e grava os dados processados na saída +padrão. \fBxz\fP recusará (exibirá um erro e ignorará o \fIarquivo\fP) para gravar +dados compactados na saída padrão se for um terminal. Da mesma forma, \fBxz\fP +se recusará a ler dados compactados da entrada padrão se for um terminal. +.PP +A menos que \fB\-\-stdout\fP seja especificado, \fIarquivos\fP diferentes de \fB\-\fP +são gravados em um novo arquivo cujo nome é derivado do nome \fIarquivo\fP de +origem: +.IP \(bu 3 +Ao compactar, o sufixo do formato de arquivo de destino (\fB.xz\fP ou \fB.lzma\fP) +é anexado ao nome do arquivo de origem para obter o nome do arquivo de +destino. +.IP \(bu 3 +Ao descompactar, o sufixo \fB.xz\fP, \fB.lzma\fP ou \fB.lz\fP é removido do nome do +arquivo para obter o nome do arquivo de destino. \fBxz\fP também reconhece os +sufixos \fB.txz\fP e \fB.tlz\fP e os substitui pelo sufixo \fB.tar\fP. +.PP +Se o arquivo de destino já existir, um erro será exibido e \fIarquivo\fP será +ignorado. +.PP +A menos que grave na saída padrão, \fBxz\fP exibirá um aviso e pulará o +\fIarquivo\fP se qualquer um dos seguintes se aplicar: +.IP \(bu 3 +\fIArquivo\fP não é um arquivo normal. Links simbólicos não são seguidos e, +portanto, não são considerados arquivos comuns. +.IP \(bu 3 +\fIArquivo\fP tem mais de um link físico. +.IP \(bu 3 +\fIFile\fP tem setuid, setgid ou sticky bit definido. +.IP \(bu 3 +O modo de operação está definido para compactar e o \fIarquivo\fP já possui um +sufixo do formato de arquivo de destino (\fB.xz\fP ou \fB.txz\fP ao compactar para +o formato \fB.xz\fP e \fB.lzma \fP ou \fB.tlz\fP ao compactar para o formato +\&\fB.lzma\fP). +.IP \(bu 3 +O modo de operação está definido para descompactar e o \fIarquivo\fP não possui +um sufixo de nenhum dos formatos de arquivo suportados (\fB.xz\fP, \fB.txz\fP, +\&\fB.lzma\fP, \fB.tlz\fP , ou \fB.lz\fP). +.PP +Depois de compactar ou descompactar com êxito o \fIarquivo\fP, o \fBxz\fP copia o +dono, grupo, permissões, horário de acesso e horário de modificação do +\fIarquivo\fP de origem para o arquivo de destino. Se a cópia do grupo falhar, +as permissões serão modificadas para que o arquivo de destino não se torne +acessível a usuários que não têm permissão para acessar o \fIarquivo\fP de +origem. \fBxz\fP ainda não oferece suporte à cópia de outros metadados, como +listas de controle de acesso ou atributos estendidos. +.PP +Depois que o arquivo de destino for fechado com êxito, o \fIarquivo\fP de +origem será removido, a menos que \fB\-\-keep\fP tenha sido especificado. O +\fIarquivo\fP de origem nunca é removido se a saída for gravada na saída padrão +ou se ocorrer um erro. +.PP +O envio de \fBSIGINFO\fP ou \fBSIGUSR1\fP para o processo do \fBxz\fP faz com que ele +imprima informações de andamento para erro padrão. Isso tem uso limitado, +pois quando o erro padrão é um terminal, usar \fB\-\-verbose\fP exibirá um +indicador de progresso de atualização automática. +. +.SS "Uso de memória" +O uso de memória de \fBxz\fP varia de algumas centenas de kilobytes a vários +gigabytes, dependendo das configurações de compactação. As configurações +usadas ao compactar um arquivo determinam os requisitos de memória do +descompactador. Normalmente, o descompactador precisa de 5\ % a 20\ % da +quantidade de memória que o compactador precisou ao criar o arquivo. Por +exemplo, descompactar um arquivo criado com \fBxz \-9\fP atualmente requer 65\ MiB de memória. Ainda assim, é possível ter arquivos \fB.xz\fP que requerem +vários gigabytes de memória para descompactar. +.PP +Especialmente os usuários de sistemas mais antigos podem achar irritante a +possibilidade de uso de memória muito grande. Para evitar surpresas +desconfortáveis, o \fBxz\fP possui um limitador de uso de memória embutido, que +está desabilitado por padrão. Embora alguns sistemas operacionais forneçam +maneiras de limitar o uso de memória dos processos, confiar nele não foi +considerado flexível o suficiente (por exemplo, usar \fBulimit\fP(1) para +limitar a memória virtual tende a prejudicar \fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +O limitador de uso de memória pode ser ativado com a opção de linha de +comando \fB\-\-memlimit=\fP\fIlimite\fP. Geralmente é mais conveniente habilitar o +limitador por padrão definindo a variável de ambiente \fBXZ_DEFAULTS\fP, por +exemplo, \fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. É possível definir os limites +separadamente para compactação e descompactação usando +\fB\-\-memlimit\-compress=\fP\fIlimite\fP e \fB\-\-memlimit\-decompress=\fP\fIlimite\fP. Usar +essas duas opções fora de \fBXZ_DEFAULTS\fP raramente é útil porque uma única +execução de \fBxz\fP não pode fazer compactação e descompactação e +\fB\-\-memlimit=\fP\fIlimite\fP (ou \fB\-M\fP \fIlimite\fP ) é mais curto para digitar na +linha de comando. +.PP +Se o limite de uso de memória especificado for excedido durante a +descompactação, \fBxz\fP exibirá um erro e a descompactação do arquivo +falhará. Se o limite for excedido durante a compactação, \fBxz\fP tentará +reduzir as configurações para que o limite não seja mais excedido (exceto ao +usar \fB\-\-format=raw\fP ou \fB\-\-no\-adjust\fP). Dessa forma, a operação não +falhará, a menos que o limite seja muito pequeno. A escala das configurações +é feita em etapas que não correspondem às predefinições do nível de +compactação, por exemplo, se o limite for apenas um pouco menor que o valor +necessário para \fBxz \-9\fP, as configurações serão reduzidas apenas um pouco , +não até \fBxz \-8\fP. +. +.SS "Concatenação e preenchimento com arquivos .xz" +É possível concatenar arquivos \fB.xz\fP como estão. \fBxz\fP irá descompactar +tais arquivos como se fossem um único arquivo \fB.xz\fP. +.PP +É possível inserir preenchimento entre as partes concatenadas ou após a +última parte. O preenchimento deve consistir em bytes nulos e o tamanho do +preenchimento deve ser um múltiplo de quatro bytes. Isso pode ser útil, por +exemplo, se o arquivo \fB.xz\fP for armazenado em uma mídia que mede tamanhos +de arquivo em blocos de 512 bytes. +.PP +Concatenação e preenchimento não são permitidos com arquivos \fB.lzma\fP ou +fluxos brutos. +. +.SH OPÇÕES +. +.SS "Sufixos inteiros e valores especiais" +Na maioria dos lugares onde um argumento inteiro é esperado, um sufixo +opcional é suportado para indicar facilmente números inteiros grandes. Não +deve haver espaço entre o número inteiro e o sufixo. +.TP +\fBKiB\fP +Multiplica o inteiro por 1.024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP e \fBKB\fP são +aceitos como sinônimos de \fBKiB\fP. +.TP +\fBMiB\fP +Multiplica o número inteiro por 1.048.576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP e \fBMB\fP +são aceitos como sinônimos de \fBMiB\fP. +.TP +\fBGiB\fP +Multiplica o número inteiro por 1.073.741.824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP e +\fBGB\fP são aceitos como sinônimos de \fBGiB\fP. +.PP +O valor especial \fBmax\fP pode ser usado para indicar o valor inteiro máximo +suportado pela opção. +. +.SS "Modo de operação" +Se várias opções de modo de operação forem dadas, a última entrará em vigor. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Compacta. Este é o modo de operação padrão quando nenhuma opção de modo de +operação é especificada e nenhum outro modo de operação está implícito no +nome do comando (por exemplo, \fBunxz\fP implica em \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +After successful compression, the source file is removed unless writing to +standard output or \fB\-\-keep\fP was specified. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Decompress. After successful decompression, the source file is removed +unless writing to standard output or \fB\-\-keep\fP was specified. +.TP +\fB\-t\fP, \fB\-\-test\fP +Testa a integridade de \fIarquivos\fP compactados. Esta opção é equivalente a +\fB\-\-decompress \-\-stdout\fP exceto que os dados descompactados são descartados +em vez de serem gravados na saída padrão. Nenhum arquivo é criado ou +removido. +.TP +\fB\-l\fP, \fB\-\-list\fP +Imprime informações sobre \fIarquivos\fP compactados. Nenhuma saída +descompactada é produzida e nenhum arquivo é criado ou removido. No modo de +lista, o programa não pode ler os dados compactados da entrada padrão ou de +outras fontes não pesquisáveis. +.IP "" +A listagem padrão mostra informações básicas sobre \fIarquivos\fP, um arquivo +por linha. Para obter informações mais detalhadas, use também a opção +\fB\-\-verbose\fP. Para obter ainda mais informações, use \fB\-\-verbose\fP duas +vezes, mas observe que isso pode ser lento, porque obter todas as +informações extras requer muitas buscas. A largura da saída detalhada excede +80 caracteres, portanto, canalizar a saída para, por exemplo, \fBless\ \-S\fP +pode ser conveniente se o terminal não tiver largura o suficiente. +.IP "" +A saída exata pode variar entre versões \fBxz\fP e localidades diferentes. Para +saída legível por máquina, \fB\-\-robot \-\-list\fP deve ser usado. +. +.SS "Modificadores de operação" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Não exclui os arquivos de entrada. +.IP "" +Desde \fBxz\fP 5.2.6, esta opção também faz \fBxz\fP compactar ou descompactar +mesmo se a entrada for um link simbólico para um arquivo comum, tiver mais +de um link físico ou tiver o setuid, setgid ou sticky bit definir. Os bits +setuid, setgid e sticky não são copiados para o arquivo de destino. Nas +versões anteriores, isso era feito apenas com \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Esta opção tem vários efeitos: +.RS +.IP \(bu 3 +Se o arquivo de destino já existir, o exclui antes de compactar ou +descompactar. +.IP \(bu 3 +Compacta ou descompacta, mesmo que a entrada seja um link simbólico para um +arquivo normal, tenha mais de um link físico ou tenha setuid, setgid ou +sticky bit definido. Os bits setuid, setgid e sticky não são copiados para o +arquivo de destino. +.IP \(bu 3 +Quando usado com \fB\-\-decompress\fP \fB\-\-stdout\fP e \fBxz\fP não consegue reconhecer +o tipo do arquivo de origem, copia o arquivo de origem como está na saída +padrão. Isso permite que \fBxzcat\fP \fB\-\-force\fP seja usado como \fBcat\fP(1) para +arquivos que não foram compactados com \fBxz\fP. Observe que, no futuro, o +\fBxz\fP pode oferecer suporte a novos formatos de arquivo compactado, o que +pode fazer com que o \fBxz\fP descompacte mais tipos de arquivos em vez de +copiá\-los como na saída padrão. \fB\-\-format=\fP\fIformato\fP pode ser usado para +restringir \fBxz\fP para descompactar apenas um único formato de arquivo. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Grava os dados compactados ou descompactados na saída padrão em vez de em um +arquivo. Isso implica em \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Descompacta apenas o primeiro fluxo de \fB.xz\fP e ignora silenciosamente +possíveis dados de entrada restantes após o fluxo. Normalmente, esse +restante posterior sem uso faz com que \fBxz\fP exiba um erro. +.IP "" +\fBxz\fP nunca descompacta mais de um fluxo de arquivos \fB.lzma\fP ou fluxos +brutos, mas esta opção ainda faz \fBxz\fP ignorar os possíveis dados +posteriores após o arquivo \fB.lzma\fP ou fluxo bruto. +.IP "" +Esta opção não tem efeito se o modo de operação não for \fB\-\-decompress\fP ou +\fB\-\-test\fP. +.IP "" +Since \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP implies \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Desativa a criação de arquivos esparsos. Por padrão, ao descompactar em um +arquivo normal, \fBxz\fP tenta tornar o arquivo esparso se os dados +descompactados contiverem longas sequências de zeros binários. Ele também +funciona ao gravar na saída padrão, desde que a saída padrão esteja +conectada a um arquivo normal e certas condições adicionais sejam atendidas +para torná\-la segura. A criação de arquivos esparsos pode economizar espaço +em disco e acelerar a descompactação, reduzindo a quantidade de E/S do +disco. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Ao compactar, usa \fI.suf\fP como sufixo para o arquivo de destino em vez de +\&\fB.xz\fP ou \fB.lzma\fP. Se não estiver gravando na saída padrão e o arquivo de +origem já tiver o sufixo \fI.suf\fP, um aviso será exibido e o arquivo será +ignorado. +.IP "" +Ao descompactar, reconhece arquivos com o sufixo \fI.suf\fP além de arquivos +com o sufixo \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP ou \fB.lz\fP . Se o arquivo de +origem tiver o sufixo \fI.suf\fP, o sufixo será removido para obter o nome do +arquivo de destino. +.IP "" +Ao compactar ou descompactar fluxos brutos (\fB\-\-format=raw\fP), o sufixo +sempre deve ser especificado, a menos que seja gravado na saída padrão, +porque não há sufixo padrão para fluxos brutos. +.TP +\fB\-\-files\fP[\fB=\fP\fIarquivo\fP] +Lê os nomes dos arquivos a serem processados em \fIarquivo\fP; se \fIarquivo\fP +for omitido, os nomes dos arquivos serão lidos da entrada padrão. Os nomes +de arquivo devem terminar com o caractere de nova linha. Um traço (\fB\-\fP) é +considerado um nome de arquivo regular; não significa entrada padrão. Se os +nomes de arquivo forem fornecidos também como argumentos de linha de +comando, eles serão processados antes da leitura dos nomes de arquivo de +\fIarquivo\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIarquivo\fP] +Isso é idêntico a \fB\-\-files\fP[\fB=\fP\fIarquivo\fP], exceto que cada nome de +arquivo deve ser finalizado com o caractere nulo. +. +.SS "Opções básicas de formato de arquivo e de compactação" +.TP +\fB\-F\fP \fIformato\fP, \fB\-\-format=\fP\fIformato\fP +Especifica o \fIformato\fP de arquivo para compactar ou descompactar: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Este é o padrão. Ao compactar, \fBauto\fP é equivalente a \fBxz\fP. Ao +descompactar, o formato do arquivo de entrada é detectado +automaticamente. Observe que os fluxos brutos (criados com \fB\-\-format=raw\fP) +não podem ser detectados automaticamente. +.TP +\fBxz\fP +Compacta no formato de arquivo \fB.xz\fP ou aceite apenas arquivos \fB.xz\fP ao +descompactar. +.TP +\fBlzma\fP, \fBalone\fP +Compacta no formato de arquivo legado \fB.lzma\fP ou aceite apenas arquivos +\&\fB.lzma\fP ao descompactar. O nome alternativo \fBalone\fP é fornecido para +compatibilidade com versões anteriores do LZMA Utils. +.TP +\fBlzip\fP +Aceita apenas arquivos \fB.lz\fP ao descompactar. Sem suporte a compactação. +.IP "" +The \fB.lz\fP format versions 0 and 1 are supported. Version 0 files were +produced by \fBlzip\fP 1.3 and older. Such files aren't common but may be +found from file archives as a few source packages were released in this +format. People might have old personal files in this format too. +Decompression support for the format version 0 was removed in \fBlzip\fP 1.18. +\fBlzip\fP 1.4 and later create files in the format version 1. +.TP +\fBraw\fP +Compacta ou descompacta um fluxo bruto (sem cabeçalhos). Isso é destinado +apenas a usuários avançados. Para decodificar fluxos brutos, você precisa +usar \fB\-\-format=raw\fP e especificar explicitamente a cadeia de filtros, que +normalmente seria armazenada nos cabeçalhos do contêiner. +.RE +.TP +\fB\-C\fP \fIverificação\fP, \fB\-\-check=\fP\fIverificação\fP +Especifica o tipo de verificação de integridade. A verificação é calculada a +partir dos dados descompactados e armazenados no arquivo \fB.xz\fP. Esta opção +tem efeito somente ao compactar no formato \fB.xz\fP; o formato \fB.lzma\fP não +oferece suporte a verificações de integridade. A verificação de integridade +(se for o caso) é verificada quando o arquivo \fB.xz\fP é descompactado. +.IP "" +Tipos de \fIverificação\fP suportados: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Não calcula uma verificação de integridade. Isso geralmente é uma má +ideia. Pode ser útil quando a integridade dos dados é verificada por outros +meios. +.TP +\fBcrc32\fP +Calcula CRC32 usando o polinômio do IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Calcula CRC64 usando o polinômio de ECMA\-182. Este é o padrão, pois é um +pouco melhor que o CRC32 na detecção de arquivos danificados e a diferença +de velocidade é insignificante. +.TP +\fBsha256\fP +Calcula SHA\-256. Isso é um pouco mais lento do que CRC32 e CRC64. +.RE +.IP "" +A integridade dos cabeçalhos de \fB.xz\fP é sempre verificada com CRC32. Não é +possível alterá\-la ou desativá\-la. +.TP +\fB\-\-ignore\-check\fP +Não confere a verificação de integridade dos dados compactados ao +descompactar. Os valores CRC32 nos cabeçalhos \fB.xz\fP ainda serão conferidos +normalmente. +.IP "" +\fBNão use esta opção a menos que saiba o que está fazendo.\fP Possíveis razões +para usar esta opção: +.RS +.IP \(bu 3 +Tentativa de recuperar dados de um arquivo .xz corrompido. +.IP \(bu 3 +Acelerar a descompactação. Isso é importante principalmente com SHA\-256 ou +com arquivos extremamente bem compactados. É recomendável não usar essa +opção para essa finalidade, a menos que a integridade do arquivo seja +verificada externamente de alguma outra forma. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Seleciona um nível de predefinição de compactação. O padrão é \fB\-6\fP. Se +vários níveis de predefinição forem especificados, o último terá efeito. Se +uma cadeia de filtro personalizada já foi especificada, especificar um nível +de predefinição de compactação limpa a cadeia de filtro personalizada. +.IP "" +As diferenças entre as predefinições são mais significativas do que com +\fBgzip\fP(1) e \fBbzip2\fP(1). As configurações de compactação selecionadas +determinam os requisitos de memória do descompactador, portanto, usar um +nível de predefinição muito alto pode dificultar a descompactação do arquivo +em um sistema antigo com pouca RAM. Especificamente, \fBnão é uma boa ideia usar cegamente \-9 para tudo\fP como costuma acontecer com \fBgzip\fP(1) e +\fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Estas são predefinições um tanto rápidas. \fB\-0\fP às vezes é mais rápida que +\fBgzip \-9\fP ao mesmo tempo que compacta muito melhor. As mais altas +geralmente têm velocidade comparável ao \fBbzip2\fP(1) com taxa de compactação +comparável ou melhor, embora os resultados dependam muito do tipo de dados +que estão sendo compactados. +.TP +\fB\-4\fP ... \fB\-6\fP +Compactação boa a muito boa, mantendo o uso de memória do descompactador +razoável mesmo para sistemas antigos. \fB\-6\fP é o padrão, que geralmente é uma +boa escolha para distribuir arquivos que precisam ser descompactáveis, mesmo +em sistemas com apenas 16\ MiB de RAM. (\fB\-5e\fP ou \fB\-6e\fP também vale a pena +considerar. Veja \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Eles são como \fB\-6\fP, mas com requisitos de memória de compressor e +descompressor mais altos. Eles são úteis apenas ao compactar arquivos +maiores que 8\ MiB, 16\ MiB e 32\ MiB, respectivamente. +.RE +.IP "" +No mesmo hardware, a velocidade de descompactação é aproximadamente um +número constante de bytes de dados compactados por segundo. Em outras +palavras, quanto melhor a compactação, mais rápida será a +descompactação. Isso também significa que a quantidade de saída não +compactada produzida por segundo pode variar muito. +.IP "" +A tabela a seguir resume os recursos das predefinições: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Predefinição;DicTam;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Descrições das colunas: +.RS +.IP \(bu 3 +DicTam é o tamanho do dicionário LZMA2. É desperdício de memória usar um +dicionário maior que o tamanho do arquivo descompactado. É por isso que é +bom evitar usar as predefinições \fB\-7\fP ... \fB\-9\fP quando não há real +necessidade deles. Em \fB\-6\fP e inferior, a quantidade de memória desperdiçada +geralmente é baixa o suficiente para não importar. +.IP \(bu 3 +CompCPU é uma representação simplificada das configurações LZMA2 que afetam +a velocidade de compactação. O tamanho do dicionário também afeta a +velocidade, portanto, embora o CompCPU seja o mesmo para os níveis \fB\-6\fP +\&... \fB\-9\fP, níveis mais altos ainda tendem a ser um pouco mais lentos. Para +obter uma compactação ainda mais lenta e possivelmente melhor, consulte +\fB\-\-extreme\fP. +.IP \(bu 3 +CompMem contains the compressor memory requirements in the single\-threaded +mode. It may vary slightly between \fBxz\fP versions. +.IP \(bu 3 +DecMem contém os requisitos de memória do descompactador. Ou seja, as +configurações de compactação determinam os requisitos de memória do +descompactador. O uso exato da memória do descompactador é um pouco maior do +que o tamanho do dicionário LZMA2, mas os valores na tabela foram +arredondados para o próximo MiB completo. +.RE +.IP "" +Memory requirements of the multi\-threaded mode are significantly higher than +that of the single\-threaded mode. With the default value of +\fB\-\-block\-size\fP, each thread needs 3*3*DictSize plus CompMem or DecMem. For +example, four threads with preset \fB\-6\fP needs 660\(en670\ MiB of memory. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Usa uma variante mais lenta do nível de predefinição de compactação +selecionado (\fB\-0\fP ... \fB\-9\fP) para obter uma taxa de compactação um pouco +melhor, mas, com azar, isso também pode piorar. O uso da memória do +descompressor não é afetado, mas o uso da memória do compactador aumenta um +pouco nos níveis de predefinição \fB\-0\fP ... \fB\-3\fP. +.IP "" +Como existem duas predefinições com tamanhos de dicionário 4\ MiB e 8\ MiB, +as predefinições \fB\-3e\fP e \fB\-5e\fP usam configurações um pouco mais rápidas +(CompCPU inferior) do que \fB\-4e\fP e \fB\-6e\fP, respectivamente. Dessa forma, não +há duas predefinições idênticas. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Predefinição;DicTam;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Por exemplo, há um total de quatro predefinições que usam o dicionário 8\ MiB, cuja ordem do mais rápido ao mais lento é \fB\-5\fP, \fB\-6\fP, \fB\-5e\fP e +\fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Esses são apelidos um tanto enganosos para \fB\-0\fP e \fB\-9\fP, +respectivamente. Eles são fornecidos apenas para compatibilidade com versões +anteriores do LZMA Utils. Evite usar essas opções. +.TP +\fB\-\-block\-size=\fP\fItamanho\fP +Ao compactar para o formato \fB.xz\fP, divida os dados de entrada em blocos de +\fItamanho\fP bytes. Os blocos são compactados independentemente uns dos +outros, o que ajuda no multi\-threading e torna possível a descompactação +limitada de acesso aleatório. Essa opção normalmente é usada para substituir +o tamanho de bloco padrão no modo multi\-thread, mas também pode ser usada em +thread única. +.IP "" +In multi\-threaded mode about three times \fIsize\fP bytes will be allocated in +each thread for buffering input and output. The default \fIsize\fP is three +times the LZMA2 dictionary size or 1 MiB, whichever is more. Typically a +good value is 2\(en4 times the size of the LZMA2 dictionary or at least 1 +MiB. Using \fIsize\fP less than the LZMA2 dictionary size is waste of RAM +because then the LZMA2 dictionary buffer will never get fully used. In +multi\-threaded mode, the sizes of the blocks are stored in the block +headers. This size information is required for multi\-threaded +decompression. +.IP "" +In single\-threaded mode no block splitting is done by default. Setting this +option doesn't affect memory usage. No size information is stored in block +headers, thus files created in single\-threaded mode won't be identical to +files created in multi\-threaded mode. The lack of size information also +means that \fBxz\fP won't be able decompress the files in multi\-threaded mode. +.TP +\fB\-\-block\-list=\fP\fIitems\fP +When compressing to the \fB.xz\fP format, start a new block with an optional +custom filter chain after the given intervals of uncompressed data. +.IP "" +The \fIitems\fP are a comma\-separated list. Each item consists of an optional +filter chain number between 0 and 9 followed by a colon (\fB:\fP) and a +required size of uncompressed data. Omitting an item (two or more +consecutive commas) is a shorthand to use the size and filters of the +previous item. +.IP "" +If the input file is bigger than the sum of the sizes in \fIitems\fP, the last +item is repeated until the end of the file. A special value of \fB0\fP may be +used as the last size to indicate that the rest of the file should be +encoded as a single block. +.IP "" +An alternative filter chain for each block can be specified in combination +with the \fB\-\-filters1=\fP\fIfilters\fP \&...\& \fB\-\-filters9=\fP\fIfilters\fP options. +These options define filter chains with an identifier between 1\(en9. +Filter chain 0 can be used to refer to the default filter chain, which is +the same as not specifying a filter chain. The filter chain identifier can +be used before the uncompressed size, followed by a colon (\fB:\fP). For +example, if one specifies \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP +then blocks will be created using: +.RS +.IP \(bu 3 +The filter chain specified by \fB\-\-filters1\fP and 2 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters3\fP and 2 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters2\fP and 4 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters2\fP and 4 MiB input +.IP \(bu 3 +The default filter chain and 2 MiB input +.IP \(bu 3 +The default filter chain and 4 MiB input for every block until end of input. +.RE +.IP "" +If one specifies a size that exceeds the encoder's block size (either the +default value in threaded mode or the value specified with +\fB\-\-block\-size=\fP\fIsize\fP), the encoder will create additional blocks while +keeping the boundaries specified in \fIitems\fP. For example, if one specifies +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP and the +input file is 80 MiB, one will get 11 blocks: 5, 10, 8, 10, 2, 10, 10, 4, +10, 10, and 1 MiB. +.IP "" +No modo multi\-thread, os tamanhos dos blocos são armazenados nos cabeçalhos +dos blocos. Isso não é feito no modo de thread única, portanto, a saída +codificada não será idêntica à do modo multi\-thread. +.TP +\fB\-\-flush\-timeout=\fP\fItempo_limite\fP +Ao compactar, se mais de \fItempo_limite\fP milissegundos (um número inteiro +positivo) se passaram desde a liberação anterior e a leitura de mais entrada +seria bloqueada, todos os dados de entrada pendentes serão liberados do +codificador e disponibilizados no fluxo de saída. Isso pode ser útil se +\fBxz\fP for usado para compactar dados transmitidos por uma rede. Valores +\fItempo_limite\fP pequenos tornam os dados disponíveis na extremidade +receptora com um pequeno atraso, mas valores \fItempo_limite\fP grandes +oferecem melhor taxa de compactação. +.IP "" +Esse recurso está desabilitado por padrão. Se esta opção for especificada +mais de uma vez, a última terá efeito. O valor especial \fItempo_limite\fP de +\fB0\fP pode ser usado para desabilitar explicitamente esse recurso. +.IP "" +Este recurso não está disponível em sistemas não\-POSIX. +.IP "" +.\" FIXME +\fBEste recurso ainda é experimental.\fP Atualmente, \fBxz\fP não é adequado para +descompactar o fluxo em tempo real devido à forma como \fBxz\fP faz o buffer. +.TP +\fB\-\-no\-sync\fP +Do not synchronize the target file and its directory to the storage device +before removing the source file. This can improve performance if +compressing or decompressing many small files. However, if the system +crashes soon after the deletion, it is possible that the target file was not +written to the storage device but the delete operation was. In that case +neither the original source file nor the target file is available. +.IP "" +This option has an effect only when \fBxz\fP is going to remove the source +file. In other cases synchronization is never done. +.IP "" +The synchronization and \fB\-\-no\-sync\fP were added in \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIlimite\fP +Define um limite de uso de memória para compactação. Se esta opção for +especificada várias vezes, a última entrará em vigor. +.IP "" +Se as configurações de compactação excederem o \fIlimite\fP, \fBxz\fP tentará +ajustar as configurações para baixo para que o limite não seja mais excedido +e exibirá um aviso de que o ajuste automático foi feito. Os ajustes são +feitos nesta ordem: reduzindo o número de encadeamentos, alternando para o +modo sigle\-thread se até mesmo uma thread no modo multi\-thread exceder o +\fIlimite\fP e, finalmente, reduzindo o tamanho do dicionário LZMA2. +.IP "" +Ao compactar com \fB\-\-format=raw\fP ou se \fB\-\-no\-adjust\fP tiver sido +especificado, apenas o número de threads pode ser reduzido, pois isso pode +ser feito sem afetar a saída compactada. +.IP "" +Se o \fIlimite\fP não puder ser alcançado mesmo com os ajustes descritos acima, +um erro será exibido e \fBxz\fP sairá com status de saída 1. +.IP "" +O \fIlimite\fP pode ser especificado de várias maneiras: +.RS +.IP \(bu 3 +O \fIlimite\fP pode ser um valor absoluto em bytes. Usar um sufixo inteiro como +\fBMiB\fP pode ser útil. Exemplo: \fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +O \fIlimite\fP pode ser especificado como uma porcentagem da memória física +total (RAM). Isso pode ser útil especialmente ao definir a variável de +ambiente \fBXZ_DEFAULTS\fP em um script de inicialização de shell que é +compartilhado entre diferentes computadores. Dessa forma o limite é +automaticamente maior em sistemas com mais memória. Exemplo: +\fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +O \fIlimite\fP pode ser redefinido para seu valor padrão, definindo\-o como +\fB0\fP. Atualmente, isso equivale a definir \fIlimite\fP como \fBmax\fP (sem limite +de uso de memória). +.RE +.IP "" +Para \fBxz\fP de 32 bits, há um caso especial: se o \fIlimite\fP estiver acima de +\fB4020\ MiB\fP, o \fIlimite\fP é definido como \fB4020\ MiB\fP. No MIPS32 \fB2000\ MiB\fP é usado em seu lugar. (Os valores \fB0\fP e \fBmax\fP não são afetados por +isso. Um recurso semelhante não existe para descompactação.) Isso pode ser +útil quando um executável de 32 bits tem acesso a espaço de endereço de 4\ GiB (2 GiB no MIPS32) enquanto espero não causar danos em outras situações. +.IP "" +Consulte também a seção \fBUso de memória\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIlimite\fP +Define um limite de uso de memória para descompactação. Isso também afeta o +modo \fB\-\-list\fP. Se a operação não for possível sem exceder o \fIlimite\fP, +\fBxz\fP exibirá um erro e a descompactação do arquivo falhará. Consulte +\fB\-\-memlimit\-compress=\fP\fIlimite\fP para possíveis maneiras de especificar o +\fIlimite\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimite\fP +Define um limite de uso de memória para descompactação multi\-thread. Isso +pode afetar apenas o número de threads; isso nunca fará com que \fBxz\fP se +recuse a descompactar um arquivo. Se \fIlimite\fP for muito baixo para permitir +qualquer multi\-thread, o \fIlimite\fP será ignorado e \fBxz\fP continuará no modo +de thread única. Observe que se \fB\-\-memlimit\-decompress\fP também for usado, +ele sempre se aplicará aos modos de thread única e multi\-thread e, portanto, +o \fIlimite\fP efetivo para multi\-threading nunca será maior que o limite +definido com \fB\-\-memlimit\-decompress\fP. +.IP "" +Em contraste com as outras opções de limite de uso de memória, +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimite\fP tem um padrão \fIlimite\fP específico do +sistema. \fBxz \-\-info\-memory\fP pode ser usado para ver o valor atual. +.IP "" +Esta opção e seu valor padrão existem porque, sem qualquer limite, o +descompactador usando threads pode acabar alocando uma quantidade insana de +memória com alguns arquivos de entrada. Se o \fIlimite\fP padrão for muito +baixo em seu sistema, sinta\-se à vontade para aumentar o \fIlimite\fP, mas +nunca defina\-o para um valor maior que a quantidade de RAM utilizável, pois +com os arquivos de entrada apropriados \fBxz\fP tentará usar essa quantidade de +memória mesmo com um baixo número de threads. Ficar sem memória ou trocar +não melhorará o desempenho da descompactação. +.IP "" +Consulte \fB\-\-memlimit\-compress=\fP\fIlimite\fP para possíveis maneiras de +especificar o \fIlimite\fP. Definir \fIlimite\fP como \fB0\fP redefine \fIlimite\fP para +o valor padrão específico do sistema. +.TP +\fB\-M\fP \fIlimite\fP, \fB\-\-memlimit=\fP\fIlimite\fP, \fB\-\-memory=\fP\fIlimite\fP +Isso é equivalente a especificar \fB\-\-memlimit\-compress=\fP\fIlimite\fP +\fB\-\-memlimit\-decompress=\fP\fIlimite\fP \fB\-\-memlimit\-mt\-decompress=\fP\fIlimite\fP. +.TP +\fB\-\-no\-adjust\fP +Exibe um erro e saia se o limite de uso de memória não puder ser atendido +sem ajustar as configurações que afetam a saída compactada. Ou seja, isso +evita que \fBxz\fP alterne o codificador do modo multi\-thread para o modo +encadeado único e reduza o tamanho do dicionário LZMA2. Mesmo quando esta +opção é usada, o número de threads pode ser reduzido para atender ao limite +de uso de memória, pois isso não afetará a saída compactada. +.IP "" +O ajuste automático é sempre desativado ao criar fluxos brutos +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fIthreads\fP, \fB\-\-threads=\fP\fIthreads\fP +Especifica o número de threads de trabalho a serem usados. Definir +\fIthreads\fP para um valor especial \fB0\fP faz com que \fBxz\fP use tantos threads +quanto o(s) processador(es) no suporte do sistema. O número real de +encadeamentos pode ser menor que \fIthreads\fP se o arquivo de entrada não for +grande o suficiente para subdividir em threads com as configurações +fornecidas ou se o uso de mais threads exceder o limite de uso de memória. +.IP "" +Os compactadores usando thread única e várias threads produzem saídas +diferentes. O compactador de thread única fornecerá o menor tamanho de +arquivo, mas apenas a saída do compactador de várias threads pode ser +descompactada usando várias threads. Definir \fIthreads\fP como \fB1\fP usará o +modo de thread única. Definir \fIthreads\fP para qualquer outro valor, +incluindo \fB0\fP, usará o compressor de várias threads, mesmo que o sistema +tenha suporte a apenas uma thread de hardware. (\fBxz\fP 5.2.x usou o modo de +thread única nesta situação.) +.IP "" +Para usar o modo de várias threads com apenas uma thread, defina \fIthreads\fP +como \fB+1\fP. O prefixo \fB+\fP não tem efeito com valores diferentes de \fB1\fP. Um +limite de uso de memória ainda pode fazer \fBxz\fP alternar para o modo de +thread única, a menos que \fB\-\-no\-adjust\fP seja usado. O suporte para o +prefixo \fB+\fP foi adicionado no \fBxz\fP 5.4.0. +.IP "" +Se um número automático de threads foi solicitado e nenhum limite de uso de +memória foi especificado, um limite flexível padrão específico do sistema +será usado para possivelmente limitar o número de threads. É um limite +flexível no sentido de que é ignorado se o número de threads se tornar um, +portanto, um limite flexível nunca impedirá \fBxz\fP de compactar ou +descompactar. Este limite flexível padrão não fará com que \fBxz\fP alterne do +modo de várias threads para o modo de thread única. Os limites ativos podem +ser vistos com \fBxz \-\-info\-memory\fP. +.IP "" +Atualmente, o único método de threading é dividir a entrada em blocos e +comprimi\-los independentemente um do outro. O tamanho padrão do bloco +depende do nível de compactação e pode ser substituído com a opção +\fB\-\-block\-size=\fP\fItamanho\fP. +.IP "" +A descompactação em threads funciona apenas em arquivos que contêm vários +blocos com informações de tamanho nos cabeçalhos dos blocos. Todos os +arquivos grandes o suficiente compactados no modo de várias thread atendem a +essa condição, mas os arquivos compactados no modo de thread única não +atendem, mesmo se \fB\-\-block\-size=\fP\fItamanho\fP tiver sido usado. +.IP "" +The default value for \fIthreads\fP is \fB0\fP. In \fBxz\fP 5.4.x and older the +default is \fB1\fP. +. +.SS "Cadeias de filtro de compressor personalizadas" +Uma cadeia de filtro personalizada permite especificar as configurações de +compactação em detalhes, em vez de confiar nas configurações associadas às +predefinições. Quando uma cadeia de filtro personalizada é especificada, as +opções predefinidas (\fB\-0\fP \&...\& \fB\-9\fP e \fB\-\-extreme\fP) anteriores na linha +de comando são esquecidas. Se uma opção predefinida for especificada após +uma ou mais opções de cadeia de filtros personalizados, a nova predefinição +entrará em vigor e as opções de cadeia de filtros personalizados +especificadas anteriormente serão esquecidas. +.PP +Uma cadeia de filtro é comparável à tubulação na linha de comando. Ao +compactar, a entrada descompactada vai para o primeiro filtro, cuja saída +vai para o próximo filtro (se houver). A saída do último filtro é gravada no +arquivo compactado. O número máximo de filtros na cadeia é quatro, mas +normalmente uma cadeia de filtros tem apenas um ou dois filtros. +.PP +Muitos filtros têm limitações sobre onde podem estar na cadeia de filtros: +alguns filtros podem funcionar apenas como o último filtro na cadeia, alguns +apenas como filtro não\-último e alguns funcionam em qualquer posição na +cadeia. Dependendo do filtro, essa limitação é inerente ao projeto do filtro +ou existe para evitar problemas de segurança. +.PP +A custom filter chain can be specified in two different ways. The options +\fB\-\-filters=\fP\fIfilters\fP and \fB\-\-filters1=\fP\fIfilters\fP \&...\& +\fB\-\-filters9=\fP\fIfilters\fP allow specifying an entire filter chain in one +option using the liblzma filter string syntax. Alternatively, a filter +chain can be specified by using one or more individual filter options in the +order they are wanted in the filter chain. That is, the order of the +individual filter options is significant! When decoding raw streams +(\fB\-\-format=raw\fP), the filter chain must be specified in the same order as +it was specified when compressing. Any individual filter or preset options +specified before the full chain option (\fB\-\-filters=\fP\fIfilters\fP) will be +forgotten. Individual filters specified after the full chain option will +reset the filter chain. +.PP +Both the full and individual filter options take filter\-specific \fIoptions\fP +as a comma\-separated list. Extra commas in \fIoptions\fP are ignored. Every +option has a default value, so specify those you want to change. +.PP +Para ver toda a cadeia de filtros e \fIopções\fP, use \fBxz \-vv\fP (isto é, use +\fB\-\-verbose\fP duas vezes). Isso também funciona para visualizar as opções da +cadeia de filtros usadas pelas predefinições. +.TP +\fB\-\-filters=\fP\fIfilters\fP +Specify the full filter chain or a preset in a single option. Each filter +can be separated by spaces or two dashes (\fB\-\-\fP). \fIfilters\fP may need to be +quoted on the shell command line so it is parsed as a single option. To +denote \fIoptions\fP, use \fB:\fP or \fB=\fP. A preset can be prefixed with a \fB\-\fP +and followed with zero or more flags. The only supported flag is \fBe\fP to +apply the same options as \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIfilters\fP ... \fB\-\-filters9\fP=\fIfilters\fP +Specify up to nine additional filter chains that can be used with +\fB\-\-block\-list\fP. +.IP "" +For example, when compressing an archive with executable files followed by +text files, the executable part could use a filter chain with a BCJ filter +and the text part only the LZMA2 filter. +.TP +\fB\-\-filters\-help\fP +Display a help message describing how to specify presets and custom filter +chains in the \fB\-\-filters\fP and \fB\-\-filters1=\fP\fIfilters\fP \&...\& +\fB\-\-filters9=\fP\fIfilters\fP options, and exit successfully. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIopções\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIopções\fP] +.PD +Adiciona o filtro LZMA1 ou LZMA2 à cadeia de filtros. Esses filtros podem +ser usados apenas como o último filtro na cadeia. +.IP "" +LZMA1 é um filtro legado, que é suportado quase exclusivamente devido ao +formato de arquivo legado \fB.lzma\fP, que suporta apenas LZMA1. LZMA2 é uma +versão atualizada do LZMA1 para corrigir alguns problemas práticos do +LZMA1. O formato \fB.xz\fP usa LZMA2 e não suporta LZMA1. A velocidade de +compactação e as proporções de LZMA1 e LZMA2 são praticamente as mesmas. +.IP "" +LZMA1 e LZMA2 compartilham o mesmo conjunto de \fIopções\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIpredefinição\fP +Redefine todas as \fIopções\fP de LZMA1 ou LZMA2 para +\fIpredefinição\fP. \fIPredefinição\fP consiste em um número inteiro, que pode ser +seguido por modificadores de predefinição de uma única letra. O inteiro pode +ser de \fB0\fP a \fB9\fP, correspondendo às opções de linha de comando \fB\-0\fP +\&...\& \fB\-9\fP. O único modificador suportado atualmente é \fBe\fP, que +corresponde a \fB\-\-extreme\fP. Se nenhum \fBpreset\fP for especificado, os valores +padrão das \fIopções\fP LZMA1 ou LZMA2 serão obtidos da predefinição \fB6\fP. +.TP +\fBdict=\fP\fItamanho\fP +O \fItamanho\fP do dicionário (buffer de histórico) indica quantos bytes dos +dados não compactados processados recentemente são mantidos na memória. O +algoritmo tenta encontrar sequências de bytes repetidos (correspondências) +nos dados não compactados e substituí\-los por referências aos dados +atualmente no dicionário. Quanto maior o dicionário, maior a chance de +encontrar uma correspondência. Portanto, aumentar o dicionário \fItamanho\fP +geralmente melhora a taxa de compactação, mas um dicionário maior que o +arquivo não compactado é um desperdício de memória. +.IP "" +Um \fItamanho\fP de dicionário típico é de 64\ KiB a 64\ MiB. O mínimo é 4\ KiB. O máximo para compactação é atualmente 1,5\ GiB (1536\ MiB). O +descompactador já oferece suporte a dicionários de até um byte a menos de 4\ GiB, que é o máximo para os formatos de fluxo LZMA1 e LZMA2. +.IP "" +O \fItamanho\fP de dicionário e o localizador de correspondência (\fImf\fP) juntos +determinam o uso de memória do codificador LZMA1 ou LZMA2. O mesmo (ou +maior) \fItamanho\fP de dicionário é necessário para descompactar que foi usado +durante a compactação, portanto, o uso de memória do decodificador é +determinado pelo tamanho do dicionário usado durante a compactação. Os +cabeçalhos \fB.xz\fP armazenam o \fItamanho\fP de dicionário como 2^\fIn\fP ou 2^\fIn\fP ++ 2^(\fIn\fP\-1), então esses \fItamanhos\fP são um tanto preferidos para +compactação. Outros \fItamanhos\fP serão arredondados quando armazenados nos +cabeçalhos \fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Especifica o número de bits de contexto literais. O mínimo é 0 e o máximo é +4; o padrão é 3. Além disso, a soma de \fIlc\fP e \fIlp\fP não deve exceder 4. +.IP "" +Todos os bytes que não podem ser codificados como correspondências são +codificados como literais. Ou seja, literais são simplesmente bytes de 8 +bits que são codificados um de cada vez. +.IP "" +A codificação literal assume que os bits \fIlc\fP mais altos do byte não +compactado anterior se correlacionam com o próximo byte. Por exemplo, em um +texto típico em inglês, uma letra maiúscula geralmente é seguida por uma +letra minúscula, e uma letra minúscula geralmente é seguida por outra letra +minúscula. No conjunto de caracteres US\-ASCII, os três bits mais altos são +010 para letras maiúsculas e 011 para letras minúsculas. Quando \fIlc\fP é pelo +menos 3, a codificação literal pode aproveitar essa propriedade nos dados +não compactados. +.IP "" +O valor padrão (3) geralmente é bom. Se você deseja compactação máxima, +experimente \fBlc=4\fP. Às vezes ajuda um pouco, às vezes piora a +compactação. Se piorar, experimente \fBlc=2\fP também. +.TP +\fBlp=\fP\fIlp\fP +Especifica o número de bits de posição literal. O mínimo é 0 e o máximo é 4; +o padrão é 0. +.IP "" +\fILp\fP afeta que tipo de alinhamento nos dados não compactados é assumido ao +codificar literais. Consulte \fIpb\fP abaixo para obter mais informações sobre +alinhamento. +.TP +\fBpb=\fP\fIpb\fP +Especifica o número de bits de posição. O mínimo é 0 e o máximo é 4; o +padrão é 2. +.IP "" +\fIPb\fP afeta que tipo de alinhamento nos dados não compactados é assumido em +geral. O padrão significa alinhamento de quatro bytes (2^\fIpb\fP=2^2=4), que +geralmente é uma boa escolha quando não há melhor estimativa. +.IP "" +Quando o alinhamento é conhecido, definir \fIpb\fP adequadamente pode reduzir +um pouco o tamanho do arquivo. Por exemplo, com arquivos de texto com +alinhamento de um byte (US\-ASCII, ISO\-8859\-*, UTF\-8), a configuração \fBpb=0\fP +pode melhorar um pouco a compactação. Para texto UTF\-16, \fBpb=1\fP é uma boa +escolha. Se o alinhamento for um número ímpar como 3 bytes, \fBpb=0\fP pode ser +a melhor escolha. +.IP "" +Embora o alinhamento assumido possa ser ajustado com \fIpb\fP e \fIlp\fP, LZMA1 e +LZMA2 ainda favorecem ligeiramente o alinhamento de 16 bytes. Pode valer a +pena levar em consideração ao projetar formatos de arquivo que provavelmente +serão compactados com LZMA1 ou LZMA2. +.TP +\fBmf=\fP\fImf\fP +O localizador de correspondência tem um efeito importante na velocidade do +codificador, uso de memória e taxa de compactação. Normalmente, os +localizadores de correspondência de Hash Chain são mais rápidos do que os +localizadores de correspondência de árvore binária. O padrão depende do +\fIpredefinição\fP: 0 usa \fBhc3\fP, 1\(en3 usa \fBhc4\fP e o resto usa \fBbt4\fP. +.IP "" +Os seguintes localizadores de correspondência são suportados. As fórmulas de +uso de memória abaixo são aproximações aproximadas, que estão mais próximas +da realidade quando \fIdict\fP é uma potência de dois. +.RS +.TP +\fBhc3\fP +Cadeia de hashs com hashing de 2 e 3 bytes +.br +Valor mínimo para \fInice\fP: 3 +.br +Uso de memória: +.br +\fIdict\fP * 7.5 (if \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 5.5 + 64 MiB (if \fIdict\fP > 16 MiB) +.TP +\fBhc4\fP +Cadeia de hashs com hashing de 2, 3 e 4 bytes +.br +Valor mínimo para \fInice\fP: 4 +.br +Uso de memória: +.br +\fIdict\fP * 7.5 (if \fIdict\fP <= 32 MiB); +.br +\fIdict\fP * 6.5 (if \fIdict\fP > 32 MiB) +.TP +\fBbt2\fP +Árvore binária com hashing de 2 bytes +.br +Valor mínimo para \fInice\fP: 2 +.br +Uso de memória: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Árvore binária com hashing de 2 e 3 bytes +.br +Valor mínimo para \fInice\fP: 3 +.br +Uso de memória: +.br +\fIdict\fP * 11.5 (if \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 9.5 + 64 MiB (if \fIdict\fP > 16 MiB) +.TP +\fBbt4\fP +Árvore binária com hashing de 2, 3 e 4 bytes +.br +Valor mínimo para \fInice\fP: 4 +.br +Uso de memória: +.br +\fIdict\fP * 11.5 (if \fIdict\fP <= 32 MiB); +.br +\fIdict\fP * 10.5 (if \fIdict\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fImodo\fP +O \fImodo\fP de compactação especifica o método para analisar os dados +produzidos pelo localizador de correspondência. Os \fImodos\fP suportados são +\fBfast\fP e \fBnormal\fP. O padrão é \fBfast\fP para \fIpredefinições\fP 0\(en3 e +\fBnormal\fP para \fIpredefinições\fP 4\(en9. +.IP "" +Normalmente, \fBfast\fP é usado com localizadores de correspondência cadeia de +hashs e \fBnormal\fP com localizadores de correspondência de árvore +binária. Isso também é o que os \fIpredefinições\fP fazem. +.TP +\fBnice=\fP\fInice\fP +Especifica o que é considerado um bom comprimento para uma +correspondência. Uma vez que uma correspondência de pelo menos \fInice\fP bytes +é encontrada, o algoritmo para de procurar correspondências possivelmente +melhores. +.IP "" +\fINice\fP pode ser 2\(en273 bytes. Valores mais altos tendem a fornecer melhor +taxa de compactação em detrimento da velocidade. O padrão depende do +\fIpredefinição\fP. +.TP +\fBdepth=\fP\fIprofundidade\fP +Especifica a profundidade máxima de pesquisa no localizador de +correspondências. O padrão é o valor especial de 0, que faz com que o +compressor determine um \fIprofundidade\fP razoável de \fImf\fP e \fInice\fP. +.IP "" +Uma \fIprofundidade\fP razoável para cadeias de hash é 4\(en100 e 16\(en1000 +para árvores binárias. Usar valores muito altos para \fIprofundidade\fP pode +tornar o codificador extremamente lento com alguns arquivos. Evite definir +\fIprofundidade\fP acima de 1000 a menos que você esteja preparado para +interromper a compactação caso ela esteja demorando muito. +.RE +.IP "" +Ao decodificar fluxos brutos (\fB\-\-format=raw\fP), o LZMA2 precisa apenas do +dicionário \fItamanho\fP. LZMA1 também precisa de \fIlc\fP, \fIlp\fP e \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIopções\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIopções\fP] +.PD +Adiciona um filtro de ramificação/chamada/salto (BCJ) à cadeia de +filtros. Esses filtros podem ser usados apenas como um filtro não último na +cadeia de filtros. +.IP "" +Um filtro BCJ converte endereços relativos no código de máquina em suas +contrapartes absolutas. Isso não altera o tamanho dos dados, mas aumenta a +redundância, o que pode ajudar o LZMA2 a produzir um arquivo \fB.xz\fP 0\(en15\ % menor. Os filtros BCJ são sempre reversíveis, portanto, usar um filtro BCJ +para o tipo errado de dados não causa nenhuma perda de dados, embora possa +piorar um pouco a taxa de compactação.Os filtros BCJ são muito rápidos e +usam uma quantidade insignificante de memória. +.IP "" +Esses filtros BCJ têm problemas conhecidos relacionados à taxa de +compactação: +.RS +.IP \(bu 3 +Alguns tipos de arquivos contendo código executável (por exemplo, arquivos +de objeto, bibliotecas estáticas e módulos do kernel do Linux) têm os +endereços nas instruções preenchidos com valores de preenchimento. Esses +filtros BCJ ainda vão fazer a conversão de endereço, o que vai piorar a +compactação desses arquivos. +.IP \(bu 3 +Se um filtro BCJ for aplicado em um arquivo, é possível que isso torne a +taxa de compactação pior do que não usar um filtro BCJ. Por exemplo, se +houver executáveis semelhantes ou mesmo idênticos, a filtragem provavelmente +tornará os arquivos menos semelhantes e, portanto, a compactação será +pior. O conteúdo de arquivos não executáveis no mesmo arquivo também pode +ser importante. Na prática tem que tentar com e sem filtro BCJ para ver qual +é melhor em cada situação. +.RE +.IP "" +Conjuntos de instruções diferentes têm alinhamento diferente: o arquivo +executável deve ser alinhado a um múltiplo desse valor nos dados de entrada +para fazer o filtro funcionar. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filtro;Alinhamento;Observações +x86;1;x86 32 bits ou 64 bits +ARM;4; +ARM\-Thumb;2; +ARM64;4;Alinhamento de 4096 bytes +;;é melhor +PowerPC;4;Somente big endian +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Since the BCJ\-filtered data is usually compressed with LZMA2, the +compression ratio may be improved slightly if the LZMA2 options are set to +match the alignment of the selected BCJ filter. Examples: +.RS +.IP \(bu 3 +IA\-64 filter has 16\-byte alignment so \fBpb=4,lp=4,lc=0\fP is good with LZMA2 +(2^4=16). +.IP \(bu 3 +RISC\-V code has 2\-byte or 4\-byte alignment depending on whether the file +contains 16\-bit compressed instructions (the C extension). When 16\-bit +instructions are used, \fBpb=2,lp=1,lc=3\fP or \fBpb=1,lp=1,lc=3\fP is good. When +16\-bit instructions aren't present, \fBpb=2,lp=2,lc=2\fP is the best. +\fBreadelf \-h\fP can be used to check if "RVC" appears on the "Flags" line. +.IP \(bu 3 +ARM64 is always 4\-byte aligned so \fBpb=2,lp=2,lc=2\fP is the best. +.IP \(bu 3 +The x86 filter is an exception. It's usually good to stick to LZMA2's +defaults (\fBpb=2,lp=0,lc=3\fP) when compressing x86 executables. +.RE +.IP "" +Todos os filtros BCJ suportam as mesmas \fIopções\fP: +.RS +.TP +\fBstart=\fP\fIdeslocamento\fP +Especifica o \fIdeslocamento\fP inicial que é usado na conversão entre +endereços relativos e absolutos. O \fIdeslocamento\fP deve ser um múltiplo do +alinhamento do filtro (ver tabela acima). O padrão é zero. Na prática, o +padrão é bom; especificar um \fIdeslocamento\fP personalizado quase nunca é +útil. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIopções\fP] +Adiciona o filtro Delta à cadeia de filtros. O filtro Delta só pode ser +usado como filtro não\-último na cadeia de filtros. +.IP "" +Atualmente, apenas o cálculo simples de delta byte a byte é suportado. Pode +ser útil ao compactar, por exemplo, imagens bitmap não compactadas ou áudio +PCM não compactado. No entanto, algoritmos de propósito especial podem +fornecer resultados significativamente melhores do que Delta + LZMA2. Isso é +verdade especialmente com áudio, que compacta mais rápido e melhor, por +exemplo, com \fBflac\fP(1). +.IP "" +\fIOpções\fP suportadas: +.RS +.TP +\fBdist=\fP\fIdistância\fP +Especifica a \fIdistância\fP do cálculo delta em bytes. \fIdistância\fP deve ser +1\(en256. O padrão é 1. +.IP "" +Por exemplo, com \fBdist=2\fP e entrada de oito bytes A1 B1 A2 B3 A3 B5 A4 B7, +a saída será A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Outras opções" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Suprime avisos e avisos. Especifique isso duas vezes para suprimir erros +também. Esta opção não tem efeito no status de saída. Ou seja, mesmo que um +aviso tenha sido suprimido, o status de saída para indicar um aviso ainda é +usado. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Ser detalhado. Se o erro padrão estiver conectado a um terminal, \fBxz\fP +exibirá um indicador de progresso. Especifique \fB\-\-verbose\fP duas vezes dará +uma saída ainda mais detalhada. +.IP "" +O indicador de progresso mostra as seguintes informações: +.RS +.IP \(bu 3 +A porcentagem de conclusão é mostrada se o tamanho do arquivo de entrada for +conhecido. Ou seja, a porcentagem não pode ser mostrada em encadeamentos +(pipe). +.IP \(bu 3 +Quantidade de dados compactados produzidos (compactando) ou consumidos +(descompactando). +.IP \(bu 3 +Quantidade de dados não compactados consumidos (compactação) ou produzidos +(descompactação). +.IP \(bu 3 +Taxa de compactação, que é calculada dividindo a quantidade de dados +compactados processados até o momento pela quantidade de dados não +compactados processados até o momento. +.IP \(bu 3 +Velocidade de compactação ou descompactação. Isso é medido como a quantidade +de dados não compactados consumidos (compactação) ou produzidos +(descompactação) por segundo. É mostrado após alguns segundos desde que +\fBxz\fP começou a processar o arquivo. +.IP \(bu 3 +Tempo decorrido no formato M:SS ou H:MM:SS. +.IP \(bu 3 +O tempo restante estimado é mostrado apenas quando o tamanho do arquivo de +entrada é conhecido e alguns segundos já se passaram desde que \fBxz\fP começou +a processar o arquivo. A hora é mostrada em um formato menos preciso que +nunca tem dois pontos, por exemplo, 2 min 30 s. +.RE +.IP "" +Quando o erro padrão não é um terminal, \fB\-\-verbose\fP fará com que \fBxz\fP +imprima o nome do arquivo, tamanho compactado, tamanho não compactado, taxa +de compactação e possivelmente também a velocidade e o tempo decorrido em +uma única linha para o erro padrão após a compactação ou descompactando o +arquivo. A velocidade e o tempo decorrido são incluídos apenas quando a +operação leva pelo menos alguns segundos. Se a operação não foi concluída, +por exemplo, devido à interrupção do usuário, também é impressa a +porcentagem de conclusão se o tamanho do arquivo de entrada for conhecido. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Não define o status de saída como 2, mesmo que uma condição digna de um +aviso tenha sido detectada. Esta opção não afeta o nível de detalhamento, +portanto, tanto \fB\-\-quiet\fP quanto \fB\-\-no\-warn\fP devem ser usados para não +exibir avisos e não alterar o status de saída. +.TP +\fB\-\-robot\fP +Imprime mensagens em um formato analisável por máquina. Isso visa facilitar +a criação de frontends que desejam usar \fBxz\fP em vez de liblzma, o que pode +ser o caso de vários scripts. A saída com esta opção habilitada deve ser +estável em versões \fBxz\fP. Consulte a seção \fBMODO ROBÔ\fP para obter detalhes. +.TP +\fB\-\-info\-memory\fP +Exibe, em formato legível por humanos, quanta memória física (RAM) e quantos +threads de processador \fBxz\fP acredita que o sistema possui e os limites de +uso de memória para compactação e descompactação e saia com êxito. +.TP +\fB\-h\fP, \fB\-\-help\fP +Exibe uma mensagem de ajuda descrevendo as opções mais usadas e sai com +sucesso. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Exibe uma mensagem de ajuda descrevendo todos os recursos de \fBxz\fP e sai com +sucesso +.TP +\fB\-V\fP, \fB\-\-version\fP +Exibe o número da versão de \fBxz\fP e liblzma em formato legível por +humanos. Para obter uma saída analisável por máquina, especifique \fB\-\-robot\fP +antes de \fB\-\-version\fP. +. +.SH "MODO ROBÔ" +The robot mode is activated with the \fB\-\-robot\fP option. It makes the output +of \fBxz\fP easier to parse by other programs. Currently \fB\-\-robot\fP is +supported only together with \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, +and \fB\-\-version\fP. It will be supported for compression and decompression in +the future. +. +.SS "Modo lista" +\fBxz \-\-robot \-\-list\fP usa saída separada por tabulações. A primeira coluna de +cada linha possui uma string que indica o tipo de informação encontrada +naquela linha: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Esta é sempre a primeira linha ao começar a listar um arquivo. A segunda +coluna na linha é o nome do arquivo. +.TP +\fBfile\fP +Esta linha contém informações gerais sobre o arquivo \fB.xz\fP. Esta linha é +sempre impressa após a linha \fBname\fP. +.TP +\fBstream\fP +Este tipo de linha é usado somente quando \fB\-\-verbose\fP foi +especificado. Existem tantas linhas de \fBstream\fP quanto fluxos no arquivo +\&\fB.xz\fP. +.TP +\fBblock\fP +Este tipo de linha é usado somente quando \fB\-\-verbose\fP foi +especificado. Existem tantas linhas \fBblock\fP quanto blocos no arquivo +\&\fB.xz\fP. As linhas \fBblock\fP são mostradas após todas as linhas \fBstream\fP; +diferentes tipos de linha não são intercalados. +.TP +\fBsummary\fP +Este tipo de linha é usado apenas quando \fB\-\-verbose\fP foi especificado duas +vezes. Esta linha é impressa após todas as linhas de \fBblock\fP. Assim como a +linha \fBarquivo\fP, a linha \fBsummary\fP contém informações gerais sobre o +arquivo \fB.xz\fP. +.TP +\fBtotals\fP +Esta linha é sempre a última linha da saída da lista. Ele mostra as +contagens totais e tamanhos. +.PP +As colunas das linhas \fBfile\fP: +.PD 0 +.RS +.IP 2. 4 +Número de fluxos no arquivo +.IP 3. 4 +Número total de blocos no(s) fluxo(s) +.IP 4. 4 +Tamanho compactado do arquivo +.IP 5. 4 +Uncompressed size of the file +.IP 6. 4 +Taxa de compactação, por exemplo, \fB0.123\fP. Se a proporção for superior a +9.999, serão exibidos três traços (\fB\-\-\-\fP) em vez da proporção. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Lista separada por vírgulas de nomes de verificação de integridade. As +seguintes strings são usadas para os tipos de verificação conhecidos: +\fBNone\fP, \fBCRC32\fP, \fBCRC64\fP e \fBSHA\-256\fP. Para tipos de verificações +desconhecidos, \fBUnknown\-\fP\fIN\fP é usado, onde \fIN\fP é o ID do cheque como um +número decimal (um ou dois dígitos). +.IP 8. 4 +Tamanho total do preenchimento de fluxo no arquivo +.RE +.PD +.PP +As colunas das linhas \fBstream\fP: +.PD 0 +.RS +.IP 2. 4 +Número do fluxo (o primeiro fluxo é 1) +.IP 3. 4 +Número de blocos no fluxo +.IP 4. 4 +Deslocamento inicial compactado +.IP 5. 4 +Deslocamento inicial descompactado +.IP 6. 4 +Tamanho compactado (não inclui preenchimento de fluxo) +.IP 7. 4 +Tamanho descompactado +.IP 8. 4 +Taxa de compactação +.IP 9. 4 +Nome da verificação de integridade +.IP 10. 4 +Tamanho do preenchimento do fluxo +.RE +.PD +.PP +As colunas das linhas \fBblock\fP: +.PD 0 +.RS +.IP 2. 4 +Número do fluxo que contém este bloco +.IP 3. 4 +Número do bloco relativo ao início do fluxo (o primeiro bloco é 1) +.IP 4. 4 +Número do bloco relativo ao início do arquivo +.IP 5. 4 +Deslocamento inicial compactado em relação ao início do arquivo +.IP 6. 4 +Deslocamento inicial descompactado em relação ao início do arquivo +.IP 7. 4 +Tamanho total compactado do bloco (inclui cabeçalhos) +.IP 8. 4 +Tamanho descompactado +.IP 9. 4 +Taxa de compactação +.IP 10. 4 +Nome da verificação de integridade +.RE +.PD +.PP +Se \fB\-\-verbose\fP for especificado duas vezes, colunas adicionais serão +incluídas nas linhas \fBblock\fP. Eles não são exibidos com um único +\fB\-\-verbose\fP, porque obter essas informações requer muitas buscas e, +portanto, pode ser lento: +.PD 0 +.RS +.IP 11. 4 +Valor da verificação de integridade em hexadecimal +.IP 12. 4 +Tamanho do cabeçalho do bloco +.IP 13. 4 +Sinalizadores de bloco: \fBc\fP indica que o tamanho compactado está presente e +\fBu\fP indica que o tamanho não compactado está presente. Se o sinalizador não +estiver definido, um traço (\fB\-\fP) será exibido para manter o comprimento da +string fixo. Novos sinalizadores podem ser adicionados ao final da string no +futuro. +.IP 14. 4 +Tamanho dos dados reais compactados no bloco (isso exclui o cabeçalho do +bloco, o preenchimento do bloco e os campos de verificação) +.IP 15. 4 +Quantidade de memória (em bytes) necessária para descompactar este bloco com +esta versão \fBxz\fP +.IP 16. 4 +Cadeia de filtro. Observe que a maioria das opções usadas no momento da +compactação não pode ser conhecida, pois apenas as opções necessárias para a +descompactação são armazenadas nos cabeçalhos \fB.xz\fP. +.RE +.PD +.PP +As colunas das linhas \fBsummary\fP: +.PD 0 +.RS +.IP 2. 4 +Quantidade de memória (em bytes) necessária para descompactar este arquivo +com esta versão do \fBxz\fP +.IP 3. 4 +\fByes\fP ou \fBno\fP indicando se todos os cabeçalhos de bloco têm tamanho +compactado e tamanho não compactado armazenados neles +.PP +\fIDesde\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Versão mínima do \fBxz\fP necessária para descompactar o arquivo +.RE +.PD +.PP +As colunas da linha \fBtotals\fP: +.PD 0 +.RS +.IP 2. 4 +Número de fluxos +.IP 3. 4 +Número de blocos +.IP 4. 4 +Tamanho compactado +.IP 5. 4 +Tamanho descompactado +.IP 6. 4 +Taxa de compactação média +.IP 7. 4 +Lista separada por vírgulas de nomes de verificação de integridade que +estavam presentes nos arquivos +.IP 8. 4 +Tamanho do preenchimento do fluxo +.IP 9. 4 +Número de arquivos. Isso está aqui para manter a ordem das colunas +anteriores a mesma das linhas \fBfile\fP. +.PD +.RE +.PP +Se \fB\-\-verbose\fP for especificado duas vezes, colunas adicionais serão +incluídas na linha \fBtotals\fP: +.PD 0 +.RS +.IP 10. 4 +Quantidade máxima de memória (em bytes) necessária para descompactar os +arquivos com esta versão do \fBxz\fP +.IP 11. 4 +\fByes\fP ou \fBno\fP indicando se todos os cabeçalhos de bloco têm tamanho +compactado e tamanho não compactado armazenados neles +.PP +\fIDesde\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Versão mínima do \fBxz\fP necessária para descompactar o arquivo +.RE +.PD +.PP +Versões futuras podem adicionar novos tipos de linha e novas colunas podem +ser adicionadas aos tipos de linha existentes, mas as colunas existentes não +serão alteradas. +. +.SS "Filters help" +\fBxz \-\-robot \-\-filters\-help\fP prints the supported filters in the following +format: +.PP +\fIfilter\fP\fB:\fP\fIoption\fP\fB=<\fP\fIvalue\fP\fB>,\fP\fIoption\fP\fB=<\fP\fIvalue\fP\fB>\fP... +.TP +\fIfilter\fP +Name of the filter +.TP +\fIoption\fP +Name of a filter specific option +.TP +\fIvalue\fP +Numeric \fIvalue\fP ranges appear as \fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. String +\fIvalue\fP choices are shown within \fB< >\fP and separated by a \fB|\fP +character. +.PP +Each filter is printed on its own line. +. +.SS "Informações de limite de memória" +\fBxz \-\-robot \-\-info\-memory\fP prints a single line with multiple tab\-separated +columns: +.IP 1. 4 +Quantidade total de memória física (RAM) em bytes. +.IP 2. 4 +Limite de uso de memória para compactação em bytes +(\fB\-\-memlimit\-compress\fP). Um valor especial de \fB0\fP indica a configuração +padrão que para o modo de thread única é o mesmo que sem limite. +.IP 3. 4 +Limite de uso de memória para descompactação em bytes +(\fB\-\-memlimit\-decompress\fP). Um valor especial de \fB0\fP indica a configuração +padrão que para o modo de thread única é o mesmo que sem limite. +.IP 4. 4 +Desde \fBxz\fP 5.3.4alpha: Uso de memória para descompactação com várias thread +em bytes (\fB\-\-memlimit\-mt\-decompress\fP). Isso nunca é zero porque um valor +padrão específico do sistema mostrado na coluna 5 é usado se nenhum limite +for especificado explicitamente. Isso também nunca é maior que o valor na +coluna 3, mesmo que um valor maior tenha sido especificado com +\fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Desde \fBxz\fP 5.3.4alpha: Um limite de uso de memória padrão específico do +sistema que é usado para limitar o número de threads ao compactar com um +número automático de threads (\fB\-\-threads=0\fP) e nenhum limite de uso de +memória foi especificado (\fB\-\-memlimit\-compress\fP). Isso também é usado como +o valor padrão para \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Desde \fBxz\fP 5.3.4alpha: Número de threads de processador disponíveis. +.PP +No futuro, a saída de \fBxz \-\-robot \-\-info\-memory\fP pode ter mais colunas, mas +nunca mais do que uma única linha. +. +.SS Versão +\fBxz \-\-robot \-\-version\fP prints the version number of \fBxz\fP and liblzma in +the following format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Versão principal. +.TP +\fIYYY\fP +Versão menor. Números pares são estáveis. Os números ímpares são versões +alfa ou beta. +.TP +\fIZZZ\fP +Nível de patch para versões estáveis ou apenas um contador para versões de +desenvolvimento. +.TP +\fIS\fP +Estabilidade. 0 é alfa, 1 é beta e 2 é estável. \fIS\fP deve ser sempre 2 +quando \fIYYY\fP for par. +.PP +\fIXYYYZZZS\fP são iguais em ambas as linhas se \fBxz\fP e liblzma forem da mesma +versão do XZ Utils. +.PP +Exemplos: 4.999.9beta é \fB49990091\fP e 5.0.0 é \fB50000002\fP. +. +.SH "STATUS DE SAÍDA" +.TP +\fB0\fP +Está tudo bem. +.TP +\fB1\fP +Ocorreu um erro. +.TP +\fB2\fP +Algo digno de um aviso ocorreu, mas ocorreu nenhum erro real. +.PP +Observações (não avisos ou erros) impressas no erro padrão não afetam o +status de saída. +. +.SH AMBIENTE +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP analisa listas de opções separadas por espaços das variáveis de +ambiente \fBXZ_DEFAULTS\fP e \fBXZ_OPT\fP, nesta ordem, antes de analisar as +opções da linha de comando. Observe que apenas as opções são analisadas a +partir das variáveis de ambiente; todas as não opções são silenciosamente +ignoradas. A análise é feita com \fBgetopt_long\fP(3) que também é usado para +os argumentos da linha de comando. +.PP +\fBWarning:\fP By setting these environment variables, one is effectively +modifying programs and scripts that run \fBxz\fP. Most of the time it is safe +to set memory usage limits, number of threads, and compression options via +the environment variables. However, some options can break scripts. An +obvious example is \fB\-\-help\fP which makes \fBxz\fP show the help text instead of +compressing or decompressing a file. More subtle examples are \fB\-\-quiet\fP +and \fB\-\-verbose\fP. In many cases it works well to enable the progress +indicator using \fB\-\-verbose\fP, but in some situations the extra messages +create problems. The verbosity level also affects the behavior of +\fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +User\-specific or system\-wide default options. Typically this is set in a +shell initialization script to enable \fBxz\fP's memory usage limiter by +default or set the default number of threads. Excluding shell +initialization scripts and similar special cases, scripts should never set +or unset \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Isso é para passar opções para \fBxz\fP quando não é possível definir as opções +diretamente na linha de comando \fBxz\fP. Este é o caso quando \fBxz\fP é +executado por um script ou ferramenta, por exemplo, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Os scripts podem usar \fBXZ_OPT\fP, por exemplo, para definir opções de +compactação padrão específicas do script. Ainda é recomendável permitir que +os usuários substituam \fBXZ_OPT\fP se isso for razoável. Por exemplo, em +scripts \fBsh\fP(1) pode\-se usar algo assim: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "COMPATIBILIDADE COM LZMA UTILS" +A sintaxe da linha de comando do \fBxz\fP é praticamente um superconjunto de +\fBlzma\fP, \fBunlzma\fP e \fBlzcat\fP conforme encontrado no LZMA Utils 4.32.x. Na +maioria dos casos, é possível substituir LZMA Utils por XZ Utils sem +interromper os scripts existentes. Existem algumas incompatibilidades, +porém, que às vezes podem causar problemas. +. +.SS "Níveis de predefinição de compactação" +A numeração das predefinições de nível de compactação não é idêntica em +\fBxz\fP e LZMA Utils. A diferença mais importante é como os tamanhos dos +dicionários são mapeados para diferentes predefinições. O tamanho do +dicionário é aproximadamente igual ao uso de memória do descompactador. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nível;xz;LZMA Utils +\-0;256 KiB;N/D +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +As diferenças de tamanho do dicionário também afetam o uso da memória do +compressor, mas existem algumas outras diferenças entre LZMA Utils e XZ +Utils, que tornam a diferença ainda maior: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nível;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/D +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +O nível de predefinição padrão no LZMA Utils é \fB\-7\fP enquanto no XZ Utils é +\fB\-6\fP, então ambos usam um dicionário de 8 MiB por padrão. +. +.SS "Arquivos .lzma em um fluxo versus sem ser em um fluxo" +O tamanho descompactado do arquivo pode ser armazenado no cabeçalho de +\&\fB.lzma\fP. O LZMA Utils faz isso ao compactar arquivos comuns. A alternativa +é marcar que o tamanho não compactado é desconhecido e usar o marcador de +fim de carga útil para indicar onde o descompactador deve parar. O LZMA +Utils usa este método quando o tamanho não compactado não é conhecido, como +é o caso, por exemplo, de encadeamentos (pipes). +.PP +\fBxz\fP oferece suporte à descompactação de arquivos \fB.lzma\fP com ou sem +marcador de fim de carga útil, mas todos os arquivos \fB.lzma\fP criados por +\fBxz\fP usarão marcador de fim de carga útil e terão o tamanho descompactado +marcado como desconhecido no cabeçalho de \fB.lzma\fP. Isso pode ser um +problema em algumas situações incomuns. Por exemplo, um descompactador de +\&\fB.lzma\fP em um dispositivo embarcado pode funcionar apenas com arquivos que +tenham tamanho descompactado conhecido. Se você encontrar esse problema, +precisará usar o LZMA Utils ou o LZMA SDK para criar arquivos \fB.lzma\fP com +tamanho descompactado conhecido. +. +.SS "Arquivos .lzma não suportados" +O formato \fB.lzma\fP permite valores \fIlc\fP até 8 e valores \fIlp\fP até 4. LZMA +Utils pode descompactar arquivos com qualquer \fIlc\fP e \fIlp\fP, mas sempre cria +arquivos com \fBlc=3\fP e \fBlp=0\fP. Criar arquivos com outros \fIlc\fP e \fIlp\fP é +possível com \fBxz\fP e com LZMA SDK. +.PP +A implementação do filtro LZMA1 em liblzma requer que a soma de \fIlc\fP e +\fIlp\fP não exceda 4. Assim, arquivos \fB.lzma\fP, que excedam esta limitação, +não podem ser descompactados com \fBxz\fP. +.PP +LZMA Utils cria apenas arquivos \fB.lzma\fP que possuem um tamanho de +dicionário de 2^\fIn\fP (uma potência de 2), mas aceita arquivos com qualquer +tamanho de dicionário. liblzma aceita apenas arquivos \fB.lzma\fP que tenham um +tamanho de dicionário de 2^\fIn\fP ou 2^\fIn\fP + 2^(\fIn\fP\-1). Isso é para diminuir +os falsos positivos ao detectar arquivos \fB.lzma\fP. +.PP +Essas limitações não devem ser um problema na prática, já que praticamente +todos os arquivos \fB.lzma\fP foram compactados com configurações que o liblzma +aceitará. +. +.SS "Lixo à direita" +Ao descompactar, o LZMA Utils silenciosamente ignora tudo após o primeiro +fluxo \fB.lzma\fP. Na maioria das situações, isso é um bug. Isso também +significa que o LZMA Utils não oferece suporte a descompactação de arquivos +\&\fB.lzma\fP concatenados. +.PP +Se houver dados restantes após o primeiro fluxo de \fB.lzma\fP, \fBxz\fP considera +o arquivo corrompido, a menos que \fB\-\-single\-stream\fP tenha sido usado. Isso +pode quebrar scripts obscuros que presumiram que o lixo à direita é +ignorado. +. +.SH NOTAS +. +.SS "A saída compactada pode variar" +A saída compactada exata produzida a partir do mesmo arquivo de entrada não +compactado pode variar entre as versões do XZ Utils, mesmo se as opções de +compactação forem idênticas. Isso ocorre porque o codificador pode ser +aprimorado (compactação mais rápida ou melhor) sem afetar o formato do +arquivo. A saída pode variar mesmo entre diferentes compilações da mesma +versão do XZ Utils, se diferentes opções de compilação forem usadas. +.PP +A informação acima significa que, uma vez que \fB\-\-rsyncable\fP tenha sido +implementado, os arquivos resultantes não serão necessariamente +"rsyncáveis", a menos que os arquivos antigos e novos tenham sido +compactados com a mesma versão xz. Esse problema pode ser corrigido se uma +parte da implementação do codificador for congelada para manter a saída de +rsyncable estável nas versões do xz. +. +.SS "Descompactadores .xz embarcados" +As implementações do descompactador \fB.xz\fP embarcados, como o XZ Embedded, +não oferecem necessariamente suporte a arquivos criados com tipos de +\fIverificações\fP de integridade diferentes de \fBnone\fP e \fBcrc32\fP. Como o +padrão é \fB\-\-check=crc64\fP, você deve usar \fB\-\-check=none\fP ou +\fB\-\-check=crc32\fP ao criar arquivos para sistemas embarcados. +.PP +Fora dos sistemas embarcados, todos os descompactadores de formato \fB.xz\fP +oferecem suporte a todos os tipos de \fIverificação\fP ou, pelo menos, são +capazes de descompactar o arquivo sem verificar a verificação de integridade +se a \fIverificação\fP específica não for suportada. +.PP +XZ Embedded oferece suporte a filtros BCJ, mas apenas com o deslocamento +inicial padrão. +. +.SH EXEMPLOS +. +.SS Básico +Compactar o arquivo \fIfoo\fP em \fIfoo.xz\fP usando o nível de compactação padrão +(\fB\-6\fP) e remover \fIfoo\fP se a compactação for bem\-sucedida: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Descompactar \fIbar.xz\fP em \fIbar\fP e não remover \fIbar.xz\fP mesmo se a +descompactação for bem\-sucedida: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Criar \fIbaz.tar.xz\fP com a predefinição \fB\-4e\fP (\fB\-4 \-\-extreme\fP), que é mais +lenta que o padrão \fB\-6\fP, mas precisa de menos memória para compactação e +descompactação (48 \ MiB e 5\ MiB, respectivamente): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Uma mistura de arquivos compactados e descompactados pode ser descompactada +para a saída padrão com um único comando: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Compactação paralela de muitos arquivos" +No GNU e *BSD, \fBfind\fP(1) e \fBxargs\fP(1) podem ser usados para paralelizar a +compactação de muitos arquivos: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +A opção \fB\-P\fP para \fBxargs\fP(1) define o número de processos paralelos do +\fBxz\fP. O melhor valor para a opção \fB\-n\fP depende de quantos arquivos devem +ser compactados. Se houver apenas alguns arquivos, o valor provavelmente +deve ser 1; com dezenas de milhares de arquivos, 100 ou até mais podem ser +apropriados para reduzir o número de processos de \fBxz\fP que \fBxargs\fP(1) +eventualmente criará. +.PP +A opção \fB\-T1\fP para \fBxz\fP existe para forçá\-lo ao modo de thread única, +porque \fBxargs\fP(1) é usado para controlar a quantidade de paralelização. +. +.SS "Modo robô" +Calcular quantos bytes foram salvos no total depois de compactar vários +arquivos: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Um script pode querer saber que está usando \fBxz\fP novo o suficiente. O +seguinte script \fBsh\fP(1) verifica se o número da versão da ferramenta \fBxz\fP +é pelo menos 5.0.0. Este método é compatível com versões beta antigas, que +não suportavam a opção \fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Definir um limite de uso de memória para descompactação usando \fBXZ_OPT\fP, +mas se um limite já tiver sido definido, não o aumentar: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Cadeias de filtro de compressor personalizadas" +O uso mais simples para cadeias de filtro personalizadas é personalizar uma +predefinição LZMA2. Isso pode ser útil, porque as predefinições abrangem +apenas um subconjunto das combinações potencialmente úteis de configurações +de compactação. +.PP +As colunas CompCPU das tabelas das descrições das opções \fB\-0\fP ... \fB\-9\fP e +\fB\-\-extreme\fP são úteis ao personalizar as predefinições LZMA2. Aqui estão as +partes relevantes coletadas dessas duas tabelas: +.RS +.PP +.TS +tab(;); +c c +n n. +Predefinição;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Se você sabe que um arquivo requer um dicionário um tanto grande (por +exemplo, 32\ MiB) para compactar bem, mas deseja comprimi\-lo mais +rapidamente do que \fBxz \-8\fP faria, uma predefinição com um valor CompCPU +baixo (por exemplo, 1) pode ser modificado para usar um dicionário maior: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Com certos arquivos, o comando acima pode ser mais rápido que \fBxz \-6\fP +enquanto compacta significativamente melhor. No entanto, deve\-se enfatizar +que apenas alguns arquivos se beneficiam de um grande dicionário, mantendo o +valor CompCPU baixo. A situação mais óbvia, onde um grande dicionário pode +ajudar muito, é um arquivo contendo arquivos muito semelhantes de pelo menos +alguns megabytes cada. O tamanho do dicionário deve ser significativamente +maior do que qualquer arquivo individual para permitir que o LZMA2 aproveite +ao máximo as semelhanças entre arquivos consecutivos. +.PP +Se o uso muito alto de memória do compactador e do descompactador for bom e +o arquivo que está sendo compactado tiver pelo menos várias centenas de +megabytes, pode ser útil usar um dicionário ainda maior do que os 64 MiB que +o \fBxz \-9\fP usaria: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Usar \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) como no exemplo acima pode ser útil +para ver os requisitos de memória do compactador e do +descompactador. Lembre\-se que usar um dicionário maior que o tamanho do +arquivo descompactado é desperdício de memória, então o comando acima não é +útil para arquivos pequenos. +.PP +Às vezes, o tempo de compactação não importa, mas o uso de memória do +descompactador deve ser mantido baixo, por exemplo, para possibilitar a +descompactação do arquivo em um sistema embarcado. O comando a seguir usa +\fB\-6e\fP (\fB\-6 \-\-extreme\fP) como base e define o dicionário como apenas 64\ KiB. O arquivo resultante pode ser descompactado com XZ Embedded (é por isso +que existe \fB\-\-check=crc32\fP) usando cerca de 100\ KiB de memória. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Se você deseja espremer o máximo de bytes possível, ajustar o número de bits +de contexto literal (\fIlc\fP) e o número de bits de posição (\fIpb\fP) às vezes +pode ajudar. Ajustar o número de bits de posição literal (\fIlp\fP) também pode +ajudar, mas geralmente \fIlc\fP e \fIpb\fP são mais importantes. Por exemplo, um +arquivo de código\-fonte contém principalmente texto US\-ASCII, então algo +como o seguinte pode fornecer um arquivo ligeiramente (como 0,1\ %) menor +que \fBxz \-6e\fP (tente também sem \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +O uso de outro filtro junto com o LZMA2 pode melhorar a compactação com +determinados tipos de arquivo. Por exemplo, para compactar uma biblioteca +compartilhada x86\-32 ou x86\-64 usando o filtro x86 BCJ: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Observe que a ordem das opções de filtro é significativa. Se \fB\-\-x86\fP for +especificado após \fB\-\-lzma2\fP, \fBxz\fP dará um erro, porque não pode haver +nenhum filtro após LZMA2 e também porque o filtro x86 BCJ não pode ser usado +como o último filtro em a corrente. +.PP +O filtro Delta junto com LZMA2 pode dar bons resultados com imagens +bitmap. Ele geralmente deve superar o PNG, que possui alguns filtros mais +avançados do que o delta simples, mas usa Deflate para a compactação real. +.PP +A imagem deve ser salva em formato não compactado, por exemplo, como TIFF +não compactado. O parâmetro de distância do filtro Delta é definido para +corresponder ao número de bytes por pixel na imagem. Por exemplo, bitmap RGB +de 24 bits precisa de \fBdist=3\fP, e também é bom passar \fBpb=0\fP para LZMA2 +para acomodar o alinhamento de três bytes: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Se várias imagens foram colocadas em um único arquivo (por exemplo, +\&\fB.tar\fP), o filtro Delta também funcionará, desde que todas as imagens +tenham o mesmo número de bytes por pixel. +. +.SH "VEJA TAMBÉM" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/lzmadec.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/lzmadec.1 new file mode 100644 index 0000000000000000000000000000000000000000..996139d902e42586500e065920dcaa01e8630344 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/lzmadec.1 @@ -0,0 +1,87 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.\" Brazilian Portuguese translations for xz package +.\" Traduções em português brasileiro para o pacote xz. +.\" Rafael Fontenelle , 2022-2023. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDEC 1 2024\-04\-08 Tukaani "XZ Utils" +.SH NOME +xzdec, lzmadec \- Pequenos descompactadores .xz e .lzma +.SH SINOPSE +\fBxzdec\fP [\fIopção...\fP] [\fIarquivo...\fP] +.br +\fBlzmadec\fP [\fIopção...\fP] [\fIarquivo...\fP] +.SH DESCRIÇÃO +\fBxzdec\fP é uma ferramenta de descompactação baseada em liblzma somente para +arquivos \fB.xz\fP (e somente \fB.xz\fP). \fBxzdec\fP destina\-se a funcionar como um +substituto para \fBxz\fP(1) nas situações mais comuns em que um script foi +escrito para usar \fBxz \-\-decompress \-\-stdout\fP (e possivelmente alguns outras +opções comumente usadas) para descompactar arquivos \fB.xz\fP. \fBlzmadec\fP é +idêntico a \fBxzdec\fP exceto que \fBlzmadec\fP tem suporte a arquivos \fB.lzma\fP em +vez de arquivos \fB.xz\fP. +.PP +Para reduzir o tamanho do executável, \fBxzdec\fP não tem suporte ao uso de +várias threads ou a localização, e não lê opções de variáveis de ambiente +\fBXZ_DEFAULTS\fP e \fBXZ_OPT\fP. \fBxzdec\fP não tem suporte à exibição de +informações de progresso intermediárias: enviar \fBSIGINFO\fP para \fBxzdec\fP não +faz nada, mas enviar \fBSIGUSR1\fP encerra o processo em vez de exibir +informações de progresso. +.SH OPÇÕES +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +Ignorada para compatibilidade \fBxz\fP(1). \fBxzdec\fP tem suporte a apenas +descompactação. +.TP +\fB\-k\fP, \fB\-\-keep\fP +Ignorada para compatibilidade \fBxz\fP(1). \fBxzdec\fP nunca cria ou remove +quaisquer arquivos. +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Ignorada para compatibilidade \fBxz\fP(1). \fBxzdec\fP sempre grava os dados +descompactados para a saída padrão. +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Especificar isso uma vez não faz nada, pois \fBxzdec\fP nunca exibe nenhum +aviso ou notificação. Especifique isso duas vezes para suprimir erros. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Ignorada para compatibilidade \fBxz\fP(1). \fBxzdec\fP nunca usa o status de saída +2. +.TP +\fB\-h\fP, \fB\-\-help\fP +Exibe uma mensagem de ajuda e sai com sucesso. +.TP +\fB\-V\fP, \fB\-\-version\fP +Mostra o número da versão do \fBxzdec\fP e liblzma. +.SH "STATUS DE SAÍDA" +.TP +\fB0\fP +Correu tudo bem. +.TP +\fB1\fP +Ocorreu um erro. +.PP +\fBxzdec\fP não possui nenhuma mensagem de aviso como o \fBxz\fP(1), portanto, o +status de saída 2 não é usado por \fBxzdec\fP. +.SH NOTAS +Use \fBxz\fP(1) em vez de \fBxzdec\fP ou \fBlzmadec\fP para uso diário +normal. \fBxzdec\fP ou \fBlzmadec\fP destinam\-se apenas a situações em que é +importante ter um descompactador menor do que o \fBxz\fP(1) completo. +.PP +\fBxzdec\fP e \fBlzmadec\fP não são realmente tão pequenos. O tamanho pode ser +reduzido ainda mais eliminando recursos do liblzma no tempo de compilação, +mas isso geralmente não deve ser feito para executáveis distribuídos em +distribuições típicas de sistemas operacionais não embarcados. Se você +precisa de um descompactador \fB.xz\fP realmente pequeno, considere usar o XZ +Embedded. +.SH "VEJA TAMBÉM" +\fBxz\fP(1) +.PP +XZ Embedded: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/lzmainfo.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/lzmainfo.1 new file mode 100644 index 0000000000000000000000000000000000000000..5566566aaab6c61810ba235dc1961b23312bde05 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/lzmainfo.1 @@ -0,0 +1,45 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.\" Brazilian Portuguese translations for xz package +.\" Traduções em português brasileiro para o pacote xz. +.\" Rafael Fontenelle , 2022-2023. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH LZMAINFO 1 2013\-06\-30 Tukaani "XZ Utils" +.SH NOME +lzmainfo \- mostra informações armazenadas no cabeçalho do arquivo .lzma +.SH SINOPSE +\fBlzmainfo\fP [\fB\-\-help\fP] [\fB\-\-version\fP] [\fIarquivo...\fP] +.SH DESCRIÇÃO +\fBlzmainfo\fP mostra as informações armazenadas no cabeçalho do arquivo +\&\fB.lzma\fP. Ele lê os primeiros 13 bytes do \fIarquivo\fP especificado, +decodifica o cabeçalho e o imprime na saída padrão em formato legível por +humanos. Se nenhum \fIarquivo\fP for fornecido ou \fIarquivo\fP for \fB\-\fP, a +entrada padrão será lida. +.PP +Normalmente, as informações mais interessantes são o tamanho descompactado e +o tamanho do dicionário. O tamanho não compactado pode ser mostrado apenas +se o arquivo estiver na variante de formato \fB.lzma\fP não transmitido. A +quantidade de memória necessária para descompactar o arquivo é de algumas +dezenas de kilobytes mais o tamanho do dicionário. +.PP +\fBlzmainfo\fP está incluído no XZ Utils principalmente para compatibilidade +com versões anteriores do LZMA Utils. +.SH "STATUS DE SAÍDA" +.TP +\fB0\fP +Está tudo bem. +.TP +\fB1\fP +Ocorreu um erro. +.SH BUGS +\fBlzmainfo\fP usa \fBMB\fP enquanto o sufixo correto seria \fBMiB\fP (2^20 +bytes). Isso é para manter a saída compatível com LZMA Utils. +.SH "VEJA TAMBÉM" +\fBxz\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/unlzma.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/unlzma.1 new file mode 100644 index 0000000000000000000000000000000000000000..0f85fc96ac66488096221e723d837e7d28ff6bc2 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/unlzma.1 @@ -0,0 +1,1994 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Brazilian Portuguese translations for xz package +.\" Traduções em português brasileiro para o pacote xz. +.\" Rafael Fontenelle , 2022-2023. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 2025\-03\-08 Tukaani "XZ Utils" +. +.SH NOME +xz, unxz, xzcat, lzma, unlzma, lzcat \- Compacta ou descompacta arquivos .xz +e .lzma +. +.SH SINOPSE +\fBxz\fP [\fIopção...\fP] [\fIarquivo...\fP] +. +.SH "COMANDOS APELIDOS" +\fBunxz\fP é equivalente a \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP é equivalente a \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP é equivalente a \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP é equivalente a \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP é equivalente a \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Ao escrever scripts que precisam descompactar arquivos, é recomendável +sempre usar o nome \fBxz\fP com os argumentos apropriados (\fBxz \-d\fP ou \fBxz \-dc\fP) em vez dos nomes \fBunxz\fP e \fBxzcat\fP. +. +.SH DESCRIÇÃO +\fBxz\fP é uma ferramenta de compactação de dados de uso geral com sintaxe de +linha de comando semelhante ao \fBgzip\fP(1) e ao \fBbzip2\fP(1). O formato de +arquivo nativo é o formato \fB.xz\fP, mas o formato legado \fB.lzma\fP usado por +LZMA Utils e fluxos compactados brutos sem cabeçalhos de formato de +contêiner também são suportados. Além disso, a descompactação do formato +\&\fB.lz\fP usado por \fBlzip\fP é suportada. +.PP +\fBxz\fP compacta ou descompacta cada \fIarquivo\fP de acordo com o modo de +operação selecionado. Se nenhum \fIarquivo\fP for fornecido ou \fIarquivo\fP for +\fB\-\fP, \fBxz\fP lê da entrada padrão e grava os dados processados na saída +padrão. \fBxz\fP recusará (exibirá um erro e ignorará o \fIarquivo\fP) para gravar +dados compactados na saída padrão se for um terminal. Da mesma forma, \fBxz\fP +se recusará a ler dados compactados da entrada padrão se for um terminal. +.PP +A menos que \fB\-\-stdout\fP seja especificado, \fIarquivos\fP diferentes de \fB\-\fP +são gravados em um novo arquivo cujo nome é derivado do nome \fIarquivo\fP de +origem: +.IP \(bu 3 +Ao compactar, o sufixo do formato de arquivo de destino (\fB.xz\fP ou \fB.lzma\fP) +é anexado ao nome do arquivo de origem para obter o nome do arquivo de +destino. +.IP \(bu 3 +Ao descompactar, o sufixo \fB.xz\fP, \fB.lzma\fP ou \fB.lz\fP é removido do nome do +arquivo para obter o nome do arquivo de destino. \fBxz\fP também reconhece os +sufixos \fB.txz\fP e \fB.tlz\fP e os substitui pelo sufixo \fB.tar\fP. +.PP +Se o arquivo de destino já existir, um erro será exibido e \fIarquivo\fP será +ignorado. +.PP +A menos que grave na saída padrão, \fBxz\fP exibirá um aviso e pulará o +\fIarquivo\fP se qualquer um dos seguintes se aplicar: +.IP \(bu 3 +\fIArquivo\fP não é um arquivo normal. Links simbólicos não são seguidos e, +portanto, não são considerados arquivos comuns. +.IP \(bu 3 +\fIArquivo\fP tem mais de um link físico. +.IP \(bu 3 +\fIFile\fP tem setuid, setgid ou sticky bit definido. +.IP \(bu 3 +O modo de operação está definido para compactar e o \fIarquivo\fP já possui um +sufixo do formato de arquivo de destino (\fB.xz\fP ou \fB.txz\fP ao compactar para +o formato \fB.xz\fP e \fB.lzma \fP ou \fB.tlz\fP ao compactar para o formato +\&\fB.lzma\fP). +.IP \(bu 3 +O modo de operação está definido para descompactar e o \fIarquivo\fP não possui +um sufixo de nenhum dos formatos de arquivo suportados (\fB.xz\fP, \fB.txz\fP, +\&\fB.lzma\fP, \fB.tlz\fP , ou \fB.lz\fP). +.PP +Depois de compactar ou descompactar com êxito o \fIarquivo\fP, o \fBxz\fP copia o +dono, grupo, permissões, horário de acesso e horário de modificação do +\fIarquivo\fP de origem para o arquivo de destino. Se a cópia do grupo falhar, +as permissões serão modificadas para que o arquivo de destino não se torne +acessível a usuários que não têm permissão para acessar o \fIarquivo\fP de +origem. \fBxz\fP ainda não oferece suporte à cópia de outros metadados, como +listas de controle de acesso ou atributos estendidos. +.PP +Depois que o arquivo de destino for fechado com êxito, o \fIarquivo\fP de +origem será removido, a menos que \fB\-\-keep\fP tenha sido especificado. O +\fIarquivo\fP de origem nunca é removido se a saída for gravada na saída padrão +ou se ocorrer um erro. +.PP +O envio de \fBSIGINFO\fP ou \fBSIGUSR1\fP para o processo do \fBxz\fP faz com que ele +imprima informações de andamento para erro padrão. Isso tem uso limitado, +pois quando o erro padrão é um terminal, usar \fB\-\-verbose\fP exibirá um +indicador de progresso de atualização automática. +. +.SS "Uso de memória" +O uso de memória de \fBxz\fP varia de algumas centenas de kilobytes a vários +gigabytes, dependendo das configurações de compactação. As configurações +usadas ao compactar um arquivo determinam os requisitos de memória do +descompactador. Normalmente, o descompactador precisa de 5\ % a 20\ % da +quantidade de memória que o compactador precisou ao criar o arquivo. Por +exemplo, descompactar um arquivo criado com \fBxz \-9\fP atualmente requer 65\ MiB de memória. Ainda assim, é possível ter arquivos \fB.xz\fP que requerem +vários gigabytes de memória para descompactar. +.PP +Especialmente os usuários de sistemas mais antigos podem achar irritante a +possibilidade de uso de memória muito grande. Para evitar surpresas +desconfortáveis, o \fBxz\fP possui um limitador de uso de memória embutido, que +está desabilitado por padrão. Embora alguns sistemas operacionais forneçam +maneiras de limitar o uso de memória dos processos, confiar nele não foi +considerado flexível o suficiente (por exemplo, usar \fBulimit\fP(1) para +limitar a memória virtual tende a prejudicar \fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +O limitador de uso de memória pode ser ativado com a opção de linha de +comando \fB\-\-memlimit=\fP\fIlimite\fP. Geralmente é mais conveniente habilitar o +limitador por padrão definindo a variável de ambiente \fBXZ_DEFAULTS\fP, por +exemplo, \fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. É possível definir os limites +separadamente para compactação e descompactação usando +\fB\-\-memlimit\-compress=\fP\fIlimite\fP e \fB\-\-memlimit\-decompress=\fP\fIlimite\fP. Usar +essas duas opções fora de \fBXZ_DEFAULTS\fP raramente é útil porque uma única +execução de \fBxz\fP não pode fazer compactação e descompactação e +\fB\-\-memlimit=\fP\fIlimite\fP (ou \fB\-M\fP \fIlimite\fP ) é mais curto para digitar na +linha de comando. +.PP +Se o limite de uso de memória especificado for excedido durante a +descompactação, \fBxz\fP exibirá um erro e a descompactação do arquivo +falhará. Se o limite for excedido durante a compactação, \fBxz\fP tentará +reduzir as configurações para que o limite não seja mais excedido (exceto ao +usar \fB\-\-format=raw\fP ou \fB\-\-no\-adjust\fP). Dessa forma, a operação não +falhará, a menos que o limite seja muito pequeno. A escala das configurações +é feita em etapas que não correspondem às predefinições do nível de +compactação, por exemplo, se o limite for apenas um pouco menor que o valor +necessário para \fBxz \-9\fP, as configurações serão reduzidas apenas um pouco , +não até \fBxz \-8\fP. +. +.SS "Concatenação e preenchimento com arquivos .xz" +É possível concatenar arquivos \fB.xz\fP como estão. \fBxz\fP irá descompactar +tais arquivos como se fossem um único arquivo \fB.xz\fP. +.PP +É possível inserir preenchimento entre as partes concatenadas ou após a +última parte. O preenchimento deve consistir em bytes nulos e o tamanho do +preenchimento deve ser um múltiplo de quatro bytes. Isso pode ser útil, por +exemplo, se o arquivo \fB.xz\fP for armazenado em uma mídia que mede tamanhos +de arquivo em blocos de 512 bytes. +.PP +Concatenação e preenchimento não são permitidos com arquivos \fB.lzma\fP ou +fluxos brutos. +. +.SH OPÇÕES +. +.SS "Sufixos inteiros e valores especiais" +Na maioria dos lugares onde um argumento inteiro é esperado, um sufixo +opcional é suportado para indicar facilmente números inteiros grandes. Não +deve haver espaço entre o número inteiro e o sufixo. +.TP +\fBKiB\fP +Multiplica o inteiro por 1.024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP e \fBKB\fP são +aceitos como sinônimos de \fBKiB\fP. +.TP +\fBMiB\fP +Multiplica o número inteiro por 1.048.576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP e \fBMB\fP +são aceitos como sinônimos de \fBMiB\fP. +.TP +\fBGiB\fP +Multiplica o número inteiro por 1.073.741.824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP e +\fBGB\fP são aceitos como sinônimos de \fBGiB\fP. +.PP +O valor especial \fBmax\fP pode ser usado para indicar o valor inteiro máximo +suportado pela opção. +. +.SS "Modo de operação" +Se várias opções de modo de operação forem dadas, a última entrará em vigor. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Compacta. Este é o modo de operação padrão quando nenhuma opção de modo de +operação é especificada e nenhum outro modo de operação está implícito no +nome do comando (por exemplo, \fBunxz\fP implica em \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +After successful compression, the source file is removed unless writing to +standard output or \fB\-\-keep\fP was specified. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Decompress. After successful decompression, the source file is removed +unless writing to standard output or \fB\-\-keep\fP was specified. +.TP +\fB\-t\fP, \fB\-\-test\fP +Testa a integridade de \fIarquivos\fP compactados. Esta opção é equivalente a +\fB\-\-decompress \-\-stdout\fP exceto que os dados descompactados são descartados +em vez de serem gravados na saída padrão. Nenhum arquivo é criado ou +removido. +.TP +\fB\-l\fP, \fB\-\-list\fP +Imprime informações sobre \fIarquivos\fP compactados. Nenhuma saída +descompactada é produzida e nenhum arquivo é criado ou removido. No modo de +lista, o programa não pode ler os dados compactados da entrada padrão ou de +outras fontes não pesquisáveis. +.IP "" +A listagem padrão mostra informações básicas sobre \fIarquivos\fP, um arquivo +por linha. Para obter informações mais detalhadas, use também a opção +\fB\-\-verbose\fP. Para obter ainda mais informações, use \fB\-\-verbose\fP duas +vezes, mas observe que isso pode ser lento, porque obter todas as +informações extras requer muitas buscas. A largura da saída detalhada excede +80 caracteres, portanto, canalizar a saída para, por exemplo, \fBless\ \-S\fP +pode ser conveniente se o terminal não tiver largura o suficiente. +.IP "" +A saída exata pode variar entre versões \fBxz\fP e localidades diferentes. Para +saída legível por máquina, \fB\-\-robot \-\-list\fP deve ser usado. +. +.SS "Modificadores de operação" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Não exclui os arquivos de entrada. +.IP "" +Desde \fBxz\fP 5.2.6, esta opção também faz \fBxz\fP compactar ou descompactar +mesmo se a entrada for um link simbólico para um arquivo comum, tiver mais +de um link físico ou tiver o setuid, setgid ou sticky bit definir. Os bits +setuid, setgid e sticky não são copiados para o arquivo de destino. Nas +versões anteriores, isso era feito apenas com \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Esta opção tem vários efeitos: +.RS +.IP \(bu 3 +Se o arquivo de destino já existir, o exclui antes de compactar ou +descompactar. +.IP \(bu 3 +Compacta ou descompacta, mesmo que a entrada seja um link simbólico para um +arquivo normal, tenha mais de um link físico ou tenha setuid, setgid ou +sticky bit definido. Os bits setuid, setgid e sticky não são copiados para o +arquivo de destino. +.IP \(bu 3 +Quando usado com \fB\-\-decompress\fP \fB\-\-stdout\fP e \fBxz\fP não consegue reconhecer +o tipo do arquivo de origem, copia o arquivo de origem como está na saída +padrão. Isso permite que \fBxzcat\fP \fB\-\-force\fP seja usado como \fBcat\fP(1) para +arquivos que não foram compactados com \fBxz\fP. Observe que, no futuro, o +\fBxz\fP pode oferecer suporte a novos formatos de arquivo compactado, o que +pode fazer com que o \fBxz\fP descompacte mais tipos de arquivos em vez de +copiá\-los como na saída padrão. \fB\-\-format=\fP\fIformato\fP pode ser usado para +restringir \fBxz\fP para descompactar apenas um único formato de arquivo. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Grava os dados compactados ou descompactados na saída padrão em vez de em um +arquivo. Isso implica em \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Descompacta apenas o primeiro fluxo de \fB.xz\fP e ignora silenciosamente +possíveis dados de entrada restantes após o fluxo. Normalmente, esse +restante posterior sem uso faz com que \fBxz\fP exiba um erro. +.IP "" +\fBxz\fP nunca descompacta mais de um fluxo de arquivos \fB.lzma\fP ou fluxos +brutos, mas esta opção ainda faz \fBxz\fP ignorar os possíveis dados +posteriores após o arquivo \fB.lzma\fP ou fluxo bruto. +.IP "" +Esta opção não tem efeito se o modo de operação não for \fB\-\-decompress\fP ou +\fB\-\-test\fP. +.IP "" +Since \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP implies \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Desativa a criação de arquivos esparsos. Por padrão, ao descompactar em um +arquivo normal, \fBxz\fP tenta tornar o arquivo esparso se os dados +descompactados contiverem longas sequências de zeros binários. Ele também +funciona ao gravar na saída padrão, desde que a saída padrão esteja +conectada a um arquivo normal e certas condições adicionais sejam atendidas +para torná\-la segura. A criação de arquivos esparsos pode economizar espaço +em disco e acelerar a descompactação, reduzindo a quantidade de E/S do +disco. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Ao compactar, usa \fI.suf\fP como sufixo para o arquivo de destino em vez de +\&\fB.xz\fP ou \fB.lzma\fP. Se não estiver gravando na saída padrão e o arquivo de +origem já tiver o sufixo \fI.suf\fP, um aviso será exibido e o arquivo será +ignorado. +.IP "" +Ao descompactar, reconhece arquivos com o sufixo \fI.suf\fP além de arquivos +com o sufixo \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP ou \fB.lz\fP . Se o arquivo de +origem tiver o sufixo \fI.suf\fP, o sufixo será removido para obter o nome do +arquivo de destino. +.IP "" +Ao compactar ou descompactar fluxos brutos (\fB\-\-format=raw\fP), o sufixo +sempre deve ser especificado, a menos que seja gravado na saída padrão, +porque não há sufixo padrão para fluxos brutos. +.TP +\fB\-\-files\fP[\fB=\fP\fIarquivo\fP] +Lê os nomes dos arquivos a serem processados em \fIarquivo\fP; se \fIarquivo\fP +for omitido, os nomes dos arquivos serão lidos da entrada padrão. Os nomes +de arquivo devem terminar com o caractere de nova linha. Um traço (\fB\-\fP) é +considerado um nome de arquivo regular; não significa entrada padrão. Se os +nomes de arquivo forem fornecidos também como argumentos de linha de +comando, eles serão processados antes da leitura dos nomes de arquivo de +\fIarquivo\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIarquivo\fP] +Isso é idêntico a \fB\-\-files\fP[\fB=\fP\fIarquivo\fP], exceto que cada nome de +arquivo deve ser finalizado com o caractere nulo. +. +.SS "Opções básicas de formato de arquivo e de compactação" +.TP +\fB\-F\fP \fIformato\fP, \fB\-\-format=\fP\fIformato\fP +Especifica o \fIformato\fP de arquivo para compactar ou descompactar: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Este é o padrão. Ao compactar, \fBauto\fP é equivalente a \fBxz\fP. Ao +descompactar, o formato do arquivo de entrada é detectado +automaticamente. Observe que os fluxos brutos (criados com \fB\-\-format=raw\fP) +não podem ser detectados automaticamente. +.TP +\fBxz\fP +Compacta no formato de arquivo \fB.xz\fP ou aceite apenas arquivos \fB.xz\fP ao +descompactar. +.TP +\fBlzma\fP, \fBalone\fP +Compacta no formato de arquivo legado \fB.lzma\fP ou aceite apenas arquivos +\&\fB.lzma\fP ao descompactar. O nome alternativo \fBalone\fP é fornecido para +compatibilidade com versões anteriores do LZMA Utils. +.TP +\fBlzip\fP +Aceita apenas arquivos \fB.lz\fP ao descompactar. Sem suporte a compactação. +.IP "" +The \fB.lz\fP format versions 0 and 1 are supported. Version 0 files were +produced by \fBlzip\fP 1.3 and older. Such files aren't common but may be +found from file archives as a few source packages were released in this +format. People might have old personal files in this format too. +Decompression support for the format version 0 was removed in \fBlzip\fP 1.18. +\fBlzip\fP 1.4 and later create files in the format version 1. +.TP +\fBraw\fP +Compacta ou descompacta um fluxo bruto (sem cabeçalhos). Isso é destinado +apenas a usuários avançados. Para decodificar fluxos brutos, você precisa +usar \fB\-\-format=raw\fP e especificar explicitamente a cadeia de filtros, que +normalmente seria armazenada nos cabeçalhos do contêiner. +.RE +.TP +\fB\-C\fP \fIverificação\fP, \fB\-\-check=\fP\fIverificação\fP +Especifica o tipo de verificação de integridade. A verificação é calculada a +partir dos dados descompactados e armazenados no arquivo \fB.xz\fP. Esta opção +tem efeito somente ao compactar no formato \fB.xz\fP; o formato \fB.lzma\fP não +oferece suporte a verificações de integridade. A verificação de integridade +(se for o caso) é verificada quando o arquivo \fB.xz\fP é descompactado. +.IP "" +Tipos de \fIverificação\fP suportados: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Não calcula uma verificação de integridade. Isso geralmente é uma má +ideia. Pode ser útil quando a integridade dos dados é verificada por outros +meios. +.TP +\fBcrc32\fP +Calcula CRC32 usando o polinômio do IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Calcula CRC64 usando o polinômio de ECMA\-182. Este é o padrão, pois é um +pouco melhor que o CRC32 na detecção de arquivos danificados e a diferença +de velocidade é insignificante. +.TP +\fBsha256\fP +Calcula SHA\-256. Isso é um pouco mais lento do que CRC32 e CRC64. +.RE +.IP "" +A integridade dos cabeçalhos de \fB.xz\fP é sempre verificada com CRC32. Não é +possível alterá\-la ou desativá\-la. +.TP +\fB\-\-ignore\-check\fP +Não confere a verificação de integridade dos dados compactados ao +descompactar. Os valores CRC32 nos cabeçalhos \fB.xz\fP ainda serão conferidos +normalmente. +.IP "" +\fBNão use esta opção a menos que saiba o que está fazendo.\fP Possíveis razões +para usar esta opção: +.RS +.IP \(bu 3 +Tentativa de recuperar dados de um arquivo .xz corrompido. +.IP \(bu 3 +Acelerar a descompactação. Isso é importante principalmente com SHA\-256 ou +com arquivos extremamente bem compactados. É recomendável não usar essa +opção para essa finalidade, a menos que a integridade do arquivo seja +verificada externamente de alguma outra forma. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Seleciona um nível de predefinição de compactação. O padrão é \fB\-6\fP. Se +vários níveis de predefinição forem especificados, o último terá efeito. Se +uma cadeia de filtro personalizada já foi especificada, especificar um nível +de predefinição de compactação limpa a cadeia de filtro personalizada. +.IP "" +As diferenças entre as predefinições são mais significativas do que com +\fBgzip\fP(1) e \fBbzip2\fP(1). As configurações de compactação selecionadas +determinam os requisitos de memória do descompactador, portanto, usar um +nível de predefinição muito alto pode dificultar a descompactação do arquivo +em um sistema antigo com pouca RAM. Especificamente, \fBnão é uma boa ideia usar cegamente \-9 para tudo\fP como costuma acontecer com \fBgzip\fP(1) e +\fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Estas são predefinições um tanto rápidas. \fB\-0\fP às vezes é mais rápida que +\fBgzip \-9\fP ao mesmo tempo que compacta muito melhor. As mais altas +geralmente têm velocidade comparável ao \fBbzip2\fP(1) com taxa de compactação +comparável ou melhor, embora os resultados dependam muito do tipo de dados +que estão sendo compactados. +.TP +\fB\-4\fP ... \fB\-6\fP +Compactação boa a muito boa, mantendo o uso de memória do descompactador +razoável mesmo para sistemas antigos. \fB\-6\fP é o padrão, que geralmente é uma +boa escolha para distribuir arquivos que precisam ser descompactáveis, mesmo +em sistemas com apenas 16\ MiB de RAM. (\fB\-5e\fP ou \fB\-6e\fP também vale a pena +considerar. Veja \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Eles são como \fB\-6\fP, mas com requisitos de memória de compressor e +descompressor mais altos. Eles são úteis apenas ao compactar arquivos +maiores que 8\ MiB, 16\ MiB e 32\ MiB, respectivamente. +.RE +.IP "" +No mesmo hardware, a velocidade de descompactação é aproximadamente um +número constante de bytes de dados compactados por segundo. Em outras +palavras, quanto melhor a compactação, mais rápida será a +descompactação. Isso também significa que a quantidade de saída não +compactada produzida por segundo pode variar muito. +.IP "" +A tabela a seguir resume os recursos das predefinições: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Predefinição;DicTam;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Descrições das colunas: +.RS +.IP \(bu 3 +DicTam é o tamanho do dicionário LZMA2. É desperdício de memória usar um +dicionário maior que o tamanho do arquivo descompactado. É por isso que é +bom evitar usar as predefinições \fB\-7\fP ... \fB\-9\fP quando não há real +necessidade deles. Em \fB\-6\fP e inferior, a quantidade de memória desperdiçada +geralmente é baixa o suficiente para não importar. +.IP \(bu 3 +CompCPU é uma representação simplificada das configurações LZMA2 que afetam +a velocidade de compactação. O tamanho do dicionário também afeta a +velocidade, portanto, embora o CompCPU seja o mesmo para os níveis \fB\-6\fP +\&... \fB\-9\fP, níveis mais altos ainda tendem a ser um pouco mais lentos. Para +obter uma compactação ainda mais lenta e possivelmente melhor, consulte +\fB\-\-extreme\fP. +.IP \(bu 3 +CompMem contains the compressor memory requirements in the single\-threaded +mode. It may vary slightly between \fBxz\fP versions. +.IP \(bu 3 +DecMem contém os requisitos de memória do descompactador. Ou seja, as +configurações de compactação determinam os requisitos de memória do +descompactador. O uso exato da memória do descompactador é um pouco maior do +que o tamanho do dicionário LZMA2, mas os valores na tabela foram +arredondados para o próximo MiB completo. +.RE +.IP "" +Memory requirements of the multi\-threaded mode are significantly higher than +that of the single\-threaded mode. With the default value of +\fB\-\-block\-size\fP, each thread needs 3*3*DictSize plus CompMem or DecMem. For +example, four threads with preset \fB\-6\fP needs 660\(en670\ MiB of memory. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Usa uma variante mais lenta do nível de predefinição de compactação +selecionado (\fB\-0\fP ... \fB\-9\fP) para obter uma taxa de compactação um pouco +melhor, mas, com azar, isso também pode piorar. O uso da memória do +descompressor não é afetado, mas o uso da memória do compactador aumenta um +pouco nos níveis de predefinição \fB\-0\fP ... \fB\-3\fP. +.IP "" +Como existem duas predefinições com tamanhos de dicionário 4\ MiB e 8\ MiB, +as predefinições \fB\-3e\fP e \fB\-5e\fP usam configurações um pouco mais rápidas +(CompCPU inferior) do que \fB\-4e\fP e \fB\-6e\fP, respectivamente. Dessa forma, não +há duas predefinições idênticas. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Predefinição;DicTam;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Por exemplo, há um total de quatro predefinições que usam o dicionário 8\ MiB, cuja ordem do mais rápido ao mais lento é \fB\-5\fP, \fB\-6\fP, \fB\-5e\fP e +\fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Esses são apelidos um tanto enganosos para \fB\-0\fP e \fB\-9\fP, +respectivamente. Eles são fornecidos apenas para compatibilidade com versões +anteriores do LZMA Utils. Evite usar essas opções. +.TP +\fB\-\-block\-size=\fP\fItamanho\fP +Ao compactar para o formato \fB.xz\fP, divida os dados de entrada em blocos de +\fItamanho\fP bytes. Os blocos são compactados independentemente uns dos +outros, o que ajuda no multi\-threading e torna possível a descompactação +limitada de acesso aleatório. Essa opção normalmente é usada para substituir +o tamanho de bloco padrão no modo multi\-thread, mas também pode ser usada em +thread única. +.IP "" +In multi\-threaded mode about three times \fIsize\fP bytes will be allocated in +each thread for buffering input and output. The default \fIsize\fP is three +times the LZMA2 dictionary size or 1 MiB, whichever is more. Typically a +good value is 2\(en4 times the size of the LZMA2 dictionary or at least 1 +MiB. Using \fIsize\fP less than the LZMA2 dictionary size is waste of RAM +because then the LZMA2 dictionary buffer will never get fully used. In +multi\-threaded mode, the sizes of the blocks are stored in the block +headers. This size information is required for multi\-threaded +decompression. +.IP "" +In single\-threaded mode no block splitting is done by default. Setting this +option doesn't affect memory usage. No size information is stored in block +headers, thus files created in single\-threaded mode won't be identical to +files created in multi\-threaded mode. The lack of size information also +means that \fBxz\fP won't be able decompress the files in multi\-threaded mode. +.TP +\fB\-\-block\-list=\fP\fIitems\fP +When compressing to the \fB.xz\fP format, start a new block with an optional +custom filter chain after the given intervals of uncompressed data. +.IP "" +The \fIitems\fP are a comma\-separated list. Each item consists of an optional +filter chain number between 0 and 9 followed by a colon (\fB:\fP) and a +required size of uncompressed data. Omitting an item (two or more +consecutive commas) is a shorthand to use the size and filters of the +previous item. +.IP "" +If the input file is bigger than the sum of the sizes in \fIitems\fP, the last +item is repeated until the end of the file. A special value of \fB0\fP may be +used as the last size to indicate that the rest of the file should be +encoded as a single block. +.IP "" +An alternative filter chain for each block can be specified in combination +with the \fB\-\-filters1=\fP\fIfilters\fP \&...\& \fB\-\-filters9=\fP\fIfilters\fP options. +These options define filter chains with an identifier between 1\(en9. +Filter chain 0 can be used to refer to the default filter chain, which is +the same as not specifying a filter chain. The filter chain identifier can +be used before the uncompressed size, followed by a colon (\fB:\fP). For +example, if one specifies \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP +then blocks will be created using: +.RS +.IP \(bu 3 +The filter chain specified by \fB\-\-filters1\fP and 2 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters3\fP and 2 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters2\fP and 4 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters2\fP and 4 MiB input +.IP \(bu 3 +The default filter chain and 2 MiB input +.IP \(bu 3 +The default filter chain and 4 MiB input for every block until end of input. +.RE +.IP "" +If one specifies a size that exceeds the encoder's block size (either the +default value in threaded mode or the value specified with +\fB\-\-block\-size=\fP\fIsize\fP), the encoder will create additional blocks while +keeping the boundaries specified in \fIitems\fP. For example, if one specifies +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP and the +input file is 80 MiB, one will get 11 blocks: 5, 10, 8, 10, 2, 10, 10, 4, +10, 10, and 1 MiB. +.IP "" +No modo multi\-thread, os tamanhos dos blocos são armazenados nos cabeçalhos +dos blocos. Isso não é feito no modo de thread única, portanto, a saída +codificada não será idêntica à do modo multi\-thread. +.TP +\fB\-\-flush\-timeout=\fP\fItempo_limite\fP +Ao compactar, se mais de \fItempo_limite\fP milissegundos (um número inteiro +positivo) se passaram desde a liberação anterior e a leitura de mais entrada +seria bloqueada, todos os dados de entrada pendentes serão liberados do +codificador e disponibilizados no fluxo de saída. Isso pode ser útil se +\fBxz\fP for usado para compactar dados transmitidos por uma rede. Valores +\fItempo_limite\fP pequenos tornam os dados disponíveis na extremidade +receptora com um pequeno atraso, mas valores \fItempo_limite\fP grandes +oferecem melhor taxa de compactação. +.IP "" +Esse recurso está desabilitado por padrão. Se esta opção for especificada +mais de uma vez, a última terá efeito. O valor especial \fItempo_limite\fP de +\fB0\fP pode ser usado para desabilitar explicitamente esse recurso. +.IP "" +Este recurso não está disponível em sistemas não\-POSIX. +.IP "" +.\" FIXME +\fBEste recurso ainda é experimental.\fP Atualmente, \fBxz\fP não é adequado para +descompactar o fluxo em tempo real devido à forma como \fBxz\fP faz o buffer. +.TP +\fB\-\-no\-sync\fP +Do not synchronize the target file and its directory to the storage device +before removing the source file. This can improve performance if +compressing or decompressing many small files. However, if the system +crashes soon after the deletion, it is possible that the target file was not +written to the storage device but the delete operation was. In that case +neither the original source file nor the target file is available. +.IP "" +This option has an effect only when \fBxz\fP is going to remove the source +file. In other cases synchronization is never done. +.IP "" +The synchronization and \fB\-\-no\-sync\fP were added in \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIlimite\fP +Define um limite de uso de memória para compactação. Se esta opção for +especificada várias vezes, a última entrará em vigor. +.IP "" +Se as configurações de compactação excederem o \fIlimite\fP, \fBxz\fP tentará +ajustar as configurações para baixo para que o limite não seja mais excedido +e exibirá um aviso de que o ajuste automático foi feito. Os ajustes são +feitos nesta ordem: reduzindo o número de encadeamentos, alternando para o +modo sigle\-thread se até mesmo uma thread no modo multi\-thread exceder o +\fIlimite\fP e, finalmente, reduzindo o tamanho do dicionário LZMA2. +.IP "" +Ao compactar com \fB\-\-format=raw\fP ou se \fB\-\-no\-adjust\fP tiver sido +especificado, apenas o número de threads pode ser reduzido, pois isso pode +ser feito sem afetar a saída compactada. +.IP "" +Se o \fIlimite\fP não puder ser alcançado mesmo com os ajustes descritos acima, +um erro será exibido e \fBxz\fP sairá com status de saída 1. +.IP "" +O \fIlimite\fP pode ser especificado de várias maneiras: +.RS +.IP \(bu 3 +O \fIlimite\fP pode ser um valor absoluto em bytes. Usar um sufixo inteiro como +\fBMiB\fP pode ser útil. Exemplo: \fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +O \fIlimite\fP pode ser especificado como uma porcentagem da memória física +total (RAM). Isso pode ser útil especialmente ao definir a variável de +ambiente \fBXZ_DEFAULTS\fP em um script de inicialização de shell que é +compartilhado entre diferentes computadores. Dessa forma o limite é +automaticamente maior em sistemas com mais memória. Exemplo: +\fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +O \fIlimite\fP pode ser redefinido para seu valor padrão, definindo\-o como +\fB0\fP. Atualmente, isso equivale a definir \fIlimite\fP como \fBmax\fP (sem limite +de uso de memória). +.RE +.IP "" +Para \fBxz\fP de 32 bits, há um caso especial: se o \fIlimite\fP estiver acima de +\fB4020\ MiB\fP, o \fIlimite\fP é definido como \fB4020\ MiB\fP. No MIPS32 \fB2000\ MiB\fP é usado em seu lugar. (Os valores \fB0\fP e \fBmax\fP não são afetados por +isso. Um recurso semelhante não existe para descompactação.) Isso pode ser +útil quando um executável de 32 bits tem acesso a espaço de endereço de 4\ GiB (2 GiB no MIPS32) enquanto espero não causar danos em outras situações. +.IP "" +Consulte também a seção \fBUso de memória\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIlimite\fP +Define um limite de uso de memória para descompactação. Isso também afeta o +modo \fB\-\-list\fP. Se a operação não for possível sem exceder o \fIlimite\fP, +\fBxz\fP exibirá um erro e a descompactação do arquivo falhará. Consulte +\fB\-\-memlimit\-compress=\fP\fIlimite\fP para possíveis maneiras de especificar o +\fIlimite\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimite\fP +Define um limite de uso de memória para descompactação multi\-thread. Isso +pode afetar apenas o número de threads; isso nunca fará com que \fBxz\fP se +recuse a descompactar um arquivo. Se \fIlimite\fP for muito baixo para permitir +qualquer multi\-thread, o \fIlimite\fP será ignorado e \fBxz\fP continuará no modo +de thread única. Observe que se \fB\-\-memlimit\-decompress\fP também for usado, +ele sempre se aplicará aos modos de thread única e multi\-thread e, portanto, +o \fIlimite\fP efetivo para multi\-threading nunca será maior que o limite +definido com \fB\-\-memlimit\-decompress\fP. +.IP "" +Em contraste com as outras opções de limite de uso de memória, +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimite\fP tem um padrão \fIlimite\fP específico do +sistema. \fBxz \-\-info\-memory\fP pode ser usado para ver o valor atual. +.IP "" +Esta opção e seu valor padrão existem porque, sem qualquer limite, o +descompactador usando threads pode acabar alocando uma quantidade insana de +memória com alguns arquivos de entrada. Se o \fIlimite\fP padrão for muito +baixo em seu sistema, sinta\-se à vontade para aumentar o \fIlimite\fP, mas +nunca defina\-o para um valor maior que a quantidade de RAM utilizável, pois +com os arquivos de entrada apropriados \fBxz\fP tentará usar essa quantidade de +memória mesmo com um baixo número de threads. Ficar sem memória ou trocar +não melhorará o desempenho da descompactação. +.IP "" +Consulte \fB\-\-memlimit\-compress=\fP\fIlimite\fP para possíveis maneiras de +especificar o \fIlimite\fP. Definir \fIlimite\fP como \fB0\fP redefine \fIlimite\fP para +o valor padrão específico do sistema. +.TP +\fB\-M\fP \fIlimite\fP, \fB\-\-memlimit=\fP\fIlimite\fP, \fB\-\-memory=\fP\fIlimite\fP +Isso é equivalente a especificar \fB\-\-memlimit\-compress=\fP\fIlimite\fP +\fB\-\-memlimit\-decompress=\fP\fIlimite\fP \fB\-\-memlimit\-mt\-decompress=\fP\fIlimite\fP. +.TP +\fB\-\-no\-adjust\fP +Exibe um erro e saia se o limite de uso de memória não puder ser atendido +sem ajustar as configurações que afetam a saída compactada. Ou seja, isso +evita que \fBxz\fP alterne o codificador do modo multi\-thread para o modo +encadeado único e reduza o tamanho do dicionário LZMA2. Mesmo quando esta +opção é usada, o número de threads pode ser reduzido para atender ao limite +de uso de memória, pois isso não afetará a saída compactada. +.IP "" +O ajuste automático é sempre desativado ao criar fluxos brutos +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fIthreads\fP, \fB\-\-threads=\fP\fIthreads\fP +Especifica o número de threads de trabalho a serem usados. Definir +\fIthreads\fP para um valor especial \fB0\fP faz com que \fBxz\fP use tantos threads +quanto o(s) processador(es) no suporte do sistema. O número real de +encadeamentos pode ser menor que \fIthreads\fP se o arquivo de entrada não for +grande o suficiente para subdividir em threads com as configurações +fornecidas ou se o uso de mais threads exceder o limite de uso de memória. +.IP "" +Os compactadores usando thread única e várias threads produzem saídas +diferentes. O compactador de thread única fornecerá o menor tamanho de +arquivo, mas apenas a saída do compactador de várias threads pode ser +descompactada usando várias threads. Definir \fIthreads\fP como \fB1\fP usará o +modo de thread única. Definir \fIthreads\fP para qualquer outro valor, +incluindo \fB0\fP, usará o compressor de várias threads, mesmo que o sistema +tenha suporte a apenas uma thread de hardware. (\fBxz\fP 5.2.x usou o modo de +thread única nesta situação.) +.IP "" +Para usar o modo de várias threads com apenas uma thread, defina \fIthreads\fP +como \fB+1\fP. O prefixo \fB+\fP não tem efeito com valores diferentes de \fB1\fP. Um +limite de uso de memória ainda pode fazer \fBxz\fP alternar para o modo de +thread única, a menos que \fB\-\-no\-adjust\fP seja usado. O suporte para o +prefixo \fB+\fP foi adicionado no \fBxz\fP 5.4.0. +.IP "" +Se um número automático de threads foi solicitado e nenhum limite de uso de +memória foi especificado, um limite flexível padrão específico do sistema +será usado para possivelmente limitar o número de threads. É um limite +flexível no sentido de que é ignorado se o número de threads se tornar um, +portanto, um limite flexível nunca impedirá \fBxz\fP de compactar ou +descompactar. Este limite flexível padrão não fará com que \fBxz\fP alterne do +modo de várias threads para o modo de thread única. Os limites ativos podem +ser vistos com \fBxz \-\-info\-memory\fP. +.IP "" +Atualmente, o único método de threading é dividir a entrada em blocos e +comprimi\-los independentemente um do outro. O tamanho padrão do bloco +depende do nível de compactação e pode ser substituído com a opção +\fB\-\-block\-size=\fP\fItamanho\fP. +.IP "" +A descompactação em threads funciona apenas em arquivos que contêm vários +blocos com informações de tamanho nos cabeçalhos dos blocos. Todos os +arquivos grandes o suficiente compactados no modo de várias thread atendem a +essa condição, mas os arquivos compactados no modo de thread única não +atendem, mesmo se \fB\-\-block\-size=\fP\fItamanho\fP tiver sido usado. +.IP "" +The default value for \fIthreads\fP is \fB0\fP. In \fBxz\fP 5.4.x and older the +default is \fB1\fP. +. +.SS "Cadeias de filtro de compressor personalizadas" +Uma cadeia de filtro personalizada permite especificar as configurações de +compactação em detalhes, em vez de confiar nas configurações associadas às +predefinições. Quando uma cadeia de filtro personalizada é especificada, as +opções predefinidas (\fB\-0\fP \&...\& \fB\-9\fP e \fB\-\-extreme\fP) anteriores na linha +de comando são esquecidas. Se uma opção predefinida for especificada após +uma ou mais opções de cadeia de filtros personalizados, a nova predefinição +entrará em vigor e as opções de cadeia de filtros personalizados +especificadas anteriormente serão esquecidas. +.PP +Uma cadeia de filtro é comparável à tubulação na linha de comando. Ao +compactar, a entrada descompactada vai para o primeiro filtro, cuja saída +vai para o próximo filtro (se houver). A saída do último filtro é gravada no +arquivo compactado. O número máximo de filtros na cadeia é quatro, mas +normalmente uma cadeia de filtros tem apenas um ou dois filtros. +.PP +Muitos filtros têm limitações sobre onde podem estar na cadeia de filtros: +alguns filtros podem funcionar apenas como o último filtro na cadeia, alguns +apenas como filtro não\-último e alguns funcionam em qualquer posição na +cadeia. Dependendo do filtro, essa limitação é inerente ao projeto do filtro +ou existe para evitar problemas de segurança. +.PP +A custom filter chain can be specified in two different ways. The options +\fB\-\-filters=\fP\fIfilters\fP and \fB\-\-filters1=\fP\fIfilters\fP \&...\& +\fB\-\-filters9=\fP\fIfilters\fP allow specifying an entire filter chain in one +option using the liblzma filter string syntax. Alternatively, a filter +chain can be specified by using one or more individual filter options in the +order they are wanted in the filter chain. That is, the order of the +individual filter options is significant! When decoding raw streams +(\fB\-\-format=raw\fP), the filter chain must be specified in the same order as +it was specified when compressing. Any individual filter or preset options +specified before the full chain option (\fB\-\-filters=\fP\fIfilters\fP) will be +forgotten. Individual filters specified after the full chain option will +reset the filter chain. +.PP +Both the full and individual filter options take filter\-specific \fIoptions\fP +as a comma\-separated list. Extra commas in \fIoptions\fP are ignored. Every +option has a default value, so specify those you want to change. +.PP +Para ver toda a cadeia de filtros e \fIopções\fP, use \fBxz \-vv\fP (isto é, use +\fB\-\-verbose\fP duas vezes). Isso também funciona para visualizar as opções da +cadeia de filtros usadas pelas predefinições. +.TP +\fB\-\-filters=\fP\fIfilters\fP +Specify the full filter chain or a preset in a single option. Each filter +can be separated by spaces or two dashes (\fB\-\-\fP). \fIfilters\fP may need to be +quoted on the shell command line so it is parsed as a single option. To +denote \fIoptions\fP, use \fB:\fP or \fB=\fP. A preset can be prefixed with a \fB\-\fP +and followed with zero or more flags. The only supported flag is \fBe\fP to +apply the same options as \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIfilters\fP ... \fB\-\-filters9\fP=\fIfilters\fP +Specify up to nine additional filter chains that can be used with +\fB\-\-block\-list\fP. +.IP "" +For example, when compressing an archive with executable files followed by +text files, the executable part could use a filter chain with a BCJ filter +and the text part only the LZMA2 filter. +.TP +\fB\-\-filters\-help\fP +Display a help message describing how to specify presets and custom filter +chains in the \fB\-\-filters\fP and \fB\-\-filters1=\fP\fIfilters\fP \&...\& +\fB\-\-filters9=\fP\fIfilters\fP options, and exit successfully. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIopções\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIopções\fP] +.PD +Adiciona o filtro LZMA1 ou LZMA2 à cadeia de filtros. Esses filtros podem +ser usados apenas como o último filtro na cadeia. +.IP "" +LZMA1 é um filtro legado, que é suportado quase exclusivamente devido ao +formato de arquivo legado \fB.lzma\fP, que suporta apenas LZMA1. LZMA2 é uma +versão atualizada do LZMA1 para corrigir alguns problemas práticos do +LZMA1. O formato \fB.xz\fP usa LZMA2 e não suporta LZMA1. A velocidade de +compactação e as proporções de LZMA1 e LZMA2 são praticamente as mesmas. +.IP "" +LZMA1 e LZMA2 compartilham o mesmo conjunto de \fIopções\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIpredefinição\fP +Redefine todas as \fIopções\fP de LZMA1 ou LZMA2 para +\fIpredefinição\fP. \fIPredefinição\fP consiste em um número inteiro, que pode ser +seguido por modificadores de predefinição de uma única letra. O inteiro pode +ser de \fB0\fP a \fB9\fP, correspondendo às opções de linha de comando \fB\-0\fP +\&...\& \fB\-9\fP. O único modificador suportado atualmente é \fBe\fP, que +corresponde a \fB\-\-extreme\fP. Se nenhum \fBpreset\fP for especificado, os valores +padrão das \fIopções\fP LZMA1 ou LZMA2 serão obtidos da predefinição \fB6\fP. +.TP +\fBdict=\fP\fItamanho\fP +O \fItamanho\fP do dicionário (buffer de histórico) indica quantos bytes dos +dados não compactados processados recentemente são mantidos na memória. O +algoritmo tenta encontrar sequências de bytes repetidos (correspondências) +nos dados não compactados e substituí\-los por referências aos dados +atualmente no dicionário. Quanto maior o dicionário, maior a chance de +encontrar uma correspondência. Portanto, aumentar o dicionário \fItamanho\fP +geralmente melhora a taxa de compactação, mas um dicionário maior que o +arquivo não compactado é um desperdício de memória. +.IP "" +Um \fItamanho\fP de dicionário típico é de 64\ KiB a 64\ MiB. O mínimo é 4\ KiB. O máximo para compactação é atualmente 1,5\ GiB (1536\ MiB). O +descompactador já oferece suporte a dicionários de até um byte a menos de 4\ GiB, que é o máximo para os formatos de fluxo LZMA1 e LZMA2. +.IP "" +O \fItamanho\fP de dicionário e o localizador de correspondência (\fImf\fP) juntos +determinam o uso de memória do codificador LZMA1 ou LZMA2. O mesmo (ou +maior) \fItamanho\fP de dicionário é necessário para descompactar que foi usado +durante a compactação, portanto, o uso de memória do decodificador é +determinado pelo tamanho do dicionário usado durante a compactação. Os +cabeçalhos \fB.xz\fP armazenam o \fItamanho\fP de dicionário como 2^\fIn\fP ou 2^\fIn\fP ++ 2^(\fIn\fP\-1), então esses \fItamanhos\fP são um tanto preferidos para +compactação. Outros \fItamanhos\fP serão arredondados quando armazenados nos +cabeçalhos \fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Especifica o número de bits de contexto literais. O mínimo é 0 e o máximo é +4; o padrão é 3. Além disso, a soma de \fIlc\fP e \fIlp\fP não deve exceder 4. +.IP "" +Todos os bytes que não podem ser codificados como correspondências são +codificados como literais. Ou seja, literais são simplesmente bytes de 8 +bits que são codificados um de cada vez. +.IP "" +A codificação literal assume que os bits \fIlc\fP mais altos do byte não +compactado anterior se correlacionam com o próximo byte. Por exemplo, em um +texto típico em inglês, uma letra maiúscula geralmente é seguida por uma +letra minúscula, e uma letra minúscula geralmente é seguida por outra letra +minúscula. No conjunto de caracteres US\-ASCII, os três bits mais altos são +010 para letras maiúsculas e 011 para letras minúsculas. Quando \fIlc\fP é pelo +menos 3, a codificação literal pode aproveitar essa propriedade nos dados +não compactados. +.IP "" +O valor padrão (3) geralmente é bom. Se você deseja compactação máxima, +experimente \fBlc=4\fP. Às vezes ajuda um pouco, às vezes piora a +compactação. Se piorar, experimente \fBlc=2\fP também. +.TP +\fBlp=\fP\fIlp\fP +Especifica o número de bits de posição literal. O mínimo é 0 e o máximo é 4; +o padrão é 0. +.IP "" +\fILp\fP afeta que tipo de alinhamento nos dados não compactados é assumido ao +codificar literais. Consulte \fIpb\fP abaixo para obter mais informações sobre +alinhamento. +.TP +\fBpb=\fP\fIpb\fP +Especifica o número de bits de posição. O mínimo é 0 e o máximo é 4; o +padrão é 2. +.IP "" +\fIPb\fP afeta que tipo de alinhamento nos dados não compactados é assumido em +geral. O padrão significa alinhamento de quatro bytes (2^\fIpb\fP=2^2=4), que +geralmente é uma boa escolha quando não há melhor estimativa. +.IP "" +Quando o alinhamento é conhecido, definir \fIpb\fP adequadamente pode reduzir +um pouco o tamanho do arquivo. Por exemplo, com arquivos de texto com +alinhamento de um byte (US\-ASCII, ISO\-8859\-*, UTF\-8), a configuração \fBpb=0\fP +pode melhorar um pouco a compactação. Para texto UTF\-16, \fBpb=1\fP é uma boa +escolha. Se o alinhamento for um número ímpar como 3 bytes, \fBpb=0\fP pode ser +a melhor escolha. +.IP "" +Embora o alinhamento assumido possa ser ajustado com \fIpb\fP e \fIlp\fP, LZMA1 e +LZMA2 ainda favorecem ligeiramente o alinhamento de 16 bytes. Pode valer a +pena levar em consideração ao projetar formatos de arquivo que provavelmente +serão compactados com LZMA1 ou LZMA2. +.TP +\fBmf=\fP\fImf\fP +O localizador de correspondência tem um efeito importante na velocidade do +codificador, uso de memória e taxa de compactação. Normalmente, os +localizadores de correspondência de Hash Chain são mais rápidos do que os +localizadores de correspondência de árvore binária. O padrão depende do +\fIpredefinição\fP: 0 usa \fBhc3\fP, 1\(en3 usa \fBhc4\fP e o resto usa \fBbt4\fP. +.IP "" +Os seguintes localizadores de correspondência são suportados. As fórmulas de +uso de memória abaixo são aproximações aproximadas, que estão mais próximas +da realidade quando \fIdict\fP é uma potência de dois. +.RS +.TP +\fBhc3\fP +Cadeia de hashs com hashing de 2 e 3 bytes +.br +Valor mínimo para \fInice\fP: 3 +.br +Uso de memória: +.br +\fIdict\fP * 7.5 (if \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 5.5 + 64 MiB (if \fIdict\fP > 16 MiB) +.TP +\fBhc4\fP +Cadeia de hashs com hashing de 2, 3 e 4 bytes +.br +Valor mínimo para \fInice\fP: 4 +.br +Uso de memória: +.br +\fIdict\fP * 7.5 (if \fIdict\fP <= 32 MiB); +.br +\fIdict\fP * 6.5 (if \fIdict\fP > 32 MiB) +.TP +\fBbt2\fP +Árvore binária com hashing de 2 bytes +.br +Valor mínimo para \fInice\fP: 2 +.br +Uso de memória: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Árvore binária com hashing de 2 e 3 bytes +.br +Valor mínimo para \fInice\fP: 3 +.br +Uso de memória: +.br +\fIdict\fP * 11.5 (if \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 9.5 + 64 MiB (if \fIdict\fP > 16 MiB) +.TP +\fBbt4\fP +Árvore binária com hashing de 2, 3 e 4 bytes +.br +Valor mínimo para \fInice\fP: 4 +.br +Uso de memória: +.br +\fIdict\fP * 11.5 (if \fIdict\fP <= 32 MiB); +.br +\fIdict\fP * 10.5 (if \fIdict\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fImodo\fP +O \fImodo\fP de compactação especifica o método para analisar os dados +produzidos pelo localizador de correspondência. Os \fImodos\fP suportados são +\fBfast\fP e \fBnormal\fP. O padrão é \fBfast\fP para \fIpredefinições\fP 0\(en3 e +\fBnormal\fP para \fIpredefinições\fP 4\(en9. +.IP "" +Normalmente, \fBfast\fP é usado com localizadores de correspondência cadeia de +hashs e \fBnormal\fP com localizadores de correspondência de árvore +binária. Isso também é o que os \fIpredefinições\fP fazem. +.TP +\fBnice=\fP\fInice\fP +Especifica o que é considerado um bom comprimento para uma +correspondência. Uma vez que uma correspondência de pelo menos \fInice\fP bytes +é encontrada, o algoritmo para de procurar correspondências possivelmente +melhores. +.IP "" +\fINice\fP pode ser 2\(en273 bytes. Valores mais altos tendem a fornecer melhor +taxa de compactação em detrimento da velocidade. O padrão depende do +\fIpredefinição\fP. +.TP +\fBdepth=\fP\fIprofundidade\fP +Especifica a profundidade máxima de pesquisa no localizador de +correspondências. O padrão é o valor especial de 0, que faz com que o +compressor determine um \fIprofundidade\fP razoável de \fImf\fP e \fInice\fP. +.IP "" +Uma \fIprofundidade\fP razoável para cadeias de hash é 4\(en100 e 16\(en1000 +para árvores binárias. Usar valores muito altos para \fIprofundidade\fP pode +tornar o codificador extremamente lento com alguns arquivos. Evite definir +\fIprofundidade\fP acima de 1000 a menos que você esteja preparado para +interromper a compactação caso ela esteja demorando muito. +.RE +.IP "" +Ao decodificar fluxos brutos (\fB\-\-format=raw\fP), o LZMA2 precisa apenas do +dicionário \fItamanho\fP. LZMA1 também precisa de \fIlc\fP, \fIlp\fP e \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIopções\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIopções\fP] +.PD +Adiciona um filtro de ramificação/chamada/salto (BCJ) à cadeia de +filtros. Esses filtros podem ser usados apenas como um filtro não último na +cadeia de filtros. +.IP "" +Um filtro BCJ converte endereços relativos no código de máquina em suas +contrapartes absolutas. Isso não altera o tamanho dos dados, mas aumenta a +redundância, o que pode ajudar o LZMA2 a produzir um arquivo \fB.xz\fP 0\(en15\ % menor. Os filtros BCJ são sempre reversíveis, portanto, usar um filtro BCJ +para o tipo errado de dados não causa nenhuma perda de dados, embora possa +piorar um pouco a taxa de compactação.Os filtros BCJ são muito rápidos e +usam uma quantidade insignificante de memória. +.IP "" +Esses filtros BCJ têm problemas conhecidos relacionados à taxa de +compactação: +.RS +.IP \(bu 3 +Alguns tipos de arquivos contendo código executável (por exemplo, arquivos +de objeto, bibliotecas estáticas e módulos do kernel do Linux) têm os +endereços nas instruções preenchidos com valores de preenchimento. Esses +filtros BCJ ainda vão fazer a conversão de endereço, o que vai piorar a +compactação desses arquivos. +.IP \(bu 3 +Se um filtro BCJ for aplicado em um arquivo, é possível que isso torne a +taxa de compactação pior do que não usar um filtro BCJ. Por exemplo, se +houver executáveis semelhantes ou mesmo idênticos, a filtragem provavelmente +tornará os arquivos menos semelhantes e, portanto, a compactação será +pior. O conteúdo de arquivos não executáveis no mesmo arquivo também pode +ser importante. Na prática tem que tentar com e sem filtro BCJ para ver qual +é melhor em cada situação. +.RE +.IP "" +Conjuntos de instruções diferentes têm alinhamento diferente: o arquivo +executável deve ser alinhado a um múltiplo desse valor nos dados de entrada +para fazer o filtro funcionar. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filtro;Alinhamento;Observações +x86;1;x86 32 bits ou 64 bits +ARM;4; +ARM\-Thumb;2; +ARM64;4;Alinhamento de 4096 bytes +;;é melhor +PowerPC;4;Somente big endian +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Since the BCJ\-filtered data is usually compressed with LZMA2, the +compression ratio may be improved slightly if the LZMA2 options are set to +match the alignment of the selected BCJ filter. Examples: +.RS +.IP \(bu 3 +IA\-64 filter has 16\-byte alignment so \fBpb=4,lp=4,lc=0\fP is good with LZMA2 +(2^4=16). +.IP \(bu 3 +RISC\-V code has 2\-byte or 4\-byte alignment depending on whether the file +contains 16\-bit compressed instructions (the C extension). When 16\-bit +instructions are used, \fBpb=2,lp=1,lc=3\fP or \fBpb=1,lp=1,lc=3\fP is good. When +16\-bit instructions aren't present, \fBpb=2,lp=2,lc=2\fP is the best. +\fBreadelf \-h\fP can be used to check if "RVC" appears on the "Flags" line. +.IP \(bu 3 +ARM64 is always 4\-byte aligned so \fBpb=2,lp=2,lc=2\fP is the best. +.IP \(bu 3 +The x86 filter is an exception. It's usually good to stick to LZMA2's +defaults (\fBpb=2,lp=0,lc=3\fP) when compressing x86 executables. +.RE +.IP "" +Todos os filtros BCJ suportam as mesmas \fIopções\fP: +.RS +.TP +\fBstart=\fP\fIdeslocamento\fP +Especifica o \fIdeslocamento\fP inicial que é usado na conversão entre +endereços relativos e absolutos. O \fIdeslocamento\fP deve ser um múltiplo do +alinhamento do filtro (ver tabela acima). O padrão é zero. Na prática, o +padrão é bom; especificar um \fIdeslocamento\fP personalizado quase nunca é +útil. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIopções\fP] +Adiciona o filtro Delta à cadeia de filtros. O filtro Delta só pode ser +usado como filtro não\-último na cadeia de filtros. +.IP "" +Atualmente, apenas o cálculo simples de delta byte a byte é suportado. Pode +ser útil ao compactar, por exemplo, imagens bitmap não compactadas ou áudio +PCM não compactado. No entanto, algoritmos de propósito especial podem +fornecer resultados significativamente melhores do que Delta + LZMA2. Isso é +verdade especialmente com áudio, que compacta mais rápido e melhor, por +exemplo, com \fBflac\fP(1). +.IP "" +\fIOpções\fP suportadas: +.RS +.TP +\fBdist=\fP\fIdistância\fP +Especifica a \fIdistância\fP do cálculo delta em bytes. \fIdistância\fP deve ser +1\(en256. O padrão é 1. +.IP "" +Por exemplo, com \fBdist=2\fP e entrada de oito bytes A1 B1 A2 B3 A3 B5 A4 B7, +a saída será A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Outras opções" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Suprime avisos e avisos. Especifique isso duas vezes para suprimir erros +também. Esta opção não tem efeito no status de saída. Ou seja, mesmo que um +aviso tenha sido suprimido, o status de saída para indicar um aviso ainda é +usado. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Ser detalhado. Se o erro padrão estiver conectado a um terminal, \fBxz\fP +exibirá um indicador de progresso. Especifique \fB\-\-verbose\fP duas vezes dará +uma saída ainda mais detalhada. +.IP "" +O indicador de progresso mostra as seguintes informações: +.RS +.IP \(bu 3 +A porcentagem de conclusão é mostrada se o tamanho do arquivo de entrada for +conhecido. Ou seja, a porcentagem não pode ser mostrada em encadeamentos +(pipe). +.IP \(bu 3 +Quantidade de dados compactados produzidos (compactando) ou consumidos +(descompactando). +.IP \(bu 3 +Quantidade de dados não compactados consumidos (compactação) ou produzidos +(descompactação). +.IP \(bu 3 +Taxa de compactação, que é calculada dividindo a quantidade de dados +compactados processados até o momento pela quantidade de dados não +compactados processados até o momento. +.IP \(bu 3 +Velocidade de compactação ou descompactação. Isso é medido como a quantidade +de dados não compactados consumidos (compactação) ou produzidos +(descompactação) por segundo. É mostrado após alguns segundos desde que +\fBxz\fP começou a processar o arquivo. +.IP \(bu 3 +Tempo decorrido no formato M:SS ou H:MM:SS. +.IP \(bu 3 +O tempo restante estimado é mostrado apenas quando o tamanho do arquivo de +entrada é conhecido e alguns segundos já se passaram desde que \fBxz\fP começou +a processar o arquivo. A hora é mostrada em um formato menos preciso que +nunca tem dois pontos, por exemplo, 2 min 30 s. +.RE +.IP "" +Quando o erro padrão não é um terminal, \fB\-\-verbose\fP fará com que \fBxz\fP +imprima o nome do arquivo, tamanho compactado, tamanho não compactado, taxa +de compactação e possivelmente também a velocidade e o tempo decorrido em +uma única linha para o erro padrão após a compactação ou descompactando o +arquivo. A velocidade e o tempo decorrido são incluídos apenas quando a +operação leva pelo menos alguns segundos. Se a operação não foi concluída, +por exemplo, devido à interrupção do usuário, também é impressa a +porcentagem de conclusão se o tamanho do arquivo de entrada for conhecido. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Não define o status de saída como 2, mesmo que uma condição digna de um +aviso tenha sido detectada. Esta opção não afeta o nível de detalhamento, +portanto, tanto \fB\-\-quiet\fP quanto \fB\-\-no\-warn\fP devem ser usados para não +exibir avisos e não alterar o status de saída. +.TP +\fB\-\-robot\fP +Imprime mensagens em um formato analisável por máquina. Isso visa facilitar +a criação de frontends que desejam usar \fBxz\fP em vez de liblzma, o que pode +ser o caso de vários scripts. A saída com esta opção habilitada deve ser +estável em versões \fBxz\fP. Consulte a seção \fBMODO ROBÔ\fP para obter detalhes. +.TP +\fB\-\-info\-memory\fP +Exibe, em formato legível por humanos, quanta memória física (RAM) e quantos +threads de processador \fBxz\fP acredita que o sistema possui e os limites de +uso de memória para compactação e descompactação e saia com êxito. +.TP +\fB\-h\fP, \fB\-\-help\fP +Exibe uma mensagem de ajuda descrevendo as opções mais usadas e sai com +sucesso. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Exibe uma mensagem de ajuda descrevendo todos os recursos de \fBxz\fP e sai com +sucesso +.TP +\fB\-V\fP, \fB\-\-version\fP +Exibe o número da versão de \fBxz\fP e liblzma em formato legível por +humanos. Para obter uma saída analisável por máquina, especifique \fB\-\-robot\fP +antes de \fB\-\-version\fP. +. +.SH "MODO ROBÔ" +The robot mode is activated with the \fB\-\-robot\fP option. It makes the output +of \fBxz\fP easier to parse by other programs. Currently \fB\-\-robot\fP is +supported only together with \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, +and \fB\-\-version\fP. It will be supported for compression and decompression in +the future. +. +.SS "Modo lista" +\fBxz \-\-robot \-\-list\fP usa saída separada por tabulações. A primeira coluna de +cada linha possui uma string que indica o tipo de informação encontrada +naquela linha: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Esta é sempre a primeira linha ao começar a listar um arquivo. A segunda +coluna na linha é o nome do arquivo. +.TP +\fBfile\fP +Esta linha contém informações gerais sobre o arquivo \fB.xz\fP. Esta linha é +sempre impressa após a linha \fBname\fP. +.TP +\fBstream\fP +Este tipo de linha é usado somente quando \fB\-\-verbose\fP foi +especificado. Existem tantas linhas de \fBstream\fP quanto fluxos no arquivo +\&\fB.xz\fP. +.TP +\fBblock\fP +Este tipo de linha é usado somente quando \fB\-\-verbose\fP foi +especificado. Existem tantas linhas \fBblock\fP quanto blocos no arquivo +\&\fB.xz\fP. As linhas \fBblock\fP são mostradas após todas as linhas \fBstream\fP; +diferentes tipos de linha não são intercalados. +.TP +\fBsummary\fP +Este tipo de linha é usado apenas quando \fB\-\-verbose\fP foi especificado duas +vezes. Esta linha é impressa após todas as linhas de \fBblock\fP. Assim como a +linha \fBarquivo\fP, a linha \fBsummary\fP contém informações gerais sobre o +arquivo \fB.xz\fP. +.TP +\fBtotals\fP +Esta linha é sempre a última linha da saída da lista. Ele mostra as +contagens totais e tamanhos. +.PP +As colunas das linhas \fBfile\fP: +.PD 0 +.RS +.IP 2. 4 +Número de fluxos no arquivo +.IP 3. 4 +Número total de blocos no(s) fluxo(s) +.IP 4. 4 +Tamanho compactado do arquivo +.IP 5. 4 +Uncompressed size of the file +.IP 6. 4 +Taxa de compactação, por exemplo, \fB0.123\fP. Se a proporção for superior a +9.999, serão exibidos três traços (\fB\-\-\-\fP) em vez da proporção. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Lista separada por vírgulas de nomes de verificação de integridade. As +seguintes strings são usadas para os tipos de verificação conhecidos: +\fBNone\fP, \fBCRC32\fP, \fBCRC64\fP e \fBSHA\-256\fP. Para tipos de verificações +desconhecidos, \fBUnknown\-\fP\fIN\fP é usado, onde \fIN\fP é o ID do cheque como um +número decimal (um ou dois dígitos). +.IP 8. 4 +Tamanho total do preenchimento de fluxo no arquivo +.RE +.PD +.PP +As colunas das linhas \fBstream\fP: +.PD 0 +.RS +.IP 2. 4 +Número do fluxo (o primeiro fluxo é 1) +.IP 3. 4 +Número de blocos no fluxo +.IP 4. 4 +Deslocamento inicial compactado +.IP 5. 4 +Deslocamento inicial descompactado +.IP 6. 4 +Tamanho compactado (não inclui preenchimento de fluxo) +.IP 7. 4 +Tamanho descompactado +.IP 8. 4 +Taxa de compactação +.IP 9. 4 +Nome da verificação de integridade +.IP 10. 4 +Tamanho do preenchimento do fluxo +.RE +.PD +.PP +As colunas das linhas \fBblock\fP: +.PD 0 +.RS +.IP 2. 4 +Número do fluxo que contém este bloco +.IP 3. 4 +Número do bloco relativo ao início do fluxo (o primeiro bloco é 1) +.IP 4. 4 +Número do bloco relativo ao início do arquivo +.IP 5. 4 +Deslocamento inicial compactado em relação ao início do arquivo +.IP 6. 4 +Deslocamento inicial descompactado em relação ao início do arquivo +.IP 7. 4 +Tamanho total compactado do bloco (inclui cabeçalhos) +.IP 8. 4 +Tamanho descompactado +.IP 9. 4 +Taxa de compactação +.IP 10. 4 +Nome da verificação de integridade +.RE +.PD +.PP +Se \fB\-\-verbose\fP for especificado duas vezes, colunas adicionais serão +incluídas nas linhas \fBblock\fP. Eles não são exibidos com um único +\fB\-\-verbose\fP, porque obter essas informações requer muitas buscas e, +portanto, pode ser lento: +.PD 0 +.RS +.IP 11. 4 +Valor da verificação de integridade em hexadecimal +.IP 12. 4 +Tamanho do cabeçalho do bloco +.IP 13. 4 +Sinalizadores de bloco: \fBc\fP indica que o tamanho compactado está presente e +\fBu\fP indica que o tamanho não compactado está presente. Se o sinalizador não +estiver definido, um traço (\fB\-\fP) será exibido para manter o comprimento da +string fixo. Novos sinalizadores podem ser adicionados ao final da string no +futuro. +.IP 14. 4 +Tamanho dos dados reais compactados no bloco (isso exclui o cabeçalho do +bloco, o preenchimento do bloco e os campos de verificação) +.IP 15. 4 +Quantidade de memória (em bytes) necessária para descompactar este bloco com +esta versão \fBxz\fP +.IP 16. 4 +Cadeia de filtro. Observe que a maioria das opções usadas no momento da +compactação não pode ser conhecida, pois apenas as opções necessárias para a +descompactação são armazenadas nos cabeçalhos \fB.xz\fP. +.RE +.PD +.PP +As colunas das linhas \fBsummary\fP: +.PD 0 +.RS +.IP 2. 4 +Quantidade de memória (em bytes) necessária para descompactar este arquivo +com esta versão do \fBxz\fP +.IP 3. 4 +\fByes\fP ou \fBno\fP indicando se todos os cabeçalhos de bloco têm tamanho +compactado e tamanho não compactado armazenados neles +.PP +\fIDesde\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Versão mínima do \fBxz\fP necessária para descompactar o arquivo +.RE +.PD +.PP +As colunas da linha \fBtotals\fP: +.PD 0 +.RS +.IP 2. 4 +Número de fluxos +.IP 3. 4 +Número de blocos +.IP 4. 4 +Tamanho compactado +.IP 5. 4 +Tamanho descompactado +.IP 6. 4 +Taxa de compactação média +.IP 7. 4 +Lista separada por vírgulas de nomes de verificação de integridade que +estavam presentes nos arquivos +.IP 8. 4 +Tamanho do preenchimento do fluxo +.IP 9. 4 +Número de arquivos. Isso está aqui para manter a ordem das colunas +anteriores a mesma das linhas \fBfile\fP. +.PD +.RE +.PP +Se \fB\-\-verbose\fP for especificado duas vezes, colunas adicionais serão +incluídas na linha \fBtotals\fP: +.PD 0 +.RS +.IP 10. 4 +Quantidade máxima de memória (em bytes) necessária para descompactar os +arquivos com esta versão do \fBxz\fP +.IP 11. 4 +\fByes\fP ou \fBno\fP indicando se todos os cabeçalhos de bloco têm tamanho +compactado e tamanho não compactado armazenados neles +.PP +\fIDesde\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Versão mínima do \fBxz\fP necessária para descompactar o arquivo +.RE +.PD +.PP +Versões futuras podem adicionar novos tipos de linha e novas colunas podem +ser adicionadas aos tipos de linha existentes, mas as colunas existentes não +serão alteradas. +. +.SS "Filters help" +\fBxz \-\-robot \-\-filters\-help\fP prints the supported filters in the following +format: +.PP +\fIfilter\fP\fB:\fP\fIoption\fP\fB=<\fP\fIvalue\fP\fB>,\fP\fIoption\fP\fB=<\fP\fIvalue\fP\fB>\fP... +.TP +\fIfilter\fP +Name of the filter +.TP +\fIoption\fP +Name of a filter specific option +.TP +\fIvalue\fP +Numeric \fIvalue\fP ranges appear as \fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. String +\fIvalue\fP choices are shown within \fB< >\fP and separated by a \fB|\fP +character. +.PP +Each filter is printed on its own line. +. +.SS "Informações de limite de memória" +\fBxz \-\-robot \-\-info\-memory\fP prints a single line with multiple tab\-separated +columns: +.IP 1. 4 +Quantidade total de memória física (RAM) em bytes. +.IP 2. 4 +Limite de uso de memória para compactação em bytes +(\fB\-\-memlimit\-compress\fP). Um valor especial de \fB0\fP indica a configuração +padrão que para o modo de thread única é o mesmo que sem limite. +.IP 3. 4 +Limite de uso de memória para descompactação em bytes +(\fB\-\-memlimit\-decompress\fP). Um valor especial de \fB0\fP indica a configuração +padrão que para o modo de thread única é o mesmo que sem limite. +.IP 4. 4 +Desde \fBxz\fP 5.3.4alpha: Uso de memória para descompactação com várias thread +em bytes (\fB\-\-memlimit\-mt\-decompress\fP). Isso nunca é zero porque um valor +padrão específico do sistema mostrado na coluna 5 é usado se nenhum limite +for especificado explicitamente. Isso também nunca é maior que o valor na +coluna 3, mesmo que um valor maior tenha sido especificado com +\fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Desde \fBxz\fP 5.3.4alpha: Um limite de uso de memória padrão específico do +sistema que é usado para limitar o número de threads ao compactar com um +número automático de threads (\fB\-\-threads=0\fP) e nenhum limite de uso de +memória foi especificado (\fB\-\-memlimit\-compress\fP). Isso também é usado como +o valor padrão para \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Desde \fBxz\fP 5.3.4alpha: Número de threads de processador disponíveis. +.PP +No futuro, a saída de \fBxz \-\-robot \-\-info\-memory\fP pode ter mais colunas, mas +nunca mais do que uma única linha. +. +.SS Versão +\fBxz \-\-robot \-\-version\fP prints the version number of \fBxz\fP and liblzma in +the following format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Versão principal. +.TP +\fIYYY\fP +Versão menor. Números pares são estáveis. Os números ímpares são versões +alfa ou beta. +.TP +\fIZZZ\fP +Nível de patch para versões estáveis ou apenas um contador para versões de +desenvolvimento. +.TP +\fIS\fP +Estabilidade. 0 é alfa, 1 é beta e 2 é estável. \fIS\fP deve ser sempre 2 +quando \fIYYY\fP for par. +.PP +\fIXYYYZZZS\fP são iguais em ambas as linhas se \fBxz\fP e liblzma forem da mesma +versão do XZ Utils. +.PP +Exemplos: 4.999.9beta é \fB49990091\fP e 5.0.0 é \fB50000002\fP. +. +.SH "STATUS DE SAÍDA" +.TP +\fB0\fP +Está tudo bem. +.TP +\fB1\fP +Ocorreu um erro. +.TP +\fB2\fP +Algo digno de um aviso ocorreu, mas ocorreu nenhum erro real. +.PP +Observações (não avisos ou erros) impressas no erro padrão não afetam o +status de saída. +. +.SH AMBIENTE +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP analisa listas de opções separadas por espaços das variáveis de +ambiente \fBXZ_DEFAULTS\fP e \fBXZ_OPT\fP, nesta ordem, antes de analisar as +opções da linha de comando. Observe que apenas as opções são analisadas a +partir das variáveis de ambiente; todas as não opções são silenciosamente +ignoradas. A análise é feita com \fBgetopt_long\fP(3) que também é usado para +os argumentos da linha de comando. +.PP +\fBWarning:\fP By setting these environment variables, one is effectively +modifying programs and scripts that run \fBxz\fP. Most of the time it is safe +to set memory usage limits, number of threads, and compression options via +the environment variables. However, some options can break scripts. An +obvious example is \fB\-\-help\fP which makes \fBxz\fP show the help text instead of +compressing or decompressing a file. More subtle examples are \fB\-\-quiet\fP +and \fB\-\-verbose\fP. In many cases it works well to enable the progress +indicator using \fB\-\-verbose\fP, but in some situations the extra messages +create problems. The verbosity level also affects the behavior of +\fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +User\-specific or system\-wide default options. Typically this is set in a +shell initialization script to enable \fBxz\fP's memory usage limiter by +default or set the default number of threads. Excluding shell +initialization scripts and similar special cases, scripts should never set +or unset \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Isso é para passar opções para \fBxz\fP quando não é possível definir as opções +diretamente na linha de comando \fBxz\fP. Este é o caso quando \fBxz\fP é +executado por um script ou ferramenta, por exemplo, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Os scripts podem usar \fBXZ_OPT\fP, por exemplo, para definir opções de +compactação padrão específicas do script. Ainda é recomendável permitir que +os usuários substituam \fBXZ_OPT\fP se isso for razoável. Por exemplo, em +scripts \fBsh\fP(1) pode\-se usar algo assim: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "COMPATIBILIDADE COM LZMA UTILS" +A sintaxe da linha de comando do \fBxz\fP é praticamente um superconjunto de +\fBlzma\fP, \fBunlzma\fP e \fBlzcat\fP conforme encontrado no LZMA Utils 4.32.x. Na +maioria dos casos, é possível substituir LZMA Utils por XZ Utils sem +interromper os scripts existentes. Existem algumas incompatibilidades, +porém, que às vezes podem causar problemas. +. +.SS "Níveis de predefinição de compactação" +A numeração das predefinições de nível de compactação não é idêntica em +\fBxz\fP e LZMA Utils. A diferença mais importante é como os tamanhos dos +dicionários são mapeados para diferentes predefinições. O tamanho do +dicionário é aproximadamente igual ao uso de memória do descompactador. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nível;xz;LZMA Utils +\-0;256 KiB;N/D +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +As diferenças de tamanho do dicionário também afetam o uso da memória do +compressor, mas existem algumas outras diferenças entre LZMA Utils e XZ +Utils, que tornam a diferença ainda maior: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nível;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/D +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +O nível de predefinição padrão no LZMA Utils é \fB\-7\fP enquanto no XZ Utils é +\fB\-6\fP, então ambos usam um dicionário de 8 MiB por padrão. +. +.SS "Arquivos .lzma em um fluxo versus sem ser em um fluxo" +O tamanho descompactado do arquivo pode ser armazenado no cabeçalho de +\&\fB.lzma\fP. O LZMA Utils faz isso ao compactar arquivos comuns. A alternativa +é marcar que o tamanho não compactado é desconhecido e usar o marcador de +fim de carga útil para indicar onde o descompactador deve parar. O LZMA +Utils usa este método quando o tamanho não compactado não é conhecido, como +é o caso, por exemplo, de encadeamentos (pipes). +.PP +\fBxz\fP oferece suporte à descompactação de arquivos \fB.lzma\fP com ou sem +marcador de fim de carga útil, mas todos os arquivos \fB.lzma\fP criados por +\fBxz\fP usarão marcador de fim de carga útil e terão o tamanho descompactado +marcado como desconhecido no cabeçalho de \fB.lzma\fP. Isso pode ser um +problema em algumas situações incomuns. Por exemplo, um descompactador de +\&\fB.lzma\fP em um dispositivo embarcado pode funcionar apenas com arquivos que +tenham tamanho descompactado conhecido. Se você encontrar esse problema, +precisará usar o LZMA Utils ou o LZMA SDK para criar arquivos \fB.lzma\fP com +tamanho descompactado conhecido. +. +.SS "Arquivos .lzma não suportados" +O formato \fB.lzma\fP permite valores \fIlc\fP até 8 e valores \fIlp\fP até 4. LZMA +Utils pode descompactar arquivos com qualquer \fIlc\fP e \fIlp\fP, mas sempre cria +arquivos com \fBlc=3\fP e \fBlp=0\fP. Criar arquivos com outros \fIlc\fP e \fIlp\fP é +possível com \fBxz\fP e com LZMA SDK. +.PP +A implementação do filtro LZMA1 em liblzma requer que a soma de \fIlc\fP e +\fIlp\fP não exceda 4. Assim, arquivos \fB.lzma\fP, que excedam esta limitação, +não podem ser descompactados com \fBxz\fP. +.PP +LZMA Utils cria apenas arquivos \fB.lzma\fP que possuem um tamanho de +dicionário de 2^\fIn\fP (uma potência de 2), mas aceita arquivos com qualquer +tamanho de dicionário. liblzma aceita apenas arquivos \fB.lzma\fP que tenham um +tamanho de dicionário de 2^\fIn\fP ou 2^\fIn\fP + 2^(\fIn\fP\-1). Isso é para diminuir +os falsos positivos ao detectar arquivos \fB.lzma\fP. +.PP +Essas limitações não devem ser um problema na prática, já que praticamente +todos os arquivos \fB.lzma\fP foram compactados com configurações que o liblzma +aceitará. +. +.SS "Lixo à direita" +Ao descompactar, o LZMA Utils silenciosamente ignora tudo após o primeiro +fluxo \fB.lzma\fP. Na maioria das situações, isso é um bug. Isso também +significa que o LZMA Utils não oferece suporte a descompactação de arquivos +\&\fB.lzma\fP concatenados. +.PP +Se houver dados restantes após o primeiro fluxo de \fB.lzma\fP, \fBxz\fP considera +o arquivo corrompido, a menos que \fB\-\-single\-stream\fP tenha sido usado. Isso +pode quebrar scripts obscuros que presumiram que o lixo à direita é +ignorado. +. +.SH NOTAS +. +.SS "A saída compactada pode variar" +A saída compactada exata produzida a partir do mesmo arquivo de entrada não +compactado pode variar entre as versões do XZ Utils, mesmo se as opções de +compactação forem idênticas. Isso ocorre porque o codificador pode ser +aprimorado (compactação mais rápida ou melhor) sem afetar o formato do +arquivo. A saída pode variar mesmo entre diferentes compilações da mesma +versão do XZ Utils, se diferentes opções de compilação forem usadas. +.PP +A informação acima significa que, uma vez que \fB\-\-rsyncable\fP tenha sido +implementado, os arquivos resultantes não serão necessariamente +"rsyncáveis", a menos que os arquivos antigos e novos tenham sido +compactados com a mesma versão xz. Esse problema pode ser corrigido se uma +parte da implementação do codificador for congelada para manter a saída de +rsyncable estável nas versões do xz. +. +.SS "Descompactadores .xz embarcados" +As implementações do descompactador \fB.xz\fP embarcados, como o XZ Embedded, +não oferecem necessariamente suporte a arquivos criados com tipos de +\fIverificações\fP de integridade diferentes de \fBnone\fP e \fBcrc32\fP. Como o +padrão é \fB\-\-check=crc64\fP, você deve usar \fB\-\-check=none\fP ou +\fB\-\-check=crc32\fP ao criar arquivos para sistemas embarcados. +.PP +Fora dos sistemas embarcados, todos os descompactadores de formato \fB.xz\fP +oferecem suporte a todos os tipos de \fIverificação\fP ou, pelo menos, são +capazes de descompactar o arquivo sem verificar a verificação de integridade +se a \fIverificação\fP específica não for suportada. +.PP +XZ Embedded oferece suporte a filtros BCJ, mas apenas com o deslocamento +inicial padrão. +. +.SH EXEMPLOS +. +.SS Básico +Compactar o arquivo \fIfoo\fP em \fIfoo.xz\fP usando o nível de compactação padrão +(\fB\-6\fP) e remover \fIfoo\fP se a compactação for bem\-sucedida: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Descompactar \fIbar.xz\fP em \fIbar\fP e não remover \fIbar.xz\fP mesmo se a +descompactação for bem\-sucedida: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Criar \fIbaz.tar.xz\fP com a predefinição \fB\-4e\fP (\fB\-4 \-\-extreme\fP), que é mais +lenta que o padrão \fB\-6\fP, mas precisa de menos memória para compactação e +descompactação (48 \ MiB e 5\ MiB, respectivamente): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Uma mistura de arquivos compactados e descompactados pode ser descompactada +para a saída padrão com um único comando: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Compactação paralela de muitos arquivos" +No GNU e *BSD, \fBfind\fP(1) e \fBxargs\fP(1) podem ser usados para paralelizar a +compactação de muitos arquivos: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +A opção \fB\-P\fP para \fBxargs\fP(1) define o número de processos paralelos do +\fBxz\fP. O melhor valor para a opção \fB\-n\fP depende de quantos arquivos devem +ser compactados. Se houver apenas alguns arquivos, o valor provavelmente +deve ser 1; com dezenas de milhares de arquivos, 100 ou até mais podem ser +apropriados para reduzir o número de processos de \fBxz\fP que \fBxargs\fP(1) +eventualmente criará. +.PP +A opção \fB\-T1\fP para \fBxz\fP existe para forçá\-lo ao modo de thread única, +porque \fBxargs\fP(1) é usado para controlar a quantidade de paralelização. +. +.SS "Modo robô" +Calcular quantos bytes foram salvos no total depois de compactar vários +arquivos: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Um script pode querer saber que está usando \fBxz\fP novo o suficiente. O +seguinte script \fBsh\fP(1) verifica se o número da versão da ferramenta \fBxz\fP +é pelo menos 5.0.0. Este método é compatível com versões beta antigas, que +não suportavam a opção \fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Definir um limite de uso de memória para descompactação usando \fBXZ_OPT\fP, +mas se um limite já tiver sido definido, não o aumentar: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Cadeias de filtro de compressor personalizadas" +O uso mais simples para cadeias de filtro personalizadas é personalizar uma +predefinição LZMA2. Isso pode ser útil, porque as predefinições abrangem +apenas um subconjunto das combinações potencialmente úteis de configurações +de compactação. +.PP +As colunas CompCPU das tabelas das descrições das opções \fB\-0\fP ... \fB\-9\fP e +\fB\-\-extreme\fP são úteis ao personalizar as predefinições LZMA2. Aqui estão as +partes relevantes coletadas dessas duas tabelas: +.RS +.PP +.TS +tab(;); +c c +n n. +Predefinição;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Se você sabe que um arquivo requer um dicionário um tanto grande (por +exemplo, 32\ MiB) para compactar bem, mas deseja comprimi\-lo mais +rapidamente do que \fBxz \-8\fP faria, uma predefinição com um valor CompCPU +baixo (por exemplo, 1) pode ser modificado para usar um dicionário maior: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Com certos arquivos, o comando acima pode ser mais rápido que \fBxz \-6\fP +enquanto compacta significativamente melhor. No entanto, deve\-se enfatizar +que apenas alguns arquivos se beneficiam de um grande dicionário, mantendo o +valor CompCPU baixo. A situação mais óbvia, onde um grande dicionário pode +ajudar muito, é um arquivo contendo arquivos muito semelhantes de pelo menos +alguns megabytes cada. O tamanho do dicionário deve ser significativamente +maior do que qualquer arquivo individual para permitir que o LZMA2 aproveite +ao máximo as semelhanças entre arquivos consecutivos. +.PP +Se o uso muito alto de memória do compactador e do descompactador for bom e +o arquivo que está sendo compactado tiver pelo menos várias centenas de +megabytes, pode ser útil usar um dicionário ainda maior do que os 64 MiB que +o \fBxz \-9\fP usaria: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Usar \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) como no exemplo acima pode ser útil +para ver os requisitos de memória do compactador e do +descompactador. Lembre\-se que usar um dicionário maior que o tamanho do +arquivo descompactado é desperdício de memória, então o comando acima não é +útil para arquivos pequenos. +.PP +Às vezes, o tempo de compactação não importa, mas o uso de memória do +descompactador deve ser mantido baixo, por exemplo, para possibilitar a +descompactação do arquivo em um sistema embarcado. O comando a seguir usa +\fB\-6e\fP (\fB\-6 \-\-extreme\fP) como base e define o dicionário como apenas 64\ KiB. O arquivo resultante pode ser descompactado com XZ Embedded (é por isso +que existe \fB\-\-check=crc32\fP) usando cerca de 100\ KiB de memória. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Se você deseja espremer o máximo de bytes possível, ajustar o número de bits +de contexto literal (\fIlc\fP) e o número de bits de posição (\fIpb\fP) às vezes +pode ajudar. Ajustar o número de bits de posição literal (\fIlp\fP) também pode +ajudar, mas geralmente \fIlc\fP e \fIpb\fP são mais importantes. Por exemplo, um +arquivo de código\-fonte contém principalmente texto US\-ASCII, então algo +como o seguinte pode fornecer um arquivo ligeiramente (como 0,1\ %) menor +que \fBxz \-6e\fP (tente também sem \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +O uso de outro filtro junto com o LZMA2 pode melhorar a compactação com +determinados tipos de arquivo. Por exemplo, para compactar uma biblioteca +compartilhada x86\-32 ou x86\-64 usando o filtro x86 BCJ: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Observe que a ordem das opções de filtro é significativa. Se \fB\-\-x86\fP for +especificado após \fB\-\-lzma2\fP, \fBxz\fP dará um erro, porque não pode haver +nenhum filtro após LZMA2 e também porque o filtro x86 BCJ não pode ser usado +como o último filtro em a corrente. +.PP +O filtro Delta junto com LZMA2 pode dar bons resultados com imagens +bitmap. Ele geralmente deve superar o PNG, que possui alguns filtros mais +avançados do que o delta simples, mas usa Deflate para a compactação real. +.PP +A imagem deve ser salva em formato não compactado, por exemplo, como TIFF +não compactado. O parâmetro de distância do filtro Delta é definido para +corresponder ao número de bytes por pixel na imagem. Por exemplo, bitmap RGB +de 24 bits precisa de \fBdist=3\fP, e também é bom passar \fBpb=0\fP para LZMA2 +para acomodar o alinhamento de três bytes: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Se várias imagens foram colocadas em um único arquivo (por exemplo, +\&\fB.tar\fP), o filtro Delta também funcionará, desde que todas as imagens +tenham o mesmo número de bytes por pixel. +. +.SH "VEJA TAMBÉM" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/unxz.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/unxz.1 new file mode 100644 index 0000000000000000000000000000000000000000..0f85fc96ac66488096221e723d837e7d28ff6bc2 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/unxz.1 @@ -0,0 +1,1994 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Brazilian Portuguese translations for xz package +.\" Traduções em português brasileiro para o pacote xz. +.\" Rafael Fontenelle , 2022-2023. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 2025\-03\-08 Tukaani "XZ Utils" +. +.SH NOME +xz, unxz, xzcat, lzma, unlzma, lzcat \- Compacta ou descompacta arquivos .xz +e .lzma +. +.SH SINOPSE +\fBxz\fP [\fIopção...\fP] [\fIarquivo...\fP] +. +.SH "COMANDOS APELIDOS" +\fBunxz\fP é equivalente a \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP é equivalente a \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP é equivalente a \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP é equivalente a \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP é equivalente a \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Ao escrever scripts que precisam descompactar arquivos, é recomendável +sempre usar o nome \fBxz\fP com os argumentos apropriados (\fBxz \-d\fP ou \fBxz \-dc\fP) em vez dos nomes \fBunxz\fP e \fBxzcat\fP. +. +.SH DESCRIÇÃO +\fBxz\fP é uma ferramenta de compactação de dados de uso geral com sintaxe de +linha de comando semelhante ao \fBgzip\fP(1) e ao \fBbzip2\fP(1). O formato de +arquivo nativo é o formato \fB.xz\fP, mas o formato legado \fB.lzma\fP usado por +LZMA Utils e fluxos compactados brutos sem cabeçalhos de formato de +contêiner também são suportados. Além disso, a descompactação do formato +\&\fB.lz\fP usado por \fBlzip\fP é suportada. +.PP +\fBxz\fP compacta ou descompacta cada \fIarquivo\fP de acordo com o modo de +operação selecionado. Se nenhum \fIarquivo\fP for fornecido ou \fIarquivo\fP for +\fB\-\fP, \fBxz\fP lê da entrada padrão e grava os dados processados na saída +padrão. \fBxz\fP recusará (exibirá um erro e ignorará o \fIarquivo\fP) para gravar +dados compactados na saída padrão se for um terminal. Da mesma forma, \fBxz\fP +se recusará a ler dados compactados da entrada padrão se for um terminal. +.PP +A menos que \fB\-\-stdout\fP seja especificado, \fIarquivos\fP diferentes de \fB\-\fP +são gravados em um novo arquivo cujo nome é derivado do nome \fIarquivo\fP de +origem: +.IP \(bu 3 +Ao compactar, o sufixo do formato de arquivo de destino (\fB.xz\fP ou \fB.lzma\fP) +é anexado ao nome do arquivo de origem para obter o nome do arquivo de +destino. +.IP \(bu 3 +Ao descompactar, o sufixo \fB.xz\fP, \fB.lzma\fP ou \fB.lz\fP é removido do nome do +arquivo para obter o nome do arquivo de destino. \fBxz\fP também reconhece os +sufixos \fB.txz\fP e \fB.tlz\fP e os substitui pelo sufixo \fB.tar\fP. +.PP +Se o arquivo de destino já existir, um erro será exibido e \fIarquivo\fP será +ignorado. +.PP +A menos que grave na saída padrão, \fBxz\fP exibirá um aviso e pulará o +\fIarquivo\fP se qualquer um dos seguintes se aplicar: +.IP \(bu 3 +\fIArquivo\fP não é um arquivo normal. Links simbólicos não são seguidos e, +portanto, não são considerados arquivos comuns. +.IP \(bu 3 +\fIArquivo\fP tem mais de um link físico. +.IP \(bu 3 +\fIFile\fP tem setuid, setgid ou sticky bit definido. +.IP \(bu 3 +O modo de operação está definido para compactar e o \fIarquivo\fP já possui um +sufixo do formato de arquivo de destino (\fB.xz\fP ou \fB.txz\fP ao compactar para +o formato \fB.xz\fP e \fB.lzma \fP ou \fB.tlz\fP ao compactar para o formato +\&\fB.lzma\fP). +.IP \(bu 3 +O modo de operação está definido para descompactar e o \fIarquivo\fP não possui +um sufixo de nenhum dos formatos de arquivo suportados (\fB.xz\fP, \fB.txz\fP, +\&\fB.lzma\fP, \fB.tlz\fP , ou \fB.lz\fP). +.PP +Depois de compactar ou descompactar com êxito o \fIarquivo\fP, o \fBxz\fP copia o +dono, grupo, permissões, horário de acesso e horário de modificação do +\fIarquivo\fP de origem para o arquivo de destino. Se a cópia do grupo falhar, +as permissões serão modificadas para que o arquivo de destino não se torne +acessível a usuários que não têm permissão para acessar o \fIarquivo\fP de +origem. \fBxz\fP ainda não oferece suporte à cópia de outros metadados, como +listas de controle de acesso ou atributos estendidos. +.PP +Depois que o arquivo de destino for fechado com êxito, o \fIarquivo\fP de +origem será removido, a menos que \fB\-\-keep\fP tenha sido especificado. O +\fIarquivo\fP de origem nunca é removido se a saída for gravada na saída padrão +ou se ocorrer um erro. +.PP +O envio de \fBSIGINFO\fP ou \fBSIGUSR1\fP para o processo do \fBxz\fP faz com que ele +imprima informações de andamento para erro padrão. Isso tem uso limitado, +pois quando o erro padrão é um terminal, usar \fB\-\-verbose\fP exibirá um +indicador de progresso de atualização automática. +. +.SS "Uso de memória" +O uso de memória de \fBxz\fP varia de algumas centenas de kilobytes a vários +gigabytes, dependendo das configurações de compactação. As configurações +usadas ao compactar um arquivo determinam os requisitos de memória do +descompactador. Normalmente, o descompactador precisa de 5\ % a 20\ % da +quantidade de memória que o compactador precisou ao criar o arquivo. Por +exemplo, descompactar um arquivo criado com \fBxz \-9\fP atualmente requer 65\ MiB de memória. Ainda assim, é possível ter arquivos \fB.xz\fP que requerem +vários gigabytes de memória para descompactar. +.PP +Especialmente os usuários de sistemas mais antigos podem achar irritante a +possibilidade de uso de memória muito grande. Para evitar surpresas +desconfortáveis, o \fBxz\fP possui um limitador de uso de memória embutido, que +está desabilitado por padrão. Embora alguns sistemas operacionais forneçam +maneiras de limitar o uso de memória dos processos, confiar nele não foi +considerado flexível o suficiente (por exemplo, usar \fBulimit\fP(1) para +limitar a memória virtual tende a prejudicar \fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +O limitador de uso de memória pode ser ativado com a opção de linha de +comando \fB\-\-memlimit=\fP\fIlimite\fP. Geralmente é mais conveniente habilitar o +limitador por padrão definindo a variável de ambiente \fBXZ_DEFAULTS\fP, por +exemplo, \fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. É possível definir os limites +separadamente para compactação e descompactação usando +\fB\-\-memlimit\-compress=\fP\fIlimite\fP e \fB\-\-memlimit\-decompress=\fP\fIlimite\fP. Usar +essas duas opções fora de \fBXZ_DEFAULTS\fP raramente é útil porque uma única +execução de \fBxz\fP não pode fazer compactação e descompactação e +\fB\-\-memlimit=\fP\fIlimite\fP (ou \fB\-M\fP \fIlimite\fP ) é mais curto para digitar na +linha de comando. +.PP +Se o limite de uso de memória especificado for excedido durante a +descompactação, \fBxz\fP exibirá um erro e a descompactação do arquivo +falhará. Se o limite for excedido durante a compactação, \fBxz\fP tentará +reduzir as configurações para que o limite não seja mais excedido (exceto ao +usar \fB\-\-format=raw\fP ou \fB\-\-no\-adjust\fP). Dessa forma, a operação não +falhará, a menos que o limite seja muito pequeno. A escala das configurações +é feita em etapas que não correspondem às predefinições do nível de +compactação, por exemplo, se o limite for apenas um pouco menor que o valor +necessário para \fBxz \-9\fP, as configurações serão reduzidas apenas um pouco , +não até \fBxz \-8\fP. +. +.SS "Concatenação e preenchimento com arquivos .xz" +É possível concatenar arquivos \fB.xz\fP como estão. \fBxz\fP irá descompactar +tais arquivos como se fossem um único arquivo \fB.xz\fP. +.PP +É possível inserir preenchimento entre as partes concatenadas ou após a +última parte. O preenchimento deve consistir em bytes nulos e o tamanho do +preenchimento deve ser um múltiplo de quatro bytes. Isso pode ser útil, por +exemplo, se o arquivo \fB.xz\fP for armazenado em uma mídia que mede tamanhos +de arquivo em blocos de 512 bytes. +.PP +Concatenação e preenchimento não são permitidos com arquivos \fB.lzma\fP ou +fluxos brutos. +. +.SH OPÇÕES +. +.SS "Sufixos inteiros e valores especiais" +Na maioria dos lugares onde um argumento inteiro é esperado, um sufixo +opcional é suportado para indicar facilmente números inteiros grandes. Não +deve haver espaço entre o número inteiro e o sufixo. +.TP +\fBKiB\fP +Multiplica o inteiro por 1.024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP e \fBKB\fP são +aceitos como sinônimos de \fBKiB\fP. +.TP +\fBMiB\fP +Multiplica o número inteiro por 1.048.576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP e \fBMB\fP +são aceitos como sinônimos de \fBMiB\fP. +.TP +\fBGiB\fP +Multiplica o número inteiro por 1.073.741.824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP e +\fBGB\fP são aceitos como sinônimos de \fBGiB\fP. +.PP +O valor especial \fBmax\fP pode ser usado para indicar o valor inteiro máximo +suportado pela opção. +. +.SS "Modo de operação" +Se várias opções de modo de operação forem dadas, a última entrará em vigor. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Compacta. Este é o modo de operação padrão quando nenhuma opção de modo de +operação é especificada e nenhum outro modo de operação está implícito no +nome do comando (por exemplo, \fBunxz\fP implica em \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +After successful compression, the source file is removed unless writing to +standard output or \fB\-\-keep\fP was specified. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Decompress. After successful decompression, the source file is removed +unless writing to standard output or \fB\-\-keep\fP was specified. +.TP +\fB\-t\fP, \fB\-\-test\fP +Testa a integridade de \fIarquivos\fP compactados. Esta opção é equivalente a +\fB\-\-decompress \-\-stdout\fP exceto que os dados descompactados são descartados +em vez de serem gravados na saída padrão. Nenhum arquivo é criado ou +removido. +.TP +\fB\-l\fP, \fB\-\-list\fP +Imprime informações sobre \fIarquivos\fP compactados. Nenhuma saída +descompactada é produzida e nenhum arquivo é criado ou removido. No modo de +lista, o programa não pode ler os dados compactados da entrada padrão ou de +outras fontes não pesquisáveis. +.IP "" +A listagem padrão mostra informações básicas sobre \fIarquivos\fP, um arquivo +por linha. Para obter informações mais detalhadas, use também a opção +\fB\-\-verbose\fP. Para obter ainda mais informações, use \fB\-\-verbose\fP duas +vezes, mas observe que isso pode ser lento, porque obter todas as +informações extras requer muitas buscas. A largura da saída detalhada excede +80 caracteres, portanto, canalizar a saída para, por exemplo, \fBless\ \-S\fP +pode ser conveniente se o terminal não tiver largura o suficiente. +.IP "" +A saída exata pode variar entre versões \fBxz\fP e localidades diferentes. Para +saída legível por máquina, \fB\-\-robot \-\-list\fP deve ser usado. +. +.SS "Modificadores de operação" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Não exclui os arquivos de entrada. +.IP "" +Desde \fBxz\fP 5.2.6, esta opção também faz \fBxz\fP compactar ou descompactar +mesmo se a entrada for um link simbólico para um arquivo comum, tiver mais +de um link físico ou tiver o setuid, setgid ou sticky bit definir. Os bits +setuid, setgid e sticky não são copiados para o arquivo de destino. Nas +versões anteriores, isso era feito apenas com \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Esta opção tem vários efeitos: +.RS +.IP \(bu 3 +Se o arquivo de destino já existir, o exclui antes de compactar ou +descompactar. +.IP \(bu 3 +Compacta ou descompacta, mesmo que a entrada seja um link simbólico para um +arquivo normal, tenha mais de um link físico ou tenha setuid, setgid ou +sticky bit definido. Os bits setuid, setgid e sticky não são copiados para o +arquivo de destino. +.IP \(bu 3 +Quando usado com \fB\-\-decompress\fP \fB\-\-stdout\fP e \fBxz\fP não consegue reconhecer +o tipo do arquivo de origem, copia o arquivo de origem como está na saída +padrão. Isso permite que \fBxzcat\fP \fB\-\-force\fP seja usado como \fBcat\fP(1) para +arquivos que não foram compactados com \fBxz\fP. Observe que, no futuro, o +\fBxz\fP pode oferecer suporte a novos formatos de arquivo compactado, o que +pode fazer com que o \fBxz\fP descompacte mais tipos de arquivos em vez de +copiá\-los como na saída padrão. \fB\-\-format=\fP\fIformato\fP pode ser usado para +restringir \fBxz\fP para descompactar apenas um único formato de arquivo. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Grava os dados compactados ou descompactados na saída padrão em vez de em um +arquivo. Isso implica em \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Descompacta apenas o primeiro fluxo de \fB.xz\fP e ignora silenciosamente +possíveis dados de entrada restantes após o fluxo. Normalmente, esse +restante posterior sem uso faz com que \fBxz\fP exiba um erro. +.IP "" +\fBxz\fP nunca descompacta mais de um fluxo de arquivos \fB.lzma\fP ou fluxos +brutos, mas esta opção ainda faz \fBxz\fP ignorar os possíveis dados +posteriores após o arquivo \fB.lzma\fP ou fluxo bruto. +.IP "" +Esta opção não tem efeito se o modo de operação não for \fB\-\-decompress\fP ou +\fB\-\-test\fP. +.IP "" +Since \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP implies \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Desativa a criação de arquivos esparsos. Por padrão, ao descompactar em um +arquivo normal, \fBxz\fP tenta tornar o arquivo esparso se os dados +descompactados contiverem longas sequências de zeros binários. Ele também +funciona ao gravar na saída padrão, desde que a saída padrão esteja +conectada a um arquivo normal e certas condições adicionais sejam atendidas +para torná\-la segura. A criação de arquivos esparsos pode economizar espaço +em disco e acelerar a descompactação, reduzindo a quantidade de E/S do +disco. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Ao compactar, usa \fI.suf\fP como sufixo para o arquivo de destino em vez de +\&\fB.xz\fP ou \fB.lzma\fP. Se não estiver gravando na saída padrão e o arquivo de +origem já tiver o sufixo \fI.suf\fP, um aviso será exibido e o arquivo será +ignorado. +.IP "" +Ao descompactar, reconhece arquivos com o sufixo \fI.suf\fP além de arquivos +com o sufixo \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP ou \fB.lz\fP . Se o arquivo de +origem tiver o sufixo \fI.suf\fP, o sufixo será removido para obter o nome do +arquivo de destino. +.IP "" +Ao compactar ou descompactar fluxos brutos (\fB\-\-format=raw\fP), o sufixo +sempre deve ser especificado, a menos que seja gravado na saída padrão, +porque não há sufixo padrão para fluxos brutos. +.TP +\fB\-\-files\fP[\fB=\fP\fIarquivo\fP] +Lê os nomes dos arquivos a serem processados em \fIarquivo\fP; se \fIarquivo\fP +for omitido, os nomes dos arquivos serão lidos da entrada padrão. Os nomes +de arquivo devem terminar com o caractere de nova linha. Um traço (\fB\-\fP) é +considerado um nome de arquivo regular; não significa entrada padrão. Se os +nomes de arquivo forem fornecidos também como argumentos de linha de +comando, eles serão processados antes da leitura dos nomes de arquivo de +\fIarquivo\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIarquivo\fP] +Isso é idêntico a \fB\-\-files\fP[\fB=\fP\fIarquivo\fP], exceto que cada nome de +arquivo deve ser finalizado com o caractere nulo. +. +.SS "Opções básicas de formato de arquivo e de compactação" +.TP +\fB\-F\fP \fIformato\fP, \fB\-\-format=\fP\fIformato\fP +Especifica o \fIformato\fP de arquivo para compactar ou descompactar: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Este é o padrão. Ao compactar, \fBauto\fP é equivalente a \fBxz\fP. Ao +descompactar, o formato do arquivo de entrada é detectado +automaticamente. Observe que os fluxos brutos (criados com \fB\-\-format=raw\fP) +não podem ser detectados automaticamente. +.TP +\fBxz\fP +Compacta no formato de arquivo \fB.xz\fP ou aceite apenas arquivos \fB.xz\fP ao +descompactar. +.TP +\fBlzma\fP, \fBalone\fP +Compacta no formato de arquivo legado \fB.lzma\fP ou aceite apenas arquivos +\&\fB.lzma\fP ao descompactar. O nome alternativo \fBalone\fP é fornecido para +compatibilidade com versões anteriores do LZMA Utils. +.TP +\fBlzip\fP +Aceita apenas arquivos \fB.lz\fP ao descompactar. Sem suporte a compactação. +.IP "" +The \fB.lz\fP format versions 0 and 1 are supported. Version 0 files were +produced by \fBlzip\fP 1.3 and older. Such files aren't common but may be +found from file archives as a few source packages were released in this +format. People might have old personal files in this format too. +Decompression support for the format version 0 was removed in \fBlzip\fP 1.18. +\fBlzip\fP 1.4 and later create files in the format version 1. +.TP +\fBraw\fP +Compacta ou descompacta um fluxo bruto (sem cabeçalhos). Isso é destinado +apenas a usuários avançados. Para decodificar fluxos brutos, você precisa +usar \fB\-\-format=raw\fP e especificar explicitamente a cadeia de filtros, que +normalmente seria armazenada nos cabeçalhos do contêiner. +.RE +.TP +\fB\-C\fP \fIverificação\fP, \fB\-\-check=\fP\fIverificação\fP +Especifica o tipo de verificação de integridade. A verificação é calculada a +partir dos dados descompactados e armazenados no arquivo \fB.xz\fP. Esta opção +tem efeito somente ao compactar no formato \fB.xz\fP; o formato \fB.lzma\fP não +oferece suporte a verificações de integridade. A verificação de integridade +(se for o caso) é verificada quando o arquivo \fB.xz\fP é descompactado. +.IP "" +Tipos de \fIverificação\fP suportados: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Não calcula uma verificação de integridade. Isso geralmente é uma má +ideia. Pode ser útil quando a integridade dos dados é verificada por outros +meios. +.TP +\fBcrc32\fP +Calcula CRC32 usando o polinômio do IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Calcula CRC64 usando o polinômio de ECMA\-182. Este é o padrão, pois é um +pouco melhor que o CRC32 na detecção de arquivos danificados e a diferença +de velocidade é insignificante. +.TP +\fBsha256\fP +Calcula SHA\-256. Isso é um pouco mais lento do que CRC32 e CRC64. +.RE +.IP "" +A integridade dos cabeçalhos de \fB.xz\fP é sempre verificada com CRC32. Não é +possível alterá\-la ou desativá\-la. +.TP +\fB\-\-ignore\-check\fP +Não confere a verificação de integridade dos dados compactados ao +descompactar. Os valores CRC32 nos cabeçalhos \fB.xz\fP ainda serão conferidos +normalmente. +.IP "" +\fBNão use esta opção a menos que saiba o que está fazendo.\fP Possíveis razões +para usar esta opção: +.RS +.IP \(bu 3 +Tentativa de recuperar dados de um arquivo .xz corrompido. +.IP \(bu 3 +Acelerar a descompactação. Isso é importante principalmente com SHA\-256 ou +com arquivos extremamente bem compactados. É recomendável não usar essa +opção para essa finalidade, a menos que a integridade do arquivo seja +verificada externamente de alguma outra forma. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Seleciona um nível de predefinição de compactação. O padrão é \fB\-6\fP. Se +vários níveis de predefinição forem especificados, o último terá efeito. Se +uma cadeia de filtro personalizada já foi especificada, especificar um nível +de predefinição de compactação limpa a cadeia de filtro personalizada. +.IP "" +As diferenças entre as predefinições são mais significativas do que com +\fBgzip\fP(1) e \fBbzip2\fP(1). As configurações de compactação selecionadas +determinam os requisitos de memória do descompactador, portanto, usar um +nível de predefinição muito alto pode dificultar a descompactação do arquivo +em um sistema antigo com pouca RAM. Especificamente, \fBnão é uma boa ideia usar cegamente \-9 para tudo\fP como costuma acontecer com \fBgzip\fP(1) e +\fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Estas são predefinições um tanto rápidas. \fB\-0\fP às vezes é mais rápida que +\fBgzip \-9\fP ao mesmo tempo que compacta muito melhor. As mais altas +geralmente têm velocidade comparável ao \fBbzip2\fP(1) com taxa de compactação +comparável ou melhor, embora os resultados dependam muito do tipo de dados +que estão sendo compactados. +.TP +\fB\-4\fP ... \fB\-6\fP +Compactação boa a muito boa, mantendo o uso de memória do descompactador +razoável mesmo para sistemas antigos. \fB\-6\fP é o padrão, que geralmente é uma +boa escolha para distribuir arquivos que precisam ser descompactáveis, mesmo +em sistemas com apenas 16\ MiB de RAM. (\fB\-5e\fP ou \fB\-6e\fP também vale a pena +considerar. Veja \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Eles são como \fB\-6\fP, mas com requisitos de memória de compressor e +descompressor mais altos. Eles são úteis apenas ao compactar arquivos +maiores que 8\ MiB, 16\ MiB e 32\ MiB, respectivamente. +.RE +.IP "" +No mesmo hardware, a velocidade de descompactação é aproximadamente um +número constante de bytes de dados compactados por segundo. Em outras +palavras, quanto melhor a compactação, mais rápida será a +descompactação. Isso também significa que a quantidade de saída não +compactada produzida por segundo pode variar muito. +.IP "" +A tabela a seguir resume os recursos das predefinições: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Predefinição;DicTam;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Descrições das colunas: +.RS +.IP \(bu 3 +DicTam é o tamanho do dicionário LZMA2. É desperdício de memória usar um +dicionário maior que o tamanho do arquivo descompactado. É por isso que é +bom evitar usar as predefinições \fB\-7\fP ... \fB\-9\fP quando não há real +necessidade deles. Em \fB\-6\fP e inferior, a quantidade de memória desperdiçada +geralmente é baixa o suficiente para não importar. +.IP \(bu 3 +CompCPU é uma representação simplificada das configurações LZMA2 que afetam +a velocidade de compactação. O tamanho do dicionário também afeta a +velocidade, portanto, embora o CompCPU seja o mesmo para os níveis \fB\-6\fP +\&... \fB\-9\fP, níveis mais altos ainda tendem a ser um pouco mais lentos. Para +obter uma compactação ainda mais lenta e possivelmente melhor, consulte +\fB\-\-extreme\fP. +.IP \(bu 3 +CompMem contains the compressor memory requirements in the single\-threaded +mode. It may vary slightly between \fBxz\fP versions. +.IP \(bu 3 +DecMem contém os requisitos de memória do descompactador. Ou seja, as +configurações de compactação determinam os requisitos de memória do +descompactador. O uso exato da memória do descompactador é um pouco maior do +que o tamanho do dicionário LZMA2, mas os valores na tabela foram +arredondados para o próximo MiB completo. +.RE +.IP "" +Memory requirements of the multi\-threaded mode are significantly higher than +that of the single\-threaded mode. With the default value of +\fB\-\-block\-size\fP, each thread needs 3*3*DictSize plus CompMem or DecMem. For +example, four threads with preset \fB\-6\fP needs 660\(en670\ MiB of memory. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Usa uma variante mais lenta do nível de predefinição de compactação +selecionado (\fB\-0\fP ... \fB\-9\fP) para obter uma taxa de compactação um pouco +melhor, mas, com azar, isso também pode piorar. O uso da memória do +descompressor não é afetado, mas o uso da memória do compactador aumenta um +pouco nos níveis de predefinição \fB\-0\fP ... \fB\-3\fP. +.IP "" +Como existem duas predefinições com tamanhos de dicionário 4\ MiB e 8\ MiB, +as predefinições \fB\-3e\fP e \fB\-5e\fP usam configurações um pouco mais rápidas +(CompCPU inferior) do que \fB\-4e\fP e \fB\-6e\fP, respectivamente. Dessa forma, não +há duas predefinições idênticas. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Predefinição;DicTam;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Por exemplo, há um total de quatro predefinições que usam o dicionário 8\ MiB, cuja ordem do mais rápido ao mais lento é \fB\-5\fP, \fB\-6\fP, \fB\-5e\fP e +\fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Esses são apelidos um tanto enganosos para \fB\-0\fP e \fB\-9\fP, +respectivamente. Eles são fornecidos apenas para compatibilidade com versões +anteriores do LZMA Utils. Evite usar essas opções. +.TP +\fB\-\-block\-size=\fP\fItamanho\fP +Ao compactar para o formato \fB.xz\fP, divida os dados de entrada em blocos de +\fItamanho\fP bytes. Os blocos são compactados independentemente uns dos +outros, o que ajuda no multi\-threading e torna possível a descompactação +limitada de acesso aleatório. Essa opção normalmente é usada para substituir +o tamanho de bloco padrão no modo multi\-thread, mas também pode ser usada em +thread única. +.IP "" +In multi\-threaded mode about three times \fIsize\fP bytes will be allocated in +each thread for buffering input and output. The default \fIsize\fP is three +times the LZMA2 dictionary size or 1 MiB, whichever is more. Typically a +good value is 2\(en4 times the size of the LZMA2 dictionary or at least 1 +MiB. Using \fIsize\fP less than the LZMA2 dictionary size is waste of RAM +because then the LZMA2 dictionary buffer will never get fully used. In +multi\-threaded mode, the sizes of the blocks are stored in the block +headers. This size information is required for multi\-threaded +decompression. +.IP "" +In single\-threaded mode no block splitting is done by default. Setting this +option doesn't affect memory usage. No size information is stored in block +headers, thus files created in single\-threaded mode won't be identical to +files created in multi\-threaded mode. The lack of size information also +means that \fBxz\fP won't be able decompress the files in multi\-threaded mode. +.TP +\fB\-\-block\-list=\fP\fIitems\fP +When compressing to the \fB.xz\fP format, start a new block with an optional +custom filter chain after the given intervals of uncompressed data. +.IP "" +The \fIitems\fP are a comma\-separated list. Each item consists of an optional +filter chain number between 0 and 9 followed by a colon (\fB:\fP) and a +required size of uncompressed data. Omitting an item (two or more +consecutive commas) is a shorthand to use the size and filters of the +previous item. +.IP "" +If the input file is bigger than the sum of the sizes in \fIitems\fP, the last +item is repeated until the end of the file. A special value of \fB0\fP may be +used as the last size to indicate that the rest of the file should be +encoded as a single block. +.IP "" +An alternative filter chain for each block can be specified in combination +with the \fB\-\-filters1=\fP\fIfilters\fP \&...\& \fB\-\-filters9=\fP\fIfilters\fP options. +These options define filter chains with an identifier between 1\(en9. +Filter chain 0 can be used to refer to the default filter chain, which is +the same as not specifying a filter chain. The filter chain identifier can +be used before the uncompressed size, followed by a colon (\fB:\fP). For +example, if one specifies \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP +then blocks will be created using: +.RS +.IP \(bu 3 +The filter chain specified by \fB\-\-filters1\fP and 2 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters3\fP and 2 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters2\fP and 4 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters2\fP and 4 MiB input +.IP \(bu 3 +The default filter chain and 2 MiB input +.IP \(bu 3 +The default filter chain and 4 MiB input for every block until end of input. +.RE +.IP "" +If one specifies a size that exceeds the encoder's block size (either the +default value in threaded mode or the value specified with +\fB\-\-block\-size=\fP\fIsize\fP), the encoder will create additional blocks while +keeping the boundaries specified in \fIitems\fP. For example, if one specifies +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP and the +input file is 80 MiB, one will get 11 blocks: 5, 10, 8, 10, 2, 10, 10, 4, +10, 10, and 1 MiB. +.IP "" +No modo multi\-thread, os tamanhos dos blocos são armazenados nos cabeçalhos +dos blocos. Isso não é feito no modo de thread única, portanto, a saída +codificada não será idêntica à do modo multi\-thread. +.TP +\fB\-\-flush\-timeout=\fP\fItempo_limite\fP +Ao compactar, se mais de \fItempo_limite\fP milissegundos (um número inteiro +positivo) se passaram desde a liberação anterior e a leitura de mais entrada +seria bloqueada, todos os dados de entrada pendentes serão liberados do +codificador e disponibilizados no fluxo de saída. Isso pode ser útil se +\fBxz\fP for usado para compactar dados transmitidos por uma rede. Valores +\fItempo_limite\fP pequenos tornam os dados disponíveis na extremidade +receptora com um pequeno atraso, mas valores \fItempo_limite\fP grandes +oferecem melhor taxa de compactação. +.IP "" +Esse recurso está desabilitado por padrão. Se esta opção for especificada +mais de uma vez, a última terá efeito. O valor especial \fItempo_limite\fP de +\fB0\fP pode ser usado para desabilitar explicitamente esse recurso. +.IP "" +Este recurso não está disponível em sistemas não\-POSIX. +.IP "" +.\" FIXME +\fBEste recurso ainda é experimental.\fP Atualmente, \fBxz\fP não é adequado para +descompactar o fluxo em tempo real devido à forma como \fBxz\fP faz o buffer. +.TP +\fB\-\-no\-sync\fP +Do not synchronize the target file and its directory to the storage device +before removing the source file. This can improve performance if +compressing or decompressing many small files. However, if the system +crashes soon after the deletion, it is possible that the target file was not +written to the storage device but the delete operation was. In that case +neither the original source file nor the target file is available. +.IP "" +This option has an effect only when \fBxz\fP is going to remove the source +file. In other cases synchronization is never done. +.IP "" +The synchronization and \fB\-\-no\-sync\fP were added in \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIlimite\fP +Define um limite de uso de memória para compactação. Se esta opção for +especificada várias vezes, a última entrará em vigor. +.IP "" +Se as configurações de compactação excederem o \fIlimite\fP, \fBxz\fP tentará +ajustar as configurações para baixo para que o limite não seja mais excedido +e exibirá um aviso de que o ajuste automático foi feito. Os ajustes são +feitos nesta ordem: reduzindo o número de encadeamentos, alternando para o +modo sigle\-thread se até mesmo uma thread no modo multi\-thread exceder o +\fIlimite\fP e, finalmente, reduzindo o tamanho do dicionário LZMA2. +.IP "" +Ao compactar com \fB\-\-format=raw\fP ou se \fB\-\-no\-adjust\fP tiver sido +especificado, apenas o número de threads pode ser reduzido, pois isso pode +ser feito sem afetar a saída compactada. +.IP "" +Se o \fIlimite\fP não puder ser alcançado mesmo com os ajustes descritos acima, +um erro será exibido e \fBxz\fP sairá com status de saída 1. +.IP "" +O \fIlimite\fP pode ser especificado de várias maneiras: +.RS +.IP \(bu 3 +O \fIlimite\fP pode ser um valor absoluto em bytes. Usar um sufixo inteiro como +\fBMiB\fP pode ser útil. Exemplo: \fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +O \fIlimite\fP pode ser especificado como uma porcentagem da memória física +total (RAM). Isso pode ser útil especialmente ao definir a variável de +ambiente \fBXZ_DEFAULTS\fP em um script de inicialização de shell que é +compartilhado entre diferentes computadores. Dessa forma o limite é +automaticamente maior em sistemas com mais memória. Exemplo: +\fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +O \fIlimite\fP pode ser redefinido para seu valor padrão, definindo\-o como +\fB0\fP. Atualmente, isso equivale a definir \fIlimite\fP como \fBmax\fP (sem limite +de uso de memória). +.RE +.IP "" +Para \fBxz\fP de 32 bits, há um caso especial: se o \fIlimite\fP estiver acima de +\fB4020\ MiB\fP, o \fIlimite\fP é definido como \fB4020\ MiB\fP. No MIPS32 \fB2000\ MiB\fP é usado em seu lugar. (Os valores \fB0\fP e \fBmax\fP não são afetados por +isso. Um recurso semelhante não existe para descompactação.) Isso pode ser +útil quando um executável de 32 bits tem acesso a espaço de endereço de 4\ GiB (2 GiB no MIPS32) enquanto espero não causar danos em outras situações. +.IP "" +Consulte também a seção \fBUso de memória\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIlimite\fP +Define um limite de uso de memória para descompactação. Isso também afeta o +modo \fB\-\-list\fP. Se a operação não for possível sem exceder o \fIlimite\fP, +\fBxz\fP exibirá um erro e a descompactação do arquivo falhará. Consulte +\fB\-\-memlimit\-compress=\fP\fIlimite\fP para possíveis maneiras de especificar o +\fIlimite\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimite\fP +Define um limite de uso de memória para descompactação multi\-thread. Isso +pode afetar apenas o número de threads; isso nunca fará com que \fBxz\fP se +recuse a descompactar um arquivo. Se \fIlimite\fP for muito baixo para permitir +qualquer multi\-thread, o \fIlimite\fP será ignorado e \fBxz\fP continuará no modo +de thread única. Observe que se \fB\-\-memlimit\-decompress\fP também for usado, +ele sempre se aplicará aos modos de thread única e multi\-thread e, portanto, +o \fIlimite\fP efetivo para multi\-threading nunca será maior que o limite +definido com \fB\-\-memlimit\-decompress\fP. +.IP "" +Em contraste com as outras opções de limite de uso de memória, +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimite\fP tem um padrão \fIlimite\fP específico do +sistema. \fBxz \-\-info\-memory\fP pode ser usado para ver o valor atual. +.IP "" +Esta opção e seu valor padrão existem porque, sem qualquer limite, o +descompactador usando threads pode acabar alocando uma quantidade insana de +memória com alguns arquivos de entrada. Se o \fIlimite\fP padrão for muito +baixo em seu sistema, sinta\-se à vontade para aumentar o \fIlimite\fP, mas +nunca defina\-o para um valor maior que a quantidade de RAM utilizável, pois +com os arquivos de entrada apropriados \fBxz\fP tentará usar essa quantidade de +memória mesmo com um baixo número de threads. Ficar sem memória ou trocar +não melhorará o desempenho da descompactação. +.IP "" +Consulte \fB\-\-memlimit\-compress=\fP\fIlimite\fP para possíveis maneiras de +especificar o \fIlimite\fP. Definir \fIlimite\fP como \fB0\fP redefine \fIlimite\fP para +o valor padrão específico do sistema. +.TP +\fB\-M\fP \fIlimite\fP, \fB\-\-memlimit=\fP\fIlimite\fP, \fB\-\-memory=\fP\fIlimite\fP +Isso é equivalente a especificar \fB\-\-memlimit\-compress=\fP\fIlimite\fP +\fB\-\-memlimit\-decompress=\fP\fIlimite\fP \fB\-\-memlimit\-mt\-decompress=\fP\fIlimite\fP. +.TP +\fB\-\-no\-adjust\fP +Exibe um erro e saia se o limite de uso de memória não puder ser atendido +sem ajustar as configurações que afetam a saída compactada. Ou seja, isso +evita que \fBxz\fP alterne o codificador do modo multi\-thread para o modo +encadeado único e reduza o tamanho do dicionário LZMA2. Mesmo quando esta +opção é usada, o número de threads pode ser reduzido para atender ao limite +de uso de memória, pois isso não afetará a saída compactada. +.IP "" +O ajuste automático é sempre desativado ao criar fluxos brutos +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fIthreads\fP, \fB\-\-threads=\fP\fIthreads\fP +Especifica o número de threads de trabalho a serem usados. Definir +\fIthreads\fP para um valor especial \fB0\fP faz com que \fBxz\fP use tantos threads +quanto o(s) processador(es) no suporte do sistema. O número real de +encadeamentos pode ser menor que \fIthreads\fP se o arquivo de entrada não for +grande o suficiente para subdividir em threads com as configurações +fornecidas ou se o uso de mais threads exceder o limite de uso de memória. +.IP "" +Os compactadores usando thread única e várias threads produzem saídas +diferentes. O compactador de thread única fornecerá o menor tamanho de +arquivo, mas apenas a saída do compactador de várias threads pode ser +descompactada usando várias threads. Definir \fIthreads\fP como \fB1\fP usará o +modo de thread única. Definir \fIthreads\fP para qualquer outro valor, +incluindo \fB0\fP, usará o compressor de várias threads, mesmo que o sistema +tenha suporte a apenas uma thread de hardware. (\fBxz\fP 5.2.x usou o modo de +thread única nesta situação.) +.IP "" +Para usar o modo de várias threads com apenas uma thread, defina \fIthreads\fP +como \fB+1\fP. O prefixo \fB+\fP não tem efeito com valores diferentes de \fB1\fP. Um +limite de uso de memória ainda pode fazer \fBxz\fP alternar para o modo de +thread única, a menos que \fB\-\-no\-adjust\fP seja usado. O suporte para o +prefixo \fB+\fP foi adicionado no \fBxz\fP 5.4.0. +.IP "" +Se um número automático de threads foi solicitado e nenhum limite de uso de +memória foi especificado, um limite flexível padrão específico do sistema +será usado para possivelmente limitar o número de threads. É um limite +flexível no sentido de que é ignorado se o número de threads se tornar um, +portanto, um limite flexível nunca impedirá \fBxz\fP de compactar ou +descompactar. Este limite flexível padrão não fará com que \fBxz\fP alterne do +modo de várias threads para o modo de thread única. Os limites ativos podem +ser vistos com \fBxz \-\-info\-memory\fP. +.IP "" +Atualmente, o único método de threading é dividir a entrada em blocos e +comprimi\-los independentemente um do outro. O tamanho padrão do bloco +depende do nível de compactação e pode ser substituído com a opção +\fB\-\-block\-size=\fP\fItamanho\fP. +.IP "" +A descompactação em threads funciona apenas em arquivos que contêm vários +blocos com informações de tamanho nos cabeçalhos dos blocos. Todos os +arquivos grandes o suficiente compactados no modo de várias thread atendem a +essa condição, mas os arquivos compactados no modo de thread única não +atendem, mesmo se \fB\-\-block\-size=\fP\fItamanho\fP tiver sido usado. +.IP "" +The default value for \fIthreads\fP is \fB0\fP. In \fBxz\fP 5.4.x and older the +default is \fB1\fP. +. +.SS "Cadeias de filtro de compressor personalizadas" +Uma cadeia de filtro personalizada permite especificar as configurações de +compactação em detalhes, em vez de confiar nas configurações associadas às +predefinições. Quando uma cadeia de filtro personalizada é especificada, as +opções predefinidas (\fB\-0\fP \&...\& \fB\-9\fP e \fB\-\-extreme\fP) anteriores na linha +de comando são esquecidas. Se uma opção predefinida for especificada após +uma ou mais opções de cadeia de filtros personalizados, a nova predefinição +entrará em vigor e as opções de cadeia de filtros personalizados +especificadas anteriormente serão esquecidas. +.PP +Uma cadeia de filtro é comparável à tubulação na linha de comando. Ao +compactar, a entrada descompactada vai para o primeiro filtro, cuja saída +vai para o próximo filtro (se houver). A saída do último filtro é gravada no +arquivo compactado. O número máximo de filtros na cadeia é quatro, mas +normalmente uma cadeia de filtros tem apenas um ou dois filtros. +.PP +Muitos filtros têm limitações sobre onde podem estar na cadeia de filtros: +alguns filtros podem funcionar apenas como o último filtro na cadeia, alguns +apenas como filtro não\-último e alguns funcionam em qualquer posição na +cadeia. Dependendo do filtro, essa limitação é inerente ao projeto do filtro +ou existe para evitar problemas de segurança. +.PP +A custom filter chain can be specified in two different ways. The options +\fB\-\-filters=\fP\fIfilters\fP and \fB\-\-filters1=\fP\fIfilters\fP \&...\& +\fB\-\-filters9=\fP\fIfilters\fP allow specifying an entire filter chain in one +option using the liblzma filter string syntax. Alternatively, a filter +chain can be specified by using one or more individual filter options in the +order they are wanted in the filter chain. That is, the order of the +individual filter options is significant! When decoding raw streams +(\fB\-\-format=raw\fP), the filter chain must be specified in the same order as +it was specified when compressing. Any individual filter or preset options +specified before the full chain option (\fB\-\-filters=\fP\fIfilters\fP) will be +forgotten. Individual filters specified after the full chain option will +reset the filter chain. +.PP +Both the full and individual filter options take filter\-specific \fIoptions\fP +as a comma\-separated list. Extra commas in \fIoptions\fP are ignored. Every +option has a default value, so specify those you want to change. +.PP +Para ver toda a cadeia de filtros e \fIopções\fP, use \fBxz \-vv\fP (isto é, use +\fB\-\-verbose\fP duas vezes). Isso também funciona para visualizar as opções da +cadeia de filtros usadas pelas predefinições. +.TP +\fB\-\-filters=\fP\fIfilters\fP +Specify the full filter chain or a preset in a single option. Each filter +can be separated by spaces or two dashes (\fB\-\-\fP). \fIfilters\fP may need to be +quoted on the shell command line so it is parsed as a single option. To +denote \fIoptions\fP, use \fB:\fP or \fB=\fP. A preset can be prefixed with a \fB\-\fP +and followed with zero or more flags. The only supported flag is \fBe\fP to +apply the same options as \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIfilters\fP ... \fB\-\-filters9\fP=\fIfilters\fP +Specify up to nine additional filter chains that can be used with +\fB\-\-block\-list\fP. +.IP "" +For example, when compressing an archive with executable files followed by +text files, the executable part could use a filter chain with a BCJ filter +and the text part only the LZMA2 filter. +.TP +\fB\-\-filters\-help\fP +Display a help message describing how to specify presets and custom filter +chains in the \fB\-\-filters\fP and \fB\-\-filters1=\fP\fIfilters\fP \&...\& +\fB\-\-filters9=\fP\fIfilters\fP options, and exit successfully. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIopções\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIopções\fP] +.PD +Adiciona o filtro LZMA1 ou LZMA2 à cadeia de filtros. Esses filtros podem +ser usados apenas como o último filtro na cadeia. +.IP "" +LZMA1 é um filtro legado, que é suportado quase exclusivamente devido ao +formato de arquivo legado \fB.lzma\fP, que suporta apenas LZMA1. LZMA2 é uma +versão atualizada do LZMA1 para corrigir alguns problemas práticos do +LZMA1. O formato \fB.xz\fP usa LZMA2 e não suporta LZMA1. A velocidade de +compactação e as proporções de LZMA1 e LZMA2 são praticamente as mesmas. +.IP "" +LZMA1 e LZMA2 compartilham o mesmo conjunto de \fIopções\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIpredefinição\fP +Redefine todas as \fIopções\fP de LZMA1 ou LZMA2 para +\fIpredefinição\fP. \fIPredefinição\fP consiste em um número inteiro, que pode ser +seguido por modificadores de predefinição de uma única letra. O inteiro pode +ser de \fB0\fP a \fB9\fP, correspondendo às opções de linha de comando \fB\-0\fP +\&...\& \fB\-9\fP. O único modificador suportado atualmente é \fBe\fP, que +corresponde a \fB\-\-extreme\fP. Se nenhum \fBpreset\fP for especificado, os valores +padrão das \fIopções\fP LZMA1 ou LZMA2 serão obtidos da predefinição \fB6\fP. +.TP +\fBdict=\fP\fItamanho\fP +O \fItamanho\fP do dicionário (buffer de histórico) indica quantos bytes dos +dados não compactados processados recentemente são mantidos na memória. O +algoritmo tenta encontrar sequências de bytes repetidos (correspondências) +nos dados não compactados e substituí\-los por referências aos dados +atualmente no dicionário. Quanto maior o dicionário, maior a chance de +encontrar uma correspondência. Portanto, aumentar o dicionário \fItamanho\fP +geralmente melhora a taxa de compactação, mas um dicionário maior que o +arquivo não compactado é um desperdício de memória. +.IP "" +Um \fItamanho\fP de dicionário típico é de 64\ KiB a 64\ MiB. O mínimo é 4\ KiB. O máximo para compactação é atualmente 1,5\ GiB (1536\ MiB). O +descompactador já oferece suporte a dicionários de até um byte a menos de 4\ GiB, que é o máximo para os formatos de fluxo LZMA1 e LZMA2. +.IP "" +O \fItamanho\fP de dicionário e o localizador de correspondência (\fImf\fP) juntos +determinam o uso de memória do codificador LZMA1 ou LZMA2. O mesmo (ou +maior) \fItamanho\fP de dicionário é necessário para descompactar que foi usado +durante a compactação, portanto, o uso de memória do decodificador é +determinado pelo tamanho do dicionário usado durante a compactação. Os +cabeçalhos \fB.xz\fP armazenam o \fItamanho\fP de dicionário como 2^\fIn\fP ou 2^\fIn\fP ++ 2^(\fIn\fP\-1), então esses \fItamanhos\fP são um tanto preferidos para +compactação. Outros \fItamanhos\fP serão arredondados quando armazenados nos +cabeçalhos \fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Especifica o número de bits de contexto literais. O mínimo é 0 e o máximo é +4; o padrão é 3. Além disso, a soma de \fIlc\fP e \fIlp\fP não deve exceder 4. +.IP "" +Todos os bytes que não podem ser codificados como correspondências são +codificados como literais. Ou seja, literais são simplesmente bytes de 8 +bits que são codificados um de cada vez. +.IP "" +A codificação literal assume que os bits \fIlc\fP mais altos do byte não +compactado anterior se correlacionam com o próximo byte. Por exemplo, em um +texto típico em inglês, uma letra maiúscula geralmente é seguida por uma +letra minúscula, e uma letra minúscula geralmente é seguida por outra letra +minúscula. No conjunto de caracteres US\-ASCII, os três bits mais altos são +010 para letras maiúsculas e 011 para letras minúsculas. Quando \fIlc\fP é pelo +menos 3, a codificação literal pode aproveitar essa propriedade nos dados +não compactados. +.IP "" +O valor padrão (3) geralmente é bom. Se você deseja compactação máxima, +experimente \fBlc=4\fP. Às vezes ajuda um pouco, às vezes piora a +compactação. Se piorar, experimente \fBlc=2\fP também. +.TP +\fBlp=\fP\fIlp\fP +Especifica o número de bits de posição literal. O mínimo é 0 e o máximo é 4; +o padrão é 0. +.IP "" +\fILp\fP afeta que tipo de alinhamento nos dados não compactados é assumido ao +codificar literais. Consulte \fIpb\fP abaixo para obter mais informações sobre +alinhamento. +.TP +\fBpb=\fP\fIpb\fP +Especifica o número de bits de posição. O mínimo é 0 e o máximo é 4; o +padrão é 2. +.IP "" +\fIPb\fP afeta que tipo de alinhamento nos dados não compactados é assumido em +geral. O padrão significa alinhamento de quatro bytes (2^\fIpb\fP=2^2=4), que +geralmente é uma boa escolha quando não há melhor estimativa. +.IP "" +Quando o alinhamento é conhecido, definir \fIpb\fP adequadamente pode reduzir +um pouco o tamanho do arquivo. Por exemplo, com arquivos de texto com +alinhamento de um byte (US\-ASCII, ISO\-8859\-*, UTF\-8), a configuração \fBpb=0\fP +pode melhorar um pouco a compactação. Para texto UTF\-16, \fBpb=1\fP é uma boa +escolha. Se o alinhamento for um número ímpar como 3 bytes, \fBpb=0\fP pode ser +a melhor escolha. +.IP "" +Embora o alinhamento assumido possa ser ajustado com \fIpb\fP e \fIlp\fP, LZMA1 e +LZMA2 ainda favorecem ligeiramente o alinhamento de 16 bytes. Pode valer a +pena levar em consideração ao projetar formatos de arquivo que provavelmente +serão compactados com LZMA1 ou LZMA2. +.TP +\fBmf=\fP\fImf\fP +O localizador de correspondência tem um efeito importante na velocidade do +codificador, uso de memória e taxa de compactação. Normalmente, os +localizadores de correspondência de Hash Chain são mais rápidos do que os +localizadores de correspondência de árvore binária. O padrão depende do +\fIpredefinição\fP: 0 usa \fBhc3\fP, 1\(en3 usa \fBhc4\fP e o resto usa \fBbt4\fP. +.IP "" +Os seguintes localizadores de correspondência são suportados. As fórmulas de +uso de memória abaixo são aproximações aproximadas, que estão mais próximas +da realidade quando \fIdict\fP é uma potência de dois. +.RS +.TP +\fBhc3\fP +Cadeia de hashs com hashing de 2 e 3 bytes +.br +Valor mínimo para \fInice\fP: 3 +.br +Uso de memória: +.br +\fIdict\fP * 7.5 (if \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 5.5 + 64 MiB (if \fIdict\fP > 16 MiB) +.TP +\fBhc4\fP +Cadeia de hashs com hashing de 2, 3 e 4 bytes +.br +Valor mínimo para \fInice\fP: 4 +.br +Uso de memória: +.br +\fIdict\fP * 7.5 (if \fIdict\fP <= 32 MiB); +.br +\fIdict\fP * 6.5 (if \fIdict\fP > 32 MiB) +.TP +\fBbt2\fP +Árvore binária com hashing de 2 bytes +.br +Valor mínimo para \fInice\fP: 2 +.br +Uso de memória: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Árvore binária com hashing de 2 e 3 bytes +.br +Valor mínimo para \fInice\fP: 3 +.br +Uso de memória: +.br +\fIdict\fP * 11.5 (if \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 9.5 + 64 MiB (if \fIdict\fP > 16 MiB) +.TP +\fBbt4\fP +Árvore binária com hashing de 2, 3 e 4 bytes +.br +Valor mínimo para \fInice\fP: 4 +.br +Uso de memória: +.br +\fIdict\fP * 11.5 (if \fIdict\fP <= 32 MiB); +.br +\fIdict\fP * 10.5 (if \fIdict\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fImodo\fP +O \fImodo\fP de compactação especifica o método para analisar os dados +produzidos pelo localizador de correspondência. Os \fImodos\fP suportados são +\fBfast\fP e \fBnormal\fP. O padrão é \fBfast\fP para \fIpredefinições\fP 0\(en3 e +\fBnormal\fP para \fIpredefinições\fP 4\(en9. +.IP "" +Normalmente, \fBfast\fP é usado com localizadores de correspondência cadeia de +hashs e \fBnormal\fP com localizadores de correspondência de árvore +binária. Isso também é o que os \fIpredefinições\fP fazem. +.TP +\fBnice=\fP\fInice\fP +Especifica o que é considerado um bom comprimento para uma +correspondência. Uma vez que uma correspondência de pelo menos \fInice\fP bytes +é encontrada, o algoritmo para de procurar correspondências possivelmente +melhores. +.IP "" +\fINice\fP pode ser 2\(en273 bytes. Valores mais altos tendem a fornecer melhor +taxa de compactação em detrimento da velocidade. O padrão depende do +\fIpredefinição\fP. +.TP +\fBdepth=\fP\fIprofundidade\fP +Especifica a profundidade máxima de pesquisa no localizador de +correspondências. O padrão é o valor especial de 0, que faz com que o +compressor determine um \fIprofundidade\fP razoável de \fImf\fP e \fInice\fP. +.IP "" +Uma \fIprofundidade\fP razoável para cadeias de hash é 4\(en100 e 16\(en1000 +para árvores binárias. Usar valores muito altos para \fIprofundidade\fP pode +tornar o codificador extremamente lento com alguns arquivos. Evite definir +\fIprofundidade\fP acima de 1000 a menos que você esteja preparado para +interromper a compactação caso ela esteja demorando muito. +.RE +.IP "" +Ao decodificar fluxos brutos (\fB\-\-format=raw\fP), o LZMA2 precisa apenas do +dicionário \fItamanho\fP. LZMA1 também precisa de \fIlc\fP, \fIlp\fP e \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIopções\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIopções\fP] +.PD +Adiciona um filtro de ramificação/chamada/salto (BCJ) à cadeia de +filtros. Esses filtros podem ser usados apenas como um filtro não último na +cadeia de filtros. +.IP "" +Um filtro BCJ converte endereços relativos no código de máquina em suas +contrapartes absolutas. Isso não altera o tamanho dos dados, mas aumenta a +redundância, o que pode ajudar o LZMA2 a produzir um arquivo \fB.xz\fP 0\(en15\ % menor. Os filtros BCJ são sempre reversíveis, portanto, usar um filtro BCJ +para o tipo errado de dados não causa nenhuma perda de dados, embora possa +piorar um pouco a taxa de compactação.Os filtros BCJ são muito rápidos e +usam uma quantidade insignificante de memória. +.IP "" +Esses filtros BCJ têm problemas conhecidos relacionados à taxa de +compactação: +.RS +.IP \(bu 3 +Alguns tipos de arquivos contendo código executável (por exemplo, arquivos +de objeto, bibliotecas estáticas e módulos do kernel do Linux) têm os +endereços nas instruções preenchidos com valores de preenchimento. Esses +filtros BCJ ainda vão fazer a conversão de endereço, o que vai piorar a +compactação desses arquivos. +.IP \(bu 3 +Se um filtro BCJ for aplicado em um arquivo, é possível que isso torne a +taxa de compactação pior do que não usar um filtro BCJ. Por exemplo, se +houver executáveis semelhantes ou mesmo idênticos, a filtragem provavelmente +tornará os arquivos menos semelhantes e, portanto, a compactação será +pior. O conteúdo de arquivos não executáveis no mesmo arquivo também pode +ser importante. Na prática tem que tentar com e sem filtro BCJ para ver qual +é melhor em cada situação. +.RE +.IP "" +Conjuntos de instruções diferentes têm alinhamento diferente: o arquivo +executável deve ser alinhado a um múltiplo desse valor nos dados de entrada +para fazer o filtro funcionar. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filtro;Alinhamento;Observações +x86;1;x86 32 bits ou 64 bits +ARM;4; +ARM\-Thumb;2; +ARM64;4;Alinhamento de 4096 bytes +;;é melhor +PowerPC;4;Somente big endian +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Since the BCJ\-filtered data is usually compressed with LZMA2, the +compression ratio may be improved slightly if the LZMA2 options are set to +match the alignment of the selected BCJ filter. Examples: +.RS +.IP \(bu 3 +IA\-64 filter has 16\-byte alignment so \fBpb=4,lp=4,lc=0\fP is good with LZMA2 +(2^4=16). +.IP \(bu 3 +RISC\-V code has 2\-byte or 4\-byte alignment depending on whether the file +contains 16\-bit compressed instructions (the C extension). When 16\-bit +instructions are used, \fBpb=2,lp=1,lc=3\fP or \fBpb=1,lp=1,lc=3\fP is good. When +16\-bit instructions aren't present, \fBpb=2,lp=2,lc=2\fP is the best. +\fBreadelf \-h\fP can be used to check if "RVC" appears on the "Flags" line. +.IP \(bu 3 +ARM64 is always 4\-byte aligned so \fBpb=2,lp=2,lc=2\fP is the best. +.IP \(bu 3 +The x86 filter is an exception. It's usually good to stick to LZMA2's +defaults (\fBpb=2,lp=0,lc=3\fP) when compressing x86 executables. +.RE +.IP "" +Todos os filtros BCJ suportam as mesmas \fIopções\fP: +.RS +.TP +\fBstart=\fP\fIdeslocamento\fP +Especifica o \fIdeslocamento\fP inicial que é usado na conversão entre +endereços relativos e absolutos. O \fIdeslocamento\fP deve ser um múltiplo do +alinhamento do filtro (ver tabela acima). O padrão é zero. Na prática, o +padrão é bom; especificar um \fIdeslocamento\fP personalizado quase nunca é +útil. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIopções\fP] +Adiciona o filtro Delta à cadeia de filtros. O filtro Delta só pode ser +usado como filtro não\-último na cadeia de filtros. +.IP "" +Atualmente, apenas o cálculo simples de delta byte a byte é suportado. Pode +ser útil ao compactar, por exemplo, imagens bitmap não compactadas ou áudio +PCM não compactado. No entanto, algoritmos de propósito especial podem +fornecer resultados significativamente melhores do que Delta + LZMA2. Isso é +verdade especialmente com áudio, que compacta mais rápido e melhor, por +exemplo, com \fBflac\fP(1). +.IP "" +\fIOpções\fP suportadas: +.RS +.TP +\fBdist=\fP\fIdistância\fP +Especifica a \fIdistância\fP do cálculo delta em bytes. \fIdistância\fP deve ser +1\(en256. O padrão é 1. +.IP "" +Por exemplo, com \fBdist=2\fP e entrada de oito bytes A1 B1 A2 B3 A3 B5 A4 B7, +a saída será A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Outras opções" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Suprime avisos e avisos. Especifique isso duas vezes para suprimir erros +também. Esta opção não tem efeito no status de saída. Ou seja, mesmo que um +aviso tenha sido suprimido, o status de saída para indicar um aviso ainda é +usado. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Ser detalhado. Se o erro padrão estiver conectado a um terminal, \fBxz\fP +exibirá um indicador de progresso. Especifique \fB\-\-verbose\fP duas vezes dará +uma saída ainda mais detalhada. +.IP "" +O indicador de progresso mostra as seguintes informações: +.RS +.IP \(bu 3 +A porcentagem de conclusão é mostrada se o tamanho do arquivo de entrada for +conhecido. Ou seja, a porcentagem não pode ser mostrada em encadeamentos +(pipe). +.IP \(bu 3 +Quantidade de dados compactados produzidos (compactando) ou consumidos +(descompactando). +.IP \(bu 3 +Quantidade de dados não compactados consumidos (compactação) ou produzidos +(descompactação). +.IP \(bu 3 +Taxa de compactação, que é calculada dividindo a quantidade de dados +compactados processados até o momento pela quantidade de dados não +compactados processados até o momento. +.IP \(bu 3 +Velocidade de compactação ou descompactação. Isso é medido como a quantidade +de dados não compactados consumidos (compactação) ou produzidos +(descompactação) por segundo. É mostrado após alguns segundos desde que +\fBxz\fP começou a processar o arquivo. +.IP \(bu 3 +Tempo decorrido no formato M:SS ou H:MM:SS. +.IP \(bu 3 +O tempo restante estimado é mostrado apenas quando o tamanho do arquivo de +entrada é conhecido e alguns segundos já se passaram desde que \fBxz\fP começou +a processar o arquivo. A hora é mostrada em um formato menos preciso que +nunca tem dois pontos, por exemplo, 2 min 30 s. +.RE +.IP "" +Quando o erro padrão não é um terminal, \fB\-\-verbose\fP fará com que \fBxz\fP +imprima o nome do arquivo, tamanho compactado, tamanho não compactado, taxa +de compactação e possivelmente também a velocidade e o tempo decorrido em +uma única linha para o erro padrão após a compactação ou descompactando o +arquivo. A velocidade e o tempo decorrido são incluídos apenas quando a +operação leva pelo menos alguns segundos. Se a operação não foi concluída, +por exemplo, devido à interrupção do usuário, também é impressa a +porcentagem de conclusão se o tamanho do arquivo de entrada for conhecido. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Não define o status de saída como 2, mesmo que uma condição digna de um +aviso tenha sido detectada. Esta opção não afeta o nível de detalhamento, +portanto, tanto \fB\-\-quiet\fP quanto \fB\-\-no\-warn\fP devem ser usados para não +exibir avisos e não alterar o status de saída. +.TP +\fB\-\-robot\fP +Imprime mensagens em um formato analisável por máquina. Isso visa facilitar +a criação de frontends que desejam usar \fBxz\fP em vez de liblzma, o que pode +ser o caso de vários scripts. A saída com esta opção habilitada deve ser +estável em versões \fBxz\fP. Consulte a seção \fBMODO ROBÔ\fP para obter detalhes. +.TP +\fB\-\-info\-memory\fP +Exibe, em formato legível por humanos, quanta memória física (RAM) e quantos +threads de processador \fBxz\fP acredita que o sistema possui e os limites de +uso de memória para compactação e descompactação e saia com êxito. +.TP +\fB\-h\fP, \fB\-\-help\fP +Exibe uma mensagem de ajuda descrevendo as opções mais usadas e sai com +sucesso. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Exibe uma mensagem de ajuda descrevendo todos os recursos de \fBxz\fP e sai com +sucesso +.TP +\fB\-V\fP, \fB\-\-version\fP +Exibe o número da versão de \fBxz\fP e liblzma em formato legível por +humanos. Para obter uma saída analisável por máquina, especifique \fB\-\-robot\fP +antes de \fB\-\-version\fP. +. +.SH "MODO ROBÔ" +The robot mode is activated with the \fB\-\-robot\fP option. It makes the output +of \fBxz\fP easier to parse by other programs. Currently \fB\-\-robot\fP is +supported only together with \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, +and \fB\-\-version\fP. It will be supported for compression and decompression in +the future. +. +.SS "Modo lista" +\fBxz \-\-robot \-\-list\fP usa saída separada por tabulações. A primeira coluna de +cada linha possui uma string que indica o tipo de informação encontrada +naquela linha: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Esta é sempre a primeira linha ao começar a listar um arquivo. A segunda +coluna na linha é o nome do arquivo. +.TP +\fBfile\fP +Esta linha contém informações gerais sobre o arquivo \fB.xz\fP. Esta linha é +sempre impressa após a linha \fBname\fP. +.TP +\fBstream\fP +Este tipo de linha é usado somente quando \fB\-\-verbose\fP foi +especificado. Existem tantas linhas de \fBstream\fP quanto fluxos no arquivo +\&\fB.xz\fP. +.TP +\fBblock\fP +Este tipo de linha é usado somente quando \fB\-\-verbose\fP foi +especificado. Existem tantas linhas \fBblock\fP quanto blocos no arquivo +\&\fB.xz\fP. As linhas \fBblock\fP são mostradas após todas as linhas \fBstream\fP; +diferentes tipos de linha não são intercalados. +.TP +\fBsummary\fP +Este tipo de linha é usado apenas quando \fB\-\-verbose\fP foi especificado duas +vezes. Esta linha é impressa após todas as linhas de \fBblock\fP. Assim como a +linha \fBarquivo\fP, a linha \fBsummary\fP contém informações gerais sobre o +arquivo \fB.xz\fP. +.TP +\fBtotals\fP +Esta linha é sempre a última linha da saída da lista. Ele mostra as +contagens totais e tamanhos. +.PP +As colunas das linhas \fBfile\fP: +.PD 0 +.RS +.IP 2. 4 +Número de fluxos no arquivo +.IP 3. 4 +Número total de blocos no(s) fluxo(s) +.IP 4. 4 +Tamanho compactado do arquivo +.IP 5. 4 +Uncompressed size of the file +.IP 6. 4 +Taxa de compactação, por exemplo, \fB0.123\fP. Se a proporção for superior a +9.999, serão exibidos três traços (\fB\-\-\-\fP) em vez da proporção. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Lista separada por vírgulas de nomes de verificação de integridade. As +seguintes strings são usadas para os tipos de verificação conhecidos: +\fBNone\fP, \fBCRC32\fP, \fBCRC64\fP e \fBSHA\-256\fP. Para tipos de verificações +desconhecidos, \fBUnknown\-\fP\fIN\fP é usado, onde \fIN\fP é o ID do cheque como um +número decimal (um ou dois dígitos). +.IP 8. 4 +Tamanho total do preenchimento de fluxo no arquivo +.RE +.PD +.PP +As colunas das linhas \fBstream\fP: +.PD 0 +.RS +.IP 2. 4 +Número do fluxo (o primeiro fluxo é 1) +.IP 3. 4 +Número de blocos no fluxo +.IP 4. 4 +Deslocamento inicial compactado +.IP 5. 4 +Deslocamento inicial descompactado +.IP 6. 4 +Tamanho compactado (não inclui preenchimento de fluxo) +.IP 7. 4 +Tamanho descompactado +.IP 8. 4 +Taxa de compactação +.IP 9. 4 +Nome da verificação de integridade +.IP 10. 4 +Tamanho do preenchimento do fluxo +.RE +.PD +.PP +As colunas das linhas \fBblock\fP: +.PD 0 +.RS +.IP 2. 4 +Número do fluxo que contém este bloco +.IP 3. 4 +Número do bloco relativo ao início do fluxo (o primeiro bloco é 1) +.IP 4. 4 +Número do bloco relativo ao início do arquivo +.IP 5. 4 +Deslocamento inicial compactado em relação ao início do arquivo +.IP 6. 4 +Deslocamento inicial descompactado em relação ao início do arquivo +.IP 7. 4 +Tamanho total compactado do bloco (inclui cabeçalhos) +.IP 8. 4 +Tamanho descompactado +.IP 9. 4 +Taxa de compactação +.IP 10. 4 +Nome da verificação de integridade +.RE +.PD +.PP +Se \fB\-\-verbose\fP for especificado duas vezes, colunas adicionais serão +incluídas nas linhas \fBblock\fP. Eles não são exibidos com um único +\fB\-\-verbose\fP, porque obter essas informações requer muitas buscas e, +portanto, pode ser lento: +.PD 0 +.RS +.IP 11. 4 +Valor da verificação de integridade em hexadecimal +.IP 12. 4 +Tamanho do cabeçalho do bloco +.IP 13. 4 +Sinalizadores de bloco: \fBc\fP indica que o tamanho compactado está presente e +\fBu\fP indica que o tamanho não compactado está presente. Se o sinalizador não +estiver definido, um traço (\fB\-\fP) será exibido para manter o comprimento da +string fixo. Novos sinalizadores podem ser adicionados ao final da string no +futuro. +.IP 14. 4 +Tamanho dos dados reais compactados no bloco (isso exclui o cabeçalho do +bloco, o preenchimento do bloco e os campos de verificação) +.IP 15. 4 +Quantidade de memória (em bytes) necessária para descompactar este bloco com +esta versão \fBxz\fP +.IP 16. 4 +Cadeia de filtro. Observe que a maioria das opções usadas no momento da +compactação não pode ser conhecida, pois apenas as opções necessárias para a +descompactação são armazenadas nos cabeçalhos \fB.xz\fP. +.RE +.PD +.PP +As colunas das linhas \fBsummary\fP: +.PD 0 +.RS +.IP 2. 4 +Quantidade de memória (em bytes) necessária para descompactar este arquivo +com esta versão do \fBxz\fP +.IP 3. 4 +\fByes\fP ou \fBno\fP indicando se todos os cabeçalhos de bloco têm tamanho +compactado e tamanho não compactado armazenados neles +.PP +\fIDesde\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Versão mínima do \fBxz\fP necessária para descompactar o arquivo +.RE +.PD +.PP +As colunas da linha \fBtotals\fP: +.PD 0 +.RS +.IP 2. 4 +Número de fluxos +.IP 3. 4 +Número de blocos +.IP 4. 4 +Tamanho compactado +.IP 5. 4 +Tamanho descompactado +.IP 6. 4 +Taxa de compactação média +.IP 7. 4 +Lista separada por vírgulas de nomes de verificação de integridade que +estavam presentes nos arquivos +.IP 8. 4 +Tamanho do preenchimento do fluxo +.IP 9. 4 +Número de arquivos. Isso está aqui para manter a ordem das colunas +anteriores a mesma das linhas \fBfile\fP. +.PD +.RE +.PP +Se \fB\-\-verbose\fP for especificado duas vezes, colunas adicionais serão +incluídas na linha \fBtotals\fP: +.PD 0 +.RS +.IP 10. 4 +Quantidade máxima de memória (em bytes) necessária para descompactar os +arquivos com esta versão do \fBxz\fP +.IP 11. 4 +\fByes\fP ou \fBno\fP indicando se todos os cabeçalhos de bloco têm tamanho +compactado e tamanho não compactado armazenados neles +.PP +\fIDesde\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Versão mínima do \fBxz\fP necessária para descompactar o arquivo +.RE +.PD +.PP +Versões futuras podem adicionar novos tipos de linha e novas colunas podem +ser adicionadas aos tipos de linha existentes, mas as colunas existentes não +serão alteradas. +. +.SS "Filters help" +\fBxz \-\-robot \-\-filters\-help\fP prints the supported filters in the following +format: +.PP +\fIfilter\fP\fB:\fP\fIoption\fP\fB=<\fP\fIvalue\fP\fB>,\fP\fIoption\fP\fB=<\fP\fIvalue\fP\fB>\fP... +.TP +\fIfilter\fP +Name of the filter +.TP +\fIoption\fP +Name of a filter specific option +.TP +\fIvalue\fP +Numeric \fIvalue\fP ranges appear as \fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. String +\fIvalue\fP choices are shown within \fB< >\fP and separated by a \fB|\fP +character. +.PP +Each filter is printed on its own line. +. +.SS "Informações de limite de memória" +\fBxz \-\-robot \-\-info\-memory\fP prints a single line with multiple tab\-separated +columns: +.IP 1. 4 +Quantidade total de memória física (RAM) em bytes. +.IP 2. 4 +Limite de uso de memória para compactação em bytes +(\fB\-\-memlimit\-compress\fP). Um valor especial de \fB0\fP indica a configuração +padrão que para o modo de thread única é o mesmo que sem limite. +.IP 3. 4 +Limite de uso de memória para descompactação em bytes +(\fB\-\-memlimit\-decompress\fP). Um valor especial de \fB0\fP indica a configuração +padrão que para o modo de thread única é o mesmo que sem limite. +.IP 4. 4 +Desde \fBxz\fP 5.3.4alpha: Uso de memória para descompactação com várias thread +em bytes (\fB\-\-memlimit\-mt\-decompress\fP). Isso nunca é zero porque um valor +padrão específico do sistema mostrado na coluna 5 é usado se nenhum limite +for especificado explicitamente. Isso também nunca é maior que o valor na +coluna 3, mesmo que um valor maior tenha sido especificado com +\fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Desde \fBxz\fP 5.3.4alpha: Um limite de uso de memória padrão específico do +sistema que é usado para limitar o número de threads ao compactar com um +número automático de threads (\fB\-\-threads=0\fP) e nenhum limite de uso de +memória foi especificado (\fB\-\-memlimit\-compress\fP). Isso também é usado como +o valor padrão para \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Desde \fBxz\fP 5.3.4alpha: Número de threads de processador disponíveis. +.PP +No futuro, a saída de \fBxz \-\-robot \-\-info\-memory\fP pode ter mais colunas, mas +nunca mais do que uma única linha. +. +.SS Versão +\fBxz \-\-robot \-\-version\fP prints the version number of \fBxz\fP and liblzma in +the following format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Versão principal. +.TP +\fIYYY\fP +Versão menor. Números pares são estáveis. Os números ímpares são versões +alfa ou beta. +.TP +\fIZZZ\fP +Nível de patch para versões estáveis ou apenas um contador para versões de +desenvolvimento. +.TP +\fIS\fP +Estabilidade. 0 é alfa, 1 é beta e 2 é estável. \fIS\fP deve ser sempre 2 +quando \fIYYY\fP for par. +.PP +\fIXYYYZZZS\fP são iguais em ambas as linhas se \fBxz\fP e liblzma forem da mesma +versão do XZ Utils. +.PP +Exemplos: 4.999.9beta é \fB49990091\fP e 5.0.0 é \fB50000002\fP. +. +.SH "STATUS DE SAÍDA" +.TP +\fB0\fP +Está tudo bem. +.TP +\fB1\fP +Ocorreu um erro. +.TP +\fB2\fP +Algo digno de um aviso ocorreu, mas ocorreu nenhum erro real. +.PP +Observações (não avisos ou erros) impressas no erro padrão não afetam o +status de saída. +. +.SH AMBIENTE +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP analisa listas de opções separadas por espaços das variáveis de +ambiente \fBXZ_DEFAULTS\fP e \fBXZ_OPT\fP, nesta ordem, antes de analisar as +opções da linha de comando. Observe que apenas as opções são analisadas a +partir das variáveis de ambiente; todas as não opções são silenciosamente +ignoradas. A análise é feita com \fBgetopt_long\fP(3) que também é usado para +os argumentos da linha de comando. +.PP +\fBWarning:\fP By setting these environment variables, one is effectively +modifying programs and scripts that run \fBxz\fP. Most of the time it is safe +to set memory usage limits, number of threads, and compression options via +the environment variables. However, some options can break scripts. An +obvious example is \fB\-\-help\fP which makes \fBxz\fP show the help text instead of +compressing or decompressing a file. More subtle examples are \fB\-\-quiet\fP +and \fB\-\-verbose\fP. In many cases it works well to enable the progress +indicator using \fB\-\-verbose\fP, but in some situations the extra messages +create problems. The verbosity level also affects the behavior of +\fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +User\-specific or system\-wide default options. Typically this is set in a +shell initialization script to enable \fBxz\fP's memory usage limiter by +default or set the default number of threads. Excluding shell +initialization scripts and similar special cases, scripts should never set +or unset \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Isso é para passar opções para \fBxz\fP quando não é possível definir as opções +diretamente na linha de comando \fBxz\fP. Este é o caso quando \fBxz\fP é +executado por um script ou ferramenta, por exemplo, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Os scripts podem usar \fBXZ_OPT\fP, por exemplo, para definir opções de +compactação padrão específicas do script. Ainda é recomendável permitir que +os usuários substituam \fBXZ_OPT\fP se isso for razoável. Por exemplo, em +scripts \fBsh\fP(1) pode\-se usar algo assim: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "COMPATIBILIDADE COM LZMA UTILS" +A sintaxe da linha de comando do \fBxz\fP é praticamente um superconjunto de +\fBlzma\fP, \fBunlzma\fP e \fBlzcat\fP conforme encontrado no LZMA Utils 4.32.x. Na +maioria dos casos, é possível substituir LZMA Utils por XZ Utils sem +interromper os scripts existentes. Existem algumas incompatibilidades, +porém, que às vezes podem causar problemas. +. +.SS "Níveis de predefinição de compactação" +A numeração das predefinições de nível de compactação não é idêntica em +\fBxz\fP e LZMA Utils. A diferença mais importante é como os tamanhos dos +dicionários são mapeados para diferentes predefinições. O tamanho do +dicionário é aproximadamente igual ao uso de memória do descompactador. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nível;xz;LZMA Utils +\-0;256 KiB;N/D +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +As diferenças de tamanho do dicionário também afetam o uso da memória do +compressor, mas existem algumas outras diferenças entre LZMA Utils e XZ +Utils, que tornam a diferença ainda maior: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nível;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/D +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +O nível de predefinição padrão no LZMA Utils é \fB\-7\fP enquanto no XZ Utils é +\fB\-6\fP, então ambos usam um dicionário de 8 MiB por padrão. +. +.SS "Arquivos .lzma em um fluxo versus sem ser em um fluxo" +O tamanho descompactado do arquivo pode ser armazenado no cabeçalho de +\&\fB.lzma\fP. O LZMA Utils faz isso ao compactar arquivos comuns. A alternativa +é marcar que o tamanho não compactado é desconhecido e usar o marcador de +fim de carga útil para indicar onde o descompactador deve parar. O LZMA +Utils usa este método quando o tamanho não compactado não é conhecido, como +é o caso, por exemplo, de encadeamentos (pipes). +.PP +\fBxz\fP oferece suporte à descompactação de arquivos \fB.lzma\fP com ou sem +marcador de fim de carga útil, mas todos os arquivos \fB.lzma\fP criados por +\fBxz\fP usarão marcador de fim de carga útil e terão o tamanho descompactado +marcado como desconhecido no cabeçalho de \fB.lzma\fP. Isso pode ser um +problema em algumas situações incomuns. Por exemplo, um descompactador de +\&\fB.lzma\fP em um dispositivo embarcado pode funcionar apenas com arquivos que +tenham tamanho descompactado conhecido. Se você encontrar esse problema, +precisará usar o LZMA Utils ou o LZMA SDK para criar arquivos \fB.lzma\fP com +tamanho descompactado conhecido. +. +.SS "Arquivos .lzma não suportados" +O formato \fB.lzma\fP permite valores \fIlc\fP até 8 e valores \fIlp\fP até 4. LZMA +Utils pode descompactar arquivos com qualquer \fIlc\fP e \fIlp\fP, mas sempre cria +arquivos com \fBlc=3\fP e \fBlp=0\fP. Criar arquivos com outros \fIlc\fP e \fIlp\fP é +possível com \fBxz\fP e com LZMA SDK. +.PP +A implementação do filtro LZMA1 em liblzma requer que a soma de \fIlc\fP e +\fIlp\fP não exceda 4. Assim, arquivos \fB.lzma\fP, que excedam esta limitação, +não podem ser descompactados com \fBxz\fP. +.PP +LZMA Utils cria apenas arquivos \fB.lzma\fP que possuem um tamanho de +dicionário de 2^\fIn\fP (uma potência de 2), mas aceita arquivos com qualquer +tamanho de dicionário. liblzma aceita apenas arquivos \fB.lzma\fP que tenham um +tamanho de dicionário de 2^\fIn\fP ou 2^\fIn\fP + 2^(\fIn\fP\-1). Isso é para diminuir +os falsos positivos ao detectar arquivos \fB.lzma\fP. +.PP +Essas limitações não devem ser um problema na prática, já que praticamente +todos os arquivos \fB.lzma\fP foram compactados com configurações que o liblzma +aceitará. +. +.SS "Lixo à direita" +Ao descompactar, o LZMA Utils silenciosamente ignora tudo após o primeiro +fluxo \fB.lzma\fP. Na maioria das situações, isso é um bug. Isso também +significa que o LZMA Utils não oferece suporte a descompactação de arquivos +\&\fB.lzma\fP concatenados. +.PP +Se houver dados restantes após o primeiro fluxo de \fB.lzma\fP, \fBxz\fP considera +o arquivo corrompido, a menos que \fB\-\-single\-stream\fP tenha sido usado. Isso +pode quebrar scripts obscuros que presumiram que o lixo à direita é +ignorado. +. +.SH NOTAS +. +.SS "A saída compactada pode variar" +A saída compactada exata produzida a partir do mesmo arquivo de entrada não +compactado pode variar entre as versões do XZ Utils, mesmo se as opções de +compactação forem idênticas. Isso ocorre porque o codificador pode ser +aprimorado (compactação mais rápida ou melhor) sem afetar o formato do +arquivo. A saída pode variar mesmo entre diferentes compilações da mesma +versão do XZ Utils, se diferentes opções de compilação forem usadas. +.PP +A informação acima significa que, uma vez que \fB\-\-rsyncable\fP tenha sido +implementado, os arquivos resultantes não serão necessariamente +"rsyncáveis", a menos que os arquivos antigos e novos tenham sido +compactados com a mesma versão xz. Esse problema pode ser corrigido se uma +parte da implementação do codificador for congelada para manter a saída de +rsyncable estável nas versões do xz. +. +.SS "Descompactadores .xz embarcados" +As implementações do descompactador \fB.xz\fP embarcados, como o XZ Embedded, +não oferecem necessariamente suporte a arquivos criados com tipos de +\fIverificações\fP de integridade diferentes de \fBnone\fP e \fBcrc32\fP. Como o +padrão é \fB\-\-check=crc64\fP, você deve usar \fB\-\-check=none\fP ou +\fB\-\-check=crc32\fP ao criar arquivos para sistemas embarcados. +.PP +Fora dos sistemas embarcados, todos os descompactadores de formato \fB.xz\fP +oferecem suporte a todos os tipos de \fIverificação\fP ou, pelo menos, são +capazes de descompactar o arquivo sem verificar a verificação de integridade +se a \fIverificação\fP específica não for suportada. +.PP +XZ Embedded oferece suporte a filtros BCJ, mas apenas com o deslocamento +inicial padrão. +. +.SH EXEMPLOS +. +.SS Básico +Compactar o arquivo \fIfoo\fP em \fIfoo.xz\fP usando o nível de compactação padrão +(\fB\-6\fP) e remover \fIfoo\fP se a compactação for bem\-sucedida: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Descompactar \fIbar.xz\fP em \fIbar\fP e não remover \fIbar.xz\fP mesmo se a +descompactação for bem\-sucedida: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Criar \fIbaz.tar.xz\fP com a predefinição \fB\-4e\fP (\fB\-4 \-\-extreme\fP), que é mais +lenta que o padrão \fB\-6\fP, mas precisa de menos memória para compactação e +descompactação (48 \ MiB e 5\ MiB, respectivamente): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Uma mistura de arquivos compactados e descompactados pode ser descompactada +para a saída padrão com um único comando: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Compactação paralela de muitos arquivos" +No GNU e *BSD, \fBfind\fP(1) e \fBxargs\fP(1) podem ser usados para paralelizar a +compactação de muitos arquivos: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +A opção \fB\-P\fP para \fBxargs\fP(1) define o número de processos paralelos do +\fBxz\fP. O melhor valor para a opção \fB\-n\fP depende de quantos arquivos devem +ser compactados. Se houver apenas alguns arquivos, o valor provavelmente +deve ser 1; com dezenas de milhares de arquivos, 100 ou até mais podem ser +apropriados para reduzir o número de processos de \fBxz\fP que \fBxargs\fP(1) +eventualmente criará. +.PP +A opção \fB\-T1\fP para \fBxz\fP existe para forçá\-lo ao modo de thread única, +porque \fBxargs\fP(1) é usado para controlar a quantidade de paralelização. +. +.SS "Modo robô" +Calcular quantos bytes foram salvos no total depois de compactar vários +arquivos: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Um script pode querer saber que está usando \fBxz\fP novo o suficiente. O +seguinte script \fBsh\fP(1) verifica se o número da versão da ferramenta \fBxz\fP +é pelo menos 5.0.0. Este método é compatível com versões beta antigas, que +não suportavam a opção \fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Definir um limite de uso de memória para descompactação usando \fBXZ_OPT\fP, +mas se um limite já tiver sido definido, não o aumentar: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Cadeias de filtro de compressor personalizadas" +O uso mais simples para cadeias de filtro personalizadas é personalizar uma +predefinição LZMA2. Isso pode ser útil, porque as predefinições abrangem +apenas um subconjunto das combinações potencialmente úteis de configurações +de compactação. +.PP +As colunas CompCPU das tabelas das descrições das opções \fB\-0\fP ... \fB\-9\fP e +\fB\-\-extreme\fP são úteis ao personalizar as predefinições LZMA2. Aqui estão as +partes relevantes coletadas dessas duas tabelas: +.RS +.PP +.TS +tab(;); +c c +n n. +Predefinição;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Se você sabe que um arquivo requer um dicionário um tanto grande (por +exemplo, 32\ MiB) para compactar bem, mas deseja comprimi\-lo mais +rapidamente do que \fBxz \-8\fP faria, uma predefinição com um valor CompCPU +baixo (por exemplo, 1) pode ser modificado para usar um dicionário maior: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Com certos arquivos, o comando acima pode ser mais rápido que \fBxz \-6\fP +enquanto compacta significativamente melhor. No entanto, deve\-se enfatizar +que apenas alguns arquivos se beneficiam de um grande dicionário, mantendo o +valor CompCPU baixo. A situação mais óbvia, onde um grande dicionário pode +ajudar muito, é um arquivo contendo arquivos muito semelhantes de pelo menos +alguns megabytes cada. O tamanho do dicionário deve ser significativamente +maior do que qualquer arquivo individual para permitir que o LZMA2 aproveite +ao máximo as semelhanças entre arquivos consecutivos. +.PP +Se o uso muito alto de memória do compactador e do descompactador for bom e +o arquivo que está sendo compactado tiver pelo menos várias centenas de +megabytes, pode ser útil usar um dicionário ainda maior do que os 64 MiB que +o \fBxz \-9\fP usaria: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Usar \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) como no exemplo acima pode ser útil +para ver os requisitos de memória do compactador e do +descompactador. Lembre\-se que usar um dicionário maior que o tamanho do +arquivo descompactado é desperdício de memória, então o comando acima não é +útil para arquivos pequenos. +.PP +Às vezes, o tempo de compactação não importa, mas o uso de memória do +descompactador deve ser mantido baixo, por exemplo, para possibilitar a +descompactação do arquivo em um sistema embarcado. O comando a seguir usa +\fB\-6e\fP (\fB\-6 \-\-extreme\fP) como base e define o dicionário como apenas 64\ KiB. O arquivo resultante pode ser descompactado com XZ Embedded (é por isso +que existe \fB\-\-check=crc32\fP) usando cerca de 100\ KiB de memória. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Se você deseja espremer o máximo de bytes possível, ajustar o número de bits +de contexto literal (\fIlc\fP) e o número de bits de posição (\fIpb\fP) às vezes +pode ajudar. Ajustar o número de bits de posição literal (\fIlp\fP) também pode +ajudar, mas geralmente \fIlc\fP e \fIpb\fP são mais importantes. Por exemplo, um +arquivo de código\-fonte contém principalmente texto US\-ASCII, então algo +como o seguinte pode fornecer um arquivo ligeiramente (como 0,1\ %) menor +que \fBxz \-6e\fP (tente também sem \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +O uso de outro filtro junto com o LZMA2 pode melhorar a compactação com +determinados tipos de arquivo. Por exemplo, para compactar uma biblioteca +compartilhada x86\-32 ou x86\-64 usando o filtro x86 BCJ: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Observe que a ordem das opções de filtro é significativa. Se \fB\-\-x86\fP for +especificado após \fB\-\-lzma2\fP, \fBxz\fP dará um erro, porque não pode haver +nenhum filtro após LZMA2 e também porque o filtro x86 BCJ não pode ser usado +como o último filtro em a corrente. +.PP +O filtro Delta junto com LZMA2 pode dar bons resultados com imagens +bitmap. Ele geralmente deve superar o PNG, que possui alguns filtros mais +avançados do que o delta simples, mas usa Deflate para a compactação real. +.PP +A imagem deve ser salva em formato não compactado, por exemplo, como TIFF +não compactado. O parâmetro de distância do filtro Delta é definido para +corresponder ao número de bytes por pixel na imagem. Por exemplo, bitmap RGB +de 24 bits precisa de \fBdist=3\fP, e também é bom passar \fBpb=0\fP para LZMA2 +para acomodar o alinhamento de três bytes: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Se várias imagens foram colocadas em um único arquivo (por exemplo, +\&\fB.tar\fP), o filtro Delta também funcionará, desde que todas as imagens +tenham o mesmo número de bytes por pixel. +. +.SH "VEJA TAMBÉM" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/xz.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/xz.1 new file mode 100644 index 0000000000000000000000000000000000000000..0f85fc96ac66488096221e723d837e7d28ff6bc2 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/xz.1 @@ -0,0 +1,1994 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Brazilian Portuguese translations for xz package +.\" Traduções em português brasileiro para o pacote xz. +.\" Rafael Fontenelle , 2022-2023. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 2025\-03\-08 Tukaani "XZ Utils" +. +.SH NOME +xz, unxz, xzcat, lzma, unlzma, lzcat \- Compacta ou descompacta arquivos .xz +e .lzma +. +.SH SINOPSE +\fBxz\fP [\fIopção...\fP] [\fIarquivo...\fP] +. +.SH "COMANDOS APELIDOS" +\fBunxz\fP é equivalente a \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP é equivalente a \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP é equivalente a \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP é equivalente a \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP é equivalente a \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Ao escrever scripts que precisam descompactar arquivos, é recomendável +sempre usar o nome \fBxz\fP com os argumentos apropriados (\fBxz \-d\fP ou \fBxz \-dc\fP) em vez dos nomes \fBunxz\fP e \fBxzcat\fP. +. +.SH DESCRIÇÃO +\fBxz\fP é uma ferramenta de compactação de dados de uso geral com sintaxe de +linha de comando semelhante ao \fBgzip\fP(1) e ao \fBbzip2\fP(1). O formato de +arquivo nativo é o formato \fB.xz\fP, mas o formato legado \fB.lzma\fP usado por +LZMA Utils e fluxos compactados brutos sem cabeçalhos de formato de +contêiner também são suportados. Além disso, a descompactação do formato +\&\fB.lz\fP usado por \fBlzip\fP é suportada. +.PP +\fBxz\fP compacta ou descompacta cada \fIarquivo\fP de acordo com o modo de +operação selecionado. Se nenhum \fIarquivo\fP for fornecido ou \fIarquivo\fP for +\fB\-\fP, \fBxz\fP lê da entrada padrão e grava os dados processados na saída +padrão. \fBxz\fP recusará (exibirá um erro e ignorará o \fIarquivo\fP) para gravar +dados compactados na saída padrão se for um terminal. Da mesma forma, \fBxz\fP +se recusará a ler dados compactados da entrada padrão se for um terminal. +.PP +A menos que \fB\-\-stdout\fP seja especificado, \fIarquivos\fP diferentes de \fB\-\fP +são gravados em um novo arquivo cujo nome é derivado do nome \fIarquivo\fP de +origem: +.IP \(bu 3 +Ao compactar, o sufixo do formato de arquivo de destino (\fB.xz\fP ou \fB.lzma\fP) +é anexado ao nome do arquivo de origem para obter o nome do arquivo de +destino. +.IP \(bu 3 +Ao descompactar, o sufixo \fB.xz\fP, \fB.lzma\fP ou \fB.lz\fP é removido do nome do +arquivo para obter o nome do arquivo de destino. \fBxz\fP também reconhece os +sufixos \fB.txz\fP e \fB.tlz\fP e os substitui pelo sufixo \fB.tar\fP. +.PP +Se o arquivo de destino já existir, um erro será exibido e \fIarquivo\fP será +ignorado. +.PP +A menos que grave na saída padrão, \fBxz\fP exibirá um aviso e pulará o +\fIarquivo\fP se qualquer um dos seguintes se aplicar: +.IP \(bu 3 +\fIArquivo\fP não é um arquivo normal. Links simbólicos não são seguidos e, +portanto, não são considerados arquivos comuns. +.IP \(bu 3 +\fIArquivo\fP tem mais de um link físico. +.IP \(bu 3 +\fIFile\fP tem setuid, setgid ou sticky bit definido. +.IP \(bu 3 +O modo de operação está definido para compactar e o \fIarquivo\fP já possui um +sufixo do formato de arquivo de destino (\fB.xz\fP ou \fB.txz\fP ao compactar para +o formato \fB.xz\fP e \fB.lzma \fP ou \fB.tlz\fP ao compactar para o formato +\&\fB.lzma\fP). +.IP \(bu 3 +O modo de operação está definido para descompactar e o \fIarquivo\fP não possui +um sufixo de nenhum dos formatos de arquivo suportados (\fB.xz\fP, \fB.txz\fP, +\&\fB.lzma\fP, \fB.tlz\fP , ou \fB.lz\fP). +.PP +Depois de compactar ou descompactar com êxito o \fIarquivo\fP, o \fBxz\fP copia o +dono, grupo, permissões, horário de acesso e horário de modificação do +\fIarquivo\fP de origem para o arquivo de destino. Se a cópia do grupo falhar, +as permissões serão modificadas para que o arquivo de destino não se torne +acessível a usuários que não têm permissão para acessar o \fIarquivo\fP de +origem. \fBxz\fP ainda não oferece suporte à cópia de outros metadados, como +listas de controle de acesso ou atributos estendidos. +.PP +Depois que o arquivo de destino for fechado com êxito, o \fIarquivo\fP de +origem será removido, a menos que \fB\-\-keep\fP tenha sido especificado. O +\fIarquivo\fP de origem nunca é removido se a saída for gravada na saída padrão +ou se ocorrer um erro. +.PP +O envio de \fBSIGINFO\fP ou \fBSIGUSR1\fP para o processo do \fBxz\fP faz com que ele +imprima informações de andamento para erro padrão. Isso tem uso limitado, +pois quando o erro padrão é um terminal, usar \fB\-\-verbose\fP exibirá um +indicador de progresso de atualização automática. +. +.SS "Uso de memória" +O uso de memória de \fBxz\fP varia de algumas centenas de kilobytes a vários +gigabytes, dependendo das configurações de compactação. As configurações +usadas ao compactar um arquivo determinam os requisitos de memória do +descompactador. Normalmente, o descompactador precisa de 5\ % a 20\ % da +quantidade de memória que o compactador precisou ao criar o arquivo. Por +exemplo, descompactar um arquivo criado com \fBxz \-9\fP atualmente requer 65\ MiB de memória. Ainda assim, é possível ter arquivos \fB.xz\fP que requerem +vários gigabytes de memória para descompactar. +.PP +Especialmente os usuários de sistemas mais antigos podem achar irritante a +possibilidade de uso de memória muito grande. Para evitar surpresas +desconfortáveis, o \fBxz\fP possui um limitador de uso de memória embutido, que +está desabilitado por padrão. Embora alguns sistemas operacionais forneçam +maneiras de limitar o uso de memória dos processos, confiar nele não foi +considerado flexível o suficiente (por exemplo, usar \fBulimit\fP(1) para +limitar a memória virtual tende a prejudicar \fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +O limitador de uso de memória pode ser ativado com a opção de linha de +comando \fB\-\-memlimit=\fP\fIlimite\fP. Geralmente é mais conveniente habilitar o +limitador por padrão definindo a variável de ambiente \fBXZ_DEFAULTS\fP, por +exemplo, \fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. É possível definir os limites +separadamente para compactação e descompactação usando +\fB\-\-memlimit\-compress=\fP\fIlimite\fP e \fB\-\-memlimit\-decompress=\fP\fIlimite\fP. Usar +essas duas opções fora de \fBXZ_DEFAULTS\fP raramente é útil porque uma única +execução de \fBxz\fP não pode fazer compactação e descompactação e +\fB\-\-memlimit=\fP\fIlimite\fP (ou \fB\-M\fP \fIlimite\fP ) é mais curto para digitar na +linha de comando. +.PP +Se o limite de uso de memória especificado for excedido durante a +descompactação, \fBxz\fP exibirá um erro e a descompactação do arquivo +falhará. Se o limite for excedido durante a compactação, \fBxz\fP tentará +reduzir as configurações para que o limite não seja mais excedido (exceto ao +usar \fB\-\-format=raw\fP ou \fB\-\-no\-adjust\fP). Dessa forma, a operação não +falhará, a menos que o limite seja muito pequeno. A escala das configurações +é feita em etapas que não correspondem às predefinições do nível de +compactação, por exemplo, se o limite for apenas um pouco menor que o valor +necessário para \fBxz \-9\fP, as configurações serão reduzidas apenas um pouco , +não até \fBxz \-8\fP. +. +.SS "Concatenação e preenchimento com arquivos .xz" +É possível concatenar arquivos \fB.xz\fP como estão. \fBxz\fP irá descompactar +tais arquivos como se fossem um único arquivo \fB.xz\fP. +.PP +É possível inserir preenchimento entre as partes concatenadas ou após a +última parte. O preenchimento deve consistir em bytes nulos e o tamanho do +preenchimento deve ser um múltiplo de quatro bytes. Isso pode ser útil, por +exemplo, se o arquivo \fB.xz\fP for armazenado em uma mídia que mede tamanhos +de arquivo em blocos de 512 bytes. +.PP +Concatenação e preenchimento não são permitidos com arquivos \fB.lzma\fP ou +fluxos brutos. +. +.SH OPÇÕES +. +.SS "Sufixos inteiros e valores especiais" +Na maioria dos lugares onde um argumento inteiro é esperado, um sufixo +opcional é suportado para indicar facilmente números inteiros grandes. Não +deve haver espaço entre o número inteiro e o sufixo. +.TP +\fBKiB\fP +Multiplica o inteiro por 1.024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP e \fBKB\fP são +aceitos como sinônimos de \fBKiB\fP. +.TP +\fBMiB\fP +Multiplica o número inteiro por 1.048.576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP e \fBMB\fP +são aceitos como sinônimos de \fBMiB\fP. +.TP +\fBGiB\fP +Multiplica o número inteiro por 1.073.741.824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP e +\fBGB\fP são aceitos como sinônimos de \fBGiB\fP. +.PP +O valor especial \fBmax\fP pode ser usado para indicar o valor inteiro máximo +suportado pela opção. +. +.SS "Modo de operação" +Se várias opções de modo de operação forem dadas, a última entrará em vigor. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Compacta. Este é o modo de operação padrão quando nenhuma opção de modo de +operação é especificada e nenhum outro modo de operação está implícito no +nome do comando (por exemplo, \fBunxz\fP implica em \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +After successful compression, the source file is removed unless writing to +standard output or \fB\-\-keep\fP was specified. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Decompress. After successful decompression, the source file is removed +unless writing to standard output or \fB\-\-keep\fP was specified. +.TP +\fB\-t\fP, \fB\-\-test\fP +Testa a integridade de \fIarquivos\fP compactados. Esta opção é equivalente a +\fB\-\-decompress \-\-stdout\fP exceto que os dados descompactados são descartados +em vez de serem gravados na saída padrão. Nenhum arquivo é criado ou +removido. +.TP +\fB\-l\fP, \fB\-\-list\fP +Imprime informações sobre \fIarquivos\fP compactados. Nenhuma saída +descompactada é produzida e nenhum arquivo é criado ou removido. No modo de +lista, o programa não pode ler os dados compactados da entrada padrão ou de +outras fontes não pesquisáveis. +.IP "" +A listagem padrão mostra informações básicas sobre \fIarquivos\fP, um arquivo +por linha. Para obter informações mais detalhadas, use também a opção +\fB\-\-verbose\fP. Para obter ainda mais informações, use \fB\-\-verbose\fP duas +vezes, mas observe que isso pode ser lento, porque obter todas as +informações extras requer muitas buscas. A largura da saída detalhada excede +80 caracteres, portanto, canalizar a saída para, por exemplo, \fBless\ \-S\fP +pode ser conveniente se o terminal não tiver largura o suficiente. +.IP "" +A saída exata pode variar entre versões \fBxz\fP e localidades diferentes. Para +saída legível por máquina, \fB\-\-robot \-\-list\fP deve ser usado. +. +.SS "Modificadores de operação" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Não exclui os arquivos de entrada. +.IP "" +Desde \fBxz\fP 5.2.6, esta opção também faz \fBxz\fP compactar ou descompactar +mesmo se a entrada for um link simbólico para um arquivo comum, tiver mais +de um link físico ou tiver o setuid, setgid ou sticky bit definir. Os bits +setuid, setgid e sticky não são copiados para o arquivo de destino. Nas +versões anteriores, isso era feito apenas com \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Esta opção tem vários efeitos: +.RS +.IP \(bu 3 +Se o arquivo de destino já existir, o exclui antes de compactar ou +descompactar. +.IP \(bu 3 +Compacta ou descompacta, mesmo que a entrada seja um link simbólico para um +arquivo normal, tenha mais de um link físico ou tenha setuid, setgid ou +sticky bit definido. Os bits setuid, setgid e sticky não são copiados para o +arquivo de destino. +.IP \(bu 3 +Quando usado com \fB\-\-decompress\fP \fB\-\-stdout\fP e \fBxz\fP não consegue reconhecer +o tipo do arquivo de origem, copia o arquivo de origem como está na saída +padrão. Isso permite que \fBxzcat\fP \fB\-\-force\fP seja usado como \fBcat\fP(1) para +arquivos que não foram compactados com \fBxz\fP. Observe que, no futuro, o +\fBxz\fP pode oferecer suporte a novos formatos de arquivo compactado, o que +pode fazer com que o \fBxz\fP descompacte mais tipos de arquivos em vez de +copiá\-los como na saída padrão. \fB\-\-format=\fP\fIformato\fP pode ser usado para +restringir \fBxz\fP para descompactar apenas um único formato de arquivo. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Grava os dados compactados ou descompactados na saída padrão em vez de em um +arquivo. Isso implica em \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Descompacta apenas o primeiro fluxo de \fB.xz\fP e ignora silenciosamente +possíveis dados de entrada restantes após o fluxo. Normalmente, esse +restante posterior sem uso faz com que \fBxz\fP exiba um erro. +.IP "" +\fBxz\fP nunca descompacta mais de um fluxo de arquivos \fB.lzma\fP ou fluxos +brutos, mas esta opção ainda faz \fBxz\fP ignorar os possíveis dados +posteriores após o arquivo \fB.lzma\fP ou fluxo bruto. +.IP "" +Esta opção não tem efeito se o modo de operação não for \fB\-\-decompress\fP ou +\fB\-\-test\fP. +.IP "" +Since \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP implies \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Desativa a criação de arquivos esparsos. Por padrão, ao descompactar em um +arquivo normal, \fBxz\fP tenta tornar o arquivo esparso se os dados +descompactados contiverem longas sequências de zeros binários. Ele também +funciona ao gravar na saída padrão, desde que a saída padrão esteja +conectada a um arquivo normal e certas condições adicionais sejam atendidas +para torná\-la segura. A criação de arquivos esparsos pode economizar espaço +em disco e acelerar a descompactação, reduzindo a quantidade de E/S do +disco. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Ao compactar, usa \fI.suf\fP como sufixo para o arquivo de destino em vez de +\&\fB.xz\fP ou \fB.lzma\fP. Se não estiver gravando na saída padrão e o arquivo de +origem já tiver o sufixo \fI.suf\fP, um aviso será exibido e o arquivo será +ignorado. +.IP "" +Ao descompactar, reconhece arquivos com o sufixo \fI.suf\fP além de arquivos +com o sufixo \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP ou \fB.lz\fP . Se o arquivo de +origem tiver o sufixo \fI.suf\fP, o sufixo será removido para obter o nome do +arquivo de destino. +.IP "" +Ao compactar ou descompactar fluxos brutos (\fB\-\-format=raw\fP), o sufixo +sempre deve ser especificado, a menos que seja gravado na saída padrão, +porque não há sufixo padrão para fluxos brutos. +.TP +\fB\-\-files\fP[\fB=\fP\fIarquivo\fP] +Lê os nomes dos arquivos a serem processados em \fIarquivo\fP; se \fIarquivo\fP +for omitido, os nomes dos arquivos serão lidos da entrada padrão. Os nomes +de arquivo devem terminar com o caractere de nova linha. Um traço (\fB\-\fP) é +considerado um nome de arquivo regular; não significa entrada padrão. Se os +nomes de arquivo forem fornecidos também como argumentos de linha de +comando, eles serão processados antes da leitura dos nomes de arquivo de +\fIarquivo\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIarquivo\fP] +Isso é idêntico a \fB\-\-files\fP[\fB=\fP\fIarquivo\fP], exceto que cada nome de +arquivo deve ser finalizado com o caractere nulo. +. +.SS "Opções básicas de formato de arquivo e de compactação" +.TP +\fB\-F\fP \fIformato\fP, \fB\-\-format=\fP\fIformato\fP +Especifica o \fIformato\fP de arquivo para compactar ou descompactar: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Este é o padrão. Ao compactar, \fBauto\fP é equivalente a \fBxz\fP. Ao +descompactar, o formato do arquivo de entrada é detectado +automaticamente. Observe que os fluxos brutos (criados com \fB\-\-format=raw\fP) +não podem ser detectados automaticamente. +.TP +\fBxz\fP +Compacta no formato de arquivo \fB.xz\fP ou aceite apenas arquivos \fB.xz\fP ao +descompactar. +.TP +\fBlzma\fP, \fBalone\fP +Compacta no formato de arquivo legado \fB.lzma\fP ou aceite apenas arquivos +\&\fB.lzma\fP ao descompactar. O nome alternativo \fBalone\fP é fornecido para +compatibilidade com versões anteriores do LZMA Utils. +.TP +\fBlzip\fP +Aceita apenas arquivos \fB.lz\fP ao descompactar. Sem suporte a compactação. +.IP "" +The \fB.lz\fP format versions 0 and 1 are supported. Version 0 files were +produced by \fBlzip\fP 1.3 and older. Such files aren't common but may be +found from file archives as a few source packages were released in this +format. People might have old personal files in this format too. +Decompression support for the format version 0 was removed in \fBlzip\fP 1.18. +\fBlzip\fP 1.4 and later create files in the format version 1. +.TP +\fBraw\fP +Compacta ou descompacta um fluxo bruto (sem cabeçalhos). Isso é destinado +apenas a usuários avançados. Para decodificar fluxos brutos, você precisa +usar \fB\-\-format=raw\fP e especificar explicitamente a cadeia de filtros, que +normalmente seria armazenada nos cabeçalhos do contêiner. +.RE +.TP +\fB\-C\fP \fIverificação\fP, \fB\-\-check=\fP\fIverificação\fP +Especifica o tipo de verificação de integridade. A verificação é calculada a +partir dos dados descompactados e armazenados no arquivo \fB.xz\fP. Esta opção +tem efeito somente ao compactar no formato \fB.xz\fP; o formato \fB.lzma\fP não +oferece suporte a verificações de integridade. A verificação de integridade +(se for o caso) é verificada quando o arquivo \fB.xz\fP é descompactado. +.IP "" +Tipos de \fIverificação\fP suportados: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Não calcula uma verificação de integridade. Isso geralmente é uma má +ideia. Pode ser útil quando a integridade dos dados é verificada por outros +meios. +.TP +\fBcrc32\fP +Calcula CRC32 usando o polinômio do IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Calcula CRC64 usando o polinômio de ECMA\-182. Este é o padrão, pois é um +pouco melhor que o CRC32 na detecção de arquivos danificados e a diferença +de velocidade é insignificante. +.TP +\fBsha256\fP +Calcula SHA\-256. Isso é um pouco mais lento do que CRC32 e CRC64. +.RE +.IP "" +A integridade dos cabeçalhos de \fB.xz\fP é sempre verificada com CRC32. Não é +possível alterá\-la ou desativá\-la. +.TP +\fB\-\-ignore\-check\fP +Não confere a verificação de integridade dos dados compactados ao +descompactar. Os valores CRC32 nos cabeçalhos \fB.xz\fP ainda serão conferidos +normalmente. +.IP "" +\fBNão use esta opção a menos que saiba o que está fazendo.\fP Possíveis razões +para usar esta opção: +.RS +.IP \(bu 3 +Tentativa de recuperar dados de um arquivo .xz corrompido. +.IP \(bu 3 +Acelerar a descompactação. Isso é importante principalmente com SHA\-256 ou +com arquivos extremamente bem compactados. É recomendável não usar essa +opção para essa finalidade, a menos que a integridade do arquivo seja +verificada externamente de alguma outra forma. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Seleciona um nível de predefinição de compactação. O padrão é \fB\-6\fP. Se +vários níveis de predefinição forem especificados, o último terá efeito. Se +uma cadeia de filtro personalizada já foi especificada, especificar um nível +de predefinição de compactação limpa a cadeia de filtro personalizada. +.IP "" +As diferenças entre as predefinições são mais significativas do que com +\fBgzip\fP(1) e \fBbzip2\fP(1). As configurações de compactação selecionadas +determinam os requisitos de memória do descompactador, portanto, usar um +nível de predefinição muito alto pode dificultar a descompactação do arquivo +em um sistema antigo com pouca RAM. Especificamente, \fBnão é uma boa ideia usar cegamente \-9 para tudo\fP como costuma acontecer com \fBgzip\fP(1) e +\fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Estas são predefinições um tanto rápidas. \fB\-0\fP às vezes é mais rápida que +\fBgzip \-9\fP ao mesmo tempo que compacta muito melhor. As mais altas +geralmente têm velocidade comparável ao \fBbzip2\fP(1) com taxa de compactação +comparável ou melhor, embora os resultados dependam muito do tipo de dados +que estão sendo compactados. +.TP +\fB\-4\fP ... \fB\-6\fP +Compactação boa a muito boa, mantendo o uso de memória do descompactador +razoável mesmo para sistemas antigos. \fB\-6\fP é o padrão, que geralmente é uma +boa escolha para distribuir arquivos que precisam ser descompactáveis, mesmo +em sistemas com apenas 16\ MiB de RAM. (\fB\-5e\fP ou \fB\-6e\fP também vale a pena +considerar. Veja \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Eles são como \fB\-6\fP, mas com requisitos de memória de compressor e +descompressor mais altos. Eles são úteis apenas ao compactar arquivos +maiores que 8\ MiB, 16\ MiB e 32\ MiB, respectivamente. +.RE +.IP "" +No mesmo hardware, a velocidade de descompactação é aproximadamente um +número constante de bytes de dados compactados por segundo. Em outras +palavras, quanto melhor a compactação, mais rápida será a +descompactação. Isso também significa que a quantidade de saída não +compactada produzida por segundo pode variar muito. +.IP "" +A tabela a seguir resume os recursos das predefinições: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Predefinição;DicTam;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Descrições das colunas: +.RS +.IP \(bu 3 +DicTam é o tamanho do dicionário LZMA2. É desperdício de memória usar um +dicionário maior que o tamanho do arquivo descompactado. É por isso que é +bom evitar usar as predefinições \fB\-7\fP ... \fB\-9\fP quando não há real +necessidade deles. Em \fB\-6\fP e inferior, a quantidade de memória desperdiçada +geralmente é baixa o suficiente para não importar. +.IP \(bu 3 +CompCPU é uma representação simplificada das configurações LZMA2 que afetam +a velocidade de compactação. O tamanho do dicionário também afeta a +velocidade, portanto, embora o CompCPU seja o mesmo para os níveis \fB\-6\fP +\&... \fB\-9\fP, níveis mais altos ainda tendem a ser um pouco mais lentos. Para +obter uma compactação ainda mais lenta e possivelmente melhor, consulte +\fB\-\-extreme\fP. +.IP \(bu 3 +CompMem contains the compressor memory requirements in the single\-threaded +mode. It may vary slightly between \fBxz\fP versions. +.IP \(bu 3 +DecMem contém os requisitos de memória do descompactador. Ou seja, as +configurações de compactação determinam os requisitos de memória do +descompactador. O uso exato da memória do descompactador é um pouco maior do +que o tamanho do dicionário LZMA2, mas os valores na tabela foram +arredondados para o próximo MiB completo. +.RE +.IP "" +Memory requirements of the multi\-threaded mode are significantly higher than +that of the single\-threaded mode. With the default value of +\fB\-\-block\-size\fP, each thread needs 3*3*DictSize plus CompMem or DecMem. For +example, four threads with preset \fB\-6\fP needs 660\(en670\ MiB of memory. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Usa uma variante mais lenta do nível de predefinição de compactação +selecionado (\fB\-0\fP ... \fB\-9\fP) para obter uma taxa de compactação um pouco +melhor, mas, com azar, isso também pode piorar. O uso da memória do +descompressor não é afetado, mas o uso da memória do compactador aumenta um +pouco nos níveis de predefinição \fB\-0\fP ... \fB\-3\fP. +.IP "" +Como existem duas predefinições com tamanhos de dicionário 4\ MiB e 8\ MiB, +as predefinições \fB\-3e\fP e \fB\-5e\fP usam configurações um pouco mais rápidas +(CompCPU inferior) do que \fB\-4e\fP e \fB\-6e\fP, respectivamente. Dessa forma, não +há duas predefinições idênticas. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Predefinição;DicTam;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Por exemplo, há um total de quatro predefinições que usam o dicionário 8\ MiB, cuja ordem do mais rápido ao mais lento é \fB\-5\fP, \fB\-6\fP, \fB\-5e\fP e +\fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Esses são apelidos um tanto enganosos para \fB\-0\fP e \fB\-9\fP, +respectivamente. Eles são fornecidos apenas para compatibilidade com versões +anteriores do LZMA Utils. Evite usar essas opções. +.TP +\fB\-\-block\-size=\fP\fItamanho\fP +Ao compactar para o formato \fB.xz\fP, divida os dados de entrada em blocos de +\fItamanho\fP bytes. Os blocos são compactados independentemente uns dos +outros, o que ajuda no multi\-threading e torna possível a descompactação +limitada de acesso aleatório. Essa opção normalmente é usada para substituir +o tamanho de bloco padrão no modo multi\-thread, mas também pode ser usada em +thread única. +.IP "" +In multi\-threaded mode about three times \fIsize\fP bytes will be allocated in +each thread for buffering input and output. The default \fIsize\fP is three +times the LZMA2 dictionary size or 1 MiB, whichever is more. Typically a +good value is 2\(en4 times the size of the LZMA2 dictionary or at least 1 +MiB. Using \fIsize\fP less than the LZMA2 dictionary size is waste of RAM +because then the LZMA2 dictionary buffer will never get fully used. In +multi\-threaded mode, the sizes of the blocks are stored in the block +headers. This size information is required for multi\-threaded +decompression. +.IP "" +In single\-threaded mode no block splitting is done by default. Setting this +option doesn't affect memory usage. No size information is stored in block +headers, thus files created in single\-threaded mode won't be identical to +files created in multi\-threaded mode. The lack of size information also +means that \fBxz\fP won't be able decompress the files in multi\-threaded mode. +.TP +\fB\-\-block\-list=\fP\fIitems\fP +When compressing to the \fB.xz\fP format, start a new block with an optional +custom filter chain after the given intervals of uncompressed data. +.IP "" +The \fIitems\fP are a comma\-separated list. Each item consists of an optional +filter chain number between 0 and 9 followed by a colon (\fB:\fP) and a +required size of uncompressed data. Omitting an item (two or more +consecutive commas) is a shorthand to use the size and filters of the +previous item. +.IP "" +If the input file is bigger than the sum of the sizes in \fIitems\fP, the last +item is repeated until the end of the file. A special value of \fB0\fP may be +used as the last size to indicate that the rest of the file should be +encoded as a single block. +.IP "" +An alternative filter chain for each block can be specified in combination +with the \fB\-\-filters1=\fP\fIfilters\fP \&...\& \fB\-\-filters9=\fP\fIfilters\fP options. +These options define filter chains with an identifier between 1\(en9. +Filter chain 0 can be used to refer to the default filter chain, which is +the same as not specifying a filter chain. The filter chain identifier can +be used before the uncompressed size, followed by a colon (\fB:\fP). For +example, if one specifies \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP +then blocks will be created using: +.RS +.IP \(bu 3 +The filter chain specified by \fB\-\-filters1\fP and 2 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters3\fP and 2 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters2\fP and 4 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters2\fP and 4 MiB input +.IP \(bu 3 +The default filter chain and 2 MiB input +.IP \(bu 3 +The default filter chain and 4 MiB input for every block until end of input. +.RE +.IP "" +If one specifies a size that exceeds the encoder's block size (either the +default value in threaded mode or the value specified with +\fB\-\-block\-size=\fP\fIsize\fP), the encoder will create additional blocks while +keeping the boundaries specified in \fIitems\fP. For example, if one specifies +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP and the +input file is 80 MiB, one will get 11 blocks: 5, 10, 8, 10, 2, 10, 10, 4, +10, 10, and 1 MiB. +.IP "" +No modo multi\-thread, os tamanhos dos blocos são armazenados nos cabeçalhos +dos blocos. Isso não é feito no modo de thread única, portanto, a saída +codificada não será idêntica à do modo multi\-thread. +.TP +\fB\-\-flush\-timeout=\fP\fItempo_limite\fP +Ao compactar, se mais de \fItempo_limite\fP milissegundos (um número inteiro +positivo) se passaram desde a liberação anterior e a leitura de mais entrada +seria bloqueada, todos os dados de entrada pendentes serão liberados do +codificador e disponibilizados no fluxo de saída. Isso pode ser útil se +\fBxz\fP for usado para compactar dados transmitidos por uma rede. Valores +\fItempo_limite\fP pequenos tornam os dados disponíveis na extremidade +receptora com um pequeno atraso, mas valores \fItempo_limite\fP grandes +oferecem melhor taxa de compactação. +.IP "" +Esse recurso está desabilitado por padrão. Se esta opção for especificada +mais de uma vez, a última terá efeito. O valor especial \fItempo_limite\fP de +\fB0\fP pode ser usado para desabilitar explicitamente esse recurso. +.IP "" +Este recurso não está disponível em sistemas não\-POSIX. +.IP "" +.\" FIXME +\fBEste recurso ainda é experimental.\fP Atualmente, \fBxz\fP não é adequado para +descompactar o fluxo em tempo real devido à forma como \fBxz\fP faz o buffer. +.TP +\fB\-\-no\-sync\fP +Do not synchronize the target file and its directory to the storage device +before removing the source file. This can improve performance if +compressing or decompressing many small files. However, if the system +crashes soon after the deletion, it is possible that the target file was not +written to the storage device but the delete operation was. In that case +neither the original source file nor the target file is available. +.IP "" +This option has an effect only when \fBxz\fP is going to remove the source +file. In other cases synchronization is never done. +.IP "" +The synchronization and \fB\-\-no\-sync\fP were added in \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIlimite\fP +Define um limite de uso de memória para compactação. Se esta opção for +especificada várias vezes, a última entrará em vigor. +.IP "" +Se as configurações de compactação excederem o \fIlimite\fP, \fBxz\fP tentará +ajustar as configurações para baixo para que o limite não seja mais excedido +e exibirá um aviso de que o ajuste automático foi feito. Os ajustes são +feitos nesta ordem: reduzindo o número de encadeamentos, alternando para o +modo sigle\-thread se até mesmo uma thread no modo multi\-thread exceder o +\fIlimite\fP e, finalmente, reduzindo o tamanho do dicionário LZMA2. +.IP "" +Ao compactar com \fB\-\-format=raw\fP ou se \fB\-\-no\-adjust\fP tiver sido +especificado, apenas o número de threads pode ser reduzido, pois isso pode +ser feito sem afetar a saída compactada. +.IP "" +Se o \fIlimite\fP não puder ser alcançado mesmo com os ajustes descritos acima, +um erro será exibido e \fBxz\fP sairá com status de saída 1. +.IP "" +O \fIlimite\fP pode ser especificado de várias maneiras: +.RS +.IP \(bu 3 +O \fIlimite\fP pode ser um valor absoluto em bytes. Usar um sufixo inteiro como +\fBMiB\fP pode ser útil. Exemplo: \fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +O \fIlimite\fP pode ser especificado como uma porcentagem da memória física +total (RAM). Isso pode ser útil especialmente ao definir a variável de +ambiente \fBXZ_DEFAULTS\fP em um script de inicialização de shell que é +compartilhado entre diferentes computadores. Dessa forma o limite é +automaticamente maior em sistemas com mais memória. Exemplo: +\fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +O \fIlimite\fP pode ser redefinido para seu valor padrão, definindo\-o como +\fB0\fP. Atualmente, isso equivale a definir \fIlimite\fP como \fBmax\fP (sem limite +de uso de memória). +.RE +.IP "" +Para \fBxz\fP de 32 bits, há um caso especial: se o \fIlimite\fP estiver acima de +\fB4020\ MiB\fP, o \fIlimite\fP é definido como \fB4020\ MiB\fP. No MIPS32 \fB2000\ MiB\fP é usado em seu lugar. (Os valores \fB0\fP e \fBmax\fP não são afetados por +isso. Um recurso semelhante não existe para descompactação.) Isso pode ser +útil quando um executável de 32 bits tem acesso a espaço de endereço de 4\ GiB (2 GiB no MIPS32) enquanto espero não causar danos em outras situações. +.IP "" +Consulte também a seção \fBUso de memória\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIlimite\fP +Define um limite de uso de memória para descompactação. Isso também afeta o +modo \fB\-\-list\fP. Se a operação não for possível sem exceder o \fIlimite\fP, +\fBxz\fP exibirá um erro e a descompactação do arquivo falhará. Consulte +\fB\-\-memlimit\-compress=\fP\fIlimite\fP para possíveis maneiras de especificar o +\fIlimite\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimite\fP +Define um limite de uso de memória para descompactação multi\-thread. Isso +pode afetar apenas o número de threads; isso nunca fará com que \fBxz\fP se +recuse a descompactar um arquivo. Se \fIlimite\fP for muito baixo para permitir +qualquer multi\-thread, o \fIlimite\fP será ignorado e \fBxz\fP continuará no modo +de thread única. Observe que se \fB\-\-memlimit\-decompress\fP também for usado, +ele sempre se aplicará aos modos de thread única e multi\-thread e, portanto, +o \fIlimite\fP efetivo para multi\-threading nunca será maior que o limite +definido com \fB\-\-memlimit\-decompress\fP. +.IP "" +Em contraste com as outras opções de limite de uso de memória, +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimite\fP tem um padrão \fIlimite\fP específico do +sistema. \fBxz \-\-info\-memory\fP pode ser usado para ver o valor atual. +.IP "" +Esta opção e seu valor padrão existem porque, sem qualquer limite, o +descompactador usando threads pode acabar alocando uma quantidade insana de +memória com alguns arquivos de entrada. Se o \fIlimite\fP padrão for muito +baixo em seu sistema, sinta\-se à vontade para aumentar o \fIlimite\fP, mas +nunca defina\-o para um valor maior que a quantidade de RAM utilizável, pois +com os arquivos de entrada apropriados \fBxz\fP tentará usar essa quantidade de +memória mesmo com um baixo número de threads. Ficar sem memória ou trocar +não melhorará o desempenho da descompactação. +.IP "" +Consulte \fB\-\-memlimit\-compress=\fP\fIlimite\fP para possíveis maneiras de +especificar o \fIlimite\fP. Definir \fIlimite\fP como \fB0\fP redefine \fIlimite\fP para +o valor padrão específico do sistema. +.TP +\fB\-M\fP \fIlimite\fP, \fB\-\-memlimit=\fP\fIlimite\fP, \fB\-\-memory=\fP\fIlimite\fP +Isso é equivalente a especificar \fB\-\-memlimit\-compress=\fP\fIlimite\fP +\fB\-\-memlimit\-decompress=\fP\fIlimite\fP \fB\-\-memlimit\-mt\-decompress=\fP\fIlimite\fP. +.TP +\fB\-\-no\-adjust\fP +Exibe um erro e saia se o limite de uso de memória não puder ser atendido +sem ajustar as configurações que afetam a saída compactada. Ou seja, isso +evita que \fBxz\fP alterne o codificador do modo multi\-thread para o modo +encadeado único e reduza o tamanho do dicionário LZMA2. Mesmo quando esta +opção é usada, o número de threads pode ser reduzido para atender ao limite +de uso de memória, pois isso não afetará a saída compactada. +.IP "" +O ajuste automático é sempre desativado ao criar fluxos brutos +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fIthreads\fP, \fB\-\-threads=\fP\fIthreads\fP +Especifica o número de threads de trabalho a serem usados. Definir +\fIthreads\fP para um valor especial \fB0\fP faz com que \fBxz\fP use tantos threads +quanto o(s) processador(es) no suporte do sistema. O número real de +encadeamentos pode ser menor que \fIthreads\fP se o arquivo de entrada não for +grande o suficiente para subdividir em threads com as configurações +fornecidas ou se o uso de mais threads exceder o limite de uso de memória. +.IP "" +Os compactadores usando thread única e várias threads produzem saídas +diferentes. O compactador de thread única fornecerá o menor tamanho de +arquivo, mas apenas a saída do compactador de várias threads pode ser +descompactada usando várias threads. Definir \fIthreads\fP como \fB1\fP usará o +modo de thread única. Definir \fIthreads\fP para qualquer outro valor, +incluindo \fB0\fP, usará o compressor de várias threads, mesmo que o sistema +tenha suporte a apenas uma thread de hardware. (\fBxz\fP 5.2.x usou o modo de +thread única nesta situação.) +.IP "" +Para usar o modo de várias threads com apenas uma thread, defina \fIthreads\fP +como \fB+1\fP. O prefixo \fB+\fP não tem efeito com valores diferentes de \fB1\fP. Um +limite de uso de memória ainda pode fazer \fBxz\fP alternar para o modo de +thread única, a menos que \fB\-\-no\-adjust\fP seja usado. O suporte para o +prefixo \fB+\fP foi adicionado no \fBxz\fP 5.4.0. +.IP "" +Se um número automático de threads foi solicitado e nenhum limite de uso de +memória foi especificado, um limite flexível padrão específico do sistema +será usado para possivelmente limitar o número de threads. É um limite +flexível no sentido de que é ignorado se o número de threads se tornar um, +portanto, um limite flexível nunca impedirá \fBxz\fP de compactar ou +descompactar. Este limite flexível padrão não fará com que \fBxz\fP alterne do +modo de várias threads para o modo de thread única. Os limites ativos podem +ser vistos com \fBxz \-\-info\-memory\fP. +.IP "" +Atualmente, o único método de threading é dividir a entrada em blocos e +comprimi\-los independentemente um do outro. O tamanho padrão do bloco +depende do nível de compactação e pode ser substituído com a opção +\fB\-\-block\-size=\fP\fItamanho\fP. +.IP "" +A descompactação em threads funciona apenas em arquivos que contêm vários +blocos com informações de tamanho nos cabeçalhos dos blocos. Todos os +arquivos grandes o suficiente compactados no modo de várias thread atendem a +essa condição, mas os arquivos compactados no modo de thread única não +atendem, mesmo se \fB\-\-block\-size=\fP\fItamanho\fP tiver sido usado. +.IP "" +The default value for \fIthreads\fP is \fB0\fP. In \fBxz\fP 5.4.x and older the +default is \fB1\fP. +. +.SS "Cadeias de filtro de compressor personalizadas" +Uma cadeia de filtro personalizada permite especificar as configurações de +compactação em detalhes, em vez de confiar nas configurações associadas às +predefinições. Quando uma cadeia de filtro personalizada é especificada, as +opções predefinidas (\fB\-0\fP \&...\& \fB\-9\fP e \fB\-\-extreme\fP) anteriores na linha +de comando são esquecidas. Se uma opção predefinida for especificada após +uma ou mais opções de cadeia de filtros personalizados, a nova predefinição +entrará em vigor e as opções de cadeia de filtros personalizados +especificadas anteriormente serão esquecidas. +.PP +Uma cadeia de filtro é comparável à tubulação na linha de comando. Ao +compactar, a entrada descompactada vai para o primeiro filtro, cuja saída +vai para o próximo filtro (se houver). A saída do último filtro é gravada no +arquivo compactado. O número máximo de filtros na cadeia é quatro, mas +normalmente uma cadeia de filtros tem apenas um ou dois filtros. +.PP +Muitos filtros têm limitações sobre onde podem estar na cadeia de filtros: +alguns filtros podem funcionar apenas como o último filtro na cadeia, alguns +apenas como filtro não\-último e alguns funcionam em qualquer posição na +cadeia. Dependendo do filtro, essa limitação é inerente ao projeto do filtro +ou existe para evitar problemas de segurança. +.PP +A custom filter chain can be specified in two different ways. The options +\fB\-\-filters=\fP\fIfilters\fP and \fB\-\-filters1=\fP\fIfilters\fP \&...\& +\fB\-\-filters9=\fP\fIfilters\fP allow specifying an entire filter chain in one +option using the liblzma filter string syntax. Alternatively, a filter +chain can be specified by using one or more individual filter options in the +order they are wanted in the filter chain. That is, the order of the +individual filter options is significant! When decoding raw streams +(\fB\-\-format=raw\fP), the filter chain must be specified in the same order as +it was specified when compressing. Any individual filter or preset options +specified before the full chain option (\fB\-\-filters=\fP\fIfilters\fP) will be +forgotten. Individual filters specified after the full chain option will +reset the filter chain. +.PP +Both the full and individual filter options take filter\-specific \fIoptions\fP +as a comma\-separated list. Extra commas in \fIoptions\fP are ignored. Every +option has a default value, so specify those you want to change. +.PP +Para ver toda a cadeia de filtros e \fIopções\fP, use \fBxz \-vv\fP (isto é, use +\fB\-\-verbose\fP duas vezes). Isso também funciona para visualizar as opções da +cadeia de filtros usadas pelas predefinições. +.TP +\fB\-\-filters=\fP\fIfilters\fP +Specify the full filter chain or a preset in a single option. Each filter +can be separated by spaces or two dashes (\fB\-\-\fP). \fIfilters\fP may need to be +quoted on the shell command line so it is parsed as a single option. To +denote \fIoptions\fP, use \fB:\fP or \fB=\fP. A preset can be prefixed with a \fB\-\fP +and followed with zero or more flags. The only supported flag is \fBe\fP to +apply the same options as \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIfilters\fP ... \fB\-\-filters9\fP=\fIfilters\fP +Specify up to nine additional filter chains that can be used with +\fB\-\-block\-list\fP. +.IP "" +For example, when compressing an archive with executable files followed by +text files, the executable part could use a filter chain with a BCJ filter +and the text part only the LZMA2 filter. +.TP +\fB\-\-filters\-help\fP +Display a help message describing how to specify presets and custom filter +chains in the \fB\-\-filters\fP and \fB\-\-filters1=\fP\fIfilters\fP \&...\& +\fB\-\-filters9=\fP\fIfilters\fP options, and exit successfully. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIopções\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIopções\fP] +.PD +Adiciona o filtro LZMA1 ou LZMA2 à cadeia de filtros. Esses filtros podem +ser usados apenas como o último filtro na cadeia. +.IP "" +LZMA1 é um filtro legado, que é suportado quase exclusivamente devido ao +formato de arquivo legado \fB.lzma\fP, que suporta apenas LZMA1. LZMA2 é uma +versão atualizada do LZMA1 para corrigir alguns problemas práticos do +LZMA1. O formato \fB.xz\fP usa LZMA2 e não suporta LZMA1. A velocidade de +compactação e as proporções de LZMA1 e LZMA2 são praticamente as mesmas. +.IP "" +LZMA1 e LZMA2 compartilham o mesmo conjunto de \fIopções\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIpredefinição\fP +Redefine todas as \fIopções\fP de LZMA1 ou LZMA2 para +\fIpredefinição\fP. \fIPredefinição\fP consiste em um número inteiro, que pode ser +seguido por modificadores de predefinição de uma única letra. O inteiro pode +ser de \fB0\fP a \fB9\fP, correspondendo às opções de linha de comando \fB\-0\fP +\&...\& \fB\-9\fP. O único modificador suportado atualmente é \fBe\fP, que +corresponde a \fB\-\-extreme\fP. Se nenhum \fBpreset\fP for especificado, os valores +padrão das \fIopções\fP LZMA1 ou LZMA2 serão obtidos da predefinição \fB6\fP. +.TP +\fBdict=\fP\fItamanho\fP +O \fItamanho\fP do dicionário (buffer de histórico) indica quantos bytes dos +dados não compactados processados recentemente são mantidos na memória. O +algoritmo tenta encontrar sequências de bytes repetidos (correspondências) +nos dados não compactados e substituí\-los por referências aos dados +atualmente no dicionário. Quanto maior o dicionário, maior a chance de +encontrar uma correspondência. Portanto, aumentar o dicionário \fItamanho\fP +geralmente melhora a taxa de compactação, mas um dicionário maior que o +arquivo não compactado é um desperdício de memória. +.IP "" +Um \fItamanho\fP de dicionário típico é de 64\ KiB a 64\ MiB. O mínimo é 4\ KiB. O máximo para compactação é atualmente 1,5\ GiB (1536\ MiB). O +descompactador já oferece suporte a dicionários de até um byte a menos de 4\ GiB, que é o máximo para os formatos de fluxo LZMA1 e LZMA2. +.IP "" +O \fItamanho\fP de dicionário e o localizador de correspondência (\fImf\fP) juntos +determinam o uso de memória do codificador LZMA1 ou LZMA2. O mesmo (ou +maior) \fItamanho\fP de dicionário é necessário para descompactar que foi usado +durante a compactação, portanto, o uso de memória do decodificador é +determinado pelo tamanho do dicionário usado durante a compactação. Os +cabeçalhos \fB.xz\fP armazenam o \fItamanho\fP de dicionário como 2^\fIn\fP ou 2^\fIn\fP ++ 2^(\fIn\fP\-1), então esses \fItamanhos\fP são um tanto preferidos para +compactação. Outros \fItamanhos\fP serão arredondados quando armazenados nos +cabeçalhos \fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Especifica o número de bits de contexto literais. O mínimo é 0 e o máximo é +4; o padrão é 3. Além disso, a soma de \fIlc\fP e \fIlp\fP não deve exceder 4. +.IP "" +Todos os bytes que não podem ser codificados como correspondências são +codificados como literais. Ou seja, literais são simplesmente bytes de 8 +bits que são codificados um de cada vez. +.IP "" +A codificação literal assume que os bits \fIlc\fP mais altos do byte não +compactado anterior se correlacionam com o próximo byte. Por exemplo, em um +texto típico em inglês, uma letra maiúscula geralmente é seguida por uma +letra minúscula, e uma letra minúscula geralmente é seguida por outra letra +minúscula. No conjunto de caracteres US\-ASCII, os três bits mais altos são +010 para letras maiúsculas e 011 para letras minúsculas. Quando \fIlc\fP é pelo +menos 3, a codificação literal pode aproveitar essa propriedade nos dados +não compactados. +.IP "" +O valor padrão (3) geralmente é bom. Se você deseja compactação máxima, +experimente \fBlc=4\fP. Às vezes ajuda um pouco, às vezes piora a +compactação. Se piorar, experimente \fBlc=2\fP também. +.TP +\fBlp=\fP\fIlp\fP +Especifica o número de bits de posição literal. O mínimo é 0 e o máximo é 4; +o padrão é 0. +.IP "" +\fILp\fP afeta que tipo de alinhamento nos dados não compactados é assumido ao +codificar literais. Consulte \fIpb\fP abaixo para obter mais informações sobre +alinhamento. +.TP +\fBpb=\fP\fIpb\fP +Especifica o número de bits de posição. O mínimo é 0 e o máximo é 4; o +padrão é 2. +.IP "" +\fIPb\fP afeta que tipo de alinhamento nos dados não compactados é assumido em +geral. O padrão significa alinhamento de quatro bytes (2^\fIpb\fP=2^2=4), que +geralmente é uma boa escolha quando não há melhor estimativa. +.IP "" +Quando o alinhamento é conhecido, definir \fIpb\fP adequadamente pode reduzir +um pouco o tamanho do arquivo. Por exemplo, com arquivos de texto com +alinhamento de um byte (US\-ASCII, ISO\-8859\-*, UTF\-8), a configuração \fBpb=0\fP +pode melhorar um pouco a compactação. Para texto UTF\-16, \fBpb=1\fP é uma boa +escolha. Se o alinhamento for um número ímpar como 3 bytes, \fBpb=0\fP pode ser +a melhor escolha. +.IP "" +Embora o alinhamento assumido possa ser ajustado com \fIpb\fP e \fIlp\fP, LZMA1 e +LZMA2 ainda favorecem ligeiramente o alinhamento de 16 bytes. Pode valer a +pena levar em consideração ao projetar formatos de arquivo que provavelmente +serão compactados com LZMA1 ou LZMA2. +.TP +\fBmf=\fP\fImf\fP +O localizador de correspondência tem um efeito importante na velocidade do +codificador, uso de memória e taxa de compactação. Normalmente, os +localizadores de correspondência de Hash Chain são mais rápidos do que os +localizadores de correspondência de árvore binária. O padrão depende do +\fIpredefinição\fP: 0 usa \fBhc3\fP, 1\(en3 usa \fBhc4\fP e o resto usa \fBbt4\fP. +.IP "" +Os seguintes localizadores de correspondência são suportados. As fórmulas de +uso de memória abaixo são aproximações aproximadas, que estão mais próximas +da realidade quando \fIdict\fP é uma potência de dois. +.RS +.TP +\fBhc3\fP +Cadeia de hashs com hashing de 2 e 3 bytes +.br +Valor mínimo para \fInice\fP: 3 +.br +Uso de memória: +.br +\fIdict\fP * 7.5 (if \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 5.5 + 64 MiB (if \fIdict\fP > 16 MiB) +.TP +\fBhc4\fP +Cadeia de hashs com hashing de 2, 3 e 4 bytes +.br +Valor mínimo para \fInice\fP: 4 +.br +Uso de memória: +.br +\fIdict\fP * 7.5 (if \fIdict\fP <= 32 MiB); +.br +\fIdict\fP * 6.5 (if \fIdict\fP > 32 MiB) +.TP +\fBbt2\fP +Árvore binária com hashing de 2 bytes +.br +Valor mínimo para \fInice\fP: 2 +.br +Uso de memória: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Árvore binária com hashing de 2 e 3 bytes +.br +Valor mínimo para \fInice\fP: 3 +.br +Uso de memória: +.br +\fIdict\fP * 11.5 (if \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 9.5 + 64 MiB (if \fIdict\fP > 16 MiB) +.TP +\fBbt4\fP +Árvore binária com hashing de 2, 3 e 4 bytes +.br +Valor mínimo para \fInice\fP: 4 +.br +Uso de memória: +.br +\fIdict\fP * 11.5 (if \fIdict\fP <= 32 MiB); +.br +\fIdict\fP * 10.5 (if \fIdict\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fImodo\fP +O \fImodo\fP de compactação especifica o método para analisar os dados +produzidos pelo localizador de correspondência. Os \fImodos\fP suportados são +\fBfast\fP e \fBnormal\fP. O padrão é \fBfast\fP para \fIpredefinições\fP 0\(en3 e +\fBnormal\fP para \fIpredefinições\fP 4\(en9. +.IP "" +Normalmente, \fBfast\fP é usado com localizadores de correspondência cadeia de +hashs e \fBnormal\fP com localizadores de correspondência de árvore +binária. Isso também é o que os \fIpredefinições\fP fazem. +.TP +\fBnice=\fP\fInice\fP +Especifica o que é considerado um bom comprimento para uma +correspondência. Uma vez que uma correspondência de pelo menos \fInice\fP bytes +é encontrada, o algoritmo para de procurar correspondências possivelmente +melhores. +.IP "" +\fINice\fP pode ser 2\(en273 bytes. Valores mais altos tendem a fornecer melhor +taxa de compactação em detrimento da velocidade. O padrão depende do +\fIpredefinição\fP. +.TP +\fBdepth=\fP\fIprofundidade\fP +Especifica a profundidade máxima de pesquisa no localizador de +correspondências. O padrão é o valor especial de 0, que faz com que o +compressor determine um \fIprofundidade\fP razoável de \fImf\fP e \fInice\fP. +.IP "" +Uma \fIprofundidade\fP razoável para cadeias de hash é 4\(en100 e 16\(en1000 +para árvores binárias. Usar valores muito altos para \fIprofundidade\fP pode +tornar o codificador extremamente lento com alguns arquivos. Evite definir +\fIprofundidade\fP acima de 1000 a menos que você esteja preparado para +interromper a compactação caso ela esteja demorando muito. +.RE +.IP "" +Ao decodificar fluxos brutos (\fB\-\-format=raw\fP), o LZMA2 precisa apenas do +dicionário \fItamanho\fP. LZMA1 também precisa de \fIlc\fP, \fIlp\fP e \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIopções\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIopções\fP] +.PD +Adiciona um filtro de ramificação/chamada/salto (BCJ) à cadeia de +filtros. Esses filtros podem ser usados apenas como um filtro não último na +cadeia de filtros. +.IP "" +Um filtro BCJ converte endereços relativos no código de máquina em suas +contrapartes absolutas. Isso não altera o tamanho dos dados, mas aumenta a +redundância, o que pode ajudar o LZMA2 a produzir um arquivo \fB.xz\fP 0\(en15\ % menor. Os filtros BCJ são sempre reversíveis, portanto, usar um filtro BCJ +para o tipo errado de dados não causa nenhuma perda de dados, embora possa +piorar um pouco a taxa de compactação.Os filtros BCJ são muito rápidos e +usam uma quantidade insignificante de memória. +.IP "" +Esses filtros BCJ têm problemas conhecidos relacionados à taxa de +compactação: +.RS +.IP \(bu 3 +Alguns tipos de arquivos contendo código executável (por exemplo, arquivos +de objeto, bibliotecas estáticas e módulos do kernel do Linux) têm os +endereços nas instruções preenchidos com valores de preenchimento. Esses +filtros BCJ ainda vão fazer a conversão de endereço, o que vai piorar a +compactação desses arquivos. +.IP \(bu 3 +Se um filtro BCJ for aplicado em um arquivo, é possível que isso torne a +taxa de compactação pior do que não usar um filtro BCJ. Por exemplo, se +houver executáveis semelhantes ou mesmo idênticos, a filtragem provavelmente +tornará os arquivos menos semelhantes e, portanto, a compactação será +pior. O conteúdo de arquivos não executáveis no mesmo arquivo também pode +ser importante. Na prática tem que tentar com e sem filtro BCJ para ver qual +é melhor em cada situação. +.RE +.IP "" +Conjuntos de instruções diferentes têm alinhamento diferente: o arquivo +executável deve ser alinhado a um múltiplo desse valor nos dados de entrada +para fazer o filtro funcionar. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filtro;Alinhamento;Observações +x86;1;x86 32 bits ou 64 bits +ARM;4; +ARM\-Thumb;2; +ARM64;4;Alinhamento de 4096 bytes +;;é melhor +PowerPC;4;Somente big endian +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Since the BCJ\-filtered data is usually compressed with LZMA2, the +compression ratio may be improved slightly if the LZMA2 options are set to +match the alignment of the selected BCJ filter. Examples: +.RS +.IP \(bu 3 +IA\-64 filter has 16\-byte alignment so \fBpb=4,lp=4,lc=0\fP is good with LZMA2 +(2^4=16). +.IP \(bu 3 +RISC\-V code has 2\-byte or 4\-byte alignment depending on whether the file +contains 16\-bit compressed instructions (the C extension). When 16\-bit +instructions are used, \fBpb=2,lp=1,lc=3\fP or \fBpb=1,lp=1,lc=3\fP is good. When +16\-bit instructions aren't present, \fBpb=2,lp=2,lc=2\fP is the best. +\fBreadelf \-h\fP can be used to check if "RVC" appears on the "Flags" line. +.IP \(bu 3 +ARM64 is always 4\-byte aligned so \fBpb=2,lp=2,lc=2\fP is the best. +.IP \(bu 3 +The x86 filter is an exception. It's usually good to stick to LZMA2's +defaults (\fBpb=2,lp=0,lc=3\fP) when compressing x86 executables. +.RE +.IP "" +Todos os filtros BCJ suportam as mesmas \fIopções\fP: +.RS +.TP +\fBstart=\fP\fIdeslocamento\fP +Especifica o \fIdeslocamento\fP inicial que é usado na conversão entre +endereços relativos e absolutos. O \fIdeslocamento\fP deve ser um múltiplo do +alinhamento do filtro (ver tabela acima). O padrão é zero. Na prática, o +padrão é bom; especificar um \fIdeslocamento\fP personalizado quase nunca é +útil. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIopções\fP] +Adiciona o filtro Delta à cadeia de filtros. O filtro Delta só pode ser +usado como filtro não\-último na cadeia de filtros. +.IP "" +Atualmente, apenas o cálculo simples de delta byte a byte é suportado. Pode +ser útil ao compactar, por exemplo, imagens bitmap não compactadas ou áudio +PCM não compactado. No entanto, algoritmos de propósito especial podem +fornecer resultados significativamente melhores do que Delta + LZMA2. Isso é +verdade especialmente com áudio, que compacta mais rápido e melhor, por +exemplo, com \fBflac\fP(1). +.IP "" +\fIOpções\fP suportadas: +.RS +.TP +\fBdist=\fP\fIdistância\fP +Especifica a \fIdistância\fP do cálculo delta em bytes. \fIdistância\fP deve ser +1\(en256. O padrão é 1. +.IP "" +Por exemplo, com \fBdist=2\fP e entrada de oito bytes A1 B1 A2 B3 A3 B5 A4 B7, +a saída será A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Outras opções" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Suprime avisos e avisos. Especifique isso duas vezes para suprimir erros +também. Esta opção não tem efeito no status de saída. Ou seja, mesmo que um +aviso tenha sido suprimido, o status de saída para indicar um aviso ainda é +usado. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Ser detalhado. Se o erro padrão estiver conectado a um terminal, \fBxz\fP +exibirá um indicador de progresso. Especifique \fB\-\-verbose\fP duas vezes dará +uma saída ainda mais detalhada. +.IP "" +O indicador de progresso mostra as seguintes informações: +.RS +.IP \(bu 3 +A porcentagem de conclusão é mostrada se o tamanho do arquivo de entrada for +conhecido. Ou seja, a porcentagem não pode ser mostrada em encadeamentos +(pipe). +.IP \(bu 3 +Quantidade de dados compactados produzidos (compactando) ou consumidos +(descompactando). +.IP \(bu 3 +Quantidade de dados não compactados consumidos (compactação) ou produzidos +(descompactação). +.IP \(bu 3 +Taxa de compactação, que é calculada dividindo a quantidade de dados +compactados processados até o momento pela quantidade de dados não +compactados processados até o momento. +.IP \(bu 3 +Velocidade de compactação ou descompactação. Isso é medido como a quantidade +de dados não compactados consumidos (compactação) ou produzidos +(descompactação) por segundo. É mostrado após alguns segundos desde que +\fBxz\fP começou a processar o arquivo. +.IP \(bu 3 +Tempo decorrido no formato M:SS ou H:MM:SS. +.IP \(bu 3 +O tempo restante estimado é mostrado apenas quando o tamanho do arquivo de +entrada é conhecido e alguns segundos já se passaram desde que \fBxz\fP começou +a processar o arquivo. A hora é mostrada em um formato menos preciso que +nunca tem dois pontos, por exemplo, 2 min 30 s. +.RE +.IP "" +Quando o erro padrão não é um terminal, \fB\-\-verbose\fP fará com que \fBxz\fP +imprima o nome do arquivo, tamanho compactado, tamanho não compactado, taxa +de compactação e possivelmente também a velocidade e o tempo decorrido em +uma única linha para o erro padrão após a compactação ou descompactando o +arquivo. A velocidade e o tempo decorrido são incluídos apenas quando a +operação leva pelo menos alguns segundos. Se a operação não foi concluída, +por exemplo, devido à interrupção do usuário, também é impressa a +porcentagem de conclusão se o tamanho do arquivo de entrada for conhecido. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Não define o status de saída como 2, mesmo que uma condição digna de um +aviso tenha sido detectada. Esta opção não afeta o nível de detalhamento, +portanto, tanto \fB\-\-quiet\fP quanto \fB\-\-no\-warn\fP devem ser usados para não +exibir avisos e não alterar o status de saída. +.TP +\fB\-\-robot\fP +Imprime mensagens em um formato analisável por máquina. Isso visa facilitar +a criação de frontends que desejam usar \fBxz\fP em vez de liblzma, o que pode +ser o caso de vários scripts. A saída com esta opção habilitada deve ser +estável em versões \fBxz\fP. Consulte a seção \fBMODO ROBÔ\fP para obter detalhes. +.TP +\fB\-\-info\-memory\fP +Exibe, em formato legível por humanos, quanta memória física (RAM) e quantos +threads de processador \fBxz\fP acredita que o sistema possui e os limites de +uso de memória para compactação e descompactação e saia com êxito. +.TP +\fB\-h\fP, \fB\-\-help\fP +Exibe uma mensagem de ajuda descrevendo as opções mais usadas e sai com +sucesso. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Exibe uma mensagem de ajuda descrevendo todos os recursos de \fBxz\fP e sai com +sucesso +.TP +\fB\-V\fP, \fB\-\-version\fP +Exibe o número da versão de \fBxz\fP e liblzma em formato legível por +humanos. Para obter uma saída analisável por máquina, especifique \fB\-\-robot\fP +antes de \fB\-\-version\fP. +. +.SH "MODO ROBÔ" +The robot mode is activated with the \fB\-\-robot\fP option. It makes the output +of \fBxz\fP easier to parse by other programs. Currently \fB\-\-robot\fP is +supported only together with \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, +and \fB\-\-version\fP. It will be supported for compression and decompression in +the future. +. +.SS "Modo lista" +\fBxz \-\-robot \-\-list\fP usa saída separada por tabulações. A primeira coluna de +cada linha possui uma string que indica o tipo de informação encontrada +naquela linha: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Esta é sempre a primeira linha ao começar a listar um arquivo. A segunda +coluna na linha é o nome do arquivo. +.TP +\fBfile\fP +Esta linha contém informações gerais sobre o arquivo \fB.xz\fP. Esta linha é +sempre impressa após a linha \fBname\fP. +.TP +\fBstream\fP +Este tipo de linha é usado somente quando \fB\-\-verbose\fP foi +especificado. Existem tantas linhas de \fBstream\fP quanto fluxos no arquivo +\&\fB.xz\fP. +.TP +\fBblock\fP +Este tipo de linha é usado somente quando \fB\-\-verbose\fP foi +especificado. Existem tantas linhas \fBblock\fP quanto blocos no arquivo +\&\fB.xz\fP. As linhas \fBblock\fP são mostradas após todas as linhas \fBstream\fP; +diferentes tipos de linha não são intercalados. +.TP +\fBsummary\fP +Este tipo de linha é usado apenas quando \fB\-\-verbose\fP foi especificado duas +vezes. Esta linha é impressa após todas as linhas de \fBblock\fP. Assim como a +linha \fBarquivo\fP, a linha \fBsummary\fP contém informações gerais sobre o +arquivo \fB.xz\fP. +.TP +\fBtotals\fP +Esta linha é sempre a última linha da saída da lista. Ele mostra as +contagens totais e tamanhos. +.PP +As colunas das linhas \fBfile\fP: +.PD 0 +.RS +.IP 2. 4 +Número de fluxos no arquivo +.IP 3. 4 +Número total de blocos no(s) fluxo(s) +.IP 4. 4 +Tamanho compactado do arquivo +.IP 5. 4 +Uncompressed size of the file +.IP 6. 4 +Taxa de compactação, por exemplo, \fB0.123\fP. Se a proporção for superior a +9.999, serão exibidos três traços (\fB\-\-\-\fP) em vez da proporção. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Lista separada por vírgulas de nomes de verificação de integridade. As +seguintes strings são usadas para os tipos de verificação conhecidos: +\fBNone\fP, \fBCRC32\fP, \fBCRC64\fP e \fBSHA\-256\fP. Para tipos de verificações +desconhecidos, \fBUnknown\-\fP\fIN\fP é usado, onde \fIN\fP é o ID do cheque como um +número decimal (um ou dois dígitos). +.IP 8. 4 +Tamanho total do preenchimento de fluxo no arquivo +.RE +.PD +.PP +As colunas das linhas \fBstream\fP: +.PD 0 +.RS +.IP 2. 4 +Número do fluxo (o primeiro fluxo é 1) +.IP 3. 4 +Número de blocos no fluxo +.IP 4. 4 +Deslocamento inicial compactado +.IP 5. 4 +Deslocamento inicial descompactado +.IP 6. 4 +Tamanho compactado (não inclui preenchimento de fluxo) +.IP 7. 4 +Tamanho descompactado +.IP 8. 4 +Taxa de compactação +.IP 9. 4 +Nome da verificação de integridade +.IP 10. 4 +Tamanho do preenchimento do fluxo +.RE +.PD +.PP +As colunas das linhas \fBblock\fP: +.PD 0 +.RS +.IP 2. 4 +Número do fluxo que contém este bloco +.IP 3. 4 +Número do bloco relativo ao início do fluxo (o primeiro bloco é 1) +.IP 4. 4 +Número do bloco relativo ao início do arquivo +.IP 5. 4 +Deslocamento inicial compactado em relação ao início do arquivo +.IP 6. 4 +Deslocamento inicial descompactado em relação ao início do arquivo +.IP 7. 4 +Tamanho total compactado do bloco (inclui cabeçalhos) +.IP 8. 4 +Tamanho descompactado +.IP 9. 4 +Taxa de compactação +.IP 10. 4 +Nome da verificação de integridade +.RE +.PD +.PP +Se \fB\-\-verbose\fP for especificado duas vezes, colunas adicionais serão +incluídas nas linhas \fBblock\fP. Eles não são exibidos com um único +\fB\-\-verbose\fP, porque obter essas informações requer muitas buscas e, +portanto, pode ser lento: +.PD 0 +.RS +.IP 11. 4 +Valor da verificação de integridade em hexadecimal +.IP 12. 4 +Tamanho do cabeçalho do bloco +.IP 13. 4 +Sinalizadores de bloco: \fBc\fP indica que o tamanho compactado está presente e +\fBu\fP indica que o tamanho não compactado está presente. Se o sinalizador não +estiver definido, um traço (\fB\-\fP) será exibido para manter o comprimento da +string fixo. Novos sinalizadores podem ser adicionados ao final da string no +futuro. +.IP 14. 4 +Tamanho dos dados reais compactados no bloco (isso exclui o cabeçalho do +bloco, o preenchimento do bloco e os campos de verificação) +.IP 15. 4 +Quantidade de memória (em bytes) necessária para descompactar este bloco com +esta versão \fBxz\fP +.IP 16. 4 +Cadeia de filtro. Observe que a maioria das opções usadas no momento da +compactação não pode ser conhecida, pois apenas as opções necessárias para a +descompactação são armazenadas nos cabeçalhos \fB.xz\fP. +.RE +.PD +.PP +As colunas das linhas \fBsummary\fP: +.PD 0 +.RS +.IP 2. 4 +Quantidade de memória (em bytes) necessária para descompactar este arquivo +com esta versão do \fBxz\fP +.IP 3. 4 +\fByes\fP ou \fBno\fP indicando se todos os cabeçalhos de bloco têm tamanho +compactado e tamanho não compactado armazenados neles +.PP +\fIDesde\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Versão mínima do \fBxz\fP necessária para descompactar o arquivo +.RE +.PD +.PP +As colunas da linha \fBtotals\fP: +.PD 0 +.RS +.IP 2. 4 +Número de fluxos +.IP 3. 4 +Número de blocos +.IP 4. 4 +Tamanho compactado +.IP 5. 4 +Tamanho descompactado +.IP 6. 4 +Taxa de compactação média +.IP 7. 4 +Lista separada por vírgulas de nomes de verificação de integridade que +estavam presentes nos arquivos +.IP 8. 4 +Tamanho do preenchimento do fluxo +.IP 9. 4 +Número de arquivos. Isso está aqui para manter a ordem das colunas +anteriores a mesma das linhas \fBfile\fP. +.PD +.RE +.PP +Se \fB\-\-verbose\fP for especificado duas vezes, colunas adicionais serão +incluídas na linha \fBtotals\fP: +.PD 0 +.RS +.IP 10. 4 +Quantidade máxima de memória (em bytes) necessária para descompactar os +arquivos com esta versão do \fBxz\fP +.IP 11. 4 +\fByes\fP ou \fBno\fP indicando se todos os cabeçalhos de bloco têm tamanho +compactado e tamanho não compactado armazenados neles +.PP +\fIDesde\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Versão mínima do \fBxz\fP necessária para descompactar o arquivo +.RE +.PD +.PP +Versões futuras podem adicionar novos tipos de linha e novas colunas podem +ser adicionadas aos tipos de linha existentes, mas as colunas existentes não +serão alteradas. +. +.SS "Filters help" +\fBxz \-\-robot \-\-filters\-help\fP prints the supported filters in the following +format: +.PP +\fIfilter\fP\fB:\fP\fIoption\fP\fB=<\fP\fIvalue\fP\fB>,\fP\fIoption\fP\fB=<\fP\fIvalue\fP\fB>\fP... +.TP +\fIfilter\fP +Name of the filter +.TP +\fIoption\fP +Name of a filter specific option +.TP +\fIvalue\fP +Numeric \fIvalue\fP ranges appear as \fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. String +\fIvalue\fP choices are shown within \fB< >\fP and separated by a \fB|\fP +character. +.PP +Each filter is printed on its own line. +. +.SS "Informações de limite de memória" +\fBxz \-\-robot \-\-info\-memory\fP prints a single line with multiple tab\-separated +columns: +.IP 1. 4 +Quantidade total de memória física (RAM) em bytes. +.IP 2. 4 +Limite de uso de memória para compactação em bytes +(\fB\-\-memlimit\-compress\fP). Um valor especial de \fB0\fP indica a configuração +padrão que para o modo de thread única é o mesmo que sem limite. +.IP 3. 4 +Limite de uso de memória para descompactação em bytes +(\fB\-\-memlimit\-decompress\fP). Um valor especial de \fB0\fP indica a configuração +padrão que para o modo de thread única é o mesmo que sem limite. +.IP 4. 4 +Desde \fBxz\fP 5.3.4alpha: Uso de memória para descompactação com várias thread +em bytes (\fB\-\-memlimit\-mt\-decompress\fP). Isso nunca é zero porque um valor +padrão específico do sistema mostrado na coluna 5 é usado se nenhum limite +for especificado explicitamente. Isso também nunca é maior que o valor na +coluna 3, mesmo que um valor maior tenha sido especificado com +\fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Desde \fBxz\fP 5.3.4alpha: Um limite de uso de memória padrão específico do +sistema que é usado para limitar o número de threads ao compactar com um +número automático de threads (\fB\-\-threads=0\fP) e nenhum limite de uso de +memória foi especificado (\fB\-\-memlimit\-compress\fP). Isso também é usado como +o valor padrão para \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Desde \fBxz\fP 5.3.4alpha: Número de threads de processador disponíveis. +.PP +No futuro, a saída de \fBxz \-\-robot \-\-info\-memory\fP pode ter mais colunas, mas +nunca mais do que uma única linha. +. +.SS Versão +\fBxz \-\-robot \-\-version\fP prints the version number of \fBxz\fP and liblzma in +the following format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Versão principal. +.TP +\fIYYY\fP +Versão menor. Números pares são estáveis. Os números ímpares são versões +alfa ou beta. +.TP +\fIZZZ\fP +Nível de patch para versões estáveis ou apenas um contador para versões de +desenvolvimento. +.TP +\fIS\fP +Estabilidade. 0 é alfa, 1 é beta e 2 é estável. \fIS\fP deve ser sempre 2 +quando \fIYYY\fP for par. +.PP +\fIXYYYZZZS\fP são iguais em ambas as linhas se \fBxz\fP e liblzma forem da mesma +versão do XZ Utils. +.PP +Exemplos: 4.999.9beta é \fB49990091\fP e 5.0.0 é \fB50000002\fP. +. +.SH "STATUS DE SAÍDA" +.TP +\fB0\fP +Está tudo bem. +.TP +\fB1\fP +Ocorreu um erro. +.TP +\fB2\fP +Algo digno de um aviso ocorreu, mas ocorreu nenhum erro real. +.PP +Observações (não avisos ou erros) impressas no erro padrão não afetam o +status de saída. +. +.SH AMBIENTE +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP analisa listas de opções separadas por espaços das variáveis de +ambiente \fBXZ_DEFAULTS\fP e \fBXZ_OPT\fP, nesta ordem, antes de analisar as +opções da linha de comando. Observe que apenas as opções são analisadas a +partir das variáveis de ambiente; todas as não opções são silenciosamente +ignoradas. A análise é feita com \fBgetopt_long\fP(3) que também é usado para +os argumentos da linha de comando. +.PP +\fBWarning:\fP By setting these environment variables, one is effectively +modifying programs and scripts that run \fBxz\fP. Most of the time it is safe +to set memory usage limits, number of threads, and compression options via +the environment variables. However, some options can break scripts. An +obvious example is \fB\-\-help\fP which makes \fBxz\fP show the help text instead of +compressing or decompressing a file. More subtle examples are \fB\-\-quiet\fP +and \fB\-\-verbose\fP. In many cases it works well to enable the progress +indicator using \fB\-\-verbose\fP, but in some situations the extra messages +create problems. The verbosity level also affects the behavior of +\fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +User\-specific or system\-wide default options. Typically this is set in a +shell initialization script to enable \fBxz\fP's memory usage limiter by +default or set the default number of threads. Excluding shell +initialization scripts and similar special cases, scripts should never set +or unset \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Isso é para passar opções para \fBxz\fP quando não é possível definir as opções +diretamente na linha de comando \fBxz\fP. Este é o caso quando \fBxz\fP é +executado por um script ou ferramenta, por exemplo, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Os scripts podem usar \fBXZ_OPT\fP, por exemplo, para definir opções de +compactação padrão específicas do script. Ainda é recomendável permitir que +os usuários substituam \fBXZ_OPT\fP se isso for razoável. Por exemplo, em +scripts \fBsh\fP(1) pode\-se usar algo assim: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "COMPATIBILIDADE COM LZMA UTILS" +A sintaxe da linha de comando do \fBxz\fP é praticamente um superconjunto de +\fBlzma\fP, \fBunlzma\fP e \fBlzcat\fP conforme encontrado no LZMA Utils 4.32.x. Na +maioria dos casos, é possível substituir LZMA Utils por XZ Utils sem +interromper os scripts existentes. Existem algumas incompatibilidades, +porém, que às vezes podem causar problemas. +. +.SS "Níveis de predefinição de compactação" +A numeração das predefinições de nível de compactação não é idêntica em +\fBxz\fP e LZMA Utils. A diferença mais importante é como os tamanhos dos +dicionários são mapeados para diferentes predefinições. O tamanho do +dicionário é aproximadamente igual ao uso de memória do descompactador. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nível;xz;LZMA Utils +\-0;256 KiB;N/D +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +As diferenças de tamanho do dicionário também afetam o uso da memória do +compressor, mas existem algumas outras diferenças entre LZMA Utils e XZ +Utils, que tornam a diferença ainda maior: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nível;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/D +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +O nível de predefinição padrão no LZMA Utils é \fB\-7\fP enquanto no XZ Utils é +\fB\-6\fP, então ambos usam um dicionário de 8 MiB por padrão. +. +.SS "Arquivos .lzma em um fluxo versus sem ser em um fluxo" +O tamanho descompactado do arquivo pode ser armazenado no cabeçalho de +\&\fB.lzma\fP. O LZMA Utils faz isso ao compactar arquivos comuns. A alternativa +é marcar que o tamanho não compactado é desconhecido e usar o marcador de +fim de carga útil para indicar onde o descompactador deve parar. O LZMA +Utils usa este método quando o tamanho não compactado não é conhecido, como +é o caso, por exemplo, de encadeamentos (pipes). +.PP +\fBxz\fP oferece suporte à descompactação de arquivos \fB.lzma\fP com ou sem +marcador de fim de carga útil, mas todos os arquivos \fB.lzma\fP criados por +\fBxz\fP usarão marcador de fim de carga útil e terão o tamanho descompactado +marcado como desconhecido no cabeçalho de \fB.lzma\fP. Isso pode ser um +problema em algumas situações incomuns. Por exemplo, um descompactador de +\&\fB.lzma\fP em um dispositivo embarcado pode funcionar apenas com arquivos que +tenham tamanho descompactado conhecido. Se você encontrar esse problema, +precisará usar o LZMA Utils ou o LZMA SDK para criar arquivos \fB.lzma\fP com +tamanho descompactado conhecido. +. +.SS "Arquivos .lzma não suportados" +O formato \fB.lzma\fP permite valores \fIlc\fP até 8 e valores \fIlp\fP até 4. LZMA +Utils pode descompactar arquivos com qualquer \fIlc\fP e \fIlp\fP, mas sempre cria +arquivos com \fBlc=3\fP e \fBlp=0\fP. Criar arquivos com outros \fIlc\fP e \fIlp\fP é +possível com \fBxz\fP e com LZMA SDK. +.PP +A implementação do filtro LZMA1 em liblzma requer que a soma de \fIlc\fP e +\fIlp\fP não exceda 4. Assim, arquivos \fB.lzma\fP, que excedam esta limitação, +não podem ser descompactados com \fBxz\fP. +.PP +LZMA Utils cria apenas arquivos \fB.lzma\fP que possuem um tamanho de +dicionário de 2^\fIn\fP (uma potência de 2), mas aceita arquivos com qualquer +tamanho de dicionário. liblzma aceita apenas arquivos \fB.lzma\fP que tenham um +tamanho de dicionário de 2^\fIn\fP ou 2^\fIn\fP + 2^(\fIn\fP\-1). Isso é para diminuir +os falsos positivos ao detectar arquivos \fB.lzma\fP. +.PP +Essas limitações não devem ser um problema na prática, já que praticamente +todos os arquivos \fB.lzma\fP foram compactados com configurações que o liblzma +aceitará. +. +.SS "Lixo à direita" +Ao descompactar, o LZMA Utils silenciosamente ignora tudo após o primeiro +fluxo \fB.lzma\fP. Na maioria das situações, isso é um bug. Isso também +significa que o LZMA Utils não oferece suporte a descompactação de arquivos +\&\fB.lzma\fP concatenados. +.PP +Se houver dados restantes após o primeiro fluxo de \fB.lzma\fP, \fBxz\fP considera +o arquivo corrompido, a menos que \fB\-\-single\-stream\fP tenha sido usado. Isso +pode quebrar scripts obscuros que presumiram que o lixo à direita é +ignorado. +. +.SH NOTAS +. +.SS "A saída compactada pode variar" +A saída compactada exata produzida a partir do mesmo arquivo de entrada não +compactado pode variar entre as versões do XZ Utils, mesmo se as opções de +compactação forem idênticas. Isso ocorre porque o codificador pode ser +aprimorado (compactação mais rápida ou melhor) sem afetar o formato do +arquivo. A saída pode variar mesmo entre diferentes compilações da mesma +versão do XZ Utils, se diferentes opções de compilação forem usadas. +.PP +A informação acima significa que, uma vez que \fB\-\-rsyncable\fP tenha sido +implementado, os arquivos resultantes não serão necessariamente +"rsyncáveis", a menos que os arquivos antigos e novos tenham sido +compactados com a mesma versão xz. Esse problema pode ser corrigido se uma +parte da implementação do codificador for congelada para manter a saída de +rsyncable estável nas versões do xz. +. +.SS "Descompactadores .xz embarcados" +As implementações do descompactador \fB.xz\fP embarcados, como o XZ Embedded, +não oferecem necessariamente suporte a arquivos criados com tipos de +\fIverificações\fP de integridade diferentes de \fBnone\fP e \fBcrc32\fP. Como o +padrão é \fB\-\-check=crc64\fP, você deve usar \fB\-\-check=none\fP ou +\fB\-\-check=crc32\fP ao criar arquivos para sistemas embarcados. +.PP +Fora dos sistemas embarcados, todos os descompactadores de formato \fB.xz\fP +oferecem suporte a todos os tipos de \fIverificação\fP ou, pelo menos, são +capazes de descompactar o arquivo sem verificar a verificação de integridade +se a \fIverificação\fP específica não for suportada. +.PP +XZ Embedded oferece suporte a filtros BCJ, mas apenas com o deslocamento +inicial padrão. +. +.SH EXEMPLOS +. +.SS Básico +Compactar o arquivo \fIfoo\fP em \fIfoo.xz\fP usando o nível de compactação padrão +(\fB\-6\fP) e remover \fIfoo\fP se a compactação for bem\-sucedida: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Descompactar \fIbar.xz\fP em \fIbar\fP e não remover \fIbar.xz\fP mesmo se a +descompactação for bem\-sucedida: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Criar \fIbaz.tar.xz\fP com a predefinição \fB\-4e\fP (\fB\-4 \-\-extreme\fP), que é mais +lenta que o padrão \fB\-6\fP, mas precisa de menos memória para compactação e +descompactação (48 \ MiB e 5\ MiB, respectivamente): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Uma mistura de arquivos compactados e descompactados pode ser descompactada +para a saída padrão com um único comando: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Compactação paralela de muitos arquivos" +No GNU e *BSD, \fBfind\fP(1) e \fBxargs\fP(1) podem ser usados para paralelizar a +compactação de muitos arquivos: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +A opção \fB\-P\fP para \fBxargs\fP(1) define o número de processos paralelos do +\fBxz\fP. O melhor valor para a opção \fB\-n\fP depende de quantos arquivos devem +ser compactados. Se houver apenas alguns arquivos, o valor provavelmente +deve ser 1; com dezenas de milhares de arquivos, 100 ou até mais podem ser +apropriados para reduzir o número de processos de \fBxz\fP que \fBxargs\fP(1) +eventualmente criará. +.PP +A opção \fB\-T1\fP para \fBxz\fP existe para forçá\-lo ao modo de thread única, +porque \fBxargs\fP(1) é usado para controlar a quantidade de paralelização. +. +.SS "Modo robô" +Calcular quantos bytes foram salvos no total depois de compactar vários +arquivos: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Um script pode querer saber que está usando \fBxz\fP novo o suficiente. O +seguinte script \fBsh\fP(1) verifica se o número da versão da ferramenta \fBxz\fP +é pelo menos 5.0.0. Este método é compatível com versões beta antigas, que +não suportavam a opção \fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Definir um limite de uso de memória para descompactação usando \fBXZ_OPT\fP, +mas se um limite já tiver sido definido, não o aumentar: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Cadeias de filtro de compressor personalizadas" +O uso mais simples para cadeias de filtro personalizadas é personalizar uma +predefinição LZMA2. Isso pode ser útil, porque as predefinições abrangem +apenas um subconjunto das combinações potencialmente úteis de configurações +de compactação. +.PP +As colunas CompCPU das tabelas das descrições das opções \fB\-0\fP ... \fB\-9\fP e +\fB\-\-extreme\fP são úteis ao personalizar as predefinições LZMA2. Aqui estão as +partes relevantes coletadas dessas duas tabelas: +.RS +.PP +.TS +tab(;); +c c +n n. +Predefinição;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Se você sabe que um arquivo requer um dicionário um tanto grande (por +exemplo, 32\ MiB) para compactar bem, mas deseja comprimi\-lo mais +rapidamente do que \fBxz \-8\fP faria, uma predefinição com um valor CompCPU +baixo (por exemplo, 1) pode ser modificado para usar um dicionário maior: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Com certos arquivos, o comando acima pode ser mais rápido que \fBxz \-6\fP +enquanto compacta significativamente melhor. No entanto, deve\-se enfatizar +que apenas alguns arquivos se beneficiam de um grande dicionário, mantendo o +valor CompCPU baixo. A situação mais óbvia, onde um grande dicionário pode +ajudar muito, é um arquivo contendo arquivos muito semelhantes de pelo menos +alguns megabytes cada. O tamanho do dicionário deve ser significativamente +maior do que qualquer arquivo individual para permitir que o LZMA2 aproveite +ao máximo as semelhanças entre arquivos consecutivos. +.PP +Se o uso muito alto de memória do compactador e do descompactador for bom e +o arquivo que está sendo compactado tiver pelo menos várias centenas de +megabytes, pode ser útil usar um dicionário ainda maior do que os 64 MiB que +o \fBxz \-9\fP usaria: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Usar \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) como no exemplo acima pode ser útil +para ver os requisitos de memória do compactador e do +descompactador. Lembre\-se que usar um dicionário maior que o tamanho do +arquivo descompactado é desperdício de memória, então o comando acima não é +útil para arquivos pequenos. +.PP +Às vezes, o tempo de compactação não importa, mas o uso de memória do +descompactador deve ser mantido baixo, por exemplo, para possibilitar a +descompactação do arquivo em um sistema embarcado. O comando a seguir usa +\fB\-6e\fP (\fB\-6 \-\-extreme\fP) como base e define o dicionário como apenas 64\ KiB. O arquivo resultante pode ser descompactado com XZ Embedded (é por isso +que existe \fB\-\-check=crc32\fP) usando cerca de 100\ KiB de memória. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Se você deseja espremer o máximo de bytes possível, ajustar o número de bits +de contexto literal (\fIlc\fP) e o número de bits de posição (\fIpb\fP) às vezes +pode ajudar. Ajustar o número de bits de posição literal (\fIlp\fP) também pode +ajudar, mas geralmente \fIlc\fP e \fIpb\fP são mais importantes. Por exemplo, um +arquivo de código\-fonte contém principalmente texto US\-ASCII, então algo +como o seguinte pode fornecer um arquivo ligeiramente (como 0,1\ %) menor +que \fBxz \-6e\fP (tente também sem \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +O uso de outro filtro junto com o LZMA2 pode melhorar a compactação com +determinados tipos de arquivo. Por exemplo, para compactar uma biblioteca +compartilhada x86\-32 ou x86\-64 usando o filtro x86 BCJ: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Observe que a ordem das opções de filtro é significativa. Se \fB\-\-x86\fP for +especificado após \fB\-\-lzma2\fP, \fBxz\fP dará um erro, porque não pode haver +nenhum filtro após LZMA2 e também porque o filtro x86 BCJ não pode ser usado +como o último filtro em a corrente. +.PP +O filtro Delta junto com LZMA2 pode dar bons resultados com imagens +bitmap. Ele geralmente deve superar o PNG, que possui alguns filtros mais +avançados do que o delta simples, mas usa Deflate para a compactação real. +.PP +A imagem deve ser salva em formato não compactado, por exemplo, como TIFF +não compactado. O parâmetro de distância do filtro Delta é definido para +corresponder ao número de bytes por pixel na imagem. Por exemplo, bitmap RGB +de 24 bits precisa de \fBdist=3\fP, e também é bom passar \fBpb=0\fP para LZMA2 +para acomodar o alinhamento de três bytes: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Se várias imagens foram colocadas em um único arquivo (por exemplo, +\&\fB.tar\fP), o filtro Delta também funcionará, desde que todas as imagens +tenham o mesmo número de bytes por pixel. +. +.SH "VEJA TAMBÉM" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/xzcat.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/xzcat.1 new file mode 100644 index 0000000000000000000000000000000000000000..0f85fc96ac66488096221e723d837e7d28ff6bc2 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/xzcat.1 @@ -0,0 +1,1994 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Brazilian Portuguese translations for xz package +.\" Traduções em português brasileiro para o pacote xz. +.\" Rafael Fontenelle , 2022-2023. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 2025\-03\-08 Tukaani "XZ Utils" +. +.SH NOME +xz, unxz, xzcat, lzma, unlzma, lzcat \- Compacta ou descompacta arquivos .xz +e .lzma +. +.SH SINOPSE +\fBxz\fP [\fIopção...\fP] [\fIarquivo...\fP] +. +.SH "COMANDOS APELIDOS" +\fBunxz\fP é equivalente a \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP é equivalente a \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP é equivalente a \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP é equivalente a \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP é equivalente a \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Ao escrever scripts que precisam descompactar arquivos, é recomendável +sempre usar o nome \fBxz\fP com os argumentos apropriados (\fBxz \-d\fP ou \fBxz \-dc\fP) em vez dos nomes \fBunxz\fP e \fBxzcat\fP. +. +.SH DESCRIÇÃO +\fBxz\fP é uma ferramenta de compactação de dados de uso geral com sintaxe de +linha de comando semelhante ao \fBgzip\fP(1) e ao \fBbzip2\fP(1). O formato de +arquivo nativo é o formato \fB.xz\fP, mas o formato legado \fB.lzma\fP usado por +LZMA Utils e fluxos compactados brutos sem cabeçalhos de formato de +contêiner também são suportados. Além disso, a descompactação do formato +\&\fB.lz\fP usado por \fBlzip\fP é suportada. +.PP +\fBxz\fP compacta ou descompacta cada \fIarquivo\fP de acordo com o modo de +operação selecionado. Se nenhum \fIarquivo\fP for fornecido ou \fIarquivo\fP for +\fB\-\fP, \fBxz\fP lê da entrada padrão e grava os dados processados na saída +padrão. \fBxz\fP recusará (exibirá um erro e ignorará o \fIarquivo\fP) para gravar +dados compactados na saída padrão se for um terminal. Da mesma forma, \fBxz\fP +se recusará a ler dados compactados da entrada padrão se for um terminal. +.PP +A menos que \fB\-\-stdout\fP seja especificado, \fIarquivos\fP diferentes de \fB\-\fP +são gravados em um novo arquivo cujo nome é derivado do nome \fIarquivo\fP de +origem: +.IP \(bu 3 +Ao compactar, o sufixo do formato de arquivo de destino (\fB.xz\fP ou \fB.lzma\fP) +é anexado ao nome do arquivo de origem para obter o nome do arquivo de +destino. +.IP \(bu 3 +Ao descompactar, o sufixo \fB.xz\fP, \fB.lzma\fP ou \fB.lz\fP é removido do nome do +arquivo para obter o nome do arquivo de destino. \fBxz\fP também reconhece os +sufixos \fB.txz\fP e \fB.tlz\fP e os substitui pelo sufixo \fB.tar\fP. +.PP +Se o arquivo de destino já existir, um erro será exibido e \fIarquivo\fP será +ignorado. +.PP +A menos que grave na saída padrão, \fBxz\fP exibirá um aviso e pulará o +\fIarquivo\fP se qualquer um dos seguintes se aplicar: +.IP \(bu 3 +\fIArquivo\fP não é um arquivo normal. Links simbólicos não são seguidos e, +portanto, não são considerados arquivos comuns. +.IP \(bu 3 +\fIArquivo\fP tem mais de um link físico. +.IP \(bu 3 +\fIFile\fP tem setuid, setgid ou sticky bit definido. +.IP \(bu 3 +O modo de operação está definido para compactar e o \fIarquivo\fP já possui um +sufixo do formato de arquivo de destino (\fB.xz\fP ou \fB.txz\fP ao compactar para +o formato \fB.xz\fP e \fB.lzma \fP ou \fB.tlz\fP ao compactar para o formato +\&\fB.lzma\fP). +.IP \(bu 3 +O modo de operação está definido para descompactar e o \fIarquivo\fP não possui +um sufixo de nenhum dos formatos de arquivo suportados (\fB.xz\fP, \fB.txz\fP, +\&\fB.lzma\fP, \fB.tlz\fP , ou \fB.lz\fP). +.PP +Depois de compactar ou descompactar com êxito o \fIarquivo\fP, o \fBxz\fP copia o +dono, grupo, permissões, horário de acesso e horário de modificação do +\fIarquivo\fP de origem para o arquivo de destino. Se a cópia do grupo falhar, +as permissões serão modificadas para que o arquivo de destino não se torne +acessível a usuários que não têm permissão para acessar o \fIarquivo\fP de +origem. \fBxz\fP ainda não oferece suporte à cópia de outros metadados, como +listas de controle de acesso ou atributos estendidos. +.PP +Depois que o arquivo de destino for fechado com êxito, o \fIarquivo\fP de +origem será removido, a menos que \fB\-\-keep\fP tenha sido especificado. O +\fIarquivo\fP de origem nunca é removido se a saída for gravada na saída padrão +ou se ocorrer um erro. +.PP +O envio de \fBSIGINFO\fP ou \fBSIGUSR1\fP para o processo do \fBxz\fP faz com que ele +imprima informações de andamento para erro padrão. Isso tem uso limitado, +pois quando o erro padrão é um terminal, usar \fB\-\-verbose\fP exibirá um +indicador de progresso de atualização automática. +. +.SS "Uso de memória" +O uso de memória de \fBxz\fP varia de algumas centenas de kilobytes a vários +gigabytes, dependendo das configurações de compactação. As configurações +usadas ao compactar um arquivo determinam os requisitos de memória do +descompactador. Normalmente, o descompactador precisa de 5\ % a 20\ % da +quantidade de memória que o compactador precisou ao criar o arquivo. Por +exemplo, descompactar um arquivo criado com \fBxz \-9\fP atualmente requer 65\ MiB de memória. Ainda assim, é possível ter arquivos \fB.xz\fP que requerem +vários gigabytes de memória para descompactar. +.PP +Especialmente os usuários de sistemas mais antigos podem achar irritante a +possibilidade de uso de memória muito grande. Para evitar surpresas +desconfortáveis, o \fBxz\fP possui um limitador de uso de memória embutido, que +está desabilitado por padrão. Embora alguns sistemas operacionais forneçam +maneiras de limitar o uso de memória dos processos, confiar nele não foi +considerado flexível o suficiente (por exemplo, usar \fBulimit\fP(1) para +limitar a memória virtual tende a prejudicar \fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +O limitador de uso de memória pode ser ativado com a opção de linha de +comando \fB\-\-memlimit=\fP\fIlimite\fP. Geralmente é mais conveniente habilitar o +limitador por padrão definindo a variável de ambiente \fBXZ_DEFAULTS\fP, por +exemplo, \fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. É possível definir os limites +separadamente para compactação e descompactação usando +\fB\-\-memlimit\-compress=\fP\fIlimite\fP e \fB\-\-memlimit\-decompress=\fP\fIlimite\fP. Usar +essas duas opções fora de \fBXZ_DEFAULTS\fP raramente é útil porque uma única +execução de \fBxz\fP não pode fazer compactação e descompactação e +\fB\-\-memlimit=\fP\fIlimite\fP (ou \fB\-M\fP \fIlimite\fP ) é mais curto para digitar na +linha de comando. +.PP +Se o limite de uso de memória especificado for excedido durante a +descompactação, \fBxz\fP exibirá um erro e a descompactação do arquivo +falhará. Se o limite for excedido durante a compactação, \fBxz\fP tentará +reduzir as configurações para que o limite não seja mais excedido (exceto ao +usar \fB\-\-format=raw\fP ou \fB\-\-no\-adjust\fP). Dessa forma, a operação não +falhará, a menos que o limite seja muito pequeno. A escala das configurações +é feita em etapas que não correspondem às predefinições do nível de +compactação, por exemplo, se o limite for apenas um pouco menor que o valor +necessário para \fBxz \-9\fP, as configurações serão reduzidas apenas um pouco , +não até \fBxz \-8\fP. +. +.SS "Concatenação e preenchimento com arquivos .xz" +É possível concatenar arquivos \fB.xz\fP como estão. \fBxz\fP irá descompactar +tais arquivos como se fossem um único arquivo \fB.xz\fP. +.PP +É possível inserir preenchimento entre as partes concatenadas ou após a +última parte. O preenchimento deve consistir em bytes nulos e o tamanho do +preenchimento deve ser um múltiplo de quatro bytes. Isso pode ser útil, por +exemplo, se o arquivo \fB.xz\fP for armazenado em uma mídia que mede tamanhos +de arquivo em blocos de 512 bytes. +.PP +Concatenação e preenchimento não são permitidos com arquivos \fB.lzma\fP ou +fluxos brutos. +. +.SH OPÇÕES +. +.SS "Sufixos inteiros e valores especiais" +Na maioria dos lugares onde um argumento inteiro é esperado, um sufixo +opcional é suportado para indicar facilmente números inteiros grandes. Não +deve haver espaço entre o número inteiro e o sufixo. +.TP +\fBKiB\fP +Multiplica o inteiro por 1.024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP e \fBKB\fP são +aceitos como sinônimos de \fBKiB\fP. +.TP +\fBMiB\fP +Multiplica o número inteiro por 1.048.576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP e \fBMB\fP +são aceitos como sinônimos de \fBMiB\fP. +.TP +\fBGiB\fP +Multiplica o número inteiro por 1.073.741.824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP e +\fBGB\fP são aceitos como sinônimos de \fBGiB\fP. +.PP +O valor especial \fBmax\fP pode ser usado para indicar o valor inteiro máximo +suportado pela opção. +. +.SS "Modo de operação" +Se várias opções de modo de operação forem dadas, a última entrará em vigor. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Compacta. Este é o modo de operação padrão quando nenhuma opção de modo de +operação é especificada e nenhum outro modo de operação está implícito no +nome do comando (por exemplo, \fBunxz\fP implica em \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +After successful compression, the source file is removed unless writing to +standard output or \fB\-\-keep\fP was specified. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Decompress. After successful decompression, the source file is removed +unless writing to standard output or \fB\-\-keep\fP was specified. +.TP +\fB\-t\fP, \fB\-\-test\fP +Testa a integridade de \fIarquivos\fP compactados. Esta opção é equivalente a +\fB\-\-decompress \-\-stdout\fP exceto que os dados descompactados são descartados +em vez de serem gravados na saída padrão. Nenhum arquivo é criado ou +removido. +.TP +\fB\-l\fP, \fB\-\-list\fP +Imprime informações sobre \fIarquivos\fP compactados. Nenhuma saída +descompactada é produzida e nenhum arquivo é criado ou removido. No modo de +lista, o programa não pode ler os dados compactados da entrada padrão ou de +outras fontes não pesquisáveis. +.IP "" +A listagem padrão mostra informações básicas sobre \fIarquivos\fP, um arquivo +por linha. Para obter informações mais detalhadas, use também a opção +\fB\-\-verbose\fP. Para obter ainda mais informações, use \fB\-\-verbose\fP duas +vezes, mas observe que isso pode ser lento, porque obter todas as +informações extras requer muitas buscas. A largura da saída detalhada excede +80 caracteres, portanto, canalizar a saída para, por exemplo, \fBless\ \-S\fP +pode ser conveniente se o terminal não tiver largura o suficiente. +.IP "" +A saída exata pode variar entre versões \fBxz\fP e localidades diferentes. Para +saída legível por máquina, \fB\-\-robot \-\-list\fP deve ser usado. +. +.SS "Modificadores de operação" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Não exclui os arquivos de entrada. +.IP "" +Desde \fBxz\fP 5.2.6, esta opção também faz \fBxz\fP compactar ou descompactar +mesmo se a entrada for um link simbólico para um arquivo comum, tiver mais +de um link físico ou tiver o setuid, setgid ou sticky bit definir. Os bits +setuid, setgid e sticky não são copiados para o arquivo de destino. Nas +versões anteriores, isso era feito apenas com \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Esta opção tem vários efeitos: +.RS +.IP \(bu 3 +Se o arquivo de destino já existir, o exclui antes de compactar ou +descompactar. +.IP \(bu 3 +Compacta ou descompacta, mesmo que a entrada seja um link simbólico para um +arquivo normal, tenha mais de um link físico ou tenha setuid, setgid ou +sticky bit definido. Os bits setuid, setgid e sticky não são copiados para o +arquivo de destino. +.IP \(bu 3 +Quando usado com \fB\-\-decompress\fP \fB\-\-stdout\fP e \fBxz\fP não consegue reconhecer +o tipo do arquivo de origem, copia o arquivo de origem como está na saída +padrão. Isso permite que \fBxzcat\fP \fB\-\-force\fP seja usado como \fBcat\fP(1) para +arquivos que não foram compactados com \fBxz\fP. Observe que, no futuro, o +\fBxz\fP pode oferecer suporte a novos formatos de arquivo compactado, o que +pode fazer com que o \fBxz\fP descompacte mais tipos de arquivos em vez de +copiá\-los como na saída padrão. \fB\-\-format=\fP\fIformato\fP pode ser usado para +restringir \fBxz\fP para descompactar apenas um único formato de arquivo. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Grava os dados compactados ou descompactados na saída padrão em vez de em um +arquivo. Isso implica em \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Descompacta apenas o primeiro fluxo de \fB.xz\fP e ignora silenciosamente +possíveis dados de entrada restantes após o fluxo. Normalmente, esse +restante posterior sem uso faz com que \fBxz\fP exiba um erro. +.IP "" +\fBxz\fP nunca descompacta mais de um fluxo de arquivos \fB.lzma\fP ou fluxos +brutos, mas esta opção ainda faz \fBxz\fP ignorar os possíveis dados +posteriores após o arquivo \fB.lzma\fP ou fluxo bruto. +.IP "" +Esta opção não tem efeito se o modo de operação não for \fB\-\-decompress\fP ou +\fB\-\-test\fP. +.IP "" +Since \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP implies \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Desativa a criação de arquivos esparsos. Por padrão, ao descompactar em um +arquivo normal, \fBxz\fP tenta tornar o arquivo esparso se os dados +descompactados contiverem longas sequências de zeros binários. Ele também +funciona ao gravar na saída padrão, desde que a saída padrão esteja +conectada a um arquivo normal e certas condições adicionais sejam atendidas +para torná\-la segura. A criação de arquivos esparsos pode economizar espaço +em disco e acelerar a descompactação, reduzindo a quantidade de E/S do +disco. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Ao compactar, usa \fI.suf\fP como sufixo para o arquivo de destino em vez de +\&\fB.xz\fP ou \fB.lzma\fP. Se não estiver gravando na saída padrão e o arquivo de +origem já tiver o sufixo \fI.suf\fP, um aviso será exibido e o arquivo será +ignorado. +.IP "" +Ao descompactar, reconhece arquivos com o sufixo \fI.suf\fP além de arquivos +com o sufixo \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP ou \fB.lz\fP . Se o arquivo de +origem tiver o sufixo \fI.suf\fP, o sufixo será removido para obter o nome do +arquivo de destino. +.IP "" +Ao compactar ou descompactar fluxos brutos (\fB\-\-format=raw\fP), o sufixo +sempre deve ser especificado, a menos que seja gravado na saída padrão, +porque não há sufixo padrão para fluxos brutos. +.TP +\fB\-\-files\fP[\fB=\fP\fIarquivo\fP] +Lê os nomes dos arquivos a serem processados em \fIarquivo\fP; se \fIarquivo\fP +for omitido, os nomes dos arquivos serão lidos da entrada padrão. Os nomes +de arquivo devem terminar com o caractere de nova linha. Um traço (\fB\-\fP) é +considerado um nome de arquivo regular; não significa entrada padrão. Se os +nomes de arquivo forem fornecidos também como argumentos de linha de +comando, eles serão processados antes da leitura dos nomes de arquivo de +\fIarquivo\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIarquivo\fP] +Isso é idêntico a \fB\-\-files\fP[\fB=\fP\fIarquivo\fP], exceto que cada nome de +arquivo deve ser finalizado com o caractere nulo. +. +.SS "Opções básicas de formato de arquivo e de compactação" +.TP +\fB\-F\fP \fIformato\fP, \fB\-\-format=\fP\fIformato\fP +Especifica o \fIformato\fP de arquivo para compactar ou descompactar: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Este é o padrão. Ao compactar, \fBauto\fP é equivalente a \fBxz\fP. Ao +descompactar, o formato do arquivo de entrada é detectado +automaticamente. Observe que os fluxos brutos (criados com \fB\-\-format=raw\fP) +não podem ser detectados automaticamente. +.TP +\fBxz\fP +Compacta no formato de arquivo \fB.xz\fP ou aceite apenas arquivos \fB.xz\fP ao +descompactar. +.TP +\fBlzma\fP, \fBalone\fP +Compacta no formato de arquivo legado \fB.lzma\fP ou aceite apenas arquivos +\&\fB.lzma\fP ao descompactar. O nome alternativo \fBalone\fP é fornecido para +compatibilidade com versões anteriores do LZMA Utils. +.TP +\fBlzip\fP +Aceita apenas arquivos \fB.lz\fP ao descompactar. Sem suporte a compactação. +.IP "" +The \fB.lz\fP format versions 0 and 1 are supported. Version 0 files were +produced by \fBlzip\fP 1.3 and older. Such files aren't common but may be +found from file archives as a few source packages were released in this +format. People might have old personal files in this format too. +Decompression support for the format version 0 was removed in \fBlzip\fP 1.18. +\fBlzip\fP 1.4 and later create files in the format version 1. +.TP +\fBraw\fP +Compacta ou descompacta um fluxo bruto (sem cabeçalhos). Isso é destinado +apenas a usuários avançados. Para decodificar fluxos brutos, você precisa +usar \fB\-\-format=raw\fP e especificar explicitamente a cadeia de filtros, que +normalmente seria armazenada nos cabeçalhos do contêiner. +.RE +.TP +\fB\-C\fP \fIverificação\fP, \fB\-\-check=\fP\fIverificação\fP +Especifica o tipo de verificação de integridade. A verificação é calculada a +partir dos dados descompactados e armazenados no arquivo \fB.xz\fP. Esta opção +tem efeito somente ao compactar no formato \fB.xz\fP; o formato \fB.lzma\fP não +oferece suporte a verificações de integridade. A verificação de integridade +(se for o caso) é verificada quando o arquivo \fB.xz\fP é descompactado. +.IP "" +Tipos de \fIverificação\fP suportados: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Não calcula uma verificação de integridade. Isso geralmente é uma má +ideia. Pode ser útil quando a integridade dos dados é verificada por outros +meios. +.TP +\fBcrc32\fP +Calcula CRC32 usando o polinômio do IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Calcula CRC64 usando o polinômio de ECMA\-182. Este é o padrão, pois é um +pouco melhor que o CRC32 na detecção de arquivos danificados e a diferença +de velocidade é insignificante. +.TP +\fBsha256\fP +Calcula SHA\-256. Isso é um pouco mais lento do que CRC32 e CRC64. +.RE +.IP "" +A integridade dos cabeçalhos de \fB.xz\fP é sempre verificada com CRC32. Não é +possível alterá\-la ou desativá\-la. +.TP +\fB\-\-ignore\-check\fP +Não confere a verificação de integridade dos dados compactados ao +descompactar. Os valores CRC32 nos cabeçalhos \fB.xz\fP ainda serão conferidos +normalmente. +.IP "" +\fBNão use esta opção a menos que saiba o que está fazendo.\fP Possíveis razões +para usar esta opção: +.RS +.IP \(bu 3 +Tentativa de recuperar dados de um arquivo .xz corrompido. +.IP \(bu 3 +Acelerar a descompactação. Isso é importante principalmente com SHA\-256 ou +com arquivos extremamente bem compactados. É recomendável não usar essa +opção para essa finalidade, a menos que a integridade do arquivo seja +verificada externamente de alguma outra forma. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Seleciona um nível de predefinição de compactação. O padrão é \fB\-6\fP. Se +vários níveis de predefinição forem especificados, o último terá efeito. Se +uma cadeia de filtro personalizada já foi especificada, especificar um nível +de predefinição de compactação limpa a cadeia de filtro personalizada. +.IP "" +As diferenças entre as predefinições são mais significativas do que com +\fBgzip\fP(1) e \fBbzip2\fP(1). As configurações de compactação selecionadas +determinam os requisitos de memória do descompactador, portanto, usar um +nível de predefinição muito alto pode dificultar a descompactação do arquivo +em um sistema antigo com pouca RAM. Especificamente, \fBnão é uma boa ideia usar cegamente \-9 para tudo\fP como costuma acontecer com \fBgzip\fP(1) e +\fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Estas são predefinições um tanto rápidas. \fB\-0\fP às vezes é mais rápida que +\fBgzip \-9\fP ao mesmo tempo que compacta muito melhor. As mais altas +geralmente têm velocidade comparável ao \fBbzip2\fP(1) com taxa de compactação +comparável ou melhor, embora os resultados dependam muito do tipo de dados +que estão sendo compactados. +.TP +\fB\-4\fP ... \fB\-6\fP +Compactação boa a muito boa, mantendo o uso de memória do descompactador +razoável mesmo para sistemas antigos. \fB\-6\fP é o padrão, que geralmente é uma +boa escolha para distribuir arquivos que precisam ser descompactáveis, mesmo +em sistemas com apenas 16\ MiB de RAM. (\fB\-5e\fP ou \fB\-6e\fP também vale a pena +considerar. Veja \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Eles são como \fB\-6\fP, mas com requisitos de memória de compressor e +descompressor mais altos. Eles são úteis apenas ao compactar arquivos +maiores que 8\ MiB, 16\ MiB e 32\ MiB, respectivamente. +.RE +.IP "" +No mesmo hardware, a velocidade de descompactação é aproximadamente um +número constante de bytes de dados compactados por segundo. Em outras +palavras, quanto melhor a compactação, mais rápida será a +descompactação. Isso também significa que a quantidade de saída não +compactada produzida por segundo pode variar muito. +.IP "" +A tabela a seguir resume os recursos das predefinições: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Predefinição;DicTam;CompCPU;CompMem;DecMem +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Descrições das colunas: +.RS +.IP \(bu 3 +DicTam é o tamanho do dicionário LZMA2. É desperdício de memória usar um +dicionário maior que o tamanho do arquivo descompactado. É por isso que é +bom evitar usar as predefinições \fB\-7\fP ... \fB\-9\fP quando não há real +necessidade deles. Em \fB\-6\fP e inferior, a quantidade de memória desperdiçada +geralmente é baixa o suficiente para não importar. +.IP \(bu 3 +CompCPU é uma representação simplificada das configurações LZMA2 que afetam +a velocidade de compactação. O tamanho do dicionário também afeta a +velocidade, portanto, embora o CompCPU seja o mesmo para os níveis \fB\-6\fP +\&... \fB\-9\fP, níveis mais altos ainda tendem a ser um pouco mais lentos. Para +obter uma compactação ainda mais lenta e possivelmente melhor, consulte +\fB\-\-extreme\fP. +.IP \(bu 3 +CompMem contains the compressor memory requirements in the single\-threaded +mode. It may vary slightly between \fBxz\fP versions. +.IP \(bu 3 +DecMem contém os requisitos de memória do descompactador. Ou seja, as +configurações de compactação determinam os requisitos de memória do +descompactador. O uso exato da memória do descompactador é um pouco maior do +que o tamanho do dicionário LZMA2, mas os valores na tabela foram +arredondados para o próximo MiB completo. +.RE +.IP "" +Memory requirements of the multi\-threaded mode are significantly higher than +that of the single\-threaded mode. With the default value of +\fB\-\-block\-size\fP, each thread needs 3*3*DictSize plus CompMem or DecMem. For +example, four threads with preset \fB\-6\fP needs 660\(en670\ MiB of memory. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Usa uma variante mais lenta do nível de predefinição de compactação +selecionado (\fB\-0\fP ... \fB\-9\fP) para obter uma taxa de compactação um pouco +melhor, mas, com azar, isso também pode piorar. O uso da memória do +descompressor não é afetado, mas o uso da memória do compactador aumenta um +pouco nos níveis de predefinição \fB\-0\fP ... \fB\-3\fP. +.IP "" +Como existem duas predefinições com tamanhos de dicionário 4\ MiB e 8\ MiB, +as predefinições \fB\-3e\fP e \fB\-5e\fP usam configurações um pouco mais rápidas +(CompCPU inferior) do que \fB\-4e\fP e \fB\-6e\fP, respectivamente. Dessa forma, não +há duas predefinições idênticas. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Predefinição;DicTam;CompCPU;CompMem;DecMem +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Por exemplo, há um total de quatro predefinições que usam o dicionário 8\ MiB, cuja ordem do mais rápido ao mais lento é \fB\-5\fP, \fB\-6\fP, \fB\-5e\fP e +\fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Esses são apelidos um tanto enganosos para \fB\-0\fP e \fB\-9\fP, +respectivamente. Eles são fornecidos apenas para compatibilidade com versões +anteriores do LZMA Utils. Evite usar essas opções. +.TP +\fB\-\-block\-size=\fP\fItamanho\fP +Ao compactar para o formato \fB.xz\fP, divida os dados de entrada em blocos de +\fItamanho\fP bytes. Os blocos são compactados independentemente uns dos +outros, o que ajuda no multi\-threading e torna possível a descompactação +limitada de acesso aleatório. Essa opção normalmente é usada para substituir +o tamanho de bloco padrão no modo multi\-thread, mas também pode ser usada em +thread única. +.IP "" +In multi\-threaded mode about three times \fIsize\fP bytes will be allocated in +each thread for buffering input and output. The default \fIsize\fP is three +times the LZMA2 dictionary size or 1 MiB, whichever is more. Typically a +good value is 2\(en4 times the size of the LZMA2 dictionary or at least 1 +MiB. Using \fIsize\fP less than the LZMA2 dictionary size is waste of RAM +because then the LZMA2 dictionary buffer will never get fully used. In +multi\-threaded mode, the sizes of the blocks are stored in the block +headers. This size information is required for multi\-threaded +decompression. +.IP "" +In single\-threaded mode no block splitting is done by default. Setting this +option doesn't affect memory usage. No size information is stored in block +headers, thus files created in single\-threaded mode won't be identical to +files created in multi\-threaded mode. The lack of size information also +means that \fBxz\fP won't be able decompress the files in multi\-threaded mode. +.TP +\fB\-\-block\-list=\fP\fIitems\fP +When compressing to the \fB.xz\fP format, start a new block with an optional +custom filter chain after the given intervals of uncompressed data. +.IP "" +The \fIitems\fP are a comma\-separated list. Each item consists of an optional +filter chain number between 0 and 9 followed by a colon (\fB:\fP) and a +required size of uncompressed data. Omitting an item (two or more +consecutive commas) is a shorthand to use the size and filters of the +previous item. +.IP "" +If the input file is bigger than the sum of the sizes in \fIitems\fP, the last +item is repeated until the end of the file. A special value of \fB0\fP may be +used as the last size to indicate that the rest of the file should be +encoded as a single block. +.IP "" +An alternative filter chain for each block can be specified in combination +with the \fB\-\-filters1=\fP\fIfilters\fP \&...\& \fB\-\-filters9=\fP\fIfilters\fP options. +These options define filter chains with an identifier between 1\(en9. +Filter chain 0 can be used to refer to the default filter chain, which is +the same as not specifying a filter chain. The filter chain identifier can +be used before the uncompressed size, followed by a colon (\fB:\fP). For +example, if one specifies \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP +then blocks will be created using: +.RS +.IP \(bu 3 +The filter chain specified by \fB\-\-filters1\fP and 2 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters3\fP and 2 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters2\fP and 4 MiB input +.IP \(bu 3 +The filter chain specified by \fB\-\-filters2\fP and 4 MiB input +.IP \(bu 3 +The default filter chain and 2 MiB input +.IP \(bu 3 +The default filter chain and 4 MiB input for every block until end of input. +.RE +.IP "" +If one specifies a size that exceeds the encoder's block size (either the +default value in threaded mode or the value specified with +\fB\-\-block\-size=\fP\fIsize\fP), the encoder will create additional blocks while +keeping the boundaries specified in \fIitems\fP. For example, if one specifies +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP and the +input file is 80 MiB, one will get 11 blocks: 5, 10, 8, 10, 2, 10, 10, 4, +10, 10, and 1 MiB. +.IP "" +No modo multi\-thread, os tamanhos dos blocos são armazenados nos cabeçalhos +dos blocos. Isso não é feito no modo de thread única, portanto, a saída +codificada não será idêntica à do modo multi\-thread. +.TP +\fB\-\-flush\-timeout=\fP\fItempo_limite\fP +Ao compactar, se mais de \fItempo_limite\fP milissegundos (um número inteiro +positivo) se passaram desde a liberação anterior e a leitura de mais entrada +seria bloqueada, todos os dados de entrada pendentes serão liberados do +codificador e disponibilizados no fluxo de saída. Isso pode ser útil se +\fBxz\fP for usado para compactar dados transmitidos por uma rede. Valores +\fItempo_limite\fP pequenos tornam os dados disponíveis na extremidade +receptora com um pequeno atraso, mas valores \fItempo_limite\fP grandes +oferecem melhor taxa de compactação. +.IP "" +Esse recurso está desabilitado por padrão. Se esta opção for especificada +mais de uma vez, a última terá efeito. O valor especial \fItempo_limite\fP de +\fB0\fP pode ser usado para desabilitar explicitamente esse recurso. +.IP "" +Este recurso não está disponível em sistemas não\-POSIX. +.IP "" +.\" FIXME +\fBEste recurso ainda é experimental.\fP Atualmente, \fBxz\fP não é adequado para +descompactar o fluxo em tempo real devido à forma como \fBxz\fP faz o buffer. +.TP +\fB\-\-no\-sync\fP +Do not synchronize the target file and its directory to the storage device +before removing the source file. This can improve performance if +compressing or decompressing many small files. However, if the system +crashes soon after the deletion, it is possible that the target file was not +written to the storage device but the delete operation was. In that case +neither the original source file nor the target file is available. +.IP "" +This option has an effect only when \fBxz\fP is going to remove the source +file. In other cases synchronization is never done. +.IP "" +The synchronization and \fB\-\-no\-sync\fP were added in \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIlimite\fP +Define um limite de uso de memória para compactação. Se esta opção for +especificada várias vezes, a última entrará em vigor. +.IP "" +Se as configurações de compactação excederem o \fIlimite\fP, \fBxz\fP tentará +ajustar as configurações para baixo para que o limite não seja mais excedido +e exibirá um aviso de que o ajuste automático foi feito. Os ajustes são +feitos nesta ordem: reduzindo o número de encadeamentos, alternando para o +modo sigle\-thread se até mesmo uma thread no modo multi\-thread exceder o +\fIlimite\fP e, finalmente, reduzindo o tamanho do dicionário LZMA2. +.IP "" +Ao compactar com \fB\-\-format=raw\fP ou se \fB\-\-no\-adjust\fP tiver sido +especificado, apenas o número de threads pode ser reduzido, pois isso pode +ser feito sem afetar a saída compactada. +.IP "" +Se o \fIlimite\fP não puder ser alcançado mesmo com os ajustes descritos acima, +um erro será exibido e \fBxz\fP sairá com status de saída 1. +.IP "" +O \fIlimite\fP pode ser especificado de várias maneiras: +.RS +.IP \(bu 3 +O \fIlimite\fP pode ser um valor absoluto em bytes. Usar um sufixo inteiro como +\fBMiB\fP pode ser útil. Exemplo: \fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +O \fIlimite\fP pode ser especificado como uma porcentagem da memória física +total (RAM). Isso pode ser útil especialmente ao definir a variável de +ambiente \fBXZ_DEFAULTS\fP em um script de inicialização de shell que é +compartilhado entre diferentes computadores. Dessa forma o limite é +automaticamente maior em sistemas com mais memória. Exemplo: +\fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +O \fIlimite\fP pode ser redefinido para seu valor padrão, definindo\-o como +\fB0\fP. Atualmente, isso equivale a definir \fIlimite\fP como \fBmax\fP (sem limite +de uso de memória). +.RE +.IP "" +Para \fBxz\fP de 32 bits, há um caso especial: se o \fIlimite\fP estiver acima de +\fB4020\ MiB\fP, o \fIlimite\fP é definido como \fB4020\ MiB\fP. No MIPS32 \fB2000\ MiB\fP é usado em seu lugar. (Os valores \fB0\fP e \fBmax\fP não são afetados por +isso. Um recurso semelhante não existe para descompactação.) Isso pode ser +útil quando um executável de 32 bits tem acesso a espaço de endereço de 4\ GiB (2 GiB no MIPS32) enquanto espero não causar danos em outras situações. +.IP "" +Consulte também a seção \fBUso de memória\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIlimite\fP +Define um limite de uso de memória para descompactação. Isso também afeta o +modo \fB\-\-list\fP. Se a operação não for possível sem exceder o \fIlimite\fP, +\fBxz\fP exibirá um erro e a descompactação do arquivo falhará. Consulte +\fB\-\-memlimit\-compress=\fP\fIlimite\fP para possíveis maneiras de especificar o +\fIlimite\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimite\fP +Define um limite de uso de memória para descompactação multi\-thread. Isso +pode afetar apenas o número de threads; isso nunca fará com que \fBxz\fP se +recuse a descompactar um arquivo. Se \fIlimite\fP for muito baixo para permitir +qualquer multi\-thread, o \fIlimite\fP será ignorado e \fBxz\fP continuará no modo +de thread única. Observe que se \fB\-\-memlimit\-decompress\fP também for usado, +ele sempre se aplicará aos modos de thread única e multi\-thread e, portanto, +o \fIlimite\fP efetivo para multi\-threading nunca será maior que o limite +definido com \fB\-\-memlimit\-decompress\fP. +.IP "" +Em contraste com as outras opções de limite de uso de memória, +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimite\fP tem um padrão \fIlimite\fP específico do +sistema. \fBxz \-\-info\-memory\fP pode ser usado para ver o valor atual. +.IP "" +Esta opção e seu valor padrão existem porque, sem qualquer limite, o +descompactador usando threads pode acabar alocando uma quantidade insana de +memória com alguns arquivos de entrada. Se o \fIlimite\fP padrão for muito +baixo em seu sistema, sinta\-se à vontade para aumentar o \fIlimite\fP, mas +nunca defina\-o para um valor maior que a quantidade de RAM utilizável, pois +com os arquivos de entrada apropriados \fBxz\fP tentará usar essa quantidade de +memória mesmo com um baixo número de threads. Ficar sem memória ou trocar +não melhorará o desempenho da descompactação. +.IP "" +Consulte \fB\-\-memlimit\-compress=\fP\fIlimite\fP para possíveis maneiras de +especificar o \fIlimite\fP. Definir \fIlimite\fP como \fB0\fP redefine \fIlimite\fP para +o valor padrão específico do sistema. +.TP +\fB\-M\fP \fIlimite\fP, \fB\-\-memlimit=\fP\fIlimite\fP, \fB\-\-memory=\fP\fIlimite\fP +Isso é equivalente a especificar \fB\-\-memlimit\-compress=\fP\fIlimite\fP +\fB\-\-memlimit\-decompress=\fP\fIlimite\fP \fB\-\-memlimit\-mt\-decompress=\fP\fIlimite\fP. +.TP +\fB\-\-no\-adjust\fP +Exibe um erro e saia se o limite de uso de memória não puder ser atendido +sem ajustar as configurações que afetam a saída compactada. Ou seja, isso +evita que \fBxz\fP alterne o codificador do modo multi\-thread para o modo +encadeado único e reduza o tamanho do dicionário LZMA2. Mesmo quando esta +opção é usada, o número de threads pode ser reduzido para atender ao limite +de uso de memória, pois isso não afetará a saída compactada. +.IP "" +O ajuste automático é sempre desativado ao criar fluxos brutos +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fIthreads\fP, \fB\-\-threads=\fP\fIthreads\fP +Especifica o número de threads de trabalho a serem usados. Definir +\fIthreads\fP para um valor especial \fB0\fP faz com que \fBxz\fP use tantos threads +quanto o(s) processador(es) no suporte do sistema. O número real de +encadeamentos pode ser menor que \fIthreads\fP se o arquivo de entrada não for +grande o suficiente para subdividir em threads com as configurações +fornecidas ou se o uso de mais threads exceder o limite de uso de memória. +.IP "" +Os compactadores usando thread única e várias threads produzem saídas +diferentes. O compactador de thread única fornecerá o menor tamanho de +arquivo, mas apenas a saída do compactador de várias threads pode ser +descompactada usando várias threads. Definir \fIthreads\fP como \fB1\fP usará o +modo de thread única. Definir \fIthreads\fP para qualquer outro valor, +incluindo \fB0\fP, usará o compressor de várias threads, mesmo que o sistema +tenha suporte a apenas uma thread de hardware. (\fBxz\fP 5.2.x usou o modo de +thread única nesta situação.) +.IP "" +Para usar o modo de várias threads com apenas uma thread, defina \fIthreads\fP +como \fB+1\fP. O prefixo \fB+\fP não tem efeito com valores diferentes de \fB1\fP. Um +limite de uso de memória ainda pode fazer \fBxz\fP alternar para o modo de +thread única, a menos que \fB\-\-no\-adjust\fP seja usado. O suporte para o +prefixo \fB+\fP foi adicionado no \fBxz\fP 5.4.0. +.IP "" +Se um número automático de threads foi solicitado e nenhum limite de uso de +memória foi especificado, um limite flexível padrão específico do sistema +será usado para possivelmente limitar o número de threads. É um limite +flexível no sentido de que é ignorado se o número de threads se tornar um, +portanto, um limite flexível nunca impedirá \fBxz\fP de compactar ou +descompactar. Este limite flexível padrão não fará com que \fBxz\fP alterne do +modo de várias threads para o modo de thread única. Os limites ativos podem +ser vistos com \fBxz \-\-info\-memory\fP. +.IP "" +Atualmente, o único método de threading é dividir a entrada em blocos e +comprimi\-los independentemente um do outro. O tamanho padrão do bloco +depende do nível de compactação e pode ser substituído com a opção +\fB\-\-block\-size=\fP\fItamanho\fP. +.IP "" +A descompactação em threads funciona apenas em arquivos que contêm vários +blocos com informações de tamanho nos cabeçalhos dos blocos. Todos os +arquivos grandes o suficiente compactados no modo de várias thread atendem a +essa condição, mas os arquivos compactados no modo de thread única não +atendem, mesmo se \fB\-\-block\-size=\fP\fItamanho\fP tiver sido usado. +.IP "" +The default value for \fIthreads\fP is \fB0\fP. In \fBxz\fP 5.4.x and older the +default is \fB1\fP. +. +.SS "Cadeias de filtro de compressor personalizadas" +Uma cadeia de filtro personalizada permite especificar as configurações de +compactação em detalhes, em vez de confiar nas configurações associadas às +predefinições. Quando uma cadeia de filtro personalizada é especificada, as +opções predefinidas (\fB\-0\fP \&...\& \fB\-9\fP e \fB\-\-extreme\fP) anteriores na linha +de comando são esquecidas. Se uma opção predefinida for especificada após +uma ou mais opções de cadeia de filtros personalizados, a nova predefinição +entrará em vigor e as opções de cadeia de filtros personalizados +especificadas anteriormente serão esquecidas. +.PP +Uma cadeia de filtro é comparável à tubulação na linha de comando. Ao +compactar, a entrada descompactada vai para o primeiro filtro, cuja saída +vai para o próximo filtro (se houver). A saída do último filtro é gravada no +arquivo compactado. O número máximo de filtros na cadeia é quatro, mas +normalmente uma cadeia de filtros tem apenas um ou dois filtros. +.PP +Muitos filtros têm limitações sobre onde podem estar na cadeia de filtros: +alguns filtros podem funcionar apenas como o último filtro na cadeia, alguns +apenas como filtro não\-último e alguns funcionam em qualquer posição na +cadeia. Dependendo do filtro, essa limitação é inerente ao projeto do filtro +ou existe para evitar problemas de segurança. +.PP +A custom filter chain can be specified in two different ways. The options +\fB\-\-filters=\fP\fIfilters\fP and \fB\-\-filters1=\fP\fIfilters\fP \&...\& +\fB\-\-filters9=\fP\fIfilters\fP allow specifying an entire filter chain in one +option using the liblzma filter string syntax. Alternatively, a filter +chain can be specified by using one or more individual filter options in the +order they are wanted in the filter chain. That is, the order of the +individual filter options is significant! When decoding raw streams +(\fB\-\-format=raw\fP), the filter chain must be specified in the same order as +it was specified when compressing. Any individual filter or preset options +specified before the full chain option (\fB\-\-filters=\fP\fIfilters\fP) will be +forgotten. Individual filters specified after the full chain option will +reset the filter chain. +.PP +Both the full and individual filter options take filter\-specific \fIoptions\fP +as a comma\-separated list. Extra commas in \fIoptions\fP are ignored. Every +option has a default value, so specify those you want to change. +.PP +Para ver toda a cadeia de filtros e \fIopções\fP, use \fBxz \-vv\fP (isto é, use +\fB\-\-verbose\fP duas vezes). Isso também funciona para visualizar as opções da +cadeia de filtros usadas pelas predefinições. +.TP +\fB\-\-filters=\fP\fIfilters\fP +Specify the full filter chain or a preset in a single option. Each filter +can be separated by spaces or two dashes (\fB\-\-\fP). \fIfilters\fP may need to be +quoted on the shell command line so it is parsed as a single option. To +denote \fIoptions\fP, use \fB:\fP or \fB=\fP. A preset can be prefixed with a \fB\-\fP +and followed with zero or more flags. The only supported flag is \fBe\fP to +apply the same options as \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIfilters\fP ... \fB\-\-filters9\fP=\fIfilters\fP +Specify up to nine additional filter chains that can be used with +\fB\-\-block\-list\fP. +.IP "" +For example, when compressing an archive with executable files followed by +text files, the executable part could use a filter chain with a BCJ filter +and the text part only the LZMA2 filter. +.TP +\fB\-\-filters\-help\fP +Display a help message describing how to specify presets and custom filter +chains in the \fB\-\-filters\fP and \fB\-\-filters1=\fP\fIfilters\fP \&...\& +\fB\-\-filters9=\fP\fIfilters\fP options, and exit successfully. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIopções\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIopções\fP] +.PD +Adiciona o filtro LZMA1 ou LZMA2 à cadeia de filtros. Esses filtros podem +ser usados apenas como o último filtro na cadeia. +.IP "" +LZMA1 é um filtro legado, que é suportado quase exclusivamente devido ao +formato de arquivo legado \fB.lzma\fP, que suporta apenas LZMA1. LZMA2 é uma +versão atualizada do LZMA1 para corrigir alguns problemas práticos do +LZMA1. O formato \fB.xz\fP usa LZMA2 e não suporta LZMA1. A velocidade de +compactação e as proporções de LZMA1 e LZMA2 são praticamente as mesmas. +.IP "" +LZMA1 e LZMA2 compartilham o mesmo conjunto de \fIopções\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIpredefinição\fP +Redefine todas as \fIopções\fP de LZMA1 ou LZMA2 para +\fIpredefinição\fP. \fIPredefinição\fP consiste em um número inteiro, que pode ser +seguido por modificadores de predefinição de uma única letra. O inteiro pode +ser de \fB0\fP a \fB9\fP, correspondendo às opções de linha de comando \fB\-0\fP +\&...\& \fB\-9\fP. O único modificador suportado atualmente é \fBe\fP, que +corresponde a \fB\-\-extreme\fP. Se nenhum \fBpreset\fP for especificado, os valores +padrão das \fIopções\fP LZMA1 ou LZMA2 serão obtidos da predefinição \fB6\fP. +.TP +\fBdict=\fP\fItamanho\fP +O \fItamanho\fP do dicionário (buffer de histórico) indica quantos bytes dos +dados não compactados processados recentemente são mantidos na memória. O +algoritmo tenta encontrar sequências de bytes repetidos (correspondências) +nos dados não compactados e substituí\-los por referências aos dados +atualmente no dicionário. Quanto maior o dicionário, maior a chance de +encontrar uma correspondência. Portanto, aumentar o dicionário \fItamanho\fP +geralmente melhora a taxa de compactação, mas um dicionário maior que o +arquivo não compactado é um desperdício de memória. +.IP "" +Um \fItamanho\fP de dicionário típico é de 64\ KiB a 64\ MiB. O mínimo é 4\ KiB. O máximo para compactação é atualmente 1,5\ GiB (1536\ MiB). O +descompactador já oferece suporte a dicionários de até um byte a menos de 4\ GiB, que é o máximo para os formatos de fluxo LZMA1 e LZMA2. +.IP "" +O \fItamanho\fP de dicionário e o localizador de correspondência (\fImf\fP) juntos +determinam o uso de memória do codificador LZMA1 ou LZMA2. O mesmo (ou +maior) \fItamanho\fP de dicionário é necessário para descompactar que foi usado +durante a compactação, portanto, o uso de memória do decodificador é +determinado pelo tamanho do dicionário usado durante a compactação. Os +cabeçalhos \fB.xz\fP armazenam o \fItamanho\fP de dicionário como 2^\fIn\fP ou 2^\fIn\fP ++ 2^(\fIn\fP\-1), então esses \fItamanhos\fP são um tanto preferidos para +compactação. Outros \fItamanhos\fP serão arredondados quando armazenados nos +cabeçalhos \fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Especifica o número de bits de contexto literais. O mínimo é 0 e o máximo é +4; o padrão é 3. Além disso, a soma de \fIlc\fP e \fIlp\fP não deve exceder 4. +.IP "" +Todos os bytes que não podem ser codificados como correspondências são +codificados como literais. Ou seja, literais são simplesmente bytes de 8 +bits que são codificados um de cada vez. +.IP "" +A codificação literal assume que os bits \fIlc\fP mais altos do byte não +compactado anterior se correlacionam com o próximo byte. Por exemplo, em um +texto típico em inglês, uma letra maiúscula geralmente é seguida por uma +letra minúscula, e uma letra minúscula geralmente é seguida por outra letra +minúscula. No conjunto de caracteres US\-ASCII, os três bits mais altos são +010 para letras maiúsculas e 011 para letras minúsculas. Quando \fIlc\fP é pelo +menos 3, a codificação literal pode aproveitar essa propriedade nos dados +não compactados. +.IP "" +O valor padrão (3) geralmente é bom. Se você deseja compactação máxima, +experimente \fBlc=4\fP. Às vezes ajuda um pouco, às vezes piora a +compactação. Se piorar, experimente \fBlc=2\fP também. +.TP +\fBlp=\fP\fIlp\fP +Especifica o número de bits de posição literal. O mínimo é 0 e o máximo é 4; +o padrão é 0. +.IP "" +\fILp\fP afeta que tipo de alinhamento nos dados não compactados é assumido ao +codificar literais. Consulte \fIpb\fP abaixo para obter mais informações sobre +alinhamento. +.TP +\fBpb=\fP\fIpb\fP +Especifica o número de bits de posição. O mínimo é 0 e o máximo é 4; o +padrão é 2. +.IP "" +\fIPb\fP afeta que tipo de alinhamento nos dados não compactados é assumido em +geral. O padrão significa alinhamento de quatro bytes (2^\fIpb\fP=2^2=4), que +geralmente é uma boa escolha quando não há melhor estimativa. +.IP "" +Quando o alinhamento é conhecido, definir \fIpb\fP adequadamente pode reduzir +um pouco o tamanho do arquivo. Por exemplo, com arquivos de texto com +alinhamento de um byte (US\-ASCII, ISO\-8859\-*, UTF\-8), a configuração \fBpb=0\fP +pode melhorar um pouco a compactação. Para texto UTF\-16, \fBpb=1\fP é uma boa +escolha. Se o alinhamento for um número ímpar como 3 bytes, \fBpb=0\fP pode ser +a melhor escolha. +.IP "" +Embora o alinhamento assumido possa ser ajustado com \fIpb\fP e \fIlp\fP, LZMA1 e +LZMA2 ainda favorecem ligeiramente o alinhamento de 16 bytes. Pode valer a +pena levar em consideração ao projetar formatos de arquivo que provavelmente +serão compactados com LZMA1 ou LZMA2. +.TP +\fBmf=\fP\fImf\fP +O localizador de correspondência tem um efeito importante na velocidade do +codificador, uso de memória e taxa de compactação. Normalmente, os +localizadores de correspondência de Hash Chain são mais rápidos do que os +localizadores de correspondência de árvore binária. O padrão depende do +\fIpredefinição\fP: 0 usa \fBhc3\fP, 1\(en3 usa \fBhc4\fP e o resto usa \fBbt4\fP. +.IP "" +Os seguintes localizadores de correspondência são suportados. As fórmulas de +uso de memória abaixo são aproximações aproximadas, que estão mais próximas +da realidade quando \fIdict\fP é uma potência de dois. +.RS +.TP +\fBhc3\fP +Cadeia de hashs com hashing de 2 e 3 bytes +.br +Valor mínimo para \fInice\fP: 3 +.br +Uso de memória: +.br +\fIdict\fP * 7.5 (if \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 5.5 + 64 MiB (if \fIdict\fP > 16 MiB) +.TP +\fBhc4\fP +Cadeia de hashs com hashing de 2, 3 e 4 bytes +.br +Valor mínimo para \fInice\fP: 4 +.br +Uso de memória: +.br +\fIdict\fP * 7.5 (if \fIdict\fP <= 32 MiB); +.br +\fIdict\fP * 6.5 (if \fIdict\fP > 32 MiB) +.TP +\fBbt2\fP +Árvore binária com hashing de 2 bytes +.br +Valor mínimo para \fInice\fP: 2 +.br +Uso de memória: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Árvore binária com hashing de 2 e 3 bytes +.br +Valor mínimo para \fInice\fP: 3 +.br +Uso de memória: +.br +\fIdict\fP * 11.5 (if \fIdict\fP <= 16 MiB); +.br +\fIdict\fP * 9.5 + 64 MiB (if \fIdict\fP > 16 MiB) +.TP +\fBbt4\fP +Árvore binária com hashing de 2, 3 e 4 bytes +.br +Valor mínimo para \fInice\fP: 4 +.br +Uso de memória: +.br +\fIdict\fP * 11.5 (if \fIdict\fP <= 32 MiB); +.br +\fIdict\fP * 10.5 (if \fIdict\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fImodo\fP +O \fImodo\fP de compactação especifica o método para analisar os dados +produzidos pelo localizador de correspondência. Os \fImodos\fP suportados são +\fBfast\fP e \fBnormal\fP. O padrão é \fBfast\fP para \fIpredefinições\fP 0\(en3 e +\fBnormal\fP para \fIpredefinições\fP 4\(en9. +.IP "" +Normalmente, \fBfast\fP é usado com localizadores de correspondência cadeia de +hashs e \fBnormal\fP com localizadores de correspondência de árvore +binária. Isso também é o que os \fIpredefinições\fP fazem. +.TP +\fBnice=\fP\fInice\fP +Especifica o que é considerado um bom comprimento para uma +correspondência. Uma vez que uma correspondência de pelo menos \fInice\fP bytes +é encontrada, o algoritmo para de procurar correspondências possivelmente +melhores. +.IP "" +\fINice\fP pode ser 2\(en273 bytes. Valores mais altos tendem a fornecer melhor +taxa de compactação em detrimento da velocidade. O padrão depende do +\fIpredefinição\fP. +.TP +\fBdepth=\fP\fIprofundidade\fP +Especifica a profundidade máxima de pesquisa no localizador de +correspondências. O padrão é o valor especial de 0, que faz com que o +compressor determine um \fIprofundidade\fP razoável de \fImf\fP e \fInice\fP. +.IP "" +Uma \fIprofundidade\fP razoável para cadeias de hash é 4\(en100 e 16\(en1000 +para árvores binárias. Usar valores muito altos para \fIprofundidade\fP pode +tornar o codificador extremamente lento com alguns arquivos. Evite definir +\fIprofundidade\fP acima de 1000 a menos que você esteja preparado para +interromper a compactação caso ela esteja demorando muito. +.RE +.IP "" +Ao decodificar fluxos brutos (\fB\-\-format=raw\fP), o LZMA2 precisa apenas do +dicionário \fItamanho\fP. LZMA1 também precisa de \fIlc\fP, \fIlp\fP e \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIopções\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIopções\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIopções\fP] +.PD +Adiciona um filtro de ramificação/chamada/salto (BCJ) à cadeia de +filtros. Esses filtros podem ser usados apenas como um filtro não último na +cadeia de filtros. +.IP "" +Um filtro BCJ converte endereços relativos no código de máquina em suas +contrapartes absolutas. Isso não altera o tamanho dos dados, mas aumenta a +redundância, o que pode ajudar o LZMA2 a produzir um arquivo \fB.xz\fP 0\(en15\ % menor. Os filtros BCJ são sempre reversíveis, portanto, usar um filtro BCJ +para o tipo errado de dados não causa nenhuma perda de dados, embora possa +piorar um pouco a taxa de compactação.Os filtros BCJ são muito rápidos e +usam uma quantidade insignificante de memória. +.IP "" +Esses filtros BCJ têm problemas conhecidos relacionados à taxa de +compactação: +.RS +.IP \(bu 3 +Alguns tipos de arquivos contendo código executável (por exemplo, arquivos +de objeto, bibliotecas estáticas e módulos do kernel do Linux) têm os +endereços nas instruções preenchidos com valores de preenchimento. Esses +filtros BCJ ainda vão fazer a conversão de endereço, o que vai piorar a +compactação desses arquivos. +.IP \(bu 3 +Se um filtro BCJ for aplicado em um arquivo, é possível que isso torne a +taxa de compactação pior do que não usar um filtro BCJ. Por exemplo, se +houver executáveis semelhantes ou mesmo idênticos, a filtragem provavelmente +tornará os arquivos menos semelhantes e, portanto, a compactação será +pior. O conteúdo de arquivos não executáveis no mesmo arquivo também pode +ser importante. Na prática tem que tentar com e sem filtro BCJ para ver qual +é melhor em cada situação. +.RE +.IP "" +Conjuntos de instruções diferentes têm alinhamento diferente: o arquivo +executável deve ser alinhado a um múltiplo desse valor nos dados de entrada +para fazer o filtro funcionar. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filtro;Alinhamento;Observações +x86;1;x86 32 bits ou 64 bits +ARM;4; +ARM\-Thumb;2; +ARM64;4;Alinhamento de 4096 bytes +;;é melhor +PowerPC;4;Somente big endian +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Since the BCJ\-filtered data is usually compressed with LZMA2, the +compression ratio may be improved slightly if the LZMA2 options are set to +match the alignment of the selected BCJ filter. Examples: +.RS +.IP \(bu 3 +IA\-64 filter has 16\-byte alignment so \fBpb=4,lp=4,lc=0\fP is good with LZMA2 +(2^4=16). +.IP \(bu 3 +RISC\-V code has 2\-byte or 4\-byte alignment depending on whether the file +contains 16\-bit compressed instructions (the C extension). When 16\-bit +instructions are used, \fBpb=2,lp=1,lc=3\fP or \fBpb=1,lp=1,lc=3\fP is good. When +16\-bit instructions aren't present, \fBpb=2,lp=2,lc=2\fP is the best. +\fBreadelf \-h\fP can be used to check if "RVC" appears on the "Flags" line. +.IP \(bu 3 +ARM64 is always 4\-byte aligned so \fBpb=2,lp=2,lc=2\fP is the best. +.IP \(bu 3 +The x86 filter is an exception. It's usually good to stick to LZMA2's +defaults (\fBpb=2,lp=0,lc=3\fP) when compressing x86 executables. +.RE +.IP "" +Todos os filtros BCJ suportam as mesmas \fIopções\fP: +.RS +.TP +\fBstart=\fP\fIdeslocamento\fP +Especifica o \fIdeslocamento\fP inicial que é usado na conversão entre +endereços relativos e absolutos. O \fIdeslocamento\fP deve ser um múltiplo do +alinhamento do filtro (ver tabela acima). O padrão é zero. Na prática, o +padrão é bom; especificar um \fIdeslocamento\fP personalizado quase nunca é +útil. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIopções\fP] +Adiciona o filtro Delta à cadeia de filtros. O filtro Delta só pode ser +usado como filtro não\-último na cadeia de filtros. +.IP "" +Atualmente, apenas o cálculo simples de delta byte a byte é suportado. Pode +ser útil ao compactar, por exemplo, imagens bitmap não compactadas ou áudio +PCM não compactado. No entanto, algoritmos de propósito especial podem +fornecer resultados significativamente melhores do que Delta + LZMA2. Isso é +verdade especialmente com áudio, que compacta mais rápido e melhor, por +exemplo, com \fBflac\fP(1). +.IP "" +\fIOpções\fP suportadas: +.RS +.TP +\fBdist=\fP\fIdistância\fP +Especifica a \fIdistância\fP do cálculo delta em bytes. \fIdistância\fP deve ser +1\(en256. O padrão é 1. +.IP "" +Por exemplo, com \fBdist=2\fP e entrada de oito bytes A1 B1 A2 B3 A3 B5 A4 B7, +a saída será A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Outras opções" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Suprime avisos e avisos. Especifique isso duas vezes para suprimir erros +também. Esta opção não tem efeito no status de saída. Ou seja, mesmo que um +aviso tenha sido suprimido, o status de saída para indicar um aviso ainda é +usado. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Ser detalhado. Se o erro padrão estiver conectado a um terminal, \fBxz\fP +exibirá um indicador de progresso. Especifique \fB\-\-verbose\fP duas vezes dará +uma saída ainda mais detalhada. +.IP "" +O indicador de progresso mostra as seguintes informações: +.RS +.IP \(bu 3 +A porcentagem de conclusão é mostrada se o tamanho do arquivo de entrada for +conhecido. Ou seja, a porcentagem não pode ser mostrada em encadeamentos +(pipe). +.IP \(bu 3 +Quantidade de dados compactados produzidos (compactando) ou consumidos +(descompactando). +.IP \(bu 3 +Quantidade de dados não compactados consumidos (compactação) ou produzidos +(descompactação). +.IP \(bu 3 +Taxa de compactação, que é calculada dividindo a quantidade de dados +compactados processados até o momento pela quantidade de dados não +compactados processados até o momento. +.IP \(bu 3 +Velocidade de compactação ou descompactação. Isso é medido como a quantidade +de dados não compactados consumidos (compactação) ou produzidos +(descompactação) por segundo. É mostrado após alguns segundos desde que +\fBxz\fP começou a processar o arquivo. +.IP \(bu 3 +Tempo decorrido no formato M:SS ou H:MM:SS. +.IP \(bu 3 +O tempo restante estimado é mostrado apenas quando o tamanho do arquivo de +entrada é conhecido e alguns segundos já se passaram desde que \fBxz\fP começou +a processar o arquivo. A hora é mostrada em um formato menos preciso que +nunca tem dois pontos, por exemplo, 2 min 30 s. +.RE +.IP "" +Quando o erro padrão não é um terminal, \fB\-\-verbose\fP fará com que \fBxz\fP +imprima o nome do arquivo, tamanho compactado, tamanho não compactado, taxa +de compactação e possivelmente também a velocidade e o tempo decorrido em +uma única linha para o erro padrão após a compactação ou descompactando o +arquivo. A velocidade e o tempo decorrido são incluídos apenas quando a +operação leva pelo menos alguns segundos. Se a operação não foi concluída, +por exemplo, devido à interrupção do usuário, também é impressa a +porcentagem de conclusão se o tamanho do arquivo de entrada for conhecido. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Não define o status de saída como 2, mesmo que uma condição digna de um +aviso tenha sido detectada. Esta opção não afeta o nível de detalhamento, +portanto, tanto \fB\-\-quiet\fP quanto \fB\-\-no\-warn\fP devem ser usados para não +exibir avisos e não alterar o status de saída. +.TP +\fB\-\-robot\fP +Imprime mensagens em um formato analisável por máquina. Isso visa facilitar +a criação de frontends que desejam usar \fBxz\fP em vez de liblzma, o que pode +ser o caso de vários scripts. A saída com esta opção habilitada deve ser +estável em versões \fBxz\fP. Consulte a seção \fBMODO ROBÔ\fP para obter detalhes. +.TP +\fB\-\-info\-memory\fP +Exibe, em formato legível por humanos, quanta memória física (RAM) e quantos +threads de processador \fBxz\fP acredita que o sistema possui e os limites de +uso de memória para compactação e descompactação e saia com êxito. +.TP +\fB\-h\fP, \fB\-\-help\fP +Exibe uma mensagem de ajuda descrevendo as opções mais usadas e sai com +sucesso. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Exibe uma mensagem de ajuda descrevendo todos os recursos de \fBxz\fP e sai com +sucesso +.TP +\fB\-V\fP, \fB\-\-version\fP +Exibe o número da versão de \fBxz\fP e liblzma em formato legível por +humanos. Para obter uma saída analisável por máquina, especifique \fB\-\-robot\fP +antes de \fB\-\-version\fP. +. +.SH "MODO ROBÔ" +The robot mode is activated with the \fB\-\-robot\fP option. It makes the output +of \fBxz\fP easier to parse by other programs. Currently \fB\-\-robot\fP is +supported only together with \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, +and \fB\-\-version\fP. It will be supported for compression and decompression in +the future. +. +.SS "Modo lista" +\fBxz \-\-robot \-\-list\fP usa saída separada por tabulações. A primeira coluna de +cada linha possui uma string que indica o tipo de informação encontrada +naquela linha: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Esta é sempre a primeira linha ao começar a listar um arquivo. A segunda +coluna na linha é o nome do arquivo. +.TP +\fBfile\fP +Esta linha contém informações gerais sobre o arquivo \fB.xz\fP. Esta linha é +sempre impressa após a linha \fBname\fP. +.TP +\fBstream\fP +Este tipo de linha é usado somente quando \fB\-\-verbose\fP foi +especificado. Existem tantas linhas de \fBstream\fP quanto fluxos no arquivo +\&\fB.xz\fP. +.TP +\fBblock\fP +Este tipo de linha é usado somente quando \fB\-\-verbose\fP foi +especificado. Existem tantas linhas \fBblock\fP quanto blocos no arquivo +\&\fB.xz\fP. As linhas \fBblock\fP são mostradas após todas as linhas \fBstream\fP; +diferentes tipos de linha não são intercalados. +.TP +\fBsummary\fP +Este tipo de linha é usado apenas quando \fB\-\-verbose\fP foi especificado duas +vezes. Esta linha é impressa após todas as linhas de \fBblock\fP. Assim como a +linha \fBarquivo\fP, a linha \fBsummary\fP contém informações gerais sobre o +arquivo \fB.xz\fP. +.TP +\fBtotals\fP +Esta linha é sempre a última linha da saída da lista. Ele mostra as +contagens totais e tamanhos. +.PP +As colunas das linhas \fBfile\fP: +.PD 0 +.RS +.IP 2. 4 +Número de fluxos no arquivo +.IP 3. 4 +Número total de blocos no(s) fluxo(s) +.IP 4. 4 +Tamanho compactado do arquivo +.IP 5. 4 +Uncompressed size of the file +.IP 6. 4 +Taxa de compactação, por exemplo, \fB0.123\fP. Se a proporção for superior a +9.999, serão exibidos três traços (\fB\-\-\-\fP) em vez da proporção. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Lista separada por vírgulas de nomes de verificação de integridade. As +seguintes strings são usadas para os tipos de verificação conhecidos: +\fBNone\fP, \fBCRC32\fP, \fBCRC64\fP e \fBSHA\-256\fP. Para tipos de verificações +desconhecidos, \fBUnknown\-\fP\fIN\fP é usado, onde \fIN\fP é o ID do cheque como um +número decimal (um ou dois dígitos). +.IP 8. 4 +Tamanho total do preenchimento de fluxo no arquivo +.RE +.PD +.PP +As colunas das linhas \fBstream\fP: +.PD 0 +.RS +.IP 2. 4 +Número do fluxo (o primeiro fluxo é 1) +.IP 3. 4 +Número de blocos no fluxo +.IP 4. 4 +Deslocamento inicial compactado +.IP 5. 4 +Deslocamento inicial descompactado +.IP 6. 4 +Tamanho compactado (não inclui preenchimento de fluxo) +.IP 7. 4 +Tamanho descompactado +.IP 8. 4 +Taxa de compactação +.IP 9. 4 +Nome da verificação de integridade +.IP 10. 4 +Tamanho do preenchimento do fluxo +.RE +.PD +.PP +As colunas das linhas \fBblock\fP: +.PD 0 +.RS +.IP 2. 4 +Número do fluxo que contém este bloco +.IP 3. 4 +Número do bloco relativo ao início do fluxo (o primeiro bloco é 1) +.IP 4. 4 +Número do bloco relativo ao início do arquivo +.IP 5. 4 +Deslocamento inicial compactado em relação ao início do arquivo +.IP 6. 4 +Deslocamento inicial descompactado em relação ao início do arquivo +.IP 7. 4 +Tamanho total compactado do bloco (inclui cabeçalhos) +.IP 8. 4 +Tamanho descompactado +.IP 9. 4 +Taxa de compactação +.IP 10. 4 +Nome da verificação de integridade +.RE +.PD +.PP +Se \fB\-\-verbose\fP for especificado duas vezes, colunas adicionais serão +incluídas nas linhas \fBblock\fP. Eles não são exibidos com um único +\fB\-\-verbose\fP, porque obter essas informações requer muitas buscas e, +portanto, pode ser lento: +.PD 0 +.RS +.IP 11. 4 +Valor da verificação de integridade em hexadecimal +.IP 12. 4 +Tamanho do cabeçalho do bloco +.IP 13. 4 +Sinalizadores de bloco: \fBc\fP indica que o tamanho compactado está presente e +\fBu\fP indica que o tamanho não compactado está presente. Se o sinalizador não +estiver definido, um traço (\fB\-\fP) será exibido para manter o comprimento da +string fixo. Novos sinalizadores podem ser adicionados ao final da string no +futuro. +.IP 14. 4 +Tamanho dos dados reais compactados no bloco (isso exclui o cabeçalho do +bloco, o preenchimento do bloco e os campos de verificação) +.IP 15. 4 +Quantidade de memória (em bytes) necessária para descompactar este bloco com +esta versão \fBxz\fP +.IP 16. 4 +Cadeia de filtro. Observe que a maioria das opções usadas no momento da +compactação não pode ser conhecida, pois apenas as opções necessárias para a +descompactação são armazenadas nos cabeçalhos \fB.xz\fP. +.RE +.PD +.PP +As colunas das linhas \fBsummary\fP: +.PD 0 +.RS +.IP 2. 4 +Quantidade de memória (em bytes) necessária para descompactar este arquivo +com esta versão do \fBxz\fP +.IP 3. 4 +\fByes\fP ou \fBno\fP indicando se todos os cabeçalhos de bloco têm tamanho +compactado e tamanho não compactado armazenados neles +.PP +\fIDesde\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Versão mínima do \fBxz\fP necessária para descompactar o arquivo +.RE +.PD +.PP +As colunas da linha \fBtotals\fP: +.PD 0 +.RS +.IP 2. 4 +Número de fluxos +.IP 3. 4 +Número de blocos +.IP 4. 4 +Tamanho compactado +.IP 5. 4 +Tamanho descompactado +.IP 6. 4 +Taxa de compactação média +.IP 7. 4 +Lista separada por vírgulas de nomes de verificação de integridade que +estavam presentes nos arquivos +.IP 8. 4 +Tamanho do preenchimento do fluxo +.IP 9. 4 +Número de arquivos. Isso está aqui para manter a ordem das colunas +anteriores a mesma das linhas \fBfile\fP. +.PD +.RE +.PP +Se \fB\-\-verbose\fP for especificado duas vezes, colunas adicionais serão +incluídas na linha \fBtotals\fP: +.PD 0 +.RS +.IP 10. 4 +Quantidade máxima de memória (em bytes) necessária para descompactar os +arquivos com esta versão do \fBxz\fP +.IP 11. 4 +\fByes\fP ou \fBno\fP indicando se todos os cabeçalhos de bloco têm tamanho +compactado e tamanho não compactado armazenados neles +.PP +\fIDesde\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Versão mínima do \fBxz\fP necessária para descompactar o arquivo +.RE +.PD +.PP +Versões futuras podem adicionar novos tipos de linha e novas colunas podem +ser adicionadas aos tipos de linha existentes, mas as colunas existentes não +serão alteradas. +. +.SS "Filters help" +\fBxz \-\-robot \-\-filters\-help\fP prints the supported filters in the following +format: +.PP +\fIfilter\fP\fB:\fP\fIoption\fP\fB=<\fP\fIvalue\fP\fB>,\fP\fIoption\fP\fB=<\fP\fIvalue\fP\fB>\fP... +.TP +\fIfilter\fP +Name of the filter +.TP +\fIoption\fP +Name of a filter specific option +.TP +\fIvalue\fP +Numeric \fIvalue\fP ranges appear as \fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. String +\fIvalue\fP choices are shown within \fB< >\fP and separated by a \fB|\fP +character. +.PP +Each filter is printed on its own line. +. +.SS "Informações de limite de memória" +\fBxz \-\-robot \-\-info\-memory\fP prints a single line with multiple tab\-separated +columns: +.IP 1. 4 +Quantidade total de memória física (RAM) em bytes. +.IP 2. 4 +Limite de uso de memória para compactação em bytes +(\fB\-\-memlimit\-compress\fP). Um valor especial de \fB0\fP indica a configuração +padrão que para o modo de thread única é o mesmo que sem limite. +.IP 3. 4 +Limite de uso de memória para descompactação em bytes +(\fB\-\-memlimit\-decompress\fP). Um valor especial de \fB0\fP indica a configuração +padrão que para o modo de thread única é o mesmo que sem limite. +.IP 4. 4 +Desde \fBxz\fP 5.3.4alpha: Uso de memória para descompactação com várias thread +em bytes (\fB\-\-memlimit\-mt\-decompress\fP). Isso nunca é zero porque um valor +padrão específico do sistema mostrado na coluna 5 é usado se nenhum limite +for especificado explicitamente. Isso também nunca é maior que o valor na +coluna 3, mesmo que um valor maior tenha sido especificado com +\fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Desde \fBxz\fP 5.3.4alpha: Um limite de uso de memória padrão específico do +sistema que é usado para limitar o número de threads ao compactar com um +número automático de threads (\fB\-\-threads=0\fP) e nenhum limite de uso de +memória foi especificado (\fB\-\-memlimit\-compress\fP). Isso também é usado como +o valor padrão para \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Desde \fBxz\fP 5.3.4alpha: Número de threads de processador disponíveis. +.PP +No futuro, a saída de \fBxz \-\-robot \-\-info\-memory\fP pode ter mais colunas, mas +nunca mais do que uma única linha. +. +.SS Versão +\fBxz \-\-robot \-\-version\fP prints the version number of \fBxz\fP and liblzma in +the following format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Versão principal. +.TP +\fIYYY\fP +Versão menor. Números pares são estáveis. Os números ímpares são versões +alfa ou beta. +.TP +\fIZZZ\fP +Nível de patch para versões estáveis ou apenas um contador para versões de +desenvolvimento. +.TP +\fIS\fP +Estabilidade. 0 é alfa, 1 é beta e 2 é estável. \fIS\fP deve ser sempre 2 +quando \fIYYY\fP for par. +.PP +\fIXYYYZZZS\fP são iguais em ambas as linhas se \fBxz\fP e liblzma forem da mesma +versão do XZ Utils. +.PP +Exemplos: 4.999.9beta é \fB49990091\fP e 5.0.0 é \fB50000002\fP. +. +.SH "STATUS DE SAÍDA" +.TP +\fB0\fP +Está tudo bem. +.TP +\fB1\fP +Ocorreu um erro. +.TP +\fB2\fP +Algo digno de um aviso ocorreu, mas ocorreu nenhum erro real. +.PP +Observações (não avisos ou erros) impressas no erro padrão não afetam o +status de saída. +. +.SH AMBIENTE +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP analisa listas de opções separadas por espaços das variáveis de +ambiente \fBXZ_DEFAULTS\fP e \fBXZ_OPT\fP, nesta ordem, antes de analisar as +opções da linha de comando. Observe que apenas as opções são analisadas a +partir das variáveis de ambiente; todas as não opções são silenciosamente +ignoradas. A análise é feita com \fBgetopt_long\fP(3) que também é usado para +os argumentos da linha de comando. +.PP +\fBWarning:\fP By setting these environment variables, one is effectively +modifying programs and scripts that run \fBxz\fP. Most of the time it is safe +to set memory usage limits, number of threads, and compression options via +the environment variables. However, some options can break scripts. An +obvious example is \fB\-\-help\fP which makes \fBxz\fP show the help text instead of +compressing or decompressing a file. More subtle examples are \fB\-\-quiet\fP +and \fB\-\-verbose\fP. In many cases it works well to enable the progress +indicator using \fB\-\-verbose\fP, but in some situations the extra messages +create problems. The verbosity level also affects the behavior of +\fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +User\-specific or system\-wide default options. Typically this is set in a +shell initialization script to enable \fBxz\fP's memory usage limiter by +default or set the default number of threads. Excluding shell +initialization scripts and similar special cases, scripts should never set +or unset \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Isso é para passar opções para \fBxz\fP quando não é possível definir as opções +diretamente na linha de comando \fBxz\fP. Este é o caso quando \fBxz\fP é +executado por um script ou ferramenta, por exemplo, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Os scripts podem usar \fBXZ_OPT\fP, por exemplo, para definir opções de +compactação padrão específicas do script. Ainda é recomendável permitir que +os usuários substituam \fBXZ_OPT\fP se isso for razoável. Por exemplo, em +scripts \fBsh\fP(1) pode\-se usar algo assim: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "COMPATIBILIDADE COM LZMA UTILS" +A sintaxe da linha de comando do \fBxz\fP é praticamente um superconjunto de +\fBlzma\fP, \fBunlzma\fP e \fBlzcat\fP conforme encontrado no LZMA Utils 4.32.x. Na +maioria dos casos, é possível substituir LZMA Utils por XZ Utils sem +interromper os scripts existentes. Existem algumas incompatibilidades, +porém, que às vezes podem causar problemas. +. +.SS "Níveis de predefinição de compactação" +A numeração das predefinições de nível de compactação não é idêntica em +\fBxz\fP e LZMA Utils. A diferença mais importante é como os tamanhos dos +dicionários são mapeados para diferentes predefinições. O tamanho do +dicionário é aproximadamente igual ao uso de memória do descompactador. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nível;xz;LZMA Utils +\-0;256 KiB;N/D +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +As diferenças de tamanho do dicionário também afetam o uso da memória do +compressor, mas existem algumas outras diferenças entre LZMA Utils e XZ +Utils, que tornam a diferença ainda maior: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nível;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/D +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +O nível de predefinição padrão no LZMA Utils é \fB\-7\fP enquanto no XZ Utils é +\fB\-6\fP, então ambos usam um dicionário de 8 MiB por padrão. +. +.SS "Arquivos .lzma em um fluxo versus sem ser em um fluxo" +O tamanho descompactado do arquivo pode ser armazenado no cabeçalho de +\&\fB.lzma\fP. O LZMA Utils faz isso ao compactar arquivos comuns. A alternativa +é marcar que o tamanho não compactado é desconhecido e usar o marcador de +fim de carga útil para indicar onde o descompactador deve parar. O LZMA +Utils usa este método quando o tamanho não compactado não é conhecido, como +é o caso, por exemplo, de encadeamentos (pipes). +.PP +\fBxz\fP oferece suporte à descompactação de arquivos \fB.lzma\fP com ou sem +marcador de fim de carga útil, mas todos os arquivos \fB.lzma\fP criados por +\fBxz\fP usarão marcador de fim de carga útil e terão o tamanho descompactado +marcado como desconhecido no cabeçalho de \fB.lzma\fP. Isso pode ser um +problema em algumas situações incomuns. Por exemplo, um descompactador de +\&\fB.lzma\fP em um dispositivo embarcado pode funcionar apenas com arquivos que +tenham tamanho descompactado conhecido. Se você encontrar esse problema, +precisará usar o LZMA Utils ou o LZMA SDK para criar arquivos \fB.lzma\fP com +tamanho descompactado conhecido. +. +.SS "Arquivos .lzma não suportados" +O formato \fB.lzma\fP permite valores \fIlc\fP até 8 e valores \fIlp\fP até 4. LZMA +Utils pode descompactar arquivos com qualquer \fIlc\fP e \fIlp\fP, mas sempre cria +arquivos com \fBlc=3\fP e \fBlp=0\fP. Criar arquivos com outros \fIlc\fP e \fIlp\fP é +possível com \fBxz\fP e com LZMA SDK. +.PP +A implementação do filtro LZMA1 em liblzma requer que a soma de \fIlc\fP e +\fIlp\fP não exceda 4. Assim, arquivos \fB.lzma\fP, que excedam esta limitação, +não podem ser descompactados com \fBxz\fP. +.PP +LZMA Utils cria apenas arquivos \fB.lzma\fP que possuem um tamanho de +dicionário de 2^\fIn\fP (uma potência de 2), mas aceita arquivos com qualquer +tamanho de dicionário. liblzma aceita apenas arquivos \fB.lzma\fP que tenham um +tamanho de dicionário de 2^\fIn\fP ou 2^\fIn\fP + 2^(\fIn\fP\-1). Isso é para diminuir +os falsos positivos ao detectar arquivos \fB.lzma\fP. +.PP +Essas limitações não devem ser um problema na prática, já que praticamente +todos os arquivos \fB.lzma\fP foram compactados com configurações que o liblzma +aceitará. +. +.SS "Lixo à direita" +Ao descompactar, o LZMA Utils silenciosamente ignora tudo após o primeiro +fluxo \fB.lzma\fP. Na maioria das situações, isso é um bug. Isso também +significa que o LZMA Utils não oferece suporte a descompactação de arquivos +\&\fB.lzma\fP concatenados. +.PP +Se houver dados restantes após o primeiro fluxo de \fB.lzma\fP, \fBxz\fP considera +o arquivo corrompido, a menos que \fB\-\-single\-stream\fP tenha sido usado. Isso +pode quebrar scripts obscuros que presumiram que o lixo à direita é +ignorado. +. +.SH NOTAS +. +.SS "A saída compactada pode variar" +A saída compactada exata produzida a partir do mesmo arquivo de entrada não +compactado pode variar entre as versões do XZ Utils, mesmo se as opções de +compactação forem idênticas. Isso ocorre porque o codificador pode ser +aprimorado (compactação mais rápida ou melhor) sem afetar o formato do +arquivo. A saída pode variar mesmo entre diferentes compilações da mesma +versão do XZ Utils, se diferentes opções de compilação forem usadas. +.PP +A informação acima significa que, uma vez que \fB\-\-rsyncable\fP tenha sido +implementado, os arquivos resultantes não serão necessariamente +"rsyncáveis", a menos que os arquivos antigos e novos tenham sido +compactados com a mesma versão xz. Esse problema pode ser corrigido se uma +parte da implementação do codificador for congelada para manter a saída de +rsyncable estável nas versões do xz. +. +.SS "Descompactadores .xz embarcados" +As implementações do descompactador \fB.xz\fP embarcados, como o XZ Embedded, +não oferecem necessariamente suporte a arquivos criados com tipos de +\fIverificações\fP de integridade diferentes de \fBnone\fP e \fBcrc32\fP. Como o +padrão é \fB\-\-check=crc64\fP, você deve usar \fB\-\-check=none\fP ou +\fB\-\-check=crc32\fP ao criar arquivos para sistemas embarcados. +.PP +Fora dos sistemas embarcados, todos os descompactadores de formato \fB.xz\fP +oferecem suporte a todos os tipos de \fIverificação\fP ou, pelo menos, são +capazes de descompactar o arquivo sem verificar a verificação de integridade +se a \fIverificação\fP específica não for suportada. +.PP +XZ Embedded oferece suporte a filtros BCJ, mas apenas com o deslocamento +inicial padrão. +. +.SH EXEMPLOS +. +.SS Básico +Compactar o arquivo \fIfoo\fP em \fIfoo.xz\fP usando o nível de compactação padrão +(\fB\-6\fP) e remover \fIfoo\fP se a compactação for bem\-sucedida: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Descompactar \fIbar.xz\fP em \fIbar\fP e não remover \fIbar.xz\fP mesmo se a +descompactação for bem\-sucedida: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Criar \fIbaz.tar.xz\fP com a predefinição \fB\-4e\fP (\fB\-4 \-\-extreme\fP), que é mais +lenta que o padrão \fB\-6\fP, mas precisa de menos memória para compactação e +descompactação (48 \ MiB e 5\ MiB, respectivamente): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Uma mistura de arquivos compactados e descompactados pode ser descompactada +para a saída padrão com um único comando: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Compactação paralela de muitos arquivos" +No GNU e *BSD, \fBfind\fP(1) e \fBxargs\fP(1) podem ser usados para paralelizar a +compactação de muitos arquivos: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +A opção \fB\-P\fP para \fBxargs\fP(1) define o número de processos paralelos do +\fBxz\fP. O melhor valor para a opção \fB\-n\fP depende de quantos arquivos devem +ser compactados. Se houver apenas alguns arquivos, o valor provavelmente +deve ser 1; com dezenas de milhares de arquivos, 100 ou até mais podem ser +apropriados para reduzir o número de processos de \fBxz\fP que \fBxargs\fP(1) +eventualmente criará. +.PP +A opção \fB\-T1\fP para \fBxz\fP existe para forçá\-lo ao modo de thread única, +porque \fBxargs\fP(1) é usado para controlar a quantidade de paralelização. +. +.SS "Modo robô" +Calcular quantos bytes foram salvos no total depois de compactar vários +arquivos: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Um script pode querer saber que está usando \fBxz\fP novo o suficiente. O +seguinte script \fBsh\fP(1) verifica se o número da versão da ferramenta \fBxz\fP +é pelo menos 5.0.0. Este método é compatível com versões beta antigas, que +não suportavam a opção \fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Definir um limite de uso de memória para descompactação usando \fBXZ_OPT\fP, +mas se um limite já tiver sido definido, não o aumentar: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Cadeias de filtro de compressor personalizadas" +O uso mais simples para cadeias de filtro personalizadas é personalizar uma +predefinição LZMA2. Isso pode ser útil, porque as predefinições abrangem +apenas um subconjunto das combinações potencialmente úteis de configurações +de compactação. +.PP +As colunas CompCPU das tabelas das descrições das opções \fB\-0\fP ... \fB\-9\fP e +\fB\-\-extreme\fP são úteis ao personalizar as predefinições LZMA2. Aqui estão as +partes relevantes coletadas dessas duas tabelas: +.RS +.PP +.TS +tab(;); +c c +n n. +Predefinição;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Se você sabe que um arquivo requer um dicionário um tanto grande (por +exemplo, 32\ MiB) para compactar bem, mas deseja comprimi\-lo mais +rapidamente do que \fBxz \-8\fP faria, uma predefinição com um valor CompCPU +baixo (por exemplo, 1) pode ser modificado para usar um dicionário maior: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Com certos arquivos, o comando acima pode ser mais rápido que \fBxz \-6\fP +enquanto compacta significativamente melhor. No entanto, deve\-se enfatizar +que apenas alguns arquivos se beneficiam de um grande dicionário, mantendo o +valor CompCPU baixo. A situação mais óbvia, onde um grande dicionário pode +ajudar muito, é um arquivo contendo arquivos muito semelhantes de pelo menos +alguns megabytes cada. O tamanho do dicionário deve ser significativamente +maior do que qualquer arquivo individual para permitir que o LZMA2 aproveite +ao máximo as semelhanças entre arquivos consecutivos. +.PP +Se o uso muito alto de memória do compactador e do descompactador for bom e +o arquivo que está sendo compactado tiver pelo menos várias centenas de +megabytes, pode ser útil usar um dicionário ainda maior do que os 64 MiB que +o \fBxz \-9\fP usaria: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Usar \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) como no exemplo acima pode ser útil +para ver os requisitos de memória do compactador e do +descompactador. Lembre\-se que usar um dicionário maior que o tamanho do +arquivo descompactado é desperdício de memória, então o comando acima não é +útil para arquivos pequenos. +.PP +Às vezes, o tempo de compactação não importa, mas o uso de memória do +descompactador deve ser mantido baixo, por exemplo, para possibilitar a +descompactação do arquivo em um sistema embarcado. O comando a seguir usa +\fB\-6e\fP (\fB\-6 \-\-extreme\fP) como base e define o dicionário como apenas 64\ KiB. O arquivo resultante pode ser descompactado com XZ Embedded (é por isso +que existe \fB\-\-check=crc32\fP) usando cerca de 100\ KiB de memória. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Se você deseja espremer o máximo de bytes possível, ajustar o número de bits +de contexto literal (\fIlc\fP) e o número de bits de posição (\fIpb\fP) às vezes +pode ajudar. Ajustar o número de bits de posição literal (\fIlp\fP) também pode +ajudar, mas geralmente \fIlc\fP e \fIpb\fP são mais importantes. Por exemplo, um +arquivo de código\-fonte contém principalmente texto US\-ASCII, então algo +como o seguinte pode fornecer um arquivo ligeiramente (como 0,1\ %) menor +que \fBxz \-6e\fP (tente também sem \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +O uso de outro filtro junto com o LZMA2 pode melhorar a compactação com +determinados tipos de arquivo. Por exemplo, para compactar uma biblioteca +compartilhada x86\-32 ou x86\-64 usando o filtro x86 BCJ: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Observe que a ordem das opções de filtro é significativa. Se \fB\-\-x86\fP for +especificado após \fB\-\-lzma2\fP, \fBxz\fP dará um erro, porque não pode haver +nenhum filtro após LZMA2 e também porque o filtro x86 BCJ não pode ser usado +como o último filtro em a corrente. +.PP +O filtro Delta junto com LZMA2 pode dar bons resultados com imagens +bitmap. Ele geralmente deve superar o PNG, que possui alguns filtros mais +avançados do que o delta simples, mas usa Deflate para a compactação real. +.PP +A imagem deve ser salva em formato não compactado, por exemplo, como TIFF +não compactado. O parâmetro de distância do filtro Delta é definido para +corresponder ao número de bytes por pixel na imagem. Por exemplo, bitmap RGB +de 24 bits precisa de \fBdist=3\fP, e também é bom passar \fBpb=0\fP para LZMA2 +para acomodar o alinhamento de três bytes: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Se várias imagens foram colocadas em um único arquivo (por exemplo, +\&\fB.tar\fP), o filtro Delta também funcionará, desde que todas as imagens +tenham o mesmo número de bytes por pixel. +. +.SH "VEJA TAMBÉM" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/xzdec.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/xzdec.1 new file mode 100644 index 0000000000000000000000000000000000000000..996139d902e42586500e065920dcaa01e8630344 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/xzdec.1 @@ -0,0 +1,87 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.\" Brazilian Portuguese translations for xz package +.\" Traduções em português brasileiro para o pacote xz. +.\" Rafael Fontenelle , 2022-2023. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDEC 1 2024\-04\-08 Tukaani "XZ Utils" +.SH NOME +xzdec, lzmadec \- Pequenos descompactadores .xz e .lzma +.SH SINOPSE +\fBxzdec\fP [\fIopção...\fP] [\fIarquivo...\fP] +.br +\fBlzmadec\fP [\fIopção...\fP] [\fIarquivo...\fP] +.SH DESCRIÇÃO +\fBxzdec\fP é uma ferramenta de descompactação baseada em liblzma somente para +arquivos \fB.xz\fP (e somente \fB.xz\fP). \fBxzdec\fP destina\-se a funcionar como um +substituto para \fBxz\fP(1) nas situações mais comuns em que um script foi +escrito para usar \fBxz \-\-decompress \-\-stdout\fP (e possivelmente alguns outras +opções comumente usadas) para descompactar arquivos \fB.xz\fP. \fBlzmadec\fP é +idêntico a \fBxzdec\fP exceto que \fBlzmadec\fP tem suporte a arquivos \fB.lzma\fP em +vez de arquivos \fB.xz\fP. +.PP +Para reduzir o tamanho do executável, \fBxzdec\fP não tem suporte ao uso de +várias threads ou a localização, e não lê opções de variáveis de ambiente +\fBXZ_DEFAULTS\fP e \fBXZ_OPT\fP. \fBxzdec\fP não tem suporte à exibição de +informações de progresso intermediárias: enviar \fBSIGINFO\fP para \fBxzdec\fP não +faz nada, mas enviar \fBSIGUSR1\fP encerra o processo em vez de exibir +informações de progresso. +.SH OPÇÕES +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +Ignorada para compatibilidade \fBxz\fP(1). \fBxzdec\fP tem suporte a apenas +descompactação. +.TP +\fB\-k\fP, \fB\-\-keep\fP +Ignorada para compatibilidade \fBxz\fP(1). \fBxzdec\fP nunca cria ou remove +quaisquer arquivos. +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Ignorada para compatibilidade \fBxz\fP(1). \fBxzdec\fP sempre grava os dados +descompactados para a saída padrão. +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Especificar isso uma vez não faz nada, pois \fBxzdec\fP nunca exibe nenhum +aviso ou notificação. Especifique isso duas vezes para suprimir erros. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Ignorada para compatibilidade \fBxz\fP(1). \fBxzdec\fP nunca usa o status de saída +2. +.TP +\fB\-h\fP, \fB\-\-help\fP +Exibe uma mensagem de ajuda e sai com sucesso. +.TP +\fB\-V\fP, \fB\-\-version\fP +Mostra o número da versão do \fBxzdec\fP e liblzma. +.SH "STATUS DE SAÍDA" +.TP +\fB0\fP +Correu tudo bem. +.TP +\fB1\fP +Ocorreu um erro. +.PP +\fBxzdec\fP não possui nenhuma mensagem de aviso como o \fBxz\fP(1), portanto, o +status de saída 2 não é usado por \fBxzdec\fP. +.SH NOTAS +Use \fBxz\fP(1) em vez de \fBxzdec\fP ou \fBlzmadec\fP para uso diário +normal. \fBxzdec\fP ou \fBlzmadec\fP destinam\-se apenas a situações em que é +importante ter um descompactador menor do que o \fBxz\fP(1) completo. +.PP +\fBxzdec\fP e \fBlzmadec\fP não são realmente tão pequenos. O tamanho pode ser +reduzido ainda mais eliminando recursos do liblzma no tempo de compilação, +mas isso geralmente não deve ser feito para executáveis distribuídos em +distribuições típicas de sistemas operacionais não embarcados. Se você +precisa de um descompactador \fB.xz\fP realmente pequeno, considere usar o XZ +Embedded. +.SH "VEJA TAMBÉM" +\fBxz\fP(1) +.PP +XZ Embedded: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/xzless.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/xzless.1 new file mode 100644 index 0000000000000000000000000000000000000000..a39dabb94a2bcc67dfe99963c489e76222de6af8 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/pt_BR/man1/xzless.1 @@ -0,0 +1,48 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" Brazilian Portuguese translations for xz package +.\" Traduções em português brasileiro para o pacote xz. +.\" Rafael Fontenelle , 2022-2023. +.\" +.\" (Note that this file is not based on gzip's zless.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZLESS 1 2025\-03\-06 Tukaani "XZ Utils" +.SH NOME +xzless, lzless \- visualiza arquivos (texto) compactados em xz ou lzma +.SH SINOPSE +\fBxzless\fP [\fIarquivo\fP...] +.br +\fBlzless\fP [\fIfile\fP...] (DEPRECATED) +.SH DESCRIÇÃO +\fBxzless\fP is a filter that displays text from compressed files to a +terminal. Files supported by \fBxz\fP(1) are decompressed; other files are +assumed to be in uncompressed form already. If no \fIfiles\fP are given, +\fBxzless\fP reads from standard input. +.PP +\fBxzless\fP usa \fBless\fP(1) para apresentar sua saída. Ao contrário de +\fBxzmore\fP, sua escolha de pager não pode ser alterada pela configuração de +uma variável de ambiente. Os comandos são baseados em \fBmore\fP(1) e \fBvi\fP(1) +e permitem movimento e busca para frente e para trás. Consulte o manual +\fBless\fP(1) para obter mais informações. +.PP +The command named \fBlzless\fP is provided for backward compatibility with LZMA +Utils. It is deprecated and will be removed in a future version. +.SH AMBIENTE +.TP +\fBLESSMETACHARS\fP +Uma lista de caracteres especiais para o shell. Definido por \fBxzless\fP a +menos que já esteja definido no ambiente. +.TP +\fBLESSOPEN\fP +Defina como uma linha de comando para invocar o descompactador \fBxz\fP(1) para +pré\-processar os arquivos de entrada para \fBless\fP(1). +.SH "VEJA TAMBÉM" +\fBless\fP(1), \fBxz\fP(1), \fBxzmore\fP(1), \fBzless\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzcat.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzcat.1 new file mode 100644 index 0000000000000000000000000000000000000000..1555445592944b4f24e548fc0dc0b1c3af876030 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzcat.1 @@ -0,0 +1,2111 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Romanian translation for xz-man. +.\" Mesajele în limba română pentru manualul pachetului XZ Utils. +.\" Remus-Gabriel Chelu , 2022 - 2025. +.\" Cronologia traducerii fișierului „xz-man”: +.\" Traducerea inițială, făcută de R-GC, pentru versiunea xz-man 5.4.0-pre1. +.\" Actualizare a traducerii pentru versiunea 5.4.0-pre2, făcută de R-GC, dec-2022. +.\" Actualizare a traducerii pentru versiunea 5.4.3, făcută de R-GC, mai-2023. +.\" Actualizare a traducerii pentru versiunea 5.4.4-pre1, făcută de R-GC, iul-2023. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre1, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre2, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.7.1-dev1, făcută de R-GC, ian-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.0-pre1, făcută de R-GC, mar-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.2-pre1, făcută de R-GC, oct-2025. +.\" Actualizare a traducerii pentru versiunea Y, făcută de X, Z(luna-anul). +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 "8 martie 2025" Tukaani "Utilități XZ" +. +.SH NUME +xz, unxz, xzcat, lzma, unlzma, lzcat \- Comprimă sau decomprimă fișiere .xz +și .lzma +. +.SH REZUMAT +\fBxz\fP [\fIopțiune...\fP] [\fIfișier...\fP] +. +.SH "ALIAS COMENZI" +\fBunxz\fP este echivalent cu \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP este echivalent cu \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP este echivalent cu \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP este echivalent cu \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP este echivalent cu \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Când scrieți scripturi care trebuie să decomprime fișiere, este recomandat +să folosiți întotdeauna comanda \fBxz\fP cu argumentele adecvate (\fBxz \-d\fP sau +\fBxz \-dc\fP) în loc de comenzile \fBunxz\fP și \fBxzcat\fP. +. +.SH DESCRIERE +\fBxz\fP este un instrument de comprimare a datelor de uz general cu sintaxă de +linie de comandă similară cu \fBgzip\fP(1) și \fBbzip2\fP(1). Formatul de fișier +nativ este formatul \fB.xz\fP, dar formatul vechi \fB.lzma\fP folosit de LZMA +Utils și fluxurile comprimate brute fără anteturi de format container sunt +de asemenea acceptate. În plus, este acceptată decomprimarea formatului +\&\fB.lz\fP folosit de \fBlzip\fP. +.PP +\fBxz\fP comprimă sau decomprimă fiecare \fIfișier\fP în funcție de modul de +operare selectat. Dacă nu sunt date \fIfișiere\fP sau \fIfișier\fP este \fB\-\fP, +\fBxz\fP citește de la intrarea standard și scrie datele procesate la ieșirea +standard. \fBxz\fP va refuza (afișează o eroare și omite \fIfișier\fP) să scrie +date comprimate la ieșirea standard dacă este un terminal. În mod similar, +\fBxz\fP va refuza să citească datele comprimate de la intrarea standard dacă +este un terminal. +.PP +Cu excepția cazului în care este specificată opțiunea \fB\-\-stdout\fP, +\fIfișierele\fP altele decât \fB\-\fP sunt scrise într\-un fișier nou al cărui nume +este derivat din numele \fIfișierului\fP sursă: +.IP \(bu 3 +La comprimare, sufixul formatului de fișier țintă (\fB.xz\fP sau \fB.lzma\fP) este +atașat la numele fișierului sursă pentru a se obține numele fișierului +țintă. +.IP \(bu 3 +La decomprimare, sufixul \fB.xz\fP, \fB.lzma\fP sau \fB.lz\fP este eliminat din +numele fișierului pentru a se obține numele fișierului țintă. \fBxz\fP +recunoaște și sufixele \fB.txz\fP și \fB.tlz\fP și le înlocuiește cu sufixul +\&\fB.tar\fP. +.PP +Dacă fișierul țintă există deja, este afișată o eroare și \fIfișier\fP este +omis. +.PP +Cu excepția cazului în care scrie la ieșirea standard, \fBxz\fP va afișa un +avertisment și va omite \fIfișier\fPul dacă se aplică oricare dintre +următoarele: +.IP \(bu 3 +\fIFișierul\fP nu este un fișier obișnuit. Legăturile simbolice nu sunt urmate +și, prin urmare, nu sunt considerate fișiere obișnuite. +.IP \(bu 3 +\fIFișierul\fP are mai mult de o legătură dură. +.IP \(bu 3 +\fIFișierul\fP are activat bitul «setuid», «setgid» sau cel lipicios(sticky). +.IP \(bu 3 +Modul de operare este stabilit la comprimare și \fIfișier\fP are deja un sufix +al formatului de fișier țintă (\fB.xz\fP sau \fB.txz\fP când se comprimă în +formatul \fB.xz\fP și \fB.lzma\fP sau \fB.tlz\fP când se comprimă în formatul +\&\fB.lzma\fP). +.IP \(bu 3 +Modul de operare este stabilit la decomprimare și \fIfișierul\fP nu are un +sufix al niciunui format de fișier acceptat (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, +\&\fB.tlz\fP, sau \fB.lz\fP). +.PP +După comprimarea sau decomprimarea cu succes a \fIfișierului\fP, \fBxz\fP copiază +proprietarul, grupul, permisiunile, timpul de acces și timpul de modificare +din \fIfișierul\fP sursă în fișierul țintă. Dacă copierea grupului eșuează, +permisiunile sunt modificate astfel încât fișierul țintă să nu devină +accesibil utilizatorilor care nu aveau permisiunea de a accesa \fIfișierul\fP +sursă. \fBxz\fP nu acceptă încă copierea altor metadate, cum ar fi listele de +control al accesului sau atributele extinse. +.PP +Odată ce fișierul țintă a fost închis cu succes, \fIfișierul\fP sursă este +eliminat dacă nu a fost specificată opțiunea \fB\-\-keep\fP. \fIFișierul\fP sursă nu +este niciodată eliminat dacă rezultatul este scris la ieșirea standard sau +dacă apare o eroare. +.PP +Trimiterea unui semnal \fBSIGINFO\fP sau \fBSIGUSR1\fP către procesul \fBxz\fP face +ca acesta să imprime informații despre progres la ieșirea de eroare +standard. Acest lucru are o utilizare limitată, deoarece atunci când ieșirea +de eroare standard este un terminal, folosind opțiunea \fB\-\-verbose\fP va afișa +un indicator de progres de actualizare automată. +. +.SS "Utilizarea memoriei" +Cantitatea de memorie utilizată de \fBxz\fP variază de la câteva sute de +kiloocteți la câțiva gigaocteți, în funcție de opțiunile de +comprimare. Opțiunile utilizate la comprimarea unui fișier determină +cerințele de memorie ale instrumentului de decomprimare. De obicei, +instrumentul de decomprimare are nevoie de 5% până la 20% din cantitatea de +memorie de care a avut nevoie instrumentul de comprimare la crearea +fișierului. De exemplu, decomprimarea unui fișier creat cu \fBxz \-9\fP necesită +în prezent 65Mio de memorie. Totuși, este posibil să aveți fișiere \fB.xz\fP +care necesită câțiva gigaocteți de memorie pentru decomprimare. +.PP +În special utilizatorii de sisteme mai vechi pot considera deranjantă +posibilitatea unei utilizări foarte mari a memoriei. Pentru a preveni +surprizele neplăcute, \fBxz\fP are încorporat un limitator de utilizare a +memoriei, care este dezactivat implicit. În timp ce unele sisteme de operare +oferă modalități de a limita utilizarea memoriei proceselor, bazarea pe +aceasta nu a fost considerată a fi suficient de flexibilă (de exemplu, +utilizarea \fBulimit\fP(1) pentru a limita memoria virtuală tinde să paralizeze +\fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Limitatorul de utilizare a memoriei poate fi activat cu opțiunea din linia +de comandă \fB\-\-memlimit=\fP\fIlimita\fP. Adesea este mai convenabil să activați +limitatorul în mod implicit prin definirea variabilei de mediu +\fBXZ_DEFAULTS\fP, de exemplu, \fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Este posibil +să stabiliți limitele separat pentru comprimare și decomprimare folosind +\fB\-\-memlimit\-compress=\fP\fIlimita\fP și +\fB\-\-memlimit\-decompress=\fP\fIlimita\fP. Utilizarea acestor două opțiuni în afara +\fBXZ_DEFAULTS\fP este foarte rar utilă, deoarece o singură rulare a \fBxz\fP nu +poate face atât comprimarea, cât și decomprimarea și \fB\-\-memlimit=\fP\fIlimita\fP +(sau \fB\-M\fP \fIlimita\fP ) este mai scurt de tastat pe linia de comandă. +.PP +Dacă limita de utilizare a memoriei specificată este depășită la +decomprimare, \fBxz\fP va afișa o eroare și decomprimarea fișierului va +eșua. Dacă limita este depășită la comprimare, \fBxz\fP va încerca să reducă +valorile stabilite astfel încât limita să nu mai fie depășită (cu excepția +cazului în care se utilizează opțiunea \fB\-\-format=raw\fP sau +\fB\-\-no\-adjust\fP). În acest fel, operațiunea nu va eșua decât dacă limita +stabilită este foarte mică. Scalarea valorilor stabilite se face în pași +care nu se potrivesc cu valorile prestabilite ale nivelului de comprimare, +de exemplu, dacă limita este doar puțin mai mică decât cantitatea necesară +pentru \fBxz \-9\fP, valorile stabilite vor fi reduse doar puțin , nu până la +valoarea prestabilită a lui \fBxz \-8\fP. +. +.SS "Concatenare și completare (prin umplere cu octeți nuli) cu fișiere .xz" +Este posibil să concatenați fișierele \fB.xz\fP așa cum sunt. \fBxz\fP va +decomprima astfel de fișiere ca și cum ar fi un singur fișier \fB.xz\fP. +.PP +Este posibil să se introducă umplutură între părțile concatenate sau după +ultima parte. Umplutura trebuie să fie compusă din octeți nuli, iar +dimensiunea umpluturii trebuie să fie un multiplu de patru octeți. Acest +lucru poate fi util, de exemplu, dacă fișierul \fB.xz\fP este stocat pe un +mediu care măsoară dimensiunile fișierelor în blocuri de 512 de octeți. +.PP +Concatenarea și completarea nu sunt permise cu fișierele \fB.lzma\fP sau +fluxurile brute. +. +.SH OPȚIUNI +. +.SS "Sufixe de numere întregi și valori speciale" +În majoritatea locurilor în care este de așteptat un număr întreg ca +argument, un sufix opțional este acceptat pentru a indica cu ușurință +numerele întregi mari. Nu trebuie să existe spațiu între numărul întreg și +sufix. +.TP +\fBKiB\fP +Înmulțește numărul întreg cu 1.024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP și +\fBKB\fP sunt acceptate ca sinonime pentru \fBKiB\fP. +.TP +\fBMiB\fP +Înmulțește numărul întreg cu 1,048,576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP, și \fBMB\fP +sunt acceptate ca sinonime pentru \fBMiB\fP. +.TP +\fBGiB\fP +Înmulțește numărul întreg cu 1,073,741,824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP, și +\fBGB\fP sunt acceptate ca sinonime pentru \fBGiB\fP. +.PP +Valoarea specială \fBmax\fP poate fi utilizată pentru a indica valoarea maximă +întreagă suportată de opțiune. +. +.SS "Mod de operare" +Dacă sunt date mai multe opțiuni de mod de funcționare, ultima dintre ele, +este cea care va avea efect. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Comprimare. Acesta este modul de operare implicit atunci când nu este +specificată nicio opțiune de mod de funcționare și nici un alt mod de +operare nu este implicat din numele comenzii (de exemplu, \fBunxz\fP implică +\fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +După o comprimare reușită, fișierul sursă este eliminat, cu excepția cazului +în care a fost specificată scrierea la ieșirea standard sau opțiunea +\fB\-\-keep\fP. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Decomprimare. După o decomprimare reușită, fișierul sursă este eliminat, cu +excepția cazului în care a fost specificată scrierea la ieșirea standard sau +opțiunea \fB\-\-keep\fP. +.TP +\fB\-t\fP, \fB\-\-test\fP +Testează integritatea \fIfișierelor\fP comprimate. Această opțiune este +echivalentă cu \fB\-\-decompress \-\-stdout\fP cu excepția faptului că datele +decomprimate sunt înlăturate în loc să fie scrise la ieșirea standard. Nu +sunt create sau eliminate fișiere. +.TP +\fB\-l\fP, \fB\-\-list\fP +Afișează informații despre \fIfișiere\fP comprimate. Nu are loc nicio +decomprimare la ieșire și nu sunt create sau eliminate fișiere. În modul +listă, programul nu poate citi datele comprimate din intrarea standard sau +din alte surse care nu pot fi explorate. +.IP "" +Listarea implicită arată informații de bază despre \fIfișiere\fP, câte un +fișier pe linie. Pentru a obține informații mai detaliate, utilizați și +opțiunea \fB\-\-verbose\fP. Pentru și mai multe informații, utilizați opțiunea +\fB\-\-verbose\fP de două ori, dar rețineți că acest lucru poate fi lent, +deoarece obținerea tuturor informațiilor suplimentare necesită multe +căutări. Lățimea ieșirii detaliate depășește 80 de caractere, deci +canalizarea ieșirii către, de exemplu, \fBless\ \-S\fP poate fi convenabilă dacă +terminalul nu este suficient de lat. +.IP "" +Ieșirea exactă poate varia între versiunile \fBxz\fP și diferitele +localizări(configurările regionale). Pentru ieșiri care pot fi citite de +mașină, ar trebui utilizată opțiunea \fB\-\-robot \-\-list\fP. +. +.SS "Modificatori de operare" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Nu șterge fișierele de intrare. +.IP "" +Începând cu \fBxz\fP 5.2.6, această opțiune face ca \fBxz\fP să comprime sau să +decomprime, chiar dacă intrarea este o legătură simbolică către un fișier +obișnuit, are mai mult de\-o legătură dură sau are marcați biții setuid, +setgid sau bitul lipicios. Biții setuid, setgid și bitul lipicios nu sunt +copiați în fișierul țintă. În versiunile anterioare acest lucru se făcea +numai cu ajutorul opțiunii \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Această opțiune are mai multe efecte: +.RS +.IP \(bu 3 +Dacă fișierul țintă există deja, îl șterge înainte de comprimare sau +decomprimare. +.IP \(bu 3 +Comprimă sau decomprimă chiar dacă intrarea este o legătură simbolică către +un fișier obișnuit, are mai mult de\-o legătură dură sau are marcați biții +setuid, setgid sau bitul lipicios. Biții setuid, setgid și bitul lipicios nu +sunt copiați în fișierul țintă. +.IP \(bu 3 +Când este utilizată cu opțiunile \fB\-\-decompress\fP și \fB\-\-stdout\fP, comanda +\fBxz\fP nu poate recunoaște tipul fișierului sursă, și copiază fișierul sursă +așa cum este la ieșirea standard. Acest lucru permite comenzii \fBxzcat\fP +\fB\-\-force\fP să fie folosită drept comanda \fBcat\fP(1) pentru fișierele care nu +au fost comprimate cu \fBxz\fP. Rețineți că, în viitor, \fBxz\fP ar putea să +accepte noi formate de fișiere comprimate, ceea ce poate face ca \fBxz\fP să +decomprime mai multe tipuri de fișiere în loc să le copieze așa cum sunt la +ieșirea standard. Opțiunea \fB\-\-format=\fP\fIformat\fP poate fi folosită pentru a +restricționa \fBxz\fP să decomprime doar un singur format de fișier. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Scrie datele comprimate sau decomprimate la ieșirea standard în loc de +într\-un fișier. Aceasta implică \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Decomprimă numai primul flux \fB.xz\fP și ignoră în tăcere posibilele date de +intrare rămase în urma fluxului. În mod normal, astfel de resturi rămase +face ca \fBxz\fP să afișeze o eroare. +.IP "" +\fBxz\fP nu decomprimă niciodată mai mult de un flux din fișierele \fB.lzma\fP sau +din fluxurile brute, dar această opțiune face ca \fBxz\fP să ignore posibilele +resturi de date rămase după fișierul \fB.lzma\fP sau fluxul brut. +.IP "" +Această opțiune nu are efect dacă modul de funcționare nu este +\fB\-\-decompress\fP sau \fB\-\-test\fP. +.IP "" +Începând cu \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP implică \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Dezactivează crearea de fișiere dispersate. În mod implicit, dacă decomprimă +într\-un fișier obișnuit, \fBxz\fP încearcă să facă fișierul dispersat dacă +datele decomprimate conțin secvențe lungi de zerouri binare. De asemenea, +funcționează atunci când scrie la ieșirea standard, atâta timp cât ieșirea +standard este conectată la un fișier obișnuit și sunt îndeplinite anumite +condiții suplimentare pentru a o face în siguranță. Crearea de fișiere +dispersate poate economisi spațiu pe disc și poate accelera decomprimarea +prin reducerea cantității de date de In/Ieș pe disc. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Când comprimă, utilizează \fI.suf\fP ca sufix pentru fișierul țintă în loc de +\&\fB.xz\fP sau \fB.lzma\fP. Dacă nu scrie la ieșirea standard și fișierul sursă are +deja sufixul \fI.suf\fP, este afișat un avertisment și fișierul este omis. +.IP "" +Când decomprimă, recunoaște fișierele cu sufixul \fI.suf\fP în plus față de +fișierele cu sufixul \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP sau \fB.lz\fP. Dacă +fișierul sursă are sufixul \fI.suf\fP, sufixul este eliminat pentru a obține +numele fișierului țintă. +.IP "" +La comprimarea sau decomprimarea fluxurilor brute (\fB\-\-format=raw\fP), sufixul +trebuie să fie întotdeauna specificat, cu excepția cazului în care se scrie +la ieșirea standard, deoarece nu există un sufix implicit pentru fluxurile +brute. +.TP +\fB\-\-files\fP[\fB=\fP\fIfișier\fP] +Citește numele fișierelor de procesat din \fIfișier\fP; dacă \fIfișierul\fP este +omis, numele fișierelor sunt citite de la intrarea standard. Numele de +fișiere trebuie să fie terminate cu caracterul de linie nouă. O liniuță +(\fB\-\fP) este luată ca nume de fișier obișnuit; nu înseamnă intrarea +standard. Dacă numele de fișiere sunt date și ca argumente în linia de +comandă, ele sunt procesate înainte ca numele fișierelor să fie citite din +\fIfișier\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIfișier\fP] +Această opțiune este identică cu \fB\-\-files\fP[\fB=\fP\fIfișier\fP], cu excepția +faptului că fiecare nume de fișier trebuie să fie terminat cu caracterul +nul. +. +.SS "Formatul de bază al fișierului și opțiunile de comprimare" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fIformat\fP +Specifică \fIformatul\fP fișierului pentru comprimare sau decomprimare: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Aceasta este valoarea implicită. La comprimare, \fBauto\fP este echivalent cu +\fBxz\fP. La decomprimare, formatul fișierului de intrare este detectat +automat. Rețineți că fluxurile brute (create cu \fB\-\-format=raw\fP) nu pot fi +detectate automat. +.TP +\fBxz\fP +Comprimă în formatul de fișier \fB.xz\fP sau acceptă numai fișierele \fB.xz\fP +când decomprimă. +.TP +\fBlzma\fP, \fBalone\fP +Comprimă în formatul de fișier \fB.lzma\fP vechi sau acceptă numai fișierele +\&\fB.lzma\fP când decomprimă. Numele alternativ \fBalone\fP este furnizat pentru +compatibilitatea cu versiunile mai vechi de LZMA Utils. +.TP +\fBlzip\fP +Acceptă numai fișierele \fB.lz\fP când decomprimă. Comprimarea nu este +acceptată. +.IP "" +Sunt acceptate versiunile 0 și 1 ale formatului \fB.lz\fP. Fișierele versiunii +0 au fost create cu \fBlzip\fP 1.3 și versiuni mai vechi. Astfel de fișiere nu +sunt comune, dar pot fi găsite în arhivele de fișiere, deoarece câteva +pachete sursă au fost lansate în acest format. Este posibil ca oamenii să +aibă și fișiere personale vechi în acest format. Suportul pentru +decomprimare pentru versiunea 0 a formatului a fost eliminat în \fBlzip\fP +1.18. \fBlzip\fP 1.4 și versiunile ulterioare creează fișiere în versiunea 1 a +formatului. +.TP +\fBraw\fP +Comprimă sau decomprimă un flux brut (fără anteturi). Acest lucru este +destinat doar utilizatorilor avansați. Pentru a decodifica fluxurile brute, +trebuie să utilizați opțiunea \fB\-\-format=raw\fP și să specificați în mod +explicit lanțul de filtre, care în mod normal ar fi fost stocat în +anteturile containerului. +.RE +.TP +\fB\-C\fP \fIverificarea\fP, \fB\-\-check=\fP\fIverificarea\fP +Specifică tipul verificării integrității. Verificarea este calculată din +datele necomprimate și stocată în fișierul \fB.xz\fP. Această opțiune are efect +numai la comprimarea în format \fB.xz\fP; formatul \fB.lzma\fP nu acceptă +verificări de integritate. Verificarea integrității (dacă există) este +efectuată atunci când fișierul \fB.xz\fP este decomprimat. +.IP "" +Tipuri de \fIverificare\fP acceptate: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Nu calculează deloc o verificare a integrității. Aceasta este de obicei o +idee proastă. Acest lucru poate fi util atunci când integritatea datelor +este oricum verificată prin alte mijloace. +.TP +\fBcrc32\fP +Calculează CRC32 folosind polinomul din IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Calculează CRC64 folosind polinomul din ECMA\-182. Aceasta este valoarea +implicită, deoarece este ceva mai bună decât CRC32 la detectarea fișierelor +deteriorate, iar diferența de viteză este neglijabilă. +.TP +\fBsha256\fP +Calculează SHA\-256. Acest lucru este oarecum mai lent decât CRC32 și CRC64. +.RE +.IP "" +Integritatea antetelor \fB.xz\fP este întotdeauna verificată cu CRC32. Nu este +posibilă modificarea sau dezactivarea acesteia. +.TP +\fB\-\-ignore\-check\fP +Nu efectuează verificarea integrității datelor comprimate la +decomprimare. Valorile CRC32 din antetele \fB.xz\fP vor fi însă verificate +normal. +.IP "" +\fBNu utilizați această opțiune decât dacă știți ce faceți\fP. Motive posibile +pentru a utiliza această opțiune: +.RS +.IP \(bu 3 +Încercarea de a recupera datele dintr\-un fișier .xz corupt. +.IP \(bu 3 +Accelerarea decomprimării. Acest lucru contează mai ales cu SHA\-256 sau cu +fișierele care s\-au comprimat extrem de bine. Este recomandat să nu +utilizați această opțiune în acest scop decât dacă integritatea fișierului +este verificată extern într\-un alt mod. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Selectează un nivel prestabilit de comprimare. Valoarea implicită este +\fB\-6\fP. Dacă sunt specificate mai multe niveluri prestabilite, ultimul are +efect. Dacă a fost deja specificat un lanț de filtre personalizat, +specificarea unui nivel prestabilit de comprimare șterge lanțul de filtre +personalizat. +.IP "" +Diferențele dintre valorile prestabilite sunt mai semnificative decât cu +\fBgzip\fP(1) și \fBbzip2\fP(1). Valorile de comprimare selectate determină +cerințele de memorie ale instrumentului de decomprimare, astfel încât +utilizarea unui nivel prea mare prestabilit ar putea face „dureroasă” +decomprimarea fișierului pe un sistem vechi cu puțină memorie RAM. Mai +exact, \fBnu este o idee bună să folosiți orbește \-9 pentru tot\fP așa cum se +întâmplă adesea cu \fBgzip\fP(1) și \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Acestea sunt valorile prestabilite oarecum rapide. \fB\-0\fP este uneori mai +rapid decât \fBgzip \-9\fP în timp ce comprimă mult mai bine. Cele mai ridicate +au adesea viteza comparabilă cu \fBbzip2\fP(1) cu un raport de comprimare +comparabil sau mai bun, deși rezultatele depind foarte mult de tipul de date +care sunt comprimate. +.TP +\fB\-4\fP ... \fB\-6\fP +Comprimare bună spre foarte bună, păstrând în același timp utilizarea +memoriei de către instrumentul de decomprimare la un nivel rezonabil chiar +și pentru sistemele vechi. \fB\-6\fP este valoarea implicită, care este de +obicei o alegere bună pentru distribuirea fișierelor care trebuie să poată +fi decomprimate chiar și pe sisteme cu doar 16Mio de memorie RAM. Opțiunile +(\fB\-5e\fP sau \fB\-6e\fP ar putea fi demne de luat în considerare. A se vedea +opțiunea \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Acestea sunt precum \fB\-6\fP, dar cu cerințe mai mari de memorie pentru +comprimare și decomprimare. Acestea sunt utile numai atunci când comprimați +fișiere mai mari de 8Mio, 16Mio și, respectiv, 32Mio. +.RE +.IP "" +Pe același hardware, viteza de decomprimare este aproximativ un număr +constant de octeți de date comprimate pe secundă. Cu alte cuvinte, cu cât +comprimarea este mai bună, cu atât decomprimarea va fi de obicei mai +rapidă. Aceasta înseamnă, de asemenea, că valoarea de la ieșire a cantității +de date necomprimate produsă pe secundă poate varia foarte mult. +.IP "" +Următorul tabel rezumă caracteristicile valorilor prestabilite: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +ValPrestab;DimDict;CPUComp;MemComp;MemDec +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Descrieri coloane: +.RS +.IP \(bu 3 +DimDict este dimensiunea dicționarului LZMA2. Este o risipă de memorie să +folosești un dicționar mai mare decât dimensiunea fișierului necomprimat. De +aceea este bine să evitați utilizarea valorilor prestabilite \fB\-7\fP ... \fB\-9\fP +atunci când nu este nevoie cu adevărat de ele. Pentru valoarea prestabilită +\fB\-6\fP sau alta mai mică, cantitatea de memorie irosită este de obicei +suficient de mică pentru a nu conta. +.IP \(bu 3 +CPUComp este o reprezentare simplificată a configurărilor LZMA2 care +afectează viteza de comprimare. Dimensiunea dicționarului afectează și +viteza, așa că, în timp ce CPUComp este aceeași pentru nivelurile \fB\-6\fP +\&... \fB\-9\fP, nivelurile mai mari tind să fie puțin mai lente. Pentru a obține +o comprimare și mai lentă și, astfel, posibil mai bună, consultați opțiunea +\fB\-\-extreme\fP. +.IP \(bu 3 +MemComp conține cerințele de memorie ale comprimării în modul cu un singur +fir de execuție. Poate varia ușor între versiunile \fBxz\fP. +.IP \(bu 3 +MemDec conține cerințele de memorie pentru decomprimare. Adică, +configurările de comprimare determină cerințele de memorie ale +decomprimării. Cantitatea exactă a memoriei utilizate la decomprimare este +puțin mai mare decât dimensiunea dicționarului LZMA2, dar valorile din tabel +au fost rotunjite la următorul Mio. +.RE +.IP "" +Cerințele de memorie ale modului cu mai multe fire de execuție sunt +semnificativ mai mari decât cele ale modului cu un singur fir de +execuție. Cu valoarea implicită a lui \fB\-\-block\-size\fP, fiecare fir are +nevoie de 3*3*DictSize plus MemComp sau MemDec. De exemplu, patru fire de +execuție cu valoarea prestabilită \fB\-6\fP au nevoie de 660\(en670\ Mio de +memorie. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Utilizează o variantă mai lentă a nivelului prestabilit de comprimare +selectat (\fB\-0\fP ... \fB\-9\fP) pentru a obține un raport de comprimare puțin mai +bun, dar din nefericire, acest lucru îl poate înrăutăți. Utilizarea memoriei +pentru decomprimare nu este afectată, dar utilizarea memoriei la comprimare +crește puțin la nivelurile prestabilite \fB\-0\fP ... \fB\-3\fP. +.IP "" +Deoarece există două valori prestabilite cu dimensiuni ale dicționarului de +4Mio și 8Mio, valorile prestabilite \fB\-3e\fP și \fB\-5e\fP folosesc configurări +puțin mai rapide (CPUComp mai mic) decât \fB\-4e\fP și \fB\-6e\fP, respectiv. În +acest fel, nu există două nivele prestabilite identice. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +ValPrestab;DimDict;CPUComp;MemComp;MemDec +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +De exemplu, există un total de patru nivele prestabilite care folosesc +dicționarul 8Mio, a căror ordine de la cel mai rapid la cel mai lent este +\fB\-5\fP, \fB\-6\fP, \fB\-5e\fP și \fB\-6e\fP . +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Acestea sunt alias de opțiuni, oarecum înșelătoare pentru \fB\-0\fP și, +respectiv, \fB\-9\fP. Acestea sunt furnizate numai pentru compatibilitatea cu +LZMA Utils. Evitați utilizarea acestor opțiuni. +.TP +\fB\-\-block\-size=\fP\fIdimensiunea\fP +Când comprimă în formatul \fB.xz\fP, împarte datele de intrare în blocuri de +\fIdimensiunea\fP octeți. Blocurile sunt comprimate independent unul de +celălalt, ceea ce ajută în modul cu mai multe fire de execuție și face +posibilă decomprimarea cu acces aleatoriu limitat. Această opțiune este de +obicei folosită pentru a suprascrie dimensiunea implicită a blocului în +modul cu mai multe fire de execuție, dar această opțiune poate fi folosită +și în modul cu un singur fir de execuție. +.IP "" +În modul cu mai multe fire de execuție, aproximativ de trei ori +\fIdimensiunea\fP de octeți vor fi alocați în fiecare fir pentru stocarea +intrării și ieșirii. \fIDimensiunea\fP implicită este de trei ori dimensiunea +dicționarului LZMA2 sau 1Mio, oricare dintre acestea este mai mare. În mod +obișnuit, o valoare bună este de două la patru ori dimensiunea dicționarului +LZMA2 sau de cel puțin 1Mio. Utilizarea unei \fIdimensiuni\fP mai mici decât +dimensiunea dicționarului LZMA2 este o risipă de memorie RAM, deoarece +atunci memoria tampon a dicționarului LZMA2 nu va fi niciodată utilizată pe +deplin. În modul cu mai multe fire de execuție, dimensiunile blocurilor sunt +stocate în anteturile blocurilor. Aceste informații privind dimensiunea sunt +necesare pentru decomprimarea cu mai multe fire. +.IP "" +În modul cu un singur fir de execuție, nicio divizare a blocurilor nu se +face în mod implicit. Folosirea acestei opțiuni nu afectează utilizarea +memoriei. Nu sunt stocate informații despre dimensiune în antetele +blocurilor, astfel încât fișierele create în modul cu un singur fir de +execuție nu vor fi identice cu fișierele create în modul cu mai multe fire +de execuție. Lipsa informațiilor privind dimensiunea înseamnă, de asemenea, +că \fBxz\fP nu va putea decomprima fișierele în modul cu mai multe fire. de +execuție. +.TP +\fB\-\-block\-list=\fP\fIelemente\fP +Când comprimă în formatul \fB.xz\fP, începe un nou bloc cu un lanț de filtre +personalizat opțional după intervalele specificate de date necomprimate. +.IP "" +\fIelementele\fP sunt o listă separată prin virgule. Fiecare element este +format dintr\-un număr opțional de lanț de filtrare între 0 și 9, urmat de +două puncte (\fB:\fP) și de o dimensiune cerută a datelor +necomprimate. Omiterea unui element (două sau mai multe virgule consecutive) +este o prescurtare pentru a utiliza dimensiunea și filtrele din elementul +anterior. +.IP "" +În cazul în care fișierul de intrare este mai mare decât suma dimensiunilor +din \fIelemente\fP, ultimul element se repetă până la sfârșitul fișierului. O +valoare specială de \fB0\fP poate fi utilizată ca ultimă dimensiune pentru a +indica faptul că restul fișierului trebuie să fie codificat ca un singur +bloc. +.IP "" +Un lanț de filtre alternativ pentru fiecare bloc poate fi specificat în +combinație cu opțiunile \fB\-\-filters1=\fP\fIfiltre\fP \&...\& +\fB\-\-filters9=\fP\fIfiltre\fP. Aceste opțiuni definesc lanțuri de filtre cu un +identificator cuprins între 1\(en9. Lanțul de filtre 0 poate fi utilizat +pentru a se referi la lanțul de filtre implicit, ceea ce este același lucru +cu a nu specifica un lanț de filtre. Identificatorul lanțului de filtre +poate fi utilizat înaintea dimensiunii necomprimate, urmat de două puncte +(\fB:\fP). De exemplu, dacă se specifică +\fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP, atunci blocurile vor fi +create folosind: +.RS +.IP \(bu 3 +Lanțul de filtre specificat de \fB\-\-filters1\fP și 2 Mio de intrare +.IP \(bu 3 +Lanțul de filtre specificat de \fB\-\-filters3\fP și 2 Mio de intrare +.IP \(bu 3 +Lanțul de filtre specificat de \fB\-\-filters2\fP și 4 Mio de intrare +.IP \(bu 3 +Lanțul de filtre specificat de \fB\-\-filters2\fP și 4 Mio de intrare +.IP \(bu 3 +Lanțul de filtre implicit și 2 MiB de intrare +.IP \(bu 3 +Lanțul de filtre implicit și 4 MiB de intrare pentru fiecare bloc până la +sfârșitul intrării. +.RE +.IP "" +Dacă se specifică o dimensiune care depășește dimensiunea blocului +codificatorului (fie valoarea implicită în modul cu fire de execuție, fie +valoarea specificată cu \fB\-\-block\-size=\fP\fIdimensiune\fP), codificatorul va +crea blocuri suplimentare, păstrând limitele specificate în \fIelemente\fP. De +exemplu, dacă se specifică \fB\-\-block\-size=10MiB\fP +\fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP și fișierul de intrare este de +80 MiB, se vor obține 11 blocuri: 5, 10, 8, 10, 10, 2, 10, 10, 10, 4, 10, +10, 10 și 1 Mio. +.IP "" +În modul cu mai multe fire de execuție, dimensiunile blocurilor sunt stocate +în antetele blocurilor. Acest lucru nu se face în modul cu un singur fir de +execuție, astfel încât ieșirea codificată nu va fi identică cu cea a modului +cu mai multe fire de execuție. +.TP +\fB\-\-flush\-timeout=\fP\fItimp_limită\fP +La comprimare, dacă au trecut mai mult de \fItimp_limită\fP milisecunde (un +întreg pozitiv) de la curățarea anterioară și citirea mai multor intrări +s\-ar bloca, toate datele de intrare în așteptare sunt eliminate din +codificator și puse la dispoziție în fluxul de ieșire. Acest lucru poate să +fie util dacă \fBxz\fP este utilizat pentru a comprima datele care sunt +transmise în flux printr\-o rețea. Valorile mici de \fItimp_limită\fP fac datele +disponibile la capătul de recepție cu o mică întârziere, dar valorile mari +de \fItimp_limită\fP oferă un raport de comprimare mai bun. +.IP "" +Această caracteristică este dezactivată în mod implicit. Dacă această +opțiune este specificată de mai multe ori, ultima este cea care se ia în +considerare. Valoarea specială a lui \fItimp_limită\fP de \fB0\fP, poate fi +utilizată pentru a dezactiva în mod explicit această caracteristică. +.IP "" +Această caracteristică nu este disponibilă în sistemele non\-POSIX. +.IP "" +.\" FIXME +\fBAceastă caracteristică este încă experimentală\fP. În prezent, \fBxz\fP este +nepotrivit pentru decomprimarea fluxului în timp real datorită modului în +care \fBxz\fP utilizează memoria tampon. +.TP +\fB\-\-no\-sync\fP +Nu sincronizează fișierul țintă și directorul acestuia cu dispozitivul de +stocare înainte de a elimina fișierul sursă. Acest lucru poate îmbunătăți +performanța în cazul comprimării sau decomprimării multor fișiere mici. Cu +toate acestea, dacă sistemul se blochează imediat după ștergere, este +posibil ca fișierul țintă să nu fi fost scris pe dispozitivul de stocare, +dar operația de ștergere să fi fost. În acest caz, nici fișierul sursă +original, nici fișierul țintă nu sunt disponibile. +.IP "" +Această opțiune are efect numai atunci când \fBxz\fP urmează să elimine +fișierul sursă. În alte cazuri, sincronizarea nu se face niciodată. +.IP "" +Sincronizarea și \fB\-\-no\-sync\fP au fost adăugate în \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIlimita\fP +Stabilește o limită de utilizare a memoriei pentru comprimare. Dacă această +opțiune este specificată de mai multe ori, ultima va avea efect. +.IP "" +Dacă parametrii de comprimare depășesc \fIlimita\fP, \fBxz\fP va încerca să +ajusteze parametrii scăzând valorile acestora, astfel încât limita să nu mai +fie depășită și va afișa o notificare că ajustarea automată a fost +efectuată. Ajustările se fac în această ordine: reducerea numărului de fire, +trecerea la modul un singur fir de execuție dacă chiar și un singur fir în +modul cu mai multe fire de execuție depășește \fIlimita\fP și, în final, +reducerea dimensiunii dicționarului LZMA2. +.IP "" +Când comprimă cu opțiunea \fB\-\-format=raw\fP sau dacă a fost specificată +opțiunea \fB\-\-no\-adjust\fP, numai numărul de fire poate fi redus, deoarece se +poate face fără a afecta rezultatul comprimării. +.IP "" +Dacă \fIlimita\fP nu poate fi îndeplinită chiar și cu ajustările descrise mai +sus, este afișată o eroare și \fBxz\fP va ieși cu starea de ieșire 1. +.IP "" +\fILimita\fP poate fi specificata în mai multe moduri: +.RS +.IP \(bu 3 +\fILimita\fP poate fi o valoare absolută în octeți. Utilizarea unui sufix +întreg precum \fBMiB\fP poate fi utilă. De exemplu: +\fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +\fILimita\fP poate fi specificată ca procent din memoria fizică totală +(RAM). Acest lucru poate fi util mai ales atunci când definiți variabila de +mediu \fBXZ_DEFAULTS\fP într\-un script de inițializare shell care este partajat +între diferite calculatoare. În acest fel, limita este automat mai mare pe +sistemele cu mai multă memorie. De exemplu: \fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +\fILimita\fP poate fi restabilită la valoarea implicită dându\-i valoarea +\fB0\fP. În prezent, aceasta este echivalentă cu stabilirea \fIlimitei\fP la +\fBmax\fP (fără limită de utilizare a memoriei). +.RE +.IP "" +Pentru \fBxz\fP pe 32 de biți există un caz special: dacă \fIlimita\fP ar fi peste +\fB4020MiB\fP, \fIlimita\fP este stabilită la \fB4020MiB\fP. Pe MIPS32 este +stabilită în schimb la \fB2000MiB\fP; (valorile \fB0\fP și \fBmax\fP nu sunt afectate +de acest lucru \-\- o caracteristică similară nu există pentru +decomprimare). Acest lucru poate fi util atunci când un executabil pe 32 de +biți are acces la un spațiu de adrese de 4Gio (2Gio pe MIPS32), se speră că +nu produce daune în alte situații. +.IP "" +Consultați și secțiunea \fBUtilizarea memoriei\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIlimita\fP +Stabilește o limită de utilizare a memoriei pentru decomprimare. Acest lucru +afectează și modul \fB\-\-list\fP. Dacă operațiunea nu este posibilă fără a +depăși \fIlimita\fP, \fBxz\fP va afișa o eroare și decomprimarea fișierului va +eșua. Consultați \fB\-\-memlimit\-compress=\fP\fIlimita\fP pentru modalitățile +posibile de a specifica \fIlimita\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimita\fP +Stabilește o limită de utilizare a memoriei pentru decomprimarea cu mai +multe fire de execuție. Acest lucru poate afecta doar numărul de fire de +execuție; acest lucru nu îl va face niciodată pe \fBxz\fP să refuze +decomprimarea unui fișier. Dacă \fIlimita\fP este prea scăzută pentru a permite +orice mod cu mai multe fire de execuție, \fIlimita\fP este ignorată și \fBxz\fP va +continua în modul cu un singur fir de execuție. Rețineți că, dacă se +folosește și opțiunea \fB\-\-memlimit\-decompress\fP, se va aplica întotdeauna +atât modurilor cu un singur fir de execuție, cât și modurilor cu mai multe +fire de execuție și astfel \fIlimita\fP efectivă pentru modul cu mai multe fire +de execuție nu va fi niciodată mai mare decât limita stabilită cu opțiunea +\fB\-\-memlimit\-decompress\fP. +.IP "" +Spre deosebire de celelalte opțiuni de limită de utilizare a memoriei, +opțiunea \fB\-\-memlimit\-mt\-decompress=\fP\fIlimita\fP are o \fIlimită\fP implicită +specifică sistemului. Comanda \fBxz \-\-info\-memory\fP poate fi folosită pentru a +vedea valoarea curentă. +.IP "" +Această opțiune și valoarea ei implicită există deoarece, fără nicio limită, +decomprimarea cu (mai multe) fire de execuție ar putea ajunge să aloce o +cantitate „nebună” de memorie cu unele fișiere de intrare. Dacă \fIlimita\fP +implicită este prea scăzută pe sistemul dumneavoastră, nu ezitați să +creșteți \fIlimita\fP, dar niciodată să nu o stabiliți la o valoare mai mare +decât cantitatea de memorie RAM utilizabilă și cu niște fișiere de intrare +adecvate, \fBxz\fP va încerca să utilizeze acea cantitate de memorie chiar și +cu un număr redus de fire de execuție. Rularea lui \fBxz\fP cu depășirea +cantității de memorie fizice(RAM) sau a celei de interschimb(swap) nu va +îmbunătăți performanța de decomprimare. +.IP "" +Consultați opțiunea \fB\-\-memlimit\-compress=\fP\fIlimita\fP pentru modalități +posibile de a specifica \fIlimita\fP. Stabilirea \fIlimitei\fP la \fB0\fP +restabilește \fIlimita\fP la valoarea implicită specifică sistemului. +.TP +\fB\-M\fP \fIlimita\fP, \fB\-\-memlimit=\fP\fIlimita\fP, \fB\-\-memory=\fP\fIlimita\fP +Aceasta este echivalentă cu specificarea opțiunilor: +\fB\-\-memlimit\-compress=\fP\fIlimita\fP \fB\-\-memlimit\-decompress=\fP\fIlimita\fP +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimita\fP. +.TP +\fB\-\-no\-adjust\fP +Afișează o eroare și iese dacă limita de utilizare a memoriei nu poate fi +îndeplinită fără ajustarea parametrilor care afectează ieșirea +comprimată. Adică, acest lucru împiedică \fBxz\fP să comute codificatorul din +modul cu mai multe fire de execuție în modul cu un singur fir de execuție și +să reducă dimensiunea dicționarului LZMA2. Chiar și atunci când această +opțiune este utilizată, numărul de fire de execuție poate fi redus pentru a +îndeplini limita de utilizare a memoriei, deoarece aceasta nu va afecta +comprimarea. +.IP "" +Ajustarea automată este întotdeauna dezactivată la crearea fluxurilor brute +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fInumăr\fP, \fB\-\-threads=\fP\fInumăr\fP +Specifică numărul de fire de execuție de utilizat. Stabilirea \fInumărului\fP +la valoarea specială \fB0\fP, face ca \fBxz\fP să utilizeze până la atâtea fire de +execuție câte procesoare sunt în sistem. Numărul real de fire de execuție +poate fi mai mic decât \fInumăr\fP dacă fișierul de intrare nu este suficient +de mare pentru a trece la modul cu mai multe fire de execuție cu parametrii +dați, sau dacă folosirea mai multor fire de execuție ar depăși limita de +utilizare a memoriei. +.IP "" +Operațiile de comprimare cu un singur fir de execuție și cele cu mai multe +fire de execuție produc ieșiri diferite. Comprimarea cu un singur fir de +execuție va oferi cea mai mică dimensiune a fișierului, dar numai ieșirea de +la comprimarea cu mai multe fire de execuție poate fi decomprimată folosind +mai multe fire. Stabilirea \fInumărului\fP la \fB1\fP va determina ca \fBxz\fP să +folosească modul cu un singur fir de execuție. Stabilirea \fInumărului\fP la +orice altă valoare, inclusiv \fB0\fP, va determina ca \fBxz\fP să folosească +comprimarea cu mai multe fire de execuție chiar dacă sistemul acceptă doar +un fir hardware; (\fBxz\fP 5.2.x folosește modul cu un singur fir de execuție +în această situație). +.IP "" +Pentru a utiliza modul cu mai multe fire de execuție cu un singur fir, +stabiliți \fInumărul\fP la \fB+1\fP. Prefixul \fB+\fP nu are efect cu alte valori +decât \fB1\fP. O limită de utilizare a memoriei poate face în continuare \fBxz\fP +să treacă în modul cu un singur fir, cu excepția cazului în care este +utilizată opțiunea \fB\-\-no\-adjust\fP. Suportul pentru prefixul \fB+\fP a fost +adăugat în \fBxz\fP 5.4.0. +.IP "" +Dacă a fost solicitat un număr automat de fire și nu a fost specificată +nicio limită de utilizare a memoriei, atunci o limită „maleabilă” implicită +specifică sistemului va fi utilizată pentru a limita eventual numărul de +fire de execuție. Este o limită „maleabilă” în sensul că este ignorată dacă +numărul de fire devine unul, astfel o limită „maleabilă” nu va opri +niciodată \fBxz\fP să comprime sau să decomprime. Această limită „maleabilă” +implicită nu va face \fBxz\fP să treacă de la modul cu mai multe fire de +execuție la modul cu un singur fir de execuție. Limitele active pot fi +văzute rulând comanda \fBxz \-\-info\-memory\fP. +.IP "" +În prezent, singura metodă de procesare cu fire de execuție este împărțirea +intrării în blocuri și comprimarea lor independent unul de +celălalt. Dimensiunea implicită a blocului depinde de nivelul de comprimare +și poate fi înlocuită cu opțiunea \fB\-\-block\-size=\fP\fIdimensiune\fP. +.IP "" +Decomprimarea cu fire de execuție funcționează numai pe fișierele care +conțin mai multe blocuri cu informații despre dimensiune în antetele +blocurilor. Toate fișierele suficient de mari comprimate în modul cu mai +multe fire de execuție îndeplinesc această condiție, dar fișierele +comprimate în modul cu un singur fir de execuție nu o îndeplinesc chiar dacă +a fost folosită opțiunea \fB\-\-block\-size=\fP\fIdimensiune\fP. +.IP "" +Valoarea implicită pentru \fIfire de execuție\fP este \fB0\fP. În \fBxz\fP 5.4.x și +mai vechi, valoarea implicită este \fB1\fP. +. +.SS "Lanțuri de filtrare personalizate pentru instrumentul de comprimare" +Un lanț de filtrare personalizat permite specificarea parametrilor de +comprimare în detaliu, în loc să se bazeze pe cei asociați opțiunilor +prestabilite. Când este specificat un lanț de filtrare personalizat, +opțiunile prestabilite (\fB\-0\fP \&...\& \fB\-9\fP și \fB\-\-extreme\fP) de mai devreme +din linia de comandă sunt uitate. Dacă o opțiune prestabilită este +specificată după una sau mai multe opțiuni de lanț de filtrare personalizat, +noua prestabilire intră în vigoare și opțiunile lanțului de filtrare +personalizat, specificate mai devreme sunt uitate. +.PP +Un lanț de filtrare este comparabil cu conductele din linia de comandă. La +comprimare, intrarea necomprimată merge la primul filtru, a cărui ieșire +merge la următorul filtru (dacă există). Ieșirea ultimului filtru este +scrisă în fișierul comprimat. Numărul maxim de filtre din lanț este de +patru, dar de obicei un lanț de filtrare are doar unul sau două filtre. +.PP +Multe filtre au limitări în ceea ce privește locul în care se pot afla în +lanțul de filtrare: unele filtre pot funcționa doar ca ultimul filtru din +lanț, altele doar ca non\-ultim filtru și unele funcționează în orice poziție +din lanț. În funcție de filtru, această limitare este fie inerentă +proiectării filtrului, fie există pentru a preveni problemele de securitate. +.PP +Un lanț de filtre personalizat poate fi specificat în două moduri +diferite. Opțiunile \fB\-\-filters=\fP\fIfiltre\fP și \fB\-\-filters1=\fP\fIfiltre\fP +\&...\& \fB\-\-filters9=\fP\fIfiltre\fP permit specificarea unui întreg lanț de +filtre într\-o singură opțiune, folosind sintaxa șirului de filtre +liblzma. Alternativ, un lanț de filtre poate fi specificat prin utilizarea +uneia sau mai multor opțiuni de filtrare individuale în ordinea în care sunt +dorite în lanțul de filtre. Adică, ordinea opțiunilor de filtrare +individuale este semnificativă! La decodificarea fluxurilor brute +(\fB\-\-format=raw\fP), lanțul de filtre trebuie să fie specificat în aceeași +ordine în care a fost specificat la comprimare. Orice filtru individual sau +opțiuni presetate specificate înainte de opțiunea de lanț complet +(\fB\-\-filters=\fP\fIfiltre\fP) vor fi uitate. Filtrele individuale specificate +după opțiunea „lanț complet” vor reinițializa lanțul de filtre. +.PP +Atât opțiunile de filtrare completă, cât și cele de filtrare individuală +acceptă \fIopțiuni\fP specifice filtrului sub forma unei liste separate prin +virgule. Se ignoră virgulele suplimentare din \fIopțiuni\fP. Fiecare opțiune +are o valoare implicită, deci specificați\-le pe cele pe care doriți să le +modificați. +.PP +Pentru a vedea întregul lanț de filtre și \fIopțiuni\fP, utilizați \fBxz \-vv\fP +(adică folosiți \fB\-\-verbose\fP de două ori). Acest lucru funcționează și +pentru vizualizarea opțiunilor lanțului de filtre utilizate de valorile +prestabilite. +.TP +\fB\-\-filters=\fP\fIfiltre\fP +Specificați întregul lanț de filtre sau o presetare într\-o singură +opțiune. Fiecare filtru poate fi separat prin spații sau două liniuțe +(\fB\-\-\fP). Este posibil să fie necesar ca \fIfiltrele\fP să fie puse între +ghilimele în linia de comandă a shell\-ului pentru a fi analizate ca o +singură opțiune. Pentru a indica \fIopțiuni\fP, utilizați \fB:\fP sau \fB=\fP. O +presetare poate fi prefixată cu un \fB\-\fP și urmată de zero sau mai multe +indicatoare. Singurul indicator suportat este \fBe\fP pentru a aplica aceleași +opțiuni ca și \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIfiltre\fP ... \fB\-\-filters9\fP=\fIfiltre\fP +Specifică până la nouă lanțuri de filtre suplimentare care pot fi utilizate +cu \fB\-\-block\-list\fP. +.IP "" +De exemplu, atunci când se comprimă o arhivă cu fișiere executabile urmate +de fișiere text, partea executabilă ar putea utiliza un lanț de filtre cu un +filtru BCJ, iar partea de text doar filtrul LZMA2. +.TP +\fB\-\-filters\-help\fP +Afișează un mesaj de ajutor care descrie modul de specificare a presetărilor +și a lanțurilor de filtre personalizate în opțiunile \fB\-\-filters\fP și +\fB\-\-filters1=\fP\fIfiltre\fP \&...\& \fB\-\-filters9=\fP\fIfiltre\fP și iese. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIopțiuni\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIopțiuni\fP] +.PD +Adaugă filtrul LZMA1 sau LZMA2 la lanțul de filtre. Aceste filtre pot fi +folosite doar ca ultimul filtru din lanț. +.IP "" +LZMA1 este un filtru vechi, care este acceptat aproape exclusiv datorită +formatului de fișier vechi \fB.lzma\fP, care acceptă numai LZMA1. LZMA2 este o +versiune actualizată a LZMA1 pentru a rezolva unele probleme practice ale +LZMA1. Formatul \fB.xz\fP folosește LZMA2 și nu acceptă deloc LZMA1. Viteza de +comprimare și rapoartele LZMA1 și LZMA2 sunt practic aceleași. +.IP "" +LZMA1 și LZMA2 au același set de \fIopțiuni\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIprestabilit\fP +Reconfigurează toate \fIopțiunile\fP LZMA1 sau LZMA2 la +\fIprestabilit\fP. \fIprestabilit\fP constă dintr\-un număr întreg, care poate fi +urmat de modificatori prestabiliți cu o singură literă. Numărul întreg +poate fi de la \fB0\fP la \fB9\fP, potrivindu\-se cu opțiunile liniei de comandă +\fB\-0\fP \&...\& \fB\-9\fP. Singurul modificator acceptat în prezent este \fBe\fP, +care se potrivește cu \fB\-\-extreme\fP. Dacă nu este specificat \fBprestabilit\fP, +valorile implicite ale \fIopțiunilor\fP LZMA1 sau LZMA2 sunt preluate din +prestabilirea \fB6\fP. +.TP +\fBdict=\fP\fIdimensiunea\fP +\fIDimensiunea\fP dicționarului (istoricul memoriei tampon) indică câți octeți +din datele necomprimate recent procesate sunt păstrați în +memorie. Algoritmul încearcă să găsească secvențe de octeți care se repetă +(potriviri) în datele necomprimate și să le înlocuiască cu referințe la +datele aflate în prezent în dicționar. Cu cât dicționarul este mai mare, cu +atât este mai mare șansa de a găsi o potrivire. Astfel, creșterea +\fIdimensiunii\fP dicționarului îmbunătățește de obicei raportul de comprimare, +dar un dicționar mai mare decât fișierul necomprimat este risipă de memorie. +.IP "" +\fIDimensiunea\fPtipică a dicționarului este de la 64Kio până la 64Mio. Minimul +este de 4Kio. Maximul pentru compresie este în prezent de 1,5Gio +(1536Mio). Decomprimarea acceptă deja dicționare cu până la un octet mai +puțin de 4Gio, care este maximul pentru formatele de flux LZMA1 și LZMA2. +.IP "" +\fIDimensiunea\fP dicționarului și găsitorul de potriviri (match finder) → +(\fImf\fP) determină împreună utilizarea memoriei de către codificatorul LZMA1 +sau LZMA2. Aceeași \fIdimensiune\fP a dicționarului (sau mai mare) care a fost +utilizată la comprimare, este necesară pentru decomprimare, astfel încât +utilizarea memoriei de către decodificator este determinată de dimensiunea +dicționarului utilizată la comprimare. Antetele \fB.xz\fP stochează +\fIdimensiunea\fP dicționarului fie ca 2^\fIn\fP, fie ca 2^\fIn\fP + 2^(\fIn\fP\-1), deci +aceste \fIdimensiuni\fP sunt oarecum preferate pentru comprimare. Alte +\fIdimensiuni\fP vor fi rotunjite atunci când sunt stocate în anteturile +\&\fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Specifică numărul de biți de context literal. Minimul este 0 și maximul este +4; implicit este 3. În plus, suma \fIlc\fP și \fIlp\fP nu trebuie să depășească +4. +.IP "" +Toți octeții care nu pot fi codificați ca potriviri sunt codificați ca +literali. Adică, literalii sunt pur și simplu octeți de 8 biți care sunt +codificați unul câte unul. +.IP "" +Codificarea literală presupune că cei mai mari biți \fIlc\fP ai octetului +anterior necomprimat se corelează cu octetul următor. De exemplu, în textul +tipic englezesc, o literă mare este adesea urmată de o literă mică, iar o +literă mică este urmată de obicei de o altă literă mică. În setul de +caractere US\-ASCII, cei mai mari trei biți sunt 010 pentru literele mari și +011 pentru literele mici. Când \fIlc\fP este cel puțin 3, codificarea literală +poate profita de această proprietate în datele necomprimate. +.IP "" +Valoarea implicită (3) este de obicei bună. Dacă doriți o comprimare maximă, +testați \fBlc=4\fP. Uneori ajută puțin, iar uneori înrăutățește comprimarea +\&. Dacă o agravează, încercați de\-asemeni cu \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Specifică numărul de biți de poziție literală. Minimul este 0 și maximul +este 4; implicit este 0. +.IP "" +\fILp\fP afectează ce fel de aliniere în datele necomprimate este presupusă la +codificarea literalelor. Consultați argumentul \fIpb\fP de mai jos pentru mai +multe informații despre aliniere. +.TP +\fBpb=\fP\fIpb\fP +Specifică numărul de biți de poziție. Minimul este 0 și maximul este 4; +implicit este 2. +.IP "" +\fIPb\fP afectează ce fel de aliniere în datele necomprimate este presupusă în +general. Valoarea implicită înseamnă alinierea pe patru octeți +(2^\fIpb\fP=2^2=4), care este adesea o alegere bună atunci când nu există o +ipoteză mai bună. +.IP "" +Când alinierea este cunoscută, definirea lui \fIpb\fP în mod corespunzător +poate reduce puțin dimensiunea fișierului. De exemplu, cu fișierele text cu +aliniere pe un octet (US\-ASCII, ISO\-8859\-*, UTF\-8), definirea \fBpb=0\fP poate +îmbunătăți ușor comprimarea. Pentru textul UTF\-16, \fBpb=1\fP este o alegere +bună. Dacă alinierea este un număr impar, cum ar fi 3 octeți, \fBpb=0\fP ar +putea fi cea mai bună alegere. +.IP "" +Chiar dacă alinierea presupusă poate fi ajustată cu \fIpb\fP și \fIlp\fP, LZMA1 și +LZMA2 încă favorizează ușor alinierea pe 16 octeți. Ar putea fi demn de luat +în considerare atunci când proiectați formate de fișiere care pot fi adesea +comprimate cu LZMA1 sau LZMA2. +.TP +\fBmf=\fP\fImf\fP +Căutarea potrivirilor are un efect major asupra vitezei codificatorului, +utilizării memoriei și raportului de comprimare. De obicei, găsitorii de +potriviri din lanțul sumelor de control sunt mai rapizi decât găsitorii de +potriviri din arborele binar. Valoarea implicită depinde de \fIprestabilit\fP: +0 folosește \fBhc3\fP, 1\(en3 folosește \fBhc4\fP, iar restul folosește \fBbt4\fP. +.IP "" +Sunt acceptate următoarele opțiuni de căutare de potriviri. Formulele de +utilizare a memoriei de mai jos sunt aproximări estimative, care se apropie +cel mai mult de realitate atunci când \fIdict\fP este o putere a lui doi. +.RS +.TP +\fBhc3\fP +Lanț de sumă de control, cu suma de control de 2 și 3 octeți +.br +Valoarea minimă pentru \fInice\fP: 3 +.br +Utilizarea memoriei: +.br +\fIdict\fP * 7.5 (dacă \fIdict\fP <= 16 Mio); +.br +\fIdict\fP * 5.5 + 64 MiB (dacă \fIdict\fP > 16 Mio) +.TP +\fBhc4\fP +Lanț de sumă de control, cu suma de control de 2, 3 și 4 octeți +.br +Valoarea minimă pentru \fInice\fP: 4 +.br +Utilizarea memoriei: +.br +\fIdict\fP * 7.5 (dacă \fIdict\fP <= 32 Mio); +.br +\fIdict\fP * 6.5 (dacă \fIdict\fP > 32 Mio) +.TP +\fBbt2\fP +Arbore binar cu suma de control de 2 octeți +.br +Valoarea minimă pentru \fInice\fP: 2 +.br +Utilizarea memoriei: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Arbore binar cu suma de control de 2 și 3 octeți +.br +Valoarea minimă pentru \fInice\fP: 3 +.br +Utilizarea memoriei: +.br +\fIdict\fP * 11.5 (dacă \fIdict\fP <= 16 Mio); +.br +\fIdict\fP * 9.5 + 64 MiB (dacă \fIdict\fP > 16 Mio) +.TP +\fBbt4\fP +Arbore binar cu suma de control de 2, 3 și 4 octeți +.br +Valoarea minimă pentru \fInice\fP: 4 +.br +Utilizarea memoriei: +.br +\fIdict\fP * 11.5 (dacă \fIdict\fP <= 32 Mio); +.br +\fIdict\fP * 10.5 (dacă \fIdict\fP > 32 Mio) +.RE +.TP +\fBmode=\fP\fImod\fP +Comprimarea \fImod\fP specifică metoda de analiză a datelor produse de +găsitorul de potriviri. \fIModurile\fP acceptate sunt \fBfast\fP(rapid) și +\fBnormal\fP. Valoarea implicită este \fBfast\fP pentru \fIprestabiliri\fP 0\(en3 și +\fBnormal\fP pentru \fIprestabiliri\fP 4\(en9. +.IP "" +De obicei, \fBfast\fP este folosit cu instrumentele de căutare de potriviri ale +lanțului de sume de control, și \fBnormal\fP cu instrumentele de căutare de +potriviri din arborele binar. Aceasta este și ceea ce fac \fIprestabiririle\fP. +.TP +\fBnice=\fP\fInice\fP +Specifică ceea ce este considerat a fi o lungime bună(nice) pentru o +potrivire. Odată ce este găsită o potrivire de cel puțin \fInice\fP octeți, +algoritmul nu mai caută după potriviri posibile mai bune. +.IP "" +\fINice\fP poate fi de 2\(en273 octeți. Valorile mai mari tind să ofere un +raport de comprimare mai bun în detrimentul vitezei. Valoarea implicită +depinde de \fIprestabilit\fP. +.TP +\fBdepth=\fP\fIadâncimea\fP +Specifică adâncimea maximă de căutare în găsitorul de potriviri. Valoarea +implicită este valoarea specială de 0, ceea ce face ca instrumentul de +comprimare să determine o \fIadâncime\fP rezonabilă pornind de la valorile +\fImf\fP și \fInice\fP. +.IP "" +\fIAdâncimea\fP rezonabilă pentru lanțuri de sumă de control este 4\(en100 și +16\(en1000 pentru arbori binari. Folosirea unor valori foarte mari pentru +\fIadâncime\fP poate face codificatorul extrem de lent cu unele +fișiere. Evitați să stabiliți \fIadâncimea\fP la valori peste 1000, cu excepția +cazului în care sunteți pregătit să întrerupeți comprimarea în cazul în care +durează prea mult. +.RE +.IP "" +La decodificarea fluxurilor brute (\fB\-\-format=raw\fP), LZMA2 are nevoie doar +de \fIdimensiunea\fP dicționarului. LZMA1 are nevoie de asemenea de \fIlc\fP, +\fIlp\fP și \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIopțiuni\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIopțiuni\fP] +.PD +Adaugă un filtru de ramură/apel/salt (branch/call/jump ⟶ „BCJ”) la lanțul de +filtre. Aceste filtre pot fi utilizate numai ca un filtru care nu este +ultimul din lanțul de filtrare. +.IP "" +Un filtru BCJ convertește adresele relative din codul mașinii în omoloagele +lor absolute. Acest lucru nu modifică dimensiunea datelor, dar crește +redundanța, ceea ce poate ajuta LZMA2 să producă fișier \fB.xz\fP cu 0\(en15\ % +mai mic. Filtrele BCJ sunt întotdeauna reversibile, deci folosind un filtru +BCJ pentru tipul greșit de date nu provoacă nicio pierdere de date, deși +poate înrăutăți puțin raportul de comprimare. Filtrele BCJ sunt foarte +rapide și folosesc o cantitate nesemnificativă de memorie. +.IP "" +Aceste filtre BCJ au probleme cunoscute legate de raportul de comprimare: +.RS +.IP \(bu 3 +Unele tipuri de fișiere care conțin cod executabil (de exemplu, fișiere +obiect, biblioteci statice și module de kernel Linux) au adresele din +instrucțiuni completate cu valori de umplere. Aceste filtre BCJ vor face în +continuare conversia adresei, ceea ce va înrăutăți comprimarea cu aceste +fișiere. +.IP \(bu 3 +Dacă pe o arhivă este aplicat un filtru BCJ, este posibil ca raportul de +comprimare să fie mai rău decât la neutilizarea unui filtru BCJ. De exemplu, +dacă există executabile similare sau chiar identice, filtrarea va face +probabil fișierele mai puțin asemănătoare și astfel comprimarea este mai +proastă. Conținutul fișierelor neexecutabile din aceeași arhivă poate conta +și el. În practică, trebuie să încercați cu și fără filtru BCJ pentru a +vedea care rezultat este mai bun în fiecare situație. +.RE +.IP "" +Seturi de instrucțiuni diferite au o aliniere diferită: fișierul executabil +trebuie aliniat la un multiplu al acestei valori în datele de intrare pentru +ca filtrul să funcționeze. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filtru;Aliniere;Note +x86;1;x86 pe 32 de biți +;;sau 64 de biți +ARM;4; +ARM\-Thumb;2; +ARM64;4;alinierea pe 4096\-octeți +;;este cea mai bună +PowerPC;4;Doar big endian +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Deoarece datele filtrate prin BCJ sunt de obicei comprimate cu LZMA2, +raportul de comprimare poate fi ușor îmbunătățit dacă opțiunile LZMA2 sunt +definite pentru a se potrivi cu alinierea filtrului BCJ selectat. Exemple: +.RS +.IP \(bu 3 +Filtrul IA\-64 are o aliniere de 16 octeți, astfel încât \fBpb=4,lp=4,lc=0\fP +este alegere adecvată cu LZMA2 (2^4=16). +.IP \(bu 3 +Codul RISC\-V are o aliniere pe 2 sau 4 octeți, depinzând de faptul că +fișierul conține instrucțiuni comprimate pe 16 biți (extensia C) sau +nu. Atunci când se utilizează instrucțiuni pe 16 biți, \fBpb=2,lp=1,lc=3\fP sau +\fBpb=1,lp=1,lc=3\fP este o alegere bună. Atunci când nu sunt prezente +instrucțiuni pe 16 biți, \fBpb=2,lp=2,lc=2\fP este cea mai bună +alegere. \fBreadelf \-h\fP poate fi utilizată pentru a verifica dacă „RVC” apare +în linia „Indicatori". +.IP \(bu 3 +ARM64 este întotdeauna aliniat pe 4 octeți, astfel încât \fBpb=2,lp=2,lc=2\fP +este cea mai bună alegere. +.IP \(bu 3 +Filtrul x86 este o excepție. De obicei, este bine să rămâneți la valorile +implicite ale LZMA2 (\fBpb=2,lp=0,lc=3\fP) atunci când comprimați executabile +x86. +.RE +.IP "" +Toate filtrele BCJ acceptă același \fIopțiuni\fP: +.RS +.TP +\fBstart=\fP\fIpoziție\fP +Specifică \fIpoziția\fP de pornire care este utilizată la conversia între +adresele relative și absolute. \fIPoziția\fP trebuie să fie un multiplu al +alinierii filtrului (consultați tabelul de mai sus). Valoarea implicită +este zero. În practică, valoarea implicită este bună; specificarea unei +\fIpoziții\fP personalizate nu este aproape niciodată utilă. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIopțiuni\fP] +Adaugă filtrul Delta în lanțul de filtrare. Filtrul Delta poate fi folosit +doar ca un filtru care nu este ultimul în lanțul de filtrare. +.IP "" +În prezent, este acceptat doar calculul delta simplu de octeți. Poate fi +util la comprimarea, de exemplu, a imaginilor bitmap necomprimate sau a +sunetului PCM necomprimat. Cu toate acestea, algoritmii cu scop special pot +da rezultate semnificativ mai bune decât Delta + LZMA2. Acest lucru este +valabil mai ales în cazul audio, care se comprimă mai repede și mai bine, de +exemplu, cu \fBflac\fP(1). +.IP "" +\fIOpțiuni\fP acceptate: +.RS +.TP +\fBdist=\fP\fIdistanța\fP +Specifică \fIdistanța\fP calculului delta în octeți. \fIDistanța\fP trebuie să fie +1\(en256. Valoarea implicită este 1. +.IP "" +De exemplu, cu \fBdist=2\fP și intrare de opt octeți: A1 B1 A2 B3 A3 B5 A4 B7, +ieșirea va fi: A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Alte opțiuni" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Suprimă avertismentele și notificările. Specificați acest lucru de două ori +pentru a suprima și erorile. Această opțiune nu are niciun efect asupra +stării de ieșire. Adică, chiar dacă o avertizare a fost suprimată, starea de +ieșire pentru a indica o avertizare este încă utilizată. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Oferă informații detaliate. Dacă ieșirea de eroare standard este conectată +la un terminal, \fBxz\fP va afișa un indicator de progres. Specificarea +opțiunii \fB\-\-verbose\fP de două ori, va avea ca rezultat oferirea de +informații și mai detaliate. +.IP "" +Indicatorul de progres afișează următoarele informații: +.RS +.IP \(bu 3 +Procentul de completare este afișat dacă se cunoaște dimensiunea fișierului +de intrare. Adică, procentul nu poate fi afișat la procesarea fișierului +prin conducte(pipe). +.IP \(bu 3 +Cantitatea de date comprimate produse (comprimare) sau consumate +(decomprimare). +.IP \(bu 3 +Cantitatea de date necomprimate consumate (comprimare) sau produse +(decomprimare). +.IP \(bu 3 +Raportul de comprimare, care se calculează împărțind cantitatea de date +comprimate procesate până acum la cantitatea de date necomprimate procesate +până acum. +.IP \(bu 3 +Viteza de comprimare sau decomprimare. Aceasta este măsurată drept +cantitatea de date necomprimate consumate (comprimare) sau produse +(decomprimare) pe secundă. Este afișată după ce au trecut câteva secunde de +când \fBxz\fP a început procesarea fișierului. +.IP \(bu 3 +Timpul scurs în format M:SS sau H:MM:SS. +.IP \(bu 3 +Timpul rămas estimat este afișat numai atunci când dimensiunea fișierului de +intrare este cunoscută și au trecut deja câteva secunde de când \fBxz\fP a +început procesarea fișierului. Ora este afișată într\-un format mai puțin +precis, care nu are niciodată două puncte, de exemplu, 2 min 30 s. +.RE +.IP "" +Când ieșirea de eroare standard nu este un terminal, \fB\-\-verbose\fP va face +\fBxz\fP să imprime numele fișierului, dimensiunea comprimată, dimensiunea +necomprimată, raportul de comprimare și, eventual, de asemenea, viteza și +timpul scurs pe o singură linie la ieșirea de eroare standard după +comprimarea sau decomprimarea fișierului. Viteza și timpul scurs sunt +incluse numai atunci când operațiunea a durat cel puțin câteva secunde. Dacă +operațiunea nu s\-a încheiat, de exemplu, din cauza întreruperii din partea +utilizatorului, se imprimă și procentul de completare dacă se cunoaște +dimensiunea fișierului de intrare. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Nu comută starea de ieșire la 2 chiar dacă a fost detectată o condiție care +merită avertizată. Această opțiune nu afectează nivelul de detaliere al +informațiilor, astfel încât atât \fB\-\-quiet\fP cât și \fB\-\-no\-warn\fP trebuie +folosite pentru a nu afișa avertismente și pentru a nu modifica starea de +ieșire. +.TP +\fB\-\-robot\fP +Afișează mesajele într\-un format care poate fi analizat de mașină. Acest +lucru are scopul de a ușura scrierea interfețelor în care se dorește să se +folosească \fBxz\fP în loc de liblzma, ceea ce poate fi cazul cu diferite +scripturi. Ieșirea cu această opțiune activată este menită să fie stabilă în +toate versiunile \fBxz\fP. Consultați secțiunea \fBMOD ROBOT\fP pentru detalii. +.TP +\fB\-\-info\-memory\fP +Afișează, într\-un format care poate fi citit de om, câtă memorie fizică +(RAM) și câte fire de execuție de procesor \fBxz\fP crede că are sistemul și +limitele de utilizare a memoriei pentru comprimare și decomprimare și iese +cu succes. +.TP +\fB\-h\fP, \fB\-\-help\fP +Afișează un mesaj de ajutor care descrie opțiunile cele mai frecvent +utilizate și iese cu succes. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Afișează un mesaj de ajutor care descrie toate caracteristicile \fBxz\fP și +iese cu succes +.TP +\fB\-V\fP, \fB\-\-version\fP +Afișează numărul versiunii \fBxz\fP și liblzma într\-un format care poate fi +citit de om. Pentru a obține rezultate analizabile de mașină, specificați +\fB\-\-robot\fP înainte de \fB\-\-version\fP. +. +.SH "MOD ROBOT" +Modul robot este activat cu opțiunea \fB\-\-robot\fP. Face ieșirea lui \fBxz\fP mai +ușor de analizat de către alte programe. În prezent, opțiunea \fB\-\-robot\fP +este acceptată numai împreună cu opțiunile \fB\-\-list\fP, \fB\-\-filters\-help\fP, +\fB\-\-info\-memory\fP, și \fB\-\-version\fP. Va fi acceptată pentru comprimare și +decomprimare în viitor. +. +.SS "Modul listă" +\fBxz \-\-robot \-\-list\fP utilizează o ieșire separată de tabulatori. Prima +coloană a fiecărei linii are un șir care indică tipul de informații găsite +pe acea linie: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Aceasta este întotdeauna prima linie când începe să se listeze un fișier. A +doua coloană de pe linie este numele fișierului. +.TP +\fBfile\fP +Această linie conține informații generale despre fișierul \fB.xz\fP. Această +linie este întotdeauna tipărită după linia \fBname\fP. +.TP +\fBstream\fP +Acest tip de linie este utilizat numai atunci când a fost specificată +opțiunea \fB\-\-verbose\fP. Există tot atâtea linii \fBstream\fP câte fluxuri există +în fișierul \fB.xz\fP. +.TP +\fBblock\fP +Acest tip de linie este utilizat numai atunci când a fost specificată +opțiunea \fB\-\-verbose\fP. Există tot atâtea linii \fBblock\fP câte blocuri există +în fișierul \fB.xz\fP. Liniile \fBblock\fP sunt afișate după toate liniile +\fBstream\fP; tipurile diferite de linii nu sunt intercalate. +.TP +\fBsummary\fP +Acest tip de linie este folosit numai atunci când opțiunea \fB\-\-verbose\fP a +fost specificată de două ori. Această linie este afișată după toate liniile +\fBblock\fP. Ca și linia \fBfile\fP, linia \fBsummary\fP conține informații generale +despre fișierul \fB.xz\fP. +.TP +\fBtotals\fP +Această linie este întotdeauna ultima linie din lista afișată la +ieșire. Aceasta arată numărul total și dimensiunile. +.PP +Coloanele din liniile \fBfile\fP: +.PD 0 +.RS +.IP 2. 4 +Numărul de fluxuri din fișier +.IP 3. 4 +Numărul total de blocuri din fluxuri +.IP 4. 4 +Dimensiunea comprimată a fișierului +.IP 5. 4 +Dimensiunea necomprimată a fișierului +.IP 6. 4 +Raportul de comprimare, de exemplu, \fB0,123\fP. Dacă raportul este peste +9,999, în locul raportului sunt afișate trei liniuțe (\fB\-\-\-\fP). +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Lista de nume de verificare a integrității, separate prin +virgule. Următoarele șiruri sunt utilizate pentru tipurile de verificare +cunoscute: \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP și \fBSHA\-256\fP. Pentru tipurile de +verificări necunoscute, se utilizează \fBUnknown\-\fP\fIN\fP, unde \fIN\fP este ID\-ul +de verificare ca număr zecimal (una sau două cifre). +.IP 8. 4 +Dimensiunea totală a umpluturii fluxului din fișier +.RE +.PD +.PP +Coloanele din liniile \fBstream\fP: +.PD 0 +.RS +.IP 2. 4 +Numărul fluxului (primul flux este 1) +.IP 3. 4 +Numărul de blocuri din flux +.IP 4. 4 +Poziția de pornire a comprimării +.IP 5. 4 +Poziția de pornire a decomprimării +.IP 6. 4 +Dimensiune comprimată (nu include umplutura fluxului) +.IP 7. 4 +Dimensiune necomprimată +.IP 8. 4 +Raport de comprimare +.IP 9. 4 +Numele verificării de integritate +.IP 10. 4 +Dimensiunea umpluturii fluxului +.RE +.PD +.PP +Coloanele din liniile \fBblock\fP: +.PD 0 +.RS +.IP 2. 4 +Numărul fluxului care conține acest bloc +.IP 3. 4 +Numărul blocului în raport cu începutul fluxului (primul bloc este 1) +.IP 4. 4 +Numărul blocului în raport cu începutul fișierului +.IP 5. 4 +Poziția de pornire a comprimării în raport cu începutul fișierului +.IP 6. 4 +Poziția de pornire necomprimată în raport cu începutul fișierului +.IP 7. 4 +Dimensiunea totală comprimată a blocului (include antetele) +.IP 8. 4 +Dimensiune necomprimată +.IP 9. 4 +Raport de comprimare +.IP 10. 4 +Numele verificării de integritate +.RE +.PD +.PP +Dacă opțiunea \fB\-\-verbose\fP a fost specificată de două ori, coloane +suplimentare sunt incluse pe liniile \fBblock\fP. Acestea nu sunt afișate cu o +singură specificare a opțiunii \fB\-\-verbose\fP, deoarece obținerea acestor +informații necesită multe căutări și, prin urmare, poate fi lentă: +.PD 0 +.RS +.IP 11. 4 +Valoarea verificării integrității în hexazecimal +.IP 12. 4 +Dimensiunea antetului blocului +.IP 13. 4 +Indicatori de bloc: \fBc\fP indică faptul că este prezentă dimensiunea +comprimată, iar \fBu\fP indică faptul că este prezentă dimensiunea +necomprimată. Dacă indicatorul nu este determinat, este afișată o liniuță +(\fB\-\fP) pentru a menține lungimea șirului fixă. Pot fi adăugate noi +indicatoare la sfârșitul șirului, în viitor. +.IP 14. 4 +Dimensiunea datelor comprimate reale din bloc (acest lucru exclude antetul +blocului, umplutura blocului și câmpurile de verificare) +.IP 15. 4 +Cantitatea de memorie (în octeți) necesară pentru a decomprima acest bloc cu +această versiune \fBxz\fP +.IP 16. 4 +Lanț de filtrare. Rețineți că majoritatea opțiunilor utilizate în timpul +comprimării nu pot fi cunoscute, deoarece doar opțiunile necesare pentru +decomprimare sunt stocate în anteturile \fB.xz\fP. +.RE +.PD +.PP +Coloanele din liniile \fBsummary\fP: +.PD 0 +.RS +.IP 2. 4 +Cantitatea de memorie (în octeți) necesară pentru a decomprima acest fișier +cu această versiune \fBxz\fP +.IP 3. 4 +\fByes\fP sau \fBno\fP indicând dacă toate antetele blocurilor au atât dimensiunea +comprimată, cât și dimensiunea necomprimată stocate în ele +.PP +\fIÎncepând cu\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Versiunea \fBxz\fP minimă necesară pentru a decomprima fișierul +.RE +.PD +.PP +Coloanele din linia \fBtotals\fP: +.PD 0 +.RS +.IP 2. 4 +Numărul de fluxuri +.IP 3. 4 +Numărul de blocuri +.IP 4. 4 +Dimensiunea comprimată +.IP 5. 4 +Dimensiune necomprimată +.IP 6. 4 +Raportul mediu de comprimare +.IP 7. 4 +Lista de nume de verificare a integrității, separate prin virgule, care au +fost prezente în fișiere +.IP 8. 4 +Dimensiunea umpluturii fluxului +.IP 9. 4 +Numărul de fișiere. Aceasta este aici pentru a păstra ordinea coloanelor +anterioare la fel ca pe liniile \fBfile\fP. +.PD +.RE +.PP +Dacă opțiunea \fB\-\-verbose\fP a fost specificată de două ori, pe linia +\fBtotals\fP sunt incluse coloane suplimentare: +.PD 0 +.RS +.IP 10. 4 +Cantitatea maximă de memorie (în octeți) necesară pentru a decomprima +fișierele cu această versiune \fBxz\fP +.IP 11. 4 +\fByes\fP sau \fBno\fP indicând dacă toate antetele blocurilor au atât dimensiunea +comprimată, cât și dimensiunea necomprimată stocate în ele +.PP +\fIÎncepând cu\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Versiunea \fBxz\fP minimă necesară pentru a decomprima fișierul +.RE +.PD +.PP +Versiunile viitoare pot adăuga noi tipuri de linii și pot fi adăugate +coloane noi la tipurile de linii existente, dar coloanele existente nu vor +fi modificate. +. +.SS "Ajutor pentru filtrare" +\fBxz \-\-robot \-\-filters\-help\fP afișează filtrele acceptate în următorul +format: +.PP +\fIfiltru\fP\fB:\fP\fIopțiune\fP\fB=<\fP\fIvaloare\fP\fB>,\fP\fIopțiune\fP\fB=<\fP\fIvaloare\fP\fB>\fP... +.TP +\fBfiltru\fP +Numele filtrului +.TP +\fIopțiune\fP +Numele unei opțiuni specifice unui filtru +.TP +\fIvaloare\fP +Intervalele numerice \fIvaloare\fP apar ca +\fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. Alegerile \fIvaloare\fP de tip șir de +caractere sunt afișate în cadrul \fB< >\fP și separate de un caracter +\fB|\fP. +.PP +Fiecare filtru este afișat pe propria linie. +. +.SS "Informații privind limita memoriei" +\fBxz \-\-robot \-\-info\-memory\fP afișează o singură linie cu multiple coloane +separate prin tabulatoare: +.IP 1. 4 +Cantitatea totală de memorie fizică (RAM) în octeți. +.IP 2. 4 +Limita de utilizare a memoriei pentru comprimare în octeți +(\fB\-\-memlimit\-compress\fP). O valoare specială de \fB0\fP indică configurarea +implicită, care pentru modul cu un singur fir este la fel ca fără limită. +.IP 3. 4 +Limita de utilizare a memoriei pentru decomprimare în octeți +(\fB\-\-memlimit\-decompress\fP). O valoare specială de \fB0\fP indică configurarea +implicită, care pentru modul cu un singur fir este la fel ca fără limită. +.IP 4. 4 +Începând cu \fBxz\fP 5.3.4alpha: Utilizarea memoriei pentru decomprimarea cu +mai multe fire în octeți (\fB\-\-memlimit\-mt\-decompress\fP). Acesta nu este +niciodată zero, deoarece o valoare implicită specifică sistemului afișată în +coloana 5 este utilizată dacă nu a fost specificată în mod explicit nicio +limită. De asemenea, aceasta nu este niciodată mai mare decât valoarea din +coloana 3, chiar dacă a fost specificată o valoare mai mare cu +\fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Începând cu \fBxz\fP 5.3.4alpha: o limită implicită de utilizare a memoriei +specifică sistemului, care este utilizată pentru a limita numărul de fire de +execuție atunci când se comprimă cu un număr automat de fire de execuție +(\fB\-\-threads=0\fP) și nicio limită de utilizare a memoriei nu fost specificată +cu (\fB\-\-memlimit\-compress\fP). Aceasta este, de asemenea, utilizată ca valoare +implicită pentru \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Începând cu \fBxz\fP 5.3.4alpha: numărul de fire de execuție de procesor +disponibile. +.PP +În viitor, rezultatul \fBxz \-\-robot \-\-info\-memory\fP poate avea mai multe +coloane, dar niciodată mai mult de o singură linie. +. +.SS Versiunea +\fBxz \-\-robot \-\-version\fP va afișa numărul versiunii \fBxz\fP și liblzma în +următorul format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Versiunea majoră. +.TP +\fIYYY\fP +Versiunea minoră. Numerele pare sunt prezente în versiunile +stabile. Numerele impare sunt prezente în versiunile alfa sau beta. +.TP +\fIZZZ\fP +Nivelul de plasture(patch) pentru versiunile stabile sau doar un contor +pentru versiunile de dezvoltare. +.TP +\fIS\fP +Stabilitate. 0 este alfa, 1 este beta și 2 este stabil. \fIS\fP trebuie să fie +întotdeauna 2 atunci când \fIAAA\fP este par. +.PP +\fIXYYYZZZS\fP sunt aceleași pe ambele linii dacă \fBxz\fP și liblzma sunt din +aceeași versiune XZ Utils. +.PP +Exemple: 4.999.9beta este \fB49990091\fP și 5.0.0 este \fB50000002\fP. +. +.SH "STARE DE IEȘIRE" +.TP +\fB0\fP +Totul este bine. +.TP +\fB1\fP +A apărut o eroare. +.TP +\fB2\fP +A apărut ceva care merită să fie avertizat, dar nu au apărut erori reale. +.PP +Notificările (nu avertismentele sau erorile) afișate la ieșirea de eroare +standard nu afectează starea de ieșire. +. +.SH "VARIABILE DE MEDIU" +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP analizează liste de opțiuni separate prin spații din variabilele de +mediu \fBXZ_DEFAULTS\fP și \fBXZ_OPT\fP, în această ordine, înainte de a analiza +opțiunile din linia de comandă. Rețineți că numai opțiunile sunt analizate +din variabilele de mediu; toate non\-opțiunile sunt ignorate în +tăcere. Analiza se face cu funcția \fBgetopt_long\fP(3) care este folosită și +pentru argumentele liniei de comandă. +.PP +\fBAvertisment:\fP Prin definirea acestor variabile de mediu, se modifică +efectiv programele și scripturile care rulează \fBxz\fP. De cele mai multe ori +este sigur să se definească limitele de utilizare a memoriei, numărul de +fire și opțiunile de comprimare prin intermediul variabilelor de mediu. Cu +toate acestea, unele opțiuni pot întrerupe scripturile. Un exemplu evident +este \fB\-\-help\fP care face ca \fBxz\fP să afișeze textul de ajutor în loc să +comprime sau să decomprime un fișier. Exemple mai subtile sunt \fB\-\-quiet\fP și +\fB\-\-verbose\fP. În multe cazuri funcționează bine activarea indicatorului de +progres folosind \fB\-\-verbose\fP, dar în unele situații mesajele suplimentare +creează probleme. Nivelul de detaliere al mesajelor afectează, de asemenea, +comportamentul lui \fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Opțiuni implicite specifice utilizatorului sau la nivelul întregului +sistem. De obicei, acest lucru este specificat într\-un script de +inițializare shell pentru a activa limitatorul de utilizare a memoriei lui +\fBxz\fP implicit sau pentru a stabili numărul implicit de fire. Excluzând +scripturile de inițializare shell și cazurile speciale similare, scripturile +nu trebuie niciodată să modifice sau să dezactiveze \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Acest lucru este pentru transmiterea opțiunilor către \fBxz\fP atunci când nu +este posibil să definiți opțiunile direct în linia de comandă a +\fBxz\fP. Acesta este cazul când \fBxz\fP este rulat de un script sau de un +instrument, de exemplu, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Scripturile pot folosi \fBXZ_OPT\fP, de exemplu, pentru a configura opțiunile +implicite de comprimare specifice scriptului. Se recomandă totuși să se +permită utilizatorilor să înlocuiască \fBXZ_OPT\fP dacă acest lucru este +rezonabil. De exemplu, în scripturile \fBsh\fP(1) se poate folosi ceva de genul +acesta: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "COMPATIBILITATE CU LZMA\-UTILS" +Sintaxa liniei de comandă a lui \fBxz\fP este practic o super\-colecție de +\fBlzma\fP, \fBunlzma\fP și \fBlzcat\fP așa cum se găsește în LZMA Utils 4.32.x. În +cele mai multe cazuri, este posibil să înlocuiți LZMA Utils cu XZ Utils fără +a întrerupe scripturile existente. Există totuși unele incompatibilități, +care uneori pot cauza probleme. +. +.SS "Niveluri de comprimare prestabilite" +Numerotarea nivelurilor de comprimare prestabilite nu este identică în \fBxz\fP +și LZMA Utils. Cea mai importantă diferență este modul în care dimensiunile +dicționarului sunt atribuite diferitelor niveluri prestabilite. Dimensiunea +dicționarului este aproximativ egală cu memoria utilizată la decomprimare. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nivel;xz;LZMA Utils +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Diferențele de dimensiune a dicționarului afectează deasemenea cantitatea de +memorie utilizată la comprimare dar există și alte diferențe între LZMA +Utils și XZ Utils, care fac diferența și mai mare: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nivel;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Nivelul prestabilit implicit în LZMA Utils este \fB\-7\fP, în timp ce în XZ +Utils este \fB\-6\fP, deci ambele folosesc un dicționar de 8Mio în mod implicit. +. +.SS "Fișiere .lzma transmise în flux vs. netransmise în flux" +Dimensiunea necomprimată a fișierului poate fi stocată în antetul +\&\fB.lzma\fP. LZMA Utils face asta atunci când comprimă fișiere +obișnuite. Alternativa este să marcați că dimensiunea necomprimată este +necunoscută și să folosiți marcajul de sfârșit de încărcare pentru a indica +unde ar trebui să se oprească decomprimarea. LZMA Utils folosește această +metodă atunci când dimensiunea necomprimată nu este cunoscută, ceea ce este +cazul, de exemplu, când se folosesc conducte. +.PP +\fBxz\fP acceptă decomprimarea fișierelor \fB.lzma\fP cu sau fără marcaj de +sfârșit de încărcare, dar toate fișierele \fB.lzma\fP create de \fBxz\fP vor +folosi marcajul de sfârșit de încărcare și vor avea dimensiunea necomprimată +marcată ca necunoscută în antetul \fB.lzma\fP. Aceasta poate fi o problemă în +unele situații mai puțin frecvente. De exemplu, un instrument de +decomprimare \fB.lzma\fP încorporat într\-un dispozitiv poate funcționa numai cu +fișiere care au dimensiunea necomprimată cunoscută. Dacă întâmpinați această +problemă, trebuie să utilizați LZMA Utils sau LZMA SDK pentru a crea fișiere +\&\fB.lzma\fP cu dimensiunea necomprimată cunoscută. +. +.SS "Fișiere .lzma neacceptate" +Formatul \fB.lzma\fP permite valori \fIlc\fP de până la 8 și valori \fIlp\fP de până +la 4. LZMA Utils poate decomprima fișiere cu orice \fIlc\fP și \fIlp\fP, dar +creează întotdeauna fișiere cu \fBlc=3\fP și \fBlp=0\fP. Crearea de fișiere cu +alte \fIlc\fP și \fIlp\fP este posibilă cu \fBxz\fP și cu LZMA SDK. +.PP +Implementarea filtrului LZMA1 în liblzma necesită ca suma \fIlc\fP și \fIlp\fP să +nu depășească 4. Altfel, fișierele \fB.lzma\fP, care depășesc această limitare, +nu pot fi decomprimate cu \fBxz\fP. +.PP +LZMA Utils creează numai fișiere \fB.lzma\fP care au o dimensiune de dicționar +de 2^\fIn\fP (o putere de 2), dar acceptă fișiere cu orice dimensiune de +dicționar. liblzma acceptă numai fișierele \fB.lzma\fP care au dimensiunea de +dicționar de 2^\fIn\fP sau 2^\fIn\fP + 2^(\fIn\fP\-1). Acest lucru este pentru a +reduce numărul de „fals pozitiv” atunci când se detectează fișiere \fB.lzma\fP. +.PP +Aceste limitări nu ar trebui să fie o problemă în practică, deoarece practic +toate fișierele \fB.lzma\fP au fost comprimate cu opțiuni pe care liblzma le va +accepta. +. +.SS "Resturi rămase" +Când decomprimă, LZMA Utils ignoră în tăcere totul după primul flux +\&\fB.lzma\fP. În majoritatea situațiilor, aceasta este o eroare. Aceasta +înseamnă, de asemenea, că LZMA Utils nu acceptă decomprimarea fișierelor +\&\fB.lzma\fP concatenate. +.PP +Dacă au rămas date după primul flux \fB.lzma\fP, \fBxz\fP consideră că fișierul +este corupt, cu excepția cazului în care a fost utilizată opțiunea +\fB\-\-single\-stream\fP. Acest lucru poate rupe scripturile obscure(scrise +deficitar) care presupun că resturile rămase sunt ignorate. +. +.SH NOTE +. +.SS "Rezultatul comprimării poate varia" +Ieșirea exactă comprimată produsă din același fișier de intrare necomprimat +poate varia între versiunile XZ Utils, chiar dacă opțiunile de comprimare +sunt identice. Acest lucru se datorează faptului că instrumentul codificator +poate fi îmbunătățit (comprimare mai rapidă sau mai bună) fără a afecta +formatul fișierului. Ieșirea poate varia chiar și între compilările diferite +ale aceleiași versiuni XZ Utils, dacă sunt utilizate opțiuni diferite de +compilare. +.PP +Cele de mai sus înseamnă că odată ce opțiunea \fB\-\-rsyncable\fP a fost +utilizată, fișierele rezultate nu vor fi neapărat sincronizate cu rsync +decât dacă atât fișierele vechi, cât și cele noi au fost comprimate cu +aceeași versiune xz. Această problemă poate fi remediată dacă o parte a +implementării codificatorului este înghețată pentru a menține stabilă +ieșirea „rsyncabilă” între versiunile xz. +. +.SS "Instrumente de decomprimare .xz încorporate" +Implementările instrumentului de decomprimare \fB.xz\fP încorporat, cum ar fi +XZ Embedded, nu acceptă neapărat fișiere create cu tipuri de \fIverificare\fP a +integrității, altele decât \fBnone\fP și \fBcrc32\fP. Deoarece valoarea implicită +este \fB\-\-check=crc64\fP, trebuie să utilizați \fB\-\-check=none\fP sau +\fB\-\-check=crc32\fP atunci când creați fișiere pentru sistemele încorporate. +.PP +În afara sistemelor încorporate, toate instrumentele de decomprimare în +format \fB.xz\fP acceptă toate tipurile de \fIverificare\fP sau cel puțin pot +decomprima fișierul fără a efectua verificarea integrității dacă acel tip de +\fIverificare\fP nu este acceptat. +.PP +XZ Embedded acceptă filtre BCJ, dar numai cu poziție de pornire implicită. +. +.SH EXEMPLE +. +.SS Bazice +Comprimă fișierul \fIfoo\fP în \fIfoo.xz\fP folosind nivelul de comprimare +implicit (\fB\-6\fP) și elimină fișierul \fIfoo\fP dacă comprimarea are succes: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Decomprimă \fIbar.xz\fP în \fIbar\fP și nu elimină \fIbar.xz\fP chiar dacă +decomprimarea este efectuată cu succes: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Creează \fIbaz.tar.xz\fP cu nivelul prestabilit \fB\-4e\fP (\fB\-4 \-\-extreme\fP), care +este mai lent decât nivelul prestabilit implicit \fB\-6\fP, dar necesită mai +puțină memorie pentru comprimare și decomprimare (48Mio și, respectiv, +5Mio): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Un amestec de fișiere comprimate și necomprimate poate fi decomprimat la +ieșirea standard cu o singură comandă: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Comprimarea în paralel a mai multor fișiere" +În sisteme GNU și *BSD, \fBfind\fP(1) și \fBxargs\fP(1) pot fi utilizate pentru a +paraleliza comprimarea mai multor fișiere: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Opțiunea \fB\-P\fP pentru comanda \fBxargs\fP(1) stabilește numărul de procese +paralele \fBxz\fP. Cea mai bună valoare pentru opțiunea \fB\-n\fP depinde de câte +fișiere trebuie să fie comprimate. Dacă există doar câteva fișiere, valoarea +ar trebui probabil să fie 1; cu zeci de mii de fișiere, 100 sau chiar mai +mult poate să fie valoarea potrivită pentru a reduce numărul de procese +\fBxz\fP pe care \fBxargs\fP(1) le va crea în final. +.PP +Opțiunea \fB\-T1\fP pentru \fBxz\fP este acolo pentru a\-l forța să ruleze în modul +cu un singur fir de execuție, deoarece \fBxargs\fP(1) este folosit pentru a +controla cantitatea de paralelizare. +. +.SS "Modul robot" +Calculează câți octeți au fost salvați în total după comprimarea mai multor +fișiere: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Un script poate dori să afle dacă folosește o versiune \fBxz\fP suficient de +nouă. Următorul script \fBsh\fP(1) verifică dacă numărul versiunii +instrumentului \fBxz\fP este cel puțin 5.0.0. Această metodă este compatibilă +cu versiunile beta vechi, care nu acceptau opțiunea \fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Versiunea dumneavoastră de „xz” este prea veche!" +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Stabilește o limită de utilizare a memoriei pentru decomprimare folosind +variabila de mediu \fBXZ_OPT\fP, dar dacă o limită a fost deja stabilită, nu o +mărește: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Lanțuri de filtrare personalizate pentru instrumentul de comprimare" +Cea mai simplă utilizare a lanțurilor de filtrare personalizate este +personalizarea unei opțiuni prestabilite LZMA2. Acest lucru poate fi util, +deoarece opțiunile prestabilite acoperă doar un subset al combinațiilor +potențial utile de opțiuni de comprimare. +.PP +Coloanele CPUComp din tabelele de descriere a opțiunilor \fB\-0\fP ... \fB\-9\fP și +\fB\-\-extreme\fP sunt utile atunci când personalizați opțiunilor prestabilite +LZMA2. Iată părțile relevante colectate din aceste două tabele: +.RS +.PP +.TS +tab(;); +c c +n n. +ValPrestab;CPUComp +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Dacă știți că un fișier necesită un dicționar oarecum mare (de exemplu, +32Mio) pentru a se comprima bine, dar doriți să\-l comprimați mai repede +decât ar face \fBxz \-8\fP, o opțiune prestabilită cu o valoare CPUComp scăzută +(de exemplu, 1) poate fi modificată pentru a utiliza un dicționar mai mare: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Cu anumite fișiere, comanda de mai sus poate fi mai rapidă decât \fBxz \-6\fP în +timp ce comprimă semnificativ mai bine. Cu toate acestea, trebuie subliniat +că doar unele fișiere se beneficiază de un dicționar mare, păstrând în +același timp valoarea CPUComp scăzută. Cea mai evidentă situație, în care un +dicționar mare poate ajuta foarte mult, este o arhivă care conține fișiere +foarte asemănătoare de cel puțin câțiva megaocteți fiecare. Dimensiunea +dicționarului trebuie să fie semnificativ mai mare decât orice fișier +individual pentru a permite LZMA2 să profite din plin de asemănările dintre +fișierele consecutive. +.PP +Dacă utilizarea unei mari cantități de memorie pentru comprimare și +decomprimare este în regulă, iar fișierul comprimat are cel puțin câteva +sute de megaocteți, poate fi util să folosiți un dicționar și mai mare decât +cei 64Mio pe care i\-ar folosi \fBxz \-9\fP: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Utilizarea opțiunii \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) ca în exemplul de mai +sus, poate fi utilă pentru a vedea cerințele de memorie la comprimare și +decomprimare. Amintiți\-vă că utilizarea unui dicționar mai mare decât +dimensiunea fișierului necomprimat este risipă de memorie, de aceea, comanda +de mai sus nu este utilă pentru fișiere mici. +.PP +Uneori, timpul de comprimare nu contează, dar utilizarea memoriei la +decomprimare trebuie menținută la un nivel scăzut, de exemplu, pentru a face +posibilă decomprimarea fișierului pe un sistem încorporat. Următoarea +comandă folosește \fB\-6e\fP (\fB\-6 \-\-extreme\fP) ca bază și fixează dimensiunea +dicționarului la doar 64Kio. Fișierul rezultat poate fi decomprimat cu XZ +Embedded (de aceea există \fB\-\-check=crc32\fP) folosind aproximativ 100Kio de +memorie. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Dacă doriți să stoarceți cât mai mulți octeți posibil, ajustarea numărului +de biți de context literal (\fIlc\fP) și a numărului de biți de poziție (\fIpb\fP) +poate ajuta uneori. Ajustarea numărului de biți de poziție literală (\fIlp\fP) +ar putea ajuta, de asemenea, dar de obicei \fIlc\fP și \fIpb\fP sunt mai +importante. De exemplu, o arhivă de cod sursă conține în mare parte text +US\-ASCII, așa că ceva precum comanda următoare, ar putea oferi un fișier +„mai slăbuț” (aproximativ cu 0,1%) mai mic decât cu \fBxz \-6e\fP (încercați și +fără \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 fișierul_sursă.tar\fR +.fi +.RE +.PP +Utilizarea unui alt filtru împreună cu LZMA2 poate îmbunătăți comprimarea cu +anumite tipuri de fișiere. De exemplu, pentru a comprima o bibliotecă +partajată x86 pe 32 de biți sau x86 pe 64 de biți folosind filtrul BCJ x86: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Rețineți că ordinea opțiunilor de filtrare este semnificativă. Dacă \fB\-\-x86\fP +este specificată după \fB\-\-lzma2\fP, \fBxz\fP va da o eroare, deoarece nu poate +exista niciun filtru după LZMA2 și, de asemenea, pentru că filtrul x86 BCJ +nu poate fi utilizat ca ultimul filtru din lanțul de filtrare. +.PP +Filtrul Delta împreună cu LZMA2 pot da rezultate bune cu imagini bitmap. De +obicei, ar trebui să întreacă comprimarea PNG, care are câteva filtre mai +avansate decât delta simplă, dar utilizează Deflate pentru comprimarea +reală. +.PP +Imaginea trebuie să fie salvată în format necomprimat, de exemplu, ca TIFF +necomprimat. Parametrul de distanță al filtrului Delta este fixat să se +potrivească cu numărul de octeți per pixel din imagine. De exemplu, +bitmap\-ul RGB pe 24 de biți necesită \fBdist=3\fP și este, de asemenea, bine să +pasați \fBpb=0\fP la LZMA2 pentru a se adapta alinierii pe trei octeți: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Dacă mai multe imagini au fost introduse într\-o singură arhivă (de exemplu, +\&\fB.tar\fP), filtrul Delta va funcționa și pe aceasta atâta timp cât toate +imaginile au același număr de octeți per pixel. +. +.SH "CONSULTAȚI ȘI" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzcmp.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzcmp.1 new file mode 100644 index 0000000000000000000000000000000000000000..cebad3bb3ad049a59a6f1d29360d76fa73a915e4 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzcmp.1 @@ -0,0 +1,70 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Romanian translation for xz-man. +.\" Mesajele în limba română pentru manualul pachetului XZ Utils. +.\" Remus-Gabriel Chelu , 2022 - 2025. +.\" Cronologia traducerii fișierului „xz-man”: +.\" Traducerea inițială, făcută de R-GC, pentru versiunea xz-man 5.4.0-pre1. +.\" Actualizare a traducerii pentru versiunea 5.4.0-pre2, făcută de R-GC, dec-2022. +.\" Actualizare a traducerii pentru versiunea 5.4.3, făcută de R-GC, mai-2023. +.\" Actualizare a traducerii pentru versiunea 5.4.4-pre1, făcută de R-GC, iul-2023. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre1, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre2, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.7.1-dev1, făcută de R-GC, ian-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.0-pre1, făcută de R-GC, mar-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.2-pre1, făcută de R-GC, oct-2025. +.\" Actualizare a traducerii pentru versiunea Y, făcută de X, Z(luna-anul). +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 "6 martie 2025" Tukaani "Utilități XZ" +.SH NUME +xzcmp, xzdiff, lzcmp, lzdiff \- compară fișierele comprimate +. +.SH REZUMAT +\fBxzcmp\fP [\fIopțiune...\fP] \fIfișier1\fP [\fIfișier2\fP] +.br +\fBxzdiff\fP \&... +.br +\fBlzcmp\fP \&... (DEPRECIATĂ) +.br +\fBlzdiff\fP \&... (DEPRECIATĂ) +. +.SH DESCRIERE +\fBxzcmp\fP și \fBxzdiff\fP compară conținutul necomprimat a două fișiere. Datele +necomprimate și opțiunile sunt transmise la \fBcmp\fP(1) sau \fBdiff\fP(1), cu +excepția cazului în care se specifică \fB\-\-help\fP sau \fB\-\-version\fP. +.PP +Dacă sunt specificate atât \fIfișier1\fP, cât și \fIfișier2\fP, acestea pot fi +fișiere necomprimate sau fișiere în formate pe care \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) sau \fBlz4\fP(1) le poate +decomprima. Comenzile de decomprimare necesare sunt determinate de sufixele +numelor de fișiere \fIfișier1\fP și \fIfișier2\fP. Se presupune că un fișier cu un +sufix necunoscut este fie necomprimat, fie într\-un format pe care \fBxz\fP(1) +îl poate decomprima. +.PP +În cazul în care se furnizează un singur nume de fișier, \fIfișier1\fP trebuie +să aibă un sufix al unui format de comprimare acceptat, iar numele pentru +\fIfișier2\fP se presupune că este \fIfișier1\fP fără sufixul formatului de +comprimare. +.PP +Comenzile \fBlzcmp\fP și \fBlzdiff\fP sunt furnizate pentru compatibilitate +retroactivă cu LZMA Utils. Acestea sunt depreciate și vor fi eliminate +într\-o versiune viitoare. +. +.SH "STARE DE IEȘIRE" +În cazul în care apare o eroare de decomprimare, starea de ieșire este +\fB2\fP. În caz contrar, se utilizează starea de ieșire \fBcmp\fP(1) sau +\fBdiff\fP(1). +. +.SH "CONSULTAȚI ȘI" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzdiff.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzdiff.1 new file mode 100644 index 0000000000000000000000000000000000000000..cebad3bb3ad049a59a6f1d29360d76fa73a915e4 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzdiff.1 @@ -0,0 +1,70 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Romanian translation for xz-man. +.\" Mesajele în limba română pentru manualul pachetului XZ Utils. +.\" Remus-Gabriel Chelu , 2022 - 2025. +.\" Cronologia traducerii fișierului „xz-man”: +.\" Traducerea inițială, făcută de R-GC, pentru versiunea xz-man 5.4.0-pre1. +.\" Actualizare a traducerii pentru versiunea 5.4.0-pre2, făcută de R-GC, dec-2022. +.\" Actualizare a traducerii pentru versiunea 5.4.3, făcută de R-GC, mai-2023. +.\" Actualizare a traducerii pentru versiunea 5.4.4-pre1, făcută de R-GC, iul-2023. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre1, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre2, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.7.1-dev1, făcută de R-GC, ian-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.0-pre1, făcută de R-GC, mar-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.2-pre1, făcută de R-GC, oct-2025. +.\" Actualizare a traducerii pentru versiunea Y, făcută de X, Z(luna-anul). +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 "6 martie 2025" Tukaani "Utilități XZ" +.SH NUME +xzcmp, xzdiff, lzcmp, lzdiff \- compară fișierele comprimate +. +.SH REZUMAT +\fBxzcmp\fP [\fIopțiune...\fP] \fIfișier1\fP [\fIfișier2\fP] +.br +\fBxzdiff\fP \&... +.br +\fBlzcmp\fP \&... (DEPRECIATĂ) +.br +\fBlzdiff\fP \&... (DEPRECIATĂ) +. +.SH DESCRIERE +\fBxzcmp\fP și \fBxzdiff\fP compară conținutul necomprimat a două fișiere. Datele +necomprimate și opțiunile sunt transmise la \fBcmp\fP(1) sau \fBdiff\fP(1), cu +excepția cazului în care se specifică \fB\-\-help\fP sau \fB\-\-version\fP. +.PP +Dacă sunt specificate atât \fIfișier1\fP, cât și \fIfișier2\fP, acestea pot fi +fișiere necomprimate sau fișiere în formate pe care \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) sau \fBlz4\fP(1) le poate +decomprima. Comenzile de decomprimare necesare sunt determinate de sufixele +numelor de fișiere \fIfișier1\fP și \fIfișier2\fP. Se presupune că un fișier cu un +sufix necunoscut este fie necomprimat, fie într\-un format pe care \fBxz\fP(1) +îl poate decomprima. +.PP +În cazul în care se furnizează un singur nume de fișier, \fIfișier1\fP trebuie +să aibă un sufix al unui format de comprimare acceptat, iar numele pentru +\fIfișier2\fP se presupune că este \fIfișier1\fP fără sufixul formatului de +comprimare. +.PP +Comenzile \fBlzcmp\fP și \fBlzdiff\fP sunt furnizate pentru compatibilitate +retroactivă cu LZMA Utils. Acestea sunt depreciate și vor fi eliminate +într\-o versiune viitoare. +. +.SH "STARE DE IEȘIRE" +În cazul în care apare o eroare de decomprimare, starea de ieșire este +\fB2\fP. În caz contrar, se utilizează starea de ieșire \fBcmp\fP(1) sau +\fBdiff\fP(1). +. +.SH "CONSULTAȚI ȘI" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzegrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzegrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..fc411dfa1f83b5dfc4fa390829a8be970e426b47 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzegrep.1 @@ -0,0 +1,107 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Romanian translation for xz-man. +.\" Mesajele în limba română pentru manualul pachetului XZ Utils. +.\" Remus-Gabriel Chelu , 2022 - 2025. +.\" Cronologia traducerii fișierului „xz-man”: +.\" Traducerea inițială, făcută de R-GC, pentru versiunea xz-man 5.4.0-pre1. +.\" Actualizare a traducerii pentru versiunea 5.4.0-pre2, făcută de R-GC, dec-2022. +.\" Actualizare a traducerii pentru versiunea 5.4.3, făcută de R-GC, mai-2023. +.\" Actualizare a traducerii pentru versiunea 5.4.4-pre1, făcută de R-GC, iul-2023. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre1, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre2, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.7.1-dev1, făcută de R-GC, ian-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.0-pre1, făcută de R-GC, mar-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.2-pre1, făcută de R-GC, oct-2025. +.\" Actualizare a traducerii pentru versiunea Y, făcută de X, Z(luna-anul). +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 "6 martie 2025" Tukaani "Utilități XZ" +.SH NUME +xzgrep \- caută modele în fișiere posibil comprimate +. +.SH REZUMAT +\fBxzgrep\fP [\fIopțiune...\fP] \fIlistă\-modele\fP [\fIfișier...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (DEPRECIATĂ) +.br +\fBlzegrep\fP \&... (DEPRECIATĂ) +.br +\fBlzfgrep\fP \&... (DEPRECIATĂ) +. +.SH DESCRIERE +\fBxzgrep\fP invocă \fBgrep\fP(1) asupra conținutului necomprimat al +fișierelor. Formatele \fIfișierelor\fP sunt determinate de sufixele numelor de +fișiere. Orice \fIfișier\fP cu un sufix acceptat de \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) sau \fBlz4\fP(1) va fi decomprimat; toate +celelalte fișiere sunt presupuse a fi necomprimate. +.PP +Dacă nu se specifică niciun \fIfișier\fP sau dacă \fIfișier\fP este \fB\-\fP, se +citește intrarea standard. Atunci când se citește de la intrarea standard, +sunt decomprimate numai fișierele acceptate de \fBxz\fP(1). Se presupune că +celelalte fișiere sunt deja în format necomprimat. +.PP +Sunt acceptate majoritatea \fIopțiunilor\fP din \fBgrep\fP(1). Cu toate acestea, +următoarele opțiuni nu sunt acceptate: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIacțiune\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglobal\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglobal\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIfișier\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglobal\fP +.PP +\fBxzegrep\fP este un alias pentru \fBxzgrep \-E\fP. \fBxzfgrep\fP este un alias +pentru \fBxzgrep \-F\fP. +.PP +Comenzile \fBlzgrep\fP, \fBlzegrep\fP și \fBlzfgrep\fP sunt furnizate pentru +compatibilitate retroactivă cu LZMA Utils. Acestea sunt depreciate și vor fi +eliminate într\-o versiune viitoare. +. +.SH "STARE DE IEȘIRE" +.TP +0 +A fost găsită cel puțin o potrivire din cel puțin unul dintre fișierele de +la intrare. Nu au apărut erori. +.TP +1 +Nu au fost găsite potriviri din niciunul dintre fișierele de la intrare. Nu +au apărut erori. +.TP +>1 +A apărut una sau mai multe erori. Nu se cunoaște dacă au fost găsite +potriviri. +. +.SH "VARIABILE DE MEDIU" +.TP +\fBGREP\fP +Dacă variabila de mediu \fBGREP\fP este stabilită la o valoare nevidă, aceasta +este utilizată în locul lui \fBgrep\fP, \fBgrep \-E\fP sau \fBgrep \-F\fP. +. +.SH "CONSULTAȚI ȘI" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzfgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzfgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..fc411dfa1f83b5dfc4fa390829a8be970e426b47 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzfgrep.1 @@ -0,0 +1,107 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Romanian translation for xz-man. +.\" Mesajele în limba română pentru manualul pachetului XZ Utils. +.\" Remus-Gabriel Chelu , 2022 - 2025. +.\" Cronologia traducerii fișierului „xz-man”: +.\" Traducerea inițială, făcută de R-GC, pentru versiunea xz-man 5.4.0-pre1. +.\" Actualizare a traducerii pentru versiunea 5.4.0-pre2, făcută de R-GC, dec-2022. +.\" Actualizare a traducerii pentru versiunea 5.4.3, făcută de R-GC, mai-2023. +.\" Actualizare a traducerii pentru versiunea 5.4.4-pre1, făcută de R-GC, iul-2023. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre1, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre2, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.7.1-dev1, făcută de R-GC, ian-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.0-pre1, făcută de R-GC, mar-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.2-pre1, făcută de R-GC, oct-2025. +.\" Actualizare a traducerii pentru versiunea Y, făcută de X, Z(luna-anul). +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 "6 martie 2025" Tukaani "Utilități XZ" +.SH NUME +xzgrep \- caută modele în fișiere posibil comprimate +. +.SH REZUMAT +\fBxzgrep\fP [\fIopțiune...\fP] \fIlistă\-modele\fP [\fIfișier...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (DEPRECIATĂ) +.br +\fBlzegrep\fP \&... (DEPRECIATĂ) +.br +\fBlzfgrep\fP \&... (DEPRECIATĂ) +. +.SH DESCRIERE +\fBxzgrep\fP invocă \fBgrep\fP(1) asupra conținutului necomprimat al +fișierelor. Formatele \fIfișierelor\fP sunt determinate de sufixele numelor de +fișiere. Orice \fIfișier\fP cu un sufix acceptat de \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) sau \fBlz4\fP(1) va fi decomprimat; toate +celelalte fișiere sunt presupuse a fi necomprimate. +.PP +Dacă nu se specifică niciun \fIfișier\fP sau dacă \fIfișier\fP este \fB\-\fP, se +citește intrarea standard. Atunci când se citește de la intrarea standard, +sunt decomprimate numai fișierele acceptate de \fBxz\fP(1). Se presupune că +celelalte fișiere sunt deja în format necomprimat. +.PP +Sunt acceptate majoritatea \fIopțiunilor\fP din \fBgrep\fP(1). Cu toate acestea, +următoarele opțiuni nu sunt acceptate: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIacțiune\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglobal\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglobal\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIfișier\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglobal\fP +.PP +\fBxzegrep\fP este un alias pentru \fBxzgrep \-E\fP. \fBxzfgrep\fP este un alias +pentru \fBxzgrep \-F\fP. +.PP +Comenzile \fBlzgrep\fP, \fBlzegrep\fP și \fBlzfgrep\fP sunt furnizate pentru +compatibilitate retroactivă cu LZMA Utils. Acestea sunt depreciate și vor fi +eliminate într\-o versiune viitoare. +. +.SH "STARE DE IEȘIRE" +.TP +0 +A fost găsită cel puțin o potrivire din cel puțin unul dintre fișierele de +la intrare. Nu au apărut erori. +.TP +1 +Nu au fost găsite potriviri din niciunul dintre fișierele de la intrare. Nu +au apărut erori. +.TP +>1 +A apărut una sau mai multe erori. Nu se cunoaște dacă au fost găsite +potriviri. +. +.SH "VARIABILE DE MEDIU" +.TP +\fBGREP\fP +Dacă variabila de mediu \fBGREP\fP este stabilită la o valoare nevidă, aceasta +este utilizată în locul lui \fBgrep\fP, \fBgrep \-E\fP sau \fBgrep \-F\fP. +. +.SH "CONSULTAȚI ȘI" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..fc411dfa1f83b5dfc4fa390829a8be970e426b47 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzgrep.1 @@ -0,0 +1,107 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Romanian translation for xz-man. +.\" Mesajele în limba română pentru manualul pachetului XZ Utils. +.\" Remus-Gabriel Chelu , 2022 - 2025. +.\" Cronologia traducerii fișierului „xz-man”: +.\" Traducerea inițială, făcută de R-GC, pentru versiunea xz-man 5.4.0-pre1. +.\" Actualizare a traducerii pentru versiunea 5.4.0-pre2, făcută de R-GC, dec-2022. +.\" Actualizare a traducerii pentru versiunea 5.4.3, făcută de R-GC, mai-2023. +.\" Actualizare a traducerii pentru versiunea 5.4.4-pre1, făcută de R-GC, iul-2023. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre1, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre2, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.7.1-dev1, făcută de R-GC, ian-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.0-pre1, făcută de R-GC, mar-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.2-pre1, făcută de R-GC, oct-2025. +.\" Actualizare a traducerii pentru versiunea Y, făcută de X, Z(luna-anul). +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 "6 martie 2025" Tukaani "Utilități XZ" +.SH NUME +xzgrep \- caută modele în fișiere posibil comprimate +. +.SH REZUMAT +\fBxzgrep\fP [\fIopțiune...\fP] \fIlistă\-modele\fP [\fIfișier...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (DEPRECIATĂ) +.br +\fBlzegrep\fP \&... (DEPRECIATĂ) +.br +\fBlzfgrep\fP \&... (DEPRECIATĂ) +. +.SH DESCRIERE +\fBxzgrep\fP invocă \fBgrep\fP(1) asupra conținutului necomprimat al +fișierelor. Formatele \fIfișierelor\fP sunt determinate de sufixele numelor de +fișiere. Orice \fIfișier\fP cu un sufix acceptat de \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) sau \fBlz4\fP(1) va fi decomprimat; toate +celelalte fișiere sunt presupuse a fi necomprimate. +.PP +Dacă nu se specifică niciun \fIfișier\fP sau dacă \fIfișier\fP este \fB\-\fP, se +citește intrarea standard. Atunci când se citește de la intrarea standard, +sunt decomprimate numai fișierele acceptate de \fBxz\fP(1). Se presupune că +celelalte fișiere sunt deja în format necomprimat. +.PP +Sunt acceptate majoritatea \fIopțiunilor\fP din \fBgrep\fP(1). Cu toate acestea, +următoarele opțiuni nu sunt acceptate: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIacțiune\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglobal\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglobal\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIfișier\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglobal\fP +.PP +\fBxzegrep\fP este un alias pentru \fBxzgrep \-E\fP. \fBxzfgrep\fP este un alias +pentru \fBxzgrep \-F\fP. +.PP +Comenzile \fBlzgrep\fP, \fBlzegrep\fP și \fBlzfgrep\fP sunt furnizate pentru +compatibilitate retroactivă cu LZMA Utils. Acestea sunt depreciate și vor fi +eliminate într\-o versiune viitoare. +. +.SH "STARE DE IEȘIRE" +.TP +0 +A fost găsită cel puțin o potrivire din cel puțin unul dintre fișierele de +la intrare. Nu au apărut erori. +.TP +1 +Nu au fost găsite potriviri din niciunul dintre fișierele de la intrare. Nu +au apărut erori. +.TP +>1 +A apărut una sau mai multe erori. Nu se cunoaște dacă au fost găsite +potriviri. +. +.SH "VARIABILE DE MEDIU" +.TP +\fBGREP\fP +Dacă variabila de mediu \fBGREP\fP este stabilită la o valoare nevidă, aceasta +este utilizată în locul lui \fBgrep\fP, \fBgrep \-E\fP sau \fBgrep \-F\fP. +. +.SH "CONSULTAȚI ȘI" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzless.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzless.1 new file mode 100644 index 0000000000000000000000000000000000000000..9bd9b2c296d7b6921c54b05a3508a9b2dd281db7 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzless.1 @@ -0,0 +1,60 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" Romanian translation for xz-man. +.\" Mesajele în limba română pentru manualul pachetului XZ Utils. +.\" Remus-Gabriel Chelu , 2022 - 2025. +.\" Cronologia traducerii fișierului „xz-man”: +.\" Traducerea inițială, făcută de R-GC, pentru versiunea xz-man 5.4.0-pre1. +.\" Actualizare a traducerii pentru versiunea 5.4.0-pre2, făcută de R-GC, dec-2022. +.\" Actualizare a traducerii pentru versiunea 5.4.3, făcută de R-GC, mai-2023. +.\" Actualizare a traducerii pentru versiunea 5.4.4-pre1, făcută de R-GC, iul-2023. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre1, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre2, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.7.1-dev1, făcută de R-GC, ian-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.0-pre1, făcută de R-GC, mar-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.2-pre1, făcută de R-GC, oct-2025. +.\" Actualizare a traducerii pentru versiunea Y, făcută de X, Z(luna-anul). +.\" +.\" (Note that this file is not based on gzip's zless.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZLESS 1 "6 martie 2025" Tukaani "Utilități XZ" +.SH NUME +xzless, lzless \- vizualizează fișierele (text) comprimate xz sau lzma +.SH REZUMAT +\fBxzless\fP [\fIfișier\fP...] +.br +\fBlzless\fP [\fIfișier\fP...] (DEPRECIATĂ) +.SH DESCRIERE +\fBxzless\fP este un filtru care afișează textul din fișierele comprimate pe un +terminal. Fișierele acceptate de \fBxz\fP(1) sunt decomprimate; se presupune că +celelalte fișiere sunt deja în format necomprimat. Dacă nu se dă nici un +\fIfișier\fP, \fBxzless\fP citește de la intrarea standard. +.PP +\fBxzless\fP folosește \fBless\fP(1) pentru a\-și prezenta rezultatul. Spre +deosebire de \fBxzmore\fP, alegerea sa de pager nu poate fi modificată prin +definirea unei variabile de mediu. Comenzile se bazează atât pe \fBmore\fP(1) +cât și pe \fBvi\fP(1) și permit mișcarea înainte și înapoi și +căutarea. Consultați manualul \fBless\fP(1) pentru mai multe informații. +.PP +Comanda numită \fBlzless\fP este furnizată pentru compatibilitatea cu LZMA +Utils. Aceasta este depreciată și va fi eliminată într\-o versiune viitoare. +.SH "VARIABILE DE MEDIU" +.TP +\fBLESSMETACHARS\fP +O listă de caractere speciale pentru shell. Definită de \fBxzless\fP, cu +excepția cazului în care este deja definită în mediu. +.TP +\fBLESSOPEN\fP +Aceasta este definită în linia de comandă pentru a invoca instrumentul de +decomprimare \fBxz\fP(1) pentru preprocesarea fișierelor de intrare pentru +\fBless\fP(1). +.SH "CONSULTAȚI ȘI" +\fBless\fP(1), \fBxz\fP(1), \fBxzmore\fP(1), \fBzless\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzma.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzma.1 new file mode 100644 index 0000000000000000000000000000000000000000..1555445592944b4f24e548fc0dc0b1c3af876030 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzma.1 @@ -0,0 +1,2111 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Romanian translation for xz-man. +.\" Mesajele în limba română pentru manualul pachetului XZ Utils. +.\" Remus-Gabriel Chelu , 2022 - 2025. +.\" Cronologia traducerii fișierului „xz-man”: +.\" Traducerea inițială, făcută de R-GC, pentru versiunea xz-man 5.4.0-pre1. +.\" Actualizare a traducerii pentru versiunea 5.4.0-pre2, făcută de R-GC, dec-2022. +.\" Actualizare a traducerii pentru versiunea 5.4.3, făcută de R-GC, mai-2023. +.\" Actualizare a traducerii pentru versiunea 5.4.4-pre1, făcută de R-GC, iul-2023. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre1, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre2, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.7.1-dev1, făcută de R-GC, ian-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.0-pre1, făcută de R-GC, mar-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.2-pre1, făcută de R-GC, oct-2025. +.\" Actualizare a traducerii pentru versiunea Y, făcută de X, Z(luna-anul). +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 "8 martie 2025" Tukaani "Utilități XZ" +. +.SH NUME +xz, unxz, xzcat, lzma, unlzma, lzcat \- Comprimă sau decomprimă fișiere .xz +și .lzma +. +.SH REZUMAT +\fBxz\fP [\fIopțiune...\fP] [\fIfișier...\fP] +. +.SH "ALIAS COMENZI" +\fBunxz\fP este echivalent cu \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP este echivalent cu \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP este echivalent cu \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP este echivalent cu \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP este echivalent cu \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Când scrieți scripturi care trebuie să decomprime fișiere, este recomandat +să folosiți întotdeauna comanda \fBxz\fP cu argumentele adecvate (\fBxz \-d\fP sau +\fBxz \-dc\fP) în loc de comenzile \fBunxz\fP și \fBxzcat\fP. +. +.SH DESCRIERE +\fBxz\fP este un instrument de comprimare a datelor de uz general cu sintaxă de +linie de comandă similară cu \fBgzip\fP(1) și \fBbzip2\fP(1). Formatul de fișier +nativ este formatul \fB.xz\fP, dar formatul vechi \fB.lzma\fP folosit de LZMA +Utils și fluxurile comprimate brute fără anteturi de format container sunt +de asemenea acceptate. În plus, este acceptată decomprimarea formatului +\&\fB.lz\fP folosit de \fBlzip\fP. +.PP +\fBxz\fP comprimă sau decomprimă fiecare \fIfișier\fP în funcție de modul de +operare selectat. Dacă nu sunt date \fIfișiere\fP sau \fIfișier\fP este \fB\-\fP, +\fBxz\fP citește de la intrarea standard și scrie datele procesate la ieșirea +standard. \fBxz\fP va refuza (afișează o eroare și omite \fIfișier\fP) să scrie +date comprimate la ieșirea standard dacă este un terminal. În mod similar, +\fBxz\fP va refuza să citească datele comprimate de la intrarea standard dacă +este un terminal. +.PP +Cu excepția cazului în care este specificată opțiunea \fB\-\-stdout\fP, +\fIfișierele\fP altele decât \fB\-\fP sunt scrise într\-un fișier nou al cărui nume +este derivat din numele \fIfișierului\fP sursă: +.IP \(bu 3 +La comprimare, sufixul formatului de fișier țintă (\fB.xz\fP sau \fB.lzma\fP) este +atașat la numele fișierului sursă pentru a se obține numele fișierului +țintă. +.IP \(bu 3 +La decomprimare, sufixul \fB.xz\fP, \fB.lzma\fP sau \fB.lz\fP este eliminat din +numele fișierului pentru a se obține numele fișierului țintă. \fBxz\fP +recunoaște și sufixele \fB.txz\fP și \fB.tlz\fP și le înlocuiește cu sufixul +\&\fB.tar\fP. +.PP +Dacă fișierul țintă există deja, este afișată o eroare și \fIfișier\fP este +omis. +.PP +Cu excepția cazului în care scrie la ieșirea standard, \fBxz\fP va afișa un +avertisment și va omite \fIfișier\fPul dacă se aplică oricare dintre +următoarele: +.IP \(bu 3 +\fIFișierul\fP nu este un fișier obișnuit. Legăturile simbolice nu sunt urmate +și, prin urmare, nu sunt considerate fișiere obișnuite. +.IP \(bu 3 +\fIFișierul\fP are mai mult de o legătură dură. +.IP \(bu 3 +\fIFișierul\fP are activat bitul «setuid», «setgid» sau cel lipicios(sticky). +.IP \(bu 3 +Modul de operare este stabilit la comprimare și \fIfișier\fP are deja un sufix +al formatului de fișier țintă (\fB.xz\fP sau \fB.txz\fP când se comprimă în +formatul \fB.xz\fP și \fB.lzma\fP sau \fB.tlz\fP când se comprimă în formatul +\&\fB.lzma\fP). +.IP \(bu 3 +Modul de operare este stabilit la decomprimare și \fIfișierul\fP nu are un +sufix al niciunui format de fișier acceptat (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, +\&\fB.tlz\fP, sau \fB.lz\fP). +.PP +După comprimarea sau decomprimarea cu succes a \fIfișierului\fP, \fBxz\fP copiază +proprietarul, grupul, permisiunile, timpul de acces și timpul de modificare +din \fIfișierul\fP sursă în fișierul țintă. Dacă copierea grupului eșuează, +permisiunile sunt modificate astfel încât fișierul țintă să nu devină +accesibil utilizatorilor care nu aveau permisiunea de a accesa \fIfișierul\fP +sursă. \fBxz\fP nu acceptă încă copierea altor metadate, cum ar fi listele de +control al accesului sau atributele extinse. +.PP +Odată ce fișierul țintă a fost închis cu succes, \fIfișierul\fP sursă este +eliminat dacă nu a fost specificată opțiunea \fB\-\-keep\fP. \fIFișierul\fP sursă nu +este niciodată eliminat dacă rezultatul este scris la ieșirea standard sau +dacă apare o eroare. +.PP +Trimiterea unui semnal \fBSIGINFO\fP sau \fBSIGUSR1\fP către procesul \fBxz\fP face +ca acesta să imprime informații despre progres la ieșirea de eroare +standard. Acest lucru are o utilizare limitată, deoarece atunci când ieșirea +de eroare standard este un terminal, folosind opțiunea \fB\-\-verbose\fP va afișa +un indicator de progres de actualizare automată. +. +.SS "Utilizarea memoriei" +Cantitatea de memorie utilizată de \fBxz\fP variază de la câteva sute de +kiloocteți la câțiva gigaocteți, în funcție de opțiunile de +comprimare. Opțiunile utilizate la comprimarea unui fișier determină +cerințele de memorie ale instrumentului de decomprimare. De obicei, +instrumentul de decomprimare are nevoie de 5% până la 20% din cantitatea de +memorie de care a avut nevoie instrumentul de comprimare la crearea +fișierului. De exemplu, decomprimarea unui fișier creat cu \fBxz \-9\fP necesită +în prezent 65Mio de memorie. Totuși, este posibil să aveți fișiere \fB.xz\fP +care necesită câțiva gigaocteți de memorie pentru decomprimare. +.PP +În special utilizatorii de sisteme mai vechi pot considera deranjantă +posibilitatea unei utilizări foarte mari a memoriei. Pentru a preveni +surprizele neplăcute, \fBxz\fP are încorporat un limitator de utilizare a +memoriei, care este dezactivat implicit. În timp ce unele sisteme de operare +oferă modalități de a limita utilizarea memoriei proceselor, bazarea pe +aceasta nu a fost considerată a fi suficient de flexibilă (de exemplu, +utilizarea \fBulimit\fP(1) pentru a limita memoria virtuală tinde să paralizeze +\fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Limitatorul de utilizare a memoriei poate fi activat cu opțiunea din linia +de comandă \fB\-\-memlimit=\fP\fIlimita\fP. Adesea este mai convenabil să activați +limitatorul în mod implicit prin definirea variabilei de mediu +\fBXZ_DEFAULTS\fP, de exemplu, \fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Este posibil +să stabiliți limitele separat pentru comprimare și decomprimare folosind +\fB\-\-memlimit\-compress=\fP\fIlimita\fP și +\fB\-\-memlimit\-decompress=\fP\fIlimita\fP. Utilizarea acestor două opțiuni în afara +\fBXZ_DEFAULTS\fP este foarte rar utilă, deoarece o singură rulare a \fBxz\fP nu +poate face atât comprimarea, cât și decomprimarea și \fB\-\-memlimit=\fP\fIlimita\fP +(sau \fB\-M\fP \fIlimita\fP ) este mai scurt de tastat pe linia de comandă. +.PP +Dacă limita de utilizare a memoriei specificată este depășită la +decomprimare, \fBxz\fP va afișa o eroare și decomprimarea fișierului va +eșua. Dacă limita este depășită la comprimare, \fBxz\fP va încerca să reducă +valorile stabilite astfel încât limita să nu mai fie depășită (cu excepția +cazului în care se utilizează opțiunea \fB\-\-format=raw\fP sau +\fB\-\-no\-adjust\fP). În acest fel, operațiunea nu va eșua decât dacă limita +stabilită este foarte mică. Scalarea valorilor stabilite se face în pași +care nu se potrivesc cu valorile prestabilite ale nivelului de comprimare, +de exemplu, dacă limita este doar puțin mai mică decât cantitatea necesară +pentru \fBxz \-9\fP, valorile stabilite vor fi reduse doar puțin , nu până la +valoarea prestabilită a lui \fBxz \-8\fP. +. +.SS "Concatenare și completare (prin umplere cu octeți nuli) cu fișiere .xz" +Este posibil să concatenați fișierele \fB.xz\fP așa cum sunt. \fBxz\fP va +decomprima astfel de fișiere ca și cum ar fi un singur fișier \fB.xz\fP. +.PP +Este posibil să se introducă umplutură între părțile concatenate sau după +ultima parte. Umplutura trebuie să fie compusă din octeți nuli, iar +dimensiunea umpluturii trebuie să fie un multiplu de patru octeți. Acest +lucru poate fi util, de exemplu, dacă fișierul \fB.xz\fP este stocat pe un +mediu care măsoară dimensiunile fișierelor în blocuri de 512 de octeți. +.PP +Concatenarea și completarea nu sunt permise cu fișierele \fB.lzma\fP sau +fluxurile brute. +. +.SH OPȚIUNI +. +.SS "Sufixe de numere întregi și valori speciale" +În majoritatea locurilor în care este de așteptat un număr întreg ca +argument, un sufix opțional este acceptat pentru a indica cu ușurință +numerele întregi mari. Nu trebuie să existe spațiu între numărul întreg și +sufix. +.TP +\fBKiB\fP +Înmulțește numărul întreg cu 1.024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP și +\fBKB\fP sunt acceptate ca sinonime pentru \fBKiB\fP. +.TP +\fBMiB\fP +Înmulțește numărul întreg cu 1,048,576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP, și \fBMB\fP +sunt acceptate ca sinonime pentru \fBMiB\fP. +.TP +\fBGiB\fP +Înmulțește numărul întreg cu 1,073,741,824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP, și +\fBGB\fP sunt acceptate ca sinonime pentru \fBGiB\fP. +.PP +Valoarea specială \fBmax\fP poate fi utilizată pentru a indica valoarea maximă +întreagă suportată de opțiune. +. +.SS "Mod de operare" +Dacă sunt date mai multe opțiuni de mod de funcționare, ultima dintre ele, +este cea care va avea efect. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Comprimare. Acesta este modul de operare implicit atunci când nu este +specificată nicio opțiune de mod de funcționare și nici un alt mod de +operare nu este implicat din numele comenzii (de exemplu, \fBunxz\fP implică +\fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +După o comprimare reușită, fișierul sursă este eliminat, cu excepția cazului +în care a fost specificată scrierea la ieșirea standard sau opțiunea +\fB\-\-keep\fP. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Decomprimare. După o decomprimare reușită, fișierul sursă este eliminat, cu +excepția cazului în care a fost specificată scrierea la ieșirea standard sau +opțiunea \fB\-\-keep\fP. +.TP +\fB\-t\fP, \fB\-\-test\fP +Testează integritatea \fIfișierelor\fP comprimate. Această opțiune este +echivalentă cu \fB\-\-decompress \-\-stdout\fP cu excepția faptului că datele +decomprimate sunt înlăturate în loc să fie scrise la ieșirea standard. Nu +sunt create sau eliminate fișiere. +.TP +\fB\-l\fP, \fB\-\-list\fP +Afișează informații despre \fIfișiere\fP comprimate. Nu are loc nicio +decomprimare la ieșire și nu sunt create sau eliminate fișiere. În modul +listă, programul nu poate citi datele comprimate din intrarea standard sau +din alte surse care nu pot fi explorate. +.IP "" +Listarea implicită arată informații de bază despre \fIfișiere\fP, câte un +fișier pe linie. Pentru a obține informații mai detaliate, utilizați și +opțiunea \fB\-\-verbose\fP. Pentru și mai multe informații, utilizați opțiunea +\fB\-\-verbose\fP de două ori, dar rețineți că acest lucru poate fi lent, +deoarece obținerea tuturor informațiilor suplimentare necesită multe +căutări. Lățimea ieșirii detaliate depășește 80 de caractere, deci +canalizarea ieșirii către, de exemplu, \fBless\ \-S\fP poate fi convenabilă dacă +terminalul nu este suficient de lat. +.IP "" +Ieșirea exactă poate varia între versiunile \fBxz\fP și diferitele +localizări(configurările regionale). Pentru ieșiri care pot fi citite de +mașină, ar trebui utilizată opțiunea \fB\-\-robot \-\-list\fP. +. +.SS "Modificatori de operare" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Nu șterge fișierele de intrare. +.IP "" +Începând cu \fBxz\fP 5.2.6, această opțiune face ca \fBxz\fP să comprime sau să +decomprime, chiar dacă intrarea este o legătură simbolică către un fișier +obișnuit, are mai mult de\-o legătură dură sau are marcați biții setuid, +setgid sau bitul lipicios. Biții setuid, setgid și bitul lipicios nu sunt +copiați în fișierul țintă. În versiunile anterioare acest lucru se făcea +numai cu ajutorul opțiunii \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Această opțiune are mai multe efecte: +.RS +.IP \(bu 3 +Dacă fișierul țintă există deja, îl șterge înainte de comprimare sau +decomprimare. +.IP \(bu 3 +Comprimă sau decomprimă chiar dacă intrarea este o legătură simbolică către +un fișier obișnuit, are mai mult de\-o legătură dură sau are marcați biții +setuid, setgid sau bitul lipicios. Biții setuid, setgid și bitul lipicios nu +sunt copiați în fișierul țintă. +.IP \(bu 3 +Când este utilizată cu opțiunile \fB\-\-decompress\fP și \fB\-\-stdout\fP, comanda +\fBxz\fP nu poate recunoaște tipul fișierului sursă, și copiază fișierul sursă +așa cum este la ieșirea standard. Acest lucru permite comenzii \fBxzcat\fP +\fB\-\-force\fP să fie folosită drept comanda \fBcat\fP(1) pentru fișierele care nu +au fost comprimate cu \fBxz\fP. Rețineți că, în viitor, \fBxz\fP ar putea să +accepte noi formate de fișiere comprimate, ceea ce poate face ca \fBxz\fP să +decomprime mai multe tipuri de fișiere în loc să le copieze așa cum sunt la +ieșirea standard. Opțiunea \fB\-\-format=\fP\fIformat\fP poate fi folosită pentru a +restricționa \fBxz\fP să decomprime doar un singur format de fișier. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Scrie datele comprimate sau decomprimate la ieșirea standard în loc de +într\-un fișier. Aceasta implică \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Decomprimă numai primul flux \fB.xz\fP și ignoră în tăcere posibilele date de +intrare rămase în urma fluxului. În mod normal, astfel de resturi rămase +face ca \fBxz\fP să afișeze o eroare. +.IP "" +\fBxz\fP nu decomprimă niciodată mai mult de un flux din fișierele \fB.lzma\fP sau +din fluxurile brute, dar această opțiune face ca \fBxz\fP să ignore posibilele +resturi de date rămase după fișierul \fB.lzma\fP sau fluxul brut. +.IP "" +Această opțiune nu are efect dacă modul de funcționare nu este +\fB\-\-decompress\fP sau \fB\-\-test\fP. +.IP "" +Începând cu \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP implică \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Dezactivează crearea de fișiere dispersate. În mod implicit, dacă decomprimă +într\-un fișier obișnuit, \fBxz\fP încearcă să facă fișierul dispersat dacă +datele decomprimate conțin secvențe lungi de zerouri binare. De asemenea, +funcționează atunci când scrie la ieșirea standard, atâta timp cât ieșirea +standard este conectată la un fișier obișnuit și sunt îndeplinite anumite +condiții suplimentare pentru a o face în siguranță. Crearea de fișiere +dispersate poate economisi spațiu pe disc și poate accelera decomprimarea +prin reducerea cantității de date de In/Ieș pe disc. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Când comprimă, utilizează \fI.suf\fP ca sufix pentru fișierul țintă în loc de +\&\fB.xz\fP sau \fB.lzma\fP. Dacă nu scrie la ieșirea standard și fișierul sursă are +deja sufixul \fI.suf\fP, este afișat un avertisment și fișierul este omis. +.IP "" +Când decomprimă, recunoaște fișierele cu sufixul \fI.suf\fP în plus față de +fișierele cu sufixul \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP sau \fB.lz\fP. Dacă +fișierul sursă are sufixul \fI.suf\fP, sufixul este eliminat pentru a obține +numele fișierului țintă. +.IP "" +La comprimarea sau decomprimarea fluxurilor brute (\fB\-\-format=raw\fP), sufixul +trebuie să fie întotdeauna specificat, cu excepția cazului în care se scrie +la ieșirea standard, deoarece nu există un sufix implicit pentru fluxurile +brute. +.TP +\fB\-\-files\fP[\fB=\fP\fIfișier\fP] +Citește numele fișierelor de procesat din \fIfișier\fP; dacă \fIfișierul\fP este +omis, numele fișierelor sunt citite de la intrarea standard. Numele de +fișiere trebuie să fie terminate cu caracterul de linie nouă. O liniuță +(\fB\-\fP) este luată ca nume de fișier obișnuit; nu înseamnă intrarea +standard. Dacă numele de fișiere sunt date și ca argumente în linia de +comandă, ele sunt procesate înainte ca numele fișierelor să fie citite din +\fIfișier\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIfișier\fP] +Această opțiune este identică cu \fB\-\-files\fP[\fB=\fP\fIfișier\fP], cu excepția +faptului că fiecare nume de fișier trebuie să fie terminat cu caracterul +nul. +. +.SS "Formatul de bază al fișierului și opțiunile de comprimare" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fIformat\fP +Specifică \fIformatul\fP fișierului pentru comprimare sau decomprimare: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Aceasta este valoarea implicită. La comprimare, \fBauto\fP este echivalent cu +\fBxz\fP. La decomprimare, formatul fișierului de intrare este detectat +automat. Rețineți că fluxurile brute (create cu \fB\-\-format=raw\fP) nu pot fi +detectate automat. +.TP +\fBxz\fP +Comprimă în formatul de fișier \fB.xz\fP sau acceptă numai fișierele \fB.xz\fP +când decomprimă. +.TP +\fBlzma\fP, \fBalone\fP +Comprimă în formatul de fișier \fB.lzma\fP vechi sau acceptă numai fișierele +\&\fB.lzma\fP când decomprimă. Numele alternativ \fBalone\fP este furnizat pentru +compatibilitatea cu versiunile mai vechi de LZMA Utils. +.TP +\fBlzip\fP +Acceptă numai fișierele \fB.lz\fP când decomprimă. Comprimarea nu este +acceptată. +.IP "" +Sunt acceptate versiunile 0 și 1 ale formatului \fB.lz\fP. Fișierele versiunii +0 au fost create cu \fBlzip\fP 1.3 și versiuni mai vechi. Astfel de fișiere nu +sunt comune, dar pot fi găsite în arhivele de fișiere, deoarece câteva +pachete sursă au fost lansate în acest format. Este posibil ca oamenii să +aibă și fișiere personale vechi în acest format. Suportul pentru +decomprimare pentru versiunea 0 a formatului a fost eliminat în \fBlzip\fP +1.18. \fBlzip\fP 1.4 și versiunile ulterioare creează fișiere în versiunea 1 a +formatului. +.TP +\fBraw\fP +Comprimă sau decomprimă un flux brut (fără anteturi). Acest lucru este +destinat doar utilizatorilor avansați. Pentru a decodifica fluxurile brute, +trebuie să utilizați opțiunea \fB\-\-format=raw\fP și să specificați în mod +explicit lanțul de filtre, care în mod normal ar fi fost stocat în +anteturile containerului. +.RE +.TP +\fB\-C\fP \fIverificarea\fP, \fB\-\-check=\fP\fIverificarea\fP +Specifică tipul verificării integrității. Verificarea este calculată din +datele necomprimate și stocată în fișierul \fB.xz\fP. Această opțiune are efect +numai la comprimarea în format \fB.xz\fP; formatul \fB.lzma\fP nu acceptă +verificări de integritate. Verificarea integrității (dacă există) este +efectuată atunci când fișierul \fB.xz\fP este decomprimat. +.IP "" +Tipuri de \fIverificare\fP acceptate: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Nu calculează deloc o verificare a integrității. Aceasta este de obicei o +idee proastă. Acest lucru poate fi util atunci când integritatea datelor +este oricum verificată prin alte mijloace. +.TP +\fBcrc32\fP +Calculează CRC32 folosind polinomul din IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Calculează CRC64 folosind polinomul din ECMA\-182. Aceasta este valoarea +implicită, deoarece este ceva mai bună decât CRC32 la detectarea fișierelor +deteriorate, iar diferența de viteză este neglijabilă. +.TP +\fBsha256\fP +Calculează SHA\-256. Acest lucru este oarecum mai lent decât CRC32 și CRC64. +.RE +.IP "" +Integritatea antetelor \fB.xz\fP este întotdeauna verificată cu CRC32. Nu este +posibilă modificarea sau dezactivarea acesteia. +.TP +\fB\-\-ignore\-check\fP +Nu efectuează verificarea integrității datelor comprimate la +decomprimare. Valorile CRC32 din antetele \fB.xz\fP vor fi însă verificate +normal. +.IP "" +\fBNu utilizați această opțiune decât dacă știți ce faceți\fP. Motive posibile +pentru a utiliza această opțiune: +.RS +.IP \(bu 3 +Încercarea de a recupera datele dintr\-un fișier .xz corupt. +.IP \(bu 3 +Accelerarea decomprimării. Acest lucru contează mai ales cu SHA\-256 sau cu +fișierele care s\-au comprimat extrem de bine. Este recomandat să nu +utilizați această opțiune în acest scop decât dacă integritatea fișierului +este verificată extern într\-un alt mod. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Selectează un nivel prestabilit de comprimare. Valoarea implicită este +\fB\-6\fP. Dacă sunt specificate mai multe niveluri prestabilite, ultimul are +efect. Dacă a fost deja specificat un lanț de filtre personalizat, +specificarea unui nivel prestabilit de comprimare șterge lanțul de filtre +personalizat. +.IP "" +Diferențele dintre valorile prestabilite sunt mai semnificative decât cu +\fBgzip\fP(1) și \fBbzip2\fP(1). Valorile de comprimare selectate determină +cerințele de memorie ale instrumentului de decomprimare, astfel încât +utilizarea unui nivel prea mare prestabilit ar putea face „dureroasă” +decomprimarea fișierului pe un sistem vechi cu puțină memorie RAM. Mai +exact, \fBnu este o idee bună să folosiți orbește \-9 pentru tot\fP așa cum se +întâmplă adesea cu \fBgzip\fP(1) și \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Acestea sunt valorile prestabilite oarecum rapide. \fB\-0\fP este uneori mai +rapid decât \fBgzip \-9\fP în timp ce comprimă mult mai bine. Cele mai ridicate +au adesea viteza comparabilă cu \fBbzip2\fP(1) cu un raport de comprimare +comparabil sau mai bun, deși rezultatele depind foarte mult de tipul de date +care sunt comprimate. +.TP +\fB\-4\fP ... \fB\-6\fP +Comprimare bună spre foarte bună, păstrând în același timp utilizarea +memoriei de către instrumentul de decomprimare la un nivel rezonabil chiar +și pentru sistemele vechi. \fB\-6\fP este valoarea implicită, care este de +obicei o alegere bună pentru distribuirea fișierelor care trebuie să poată +fi decomprimate chiar și pe sisteme cu doar 16Mio de memorie RAM. Opțiunile +(\fB\-5e\fP sau \fB\-6e\fP ar putea fi demne de luat în considerare. A se vedea +opțiunea \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Acestea sunt precum \fB\-6\fP, dar cu cerințe mai mari de memorie pentru +comprimare și decomprimare. Acestea sunt utile numai atunci când comprimați +fișiere mai mari de 8Mio, 16Mio și, respectiv, 32Mio. +.RE +.IP "" +Pe același hardware, viteza de decomprimare este aproximativ un număr +constant de octeți de date comprimate pe secundă. Cu alte cuvinte, cu cât +comprimarea este mai bună, cu atât decomprimarea va fi de obicei mai +rapidă. Aceasta înseamnă, de asemenea, că valoarea de la ieșire a cantității +de date necomprimate produsă pe secundă poate varia foarte mult. +.IP "" +Următorul tabel rezumă caracteristicile valorilor prestabilite: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +ValPrestab;DimDict;CPUComp;MemComp;MemDec +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Descrieri coloane: +.RS +.IP \(bu 3 +DimDict este dimensiunea dicționarului LZMA2. Este o risipă de memorie să +folosești un dicționar mai mare decât dimensiunea fișierului necomprimat. De +aceea este bine să evitați utilizarea valorilor prestabilite \fB\-7\fP ... \fB\-9\fP +atunci când nu este nevoie cu adevărat de ele. Pentru valoarea prestabilită +\fB\-6\fP sau alta mai mică, cantitatea de memorie irosită este de obicei +suficient de mică pentru a nu conta. +.IP \(bu 3 +CPUComp este o reprezentare simplificată a configurărilor LZMA2 care +afectează viteza de comprimare. Dimensiunea dicționarului afectează și +viteza, așa că, în timp ce CPUComp este aceeași pentru nivelurile \fB\-6\fP +\&... \fB\-9\fP, nivelurile mai mari tind să fie puțin mai lente. Pentru a obține +o comprimare și mai lentă și, astfel, posibil mai bună, consultați opțiunea +\fB\-\-extreme\fP. +.IP \(bu 3 +MemComp conține cerințele de memorie ale comprimării în modul cu un singur +fir de execuție. Poate varia ușor între versiunile \fBxz\fP. +.IP \(bu 3 +MemDec conține cerințele de memorie pentru decomprimare. Adică, +configurările de comprimare determină cerințele de memorie ale +decomprimării. Cantitatea exactă a memoriei utilizate la decomprimare este +puțin mai mare decât dimensiunea dicționarului LZMA2, dar valorile din tabel +au fost rotunjite la următorul Mio. +.RE +.IP "" +Cerințele de memorie ale modului cu mai multe fire de execuție sunt +semnificativ mai mari decât cele ale modului cu un singur fir de +execuție. Cu valoarea implicită a lui \fB\-\-block\-size\fP, fiecare fir are +nevoie de 3*3*DictSize plus MemComp sau MemDec. De exemplu, patru fire de +execuție cu valoarea prestabilită \fB\-6\fP au nevoie de 660\(en670\ Mio de +memorie. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Utilizează o variantă mai lentă a nivelului prestabilit de comprimare +selectat (\fB\-0\fP ... \fB\-9\fP) pentru a obține un raport de comprimare puțin mai +bun, dar din nefericire, acest lucru îl poate înrăutăți. Utilizarea memoriei +pentru decomprimare nu este afectată, dar utilizarea memoriei la comprimare +crește puțin la nivelurile prestabilite \fB\-0\fP ... \fB\-3\fP. +.IP "" +Deoarece există două valori prestabilite cu dimensiuni ale dicționarului de +4Mio și 8Mio, valorile prestabilite \fB\-3e\fP și \fB\-5e\fP folosesc configurări +puțin mai rapide (CPUComp mai mic) decât \fB\-4e\fP și \fB\-6e\fP, respectiv. În +acest fel, nu există două nivele prestabilite identice. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +ValPrestab;DimDict;CPUComp;MemComp;MemDec +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +De exemplu, există un total de patru nivele prestabilite care folosesc +dicționarul 8Mio, a căror ordine de la cel mai rapid la cel mai lent este +\fB\-5\fP, \fB\-6\fP, \fB\-5e\fP și \fB\-6e\fP . +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Acestea sunt alias de opțiuni, oarecum înșelătoare pentru \fB\-0\fP și, +respectiv, \fB\-9\fP. Acestea sunt furnizate numai pentru compatibilitatea cu +LZMA Utils. Evitați utilizarea acestor opțiuni. +.TP +\fB\-\-block\-size=\fP\fIdimensiunea\fP +Când comprimă în formatul \fB.xz\fP, împarte datele de intrare în blocuri de +\fIdimensiunea\fP octeți. Blocurile sunt comprimate independent unul de +celălalt, ceea ce ajută în modul cu mai multe fire de execuție și face +posibilă decomprimarea cu acces aleatoriu limitat. Această opțiune este de +obicei folosită pentru a suprascrie dimensiunea implicită a blocului în +modul cu mai multe fire de execuție, dar această opțiune poate fi folosită +și în modul cu un singur fir de execuție. +.IP "" +În modul cu mai multe fire de execuție, aproximativ de trei ori +\fIdimensiunea\fP de octeți vor fi alocați în fiecare fir pentru stocarea +intrării și ieșirii. \fIDimensiunea\fP implicită este de trei ori dimensiunea +dicționarului LZMA2 sau 1Mio, oricare dintre acestea este mai mare. În mod +obișnuit, o valoare bună este de două la patru ori dimensiunea dicționarului +LZMA2 sau de cel puțin 1Mio. Utilizarea unei \fIdimensiuni\fP mai mici decât +dimensiunea dicționarului LZMA2 este o risipă de memorie RAM, deoarece +atunci memoria tampon a dicționarului LZMA2 nu va fi niciodată utilizată pe +deplin. În modul cu mai multe fire de execuție, dimensiunile blocurilor sunt +stocate în anteturile blocurilor. Aceste informații privind dimensiunea sunt +necesare pentru decomprimarea cu mai multe fire. +.IP "" +În modul cu un singur fir de execuție, nicio divizare a blocurilor nu se +face în mod implicit. Folosirea acestei opțiuni nu afectează utilizarea +memoriei. Nu sunt stocate informații despre dimensiune în antetele +blocurilor, astfel încât fișierele create în modul cu un singur fir de +execuție nu vor fi identice cu fișierele create în modul cu mai multe fire +de execuție. Lipsa informațiilor privind dimensiunea înseamnă, de asemenea, +că \fBxz\fP nu va putea decomprima fișierele în modul cu mai multe fire. de +execuție. +.TP +\fB\-\-block\-list=\fP\fIelemente\fP +Când comprimă în formatul \fB.xz\fP, începe un nou bloc cu un lanț de filtre +personalizat opțional după intervalele specificate de date necomprimate. +.IP "" +\fIelementele\fP sunt o listă separată prin virgule. Fiecare element este +format dintr\-un număr opțional de lanț de filtrare între 0 și 9, urmat de +două puncte (\fB:\fP) și de o dimensiune cerută a datelor +necomprimate. Omiterea unui element (două sau mai multe virgule consecutive) +este o prescurtare pentru a utiliza dimensiunea și filtrele din elementul +anterior. +.IP "" +În cazul în care fișierul de intrare este mai mare decât suma dimensiunilor +din \fIelemente\fP, ultimul element se repetă până la sfârșitul fișierului. O +valoare specială de \fB0\fP poate fi utilizată ca ultimă dimensiune pentru a +indica faptul că restul fișierului trebuie să fie codificat ca un singur +bloc. +.IP "" +Un lanț de filtre alternativ pentru fiecare bloc poate fi specificat în +combinație cu opțiunile \fB\-\-filters1=\fP\fIfiltre\fP \&...\& +\fB\-\-filters9=\fP\fIfiltre\fP. Aceste opțiuni definesc lanțuri de filtre cu un +identificator cuprins între 1\(en9. Lanțul de filtre 0 poate fi utilizat +pentru a se referi la lanțul de filtre implicit, ceea ce este același lucru +cu a nu specifica un lanț de filtre. Identificatorul lanțului de filtre +poate fi utilizat înaintea dimensiunii necomprimate, urmat de două puncte +(\fB:\fP). De exemplu, dacă se specifică +\fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP, atunci blocurile vor fi +create folosind: +.RS +.IP \(bu 3 +Lanțul de filtre specificat de \fB\-\-filters1\fP și 2 Mio de intrare +.IP \(bu 3 +Lanțul de filtre specificat de \fB\-\-filters3\fP și 2 Mio de intrare +.IP \(bu 3 +Lanțul de filtre specificat de \fB\-\-filters2\fP și 4 Mio de intrare +.IP \(bu 3 +Lanțul de filtre specificat de \fB\-\-filters2\fP și 4 Mio de intrare +.IP \(bu 3 +Lanțul de filtre implicit și 2 MiB de intrare +.IP \(bu 3 +Lanțul de filtre implicit și 4 MiB de intrare pentru fiecare bloc până la +sfârșitul intrării. +.RE +.IP "" +Dacă se specifică o dimensiune care depășește dimensiunea blocului +codificatorului (fie valoarea implicită în modul cu fire de execuție, fie +valoarea specificată cu \fB\-\-block\-size=\fP\fIdimensiune\fP), codificatorul va +crea blocuri suplimentare, păstrând limitele specificate în \fIelemente\fP. De +exemplu, dacă se specifică \fB\-\-block\-size=10MiB\fP +\fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP și fișierul de intrare este de +80 MiB, se vor obține 11 blocuri: 5, 10, 8, 10, 10, 2, 10, 10, 10, 4, 10, +10, 10 și 1 Mio. +.IP "" +În modul cu mai multe fire de execuție, dimensiunile blocurilor sunt stocate +în antetele blocurilor. Acest lucru nu se face în modul cu un singur fir de +execuție, astfel încât ieșirea codificată nu va fi identică cu cea a modului +cu mai multe fire de execuție. +.TP +\fB\-\-flush\-timeout=\fP\fItimp_limită\fP +La comprimare, dacă au trecut mai mult de \fItimp_limită\fP milisecunde (un +întreg pozitiv) de la curățarea anterioară și citirea mai multor intrări +s\-ar bloca, toate datele de intrare în așteptare sunt eliminate din +codificator și puse la dispoziție în fluxul de ieșire. Acest lucru poate să +fie util dacă \fBxz\fP este utilizat pentru a comprima datele care sunt +transmise în flux printr\-o rețea. Valorile mici de \fItimp_limită\fP fac datele +disponibile la capătul de recepție cu o mică întârziere, dar valorile mari +de \fItimp_limită\fP oferă un raport de comprimare mai bun. +.IP "" +Această caracteristică este dezactivată în mod implicit. Dacă această +opțiune este specificată de mai multe ori, ultima este cea care se ia în +considerare. Valoarea specială a lui \fItimp_limită\fP de \fB0\fP, poate fi +utilizată pentru a dezactiva în mod explicit această caracteristică. +.IP "" +Această caracteristică nu este disponibilă în sistemele non\-POSIX. +.IP "" +.\" FIXME +\fBAceastă caracteristică este încă experimentală\fP. În prezent, \fBxz\fP este +nepotrivit pentru decomprimarea fluxului în timp real datorită modului în +care \fBxz\fP utilizează memoria tampon. +.TP +\fB\-\-no\-sync\fP +Nu sincronizează fișierul țintă și directorul acestuia cu dispozitivul de +stocare înainte de a elimina fișierul sursă. Acest lucru poate îmbunătăți +performanța în cazul comprimării sau decomprimării multor fișiere mici. Cu +toate acestea, dacă sistemul se blochează imediat după ștergere, este +posibil ca fișierul țintă să nu fi fost scris pe dispozitivul de stocare, +dar operația de ștergere să fi fost. În acest caz, nici fișierul sursă +original, nici fișierul țintă nu sunt disponibile. +.IP "" +Această opțiune are efect numai atunci când \fBxz\fP urmează să elimine +fișierul sursă. În alte cazuri, sincronizarea nu se face niciodată. +.IP "" +Sincronizarea și \fB\-\-no\-sync\fP au fost adăugate în \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIlimita\fP +Stabilește o limită de utilizare a memoriei pentru comprimare. Dacă această +opțiune este specificată de mai multe ori, ultima va avea efect. +.IP "" +Dacă parametrii de comprimare depășesc \fIlimita\fP, \fBxz\fP va încerca să +ajusteze parametrii scăzând valorile acestora, astfel încât limita să nu mai +fie depășită și va afișa o notificare că ajustarea automată a fost +efectuată. Ajustările se fac în această ordine: reducerea numărului de fire, +trecerea la modul un singur fir de execuție dacă chiar și un singur fir în +modul cu mai multe fire de execuție depășește \fIlimita\fP și, în final, +reducerea dimensiunii dicționarului LZMA2. +.IP "" +Când comprimă cu opțiunea \fB\-\-format=raw\fP sau dacă a fost specificată +opțiunea \fB\-\-no\-adjust\fP, numai numărul de fire poate fi redus, deoarece se +poate face fără a afecta rezultatul comprimării. +.IP "" +Dacă \fIlimita\fP nu poate fi îndeplinită chiar și cu ajustările descrise mai +sus, este afișată o eroare și \fBxz\fP va ieși cu starea de ieșire 1. +.IP "" +\fILimita\fP poate fi specificata în mai multe moduri: +.RS +.IP \(bu 3 +\fILimita\fP poate fi o valoare absolută în octeți. Utilizarea unui sufix +întreg precum \fBMiB\fP poate fi utilă. De exemplu: +\fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +\fILimita\fP poate fi specificată ca procent din memoria fizică totală +(RAM). Acest lucru poate fi util mai ales atunci când definiți variabila de +mediu \fBXZ_DEFAULTS\fP într\-un script de inițializare shell care este partajat +între diferite calculatoare. În acest fel, limita este automat mai mare pe +sistemele cu mai multă memorie. De exemplu: \fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +\fILimita\fP poate fi restabilită la valoarea implicită dându\-i valoarea +\fB0\fP. În prezent, aceasta este echivalentă cu stabilirea \fIlimitei\fP la +\fBmax\fP (fără limită de utilizare a memoriei). +.RE +.IP "" +Pentru \fBxz\fP pe 32 de biți există un caz special: dacă \fIlimita\fP ar fi peste +\fB4020MiB\fP, \fIlimita\fP este stabilită la \fB4020MiB\fP. Pe MIPS32 este +stabilită în schimb la \fB2000MiB\fP; (valorile \fB0\fP și \fBmax\fP nu sunt afectate +de acest lucru \-\- o caracteristică similară nu există pentru +decomprimare). Acest lucru poate fi util atunci când un executabil pe 32 de +biți are acces la un spațiu de adrese de 4Gio (2Gio pe MIPS32), se speră că +nu produce daune în alte situații. +.IP "" +Consultați și secțiunea \fBUtilizarea memoriei\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIlimita\fP +Stabilește o limită de utilizare a memoriei pentru decomprimare. Acest lucru +afectează și modul \fB\-\-list\fP. Dacă operațiunea nu este posibilă fără a +depăși \fIlimita\fP, \fBxz\fP va afișa o eroare și decomprimarea fișierului va +eșua. Consultați \fB\-\-memlimit\-compress=\fP\fIlimita\fP pentru modalitățile +posibile de a specifica \fIlimita\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimita\fP +Stabilește o limită de utilizare a memoriei pentru decomprimarea cu mai +multe fire de execuție. Acest lucru poate afecta doar numărul de fire de +execuție; acest lucru nu îl va face niciodată pe \fBxz\fP să refuze +decomprimarea unui fișier. Dacă \fIlimita\fP este prea scăzută pentru a permite +orice mod cu mai multe fire de execuție, \fIlimita\fP este ignorată și \fBxz\fP va +continua în modul cu un singur fir de execuție. Rețineți că, dacă se +folosește și opțiunea \fB\-\-memlimit\-decompress\fP, se va aplica întotdeauna +atât modurilor cu un singur fir de execuție, cât și modurilor cu mai multe +fire de execuție și astfel \fIlimita\fP efectivă pentru modul cu mai multe fire +de execuție nu va fi niciodată mai mare decât limita stabilită cu opțiunea +\fB\-\-memlimit\-decompress\fP. +.IP "" +Spre deosebire de celelalte opțiuni de limită de utilizare a memoriei, +opțiunea \fB\-\-memlimit\-mt\-decompress=\fP\fIlimita\fP are o \fIlimită\fP implicită +specifică sistemului. Comanda \fBxz \-\-info\-memory\fP poate fi folosită pentru a +vedea valoarea curentă. +.IP "" +Această opțiune și valoarea ei implicită există deoarece, fără nicio limită, +decomprimarea cu (mai multe) fire de execuție ar putea ajunge să aloce o +cantitate „nebună” de memorie cu unele fișiere de intrare. Dacă \fIlimita\fP +implicită este prea scăzută pe sistemul dumneavoastră, nu ezitați să +creșteți \fIlimita\fP, dar niciodată să nu o stabiliți la o valoare mai mare +decât cantitatea de memorie RAM utilizabilă și cu niște fișiere de intrare +adecvate, \fBxz\fP va încerca să utilizeze acea cantitate de memorie chiar și +cu un număr redus de fire de execuție. Rularea lui \fBxz\fP cu depășirea +cantității de memorie fizice(RAM) sau a celei de interschimb(swap) nu va +îmbunătăți performanța de decomprimare. +.IP "" +Consultați opțiunea \fB\-\-memlimit\-compress=\fP\fIlimita\fP pentru modalități +posibile de a specifica \fIlimita\fP. Stabilirea \fIlimitei\fP la \fB0\fP +restabilește \fIlimita\fP la valoarea implicită specifică sistemului. +.TP +\fB\-M\fP \fIlimita\fP, \fB\-\-memlimit=\fP\fIlimita\fP, \fB\-\-memory=\fP\fIlimita\fP +Aceasta este echivalentă cu specificarea opțiunilor: +\fB\-\-memlimit\-compress=\fP\fIlimita\fP \fB\-\-memlimit\-decompress=\fP\fIlimita\fP +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimita\fP. +.TP +\fB\-\-no\-adjust\fP +Afișează o eroare și iese dacă limita de utilizare a memoriei nu poate fi +îndeplinită fără ajustarea parametrilor care afectează ieșirea +comprimată. Adică, acest lucru împiedică \fBxz\fP să comute codificatorul din +modul cu mai multe fire de execuție în modul cu un singur fir de execuție și +să reducă dimensiunea dicționarului LZMA2. Chiar și atunci când această +opțiune este utilizată, numărul de fire de execuție poate fi redus pentru a +îndeplini limita de utilizare a memoriei, deoarece aceasta nu va afecta +comprimarea. +.IP "" +Ajustarea automată este întotdeauna dezactivată la crearea fluxurilor brute +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fInumăr\fP, \fB\-\-threads=\fP\fInumăr\fP +Specifică numărul de fire de execuție de utilizat. Stabilirea \fInumărului\fP +la valoarea specială \fB0\fP, face ca \fBxz\fP să utilizeze până la atâtea fire de +execuție câte procesoare sunt în sistem. Numărul real de fire de execuție +poate fi mai mic decât \fInumăr\fP dacă fișierul de intrare nu este suficient +de mare pentru a trece la modul cu mai multe fire de execuție cu parametrii +dați, sau dacă folosirea mai multor fire de execuție ar depăși limita de +utilizare a memoriei. +.IP "" +Operațiile de comprimare cu un singur fir de execuție și cele cu mai multe +fire de execuție produc ieșiri diferite. Comprimarea cu un singur fir de +execuție va oferi cea mai mică dimensiune a fișierului, dar numai ieșirea de +la comprimarea cu mai multe fire de execuție poate fi decomprimată folosind +mai multe fire. Stabilirea \fInumărului\fP la \fB1\fP va determina ca \fBxz\fP să +folosească modul cu un singur fir de execuție. Stabilirea \fInumărului\fP la +orice altă valoare, inclusiv \fB0\fP, va determina ca \fBxz\fP să folosească +comprimarea cu mai multe fire de execuție chiar dacă sistemul acceptă doar +un fir hardware; (\fBxz\fP 5.2.x folosește modul cu un singur fir de execuție +în această situație). +.IP "" +Pentru a utiliza modul cu mai multe fire de execuție cu un singur fir, +stabiliți \fInumărul\fP la \fB+1\fP. Prefixul \fB+\fP nu are efect cu alte valori +decât \fB1\fP. O limită de utilizare a memoriei poate face în continuare \fBxz\fP +să treacă în modul cu un singur fir, cu excepția cazului în care este +utilizată opțiunea \fB\-\-no\-adjust\fP. Suportul pentru prefixul \fB+\fP a fost +adăugat în \fBxz\fP 5.4.0. +.IP "" +Dacă a fost solicitat un număr automat de fire și nu a fost specificată +nicio limită de utilizare a memoriei, atunci o limită „maleabilă” implicită +specifică sistemului va fi utilizată pentru a limita eventual numărul de +fire de execuție. Este o limită „maleabilă” în sensul că este ignorată dacă +numărul de fire devine unul, astfel o limită „maleabilă” nu va opri +niciodată \fBxz\fP să comprime sau să decomprime. Această limită „maleabilă” +implicită nu va face \fBxz\fP să treacă de la modul cu mai multe fire de +execuție la modul cu un singur fir de execuție. Limitele active pot fi +văzute rulând comanda \fBxz \-\-info\-memory\fP. +.IP "" +În prezent, singura metodă de procesare cu fire de execuție este împărțirea +intrării în blocuri și comprimarea lor independent unul de +celălalt. Dimensiunea implicită a blocului depinde de nivelul de comprimare +și poate fi înlocuită cu opțiunea \fB\-\-block\-size=\fP\fIdimensiune\fP. +.IP "" +Decomprimarea cu fire de execuție funcționează numai pe fișierele care +conțin mai multe blocuri cu informații despre dimensiune în antetele +blocurilor. Toate fișierele suficient de mari comprimate în modul cu mai +multe fire de execuție îndeplinesc această condiție, dar fișierele +comprimate în modul cu un singur fir de execuție nu o îndeplinesc chiar dacă +a fost folosită opțiunea \fB\-\-block\-size=\fP\fIdimensiune\fP. +.IP "" +Valoarea implicită pentru \fIfire de execuție\fP este \fB0\fP. În \fBxz\fP 5.4.x și +mai vechi, valoarea implicită este \fB1\fP. +. +.SS "Lanțuri de filtrare personalizate pentru instrumentul de comprimare" +Un lanț de filtrare personalizat permite specificarea parametrilor de +comprimare în detaliu, în loc să se bazeze pe cei asociați opțiunilor +prestabilite. Când este specificat un lanț de filtrare personalizat, +opțiunile prestabilite (\fB\-0\fP \&...\& \fB\-9\fP și \fB\-\-extreme\fP) de mai devreme +din linia de comandă sunt uitate. Dacă o opțiune prestabilită este +specificată după una sau mai multe opțiuni de lanț de filtrare personalizat, +noua prestabilire intră în vigoare și opțiunile lanțului de filtrare +personalizat, specificate mai devreme sunt uitate. +.PP +Un lanț de filtrare este comparabil cu conductele din linia de comandă. La +comprimare, intrarea necomprimată merge la primul filtru, a cărui ieșire +merge la următorul filtru (dacă există). Ieșirea ultimului filtru este +scrisă în fișierul comprimat. Numărul maxim de filtre din lanț este de +patru, dar de obicei un lanț de filtrare are doar unul sau două filtre. +.PP +Multe filtre au limitări în ceea ce privește locul în care se pot afla în +lanțul de filtrare: unele filtre pot funcționa doar ca ultimul filtru din +lanț, altele doar ca non\-ultim filtru și unele funcționează în orice poziție +din lanț. În funcție de filtru, această limitare este fie inerentă +proiectării filtrului, fie există pentru a preveni problemele de securitate. +.PP +Un lanț de filtre personalizat poate fi specificat în două moduri +diferite. Opțiunile \fB\-\-filters=\fP\fIfiltre\fP și \fB\-\-filters1=\fP\fIfiltre\fP +\&...\& \fB\-\-filters9=\fP\fIfiltre\fP permit specificarea unui întreg lanț de +filtre într\-o singură opțiune, folosind sintaxa șirului de filtre +liblzma. Alternativ, un lanț de filtre poate fi specificat prin utilizarea +uneia sau mai multor opțiuni de filtrare individuale în ordinea în care sunt +dorite în lanțul de filtre. Adică, ordinea opțiunilor de filtrare +individuale este semnificativă! La decodificarea fluxurilor brute +(\fB\-\-format=raw\fP), lanțul de filtre trebuie să fie specificat în aceeași +ordine în care a fost specificat la comprimare. Orice filtru individual sau +opțiuni presetate specificate înainte de opțiunea de lanț complet +(\fB\-\-filters=\fP\fIfiltre\fP) vor fi uitate. Filtrele individuale specificate +după opțiunea „lanț complet” vor reinițializa lanțul de filtre. +.PP +Atât opțiunile de filtrare completă, cât și cele de filtrare individuală +acceptă \fIopțiuni\fP specifice filtrului sub forma unei liste separate prin +virgule. Se ignoră virgulele suplimentare din \fIopțiuni\fP. Fiecare opțiune +are o valoare implicită, deci specificați\-le pe cele pe care doriți să le +modificați. +.PP +Pentru a vedea întregul lanț de filtre și \fIopțiuni\fP, utilizați \fBxz \-vv\fP +(adică folosiți \fB\-\-verbose\fP de două ori). Acest lucru funcționează și +pentru vizualizarea opțiunilor lanțului de filtre utilizate de valorile +prestabilite. +.TP +\fB\-\-filters=\fP\fIfiltre\fP +Specificați întregul lanț de filtre sau o presetare într\-o singură +opțiune. Fiecare filtru poate fi separat prin spații sau două liniuțe +(\fB\-\-\fP). Este posibil să fie necesar ca \fIfiltrele\fP să fie puse între +ghilimele în linia de comandă a shell\-ului pentru a fi analizate ca o +singură opțiune. Pentru a indica \fIopțiuni\fP, utilizați \fB:\fP sau \fB=\fP. O +presetare poate fi prefixată cu un \fB\-\fP și urmată de zero sau mai multe +indicatoare. Singurul indicator suportat este \fBe\fP pentru a aplica aceleași +opțiuni ca și \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIfiltre\fP ... \fB\-\-filters9\fP=\fIfiltre\fP +Specifică până la nouă lanțuri de filtre suplimentare care pot fi utilizate +cu \fB\-\-block\-list\fP. +.IP "" +De exemplu, atunci când se comprimă o arhivă cu fișiere executabile urmate +de fișiere text, partea executabilă ar putea utiliza un lanț de filtre cu un +filtru BCJ, iar partea de text doar filtrul LZMA2. +.TP +\fB\-\-filters\-help\fP +Afișează un mesaj de ajutor care descrie modul de specificare a presetărilor +și a lanțurilor de filtre personalizate în opțiunile \fB\-\-filters\fP și +\fB\-\-filters1=\fP\fIfiltre\fP \&...\& \fB\-\-filters9=\fP\fIfiltre\fP și iese. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIopțiuni\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIopțiuni\fP] +.PD +Adaugă filtrul LZMA1 sau LZMA2 la lanțul de filtre. Aceste filtre pot fi +folosite doar ca ultimul filtru din lanț. +.IP "" +LZMA1 este un filtru vechi, care este acceptat aproape exclusiv datorită +formatului de fișier vechi \fB.lzma\fP, care acceptă numai LZMA1. LZMA2 este o +versiune actualizată a LZMA1 pentru a rezolva unele probleme practice ale +LZMA1. Formatul \fB.xz\fP folosește LZMA2 și nu acceptă deloc LZMA1. Viteza de +comprimare și rapoartele LZMA1 și LZMA2 sunt practic aceleași. +.IP "" +LZMA1 și LZMA2 au același set de \fIopțiuni\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIprestabilit\fP +Reconfigurează toate \fIopțiunile\fP LZMA1 sau LZMA2 la +\fIprestabilit\fP. \fIprestabilit\fP constă dintr\-un număr întreg, care poate fi +urmat de modificatori prestabiliți cu o singură literă. Numărul întreg +poate fi de la \fB0\fP la \fB9\fP, potrivindu\-se cu opțiunile liniei de comandă +\fB\-0\fP \&...\& \fB\-9\fP. Singurul modificator acceptat în prezent este \fBe\fP, +care se potrivește cu \fB\-\-extreme\fP. Dacă nu este specificat \fBprestabilit\fP, +valorile implicite ale \fIopțiunilor\fP LZMA1 sau LZMA2 sunt preluate din +prestabilirea \fB6\fP. +.TP +\fBdict=\fP\fIdimensiunea\fP +\fIDimensiunea\fP dicționarului (istoricul memoriei tampon) indică câți octeți +din datele necomprimate recent procesate sunt păstrați în +memorie. Algoritmul încearcă să găsească secvențe de octeți care se repetă +(potriviri) în datele necomprimate și să le înlocuiască cu referințe la +datele aflate în prezent în dicționar. Cu cât dicționarul este mai mare, cu +atât este mai mare șansa de a găsi o potrivire. Astfel, creșterea +\fIdimensiunii\fP dicționarului îmbunătățește de obicei raportul de comprimare, +dar un dicționar mai mare decât fișierul necomprimat este risipă de memorie. +.IP "" +\fIDimensiunea\fPtipică a dicționarului este de la 64Kio până la 64Mio. Minimul +este de 4Kio. Maximul pentru compresie este în prezent de 1,5Gio +(1536Mio). Decomprimarea acceptă deja dicționare cu până la un octet mai +puțin de 4Gio, care este maximul pentru formatele de flux LZMA1 și LZMA2. +.IP "" +\fIDimensiunea\fP dicționarului și găsitorul de potriviri (match finder) → +(\fImf\fP) determină împreună utilizarea memoriei de către codificatorul LZMA1 +sau LZMA2. Aceeași \fIdimensiune\fP a dicționarului (sau mai mare) care a fost +utilizată la comprimare, este necesară pentru decomprimare, astfel încât +utilizarea memoriei de către decodificator este determinată de dimensiunea +dicționarului utilizată la comprimare. Antetele \fB.xz\fP stochează +\fIdimensiunea\fP dicționarului fie ca 2^\fIn\fP, fie ca 2^\fIn\fP + 2^(\fIn\fP\-1), deci +aceste \fIdimensiuni\fP sunt oarecum preferate pentru comprimare. Alte +\fIdimensiuni\fP vor fi rotunjite atunci când sunt stocate în anteturile +\&\fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Specifică numărul de biți de context literal. Minimul este 0 și maximul este +4; implicit este 3. În plus, suma \fIlc\fP și \fIlp\fP nu trebuie să depășească +4. +.IP "" +Toți octeții care nu pot fi codificați ca potriviri sunt codificați ca +literali. Adică, literalii sunt pur și simplu octeți de 8 biți care sunt +codificați unul câte unul. +.IP "" +Codificarea literală presupune că cei mai mari biți \fIlc\fP ai octetului +anterior necomprimat se corelează cu octetul următor. De exemplu, în textul +tipic englezesc, o literă mare este adesea urmată de o literă mică, iar o +literă mică este urmată de obicei de o altă literă mică. În setul de +caractere US\-ASCII, cei mai mari trei biți sunt 010 pentru literele mari și +011 pentru literele mici. Când \fIlc\fP este cel puțin 3, codificarea literală +poate profita de această proprietate în datele necomprimate. +.IP "" +Valoarea implicită (3) este de obicei bună. Dacă doriți o comprimare maximă, +testați \fBlc=4\fP. Uneori ajută puțin, iar uneori înrăutățește comprimarea +\&. Dacă o agravează, încercați de\-asemeni cu \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Specifică numărul de biți de poziție literală. Minimul este 0 și maximul +este 4; implicit este 0. +.IP "" +\fILp\fP afectează ce fel de aliniere în datele necomprimate este presupusă la +codificarea literalelor. Consultați argumentul \fIpb\fP de mai jos pentru mai +multe informații despre aliniere. +.TP +\fBpb=\fP\fIpb\fP +Specifică numărul de biți de poziție. Minimul este 0 și maximul este 4; +implicit este 2. +.IP "" +\fIPb\fP afectează ce fel de aliniere în datele necomprimate este presupusă în +general. Valoarea implicită înseamnă alinierea pe patru octeți +(2^\fIpb\fP=2^2=4), care este adesea o alegere bună atunci când nu există o +ipoteză mai bună. +.IP "" +Când alinierea este cunoscută, definirea lui \fIpb\fP în mod corespunzător +poate reduce puțin dimensiunea fișierului. De exemplu, cu fișierele text cu +aliniere pe un octet (US\-ASCII, ISO\-8859\-*, UTF\-8), definirea \fBpb=0\fP poate +îmbunătăți ușor comprimarea. Pentru textul UTF\-16, \fBpb=1\fP este o alegere +bună. Dacă alinierea este un număr impar, cum ar fi 3 octeți, \fBpb=0\fP ar +putea fi cea mai bună alegere. +.IP "" +Chiar dacă alinierea presupusă poate fi ajustată cu \fIpb\fP și \fIlp\fP, LZMA1 și +LZMA2 încă favorizează ușor alinierea pe 16 octeți. Ar putea fi demn de luat +în considerare atunci când proiectați formate de fișiere care pot fi adesea +comprimate cu LZMA1 sau LZMA2. +.TP +\fBmf=\fP\fImf\fP +Căutarea potrivirilor are un efect major asupra vitezei codificatorului, +utilizării memoriei și raportului de comprimare. De obicei, găsitorii de +potriviri din lanțul sumelor de control sunt mai rapizi decât găsitorii de +potriviri din arborele binar. Valoarea implicită depinde de \fIprestabilit\fP: +0 folosește \fBhc3\fP, 1\(en3 folosește \fBhc4\fP, iar restul folosește \fBbt4\fP. +.IP "" +Sunt acceptate următoarele opțiuni de căutare de potriviri. Formulele de +utilizare a memoriei de mai jos sunt aproximări estimative, care se apropie +cel mai mult de realitate atunci când \fIdict\fP este o putere a lui doi. +.RS +.TP +\fBhc3\fP +Lanț de sumă de control, cu suma de control de 2 și 3 octeți +.br +Valoarea minimă pentru \fInice\fP: 3 +.br +Utilizarea memoriei: +.br +\fIdict\fP * 7.5 (dacă \fIdict\fP <= 16 Mio); +.br +\fIdict\fP * 5.5 + 64 MiB (dacă \fIdict\fP > 16 Mio) +.TP +\fBhc4\fP +Lanț de sumă de control, cu suma de control de 2, 3 și 4 octeți +.br +Valoarea minimă pentru \fInice\fP: 4 +.br +Utilizarea memoriei: +.br +\fIdict\fP * 7.5 (dacă \fIdict\fP <= 32 Mio); +.br +\fIdict\fP * 6.5 (dacă \fIdict\fP > 32 Mio) +.TP +\fBbt2\fP +Arbore binar cu suma de control de 2 octeți +.br +Valoarea minimă pentru \fInice\fP: 2 +.br +Utilizarea memoriei: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Arbore binar cu suma de control de 2 și 3 octeți +.br +Valoarea minimă pentru \fInice\fP: 3 +.br +Utilizarea memoriei: +.br +\fIdict\fP * 11.5 (dacă \fIdict\fP <= 16 Mio); +.br +\fIdict\fP * 9.5 + 64 MiB (dacă \fIdict\fP > 16 Mio) +.TP +\fBbt4\fP +Arbore binar cu suma de control de 2, 3 și 4 octeți +.br +Valoarea minimă pentru \fInice\fP: 4 +.br +Utilizarea memoriei: +.br +\fIdict\fP * 11.5 (dacă \fIdict\fP <= 32 Mio); +.br +\fIdict\fP * 10.5 (dacă \fIdict\fP > 32 Mio) +.RE +.TP +\fBmode=\fP\fImod\fP +Comprimarea \fImod\fP specifică metoda de analiză a datelor produse de +găsitorul de potriviri. \fIModurile\fP acceptate sunt \fBfast\fP(rapid) și +\fBnormal\fP. Valoarea implicită este \fBfast\fP pentru \fIprestabiliri\fP 0\(en3 și +\fBnormal\fP pentru \fIprestabiliri\fP 4\(en9. +.IP "" +De obicei, \fBfast\fP este folosit cu instrumentele de căutare de potriviri ale +lanțului de sume de control, și \fBnormal\fP cu instrumentele de căutare de +potriviri din arborele binar. Aceasta este și ceea ce fac \fIprestabiririle\fP. +.TP +\fBnice=\fP\fInice\fP +Specifică ceea ce este considerat a fi o lungime bună(nice) pentru o +potrivire. Odată ce este găsită o potrivire de cel puțin \fInice\fP octeți, +algoritmul nu mai caută după potriviri posibile mai bune. +.IP "" +\fINice\fP poate fi de 2\(en273 octeți. Valorile mai mari tind să ofere un +raport de comprimare mai bun în detrimentul vitezei. Valoarea implicită +depinde de \fIprestabilit\fP. +.TP +\fBdepth=\fP\fIadâncimea\fP +Specifică adâncimea maximă de căutare în găsitorul de potriviri. Valoarea +implicită este valoarea specială de 0, ceea ce face ca instrumentul de +comprimare să determine o \fIadâncime\fP rezonabilă pornind de la valorile +\fImf\fP și \fInice\fP. +.IP "" +\fIAdâncimea\fP rezonabilă pentru lanțuri de sumă de control este 4\(en100 și +16\(en1000 pentru arbori binari. Folosirea unor valori foarte mari pentru +\fIadâncime\fP poate face codificatorul extrem de lent cu unele +fișiere. Evitați să stabiliți \fIadâncimea\fP la valori peste 1000, cu excepția +cazului în care sunteți pregătit să întrerupeți comprimarea în cazul în care +durează prea mult. +.RE +.IP "" +La decodificarea fluxurilor brute (\fB\-\-format=raw\fP), LZMA2 are nevoie doar +de \fIdimensiunea\fP dicționarului. LZMA1 are nevoie de asemenea de \fIlc\fP, +\fIlp\fP și \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIopțiuni\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIopțiuni\fP] +.PD +Adaugă un filtru de ramură/apel/salt (branch/call/jump ⟶ „BCJ”) la lanțul de +filtre. Aceste filtre pot fi utilizate numai ca un filtru care nu este +ultimul din lanțul de filtrare. +.IP "" +Un filtru BCJ convertește adresele relative din codul mașinii în omoloagele +lor absolute. Acest lucru nu modifică dimensiunea datelor, dar crește +redundanța, ceea ce poate ajuta LZMA2 să producă fișier \fB.xz\fP cu 0\(en15\ % +mai mic. Filtrele BCJ sunt întotdeauna reversibile, deci folosind un filtru +BCJ pentru tipul greșit de date nu provoacă nicio pierdere de date, deși +poate înrăutăți puțin raportul de comprimare. Filtrele BCJ sunt foarte +rapide și folosesc o cantitate nesemnificativă de memorie. +.IP "" +Aceste filtre BCJ au probleme cunoscute legate de raportul de comprimare: +.RS +.IP \(bu 3 +Unele tipuri de fișiere care conțin cod executabil (de exemplu, fișiere +obiect, biblioteci statice și module de kernel Linux) au adresele din +instrucțiuni completate cu valori de umplere. Aceste filtre BCJ vor face în +continuare conversia adresei, ceea ce va înrăutăți comprimarea cu aceste +fișiere. +.IP \(bu 3 +Dacă pe o arhivă este aplicat un filtru BCJ, este posibil ca raportul de +comprimare să fie mai rău decât la neutilizarea unui filtru BCJ. De exemplu, +dacă există executabile similare sau chiar identice, filtrarea va face +probabil fișierele mai puțin asemănătoare și astfel comprimarea este mai +proastă. Conținutul fișierelor neexecutabile din aceeași arhivă poate conta +și el. În practică, trebuie să încercați cu și fără filtru BCJ pentru a +vedea care rezultat este mai bun în fiecare situație. +.RE +.IP "" +Seturi de instrucțiuni diferite au o aliniere diferită: fișierul executabil +trebuie aliniat la un multiplu al acestei valori în datele de intrare pentru +ca filtrul să funcționeze. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filtru;Aliniere;Note +x86;1;x86 pe 32 de biți +;;sau 64 de biți +ARM;4; +ARM\-Thumb;2; +ARM64;4;alinierea pe 4096\-octeți +;;este cea mai bună +PowerPC;4;Doar big endian +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Deoarece datele filtrate prin BCJ sunt de obicei comprimate cu LZMA2, +raportul de comprimare poate fi ușor îmbunătățit dacă opțiunile LZMA2 sunt +definite pentru a se potrivi cu alinierea filtrului BCJ selectat. Exemple: +.RS +.IP \(bu 3 +Filtrul IA\-64 are o aliniere de 16 octeți, astfel încât \fBpb=4,lp=4,lc=0\fP +este alegere adecvată cu LZMA2 (2^4=16). +.IP \(bu 3 +Codul RISC\-V are o aliniere pe 2 sau 4 octeți, depinzând de faptul că +fișierul conține instrucțiuni comprimate pe 16 biți (extensia C) sau +nu. Atunci când se utilizează instrucțiuni pe 16 biți, \fBpb=2,lp=1,lc=3\fP sau +\fBpb=1,lp=1,lc=3\fP este o alegere bună. Atunci când nu sunt prezente +instrucțiuni pe 16 biți, \fBpb=2,lp=2,lc=2\fP este cea mai bună +alegere. \fBreadelf \-h\fP poate fi utilizată pentru a verifica dacă „RVC” apare +în linia „Indicatori". +.IP \(bu 3 +ARM64 este întotdeauna aliniat pe 4 octeți, astfel încât \fBpb=2,lp=2,lc=2\fP +este cea mai bună alegere. +.IP \(bu 3 +Filtrul x86 este o excepție. De obicei, este bine să rămâneți la valorile +implicite ale LZMA2 (\fBpb=2,lp=0,lc=3\fP) atunci când comprimați executabile +x86. +.RE +.IP "" +Toate filtrele BCJ acceptă același \fIopțiuni\fP: +.RS +.TP +\fBstart=\fP\fIpoziție\fP +Specifică \fIpoziția\fP de pornire care este utilizată la conversia între +adresele relative și absolute. \fIPoziția\fP trebuie să fie un multiplu al +alinierii filtrului (consultați tabelul de mai sus). Valoarea implicită +este zero. În practică, valoarea implicită este bună; specificarea unei +\fIpoziții\fP personalizate nu este aproape niciodată utilă. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIopțiuni\fP] +Adaugă filtrul Delta în lanțul de filtrare. Filtrul Delta poate fi folosit +doar ca un filtru care nu este ultimul în lanțul de filtrare. +.IP "" +În prezent, este acceptat doar calculul delta simplu de octeți. Poate fi +util la comprimarea, de exemplu, a imaginilor bitmap necomprimate sau a +sunetului PCM necomprimat. Cu toate acestea, algoritmii cu scop special pot +da rezultate semnificativ mai bune decât Delta + LZMA2. Acest lucru este +valabil mai ales în cazul audio, care se comprimă mai repede și mai bine, de +exemplu, cu \fBflac\fP(1). +.IP "" +\fIOpțiuni\fP acceptate: +.RS +.TP +\fBdist=\fP\fIdistanța\fP +Specifică \fIdistanța\fP calculului delta în octeți. \fIDistanța\fP trebuie să fie +1\(en256. Valoarea implicită este 1. +.IP "" +De exemplu, cu \fBdist=2\fP și intrare de opt octeți: A1 B1 A2 B3 A3 B5 A4 B7, +ieșirea va fi: A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Alte opțiuni" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Suprimă avertismentele și notificările. Specificați acest lucru de două ori +pentru a suprima și erorile. Această opțiune nu are niciun efect asupra +stării de ieșire. Adică, chiar dacă o avertizare a fost suprimată, starea de +ieșire pentru a indica o avertizare este încă utilizată. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Oferă informații detaliate. Dacă ieșirea de eroare standard este conectată +la un terminal, \fBxz\fP va afișa un indicator de progres. Specificarea +opțiunii \fB\-\-verbose\fP de două ori, va avea ca rezultat oferirea de +informații și mai detaliate. +.IP "" +Indicatorul de progres afișează următoarele informații: +.RS +.IP \(bu 3 +Procentul de completare este afișat dacă se cunoaște dimensiunea fișierului +de intrare. Adică, procentul nu poate fi afișat la procesarea fișierului +prin conducte(pipe). +.IP \(bu 3 +Cantitatea de date comprimate produse (comprimare) sau consumate +(decomprimare). +.IP \(bu 3 +Cantitatea de date necomprimate consumate (comprimare) sau produse +(decomprimare). +.IP \(bu 3 +Raportul de comprimare, care se calculează împărțind cantitatea de date +comprimate procesate până acum la cantitatea de date necomprimate procesate +până acum. +.IP \(bu 3 +Viteza de comprimare sau decomprimare. Aceasta este măsurată drept +cantitatea de date necomprimate consumate (comprimare) sau produse +(decomprimare) pe secundă. Este afișată după ce au trecut câteva secunde de +când \fBxz\fP a început procesarea fișierului. +.IP \(bu 3 +Timpul scurs în format M:SS sau H:MM:SS. +.IP \(bu 3 +Timpul rămas estimat este afișat numai atunci când dimensiunea fișierului de +intrare este cunoscută și au trecut deja câteva secunde de când \fBxz\fP a +început procesarea fișierului. Ora este afișată într\-un format mai puțin +precis, care nu are niciodată două puncte, de exemplu, 2 min 30 s. +.RE +.IP "" +Când ieșirea de eroare standard nu este un terminal, \fB\-\-verbose\fP va face +\fBxz\fP să imprime numele fișierului, dimensiunea comprimată, dimensiunea +necomprimată, raportul de comprimare și, eventual, de asemenea, viteza și +timpul scurs pe o singură linie la ieșirea de eroare standard după +comprimarea sau decomprimarea fișierului. Viteza și timpul scurs sunt +incluse numai atunci când operațiunea a durat cel puțin câteva secunde. Dacă +operațiunea nu s\-a încheiat, de exemplu, din cauza întreruperii din partea +utilizatorului, se imprimă și procentul de completare dacă se cunoaște +dimensiunea fișierului de intrare. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Nu comută starea de ieșire la 2 chiar dacă a fost detectată o condiție care +merită avertizată. Această opțiune nu afectează nivelul de detaliere al +informațiilor, astfel încât atât \fB\-\-quiet\fP cât și \fB\-\-no\-warn\fP trebuie +folosite pentru a nu afișa avertismente și pentru a nu modifica starea de +ieșire. +.TP +\fB\-\-robot\fP +Afișează mesajele într\-un format care poate fi analizat de mașină. Acest +lucru are scopul de a ușura scrierea interfețelor în care se dorește să se +folosească \fBxz\fP în loc de liblzma, ceea ce poate fi cazul cu diferite +scripturi. Ieșirea cu această opțiune activată este menită să fie stabilă în +toate versiunile \fBxz\fP. Consultați secțiunea \fBMOD ROBOT\fP pentru detalii. +.TP +\fB\-\-info\-memory\fP +Afișează, într\-un format care poate fi citit de om, câtă memorie fizică +(RAM) și câte fire de execuție de procesor \fBxz\fP crede că are sistemul și +limitele de utilizare a memoriei pentru comprimare și decomprimare și iese +cu succes. +.TP +\fB\-h\fP, \fB\-\-help\fP +Afișează un mesaj de ajutor care descrie opțiunile cele mai frecvent +utilizate și iese cu succes. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Afișează un mesaj de ajutor care descrie toate caracteristicile \fBxz\fP și +iese cu succes +.TP +\fB\-V\fP, \fB\-\-version\fP +Afișează numărul versiunii \fBxz\fP și liblzma într\-un format care poate fi +citit de om. Pentru a obține rezultate analizabile de mașină, specificați +\fB\-\-robot\fP înainte de \fB\-\-version\fP. +. +.SH "MOD ROBOT" +Modul robot este activat cu opțiunea \fB\-\-robot\fP. Face ieșirea lui \fBxz\fP mai +ușor de analizat de către alte programe. În prezent, opțiunea \fB\-\-robot\fP +este acceptată numai împreună cu opțiunile \fB\-\-list\fP, \fB\-\-filters\-help\fP, +\fB\-\-info\-memory\fP, și \fB\-\-version\fP. Va fi acceptată pentru comprimare și +decomprimare în viitor. +. +.SS "Modul listă" +\fBxz \-\-robot \-\-list\fP utilizează o ieșire separată de tabulatori. Prima +coloană a fiecărei linii are un șir care indică tipul de informații găsite +pe acea linie: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Aceasta este întotdeauna prima linie când începe să se listeze un fișier. A +doua coloană de pe linie este numele fișierului. +.TP +\fBfile\fP +Această linie conține informații generale despre fișierul \fB.xz\fP. Această +linie este întotdeauna tipărită după linia \fBname\fP. +.TP +\fBstream\fP +Acest tip de linie este utilizat numai atunci când a fost specificată +opțiunea \fB\-\-verbose\fP. Există tot atâtea linii \fBstream\fP câte fluxuri există +în fișierul \fB.xz\fP. +.TP +\fBblock\fP +Acest tip de linie este utilizat numai atunci când a fost specificată +opțiunea \fB\-\-verbose\fP. Există tot atâtea linii \fBblock\fP câte blocuri există +în fișierul \fB.xz\fP. Liniile \fBblock\fP sunt afișate după toate liniile +\fBstream\fP; tipurile diferite de linii nu sunt intercalate. +.TP +\fBsummary\fP +Acest tip de linie este folosit numai atunci când opțiunea \fB\-\-verbose\fP a +fost specificată de două ori. Această linie este afișată după toate liniile +\fBblock\fP. Ca și linia \fBfile\fP, linia \fBsummary\fP conține informații generale +despre fișierul \fB.xz\fP. +.TP +\fBtotals\fP +Această linie este întotdeauna ultima linie din lista afișată la +ieșire. Aceasta arată numărul total și dimensiunile. +.PP +Coloanele din liniile \fBfile\fP: +.PD 0 +.RS +.IP 2. 4 +Numărul de fluxuri din fișier +.IP 3. 4 +Numărul total de blocuri din fluxuri +.IP 4. 4 +Dimensiunea comprimată a fișierului +.IP 5. 4 +Dimensiunea necomprimată a fișierului +.IP 6. 4 +Raportul de comprimare, de exemplu, \fB0,123\fP. Dacă raportul este peste +9,999, în locul raportului sunt afișate trei liniuțe (\fB\-\-\-\fP). +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Lista de nume de verificare a integrității, separate prin +virgule. Următoarele șiruri sunt utilizate pentru tipurile de verificare +cunoscute: \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP și \fBSHA\-256\fP. Pentru tipurile de +verificări necunoscute, se utilizează \fBUnknown\-\fP\fIN\fP, unde \fIN\fP este ID\-ul +de verificare ca număr zecimal (una sau două cifre). +.IP 8. 4 +Dimensiunea totală a umpluturii fluxului din fișier +.RE +.PD +.PP +Coloanele din liniile \fBstream\fP: +.PD 0 +.RS +.IP 2. 4 +Numărul fluxului (primul flux este 1) +.IP 3. 4 +Numărul de blocuri din flux +.IP 4. 4 +Poziția de pornire a comprimării +.IP 5. 4 +Poziția de pornire a decomprimării +.IP 6. 4 +Dimensiune comprimată (nu include umplutura fluxului) +.IP 7. 4 +Dimensiune necomprimată +.IP 8. 4 +Raport de comprimare +.IP 9. 4 +Numele verificării de integritate +.IP 10. 4 +Dimensiunea umpluturii fluxului +.RE +.PD +.PP +Coloanele din liniile \fBblock\fP: +.PD 0 +.RS +.IP 2. 4 +Numărul fluxului care conține acest bloc +.IP 3. 4 +Numărul blocului în raport cu începutul fluxului (primul bloc este 1) +.IP 4. 4 +Numărul blocului în raport cu începutul fișierului +.IP 5. 4 +Poziția de pornire a comprimării în raport cu începutul fișierului +.IP 6. 4 +Poziția de pornire necomprimată în raport cu începutul fișierului +.IP 7. 4 +Dimensiunea totală comprimată a blocului (include antetele) +.IP 8. 4 +Dimensiune necomprimată +.IP 9. 4 +Raport de comprimare +.IP 10. 4 +Numele verificării de integritate +.RE +.PD +.PP +Dacă opțiunea \fB\-\-verbose\fP a fost specificată de două ori, coloane +suplimentare sunt incluse pe liniile \fBblock\fP. Acestea nu sunt afișate cu o +singură specificare a opțiunii \fB\-\-verbose\fP, deoarece obținerea acestor +informații necesită multe căutări și, prin urmare, poate fi lentă: +.PD 0 +.RS +.IP 11. 4 +Valoarea verificării integrității în hexazecimal +.IP 12. 4 +Dimensiunea antetului blocului +.IP 13. 4 +Indicatori de bloc: \fBc\fP indică faptul că este prezentă dimensiunea +comprimată, iar \fBu\fP indică faptul că este prezentă dimensiunea +necomprimată. Dacă indicatorul nu este determinat, este afișată o liniuță +(\fB\-\fP) pentru a menține lungimea șirului fixă. Pot fi adăugate noi +indicatoare la sfârșitul șirului, în viitor. +.IP 14. 4 +Dimensiunea datelor comprimate reale din bloc (acest lucru exclude antetul +blocului, umplutura blocului și câmpurile de verificare) +.IP 15. 4 +Cantitatea de memorie (în octeți) necesară pentru a decomprima acest bloc cu +această versiune \fBxz\fP +.IP 16. 4 +Lanț de filtrare. Rețineți că majoritatea opțiunilor utilizate în timpul +comprimării nu pot fi cunoscute, deoarece doar opțiunile necesare pentru +decomprimare sunt stocate în anteturile \fB.xz\fP. +.RE +.PD +.PP +Coloanele din liniile \fBsummary\fP: +.PD 0 +.RS +.IP 2. 4 +Cantitatea de memorie (în octeți) necesară pentru a decomprima acest fișier +cu această versiune \fBxz\fP +.IP 3. 4 +\fByes\fP sau \fBno\fP indicând dacă toate antetele blocurilor au atât dimensiunea +comprimată, cât și dimensiunea necomprimată stocate în ele +.PP +\fIÎncepând cu\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Versiunea \fBxz\fP minimă necesară pentru a decomprima fișierul +.RE +.PD +.PP +Coloanele din linia \fBtotals\fP: +.PD 0 +.RS +.IP 2. 4 +Numărul de fluxuri +.IP 3. 4 +Numărul de blocuri +.IP 4. 4 +Dimensiunea comprimată +.IP 5. 4 +Dimensiune necomprimată +.IP 6. 4 +Raportul mediu de comprimare +.IP 7. 4 +Lista de nume de verificare a integrității, separate prin virgule, care au +fost prezente în fișiere +.IP 8. 4 +Dimensiunea umpluturii fluxului +.IP 9. 4 +Numărul de fișiere. Aceasta este aici pentru a păstra ordinea coloanelor +anterioare la fel ca pe liniile \fBfile\fP. +.PD +.RE +.PP +Dacă opțiunea \fB\-\-verbose\fP a fost specificată de două ori, pe linia +\fBtotals\fP sunt incluse coloane suplimentare: +.PD 0 +.RS +.IP 10. 4 +Cantitatea maximă de memorie (în octeți) necesară pentru a decomprima +fișierele cu această versiune \fBxz\fP +.IP 11. 4 +\fByes\fP sau \fBno\fP indicând dacă toate antetele blocurilor au atât dimensiunea +comprimată, cât și dimensiunea necomprimată stocate în ele +.PP +\fIÎncepând cu\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Versiunea \fBxz\fP minimă necesară pentru a decomprima fișierul +.RE +.PD +.PP +Versiunile viitoare pot adăuga noi tipuri de linii și pot fi adăugate +coloane noi la tipurile de linii existente, dar coloanele existente nu vor +fi modificate. +. +.SS "Ajutor pentru filtrare" +\fBxz \-\-robot \-\-filters\-help\fP afișează filtrele acceptate în următorul +format: +.PP +\fIfiltru\fP\fB:\fP\fIopțiune\fP\fB=<\fP\fIvaloare\fP\fB>,\fP\fIopțiune\fP\fB=<\fP\fIvaloare\fP\fB>\fP... +.TP +\fBfiltru\fP +Numele filtrului +.TP +\fIopțiune\fP +Numele unei opțiuni specifice unui filtru +.TP +\fIvaloare\fP +Intervalele numerice \fIvaloare\fP apar ca +\fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. Alegerile \fIvaloare\fP de tip șir de +caractere sunt afișate în cadrul \fB< >\fP și separate de un caracter +\fB|\fP. +.PP +Fiecare filtru este afișat pe propria linie. +. +.SS "Informații privind limita memoriei" +\fBxz \-\-robot \-\-info\-memory\fP afișează o singură linie cu multiple coloane +separate prin tabulatoare: +.IP 1. 4 +Cantitatea totală de memorie fizică (RAM) în octeți. +.IP 2. 4 +Limita de utilizare a memoriei pentru comprimare în octeți +(\fB\-\-memlimit\-compress\fP). O valoare specială de \fB0\fP indică configurarea +implicită, care pentru modul cu un singur fir este la fel ca fără limită. +.IP 3. 4 +Limita de utilizare a memoriei pentru decomprimare în octeți +(\fB\-\-memlimit\-decompress\fP). O valoare specială de \fB0\fP indică configurarea +implicită, care pentru modul cu un singur fir este la fel ca fără limită. +.IP 4. 4 +Începând cu \fBxz\fP 5.3.4alpha: Utilizarea memoriei pentru decomprimarea cu +mai multe fire în octeți (\fB\-\-memlimit\-mt\-decompress\fP). Acesta nu este +niciodată zero, deoarece o valoare implicită specifică sistemului afișată în +coloana 5 este utilizată dacă nu a fost specificată în mod explicit nicio +limită. De asemenea, aceasta nu este niciodată mai mare decât valoarea din +coloana 3, chiar dacă a fost specificată o valoare mai mare cu +\fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Începând cu \fBxz\fP 5.3.4alpha: o limită implicită de utilizare a memoriei +specifică sistemului, care este utilizată pentru a limita numărul de fire de +execuție atunci când se comprimă cu un număr automat de fire de execuție +(\fB\-\-threads=0\fP) și nicio limită de utilizare a memoriei nu fost specificată +cu (\fB\-\-memlimit\-compress\fP). Aceasta este, de asemenea, utilizată ca valoare +implicită pentru \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Începând cu \fBxz\fP 5.3.4alpha: numărul de fire de execuție de procesor +disponibile. +.PP +În viitor, rezultatul \fBxz \-\-robot \-\-info\-memory\fP poate avea mai multe +coloane, dar niciodată mai mult de o singură linie. +. +.SS Versiunea +\fBxz \-\-robot \-\-version\fP va afișa numărul versiunii \fBxz\fP și liblzma în +următorul format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Versiunea majoră. +.TP +\fIYYY\fP +Versiunea minoră. Numerele pare sunt prezente în versiunile +stabile. Numerele impare sunt prezente în versiunile alfa sau beta. +.TP +\fIZZZ\fP +Nivelul de plasture(patch) pentru versiunile stabile sau doar un contor +pentru versiunile de dezvoltare. +.TP +\fIS\fP +Stabilitate. 0 este alfa, 1 este beta și 2 este stabil. \fIS\fP trebuie să fie +întotdeauna 2 atunci când \fIAAA\fP este par. +.PP +\fIXYYYZZZS\fP sunt aceleași pe ambele linii dacă \fBxz\fP și liblzma sunt din +aceeași versiune XZ Utils. +.PP +Exemple: 4.999.9beta este \fB49990091\fP și 5.0.0 este \fB50000002\fP. +. +.SH "STARE DE IEȘIRE" +.TP +\fB0\fP +Totul este bine. +.TP +\fB1\fP +A apărut o eroare. +.TP +\fB2\fP +A apărut ceva care merită să fie avertizat, dar nu au apărut erori reale. +.PP +Notificările (nu avertismentele sau erorile) afișate la ieșirea de eroare +standard nu afectează starea de ieșire. +. +.SH "VARIABILE DE MEDIU" +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP analizează liste de opțiuni separate prin spații din variabilele de +mediu \fBXZ_DEFAULTS\fP și \fBXZ_OPT\fP, în această ordine, înainte de a analiza +opțiunile din linia de comandă. Rețineți că numai opțiunile sunt analizate +din variabilele de mediu; toate non\-opțiunile sunt ignorate în +tăcere. Analiza se face cu funcția \fBgetopt_long\fP(3) care este folosită și +pentru argumentele liniei de comandă. +.PP +\fBAvertisment:\fP Prin definirea acestor variabile de mediu, se modifică +efectiv programele și scripturile care rulează \fBxz\fP. De cele mai multe ori +este sigur să se definească limitele de utilizare a memoriei, numărul de +fire și opțiunile de comprimare prin intermediul variabilelor de mediu. Cu +toate acestea, unele opțiuni pot întrerupe scripturile. Un exemplu evident +este \fB\-\-help\fP care face ca \fBxz\fP să afișeze textul de ajutor în loc să +comprime sau să decomprime un fișier. Exemple mai subtile sunt \fB\-\-quiet\fP și +\fB\-\-verbose\fP. În multe cazuri funcționează bine activarea indicatorului de +progres folosind \fB\-\-verbose\fP, dar în unele situații mesajele suplimentare +creează probleme. Nivelul de detaliere al mesajelor afectează, de asemenea, +comportamentul lui \fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Opțiuni implicite specifice utilizatorului sau la nivelul întregului +sistem. De obicei, acest lucru este specificat într\-un script de +inițializare shell pentru a activa limitatorul de utilizare a memoriei lui +\fBxz\fP implicit sau pentru a stabili numărul implicit de fire. Excluzând +scripturile de inițializare shell și cazurile speciale similare, scripturile +nu trebuie niciodată să modifice sau să dezactiveze \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Acest lucru este pentru transmiterea opțiunilor către \fBxz\fP atunci când nu +este posibil să definiți opțiunile direct în linia de comandă a +\fBxz\fP. Acesta este cazul când \fBxz\fP este rulat de un script sau de un +instrument, de exemplu, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Scripturile pot folosi \fBXZ_OPT\fP, de exemplu, pentru a configura opțiunile +implicite de comprimare specifice scriptului. Se recomandă totuși să se +permită utilizatorilor să înlocuiască \fBXZ_OPT\fP dacă acest lucru este +rezonabil. De exemplu, în scripturile \fBsh\fP(1) se poate folosi ceva de genul +acesta: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "COMPATIBILITATE CU LZMA\-UTILS" +Sintaxa liniei de comandă a lui \fBxz\fP este practic o super\-colecție de +\fBlzma\fP, \fBunlzma\fP și \fBlzcat\fP așa cum se găsește în LZMA Utils 4.32.x. În +cele mai multe cazuri, este posibil să înlocuiți LZMA Utils cu XZ Utils fără +a întrerupe scripturile existente. Există totuși unele incompatibilități, +care uneori pot cauza probleme. +. +.SS "Niveluri de comprimare prestabilite" +Numerotarea nivelurilor de comprimare prestabilite nu este identică în \fBxz\fP +și LZMA Utils. Cea mai importantă diferență este modul în care dimensiunile +dicționarului sunt atribuite diferitelor niveluri prestabilite. Dimensiunea +dicționarului este aproximativ egală cu memoria utilizată la decomprimare. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nivel;xz;LZMA Utils +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Diferențele de dimensiune a dicționarului afectează deasemenea cantitatea de +memorie utilizată la comprimare dar există și alte diferențe între LZMA +Utils și XZ Utils, care fac diferența și mai mare: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nivel;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Nivelul prestabilit implicit în LZMA Utils este \fB\-7\fP, în timp ce în XZ +Utils este \fB\-6\fP, deci ambele folosesc un dicționar de 8Mio în mod implicit. +. +.SS "Fișiere .lzma transmise în flux vs. netransmise în flux" +Dimensiunea necomprimată a fișierului poate fi stocată în antetul +\&\fB.lzma\fP. LZMA Utils face asta atunci când comprimă fișiere +obișnuite. Alternativa este să marcați că dimensiunea necomprimată este +necunoscută și să folosiți marcajul de sfârșit de încărcare pentru a indica +unde ar trebui să se oprească decomprimarea. LZMA Utils folosește această +metodă atunci când dimensiunea necomprimată nu este cunoscută, ceea ce este +cazul, de exemplu, când se folosesc conducte. +.PP +\fBxz\fP acceptă decomprimarea fișierelor \fB.lzma\fP cu sau fără marcaj de +sfârșit de încărcare, dar toate fișierele \fB.lzma\fP create de \fBxz\fP vor +folosi marcajul de sfârșit de încărcare și vor avea dimensiunea necomprimată +marcată ca necunoscută în antetul \fB.lzma\fP. Aceasta poate fi o problemă în +unele situații mai puțin frecvente. De exemplu, un instrument de +decomprimare \fB.lzma\fP încorporat într\-un dispozitiv poate funcționa numai cu +fișiere care au dimensiunea necomprimată cunoscută. Dacă întâmpinați această +problemă, trebuie să utilizați LZMA Utils sau LZMA SDK pentru a crea fișiere +\&\fB.lzma\fP cu dimensiunea necomprimată cunoscută. +. +.SS "Fișiere .lzma neacceptate" +Formatul \fB.lzma\fP permite valori \fIlc\fP de până la 8 și valori \fIlp\fP de până +la 4. LZMA Utils poate decomprima fișiere cu orice \fIlc\fP și \fIlp\fP, dar +creează întotdeauna fișiere cu \fBlc=3\fP și \fBlp=0\fP. Crearea de fișiere cu +alte \fIlc\fP și \fIlp\fP este posibilă cu \fBxz\fP și cu LZMA SDK. +.PP +Implementarea filtrului LZMA1 în liblzma necesită ca suma \fIlc\fP și \fIlp\fP să +nu depășească 4. Altfel, fișierele \fB.lzma\fP, care depășesc această limitare, +nu pot fi decomprimate cu \fBxz\fP. +.PP +LZMA Utils creează numai fișiere \fB.lzma\fP care au o dimensiune de dicționar +de 2^\fIn\fP (o putere de 2), dar acceptă fișiere cu orice dimensiune de +dicționar. liblzma acceptă numai fișierele \fB.lzma\fP care au dimensiunea de +dicționar de 2^\fIn\fP sau 2^\fIn\fP + 2^(\fIn\fP\-1). Acest lucru este pentru a +reduce numărul de „fals pozitiv” atunci când se detectează fișiere \fB.lzma\fP. +.PP +Aceste limitări nu ar trebui să fie o problemă în practică, deoarece practic +toate fișierele \fB.lzma\fP au fost comprimate cu opțiuni pe care liblzma le va +accepta. +. +.SS "Resturi rămase" +Când decomprimă, LZMA Utils ignoră în tăcere totul după primul flux +\&\fB.lzma\fP. În majoritatea situațiilor, aceasta este o eroare. Aceasta +înseamnă, de asemenea, că LZMA Utils nu acceptă decomprimarea fișierelor +\&\fB.lzma\fP concatenate. +.PP +Dacă au rămas date după primul flux \fB.lzma\fP, \fBxz\fP consideră că fișierul +este corupt, cu excepția cazului în care a fost utilizată opțiunea +\fB\-\-single\-stream\fP. Acest lucru poate rupe scripturile obscure(scrise +deficitar) care presupun că resturile rămase sunt ignorate. +. +.SH NOTE +. +.SS "Rezultatul comprimării poate varia" +Ieșirea exactă comprimată produsă din același fișier de intrare necomprimat +poate varia între versiunile XZ Utils, chiar dacă opțiunile de comprimare +sunt identice. Acest lucru se datorează faptului că instrumentul codificator +poate fi îmbunătățit (comprimare mai rapidă sau mai bună) fără a afecta +formatul fișierului. Ieșirea poate varia chiar și între compilările diferite +ale aceleiași versiuni XZ Utils, dacă sunt utilizate opțiuni diferite de +compilare. +.PP +Cele de mai sus înseamnă că odată ce opțiunea \fB\-\-rsyncable\fP a fost +utilizată, fișierele rezultate nu vor fi neapărat sincronizate cu rsync +decât dacă atât fișierele vechi, cât și cele noi au fost comprimate cu +aceeași versiune xz. Această problemă poate fi remediată dacă o parte a +implementării codificatorului este înghețată pentru a menține stabilă +ieșirea „rsyncabilă” între versiunile xz. +. +.SS "Instrumente de decomprimare .xz încorporate" +Implementările instrumentului de decomprimare \fB.xz\fP încorporat, cum ar fi +XZ Embedded, nu acceptă neapărat fișiere create cu tipuri de \fIverificare\fP a +integrității, altele decât \fBnone\fP și \fBcrc32\fP. Deoarece valoarea implicită +este \fB\-\-check=crc64\fP, trebuie să utilizați \fB\-\-check=none\fP sau +\fB\-\-check=crc32\fP atunci când creați fișiere pentru sistemele încorporate. +.PP +În afara sistemelor încorporate, toate instrumentele de decomprimare în +format \fB.xz\fP acceptă toate tipurile de \fIverificare\fP sau cel puțin pot +decomprima fișierul fără a efectua verificarea integrității dacă acel tip de +\fIverificare\fP nu este acceptat. +.PP +XZ Embedded acceptă filtre BCJ, dar numai cu poziție de pornire implicită. +. +.SH EXEMPLE +. +.SS Bazice +Comprimă fișierul \fIfoo\fP în \fIfoo.xz\fP folosind nivelul de comprimare +implicit (\fB\-6\fP) și elimină fișierul \fIfoo\fP dacă comprimarea are succes: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Decomprimă \fIbar.xz\fP în \fIbar\fP și nu elimină \fIbar.xz\fP chiar dacă +decomprimarea este efectuată cu succes: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Creează \fIbaz.tar.xz\fP cu nivelul prestabilit \fB\-4e\fP (\fB\-4 \-\-extreme\fP), care +este mai lent decât nivelul prestabilit implicit \fB\-6\fP, dar necesită mai +puțină memorie pentru comprimare și decomprimare (48Mio și, respectiv, +5Mio): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Un amestec de fișiere comprimate și necomprimate poate fi decomprimat la +ieșirea standard cu o singură comandă: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Comprimarea în paralel a mai multor fișiere" +În sisteme GNU și *BSD, \fBfind\fP(1) și \fBxargs\fP(1) pot fi utilizate pentru a +paraleliza comprimarea mai multor fișiere: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Opțiunea \fB\-P\fP pentru comanda \fBxargs\fP(1) stabilește numărul de procese +paralele \fBxz\fP. Cea mai bună valoare pentru opțiunea \fB\-n\fP depinde de câte +fișiere trebuie să fie comprimate. Dacă există doar câteva fișiere, valoarea +ar trebui probabil să fie 1; cu zeci de mii de fișiere, 100 sau chiar mai +mult poate să fie valoarea potrivită pentru a reduce numărul de procese +\fBxz\fP pe care \fBxargs\fP(1) le va crea în final. +.PP +Opțiunea \fB\-T1\fP pentru \fBxz\fP este acolo pentru a\-l forța să ruleze în modul +cu un singur fir de execuție, deoarece \fBxargs\fP(1) este folosit pentru a +controla cantitatea de paralelizare. +. +.SS "Modul robot" +Calculează câți octeți au fost salvați în total după comprimarea mai multor +fișiere: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Un script poate dori să afle dacă folosește o versiune \fBxz\fP suficient de +nouă. Următorul script \fBsh\fP(1) verifică dacă numărul versiunii +instrumentului \fBxz\fP este cel puțin 5.0.0. Această metodă este compatibilă +cu versiunile beta vechi, care nu acceptau opțiunea \fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Versiunea dumneavoastră de „xz” este prea veche!" +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Stabilește o limită de utilizare a memoriei pentru decomprimare folosind +variabila de mediu \fBXZ_OPT\fP, dar dacă o limită a fost deja stabilită, nu o +mărește: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Lanțuri de filtrare personalizate pentru instrumentul de comprimare" +Cea mai simplă utilizare a lanțurilor de filtrare personalizate este +personalizarea unei opțiuni prestabilite LZMA2. Acest lucru poate fi util, +deoarece opțiunile prestabilite acoperă doar un subset al combinațiilor +potențial utile de opțiuni de comprimare. +.PP +Coloanele CPUComp din tabelele de descriere a opțiunilor \fB\-0\fP ... \fB\-9\fP și +\fB\-\-extreme\fP sunt utile atunci când personalizați opțiunilor prestabilite +LZMA2. Iată părțile relevante colectate din aceste două tabele: +.RS +.PP +.TS +tab(;); +c c +n n. +ValPrestab;CPUComp +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Dacă știți că un fișier necesită un dicționar oarecum mare (de exemplu, +32Mio) pentru a se comprima bine, dar doriți să\-l comprimați mai repede +decât ar face \fBxz \-8\fP, o opțiune prestabilită cu o valoare CPUComp scăzută +(de exemplu, 1) poate fi modificată pentru a utiliza un dicționar mai mare: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Cu anumite fișiere, comanda de mai sus poate fi mai rapidă decât \fBxz \-6\fP în +timp ce comprimă semnificativ mai bine. Cu toate acestea, trebuie subliniat +că doar unele fișiere se beneficiază de un dicționar mare, păstrând în +același timp valoarea CPUComp scăzută. Cea mai evidentă situație, în care un +dicționar mare poate ajuta foarte mult, este o arhivă care conține fișiere +foarte asemănătoare de cel puțin câțiva megaocteți fiecare. Dimensiunea +dicționarului trebuie să fie semnificativ mai mare decât orice fișier +individual pentru a permite LZMA2 să profite din plin de asemănările dintre +fișierele consecutive. +.PP +Dacă utilizarea unei mari cantități de memorie pentru comprimare și +decomprimare este în regulă, iar fișierul comprimat are cel puțin câteva +sute de megaocteți, poate fi util să folosiți un dicționar și mai mare decât +cei 64Mio pe care i\-ar folosi \fBxz \-9\fP: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Utilizarea opțiunii \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) ca în exemplul de mai +sus, poate fi utilă pentru a vedea cerințele de memorie la comprimare și +decomprimare. Amintiți\-vă că utilizarea unui dicționar mai mare decât +dimensiunea fișierului necomprimat este risipă de memorie, de aceea, comanda +de mai sus nu este utilă pentru fișiere mici. +.PP +Uneori, timpul de comprimare nu contează, dar utilizarea memoriei la +decomprimare trebuie menținută la un nivel scăzut, de exemplu, pentru a face +posibilă decomprimarea fișierului pe un sistem încorporat. Următoarea +comandă folosește \fB\-6e\fP (\fB\-6 \-\-extreme\fP) ca bază și fixează dimensiunea +dicționarului la doar 64Kio. Fișierul rezultat poate fi decomprimat cu XZ +Embedded (de aceea există \fB\-\-check=crc32\fP) folosind aproximativ 100Kio de +memorie. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Dacă doriți să stoarceți cât mai mulți octeți posibil, ajustarea numărului +de biți de context literal (\fIlc\fP) și a numărului de biți de poziție (\fIpb\fP) +poate ajuta uneori. Ajustarea numărului de biți de poziție literală (\fIlp\fP) +ar putea ajuta, de asemenea, dar de obicei \fIlc\fP și \fIpb\fP sunt mai +importante. De exemplu, o arhivă de cod sursă conține în mare parte text +US\-ASCII, așa că ceva precum comanda următoare, ar putea oferi un fișier +„mai slăbuț” (aproximativ cu 0,1%) mai mic decât cu \fBxz \-6e\fP (încercați și +fără \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 fișierul_sursă.tar\fR +.fi +.RE +.PP +Utilizarea unui alt filtru împreună cu LZMA2 poate îmbunătăți comprimarea cu +anumite tipuri de fișiere. De exemplu, pentru a comprima o bibliotecă +partajată x86 pe 32 de biți sau x86 pe 64 de biți folosind filtrul BCJ x86: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Rețineți că ordinea opțiunilor de filtrare este semnificativă. Dacă \fB\-\-x86\fP +este specificată după \fB\-\-lzma2\fP, \fBxz\fP va da o eroare, deoarece nu poate +exista niciun filtru după LZMA2 și, de asemenea, pentru că filtrul x86 BCJ +nu poate fi utilizat ca ultimul filtru din lanțul de filtrare. +.PP +Filtrul Delta împreună cu LZMA2 pot da rezultate bune cu imagini bitmap. De +obicei, ar trebui să întreacă comprimarea PNG, care are câteva filtre mai +avansate decât delta simplă, dar utilizează Deflate pentru comprimarea +reală. +.PP +Imaginea trebuie să fie salvată în format necomprimat, de exemplu, ca TIFF +necomprimat. Parametrul de distanță al filtrului Delta este fixat să se +potrivească cu numărul de octeți per pixel din imagine. De exemplu, +bitmap\-ul RGB pe 24 de biți necesită \fBdist=3\fP și este, de asemenea, bine să +pasați \fBpb=0\fP la LZMA2 pentru a se adapta alinierii pe trei octeți: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Dacă mai multe imagini au fost introduse într\-o singură arhivă (de exemplu, +\&\fB.tar\fP), filtrul Delta va funcționa și pe aceasta atâta timp cât toate +imaginile au același număr de octeți per pixel. +. +.SH "CONSULTAȚI ȘI" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzmadec.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzmadec.1 new file mode 100644 index 0000000000000000000000000000000000000000..2ba0113bc2dc5fc4bcde0c55e3c252171781c716 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzmadec.1 @@ -0,0 +1,101 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.\" Romanian translation for xz-man. +.\" Mesajele în limba română pentru manualul pachetului XZ Utils. +.\" Remus-Gabriel Chelu , 2022 - 2025. +.\" Cronologia traducerii fișierului „xz-man”: +.\" Traducerea inițială, făcută de R-GC, pentru versiunea xz-man 5.4.0-pre1. +.\" Actualizare a traducerii pentru versiunea 5.4.0-pre2, făcută de R-GC, dec-2022. +.\" Actualizare a traducerii pentru versiunea 5.4.3, făcută de R-GC, mai-2023. +.\" Actualizare a traducerii pentru versiunea 5.4.4-pre1, făcută de R-GC, iul-2023. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre1, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre2, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.7.1-dev1, făcută de R-GC, ian-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.0-pre1, făcută de R-GC, mar-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.2-pre1, făcută de R-GC, oct-2025. +.\" Actualizare a traducerii pentru versiunea Y, făcută de X, Z(luna-anul). +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDEC 1 "8 aprilie 2024" Tukaani "Utilități XZ" +.SH NUME +xzdec, lzmadec \- Programe de decomprimare mici de fișiere .xz și .lzma +.SH REZUMAT +\fBxzdec\fP [\fIopțiune...\fP] [\fIfișier...\fP] +.br +\fBlzmadec\fP [\fIopțiune...\fP] [\fIfișier...\fP] +.SH DESCRIERE +\fBxzdec\fP este un instrument de decomprimare bazat pe liblzma pentru +fișierele \fB.xz\fP (și numai \fB.xz\fP). \fBxzdec\fP este destinat să funcționeze ca +un înlocuitor pentru \fBxz\fP(1) în cele mai frecvente situații în care un +script a fost scris pentru a utiliza \fBxz \-\-decompress \-\-stdout\fP (și posibil +câteva alte opțiuni frecvent utilizate) pentru a decomprima fișierele +\&\fB.xz\fP. \fBlzmadec\fP este identic cu \fBxzdec\fP cu excepția faptului că +\fBlzmadec\fP acceptă fișierele \fB.lzma\fP în loc de fișierele \fB.xz\fP. +.PP +Pentru a reduce dimensiunea executabilului, \fBxzdec\fP nu acceptă modul cu mai +multe fire de execuție sau localizarea(afișarea mesajelor în limba stabilită +de configurările regionale) și nu citește opțiunile din variabilele de mediu +\fBXZ_DEFAULTS\fP și \fBXZ_OPT\fP. \fBxzdec\fP nu acceptă afișarea informațiilor +intermediare de progres: trimiterea semnalului \fBSIGINFO\fP la \fBxzdec\fP nu +face nimic, iar trimiterea semnalului \fBSIGUSR1\fP încheie procesul în loc să +afișeze informații despre progres. +.SH OPȚIUNI +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +Ignorat pentru compatibilitate cu \fBxz\fP(1). \fBxzdec\fP acceptă numai +decomprimarea. +.TP +\fB\-k\fP, \fB\-\-keep\fP +Ignorat pentru compatibilitate cu \fBxz\fP(1). \fBxzdec\fP nu creează sau elimină +niciodată niciun fișier. +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Ignorat pentru compatibilitate cu \fBxz\fP(1). \fBxzdec\fP scrie întotdeauna +datele decomprimate la ieșirea standard. +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Specificarea acestui lucru o dată nu face nimic, deoarece \fBxzdec\fP nu +afișează niciodată avertismente sau notificări. Specificați acest lucru de +două ori pentru a suprima erorile. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Ignorat pentru compatibilitate cu \fBxz\fP(1). \fBxzdec\fP nu folosește niciodată +starea de ieșire 2. +.TP +\fB\-h\fP, \fB\-\-help\fP +Afișează un mesaj de ajutor și iese cu succes. +.TP +\fB\-V\fP, \fB\-\-version\fP +Afișează numărul versiunii \fBxzdec\fP și liblzma. +.SH "STARE DE IEȘIRE" +.TP +\fB0\fP +Toate au fost bine. +.TP +\fB1\fP +A apărut o eroare. +.PP +\fBxzdec\fP nu are niciun mesaj de avertizare precum \fBxz\fP(1), astfel că starea +de ieșire 2 nu este folosită de \fBxzdec\fP. +.SH NOTE +Utilizați \fBxz\fP(1) în loc de \fBxzdec\fP sau \fBlzmadec\fP pentru utilizarea +normală de zi cu zi. \fBxzdec\fP sau \fBlzmadec\fP sunt destinate numai +situațiilor în care este important să aveți un instrument de decomprimare +mai mic decât \fBxz\fP(1), cu funcții complete. +.PP +\fBxzdec\fP și \fBlzmadec\fP nu sunt chiar atât de mici. Dimensiunea poate fi +redusă și mai mult prin eliminarea caracteristicilor din liblzma în timpul +compilării, dar acest lucru nu ar trebui să se facă de obicei pentru +executabilele distribuite în distribuții tipice de sisteme de operare +neîncorporate. Dacă aveți nevoie de un instrument de decomprimare \fB.xz\fP cu +adevărat mic, luați în considerare utilizarea XZ Embedded. +.SH "CONSULTAȚI ȘI" +\fBxz\fP(1) +.PP +XZ Embedded: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzmainfo.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzmainfo.1 new file mode 100644 index 0000000000000000000000000000000000000000..7a533bd6e3b433364b95f4e6e0bc8934e082335d --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzmainfo.1 @@ -0,0 +1,57 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.\" Romanian translation for xz-man. +.\" Mesajele în limba română pentru manualul pachetului XZ Utils. +.\" Remus-Gabriel Chelu , 2022 - 2025. +.\" Cronologia traducerii fișierului „xz-man”: +.\" Traducerea inițială, făcută de R-GC, pentru versiunea xz-man 5.4.0-pre1. +.\" Actualizare a traducerii pentru versiunea 5.4.0-pre2, făcută de R-GC, dec-2022. +.\" Actualizare a traducerii pentru versiunea 5.4.3, făcută de R-GC, mai-2023. +.\" Actualizare a traducerii pentru versiunea 5.4.4-pre1, făcută de R-GC, iul-2023. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre1, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre2, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.7.1-dev1, făcută de R-GC, ian-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.0-pre1, făcută de R-GC, mar-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.2-pre1, făcută de R-GC, oct-2025. +.\" Actualizare a traducerii pentru versiunea Y, făcută de X, Z(luna-anul). +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH LZMAINFO 1 30.06.2013 Tukaani "Utilități XZ" +.SH NUME +lzmainfo \- afișează informațiile stocate în antetul fișierului .lzma +.SH REZUMAT +\fBlzmainfo\fP [\fB\-\-help\fP] [\fB\-\-version\fP] [\fIfișier...\fP] +.SH DESCRIERE +\fBlzmainfo\fP afișează informațiile stocate în antetul fișierului +\&\fB.lzma\fP. Citește primii 13 octeți din \fIfișierul\fP specificat, decodifică +antetul și îl afișează la ieșirea standard în format care poate fi citit de +om. Dacă nu sunt date \fIfișiere\fP sau dacă \fIfișier\fP este \fB\-\fP, se citește +intrarea standard. +.PP +De obicei, cele mai interesante informații sunt dimensiunea necomprimată și +dimensiunea dicționarului. Dimensiunea necomprimată poate fi afișată numai +dacă fișierul este în varianta formatului \fB.lzma\fP netransmis în +flux. Cantitatea de memorie necesară pentru a decomprima fișierul este de +câteva zeci de kiloocteți plus dimensiunea dicționarului. +.PP +\fBlzmainfo\fP este inclus în XZ Utils în primul rând pentru compatibilitatea +cu LZMA Utils. +.SH "STARE DE IEȘIRE" +.TP +\fB0\fP +Totul este bine. +.TP +\fB1\fP +A apărut o eroare. +.SH ERORI +\fBlzmainfo\fP folosește sufixul \fBMB\fP în timp ce sufixul corect ar fi \fBMiB\fP +(2^20 octeți). Acest lucru este pentru a menține ieșirea compatibilă cu LZMA +Utils. +.SH "CONSULTAȚI ȘI" +\fBxz\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzmore.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzmore.1 new file mode 100644 index 0000000000000000000000000000000000000000..dbc1541830568b68b48e9d554a71a90eff23a612 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/lzmore.1 @@ -0,0 +1,62 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" Romanian translation for xz-man. +.\" Mesajele în limba română pentru manualul pachetului XZ Utils. +.\" Remus-Gabriel Chelu , 2022 - 2025. +.\" Cronologia traducerii fișierului „xz-man”: +.\" Traducerea inițială, făcută de R-GC, pentru versiunea xz-man 5.4.0-pre1. +.\" Actualizare a traducerii pentru versiunea 5.4.0-pre2, făcută de R-GC, dec-2022. +.\" Actualizare a traducerii pentru versiunea 5.4.3, făcută de R-GC, mai-2023. +.\" Actualizare a traducerii pentru versiunea 5.4.4-pre1, făcută de R-GC, iul-2023. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre1, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre2, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.7.1-dev1, făcută de R-GC, ian-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.0-pre1, făcută de R-GC, mar-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.2-pre1, făcută de R-GC, oct-2025. +.\" Actualizare a traducerii pentru versiunea Y, făcută de X, Z(luna-anul). +.\" +.\" (Note that this file is based on xzless.1 instead of gzip's zmore.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZMORE 1 "6 martie 2025" Tukaani "Utilități XZ" +.SH NUME +xzmore, lzmore \- vizualizează fișierele (text) comprimate xz sau lzma +. +.SH REZUMAT +\fBxzmore\fP [\fIfișier\fP...] +.br +\fBlzmore\fP [\fIfișier\fP...] (DEPRECIATĂ) +. +.SH DESCRIERE +\fBxzmore\fP afișează textul din fișierele comprimate pe un terminal folosind +\fBmore\fP(1). Fișierele acceptate de \fBxz\fP(1) sunt decomprimate; se presupune +că celelalte fișiere sunt deja în format necomprimat. Dacă nu se dă nici un +\fIfișiere\fP, \fBxzmore\fP citește de la intrarea standard. Consultați manualul +\fBmore\fP(1) pentru comenzile de la tastatură. +.PP +Rețineți că este posibil ca derularea înapoi să nu fie posibilă în funcție +de implementarea lui \fBmore\fP(1). Acest lucru se datorează faptului că +\fBxzmore\fP utilizează o conductă pentru a transmite datele decomprimate către +\fBmore\fP(1). \fBxzless\fP(1) utilizează \fBless\fP(1) care oferă caracteristici mai +avansate. +.PP +Comanda \fBlzmore\fP este furnizată pentru compatibilitate retroactivă cu LZMA +Utils. Aceasta este depreciată și va fi eliminată într\-o versiune viitoare. +. +.SH "VARIABILE DE MEDIU" +.TP +.\" TRANSLATORS: Don't translate the uppercase PAGER. +.\" It is a name of an environment variable. +\fBPAGER\fP +Dacă variabila de mediu \fBPAGER\fP, este definită, valoarea sa este utilizată +ca paginator în loc de \fBmore\fP(1). +. +.SH "CONSULTAȚI ȘI" +\fBmore\fP(1), \fBxz\fP(1), \fBxzless\fP(1), \fBzmore\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/unlzma.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/unlzma.1 new file mode 100644 index 0000000000000000000000000000000000000000..1555445592944b4f24e548fc0dc0b1c3af876030 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/unlzma.1 @@ -0,0 +1,2111 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Romanian translation for xz-man. +.\" Mesajele în limba română pentru manualul pachetului XZ Utils. +.\" Remus-Gabriel Chelu , 2022 - 2025. +.\" Cronologia traducerii fișierului „xz-man”: +.\" Traducerea inițială, făcută de R-GC, pentru versiunea xz-man 5.4.0-pre1. +.\" Actualizare a traducerii pentru versiunea 5.4.0-pre2, făcută de R-GC, dec-2022. +.\" Actualizare a traducerii pentru versiunea 5.4.3, făcută de R-GC, mai-2023. +.\" Actualizare a traducerii pentru versiunea 5.4.4-pre1, făcută de R-GC, iul-2023. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre1, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre2, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.7.1-dev1, făcută de R-GC, ian-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.0-pre1, făcută de R-GC, mar-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.2-pre1, făcută de R-GC, oct-2025. +.\" Actualizare a traducerii pentru versiunea Y, făcută de X, Z(luna-anul). +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 "8 martie 2025" Tukaani "Utilități XZ" +. +.SH NUME +xz, unxz, xzcat, lzma, unlzma, lzcat \- Comprimă sau decomprimă fișiere .xz +și .lzma +. +.SH REZUMAT +\fBxz\fP [\fIopțiune...\fP] [\fIfișier...\fP] +. +.SH "ALIAS COMENZI" +\fBunxz\fP este echivalent cu \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP este echivalent cu \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP este echivalent cu \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP este echivalent cu \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP este echivalent cu \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Când scrieți scripturi care trebuie să decomprime fișiere, este recomandat +să folosiți întotdeauna comanda \fBxz\fP cu argumentele adecvate (\fBxz \-d\fP sau +\fBxz \-dc\fP) în loc de comenzile \fBunxz\fP și \fBxzcat\fP. +. +.SH DESCRIERE +\fBxz\fP este un instrument de comprimare a datelor de uz general cu sintaxă de +linie de comandă similară cu \fBgzip\fP(1) și \fBbzip2\fP(1). Formatul de fișier +nativ este formatul \fB.xz\fP, dar formatul vechi \fB.lzma\fP folosit de LZMA +Utils și fluxurile comprimate brute fără anteturi de format container sunt +de asemenea acceptate. În plus, este acceptată decomprimarea formatului +\&\fB.lz\fP folosit de \fBlzip\fP. +.PP +\fBxz\fP comprimă sau decomprimă fiecare \fIfișier\fP în funcție de modul de +operare selectat. Dacă nu sunt date \fIfișiere\fP sau \fIfișier\fP este \fB\-\fP, +\fBxz\fP citește de la intrarea standard și scrie datele procesate la ieșirea +standard. \fBxz\fP va refuza (afișează o eroare și omite \fIfișier\fP) să scrie +date comprimate la ieșirea standard dacă este un terminal. În mod similar, +\fBxz\fP va refuza să citească datele comprimate de la intrarea standard dacă +este un terminal. +.PP +Cu excepția cazului în care este specificată opțiunea \fB\-\-stdout\fP, +\fIfișierele\fP altele decât \fB\-\fP sunt scrise într\-un fișier nou al cărui nume +este derivat din numele \fIfișierului\fP sursă: +.IP \(bu 3 +La comprimare, sufixul formatului de fișier țintă (\fB.xz\fP sau \fB.lzma\fP) este +atașat la numele fișierului sursă pentru a se obține numele fișierului +țintă. +.IP \(bu 3 +La decomprimare, sufixul \fB.xz\fP, \fB.lzma\fP sau \fB.lz\fP este eliminat din +numele fișierului pentru a se obține numele fișierului țintă. \fBxz\fP +recunoaște și sufixele \fB.txz\fP și \fB.tlz\fP și le înlocuiește cu sufixul +\&\fB.tar\fP. +.PP +Dacă fișierul țintă există deja, este afișată o eroare și \fIfișier\fP este +omis. +.PP +Cu excepția cazului în care scrie la ieșirea standard, \fBxz\fP va afișa un +avertisment și va omite \fIfișier\fPul dacă se aplică oricare dintre +următoarele: +.IP \(bu 3 +\fIFișierul\fP nu este un fișier obișnuit. Legăturile simbolice nu sunt urmate +și, prin urmare, nu sunt considerate fișiere obișnuite. +.IP \(bu 3 +\fIFișierul\fP are mai mult de o legătură dură. +.IP \(bu 3 +\fIFișierul\fP are activat bitul «setuid», «setgid» sau cel lipicios(sticky). +.IP \(bu 3 +Modul de operare este stabilit la comprimare și \fIfișier\fP are deja un sufix +al formatului de fișier țintă (\fB.xz\fP sau \fB.txz\fP când se comprimă în +formatul \fB.xz\fP și \fB.lzma\fP sau \fB.tlz\fP când se comprimă în formatul +\&\fB.lzma\fP). +.IP \(bu 3 +Modul de operare este stabilit la decomprimare și \fIfișierul\fP nu are un +sufix al niciunui format de fișier acceptat (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, +\&\fB.tlz\fP, sau \fB.lz\fP). +.PP +După comprimarea sau decomprimarea cu succes a \fIfișierului\fP, \fBxz\fP copiază +proprietarul, grupul, permisiunile, timpul de acces și timpul de modificare +din \fIfișierul\fP sursă în fișierul țintă. Dacă copierea grupului eșuează, +permisiunile sunt modificate astfel încât fișierul țintă să nu devină +accesibil utilizatorilor care nu aveau permisiunea de a accesa \fIfișierul\fP +sursă. \fBxz\fP nu acceptă încă copierea altor metadate, cum ar fi listele de +control al accesului sau atributele extinse. +.PP +Odată ce fișierul țintă a fost închis cu succes, \fIfișierul\fP sursă este +eliminat dacă nu a fost specificată opțiunea \fB\-\-keep\fP. \fIFișierul\fP sursă nu +este niciodată eliminat dacă rezultatul este scris la ieșirea standard sau +dacă apare o eroare. +.PP +Trimiterea unui semnal \fBSIGINFO\fP sau \fBSIGUSR1\fP către procesul \fBxz\fP face +ca acesta să imprime informații despre progres la ieșirea de eroare +standard. Acest lucru are o utilizare limitată, deoarece atunci când ieșirea +de eroare standard este un terminal, folosind opțiunea \fB\-\-verbose\fP va afișa +un indicator de progres de actualizare automată. +. +.SS "Utilizarea memoriei" +Cantitatea de memorie utilizată de \fBxz\fP variază de la câteva sute de +kiloocteți la câțiva gigaocteți, în funcție de opțiunile de +comprimare. Opțiunile utilizate la comprimarea unui fișier determină +cerințele de memorie ale instrumentului de decomprimare. De obicei, +instrumentul de decomprimare are nevoie de 5% până la 20% din cantitatea de +memorie de care a avut nevoie instrumentul de comprimare la crearea +fișierului. De exemplu, decomprimarea unui fișier creat cu \fBxz \-9\fP necesită +în prezent 65Mio de memorie. Totuși, este posibil să aveți fișiere \fB.xz\fP +care necesită câțiva gigaocteți de memorie pentru decomprimare. +.PP +În special utilizatorii de sisteme mai vechi pot considera deranjantă +posibilitatea unei utilizări foarte mari a memoriei. Pentru a preveni +surprizele neplăcute, \fBxz\fP are încorporat un limitator de utilizare a +memoriei, care este dezactivat implicit. În timp ce unele sisteme de operare +oferă modalități de a limita utilizarea memoriei proceselor, bazarea pe +aceasta nu a fost considerată a fi suficient de flexibilă (de exemplu, +utilizarea \fBulimit\fP(1) pentru a limita memoria virtuală tinde să paralizeze +\fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Limitatorul de utilizare a memoriei poate fi activat cu opțiunea din linia +de comandă \fB\-\-memlimit=\fP\fIlimita\fP. Adesea este mai convenabil să activați +limitatorul în mod implicit prin definirea variabilei de mediu +\fBXZ_DEFAULTS\fP, de exemplu, \fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Este posibil +să stabiliți limitele separat pentru comprimare și decomprimare folosind +\fB\-\-memlimit\-compress=\fP\fIlimita\fP și +\fB\-\-memlimit\-decompress=\fP\fIlimita\fP. Utilizarea acestor două opțiuni în afara +\fBXZ_DEFAULTS\fP este foarte rar utilă, deoarece o singură rulare a \fBxz\fP nu +poate face atât comprimarea, cât și decomprimarea și \fB\-\-memlimit=\fP\fIlimita\fP +(sau \fB\-M\fP \fIlimita\fP ) este mai scurt de tastat pe linia de comandă. +.PP +Dacă limita de utilizare a memoriei specificată este depășită la +decomprimare, \fBxz\fP va afișa o eroare și decomprimarea fișierului va +eșua. Dacă limita este depășită la comprimare, \fBxz\fP va încerca să reducă +valorile stabilite astfel încât limita să nu mai fie depășită (cu excepția +cazului în care se utilizează opțiunea \fB\-\-format=raw\fP sau +\fB\-\-no\-adjust\fP). În acest fel, operațiunea nu va eșua decât dacă limita +stabilită este foarte mică. Scalarea valorilor stabilite se face în pași +care nu se potrivesc cu valorile prestabilite ale nivelului de comprimare, +de exemplu, dacă limita este doar puțin mai mică decât cantitatea necesară +pentru \fBxz \-9\fP, valorile stabilite vor fi reduse doar puțin , nu până la +valoarea prestabilită a lui \fBxz \-8\fP. +. +.SS "Concatenare și completare (prin umplere cu octeți nuli) cu fișiere .xz" +Este posibil să concatenați fișierele \fB.xz\fP așa cum sunt. \fBxz\fP va +decomprima astfel de fișiere ca și cum ar fi un singur fișier \fB.xz\fP. +.PP +Este posibil să se introducă umplutură între părțile concatenate sau după +ultima parte. Umplutura trebuie să fie compusă din octeți nuli, iar +dimensiunea umpluturii trebuie să fie un multiplu de patru octeți. Acest +lucru poate fi util, de exemplu, dacă fișierul \fB.xz\fP este stocat pe un +mediu care măsoară dimensiunile fișierelor în blocuri de 512 de octeți. +.PP +Concatenarea și completarea nu sunt permise cu fișierele \fB.lzma\fP sau +fluxurile brute. +. +.SH OPȚIUNI +. +.SS "Sufixe de numere întregi și valori speciale" +În majoritatea locurilor în care este de așteptat un număr întreg ca +argument, un sufix opțional este acceptat pentru a indica cu ușurință +numerele întregi mari. Nu trebuie să existe spațiu între numărul întreg și +sufix. +.TP +\fBKiB\fP +Înmulțește numărul întreg cu 1.024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP și +\fBKB\fP sunt acceptate ca sinonime pentru \fBKiB\fP. +.TP +\fBMiB\fP +Înmulțește numărul întreg cu 1,048,576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP, și \fBMB\fP +sunt acceptate ca sinonime pentru \fBMiB\fP. +.TP +\fBGiB\fP +Înmulțește numărul întreg cu 1,073,741,824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP, și +\fBGB\fP sunt acceptate ca sinonime pentru \fBGiB\fP. +.PP +Valoarea specială \fBmax\fP poate fi utilizată pentru a indica valoarea maximă +întreagă suportată de opțiune. +. +.SS "Mod de operare" +Dacă sunt date mai multe opțiuni de mod de funcționare, ultima dintre ele, +este cea care va avea efect. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Comprimare. Acesta este modul de operare implicit atunci când nu este +specificată nicio opțiune de mod de funcționare și nici un alt mod de +operare nu este implicat din numele comenzii (de exemplu, \fBunxz\fP implică +\fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +După o comprimare reușită, fișierul sursă este eliminat, cu excepția cazului +în care a fost specificată scrierea la ieșirea standard sau opțiunea +\fB\-\-keep\fP. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Decomprimare. După o decomprimare reușită, fișierul sursă este eliminat, cu +excepția cazului în care a fost specificată scrierea la ieșirea standard sau +opțiunea \fB\-\-keep\fP. +.TP +\fB\-t\fP, \fB\-\-test\fP +Testează integritatea \fIfișierelor\fP comprimate. Această opțiune este +echivalentă cu \fB\-\-decompress \-\-stdout\fP cu excepția faptului că datele +decomprimate sunt înlăturate în loc să fie scrise la ieșirea standard. Nu +sunt create sau eliminate fișiere. +.TP +\fB\-l\fP, \fB\-\-list\fP +Afișează informații despre \fIfișiere\fP comprimate. Nu are loc nicio +decomprimare la ieșire și nu sunt create sau eliminate fișiere. În modul +listă, programul nu poate citi datele comprimate din intrarea standard sau +din alte surse care nu pot fi explorate. +.IP "" +Listarea implicită arată informații de bază despre \fIfișiere\fP, câte un +fișier pe linie. Pentru a obține informații mai detaliate, utilizați și +opțiunea \fB\-\-verbose\fP. Pentru și mai multe informații, utilizați opțiunea +\fB\-\-verbose\fP de două ori, dar rețineți că acest lucru poate fi lent, +deoarece obținerea tuturor informațiilor suplimentare necesită multe +căutări. Lățimea ieșirii detaliate depășește 80 de caractere, deci +canalizarea ieșirii către, de exemplu, \fBless\ \-S\fP poate fi convenabilă dacă +terminalul nu este suficient de lat. +.IP "" +Ieșirea exactă poate varia între versiunile \fBxz\fP și diferitele +localizări(configurările regionale). Pentru ieșiri care pot fi citite de +mașină, ar trebui utilizată opțiunea \fB\-\-robot \-\-list\fP. +. +.SS "Modificatori de operare" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Nu șterge fișierele de intrare. +.IP "" +Începând cu \fBxz\fP 5.2.6, această opțiune face ca \fBxz\fP să comprime sau să +decomprime, chiar dacă intrarea este o legătură simbolică către un fișier +obișnuit, are mai mult de\-o legătură dură sau are marcați biții setuid, +setgid sau bitul lipicios. Biții setuid, setgid și bitul lipicios nu sunt +copiați în fișierul țintă. În versiunile anterioare acest lucru se făcea +numai cu ajutorul opțiunii \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Această opțiune are mai multe efecte: +.RS +.IP \(bu 3 +Dacă fișierul țintă există deja, îl șterge înainte de comprimare sau +decomprimare. +.IP \(bu 3 +Comprimă sau decomprimă chiar dacă intrarea este o legătură simbolică către +un fișier obișnuit, are mai mult de\-o legătură dură sau are marcați biții +setuid, setgid sau bitul lipicios. Biții setuid, setgid și bitul lipicios nu +sunt copiați în fișierul țintă. +.IP \(bu 3 +Când este utilizată cu opțiunile \fB\-\-decompress\fP și \fB\-\-stdout\fP, comanda +\fBxz\fP nu poate recunoaște tipul fișierului sursă, și copiază fișierul sursă +așa cum este la ieșirea standard. Acest lucru permite comenzii \fBxzcat\fP +\fB\-\-force\fP să fie folosită drept comanda \fBcat\fP(1) pentru fișierele care nu +au fost comprimate cu \fBxz\fP. Rețineți că, în viitor, \fBxz\fP ar putea să +accepte noi formate de fișiere comprimate, ceea ce poate face ca \fBxz\fP să +decomprime mai multe tipuri de fișiere în loc să le copieze așa cum sunt la +ieșirea standard. Opțiunea \fB\-\-format=\fP\fIformat\fP poate fi folosită pentru a +restricționa \fBxz\fP să decomprime doar un singur format de fișier. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Scrie datele comprimate sau decomprimate la ieșirea standard în loc de +într\-un fișier. Aceasta implică \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Decomprimă numai primul flux \fB.xz\fP și ignoră în tăcere posibilele date de +intrare rămase în urma fluxului. În mod normal, astfel de resturi rămase +face ca \fBxz\fP să afișeze o eroare. +.IP "" +\fBxz\fP nu decomprimă niciodată mai mult de un flux din fișierele \fB.lzma\fP sau +din fluxurile brute, dar această opțiune face ca \fBxz\fP să ignore posibilele +resturi de date rămase după fișierul \fB.lzma\fP sau fluxul brut. +.IP "" +Această opțiune nu are efect dacă modul de funcționare nu este +\fB\-\-decompress\fP sau \fB\-\-test\fP. +.IP "" +Începând cu \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP implică \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Dezactivează crearea de fișiere dispersate. În mod implicit, dacă decomprimă +într\-un fișier obișnuit, \fBxz\fP încearcă să facă fișierul dispersat dacă +datele decomprimate conțin secvențe lungi de zerouri binare. De asemenea, +funcționează atunci când scrie la ieșirea standard, atâta timp cât ieșirea +standard este conectată la un fișier obișnuit și sunt îndeplinite anumite +condiții suplimentare pentru a o face în siguranță. Crearea de fișiere +dispersate poate economisi spațiu pe disc și poate accelera decomprimarea +prin reducerea cantității de date de In/Ieș pe disc. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Când comprimă, utilizează \fI.suf\fP ca sufix pentru fișierul țintă în loc de +\&\fB.xz\fP sau \fB.lzma\fP. Dacă nu scrie la ieșirea standard și fișierul sursă are +deja sufixul \fI.suf\fP, este afișat un avertisment și fișierul este omis. +.IP "" +Când decomprimă, recunoaște fișierele cu sufixul \fI.suf\fP în plus față de +fișierele cu sufixul \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP sau \fB.lz\fP. Dacă +fișierul sursă are sufixul \fI.suf\fP, sufixul este eliminat pentru a obține +numele fișierului țintă. +.IP "" +La comprimarea sau decomprimarea fluxurilor brute (\fB\-\-format=raw\fP), sufixul +trebuie să fie întotdeauna specificat, cu excepția cazului în care se scrie +la ieșirea standard, deoarece nu există un sufix implicit pentru fluxurile +brute. +.TP +\fB\-\-files\fP[\fB=\fP\fIfișier\fP] +Citește numele fișierelor de procesat din \fIfișier\fP; dacă \fIfișierul\fP este +omis, numele fișierelor sunt citite de la intrarea standard. Numele de +fișiere trebuie să fie terminate cu caracterul de linie nouă. O liniuță +(\fB\-\fP) este luată ca nume de fișier obișnuit; nu înseamnă intrarea +standard. Dacă numele de fișiere sunt date și ca argumente în linia de +comandă, ele sunt procesate înainte ca numele fișierelor să fie citite din +\fIfișier\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIfișier\fP] +Această opțiune este identică cu \fB\-\-files\fP[\fB=\fP\fIfișier\fP], cu excepția +faptului că fiecare nume de fișier trebuie să fie terminat cu caracterul +nul. +. +.SS "Formatul de bază al fișierului și opțiunile de comprimare" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fIformat\fP +Specifică \fIformatul\fP fișierului pentru comprimare sau decomprimare: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Aceasta este valoarea implicită. La comprimare, \fBauto\fP este echivalent cu +\fBxz\fP. La decomprimare, formatul fișierului de intrare este detectat +automat. Rețineți că fluxurile brute (create cu \fB\-\-format=raw\fP) nu pot fi +detectate automat. +.TP +\fBxz\fP +Comprimă în formatul de fișier \fB.xz\fP sau acceptă numai fișierele \fB.xz\fP +când decomprimă. +.TP +\fBlzma\fP, \fBalone\fP +Comprimă în formatul de fișier \fB.lzma\fP vechi sau acceptă numai fișierele +\&\fB.lzma\fP când decomprimă. Numele alternativ \fBalone\fP este furnizat pentru +compatibilitatea cu versiunile mai vechi de LZMA Utils. +.TP +\fBlzip\fP +Acceptă numai fișierele \fB.lz\fP când decomprimă. Comprimarea nu este +acceptată. +.IP "" +Sunt acceptate versiunile 0 și 1 ale formatului \fB.lz\fP. Fișierele versiunii +0 au fost create cu \fBlzip\fP 1.3 și versiuni mai vechi. Astfel de fișiere nu +sunt comune, dar pot fi găsite în arhivele de fișiere, deoarece câteva +pachete sursă au fost lansate în acest format. Este posibil ca oamenii să +aibă și fișiere personale vechi în acest format. Suportul pentru +decomprimare pentru versiunea 0 a formatului a fost eliminat în \fBlzip\fP +1.18. \fBlzip\fP 1.4 și versiunile ulterioare creează fișiere în versiunea 1 a +formatului. +.TP +\fBraw\fP +Comprimă sau decomprimă un flux brut (fără anteturi). Acest lucru este +destinat doar utilizatorilor avansați. Pentru a decodifica fluxurile brute, +trebuie să utilizați opțiunea \fB\-\-format=raw\fP și să specificați în mod +explicit lanțul de filtre, care în mod normal ar fi fost stocat în +anteturile containerului. +.RE +.TP +\fB\-C\fP \fIverificarea\fP, \fB\-\-check=\fP\fIverificarea\fP +Specifică tipul verificării integrității. Verificarea este calculată din +datele necomprimate și stocată în fișierul \fB.xz\fP. Această opțiune are efect +numai la comprimarea în format \fB.xz\fP; formatul \fB.lzma\fP nu acceptă +verificări de integritate. Verificarea integrității (dacă există) este +efectuată atunci când fișierul \fB.xz\fP este decomprimat. +.IP "" +Tipuri de \fIverificare\fP acceptate: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Nu calculează deloc o verificare a integrității. Aceasta este de obicei o +idee proastă. Acest lucru poate fi util atunci când integritatea datelor +este oricum verificată prin alte mijloace. +.TP +\fBcrc32\fP +Calculează CRC32 folosind polinomul din IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Calculează CRC64 folosind polinomul din ECMA\-182. Aceasta este valoarea +implicită, deoarece este ceva mai bună decât CRC32 la detectarea fișierelor +deteriorate, iar diferența de viteză este neglijabilă. +.TP +\fBsha256\fP +Calculează SHA\-256. Acest lucru este oarecum mai lent decât CRC32 și CRC64. +.RE +.IP "" +Integritatea antetelor \fB.xz\fP este întotdeauna verificată cu CRC32. Nu este +posibilă modificarea sau dezactivarea acesteia. +.TP +\fB\-\-ignore\-check\fP +Nu efectuează verificarea integrității datelor comprimate la +decomprimare. Valorile CRC32 din antetele \fB.xz\fP vor fi însă verificate +normal. +.IP "" +\fBNu utilizați această opțiune decât dacă știți ce faceți\fP. Motive posibile +pentru a utiliza această opțiune: +.RS +.IP \(bu 3 +Încercarea de a recupera datele dintr\-un fișier .xz corupt. +.IP \(bu 3 +Accelerarea decomprimării. Acest lucru contează mai ales cu SHA\-256 sau cu +fișierele care s\-au comprimat extrem de bine. Este recomandat să nu +utilizați această opțiune în acest scop decât dacă integritatea fișierului +este verificată extern într\-un alt mod. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Selectează un nivel prestabilit de comprimare. Valoarea implicită este +\fB\-6\fP. Dacă sunt specificate mai multe niveluri prestabilite, ultimul are +efect. Dacă a fost deja specificat un lanț de filtre personalizat, +specificarea unui nivel prestabilit de comprimare șterge lanțul de filtre +personalizat. +.IP "" +Diferențele dintre valorile prestabilite sunt mai semnificative decât cu +\fBgzip\fP(1) și \fBbzip2\fP(1). Valorile de comprimare selectate determină +cerințele de memorie ale instrumentului de decomprimare, astfel încât +utilizarea unui nivel prea mare prestabilit ar putea face „dureroasă” +decomprimarea fișierului pe un sistem vechi cu puțină memorie RAM. Mai +exact, \fBnu este o idee bună să folosiți orbește \-9 pentru tot\fP așa cum se +întâmplă adesea cu \fBgzip\fP(1) și \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Acestea sunt valorile prestabilite oarecum rapide. \fB\-0\fP este uneori mai +rapid decât \fBgzip \-9\fP în timp ce comprimă mult mai bine. Cele mai ridicate +au adesea viteza comparabilă cu \fBbzip2\fP(1) cu un raport de comprimare +comparabil sau mai bun, deși rezultatele depind foarte mult de tipul de date +care sunt comprimate. +.TP +\fB\-4\fP ... \fB\-6\fP +Comprimare bună spre foarte bună, păstrând în același timp utilizarea +memoriei de către instrumentul de decomprimare la un nivel rezonabil chiar +și pentru sistemele vechi. \fB\-6\fP este valoarea implicită, care este de +obicei o alegere bună pentru distribuirea fișierelor care trebuie să poată +fi decomprimate chiar și pe sisteme cu doar 16Mio de memorie RAM. Opțiunile +(\fB\-5e\fP sau \fB\-6e\fP ar putea fi demne de luat în considerare. A se vedea +opțiunea \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Acestea sunt precum \fB\-6\fP, dar cu cerințe mai mari de memorie pentru +comprimare și decomprimare. Acestea sunt utile numai atunci când comprimați +fișiere mai mari de 8Mio, 16Mio și, respectiv, 32Mio. +.RE +.IP "" +Pe același hardware, viteza de decomprimare este aproximativ un număr +constant de octeți de date comprimate pe secundă. Cu alte cuvinte, cu cât +comprimarea este mai bună, cu atât decomprimarea va fi de obicei mai +rapidă. Aceasta înseamnă, de asemenea, că valoarea de la ieșire a cantității +de date necomprimate produsă pe secundă poate varia foarte mult. +.IP "" +Următorul tabel rezumă caracteristicile valorilor prestabilite: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +ValPrestab;DimDict;CPUComp;MemComp;MemDec +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Descrieri coloane: +.RS +.IP \(bu 3 +DimDict este dimensiunea dicționarului LZMA2. Este o risipă de memorie să +folosești un dicționar mai mare decât dimensiunea fișierului necomprimat. De +aceea este bine să evitați utilizarea valorilor prestabilite \fB\-7\fP ... \fB\-9\fP +atunci când nu este nevoie cu adevărat de ele. Pentru valoarea prestabilită +\fB\-6\fP sau alta mai mică, cantitatea de memorie irosită este de obicei +suficient de mică pentru a nu conta. +.IP \(bu 3 +CPUComp este o reprezentare simplificată a configurărilor LZMA2 care +afectează viteza de comprimare. Dimensiunea dicționarului afectează și +viteza, așa că, în timp ce CPUComp este aceeași pentru nivelurile \fB\-6\fP +\&... \fB\-9\fP, nivelurile mai mari tind să fie puțin mai lente. Pentru a obține +o comprimare și mai lentă și, astfel, posibil mai bună, consultați opțiunea +\fB\-\-extreme\fP. +.IP \(bu 3 +MemComp conține cerințele de memorie ale comprimării în modul cu un singur +fir de execuție. Poate varia ușor între versiunile \fBxz\fP. +.IP \(bu 3 +MemDec conține cerințele de memorie pentru decomprimare. Adică, +configurările de comprimare determină cerințele de memorie ale +decomprimării. Cantitatea exactă a memoriei utilizate la decomprimare este +puțin mai mare decât dimensiunea dicționarului LZMA2, dar valorile din tabel +au fost rotunjite la următorul Mio. +.RE +.IP "" +Cerințele de memorie ale modului cu mai multe fire de execuție sunt +semnificativ mai mari decât cele ale modului cu un singur fir de +execuție. Cu valoarea implicită a lui \fB\-\-block\-size\fP, fiecare fir are +nevoie de 3*3*DictSize plus MemComp sau MemDec. De exemplu, patru fire de +execuție cu valoarea prestabilită \fB\-6\fP au nevoie de 660\(en670\ Mio de +memorie. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Utilizează o variantă mai lentă a nivelului prestabilit de comprimare +selectat (\fB\-0\fP ... \fB\-9\fP) pentru a obține un raport de comprimare puțin mai +bun, dar din nefericire, acest lucru îl poate înrăutăți. Utilizarea memoriei +pentru decomprimare nu este afectată, dar utilizarea memoriei la comprimare +crește puțin la nivelurile prestabilite \fB\-0\fP ... \fB\-3\fP. +.IP "" +Deoarece există două valori prestabilite cu dimensiuni ale dicționarului de +4Mio și 8Mio, valorile prestabilite \fB\-3e\fP și \fB\-5e\fP folosesc configurări +puțin mai rapide (CPUComp mai mic) decât \fB\-4e\fP și \fB\-6e\fP, respectiv. În +acest fel, nu există două nivele prestabilite identice. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +ValPrestab;DimDict;CPUComp;MemComp;MemDec +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +De exemplu, există un total de patru nivele prestabilite care folosesc +dicționarul 8Mio, a căror ordine de la cel mai rapid la cel mai lent este +\fB\-5\fP, \fB\-6\fP, \fB\-5e\fP și \fB\-6e\fP . +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Acestea sunt alias de opțiuni, oarecum înșelătoare pentru \fB\-0\fP și, +respectiv, \fB\-9\fP. Acestea sunt furnizate numai pentru compatibilitatea cu +LZMA Utils. Evitați utilizarea acestor opțiuni. +.TP +\fB\-\-block\-size=\fP\fIdimensiunea\fP +Când comprimă în formatul \fB.xz\fP, împarte datele de intrare în blocuri de +\fIdimensiunea\fP octeți. Blocurile sunt comprimate independent unul de +celălalt, ceea ce ajută în modul cu mai multe fire de execuție și face +posibilă decomprimarea cu acces aleatoriu limitat. Această opțiune este de +obicei folosită pentru a suprascrie dimensiunea implicită a blocului în +modul cu mai multe fire de execuție, dar această opțiune poate fi folosită +și în modul cu un singur fir de execuție. +.IP "" +În modul cu mai multe fire de execuție, aproximativ de trei ori +\fIdimensiunea\fP de octeți vor fi alocați în fiecare fir pentru stocarea +intrării și ieșirii. \fIDimensiunea\fP implicită este de trei ori dimensiunea +dicționarului LZMA2 sau 1Mio, oricare dintre acestea este mai mare. În mod +obișnuit, o valoare bună este de două la patru ori dimensiunea dicționarului +LZMA2 sau de cel puțin 1Mio. Utilizarea unei \fIdimensiuni\fP mai mici decât +dimensiunea dicționarului LZMA2 este o risipă de memorie RAM, deoarece +atunci memoria tampon a dicționarului LZMA2 nu va fi niciodată utilizată pe +deplin. În modul cu mai multe fire de execuție, dimensiunile blocurilor sunt +stocate în anteturile blocurilor. Aceste informații privind dimensiunea sunt +necesare pentru decomprimarea cu mai multe fire. +.IP "" +În modul cu un singur fir de execuție, nicio divizare a blocurilor nu se +face în mod implicit. Folosirea acestei opțiuni nu afectează utilizarea +memoriei. Nu sunt stocate informații despre dimensiune în antetele +blocurilor, astfel încât fișierele create în modul cu un singur fir de +execuție nu vor fi identice cu fișierele create în modul cu mai multe fire +de execuție. Lipsa informațiilor privind dimensiunea înseamnă, de asemenea, +că \fBxz\fP nu va putea decomprima fișierele în modul cu mai multe fire. de +execuție. +.TP +\fB\-\-block\-list=\fP\fIelemente\fP +Când comprimă în formatul \fB.xz\fP, începe un nou bloc cu un lanț de filtre +personalizat opțional după intervalele specificate de date necomprimate. +.IP "" +\fIelementele\fP sunt o listă separată prin virgule. Fiecare element este +format dintr\-un număr opțional de lanț de filtrare între 0 și 9, urmat de +două puncte (\fB:\fP) și de o dimensiune cerută a datelor +necomprimate. Omiterea unui element (două sau mai multe virgule consecutive) +este o prescurtare pentru a utiliza dimensiunea și filtrele din elementul +anterior. +.IP "" +În cazul în care fișierul de intrare este mai mare decât suma dimensiunilor +din \fIelemente\fP, ultimul element se repetă până la sfârșitul fișierului. O +valoare specială de \fB0\fP poate fi utilizată ca ultimă dimensiune pentru a +indica faptul că restul fișierului trebuie să fie codificat ca un singur +bloc. +.IP "" +Un lanț de filtre alternativ pentru fiecare bloc poate fi specificat în +combinație cu opțiunile \fB\-\-filters1=\fP\fIfiltre\fP \&...\& +\fB\-\-filters9=\fP\fIfiltre\fP. Aceste opțiuni definesc lanțuri de filtre cu un +identificator cuprins între 1\(en9. Lanțul de filtre 0 poate fi utilizat +pentru a se referi la lanțul de filtre implicit, ceea ce este același lucru +cu a nu specifica un lanț de filtre. Identificatorul lanțului de filtre +poate fi utilizat înaintea dimensiunii necomprimate, urmat de două puncte +(\fB:\fP). De exemplu, dacă se specifică +\fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP, atunci blocurile vor fi +create folosind: +.RS +.IP \(bu 3 +Lanțul de filtre specificat de \fB\-\-filters1\fP și 2 Mio de intrare +.IP \(bu 3 +Lanțul de filtre specificat de \fB\-\-filters3\fP și 2 Mio de intrare +.IP \(bu 3 +Lanțul de filtre specificat de \fB\-\-filters2\fP și 4 Mio de intrare +.IP \(bu 3 +Lanțul de filtre specificat de \fB\-\-filters2\fP și 4 Mio de intrare +.IP \(bu 3 +Lanțul de filtre implicit și 2 MiB de intrare +.IP \(bu 3 +Lanțul de filtre implicit și 4 MiB de intrare pentru fiecare bloc până la +sfârșitul intrării. +.RE +.IP "" +Dacă se specifică o dimensiune care depășește dimensiunea blocului +codificatorului (fie valoarea implicită în modul cu fire de execuție, fie +valoarea specificată cu \fB\-\-block\-size=\fP\fIdimensiune\fP), codificatorul va +crea blocuri suplimentare, păstrând limitele specificate în \fIelemente\fP. De +exemplu, dacă se specifică \fB\-\-block\-size=10MiB\fP +\fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP și fișierul de intrare este de +80 MiB, se vor obține 11 blocuri: 5, 10, 8, 10, 10, 2, 10, 10, 10, 4, 10, +10, 10 și 1 Mio. +.IP "" +În modul cu mai multe fire de execuție, dimensiunile blocurilor sunt stocate +în antetele blocurilor. Acest lucru nu se face în modul cu un singur fir de +execuție, astfel încât ieșirea codificată nu va fi identică cu cea a modului +cu mai multe fire de execuție. +.TP +\fB\-\-flush\-timeout=\fP\fItimp_limită\fP +La comprimare, dacă au trecut mai mult de \fItimp_limită\fP milisecunde (un +întreg pozitiv) de la curățarea anterioară și citirea mai multor intrări +s\-ar bloca, toate datele de intrare în așteptare sunt eliminate din +codificator și puse la dispoziție în fluxul de ieșire. Acest lucru poate să +fie util dacă \fBxz\fP este utilizat pentru a comprima datele care sunt +transmise în flux printr\-o rețea. Valorile mici de \fItimp_limită\fP fac datele +disponibile la capătul de recepție cu o mică întârziere, dar valorile mari +de \fItimp_limită\fP oferă un raport de comprimare mai bun. +.IP "" +Această caracteristică este dezactivată în mod implicit. Dacă această +opțiune este specificată de mai multe ori, ultima este cea care se ia în +considerare. Valoarea specială a lui \fItimp_limită\fP de \fB0\fP, poate fi +utilizată pentru a dezactiva în mod explicit această caracteristică. +.IP "" +Această caracteristică nu este disponibilă în sistemele non\-POSIX. +.IP "" +.\" FIXME +\fBAceastă caracteristică este încă experimentală\fP. În prezent, \fBxz\fP este +nepotrivit pentru decomprimarea fluxului în timp real datorită modului în +care \fBxz\fP utilizează memoria tampon. +.TP +\fB\-\-no\-sync\fP +Nu sincronizează fișierul țintă și directorul acestuia cu dispozitivul de +stocare înainte de a elimina fișierul sursă. Acest lucru poate îmbunătăți +performanța în cazul comprimării sau decomprimării multor fișiere mici. Cu +toate acestea, dacă sistemul se blochează imediat după ștergere, este +posibil ca fișierul țintă să nu fi fost scris pe dispozitivul de stocare, +dar operația de ștergere să fi fost. În acest caz, nici fișierul sursă +original, nici fișierul țintă nu sunt disponibile. +.IP "" +Această opțiune are efect numai atunci când \fBxz\fP urmează să elimine +fișierul sursă. În alte cazuri, sincronizarea nu se face niciodată. +.IP "" +Sincronizarea și \fB\-\-no\-sync\fP au fost adăugate în \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIlimita\fP +Stabilește o limită de utilizare a memoriei pentru comprimare. Dacă această +opțiune este specificată de mai multe ori, ultima va avea efect. +.IP "" +Dacă parametrii de comprimare depășesc \fIlimita\fP, \fBxz\fP va încerca să +ajusteze parametrii scăzând valorile acestora, astfel încât limita să nu mai +fie depășită și va afișa o notificare că ajustarea automată a fost +efectuată. Ajustările se fac în această ordine: reducerea numărului de fire, +trecerea la modul un singur fir de execuție dacă chiar și un singur fir în +modul cu mai multe fire de execuție depășește \fIlimita\fP și, în final, +reducerea dimensiunii dicționarului LZMA2. +.IP "" +Când comprimă cu opțiunea \fB\-\-format=raw\fP sau dacă a fost specificată +opțiunea \fB\-\-no\-adjust\fP, numai numărul de fire poate fi redus, deoarece se +poate face fără a afecta rezultatul comprimării. +.IP "" +Dacă \fIlimita\fP nu poate fi îndeplinită chiar și cu ajustările descrise mai +sus, este afișată o eroare și \fBxz\fP va ieși cu starea de ieșire 1. +.IP "" +\fILimita\fP poate fi specificata în mai multe moduri: +.RS +.IP \(bu 3 +\fILimita\fP poate fi o valoare absolută în octeți. Utilizarea unui sufix +întreg precum \fBMiB\fP poate fi utilă. De exemplu: +\fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +\fILimita\fP poate fi specificată ca procent din memoria fizică totală +(RAM). Acest lucru poate fi util mai ales atunci când definiți variabila de +mediu \fBXZ_DEFAULTS\fP într\-un script de inițializare shell care este partajat +între diferite calculatoare. În acest fel, limita este automat mai mare pe +sistemele cu mai multă memorie. De exemplu: \fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +\fILimita\fP poate fi restabilită la valoarea implicită dându\-i valoarea +\fB0\fP. În prezent, aceasta este echivalentă cu stabilirea \fIlimitei\fP la +\fBmax\fP (fără limită de utilizare a memoriei). +.RE +.IP "" +Pentru \fBxz\fP pe 32 de biți există un caz special: dacă \fIlimita\fP ar fi peste +\fB4020MiB\fP, \fIlimita\fP este stabilită la \fB4020MiB\fP. Pe MIPS32 este +stabilită în schimb la \fB2000MiB\fP; (valorile \fB0\fP și \fBmax\fP nu sunt afectate +de acest lucru \-\- o caracteristică similară nu există pentru +decomprimare). Acest lucru poate fi util atunci când un executabil pe 32 de +biți are acces la un spațiu de adrese de 4Gio (2Gio pe MIPS32), se speră că +nu produce daune în alte situații. +.IP "" +Consultați și secțiunea \fBUtilizarea memoriei\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIlimita\fP +Stabilește o limită de utilizare a memoriei pentru decomprimare. Acest lucru +afectează și modul \fB\-\-list\fP. Dacă operațiunea nu este posibilă fără a +depăși \fIlimita\fP, \fBxz\fP va afișa o eroare și decomprimarea fișierului va +eșua. Consultați \fB\-\-memlimit\-compress=\fP\fIlimita\fP pentru modalitățile +posibile de a specifica \fIlimita\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimita\fP +Stabilește o limită de utilizare a memoriei pentru decomprimarea cu mai +multe fire de execuție. Acest lucru poate afecta doar numărul de fire de +execuție; acest lucru nu îl va face niciodată pe \fBxz\fP să refuze +decomprimarea unui fișier. Dacă \fIlimita\fP este prea scăzută pentru a permite +orice mod cu mai multe fire de execuție, \fIlimita\fP este ignorată și \fBxz\fP va +continua în modul cu un singur fir de execuție. Rețineți că, dacă se +folosește și opțiunea \fB\-\-memlimit\-decompress\fP, se va aplica întotdeauna +atât modurilor cu un singur fir de execuție, cât și modurilor cu mai multe +fire de execuție și astfel \fIlimita\fP efectivă pentru modul cu mai multe fire +de execuție nu va fi niciodată mai mare decât limita stabilită cu opțiunea +\fB\-\-memlimit\-decompress\fP. +.IP "" +Spre deosebire de celelalte opțiuni de limită de utilizare a memoriei, +opțiunea \fB\-\-memlimit\-mt\-decompress=\fP\fIlimita\fP are o \fIlimită\fP implicită +specifică sistemului. Comanda \fBxz \-\-info\-memory\fP poate fi folosită pentru a +vedea valoarea curentă. +.IP "" +Această opțiune și valoarea ei implicită există deoarece, fără nicio limită, +decomprimarea cu (mai multe) fire de execuție ar putea ajunge să aloce o +cantitate „nebună” de memorie cu unele fișiere de intrare. Dacă \fIlimita\fP +implicită este prea scăzută pe sistemul dumneavoastră, nu ezitați să +creșteți \fIlimita\fP, dar niciodată să nu o stabiliți la o valoare mai mare +decât cantitatea de memorie RAM utilizabilă și cu niște fișiere de intrare +adecvate, \fBxz\fP va încerca să utilizeze acea cantitate de memorie chiar și +cu un număr redus de fire de execuție. Rularea lui \fBxz\fP cu depășirea +cantității de memorie fizice(RAM) sau a celei de interschimb(swap) nu va +îmbunătăți performanța de decomprimare. +.IP "" +Consultați opțiunea \fB\-\-memlimit\-compress=\fP\fIlimita\fP pentru modalități +posibile de a specifica \fIlimita\fP. Stabilirea \fIlimitei\fP la \fB0\fP +restabilește \fIlimita\fP la valoarea implicită specifică sistemului. +.TP +\fB\-M\fP \fIlimita\fP, \fB\-\-memlimit=\fP\fIlimita\fP, \fB\-\-memory=\fP\fIlimita\fP +Aceasta este echivalentă cu specificarea opțiunilor: +\fB\-\-memlimit\-compress=\fP\fIlimita\fP \fB\-\-memlimit\-decompress=\fP\fIlimita\fP +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimita\fP. +.TP +\fB\-\-no\-adjust\fP +Afișează o eroare și iese dacă limita de utilizare a memoriei nu poate fi +îndeplinită fără ajustarea parametrilor care afectează ieșirea +comprimată. Adică, acest lucru împiedică \fBxz\fP să comute codificatorul din +modul cu mai multe fire de execuție în modul cu un singur fir de execuție și +să reducă dimensiunea dicționarului LZMA2. Chiar și atunci când această +opțiune este utilizată, numărul de fire de execuție poate fi redus pentru a +îndeplini limita de utilizare a memoriei, deoarece aceasta nu va afecta +comprimarea. +.IP "" +Ajustarea automată este întotdeauna dezactivată la crearea fluxurilor brute +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fInumăr\fP, \fB\-\-threads=\fP\fInumăr\fP +Specifică numărul de fire de execuție de utilizat. Stabilirea \fInumărului\fP +la valoarea specială \fB0\fP, face ca \fBxz\fP să utilizeze până la atâtea fire de +execuție câte procesoare sunt în sistem. Numărul real de fire de execuție +poate fi mai mic decât \fInumăr\fP dacă fișierul de intrare nu este suficient +de mare pentru a trece la modul cu mai multe fire de execuție cu parametrii +dați, sau dacă folosirea mai multor fire de execuție ar depăși limita de +utilizare a memoriei. +.IP "" +Operațiile de comprimare cu un singur fir de execuție și cele cu mai multe +fire de execuție produc ieșiri diferite. Comprimarea cu un singur fir de +execuție va oferi cea mai mică dimensiune a fișierului, dar numai ieșirea de +la comprimarea cu mai multe fire de execuție poate fi decomprimată folosind +mai multe fire. Stabilirea \fInumărului\fP la \fB1\fP va determina ca \fBxz\fP să +folosească modul cu un singur fir de execuție. Stabilirea \fInumărului\fP la +orice altă valoare, inclusiv \fB0\fP, va determina ca \fBxz\fP să folosească +comprimarea cu mai multe fire de execuție chiar dacă sistemul acceptă doar +un fir hardware; (\fBxz\fP 5.2.x folosește modul cu un singur fir de execuție +în această situație). +.IP "" +Pentru a utiliza modul cu mai multe fire de execuție cu un singur fir, +stabiliți \fInumărul\fP la \fB+1\fP. Prefixul \fB+\fP nu are efect cu alte valori +decât \fB1\fP. O limită de utilizare a memoriei poate face în continuare \fBxz\fP +să treacă în modul cu un singur fir, cu excepția cazului în care este +utilizată opțiunea \fB\-\-no\-adjust\fP. Suportul pentru prefixul \fB+\fP a fost +adăugat în \fBxz\fP 5.4.0. +.IP "" +Dacă a fost solicitat un număr automat de fire și nu a fost specificată +nicio limită de utilizare a memoriei, atunci o limită „maleabilă” implicită +specifică sistemului va fi utilizată pentru a limita eventual numărul de +fire de execuție. Este o limită „maleabilă” în sensul că este ignorată dacă +numărul de fire devine unul, astfel o limită „maleabilă” nu va opri +niciodată \fBxz\fP să comprime sau să decomprime. Această limită „maleabilă” +implicită nu va face \fBxz\fP să treacă de la modul cu mai multe fire de +execuție la modul cu un singur fir de execuție. Limitele active pot fi +văzute rulând comanda \fBxz \-\-info\-memory\fP. +.IP "" +În prezent, singura metodă de procesare cu fire de execuție este împărțirea +intrării în blocuri și comprimarea lor independent unul de +celălalt. Dimensiunea implicită a blocului depinde de nivelul de comprimare +și poate fi înlocuită cu opțiunea \fB\-\-block\-size=\fP\fIdimensiune\fP. +.IP "" +Decomprimarea cu fire de execuție funcționează numai pe fișierele care +conțin mai multe blocuri cu informații despre dimensiune în antetele +blocurilor. Toate fișierele suficient de mari comprimate în modul cu mai +multe fire de execuție îndeplinesc această condiție, dar fișierele +comprimate în modul cu un singur fir de execuție nu o îndeplinesc chiar dacă +a fost folosită opțiunea \fB\-\-block\-size=\fP\fIdimensiune\fP. +.IP "" +Valoarea implicită pentru \fIfire de execuție\fP este \fB0\fP. În \fBxz\fP 5.4.x și +mai vechi, valoarea implicită este \fB1\fP. +. +.SS "Lanțuri de filtrare personalizate pentru instrumentul de comprimare" +Un lanț de filtrare personalizat permite specificarea parametrilor de +comprimare în detaliu, în loc să se bazeze pe cei asociați opțiunilor +prestabilite. Când este specificat un lanț de filtrare personalizat, +opțiunile prestabilite (\fB\-0\fP \&...\& \fB\-9\fP și \fB\-\-extreme\fP) de mai devreme +din linia de comandă sunt uitate. Dacă o opțiune prestabilită este +specificată după una sau mai multe opțiuni de lanț de filtrare personalizat, +noua prestabilire intră în vigoare și opțiunile lanțului de filtrare +personalizat, specificate mai devreme sunt uitate. +.PP +Un lanț de filtrare este comparabil cu conductele din linia de comandă. La +comprimare, intrarea necomprimată merge la primul filtru, a cărui ieșire +merge la următorul filtru (dacă există). Ieșirea ultimului filtru este +scrisă în fișierul comprimat. Numărul maxim de filtre din lanț este de +patru, dar de obicei un lanț de filtrare are doar unul sau două filtre. +.PP +Multe filtre au limitări în ceea ce privește locul în care se pot afla în +lanțul de filtrare: unele filtre pot funcționa doar ca ultimul filtru din +lanț, altele doar ca non\-ultim filtru și unele funcționează în orice poziție +din lanț. În funcție de filtru, această limitare este fie inerentă +proiectării filtrului, fie există pentru a preveni problemele de securitate. +.PP +Un lanț de filtre personalizat poate fi specificat în două moduri +diferite. Opțiunile \fB\-\-filters=\fP\fIfiltre\fP și \fB\-\-filters1=\fP\fIfiltre\fP +\&...\& \fB\-\-filters9=\fP\fIfiltre\fP permit specificarea unui întreg lanț de +filtre într\-o singură opțiune, folosind sintaxa șirului de filtre +liblzma. Alternativ, un lanț de filtre poate fi specificat prin utilizarea +uneia sau mai multor opțiuni de filtrare individuale în ordinea în care sunt +dorite în lanțul de filtre. Adică, ordinea opțiunilor de filtrare +individuale este semnificativă! La decodificarea fluxurilor brute +(\fB\-\-format=raw\fP), lanțul de filtre trebuie să fie specificat în aceeași +ordine în care a fost specificat la comprimare. Orice filtru individual sau +opțiuni presetate specificate înainte de opțiunea de lanț complet +(\fB\-\-filters=\fP\fIfiltre\fP) vor fi uitate. Filtrele individuale specificate +după opțiunea „lanț complet” vor reinițializa lanțul de filtre. +.PP +Atât opțiunile de filtrare completă, cât și cele de filtrare individuală +acceptă \fIopțiuni\fP specifice filtrului sub forma unei liste separate prin +virgule. Se ignoră virgulele suplimentare din \fIopțiuni\fP. Fiecare opțiune +are o valoare implicită, deci specificați\-le pe cele pe care doriți să le +modificați. +.PP +Pentru a vedea întregul lanț de filtre și \fIopțiuni\fP, utilizați \fBxz \-vv\fP +(adică folosiți \fB\-\-verbose\fP de două ori). Acest lucru funcționează și +pentru vizualizarea opțiunilor lanțului de filtre utilizate de valorile +prestabilite. +.TP +\fB\-\-filters=\fP\fIfiltre\fP +Specificați întregul lanț de filtre sau o presetare într\-o singură +opțiune. Fiecare filtru poate fi separat prin spații sau două liniuțe +(\fB\-\-\fP). Este posibil să fie necesar ca \fIfiltrele\fP să fie puse între +ghilimele în linia de comandă a shell\-ului pentru a fi analizate ca o +singură opțiune. Pentru a indica \fIopțiuni\fP, utilizați \fB:\fP sau \fB=\fP. O +presetare poate fi prefixată cu un \fB\-\fP și urmată de zero sau mai multe +indicatoare. Singurul indicator suportat este \fBe\fP pentru a aplica aceleași +opțiuni ca și \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIfiltre\fP ... \fB\-\-filters9\fP=\fIfiltre\fP +Specifică până la nouă lanțuri de filtre suplimentare care pot fi utilizate +cu \fB\-\-block\-list\fP. +.IP "" +De exemplu, atunci când se comprimă o arhivă cu fișiere executabile urmate +de fișiere text, partea executabilă ar putea utiliza un lanț de filtre cu un +filtru BCJ, iar partea de text doar filtrul LZMA2. +.TP +\fB\-\-filters\-help\fP +Afișează un mesaj de ajutor care descrie modul de specificare a presetărilor +și a lanțurilor de filtre personalizate în opțiunile \fB\-\-filters\fP și +\fB\-\-filters1=\fP\fIfiltre\fP \&...\& \fB\-\-filters9=\fP\fIfiltre\fP și iese. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIopțiuni\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIopțiuni\fP] +.PD +Adaugă filtrul LZMA1 sau LZMA2 la lanțul de filtre. Aceste filtre pot fi +folosite doar ca ultimul filtru din lanț. +.IP "" +LZMA1 este un filtru vechi, care este acceptat aproape exclusiv datorită +formatului de fișier vechi \fB.lzma\fP, care acceptă numai LZMA1. LZMA2 este o +versiune actualizată a LZMA1 pentru a rezolva unele probleme practice ale +LZMA1. Formatul \fB.xz\fP folosește LZMA2 și nu acceptă deloc LZMA1. Viteza de +comprimare și rapoartele LZMA1 și LZMA2 sunt practic aceleași. +.IP "" +LZMA1 și LZMA2 au același set de \fIopțiuni\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIprestabilit\fP +Reconfigurează toate \fIopțiunile\fP LZMA1 sau LZMA2 la +\fIprestabilit\fP. \fIprestabilit\fP constă dintr\-un număr întreg, care poate fi +urmat de modificatori prestabiliți cu o singură literă. Numărul întreg +poate fi de la \fB0\fP la \fB9\fP, potrivindu\-se cu opțiunile liniei de comandă +\fB\-0\fP \&...\& \fB\-9\fP. Singurul modificator acceptat în prezent este \fBe\fP, +care se potrivește cu \fB\-\-extreme\fP. Dacă nu este specificat \fBprestabilit\fP, +valorile implicite ale \fIopțiunilor\fP LZMA1 sau LZMA2 sunt preluate din +prestabilirea \fB6\fP. +.TP +\fBdict=\fP\fIdimensiunea\fP +\fIDimensiunea\fP dicționarului (istoricul memoriei tampon) indică câți octeți +din datele necomprimate recent procesate sunt păstrați în +memorie. Algoritmul încearcă să găsească secvențe de octeți care se repetă +(potriviri) în datele necomprimate și să le înlocuiască cu referințe la +datele aflate în prezent în dicționar. Cu cât dicționarul este mai mare, cu +atât este mai mare șansa de a găsi o potrivire. Astfel, creșterea +\fIdimensiunii\fP dicționarului îmbunătățește de obicei raportul de comprimare, +dar un dicționar mai mare decât fișierul necomprimat este risipă de memorie. +.IP "" +\fIDimensiunea\fPtipică a dicționarului este de la 64Kio până la 64Mio. Minimul +este de 4Kio. Maximul pentru compresie este în prezent de 1,5Gio +(1536Mio). Decomprimarea acceptă deja dicționare cu până la un octet mai +puțin de 4Gio, care este maximul pentru formatele de flux LZMA1 și LZMA2. +.IP "" +\fIDimensiunea\fP dicționarului și găsitorul de potriviri (match finder) → +(\fImf\fP) determină împreună utilizarea memoriei de către codificatorul LZMA1 +sau LZMA2. Aceeași \fIdimensiune\fP a dicționarului (sau mai mare) care a fost +utilizată la comprimare, este necesară pentru decomprimare, astfel încât +utilizarea memoriei de către decodificator este determinată de dimensiunea +dicționarului utilizată la comprimare. Antetele \fB.xz\fP stochează +\fIdimensiunea\fP dicționarului fie ca 2^\fIn\fP, fie ca 2^\fIn\fP + 2^(\fIn\fP\-1), deci +aceste \fIdimensiuni\fP sunt oarecum preferate pentru comprimare. Alte +\fIdimensiuni\fP vor fi rotunjite atunci când sunt stocate în anteturile +\&\fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Specifică numărul de biți de context literal. Minimul este 0 și maximul este +4; implicit este 3. În plus, suma \fIlc\fP și \fIlp\fP nu trebuie să depășească +4. +.IP "" +Toți octeții care nu pot fi codificați ca potriviri sunt codificați ca +literali. Adică, literalii sunt pur și simplu octeți de 8 biți care sunt +codificați unul câte unul. +.IP "" +Codificarea literală presupune că cei mai mari biți \fIlc\fP ai octetului +anterior necomprimat se corelează cu octetul următor. De exemplu, în textul +tipic englezesc, o literă mare este adesea urmată de o literă mică, iar o +literă mică este urmată de obicei de o altă literă mică. În setul de +caractere US\-ASCII, cei mai mari trei biți sunt 010 pentru literele mari și +011 pentru literele mici. Când \fIlc\fP este cel puțin 3, codificarea literală +poate profita de această proprietate în datele necomprimate. +.IP "" +Valoarea implicită (3) este de obicei bună. Dacă doriți o comprimare maximă, +testați \fBlc=4\fP. Uneori ajută puțin, iar uneori înrăutățește comprimarea +\&. Dacă o agravează, încercați de\-asemeni cu \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Specifică numărul de biți de poziție literală. Minimul este 0 și maximul +este 4; implicit este 0. +.IP "" +\fILp\fP afectează ce fel de aliniere în datele necomprimate este presupusă la +codificarea literalelor. Consultați argumentul \fIpb\fP de mai jos pentru mai +multe informații despre aliniere. +.TP +\fBpb=\fP\fIpb\fP +Specifică numărul de biți de poziție. Minimul este 0 și maximul este 4; +implicit este 2. +.IP "" +\fIPb\fP afectează ce fel de aliniere în datele necomprimate este presupusă în +general. Valoarea implicită înseamnă alinierea pe patru octeți +(2^\fIpb\fP=2^2=4), care este adesea o alegere bună atunci când nu există o +ipoteză mai bună. +.IP "" +Când alinierea este cunoscută, definirea lui \fIpb\fP în mod corespunzător +poate reduce puțin dimensiunea fișierului. De exemplu, cu fișierele text cu +aliniere pe un octet (US\-ASCII, ISO\-8859\-*, UTF\-8), definirea \fBpb=0\fP poate +îmbunătăți ușor comprimarea. Pentru textul UTF\-16, \fBpb=1\fP este o alegere +bună. Dacă alinierea este un număr impar, cum ar fi 3 octeți, \fBpb=0\fP ar +putea fi cea mai bună alegere. +.IP "" +Chiar dacă alinierea presupusă poate fi ajustată cu \fIpb\fP și \fIlp\fP, LZMA1 și +LZMA2 încă favorizează ușor alinierea pe 16 octeți. Ar putea fi demn de luat +în considerare atunci când proiectați formate de fișiere care pot fi adesea +comprimate cu LZMA1 sau LZMA2. +.TP +\fBmf=\fP\fImf\fP +Căutarea potrivirilor are un efect major asupra vitezei codificatorului, +utilizării memoriei și raportului de comprimare. De obicei, găsitorii de +potriviri din lanțul sumelor de control sunt mai rapizi decât găsitorii de +potriviri din arborele binar. Valoarea implicită depinde de \fIprestabilit\fP: +0 folosește \fBhc3\fP, 1\(en3 folosește \fBhc4\fP, iar restul folosește \fBbt4\fP. +.IP "" +Sunt acceptate următoarele opțiuni de căutare de potriviri. Formulele de +utilizare a memoriei de mai jos sunt aproximări estimative, care se apropie +cel mai mult de realitate atunci când \fIdict\fP este o putere a lui doi. +.RS +.TP +\fBhc3\fP +Lanț de sumă de control, cu suma de control de 2 și 3 octeți +.br +Valoarea minimă pentru \fInice\fP: 3 +.br +Utilizarea memoriei: +.br +\fIdict\fP * 7.5 (dacă \fIdict\fP <= 16 Mio); +.br +\fIdict\fP * 5.5 + 64 MiB (dacă \fIdict\fP > 16 Mio) +.TP +\fBhc4\fP +Lanț de sumă de control, cu suma de control de 2, 3 și 4 octeți +.br +Valoarea minimă pentru \fInice\fP: 4 +.br +Utilizarea memoriei: +.br +\fIdict\fP * 7.5 (dacă \fIdict\fP <= 32 Mio); +.br +\fIdict\fP * 6.5 (dacă \fIdict\fP > 32 Mio) +.TP +\fBbt2\fP +Arbore binar cu suma de control de 2 octeți +.br +Valoarea minimă pentru \fInice\fP: 2 +.br +Utilizarea memoriei: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Arbore binar cu suma de control de 2 și 3 octeți +.br +Valoarea minimă pentru \fInice\fP: 3 +.br +Utilizarea memoriei: +.br +\fIdict\fP * 11.5 (dacă \fIdict\fP <= 16 Mio); +.br +\fIdict\fP * 9.5 + 64 MiB (dacă \fIdict\fP > 16 Mio) +.TP +\fBbt4\fP +Arbore binar cu suma de control de 2, 3 și 4 octeți +.br +Valoarea minimă pentru \fInice\fP: 4 +.br +Utilizarea memoriei: +.br +\fIdict\fP * 11.5 (dacă \fIdict\fP <= 32 Mio); +.br +\fIdict\fP * 10.5 (dacă \fIdict\fP > 32 Mio) +.RE +.TP +\fBmode=\fP\fImod\fP +Comprimarea \fImod\fP specifică metoda de analiză a datelor produse de +găsitorul de potriviri. \fIModurile\fP acceptate sunt \fBfast\fP(rapid) și +\fBnormal\fP. Valoarea implicită este \fBfast\fP pentru \fIprestabiliri\fP 0\(en3 și +\fBnormal\fP pentru \fIprestabiliri\fP 4\(en9. +.IP "" +De obicei, \fBfast\fP este folosit cu instrumentele de căutare de potriviri ale +lanțului de sume de control, și \fBnormal\fP cu instrumentele de căutare de +potriviri din arborele binar. Aceasta este și ceea ce fac \fIprestabiririle\fP. +.TP +\fBnice=\fP\fInice\fP +Specifică ceea ce este considerat a fi o lungime bună(nice) pentru o +potrivire. Odată ce este găsită o potrivire de cel puțin \fInice\fP octeți, +algoritmul nu mai caută după potriviri posibile mai bune. +.IP "" +\fINice\fP poate fi de 2\(en273 octeți. Valorile mai mari tind să ofere un +raport de comprimare mai bun în detrimentul vitezei. Valoarea implicită +depinde de \fIprestabilit\fP. +.TP +\fBdepth=\fP\fIadâncimea\fP +Specifică adâncimea maximă de căutare în găsitorul de potriviri. Valoarea +implicită este valoarea specială de 0, ceea ce face ca instrumentul de +comprimare să determine o \fIadâncime\fP rezonabilă pornind de la valorile +\fImf\fP și \fInice\fP. +.IP "" +\fIAdâncimea\fP rezonabilă pentru lanțuri de sumă de control este 4\(en100 și +16\(en1000 pentru arbori binari. Folosirea unor valori foarte mari pentru +\fIadâncime\fP poate face codificatorul extrem de lent cu unele +fișiere. Evitați să stabiliți \fIadâncimea\fP la valori peste 1000, cu excepția +cazului în care sunteți pregătit să întrerupeți comprimarea în cazul în care +durează prea mult. +.RE +.IP "" +La decodificarea fluxurilor brute (\fB\-\-format=raw\fP), LZMA2 are nevoie doar +de \fIdimensiunea\fP dicționarului. LZMA1 are nevoie de asemenea de \fIlc\fP, +\fIlp\fP și \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIopțiuni\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIopțiuni\fP] +.PD +Adaugă un filtru de ramură/apel/salt (branch/call/jump ⟶ „BCJ”) la lanțul de +filtre. Aceste filtre pot fi utilizate numai ca un filtru care nu este +ultimul din lanțul de filtrare. +.IP "" +Un filtru BCJ convertește adresele relative din codul mașinii în omoloagele +lor absolute. Acest lucru nu modifică dimensiunea datelor, dar crește +redundanța, ceea ce poate ajuta LZMA2 să producă fișier \fB.xz\fP cu 0\(en15\ % +mai mic. Filtrele BCJ sunt întotdeauna reversibile, deci folosind un filtru +BCJ pentru tipul greșit de date nu provoacă nicio pierdere de date, deși +poate înrăutăți puțin raportul de comprimare. Filtrele BCJ sunt foarte +rapide și folosesc o cantitate nesemnificativă de memorie. +.IP "" +Aceste filtre BCJ au probleme cunoscute legate de raportul de comprimare: +.RS +.IP \(bu 3 +Unele tipuri de fișiere care conțin cod executabil (de exemplu, fișiere +obiect, biblioteci statice și module de kernel Linux) au adresele din +instrucțiuni completate cu valori de umplere. Aceste filtre BCJ vor face în +continuare conversia adresei, ceea ce va înrăutăți comprimarea cu aceste +fișiere. +.IP \(bu 3 +Dacă pe o arhivă este aplicat un filtru BCJ, este posibil ca raportul de +comprimare să fie mai rău decât la neutilizarea unui filtru BCJ. De exemplu, +dacă există executabile similare sau chiar identice, filtrarea va face +probabil fișierele mai puțin asemănătoare și astfel comprimarea este mai +proastă. Conținutul fișierelor neexecutabile din aceeași arhivă poate conta +și el. În practică, trebuie să încercați cu și fără filtru BCJ pentru a +vedea care rezultat este mai bun în fiecare situație. +.RE +.IP "" +Seturi de instrucțiuni diferite au o aliniere diferită: fișierul executabil +trebuie aliniat la un multiplu al acestei valori în datele de intrare pentru +ca filtrul să funcționeze. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filtru;Aliniere;Note +x86;1;x86 pe 32 de biți +;;sau 64 de biți +ARM;4; +ARM\-Thumb;2; +ARM64;4;alinierea pe 4096\-octeți +;;este cea mai bună +PowerPC;4;Doar big endian +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Deoarece datele filtrate prin BCJ sunt de obicei comprimate cu LZMA2, +raportul de comprimare poate fi ușor îmbunătățit dacă opțiunile LZMA2 sunt +definite pentru a se potrivi cu alinierea filtrului BCJ selectat. Exemple: +.RS +.IP \(bu 3 +Filtrul IA\-64 are o aliniere de 16 octeți, astfel încât \fBpb=4,lp=4,lc=0\fP +este alegere adecvată cu LZMA2 (2^4=16). +.IP \(bu 3 +Codul RISC\-V are o aliniere pe 2 sau 4 octeți, depinzând de faptul că +fișierul conține instrucțiuni comprimate pe 16 biți (extensia C) sau +nu. Atunci când se utilizează instrucțiuni pe 16 biți, \fBpb=2,lp=1,lc=3\fP sau +\fBpb=1,lp=1,lc=3\fP este o alegere bună. Atunci când nu sunt prezente +instrucțiuni pe 16 biți, \fBpb=2,lp=2,lc=2\fP este cea mai bună +alegere. \fBreadelf \-h\fP poate fi utilizată pentru a verifica dacă „RVC” apare +în linia „Indicatori". +.IP \(bu 3 +ARM64 este întotdeauna aliniat pe 4 octeți, astfel încât \fBpb=2,lp=2,lc=2\fP +este cea mai bună alegere. +.IP \(bu 3 +Filtrul x86 este o excepție. De obicei, este bine să rămâneți la valorile +implicite ale LZMA2 (\fBpb=2,lp=0,lc=3\fP) atunci când comprimați executabile +x86. +.RE +.IP "" +Toate filtrele BCJ acceptă același \fIopțiuni\fP: +.RS +.TP +\fBstart=\fP\fIpoziție\fP +Specifică \fIpoziția\fP de pornire care este utilizată la conversia între +adresele relative și absolute. \fIPoziția\fP trebuie să fie un multiplu al +alinierii filtrului (consultați tabelul de mai sus). Valoarea implicită +este zero. În practică, valoarea implicită este bună; specificarea unei +\fIpoziții\fP personalizate nu este aproape niciodată utilă. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIopțiuni\fP] +Adaugă filtrul Delta în lanțul de filtrare. Filtrul Delta poate fi folosit +doar ca un filtru care nu este ultimul în lanțul de filtrare. +.IP "" +În prezent, este acceptat doar calculul delta simplu de octeți. Poate fi +util la comprimarea, de exemplu, a imaginilor bitmap necomprimate sau a +sunetului PCM necomprimat. Cu toate acestea, algoritmii cu scop special pot +da rezultate semnificativ mai bune decât Delta + LZMA2. Acest lucru este +valabil mai ales în cazul audio, care se comprimă mai repede și mai bine, de +exemplu, cu \fBflac\fP(1). +.IP "" +\fIOpțiuni\fP acceptate: +.RS +.TP +\fBdist=\fP\fIdistanța\fP +Specifică \fIdistanța\fP calculului delta în octeți. \fIDistanța\fP trebuie să fie +1\(en256. Valoarea implicită este 1. +.IP "" +De exemplu, cu \fBdist=2\fP și intrare de opt octeți: A1 B1 A2 B3 A3 B5 A4 B7, +ieșirea va fi: A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Alte opțiuni" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Suprimă avertismentele și notificările. Specificați acest lucru de două ori +pentru a suprima și erorile. Această opțiune nu are niciun efect asupra +stării de ieșire. Adică, chiar dacă o avertizare a fost suprimată, starea de +ieșire pentru a indica o avertizare este încă utilizată. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Oferă informații detaliate. Dacă ieșirea de eroare standard este conectată +la un terminal, \fBxz\fP va afișa un indicator de progres. Specificarea +opțiunii \fB\-\-verbose\fP de două ori, va avea ca rezultat oferirea de +informații și mai detaliate. +.IP "" +Indicatorul de progres afișează următoarele informații: +.RS +.IP \(bu 3 +Procentul de completare este afișat dacă se cunoaște dimensiunea fișierului +de intrare. Adică, procentul nu poate fi afișat la procesarea fișierului +prin conducte(pipe). +.IP \(bu 3 +Cantitatea de date comprimate produse (comprimare) sau consumate +(decomprimare). +.IP \(bu 3 +Cantitatea de date necomprimate consumate (comprimare) sau produse +(decomprimare). +.IP \(bu 3 +Raportul de comprimare, care se calculează împărțind cantitatea de date +comprimate procesate până acum la cantitatea de date necomprimate procesate +până acum. +.IP \(bu 3 +Viteza de comprimare sau decomprimare. Aceasta este măsurată drept +cantitatea de date necomprimate consumate (comprimare) sau produse +(decomprimare) pe secundă. Este afișată după ce au trecut câteva secunde de +când \fBxz\fP a început procesarea fișierului. +.IP \(bu 3 +Timpul scurs în format M:SS sau H:MM:SS. +.IP \(bu 3 +Timpul rămas estimat este afișat numai atunci când dimensiunea fișierului de +intrare este cunoscută și au trecut deja câteva secunde de când \fBxz\fP a +început procesarea fișierului. Ora este afișată într\-un format mai puțin +precis, care nu are niciodată două puncte, de exemplu, 2 min 30 s. +.RE +.IP "" +Când ieșirea de eroare standard nu este un terminal, \fB\-\-verbose\fP va face +\fBxz\fP să imprime numele fișierului, dimensiunea comprimată, dimensiunea +necomprimată, raportul de comprimare și, eventual, de asemenea, viteza și +timpul scurs pe o singură linie la ieșirea de eroare standard după +comprimarea sau decomprimarea fișierului. Viteza și timpul scurs sunt +incluse numai atunci când operațiunea a durat cel puțin câteva secunde. Dacă +operațiunea nu s\-a încheiat, de exemplu, din cauza întreruperii din partea +utilizatorului, se imprimă și procentul de completare dacă se cunoaște +dimensiunea fișierului de intrare. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Nu comută starea de ieșire la 2 chiar dacă a fost detectată o condiție care +merită avertizată. Această opțiune nu afectează nivelul de detaliere al +informațiilor, astfel încât atât \fB\-\-quiet\fP cât și \fB\-\-no\-warn\fP trebuie +folosite pentru a nu afișa avertismente și pentru a nu modifica starea de +ieșire. +.TP +\fB\-\-robot\fP +Afișează mesajele într\-un format care poate fi analizat de mașină. Acest +lucru are scopul de a ușura scrierea interfețelor în care se dorește să se +folosească \fBxz\fP în loc de liblzma, ceea ce poate fi cazul cu diferite +scripturi. Ieșirea cu această opțiune activată este menită să fie stabilă în +toate versiunile \fBxz\fP. Consultați secțiunea \fBMOD ROBOT\fP pentru detalii. +.TP +\fB\-\-info\-memory\fP +Afișează, într\-un format care poate fi citit de om, câtă memorie fizică +(RAM) și câte fire de execuție de procesor \fBxz\fP crede că are sistemul și +limitele de utilizare a memoriei pentru comprimare și decomprimare și iese +cu succes. +.TP +\fB\-h\fP, \fB\-\-help\fP +Afișează un mesaj de ajutor care descrie opțiunile cele mai frecvent +utilizate și iese cu succes. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Afișează un mesaj de ajutor care descrie toate caracteristicile \fBxz\fP și +iese cu succes +.TP +\fB\-V\fP, \fB\-\-version\fP +Afișează numărul versiunii \fBxz\fP și liblzma într\-un format care poate fi +citit de om. Pentru a obține rezultate analizabile de mașină, specificați +\fB\-\-robot\fP înainte de \fB\-\-version\fP. +. +.SH "MOD ROBOT" +Modul robot este activat cu opțiunea \fB\-\-robot\fP. Face ieșirea lui \fBxz\fP mai +ușor de analizat de către alte programe. În prezent, opțiunea \fB\-\-robot\fP +este acceptată numai împreună cu opțiunile \fB\-\-list\fP, \fB\-\-filters\-help\fP, +\fB\-\-info\-memory\fP, și \fB\-\-version\fP. Va fi acceptată pentru comprimare și +decomprimare în viitor. +. +.SS "Modul listă" +\fBxz \-\-robot \-\-list\fP utilizează o ieșire separată de tabulatori. Prima +coloană a fiecărei linii are un șir care indică tipul de informații găsite +pe acea linie: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Aceasta este întotdeauna prima linie când începe să se listeze un fișier. A +doua coloană de pe linie este numele fișierului. +.TP +\fBfile\fP +Această linie conține informații generale despre fișierul \fB.xz\fP. Această +linie este întotdeauna tipărită după linia \fBname\fP. +.TP +\fBstream\fP +Acest tip de linie este utilizat numai atunci când a fost specificată +opțiunea \fB\-\-verbose\fP. Există tot atâtea linii \fBstream\fP câte fluxuri există +în fișierul \fB.xz\fP. +.TP +\fBblock\fP +Acest tip de linie este utilizat numai atunci când a fost specificată +opțiunea \fB\-\-verbose\fP. Există tot atâtea linii \fBblock\fP câte blocuri există +în fișierul \fB.xz\fP. Liniile \fBblock\fP sunt afișate după toate liniile +\fBstream\fP; tipurile diferite de linii nu sunt intercalate. +.TP +\fBsummary\fP +Acest tip de linie este folosit numai atunci când opțiunea \fB\-\-verbose\fP a +fost specificată de două ori. Această linie este afișată după toate liniile +\fBblock\fP. Ca și linia \fBfile\fP, linia \fBsummary\fP conține informații generale +despre fișierul \fB.xz\fP. +.TP +\fBtotals\fP +Această linie este întotdeauna ultima linie din lista afișată la +ieșire. Aceasta arată numărul total și dimensiunile. +.PP +Coloanele din liniile \fBfile\fP: +.PD 0 +.RS +.IP 2. 4 +Numărul de fluxuri din fișier +.IP 3. 4 +Numărul total de blocuri din fluxuri +.IP 4. 4 +Dimensiunea comprimată a fișierului +.IP 5. 4 +Dimensiunea necomprimată a fișierului +.IP 6. 4 +Raportul de comprimare, de exemplu, \fB0,123\fP. Dacă raportul este peste +9,999, în locul raportului sunt afișate trei liniuțe (\fB\-\-\-\fP). +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Lista de nume de verificare a integrității, separate prin +virgule. Următoarele șiruri sunt utilizate pentru tipurile de verificare +cunoscute: \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP și \fBSHA\-256\fP. Pentru tipurile de +verificări necunoscute, se utilizează \fBUnknown\-\fP\fIN\fP, unde \fIN\fP este ID\-ul +de verificare ca număr zecimal (una sau două cifre). +.IP 8. 4 +Dimensiunea totală a umpluturii fluxului din fișier +.RE +.PD +.PP +Coloanele din liniile \fBstream\fP: +.PD 0 +.RS +.IP 2. 4 +Numărul fluxului (primul flux este 1) +.IP 3. 4 +Numărul de blocuri din flux +.IP 4. 4 +Poziția de pornire a comprimării +.IP 5. 4 +Poziția de pornire a decomprimării +.IP 6. 4 +Dimensiune comprimată (nu include umplutura fluxului) +.IP 7. 4 +Dimensiune necomprimată +.IP 8. 4 +Raport de comprimare +.IP 9. 4 +Numele verificării de integritate +.IP 10. 4 +Dimensiunea umpluturii fluxului +.RE +.PD +.PP +Coloanele din liniile \fBblock\fP: +.PD 0 +.RS +.IP 2. 4 +Numărul fluxului care conține acest bloc +.IP 3. 4 +Numărul blocului în raport cu începutul fluxului (primul bloc este 1) +.IP 4. 4 +Numărul blocului în raport cu începutul fișierului +.IP 5. 4 +Poziția de pornire a comprimării în raport cu începutul fișierului +.IP 6. 4 +Poziția de pornire necomprimată în raport cu începutul fișierului +.IP 7. 4 +Dimensiunea totală comprimată a blocului (include antetele) +.IP 8. 4 +Dimensiune necomprimată +.IP 9. 4 +Raport de comprimare +.IP 10. 4 +Numele verificării de integritate +.RE +.PD +.PP +Dacă opțiunea \fB\-\-verbose\fP a fost specificată de două ori, coloane +suplimentare sunt incluse pe liniile \fBblock\fP. Acestea nu sunt afișate cu o +singură specificare a opțiunii \fB\-\-verbose\fP, deoarece obținerea acestor +informații necesită multe căutări și, prin urmare, poate fi lentă: +.PD 0 +.RS +.IP 11. 4 +Valoarea verificării integrității în hexazecimal +.IP 12. 4 +Dimensiunea antetului blocului +.IP 13. 4 +Indicatori de bloc: \fBc\fP indică faptul că este prezentă dimensiunea +comprimată, iar \fBu\fP indică faptul că este prezentă dimensiunea +necomprimată. Dacă indicatorul nu este determinat, este afișată o liniuță +(\fB\-\fP) pentru a menține lungimea șirului fixă. Pot fi adăugate noi +indicatoare la sfârșitul șirului, în viitor. +.IP 14. 4 +Dimensiunea datelor comprimate reale din bloc (acest lucru exclude antetul +blocului, umplutura blocului și câmpurile de verificare) +.IP 15. 4 +Cantitatea de memorie (în octeți) necesară pentru a decomprima acest bloc cu +această versiune \fBxz\fP +.IP 16. 4 +Lanț de filtrare. Rețineți că majoritatea opțiunilor utilizate în timpul +comprimării nu pot fi cunoscute, deoarece doar opțiunile necesare pentru +decomprimare sunt stocate în anteturile \fB.xz\fP. +.RE +.PD +.PP +Coloanele din liniile \fBsummary\fP: +.PD 0 +.RS +.IP 2. 4 +Cantitatea de memorie (în octeți) necesară pentru a decomprima acest fișier +cu această versiune \fBxz\fP +.IP 3. 4 +\fByes\fP sau \fBno\fP indicând dacă toate antetele blocurilor au atât dimensiunea +comprimată, cât și dimensiunea necomprimată stocate în ele +.PP +\fIÎncepând cu\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Versiunea \fBxz\fP minimă necesară pentru a decomprima fișierul +.RE +.PD +.PP +Coloanele din linia \fBtotals\fP: +.PD 0 +.RS +.IP 2. 4 +Numărul de fluxuri +.IP 3. 4 +Numărul de blocuri +.IP 4. 4 +Dimensiunea comprimată +.IP 5. 4 +Dimensiune necomprimată +.IP 6. 4 +Raportul mediu de comprimare +.IP 7. 4 +Lista de nume de verificare a integrității, separate prin virgule, care au +fost prezente în fișiere +.IP 8. 4 +Dimensiunea umpluturii fluxului +.IP 9. 4 +Numărul de fișiere. Aceasta este aici pentru a păstra ordinea coloanelor +anterioare la fel ca pe liniile \fBfile\fP. +.PD +.RE +.PP +Dacă opțiunea \fB\-\-verbose\fP a fost specificată de două ori, pe linia +\fBtotals\fP sunt incluse coloane suplimentare: +.PD 0 +.RS +.IP 10. 4 +Cantitatea maximă de memorie (în octeți) necesară pentru a decomprima +fișierele cu această versiune \fBxz\fP +.IP 11. 4 +\fByes\fP sau \fBno\fP indicând dacă toate antetele blocurilor au atât dimensiunea +comprimată, cât și dimensiunea necomprimată stocate în ele +.PP +\fIÎncepând cu\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Versiunea \fBxz\fP minimă necesară pentru a decomprima fișierul +.RE +.PD +.PP +Versiunile viitoare pot adăuga noi tipuri de linii și pot fi adăugate +coloane noi la tipurile de linii existente, dar coloanele existente nu vor +fi modificate. +. +.SS "Ajutor pentru filtrare" +\fBxz \-\-robot \-\-filters\-help\fP afișează filtrele acceptate în următorul +format: +.PP +\fIfiltru\fP\fB:\fP\fIopțiune\fP\fB=<\fP\fIvaloare\fP\fB>,\fP\fIopțiune\fP\fB=<\fP\fIvaloare\fP\fB>\fP... +.TP +\fBfiltru\fP +Numele filtrului +.TP +\fIopțiune\fP +Numele unei opțiuni specifice unui filtru +.TP +\fIvaloare\fP +Intervalele numerice \fIvaloare\fP apar ca +\fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. Alegerile \fIvaloare\fP de tip șir de +caractere sunt afișate în cadrul \fB< >\fP și separate de un caracter +\fB|\fP. +.PP +Fiecare filtru este afișat pe propria linie. +. +.SS "Informații privind limita memoriei" +\fBxz \-\-robot \-\-info\-memory\fP afișează o singură linie cu multiple coloane +separate prin tabulatoare: +.IP 1. 4 +Cantitatea totală de memorie fizică (RAM) în octeți. +.IP 2. 4 +Limita de utilizare a memoriei pentru comprimare în octeți +(\fB\-\-memlimit\-compress\fP). O valoare specială de \fB0\fP indică configurarea +implicită, care pentru modul cu un singur fir este la fel ca fără limită. +.IP 3. 4 +Limita de utilizare a memoriei pentru decomprimare în octeți +(\fB\-\-memlimit\-decompress\fP). O valoare specială de \fB0\fP indică configurarea +implicită, care pentru modul cu un singur fir este la fel ca fără limită. +.IP 4. 4 +Începând cu \fBxz\fP 5.3.4alpha: Utilizarea memoriei pentru decomprimarea cu +mai multe fire în octeți (\fB\-\-memlimit\-mt\-decompress\fP). Acesta nu este +niciodată zero, deoarece o valoare implicită specifică sistemului afișată în +coloana 5 este utilizată dacă nu a fost specificată în mod explicit nicio +limită. De asemenea, aceasta nu este niciodată mai mare decât valoarea din +coloana 3, chiar dacă a fost specificată o valoare mai mare cu +\fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Începând cu \fBxz\fP 5.3.4alpha: o limită implicită de utilizare a memoriei +specifică sistemului, care este utilizată pentru a limita numărul de fire de +execuție atunci când se comprimă cu un număr automat de fire de execuție +(\fB\-\-threads=0\fP) și nicio limită de utilizare a memoriei nu fost specificată +cu (\fB\-\-memlimit\-compress\fP). Aceasta este, de asemenea, utilizată ca valoare +implicită pentru \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Începând cu \fBxz\fP 5.3.4alpha: numărul de fire de execuție de procesor +disponibile. +.PP +În viitor, rezultatul \fBxz \-\-robot \-\-info\-memory\fP poate avea mai multe +coloane, dar niciodată mai mult de o singură linie. +. +.SS Versiunea +\fBxz \-\-robot \-\-version\fP va afișa numărul versiunii \fBxz\fP și liblzma în +următorul format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Versiunea majoră. +.TP +\fIYYY\fP +Versiunea minoră. Numerele pare sunt prezente în versiunile +stabile. Numerele impare sunt prezente în versiunile alfa sau beta. +.TP +\fIZZZ\fP +Nivelul de plasture(patch) pentru versiunile stabile sau doar un contor +pentru versiunile de dezvoltare. +.TP +\fIS\fP +Stabilitate. 0 este alfa, 1 este beta și 2 este stabil. \fIS\fP trebuie să fie +întotdeauna 2 atunci când \fIAAA\fP este par. +.PP +\fIXYYYZZZS\fP sunt aceleași pe ambele linii dacă \fBxz\fP și liblzma sunt din +aceeași versiune XZ Utils. +.PP +Exemple: 4.999.9beta este \fB49990091\fP și 5.0.0 este \fB50000002\fP. +. +.SH "STARE DE IEȘIRE" +.TP +\fB0\fP +Totul este bine. +.TP +\fB1\fP +A apărut o eroare. +.TP +\fB2\fP +A apărut ceva care merită să fie avertizat, dar nu au apărut erori reale. +.PP +Notificările (nu avertismentele sau erorile) afișate la ieșirea de eroare +standard nu afectează starea de ieșire. +. +.SH "VARIABILE DE MEDIU" +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP analizează liste de opțiuni separate prin spații din variabilele de +mediu \fBXZ_DEFAULTS\fP și \fBXZ_OPT\fP, în această ordine, înainte de a analiza +opțiunile din linia de comandă. Rețineți că numai opțiunile sunt analizate +din variabilele de mediu; toate non\-opțiunile sunt ignorate în +tăcere. Analiza se face cu funcția \fBgetopt_long\fP(3) care este folosită și +pentru argumentele liniei de comandă. +.PP +\fBAvertisment:\fP Prin definirea acestor variabile de mediu, se modifică +efectiv programele și scripturile care rulează \fBxz\fP. De cele mai multe ori +este sigur să se definească limitele de utilizare a memoriei, numărul de +fire și opțiunile de comprimare prin intermediul variabilelor de mediu. Cu +toate acestea, unele opțiuni pot întrerupe scripturile. Un exemplu evident +este \fB\-\-help\fP care face ca \fBxz\fP să afișeze textul de ajutor în loc să +comprime sau să decomprime un fișier. Exemple mai subtile sunt \fB\-\-quiet\fP și +\fB\-\-verbose\fP. În multe cazuri funcționează bine activarea indicatorului de +progres folosind \fB\-\-verbose\fP, dar în unele situații mesajele suplimentare +creează probleme. Nivelul de detaliere al mesajelor afectează, de asemenea, +comportamentul lui \fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Opțiuni implicite specifice utilizatorului sau la nivelul întregului +sistem. De obicei, acest lucru este specificat într\-un script de +inițializare shell pentru a activa limitatorul de utilizare a memoriei lui +\fBxz\fP implicit sau pentru a stabili numărul implicit de fire. Excluzând +scripturile de inițializare shell și cazurile speciale similare, scripturile +nu trebuie niciodată să modifice sau să dezactiveze \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Acest lucru este pentru transmiterea opțiunilor către \fBxz\fP atunci când nu +este posibil să definiți opțiunile direct în linia de comandă a +\fBxz\fP. Acesta este cazul când \fBxz\fP este rulat de un script sau de un +instrument, de exemplu, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Scripturile pot folosi \fBXZ_OPT\fP, de exemplu, pentru a configura opțiunile +implicite de comprimare specifice scriptului. Se recomandă totuși să se +permită utilizatorilor să înlocuiască \fBXZ_OPT\fP dacă acest lucru este +rezonabil. De exemplu, în scripturile \fBsh\fP(1) se poate folosi ceva de genul +acesta: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "COMPATIBILITATE CU LZMA\-UTILS" +Sintaxa liniei de comandă a lui \fBxz\fP este practic o super\-colecție de +\fBlzma\fP, \fBunlzma\fP și \fBlzcat\fP așa cum se găsește în LZMA Utils 4.32.x. În +cele mai multe cazuri, este posibil să înlocuiți LZMA Utils cu XZ Utils fără +a întrerupe scripturile existente. Există totuși unele incompatibilități, +care uneori pot cauza probleme. +. +.SS "Niveluri de comprimare prestabilite" +Numerotarea nivelurilor de comprimare prestabilite nu este identică în \fBxz\fP +și LZMA Utils. Cea mai importantă diferență este modul în care dimensiunile +dicționarului sunt atribuite diferitelor niveluri prestabilite. Dimensiunea +dicționarului este aproximativ egală cu memoria utilizată la decomprimare. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nivel;xz;LZMA Utils +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Diferențele de dimensiune a dicționarului afectează deasemenea cantitatea de +memorie utilizată la comprimare dar există și alte diferențe între LZMA +Utils și XZ Utils, care fac diferența și mai mare: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nivel;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Nivelul prestabilit implicit în LZMA Utils este \fB\-7\fP, în timp ce în XZ +Utils este \fB\-6\fP, deci ambele folosesc un dicționar de 8Mio în mod implicit. +. +.SS "Fișiere .lzma transmise în flux vs. netransmise în flux" +Dimensiunea necomprimată a fișierului poate fi stocată în antetul +\&\fB.lzma\fP. LZMA Utils face asta atunci când comprimă fișiere +obișnuite. Alternativa este să marcați că dimensiunea necomprimată este +necunoscută și să folosiți marcajul de sfârșit de încărcare pentru a indica +unde ar trebui să se oprească decomprimarea. LZMA Utils folosește această +metodă atunci când dimensiunea necomprimată nu este cunoscută, ceea ce este +cazul, de exemplu, când se folosesc conducte. +.PP +\fBxz\fP acceptă decomprimarea fișierelor \fB.lzma\fP cu sau fără marcaj de +sfârșit de încărcare, dar toate fișierele \fB.lzma\fP create de \fBxz\fP vor +folosi marcajul de sfârșit de încărcare și vor avea dimensiunea necomprimată +marcată ca necunoscută în antetul \fB.lzma\fP. Aceasta poate fi o problemă în +unele situații mai puțin frecvente. De exemplu, un instrument de +decomprimare \fB.lzma\fP încorporat într\-un dispozitiv poate funcționa numai cu +fișiere care au dimensiunea necomprimată cunoscută. Dacă întâmpinați această +problemă, trebuie să utilizați LZMA Utils sau LZMA SDK pentru a crea fișiere +\&\fB.lzma\fP cu dimensiunea necomprimată cunoscută. +. +.SS "Fișiere .lzma neacceptate" +Formatul \fB.lzma\fP permite valori \fIlc\fP de până la 8 și valori \fIlp\fP de până +la 4. LZMA Utils poate decomprima fișiere cu orice \fIlc\fP și \fIlp\fP, dar +creează întotdeauna fișiere cu \fBlc=3\fP și \fBlp=0\fP. Crearea de fișiere cu +alte \fIlc\fP și \fIlp\fP este posibilă cu \fBxz\fP și cu LZMA SDK. +.PP +Implementarea filtrului LZMA1 în liblzma necesită ca suma \fIlc\fP și \fIlp\fP să +nu depășească 4. Altfel, fișierele \fB.lzma\fP, care depășesc această limitare, +nu pot fi decomprimate cu \fBxz\fP. +.PP +LZMA Utils creează numai fișiere \fB.lzma\fP care au o dimensiune de dicționar +de 2^\fIn\fP (o putere de 2), dar acceptă fișiere cu orice dimensiune de +dicționar. liblzma acceptă numai fișierele \fB.lzma\fP care au dimensiunea de +dicționar de 2^\fIn\fP sau 2^\fIn\fP + 2^(\fIn\fP\-1). Acest lucru este pentru a +reduce numărul de „fals pozitiv” atunci când se detectează fișiere \fB.lzma\fP. +.PP +Aceste limitări nu ar trebui să fie o problemă în practică, deoarece practic +toate fișierele \fB.lzma\fP au fost comprimate cu opțiuni pe care liblzma le va +accepta. +. +.SS "Resturi rămase" +Când decomprimă, LZMA Utils ignoră în tăcere totul după primul flux +\&\fB.lzma\fP. În majoritatea situațiilor, aceasta este o eroare. Aceasta +înseamnă, de asemenea, că LZMA Utils nu acceptă decomprimarea fișierelor +\&\fB.lzma\fP concatenate. +.PP +Dacă au rămas date după primul flux \fB.lzma\fP, \fBxz\fP consideră că fișierul +este corupt, cu excepția cazului în care a fost utilizată opțiunea +\fB\-\-single\-stream\fP. Acest lucru poate rupe scripturile obscure(scrise +deficitar) care presupun că resturile rămase sunt ignorate. +. +.SH NOTE +. +.SS "Rezultatul comprimării poate varia" +Ieșirea exactă comprimată produsă din același fișier de intrare necomprimat +poate varia între versiunile XZ Utils, chiar dacă opțiunile de comprimare +sunt identice. Acest lucru se datorează faptului că instrumentul codificator +poate fi îmbunătățit (comprimare mai rapidă sau mai bună) fără a afecta +formatul fișierului. Ieșirea poate varia chiar și între compilările diferite +ale aceleiași versiuni XZ Utils, dacă sunt utilizate opțiuni diferite de +compilare. +.PP +Cele de mai sus înseamnă că odată ce opțiunea \fB\-\-rsyncable\fP a fost +utilizată, fișierele rezultate nu vor fi neapărat sincronizate cu rsync +decât dacă atât fișierele vechi, cât și cele noi au fost comprimate cu +aceeași versiune xz. Această problemă poate fi remediată dacă o parte a +implementării codificatorului este înghețată pentru a menține stabilă +ieșirea „rsyncabilă” între versiunile xz. +. +.SS "Instrumente de decomprimare .xz încorporate" +Implementările instrumentului de decomprimare \fB.xz\fP încorporat, cum ar fi +XZ Embedded, nu acceptă neapărat fișiere create cu tipuri de \fIverificare\fP a +integrității, altele decât \fBnone\fP și \fBcrc32\fP. Deoarece valoarea implicită +este \fB\-\-check=crc64\fP, trebuie să utilizați \fB\-\-check=none\fP sau +\fB\-\-check=crc32\fP atunci când creați fișiere pentru sistemele încorporate. +.PP +În afara sistemelor încorporate, toate instrumentele de decomprimare în +format \fB.xz\fP acceptă toate tipurile de \fIverificare\fP sau cel puțin pot +decomprima fișierul fără a efectua verificarea integrității dacă acel tip de +\fIverificare\fP nu este acceptat. +.PP +XZ Embedded acceptă filtre BCJ, dar numai cu poziție de pornire implicită. +. +.SH EXEMPLE +. +.SS Bazice +Comprimă fișierul \fIfoo\fP în \fIfoo.xz\fP folosind nivelul de comprimare +implicit (\fB\-6\fP) și elimină fișierul \fIfoo\fP dacă comprimarea are succes: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Decomprimă \fIbar.xz\fP în \fIbar\fP și nu elimină \fIbar.xz\fP chiar dacă +decomprimarea este efectuată cu succes: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Creează \fIbaz.tar.xz\fP cu nivelul prestabilit \fB\-4e\fP (\fB\-4 \-\-extreme\fP), care +este mai lent decât nivelul prestabilit implicit \fB\-6\fP, dar necesită mai +puțină memorie pentru comprimare și decomprimare (48Mio și, respectiv, +5Mio): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Un amestec de fișiere comprimate și necomprimate poate fi decomprimat la +ieșirea standard cu o singură comandă: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Comprimarea în paralel a mai multor fișiere" +În sisteme GNU și *BSD, \fBfind\fP(1) și \fBxargs\fP(1) pot fi utilizate pentru a +paraleliza comprimarea mai multor fișiere: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Opțiunea \fB\-P\fP pentru comanda \fBxargs\fP(1) stabilește numărul de procese +paralele \fBxz\fP. Cea mai bună valoare pentru opțiunea \fB\-n\fP depinde de câte +fișiere trebuie să fie comprimate. Dacă există doar câteva fișiere, valoarea +ar trebui probabil să fie 1; cu zeci de mii de fișiere, 100 sau chiar mai +mult poate să fie valoarea potrivită pentru a reduce numărul de procese +\fBxz\fP pe care \fBxargs\fP(1) le va crea în final. +.PP +Opțiunea \fB\-T1\fP pentru \fBxz\fP este acolo pentru a\-l forța să ruleze în modul +cu un singur fir de execuție, deoarece \fBxargs\fP(1) este folosit pentru a +controla cantitatea de paralelizare. +. +.SS "Modul robot" +Calculează câți octeți au fost salvați în total după comprimarea mai multor +fișiere: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Un script poate dori să afle dacă folosește o versiune \fBxz\fP suficient de +nouă. Următorul script \fBsh\fP(1) verifică dacă numărul versiunii +instrumentului \fBxz\fP este cel puțin 5.0.0. Această metodă este compatibilă +cu versiunile beta vechi, care nu acceptau opțiunea \fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Versiunea dumneavoastră de „xz” este prea veche!" +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Stabilește o limită de utilizare a memoriei pentru decomprimare folosind +variabila de mediu \fBXZ_OPT\fP, dar dacă o limită a fost deja stabilită, nu o +mărește: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Lanțuri de filtrare personalizate pentru instrumentul de comprimare" +Cea mai simplă utilizare a lanțurilor de filtrare personalizate este +personalizarea unei opțiuni prestabilite LZMA2. Acest lucru poate fi util, +deoarece opțiunile prestabilite acoperă doar un subset al combinațiilor +potențial utile de opțiuni de comprimare. +.PP +Coloanele CPUComp din tabelele de descriere a opțiunilor \fB\-0\fP ... \fB\-9\fP și +\fB\-\-extreme\fP sunt utile atunci când personalizați opțiunilor prestabilite +LZMA2. Iată părțile relevante colectate din aceste două tabele: +.RS +.PP +.TS +tab(;); +c c +n n. +ValPrestab;CPUComp +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Dacă știți că un fișier necesită un dicționar oarecum mare (de exemplu, +32Mio) pentru a se comprima bine, dar doriți să\-l comprimați mai repede +decât ar face \fBxz \-8\fP, o opțiune prestabilită cu o valoare CPUComp scăzută +(de exemplu, 1) poate fi modificată pentru a utiliza un dicționar mai mare: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Cu anumite fișiere, comanda de mai sus poate fi mai rapidă decât \fBxz \-6\fP în +timp ce comprimă semnificativ mai bine. Cu toate acestea, trebuie subliniat +că doar unele fișiere se beneficiază de un dicționar mare, păstrând în +același timp valoarea CPUComp scăzută. Cea mai evidentă situație, în care un +dicționar mare poate ajuta foarte mult, este o arhivă care conține fișiere +foarte asemănătoare de cel puțin câțiva megaocteți fiecare. Dimensiunea +dicționarului trebuie să fie semnificativ mai mare decât orice fișier +individual pentru a permite LZMA2 să profite din plin de asemănările dintre +fișierele consecutive. +.PP +Dacă utilizarea unei mari cantități de memorie pentru comprimare și +decomprimare este în regulă, iar fișierul comprimat are cel puțin câteva +sute de megaocteți, poate fi util să folosiți un dicționar și mai mare decât +cei 64Mio pe care i\-ar folosi \fBxz \-9\fP: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Utilizarea opțiunii \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) ca în exemplul de mai +sus, poate fi utilă pentru a vedea cerințele de memorie la comprimare și +decomprimare. Amintiți\-vă că utilizarea unui dicționar mai mare decât +dimensiunea fișierului necomprimat este risipă de memorie, de aceea, comanda +de mai sus nu este utilă pentru fișiere mici. +.PP +Uneori, timpul de comprimare nu contează, dar utilizarea memoriei la +decomprimare trebuie menținută la un nivel scăzut, de exemplu, pentru a face +posibilă decomprimarea fișierului pe un sistem încorporat. Următoarea +comandă folosește \fB\-6e\fP (\fB\-6 \-\-extreme\fP) ca bază și fixează dimensiunea +dicționarului la doar 64Kio. Fișierul rezultat poate fi decomprimat cu XZ +Embedded (de aceea există \fB\-\-check=crc32\fP) folosind aproximativ 100Kio de +memorie. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Dacă doriți să stoarceți cât mai mulți octeți posibil, ajustarea numărului +de biți de context literal (\fIlc\fP) și a numărului de biți de poziție (\fIpb\fP) +poate ajuta uneori. Ajustarea numărului de biți de poziție literală (\fIlp\fP) +ar putea ajuta, de asemenea, dar de obicei \fIlc\fP și \fIpb\fP sunt mai +importante. De exemplu, o arhivă de cod sursă conține în mare parte text +US\-ASCII, așa că ceva precum comanda următoare, ar putea oferi un fișier +„mai slăbuț” (aproximativ cu 0,1%) mai mic decât cu \fBxz \-6e\fP (încercați și +fără \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 fișierul_sursă.tar\fR +.fi +.RE +.PP +Utilizarea unui alt filtru împreună cu LZMA2 poate îmbunătăți comprimarea cu +anumite tipuri de fișiere. De exemplu, pentru a comprima o bibliotecă +partajată x86 pe 32 de biți sau x86 pe 64 de biți folosind filtrul BCJ x86: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Rețineți că ordinea opțiunilor de filtrare este semnificativă. Dacă \fB\-\-x86\fP +este specificată după \fB\-\-lzma2\fP, \fBxz\fP va da o eroare, deoarece nu poate +exista niciun filtru după LZMA2 și, de asemenea, pentru că filtrul x86 BCJ +nu poate fi utilizat ca ultimul filtru din lanțul de filtrare. +.PP +Filtrul Delta împreună cu LZMA2 pot da rezultate bune cu imagini bitmap. De +obicei, ar trebui să întreacă comprimarea PNG, care are câteva filtre mai +avansate decât delta simplă, dar utilizează Deflate pentru comprimarea +reală. +.PP +Imaginea trebuie să fie salvată în format necomprimat, de exemplu, ca TIFF +necomprimat. Parametrul de distanță al filtrului Delta este fixat să se +potrivească cu numărul de octeți per pixel din imagine. De exemplu, +bitmap\-ul RGB pe 24 de biți necesită \fBdist=3\fP și este, de asemenea, bine să +pasați \fBpb=0\fP la LZMA2 pentru a se adapta alinierii pe trei octeți: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Dacă mai multe imagini au fost introduse într\-o singură arhivă (de exemplu, +\&\fB.tar\fP), filtrul Delta va funcționa și pe aceasta atâta timp cât toate +imaginile au același număr de octeți per pixel. +. +.SH "CONSULTAȚI ȘI" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/unxz.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/unxz.1 new file mode 100644 index 0000000000000000000000000000000000000000..1555445592944b4f24e548fc0dc0b1c3af876030 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/unxz.1 @@ -0,0 +1,2111 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Romanian translation for xz-man. +.\" Mesajele în limba română pentru manualul pachetului XZ Utils. +.\" Remus-Gabriel Chelu , 2022 - 2025. +.\" Cronologia traducerii fișierului „xz-man”: +.\" Traducerea inițială, făcută de R-GC, pentru versiunea xz-man 5.4.0-pre1. +.\" Actualizare a traducerii pentru versiunea 5.4.0-pre2, făcută de R-GC, dec-2022. +.\" Actualizare a traducerii pentru versiunea 5.4.3, făcută de R-GC, mai-2023. +.\" Actualizare a traducerii pentru versiunea 5.4.4-pre1, făcută de R-GC, iul-2023. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre1, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre2, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.7.1-dev1, făcută de R-GC, ian-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.0-pre1, făcută de R-GC, mar-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.2-pre1, făcută de R-GC, oct-2025. +.\" Actualizare a traducerii pentru versiunea Y, făcută de X, Z(luna-anul). +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 "8 martie 2025" Tukaani "Utilități XZ" +. +.SH NUME +xz, unxz, xzcat, lzma, unlzma, lzcat \- Comprimă sau decomprimă fișiere .xz +și .lzma +. +.SH REZUMAT +\fBxz\fP [\fIopțiune...\fP] [\fIfișier...\fP] +. +.SH "ALIAS COMENZI" +\fBunxz\fP este echivalent cu \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP este echivalent cu \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP este echivalent cu \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP este echivalent cu \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP este echivalent cu \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Când scrieți scripturi care trebuie să decomprime fișiere, este recomandat +să folosiți întotdeauna comanda \fBxz\fP cu argumentele adecvate (\fBxz \-d\fP sau +\fBxz \-dc\fP) în loc de comenzile \fBunxz\fP și \fBxzcat\fP. +. +.SH DESCRIERE +\fBxz\fP este un instrument de comprimare a datelor de uz general cu sintaxă de +linie de comandă similară cu \fBgzip\fP(1) și \fBbzip2\fP(1). Formatul de fișier +nativ este formatul \fB.xz\fP, dar formatul vechi \fB.lzma\fP folosit de LZMA +Utils și fluxurile comprimate brute fără anteturi de format container sunt +de asemenea acceptate. În plus, este acceptată decomprimarea formatului +\&\fB.lz\fP folosit de \fBlzip\fP. +.PP +\fBxz\fP comprimă sau decomprimă fiecare \fIfișier\fP în funcție de modul de +operare selectat. Dacă nu sunt date \fIfișiere\fP sau \fIfișier\fP este \fB\-\fP, +\fBxz\fP citește de la intrarea standard și scrie datele procesate la ieșirea +standard. \fBxz\fP va refuza (afișează o eroare și omite \fIfișier\fP) să scrie +date comprimate la ieșirea standard dacă este un terminal. În mod similar, +\fBxz\fP va refuza să citească datele comprimate de la intrarea standard dacă +este un terminal. +.PP +Cu excepția cazului în care este specificată opțiunea \fB\-\-stdout\fP, +\fIfișierele\fP altele decât \fB\-\fP sunt scrise într\-un fișier nou al cărui nume +este derivat din numele \fIfișierului\fP sursă: +.IP \(bu 3 +La comprimare, sufixul formatului de fișier țintă (\fB.xz\fP sau \fB.lzma\fP) este +atașat la numele fișierului sursă pentru a se obține numele fișierului +țintă. +.IP \(bu 3 +La decomprimare, sufixul \fB.xz\fP, \fB.lzma\fP sau \fB.lz\fP este eliminat din +numele fișierului pentru a se obține numele fișierului țintă. \fBxz\fP +recunoaște și sufixele \fB.txz\fP și \fB.tlz\fP și le înlocuiește cu sufixul +\&\fB.tar\fP. +.PP +Dacă fișierul țintă există deja, este afișată o eroare și \fIfișier\fP este +omis. +.PP +Cu excepția cazului în care scrie la ieșirea standard, \fBxz\fP va afișa un +avertisment și va omite \fIfișier\fPul dacă se aplică oricare dintre +următoarele: +.IP \(bu 3 +\fIFișierul\fP nu este un fișier obișnuit. Legăturile simbolice nu sunt urmate +și, prin urmare, nu sunt considerate fișiere obișnuite. +.IP \(bu 3 +\fIFișierul\fP are mai mult de o legătură dură. +.IP \(bu 3 +\fIFișierul\fP are activat bitul «setuid», «setgid» sau cel lipicios(sticky). +.IP \(bu 3 +Modul de operare este stabilit la comprimare și \fIfișier\fP are deja un sufix +al formatului de fișier țintă (\fB.xz\fP sau \fB.txz\fP când se comprimă în +formatul \fB.xz\fP și \fB.lzma\fP sau \fB.tlz\fP când se comprimă în formatul +\&\fB.lzma\fP). +.IP \(bu 3 +Modul de operare este stabilit la decomprimare și \fIfișierul\fP nu are un +sufix al niciunui format de fișier acceptat (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, +\&\fB.tlz\fP, sau \fB.lz\fP). +.PP +După comprimarea sau decomprimarea cu succes a \fIfișierului\fP, \fBxz\fP copiază +proprietarul, grupul, permisiunile, timpul de acces și timpul de modificare +din \fIfișierul\fP sursă în fișierul țintă. Dacă copierea grupului eșuează, +permisiunile sunt modificate astfel încât fișierul țintă să nu devină +accesibil utilizatorilor care nu aveau permisiunea de a accesa \fIfișierul\fP +sursă. \fBxz\fP nu acceptă încă copierea altor metadate, cum ar fi listele de +control al accesului sau atributele extinse. +.PP +Odată ce fișierul țintă a fost închis cu succes, \fIfișierul\fP sursă este +eliminat dacă nu a fost specificată opțiunea \fB\-\-keep\fP. \fIFișierul\fP sursă nu +este niciodată eliminat dacă rezultatul este scris la ieșirea standard sau +dacă apare o eroare. +.PP +Trimiterea unui semnal \fBSIGINFO\fP sau \fBSIGUSR1\fP către procesul \fBxz\fP face +ca acesta să imprime informații despre progres la ieșirea de eroare +standard. Acest lucru are o utilizare limitată, deoarece atunci când ieșirea +de eroare standard este un terminal, folosind opțiunea \fB\-\-verbose\fP va afișa +un indicator de progres de actualizare automată. +. +.SS "Utilizarea memoriei" +Cantitatea de memorie utilizată de \fBxz\fP variază de la câteva sute de +kiloocteți la câțiva gigaocteți, în funcție de opțiunile de +comprimare. Opțiunile utilizate la comprimarea unui fișier determină +cerințele de memorie ale instrumentului de decomprimare. De obicei, +instrumentul de decomprimare are nevoie de 5% până la 20% din cantitatea de +memorie de care a avut nevoie instrumentul de comprimare la crearea +fișierului. De exemplu, decomprimarea unui fișier creat cu \fBxz \-9\fP necesită +în prezent 65Mio de memorie. Totuși, este posibil să aveți fișiere \fB.xz\fP +care necesită câțiva gigaocteți de memorie pentru decomprimare. +.PP +În special utilizatorii de sisteme mai vechi pot considera deranjantă +posibilitatea unei utilizări foarte mari a memoriei. Pentru a preveni +surprizele neplăcute, \fBxz\fP are încorporat un limitator de utilizare a +memoriei, care este dezactivat implicit. În timp ce unele sisteme de operare +oferă modalități de a limita utilizarea memoriei proceselor, bazarea pe +aceasta nu a fost considerată a fi suficient de flexibilă (de exemplu, +utilizarea \fBulimit\fP(1) pentru a limita memoria virtuală tinde să paralizeze +\fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Limitatorul de utilizare a memoriei poate fi activat cu opțiunea din linia +de comandă \fB\-\-memlimit=\fP\fIlimita\fP. Adesea este mai convenabil să activați +limitatorul în mod implicit prin definirea variabilei de mediu +\fBXZ_DEFAULTS\fP, de exemplu, \fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Este posibil +să stabiliți limitele separat pentru comprimare și decomprimare folosind +\fB\-\-memlimit\-compress=\fP\fIlimita\fP și +\fB\-\-memlimit\-decompress=\fP\fIlimita\fP. Utilizarea acestor două opțiuni în afara +\fBXZ_DEFAULTS\fP este foarte rar utilă, deoarece o singură rulare a \fBxz\fP nu +poate face atât comprimarea, cât și decomprimarea și \fB\-\-memlimit=\fP\fIlimita\fP +(sau \fB\-M\fP \fIlimita\fP ) este mai scurt de tastat pe linia de comandă. +.PP +Dacă limita de utilizare a memoriei specificată este depășită la +decomprimare, \fBxz\fP va afișa o eroare și decomprimarea fișierului va +eșua. Dacă limita este depășită la comprimare, \fBxz\fP va încerca să reducă +valorile stabilite astfel încât limita să nu mai fie depășită (cu excepția +cazului în care se utilizează opțiunea \fB\-\-format=raw\fP sau +\fB\-\-no\-adjust\fP). În acest fel, operațiunea nu va eșua decât dacă limita +stabilită este foarte mică. Scalarea valorilor stabilite se face în pași +care nu se potrivesc cu valorile prestabilite ale nivelului de comprimare, +de exemplu, dacă limita este doar puțin mai mică decât cantitatea necesară +pentru \fBxz \-9\fP, valorile stabilite vor fi reduse doar puțin , nu până la +valoarea prestabilită a lui \fBxz \-8\fP. +. +.SS "Concatenare și completare (prin umplere cu octeți nuli) cu fișiere .xz" +Este posibil să concatenați fișierele \fB.xz\fP așa cum sunt. \fBxz\fP va +decomprima astfel de fișiere ca și cum ar fi un singur fișier \fB.xz\fP. +.PP +Este posibil să se introducă umplutură între părțile concatenate sau după +ultima parte. Umplutura trebuie să fie compusă din octeți nuli, iar +dimensiunea umpluturii trebuie să fie un multiplu de patru octeți. Acest +lucru poate fi util, de exemplu, dacă fișierul \fB.xz\fP este stocat pe un +mediu care măsoară dimensiunile fișierelor în blocuri de 512 de octeți. +.PP +Concatenarea și completarea nu sunt permise cu fișierele \fB.lzma\fP sau +fluxurile brute. +. +.SH OPȚIUNI +. +.SS "Sufixe de numere întregi și valori speciale" +În majoritatea locurilor în care este de așteptat un număr întreg ca +argument, un sufix opțional este acceptat pentru a indica cu ușurință +numerele întregi mari. Nu trebuie să existe spațiu între numărul întreg și +sufix. +.TP +\fBKiB\fP +Înmulțește numărul întreg cu 1.024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP și +\fBKB\fP sunt acceptate ca sinonime pentru \fBKiB\fP. +.TP +\fBMiB\fP +Înmulțește numărul întreg cu 1,048,576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP, și \fBMB\fP +sunt acceptate ca sinonime pentru \fBMiB\fP. +.TP +\fBGiB\fP +Înmulțește numărul întreg cu 1,073,741,824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP, și +\fBGB\fP sunt acceptate ca sinonime pentru \fBGiB\fP. +.PP +Valoarea specială \fBmax\fP poate fi utilizată pentru a indica valoarea maximă +întreagă suportată de opțiune. +. +.SS "Mod de operare" +Dacă sunt date mai multe opțiuni de mod de funcționare, ultima dintre ele, +este cea care va avea efect. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Comprimare. Acesta este modul de operare implicit atunci când nu este +specificată nicio opțiune de mod de funcționare și nici un alt mod de +operare nu este implicat din numele comenzii (de exemplu, \fBunxz\fP implică +\fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +După o comprimare reușită, fișierul sursă este eliminat, cu excepția cazului +în care a fost specificată scrierea la ieșirea standard sau opțiunea +\fB\-\-keep\fP. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Decomprimare. După o decomprimare reușită, fișierul sursă este eliminat, cu +excepția cazului în care a fost specificată scrierea la ieșirea standard sau +opțiunea \fB\-\-keep\fP. +.TP +\fB\-t\fP, \fB\-\-test\fP +Testează integritatea \fIfișierelor\fP comprimate. Această opțiune este +echivalentă cu \fB\-\-decompress \-\-stdout\fP cu excepția faptului că datele +decomprimate sunt înlăturate în loc să fie scrise la ieșirea standard. Nu +sunt create sau eliminate fișiere. +.TP +\fB\-l\fP, \fB\-\-list\fP +Afișează informații despre \fIfișiere\fP comprimate. Nu are loc nicio +decomprimare la ieșire și nu sunt create sau eliminate fișiere. În modul +listă, programul nu poate citi datele comprimate din intrarea standard sau +din alte surse care nu pot fi explorate. +.IP "" +Listarea implicită arată informații de bază despre \fIfișiere\fP, câte un +fișier pe linie. Pentru a obține informații mai detaliate, utilizați și +opțiunea \fB\-\-verbose\fP. Pentru și mai multe informații, utilizați opțiunea +\fB\-\-verbose\fP de două ori, dar rețineți că acest lucru poate fi lent, +deoarece obținerea tuturor informațiilor suplimentare necesită multe +căutări. Lățimea ieșirii detaliate depășește 80 de caractere, deci +canalizarea ieșirii către, de exemplu, \fBless\ \-S\fP poate fi convenabilă dacă +terminalul nu este suficient de lat. +.IP "" +Ieșirea exactă poate varia între versiunile \fBxz\fP și diferitele +localizări(configurările regionale). Pentru ieșiri care pot fi citite de +mașină, ar trebui utilizată opțiunea \fB\-\-robot \-\-list\fP. +. +.SS "Modificatori de operare" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Nu șterge fișierele de intrare. +.IP "" +Începând cu \fBxz\fP 5.2.6, această opțiune face ca \fBxz\fP să comprime sau să +decomprime, chiar dacă intrarea este o legătură simbolică către un fișier +obișnuit, are mai mult de\-o legătură dură sau are marcați biții setuid, +setgid sau bitul lipicios. Biții setuid, setgid și bitul lipicios nu sunt +copiați în fișierul țintă. În versiunile anterioare acest lucru se făcea +numai cu ajutorul opțiunii \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Această opțiune are mai multe efecte: +.RS +.IP \(bu 3 +Dacă fișierul țintă există deja, îl șterge înainte de comprimare sau +decomprimare. +.IP \(bu 3 +Comprimă sau decomprimă chiar dacă intrarea este o legătură simbolică către +un fișier obișnuit, are mai mult de\-o legătură dură sau are marcați biții +setuid, setgid sau bitul lipicios. Biții setuid, setgid și bitul lipicios nu +sunt copiați în fișierul țintă. +.IP \(bu 3 +Când este utilizată cu opțiunile \fB\-\-decompress\fP și \fB\-\-stdout\fP, comanda +\fBxz\fP nu poate recunoaște tipul fișierului sursă, și copiază fișierul sursă +așa cum este la ieșirea standard. Acest lucru permite comenzii \fBxzcat\fP +\fB\-\-force\fP să fie folosită drept comanda \fBcat\fP(1) pentru fișierele care nu +au fost comprimate cu \fBxz\fP. Rețineți că, în viitor, \fBxz\fP ar putea să +accepte noi formate de fișiere comprimate, ceea ce poate face ca \fBxz\fP să +decomprime mai multe tipuri de fișiere în loc să le copieze așa cum sunt la +ieșirea standard. Opțiunea \fB\-\-format=\fP\fIformat\fP poate fi folosită pentru a +restricționa \fBxz\fP să decomprime doar un singur format de fișier. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Scrie datele comprimate sau decomprimate la ieșirea standard în loc de +într\-un fișier. Aceasta implică \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Decomprimă numai primul flux \fB.xz\fP și ignoră în tăcere posibilele date de +intrare rămase în urma fluxului. În mod normal, astfel de resturi rămase +face ca \fBxz\fP să afișeze o eroare. +.IP "" +\fBxz\fP nu decomprimă niciodată mai mult de un flux din fișierele \fB.lzma\fP sau +din fluxurile brute, dar această opțiune face ca \fBxz\fP să ignore posibilele +resturi de date rămase după fișierul \fB.lzma\fP sau fluxul brut. +.IP "" +Această opțiune nu are efect dacă modul de funcționare nu este +\fB\-\-decompress\fP sau \fB\-\-test\fP. +.IP "" +Începând cu \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP implică \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Dezactivează crearea de fișiere dispersate. În mod implicit, dacă decomprimă +într\-un fișier obișnuit, \fBxz\fP încearcă să facă fișierul dispersat dacă +datele decomprimate conțin secvențe lungi de zerouri binare. De asemenea, +funcționează atunci când scrie la ieșirea standard, atâta timp cât ieșirea +standard este conectată la un fișier obișnuit și sunt îndeplinite anumite +condiții suplimentare pentru a o face în siguranță. Crearea de fișiere +dispersate poate economisi spațiu pe disc și poate accelera decomprimarea +prin reducerea cantității de date de In/Ieș pe disc. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Când comprimă, utilizează \fI.suf\fP ca sufix pentru fișierul țintă în loc de +\&\fB.xz\fP sau \fB.lzma\fP. Dacă nu scrie la ieșirea standard și fișierul sursă are +deja sufixul \fI.suf\fP, este afișat un avertisment și fișierul este omis. +.IP "" +Când decomprimă, recunoaște fișierele cu sufixul \fI.suf\fP în plus față de +fișierele cu sufixul \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP sau \fB.lz\fP. Dacă +fișierul sursă are sufixul \fI.suf\fP, sufixul este eliminat pentru a obține +numele fișierului țintă. +.IP "" +La comprimarea sau decomprimarea fluxurilor brute (\fB\-\-format=raw\fP), sufixul +trebuie să fie întotdeauna specificat, cu excepția cazului în care se scrie +la ieșirea standard, deoarece nu există un sufix implicit pentru fluxurile +brute. +.TP +\fB\-\-files\fP[\fB=\fP\fIfișier\fP] +Citește numele fișierelor de procesat din \fIfișier\fP; dacă \fIfișierul\fP este +omis, numele fișierelor sunt citite de la intrarea standard. Numele de +fișiere trebuie să fie terminate cu caracterul de linie nouă. O liniuță +(\fB\-\fP) este luată ca nume de fișier obișnuit; nu înseamnă intrarea +standard. Dacă numele de fișiere sunt date și ca argumente în linia de +comandă, ele sunt procesate înainte ca numele fișierelor să fie citite din +\fIfișier\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIfișier\fP] +Această opțiune este identică cu \fB\-\-files\fP[\fB=\fP\fIfișier\fP], cu excepția +faptului că fiecare nume de fișier trebuie să fie terminat cu caracterul +nul. +. +.SS "Formatul de bază al fișierului și opțiunile de comprimare" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fIformat\fP +Specifică \fIformatul\fP fișierului pentru comprimare sau decomprimare: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Aceasta este valoarea implicită. La comprimare, \fBauto\fP este echivalent cu +\fBxz\fP. La decomprimare, formatul fișierului de intrare este detectat +automat. Rețineți că fluxurile brute (create cu \fB\-\-format=raw\fP) nu pot fi +detectate automat. +.TP +\fBxz\fP +Comprimă în formatul de fișier \fB.xz\fP sau acceptă numai fișierele \fB.xz\fP +când decomprimă. +.TP +\fBlzma\fP, \fBalone\fP +Comprimă în formatul de fișier \fB.lzma\fP vechi sau acceptă numai fișierele +\&\fB.lzma\fP când decomprimă. Numele alternativ \fBalone\fP este furnizat pentru +compatibilitatea cu versiunile mai vechi de LZMA Utils. +.TP +\fBlzip\fP +Acceptă numai fișierele \fB.lz\fP când decomprimă. Comprimarea nu este +acceptată. +.IP "" +Sunt acceptate versiunile 0 și 1 ale formatului \fB.lz\fP. Fișierele versiunii +0 au fost create cu \fBlzip\fP 1.3 și versiuni mai vechi. Astfel de fișiere nu +sunt comune, dar pot fi găsite în arhivele de fișiere, deoarece câteva +pachete sursă au fost lansate în acest format. Este posibil ca oamenii să +aibă și fișiere personale vechi în acest format. Suportul pentru +decomprimare pentru versiunea 0 a formatului a fost eliminat în \fBlzip\fP +1.18. \fBlzip\fP 1.4 și versiunile ulterioare creează fișiere în versiunea 1 a +formatului. +.TP +\fBraw\fP +Comprimă sau decomprimă un flux brut (fără anteturi). Acest lucru este +destinat doar utilizatorilor avansați. Pentru a decodifica fluxurile brute, +trebuie să utilizați opțiunea \fB\-\-format=raw\fP și să specificați în mod +explicit lanțul de filtre, care în mod normal ar fi fost stocat în +anteturile containerului. +.RE +.TP +\fB\-C\fP \fIverificarea\fP, \fB\-\-check=\fP\fIverificarea\fP +Specifică tipul verificării integrității. Verificarea este calculată din +datele necomprimate și stocată în fișierul \fB.xz\fP. Această opțiune are efect +numai la comprimarea în format \fB.xz\fP; formatul \fB.lzma\fP nu acceptă +verificări de integritate. Verificarea integrității (dacă există) este +efectuată atunci când fișierul \fB.xz\fP este decomprimat. +.IP "" +Tipuri de \fIverificare\fP acceptate: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Nu calculează deloc o verificare a integrității. Aceasta este de obicei o +idee proastă. Acest lucru poate fi util atunci când integritatea datelor +este oricum verificată prin alte mijloace. +.TP +\fBcrc32\fP +Calculează CRC32 folosind polinomul din IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Calculează CRC64 folosind polinomul din ECMA\-182. Aceasta este valoarea +implicită, deoarece este ceva mai bună decât CRC32 la detectarea fișierelor +deteriorate, iar diferența de viteză este neglijabilă. +.TP +\fBsha256\fP +Calculează SHA\-256. Acest lucru este oarecum mai lent decât CRC32 și CRC64. +.RE +.IP "" +Integritatea antetelor \fB.xz\fP este întotdeauna verificată cu CRC32. Nu este +posibilă modificarea sau dezactivarea acesteia. +.TP +\fB\-\-ignore\-check\fP +Nu efectuează verificarea integrității datelor comprimate la +decomprimare. Valorile CRC32 din antetele \fB.xz\fP vor fi însă verificate +normal. +.IP "" +\fBNu utilizați această opțiune decât dacă știți ce faceți\fP. Motive posibile +pentru a utiliza această opțiune: +.RS +.IP \(bu 3 +Încercarea de a recupera datele dintr\-un fișier .xz corupt. +.IP \(bu 3 +Accelerarea decomprimării. Acest lucru contează mai ales cu SHA\-256 sau cu +fișierele care s\-au comprimat extrem de bine. Este recomandat să nu +utilizați această opțiune în acest scop decât dacă integritatea fișierului +este verificată extern într\-un alt mod. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Selectează un nivel prestabilit de comprimare. Valoarea implicită este +\fB\-6\fP. Dacă sunt specificate mai multe niveluri prestabilite, ultimul are +efect. Dacă a fost deja specificat un lanț de filtre personalizat, +specificarea unui nivel prestabilit de comprimare șterge lanțul de filtre +personalizat. +.IP "" +Diferențele dintre valorile prestabilite sunt mai semnificative decât cu +\fBgzip\fP(1) și \fBbzip2\fP(1). Valorile de comprimare selectate determină +cerințele de memorie ale instrumentului de decomprimare, astfel încât +utilizarea unui nivel prea mare prestabilit ar putea face „dureroasă” +decomprimarea fișierului pe un sistem vechi cu puțină memorie RAM. Mai +exact, \fBnu este o idee bună să folosiți orbește \-9 pentru tot\fP așa cum se +întâmplă adesea cu \fBgzip\fP(1) și \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Acestea sunt valorile prestabilite oarecum rapide. \fB\-0\fP este uneori mai +rapid decât \fBgzip \-9\fP în timp ce comprimă mult mai bine. Cele mai ridicate +au adesea viteza comparabilă cu \fBbzip2\fP(1) cu un raport de comprimare +comparabil sau mai bun, deși rezultatele depind foarte mult de tipul de date +care sunt comprimate. +.TP +\fB\-4\fP ... \fB\-6\fP +Comprimare bună spre foarte bună, păstrând în același timp utilizarea +memoriei de către instrumentul de decomprimare la un nivel rezonabil chiar +și pentru sistemele vechi. \fB\-6\fP este valoarea implicită, care este de +obicei o alegere bună pentru distribuirea fișierelor care trebuie să poată +fi decomprimate chiar și pe sisteme cu doar 16Mio de memorie RAM. Opțiunile +(\fB\-5e\fP sau \fB\-6e\fP ar putea fi demne de luat în considerare. A se vedea +opțiunea \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Acestea sunt precum \fB\-6\fP, dar cu cerințe mai mari de memorie pentru +comprimare și decomprimare. Acestea sunt utile numai atunci când comprimați +fișiere mai mari de 8Mio, 16Mio și, respectiv, 32Mio. +.RE +.IP "" +Pe același hardware, viteza de decomprimare este aproximativ un număr +constant de octeți de date comprimate pe secundă. Cu alte cuvinte, cu cât +comprimarea este mai bună, cu atât decomprimarea va fi de obicei mai +rapidă. Aceasta înseamnă, de asemenea, că valoarea de la ieșire a cantității +de date necomprimate produsă pe secundă poate varia foarte mult. +.IP "" +Următorul tabel rezumă caracteristicile valorilor prestabilite: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +ValPrestab;DimDict;CPUComp;MemComp;MemDec +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Descrieri coloane: +.RS +.IP \(bu 3 +DimDict este dimensiunea dicționarului LZMA2. Este o risipă de memorie să +folosești un dicționar mai mare decât dimensiunea fișierului necomprimat. De +aceea este bine să evitați utilizarea valorilor prestabilite \fB\-7\fP ... \fB\-9\fP +atunci când nu este nevoie cu adevărat de ele. Pentru valoarea prestabilită +\fB\-6\fP sau alta mai mică, cantitatea de memorie irosită este de obicei +suficient de mică pentru a nu conta. +.IP \(bu 3 +CPUComp este o reprezentare simplificată a configurărilor LZMA2 care +afectează viteza de comprimare. Dimensiunea dicționarului afectează și +viteza, așa că, în timp ce CPUComp este aceeași pentru nivelurile \fB\-6\fP +\&... \fB\-9\fP, nivelurile mai mari tind să fie puțin mai lente. Pentru a obține +o comprimare și mai lentă și, astfel, posibil mai bună, consultați opțiunea +\fB\-\-extreme\fP. +.IP \(bu 3 +MemComp conține cerințele de memorie ale comprimării în modul cu un singur +fir de execuție. Poate varia ușor între versiunile \fBxz\fP. +.IP \(bu 3 +MemDec conține cerințele de memorie pentru decomprimare. Adică, +configurările de comprimare determină cerințele de memorie ale +decomprimării. Cantitatea exactă a memoriei utilizate la decomprimare este +puțin mai mare decât dimensiunea dicționarului LZMA2, dar valorile din tabel +au fost rotunjite la următorul Mio. +.RE +.IP "" +Cerințele de memorie ale modului cu mai multe fire de execuție sunt +semnificativ mai mari decât cele ale modului cu un singur fir de +execuție. Cu valoarea implicită a lui \fB\-\-block\-size\fP, fiecare fir are +nevoie de 3*3*DictSize plus MemComp sau MemDec. De exemplu, patru fire de +execuție cu valoarea prestabilită \fB\-6\fP au nevoie de 660\(en670\ Mio de +memorie. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Utilizează o variantă mai lentă a nivelului prestabilit de comprimare +selectat (\fB\-0\fP ... \fB\-9\fP) pentru a obține un raport de comprimare puțin mai +bun, dar din nefericire, acest lucru îl poate înrăutăți. Utilizarea memoriei +pentru decomprimare nu este afectată, dar utilizarea memoriei la comprimare +crește puțin la nivelurile prestabilite \fB\-0\fP ... \fB\-3\fP. +.IP "" +Deoarece există două valori prestabilite cu dimensiuni ale dicționarului de +4Mio și 8Mio, valorile prestabilite \fB\-3e\fP și \fB\-5e\fP folosesc configurări +puțin mai rapide (CPUComp mai mic) decât \fB\-4e\fP și \fB\-6e\fP, respectiv. În +acest fel, nu există două nivele prestabilite identice. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +ValPrestab;DimDict;CPUComp;MemComp;MemDec +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +De exemplu, există un total de patru nivele prestabilite care folosesc +dicționarul 8Mio, a căror ordine de la cel mai rapid la cel mai lent este +\fB\-5\fP, \fB\-6\fP, \fB\-5e\fP și \fB\-6e\fP . +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Acestea sunt alias de opțiuni, oarecum înșelătoare pentru \fB\-0\fP și, +respectiv, \fB\-9\fP. Acestea sunt furnizate numai pentru compatibilitatea cu +LZMA Utils. Evitați utilizarea acestor opțiuni. +.TP +\fB\-\-block\-size=\fP\fIdimensiunea\fP +Când comprimă în formatul \fB.xz\fP, împarte datele de intrare în blocuri de +\fIdimensiunea\fP octeți. Blocurile sunt comprimate independent unul de +celălalt, ceea ce ajută în modul cu mai multe fire de execuție și face +posibilă decomprimarea cu acces aleatoriu limitat. Această opțiune este de +obicei folosită pentru a suprascrie dimensiunea implicită a blocului în +modul cu mai multe fire de execuție, dar această opțiune poate fi folosită +și în modul cu un singur fir de execuție. +.IP "" +În modul cu mai multe fire de execuție, aproximativ de trei ori +\fIdimensiunea\fP de octeți vor fi alocați în fiecare fir pentru stocarea +intrării și ieșirii. \fIDimensiunea\fP implicită este de trei ori dimensiunea +dicționarului LZMA2 sau 1Mio, oricare dintre acestea este mai mare. În mod +obișnuit, o valoare bună este de două la patru ori dimensiunea dicționarului +LZMA2 sau de cel puțin 1Mio. Utilizarea unei \fIdimensiuni\fP mai mici decât +dimensiunea dicționarului LZMA2 este o risipă de memorie RAM, deoarece +atunci memoria tampon a dicționarului LZMA2 nu va fi niciodată utilizată pe +deplin. În modul cu mai multe fire de execuție, dimensiunile blocurilor sunt +stocate în anteturile blocurilor. Aceste informații privind dimensiunea sunt +necesare pentru decomprimarea cu mai multe fire. +.IP "" +În modul cu un singur fir de execuție, nicio divizare a blocurilor nu se +face în mod implicit. Folosirea acestei opțiuni nu afectează utilizarea +memoriei. Nu sunt stocate informații despre dimensiune în antetele +blocurilor, astfel încât fișierele create în modul cu un singur fir de +execuție nu vor fi identice cu fișierele create în modul cu mai multe fire +de execuție. Lipsa informațiilor privind dimensiunea înseamnă, de asemenea, +că \fBxz\fP nu va putea decomprima fișierele în modul cu mai multe fire. de +execuție. +.TP +\fB\-\-block\-list=\fP\fIelemente\fP +Când comprimă în formatul \fB.xz\fP, începe un nou bloc cu un lanț de filtre +personalizat opțional după intervalele specificate de date necomprimate. +.IP "" +\fIelementele\fP sunt o listă separată prin virgule. Fiecare element este +format dintr\-un număr opțional de lanț de filtrare între 0 și 9, urmat de +două puncte (\fB:\fP) și de o dimensiune cerută a datelor +necomprimate. Omiterea unui element (două sau mai multe virgule consecutive) +este o prescurtare pentru a utiliza dimensiunea și filtrele din elementul +anterior. +.IP "" +În cazul în care fișierul de intrare este mai mare decât suma dimensiunilor +din \fIelemente\fP, ultimul element se repetă până la sfârșitul fișierului. O +valoare specială de \fB0\fP poate fi utilizată ca ultimă dimensiune pentru a +indica faptul că restul fișierului trebuie să fie codificat ca un singur +bloc. +.IP "" +Un lanț de filtre alternativ pentru fiecare bloc poate fi specificat în +combinație cu opțiunile \fB\-\-filters1=\fP\fIfiltre\fP \&...\& +\fB\-\-filters9=\fP\fIfiltre\fP. Aceste opțiuni definesc lanțuri de filtre cu un +identificator cuprins între 1\(en9. Lanțul de filtre 0 poate fi utilizat +pentru a se referi la lanțul de filtre implicit, ceea ce este același lucru +cu a nu specifica un lanț de filtre. Identificatorul lanțului de filtre +poate fi utilizat înaintea dimensiunii necomprimate, urmat de două puncte +(\fB:\fP). De exemplu, dacă se specifică +\fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP, atunci blocurile vor fi +create folosind: +.RS +.IP \(bu 3 +Lanțul de filtre specificat de \fB\-\-filters1\fP și 2 Mio de intrare +.IP \(bu 3 +Lanțul de filtre specificat de \fB\-\-filters3\fP și 2 Mio de intrare +.IP \(bu 3 +Lanțul de filtre specificat de \fB\-\-filters2\fP și 4 Mio de intrare +.IP \(bu 3 +Lanțul de filtre specificat de \fB\-\-filters2\fP și 4 Mio de intrare +.IP \(bu 3 +Lanțul de filtre implicit și 2 MiB de intrare +.IP \(bu 3 +Lanțul de filtre implicit și 4 MiB de intrare pentru fiecare bloc până la +sfârșitul intrării. +.RE +.IP "" +Dacă se specifică o dimensiune care depășește dimensiunea blocului +codificatorului (fie valoarea implicită în modul cu fire de execuție, fie +valoarea specificată cu \fB\-\-block\-size=\fP\fIdimensiune\fP), codificatorul va +crea blocuri suplimentare, păstrând limitele specificate în \fIelemente\fP. De +exemplu, dacă se specifică \fB\-\-block\-size=10MiB\fP +\fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP și fișierul de intrare este de +80 MiB, se vor obține 11 blocuri: 5, 10, 8, 10, 10, 2, 10, 10, 10, 4, 10, +10, 10 și 1 Mio. +.IP "" +În modul cu mai multe fire de execuție, dimensiunile blocurilor sunt stocate +în antetele blocurilor. Acest lucru nu se face în modul cu un singur fir de +execuție, astfel încât ieșirea codificată nu va fi identică cu cea a modului +cu mai multe fire de execuție. +.TP +\fB\-\-flush\-timeout=\fP\fItimp_limită\fP +La comprimare, dacă au trecut mai mult de \fItimp_limită\fP milisecunde (un +întreg pozitiv) de la curățarea anterioară și citirea mai multor intrări +s\-ar bloca, toate datele de intrare în așteptare sunt eliminate din +codificator și puse la dispoziție în fluxul de ieșire. Acest lucru poate să +fie util dacă \fBxz\fP este utilizat pentru a comprima datele care sunt +transmise în flux printr\-o rețea. Valorile mici de \fItimp_limită\fP fac datele +disponibile la capătul de recepție cu o mică întârziere, dar valorile mari +de \fItimp_limită\fP oferă un raport de comprimare mai bun. +.IP "" +Această caracteristică este dezactivată în mod implicit. Dacă această +opțiune este specificată de mai multe ori, ultima este cea care se ia în +considerare. Valoarea specială a lui \fItimp_limită\fP de \fB0\fP, poate fi +utilizată pentru a dezactiva în mod explicit această caracteristică. +.IP "" +Această caracteristică nu este disponibilă în sistemele non\-POSIX. +.IP "" +.\" FIXME +\fBAceastă caracteristică este încă experimentală\fP. În prezent, \fBxz\fP este +nepotrivit pentru decomprimarea fluxului în timp real datorită modului în +care \fBxz\fP utilizează memoria tampon. +.TP +\fB\-\-no\-sync\fP +Nu sincronizează fișierul țintă și directorul acestuia cu dispozitivul de +stocare înainte de a elimina fișierul sursă. Acest lucru poate îmbunătăți +performanța în cazul comprimării sau decomprimării multor fișiere mici. Cu +toate acestea, dacă sistemul se blochează imediat după ștergere, este +posibil ca fișierul țintă să nu fi fost scris pe dispozitivul de stocare, +dar operația de ștergere să fi fost. În acest caz, nici fișierul sursă +original, nici fișierul țintă nu sunt disponibile. +.IP "" +Această opțiune are efect numai atunci când \fBxz\fP urmează să elimine +fișierul sursă. În alte cazuri, sincronizarea nu se face niciodată. +.IP "" +Sincronizarea și \fB\-\-no\-sync\fP au fost adăugate în \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIlimita\fP +Stabilește o limită de utilizare a memoriei pentru comprimare. Dacă această +opțiune este specificată de mai multe ori, ultima va avea efect. +.IP "" +Dacă parametrii de comprimare depășesc \fIlimita\fP, \fBxz\fP va încerca să +ajusteze parametrii scăzând valorile acestora, astfel încât limita să nu mai +fie depășită și va afișa o notificare că ajustarea automată a fost +efectuată. Ajustările se fac în această ordine: reducerea numărului de fire, +trecerea la modul un singur fir de execuție dacă chiar și un singur fir în +modul cu mai multe fire de execuție depășește \fIlimita\fP și, în final, +reducerea dimensiunii dicționarului LZMA2. +.IP "" +Când comprimă cu opțiunea \fB\-\-format=raw\fP sau dacă a fost specificată +opțiunea \fB\-\-no\-adjust\fP, numai numărul de fire poate fi redus, deoarece se +poate face fără a afecta rezultatul comprimării. +.IP "" +Dacă \fIlimita\fP nu poate fi îndeplinită chiar și cu ajustările descrise mai +sus, este afișată o eroare și \fBxz\fP va ieși cu starea de ieșire 1. +.IP "" +\fILimita\fP poate fi specificata în mai multe moduri: +.RS +.IP \(bu 3 +\fILimita\fP poate fi o valoare absolută în octeți. Utilizarea unui sufix +întreg precum \fBMiB\fP poate fi utilă. De exemplu: +\fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +\fILimita\fP poate fi specificată ca procent din memoria fizică totală +(RAM). Acest lucru poate fi util mai ales atunci când definiți variabila de +mediu \fBXZ_DEFAULTS\fP într\-un script de inițializare shell care este partajat +între diferite calculatoare. În acest fel, limita este automat mai mare pe +sistemele cu mai multă memorie. De exemplu: \fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +\fILimita\fP poate fi restabilită la valoarea implicită dându\-i valoarea +\fB0\fP. În prezent, aceasta este echivalentă cu stabilirea \fIlimitei\fP la +\fBmax\fP (fără limită de utilizare a memoriei). +.RE +.IP "" +Pentru \fBxz\fP pe 32 de biți există un caz special: dacă \fIlimita\fP ar fi peste +\fB4020MiB\fP, \fIlimita\fP este stabilită la \fB4020MiB\fP. Pe MIPS32 este +stabilită în schimb la \fB2000MiB\fP; (valorile \fB0\fP și \fBmax\fP nu sunt afectate +de acest lucru \-\- o caracteristică similară nu există pentru +decomprimare). Acest lucru poate fi util atunci când un executabil pe 32 de +biți are acces la un spațiu de adrese de 4Gio (2Gio pe MIPS32), se speră că +nu produce daune în alte situații. +.IP "" +Consultați și secțiunea \fBUtilizarea memoriei\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIlimita\fP +Stabilește o limită de utilizare a memoriei pentru decomprimare. Acest lucru +afectează și modul \fB\-\-list\fP. Dacă operațiunea nu este posibilă fără a +depăși \fIlimita\fP, \fBxz\fP va afișa o eroare și decomprimarea fișierului va +eșua. Consultați \fB\-\-memlimit\-compress=\fP\fIlimita\fP pentru modalitățile +posibile de a specifica \fIlimita\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimita\fP +Stabilește o limită de utilizare a memoriei pentru decomprimarea cu mai +multe fire de execuție. Acest lucru poate afecta doar numărul de fire de +execuție; acest lucru nu îl va face niciodată pe \fBxz\fP să refuze +decomprimarea unui fișier. Dacă \fIlimita\fP este prea scăzută pentru a permite +orice mod cu mai multe fire de execuție, \fIlimita\fP este ignorată și \fBxz\fP va +continua în modul cu un singur fir de execuție. Rețineți că, dacă se +folosește și opțiunea \fB\-\-memlimit\-decompress\fP, se va aplica întotdeauna +atât modurilor cu un singur fir de execuție, cât și modurilor cu mai multe +fire de execuție și astfel \fIlimita\fP efectivă pentru modul cu mai multe fire +de execuție nu va fi niciodată mai mare decât limita stabilită cu opțiunea +\fB\-\-memlimit\-decompress\fP. +.IP "" +Spre deosebire de celelalte opțiuni de limită de utilizare a memoriei, +opțiunea \fB\-\-memlimit\-mt\-decompress=\fP\fIlimita\fP are o \fIlimită\fP implicită +specifică sistemului. Comanda \fBxz \-\-info\-memory\fP poate fi folosită pentru a +vedea valoarea curentă. +.IP "" +Această opțiune și valoarea ei implicită există deoarece, fără nicio limită, +decomprimarea cu (mai multe) fire de execuție ar putea ajunge să aloce o +cantitate „nebună” de memorie cu unele fișiere de intrare. Dacă \fIlimita\fP +implicită este prea scăzută pe sistemul dumneavoastră, nu ezitați să +creșteți \fIlimita\fP, dar niciodată să nu o stabiliți la o valoare mai mare +decât cantitatea de memorie RAM utilizabilă și cu niște fișiere de intrare +adecvate, \fBxz\fP va încerca să utilizeze acea cantitate de memorie chiar și +cu un număr redus de fire de execuție. Rularea lui \fBxz\fP cu depășirea +cantității de memorie fizice(RAM) sau a celei de interschimb(swap) nu va +îmbunătăți performanța de decomprimare. +.IP "" +Consultați opțiunea \fB\-\-memlimit\-compress=\fP\fIlimita\fP pentru modalități +posibile de a specifica \fIlimita\fP. Stabilirea \fIlimitei\fP la \fB0\fP +restabilește \fIlimita\fP la valoarea implicită specifică sistemului. +.TP +\fB\-M\fP \fIlimita\fP, \fB\-\-memlimit=\fP\fIlimita\fP, \fB\-\-memory=\fP\fIlimita\fP +Aceasta este echivalentă cu specificarea opțiunilor: +\fB\-\-memlimit\-compress=\fP\fIlimita\fP \fB\-\-memlimit\-decompress=\fP\fIlimita\fP +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimita\fP. +.TP +\fB\-\-no\-adjust\fP +Afișează o eroare și iese dacă limita de utilizare a memoriei nu poate fi +îndeplinită fără ajustarea parametrilor care afectează ieșirea +comprimată. Adică, acest lucru împiedică \fBxz\fP să comute codificatorul din +modul cu mai multe fire de execuție în modul cu un singur fir de execuție și +să reducă dimensiunea dicționarului LZMA2. Chiar și atunci când această +opțiune este utilizată, numărul de fire de execuție poate fi redus pentru a +îndeplini limita de utilizare a memoriei, deoarece aceasta nu va afecta +comprimarea. +.IP "" +Ajustarea automată este întotdeauna dezactivată la crearea fluxurilor brute +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fInumăr\fP, \fB\-\-threads=\fP\fInumăr\fP +Specifică numărul de fire de execuție de utilizat. Stabilirea \fInumărului\fP +la valoarea specială \fB0\fP, face ca \fBxz\fP să utilizeze până la atâtea fire de +execuție câte procesoare sunt în sistem. Numărul real de fire de execuție +poate fi mai mic decât \fInumăr\fP dacă fișierul de intrare nu este suficient +de mare pentru a trece la modul cu mai multe fire de execuție cu parametrii +dați, sau dacă folosirea mai multor fire de execuție ar depăși limita de +utilizare a memoriei. +.IP "" +Operațiile de comprimare cu un singur fir de execuție și cele cu mai multe +fire de execuție produc ieșiri diferite. Comprimarea cu un singur fir de +execuție va oferi cea mai mică dimensiune a fișierului, dar numai ieșirea de +la comprimarea cu mai multe fire de execuție poate fi decomprimată folosind +mai multe fire. Stabilirea \fInumărului\fP la \fB1\fP va determina ca \fBxz\fP să +folosească modul cu un singur fir de execuție. Stabilirea \fInumărului\fP la +orice altă valoare, inclusiv \fB0\fP, va determina ca \fBxz\fP să folosească +comprimarea cu mai multe fire de execuție chiar dacă sistemul acceptă doar +un fir hardware; (\fBxz\fP 5.2.x folosește modul cu un singur fir de execuție +în această situație). +.IP "" +Pentru a utiliza modul cu mai multe fire de execuție cu un singur fir, +stabiliți \fInumărul\fP la \fB+1\fP. Prefixul \fB+\fP nu are efect cu alte valori +decât \fB1\fP. O limită de utilizare a memoriei poate face în continuare \fBxz\fP +să treacă în modul cu un singur fir, cu excepția cazului în care este +utilizată opțiunea \fB\-\-no\-adjust\fP. Suportul pentru prefixul \fB+\fP a fost +adăugat în \fBxz\fP 5.4.0. +.IP "" +Dacă a fost solicitat un număr automat de fire și nu a fost specificată +nicio limită de utilizare a memoriei, atunci o limită „maleabilă” implicită +specifică sistemului va fi utilizată pentru a limita eventual numărul de +fire de execuție. Este o limită „maleabilă” în sensul că este ignorată dacă +numărul de fire devine unul, astfel o limită „maleabilă” nu va opri +niciodată \fBxz\fP să comprime sau să decomprime. Această limită „maleabilă” +implicită nu va face \fBxz\fP să treacă de la modul cu mai multe fire de +execuție la modul cu un singur fir de execuție. Limitele active pot fi +văzute rulând comanda \fBxz \-\-info\-memory\fP. +.IP "" +În prezent, singura metodă de procesare cu fire de execuție este împărțirea +intrării în blocuri și comprimarea lor independent unul de +celălalt. Dimensiunea implicită a blocului depinde de nivelul de comprimare +și poate fi înlocuită cu opțiunea \fB\-\-block\-size=\fP\fIdimensiune\fP. +.IP "" +Decomprimarea cu fire de execuție funcționează numai pe fișierele care +conțin mai multe blocuri cu informații despre dimensiune în antetele +blocurilor. Toate fișierele suficient de mari comprimate în modul cu mai +multe fire de execuție îndeplinesc această condiție, dar fișierele +comprimate în modul cu un singur fir de execuție nu o îndeplinesc chiar dacă +a fost folosită opțiunea \fB\-\-block\-size=\fP\fIdimensiune\fP. +.IP "" +Valoarea implicită pentru \fIfire de execuție\fP este \fB0\fP. În \fBxz\fP 5.4.x și +mai vechi, valoarea implicită este \fB1\fP. +. +.SS "Lanțuri de filtrare personalizate pentru instrumentul de comprimare" +Un lanț de filtrare personalizat permite specificarea parametrilor de +comprimare în detaliu, în loc să se bazeze pe cei asociați opțiunilor +prestabilite. Când este specificat un lanț de filtrare personalizat, +opțiunile prestabilite (\fB\-0\fP \&...\& \fB\-9\fP și \fB\-\-extreme\fP) de mai devreme +din linia de comandă sunt uitate. Dacă o opțiune prestabilită este +specificată după una sau mai multe opțiuni de lanț de filtrare personalizat, +noua prestabilire intră în vigoare și opțiunile lanțului de filtrare +personalizat, specificate mai devreme sunt uitate. +.PP +Un lanț de filtrare este comparabil cu conductele din linia de comandă. La +comprimare, intrarea necomprimată merge la primul filtru, a cărui ieșire +merge la următorul filtru (dacă există). Ieșirea ultimului filtru este +scrisă în fișierul comprimat. Numărul maxim de filtre din lanț este de +patru, dar de obicei un lanț de filtrare are doar unul sau două filtre. +.PP +Multe filtre au limitări în ceea ce privește locul în care se pot afla în +lanțul de filtrare: unele filtre pot funcționa doar ca ultimul filtru din +lanț, altele doar ca non\-ultim filtru și unele funcționează în orice poziție +din lanț. În funcție de filtru, această limitare este fie inerentă +proiectării filtrului, fie există pentru a preveni problemele de securitate. +.PP +Un lanț de filtre personalizat poate fi specificat în două moduri +diferite. Opțiunile \fB\-\-filters=\fP\fIfiltre\fP și \fB\-\-filters1=\fP\fIfiltre\fP +\&...\& \fB\-\-filters9=\fP\fIfiltre\fP permit specificarea unui întreg lanț de +filtre într\-o singură opțiune, folosind sintaxa șirului de filtre +liblzma. Alternativ, un lanț de filtre poate fi specificat prin utilizarea +uneia sau mai multor opțiuni de filtrare individuale în ordinea în care sunt +dorite în lanțul de filtre. Adică, ordinea opțiunilor de filtrare +individuale este semnificativă! La decodificarea fluxurilor brute +(\fB\-\-format=raw\fP), lanțul de filtre trebuie să fie specificat în aceeași +ordine în care a fost specificat la comprimare. Orice filtru individual sau +opțiuni presetate specificate înainte de opțiunea de lanț complet +(\fB\-\-filters=\fP\fIfiltre\fP) vor fi uitate. Filtrele individuale specificate +după opțiunea „lanț complet” vor reinițializa lanțul de filtre. +.PP +Atât opțiunile de filtrare completă, cât și cele de filtrare individuală +acceptă \fIopțiuni\fP specifice filtrului sub forma unei liste separate prin +virgule. Se ignoră virgulele suplimentare din \fIopțiuni\fP. Fiecare opțiune +are o valoare implicită, deci specificați\-le pe cele pe care doriți să le +modificați. +.PP +Pentru a vedea întregul lanț de filtre și \fIopțiuni\fP, utilizați \fBxz \-vv\fP +(adică folosiți \fB\-\-verbose\fP de două ori). Acest lucru funcționează și +pentru vizualizarea opțiunilor lanțului de filtre utilizate de valorile +prestabilite. +.TP +\fB\-\-filters=\fP\fIfiltre\fP +Specificați întregul lanț de filtre sau o presetare într\-o singură +opțiune. Fiecare filtru poate fi separat prin spații sau două liniuțe +(\fB\-\-\fP). Este posibil să fie necesar ca \fIfiltrele\fP să fie puse între +ghilimele în linia de comandă a shell\-ului pentru a fi analizate ca o +singură opțiune. Pentru a indica \fIopțiuni\fP, utilizați \fB:\fP sau \fB=\fP. O +presetare poate fi prefixată cu un \fB\-\fP și urmată de zero sau mai multe +indicatoare. Singurul indicator suportat este \fBe\fP pentru a aplica aceleași +opțiuni ca și \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIfiltre\fP ... \fB\-\-filters9\fP=\fIfiltre\fP +Specifică până la nouă lanțuri de filtre suplimentare care pot fi utilizate +cu \fB\-\-block\-list\fP. +.IP "" +De exemplu, atunci când se comprimă o arhivă cu fișiere executabile urmate +de fișiere text, partea executabilă ar putea utiliza un lanț de filtre cu un +filtru BCJ, iar partea de text doar filtrul LZMA2. +.TP +\fB\-\-filters\-help\fP +Afișează un mesaj de ajutor care descrie modul de specificare a presetărilor +și a lanțurilor de filtre personalizate în opțiunile \fB\-\-filters\fP și +\fB\-\-filters1=\fP\fIfiltre\fP \&...\& \fB\-\-filters9=\fP\fIfiltre\fP și iese. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIopțiuni\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIopțiuni\fP] +.PD +Adaugă filtrul LZMA1 sau LZMA2 la lanțul de filtre. Aceste filtre pot fi +folosite doar ca ultimul filtru din lanț. +.IP "" +LZMA1 este un filtru vechi, care este acceptat aproape exclusiv datorită +formatului de fișier vechi \fB.lzma\fP, care acceptă numai LZMA1. LZMA2 este o +versiune actualizată a LZMA1 pentru a rezolva unele probleme practice ale +LZMA1. Formatul \fB.xz\fP folosește LZMA2 și nu acceptă deloc LZMA1. Viteza de +comprimare și rapoartele LZMA1 și LZMA2 sunt practic aceleași. +.IP "" +LZMA1 și LZMA2 au același set de \fIopțiuni\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIprestabilit\fP +Reconfigurează toate \fIopțiunile\fP LZMA1 sau LZMA2 la +\fIprestabilit\fP. \fIprestabilit\fP constă dintr\-un număr întreg, care poate fi +urmat de modificatori prestabiliți cu o singură literă. Numărul întreg +poate fi de la \fB0\fP la \fB9\fP, potrivindu\-se cu opțiunile liniei de comandă +\fB\-0\fP \&...\& \fB\-9\fP. Singurul modificator acceptat în prezent este \fBe\fP, +care se potrivește cu \fB\-\-extreme\fP. Dacă nu este specificat \fBprestabilit\fP, +valorile implicite ale \fIopțiunilor\fP LZMA1 sau LZMA2 sunt preluate din +prestabilirea \fB6\fP. +.TP +\fBdict=\fP\fIdimensiunea\fP +\fIDimensiunea\fP dicționarului (istoricul memoriei tampon) indică câți octeți +din datele necomprimate recent procesate sunt păstrați în +memorie. Algoritmul încearcă să găsească secvențe de octeți care se repetă +(potriviri) în datele necomprimate și să le înlocuiască cu referințe la +datele aflate în prezent în dicționar. Cu cât dicționarul este mai mare, cu +atât este mai mare șansa de a găsi o potrivire. Astfel, creșterea +\fIdimensiunii\fP dicționarului îmbunătățește de obicei raportul de comprimare, +dar un dicționar mai mare decât fișierul necomprimat este risipă de memorie. +.IP "" +\fIDimensiunea\fPtipică a dicționarului este de la 64Kio până la 64Mio. Minimul +este de 4Kio. Maximul pentru compresie este în prezent de 1,5Gio +(1536Mio). Decomprimarea acceptă deja dicționare cu până la un octet mai +puțin de 4Gio, care este maximul pentru formatele de flux LZMA1 și LZMA2. +.IP "" +\fIDimensiunea\fP dicționarului și găsitorul de potriviri (match finder) → +(\fImf\fP) determină împreună utilizarea memoriei de către codificatorul LZMA1 +sau LZMA2. Aceeași \fIdimensiune\fP a dicționarului (sau mai mare) care a fost +utilizată la comprimare, este necesară pentru decomprimare, astfel încât +utilizarea memoriei de către decodificator este determinată de dimensiunea +dicționarului utilizată la comprimare. Antetele \fB.xz\fP stochează +\fIdimensiunea\fP dicționarului fie ca 2^\fIn\fP, fie ca 2^\fIn\fP + 2^(\fIn\fP\-1), deci +aceste \fIdimensiuni\fP sunt oarecum preferate pentru comprimare. Alte +\fIdimensiuni\fP vor fi rotunjite atunci când sunt stocate în anteturile +\&\fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Specifică numărul de biți de context literal. Minimul este 0 și maximul este +4; implicit este 3. În plus, suma \fIlc\fP și \fIlp\fP nu trebuie să depășească +4. +.IP "" +Toți octeții care nu pot fi codificați ca potriviri sunt codificați ca +literali. Adică, literalii sunt pur și simplu octeți de 8 biți care sunt +codificați unul câte unul. +.IP "" +Codificarea literală presupune că cei mai mari biți \fIlc\fP ai octetului +anterior necomprimat se corelează cu octetul următor. De exemplu, în textul +tipic englezesc, o literă mare este adesea urmată de o literă mică, iar o +literă mică este urmată de obicei de o altă literă mică. În setul de +caractere US\-ASCII, cei mai mari trei biți sunt 010 pentru literele mari și +011 pentru literele mici. Când \fIlc\fP este cel puțin 3, codificarea literală +poate profita de această proprietate în datele necomprimate. +.IP "" +Valoarea implicită (3) este de obicei bună. Dacă doriți o comprimare maximă, +testați \fBlc=4\fP. Uneori ajută puțin, iar uneori înrăutățește comprimarea +\&. Dacă o agravează, încercați de\-asemeni cu \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Specifică numărul de biți de poziție literală. Minimul este 0 și maximul +este 4; implicit este 0. +.IP "" +\fILp\fP afectează ce fel de aliniere în datele necomprimate este presupusă la +codificarea literalelor. Consultați argumentul \fIpb\fP de mai jos pentru mai +multe informații despre aliniere. +.TP +\fBpb=\fP\fIpb\fP +Specifică numărul de biți de poziție. Minimul este 0 și maximul este 4; +implicit este 2. +.IP "" +\fIPb\fP afectează ce fel de aliniere în datele necomprimate este presupusă în +general. Valoarea implicită înseamnă alinierea pe patru octeți +(2^\fIpb\fP=2^2=4), care este adesea o alegere bună atunci când nu există o +ipoteză mai bună. +.IP "" +Când alinierea este cunoscută, definirea lui \fIpb\fP în mod corespunzător +poate reduce puțin dimensiunea fișierului. De exemplu, cu fișierele text cu +aliniere pe un octet (US\-ASCII, ISO\-8859\-*, UTF\-8), definirea \fBpb=0\fP poate +îmbunătăți ușor comprimarea. Pentru textul UTF\-16, \fBpb=1\fP este o alegere +bună. Dacă alinierea este un număr impar, cum ar fi 3 octeți, \fBpb=0\fP ar +putea fi cea mai bună alegere. +.IP "" +Chiar dacă alinierea presupusă poate fi ajustată cu \fIpb\fP și \fIlp\fP, LZMA1 și +LZMA2 încă favorizează ușor alinierea pe 16 octeți. Ar putea fi demn de luat +în considerare atunci când proiectați formate de fișiere care pot fi adesea +comprimate cu LZMA1 sau LZMA2. +.TP +\fBmf=\fP\fImf\fP +Căutarea potrivirilor are un efect major asupra vitezei codificatorului, +utilizării memoriei și raportului de comprimare. De obicei, găsitorii de +potriviri din lanțul sumelor de control sunt mai rapizi decât găsitorii de +potriviri din arborele binar. Valoarea implicită depinde de \fIprestabilit\fP: +0 folosește \fBhc3\fP, 1\(en3 folosește \fBhc4\fP, iar restul folosește \fBbt4\fP. +.IP "" +Sunt acceptate următoarele opțiuni de căutare de potriviri. Formulele de +utilizare a memoriei de mai jos sunt aproximări estimative, care se apropie +cel mai mult de realitate atunci când \fIdict\fP este o putere a lui doi. +.RS +.TP +\fBhc3\fP +Lanț de sumă de control, cu suma de control de 2 și 3 octeți +.br +Valoarea minimă pentru \fInice\fP: 3 +.br +Utilizarea memoriei: +.br +\fIdict\fP * 7.5 (dacă \fIdict\fP <= 16 Mio); +.br +\fIdict\fP * 5.5 + 64 MiB (dacă \fIdict\fP > 16 Mio) +.TP +\fBhc4\fP +Lanț de sumă de control, cu suma de control de 2, 3 și 4 octeți +.br +Valoarea minimă pentru \fInice\fP: 4 +.br +Utilizarea memoriei: +.br +\fIdict\fP * 7.5 (dacă \fIdict\fP <= 32 Mio); +.br +\fIdict\fP * 6.5 (dacă \fIdict\fP > 32 Mio) +.TP +\fBbt2\fP +Arbore binar cu suma de control de 2 octeți +.br +Valoarea minimă pentru \fInice\fP: 2 +.br +Utilizarea memoriei: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Arbore binar cu suma de control de 2 și 3 octeți +.br +Valoarea minimă pentru \fInice\fP: 3 +.br +Utilizarea memoriei: +.br +\fIdict\fP * 11.5 (dacă \fIdict\fP <= 16 Mio); +.br +\fIdict\fP * 9.5 + 64 MiB (dacă \fIdict\fP > 16 Mio) +.TP +\fBbt4\fP +Arbore binar cu suma de control de 2, 3 și 4 octeți +.br +Valoarea minimă pentru \fInice\fP: 4 +.br +Utilizarea memoriei: +.br +\fIdict\fP * 11.5 (dacă \fIdict\fP <= 32 Mio); +.br +\fIdict\fP * 10.5 (dacă \fIdict\fP > 32 Mio) +.RE +.TP +\fBmode=\fP\fImod\fP +Comprimarea \fImod\fP specifică metoda de analiză a datelor produse de +găsitorul de potriviri. \fIModurile\fP acceptate sunt \fBfast\fP(rapid) și +\fBnormal\fP. Valoarea implicită este \fBfast\fP pentru \fIprestabiliri\fP 0\(en3 și +\fBnormal\fP pentru \fIprestabiliri\fP 4\(en9. +.IP "" +De obicei, \fBfast\fP este folosit cu instrumentele de căutare de potriviri ale +lanțului de sume de control, și \fBnormal\fP cu instrumentele de căutare de +potriviri din arborele binar. Aceasta este și ceea ce fac \fIprestabiririle\fP. +.TP +\fBnice=\fP\fInice\fP +Specifică ceea ce este considerat a fi o lungime bună(nice) pentru o +potrivire. Odată ce este găsită o potrivire de cel puțin \fInice\fP octeți, +algoritmul nu mai caută după potriviri posibile mai bune. +.IP "" +\fINice\fP poate fi de 2\(en273 octeți. Valorile mai mari tind să ofere un +raport de comprimare mai bun în detrimentul vitezei. Valoarea implicită +depinde de \fIprestabilit\fP. +.TP +\fBdepth=\fP\fIadâncimea\fP +Specifică adâncimea maximă de căutare în găsitorul de potriviri. Valoarea +implicită este valoarea specială de 0, ceea ce face ca instrumentul de +comprimare să determine o \fIadâncime\fP rezonabilă pornind de la valorile +\fImf\fP și \fInice\fP. +.IP "" +\fIAdâncimea\fP rezonabilă pentru lanțuri de sumă de control este 4\(en100 și +16\(en1000 pentru arbori binari. Folosirea unor valori foarte mari pentru +\fIadâncime\fP poate face codificatorul extrem de lent cu unele +fișiere. Evitați să stabiliți \fIadâncimea\fP la valori peste 1000, cu excepția +cazului în care sunteți pregătit să întrerupeți comprimarea în cazul în care +durează prea mult. +.RE +.IP "" +La decodificarea fluxurilor brute (\fB\-\-format=raw\fP), LZMA2 are nevoie doar +de \fIdimensiunea\fP dicționarului. LZMA1 are nevoie de asemenea de \fIlc\fP, +\fIlp\fP și \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIopțiuni\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIopțiuni\fP] +.PD +Adaugă un filtru de ramură/apel/salt (branch/call/jump ⟶ „BCJ”) la lanțul de +filtre. Aceste filtre pot fi utilizate numai ca un filtru care nu este +ultimul din lanțul de filtrare. +.IP "" +Un filtru BCJ convertește adresele relative din codul mașinii în omoloagele +lor absolute. Acest lucru nu modifică dimensiunea datelor, dar crește +redundanța, ceea ce poate ajuta LZMA2 să producă fișier \fB.xz\fP cu 0\(en15\ % +mai mic. Filtrele BCJ sunt întotdeauna reversibile, deci folosind un filtru +BCJ pentru tipul greșit de date nu provoacă nicio pierdere de date, deși +poate înrăutăți puțin raportul de comprimare. Filtrele BCJ sunt foarte +rapide și folosesc o cantitate nesemnificativă de memorie. +.IP "" +Aceste filtre BCJ au probleme cunoscute legate de raportul de comprimare: +.RS +.IP \(bu 3 +Unele tipuri de fișiere care conțin cod executabil (de exemplu, fișiere +obiect, biblioteci statice și module de kernel Linux) au adresele din +instrucțiuni completate cu valori de umplere. Aceste filtre BCJ vor face în +continuare conversia adresei, ceea ce va înrăutăți comprimarea cu aceste +fișiere. +.IP \(bu 3 +Dacă pe o arhivă este aplicat un filtru BCJ, este posibil ca raportul de +comprimare să fie mai rău decât la neutilizarea unui filtru BCJ. De exemplu, +dacă există executabile similare sau chiar identice, filtrarea va face +probabil fișierele mai puțin asemănătoare și astfel comprimarea este mai +proastă. Conținutul fișierelor neexecutabile din aceeași arhivă poate conta +și el. În practică, trebuie să încercați cu și fără filtru BCJ pentru a +vedea care rezultat este mai bun în fiecare situație. +.RE +.IP "" +Seturi de instrucțiuni diferite au o aliniere diferită: fișierul executabil +trebuie aliniat la un multiplu al acestei valori în datele de intrare pentru +ca filtrul să funcționeze. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filtru;Aliniere;Note +x86;1;x86 pe 32 de biți +;;sau 64 de biți +ARM;4; +ARM\-Thumb;2; +ARM64;4;alinierea pe 4096\-octeți +;;este cea mai bună +PowerPC;4;Doar big endian +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Deoarece datele filtrate prin BCJ sunt de obicei comprimate cu LZMA2, +raportul de comprimare poate fi ușor îmbunătățit dacă opțiunile LZMA2 sunt +definite pentru a se potrivi cu alinierea filtrului BCJ selectat. Exemple: +.RS +.IP \(bu 3 +Filtrul IA\-64 are o aliniere de 16 octeți, astfel încât \fBpb=4,lp=4,lc=0\fP +este alegere adecvată cu LZMA2 (2^4=16). +.IP \(bu 3 +Codul RISC\-V are o aliniere pe 2 sau 4 octeți, depinzând de faptul că +fișierul conține instrucțiuni comprimate pe 16 biți (extensia C) sau +nu. Atunci când se utilizează instrucțiuni pe 16 biți, \fBpb=2,lp=1,lc=3\fP sau +\fBpb=1,lp=1,lc=3\fP este o alegere bună. Atunci când nu sunt prezente +instrucțiuni pe 16 biți, \fBpb=2,lp=2,lc=2\fP este cea mai bună +alegere. \fBreadelf \-h\fP poate fi utilizată pentru a verifica dacă „RVC” apare +în linia „Indicatori". +.IP \(bu 3 +ARM64 este întotdeauna aliniat pe 4 octeți, astfel încât \fBpb=2,lp=2,lc=2\fP +este cea mai bună alegere. +.IP \(bu 3 +Filtrul x86 este o excepție. De obicei, este bine să rămâneți la valorile +implicite ale LZMA2 (\fBpb=2,lp=0,lc=3\fP) atunci când comprimați executabile +x86. +.RE +.IP "" +Toate filtrele BCJ acceptă același \fIopțiuni\fP: +.RS +.TP +\fBstart=\fP\fIpoziție\fP +Specifică \fIpoziția\fP de pornire care este utilizată la conversia între +adresele relative și absolute. \fIPoziția\fP trebuie să fie un multiplu al +alinierii filtrului (consultați tabelul de mai sus). Valoarea implicită +este zero. În practică, valoarea implicită este bună; specificarea unei +\fIpoziții\fP personalizate nu este aproape niciodată utilă. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIopțiuni\fP] +Adaugă filtrul Delta în lanțul de filtrare. Filtrul Delta poate fi folosit +doar ca un filtru care nu este ultimul în lanțul de filtrare. +.IP "" +În prezent, este acceptat doar calculul delta simplu de octeți. Poate fi +util la comprimarea, de exemplu, a imaginilor bitmap necomprimate sau a +sunetului PCM necomprimat. Cu toate acestea, algoritmii cu scop special pot +da rezultate semnificativ mai bune decât Delta + LZMA2. Acest lucru este +valabil mai ales în cazul audio, care se comprimă mai repede și mai bine, de +exemplu, cu \fBflac\fP(1). +.IP "" +\fIOpțiuni\fP acceptate: +.RS +.TP +\fBdist=\fP\fIdistanța\fP +Specifică \fIdistanța\fP calculului delta în octeți. \fIDistanța\fP trebuie să fie +1\(en256. Valoarea implicită este 1. +.IP "" +De exemplu, cu \fBdist=2\fP și intrare de opt octeți: A1 B1 A2 B3 A3 B5 A4 B7, +ieșirea va fi: A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Alte opțiuni" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Suprimă avertismentele și notificările. Specificați acest lucru de două ori +pentru a suprima și erorile. Această opțiune nu are niciun efect asupra +stării de ieșire. Adică, chiar dacă o avertizare a fost suprimată, starea de +ieșire pentru a indica o avertizare este încă utilizată. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Oferă informații detaliate. Dacă ieșirea de eroare standard este conectată +la un terminal, \fBxz\fP va afișa un indicator de progres. Specificarea +opțiunii \fB\-\-verbose\fP de două ori, va avea ca rezultat oferirea de +informații și mai detaliate. +.IP "" +Indicatorul de progres afișează următoarele informații: +.RS +.IP \(bu 3 +Procentul de completare este afișat dacă se cunoaște dimensiunea fișierului +de intrare. Adică, procentul nu poate fi afișat la procesarea fișierului +prin conducte(pipe). +.IP \(bu 3 +Cantitatea de date comprimate produse (comprimare) sau consumate +(decomprimare). +.IP \(bu 3 +Cantitatea de date necomprimate consumate (comprimare) sau produse +(decomprimare). +.IP \(bu 3 +Raportul de comprimare, care se calculează împărțind cantitatea de date +comprimate procesate până acum la cantitatea de date necomprimate procesate +până acum. +.IP \(bu 3 +Viteza de comprimare sau decomprimare. Aceasta este măsurată drept +cantitatea de date necomprimate consumate (comprimare) sau produse +(decomprimare) pe secundă. Este afișată după ce au trecut câteva secunde de +când \fBxz\fP a început procesarea fișierului. +.IP \(bu 3 +Timpul scurs în format M:SS sau H:MM:SS. +.IP \(bu 3 +Timpul rămas estimat este afișat numai atunci când dimensiunea fișierului de +intrare este cunoscută și au trecut deja câteva secunde de când \fBxz\fP a +început procesarea fișierului. Ora este afișată într\-un format mai puțin +precis, care nu are niciodată două puncte, de exemplu, 2 min 30 s. +.RE +.IP "" +Când ieșirea de eroare standard nu este un terminal, \fB\-\-verbose\fP va face +\fBxz\fP să imprime numele fișierului, dimensiunea comprimată, dimensiunea +necomprimată, raportul de comprimare și, eventual, de asemenea, viteza și +timpul scurs pe o singură linie la ieșirea de eroare standard după +comprimarea sau decomprimarea fișierului. Viteza și timpul scurs sunt +incluse numai atunci când operațiunea a durat cel puțin câteva secunde. Dacă +operațiunea nu s\-a încheiat, de exemplu, din cauza întreruperii din partea +utilizatorului, se imprimă și procentul de completare dacă se cunoaște +dimensiunea fișierului de intrare. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Nu comută starea de ieșire la 2 chiar dacă a fost detectată o condiție care +merită avertizată. Această opțiune nu afectează nivelul de detaliere al +informațiilor, astfel încât atât \fB\-\-quiet\fP cât și \fB\-\-no\-warn\fP trebuie +folosite pentru a nu afișa avertismente și pentru a nu modifica starea de +ieșire. +.TP +\fB\-\-robot\fP +Afișează mesajele într\-un format care poate fi analizat de mașină. Acest +lucru are scopul de a ușura scrierea interfețelor în care se dorește să se +folosească \fBxz\fP în loc de liblzma, ceea ce poate fi cazul cu diferite +scripturi. Ieșirea cu această opțiune activată este menită să fie stabilă în +toate versiunile \fBxz\fP. Consultați secțiunea \fBMOD ROBOT\fP pentru detalii. +.TP +\fB\-\-info\-memory\fP +Afișează, într\-un format care poate fi citit de om, câtă memorie fizică +(RAM) și câte fire de execuție de procesor \fBxz\fP crede că are sistemul și +limitele de utilizare a memoriei pentru comprimare și decomprimare și iese +cu succes. +.TP +\fB\-h\fP, \fB\-\-help\fP +Afișează un mesaj de ajutor care descrie opțiunile cele mai frecvent +utilizate și iese cu succes. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Afișează un mesaj de ajutor care descrie toate caracteristicile \fBxz\fP și +iese cu succes +.TP +\fB\-V\fP, \fB\-\-version\fP +Afișează numărul versiunii \fBxz\fP și liblzma într\-un format care poate fi +citit de om. Pentru a obține rezultate analizabile de mașină, specificați +\fB\-\-robot\fP înainte de \fB\-\-version\fP. +. +.SH "MOD ROBOT" +Modul robot este activat cu opțiunea \fB\-\-robot\fP. Face ieșirea lui \fBxz\fP mai +ușor de analizat de către alte programe. În prezent, opțiunea \fB\-\-robot\fP +este acceptată numai împreună cu opțiunile \fB\-\-list\fP, \fB\-\-filters\-help\fP, +\fB\-\-info\-memory\fP, și \fB\-\-version\fP. Va fi acceptată pentru comprimare și +decomprimare în viitor. +. +.SS "Modul listă" +\fBxz \-\-robot \-\-list\fP utilizează o ieșire separată de tabulatori. Prima +coloană a fiecărei linii are un șir care indică tipul de informații găsite +pe acea linie: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Aceasta este întotdeauna prima linie când începe să se listeze un fișier. A +doua coloană de pe linie este numele fișierului. +.TP +\fBfile\fP +Această linie conține informații generale despre fișierul \fB.xz\fP. Această +linie este întotdeauna tipărită după linia \fBname\fP. +.TP +\fBstream\fP +Acest tip de linie este utilizat numai atunci când a fost specificată +opțiunea \fB\-\-verbose\fP. Există tot atâtea linii \fBstream\fP câte fluxuri există +în fișierul \fB.xz\fP. +.TP +\fBblock\fP +Acest tip de linie este utilizat numai atunci când a fost specificată +opțiunea \fB\-\-verbose\fP. Există tot atâtea linii \fBblock\fP câte blocuri există +în fișierul \fB.xz\fP. Liniile \fBblock\fP sunt afișate după toate liniile +\fBstream\fP; tipurile diferite de linii nu sunt intercalate. +.TP +\fBsummary\fP +Acest tip de linie este folosit numai atunci când opțiunea \fB\-\-verbose\fP a +fost specificată de două ori. Această linie este afișată după toate liniile +\fBblock\fP. Ca și linia \fBfile\fP, linia \fBsummary\fP conține informații generale +despre fișierul \fB.xz\fP. +.TP +\fBtotals\fP +Această linie este întotdeauna ultima linie din lista afișată la +ieșire. Aceasta arată numărul total și dimensiunile. +.PP +Coloanele din liniile \fBfile\fP: +.PD 0 +.RS +.IP 2. 4 +Numărul de fluxuri din fișier +.IP 3. 4 +Numărul total de blocuri din fluxuri +.IP 4. 4 +Dimensiunea comprimată a fișierului +.IP 5. 4 +Dimensiunea necomprimată a fișierului +.IP 6. 4 +Raportul de comprimare, de exemplu, \fB0,123\fP. Dacă raportul este peste +9,999, în locul raportului sunt afișate trei liniuțe (\fB\-\-\-\fP). +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Lista de nume de verificare a integrității, separate prin +virgule. Următoarele șiruri sunt utilizate pentru tipurile de verificare +cunoscute: \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP și \fBSHA\-256\fP. Pentru tipurile de +verificări necunoscute, se utilizează \fBUnknown\-\fP\fIN\fP, unde \fIN\fP este ID\-ul +de verificare ca număr zecimal (una sau două cifre). +.IP 8. 4 +Dimensiunea totală a umpluturii fluxului din fișier +.RE +.PD +.PP +Coloanele din liniile \fBstream\fP: +.PD 0 +.RS +.IP 2. 4 +Numărul fluxului (primul flux este 1) +.IP 3. 4 +Numărul de blocuri din flux +.IP 4. 4 +Poziția de pornire a comprimării +.IP 5. 4 +Poziția de pornire a decomprimării +.IP 6. 4 +Dimensiune comprimată (nu include umplutura fluxului) +.IP 7. 4 +Dimensiune necomprimată +.IP 8. 4 +Raport de comprimare +.IP 9. 4 +Numele verificării de integritate +.IP 10. 4 +Dimensiunea umpluturii fluxului +.RE +.PD +.PP +Coloanele din liniile \fBblock\fP: +.PD 0 +.RS +.IP 2. 4 +Numărul fluxului care conține acest bloc +.IP 3. 4 +Numărul blocului în raport cu începutul fluxului (primul bloc este 1) +.IP 4. 4 +Numărul blocului în raport cu începutul fișierului +.IP 5. 4 +Poziția de pornire a comprimării în raport cu începutul fișierului +.IP 6. 4 +Poziția de pornire necomprimată în raport cu începutul fișierului +.IP 7. 4 +Dimensiunea totală comprimată a blocului (include antetele) +.IP 8. 4 +Dimensiune necomprimată +.IP 9. 4 +Raport de comprimare +.IP 10. 4 +Numele verificării de integritate +.RE +.PD +.PP +Dacă opțiunea \fB\-\-verbose\fP a fost specificată de două ori, coloane +suplimentare sunt incluse pe liniile \fBblock\fP. Acestea nu sunt afișate cu o +singură specificare a opțiunii \fB\-\-verbose\fP, deoarece obținerea acestor +informații necesită multe căutări și, prin urmare, poate fi lentă: +.PD 0 +.RS +.IP 11. 4 +Valoarea verificării integrității în hexazecimal +.IP 12. 4 +Dimensiunea antetului blocului +.IP 13. 4 +Indicatori de bloc: \fBc\fP indică faptul că este prezentă dimensiunea +comprimată, iar \fBu\fP indică faptul că este prezentă dimensiunea +necomprimată. Dacă indicatorul nu este determinat, este afișată o liniuță +(\fB\-\fP) pentru a menține lungimea șirului fixă. Pot fi adăugate noi +indicatoare la sfârșitul șirului, în viitor. +.IP 14. 4 +Dimensiunea datelor comprimate reale din bloc (acest lucru exclude antetul +blocului, umplutura blocului și câmpurile de verificare) +.IP 15. 4 +Cantitatea de memorie (în octeți) necesară pentru a decomprima acest bloc cu +această versiune \fBxz\fP +.IP 16. 4 +Lanț de filtrare. Rețineți că majoritatea opțiunilor utilizate în timpul +comprimării nu pot fi cunoscute, deoarece doar opțiunile necesare pentru +decomprimare sunt stocate în anteturile \fB.xz\fP. +.RE +.PD +.PP +Coloanele din liniile \fBsummary\fP: +.PD 0 +.RS +.IP 2. 4 +Cantitatea de memorie (în octeți) necesară pentru a decomprima acest fișier +cu această versiune \fBxz\fP +.IP 3. 4 +\fByes\fP sau \fBno\fP indicând dacă toate antetele blocurilor au atât dimensiunea +comprimată, cât și dimensiunea necomprimată stocate în ele +.PP +\fIÎncepând cu\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Versiunea \fBxz\fP minimă necesară pentru a decomprima fișierul +.RE +.PD +.PP +Coloanele din linia \fBtotals\fP: +.PD 0 +.RS +.IP 2. 4 +Numărul de fluxuri +.IP 3. 4 +Numărul de blocuri +.IP 4. 4 +Dimensiunea comprimată +.IP 5. 4 +Dimensiune necomprimată +.IP 6. 4 +Raportul mediu de comprimare +.IP 7. 4 +Lista de nume de verificare a integrității, separate prin virgule, care au +fost prezente în fișiere +.IP 8. 4 +Dimensiunea umpluturii fluxului +.IP 9. 4 +Numărul de fișiere. Aceasta este aici pentru a păstra ordinea coloanelor +anterioare la fel ca pe liniile \fBfile\fP. +.PD +.RE +.PP +Dacă opțiunea \fB\-\-verbose\fP a fost specificată de două ori, pe linia +\fBtotals\fP sunt incluse coloane suplimentare: +.PD 0 +.RS +.IP 10. 4 +Cantitatea maximă de memorie (în octeți) necesară pentru a decomprima +fișierele cu această versiune \fBxz\fP +.IP 11. 4 +\fByes\fP sau \fBno\fP indicând dacă toate antetele blocurilor au atât dimensiunea +comprimată, cât și dimensiunea necomprimată stocate în ele +.PP +\fIÎncepând cu\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Versiunea \fBxz\fP minimă necesară pentru a decomprima fișierul +.RE +.PD +.PP +Versiunile viitoare pot adăuga noi tipuri de linii și pot fi adăugate +coloane noi la tipurile de linii existente, dar coloanele existente nu vor +fi modificate. +. +.SS "Ajutor pentru filtrare" +\fBxz \-\-robot \-\-filters\-help\fP afișează filtrele acceptate în următorul +format: +.PP +\fIfiltru\fP\fB:\fP\fIopțiune\fP\fB=<\fP\fIvaloare\fP\fB>,\fP\fIopțiune\fP\fB=<\fP\fIvaloare\fP\fB>\fP... +.TP +\fBfiltru\fP +Numele filtrului +.TP +\fIopțiune\fP +Numele unei opțiuni specifice unui filtru +.TP +\fIvaloare\fP +Intervalele numerice \fIvaloare\fP apar ca +\fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. Alegerile \fIvaloare\fP de tip șir de +caractere sunt afișate în cadrul \fB< >\fP și separate de un caracter +\fB|\fP. +.PP +Fiecare filtru este afișat pe propria linie. +. +.SS "Informații privind limita memoriei" +\fBxz \-\-robot \-\-info\-memory\fP afișează o singură linie cu multiple coloane +separate prin tabulatoare: +.IP 1. 4 +Cantitatea totală de memorie fizică (RAM) în octeți. +.IP 2. 4 +Limita de utilizare a memoriei pentru comprimare în octeți +(\fB\-\-memlimit\-compress\fP). O valoare specială de \fB0\fP indică configurarea +implicită, care pentru modul cu un singur fir este la fel ca fără limită. +.IP 3. 4 +Limita de utilizare a memoriei pentru decomprimare în octeți +(\fB\-\-memlimit\-decompress\fP). O valoare specială de \fB0\fP indică configurarea +implicită, care pentru modul cu un singur fir este la fel ca fără limită. +.IP 4. 4 +Începând cu \fBxz\fP 5.3.4alpha: Utilizarea memoriei pentru decomprimarea cu +mai multe fire în octeți (\fB\-\-memlimit\-mt\-decompress\fP). Acesta nu este +niciodată zero, deoarece o valoare implicită specifică sistemului afișată în +coloana 5 este utilizată dacă nu a fost specificată în mod explicit nicio +limită. De asemenea, aceasta nu este niciodată mai mare decât valoarea din +coloana 3, chiar dacă a fost specificată o valoare mai mare cu +\fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Începând cu \fBxz\fP 5.3.4alpha: o limită implicită de utilizare a memoriei +specifică sistemului, care este utilizată pentru a limita numărul de fire de +execuție atunci când se comprimă cu un număr automat de fire de execuție +(\fB\-\-threads=0\fP) și nicio limită de utilizare a memoriei nu fost specificată +cu (\fB\-\-memlimit\-compress\fP). Aceasta este, de asemenea, utilizată ca valoare +implicită pentru \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Începând cu \fBxz\fP 5.3.4alpha: numărul de fire de execuție de procesor +disponibile. +.PP +În viitor, rezultatul \fBxz \-\-robot \-\-info\-memory\fP poate avea mai multe +coloane, dar niciodată mai mult de o singură linie. +. +.SS Versiunea +\fBxz \-\-robot \-\-version\fP va afișa numărul versiunii \fBxz\fP și liblzma în +următorul format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Versiunea majoră. +.TP +\fIYYY\fP +Versiunea minoră. Numerele pare sunt prezente în versiunile +stabile. Numerele impare sunt prezente în versiunile alfa sau beta. +.TP +\fIZZZ\fP +Nivelul de plasture(patch) pentru versiunile stabile sau doar un contor +pentru versiunile de dezvoltare. +.TP +\fIS\fP +Stabilitate. 0 este alfa, 1 este beta și 2 este stabil. \fIS\fP trebuie să fie +întotdeauna 2 atunci când \fIAAA\fP este par. +.PP +\fIXYYYZZZS\fP sunt aceleași pe ambele linii dacă \fBxz\fP și liblzma sunt din +aceeași versiune XZ Utils. +.PP +Exemple: 4.999.9beta este \fB49990091\fP și 5.0.0 este \fB50000002\fP. +. +.SH "STARE DE IEȘIRE" +.TP +\fB0\fP +Totul este bine. +.TP +\fB1\fP +A apărut o eroare. +.TP +\fB2\fP +A apărut ceva care merită să fie avertizat, dar nu au apărut erori reale. +.PP +Notificările (nu avertismentele sau erorile) afișate la ieșirea de eroare +standard nu afectează starea de ieșire. +. +.SH "VARIABILE DE MEDIU" +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP analizează liste de opțiuni separate prin spații din variabilele de +mediu \fBXZ_DEFAULTS\fP și \fBXZ_OPT\fP, în această ordine, înainte de a analiza +opțiunile din linia de comandă. Rețineți că numai opțiunile sunt analizate +din variabilele de mediu; toate non\-opțiunile sunt ignorate în +tăcere. Analiza se face cu funcția \fBgetopt_long\fP(3) care este folosită și +pentru argumentele liniei de comandă. +.PP +\fBAvertisment:\fP Prin definirea acestor variabile de mediu, se modifică +efectiv programele și scripturile care rulează \fBxz\fP. De cele mai multe ori +este sigur să se definească limitele de utilizare a memoriei, numărul de +fire și opțiunile de comprimare prin intermediul variabilelor de mediu. Cu +toate acestea, unele opțiuni pot întrerupe scripturile. Un exemplu evident +este \fB\-\-help\fP care face ca \fBxz\fP să afișeze textul de ajutor în loc să +comprime sau să decomprime un fișier. Exemple mai subtile sunt \fB\-\-quiet\fP și +\fB\-\-verbose\fP. În multe cazuri funcționează bine activarea indicatorului de +progres folosind \fB\-\-verbose\fP, dar în unele situații mesajele suplimentare +creează probleme. Nivelul de detaliere al mesajelor afectează, de asemenea, +comportamentul lui \fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Opțiuni implicite specifice utilizatorului sau la nivelul întregului +sistem. De obicei, acest lucru este specificat într\-un script de +inițializare shell pentru a activa limitatorul de utilizare a memoriei lui +\fBxz\fP implicit sau pentru a stabili numărul implicit de fire. Excluzând +scripturile de inițializare shell și cazurile speciale similare, scripturile +nu trebuie niciodată să modifice sau să dezactiveze \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Acest lucru este pentru transmiterea opțiunilor către \fBxz\fP atunci când nu +este posibil să definiți opțiunile direct în linia de comandă a +\fBxz\fP. Acesta este cazul când \fBxz\fP este rulat de un script sau de un +instrument, de exemplu, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Scripturile pot folosi \fBXZ_OPT\fP, de exemplu, pentru a configura opțiunile +implicite de comprimare specifice scriptului. Se recomandă totuși să se +permită utilizatorilor să înlocuiască \fBXZ_OPT\fP dacă acest lucru este +rezonabil. De exemplu, în scripturile \fBsh\fP(1) se poate folosi ceva de genul +acesta: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "COMPATIBILITATE CU LZMA\-UTILS" +Sintaxa liniei de comandă a lui \fBxz\fP este practic o super\-colecție de +\fBlzma\fP, \fBunlzma\fP și \fBlzcat\fP așa cum se găsește în LZMA Utils 4.32.x. În +cele mai multe cazuri, este posibil să înlocuiți LZMA Utils cu XZ Utils fără +a întrerupe scripturile existente. Există totuși unele incompatibilități, +care uneori pot cauza probleme. +. +.SS "Niveluri de comprimare prestabilite" +Numerotarea nivelurilor de comprimare prestabilite nu este identică în \fBxz\fP +și LZMA Utils. Cea mai importantă diferență este modul în care dimensiunile +dicționarului sunt atribuite diferitelor niveluri prestabilite. Dimensiunea +dicționarului este aproximativ egală cu memoria utilizată la decomprimare. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nivel;xz;LZMA Utils +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Diferențele de dimensiune a dicționarului afectează deasemenea cantitatea de +memorie utilizată la comprimare dar există și alte diferențe între LZMA +Utils și XZ Utils, care fac diferența și mai mare: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nivel;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Nivelul prestabilit implicit în LZMA Utils este \fB\-7\fP, în timp ce în XZ +Utils este \fB\-6\fP, deci ambele folosesc un dicționar de 8Mio în mod implicit. +. +.SS "Fișiere .lzma transmise în flux vs. netransmise în flux" +Dimensiunea necomprimată a fișierului poate fi stocată în antetul +\&\fB.lzma\fP. LZMA Utils face asta atunci când comprimă fișiere +obișnuite. Alternativa este să marcați că dimensiunea necomprimată este +necunoscută și să folosiți marcajul de sfârșit de încărcare pentru a indica +unde ar trebui să se oprească decomprimarea. LZMA Utils folosește această +metodă atunci când dimensiunea necomprimată nu este cunoscută, ceea ce este +cazul, de exemplu, când se folosesc conducte. +.PP +\fBxz\fP acceptă decomprimarea fișierelor \fB.lzma\fP cu sau fără marcaj de +sfârșit de încărcare, dar toate fișierele \fB.lzma\fP create de \fBxz\fP vor +folosi marcajul de sfârșit de încărcare și vor avea dimensiunea necomprimată +marcată ca necunoscută în antetul \fB.lzma\fP. Aceasta poate fi o problemă în +unele situații mai puțin frecvente. De exemplu, un instrument de +decomprimare \fB.lzma\fP încorporat într\-un dispozitiv poate funcționa numai cu +fișiere care au dimensiunea necomprimată cunoscută. Dacă întâmpinați această +problemă, trebuie să utilizați LZMA Utils sau LZMA SDK pentru a crea fișiere +\&\fB.lzma\fP cu dimensiunea necomprimată cunoscută. +. +.SS "Fișiere .lzma neacceptate" +Formatul \fB.lzma\fP permite valori \fIlc\fP de până la 8 și valori \fIlp\fP de până +la 4. LZMA Utils poate decomprima fișiere cu orice \fIlc\fP și \fIlp\fP, dar +creează întotdeauna fișiere cu \fBlc=3\fP și \fBlp=0\fP. Crearea de fișiere cu +alte \fIlc\fP și \fIlp\fP este posibilă cu \fBxz\fP și cu LZMA SDK. +.PP +Implementarea filtrului LZMA1 în liblzma necesită ca suma \fIlc\fP și \fIlp\fP să +nu depășească 4. Altfel, fișierele \fB.lzma\fP, care depășesc această limitare, +nu pot fi decomprimate cu \fBxz\fP. +.PP +LZMA Utils creează numai fișiere \fB.lzma\fP care au o dimensiune de dicționar +de 2^\fIn\fP (o putere de 2), dar acceptă fișiere cu orice dimensiune de +dicționar. liblzma acceptă numai fișierele \fB.lzma\fP care au dimensiunea de +dicționar de 2^\fIn\fP sau 2^\fIn\fP + 2^(\fIn\fP\-1). Acest lucru este pentru a +reduce numărul de „fals pozitiv” atunci când se detectează fișiere \fB.lzma\fP. +.PP +Aceste limitări nu ar trebui să fie o problemă în practică, deoarece practic +toate fișierele \fB.lzma\fP au fost comprimate cu opțiuni pe care liblzma le va +accepta. +. +.SS "Resturi rămase" +Când decomprimă, LZMA Utils ignoră în tăcere totul după primul flux +\&\fB.lzma\fP. În majoritatea situațiilor, aceasta este o eroare. Aceasta +înseamnă, de asemenea, că LZMA Utils nu acceptă decomprimarea fișierelor +\&\fB.lzma\fP concatenate. +.PP +Dacă au rămas date după primul flux \fB.lzma\fP, \fBxz\fP consideră că fișierul +este corupt, cu excepția cazului în care a fost utilizată opțiunea +\fB\-\-single\-stream\fP. Acest lucru poate rupe scripturile obscure(scrise +deficitar) care presupun că resturile rămase sunt ignorate. +. +.SH NOTE +. +.SS "Rezultatul comprimării poate varia" +Ieșirea exactă comprimată produsă din același fișier de intrare necomprimat +poate varia între versiunile XZ Utils, chiar dacă opțiunile de comprimare +sunt identice. Acest lucru se datorează faptului că instrumentul codificator +poate fi îmbunătățit (comprimare mai rapidă sau mai bună) fără a afecta +formatul fișierului. Ieșirea poate varia chiar și între compilările diferite +ale aceleiași versiuni XZ Utils, dacă sunt utilizate opțiuni diferite de +compilare. +.PP +Cele de mai sus înseamnă că odată ce opțiunea \fB\-\-rsyncable\fP a fost +utilizată, fișierele rezultate nu vor fi neapărat sincronizate cu rsync +decât dacă atât fișierele vechi, cât și cele noi au fost comprimate cu +aceeași versiune xz. Această problemă poate fi remediată dacă o parte a +implementării codificatorului este înghețată pentru a menține stabilă +ieșirea „rsyncabilă” între versiunile xz. +. +.SS "Instrumente de decomprimare .xz încorporate" +Implementările instrumentului de decomprimare \fB.xz\fP încorporat, cum ar fi +XZ Embedded, nu acceptă neapărat fișiere create cu tipuri de \fIverificare\fP a +integrității, altele decât \fBnone\fP și \fBcrc32\fP. Deoarece valoarea implicită +este \fB\-\-check=crc64\fP, trebuie să utilizați \fB\-\-check=none\fP sau +\fB\-\-check=crc32\fP atunci când creați fișiere pentru sistemele încorporate. +.PP +În afara sistemelor încorporate, toate instrumentele de decomprimare în +format \fB.xz\fP acceptă toate tipurile de \fIverificare\fP sau cel puțin pot +decomprima fișierul fără a efectua verificarea integrității dacă acel tip de +\fIverificare\fP nu este acceptat. +.PP +XZ Embedded acceptă filtre BCJ, dar numai cu poziție de pornire implicită. +. +.SH EXEMPLE +. +.SS Bazice +Comprimă fișierul \fIfoo\fP în \fIfoo.xz\fP folosind nivelul de comprimare +implicit (\fB\-6\fP) și elimină fișierul \fIfoo\fP dacă comprimarea are succes: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Decomprimă \fIbar.xz\fP în \fIbar\fP și nu elimină \fIbar.xz\fP chiar dacă +decomprimarea este efectuată cu succes: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Creează \fIbaz.tar.xz\fP cu nivelul prestabilit \fB\-4e\fP (\fB\-4 \-\-extreme\fP), care +este mai lent decât nivelul prestabilit implicit \fB\-6\fP, dar necesită mai +puțină memorie pentru comprimare și decomprimare (48Mio și, respectiv, +5Mio): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Un amestec de fișiere comprimate și necomprimate poate fi decomprimat la +ieșirea standard cu o singură comandă: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Comprimarea în paralel a mai multor fișiere" +În sisteme GNU și *BSD, \fBfind\fP(1) și \fBxargs\fP(1) pot fi utilizate pentru a +paraleliza comprimarea mai multor fișiere: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Opțiunea \fB\-P\fP pentru comanda \fBxargs\fP(1) stabilește numărul de procese +paralele \fBxz\fP. Cea mai bună valoare pentru opțiunea \fB\-n\fP depinde de câte +fișiere trebuie să fie comprimate. Dacă există doar câteva fișiere, valoarea +ar trebui probabil să fie 1; cu zeci de mii de fișiere, 100 sau chiar mai +mult poate să fie valoarea potrivită pentru a reduce numărul de procese +\fBxz\fP pe care \fBxargs\fP(1) le va crea în final. +.PP +Opțiunea \fB\-T1\fP pentru \fBxz\fP este acolo pentru a\-l forța să ruleze în modul +cu un singur fir de execuție, deoarece \fBxargs\fP(1) este folosit pentru a +controla cantitatea de paralelizare. +. +.SS "Modul robot" +Calculează câți octeți au fost salvați în total după comprimarea mai multor +fișiere: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Un script poate dori să afle dacă folosește o versiune \fBxz\fP suficient de +nouă. Următorul script \fBsh\fP(1) verifică dacă numărul versiunii +instrumentului \fBxz\fP este cel puțin 5.0.0. Această metodă este compatibilă +cu versiunile beta vechi, care nu acceptau opțiunea \fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Versiunea dumneavoastră de „xz” este prea veche!" +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Stabilește o limită de utilizare a memoriei pentru decomprimare folosind +variabila de mediu \fBXZ_OPT\fP, dar dacă o limită a fost deja stabilită, nu o +mărește: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Lanțuri de filtrare personalizate pentru instrumentul de comprimare" +Cea mai simplă utilizare a lanțurilor de filtrare personalizate este +personalizarea unei opțiuni prestabilite LZMA2. Acest lucru poate fi util, +deoarece opțiunile prestabilite acoperă doar un subset al combinațiilor +potențial utile de opțiuni de comprimare. +.PP +Coloanele CPUComp din tabelele de descriere a opțiunilor \fB\-0\fP ... \fB\-9\fP și +\fB\-\-extreme\fP sunt utile atunci când personalizați opțiunilor prestabilite +LZMA2. Iată părțile relevante colectate din aceste două tabele: +.RS +.PP +.TS +tab(;); +c c +n n. +ValPrestab;CPUComp +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Dacă știți că un fișier necesită un dicționar oarecum mare (de exemplu, +32Mio) pentru a se comprima bine, dar doriți să\-l comprimați mai repede +decât ar face \fBxz \-8\fP, o opțiune prestabilită cu o valoare CPUComp scăzută +(de exemplu, 1) poate fi modificată pentru a utiliza un dicționar mai mare: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Cu anumite fișiere, comanda de mai sus poate fi mai rapidă decât \fBxz \-6\fP în +timp ce comprimă semnificativ mai bine. Cu toate acestea, trebuie subliniat +că doar unele fișiere se beneficiază de un dicționar mare, păstrând în +același timp valoarea CPUComp scăzută. Cea mai evidentă situație, în care un +dicționar mare poate ajuta foarte mult, este o arhivă care conține fișiere +foarte asemănătoare de cel puțin câțiva megaocteți fiecare. Dimensiunea +dicționarului trebuie să fie semnificativ mai mare decât orice fișier +individual pentru a permite LZMA2 să profite din plin de asemănările dintre +fișierele consecutive. +.PP +Dacă utilizarea unei mari cantități de memorie pentru comprimare și +decomprimare este în regulă, iar fișierul comprimat are cel puțin câteva +sute de megaocteți, poate fi util să folosiți un dicționar și mai mare decât +cei 64Mio pe care i\-ar folosi \fBxz \-9\fP: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Utilizarea opțiunii \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) ca în exemplul de mai +sus, poate fi utilă pentru a vedea cerințele de memorie la comprimare și +decomprimare. Amintiți\-vă că utilizarea unui dicționar mai mare decât +dimensiunea fișierului necomprimat este risipă de memorie, de aceea, comanda +de mai sus nu este utilă pentru fișiere mici. +.PP +Uneori, timpul de comprimare nu contează, dar utilizarea memoriei la +decomprimare trebuie menținută la un nivel scăzut, de exemplu, pentru a face +posibilă decomprimarea fișierului pe un sistem încorporat. Următoarea +comandă folosește \fB\-6e\fP (\fB\-6 \-\-extreme\fP) ca bază și fixează dimensiunea +dicționarului la doar 64Kio. Fișierul rezultat poate fi decomprimat cu XZ +Embedded (de aceea există \fB\-\-check=crc32\fP) folosind aproximativ 100Kio de +memorie. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Dacă doriți să stoarceți cât mai mulți octeți posibil, ajustarea numărului +de biți de context literal (\fIlc\fP) și a numărului de biți de poziție (\fIpb\fP) +poate ajuta uneori. Ajustarea numărului de biți de poziție literală (\fIlp\fP) +ar putea ajuta, de asemenea, dar de obicei \fIlc\fP și \fIpb\fP sunt mai +importante. De exemplu, o arhivă de cod sursă conține în mare parte text +US\-ASCII, așa că ceva precum comanda următoare, ar putea oferi un fișier +„mai slăbuț” (aproximativ cu 0,1%) mai mic decât cu \fBxz \-6e\fP (încercați și +fără \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 fișierul_sursă.tar\fR +.fi +.RE +.PP +Utilizarea unui alt filtru împreună cu LZMA2 poate îmbunătăți comprimarea cu +anumite tipuri de fișiere. De exemplu, pentru a comprima o bibliotecă +partajată x86 pe 32 de biți sau x86 pe 64 de biți folosind filtrul BCJ x86: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Rețineți că ordinea opțiunilor de filtrare este semnificativă. Dacă \fB\-\-x86\fP +este specificată după \fB\-\-lzma2\fP, \fBxz\fP va da o eroare, deoarece nu poate +exista niciun filtru după LZMA2 și, de asemenea, pentru că filtrul x86 BCJ +nu poate fi utilizat ca ultimul filtru din lanțul de filtrare. +.PP +Filtrul Delta împreună cu LZMA2 pot da rezultate bune cu imagini bitmap. De +obicei, ar trebui să întreacă comprimarea PNG, care are câteva filtre mai +avansate decât delta simplă, dar utilizează Deflate pentru comprimarea +reală. +.PP +Imaginea trebuie să fie salvată în format necomprimat, de exemplu, ca TIFF +necomprimat. Parametrul de distanță al filtrului Delta este fixat să se +potrivească cu numărul de octeți per pixel din imagine. De exemplu, +bitmap\-ul RGB pe 24 de biți necesită \fBdist=3\fP și este, de asemenea, bine să +pasați \fBpb=0\fP la LZMA2 pentru a se adapta alinierii pe trei octeți: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Dacă mai multe imagini au fost introduse într\-o singură arhivă (de exemplu, +\&\fB.tar\fP), filtrul Delta va funcționa și pe aceasta atâta timp cât toate +imaginile au același număr de octeți per pixel. +. +.SH "CONSULTAȚI ȘI" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xz.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xz.1 new file mode 100644 index 0000000000000000000000000000000000000000..1555445592944b4f24e548fc0dc0b1c3af876030 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xz.1 @@ -0,0 +1,2111 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Romanian translation for xz-man. +.\" Mesajele în limba română pentru manualul pachetului XZ Utils. +.\" Remus-Gabriel Chelu , 2022 - 2025. +.\" Cronologia traducerii fișierului „xz-man”: +.\" Traducerea inițială, făcută de R-GC, pentru versiunea xz-man 5.4.0-pre1. +.\" Actualizare a traducerii pentru versiunea 5.4.0-pre2, făcută de R-GC, dec-2022. +.\" Actualizare a traducerii pentru versiunea 5.4.3, făcută de R-GC, mai-2023. +.\" Actualizare a traducerii pentru versiunea 5.4.4-pre1, făcută de R-GC, iul-2023. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre1, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre2, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.7.1-dev1, făcută de R-GC, ian-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.0-pre1, făcută de R-GC, mar-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.2-pre1, făcută de R-GC, oct-2025. +.\" Actualizare a traducerii pentru versiunea Y, făcută de X, Z(luna-anul). +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 "8 martie 2025" Tukaani "Utilități XZ" +. +.SH NUME +xz, unxz, xzcat, lzma, unlzma, lzcat \- Comprimă sau decomprimă fișiere .xz +și .lzma +. +.SH REZUMAT +\fBxz\fP [\fIopțiune...\fP] [\fIfișier...\fP] +. +.SH "ALIAS COMENZI" +\fBunxz\fP este echivalent cu \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP este echivalent cu \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP este echivalent cu \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP este echivalent cu \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP este echivalent cu \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Când scrieți scripturi care trebuie să decomprime fișiere, este recomandat +să folosiți întotdeauna comanda \fBxz\fP cu argumentele adecvate (\fBxz \-d\fP sau +\fBxz \-dc\fP) în loc de comenzile \fBunxz\fP și \fBxzcat\fP. +. +.SH DESCRIERE +\fBxz\fP este un instrument de comprimare a datelor de uz general cu sintaxă de +linie de comandă similară cu \fBgzip\fP(1) și \fBbzip2\fP(1). Formatul de fișier +nativ este formatul \fB.xz\fP, dar formatul vechi \fB.lzma\fP folosit de LZMA +Utils și fluxurile comprimate brute fără anteturi de format container sunt +de asemenea acceptate. În plus, este acceptată decomprimarea formatului +\&\fB.lz\fP folosit de \fBlzip\fP. +.PP +\fBxz\fP comprimă sau decomprimă fiecare \fIfișier\fP în funcție de modul de +operare selectat. Dacă nu sunt date \fIfișiere\fP sau \fIfișier\fP este \fB\-\fP, +\fBxz\fP citește de la intrarea standard și scrie datele procesate la ieșirea +standard. \fBxz\fP va refuza (afișează o eroare și omite \fIfișier\fP) să scrie +date comprimate la ieșirea standard dacă este un terminal. În mod similar, +\fBxz\fP va refuza să citească datele comprimate de la intrarea standard dacă +este un terminal. +.PP +Cu excepția cazului în care este specificată opțiunea \fB\-\-stdout\fP, +\fIfișierele\fP altele decât \fB\-\fP sunt scrise într\-un fișier nou al cărui nume +este derivat din numele \fIfișierului\fP sursă: +.IP \(bu 3 +La comprimare, sufixul formatului de fișier țintă (\fB.xz\fP sau \fB.lzma\fP) este +atașat la numele fișierului sursă pentru a se obține numele fișierului +țintă. +.IP \(bu 3 +La decomprimare, sufixul \fB.xz\fP, \fB.lzma\fP sau \fB.lz\fP este eliminat din +numele fișierului pentru a se obține numele fișierului țintă. \fBxz\fP +recunoaște și sufixele \fB.txz\fP și \fB.tlz\fP și le înlocuiește cu sufixul +\&\fB.tar\fP. +.PP +Dacă fișierul țintă există deja, este afișată o eroare și \fIfișier\fP este +omis. +.PP +Cu excepția cazului în care scrie la ieșirea standard, \fBxz\fP va afișa un +avertisment și va omite \fIfișier\fPul dacă se aplică oricare dintre +următoarele: +.IP \(bu 3 +\fIFișierul\fP nu este un fișier obișnuit. Legăturile simbolice nu sunt urmate +și, prin urmare, nu sunt considerate fișiere obișnuite. +.IP \(bu 3 +\fIFișierul\fP are mai mult de o legătură dură. +.IP \(bu 3 +\fIFișierul\fP are activat bitul «setuid», «setgid» sau cel lipicios(sticky). +.IP \(bu 3 +Modul de operare este stabilit la comprimare și \fIfișier\fP are deja un sufix +al formatului de fișier țintă (\fB.xz\fP sau \fB.txz\fP când se comprimă în +formatul \fB.xz\fP și \fB.lzma\fP sau \fB.tlz\fP când se comprimă în formatul +\&\fB.lzma\fP). +.IP \(bu 3 +Modul de operare este stabilit la decomprimare și \fIfișierul\fP nu are un +sufix al niciunui format de fișier acceptat (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, +\&\fB.tlz\fP, sau \fB.lz\fP). +.PP +După comprimarea sau decomprimarea cu succes a \fIfișierului\fP, \fBxz\fP copiază +proprietarul, grupul, permisiunile, timpul de acces și timpul de modificare +din \fIfișierul\fP sursă în fișierul țintă. Dacă copierea grupului eșuează, +permisiunile sunt modificate astfel încât fișierul țintă să nu devină +accesibil utilizatorilor care nu aveau permisiunea de a accesa \fIfișierul\fP +sursă. \fBxz\fP nu acceptă încă copierea altor metadate, cum ar fi listele de +control al accesului sau atributele extinse. +.PP +Odată ce fișierul țintă a fost închis cu succes, \fIfișierul\fP sursă este +eliminat dacă nu a fost specificată opțiunea \fB\-\-keep\fP. \fIFișierul\fP sursă nu +este niciodată eliminat dacă rezultatul este scris la ieșirea standard sau +dacă apare o eroare. +.PP +Trimiterea unui semnal \fBSIGINFO\fP sau \fBSIGUSR1\fP către procesul \fBxz\fP face +ca acesta să imprime informații despre progres la ieșirea de eroare +standard. Acest lucru are o utilizare limitată, deoarece atunci când ieșirea +de eroare standard este un terminal, folosind opțiunea \fB\-\-verbose\fP va afișa +un indicator de progres de actualizare automată. +. +.SS "Utilizarea memoriei" +Cantitatea de memorie utilizată de \fBxz\fP variază de la câteva sute de +kiloocteți la câțiva gigaocteți, în funcție de opțiunile de +comprimare. Opțiunile utilizate la comprimarea unui fișier determină +cerințele de memorie ale instrumentului de decomprimare. De obicei, +instrumentul de decomprimare are nevoie de 5% până la 20% din cantitatea de +memorie de care a avut nevoie instrumentul de comprimare la crearea +fișierului. De exemplu, decomprimarea unui fișier creat cu \fBxz \-9\fP necesită +în prezent 65Mio de memorie. Totuși, este posibil să aveți fișiere \fB.xz\fP +care necesită câțiva gigaocteți de memorie pentru decomprimare. +.PP +În special utilizatorii de sisteme mai vechi pot considera deranjantă +posibilitatea unei utilizări foarte mari a memoriei. Pentru a preveni +surprizele neplăcute, \fBxz\fP are încorporat un limitator de utilizare a +memoriei, care este dezactivat implicit. În timp ce unele sisteme de operare +oferă modalități de a limita utilizarea memoriei proceselor, bazarea pe +aceasta nu a fost considerată a fi suficient de flexibilă (de exemplu, +utilizarea \fBulimit\fP(1) pentru a limita memoria virtuală tinde să paralizeze +\fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Limitatorul de utilizare a memoriei poate fi activat cu opțiunea din linia +de comandă \fB\-\-memlimit=\fP\fIlimita\fP. Adesea este mai convenabil să activați +limitatorul în mod implicit prin definirea variabilei de mediu +\fBXZ_DEFAULTS\fP, de exemplu, \fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Este posibil +să stabiliți limitele separat pentru comprimare și decomprimare folosind +\fB\-\-memlimit\-compress=\fP\fIlimita\fP și +\fB\-\-memlimit\-decompress=\fP\fIlimita\fP. Utilizarea acestor două opțiuni în afara +\fBXZ_DEFAULTS\fP este foarte rar utilă, deoarece o singură rulare a \fBxz\fP nu +poate face atât comprimarea, cât și decomprimarea și \fB\-\-memlimit=\fP\fIlimita\fP +(sau \fB\-M\fP \fIlimita\fP ) este mai scurt de tastat pe linia de comandă. +.PP +Dacă limita de utilizare a memoriei specificată este depășită la +decomprimare, \fBxz\fP va afișa o eroare și decomprimarea fișierului va +eșua. Dacă limita este depășită la comprimare, \fBxz\fP va încerca să reducă +valorile stabilite astfel încât limita să nu mai fie depășită (cu excepția +cazului în care se utilizează opțiunea \fB\-\-format=raw\fP sau +\fB\-\-no\-adjust\fP). În acest fel, operațiunea nu va eșua decât dacă limita +stabilită este foarte mică. Scalarea valorilor stabilite se face în pași +care nu se potrivesc cu valorile prestabilite ale nivelului de comprimare, +de exemplu, dacă limita este doar puțin mai mică decât cantitatea necesară +pentru \fBxz \-9\fP, valorile stabilite vor fi reduse doar puțin , nu până la +valoarea prestabilită a lui \fBxz \-8\fP. +. +.SS "Concatenare și completare (prin umplere cu octeți nuli) cu fișiere .xz" +Este posibil să concatenați fișierele \fB.xz\fP așa cum sunt. \fBxz\fP va +decomprima astfel de fișiere ca și cum ar fi un singur fișier \fB.xz\fP. +.PP +Este posibil să se introducă umplutură între părțile concatenate sau după +ultima parte. Umplutura trebuie să fie compusă din octeți nuli, iar +dimensiunea umpluturii trebuie să fie un multiplu de patru octeți. Acest +lucru poate fi util, de exemplu, dacă fișierul \fB.xz\fP este stocat pe un +mediu care măsoară dimensiunile fișierelor în blocuri de 512 de octeți. +.PP +Concatenarea și completarea nu sunt permise cu fișierele \fB.lzma\fP sau +fluxurile brute. +. +.SH OPȚIUNI +. +.SS "Sufixe de numere întregi și valori speciale" +În majoritatea locurilor în care este de așteptat un număr întreg ca +argument, un sufix opțional este acceptat pentru a indica cu ușurință +numerele întregi mari. Nu trebuie să existe spațiu între numărul întreg și +sufix. +.TP +\fBKiB\fP +Înmulțește numărul întreg cu 1.024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP și +\fBKB\fP sunt acceptate ca sinonime pentru \fBKiB\fP. +.TP +\fBMiB\fP +Înmulțește numărul întreg cu 1,048,576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP, și \fBMB\fP +sunt acceptate ca sinonime pentru \fBMiB\fP. +.TP +\fBGiB\fP +Înmulțește numărul întreg cu 1,073,741,824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP, și +\fBGB\fP sunt acceptate ca sinonime pentru \fBGiB\fP. +.PP +Valoarea specială \fBmax\fP poate fi utilizată pentru a indica valoarea maximă +întreagă suportată de opțiune. +. +.SS "Mod de operare" +Dacă sunt date mai multe opțiuni de mod de funcționare, ultima dintre ele, +este cea care va avea efect. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Comprimare. Acesta este modul de operare implicit atunci când nu este +specificată nicio opțiune de mod de funcționare și nici un alt mod de +operare nu este implicat din numele comenzii (de exemplu, \fBunxz\fP implică +\fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +După o comprimare reușită, fișierul sursă este eliminat, cu excepția cazului +în care a fost specificată scrierea la ieșirea standard sau opțiunea +\fB\-\-keep\fP. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Decomprimare. După o decomprimare reușită, fișierul sursă este eliminat, cu +excepția cazului în care a fost specificată scrierea la ieșirea standard sau +opțiunea \fB\-\-keep\fP. +.TP +\fB\-t\fP, \fB\-\-test\fP +Testează integritatea \fIfișierelor\fP comprimate. Această opțiune este +echivalentă cu \fB\-\-decompress \-\-stdout\fP cu excepția faptului că datele +decomprimate sunt înlăturate în loc să fie scrise la ieșirea standard. Nu +sunt create sau eliminate fișiere. +.TP +\fB\-l\fP, \fB\-\-list\fP +Afișează informații despre \fIfișiere\fP comprimate. Nu are loc nicio +decomprimare la ieșire și nu sunt create sau eliminate fișiere. În modul +listă, programul nu poate citi datele comprimate din intrarea standard sau +din alte surse care nu pot fi explorate. +.IP "" +Listarea implicită arată informații de bază despre \fIfișiere\fP, câte un +fișier pe linie. Pentru a obține informații mai detaliate, utilizați și +opțiunea \fB\-\-verbose\fP. Pentru și mai multe informații, utilizați opțiunea +\fB\-\-verbose\fP de două ori, dar rețineți că acest lucru poate fi lent, +deoarece obținerea tuturor informațiilor suplimentare necesită multe +căutări. Lățimea ieșirii detaliate depășește 80 de caractere, deci +canalizarea ieșirii către, de exemplu, \fBless\ \-S\fP poate fi convenabilă dacă +terminalul nu este suficient de lat. +.IP "" +Ieșirea exactă poate varia între versiunile \fBxz\fP și diferitele +localizări(configurările regionale). Pentru ieșiri care pot fi citite de +mașină, ar trebui utilizată opțiunea \fB\-\-robot \-\-list\fP. +. +.SS "Modificatori de operare" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Nu șterge fișierele de intrare. +.IP "" +Începând cu \fBxz\fP 5.2.6, această opțiune face ca \fBxz\fP să comprime sau să +decomprime, chiar dacă intrarea este o legătură simbolică către un fișier +obișnuit, are mai mult de\-o legătură dură sau are marcați biții setuid, +setgid sau bitul lipicios. Biții setuid, setgid și bitul lipicios nu sunt +copiați în fișierul țintă. În versiunile anterioare acest lucru se făcea +numai cu ajutorul opțiunii \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Această opțiune are mai multe efecte: +.RS +.IP \(bu 3 +Dacă fișierul țintă există deja, îl șterge înainte de comprimare sau +decomprimare. +.IP \(bu 3 +Comprimă sau decomprimă chiar dacă intrarea este o legătură simbolică către +un fișier obișnuit, are mai mult de\-o legătură dură sau are marcați biții +setuid, setgid sau bitul lipicios. Biții setuid, setgid și bitul lipicios nu +sunt copiați în fișierul țintă. +.IP \(bu 3 +Când este utilizată cu opțiunile \fB\-\-decompress\fP și \fB\-\-stdout\fP, comanda +\fBxz\fP nu poate recunoaște tipul fișierului sursă, și copiază fișierul sursă +așa cum este la ieșirea standard. Acest lucru permite comenzii \fBxzcat\fP +\fB\-\-force\fP să fie folosită drept comanda \fBcat\fP(1) pentru fișierele care nu +au fost comprimate cu \fBxz\fP. Rețineți că, în viitor, \fBxz\fP ar putea să +accepte noi formate de fișiere comprimate, ceea ce poate face ca \fBxz\fP să +decomprime mai multe tipuri de fișiere în loc să le copieze așa cum sunt la +ieșirea standard. Opțiunea \fB\-\-format=\fP\fIformat\fP poate fi folosită pentru a +restricționa \fBxz\fP să decomprime doar un singur format de fișier. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Scrie datele comprimate sau decomprimate la ieșirea standard în loc de +într\-un fișier. Aceasta implică \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Decomprimă numai primul flux \fB.xz\fP și ignoră în tăcere posibilele date de +intrare rămase în urma fluxului. În mod normal, astfel de resturi rămase +face ca \fBxz\fP să afișeze o eroare. +.IP "" +\fBxz\fP nu decomprimă niciodată mai mult de un flux din fișierele \fB.lzma\fP sau +din fluxurile brute, dar această opțiune face ca \fBxz\fP să ignore posibilele +resturi de date rămase după fișierul \fB.lzma\fP sau fluxul brut. +.IP "" +Această opțiune nu are efect dacă modul de funcționare nu este +\fB\-\-decompress\fP sau \fB\-\-test\fP. +.IP "" +Începând cu \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP implică \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Dezactivează crearea de fișiere dispersate. În mod implicit, dacă decomprimă +într\-un fișier obișnuit, \fBxz\fP încearcă să facă fișierul dispersat dacă +datele decomprimate conțin secvențe lungi de zerouri binare. De asemenea, +funcționează atunci când scrie la ieșirea standard, atâta timp cât ieșirea +standard este conectată la un fișier obișnuit și sunt îndeplinite anumite +condiții suplimentare pentru a o face în siguranță. Crearea de fișiere +dispersate poate economisi spațiu pe disc și poate accelera decomprimarea +prin reducerea cantității de date de In/Ieș pe disc. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Când comprimă, utilizează \fI.suf\fP ca sufix pentru fișierul țintă în loc de +\&\fB.xz\fP sau \fB.lzma\fP. Dacă nu scrie la ieșirea standard și fișierul sursă are +deja sufixul \fI.suf\fP, este afișat un avertisment și fișierul este omis. +.IP "" +Când decomprimă, recunoaște fișierele cu sufixul \fI.suf\fP în plus față de +fișierele cu sufixul \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP sau \fB.lz\fP. Dacă +fișierul sursă are sufixul \fI.suf\fP, sufixul este eliminat pentru a obține +numele fișierului țintă. +.IP "" +La comprimarea sau decomprimarea fluxurilor brute (\fB\-\-format=raw\fP), sufixul +trebuie să fie întotdeauna specificat, cu excepția cazului în care se scrie +la ieșirea standard, deoarece nu există un sufix implicit pentru fluxurile +brute. +.TP +\fB\-\-files\fP[\fB=\fP\fIfișier\fP] +Citește numele fișierelor de procesat din \fIfișier\fP; dacă \fIfișierul\fP este +omis, numele fișierelor sunt citite de la intrarea standard. Numele de +fișiere trebuie să fie terminate cu caracterul de linie nouă. O liniuță +(\fB\-\fP) este luată ca nume de fișier obișnuit; nu înseamnă intrarea +standard. Dacă numele de fișiere sunt date și ca argumente în linia de +comandă, ele sunt procesate înainte ca numele fișierelor să fie citite din +\fIfișier\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIfișier\fP] +Această opțiune este identică cu \fB\-\-files\fP[\fB=\fP\fIfișier\fP], cu excepția +faptului că fiecare nume de fișier trebuie să fie terminat cu caracterul +nul. +. +.SS "Formatul de bază al fișierului și opțiunile de comprimare" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fIformat\fP +Specifică \fIformatul\fP fișierului pentru comprimare sau decomprimare: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Aceasta este valoarea implicită. La comprimare, \fBauto\fP este echivalent cu +\fBxz\fP. La decomprimare, formatul fișierului de intrare este detectat +automat. Rețineți că fluxurile brute (create cu \fB\-\-format=raw\fP) nu pot fi +detectate automat. +.TP +\fBxz\fP +Comprimă în formatul de fișier \fB.xz\fP sau acceptă numai fișierele \fB.xz\fP +când decomprimă. +.TP +\fBlzma\fP, \fBalone\fP +Comprimă în formatul de fișier \fB.lzma\fP vechi sau acceptă numai fișierele +\&\fB.lzma\fP când decomprimă. Numele alternativ \fBalone\fP este furnizat pentru +compatibilitatea cu versiunile mai vechi de LZMA Utils. +.TP +\fBlzip\fP +Acceptă numai fișierele \fB.lz\fP când decomprimă. Comprimarea nu este +acceptată. +.IP "" +Sunt acceptate versiunile 0 și 1 ale formatului \fB.lz\fP. Fișierele versiunii +0 au fost create cu \fBlzip\fP 1.3 și versiuni mai vechi. Astfel de fișiere nu +sunt comune, dar pot fi găsite în arhivele de fișiere, deoarece câteva +pachete sursă au fost lansate în acest format. Este posibil ca oamenii să +aibă și fișiere personale vechi în acest format. Suportul pentru +decomprimare pentru versiunea 0 a formatului a fost eliminat în \fBlzip\fP +1.18. \fBlzip\fP 1.4 și versiunile ulterioare creează fișiere în versiunea 1 a +formatului. +.TP +\fBraw\fP +Comprimă sau decomprimă un flux brut (fără anteturi). Acest lucru este +destinat doar utilizatorilor avansați. Pentru a decodifica fluxurile brute, +trebuie să utilizați opțiunea \fB\-\-format=raw\fP și să specificați în mod +explicit lanțul de filtre, care în mod normal ar fi fost stocat în +anteturile containerului. +.RE +.TP +\fB\-C\fP \fIverificarea\fP, \fB\-\-check=\fP\fIverificarea\fP +Specifică tipul verificării integrității. Verificarea este calculată din +datele necomprimate și stocată în fișierul \fB.xz\fP. Această opțiune are efect +numai la comprimarea în format \fB.xz\fP; formatul \fB.lzma\fP nu acceptă +verificări de integritate. Verificarea integrității (dacă există) este +efectuată atunci când fișierul \fB.xz\fP este decomprimat. +.IP "" +Tipuri de \fIverificare\fP acceptate: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Nu calculează deloc o verificare a integrității. Aceasta este de obicei o +idee proastă. Acest lucru poate fi util atunci când integritatea datelor +este oricum verificată prin alte mijloace. +.TP +\fBcrc32\fP +Calculează CRC32 folosind polinomul din IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Calculează CRC64 folosind polinomul din ECMA\-182. Aceasta este valoarea +implicită, deoarece este ceva mai bună decât CRC32 la detectarea fișierelor +deteriorate, iar diferența de viteză este neglijabilă. +.TP +\fBsha256\fP +Calculează SHA\-256. Acest lucru este oarecum mai lent decât CRC32 și CRC64. +.RE +.IP "" +Integritatea antetelor \fB.xz\fP este întotdeauna verificată cu CRC32. Nu este +posibilă modificarea sau dezactivarea acesteia. +.TP +\fB\-\-ignore\-check\fP +Nu efectuează verificarea integrității datelor comprimate la +decomprimare. Valorile CRC32 din antetele \fB.xz\fP vor fi însă verificate +normal. +.IP "" +\fBNu utilizați această opțiune decât dacă știți ce faceți\fP. Motive posibile +pentru a utiliza această opțiune: +.RS +.IP \(bu 3 +Încercarea de a recupera datele dintr\-un fișier .xz corupt. +.IP \(bu 3 +Accelerarea decomprimării. Acest lucru contează mai ales cu SHA\-256 sau cu +fișierele care s\-au comprimat extrem de bine. Este recomandat să nu +utilizați această opțiune în acest scop decât dacă integritatea fișierului +este verificată extern într\-un alt mod. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Selectează un nivel prestabilit de comprimare. Valoarea implicită este +\fB\-6\fP. Dacă sunt specificate mai multe niveluri prestabilite, ultimul are +efect. Dacă a fost deja specificat un lanț de filtre personalizat, +specificarea unui nivel prestabilit de comprimare șterge lanțul de filtre +personalizat. +.IP "" +Diferențele dintre valorile prestabilite sunt mai semnificative decât cu +\fBgzip\fP(1) și \fBbzip2\fP(1). Valorile de comprimare selectate determină +cerințele de memorie ale instrumentului de decomprimare, astfel încât +utilizarea unui nivel prea mare prestabilit ar putea face „dureroasă” +decomprimarea fișierului pe un sistem vechi cu puțină memorie RAM. Mai +exact, \fBnu este o idee bună să folosiți orbește \-9 pentru tot\fP așa cum se +întâmplă adesea cu \fBgzip\fP(1) și \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Acestea sunt valorile prestabilite oarecum rapide. \fB\-0\fP este uneori mai +rapid decât \fBgzip \-9\fP în timp ce comprimă mult mai bine. Cele mai ridicate +au adesea viteza comparabilă cu \fBbzip2\fP(1) cu un raport de comprimare +comparabil sau mai bun, deși rezultatele depind foarte mult de tipul de date +care sunt comprimate. +.TP +\fB\-4\fP ... \fB\-6\fP +Comprimare bună spre foarte bună, păstrând în același timp utilizarea +memoriei de către instrumentul de decomprimare la un nivel rezonabil chiar +și pentru sistemele vechi. \fB\-6\fP este valoarea implicită, care este de +obicei o alegere bună pentru distribuirea fișierelor care trebuie să poată +fi decomprimate chiar și pe sisteme cu doar 16Mio de memorie RAM. Opțiunile +(\fB\-5e\fP sau \fB\-6e\fP ar putea fi demne de luat în considerare. A se vedea +opțiunea \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Acestea sunt precum \fB\-6\fP, dar cu cerințe mai mari de memorie pentru +comprimare și decomprimare. Acestea sunt utile numai atunci când comprimați +fișiere mai mari de 8Mio, 16Mio și, respectiv, 32Mio. +.RE +.IP "" +Pe același hardware, viteza de decomprimare este aproximativ un număr +constant de octeți de date comprimate pe secundă. Cu alte cuvinte, cu cât +comprimarea este mai bună, cu atât decomprimarea va fi de obicei mai +rapidă. Aceasta înseamnă, de asemenea, că valoarea de la ieșire a cantității +de date necomprimate produsă pe secundă poate varia foarte mult. +.IP "" +Următorul tabel rezumă caracteristicile valorilor prestabilite: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +ValPrestab;DimDict;CPUComp;MemComp;MemDec +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Descrieri coloane: +.RS +.IP \(bu 3 +DimDict este dimensiunea dicționarului LZMA2. Este o risipă de memorie să +folosești un dicționar mai mare decât dimensiunea fișierului necomprimat. De +aceea este bine să evitați utilizarea valorilor prestabilite \fB\-7\fP ... \fB\-9\fP +atunci când nu este nevoie cu adevărat de ele. Pentru valoarea prestabilită +\fB\-6\fP sau alta mai mică, cantitatea de memorie irosită este de obicei +suficient de mică pentru a nu conta. +.IP \(bu 3 +CPUComp este o reprezentare simplificată a configurărilor LZMA2 care +afectează viteza de comprimare. Dimensiunea dicționarului afectează și +viteza, așa că, în timp ce CPUComp este aceeași pentru nivelurile \fB\-6\fP +\&... \fB\-9\fP, nivelurile mai mari tind să fie puțin mai lente. Pentru a obține +o comprimare și mai lentă și, astfel, posibil mai bună, consultați opțiunea +\fB\-\-extreme\fP. +.IP \(bu 3 +MemComp conține cerințele de memorie ale comprimării în modul cu un singur +fir de execuție. Poate varia ușor între versiunile \fBxz\fP. +.IP \(bu 3 +MemDec conține cerințele de memorie pentru decomprimare. Adică, +configurările de comprimare determină cerințele de memorie ale +decomprimării. Cantitatea exactă a memoriei utilizate la decomprimare este +puțin mai mare decât dimensiunea dicționarului LZMA2, dar valorile din tabel +au fost rotunjite la următorul Mio. +.RE +.IP "" +Cerințele de memorie ale modului cu mai multe fire de execuție sunt +semnificativ mai mari decât cele ale modului cu un singur fir de +execuție. Cu valoarea implicită a lui \fB\-\-block\-size\fP, fiecare fir are +nevoie de 3*3*DictSize plus MemComp sau MemDec. De exemplu, patru fire de +execuție cu valoarea prestabilită \fB\-6\fP au nevoie de 660\(en670\ Mio de +memorie. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Utilizează o variantă mai lentă a nivelului prestabilit de comprimare +selectat (\fB\-0\fP ... \fB\-9\fP) pentru a obține un raport de comprimare puțin mai +bun, dar din nefericire, acest lucru îl poate înrăutăți. Utilizarea memoriei +pentru decomprimare nu este afectată, dar utilizarea memoriei la comprimare +crește puțin la nivelurile prestabilite \fB\-0\fP ... \fB\-3\fP. +.IP "" +Deoarece există două valori prestabilite cu dimensiuni ale dicționarului de +4Mio și 8Mio, valorile prestabilite \fB\-3e\fP și \fB\-5e\fP folosesc configurări +puțin mai rapide (CPUComp mai mic) decât \fB\-4e\fP și \fB\-6e\fP, respectiv. În +acest fel, nu există două nivele prestabilite identice. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +ValPrestab;DimDict;CPUComp;MemComp;MemDec +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +De exemplu, există un total de patru nivele prestabilite care folosesc +dicționarul 8Mio, a căror ordine de la cel mai rapid la cel mai lent este +\fB\-5\fP, \fB\-6\fP, \fB\-5e\fP și \fB\-6e\fP . +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Acestea sunt alias de opțiuni, oarecum înșelătoare pentru \fB\-0\fP și, +respectiv, \fB\-9\fP. Acestea sunt furnizate numai pentru compatibilitatea cu +LZMA Utils. Evitați utilizarea acestor opțiuni. +.TP +\fB\-\-block\-size=\fP\fIdimensiunea\fP +Când comprimă în formatul \fB.xz\fP, împarte datele de intrare în blocuri de +\fIdimensiunea\fP octeți. Blocurile sunt comprimate independent unul de +celălalt, ceea ce ajută în modul cu mai multe fire de execuție și face +posibilă decomprimarea cu acces aleatoriu limitat. Această opțiune este de +obicei folosită pentru a suprascrie dimensiunea implicită a blocului în +modul cu mai multe fire de execuție, dar această opțiune poate fi folosită +și în modul cu un singur fir de execuție. +.IP "" +În modul cu mai multe fire de execuție, aproximativ de trei ori +\fIdimensiunea\fP de octeți vor fi alocați în fiecare fir pentru stocarea +intrării și ieșirii. \fIDimensiunea\fP implicită este de trei ori dimensiunea +dicționarului LZMA2 sau 1Mio, oricare dintre acestea este mai mare. În mod +obișnuit, o valoare bună este de două la patru ori dimensiunea dicționarului +LZMA2 sau de cel puțin 1Mio. Utilizarea unei \fIdimensiuni\fP mai mici decât +dimensiunea dicționarului LZMA2 este o risipă de memorie RAM, deoarece +atunci memoria tampon a dicționarului LZMA2 nu va fi niciodată utilizată pe +deplin. În modul cu mai multe fire de execuție, dimensiunile blocurilor sunt +stocate în anteturile blocurilor. Aceste informații privind dimensiunea sunt +necesare pentru decomprimarea cu mai multe fire. +.IP "" +În modul cu un singur fir de execuție, nicio divizare a blocurilor nu se +face în mod implicit. Folosirea acestei opțiuni nu afectează utilizarea +memoriei. Nu sunt stocate informații despre dimensiune în antetele +blocurilor, astfel încât fișierele create în modul cu un singur fir de +execuție nu vor fi identice cu fișierele create în modul cu mai multe fire +de execuție. Lipsa informațiilor privind dimensiunea înseamnă, de asemenea, +că \fBxz\fP nu va putea decomprima fișierele în modul cu mai multe fire. de +execuție. +.TP +\fB\-\-block\-list=\fP\fIelemente\fP +Când comprimă în formatul \fB.xz\fP, începe un nou bloc cu un lanț de filtre +personalizat opțional după intervalele specificate de date necomprimate. +.IP "" +\fIelementele\fP sunt o listă separată prin virgule. Fiecare element este +format dintr\-un număr opțional de lanț de filtrare între 0 și 9, urmat de +două puncte (\fB:\fP) și de o dimensiune cerută a datelor +necomprimate. Omiterea unui element (două sau mai multe virgule consecutive) +este o prescurtare pentru a utiliza dimensiunea și filtrele din elementul +anterior. +.IP "" +În cazul în care fișierul de intrare este mai mare decât suma dimensiunilor +din \fIelemente\fP, ultimul element se repetă până la sfârșitul fișierului. O +valoare specială de \fB0\fP poate fi utilizată ca ultimă dimensiune pentru a +indica faptul că restul fișierului trebuie să fie codificat ca un singur +bloc. +.IP "" +Un lanț de filtre alternativ pentru fiecare bloc poate fi specificat în +combinație cu opțiunile \fB\-\-filters1=\fP\fIfiltre\fP \&...\& +\fB\-\-filters9=\fP\fIfiltre\fP. Aceste opțiuni definesc lanțuri de filtre cu un +identificator cuprins între 1\(en9. Lanțul de filtre 0 poate fi utilizat +pentru a se referi la lanțul de filtre implicit, ceea ce este același lucru +cu a nu specifica un lanț de filtre. Identificatorul lanțului de filtre +poate fi utilizat înaintea dimensiunii necomprimate, urmat de două puncte +(\fB:\fP). De exemplu, dacă se specifică +\fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP, atunci blocurile vor fi +create folosind: +.RS +.IP \(bu 3 +Lanțul de filtre specificat de \fB\-\-filters1\fP și 2 Mio de intrare +.IP \(bu 3 +Lanțul de filtre specificat de \fB\-\-filters3\fP și 2 Mio de intrare +.IP \(bu 3 +Lanțul de filtre specificat de \fB\-\-filters2\fP și 4 Mio de intrare +.IP \(bu 3 +Lanțul de filtre specificat de \fB\-\-filters2\fP și 4 Mio de intrare +.IP \(bu 3 +Lanțul de filtre implicit și 2 MiB de intrare +.IP \(bu 3 +Lanțul de filtre implicit și 4 MiB de intrare pentru fiecare bloc până la +sfârșitul intrării. +.RE +.IP "" +Dacă se specifică o dimensiune care depășește dimensiunea blocului +codificatorului (fie valoarea implicită în modul cu fire de execuție, fie +valoarea specificată cu \fB\-\-block\-size=\fP\fIdimensiune\fP), codificatorul va +crea blocuri suplimentare, păstrând limitele specificate în \fIelemente\fP. De +exemplu, dacă se specifică \fB\-\-block\-size=10MiB\fP +\fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP și fișierul de intrare este de +80 MiB, se vor obține 11 blocuri: 5, 10, 8, 10, 10, 2, 10, 10, 10, 4, 10, +10, 10 și 1 Mio. +.IP "" +În modul cu mai multe fire de execuție, dimensiunile blocurilor sunt stocate +în antetele blocurilor. Acest lucru nu se face în modul cu un singur fir de +execuție, astfel încât ieșirea codificată nu va fi identică cu cea a modului +cu mai multe fire de execuție. +.TP +\fB\-\-flush\-timeout=\fP\fItimp_limită\fP +La comprimare, dacă au trecut mai mult de \fItimp_limită\fP milisecunde (un +întreg pozitiv) de la curățarea anterioară și citirea mai multor intrări +s\-ar bloca, toate datele de intrare în așteptare sunt eliminate din +codificator și puse la dispoziție în fluxul de ieșire. Acest lucru poate să +fie util dacă \fBxz\fP este utilizat pentru a comprima datele care sunt +transmise în flux printr\-o rețea. Valorile mici de \fItimp_limită\fP fac datele +disponibile la capătul de recepție cu o mică întârziere, dar valorile mari +de \fItimp_limită\fP oferă un raport de comprimare mai bun. +.IP "" +Această caracteristică este dezactivată în mod implicit. Dacă această +opțiune este specificată de mai multe ori, ultima este cea care se ia în +considerare. Valoarea specială a lui \fItimp_limită\fP de \fB0\fP, poate fi +utilizată pentru a dezactiva în mod explicit această caracteristică. +.IP "" +Această caracteristică nu este disponibilă în sistemele non\-POSIX. +.IP "" +.\" FIXME +\fBAceastă caracteristică este încă experimentală\fP. În prezent, \fBxz\fP este +nepotrivit pentru decomprimarea fluxului în timp real datorită modului în +care \fBxz\fP utilizează memoria tampon. +.TP +\fB\-\-no\-sync\fP +Nu sincronizează fișierul țintă și directorul acestuia cu dispozitivul de +stocare înainte de a elimina fișierul sursă. Acest lucru poate îmbunătăți +performanța în cazul comprimării sau decomprimării multor fișiere mici. Cu +toate acestea, dacă sistemul se blochează imediat după ștergere, este +posibil ca fișierul țintă să nu fi fost scris pe dispozitivul de stocare, +dar operația de ștergere să fi fost. În acest caz, nici fișierul sursă +original, nici fișierul țintă nu sunt disponibile. +.IP "" +Această opțiune are efect numai atunci când \fBxz\fP urmează să elimine +fișierul sursă. În alte cazuri, sincronizarea nu se face niciodată. +.IP "" +Sincronizarea și \fB\-\-no\-sync\fP au fost adăugate în \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIlimita\fP +Stabilește o limită de utilizare a memoriei pentru comprimare. Dacă această +opțiune este specificată de mai multe ori, ultima va avea efect. +.IP "" +Dacă parametrii de comprimare depășesc \fIlimita\fP, \fBxz\fP va încerca să +ajusteze parametrii scăzând valorile acestora, astfel încât limita să nu mai +fie depășită și va afișa o notificare că ajustarea automată a fost +efectuată. Ajustările se fac în această ordine: reducerea numărului de fire, +trecerea la modul un singur fir de execuție dacă chiar și un singur fir în +modul cu mai multe fire de execuție depășește \fIlimita\fP și, în final, +reducerea dimensiunii dicționarului LZMA2. +.IP "" +Când comprimă cu opțiunea \fB\-\-format=raw\fP sau dacă a fost specificată +opțiunea \fB\-\-no\-adjust\fP, numai numărul de fire poate fi redus, deoarece se +poate face fără a afecta rezultatul comprimării. +.IP "" +Dacă \fIlimita\fP nu poate fi îndeplinită chiar și cu ajustările descrise mai +sus, este afișată o eroare și \fBxz\fP va ieși cu starea de ieșire 1. +.IP "" +\fILimita\fP poate fi specificata în mai multe moduri: +.RS +.IP \(bu 3 +\fILimita\fP poate fi o valoare absolută în octeți. Utilizarea unui sufix +întreg precum \fBMiB\fP poate fi utilă. De exemplu: +\fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +\fILimita\fP poate fi specificată ca procent din memoria fizică totală +(RAM). Acest lucru poate fi util mai ales atunci când definiți variabila de +mediu \fBXZ_DEFAULTS\fP într\-un script de inițializare shell care este partajat +între diferite calculatoare. În acest fel, limita este automat mai mare pe +sistemele cu mai multă memorie. De exemplu: \fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +\fILimita\fP poate fi restabilită la valoarea implicită dându\-i valoarea +\fB0\fP. În prezent, aceasta este echivalentă cu stabilirea \fIlimitei\fP la +\fBmax\fP (fără limită de utilizare a memoriei). +.RE +.IP "" +Pentru \fBxz\fP pe 32 de biți există un caz special: dacă \fIlimita\fP ar fi peste +\fB4020MiB\fP, \fIlimita\fP este stabilită la \fB4020MiB\fP. Pe MIPS32 este +stabilită în schimb la \fB2000MiB\fP; (valorile \fB0\fP și \fBmax\fP nu sunt afectate +de acest lucru \-\- o caracteristică similară nu există pentru +decomprimare). Acest lucru poate fi util atunci când un executabil pe 32 de +biți are acces la un spațiu de adrese de 4Gio (2Gio pe MIPS32), se speră că +nu produce daune în alte situații. +.IP "" +Consultați și secțiunea \fBUtilizarea memoriei\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIlimita\fP +Stabilește o limită de utilizare a memoriei pentru decomprimare. Acest lucru +afectează și modul \fB\-\-list\fP. Dacă operațiunea nu este posibilă fără a +depăși \fIlimita\fP, \fBxz\fP va afișa o eroare și decomprimarea fișierului va +eșua. Consultați \fB\-\-memlimit\-compress=\fP\fIlimita\fP pentru modalitățile +posibile de a specifica \fIlimita\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimita\fP +Stabilește o limită de utilizare a memoriei pentru decomprimarea cu mai +multe fire de execuție. Acest lucru poate afecta doar numărul de fire de +execuție; acest lucru nu îl va face niciodată pe \fBxz\fP să refuze +decomprimarea unui fișier. Dacă \fIlimita\fP este prea scăzută pentru a permite +orice mod cu mai multe fire de execuție, \fIlimita\fP este ignorată și \fBxz\fP va +continua în modul cu un singur fir de execuție. Rețineți că, dacă se +folosește și opțiunea \fB\-\-memlimit\-decompress\fP, se va aplica întotdeauna +atât modurilor cu un singur fir de execuție, cât și modurilor cu mai multe +fire de execuție și astfel \fIlimita\fP efectivă pentru modul cu mai multe fire +de execuție nu va fi niciodată mai mare decât limita stabilită cu opțiunea +\fB\-\-memlimit\-decompress\fP. +.IP "" +Spre deosebire de celelalte opțiuni de limită de utilizare a memoriei, +opțiunea \fB\-\-memlimit\-mt\-decompress=\fP\fIlimita\fP are o \fIlimită\fP implicită +specifică sistemului. Comanda \fBxz \-\-info\-memory\fP poate fi folosită pentru a +vedea valoarea curentă. +.IP "" +Această opțiune și valoarea ei implicită există deoarece, fără nicio limită, +decomprimarea cu (mai multe) fire de execuție ar putea ajunge să aloce o +cantitate „nebună” de memorie cu unele fișiere de intrare. Dacă \fIlimita\fP +implicită este prea scăzută pe sistemul dumneavoastră, nu ezitați să +creșteți \fIlimita\fP, dar niciodată să nu o stabiliți la o valoare mai mare +decât cantitatea de memorie RAM utilizabilă și cu niște fișiere de intrare +adecvate, \fBxz\fP va încerca să utilizeze acea cantitate de memorie chiar și +cu un număr redus de fire de execuție. Rularea lui \fBxz\fP cu depășirea +cantității de memorie fizice(RAM) sau a celei de interschimb(swap) nu va +îmbunătăți performanța de decomprimare. +.IP "" +Consultați opțiunea \fB\-\-memlimit\-compress=\fP\fIlimita\fP pentru modalități +posibile de a specifica \fIlimita\fP. Stabilirea \fIlimitei\fP la \fB0\fP +restabilește \fIlimita\fP la valoarea implicită specifică sistemului. +.TP +\fB\-M\fP \fIlimita\fP, \fB\-\-memlimit=\fP\fIlimita\fP, \fB\-\-memory=\fP\fIlimita\fP +Aceasta este echivalentă cu specificarea opțiunilor: +\fB\-\-memlimit\-compress=\fP\fIlimita\fP \fB\-\-memlimit\-decompress=\fP\fIlimita\fP +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimita\fP. +.TP +\fB\-\-no\-adjust\fP +Afișează o eroare și iese dacă limita de utilizare a memoriei nu poate fi +îndeplinită fără ajustarea parametrilor care afectează ieșirea +comprimată. Adică, acest lucru împiedică \fBxz\fP să comute codificatorul din +modul cu mai multe fire de execuție în modul cu un singur fir de execuție și +să reducă dimensiunea dicționarului LZMA2. Chiar și atunci când această +opțiune este utilizată, numărul de fire de execuție poate fi redus pentru a +îndeplini limita de utilizare a memoriei, deoarece aceasta nu va afecta +comprimarea. +.IP "" +Ajustarea automată este întotdeauna dezactivată la crearea fluxurilor brute +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fInumăr\fP, \fB\-\-threads=\fP\fInumăr\fP +Specifică numărul de fire de execuție de utilizat. Stabilirea \fInumărului\fP +la valoarea specială \fB0\fP, face ca \fBxz\fP să utilizeze până la atâtea fire de +execuție câte procesoare sunt în sistem. Numărul real de fire de execuție +poate fi mai mic decât \fInumăr\fP dacă fișierul de intrare nu este suficient +de mare pentru a trece la modul cu mai multe fire de execuție cu parametrii +dați, sau dacă folosirea mai multor fire de execuție ar depăși limita de +utilizare a memoriei. +.IP "" +Operațiile de comprimare cu un singur fir de execuție și cele cu mai multe +fire de execuție produc ieșiri diferite. Comprimarea cu un singur fir de +execuție va oferi cea mai mică dimensiune a fișierului, dar numai ieșirea de +la comprimarea cu mai multe fire de execuție poate fi decomprimată folosind +mai multe fire. Stabilirea \fInumărului\fP la \fB1\fP va determina ca \fBxz\fP să +folosească modul cu un singur fir de execuție. Stabilirea \fInumărului\fP la +orice altă valoare, inclusiv \fB0\fP, va determina ca \fBxz\fP să folosească +comprimarea cu mai multe fire de execuție chiar dacă sistemul acceptă doar +un fir hardware; (\fBxz\fP 5.2.x folosește modul cu un singur fir de execuție +în această situație). +.IP "" +Pentru a utiliza modul cu mai multe fire de execuție cu un singur fir, +stabiliți \fInumărul\fP la \fB+1\fP. Prefixul \fB+\fP nu are efect cu alte valori +decât \fB1\fP. O limită de utilizare a memoriei poate face în continuare \fBxz\fP +să treacă în modul cu un singur fir, cu excepția cazului în care este +utilizată opțiunea \fB\-\-no\-adjust\fP. Suportul pentru prefixul \fB+\fP a fost +adăugat în \fBxz\fP 5.4.0. +.IP "" +Dacă a fost solicitat un număr automat de fire și nu a fost specificată +nicio limită de utilizare a memoriei, atunci o limită „maleabilă” implicită +specifică sistemului va fi utilizată pentru a limita eventual numărul de +fire de execuție. Este o limită „maleabilă” în sensul că este ignorată dacă +numărul de fire devine unul, astfel o limită „maleabilă” nu va opri +niciodată \fBxz\fP să comprime sau să decomprime. Această limită „maleabilă” +implicită nu va face \fBxz\fP să treacă de la modul cu mai multe fire de +execuție la modul cu un singur fir de execuție. Limitele active pot fi +văzute rulând comanda \fBxz \-\-info\-memory\fP. +.IP "" +În prezent, singura metodă de procesare cu fire de execuție este împărțirea +intrării în blocuri și comprimarea lor independent unul de +celălalt. Dimensiunea implicită a blocului depinde de nivelul de comprimare +și poate fi înlocuită cu opțiunea \fB\-\-block\-size=\fP\fIdimensiune\fP. +.IP "" +Decomprimarea cu fire de execuție funcționează numai pe fișierele care +conțin mai multe blocuri cu informații despre dimensiune în antetele +blocurilor. Toate fișierele suficient de mari comprimate în modul cu mai +multe fire de execuție îndeplinesc această condiție, dar fișierele +comprimate în modul cu un singur fir de execuție nu o îndeplinesc chiar dacă +a fost folosită opțiunea \fB\-\-block\-size=\fP\fIdimensiune\fP. +.IP "" +Valoarea implicită pentru \fIfire de execuție\fP este \fB0\fP. În \fBxz\fP 5.4.x și +mai vechi, valoarea implicită este \fB1\fP. +. +.SS "Lanțuri de filtrare personalizate pentru instrumentul de comprimare" +Un lanț de filtrare personalizat permite specificarea parametrilor de +comprimare în detaliu, în loc să se bazeze pe cei asociați opțiunilor +prestabilite. Când este specificat un lanț de filtrare personalizat, +opțiunile prestabilite (\fB\-0\fP \&...\& \fB\-9\fP și \fB\-\-extreme\fP) de mai devreme +din linia de comandă sunt uitate. Dacă o opțiune prestabilită este +specificată după una sau mai multe opțiuni de lanț de filtrare personalizat, +noua prestabilire intră în vigoare și opțiunile lanțului de filtrare +personalizat, specificate mai devreme sunt uitate. +.PP +Un lanț de filtrare este comparabil cu conductele din linia de comandă. La +comprimare, intrarea necomprimată merge la primul filtru, a cărui ieșire +merge la următorul filtru (dacă există). Ieșirea ultimului filtru este +scrisă în fișierul comprimat. Numărul maxim de filtre din lanț este de +patru, dar de obicei un lanț de filtrare are doar unul sau două filtre. +.PP +Multe filtre au limitări în ceea ce privește locul în care se pot afla în +lanțul de filtrare: unele filtre pot funcționa doar ca ultimul filtru din +lanț, altele doar ca non\-ultim filtru și unele funcționează în orice poziție +din lanț. În funcție de filtru, această limitare este fie inerentă +proiectării filtrului, fie există pentru a preveni problemele de securitate. +.PP +Un lanț de filtre personalizat poate fi specificat în două moduri +diferite. Opțiunile \fB\-\-filters=\fP\fIfiltre\fP și \fB\-\-filters1=\fP\fIfiltre\fP +\&...\& \fB\-\-filters9=\fP\fIfiltre\fP permit specificarea unui întreg lanț de +filtre într\-o singură opțiune, folosind sintaxa șirului de filtre +liblzma. Alternativ, un lanț de filtre poate fi specificat prin utilizarea +uneia sau mai multor opțiuni de filtrare individuale în ordinea în care sunt +dorite în lanțul de filtre. Adică, ordinea opțiunilor de filtrare +individuale este semnificativă! La decodificarea fluxurilor brute +(\fB\-\-format=raw\fP), lanțul de filtre trebuie să fie specificat în aceeași +ordine în care a fost specificat la comprimare. Orice filtru individual sau +opțiuni presetate specificate înainte de opțiunea de lanț complet +(\fB\-\-filters=\fP\fIfiltre\fP) vor fi uitate. Filtrele individuale specificate +după opțiunea „lanț complet” vor reinițializa lanțul de filtre. +.PP +Atât opțiunile de filtrare completă, cât și cele de filtrare individuală +acceptă \fIopțiuni\fP specifice filtrului sub forma unei liste separate prin +virgule. Se ignoră virgulele suplimentare din \fIopțiuni\fP. Fiecare opțiune +are o valoare implicită, deci specificați\-le pe cele pe care doriți să le +modificați. +.PP +Pentru a vedea întregul lanț de filtre și \fIopțiuni\fP, utilizați \fBxz \-vv\fP +(adică folosiți \fB\-\-verbose\fP de două ori). Acest lucru funcționează și +pentru vizualizarea opțiunilor lanțului de filtre utilizate de valorile +prestabilite. +.TP +\fB\-\-filters=\fP\fIfiltre\fP +Specificați întregul lanț de filtre sau o presetare într\-o singură +opțiune. Fiecare filtru poate fi separat prin spații sau două liniuțe +(\fB\-\-\fP). Este posibil să fie necesar ca \fIfiltrele\fP să fie puse între +ghilimele în linia de comandă a shell\-ului pentru a fi analizate ca o +singură opțiune. Pentru a indica \fIopțiuni\fP, utilizați \fB:\fP sau \fB=\fP. O +presetare poate fi prefixată cu un \fB\-\fP și urmată de zero sau mai multe +indicatoare. Singurul indicator suportat este \fBe\fP pentru a aplica aceleași +opțiuni ca și \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIfiltre\fP ... \fB\-\-filters9\fP=\fIfiltre\fP +Specifică până la nouă lanțuri de filtre suplimentare care pot fi utilizate +cu \fB\-\-block\-list\fP. +.IP "" +De exemplu, atunci când se comprimă o arhivă cu fișiere executabile urmate +de fișiere text, partea executabilă ar putea utiliza un lanț de filtre cu un +filtru BCJ, iar partea de text doar filtrul LZMA2. +.TP +\fB\-\-filters\-help\fP +Afișează un mesaj de ajutor care descrie modul de specificare a presetărilor +și a lanțurilor de filtre personalizate în opțiunile \fB\-\-filters\fP și +\fB\-\-filters1=\fP\fIfiltre\fP \&...\& \fB\-\-filters9=\fP\fIfiltre\fP și iese. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIopțiuni\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIopțiuni\fP] +.PD +Adaugă filtrul LZMA1 sau LZMA2 la lanțul de filtre. Aceste filtre pot fi +folosite doar ca ultimul filtru din lanț. +.IP "" +LZMA1 este un filtru vechi, care este acceptat aproape exclusiv datorită +formatului de fișier vechi \fB.lzma\fP, care acceptă numai LZMA1. LZMA2 este o +versiune actualizată a LZMA1 pentru a rezolva unele probleme practice ale +LZMA1. Formatul \fB.xz\fP folosește LZMA2 și nu acceptă deloc LZMA1. Viteza de +comprimare și rapoartele LZMA1 și LZMA2 sunt practic aceleași. +.IP "" +LZMA1 și LZMA2 au același set de \fIopțiuni\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIprestabilit\fP +Reconfigurează toate \fIopțiunile\fP LZMA1 sau LZMA2 la +\fIprestabilit\fP. \fIprestabilit\fP constă dintr\-un număr întreg, care poate fi +urmat de modificatori prestabiliți cu o singură literă. Numărul întreg +poate fi de la \fB0\fP la \fB9\fP, potrivindu\-se cu opțiunile liniei de comandă +\fB\-0\fP \&...\& \fB\-9\fP. Singurul modificator acceptat în prezent este \fBe\fP, +care se potrivește cu \fB\-\-extreme\fP. Dacă nu este specificat \fBprestabilit\fP, +valorile implicite ale \fIopțiunilor\fP LZMA1 sau LZMA2 sunt preluate din +prestabilirea \fB6\fP. +.TP +\fBdict=\fP\fIdimensiunea\fP +\fIDimensiunea\fP dicționarului (istoricul memoriei tampon) indică câți octeți +din datele necomprimate recent procesate sunt păstrați în +memorie. Algoritmul încearcă să găsească secvențe de octeți care se repetă +(potriviri) în datele necomprimate și să le înlocuiască cu referințe la +datele aflate în prezent în dicționar. Cu cât dicționarul este mai mare, cu +atât este mai mare șansa de a găsi o potrivire. Astfel, creșterea +\fIdimensiunii\fP dicționarului îmbunătățește de obicei raportul de comprimare, +dar un dicționar mai mare decât fișierul necomprimat este risipă de memorie. +.IP "" +\fIDimensiunea\fPtipică a dicționarului este de la 64Kio până la 64Mio. Minimul +este de 4Kio. Maximul pentru compresie este în prezent de 1,5Gio +(1536Mio). Decomprimarea acceptă deja dicționare cu până la un octet mai +puțin de 4Gio, care este maximul pentru formatele de flux LZMA1 și LZMA2. +.IP "" +\fIDimensiunea\fP dicționarului și găsitorul de potriviri (match finder) → +(\fImf\fP) determină împreună utilizarea memoriei de către codificatorul LZMA1 +sau LZMA2. Aceeași \fIdimensiune\fP a dicționarului (sau mai mare) care a fost +utilizată la comprimare, este necesară pentru decomprimare, astfel încât +utilizarea memoriei de către decodificator este determinată de dimensiunea +dicționarului utilizată la comprimare. Antetele \fB.xz\fP stochează +\fIdimensiunea\fP dicționarului fie ca 2^\fIn\fP, fie ca 2^\fIn\fP + 2^(\fIn\fP\-1), deci +aceste \fIdimensiuni\fP sunt oarecum preferate pentru comprimare. Alte +\fIdimensiuni\fP vor fi rotunjite atunci când sunt stocate în anteturile +\&\fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Specifică numărul de biți de context literal. Minimul este 0 și maximul este +4; implicit este 3. În plus, suma \fIlc\fP și \fIlp\fP nu trebuie să depășească +4. +.IP "" +Toți octeții care nu pot fi codificați ca potriviri sunt codificați ca +literali. Adică, literalii sunt pur și simplu octeți de 8 biți care sunt +codificați unul câte unul. +.IP "" +Codificarea literală presupune că cei mai mari biți \fIlc\fP ai octetului +anterior necomprimat se corelează cu octetul următor. De exemplu, în textul +tipic englezesc, o literă mare este adesea urmată de o literă mică, iar o +literă mică este urmată de obicei de o altă literă mică. În setul de +caractere US\-ASCII, cei mai mari trei biți sunt 010 pentru literele mari și +011 pentru literele mici. Când \fIlc\fP este cel puțin 3, codificarea literală +poate profita de această proprietate în datele necomprimate. +.IP "" +Valoarea implicită (3) este de obicei bună. Dacă doriți o comprimare maximă, +testați \fBlc=4\fP. Uneori ajută puțin, iar uneori înrăutățește comprimarea +\&. Dacă o agravează, încercați de\-asemeni cu \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Specifică numărul de biți de poziție literală. Minimul este 0 și maximul +este 4; implicit este 0. +.IP "" +\fILp\fP afectează ce fel de aliniere în datele necomprimate este presupusă la +codificarea literalelor. Consultați argumentul \fIpb\fP de mai jos pentru mai +multe informații despre aliniere. +.TP +\fBpb=\fP\fIpb\fP +Specifică numărul de biți de poziție. Minimul este 0 și maximul este 4; +implicit este 2. +.IP "" +\fIPb\fP afectează ce fel de aliniere în datele necomprimate este presupusă în +general. Valoarea implicită înseamnă alinierea pe patru octeți +(2^\fIpb\fP=2^2=4), care este adesea o alegere bună atunci când nu există o +ipoteză mai bună. +.IP "" +Când alinierea este cunoscută, definirea lui \fIpb\fP în mod corespunzător +poate reduce puțin dimensiunea fișierului. De exemplu, cu fișierele text cu +aliniere pe un octet (US\-ASCII, ISO\-8859\-*, UTF\-8), definirea \fBpb=0\fP poate +îmbunătăți ușor comprimarea. Pentru textul UTF\-16, \fBpb=1\fP este o alegere +bună. Dacă alinierea este un număr impar, cum ar fi 3 octeți, \fBpb=0\fP ar +putea fi cea mai bună alegere. +.IP "" +Chiar dacă alinierea presupusă poate fi ajustată cu \fIpb\fP și \fIlp\fP, LZMA1 și +LZMA2 încă favorizează ușor alinierea pe 16 octeți. Ar putea fi demn de luat +în considerare atunci când proiectați formate de fișiere care pot fi adesea +comprimate cu LZMA1 sau LZMA2. +.TP +\fBmf=\fP\fImf\fP +Căutarea potrivirilor are un efect major asupra vitezei codificatorului, +utilizării memoriei și raportului de comprimare. De obicei, găsitorii de +potriviri din lanțul sumelor de control sunt mai rapizi decât găsitorii de +potriviri din arborele binar. Valoarea implicită depinde de \fIprestabilit\fP: +0 folosește \fBhc3\fP, 1\(en3 folosește \fBhc4\fP, iar restul folosește \fBbt4\fP. +.IP "" +Sunt acceptate următoarele opțiuni de căutare de potriviri. Formulele de +utilizare a memoriei de mai jos sunt aproximări estimative, care se apropie +cel mai mult de realitate atunci când \fIdict\fP este o putere a lui doi. +.RS +.TP +\fBhc3\fP +Lanț de sumă de control, cu suma de control de 2 și 3 octeți +.br +Valoarea minimă pentru \fInice\fP: 3 +.br +Utilizarea memoriei: +.br +\fIdict\fP * 7.5 (dacă \fIdict\fP <= 16 Mio); +.br +\fIdict\fP * 5.5 + 64 MiB (dacă \fIdict\fP > 16 Mio) +.TP +\fBhc4\fP +Lanț de sumă de control, cu suma de control de 2, 3 și 4 octeți +.br +Valoarea minimă pentru \fInice\fP: 4 +.br +Utilizarea memoriei: +.br +\fIdict\fP * 7.5 (dacă \fIdict\fP <= 32 Mio); +.br +\fIdict\fP * 6.5 (dacă \fIdict\fP > 32 Mio) +.TP +\fBbt2\fP +Arbore binar cu suma de control de 2 octeți +.br +Valoarea minimă pentru \fInice\fP: 2 +.br +Utilizarea memoriei: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Arbore binar cu suma de control de 2 și 3 octeți +.br +Valoarea minimă pentru \fInice\fP: 3 +.br +Utilizarea memoriei: +.br +\fIdict\fP * 11.5 (dacă \fIdict\fP <= 16 Mio); +.br +\fIdict\fP * 9.5 + 64 MiB (dacă \fIdict\fP > 16 Mio) +.TP +\fBbt4\fP +Arbore binar cu suma de control de 2, 3 și 4 octeți +.br +Valoarea minimă pentru \fInice\fP: 4 +.br +Utilizarea memoriei: +.br +\fIdict\fP * 11.5 (dacă \fIdict\fP <= 32 Mio); +.br +\fIdict\fP * 10.5 (dacă \fIdict\fP > 32 Mio) +.RE +.TP +\fBmode=\fP\fImod\fP +Comprimarea \fImod\fP specifică metoda de analiză a datelor produse de +găsitorul de potriviri. \fIModurile\fP acceptate sunt \fBfast\fP(rapid) și +\fBnormal\fP. Valoarea implicită este \fBfast\fP pentru \fIprestabiliri\fP 0\(en3 și +\fBnormal\fP pentru \fIprestabiliri\fP 4\(en9. +.IP "" +De obicei, \fBfast\fP este folosit cu instrumentele de căutare de potriviri ale +lanțului de sume de control, și \fBnormal\fP cu instrumentele de căutare de +potriviri din arborele binar. Aceasta este și ceea ce fac \fIprestabiririle\fP. +.TP +\fBnice=\fP\fInice\fP +Specifică ceea ce este considerat a fi o lungime bună(nice) pentru o +potrivire. Odată ce este găsită o potrivire de cel puțin \fInice\fP octeți, +algoritmul nu mai caută după potriviri posibile mai bune. +.IP "" +\fINice\fP poate fi de 2\(en273 octeți. Valorile mai mari tind să ofere un +raport de comprimare mai bun în detrimentul vitezei. Valoarea implicită +depinde de \fIprestabilit\fP. +.TP +\fBdepth=\fP\fIadâncimea\fP +Specifică adâncimea maximă de căutare în găsitorul de potriviri. Valoarea +implicită este valoarea specială de 0, ceea ce face ca instrumentul de +comprimare să determine o \fIadâncime\fP rezonabilă pornind de la valorile +\fImf\fP și \fInice\fP. +.IP "" +\fIAdâncimea\fP rezonabilă pentru lanțuri de sumă de control este 4\(en100 și +16\(en1000 pentru arbori binari. Folosirea unor valori foarte mari pentru +\fIadâncime\fP poate face codificatorul extrem de lent cu unele +fișiere. Evitați să stabiliți \fIadâncimea\fP la valori peste 1000, cu excepția +cazului în care sunteți pregătit să întrerupeți comprimarea în cazul în care +durează prea mult. +.RE +.IP "" +La decodificarea fluxurilor brute (\fB\-\-format=raw\fP), LZMA2 are nevoie doar +de \fIdimensiunea\fP dicționarului. LZMA1 are nevoie de asemenea de \fIlc\fP, +\fIlp\fP și \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIopțiuni\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIopțiuni\fP] +.PD +Adaugă un filtru de ramură/apel/salt (branch/call/jump ⟶ „BCJ”) la lanțul de +filtre. Aceste filtre pot fi utilizate numai ca un filtru care nu este +ultimul din lanțul de filtrare. +.IP "" +Un filtru BCJ convertește adresele relative din codul mașinii în omoloagele +lor absolute. Acest lucru nu modifică dimensiunea datelor, dar crește +redundanța, ceea ce poate ajuta LZMA2 să producă fișier \fB.xz\fP cu 0\(en15\ % +mai mic. Filtrele BCJ sunt întotdeauna reversibile, deci folosind un filtru +BCJ pentru tipul greșit de date nu provoacă nicio pierdere de date, deși +poate înrăutăți puțin raportul de comprimare. Filtrele BCJ sunt foarte +rapide și folosesc o cantitate nesemnificativă de memorie. +.IP "" +Aceste filtre BCJ au probleme cunoscute legate de raportul de comprimare: +.RS +.IP \(bu 3 +Unele tipuri de fișiere care conțin cod executabil (de exemplu, fișiere +obiect, biblioteci statice și module de kernel Linux) au adresele din +instrucțiuni completate cu valori de umplere. Aceste filtre BCJ vor face în +continuare conversia adresei, ceea ce va înrăutăți comprimarea cu aceste +fișiere. +.IP \(bu 3 +Dacă pe o arhivă este aplicat un filtru BCJ, este posibil ca raportul de +comprimare să fie mai rău decât la neutilizarea unui filtru BCJ. De exemplu, +dacă există executabile similare sau chiar identice, filtrarea va face +probabil fișierele mai puțin asemănătoare și astfel comprimarea este mai +proastă. Conținutul fișierelor neexecutabile din aceeași arhivă poate conta +și el. În practică, trebuie să încercați cu și fără filtru BCJ pentru a +vedea care rezultat este mai bun în fiecare situație. +.RE +.IP "" +Seturi de instrucțiuni diferite au o aliniere diferită: fișierul executabil +trebuie aliniat la un multiplu al acestei valori în datele de intrare pentru +ca filtrul să funcționeze. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filtru;Aliniere;Note +x86;1;x86 pe 32 de biți +;;sau 64 de biți +ARM;4; +ARM\-Thumb;2; +ARM64;4;alinierea pe 4096\-octeți +;;este cea mai bună +PowerPC;4;Doar big endian +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Deoarece datele filtrate prin BCJ sunt de obicei comprimate cu LZMA2, +raportul de comprimare poate fi ușor îmbunătățit dacă opțiunile LZMA2 sunt +definite pentru a se potrivi cu alinierea filtrului BCJ selectat. Exemple: +.RS +.IP \(bu 3 +Filtrul IA\-64 are o aliniere de 16 octeți, astfel încât \fBpb=4,lp=4,lc=0\fP +este alegere adecvată cu LZMA2 (2^4=16). +.IP \(bu 3 +Codul RISC\-V are o aliniere pe 2 sau 4 octeți, depinzând de faptul că +fișierul conține instrucțiuni comprimate pe 16 biți (extensia C) sau +nu. Atunci când se utilizează instrucțiuni pe 16 biți, \fBpb=2,lp=1,lc=3\fP sau +\fBpb=1,lp=1,lc=3\fP este o alegere bună. Atunci când nu sunt prezente +instrucțiuni pe 16 biți, \fBpb=2,lp=2,lc=2\fP este cea mai bună +alegere. \fBreadelf \-h\fP poate fi utilizată pentru a verifica dacă „RVC” apare +în linia „Indicatori". +.IP \(bu 3 +ARM64 este întotdeauna aliniat pe 4 octeți, astfel încât \fBpb=2,lp=2,lc=2\fP +este cea mai bună alegere. +.IP \(bu 3 +Filtrul x86 este o excepție. De obicei, este bine să rămâneți la valorile +implicite ale LZMA2 (\fBpb=2,lp=0,lc=3\fP) atunci când comprimați executabile +x86. +.RE +.IP "" +Toate filtrele BCJ acceptă același \fIopțiuni\fP: +.RS +.TP +\fBstart=\fP\fIpoziție\fP +Specifică \fIpoziția\fP de pornire care este utilizată la conversia între +adresele relative și absolute. \fIPoziția\fP trebuie să fie un multiplu al +alinierii filtrului (consultați tabelul de mai sus). Valoarea implicită +este zero. În practică, valoarea implicită este bună; specificarea unei +\fIpoziții\fP personalizate nu este aproape niciodată utilă. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIopțiuni\fP] +Adaugă filtrul Delta în lanțul de filtrare. Filtrul Delta poate fi folosit +doar ca un filtru care nu este ultimul în lanțul de filtrare. +.IP "" +În prezent, este acceptat doar calculul delta simplu de octeți. Poate fi +util la comprimarea, de exemplu, a imaginilor bitmap necomprimate sau a +sunetului PCM necomprimat. Cu toate acestea, algoritmii cu scop special pot +da rezultate semnificativ mai bune decât Delta + LZMA2. Acest lucru este +valabil mai ales în cazul audio, care se comprimă mai repede și mai bine, de +exemplu, cu \fBflac\fP(1). +.IP "" +\fIOpțiuni\fP acceptate: +.RS +.TP +\fBdist=\fP\fIdistanța\fP +Specifică \fIdistanța\fP calculului delta în octeți. \fIDistanța\fP trebuie să fie +1\(en256. Valoarea implicită este 1. +.IP "" +De exemplu, cu \fBdist=2\fP și intrare de opt octeți: A1 B1 A2 B3 A3 B5 A4 B7, +ieșirea va fi: A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Alte opțiuni" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Suprimă avertismentele și notificările. Specificați acest lucru de două ori +pentru a suprima și erorile. Această opțiune nu are niciun efect asupra +stării de ieșire. Adică, chiar dacă o avertizare a fost suprimată, starea de +ieșire pentru a indica o avertizare este încă utilizată. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Oferă informații detaliate. Dacă ieșirea de eroare standard este conectată +la un terminal, \fBxz\fP va afișa un indicator de progres. Specificarea +opțiunii \fB\-\-verbose\fP de două ori, va avea ca rezultat oferirea de +informații și mai detaliate. +.IP "" +Indicatorul de progres afișează următoarele informații: +.RS +.IP \(bu 3 +Procentul de completare este afișat dacă se cunoaște dimensiunea fișierului +de intrare. Adică, procentul nu poate fi afișat la procesarea fișierului +prin conducte(pipe). +.IP \(bu 3 +Cantitatea de date comprimate produse (comprimare) sau consumate +(decomprimare). +.IP \(bu 3 +Cantitatea de date necomprimate consumate (comprimare) sau produse +(decomprimare). +.IP \(bu 3 +Raportul de comprimare, care se calculează împărțind cantitatea de date +comprimate procesate până acum la cantitatea de date necomprimate procesate +până acum. +.IP \(bu 3 +Viteza de comprimare sau decomprimare. Aceasta este măsurată drept +cantitatea de date necomprimate consumate (comprimare) sau produse +(decomprimare) pe secundă. Este afișată după ce au trecut câteva secunde de +când \fBxz\fP a început procesarea fișierului. +.IP \(bu 3 +Timpul scurs în format M:SS sau H:MM:SS. +.IP \(bu 3 +Timpul rămas estimat este afișat numai atunci când dimensiunea fișierului de +intrare este cunoscută și au trecut deja câteva secunde de când \fBxz\fP a +început procesarea fișierului. Ora este afișată într\-un format mai puțin +precis, care nu are niciodată două puncte, de exemplu, 2 min 30 s. +.RE +.IP "" +Când ieșirea de eroare standard nu este un terminal, \fB\-\-verbose\fP va face +\fBxz\fP să imprime numele fișierului, dimensiunea comprimată, dimensiunea +necomprimată, raportul de comprimare și, eventual, de asemenea, viteza și +timpul scurs pe o singură linie la ieșirea de eroare standard după +comprimarea sau decomprimarea fișierului. Viteza și timpul scurs sunt +incluse numai atunci când operațiunea a durat cel puțin câteva secunde. Dacă +operațiunea nu s\-a încheiat, de exemplu, din cauza întreruperii din partea +utilizatorului, se imprimă și procentul de completare dacă se cunoaște +dimensiunea fișierului de intrare. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Nu comută starea de ieșire la 2 chiar dacă a fost detectată o condiție care +merită avertizată. Această opțiune nu afectează nivelul de detaliere al +informațiilor, astfel încât atât \fB\-\-quiet\fP cât și \fB\-\-no\-warn\fP trebuie +folosite pentru a nu afișa avertismente și pentru a nu modifica starea de +ieșire. +.TP +\fB\-\-robot\fP +Afișează mesajele într\-un format care poate fi analizat de mașină. Acest +lucru are scopul de a ușura scrierea interfețelor în care se dorește să se +folosească \fBxz\fP în loc de liblzma, ceea ce poate fi cazul cu diferite +scripturi. Ieșirea cu această opțiune activată este menită să fie stabilă în +toate versiunile \fBxz\fP. Consultați secțiunea \fBMOD ROBOT\fP pentru detalii. +.TP +\fB\-\-info\-memory\fP +Afișează, într\-un format care poate fi citit de om, câtă memorie fizică +(RAM) și câte fire de execuție de procesor \fBxz\fP crede că are sistemul și +limitele de utilizare a memoriei pentru comprimare și decomprimare și iese +cu succes. +.TP +\fB\-h\fP, \fB\-\-help\fP +Afișează un mesaj de ajutor care descrie opțiunile cele mai frecvent +utilizate și iese cu succes. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Afișează un mesaj de ajutor care descrie toate caracteristicile \fBxz\fP și +iese cu succes +.TP +\fB\-V\fP, \fB\-\-version\fP +Afișează numărul versiunii \fBxz\fP și liblzma într\-un format care poate fi +citit de om. Pentru a obține rezultate analizabile de mașină, specificați +\fB\-\-robot\fP înainte de \fB\-\-version\fP. +. +.SH "MOD ROBOT" +Modul robot este activat cu opțiunea \fB\-\-robot\fP. Face ieșirea lui \fBxz\fP mai +ușor de analizat de către alte programe. În prezent, opțiunea \fB\-\-robot\fP +este acceptată numai împreună cu opțiunile \fB\-\-list\fP, \fB\-\-filters\-help\fP, +\fB\-\-info\-memory\fP, și \fB\-\-version\fP. Va fi acceptată pentru comprimare și +decomprimare în viitor. +. +.SS "Modul listă" +\fBxz \-\-robot \-\-list\fP utilizează o ieșire separată de tabulatori. Prima +coloană a fiecărei linii are un șir care indică tipul de informații găsite +pe acea linie: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Aceasta este întotdeauna prima linie când începe să se listeze un fișier. A +doua coloană de pe linie este numele fișierului. +.TP +\fBfile\fP +Această linie conține informații generale despre fișierul \fB.xz\fP. Această +linie este întotdeauna tipărită după linia \fBname\fP. +.TP +\fBstream\fP +Acest tip de linie este utilizat numai atunci când a fost specificată +opțiunea \fB\-\-verbose\fP. Există tot atâtea linii \fBstream\fP câte fluxuri există +în fișierul \fB.xz\fP. +.TP +\fBblock\fP +Acest tip de linie este utilizat numai atunci când a fost specificată +opțiunea \fB\-\-verbose\fP. Există tot atâtea linii \fBblock\fP câte blocuri există +în fișierul \fB.xz\fP. Liniile \fBblock\fP sunt afișate după toate liniile +\fBstream\fP; tipurile diferite de linii nu sunt intercalate. +.TP +\fBsummary\fP +Acest tip de linie este folosit numai atunci când opțiunea \fB\-\-verbose\fP a +fost specificată de două ori. Această linie este afișată după toate liniile +\fBblock\fP. Ca și linia \fBfile\fP, linia \fBsummary\fP conține informații generale +despre fișierul \fB.xz\fP. +.TP +\fBtotals\fP +Această linie este întotdeauna ultima linie din lista afișată la +ieșire. Aceasta arată numărul total și dimensiunile. +.PP +Coloanele din liniile \fBfile\fP: +.PD 0 +.RS +.IP 2. 4 +Numărul de fluxuri din fișier +.IP 3. 4 +Numărul total de blocuri din fluxuri +.IP 4. 4 +Dimensiunea comprimată a fișierului +.IP 5. 4 +Dimensiunea necomprimată a fișierului +.IP 6. 4 +Raportul de comprimare, de exemplu, \fB0,123\fP. Dacă raportul este peste +9,999, în locul raportului sunt afișate trei liniuțe (\fB\-\-\-\fP). +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Lista de nume de verificare a integrității, separate prin +virgule. Următoarele șiruri sunt utilizate pentru tipurile de verificare +cunoscute: \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP și \fBSHA\-256\fP. Pentru tipurile de +verificări necunoscute, se utilizează \fBUnknown\-\fP\fIN\fP, unde \fIN\fP este ID\-ul +de verificare ca număr zecimal (una sau două cifre). +.IP 8. 4 +Dimensiunea totală a umpluturii fluxului din fișier +.RE +.PD +.PP +Coloanele din liniile \fBstream\fP: +.PD 0 +.RS +.IP 2. 4 +Numărul fluxului (primul flux este 1) +.IP 3. 4 +Numărul de blocuri din flux +.IP 4. 4 +Poziția de pornire a comprimării +.IP 5. 4 +Poziția de pornire a decomprimării +.IP 6. 4 +Dimensiune comprimată (nu include umplutura fluxului) +.IP 7. 4 +Dimensiune necomprimată +.IP 8. 4 +Raport de comprimare +.IP 9. 4 +Numele verificării de integritate +.IP 10. 4 +Dimensiunea umpluturii fluxului +.RE +.PD +.PP +Coloanele din liniile \fBblock\fP: +.PD 0 +.RS +.IP 2. 4 +Numărul fluxului care conține acest bloc +.IP 3. 4 +Numărul blocului în raport cu începutul fluxului (primul bloc este 1) +.IP 4. 4 +Numărul blocului în raport cu începutul fișierului +.IP 5. 4 +Poziția de pornire a comprimării în raport cu începutul fișierului +.IP 6. 4 +Poziția de pornire necomprimată în raport cu începutul fișierului +.IP 7. 4 +Dimensiunea totală comprimată a blocului (include antetele) +.IP 8. 4 +Dimensiune necomprimată +.IP 9. 4 +Raport de comprimare +.IP 10. 4 +Numele verificării de integritate +.RE +.PD +.PP +Dacă opțiunea \fB\-\-verbose\fP a fost specificată de două ori, coloane +suplimentare sunt incluse pe liniile \fBblock\fP. Acestea nu sunt afișate cu o +singură specificare a opțiunii \fB\-\-verbose\fP, deoarece obținerea acestor +informații necesită multe căutări și, prin urmare, poate fi lentă: +.PD 0 +.RS +.IP 11. 4 +Valoarea verificării integrității în hexazecimal +.IP 12. 4 +Dimensiunea antetului blocului +.IP 13. 4 +Indicatori de bloc: \fBc\fP indică faptul că este prezentă dimensiunea +comprimată, iar \fBu\fP indică faptul că este prezentă dimensiunea +necomprimată. Dacă indicatorul nu este determinat, este afișată o liniuță +(\fB\-\fP) pentru a menține lungimea șirului fixă. Pot fi adăugate noi +indicatoare la sfârșitul șirului, în viitor. +.IP 14. 4 +Dimensiunea datelor comprimate reale din bloc (acest lucru exclude antetul +blocului, umplutura blocului și câmpurile de verificare) +.IP 15. 4 +Cantitatea de memorie (în octeți) necesară pentru a decomprima acest bloc cu +această versiune \fBxz\fP +.IP 16. 4 +Lanț de filtrare. Rețineți că majoritatea opțiunilor utilizate în timpul +comprimării nu pot fi cunoscute, deoarece doar opțiunile necesare pentru +decomprimare sunt stocate în anteturile \fB.xz\fP. +.RE +.PD +.PP +Coloanele din liniile \fBsummary\fP: +.PD 0 +.RS +.IP 2. 4 +Cantitatea de memorie (în octeți) necesară pentru a decomprima acest fișier +cu această versiune \fBxz\fP +.IP 3. 4 +\fByes\fP sau \fBno\fP indicând dacă toate antetele blocurilor au atât dimensiunea +comprimată, cât și dimensiunea necomprimată stocate în ele +.PP +\fIÎncepând cu\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Versiunea \fBxz\fP minimă necesară pentru a decomprima fișierul +.RE +.PD +.PP +Coloanele din linia \fBtotals\fP: +.PD 0 +.RS +.IP 2. 4 +Numărul de fluxuri +.IP 3. 4 +Numărul de blocuri +.IP 4. 4 +Dimensiunea comprimată +.IP 5. 4 +Dimensiune necomprimată +.IP 6. 4 +Raportul mediu de comprimare +.IP 7. 4 +Lista de nume de verificare a integrității, separate prin virgule, care au +fost prezente în fișiere +.IP 8. 4 +Dimensiunea umpluturii fluxului +.IP 9. 4 +Numărul de fișiere. Aceasta este aici pentru a păstra ordinea coloanelor +anterioare la fel ca pe liniile \fBfile\fP. +.PD +.RE +.PP +Dacă opțiunea \fB\-\-verbose\fP a fost specificată de două ori, pe linia +\fBtotals\fP sunt incluse coloane suplimentare: +.PD 0 +.RS +.IP 10. 4 +Cantitatea maximă de memorie (în octeți) necesară pentru a decomprima +fișierele cu această versiune \fBxz\fP +.IP 11. 4 +\fByes\fP sau \fBno\fP indicând dacă toate antetele blocurilor au atât dimensiunea +comprimată, cât și dimensiunea necomprimată stocate în ele +.PP +\fIÎncepând cu\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Versiunea \fBxz\fP minimă necesară pentru a decomprima fișierul +.RE +.PD +.PP +Versiunile viitoare pot adăuga noi tipuri de linii și pot fi adăugate +coloane noi la tipurile de linii existente, dar coloanele existente nu vor +fi modificate. +. +.SS "Ajutor pentru filtrare" +\fBxz \-\-robot \-\-filters\-help\fP afișează filtrele acceptate în următorul +format: +.PP +\fIfiltru\fP\fB:\fP\fIopțiune\fP\fB=<\fP\fIvaloare\fP\fB>,\fP\fIopțiune\fP\fB=<\fP\fIvaloare\fP\fB>\fP... +.TP +\fBfiltru\fP +Numele filtrului +.TP +\fIopțiune\fP +Numele unei opțiuni specifice unui filtru +.TP +\fIvaloare\fP +Intervalele numerice \fIvaloare\fP apar ca +\fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. Alegerile \fIvaloare\fP de tip șir de +caractere sunt afișate în cadrul \fB< >\fP și separate de un caracter +\fB|\fP. +.PP +Fiecare filtru este afișat pe propria linie. +. +.SS "Informații privind limita memoriei" +\fBxz \-\-robot \-\-info\-memory\fP afișează o singură linie cu multiple coloane +separate prin tabulatoare: +.IP 1. 4 +Cantitatea totală de memorie fizică (RAM) în octeți. +.IP 2. 4 +Limita de utilizare a memoriei pentru comprimare în octeți +(\fB\-\-memlimit\-compress\fP). O valoare specială de \fB0\fP indică configurarea +implicită, care pentru modul cu un singur fir este la fel ca fără limită. +.IP 3. 4 +Limita de utilizare a memoriei pentru decomprimare în octeți +(\fB\-\-memlimit\-decompress\fP). O valoare specială de \fB0\fP indică configurarea +implicită, care pentru modul cu un singur fir este la fel ca fără limită. +.IP 4. 4 +Începând cu \fBxz\fP 5.3.4alpha: Utilizarea memoriei pentru decomprimarea cu +mai multe fire în octeți (\fB\-\-memlimit\-mt\-decompress\fP). Acesta nu este +niciodată zero, deoarece o valoare implicită specifică sistemului afișată în +coloana 5 este utilizată dacă nu a fost specificată în mod explicit nicio +limită. De asemenea, aceasta nu este niciodată mai mare decât valoarea din +coloana 3, chiar dacă a fost specificată o valoare mai mare cu +\fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Începând cu \fBxz\fP 5.3.4alpha: o limită implicită de utilizare a memoriei +specifică sistemului, care este utilizată pentru a limita numărul de fire de +execuție atunci când se comprimă cu un număr automat de fire de execuție +(\fB\-\-threads=0\fP) și nicio limită de utilizare a memoriei nu fost specificată +cu (\fB\-\-memlimit\-compress\fP). Aceasta este, de asemenea, utilizată ca valoare +implicită pentru \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Începând cu \fBxz\fP 5.3.4alpha: numărul de fire de execuție de procesor +disponibile. +.PP +În viitor, rezultatul \fBxz \-\-robot \-\-info\-memory\fP poate avea mai multe +coloane, dar niciodată mai mult de o singură linie. +. +.SS Versiunea +\fBxz \-\-robot \-\-version\fP va afișa numărul versiunii \fBxz\fP și liblzma în +următorul format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Versiunea majoră. +.TP +\fIYYY\fP +Versiunea minoră. Numerele pare sunt prezente în versiunile +stabile. Numerele impare sunt prezente în versiunile alfa sau beta. +.TP +\fIZZZ\fP +Nivelul de plasture(patch) pentru versiunile stabile sau doar un contor +pentru versiunile de dezvoltare. +.TP +\fIS\fP +Stabilitate. 0 este alfa, 1 este beta și 2 este stabil. \fIS\fP trebuie să fie +întotdeauna 2 atunci când \fIAAA\fP este par. +.PP +\fIXYYYZZZS\fP sunt aceleași pe ambele linii dacă \fBxz\fP și liblzma sunt din +aceeași versiune XZ Utils. +.PP +Exemple: 4.999.9beta este \fB49990091\fP și 5.0.0 este \fB50000002\fP. +. +.SH "STARE DE IEȘIRE" +.TP +\fB0\fP +Totul este bine. +.TP +\fB1\fP +A apărut o eroare. +.TP +\fB2\fP +A apărut ceva care merită să fie avertizat, dar nu au apărut erori reale. +.PP +Notificările (nu avertismentele sau erorile) afișate la ieșirea de eroare +standard nu afectează starea de ieșire. +. +.SH "VARIABILE DE MEDIU" +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP analizează liste de opțiuni separate prin spații din variabilele de +mediu \fBXZ_DEFAULTS\fP și \fBXZ_OPT\fP, în această ordine, înainte de a analiza +opțiunile din linia de comandă. Rețineți că numai opțiunile sunt analizate +din variabilele de mediu; toate non\-opțiunile sunt ignorate în +tăcere. Analiza se face cu funcția \fBgetopt_long\fP(3) care este folosită și +pentru argumentele liniei de comandă. +.PP +\fBAvertisment:\fP Prin definirea acestor variabile de mediu, se modifică +efectiv programele și scripturile care rulează \fBxz\fP. De cele mai multe ori +este sigur să se definească limitele de utilizare a memoriei, numărul de +fire și opțiunile de comprimare prin intermediul variabilelor de mediu. Cu +toate acestea, unele opțiuni pot întrerupe scripturile. Un exemplu evident +este \fB\-\-help\fP care face ca \fBxz\fP să afișeze textul de ajutor în loc să +comprime sau să decomprime un fișier. Exemple mai subtile sunt \fB\-\-quiet\fP și +\fB\-\-verbose\fP. În multe cazuri funcționează bine activarea indicatorului de +progres folosind \fB\-\-verbose\fP, dar în unele situații mesajele suplimentare +creează probleme. Nivelul de detaliere al mesajelor afectează, de asemenea, +comportamentul lui \fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Opțiuni implicite specifice utilizatorului sau la nivelul întregului +sistem. De obicei, acest lucru este specificat într\-un script de +inițializare shell pentru a activa limitatorul de utilizare a memoriei lui +\fBxz\fP implicit sau pentru a stabili numărul implicit de fire. Excluzând +scripturile de inițializare shell și cazurile speciale similare, scripturile +nu trebuie niciodată să modifice sau să dezactiveze \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Acest lucru este pentru transmiterea opțiunilor către \fBxz\fP atunci când nu +este posibil să definiți opțiunile direct în linia de comandă a +\fBxz\fP. Acesta este cazul când \fBxz\fP este rulat de un script sau de un +instrument, de exemplu, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Scripturile pot folosi \fBXZ_OPT\fP, de exemplu, pentru a configura opțiunile +implicite de comprimare specifice scriptului. Se recomandă totuși să se +permită utilizatorilor să înlocuiască \fBXZ_OPT\fP dacă acest lucru este +rezonabil. De exemplu, în scripturile \fBsh\fP(1) se poate folosi ceva de genul +acesta: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "COMPATIBILITATE CU LZMA\-UTILS" +Sintaxa liniei de comandă a lui \fBxz\fP este practic o super\-colecție de +\fBlzma\fP, \fBunlzma\fP și \fBlzcat\fP așa cum se găsește în LZMA Utils 4.32.x. În +cele mai multe cazuri, este posibil să înlocuiți LZMA Utils cu XZ Utils fără +a întrerupe scripturile existente. Există totuși unele incompatibilități, +care uneori pot cauza probleme. +. +.SS "Niveluri de comprimare prestabilite" +Numerotarea nivelurilor de comprimare prestabilite nu este identică în \fBxz\fP +și LZMA Utils. Cea mai importantă diferență este modul în care dimensiunile +dicționarului sunt atribuite diferitelor niveluri prestabilite. Dimensiunea +dicționarului este aproximativ egală cu memoria utilizată la decomprimare. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nivel;xz;LZMA Utils +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Diferențele de dimensiune a dicționarului afectează deasemenea cantitatea de +memorie utilizată la comprimare dar există și alte diferențe între LZMA +Utils și XZ Utils, care fac diferența și mai mare: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nivel;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Nivelul prestabilit implicit în LZMA Utils este \fB\-7\fP, în timp ce în XZ +Utils este \fB\-6\fP, deci ambele folosesc un dicționar de 8Mio în mod implicit. +. +.SS "Fișiere .lzma transmise în flux vs. netransmise în flux" +Dimensiunea necomprimată a fișierului poate fi stocată în antetul +\&\fB.lzma\fP. LZMA Utils face asta atunci când comprimă fișiere +obișnuite. Alternativa este să marcați că dimensiunea necomprimată este +necunoscută și să folosiți marcajul de sfârșit de încărcare pentru a indica +unde ar trebui să se oprească decomprimarea. LZMA Utils folosește această +metodă atunci când dimensiunea necomprimată nu este cunoscută, ceea ce este +cazul, de exemplu, când se folosesc conducte. +.PP +\fBxz\fP acceptă decomprimarea fișierelor \fB.lzma\fP cu sau fără marcaj de +sfârșit de încărcare, dar toate fișierele \fB.lzma\fP create de \fBxz\fP vor +folosi marcajul de sfârșit de încărcare și vor avea dimensiunea necomprimată +marcată ca necunoscută în antetul \fB.lzma\fP. Aceasta poate fi o problemă în +unele situații mai puțin frecvente. De exemplu, un instrument de +decomprimare \fB.lzma\fP încorporat într\-un dispozitiv poate funcționa numai cu +fișiere care au dimensiunea necomprimată cunoscută. Dacă întâmpinați această +problemă, trebuie să utilizați LZMA Utils sau LZMA SDK pentru a crea fișiere +\&\fB.lzma\fP cu dimensiunea necomprimată cunoscută. +. +.SS "Fișiere .lzma neacceptate" +Formatul \fB.lzma\fP permite valori \fIlc\fP de până la 8 și valori \fIlp\fP de până +la 4. LZMA Utils poate decomprima fișiere cu orice \fIlc\fP și \fIlp\fP, dar +creează întotdeauna fișiere cu \fBlc=3\fP și \fBlp=0\fP. Crearea de fișiere cu +alte \fIlc\fP și \fIlp\fP este posibilă cu \fBxz\fP și cu LZMA SDK. +.PP +Implementarea filtrului LZMA1 în liblzma necesită ca suma \fIlc\fP și \fIlp\fP să +nu depășească 4. Altfel, fișierele \fB.lzma\fP, care depășesc această limitare, +nu pot fi decomprimate cu \fBxz\fP. +.PP +LZMA Utils creează numai fișiere \fB.lzma\fP care au o dimensiune de dicționar +de 2^\fIn\fP (o putere de 2), dar acceptă fișiere cu orice dimensiune de +dicționar. liblzma acceptă numai fișierele \fB.lzma\fP care au dimensiunea de +dicționar de 2^\fIn\fP sau 2^\fIn\fP + 2^(\fIn\fP\-1). Acest lucru este pentru a +reduce numărul de „fals pozitiv” atunci când se detectează fișiere \fB.lzma\fP. +.PP +Aceste limitări nu ar trebui să fie o problemă în practică, deoarece practic +toate fișierele \fB.lzma\fP au fost comprimate cu opțiuni pe care liblzma le va +accepta. +. +.SS "Resturi rămase" +Când decomprimă, LZMA Utils ignoră în tăcere totul după primul flux +\&\fB.lzma\fP. În majoritatea situațiilor, aceasta este o eroare. Aceasta +înseamnă, de asemenea, că LZMA Utils nu acceptă decomprimarea fișierelor +\&\fB.lzma\fP concatenate. +.PP +Dacă au rămas date după primul flux \fB.lzma\fP, \fBxz\fP consideră că fișierul +este corupt, cu excepția cazului în care a fost utilizată opțiunea +\fB\-\-single\-stream\fP. Acest lucru poate rupe scripturile obscure(scrise +deficitar) care presupun că resturile rămase sunt ignorate. +. +.SH NOTE +. +.SS "Rezultatul comprimării poate varia" +Ieșirea exactă comprimată produsă din același fișier de intrare necomprimat +poate varia între versiunile XZ Utils, chiar dacă opțiunile de comprimare +sunt identice. Acest lucru se datorează faptului că instrumentul codificator +poate fi îmbunătățit (comprimare mai rapidă sau mai bună) fără a afecta +formatul fișierului. Ieșirea poate varia chiar și între compilările diferite +ale aceleiași versiuni XZ Utils, dacă sunt utilizate opțiuni diferite de +compilare. +.PP +Cele de mai sus înseamnă că odată ce opțiunea \fB\-\-rsyncable\fP a fost +utilizată, fișierele rezultate nu vor fi neapărat sincronizate cu rsync +decât dacă atât fișierele vechi, cât și cele noi au fost comprimate cu +aceeași versiune xz. Această problemă poate fi remediată dacă o parte a +implementării codificatorului este înghețată pentru a menține stabilă +ieșirea „rsyncabilă” între versiunile xz. +. +.SS "Instrumente de decomprimare .xz încorporate" +Implementările instrumentului de decomprimare \fB.xz\fP încorporat, cum ar fi +XZ Embedded, nu acceptă neapărat fișiere create cu tipuri de \fIverificare\fP a +integrității, altele decât \fBnone\fP și \fBcrc32\fP. Deoarece valoarea implicită +este \fB\-\-check=crc64\fP, trebuie să utilizați \fB\-\-check=none\fP sau +\fB\-\-check=crc32\fP atunci când creați fișiere pentru sistemele încorporate. +.PP +În afara sistemelor încorporate, toate instrumentele de decomprimare în +format \fB.xz\fP acceptă toate tipurile de \fIverificare\fP sau cel puțin pot +decomprima fișierul fără a efectua verificarea integrității dacă acel tip de +\fIverificare\fP nu este acceptat. +.PP +XZ Embedded acceptă filtre BCJ, dar numai cu poziție de pornire implicită. +. +.SH EXEMPLE +. +.SS Bazice +Comprimă fișierul \fIfoo\fP în \fIfoo.xz\fP folosind nivelul de comprimare +implicit (\fB\-6\fP) și elimină fișierul \fIfoo\fP dacă comprimarea are succes: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Decomprimă \fIbar.xz\fP în \fIbar\fP și nu elimină \fIbar.xz\fP chiar dacă +decomprimarea este efectuată cu succes: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Creează \fIbaz.tar.xz\fP cu nivelul prestabilit \fB\-4e\fP (\fB\-4 \-\-extreme\fP), care +este mai lent decât nivelul prestabilit implicit \fB\-6\fP, dar necesită mai +puțină memorie pentru comprimare și decomprimare (48Mio și, respectiv, +5Mio): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Un amestec de fișiere comprimate și necomprimate poate fi decomprimat la +ieșirea standard cu o singură comandă: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Comprimarea în paralel a mai multor fișiere" +În sisteme GNU și *BSD, \fBfind\fP(1) și \fBxargs\fP(1) pot fi utilizate pentru a +paraleliza comprimarea mai multor fișiere: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Opțiunea \fB\-P\fP pentru comanda \fBxargs\fP(1) stabilește numărul de procese +paralele \fBxz\fP. Cea mai bună valoare pentru opțiunea \fB\-n\fP depinde de câte +fișiere trebuie să fie comprimate. Dacă există doar câteva fișiere, valoarea +ar trebui probabil să fie 1; cu zeci de mii de fișiere, 100 sau chiar mai +mult poate să fie valoarea potrivită pentru a reduce numărul de procese +\fBxz\fP pe care \fBxargs\fP(1) le va crea în final. +.PP +Opțiunea \fB\-T1\fP pentru \fBxz\fP este acolo pentru a\-l forța să ruleze în modul +cu un singur fir de execuție, deoarece \fBxargs\fP(1) este folosit pentru a +controla cantitatea de paralelizare. +. +.SS "Modul robot" +Calculează câți octeți au fost salvați în total după comprimarea mai multor +fișiere: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Un script poate dori să afle dacă folosește o versiune \fBxz\fP suficient de +nouă. Următorul script \fBsh\fP(1) verifică dacă numărul versiunii +instrumentului \fBxz\fP este cel puțin 5.0.0. Această metodă este compatibilă +cu versiunile beta vechi, care nu acceptau opțiunea \fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Versiunea dumneavoastră de „xz” este prea veche!" +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Stabilește o limită de utilizare a memoriei pentru decomprimare folosind +variabila de mediu \fBXZ_OPT\fP, dar dacă o limită a fost deja stabilită, nu o +mărește: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Lanțuri de filtrare personalizate pentru instrumentul de comprimare" +Cea mai simplă utilizare a lanțurilor de filtrare personalizate este +personalizarea unei opțiuni prestabilite LZMA2. Acest lucru poate fi util, +deoarece opțiunile prestabilite acoperă doar un subset al combinațiilor +potențial utile de opțiuni de comprimare. +.PP +Coloanele CPUComp din tabelele de descriere a opțiunilor \fB\-0\fP ... \fB\-9\fP și +\fB\-\-extreme\fP sunt utile atunci când personalizați opțiunilor prestabilite +LZMA2. Iată părțile relevante colectate din aceste două tabele: +.RS +.PP +.TS +tab(;); +c c +n n. +ValPrestab;CPUComp +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Dacă știți că un fișier necesită un dicționar oarecum mare (de exemplu, +32Mio) pentru a se comprima bine, dar doriți să\-l comprimați mai repede +decât ar face \fBxz \-8\fP, o opțiune prestabilită cu o valoare CPUComp scăzută +(de exemplu, 1) poate fi modificată pentru a utiliza un dicționar mai mare: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Cu anumite fișiere, comanda de mai sus poate fi mai rapidă decât \fBxz \-6\fP în +timp ce comprimă semnificativ mai bine. Cu toate acestea, trebuie subliniat +că doar unele fișiere se beneficiază de un dicționar mare, păstrând în +același timp valoarea CPUComp scăzută. Cea mai evidentă situație, în care un +dicționar mare poate ajuta foarte mult, este o arhivă care conține fișiere +foarte asemănătoare de cel puțin câțiva megaocteți fiecare. Dimensiunea +dicționarului trebuie să fie semnificativ mai mare decât orice fișier +individual pentru a permite LZMA2 să profite din plin de asemănările dintre +fișierele consecutive. +.PP +Dacă utilizarea unei mari cantități de memorie pentru comprimare și +decomprimare este în regulă, iar fișierul comprimat are cel puțin câteva +sute de megaocteți, poate fi util să folosiți un dicționar și mai mare decât +cei 64Mio pe care i\-ar folosi \fBxz \-9\fP: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Utilizarea opțiunii \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) ca în exemplul de mai +sus, poate fi utilă pentru a vedea cerințele de memorie la comprimare și +decomprimare. Amintiți\-vă că utilizarea unui dicționar mai mare decât +dimensiunea fișierului necomprimat este risipă de memorie, de aceea, comanda +de mai sus nu este utilă pentru fișiere mici. +.PP +Uneori, timpul de comprimare nu contează, dar utilizarea memoriei la +decomprimare trebuie menținută la un nivel scăzut, de exemplu, pentru a face +posibilă decomprimarea fișierului pe un sistem încorporat. Următoarea +comandă folosește \fB\-6e\fP (\fB\-6 \-\-extreme\fP) ca bază și fixează dimensiunea +dicționarului la doar 64Kio. Fișierul rezultat poate fi decomprimat cu XZ +Embedded (de aceea există \fB\-\-check=crc32\fP) folosind aproximativ 100Kio de +memorie. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Dacă doriți să stoarceți cât mai mulți octeți posibil, ajustarea numărului +de biți de context literal (\fIlc\fP) și a numărului de biți de poziție (\fIpb\fP) +poate ajuta uneori. Ajustarea numărului de biți de poziție literală (\fIlp\fP) +ar putea ajuta, de asemenea, dar de obicei \fIlc\fP și \fIpb\fP sunt mai +importante. De exemplu, o arhivă de cod sursă conține în mare parte text +US\-ASCII, așa că ceva precum comanda următoare, ar putea oferi un fișier +„mai slăbuț” (aproximativ cu 0,1%) mai mic decât cu \fBxz \-6e\fP (încercați și +fără \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 fișierul_sursă.tar\fR +.fi +.RE +.PP +Utilizarea unui alt filtru împreună cu LZMA2 poate îmbunătăți comprimarea cu +anumite tipuri de fișiere. De exemplu, pentru a comprima o bibliotecă +partajată x86 pe 32 de biți sau x86 pe 64 de biți folosind filtrul BCJ x86: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Rețineți că ordinea opțiunilor de filtrare este semnificativă. Dacă \fB\-\-x86\fP +este specificată după \fB\-\-lzma2\fP, \fBxz\fP va da o eroare, deoarece nu poate +exista niciun filtru după LZMA2 și, de asemenea, pentru că filtrul x86 BCJ +nu poate fi utilizat ca ultimul filtru din lanțul de filtrare. +.PP +Filtrul Delta împreună cu LZMA2 pot da rezultate bune cu imagini bitmap. De +obicei, ar trebui să întreacă comprimarea PNG, care are câteva filtre mai +avansate decât delta simplă, dar utilizează Deflate pentru comprimarea +reală. +.PP +Imaginea trebuie să fie salvată în format necomprimat, de exemplu, ca TIFF +necomprimat. Parametrul de distanță al filtrului Delta este fixat să se +potrivească cu numărul de octeți per pixel din imagine. De exemplu, +bitmap\-ul RGB pe 24 de biți necesită \fBdist=3\fP și este, de asemenea, bine să +pasați \fBpb=0\fP la LZMA2 pentru a se adapta alinierii pe trei octeți: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Dacă mai multe imagini au fost introduse într\-o singură arhivă (de exemplu, +\&\fB.tar\fP), filtrul Delta va funcționa și pe aceasta atâta timp cât toate +imaginile au același număr de octeți per pixel. +. +.SH "CONSULTAȚI ȘI" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xzcat.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xzcat.1 new file mode 100644 index 0000000000000000000000000000000000000000..1555445592944b4f24e548fc0dc0b1c3af876030 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xzcat.1 @@ -0,0 +1,2111 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Romanian translation for xz-man. +.\" Mesajele în limba română pentru manualul pachetului XZ Utils. +.\" Remus-Gabriel Chelu , 2022 - 2025. +.\" Cronologia traducerii fișierului „xz-man”: +.\" Traducerea inițială, făcută de R-GC, pentru versiunea xz-man 5.4.0-pre1. +.\" Actualizare a traducerii pentru versiunea 5.4.0-pre2, făcută de R-GC, dec-2022. +.\" Actualizare a traducerii pentru versiunea 5.4.3, făcută de R-GC, mai-2023. +.\" Actualizare a traducerii pentru versiunea 5.4.4-pre1, făcută de R-GC, iul-2023. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre1, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre2, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.7.1-dev1, făcută de R-GC, ian-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.0-pre1, făcută de R-GC, mar-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.2-pre1, făcută de R-GC, oct-2025. +.\" Actualizare a traducerii pentru versiunea Y, făcută de X, Z(luna-anul). +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 "8 martie 2025" Tukaani "Utilități XZ" +. +.SH NUME +xz, unxz, xzcat, lzma, unlzma, lzcat \- Comprimă sau decomprimă fișiere .xz +și .lzma +. +.SH REZUMAT +\fBxz\fP [\fIopțiune...\fP] [\fIfișier...\fP] +. +.SH "ALIAS COMENZI" +\fBunxz\fP este echivalent cu \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP este echivalent cu \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP este echivalent cu \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP este echivalent cu \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP este echivalent cu \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Când scrieți scripturi care trebuie să decomprime fișiere, este recomandat +să folosiți întotdeauna comanda \fBxz\fP cu argumentele adecvate (\fBxz \-d\fP sau +\fBxz \-dc\fP) în loc de comenzile \fBunxz\fP și \fBxzcat\fP. +. +.SH DESCRIERE +\fBxz\fP este un instrument de comprimare a datelor de uz general cu sintaxă de +linie de comandă similară cu \fBgzip\fP(1) și \fBbzip2\fP(1). Formatul de fișier +nativ este formatul \fB.xz\fP, dar formatul vechi \fB.lzma\fP folosit de LZMA +Utils și fluxurile comprimate brute fără anteturi de format container sunt +de asemenea acceptate. În plus, este acceptată decomprimarea formatului +\&\fB.lz\fP folosit de \fBlzip\fP. +.PP +\fBxz\fP comprimă sau decomprimă fiecare \fIfișier\fP în funcție de modul de +operare selectat. Dacă nu sunt date \fIfișiere\fP sau \fIfișier\fP este \fB\-\fP, +\fBxz\fP citește de la intrarea standard și scrie datele procesate la ieșirea +standard. \fBxz\fP va refuza (afișează o eroare și omite \fIfișier\fP) să scrie +date comprimate la ieșirea standard dacă este un terminal. În mod similar, +\fBxz\fP va refuza să citească datele comprimate de la intrarea standard dacă +este un terminal. +.PP +Cu excepția cazului în care este specificată opțiunea \fB\-\-stdout\fP, +\fIfișierele\fP altele decât \fB\-\fP sunt scrise într\-un fișier nou al cărui nume +este derivat din numele \fIfișierului\fP sursă: +.IP \(bu 3 +La comprimare, sufixul formatului de fișier țintă (\fB.xz\fP sau \fB.lzma\fP) este +atașat la numele fișierului sursă pentru a se obține numele fișierului +țintă. +.IP \(bu 3 +La decomprimare, sufixul \fB.xz\fP, \fB.lzma\fP sau \fB.lz\fP este eliminat din +numele fișierului pentru a se obține numele fișierului țintă. \fBxz\fP +recunoaște și sufixele \fB.txz\fP și \fB.tlz\fP și le înlocuiește cu sufixul +\&\fB.tar\fP. +.PP +Dacă fișierul țintă există deja, este afișată o eroare și \fIfișier\fP este +omis. +.PP +Cu excepția cazului în care scrie la ieșirea standard, \fBxz\fP va afișa un +avertisment și va omite \fIfișier\fPul dacă se aplică oricare dintre +următoarele: +.IP \(bu 3 +\fIFișierul\fP nu este un fișier obișnuit. Legăturile simbolice nu sunt urmate +și, prin urmare, nu sunt considerate fișiere obișnuite. +.IP \(bu 3 +\fIFișierul\fP are mai mult de o legătură dură. +.IP \(bu 3 +\fIFișierul\fP are activat bitul «setuid», «setgid» sau cel lipicios(sticky). +.IP \(bu 3 +Modul de operare este stabilit la comprimare și \fIfișier\fP are deja un sufix +al formatului de fișier țintă (\fB.xz\fP sau \fB.txz\fP când se comprimă în +formatul \fB.xz\fP și \fB.lzma\fP sau \fB.tlz\fP când se comprimă în formatul +\&\fB.lzma\fP). +.IP \(bu 3 +Modul de operare este stabilit la decomprimare și \fIfișierul\fP nu are un +sufix al niciunui format de fișier acceptat (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, +\&\fB.tlz\fP, sau \fB.lz\fP). +.PP +După comprimarea sau decomprimarea cu succes a \fIfișierului\fP, \fBxz\fP copiază +proprietarul, grupul, permisiunile, timpul de acces și timpul de modificare +din \fIfișierul\fP sursă în fișierul țintă. Dacă copierea grupului eșuează, +permisiunile sunt modificate astfel încât fișierul țintă să nu devină +accesibil utilizatorilor care nu aveau permisiunea de a accesa \fIfișierul\fP +sursă. \fBxz\fP nu acceptă încă copierea altor metadate, cum ar fi listele de +control al accesului sau atributele extinse. +.PP +Odată ce fișierul țintă a fost închis cu succes, \fIfișierul\fP sursă este +eliminat dacă nu a fost specificată opțiunea \fB\-\-keep\fP. \fIFișierul\fP sursă nu +este niciodată eliminat dacă rezultatul este scris la ieșirea standard sau +dacă apare o eroare. +.PP +Trimiterea unui semnal \fBSIGINFO\fP sau \fBSIGUSR1\fP către procesul \fBxz\fP face +ca acesta să imprime informații despre progres la ieșirea de eroare +standard. Acest lucru are o utilizare limitată, deoarece atunci când ieșirea +de eroare standard este un terminal, folosind opțiunea \fB\-\-verbose\fP va afișa +un indicator de progres de actualizare automată. +. +.SS "Utilizarea memoriei" +Cantitatea de memorie utilizată de \fBxz\fP variază de la câteva sute de +kiloocteți la câțiva gigaocteți, în funcție de opțiunile de +comprimare. Opțiunile utilizate la comprimarea unui fișier determină +cerințele de memorie ale instrumentului de decomprimare. De obicei, +instrumentul de decomprimare are nevoie de 5% până la 20% din cantitatea de +memorie de care a avut nevoie instrumentul de comprimare la crearea +fișierului. De exemplu, decomprimarea unui fișier creat cu \fBxz \-9\fP necesită +în prezent 65Mio de memorie. Totuși, este posibil să aveți fișiere \fB.xz\fP +care necesită câțiva gigaocteți de memorie pentru decomprimare. +.PP +În special utilizatorii de sisteme mai vechi pot considera deranjantă +posibilitatea unei utilizări foarte mari a memoriei. Pentru a preveni +surprizele neplăcute, \fBxz\fP are încorporat un limitator de utilizare a +memoriei, care este dezactivat implicit. În timp ce unele sisteme de operare +oferă modalități de a limita utilizarea memoriei proceselor, bazarea pe +aceasta nu a fost considerată a fi suficient de flexibilă (de exemplu, +utilizarea \fBulimit\fP(1) pentru a limita memoria virtuală tinde să paralizeze +\fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Limitatorul de utilizare a memoriei poate fi activat cu opțiunea din linia +de comandă \fB\-\-memlimit=\fP\fIlimita\fP. Adesea este mai convenabil să activați +limitatorul în mod implicit prin definirea variabilei de mediu +\fBXZ_DEFAULTS\fP, de exemplu, \fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Este posibil +să stabiliți limitele separat pentru comprimare și decomprimare folosind +\fB\-\-memlimit\-compress=\fP\fIlimita\fP și +\fB\-\-memlimit\-decompress=\fP\fIlimita\fP. Utilizarea acestor două opțiuni în afara +\fBXZ_DEFAULTS\fP este foarte rar utilă, deoarece o singură rulare a \fBxz\fP nu +poate face atât comprimarea, cât și decomprimarea și \fB\-\-memlimit=\fP\fIlimita\fP +(sau \fB\-M\fP \fIlimita\fP ) este mai scurt de tastat pe linia de comandă. +.PP +Dacă limita de utilizare a memoriei specificată este depășită la +decomprimare, \fBxz\fP va afișa o eroare și decomprimarea fișierului va +eșua. Dacă limita este depășită la comprimare, \fBxz\fP va încerca să reducă +valorile stabilite astfel încât limita să nu mai fie depășită (cu excepția +cazului în care se utilizează opțiunea \fB\-\-format=raw\fP sau +\fB\-\-no\-adjust\fP). În acest fel, operațiunea nu va eșua decât dacă limita +stabilită este foarte mică. Scalarea valorilor stabilite se face în pași +care nu se potrivesc cu valorile prestabilite ale nivelului de comprimare, +de exemplu, dacă limita este doar puțin mai mică decât cantitatea necesară +pentru \fBxz \-9\fP, valorile stabilite vor fi reduse doar puțin , nu până la +valoarea prestabilită a lui \fBxz \-8\fP. +. +.SS "Concatenare și completare (prin umplere cu octeți nuli) cu fișiere .xz" +Este posibil să concatenați fișierele \fB.xz\fP așa cum sunt. \fBxz\fP va +decomprima astfel de fișiere ca și cum ar fi un singur fișier \fB.xz\fP. +.PP +Este posibil să se introducă umplutură între părțile concatenate sau după +ultima parte. Umplutura trebuie să fie compusă din octeți nuli, iar +dimensiunea umpluturii trebuie să fie un multiplu de patru octeți. Acest +lucru poate fi util, de exemplu, dacă fișierul \fB.xz\fP este stocat pe un +mediu care măsoară dimensiunile fișierelor în blocuri de 512 de octeți. +.PP +Concatenarea și completarea nu sunt permise cu fișierele \fB.lzma\fP sau +fluxurile brute. +. +.SH OPȚIUNI +. +.SS "Sufixe de numere întregi și valori speciale" +În majoritatea locurilor în care este de așteptat un număr întreg ca +argument, un sufix opțional este acceptat pentru a indica cu ușurință +numerele întregi mari. Nu trebuie să existe spațiu între numărul întreg și +sufix. +.TP +\fBKiB\fP +Înmulțește numărul întreg cu 1.024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP și +\fBKB\fP sunt acceptate ca sinonime pentru \fBKiB\fP. +.TP +\fBMiB\fP +Înmulțește numărul întreg cu 1,048,576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP, și \fBMB\fP +sunt acceptate ca sinonime pentru \fBMiB\fP. +.TP +\fBGiB\fP +Înmulțește numărul întreg cu 1,073,741,824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP, și +\fBGB\fP sunt acceptate ca sinonime pentru \fBGiB\fP. +.PP +Valoarea specială \fBmax\fP poate fi utilizată pentru a indica valoarea maximă +întreagă suportată de opțiune. +. +.SS "Mod de operare" +Dacă sunt date mai multe opțiuni de mod de funcționare, ultima dintre ele, +este cea care va avea efect. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Comprimare. Acesta este modul de operare implicit atunci când nu este +specificată nicio opțiune de mod de funcționare și nici un alt mod de +operare nu este implicat din numele comenzii (de exemplu, \fBunxz\fP implică +\fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +După o comprimare reușită, fișierul sursă este eliminat, cu excepția cazului +în care a fost specificată scrierea la ieșirea standard sau opțiunea +\fB\-\-keep\fP. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Decomprimare. După o decomprimare reușită, fișierul sursă este eliminat, cu +excepția cazului în care a fost specificată scrierea la ieșirea standard sau +opțiunea \fB\-\-keep\fP. +.TP +\fB\-t\fP, \fB\-\-test\fP +Testează integritatea \fIfișierelor\fP comprimate. Această opțiune este +echivalentă cu \fB\-\-decompress \-\-stdout\fP cu excepția faptului că datele +decomprimate sunt înlăturate în loc să fie scrise la ieșirea standard. Nu +sunt create sau eliminate fișiere. +.TP +\fB\-l\fP, \fB\-\-list\fP +Afișează informații despre \fIfișiere\fP comprimate. Nu are loc nicio +decomprimare la ieșire și nu sunt create sau eliminate fișiere. În modul +listă, programul nu poate citi datele comprimate din intrarea standard sau +din alte surse care nu pot fi explorate. +.IP "" +Listarea implicită arată informații de bază despre \fIfișiere\fP, câte un +fișier pe linie. Pentru a obține informații mai detaliate, utilizați și +opțiunea \fB\-\-verbose\fP. Pentru și mai multe informații, utilizați opțiunea +\fB\-\-verbose\fP de două ori, dar rețineți că acest lucru poate fi lent, +deoarece obținerea tuturor informațiilor suplimentare necesită multe +căutări. Lățimea ieșirii detaliate depășește 80 de caractere, deci +canalizarea ieșirii către, de exemplu, \fBless\ \-S\fP poate fi convenabilă dacă +terminalul nu este suficient de lat. +.IP "" +Ieșirea exactă poate varia între versiunile \fBxz\fP și diferitele +localizări(configurările regionale). Pentru ieșiri care pot fi citite de +mașină, ar trebui utilizată opțiunea \fB\-\-robot \-\-list\fP. +. +.SS "Modificatori de operare" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Nu șterge fișierele de intrare. +.IP "" +Începând cu \fBxz\fP 5.2.6, această opțiune face ca \fBxz\fP să comprime sau să +decomprime, chiar dacă intrarea este o legătură simbolică către un fișier +obișnuit, are mai mult de\-o legătură dură sau are marcați biții setuid, +setgid sau bitul lipicios. Biții setuid, setgid și bitul lipicios nu sunt +copiați în fișierul țintă. În versiunile anterioare acest lucru se făcea +numai cu ajutorul opțiunii \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Această opțiune are mai multe efecte: +.RS +.IP \(bu 3 +Dacă fișierul țintă există deja, îl șterge înainte de comprimare sau +decomprimare. +.IP \(bu 3 +Comprimă sau decomprimă chiar dacă intrarea este o legătură simbolică către +un fișier obișnuit, are mai mult de\-o legătură dură sau are marcați biții +setuid, setgid sau bitul lipicios. Biții setuid, setgid și bitul lipicios nu +sunt copiați în fișierul țintă. +.IP \(bu 3 +Când este utilizată cu opțiunile \fB\-\-decompress\fP și \fB\-\-stdout\fP, comanda +\fBxz\fP nu poate recunoaște tipul fișierului sursă, și copiază fișierul sursă +așa cum este la ieșirea standard. Acest lucru permite comenzii \fBxzcat\fP +\fB\-\-force\fP să fie folosită drept comanda \fBcat\fP(1) pentru fișierele care nu +au fost comprimate cu \fBxz\fP. Rețineți că, în viitor, \fBxz\fP ar putea să +accepte noi formate de fișiere comprimate, ceea ce poate face ca \fBxz\fP să +decomprime mai multe tipuri de fișiere în loc să le copieze așa cum sunt la +ieșirea standard. Opțiunea \fB\-\-format=\fP\fIformat\fP poate fi folosită pentru a +restricționa \fBxz\fP să decomprime doar un singur format de fișier. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Scrie datele comprimate sau decomprimate la ieșirea standard în loc de +într\-un fișier. Aceasta implică \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Decomprimă numai primul flux \fB.xz\fP și ignoră în tăcere posibilele date de +intrare rămase în urma fluxului. În mod normal, astfel de resturi rămase +face ca \fBxz\fP să afișeze o eroare. +.IP "" +\fBxz\fP nu decomprimă niciodată mai mult de un flux din fișierele \fB.lzma\fP sau +din fluxurile brute, dar această opțiune face ca \fBxz\fP să ignore posibilele +resturi de date rămase după fișierul \fB.lzma\fP sau fluxul brut. +.IP "" +Această opțiune nu are efect dacă modul de funcționare nu este +\fB\-\-decompress\fP sau \fB\-\-test\fP. +.IP "" +Începând cu \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP implică \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Dezactivează crearea de fișiere dispersate. În mod implicit, dacă decomprimă +într\-un fișier obișnuit, \fBxz\fP încearcă să facă fișierul dispersat dacă +datele decomprimate conțin secvențe lungi de zerouri binare. De asemenea, +funcționează atunci când scrie la ieșirea standard, atâta timp cât ieșirea +standard este conectată la un fișier obișnuit și sunt îndeplinite anumite +condiții suplimentare pentru a o face în siguranță. Crearea de fișiere +dispersate poate economisi spațiu pe disc și poate accelera decomprimarea +prin reducerea cantității de date de In/Ieș pe disc. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Când comprimă, utilizează \fI.suf\fP ca sufix pentru fișierul țintă în loc de +\&\fB.xz\fP sau \fB.lzma\fP. Dacă nu scrie la ieșirea standard și fișierul sursă are +deja sufixul \fI.suf\fP, este afișat un avertisment și fișierul este omis. +.IP "" +Când decomprimă, recunoaște fișierele cu sufixul \fI.suf\fP în plus față de +fișierele cu sufixul \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP sau \fB.lz\fP. Dacă +fișierul sursă are sufixul \fI.suf\fP, sufixul este eliminat pentru a obține +numele fișierului țintă. +.IP "" +La comprimarea sau decomprimarea fluxurilor brute (\fB\-\-format=raw\fP), sufixul +trebuie să fie întotdeauna specificat, cu excepția cazului în care se scrie +la ieșirea standard, deoarece nu există un sufix implicit pentru fluxurile +brute. +.TP +\fB\-\-files\fP[\fB=\fP\fIfișier\fP] +Citește numele fișierelor de procesat din \fIfișier\fP; dacă \fIfișierul\fP este +omis, numele fișierelor sunt citite de la intrarea standard. Numele de +fișiere trebuie să fie terminate cu caracterul de linie nouă. O liniuță +(\fB\-\fP) este luată ca nume de fișier obișnuit; nu înseamnă intrarea +standard. Dacă numele de fișiere sunt date și ca argumente în linia de +comandă, ele sunt procesate înainte ca numele fișierelor să fie citite din +\fIfișier\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIfișier\fP] +Această opțiune este identică cu \fB\-\-files\fP[\fB=\fP\fIfișier\fP], cu excepția +faptului că fiecare nume de fișier trebuie să fie terminat cu caracterul +nul. +. +.SS "Formatul de bază al fișierului și opțiunile de comprimare" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fIformat\fP +Specifică \fIformatul\fP fișierului pentru comprimare sau decomprimare: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Aceasta este valoarea implicită. La comprimare, \fBauto\fP este echivalent cu +\fBxz\fP. La decomprimare, formatul fișierului de intrare este detectat +automat. Rețineți că fluxurile brute (create cu \fB\-\-format=raw\fP) nu pot fi +detectate automat. +.TP +\fBxz\fP +Comprimă în formatul de fișier \fB.xz\fP sau acceptă numai fișierele \fB.xz\fP +când decomprimă. +.TP +\fBlzma\fP, \fBalone\fP +Comprimă în formatul de fișier \fB.lzma\fP vechi sau acceptă numai fișierele +\&\fB.lzma\fP când decomprimă. Numele alternativ \fBalone\fP este furnizat pentru +compatibilitatea cu versiunile mai vechi de LZMA Utils. +.TP +\fBlzip\fP +Acceptă numai fișierele \fB.lz\fP când decomprimă. Comprimarea nu este +acceptată. +.IP "" +Sunt acceptate versiunile 0 și 1 ale formatului \fB.lz\fP. Fișierele versiunii +0 au fost create cu \fBlzip\fP 1.3 și versiuni mai vechi. Astfel de fișiere nu +sunt comune, dar pot fi găsite în arhivele de fișiere, deoarece câteva +pachete sursă au fost lansate în acest format. Este posibil ca oamenii să +aibă și fișiere personale vechi în acest format. Suportul pentru +decomprimare pentru versiunea 0 a formatului a fost eliminat în \fBlzip\fP +1.18. \fBlzip\fP 1.4 și versiunile ulterioare creează fișiere în versiunea 1 a +formatului. +.TP +\fBraw\fP +Comprimă sau decomprimă un flux brut (fără anteturi). Acest lucru este +destinat doar utilizatorilor avansați. Pentru a decodifica fluxurile brute, +trebuie să utilizați opțiunea \fB\-\-format=raw\fP și să specificați în mod +explicit lanțul de filtre, care în mod normal ar fi fost stocat în +anteturile containerului. +.RE +.TP +\fB\-C\fP \fIverificarea\fP, \fB\-\-check=\fP\fIverificarea\fP +Specifică tipul verificării integrității. Verificarea este calculată din +datele necomprimate și stocată în fișierul \fB.xz\fP. Această opțiune are efect +numai la comprimarea în format \fB.xz\fP; formatul \fB.lzma\fP nu acceptă +verificări de integritate. Verificarea integrității (dacă există) este +efectuată atunci când fișierul \fB.xz\fP este decomprimat. +.IP "" +Tipuri de \fIverificare\fP acceptate: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Nu calculează deloc o verificare a integrității. Aceasta este de obicei o +idee proastă. Acest lucru poate fi util atunci când integritatea datelor +este oricum verificată prin alte mijloace. +.TP +\fBcrc32\fP +Calculează CRC32 folosind polinomul din IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Calculează CRC64 folosind polinomul din ECMA\-182. Aceasta este valoarea +implicită, deoarece este ceva mai bună decât CRC32 la detectarea fișierelor +deteriorate, iar diferența de viteză este neglijabilă. +.TP +\fBsha256\fP +Calculează SHA\-256. Acest lucru este oarecum mai lent decât CRC32 și CRC64. +.RE +.IP "" +Integritatea antetelor \fB.xz\fP este întotdeauna verificată cu CRC32. Nu este +posibilă modificarea sau dezactivarea acesteia. +.TP +\fB\-\-ignore\-check\fP +Nu efectuează verificarea integrității datelor comprimate la +decomprimare. Valorile CRC32 din antetele \fB.xz\fP vor fi însă verificate +normal. +.IP "" +\fBNu utilizați această opțiune decât dacă știți ce faceți\fP. Motive posibile +pentru a utiliza această opțiune: +.RS +.IP \(bu 3 +Încercarea de a recupera datele dintr\-un fișier .xz corupt. +.IP \(bu 3 +Accelerarea decomprimării. Acest lucru contează mai ales cu SHA\-256 sau cu +fișierele care s\-au comprimat extrem de bine. Este recomandat să nu +utilizați această opțiune în acest scop decât dacă integritatea fișierului +este verificată extern într\-un alt mod. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Selectează un nivel prestabilit de comprimare. Valoarea implicită este +\fB\-6\fP. Dacă sunt specificate mai multe niveluri prestabilite, ultimul are +efect. Dacă a fost deja specificat un lanț de filtre personalizat, +specificarea unui nivel prestabilit de comprimare șterge lanțul de filtre +personalizat. +.IP "" +Diferențele dintre valorile prestabilite sunt mai semnificative decât cu +\fBgzip\fP(1) și \fBbzip2\fP(1). Valorile de comprimare selectate determină +cerințele de memorie ale instrumentului de decomprimare, astfel încât +utilizarea unui nivel prea mare prestabilit ar putea face „dureroasă” +decomprimarea fișierului pe un sistem vechi cu puțină memorie RAM. Mai +exact, \fBnu este o idee bună să folosiți orbește \-9 pentru tot\fP așa cum se +întâmplă adesea cu \fBgzip\fP(1) și \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Acestea sunt valorile prestabilite oarecum rapide. \fB\-0\fP este uneori mai +rapid decât \fBgzip \-9\fP în timp ce comprimă mult mai bine. Cele mai ridicate +au adesea viteza comparabilă cu \fBbzip2\fP(1) cu un raport de comprimare +comparabil sau mai bun, deși rezultatele depind foarte mult de tipul de date +care sunt comprimate. +.TP +\fB\-4\fP ... \fB\-6\fP +Comprimare bună spre foarte bună, păstrând în același timp utilizarea +memoriei de către instrumentul de decomprimare la un nivel rezonabil chiar +și pentru sistemele vechi. \fB\-6\fP este valoarea implicită, care este de +obicei o alegere bună pentru distribuirea fișierelor care trebuie să poată +fi decomprimate chiar și pe sisteme cu doar 16Mio de memorie RAM. Opțiunile +(\fB\-5e\fP sau \fB\-6e\fP ar putea fi demne de luat în considerare. A se vedea +opțiunea \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Acestea sunt precum \fB\-6\fP, dar cu cerințe mai mari de memorie pentru +comprimare și decomprimare. Acestea sunt utile numai atunci când comprimați +fișiere mai mari de 8Mio, 16Mio și, respectiv, 32Mio. +.RE +.IP "" +Pe același hardware, viteza de decomprimare este aproximativ un număr +constant de octeți de date comprimate pe secundă. Cu alte cuvinte, cu cât +comprimarea este mai bună, cu atât decomprimarea va fi de obicei mai +rapidă. Aceasta înseamnă, de asemenea, că valoarea de la ieșire a cantității +de date necomprimate produsă pe secundă poate varia foarte mult. +.IP "" +Următorul tabel rezumă caracteristicile valorilor prestabilite: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +ValPrestab;DimDict;CPUComp;MemComp;MemDec +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Descrieri coloane: +.RS +.IP \(bu 3 +DimDict este dimensiunea dicționarului LZMA2. Este o risipă de memorie să +folosești un dicționar mai mare decât dimensiunea fișierului necomprimat. De +aceea este bine să evitați utilizarea valorilor prestabilite \fB\-7\fP ... \fB\-9\fP +atunci când nu este nevoie cu adevărat de ele. Pentru valoarea prestabilită +\fB\-6\fP sau alta mai mică, cantitatea de memorie irosită este de obicei +suficient de mică pentru a nu conta. +.IP \(bu 3 +CPUComp este o reprezentare simplificată a configurărilor LZMA2 care +afectează viteza de comprimare. Dimensiunea dicționarului afectează și +viteza, așa că, în timp ce CPUComp este aceeași pentru nivelurile \fB\-6\fP +\&... \fB\-9\fP, nivelurile mai mari tind să fie puțin mai lente. Pentru a obține +o comprimare și mai lentă și, astfel, posibil mai bună, consultați opțiunea +\fB\-\-extreme\fP. +.IP \(bu 3 +MemComp conține cerințele de memorie ale comprimării în modul cu un singur +fir de execuție. Poate varia ușor între versiunile \fBxz\fP. +.IP \(bu 3 +MemDec conține cerințele de memorie pentru decomprimare. Adică, +configurările de comprimare determină cerințele de memorie ale +decomprimării. Cantitatea exactă a memoriei utilizate la decomprimare este +puțin mai mare decât dimensiunea dicționarului LZMA2, dar valorile din tabel +au fost rotunjite la următorul Mio. +.RE +.IP "" +Cerințele de memorie ale modului cu mai multe fire de execuție sunt +semnificativ mai mari decât cele ale modului cu un singur fir de +execuție. Cu valoarea implicită a lui \fB\-\-block\-size\fP, fiecare fir are +nevoie de 3*3*DictSize plus MemComp sau MemDec. De exemplu, patru fire de +execuție cu valoarea prestabilită \fB\-6\fP au nevoie de 660\(en670\ Mio de +memorie. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Utilizează o variantă mai lentă a nivelului prestabilit de comprimare +selectat (\fB\-0\fP ... \fB\-9\fP) pentru a obține un raport de comprimare puțin mai +bun, dar din nefericire, acest lucru îl poate înrăutăți. Utilizarea memoriei +pentru decomprimare nu este afectată, dar utilizarea memoriei la comprimare +crește puțin la nivelurile prestabilite \fB\-0\fP ... \fB\-3\fP. +.IP "" +Deoarece există două valori prestabilite cu dimensiuni ale dicționarului de +4Mio și 8Mio, valorile prestabilite \fB\-3e\fP și \fB\-5e\fP folosesc configurări +puțin mai rapide (CPUComp mai mic) decât \fB\-4e\fP și \fB\-6e\fP, respectiv. În +acest fel, nu există două nivele prestabilite identice. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +ValPrestab;DimDict;CPUComp;MemComp;MemDec +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +De exemplu, există un total de patru nivele prestabilite care folosesc +dicționarul 8Mio, a căror ordine de la cel mai rapid la cel mai lent este +\fB\-5\fP, \fB\-6\fP, \fB\-5e\fP și \fB\-6e\fP . +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Acestea sunt alias de opțiuni, oarecum înșelătoare pentru \fB\-0\fP și, +respectiv, \fB\-9\fP. Acestea sunt furnizate numai pentru compatibilitatea cu +LZMA Utils. Evitați utilizarea acestor opțiuni. +.TP +\fB\-\-block\-size=\fP\fIdimensiunea\fP +Când comprimă în formatul \fB.xz\fP, împarte datele de intrare în blocuri de +\fIdimensiunea\fP octeți. Blocurile sunt comprimate independent unul de +celălalt, ceea ce ajută în modul cu mai multe fire de execuție și face +posibilă decomprimarea cu acces aleatoriu limitat. Această opțiune este de +obicei folosită pentru a suprascrie dimensiunea implicită a blocului în +modul cu mai multe fire de execuție, dar această opțiune poate fi folosită +și în modul cu un singur fir de execuție. +.IP "" +În modul cu mai multe fire de execuție, aproximativ de trei ori +\fIdimensiunea\fP de octeți vor fi alocați în fiecare fir pentru stocarea +intrării și ieșirii. \fIDimensiunea\fP implicită este de trei ori dimensiunea +dicționarului LZMA2 sau 1Mio, oricare dintre acestea este mai mare. În mod +obișnuit, o valoare bună este de două la patru ori dimensiunea dicționarului +LZMA2 sau de cel puțin 1Mio. Utilizarea unei \fIdimensiuni\fP mai mici decât +dimensiunea dicționarului LZMA2 este o risipă de memorie RAM, deoarece +atunci memoria tampon a dicționarului LZMA2 nu va fi niciodată utilizată pe +deplin. În modul cu mai multe fire de execuție, dimensiunile blocurilor sunt +stocate în anteturile blocurilor. Aceste informații privind dimensiunea sunt +necesare pentru decomprimarea cu mai multe fire. +.IP "" +În modul cu un singur fir de execuție, nicio divizare a blocurilor nu se +face în mod implicit. Folosirea acestei opțiuni nu afectează utilizarea +memoriei. Nu sunt stocate informații despre dimensiune în antetele +blocurilor, astfel încât fișierele create în modul cu un singur fir de +execuție nu vor fi identice cu fișierele create în modul cu mai multe fire +de execuție. Lipsa informațiilor privind dimensiunea înseamnă, de asemenea, +că \fBxz\fP nu va putea decomprima fișierele în modul cu mai multe fire. de +execuție. +.TP +\fB\-\-block\-list=\fP\fIelemente\fP +Când comprimă în formatul \fB.xz\fP, începe un nou bloc cu un lanț de filtre +personalizat opțional după intervalele specificate de date necomprimate. +.IP "" +\fIelementele\fP sunt o listă separată prin virgule. Fiecare element este +format dintr\-un număr opțional de lanț de filtrare între 0 și 9, urmat de +două puncte (\fB:\fP) și de o dimensiune cerută a datelor +necomprimate. Omiterea unui element (două sau mai multe virgule consecutive) +este o prescurtare pentru a utiliza dimensiunea și filtrele din elementul +anterior. +.IP "" +În cazul în care fișierul de intrare este mai mare decât suma dimensiunilor +din \fIelemente\fP, ultimul element se repetă până la sfârșitul fișierului. O +valoare specială de \fB0\fP poate fi utilizată ca ultimă dimensiune pentru a +indica faptul că restul fișierului trebuie să fie codificat ca un singur +bloc. +.IP "" +Un lanț de filtre alternativ pentru fiecare bloc poate fi specificat în +combinație cu opțiunile \fB\-\-filters1=\fP\fIfiltre\fP \&...\& +\fB\-\-filters9=\fP\fIfiltre\fP. Aceste opțiuni definesc lanțuri de filtre cu un +identificator cuprins între 1\(en9. Lanțul de filtre 0 poate fi utilizat +pentru a se referi la lanțul de filtre implicit, ceea ce este același lucru +cu a nu specifica un lanț de filtre. Identificatorul lanțului de filtre +poate fi utilizat înaintea dimensiunii necomprimate, urmat de două puncte +(\fB:\fP). De exemplu, dacă se specifică +\fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP, atunci blocurile vor fi +create folosind: +.RS +.IP \(bu 3 +Lanțul de filtre specificat de \fB\-\-filters1\fP și 2 Mio de intrare +.IP \(bu 3 +Lanțul de filtre specificat de \fB\-\-filters3\fP și 2 Mio de intrare +.IP \(bu 3 +Lanțul de filtre specificat de \fB\-\-filters2\fP și 4 Mio de intrare +.IP \(bu 3 +Lanțul de filtre specificat de \fB\-\-filters2\fP și 4 Mio de intrare +.IP \(bu 3 +Lanțul de filtre implicit și 2 MiB de intrare +.IP \(bu 3 +Lanțul de filtre implicit și 4 MiB de intrare pentru fiecare bloc până la +sfârșitul intrării. +.RE +.IP "" +Dacă se specifică o dimensiune care depășește dimensiunea blocului +codificatorului (fie valoarea implicită în modul cu fire de execuție, fie +valoarea specificată cu \fB\-\-block\-size=\fP\fIdimensiune\fP), codificatorul va +crea blocuri suplimentare, păstrând limitele specificate în \fIelemente\fP. De +exemplu, dacă se specifică \fB\-\-block\-size=10MiB\fP +\fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP și fișierul de intrare este de +80 MiB, se vor obține 11 blocuri: 5, 10, 8, 10, 10, 2, 10, 10, 10, 4, 10, +10, 10 și 1 Mio. +.IP "" +În modul cu mai multe fire de execuție, dimensiunile blocurilor sunt stocate +în antetele blocurilor. Acest lucru nu se face în modul cu un singur fir de +execuție, astfel încât ieșirea codificată nu va fi identică cu cea a modului +cu mai multe fire de execuție. +.TP +\fB\-\-flush\-timeout=\fP\fItimp_limită\fP +La comprimare, dacă au trecut mai mult de \fItimp_limită\fP milisecunde (un +întreg pozitiv) de la curățarea anterioară și citirea mai multor intrări +s\-ar bloca, toate datele de intrare în așteptare sunt eliminate din +codificator și puse la dispoziție în fluxul de ieșire. Acest lucru poate să +fie util dacă \fBxz\fP este utilizat pentru a comprima datele care sunt +transmise în flux printr\-o rețea. Valorile mici de \fItimp_limită\fP fac datele +disponibile la capătul de recepție cu o mică întârziere, dar valorile mari +de \fItimp_limită\fP oferă un raport de comprimare mai bun. +.IP "" +Această caracteristică este dezactivată în mod implicit. Dacă această +opțiune este specificată de mai multe ori, ultima este cea care se ia în +considerare. Valoarea specială a lui \fItimp_limită\fP de \fB0\fP, poate fi +utilizată pentru a dezactiva în mod explicit această caracteristică. +.IP "" +Această caracteristică nu este disponibilă în sistemele non\-POSIX. +.IP "" +.\" FIXME +\fBAceastă caracteristică este încă experimentală\fP. În prezent, \fBxz\fP este +nepotrivit pentru decomprimarea fluxului în timp real datorită modului în +care \fBxz\fP utilizează memoria tampon. +.TP +\fB\-\-no\-sync\fP +Nu sincronizează fișierul țintă și directorul acestuia cu dispozitivul de +stocare înainte de a elimina fișierul sursă. Acest lucru poate îmbunătăți +performanța în cazul comprimării sau decomprimării multor fișiere mici. Cu +toate acestea, dacă sistemul se blochează imediat după ștergere, este +posibil ca fișierul țintă să nu fi fost scris pe dispozitivul de stocare, +dar operația de ștergere să fi fost. În acest caz, nici fișierul sursă +original, nici fișierul țintă nu sunt disponibile. +.IP "" +Această opțiune are efect numai atunci când \fBxz\fP urmează să elimine +fișierul sursă. În alte cazuri, sincronizarea nu se face niciodată. +.IP "" +Sincronizarea și \fB\-\-no\-sync\fP au fost adăugate în \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIlimita\fP +Stabilește o limită de utilizare a memoriei pentru comprimare. Dacă această +opțiune este specificată de mai multe ori, ultima va avea efect. +.IP "" +Dacă parametrii de comprimare depășesc \fIlimita\fP, \fBxz\fP va încerca să +ajusteze parametrii scăzând valorile acestora, astfel încât limita să nu mai +fie depășită și va afișa o notificare că ajustarea automată a fost +efectuată. Ajustările se fac în această ordine: reducerea numărului de fire, +trecerea la modul un singur fir de execuție dacă chiar și un singur fir în +modul cu mai multe fire de execuție depășește \fIlimita\fP și, în final, +reducerea dimensiunii dicționarului LZMA2. +.IP "" +Când comprimă cu opțiunea \fB\-\-format=raw\fP sau dacă a fost specificată +opțiunea \fB\-\-no\-adjust\fP, numai numărul de fire poate fi redus, deoarece se +poate face fără a afecta rezultatul comprimării. +.IP "" +Dacă \fIlimita\fP nu poate fi îndeplinită chiar și cu ajustările descrise mai +sus, este afișată o eroare și \fBxz\fP va ieși cu starea de ieșire 1. +.IP "" +\fILimita\fP poate fi specificata în mai multe moduri: +.RS +.IP \(bu 3 +\fILimita\fP poate fi o valoare absolută în octeți. Utilizarea unui sufix +întreg precum \fBMiB\fP poate fi utilă. De exemplu: +\fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +\fILimita\fP poate fi specificată ca procent din memoria fizică totală +(RAM). Acest lucru poate fi util mai ales atunci când definiți variabila de +mediu \fBXZ_DEFAULTS\fP într\-un script de inițializare shell care este partajat +între diferite calculatoare. În acest fel, limita este automat mai mare pe +sistemele cu mai multă memorie. De exemplu: \fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +\fILimita\fP poate fi restabilită la valoarea implicită dându\-i valoarea +\fB0\fP. În prezent, aceasta este echivalentă cu stabilirea \fIlimitei\fP la +\fBmax\fP (fără limită de utilizare a memoriei). +.RE +.IP "" +Pentru \fBxz\fP pe 32 de biți există un caz special: dacă \fIlimita\fP ar fi peste +\fB4020MiB\fP, \fIlimita\fP este stabilită la \fB4020MiB\fP. Pe MIPS32 este +stabilită în schimb la \fB2000MiB\fP; (valorile \fB0\fP și \fBmax\fP nu sunt afectate +de acest lucru \-\- o caracteristică similară nu există pentru +decomprimare). Acest lucru poate fi util atunci când un executabil pe 32 de +biți are acces la un spațiu de adrese de 4Gio (2Gio pe MIPS32), se speră că +nu produce daune în alte situații. +.IP "" +Consultați și secțiunea \fBUtilizarea memoriei\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIlimita\fP +Stabilește o limită de utilizare a memoriei pentru decomprimare. Acest lucru +afectează și modul \fB\-\-list\fP. Dacă operațiunea nu este posibilă fără a +depăși \fIlimita\fP, \fBxz\fP va afișa o eroare și decomprimarea fișierului va +eșua. Consultați \fB\-\-memlimit\-compress=\fP\fIlimita\fP pentru modalitățile +posibile de a specifica \fIlimita\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimita\fP +Stabilește o limită de utilizare a memoriei pentru decomprimarea cu mai +multe fire de execuție. Acest lucru poate afecta doar numărul de fire de +execuție; acest lucru nu îl va face niciodată pe \fBxz\fP să refuze +decomprimarea unui fișier. Dacă \fIlimita\fP este prea scăzută pentru a permite +orice mod cu mai multe fire de execuție, \fIlimita\fP este ignorată și \fBxz\fP va +continua în modul cu un singur fir de execuție. Rețineți că, dacă se +folosește și opțiunea \fB\-\-memlimit\-decompress\fP, se va aplica întotdeauna +atât modurilor cu un singur fir de execuție, cât și modurilor cu mai multe +fire de execuție și astfel \fIlimita\fP efectivă pentru modul cu mai multe fire +de execuție nu va fi niciodată mai mare decât limita stabilită cu opțiunea +\fB\-\-memlimit\-decompress\fP. +.IP "" +Spre deosebire de celelalte opțiuni de limită de utilizare a memoriei, +opțiunea \fB\-\-memlimit\-mt\-decompress=\fP\fIlimita\fP are o \fIlimită\fP implicită +specifică sistemului. Comanda \fBxz \-\-info\-memory\fP poate fi folosită pentru a +vedea valoarea curentă. +.IP "" +Această opțiune și valoarea ei implicită există deoarece, fără nicio limită, +decomprimarea cu (mai multe) fire de execuție ar putea ajunge să aloce o +cantitate „nebună” de memorie cu unele fișiere de intrare. Dacă \fIlimita\fP +implicită este prea scăzută pe sistemul dumneavoastră, nu ezitați să +creșteți \fIlimita\fP, dar niciodată să nu o stabiliți la o valoare mai mare +decât cantitatea de memorie RAM utilizabilă și cu niște fișiere de intrare +adecvate, \fBxz\fP va încerca să utilizeze acea cantitate de memorie chiar și +cu un număr redus de fire de execuție. Rularea lui \fBxz\fP cu depășirea +cantității de memorie fizice(RAM) sau a celei de interschimb(swap) nu va +îmbunătăți performanța de decomprimare. +.IP "" +Consultați opțiunea \fB\-\-memlimit\-compress=\fP\fIlimita\fP pentru modalități +posibile de a specifica \fIlimita\fP. Stabilirea \fIlimitei\fP la \fB0\fP +restabilește \fIlimita\fP la valoarea implicită specifică sistemului. +.TP +\fB\-M\fP \fIlimita\fP, \fB\-\-memlimit=\fP\fIlimita\fP, \fB\-\-memory=\fP\fIlimita\fP +Aceasta este echivalentă cu specificarea opțiunilor: +\fB\-\-memlimit\-compress=\fP\fIlimita\fP \fB\-\-memlimit\-decompress=\fP\fIlimita\fP +\fB\-\-memlimit\-mt\-decompress=\fP\fIlimita\fP. +.TP +\fB\-\-no\-adjust\fP +Afișează o eroare și iese dacă limita de utilizare a memoriei nu poate fi +îndeplinită fără ajustarea parametrilor care afectează ieșirea +comprimată. Adică, acest lucru împiedică \fBxz\fP să comute codificatorul din +modul cu mai multe fire de execuție în modul cu un singur fir de execuție și +să reducă dimensiunea dicționarului LZMA2. Chiar și atunci când această +opțiune este utilizată, numărul de fire de execuție poate fi redus pentru a +îndeplini limita de utilizare a memoriei, deoarece aceasta nu va afecta +comprimarea. +.IP "" +Ajustarea automată este întotdeauna dezactivată la crearea fluxurilor brute +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fInumăr\fP, \fB\-\-threads=\fP\fInumăr\fP +Specifică numărul de fire de execuție de utilizat. Stabilirea \fInumărului\fP +la valoarea specială \fB0\fP, face ca \fBxz\fP să utilizeze până la atâtea fire de +execuție câte procesoare sunt în sistem. Numărul real de fire de execuție +poate fi mai mic decât \fInumăr\fP dacă fișierul de intrare nu este suficient +de mare pentru a trece la modul cu mai multe fire de execuție cu parametrii +dați, sau dacă folosirea mai multor fire de execuție ar depăși limita de +utilizare a memoriei. +.IP "" +Operațiile de comprimare cu un singur fir de execuție și cele cu mai multe +fire de execuție produc ieșiri diferite. Comprimarea cu un singur fir de +execuție va oferi cea mai mică dimensiune a fișierului, dar numai ieșirea de +la comprimarea cu mai multe fire de execuție poate fi decomprimată folosind +mai multe fire. Stabilirea \fInumărului\fP la \fB1\fP va determina ca \fBxz\fP să +folosească modul cu un singur fir de execuție. Stabilirea \fInumărului\fP la +orice altă valoare, inclusiv \fB0\fP, va determina ca \fBxz\fP să folosească +comprimarea cu mai multe fire de execuție chiar dacă sistemul acceptă doar +un fir hardware; (\fBxz\fP 5.2.x folosește modul cu un singur fir de execuție +în această situație). +.IP "" +Pentru a utiliza modul cu mai multe fire de execuție cu un singur fir, +stabiliți \fInumărul\fP la \fB+1\fP. Prefixul \fB+\fP nu are efect cu alte valori +decât \fB1\fP. O limită de utilizare a memoriei poate face în continuare \fBxz\fP +să treacă în modul cu un singur fir, cu excepția cazului în care este +utilizată opțiunea \fB\-\-no\-adjust\fP. Suportul pentru prefixul \fB+\fP a fost +adăugat în \fBxz\fP 5.4.0. +.IP "" +Dacă a fost solicitat un număr automat de fire și nu a fost specificată +nicio limită de utilizare a memoriei, atunci o limită „maleabilă” implicită +specifică sistemului va fi utilizată pentru a limita eventual numărul de +fire de execuție. Este o limită „maleabilă” în sensul că este ignorată dacă +numărul de fire devine unul, astfel o limită „maleabilă” nu va opri +niciodată \fBxz\fP să comprime sau să decomprime. Această limită „maleabilă” +implicită nu va face \fBxz\fP să treacă de la modul cu mai multe fire de +execuție la modul cu un singur fir de execuție. Limitele active pot fi +văzute rulând comanda \fBxz \-\-info\-memory\fP. +.IP "" +În prezent, singura metodă de procesare cu fire de execuție este împărțirea +intrării în blocuri și comprimarea lor independent unul de +celălalt. Dimensiunea implicită a blocului depinde de nivelul de comprimare +și poate fi înlocuită cu opțiunea \fB\-\-block\-size=\fP\fIdimensiune\fP. +.IP "" +Decomprimarea cu fire de execuție funcționează numai pe fișierele care +conțin mai multe blocuri cu informații despre dimensiune în antetele +blocurilor. Toate fișierele suficient de mari comprimate în modul cu mai +multe fire de execuție îndeplinesc această condiție, dar fișierele +comprimate în modul cu un singur fir de execuție nu o îndeplinesc chiar dacă +a fost folosită opțiunea \fB\-\-block\-size=\fP\fIdimensiune\fP. +.IP "" +Valoarea implicită pentru \fIfire de execuție\fP este \fB0\fP. În \fBxz\fP 5.4.x și +mai vechi, valoarea implicită este \fB1\fP. +. +.SS "Lanțuri de filtrare personalizate pentru instrumentul de comprimare" +Un lanț de filtrare personalizat permite specificarea parametrilor de +comprimare în detaliu, în loc să se bazeze pe cei asociați opțiunilor +prestabilite. Când este specificat un lanț de filtrare personalizat, +opțiunile prestabilite (\fB\-0\fP \&...\& \fB\-9\fP și \fB\-\-extreme\fP) de mai devreme +din linia de comandă sunt uitate. Dacă o opțiune prestabilită este +specificată după una sau mai multe opțiuni de lanț de filtrare personalizat, +noua prestabilire intră în vigoare și opțiunile lanțului de filtrare +personalizat, specificate mai devreme sunt uitate. +.PP +Un lanț de filtrare este comparabil cu conductele din linia de comandă. La +comprimare, intrarea necomprimată merge la primul filtru, a cărui ieșire +merge la următorul filtru (dacă există). Ieșirea ultimului filtru este +scrisă în fișierul comprimat. Numărul maxim de filtre din lanț este de +patru, dar de obicei un lanț de filtrare are doar unul sau două filtre. +.PP +Multe filtre au limitări în ceea ce privește locul în care se pot afla în +lanțul de filtrare: unele filtre pot funcționa doar ca ultimul filtru din +lanț, altele doar ca non\-ultim filtru și unele funcționează în orice poziție +din lanț. În funcție de filtru, această limitare este fie inerentă +proiectării filtrului, fie există pentru a preveni problemele de securitate. +.PP +Un lanț de filtre personalizat poate fi specificat în două moduri +diferite. Opțiunile \fB\-\-filters=\fP\fIfiltre\fP și \fB\-\-filters1=\fP\fIfiltre\fP +\&...\& \fB\-\-filters9=\fP\fIfiltre\fP permit specificarea unui întreg lanț de +filtre într\-o singură opțiune, folosind sintaxa șirului de filtre +liblzma. Alternativ, un lanț de filtre poate fi specificat prin utilizarea +uneia sau mai multor opțiuni de filtrare individuale în ordinea în care sunt +dorite în lanțul de filtre. Adică, ordinea opțiunilor de filtrare +individuale este semnificativă! La decodificarea fluxurilor brute +(\fB\-\-format=raw\fP), lanțul de filtre trebuie să fie specificat în aceeași +ordine în care a fost specificat la comprimare. Orice filtru individual sau +opțiuni presetate specificate înainte de opțiunea de lanț complet +(\fB\-\-filters=\fP\fIfiltre\fP) vor fi uitate. Filtrele individuale specificate +după opțiunea „lanț complet” vor reinițializa lanțul de filtre. +.PP +Atât opțiunile de filtrare completă, cât și cele de filtrare individuală +acceptă \fIopțiuni\fP specifice filtrului sub forma unei liste separate prin +virgule. Se ignoră virgulele suplimentare din \fIopțiuni\fP. Fiecare opțiune +are o valoare implicită, deci specificați\-le pe cele pe care doriți să le +modificați. +.PP +Pentru a vedea întregul lanț de filtre și \fIopțiuni\fP, utilizați \fBxz \-vv\fP +(adică folosiți \fB\-\-verbose\fP de două ori). Acest lucru funcționează și +pentru vizualizarea opțiunilor lanțului de filtre utilizate de valorile +prestabilite. +.TP +\fB\-\-filters=\fP\fIfiltre\fP +Specificați întregul lanț de filtre sau o presetare într\-o singură +opțiune. Fiecare filtru poate fi separat prin spații sau două liniuțe +(\fB\-\-\fP). Este posibil să fie necesar ca \fIfiltrele\fP să fie puse între +ghilimele în linia de comandă a shell\-ului pentru a fi analizate ca o +singură opțiune. Pentru a indica \fIopțiuni\fP, utilizați \fB:\fP sau \fB=\fP. O +presetare poate fi prefixată cu un \fB\-\fP și urmată de zero sau mai multe +indicatoare. Singurul indicator suportat este \fBe\fP pentru a aplica aceleași +opțiuni ca și \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIfiltre\fP ... \fB\-\-filters9\fP=\fIfiltre\fP +Specifică până la nouă lanțuri de filtre suplimentare care pot fi utilizate +cu \fB\-\-block\-list\fP. +.IP "" +De exemplu, atunci când se comprimă o arhivă cu fișiere executabile urmate +de fișiere text, partea executabilă ar putea utiliza un lanț de filtre cu un +filtru BCJ, iar partea de text doar filtrul LZMA2. +.TP +\fB\-\-filters\-help\fP +Afișează un mesaj de ajutor care descrie modul de specificare a presetărilor +și a lanțurilor de filtre personalizate în opțiunile \fB\-\-filters\fP și +\fB\-\-filters1=\fP\fIfiltre\fP \&...\& \fB\-\-filters9=\fP\fIfiltre\fP și iese. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIopțiuni\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIopțiuni\fP] +.PD +Adaugă filtrul LZMA1 sau LZMA2 la lanțul de filtre. Aceste filtre pot fi +folosite doar ca ultimul filtru din lanț. +.IP "" +LZMA1 este un filtru vechi, care este acceptat aproape exclusiv datorită +formatului de fișier vechi \fB.lzma\fP, care acceptă numai LZMA1. LZMA2 este o +versiune actualizată a LZMA1 pentru a rezolva unele probleme practice ale +LZMA1. Formatul \fB.xz\fP folosește LZMA2 și nu acceptă deloc LZMA1. Viteza de +comprimare și rapoartele LZMA1 și LZMA2 sunt practic aceleași. +.IP "" +LZMA1 și LZMA2 au același set de \fIopțiuni\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIprestabilit\fP +Reconfigurează toate \fIopțiunile\fP LZMA1 sau LZMA2 la +\fIprestabilit\fP. \fIprestabilit\fP constă dintr\-un număr întreg, care poate fi +urmat de modificatori prestabiliți cu o singură literă. Numărul întreg +poate fi de la \fB0\fP la \fB9\fP, potrivindu\-se cu opțiunile liniei de comandă +\fB\-0\fP \&...\& \fB\-9\fP. Singurul modificator acceptat în prezent este \fBe\fP, +care se potrivește cu \fB\-\-extreme\fP. Dacă nu este specificat \fBprestabilit\fP, +valorile implicite ale \fIopțiunilor\fP LZMA1 sau LZMA2 sunt preluate din +prestabilirea \fB6\fP. +.TP +\fBdict=\fP\fIdimensiunea\fP +\fIDimensiunea\fP dicționarului (istoricul memoriei tampon) indică câți octeți +din datele necomprimate recent procesate sunt păstrați în +memorie. Algoritmul încearcă să găsească secvențe de octeți care se repetă +(potriviri) în datele necomprimate și să le înlocuiască cu referințe la +datele aflate în prezent în dicționar. Cu cât dicționarul este mai mare, cu +atât este mai mare șansa de a găsi o potrivire. Astfel, creșterea +\fIdimensiunii\fP dicționarului îmbunătățește de obicei raportul de comprimare, +dar un dicționar mai mare decât fișierul necomprimat este risipă de memorie. +.IP "" +\fIDimensiunea\fPtipică a dicționarului este de la 64Kio până la 64Mio. Minimul +este de 4Kio. Maximul pentru compresie este în prezent de 1,5Gio +(1536Mio). Decomprimarea acceptă deja dicționare cu până la un octet mai +puțin de 4Gio, care este maximul pentru formatele de flux LZMA1 și LZMA2. +.IP "" +\fIDimensiunea\fP dicționarului și găsitorul de potriviri (match finder) → +(\fImf\fP) determină împreună utilizarea memoriei de către codificatorul LZMA1 +sau LZMA2. Aceeași \fIdimensiune\fP a dicționarului (sau mai mare) care a fost +utilizată la comprimare, este necesară pentru decomprimare, astfel încât +utilizarea memoriei de către decodificator este determinată de dimensiunea +dicționarului utilizată la comprimare. Antetele \fB.xz\fP stochează +\fIdimensiunea\fP dicționarului fie ca 2^\fIn\fP, fie ca 2^\fIn\fP + 2^(\fIn\fP\-1), deci +aceste \fIdimensiuni\fP sunt oarecum preferate pentru comprimare. Alte +\fIdimensiuni\fP vor fi rotunjite atunci când sunt stocate în anteturile +\&\fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Specifică numărul de biți de context literal. Minimul este 0 și maximul este +4; implicit este 3. În plus, suma \fIlc\fP și \fIlp\fP nu trebuie să depășească +4. +.IP "" +Toți octeții care nu pot fi codificați ca potriviri sunt codificați ca +literali. Adică, literalii sunt pur și simplu octeți de 8 biți care sunt +codificați unul câte unul. +.IP "" +Codificarea literală presupune că cei mai mari biți \fIlc\fP ai octetului +anterior necomprimat se corelează cu octetul următor. De exemplu, în textul +tipic englezesc, o literă mare este adesea urmată de o literă mică, iar o +literă mică este urmată de obicei de o altă literă mică. În setul de +caractere US\-ASCII, cei mai mari trei biți sunt 010 pentru literele mari și +011 pentru literele mici. Când \fIlc\fP este cel puțin 3, codificarea literală +poate profita de această proprietate în datele necomprimate. +.IP "" +Valoarea implicită (3) este de obicei bună. Dacă doriți o comprimare maximă, +testați \fBlc=4\fP. Uneori ajută puțin, iar uneori înrăutățește comprimarea +\&. Dacă o agravează, încercați de\-asemeni cu \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Specifică numărul de biți de poziție literală. Minimul este 0 și maximul +este 4; implicit este 0. +.IP "" +\fILp\fP afectează ce fel de aliniere în datele necomprimate este presupusă la +codificarea literalelor. Consultați argumentul \fIpb\fP de mai jos pentru mai +multe informații despre aliniere. +.TP +\fBpb=\fP\fIpb\fP +Specifică numărul de biți de poziție. Minimul este 0 și maximul este 4; +implicit este 2. +.IP "" +\fIPb\fP afectează ce fel de aliniere în datele necomprimate este presupusă în +general. Valoarea implicită înseamnă alinierea pe patru octeți +(2^\fIpb\fP=2^2=4), care este adesea o alegere bună atunci când nu există o +ipoteză mai bună. +.IP "" +Când alinierea este cunoscută, definirea lui \fIpb\fP în mod corespunzător +poate reduce puțin dimensiunea fișierului. De exemplu, cu fișierele text cu +aliniere pe un octet (US\-ASCII, ISO\-8859\-*, UTF\-8), definirea \fBpb=0\fP poate +îmbunătăți ușor comprimarea. Pentru textul UTF\-16, \fBpb=1\fP este o alegere +bună. Dacă alinierea este un număr impar, cum ar fi 3 octeți, \fBpb=0\fP ar +putea fi cea mai bună alegere. +.IP "" +Chiar dacă alinierea presupusă poate fi ajustată cu \fIpb\fP și \fIlp\fP, LZMA1 și +LZMA2 încă favorizează ușor alinierea pe 16 octeți. Ar putea fi demn de luat +în considerare atunci când proiectați formate de fișiere care pot fi adesea +comprimate cu LZMA1 sau LZMA2. +.TP +\fBmf=\fP\fImf\fP +Căutarea potrivirilor are un efect major asupra vitezei codificatorului, +utilizării memoriei și raportului de comprimare. De obicei, găsitorii de +potriviri din lanțul sumelor de control sunt mai rapizi decât găsitorii de +potriviri din arborele binar. Valoarea implicită depinde de \fIprestabilit\fP: +0 folosește \fBhc3\fP, 1\(en3 folosește \fBhc4\fP, iar restul folosește \fBbt4\fP. +.IP "" +Sunt acceptate următoarele opțiuni de căutare de potriviri. Formulele de +utilizare a memoriei de mai jos sunt aproximări estimative, care se apropie +cel mai mult de realitate atunci când \fIdict\fP este o putere a lui doi. +.RS +.TP +\fBhc3\fP +Lanț de sumă de control, cu suma de control de 2 și 3 octeți +.br +Valoarea minimă pentru \fInice\fP: 3 +.br +Utilizarea memoriei: +.br +\fIdict\fP * 7.5 (dacă \fIdict\fP <= 16 Mio); +.br +\fIdict\fP * 5.5 + 64 MiB (dacă \fIdict\fP > 16 Mio) +.TP +\fBhc4\fP +Lanț de sumă de control, cu suma de control de 2, 3 și 4 octeți +.br +Valoarea minimă pentru \fInice\fP: 4 +.br +Utilizarea memoriei: +.br +\fIdict\fP * 7.5 (dacă \fIdict\fP <= 32 Mio); +.br +\fIdict\fP * 6.5 (dacă \fIdict\fP > 32 Mio) +.TP +\fBbt2\fP +Arbore binar cu suma de control de 2 octeți +.br +Valoarea minimă pentru \fInice\fP: 2 +.br +Utilizarea memoriei: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Arbore binar cu suma de control de 2 și 3 octeți +.br +Valoarea minimă pentru \fInice\fP: 3 +.br +Utilizarea memoriei: +.br +\fIdict\fP * 11.5 (dacă \fIdict\fP <= 16 Mio); +.br +\fIdict\fP * 9.5 + 64 MiB (dacă \fIdict\fP > 16 Mio) +.TP +\fBbt4\fP +Arbore binar cu suma de control de 2, 3 și 4 octeți +.br +Valoarea minimă pentru \fInice\fP: 4 +.br +Utilizarea memoriei: +.br +\fIdict\fP * 11.5 (dacă \fIdict\fP <= 32 Mio); +.br +\fIdict\fP * 10.5 (dacă \fIdict\fP > 32 Mio) +.RE +.TP +\fBmode=\fP\fImod\fP +Comprimarea \fImod\fP specifică metoda de analiză a datelor produse de +găsitorul de potriviri. \fIModurile\fP acceptate sunt \fBfast\fP(rapid) și +\fBnormal\fP. Valoarea implicită este \fBfast\fP pentru \fIprestabiliri\fP 0\(en3 și +\fBnormal\fP pentru \fIprestabiliri\fP 4\(en9. +.IP "" +De obicei, \fBfast\fP este folosit cu instrumentele de căutare de potriviri ale +lanțului de sume de control, și \fBnormal\fP cu instrumentele de căutare de +potriviri din arborele binar. Aceasta este și ceea ce fac \fIprestabiririle\fP. +.TP +\fBnice=\fP\fInice\fP +Specifică ceea ce este considerat a fi o lungime bună(nice) pentru o +potrivire. Odată ce este găsită o potrivire de cel puțin \fInice\fP octeți, +algoritmul nu mai caută după potriviri posibile mai bune. +.IP "" +\fINice\fP poate fi de 2\(en273 octeți. Valorile mai mari tind să ofere un +raport de comprimare mai bun în detrimentul vitezei. Valoarea implicită +depinde de \fIprestabilit\fP. +.TP +\fBdepth=\fP\fIadâncimea\fP +Specifică adâncimea maximă de căutare în găsitorul de potriviri. Valoarea +implicită este valoarea specială de 0, ceea ce face ca instrumentul de +comprimare să determine o \fIadâncime\fP rezonabilă pornind de la valorile +\fImf\fP și \fInice\fP. +.IP "" +\fIAdâncimea\fP rezonabilă pentru lanțuri de sumă de control este 4\(en100 și +16\(en1000 pentru arbori binari. Folosirea unor valori foarte mari pentru +\fIadâncime\fP poate face codificatorul extrem de lent cu unele +fișiere. Evitați să stabiliți \fIadâncimea\fP la valori peste 1000, cu excepția +cazului în care sunteți pregătit să întrerupeți comprimarea în cazul în care +durează prea mult. +.RE +.IP "" +La decodificarea fluxurilor brute (\fB\-\-format=raw\fP), LZMA2 are nevoie doar +de \fIdimensiunea\fP dicționarului. LZMA1 are nevoie de asemenea de \fIlc\fP, +\fIlp\fP și \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIopțiuni\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIopțiuni\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIopțiuni\fP] +.PD +Adaugă un filtru de ramură/apel/salt (branch/call/jump ⟶ „BCJ”) la lanțul de +filtre. Aceste filtre pot fi utilizate numai ca un filtru care nu este +ultimul din lanțul de filtrare. +.IP "" +Un filtru BCJ convertește adresele relative din codul mașinii în omoloagele +lor absolute. Acest lucru nu modifică dimensiunea datelor, dar crește +redundanța, ceea ce poate ajuta LZMA2 să producă fișier \fB.xz\fP cu 0\(en15\ % +mai mic. Filtrele BCJ sunt întotdeauna reversibile, deci folosind un filtru +BCJ pentru tipul greșit de date nu provoacă nicio pierdere de date, deși +poate înrăutăți puțin raportul de comprimare. Filtrele BCJ sunt foarte +rapide și folosesc o cantitate nesemnificativă de memorie. +.IP "" +Aceste filtre BCJ au probleme cunoscute legate de raportul de comprimare: +.RS +.IP \(bu 3 +Unele tipuri de fișiere care conțin cod executabil (de exemplu, fișiere +obiect, biblioteci statice și module de kernel Linux) au adresele din +instrucțiuni completate cu valori de umplere. Aceste filtre BCJ vor face în +continuare conversia adresei, ceea ce va înrăutăți comprimarea cu aceste +fișiere. +.IP \(bu 3 +Dacă pe o arhivă este aplicat un filtru BCJ, este posibil ca raportul de +comprimare să fie mai rău decât la neutilizarea unui filtru BCJ. De exemplu, +dacă există executabile similare sau chiar identice, filtrarea va face +probabil fișierele mai puțin asemănătoare și astfel comprimarea este mai +proastă. Conținutul fișierelor neexecutabile din aceeași arhivă poate conta +și el. În practică, trebuie să încercați cu și fără filtru BCJ pentru a +vedea care rezultat este mai bun în fiecare situație. +.RE +.IP "" +Seturi de instrucțiuni diferite au o aliniere diferită: fișierul executabil +trebuie aliniat la un multiplu al acestei valori în datele de intrare pentru +ca filtrul să funcționeze. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filtru;Aliniere;Note +x86;1;x86 pe 32 de biți +;;sau 64 de biți +ARM;4; +ARM\-Thumb;2; +ARM64;4;alinierea pe 4096\-octeți +;;este cea mai bună +PowerPC;4;Doar big endian +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Deoarece datele filtrate prin BCJ sunt de obicei comprimate cu LZMA2, +raportul de comprimare poate fi ușor îmbunătățit dacă opțiunile LZMA2 sunt +definite pentru a se potrivi cu alinierea filtrului BCJ selectat. Exemple: +.RS +.IP \(bu 3 +Filtrul IA\-64 are o aliniere de 16 octeți, astfel încât \fBpb=4,lp=4,lc=0\fP +este alegere adecvată cu LZMA2 (2^4=16). +.IP \(bu 3 +Codul RISC\-V are o aliniere pe 2 sau 4 octeți, depinzând de faptul că +fișierul conține instrucțiuni comprimate pe 16 biți (extensia C) sau +nu. Atunci când se utilizează instrucțiuni pe 16 biți, \fBpb=2,lp=1,lc=3\fP sau +\fBpb=1,lp=1,lc=3\fP este o alegere bună. Atunci când nu sunt prezente +instrucțiuni pe 16 biți, \fBpb=2,lp=2,lc=2\fP este cea mai bună +alegere. \fBreadelf \-h\fP poate fi utilizată pentru a verifica dacă „RVC” apare +în linia „Indicatori". +.IP \(bu 3 +ARM64 este întotdeauna aliniat pe 4 octeți, astfel încât \fBpb=2,lp=2,lc=2\fP +este cea mai bună alegere. +.IP \(bu 3 +Filtrul x86 este o excepție. De obicei, este bine să rămâneți la valorile +implicite ale LZMA2 (\fBpb=2,lp=0,lc=3\fP) atunci când comprimați executabile +x86. +.RE +.IP "" +Toate filtrele BCJ acceptă același \fIopțiuni\fP: +.RS +.TP +\fBstart=\fP\fIpoziție\fP +Specifică \fIpoziția\fP de pornire care este utilizată la conversia între +adresele relative și absolute. \fIPoziția\fP trebuie să fie un multiplu al +alinierii filtrului (consultați tabelul de mai sus). Valoarea implicită +este zero. În practică, valoarea implicită este bună; specificarea unei +\fIpoziții\fP personalizate nu este aproape niciodată utilă. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIopțiuni\fP] +Adaugă filtrul Delta în lanțul de filtrare. Filtrul Delta poate fi folosit +doar ca un filtru care nu este ultimul în lanțul de filtrare. +.IP "" +În prezent, este acceptat doar calculul delta simplu de octeți. Poate fi +util la comprimarea, de exemplu, a imaginilor bitmap necomprimate sau a +sunetului PCM necomprimat. Cu toate acestea, algoritmii cu scop special pot +da rezultate semnificativ mai bune decât Delta + LZMA2. Acest lucru este +valabil mai ales în cazul audio, care se comprimă mai repede și mai bine, de +exemplu, cu \fBflac\fP(1). +.IP "" +\fIOpțiuni\fP acceptate: +.RS +.TP +\fBdist=\fP\fIdistanța\fP +Specifică \fIdistanța\fP calculului delta în octeți. \fIDistanța\fP trebuie să fie +1\(en256. Valoarea implicită este 1. +.IP "" +De exemplu, cu \fBdist=2\fP și intrare de opt octeți: A1 B1 A2 B3 A3 B5 A4 B7, +ieșirea va fi: A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Alte opțiuni" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Suprimă avertismentele și notificările. Specificați acest lucru de două ori +pentru a suprima și erorile. Această opțiune nu are niciun efect asupra +stării de ieșire. Adică, chiar dacă o avertizare a fost suprimată, starea de +ieșire pentru a indica o avertizare este încă utilizată. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Oferă informații detaliate. Dacă ieșirea de eroare standard este conectată +la un terminal, \fBxz\fP va afișa un indicator de progres. Specificarea +opțiunii \fB\-\-verbose\fP de două ori, va avea ca rezultat oferirea de +informații și mai detaliate. +.IP "" +Indicatorul de progres afișează următoarele informații: +.RS +.IP \(bu 3 +Procentul de completare este afișat dacă se cunoaște dimensiunea fișierului +de intrare. Adică, procentul nu poate fi afișat la procesarea fișierului +prin conducte(pipe). +.IP \(bu 3 +Cantitatea de date comprimate produse (comprimare) sau consumate +(decomprimare). +.IP \(bu 3 +Cantitatea de date necomprimate consumate (comprimare) sau produse +(decomprimare). +.IP \(bu 3 +Raportul de comprimare, care se calculează împărțind cantitatea de date +comprimate procesate până acum la cantitatea de date necomprimate procesate +până acum. +.IP \(bu 3 +Viteza de comprimare sau decomprimare. Aceasta este măsurată drept +cantitatea de date necomprimate consumate (comprimare) sau produse +(decomprimare) pe secundă. Este afișată după ce au trecut câteva secunde de +când \fBxz\fP a început procesarea fișierului. +.IP \(bu 3 +Timpul scurs în format M:SS sau H:MM:SS. +.IP \(bu 3 +Timpul rămas estimat este afișat numai atunci când dimensiunea fișierului de +intrare este cunoscută și au trecut deja câteva secunde de când \fBxz\fP a +început procesarea fișierului. Ora este afișată într\-un format mai puțin +precis, care nu are niciodată două puncte, de exemplu, 2 min 30 s. +.RE +.IP "" +Când ieșirea de eroare standard nu este un terminal, \fB\-\-verbose\fP va face +\fBxz\fP să imprime numele fișierului, dimensiunea comprimată, dimensiunea +necomprimată, raportul de comprimare și, eventual, de asemenea, viteza și +timpul scurs pe o singură linie la ieșirea de eroare standard după +comprimarea sau decomprimarea fișierului. Viteza și timpul scurs sunt +incluse numai atunci când operațiunea a durat cel puțin câteva secunde. Dacă +operațiunea nu s\-a încheiat, de exemplu, din cauza întreruperii din partea +utilizatorului, se imprimă și procentul de completare dacă se cunoaște +dimensiunea fișierului de intrare. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Nu comută starea de ieșire la 2 chiar dacă a fost detectată o condiție care +merită avertizată. Această opțiune nu afectează nivelul de detaliere al +informațiilor, astfel încât atât \fB\-\-quiet\fP cât și \fB\-\-no\-warn\fP trebuie +folosite pentru a nu afișa avertismente și pentru a nu modifica starea de +ieșire. +.TP +\fB\-\-robot\fP +Afișează mesajele într\-un format care poate fi analizat de mașină. Acest +lucru are scopul de a ușura scrierea interfețelor în care se dorește să se +folosească \fBxz\fP în loc de liblzma, ceea ce poate fi cazul cu diferite +scripturi. Ieșirea cu această opțiune activată este menită să fie stabilă în +toate versiunile \fBxz\fP. Consultați secțiunea \fBMOD ROBOT\fP pentru detalii. +.TP +\fB\-\-info\-memory\fP +Afișează, într\-un format care poate fi citit de om, câtă memorie fizică +(RAM) și câte fire de execuție de procesor \fBxz\fP crede că are sistemul și +limitele de utilizare a memoriei pentru comprimare și decomprimare și iese +cu succes. +.TP +\fB\-h\fP, \fB\-\-help\fP +Afișează un mesaj de ajutor care descrie opțiunile cele mai frecvent +utilizate și iese cu succes. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Afișează un mesaj de ajutor care descrie toate caracteristicile \fBxz\fP și +iese cu succes +.TP +\fB\-V\fP, \fB\-\-version\fP +Afișează numărul versiunii \fBxz\fP și liblzma într\-un format care poate fi +citit de om. Pentru a obține rezultate analizabile de mașină, specificați +\fB\-\-robot\fP înainte de \fB\-\-version\fP. +. +.SH "MOD ROBOT" +Modul robot este activat cu opțiunea \fB\-\-robot\fP. Face ieșirea lui \fBxz\fP mai +ușor de analizat de către alte programe. În prezent, opțiunea \fB\-\-robot\fP +este acceptată numai împreună cu opțiunile \fB\-\-list\fP, \fB\-\-filters\-help\fP, +\fB\-\-info\-memory\fP, și \fB\-\-version\fP. Va fi acceptată pentru comprimare și +decomprimare în viitor. +. +.SS "Modul listă" +\fBxz \-\-robot \-\-list\fP utilizează o ieșire separată de tabulatori. Prima +coloană a fiecărei linii are un șir care indică tipul de informații găsite +pe acea linie: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Aceasta este întotdeauna prima linie când începe să se listeze un fișier. A +doua coloană de pe linie este numele fișierului. +.TP +\fBfile\fP +Această linie conține informații generale despre fișierul \fB.xz\fP. Această +linie este întotdeauna tipărită după linia \fBname\fP. +.TP +\fBstream\fP +Acest tip de linie este utilizat numai atunci când a fost specificată +opțiunea \fB\-\-verbose\fP. Există tot atâtea linii \fBstream\fP câte fluxuri există +în fișierul \fB.xz\fP. +.TP +\fBblock\fP +Acest tip de linie este utilizat numai atunci când a fost specificată +opțiunea \fB\-\-verbose\fP. Există tot atâtea linii \fBblock\fP câte blocuri există +în fișierul \fB.xz\fP. Liniile \fBblock\fP sunt afișate după toate liniile +\fBstream\fP; tipurile diferite de linii nu sunt intercalate. +.TP +\fBsummary\fP +Acest tip de linie este folosit numai atunci când opțiunea \fB\-\-verbose\fP a +fost specificată de două ori. Această linie este afișată după toate liniile +\fBblock\fP. Ca și linia \fBfile\fP, linia \fBsummary\fP conține informații generale +despre fișierul \fB.xz\fP. +.TP +\fBtotals\fP +Această linie este întotdeauna ultima linie din lista afișată la +ieșire. Aceasta arată numărul total și dimensiunile. +.PP +Coloanele din liniile \fBfile\fP: +.PD 0 +.RS +.IP 2. 4 +Numărul de fluxuri din fișier +.IP 3. 4 +Numărul total de blocuri din fluxuri +.IP 4. 4 +Dimensiunea comprimată a fișierului +.IP 5. 4 +Dimensiunea necomprimată a fișierului +.IP 6. 4 +Raportul de comprimare, de exemplu, \fB0,123\fP. Dacă raportul este peste +9,999, în locul raportului sunt afișate trei liniuțe (\fB\-\-\-\fP). +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Lista de nume de verificare a integrității, separate prin +virgule. Următoarele șiruri sunt utilizate pentru tipurile de verificare +cunoscute: \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP și \fBSHA\-256\fP. Pentru tipurile de +verificări necunoscute, se utilizează \fBUnknown\-\fP\fIN\fP, unde \fIN\fP este ID\-ul +de verificare ca număr zecimal (una sau două cifre). +.IP 8. 4 +Dimensiunea totală a umpluturii fluxului din fișier +.RE +.PD +.PP +Coloanele din liniile \fBstream\fP: +.PD 0 +.RS +.IP 2. 4 +Numărul fluxului (primul flux este 1) +.IP 3. 4 +Numărul de blocuri din flux +.IP 4. 4 +Poziția de pornire a comprimării +.IP 5. 4 +Poziția de pornire a decomprimării +.IP 6. 4 +Dimensiune comprimată (nu include umplutura fluxului) +.IP 7. 4 +Dimensiune necomprimată +.IP 8. 4 +Raport de comprimare +.IP 9. 4 +Numele verificării de integritate +.IP 10. 4 +Dimensiunea umpluturii fluxului +.RE +.PD +.PP +Coloanele din liniile \fBblock\fP: +.PD 0 +.RS +.IP 2. 4 +Numărul fluxului care conține acest bloc +.IP 3. 4 +Numărul blocului în raport cu începutul fluxului (primul bloc este 1) +.IP 4. 4 +Numărul blocului în raport cu începutul fișierului +.IP 5. 4 +Poziția de pornire a comprimării în raport cu începutul fișierului +.IP 6. 4 +Poziția de pornire necomprimată în raport cu începutul fișierului +.IP 7. 4 +Dimensiunea totală comprimată a blocului (include antetele) +.IP 8. 4 +Dimensiune necomprimată +.IP 9. 4 +Raport de comprimare +.IP 10. 4 +Numele verificării de integritate +.RE +.PD +.PP +Dacă opțiunea \fB\-\-verbose\fP a fost specificată de două ori, coloane +suplimentare sunt incluse pe liniile \fBblock\fP. Acestea nu sunt afișate cu o +singură specificare a opțiunii \fB\-\-verbose\fP, deoarece obținerea acestor +informații necesită multe căutări și, prin urmare, poate fi lentă: +.PD 0 +.RS +.IP 11. 4 +Valoarea verificării integrității în hexazecimal +.IP 12. 4 +Dimensiunea antetului blocului +.IP 13. 4 +Indicatori de bloc: \fBc\fP indică faptul că este prezentă dimensiunea +comprimată, iar \fBu\fP indică faptul că este prezentă dimensiunea +necomprimată. Dacă indicatorul nu este determinat, este afișată o liniuță +(\fB\-\fP) pentru a menține lungimea șirului fixă. Pot fi adăugate noi +indicatoare la sfârșitul șirului, în viitor. +.IP 14. 4 +Dimensiunea datelor comprimate reale din bloc (acest lucru exclude antetul +blocului, umplutura blocului și câmpurile de verificare) +.IP 15. 4 +Cantitatea de memorie (în octeți) necesară pentru a decomprima acest bloc cu +această versiune \fBxz\fP +.IP 16. 4 +Lanț de filtrare. Rețineți că majoritatea opțiunilor utilizate în timpul +comprimării nu pot fi cunoscute, deoarece doar opțiunile necesare pentru +decomprimare sunt stocate în anteturile \fB.xz\fP. +.RE +.PD +.PP +Coloanele din liniile \fBsummary\fP: +.PD 0 +.RS +.IP 2. 4 +Cantitatea de memorie (în octeți) necesară pentru a decomprima acest fișier +cu această versiune \fBxz\fP +.IP 3. 4 +\fByes\fP sau \fBno\fP indicând dacă toate antetele blocurilor au atât dimensiunea +comprimată, cât și dimensiunea necomprimată stocate în ele +.PP +\fIÎncepând cu\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Versiunea \fBxz\fP minimă necesară pentru a decomprima fișierul +.RE +.PD +.PP +Coloanele din linia \fBtotals\fP: +.PD 0 +.RS +.IP 2. 4 +Numărul de fluxuri +.IP 3. 4 +Numărul de blocuri +.IP 4. 4 +Dimensiunea comprimată +.IP 5. 4 +Dimensiune necomprimată +.IP 6. 4 +Raportul mediu de comprimare +.IP 7. 4 +Lista de nume de verificare a integrității, separate prin virgule, care au +fost prezente în fișiere +.IP 8. 4 +Dimensiunea umpluturii fluxului +.IP 9. 4 +Numărul de fișiere. Aceasta este aici pentru a păstra ordinea coloanelor +anterioare la fel ca pe liniile \fBfile\fP. +.PD +.RE +.PP +Dacă opțiunea \fB\-\-verbose\fP a fost specificată de două ori, pe linia +\fBtotals\fP sunt incluse coloane suplimentare: +.PD 0 +.RS +.IP 10. 4 +Cantitatea maximă de memorie (în octeți) necesară pentru a decomprima +fișierele cu această versiune \fBxz\fP +.IP 11. 4 +\fByes\fP sau \fBno\fP indicând dacă toate antetele blocurilor au atât dimensiunea +comprimată, cât și dimensiunea necomprimată stocate în ele +.PP +\fIÎncepând cu\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Versiunea \fBxz\fP minimă necesară pentru a decomprima fișierul +.RE +.PD +.PP +Versiunile viitoare pot adăuga noi tipuri de linii și pot fi adăugate +coloane noi la tipurile de linii existente, dar coloanele existente nu vor +fi modificate. +. +.SS "Ajutor pentru filtrare" +\fBxz \-\-robot \-\-filters\-help\fP afișează filtrele acceptate în următorul +format: +.PP +\fIfiltru\fP\fB:\fP\fIopțiune\fP\fB=<\fP\fIvaloare\fP\fB>,\fP\fIopțiune\fP\fB=<\fP\fIvaloare\fP\fB>\fP... +.TP +\fBfiltru\fP +Numele filtrului +.TP +\fIopțiune\fP +Numele unei opțiuni specifice unui filtru +.TP +\fIvaloare\fP +Intervalele numerice \fIvaloare\fP apar ca +\fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. Alegerile \fIvaloare\fP de tip șir de +caractere sunt afișate în cadrul \fB< >\fP și separate de un caracter +\fB|\fP. +.PP +Fiecare filtru este afișat pe propria linie. +. +.SS "Informații privind limita memoriei" +\fBxz \-\-robot \-\-info\-memory\fP afișează o singură linie cu multiple coloane +separate prin tabulatoare: +.IP 1. 4 +Cantitatea totală de memorie fizică (RAM) în octeți. +.IP 2. 4 +Limita de utilizare a memoriei pentru comprimare în octeți +(\fB\-\-memlimit\-compress\fP). O valoare specială de \fB0\fP indică configurarea +implicită, care pentru modul cu un singur fir este la fel ca fără limită. +.IP 3. 4 +Limita de utilizare a memoriei pentru decomprimare în octeți +(\fB\-\-memlimit\-decompress\fP). O valoare specială de \fB0\fP indică configurarea +implicită, care pentru modul cu un singur fir este la fel ca fără limită. +.IP 4. 4 +Începând cu \fBxz\fP 5.3.4alpha: Utilizarea memoriei pentru decomprimarea cu +mai multe fire în octeți (\fB\-\-memlimit\-mt\-decompress\fP). Acesta nu este +niciodată zero, deoarece o valoare implicită specifică sistemului afișată în +coloana 5 este utilizată dacă nu a fost specificată în mod explicit nicio +limită. De asemenea, aceasta nu este niciodată mai mare decât valoarea din +coloana 3, chiar dacă a fost specificată o valoare mai mare cu +\fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Începând cu \fBxz\fP 5.3.4alpha: o limită implicită de utilizare a memoriei +specifică sistemului, care este utilizată pentru a limita numărul de fire de +execuție atunci când se comprimă cu un număr automat de fire de execuție +(\fB\-\-threads=0\fP) și nicio limită de utilizare a memoriei nu fost specificată +cu (\fB\-\-memlimit\-compress\fP). Aceasta este, de asemenea, utilizată ca valoare +implicită pentru \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Începând cu \fBxz\fP 5.3.4alpha: numărul de fire de execuție de procesor +disponibile. +.PP +În viitor, rezultatul \fBxz \-\-robot \-\-info\-memory\fP poate avea mai multe +coloane, dar niciodată mai mult de o singură linie. +. +.SS Versiunea +\fBxz \-\-robot \-\-version\fP va afișa numărul versiunii \fBxz\fP și liblzma în +următorul format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Versiunea majoră. +.TP +\fIYYY\fP +Versiunea minoră. Numerele pare sunt prezente în versiunile +stabile. Numerele impare sunt prezente în versiunile alfa sau beta. +.TP +\fIZZZ\fP +Nivelul de plasture(patch) pentru versiunile stabile sau doar un contor +pentru versiunile de dezvoltare. +.TP +\fIS\fP +Stabilitate. 0 este alfa, 1 este beta și 2 este stabil. \fIS\fP trebuie să fie +întotdeauna 2 atunci când \fIAAA\fP este par. +.PP +\fIXYYYZZZS\fP sunt aceleași pe ambele linii dacă \fBxz\fP și liblzma sunt din +aceeași versiune XZ Utils. +.PP +Exemple: 4.999.9beta este \fB49990091\fP și 5.0.0 este \fB50000002\fP. +. +.SH "STARE DE IEȘIRE" +.TP +\fB0\fP +Totul este bine. +.TP +\fB1\fP +A apărut o eroare. +.TP +\fB2\fP +A apărut ceva care merită să fie avertizat, dar nu au apărut erori reale. +.PP +Notificările (nu avertismentele sau erorile) afișate la ieșirea de eroare +standard nu afectează starea de ieșire. +. +.SH "VARIABILE DE MEDIU" +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP analizează liste de opțiuni separate prin spații din variabilele de +mediu \fBXZ_DEFAULTS\fP și \fBXZ_OPT\fP, în această ordine, înainte de a analiza +opțiunile din linia de comandă. Rețineți că numai opțiunile sunt analizate +din variabilele de mediu; toate non\-opțiunile sunt ignorate în +tăcere. Analiza se face cu funcția \fBgetopt_long\fP(3) care este folosită și +pentru argumentele liniei de comandă. +.PP +\fBAvertisment:\fP Prin definirea acestor variabile de mediu, se modifică +efectiv programele și scripturile care rulează \fBxz\fP. De cele mai multe ori +este sigur să se definească limitele de utilizare a memoriei, numărul de +fire și opțiunile de comprimare prin intermediul variabilelor de mediu. Cu +toate acestea, unele opțiuni pot întrerupe scripturile. Un exemplu evident +este \fB\-\-help\fP care face ca \fBxz\fP să afișeze textul de ajutor în loc să +comprime sau să decomprime un fișier. Exemple mai subtile sunt \fB\-\-quiet\fP și +\fB\-\-verbose\fP. În multe cazuri funcționează bine activarea indicatorului de +progres folosind \fB\-\-verbose\fP, dar în unele situații mesajele suplimentare +creează probleme. Nivelul de detaliere al mesajelor afectează, de asemenea, +comportamentul lui \fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Opțiuni implicite specifice utilizatorului sau la nivelul întregului +sistem. De obicei, acest lucru este specificat într\-un script de +inițializare shell pentru a activa limitatorul de utilizare a memoriei lui +\fBxz\fP implicit sau pentru a stabili numărul implicit de fire. Excluzând +scripturile de inițializare shell și cazurile speciale similare, scripturile +nu trebuie niciodată să modifice sau să dezactiveze \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Acest lucru este pentru transmiterea opțiunilor către \fBxz\fP atunci când nu +este posibil să definiți opțiunile direct în linia de comandă a +\fBxz\fP. Acesta este cazul când \fBxz\fP este rulat de un script sau de un +instrument, de exemplu, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Scripturile pot folosi \fBXZ_OPT\fP, de exemplu, pentru a configura opțiunile +implicite de comprimare specifice scriptului. Se recomandă totuși să se +permită utilizatorilor să înlocuiască \fBXZ_OPT\fP dacă acest lucru este +rezonabil. De exemplu, în scripturile \fBsh\fP(1) se poate folosi ceva de genul +acesta: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "COMPATIBILITATE CU LZMA\-UTILS" +Sintaxa liniei de comandă a lui \fBxz\fP este practic o super\-colecție de +\fBlzma\fP, \fBunlzma\fP și \fBlzcat\fP așa cum se găsește în LZMA Utils 4.32.x. În +cele mai multe cazuri, este posibil să înlocuiți LZMA Utils cu XZ Utils fără +a întrerupe scripturile existente. Există totuși unele incompatibilități, +care uneori pot cauza probleme. +. +.SS "Niveluri de comprimare prestabilite" +Numerotarea nivelurilor de comprimare prestabilite nu este identică în \fBxz\fP +și LZMA Utils. Cea mai importantă diferență este modul în care dimensiunile +dicționarului sunt atribuite diferitelor niveluri prestabilite. Dimensiunea +dicționarului este aproximativ egală cu memoria utilizată la decomprimare. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nivel;xz;LZMA Utils +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Diferențele de dimensiune a dicționarului afectează deasemenea cantitatea de +memorie utilizată la comprimare dar există și alte diferențe între LZMA +Utils și XZ Utils, care fac diferența și mai mare: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nivel;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Nivelul prestabilit implicit în LZMA Utils este \fB\-7\fP, în timp ce în XZ +Utils este \fB\-6\fP, deci ambele folosesc un dicționar de 8Mio în mod implicit. +. +.SS "Fișiere .lzma transmise în flux vs. netransmise în flux" +Dimensiunea necomprimată a fișierului poate fi stocată în antetul +\&\fB.lzma\fP. LZMA Utils face asta atunci când comprimă fișiere +obișnuite. Alternativa este să marcați că dimensiunea necomprimată este +necunoscută și să folosiți marcajul de sfârșit de încărcare pentru a indica +unde ar trebui să se oprească decomprimarea. LZMA Utils folosește această +metodă atunci când dimensiunea necomprimată nu este cunoscută, ceea ce este +cazul, de exemplu, când se folosesc conducte. +.PP +\fBxz\fP acceptă decomprimarea fișierelor \fB.lzma\fP cu sau fără marcaj de +sfârșit de încărcare, dar toate fișierele \fB.lzma\fP create de \fBxz\fP vor +folosi marcajul de sfârșit de încărcare și vor avea dimensiunea necomprimată +marcată ca necunoscută în antetul \fB.lzma\fP. Aceasta poate fi o problemă în +unele situații mai puțin frecvente. De exemplu, un instrument de +decomprimare \fB.lzma\fP încorporat într\-un dispozitiv poate funcționa numai cu +fișiere care au dimensiunea necomprimată cunoscută. Dacă întâmpinați această +problemă, trebuie să utilizați LZMA Utils sau LZMA SDK pentru a crea fișiere +\&\fB.lzma\fP cu dimensiunea necomprimată cunoscută. +. +.SS "Fișiere .lzma neacceptate" +Formatul \fB.lzma\fP permite valori \fIlc\fP de până la 8 și valori \fIlp\fP de până +la 4. LZMA Utils poate decomprima fișiere cu orice \fIlc\fP și \fIlp\fP, dar +creează întotdeauna fișiere cu \fBlc=3\fP și \fBlp=0\fP. Crearea de fișiere cu +alte \fIlc\fP și \fIlp\fP este posibilă cu \fBxz\fP și cu LZMA SDK. +.PP +Implementarea filtrului LZMA1 în liblzma necesită ca suma \fIlc\fP și \fIlp\fP să +nu depășească 4. Altfel, fișierele \fB.lzma\fP, care depășesc această limitare, +nu pot fi decomprimate cu \fBxz\fP. +.PP +LZMA Utils creează numai fișiere \fB.lzma\fP care au o dimensiune de dicționar +de 2^\fIn\fP (o putere de 2), dar acceptă fișiere cu orice dimensiune de +dicționar. liblzma acceptă numai fișierele \fB.lzma\fP care au dimensiunea de +dicționar de 2^\fIn\fP sau 2^\fIn\fP + 2^(\fIn\fP\-1). Acest lucru este pentru a +reduce numărul de „fals pozitiv” atunci când se detectează fișiere \fB.lzma\fP. +.PP +Aceste limitări nu ar trebui să fie o problemă în practică, deoarece practic +toate fișierele \fB.lzma\fP au fost comprimate cu opțiuni pe care liblzma le va +accepta. +. +.SS "Resturi rămase" +Când decomprimă, LZMA Utils ignoră în tăcere totul după primul flux +\&\fB.lzma\fP. În majoritatea situațiilor, aceasta este o eroare. Aceasta +înseamnă, de asemenea, că LZMA Utils nu acceptă decomprimarea fișierelor +\&\fB.lzma\fP concatenate. +.PP +Dacă au rămas date după primul flux \fB.lzma\fP, \fBxz\fP consideră că fișierul +este corupt, cu excepția cazului în care a fost utilizată opțiunea +\fB\-\-single\-stream\fP. Acest lucru poate rupe scripturile obscure(scrise +deficitar) care presupun că resturile rămase sunt ignorate. +. +.SH NOTE +. +.SS "Rezultatul comprimării poate varia" +Ieșirea exactă comprimată produsă din același fișier de intrare necomprimat +poate varia între versiunile XZ Utils, chiar dacă opțiunile de comprimare +sunt identice. Acest lucru se datorează faptului că instrumentul codificator +poate fi îmbunătățit (comprimare mai rapidă sau mai bună) fără a afecta +formatul fișierului. Ieșirea poate varia chiar și între compilările diferite +ale aceleiași versiuni XZ Utils, dacă sunt utilizate opțiuni diferite de +compilare. +.PP +Cele de mai sus înseamnă că odată ce opțiunea \fB\-\-rsyncable\fP a fost +utilizată, fișierele rezultate nu vor fi neapărat sincronizate cu rsync +decât dacă atât fișierele vechi, cât și cele noi au fost comprimate cu +aceeași versiune xz. Această problemă poate fi remediată dacă o parte a +implementării codificatorului este înghețată pentru a menține stabilă +ieșirea „rsyncabilă” între versiunile xz. +. +.SS "Instrumente de decomprimare .xz încorporate" +Implementările instrumentului de decomprimare \fB.xz\fP încorporat, cum ar fi +XZ Embedded, nu acceptă neapărat fișiere create cu tipuri de \fIverificare\fP a +integrității, altele decât \fBnone\fP și \fBcrc32\fP. Deoarece valoarea implicită +este \fB\-\-check=crc64\fP, trebuie să utilizați \fB\-\-check=none\fP sau +\fB\-\-check=crc32\fP atunci când creați fișiere pentru sistemele încorporate. +.PP +În afara sistemelor încorporate, toate instrumentele de decomprimare în +format \fB.xz\fP acceptă toate tipurile de \fIverificare\fP sau cel puțin pot +decomprima fișierul fără a efectua verificarea integrității dacă acel tip de +\fIverificare\fP nu este acceptat. +.PP +XZ Embedded acceptă filtre BCJ, dar numai cu poziție de pornire implicită. +. +.SH EXEMPLE +. +.SS Bazice +Comprimă fișierul \fIfoo\fP în \fIfoo.xz\fP folosind nivelul de comprimare +implicit (\fB\-6\fP) și elimină fișierul \fIfoo\fP dacă comprimarea are succes: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Decomprimă \fIbar.xz\fP în \fIbar\fP și nu elimină \fIbar.xz\fP chiar dacă +decomprimarea este efectuată cu succes: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Creează \fIbaz.tar.xz\fP cu nivelul prestabilit \fB\-4e\fP (\fB\-4 \-\-extreme\fP), care +este mai lent decât nivelul prestabilit implicit \fB\-6\fP, dar necesită mai +puțină memorie pentru comprimare și decomprimare (48Mio și, respectiv, +5Mio): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Un amestec de fișiere comprimate și necomprimate poate fi decomprimat la +ieșirea standard cu o singură comandă: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Comprimarea în paralel a mai multor fișiere" +În sisteme GNU și *BSD, \fBfind\fP(1) și \fBxargs\fP(1) pot fi utilizate pentru a +paraleliza comprimarea mai multor fișiere: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Opțiunea \fB\-P\fP pentru comanda \fBxargs\fP(1) stabilește numărul de procese +paralele \fBxz\fP. Cea mai bună valoare pentru opțiunea \fB\-n\fP depinde de câte +fișiere trebuie să fie comprimate. Dacă există doar câteva fișiere, valoarea +ar trebui probabil să fie 1; cu zeci de mii de fișiere, 100 sau chiar mai +mult poate să fie valoarea potrivită pentru a reduce numărul de procese +\fBxz\fP pe care \fBxargs\fP(1) le va crea în final. +.PP +Opțiunea \fB\-T1\fP pentru \fBxz\fP este acolo pentru a\-l forța să ruleze în modul +cu un singur fir de execuție, deoarece \fBxargs\fP(1) este folosit pentru a +controla cantitatea de paralelizare. +. +.SS "Modul robot" +Calculează câți octeți au fost salvați în total după comprimarea mai multor +fișiere: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Un script poate dori să afle dacă folosește o versiune \fBxz\fP suficient de +nouă. Următorul script \fBsh\fP(1) verifică dacă numărul versiunii +instrumentului \fBxz\fP este cel puțin 5.0.0. Această metodă este compatibilă +cu versiunile beta vechi, care nu acceptau opțiunea \fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Versiunea dumneavoastră de „xz” este prea veche!" +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Stabilește o limită de utilizare a memoriei pentru decomprimare folosind +variabila de mediu \fBXZ_OPT\fP, dar dacă o limită a fost deja stabilită, nu o +mărește: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Lanțuri de filtrare personalizate pentru instrumentul de comprimare" +Cea mai simplă utilizare a lanțurilor de filtrare personalizate este +personalizarea unei opțiuni prestabilite LZMA2. Acest lucru poate fi util, +deoarece opțiunile prestabilite acoperă doar un subset al combinațiilor +potențial utile de opțiuni de comprimare. +.PP +Coloanele CPUComp din tabelele de descriere a opțiunilor \fB\-0\fP ... \fB\-9\fP și +\fB\-\-extreme\fP sunt utile atunci când personalizați opțiunilor prestabilite +LZMA2. Iată părțile relevante colectate din aceste două tabele: +.RS +.PP +.TS +tab(;); +c c +n n. +ValPrestab;CPUComp +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Dacă știți că un fișier necesită un dicționar oarecum mare (de exemplu, +32Mio) pentru a se comprima bine, dar doriți să\-l comprimați mai repede +decât ar face \fBxz \-8\fP, o opțiune prestabilită cu o valoare CPUComp scăzută +(de exemplu, 1) poate fi modificată pentru a utiliza un dicționar mai mare: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Cu anumite fișiere, comanda de mai sus poate fi mai rapidă decât \fBxz \-6\fP în +timp ce comprimă semnificativ mai bine. Cu toate acestea, trebuie subliniat +că doar unele fișiere se beneficiază de un dicționar mare, păstrând în +același timp valoarea CPUComp scăzută. Cea mai evidentă situație, în care un +dicționar mare poate ajuta foarte mult, este o arhivă care conține fișiere +foarte asemănătoare de cel puțin câțiva megaocteți fiecare. Dimensiunea +dicționarului trebuie să fie semnificativ mai mare decât orice fișier +individual pentru a permite LZMA2 să profite din plin de asemănările dintre +fișierele consecutive. +.PP +Dacă utilizarea unei mari cantități de memorie pentru comprimare și +decomprimare este în regulă, iar fișierul comprimat are cel puțin câteva +sute de megaocteți, poate fi util să folosiți un dicționar și mai mare decât +cei 64Mio pe care i\-ar folosi \fBxz \-9\fP: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Utilizarea opțiunii \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) ca în exemplul de mai +sus, poate fi utilă pentru a vedea cerințele de memorie la comprimare și +decomprimare. Amintiți\-vă că utilizarea unui dicționar mai mare decât +dimensiunea fișierului necomprimat este risipă de memorie, de aceea, comanda +de mai sus nu este utilă pentru fișiere mici. +.PP +Uneori, timpul de comprimare nu contează, dar utilizarea memoriei la +decomprimare trebuie menținută la un nivel scăzut, de exemplu, pentru a face +posibilă decomprimarea fișierului pe un sistem încorporat. Următoarea +comandă folosește \fB\-6e\fP (\fB\-6 \-\-extreme\fP) ca bază și fixează dimensiunea +dicționarului la doar 64Kio. Fișierul rezultat poate fi decomprimat cu XZ +Embedded (de aceea există \fB\-\-check=crc32\fP) folosind aproximativ 100Kio de +memorie. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Dacă doriți să stoarceți cât mai mulți octeți posibil, ajustarea numărului +de biți de context literal (\fIlc\fP) și a numărului de biți de poziție (\fIpb\fP) +poate ajuta uneori. Ajustarea numărului de biți de poziție literală (\fIlp\fP) +ar putea ajuta, de asemenea, dar de obicei \fIlc\fP și \fIpb\fP sunt mai +importante. De exemplu, o arhivă de cod sursă conține în mare parte text +US\-ASCII, așa că ceva precum comanda următoare, ar putea oferi un fișier +„mai slăbuț” (aproximativ cu 0,1%) mai mic decât cu \fBxz \-6e\fP (încercați și +fără \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 fișierul_sursă.tar\fR +.fi +.RE +.PP +Utilizarea unui alt filtru împreună cu LZMA2 poate îmbunătăți comprimarea cu +anumite tipuri de fișiere. De exemplu, pentru a comprima o bibliotecă +partajată x86 pe 32 de biți sau x86 pe 64 de biți folosind filtrul BCJ x86: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Rețineți că ordinea opțiunilor de filtrare este semnificativă. Dacă \fB\-\-x86\fP +este specificată după \fB\-\-lzma2\fP, \fBxz\fP va da o eroare, deoarece nu poate +exista niciun filtru după LZMA2 și, de asemenea, pentru că filtrul x86 BCJ +nu poate fi utilizat ca ultimul filtru din lanțul de filtrare. +.PP +Filtrul Delta împreună cu LZMA2 pot da rezultate bune cu imagini bitmap. De +obicei, ar trebui să întreacă comprimarea PNG, care are câteva filtre mai +avansate decât delta simplă, dar utilizează Deflate pentru comprimarea +reală. +.PP +Imaginea trebuie să fie salvată în format necomprimat, de exemplu, ca TIFF +necomprimat. Parametrul de distanță al filtrului Delta este fixat să se +potrivească cu numărul de octeți per pixel din imagine. De exemplu, +bitmap\-ul RGB pe 24 de biți necesită \fBdist=3\fP și este, de asemenea, bine să +pasați \fBpb=0\fP la LZMA2 pentru a se adapta alinierii pe trei octeți: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Dacă mai multe imagini au fost introduse într\-o singură arhivă (de exemplu, +\&\fB.tar\fP), filtrul Delta va funcționa și pe aceasta atâta timp cât toate +imaginile au același număr de octeți per pixel. +. +.SH "CONSULTAȚI ȘI" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xzcmp.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xzcmp.1 new file mode 100644 index 0000000000000000000000000000000000000000..cebad3bb3ad049a59a6f1d29360d76fa73a915e4 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xzcmp.1 @@ -0,0 +1,70 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Romanian translation for xz-man. +.\" Mesajele în limba română pentru manualul pachetului XZ Utils. +.\" Remus-Gabriel Chelu , 2022 - 2025. +.\" Cronologia traducerii fișierului „xz-man”: +.\" Traducerea inițială, făcută de R-GC, pentru versiunea xz-man 5.4.0-pre1. +.\" Actualizare a traducerii pentru versiunea 5.4.0-pre2, făcută de R-GC, dec-2022. +.\" Actualizare a traducerii pentru versiunea 5.4.3, făcută de R-GC, mai-2023. +.\" Actualizare a traducerii pentru versiunea 5.4.4-pre1, făcută de R-GC, iul-2023. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre1, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre2, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.7.1-dev1, făcută de R-GC, ian-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.0-pre1, făcută de R-GC, mar-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.2-pre1, făcută de R-GC, oct-2025. +.\" Actualizare a traducerii pentru versiunea Y, făcută de X, Z(luna-anul). +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 "6 martie 2025" Tukaani "Utilități XZ" +.SH NUME +xzcmp, xzdiff, lzcmp, lzdiff \- compară fișierele comprimate +. +.SH REZUMAT +\fBxzcmp\fP [\fIopțiune...\fP] \fIfișier1\fP [\fIfișier2\fP] +.br +\fBxzdiff\fP \&... +.br +\fBlzcmp\fP \&... (DEPRECIATĂ) +.br +\fBlzdiff\fP \&... (DEPRECIATĂ) +. +.SH DESCRIERE +\fBxzcmp\fP și \fBxzdiff\fP compară conținutul necomprimat a două fișiere. Datele +necomprimate și opțiunile sunt transmise la \fBcmp\fP(1) sau \fBdiff\fP(1), cu +excepția cazului în care se specifică \fB\-\-help\fP sau \fB\-\-version\fP. +.PP +Dacă sunt specificate atât \fIfișier1\fP, cât și \fIfișier2\fP, acestea pot fi +fișiere necomprimate sau fișiere în formate pe care \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) sau \fBlz4\fP(1) le poate +decomprima. Comenzile de decomprimare necesare sunt determinate de sufixele +numelor de fișiere \fIfișier1\fP și \fIfișier2\fP. Se presupune că un fișier cu un +sufix necunoscut este fie necomprimat, fie într\-un format pe care \fBxz\fP(1) +îl poate decomprima. +.PP +În cazul în care se furnizează un singur nume de fișier, \fIfișier1\fP trebuie +să aibă un sufix al unui format de comprimare acceptat, iar numele pentru +\fIfișier2\fP se presupune că este \fIfișier1\fP fără sufixul formatului de +comprimare. +.PP +Comenzile \fBlzcmp\fP și \fBlzdiff\fP sunt furnizate pentru compatibilitate +retroactivă cu LZMA Utils. Acestea sunt depreciate și vor fi eliminate +într\-o versiune viitoare. +. +.SH "STARE DE IEȘIRE" +În cazul în care apare o eroare de decomprimare, starea de ieșire este +\fB2\fP. În caz contrar, se utilizează starea de ieșire \fBcmp\fP(1) sau +\fBdiff\fP(1). +. +.SH "CONSULTAȚI ȘI" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xzdec.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xzdec.1 new file mode 100644 index 0000000000000000000000000000000000000000..2ba0113bc2dc5fc4bcde0c55e3c252171781c716 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xzdec.1 @@ -0,0 +1,101 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.\" Romanian translation for xz-man. +.\" Mesajele în limba română pentru manualul pachetului XZ Utils. +.\" Remus-Gabriel Chelu , 2022 - 2025. +.\" Cronologia traducerii fișierului „xz-man”: +.\" Traducerea inițială, făcută de R-GC, pentru versiunea xz-man 5.4.0-pre1. +.\" Actualizare a traducerii pentru versiunea 5.4.0-pre2, făcută de R-GC, dec-2022. +.\" Actualizare a traducerii pentru versiunea 5.4.3, făcută de R-GC, mai-2023. +.\" Actualizare a traducerii pentru versiunea 5.4.4-pre1, făcută de R-GC, iul-2023. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre1, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre2, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.7.1-dev1, făcută de R-GC, ian-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.0-pre1, făcută de R-GC, mar-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.2-pre1, făcută de R-GC, oct-2025. +.\" Actualizare a traducerii pentru versiunea Y, făcută de X, Z(luna-anul). +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDEC 1 "8 aprilie 2024" Tukaani "Utilități XZ" +.SH NUME +xzdec, lzmadec \- Programe de decomprimare mici de fișiere .xz și .lzma +.SH REZUMAT +\fBxzdec\fP [\fIopțiune...\fP] [\fIfișier...\fP] +.br +\fBlzmadec\fP [\fIopțiune...\fP] [\fIfișier...\fP] +.SH DESCRIERE +\fBxzdec\fP este un instrument de decomprimare bazat pe liblzma pentru +fișierele \fB.xz\fP (și numai \fB.xz\fP). \fBxzdec\fP este destinat să funcționeze ca +un înlocuitor pentru \fBxz\fP(1) în cele mai frecvente situații în care un +script a fost scris pentru a utiliza \fBxz \-\-decompress \-\-stdout\fP (și posibil +câteva alte opțiuni frecvent utilizate) pentru a decomprima fișierele +\&\fB.xz\fP. \fBlzmadec\fP este identic cu \fBxzdec\fP cu excepția faptului că +\fBlzmadec\fP acceptă fișierele \fB.lzma\fP în loc de fișierele \fB.xz\fP. +.PP +Pentru a reduce dimensiunea executabilului, \fBxzdec\fP nu acceptă modul cu mai +multe fire de execuție sau localizarea(afișarea mesajelor în limba stabilită +de configurările regionale) și nu citește opțiunile din variabilele de mediu +\fBXZ_DEFAULTS\fP și \fBXZ_OPT\fP. \fBxzdec\fP nu acceptă afișarea informațiilor +intermediare de progres: trimiterea semnalului \fBSIGINFO\fP la \fBxzdec\fP nu +face nimic, iar trimiterea semnalului \fBSIGUSR1\fP încheie procesul în loc să +afișeze informații despre progres. +.SH OPȚIUNI +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +Ignorat pentru compatibilitate cu \fBxz\fP(1). \fBxzdec\fP acceptă numai +decomprimarea. +.TP +\fB\-k\fP, \fB\-\-keep\fP +Ignorat pentru compatibilitate cu \fBxz\fP(1). \fBxzdec\fP nu creează sau elimină +niciodată niciun fișier. +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Ignorat pentru compatibilitate cu \fBxz\fP(1). \fBxzdec\fP scrie întotdeauna +datele decomprimate la ieșirea standard. +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Specificarea acestui lucru o dată nu face nimic, deoarece \fBxzdec\fP nu +afișează niciodată avertismente sau notificări. Specificați acest lucru de +două ori pentru a suprima erorile. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Ignorat pentru compatibilitate cu \fBxz\fP(1). \fBxzdec\fP nu folosește niciodată +starea de ieșire 2. +.TP +\fB\-h\fP, \fB\-\-help\fP +Afișează un mesaj de ajutor și iese cu succes. +.TP +\fB\-V\fP, \fB\-\-version\fP +Afișează numărul versiunii \fBxzdec\fP și liblzma. +.SH "STARE DE IEȘIRE" +.TP +\fB0\fP +Toate au fost bine. +.TP +\fB1\fP +A apărut o eroare. +.PP +\fBxzdec\fP nu are niciun mesaj de avertizare precum \fBxz\fP(1), astfel că starea +de ieșire 2 nu este folosită de \fBxzdec\fP. +.SH NOTE +Utilizați \fBxz\fP(1) în loc de \fBxzdec\fP sau \fBlzmadec\fP pentru utilizarea +normală de zi cu zi. \fBxzdec\fP sau \fBlzmadec\fP sunt destinate numai +situațiilor în care este important să aveți un instrument de decomprimare +mai mic decât \fBxz\fP(1), cu funcții complete. +.PP +\fBxzdec\fP și \fBlzmadec\fP nu sunt chiar atât de mici. Dimensiunea poate fi +redusă și mai mult prin eliminarea caracteristicilor din liblzma în timpul +compilării, dar acest lucru nu ar trebui să se facă de obicei pentru +executabilele distribuite în distribuții tipice de sisteme de operare +neîncorporate. Dacă aveți nevoie de un instrument de decomprimare \fB.xz\fP cu +adevărat mic, luați în considerare utilizarea XZ Embedded. +.SH "CONSULTAȚI ȘI" +\fBxz\fP(1) +.PP +XZ Embedded: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xzdiff.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xzdiff.1 new file mode 100644 index 0000000000000000000000000000000000000000..cebad3bb3ad049a59a6f1d29360d76fa73a915e4 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xzdiff.1 @@ -0,0 +1,70 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Romanian translation for xz-man. +.\" Mesajele în limba română pentru manualul pachetului XZ Utils. +.\" Remus-Gabriel Chelu , 2022 - 2025. +.\" Cronologia traducerii fișierului „xz-man”: +.\" Traducerea inițială, făcută de R-GC, pentru versiunea xz-man 5.4.0-pre1. +.\" Actualizare a traducerii pentru versiunea 5.4.0-pre2, făcută de R-GC, dec-2022. +.\" Actualizare a traducerii pentru versiunea 5.4.3, făcută de R-GC, mai-2023. +.\" Actualizare a traducerii pentru versiunea 5.4.4-pre1, făcută de R-GC, iul-2023. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre1, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre2, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.7.1-dev1, făcută de R-GC, ian-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.0-pre1, făcută de R-GC, mar-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.2-pre1, făcută de R-GC, oct-2025. +.\" Actualizare a traducerii pentru versiunea Y, făcută de X, Z(luna-anul). +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 "6 martie 2025" Tukaani "Utilități XZ" +.SH NUME +xzcmp, xzdiff, lzcmp, lzdiff \- compară fișierele comprimate +. +.SH REZUMAT +\fBxzcmp\fP [\fIopțiune...\fP] \fIfișier1\fP [\fIfișier2\fP] +.br +\fBxzdiff\fP \&... +.br +\fBlzcmp\fP \&... (DEPRECIATĂ) +.br +\fBlzdiff\fP \&... (DEPRECIATĂ) +. +.SH DESCRIERE +\fBxzcmp\fP și \fBxzdiff\fP compară conținutul necomprimat a două fișiere. Datele +necomprimate și opțiunile sunt transmise la \fBcmp\fP(1) sau \fBdiff\fP(1), cu +excepția cazului în care se specifică \fB\-\-help\fP sau \fB\-\-version\fP. +.PP +Dacă sunt specificate atât \fIfișier1\fP, cât și \fIfișier2\fP, acestea pot fi +fișiere necomprimate sau fișiere în formate pe care \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) sau \fBlz4\fP(1) le poate +decomprima. Comenzile de decomprimare necesare sunt determinate de sufixele +numelor de fișiere \fIfișier1\fP și \fIfișier2\fP. Se presupune că un fișier cu un +sufix necunoscut este fie necomprimat, fie într\-un format pe care \fBxz\fP(1) +îl poate decomprima. +.PP +În cazul în care se furnizează un singur nume de fișier, \fIfișier1\fP trebuie +să aibă un sufix al unui format de comprimare acceptat, iar numele pentru +\fIfișier2\fP se presupune că este \fIfișier1\fP fără sufixul formatului de +comprimare. +.PP +Comenzile \fBlzcmp\fP și \fBlzdiff\fP sunt furnizate pentru compatibilitate +retroactivă cu LZMA Utils. Acestea sunt depreciate și vor fi eliminate +într\-o versiune viitoare. +. +.SH "STARE DE IEȘIRE" +În cazul în care apare o eroare de decomprimare, starea de ieșire este +\fB2\fP. În caz contrar, se utilizează starea de ieșire \fBcmp\fP(1) sau +\fBdiff\fP(1). +. +.SH "CONSULTAȚI ȘI" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xzegrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xzegrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..fc411dfa1f83b5dfc4fa390829a8be970e426b47 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xzegrep.1 @@ -0,0 +1,107 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Romanian translation for xz-man. +.\" Mesajele în limba română pentru manualul pachetului XZ Utils. +.\" Remus-Gabriel Chelu , 2022 - 2025. +.\" Cronologia traducerii fișierului „xz-man”: +.\" Traducerea inițială, făcută de R-GC, pentru versiunea xz-man 5.4.0-pre1. +.\" Actualizare a traducerii pentru versiunea 5.4.0-pre2, făcută de R-GC, dec-2022. +.\" Actualizare a traducerii pentru versiunea 5.4.3, făcută de R-GC, mai-2023. +.\" Actualizare a traducerii pentru versiunea 5.4.4-pre1, făcută de R-GC, iul-2023. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre1, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre2, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.7.1-dev1, făcută de R-GC, ian-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.0-pre1, făcută de R-GC, mar-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.2-pre1, făcută de R-GC, oct-2025. +.\" Actualizare a traducerii pentru versiunea Y, făcută de X, Z(luna-anul). +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 "6 martie 2025" Tukaani "Utilități XZ" +.SH NUME +xzgrep \- caută modele în fișiere posibil comprimate +. +.SH REZUMAT +\fBxzgrep\fP [\fIopțiune...\fP] \fIlistă\-modele\fP [\fIfișier...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (DEPRECIATĂ) +.br +\fBlzegrep\fP \&... (DEPRECIATĂ) +.br +\fBlzfgrep\fP \&... (DEPRECIATĂ) +. +.SH DESCRIERE +\fBxzgrep\fP invocă \fBgrep\fP(1) asupra conținutului necomprimat al +fișierelor. Formatele \fIfișierelor\fP sunt determinate de sufixele numelor de +fișiere. Orice \fIfișier\fP cu un sufix acceptat de \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) sau \fBlz4\fP(1) va fi decomprimat; toate +celelalte fișiere sunt presupuse a fi necomprimate. +.PP +Dacă nu se specifică niciun \fIfișier\fP sau dacă \fIfișier\fP este \fB\-\fP, se +citește intrarea standard. Atunci când se citește de la intrarea standard, +sunt decomprimate numai fișierele acceptate de \fBxz\fP(1). Se presupune că +celelalte fișiere sunt deja în format necomprimat. +.PP +Sunt acceptate majoritatea \fIopțiunilor\fP din \fBgrep\fP(1). Cu toate acestea, +următoarele opțiuni nu sunt acceptate: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIacțiune\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglobal\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglobal\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIfișier\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglobal\fP +.PP +\fBxzegrep\fP este un alias pentru \fBxzgrep \-E\fP. \fBxzfgrep\fP este un alias +pentru \fBxzgrep \-F\fP. +.PP +Comenzile \fBlzgrep\fP, \fBlzegrep\fP și \fBlzfgrep\fP sunt furnizate pentru +compatibilitate retroactivă cu LZMA Utils. Acestea sunt depreciate și vor fi +eliminate într\-o versiune viitoare. +. +.SH "STARE DE IEȘIRE" +.TP +0 +A fost găsită cel puțin o potrivire din cel puțin unul dintre fișierele de +la intrare. Nu au apărut erori. +.TP +1 +Nu au fost găsite potriviri din niciunul dintre fișierele de la intrare. Nu +au apărut erori. +.TP +>1 +A apărut una sau mai multe erori. Nu se cunoaște dacă au fost găsite +potriviri. +. +.SH "VARIABILE DE MEDIU" +.TP +\fBGREP\fP +Dacă variabila de mediu \fBGREP\fP este stabilită la o valoare nevidă, aceasta +este utilizată în locul lui \fBgrep\fP, \fBgrep \-E\fP sau \fBgrep \-F\fP. +. +.SH "CONSULTAȚI ȘI" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xzfgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xzfgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..fc411dfa1f83b5dfc4fa390829a8be970e426b47 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xzfgrep.1 @@ -0,0 +1,107 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Romanian translation for xz-man. +.\" Mesajele în limba română pentru manualul pachetului XZ Utils. +.\" Remus-Gabriel Chelu , 2022 - 2025. +.\" Cronologia traducerii fișierului „xz-man”: +.\" Traducerea inițială, făcută de R-GC, pentru versiunea xz-man 5.4.0-pre1. +.\" Actualizare a traducerii pentru versiunea 5.4.0-pre2, făcută de R-GC, dec-2022. +.\" Actualizare a traducerii pentru versiunea 5.4.3, făcută de R-GC, mai-2023. +.\" Actualizare a traducerii pentru versiunea 5.4.4-pre1, făcută de R-GC, iul-2023. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre1, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre2, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.7.1-dev1, făcută de R-GC, ian-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.0-pre1, făcută de R-GC, mar-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.2-pre1, făcută de R-GC, oct-2025. +.\" Actualizare a traducerii pentru versiunea Y, făcută de X, Z(luna-anul). +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 "6 martie 2025" Tukaani "Utilități XZ" +.SH NUME +xzgrep \- caută modele în fișiere posibil comprimate +. +.SH REZUMAT +\fBxzgrep\fP [\fIopțiune...\fP] \fIlistă\-modele\fP [\fIfișier...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (DEPRECIATĂ) +.br +\fBlzegrep\fP \&... (DEPRECIATĂ) +.br +\fBlzfgrep\fP \&... (DEPRECIATĂ) +. +.SH DESCRIERE +\fBxzgrep\fP invocă \fBgrep\fP(1) asupra conținutului necomprimat al +fișierelor. Formatele \fIfișierelor\fP sunt determinate de sufixele numelor de +fișiere. Orice \fIfișier\fP cu un sufix acceptat de \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) sau \fBlz4\fP(1) va fi decomprimat; toate +celelalte fișiere sunt presupuse a fi necomprimate. +.PP +Dacă nu se specifică niciun \fIfișier\fP sau dacă \fIfișier\fP este \fB\-\fP, se +citește intrarea standard. Atunci când se citește de la intrarea standard, +sunt decomprimate numai fișierele acceptate de \fBxz\fP(1). Se presupune că +celelalte fișiere sunt deja în format necomprimat. +.PP +Sunt acceptate majoritatea \fIopțiunilor\fP din \fBgrep\fP(1). Cu toate acestea, +următoarele opțiuni nu sunt acceptate: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIacțiune\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglobal\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglobal\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIfișier\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglobal\fP +.PP +\fBxzegrep\fP este un alias pentru \fBxzgrep \-E\fP. \fBxzfgrep\fP este un alias +pentru \fBxzgrep \-F\fP. +.PP +Comenzile \fBlzgrep\fP, \fBlzegrep\fP și \fBlzfgrep\fP sunt furnizate pentru +compatibilitate retroactivă cu LZMA Utils. Acestea sunt depreciate și vor fi +eliminate într\-o versiune viitoare. +. +.SH "STARE DE IEȘIRE" +.TP +0 +A fost găsită cel puțin o potrivire din cel puțin unul dintre fișierele de +la intrare. Nu au apărut erori. +.TP +1 +Nu au fost găsite potriviri din niciunul dintre fișierele de la intrare. Nu +au apărut erori. +.TP +>1 +A apărut una sau mai multe erori. Nu se cunoaște dacă au fost găsite +potriviri. +. +.SH "VARIABILE DE MEDIU" +.TP +\fBGREP\fP +Dacă variabila de mediu \fBGREP\fP este stabilită la o valoare nevidă, aceasta +este utilizată în locul lui \fBgrep\fP, \fBgrep \-E\fP sau \fBgrep \-F\fP. +. +.SH "CONSULTAȚI ȘI" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xzgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xzgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..fc411dfa1f83b5dfc4fa390829a8be970e426b47 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xzgrep.1 @@ -0,0 +1,107 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Romanian translation for xz-man. +.\" Mesajele în limba română pentru manualul pachetului XZ Utils. +.\" Remus-Gabriel Chelu , 2022 - 2025. +.\" Cronologia traducerii fișierului „xz-man”: +.\" Traducerea inițială, făcută de R-GC, pentru versiunea xz-man 5.4.0-pre1. +.\" Actualizare a traducerii pentru versiunea 5.4.0-pre2, făcută de R-GC, dec-2022. +.\" Actualizare a traducerii pentru versiunea 5.4.3, făcută de R-GC, mai-2023. +.\" Actualizare a traducerii pentru versiunea 5.4.4-pre1, făcută de R-GC, iul-2023. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre1, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre2, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.7.1-dev1, făcută de R-GC, ian-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.0-pre1, făcută de R-GC, mar-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.2-pre1, făcută de R-GC, oct-2025. +.\" Actualizare a traducerii pentru versiunea Y, făcută de X, Z(luna-anul). +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 "6 martie 2025" Tukaani "Utilități XZ" +.SH NUME +xzgrep \- caută modele în fișiere posibil comprimate +. +.SH REZUMAT +\fBxzgrep\fP [\fIopțiune...\fP] \fIlistă\-modele\fP [\fIfișier...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (DEPRECIATĂ) +.br +\fBlzegrep\fP \&... (DEPRECIATĂ) +.br +\fBlzfgrep\fP \&... (DEPRECIATĂ) +. +.SH DESCRIERE +\fBxzgrep\fP invocă \fBgrep\fP(1) asupra conținutului necomprimat al +fișierelor. Formatele \fIfișierelor\fP sunt determinate de sufixele numelor de +fișiere. Orice \fIfișier\fP cu un sufix acceptat de \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) sau \fBlz4\fP(1) va fi decomprimat; toate +celelalte fișiere sunt presupuse a fi necomprimate. +.PP +Dacă nu se specifică niciun \fIfișier\fP sau dacă \fIfișier\fP este \fB\-\fP, se +citește intrarea standard. Atunci când se citește de la intrarea standard, +sunt decomprimate numai fișierele acceptate de \fBxz\fP(1). Se presupune că +celelalte fișiere sunt deja în format necomprimat. +.PP +Sunt acceptate majoritatea \fIopțiunilor\fP din \fBgrep\fP(1). Cu toate acestea, +următoarele opțiuni nu sunt acceptate: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIacțiune\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglobal\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglobal\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIfișier\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglobal\fP +.PP +\fBxzegrep\fP este un alias pentru \fBxzgrep \-E\fP. \fBxzfgrep\fP este un alias +pentru \fBxzgrep \-F\fP. +.PP +Comenzile \fBlzgrep\fP, \fBlzegrep\fP și \fBlzfgrep\fP sunt furnizate pentru +compatibilitate retroactivă cu LZMA Utils. Acestea sunt depreciate și vor fi +eliminate într\-o versiune viitoare. +. +.SH "STARE DE IEȘIRE" +.TP +0 +A fost găsită cel puțin o potrivire din cel puțin unul dintre fișierele de +la intrare. Nu au apărut erori. +.TP +1 +Nu au fost găsite potriviri din niciunul dintre fișierele de la intrare. Nu +au apărut erori. +.TP +>1 +A apărut una sau mai multe erori. Nu se cunoaște dacă au fost găsite +potriviri. +. +.SH "VARIABILE DE MEDIU" +.TP +\fBGREP\fP +Dacă variabila de mediu \fBGREP\fP este stabilită la o valoare nevidă, aceasta +este utilizată în locul lui \fBgrep\fP, \fBgrep \-E\fP sau \fBgrep \-F\fP. +. +.SH "CONSULTAȚI ȘI" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xzless.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xzless.1 new file mode 100644 index 0000000000000000000000000000000000000000..9bd9b2c296d7b6921c54b05a3508a9b2dd281db7 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xzless.1 @@ -0,0 +1,60 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" Romanian translation for xz-man. +.\" Mesajele în limba română pentru manualul pachetului XZ Utils. +.\" Remus-Gabriel Chelu , 2022 - 2025. +.\" Cronologia traducerii fișierului „xz-man”: +.\" Traducerea inițială, făcută de R-GC, pentru versiunea xz-man 5.4.0-pre1. +.\" Actualizare a traducerii pentru versiunea 5.4.0-pre2, făcută de R-GC, dec-2022. +.\" Actualizare a traducerii pentru versiunea 5.4.3, făcută de R-GC, mai-2023. +.\" Actualizare a traducerii pentru versiunea 5.4.4-pre1, făcută de R-GC, iul-2023. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre1, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre2, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.7.1-dev1, făcută de R-GC, ian-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.0-pre1, făcută de R-GC, mar-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.2-pre1, făcută de R-GC, oct-2025. +.\" Actualizare a traducerii pentru versiunea Y, făcută de X, Z(luna-anul). +.\" +.\" (Note that this file is not based on gzip's zless.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZLESS 1 "6 martie 2025" Tukaani "Utilități XZ" +.SH NUME +xzless, lzless \- vizualizează fișierele (text) comprimate xz sau lzma +.SH REZUMAT +\fBxzless\fP [\fIfișier\fP...] +.br +\fBlzless\fP [\fIfișier\fP...] (DEPRECIATĂ) +.SH DESCRIERE +\fBxzless\fP este un filtru care afișează textul din fișierele comprimate pe un +terminal. Fișierele acceptate de \fBxz\fP(1) sunt decomprimate; se presupune că +celelalte fișiere sunt deja în format necomprimat. Dacă nu se dă nici un +\fIfișier\fP, \fBxzless\fP citește de la intrarea standard. +.PP +\fBxzless\fP folosește \fBless\fP(1) pentru a\-și prezenta rezultatul. Spre +deosebire de \fBxzmore\fP, alegerea sa de pager nu poate fi modificată prin +definirea unei variabile de mediu. Comenzile se bazează atât pe \fBmore\fP(1) +cât și pe \fBvi\fP(1) și permit mișcarea înainte și înapoi și +căutarea. Consultați manualul \fBless\fP(1) pentru mai multe informații. +.PP +Comanda numită \fBlzless\fP este furnizată pentru compatibilitatea cu LZMA +Utils. Aceasta este depreciată și va fi eliminată într\-o versiune viitoare. +.SH "VARIABILE DE MEDIU" +.TP +\fBLESSMETACHARS\fP +O listă de caractere speciale pentru shell. Definită de \fBxzless\fP, cu +excepția cazului în care este deja definită în mediu. +.TP +\fBLESSOPEN\fP +Aceasta este definită în linia de comandă pentru a invoca instrumentul de +decomprimare \fBxz\fP(1) pentru preprocesarea fișierelor de intrare pentru +\fBless\fP(1). +.SH "CONSULTAȚI ȘI" +\fBless\fP(1), \fBxz\fP(1), \fBxzmore\fP(1), \fBzless\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xzmore.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xzmore.1 new file mode 100644 index 0000000000000000000000000000000000000000..dbc1541830568b68b48e9d554a71a90eff23a612 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/ro/man1/xzmore.1 @@ -0,0 +1,62 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" Romanian translation for xz-man. +.\" Mesajele în limba română pentru manualul pachetului XZ Utils. +.\" Remus-Gabriel Chelu , 2022 - 2025. +.\" Cronologia traducerii fișierului „xz-man”: +.\" Traducerea inițială, făcută de R-GC, pentru versiunea xz-man 5.4.0-pre1. +.\" Actualizare a traducerii pentru versiunea 5.4.0-pre2, făcută de R-GC, dec-2022. +.\" Actualizare a traducerii pentru versiunea 5.4.3, făcută de R-GC, mai-2023. +.\" Actualizare a traducerii pentru versiunea 5.4.4-pre1, făcută de R-GC, iul-2023. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre1, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.6.0-pre2, făcută de R-GC, feb-2024. +.\" Actualizare a traducerii pentru versiunea 5.7.1-dev1, făcută de R-GC, ian-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.0-pre1, făcută de R-GC, mar-2025. +.\" Actualizare a traducerii pentru versiunea 5.8.2-pre1, făcută de R-GC, oct-2025. +.\" Actualizare a traducerii pentru versiunea Y, făcută de X, Z(luna-anul). +.\" +.\" (Note that this file is based on xzless.1 instead of gzip's zmore.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZMORE 1 "6 martie 2025" Tukaani "Utilități XZ" +.SH NUME +xzmore, lzmore \- vizualizează fișierele (text) comprimate xz sau lzma +. +.SH REZUMAT +\fBxzmore\fP [\fIfișier\fP...] +.br +\fBlzmore\fP [\fIfișier\fP...] (DEPRECIATĂ) +. +.SH DESCRIERE +\fBxzmore\fP afișează textul din fișierele comprimate pe un terminal folosind +\fBmore\fP(1). Fișierele acceptate de \fBxz\fP(1) sunt decomprimate; se presupune +că celelalte fișiere sunt deja în format necomprimat. Dacă nu se dă nici un +\fIfișiere\fP, \fBxzmore\fP citește de la intrarea standard. Consultați manualul +\fBmore\fP(1) pentru comenzile de la tastatură. +.PP +Rețineți că este posibil ca derularea înapoi să nu fie posibilă în funcție +de implementarea lui \fBmore\fP(1). Acest lucru se datorează faptului că +\fBxzmore\fP utilizează o conductă pentru a transmite datele decomprimate către +\fBmore\fP(1). \fBxzless\fP(1) utilizează \fBless\fP(1) care oferă caracteristici mai +avansate. +.PP +Comanda \fBlzmore\fP este furnizată pentru compatibilitate retroactivă cu LZMA +Utils. Aceasta este depreciată și va fi eliminată într\-o versiune viitoare. +. +.SH "VARIABILE DE MEDIU" +.TP +.\" TRANSLATORS: Don't translate the uppercase PAGER. +.\" It is a name of an environment variable. +\fBPAGER\fP +Dacă variabila de mediu \fBPAGER\fP, este definită, valoarea sa este utilizată +ca paginator în loc de \fBmore\fP(1). +. +.SH "CONSULTAȚI ȘI" +\fBmore\fP(1), \fBxz\fP(1), \fBxzless\fP(1), \fBzmore\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzcat.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzcat.1 new file mode 100644 index 0000000000000000000000000000000000000000..82d831001e1f400683d876e945d108fa8686a45a --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzcat.1 @@ -0,0 +1,1928 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Serbian translation of xz-man. +.\" Мирослав Николић , 2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 08.03.2025. Tukaani "XZ Utils" +. +.SH НАЗИВ +xz, unxz, xzcat, lzma, unlzma, lzcat – Запакује или распакује „.xz“ и „.lzma +датотеке +. +.SH САЖЕТАК +\fBxz\fP [\fIопција...\fP] [\fIдатотека...\fP] +. +.SH "АЛИЈАСИ НАРЕДБЕ" +\fBunxz\fP је исто као и \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP је исто као и \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP је исто као и \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP је исто као и \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP је исто као и \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Приликом писања скрипти које треба да распакују датотеке, препоручује се да +се увек користи назив \fBxz\fP са одговарајућим аргументима (\fBxz \-d\fP или \fBxz \-dc\fP) уместо назива \fBunxz\fP и \fBxzcat\fP. +. +.SH ОПИС +\fBxz\fP је алат опште употребе за запакивање података са синтаксом линије +наредби сличан као \fBgzip\fP(1) и \fBbzip2\fP(1). Изворни формат датотеке је +\&\fB.xz\fP формат, али стари \fB.lzma\fP формат који користи LZMA Utils и сирови +запаковани токови без заглавља формата су такође подржани. Уз то, +распакивање \fB.lz\fP формата који користи \fBlzip\fP је подржано. +.PP +\fBxz\fP запакује или распакује сваку \fIдатотеку\fP у складу са изабраним режимом +рада. Ако није дата ни једна \fIдатотека\fP или је датотека \fIfile\fP \fB\-\fP, +\fBxz\fP чита са стандардног улаза и записује обрађене податке на стандардни +излаз. \fBxz\fP ће одбити (приказаће грешку и прескочити \fIдатотеку\fP) да пише +запаковане податке на стандардни излаз ако је то терминал. Слично, \fBxz\fP ће +одбити да чита запаковане податке са стандардног улаза ако је то терминал. +.PP +Осим ако није наведено \fB\-\-stdout\fP, \fIдатотеке\fP које нису \fB\-\fP се пишу у +нову датотеку чији назив је проистекао из назива изворне \fIдатотеке\fP: +.IP \(bu 3 +Приликом запакивања, суфикс формата циљне датотеке (\fB.xz\fP или \fB.lzma\fP) се +додаје на назив изворне датотеке да би се добио назив циљне датотеке. +.IP \(bu 3 +Приликом распакивања, суфикс \fB.xz\fP, \fB.lzma\fP или \fB.lz\fP се уклања из назива +датотеке да би се добио назив циљне датотеке. \fBxz\fP такође препознаје +суфиксе \fB.txz\fP и \fB.tlz\fP и замењује их суфиксом \fB.tar\fP. +.PP +Ако циљна датотека већ пстоји, приказује се грешка а \fIдатотека\fP се +прескаче. +.PP +Осим ако не пише на стандардни излаз, \fBxz\fP ће приказати упозорење и +прескочити \fIдатотеку\fP ако се нешто од следећег примењује: +.IP \(bu 3 +\fIДатотека\fP није обична датотека. Симболичке везе се не прате, и стога се +не сматра да су обичне датотеке. +.IP \(bu 3 +\fIДатотека\fP има више од једне чврсте везе. +.IP \(bu 3 +\fIДатотека\fP има постављен „setuid, setgid“ или лепљиви бит. +.IP \(bu 3 +Режим рада је постављен на запакивање а \fIдатотека\fP већ има суфикс формата +циљне датотеке (\fB.xz\fP или \fB.txz\fP приликом запакивања у \fB.xz\fP формат, а +\&\fB.lzma\fP или \fB.tlz\fP приликом запакивања у \fB.lzma\fP формат). +.IP \(bu 3 +Режим радње је постављен за распакивање а \fIдатотека\fP нема суфикс ни једног +од подржаних формата датотеке (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP или +\&\fB.lz\fP). +.PP +Након успешног сажимања или распакивања \fIдатотеке\fP, \fBxz\fP умножава +власника, групу, дозволе, време приступа и време измене из изворне +\fIдатотеке\fP у циљну датотеку. Ако умножавање групе не успе, дозволе су +измењене тако да циљна датотека не постане доступна корисницима који нису +имали дозволу за приступ изворној \fIдатотеци\fP. \fBxz\fP не подржава умножавање +других метаподатака попут списка контрола приступа или проширених атрибута. +.PP +Једном када је циљна датотека успешно затворена, изворна \fIдатотека\fP се +уклања осим ако се \fB\-keep\fP не наведе. Изворна \fIдатотека\fP се никада не +уклања ако се излаз пише на стандардни излаз или ако дође до грешке. +.PP +Слање \fBSIGINFO\fP или \fBSIGUSR1\fP ка \fBxz\fP процесу чини да испише информације +напредовања на стандардну грешку. Ово има ограничено коришћење све док +стандардна грешка јесте терминал, коришћење \fB\-\-verbose\fP приказаће +аутоматски указивач напретка освежавања. +. +.SS "Коришћење меморије" +Коришћење меморије \fBxz\fP се мења од неколико стотина килобајта до неколико +гигабајта у зависности од поставки запакивања. Поставке коришћене приликом +запакивања датотеке одређују захтеве меморије распакивача. Обично +распакивачу треба 5\ % до 20\ % количине меморије која је потребна +запакивачу приликом прављења датотеке. На пример, распакивање датотеке +направљене са \fBxz \-9\fP тренутно захтева 65\ MiB меморије. Још увек, могуће +је имати \fB.xz\fP датотеке које захтевају неколико гигабајта меморије за +распакивање. +.PP +Нарочито корисници старијих система могу наћи досадном могућност коришћења +врло велике меморије. Да би се спречила нежељена изненађења, \fBxz\fP има +уграђен ограничавач коришћења меморије, који је искључен по основи. Док +неки оперативни системи пружају начин за ограничавање коришћење меморије за +процесе, ослањање на то сматра се да није довољно прилагодљиво (на пример, +коришћење \fBulimit\fP(1) за ограничавање виртуелне меморије тежи да обогаљи +\fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Ограничавач коришћења меморије се може укључити опцијом линије наредби +\fB\-\-memlimit=\fP\fIограничење\fP. Често је најпогодније укључити ограничавач по +основи постављањем променљиве окружења \fBXZ_DEFAULTS\fP, на пример, +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Могуће је поставити ограничења засебно за +запакивање и распакивање коришћењем \fB\-\-memlimit\-compress=\fP\fIограничење\fP и +\fB\-\-memlimit\-decompress=\fP\fIограничење\fP. Коришћење ове две опције ван +\fBXZ_DEFAULTS\fP је ретко корисно јер једно покретање \fBxz\fP не може да ради и +запакивање и распакивање а \fB\-\-memlimit=\fP\fIограничење\fP (или \fB\-M\fP +\fIограничење\fP) је краће за куцање на линији наредби. +.PP +Ако је прекорачено наведено ограничење коришћења меморије, \fBxz\fP ће +приказати грешку а распакивање датотеке неће успети. Ако је ограничење +прекорачено приликом запакивања, \fBxz\fP ће покушати да умањи поставке тако да +се ограничење више не прекорачује (оси када се користи \fB\-\-format=raw\fP или +\fB\-\-no\-adjust\fP). На тај начин радња неће бити неуспешна осим ако је +ограничење врло мало. Смањење поставке се ради у корацима који се не +подударају са предподешеностима нивоа запакивања, на пример, ако је +ограничење само незнатно мање од износа потребног за \fBxz \-9\fP, поставке ће +бити смањене само мало, а не све до \fBxz \-8\fP. +. +.SS "Надовезивање и попуњавање са „.xz“ датотекама" +Могуће је додати \fB.xz\fP датотеке као то. \fBxz\fP ће распаковати такве +датотеке као да су биле једна \fB.xz\fP датотека. +.PP +Могуће је уметнути попуњавање између придодатих делова или након последњег +дела. Попуњавање мора да се састоји од празних бајтова а величина +попуњавања мора бити умножак четири бајта. Ово може бити корисно, на +пример, ако је \fB.xz\fP датотека смештена на медијуму који мери величине +датотека у блоковима од 512 бајтова. +.PP +Надовезивање и попуњавање нису дозвољени са \fB.lzma\fP датотекама или сировим +токовима. +. +.SH ОПЦИЈЕ +. +.SS "Суфикси целог броја и специјалне вредности" +На већини места где се очекује аргумент целог броја, опционални суфикс је +подржан да би се лако назначили велики цели бројеви. Не сме бити размака +између целог броја и суфикса. +.TP +\fBKiB\fP +Множи цео број са 1.024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP, и \fBKB\fP се +прихватају као синоними за \fBKiB\fP. +.TP +\fBMiB\fP +Множи цео број са 1.048.576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP, и \fBMB\fP се +прихватају као синоними за \fBMiB\fP. +.TP +\fBGiB\fP +Множи цео број са 1.073.741.824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP, и \fBGB\fP се +прихватају као синоними за \fBGiB\fP. +.PP +Посебна вредност \fBmax\fP се може користити да укаже на највећу вредност целог +броја подржану опцијом. +. +.SS "Режим рада" +Ако је дато више опција режима рада, последња има дејства. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Запакује. Ово је основни режим радње када није наведена опција режима радње +и ниједан други режим радње се не подразумева са линије радње (на пример, +\fBunxz\fP подразумева \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Након успешног запакивања, изворна датотека се уклања осим ако се не пише на +стандардни излаз или је наведено \fB\-\-keep\fP. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Распакује. Након успешног распакивања, изворна датотека се уклања осим ако +се не пише на стандардни излаз или је наведено \fB\-\-keep\fP. +.TP +\fB\-t\fP, \fB\-\-test\fP +Тестира целовитост запакованих \fIдатотека\fP. Ова опција је исто што и +\fB\-\-decompress \-\-stdout\fP осим тога што се распаковани подаци одбацују уместо +да се пишу на стандардни излаз. Датотеке се не праве нити уклањају. +.TP +\fB\-l\fP, \fB\-\-list\fP +Исписује информације о запакованим \fIдатотекама\fP. Никакав незапакован излаз +се не добија, а ниједна датотека није направљена или уклоњена. У режиму +списка, програм не може читати запаковане податке са стандардног улаза или +из других нетраживих извора. +.IP "" +Основни списак приказује основне информације о \fIдатотекама\fP, једна датотека +у једном реду. Да добијете подробније информације, користите такође опцију +\fB\-\-verbose\fP. За чак и више информација, користите \fB\-\-verbose\fP два пуа, +али знајте да то може бити споро, јер да би се добиле све додатне +информације потребно је много тражења. Ширина опширног излаза премашује 80 +знакова, тако да преспајање излаза на, на пример, \fBless\ \-S\fP може бити +прикладно ако терминал није довољно широк. +.IP "" +Тачан излаз може варирати између \fBxz\fP издања и различитих језика. За излаз +читљив машинама треба да користите \fB\-\-robot \-\-list\fP. +. +.SS "Измењивачи рада" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Не брише улазне датотеке. +.IP "" +Од \fBxz\fP 5.2.6, ова опција такође чини да \fBxz\fP запакује или распакује чак и +ако је улаз симболичка веза ка обичној датотеци, има више од једне чврсте +везе или има постављен „setuid“, „setgid“ или лепљиви бит. „setuid“, +„setgid“ и лепљиви битови се не умножавају у циљну датотеку. У ранијим +издањима ово се могло урадити само са \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Ова опција има неколико дејстава: +.RS +.IP \(bu 3 +Ако циљна датотека већ постоји, брише је пре запакивања или распакивања. +.IP \(bu 3 +Запакује или распакује чак и ако је улаз симболичка веза ка обичној +датотеци, има више од једне чврсте везе или има постављен „setgid“, „setgid“ +или лепљиви бит. „setgid“, „setgid“ или лепљиви бит се не умножавају у +циљну датотеку. +.IP \(bu 3 +Када се користи са \fB\-\-decompress\fP \fB\-\-stdout\fP и \fBxz\fP не може да препозна +врсту изворне датотеке, умножава изворну датотеку као такву на стандардни +излаз. Ово омогућава да се \fBxzcat\fP \fB\-\-force\fP користи као \fBcat\fP(1) за +датотекекоје нису запаковане са \fBxz\fP. Знајте да ће у будућности, \fBxz\fP +моћи да подржава нове формате запаковане датотеке, који могу учинити да +\fBxz\fP распакује још врста датотека уместо да их умножи какве јесу на +стандардни излаз. \fB\-\-format=\fP\fIформат\fP се може користити да ограничи \fBxz\fP +да распакује само формат једне датотеке. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Пише запаковане или распаковане податке на стандардни излаз уместо у +датотеку, Ово подразумева \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Распакује само први \fB.xz\fP ток, и тихо занемарује могуће преостале улазне +податке који следе ток. Нормално такво пратеће смеће чини да \fBxz\fP прикаже +грешку. +.IP "" +\fBxz\fP никада не распакује више од једног тока из \fB.lzma\fP датотека или +сирових токова, али ова опција чини да \fBxz\fP још увек занемари могуће +пратеће податке након \fB.lzma\fP датотеке или сировог тока. +.IP "" +Ова опција нема дејства ако режим рада није \fB\-\-decompress\fP или \fB\-\-test\fP. +.IP "" +Од \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP подразумева \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Искључује стварање развучених датотека. По основи, ако распакује у обичну +датотеку, \fBxz\fP покушава да учини датотеку развученом ако распаковани подаци +садрже дуге низове бинарних нула. Такође ради приликом писања на стандардни +излаз све док је стандардни излаз повезан са обичном датотеком а одређени +додатни услови су испуњени да је учине безбедном. Стварање развучених +датотека може уштедети простор на диску и убрзати распакивање смањењем +количине У/И диска. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Приликом запакивања, користите \fI.suf\fP као суфикс за циљну датотеку уместо +\&\fB.xz\fP или \fB.lzma\fP. Ако се не пише на стандардни излаз а изворна датотека +већ има суфикс \fI.suf\fP, приказује се упозорење и датотека се прескаче. +.IP "" +Приликом распакивања, препознаје датотеке са суфиксом \fI.suf\fP поред датотека +са суфиксом \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, or \fB.lz\fP. Ако изворна +датотека има суфикс \fI.suf\fP, суфикс се уклања да би се добио назив циљне +датотеке. +.IP "" +Приликом запакивања или распакивања сирових токова (\fB\-\-format=raw\fP), суфикс +мора увек бити наведен осим ако се не пише на стандардни излаз, јер не +постоји основни суфикс за сирове токове. +.TP +\fB\-\-files\fP[\fB=\fP\fIдатотека\fP] +Чита називе датотека за обраду из \fIдатотеке\fP; ако се \fIдатотека\fP изостави, +називи датотека се читају са стандардног улаза. Називи датотека се морају +завршавати знаком новог реда. Цртица (\fB\-\fP) се узима као редован назив +датотеке; а не стандардни улаз. Ако су називи датотека дати такође као +аргументи линије наредби, обрађују се пре него што се називи датотека +прочитају из \fIдатотеке\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIдатотека\fP] +Ово је исто као и \fB\-\-files\fP[\fB=\fP\fIдатотека\fP] изузев тога што сваки назив +датотеке мора да се завршава „null“ знаком. +. +.SS "Основни формат датотеке и опције запакивања" +.TP +\fB\-F\fP \fIформат\fP, \fB\-\-format=\fP\fIформат\fP +Наводи \fIформат\fP датотеке за запакивање или распакивање: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Ово је основно. Приликом запакивања, \fBauto\fP је исто што и \fBxz\fP. Приликом +распакивања, формат улазне датотеке се аутоматски препознаје. Знајте да +сирови токови (направљени са \fB\-\-format=raw\fP) не могу бити аутоматски +препознати. +.TP +\fBxz\fP +Пакује у \fB.xz\fP формат датотеке, или прихвата само \fB.xz\fP датотеке приликом +распакивања. +.TP +\fBlzma\fP, \fBalone\fP +Пакује у стари \fB.lzma\fP формат датотеке, или прихвата само \fB.lzma\fP датотеке +приликом распакивања. Алтернативни назив \fBalone\fP се доставља зарад +повратне сагласности са LZMA помагалима. +.TP +\fBlzip\fP +Прихвата само \fB.lz\fP датотеке приликом распакивања. Запакивање није +подржано. +.IP "" +Формат \fB.lz\fP издања 0 и 1 је подржан. Датотеке издања 0 су настале са +\fBlzip\fP 1.3 и старијим. Такве датотеке нису уобичајене али се могу наћи у +архивама датотека јер је неколико пакета извора издато у овом формату. +Такође можда неко има старе личне датотеке у овом формату. Подршка +распакивања за формат издања 0 је уклоњена у \fBlzip\fP 1.18. \fBlzip\fP 1.4 и +новији ствара датотеке у формату издања 1. +.TP +\fBraw\fP +Запакује или распакује сирови ток (без заглавља). Ово је замишљено само за +напредне кориснике. Да дешифрујете сирове токове, треба да користите +\fB\-\-format=raw\fP и да изричито наведете ланац филтера, што би обично требало +да буде смештено у заглављима контејнера. +.RE +.TP +\fB\-C\fP \fIпровера\fP, \fB\-\-check=\fP\fIпровера\fP +Наводи врсту провере целовитости. Провера се израчунава из незапакованих +података и смештених у \fB.xz\fP датотеци. Ова опција има дејства само +приликом запакивања у \fB.xz\fP формат; \fB.lzma\fP формат не подржава провере +целовитости. Провера целовитости (ако је има) се проверава када је \fB.xz\fP +датотека распакована. +.IP "" +Подржане врсте \fIпровере\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Уопште не израчунава проверу целовитости. Ово је обично лоша идеја. Ово +може бити корисно када се целовитост података ипак проверава на друге +начине. +.TP +\fBcrc32\fP +Израчунава CRC32 користећи полином из IEEE\-802.3 (Етернет). +.TP +\fBcrc64\fP +Израчунава CRC64 користећи полином из ECMA\-182. Ово је основно, јер је +незнатно боље од CRC32 у откривању оштећених датотека а разлика брзине је +занемарљива. +.TP +\fBsha256\fP +Израчунава SHA\-256. Ово је нешто спорије од CRC32 и CRC64. +.RE +.IP "" +Целовитост \fB.xz\fP заглавља се увек проверава са CRC32. Не може се изменити +нити искључити. +.TP +\fB\-\-ignore\-check\fP +Не проверава проверу целовитости запакованих података приликом распакивања. +CRC32 вредности у \fB.xz\fP заглављима биће још увек нормално проверене. +.IP "" +\fBНемојте користити ову опцију осим ако стварно знате шта радите.\fP Могући +разлози за коришћење ове опције: +.RS +.IP \(bu 3 +Покушава да опорави податке из оштећене „.xz“ датотеке. +.IP \(bu 3 +Убрзава распакивање. Ово има значаја углавном са SHA\-256 или са датотекама +које су запаковане стварно добро. Препоручује се да не користите ову опцију +за ову сврху осим ако је целовитост датотеке проверена споља на неки други +начин. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Бира ниво преподешености запакивања. Подразумевано је \fB\-6\fP. Ако је +наведено више нивоа преподешености, последња има дејства. Ако је произвољни +ланац филтера већ наведен, постављање нивоа преподешености запакивања уклања +произвољни ланац филтера. +.IP "" +Разлике између предподешености су још значајније него са \fBgzip\fP(1) и +\fBbzip2\fP(1). Изабране поставке запакивања одређују захтеве меморије +распакивача, стога коришћење превисоког нивоа предподешености може отежати +распакивање датотеле на старом систему са мало RAM\-а. Нарочито, \fBније добра замисао слепо користити \-9 за било шта\fP као што је често са \fBgzip\fP(1) +и \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Ово су некако брзе предподешености. \fB\-0\fP је понекад брже од \fBgzip \-9\fP док +запакује много боље. Оне више често имају брзину упоредиву са \fBbzip2\fP(1) +са упоредивом или бољом стопом запакивања, иако резултати зависе много од +врсте података који се запакују. +.TP +\fB\-4\fP ... \fB\-6\fP +Добро до врло добро запакивање које одржава коришћење меморије распакивача +разумним чак и за старе системе. \fB\-6\fP је основно, што је обично добар +избор за расподелу датотека које треба да могу да се распакују чак и на +системима са само 16\ MiB RAM\-а. (\fB\-5e\fP или \fB\-6e\fP може бити вредно +узимања у обзир. Видите \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Као \fB\-6\fP али са већим захтевима меморије запакивача и распакивача. Корисне +су само приликом запакивања датотека већих од 8\ MiB, 16\ MiB и 32\ MiB. +.RE +.IP "" +На истом хардверу, брзина распакивања је приближно сталан број бајтова +запакованих података у секунди. Другим речима, биће боље запакивање, брже +распакивање. То такође значи да количина незапакованог излаза произведеног +у секунди може много да се разликује. +.IP "" +Следећа табела резимира функције предподешености: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Преподешеност;ВлчРчнка;ЗапакЦПЈ;ЗапакМем;РаспМем +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Описи колона: +.RS +.IP \(bu 3 +ВлчРчнка је величина LZMA2 речника. Коришћење речника већег од величине +незапаковане датотеке је губитак меморије. Зато је добро избегавати +коришћење предподешености \fB\-7\fP ... \fB\-9\fP када за њима нема стварне +потребе. Са \fB\-6\fP и нижим, количина изгубљене меморије је обично довољно +ниска да нема значаја. +.IP \(bu 3 +ЗапакЦПЈ је поједностављено представљање LZMA2 поставки које утичу на брзину +запакивања. Величина речника такође утиче на брзину, тако док је ЗапакЦПЈ +исто за нивое \fB\-6\fP ... \fB\-9\fP, виши нивои још увек теже да буду спорији. Да +добијете још спорије и самим тим можда боље запакивање, видите \fB\-\-extreme\fP. +.IP \(bu 3 +ЗапакМем садржи захтеве меморије запакивача у режиму једне нити. Може +незнатно да се разликује између \fBxz\fP издања. +.IP \(bu 3 +РаспМем садржи захтеве меморије распакивача. Тако је, поставке запакивања +одређују захтеве меморије распакивача. Тачно коришћење меморије распакивача +је незнатно веће од величине LZMA2 речника, али су вредности у табели +заокружене на следећи цео MiB. +.RE +.IP "" +Захтеви меморије режима са више нити су значајно већи него ли режима једне +нити. Са основном вредношћу \fB\-\-block\-size\fP, свакој нити треба 3*3*ВлчРчнка +плус ЗапакМем или РаспМем. На пример, за четири нити са предподешавањем +\fB\-6\fP потребно је 660\(en670\ MiB меморије. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Користите спорију варијанту изабраног нивоа предподешености запакивања +(\fB\-0\fP ... \fB\-9\fP) у нади да ћете добити мало бољу стопу запакивања, али уз +лошу срећу ово је може учинити гором. Не утиче на коришћење меморије +распакивача, али се коришћење меморије запакивача мало повећава на нивоима +предподешености \fB\-0\fP ... \fB\-3\fP. +.IP "" +Како постоје две предподешености са величинама речника од 4\ MiB и 8\ MiB, +предподешености \fB\-3e\fP и \fB\-5e\fP користе незнатно брже поставке (ниже +CompCPU) него \fB\-4e\fP и \fB\-6e\fP. На тај начин нема две истоветне +предподешености. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Преподешеност;ВлчРчнка;ЗапакЦПЈ;ЗапакМем;РаспМем +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +На пример, има укупно четири предподешавања која користе 8\ MiB речник, чији +поредак од најбржег до најспоријег је \fB\-5\fP, \fB\-6\fP, \fB\-5e\fP и \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Ово су помало погрешни алијаси за \fB\-0\fP и \fB\-9\fP. Достављени су само зарад +повратне сагласности са LZMA Utils\-ом. Избегавајте коришћење ових опција. +.TP +\fB\-\-block\-size=\fP\fIвеличина\fP +Приликом запакивања у \fB.xz\fP формат, дели улазне податке на блокове +\fIвеличина\fP бајта. Блокови се запакују независно један од другог, што +помаже у раду са више нити и чини ограничено распакивање насумичног приступа +могућим. Ова опција се обично користи да се препише основна величина блока +у режиму са више нити, али се ова опција може такође користити и у режиму +једне нити. +.IP "" +У режиму више нити око три пута \fIвеличина\fP бајтова биће додељено у свакој +нити за међумеморисање улаза и излаза. Основна \fIвеличина\fP је три пута +величине LZMA2 речника или 1 MiB, шта год да је више. Обично добра вредност +је 2\(en4 пута величина LZMA2 речника или барем 1 MiB. Коришћење +\fIвеличине\fP мање од величине LZMA2 речника је трошење RAM\-а јер тада +међумеморија LZMA2 речника никада неће бити потпуно коришћена. У режиму +више нити, величине блокова се чувају у заглављима блока. Ова информација +величине је потребна за распакивање са више нити. +.IP "" +У режиму једне нити никаква подела блока се не ради по основи. Постављање +ове опције не утиче на коришћење меморије. Никакве информације о величини +се не чувају у заглављима блока, стога датотеке направљене у режиму једне +нити неће бити исте као датотеке направљене у режиму више нити. Недостатак +информација о величини такође значи да \fBxz\fP неће моћи да распакује датотеке +у режиму више нити. +.TP +\fB\-\-block\-list=\fP\fIставке\fP +Приликом запакивања у \fB.xz\fP формат, почиње нови блок са изборним +произвољним ланцем филтера након датих интервала незапакованих података. +.IP "" +\fIСтавке\fP су списак одвојен зарезом. Свака ставка се састоји од изборног +броја ланца филтера између 0 и 9 за којим следи двотачка (\fB:\fP) и захтевана +величина незапакованих података . Изостављање неке ставке (два или више +узастопна зареза) је пречица за коришћење величине и филтера претходне +ставке. +.IP "" +Ако је улазна датотека већа од збира величина у \fIставкама\fP, последња ставка +се понавља све до краја датотеке. Специјална вредност \fB0\fP може се +користити као последња величина да назначи да остатак датотеке треба да буде +шифрован као један блок. +.IP "" +Алтернативни ланац филтера за сваки блок се може навести у комбинацији са +опцијама \fB\-\-filters1=\fP\fIфилтера\fP \&...\& \fB\-\-filters9=\fP\fIфилтери\fP. Ове +опције дефинишу ланце филтера са одредником између 1\(en9. Ланац филтера 0 +се може користити да упућује на основно ланац филтера, који је исти јер се +ланац филтера не наводи. Одредник ланца филтера се може користити пре +незапаковане величине, за којим следи двотачка (\fB:\fP). На пример, ако +наведемо \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP тада ће се за +прављење блокова користити: +.RS +.IP \(bu 3 +Ланац филтера наведен са \fB\-\-filters1\fP и 2 MiB улазом +.IP \(bu 3 +Ланац филтера наведен са \fB\-\-filters3\fP и 2 MiB улазом +.IP \(bu 3 +Ланац филтера наведен са \fB\-\-filters2\fP и 4 MiB улазом +.IP \(bu 3 +Ланац филтера наведен са \fB\-\-filters2\fP и 4 MiB улазом +.IP \(bu 3 +Основни ланац филтера и 2 MiB улаз +.IP \(bu 3 +Основни ланац филтера и 4 MiB улаз за сваки блок до краја улаза. +.RE +.IP "" +Ако наведемо величину која премашује величину блока шифрера (било основну +вредност у режиму нити или вредност наведену са +\fB\-\-block\-size=\fP\fIвеличина\fP), шифрер ће направити додатне блокове док ће +задржати границе наведене у \fIставкама\fP. На пример, ако наведемо +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP а улазна +датотека је 80 MiB, добићемо 11 блокова: 5, 10, 8, 10, 2, 10, 10, 4, 10, 10 +и 1 MiB. +.IP "" +У режиму са више нити величине блокова се чувају у заглављима блока. Ово се +не ради у режиму једне нити, тако да шифровани излаз неће бити истоветан +ономе у режиму са више нити. +.TP +\fB\-\-flush\-timeout=\fP\fIистек_времена\fP +Приликом запакивања, ако је више од \fIвреме_истека\fP милисекунди (позитиван +цео број) прошло од претходног испирања и читање више улаза ће блокирати, +сви заказани улазни подаци се испирају из шифрера и чине доступним у +излазном току. Ово може бити корисно ако је \fBxz\fP коришћен за запакивање +података који су слати преко мреже. Мала вредност \fIвременског_истека\fP чини +податке доступним на пријемни крај са малим закашњењем, али велика вредност +\fIвремена_истека\fP даје бољу стопу запакивања. +.IP "" +Ова функција је искључена по основи. Ако је ова опција наведена више пута, +последња има дејства. Нарочита вредност \fIвременског истека\fP \fB0\fP може се +користити за изричито искључивање ове функције. +.IP "" +Ова функција је доступна само на POSIX системима. +.IP "" +.\" FIXME +\fBОва функција је још увек експериментална.\fP Тренутно \fBxz\fP није погодан за +распакивање тока у реалном времену због начина на који \fBxz\fP ради +међумеморисање. +.TP +\fB\-\-no\-sync\fP +Не усклађује циљну датотеку и њену фасциклу на смештајном уређају пре +уклањања изворне датотеке. Ово може побољшати учинковитост ако се запакује +или распакује много малих датотека. Међутим, ако се систем уруши одмах +након брисања, може бити да циљна датотека не буде уписана на смештајном +уређају али радња брисања јесте. У том случају неће бити доступна ни +оригинална изворна ни циљна датотека. +.IP "" +Ова опција има дејство само када се \fBxz\fP спрема да уклони изворну +датотеку. У осталим случајевима усклађивање се не ради никада. +.IP "" +Синхронизација и \fB\-\-no\-sync\fP су додате у \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIограничење\fP +Поставља ограничење коришћења меморије запакивања. Ако је ова опција +наведена више пута, последња ступа у дејство. +.IP "" +Ако поставке запакивања премаше \fIограничење\fP, \fBxz\fP ће покушати да врати +назад поставке тако да ограничење више није прекорачено и приказаће +обавештење да је урађено аутоматско дотеривање. Дотеривања се раде следећим +редом: смањење броја нити, пребацивање на режим једне нити ако чак и једна +нит у режиму више нити премаши \fIограничење\fP и на крају смањење величине +LZMA2 речника. +.IP "" +Приликом запакивања са \fB\-\-format=raw\fP или ако је наведено \fB\-\-no\-adjust\fP, +само број нити може бити умањен јер може да се уради а да се не делује на +излаз запакованог. +.IP "" +Ако \fIограничење\fP не може бити задовољено чак и са поравнањима описаним +изнад, приказује се грешка и \fBxz\fP ће изаћи са излазним стањем 1. +.IP "" +\fIОграничење\fP се може навести на више начина: +.RS +.IP \(bu 3 +\fIОграничење\fP може бити апсолутна величина у бајтима. Коришћење суфикса +целог броја као \fBMiB\fP може бити корисно. Пример: +\fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +\fIОграничење\fP се може навести као проценат укупне физичке меморије (RAM). +Ово може бити корисно нарочито приликом постављања променљиве окружења +\fBXZ_DEFAULTS\fP у скрпти покретања конзоле која се дели између различитих +рачунара. На тај начин ограничење је аутоматски веће на системима са више +меморије. Пример: \fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +\fIОграничење\fP се може вратити на своју основну вредност његовим постављањем +на \fB0\fP. Ово је тренутно исто што и постављање \fIограничења\fP на \fBmax\fP (без +ограничења коришћења меморије). +.RE +.IP "" +За \fBxz\fP 32\-бита имамо посебан случај: ако \fIограничење\fP треба да буде преко +\fB4020\ MiB\fP, \fIограничење\fP се поставља на \fB4020\ MiB\fP. Али на MIPS32 +користи се \fB2000\ MiB\fP. (На вредности \fB0\fP и \fBmax\fP ово не утиче. Слична +функција не постоји за распакивање.) Ово може бити од помоћи када извршна +од 32\-бита има приступ адресном простору од 4\ GiB (2 GiB на MIPS32) док +срећом не чини ништа лоше у осталим приликама. +.IP "" +Видите такође одељак \fBКоришћење меморије\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIограничење\fP +Поставља ограничење коришћења меморије за распакивање. Ово такође утиче на +\fB\-\-list\fP режим. Ако радња није могућа а да се не премаши \fIограничење\fP, +\fBxz\fP ће приказати грешку а распакивање датотеке неће успети. Видите +\fB\-\-memlimit\-compress=\fP\fIограничење\fP за могуће начине о навођењу +\fIограничења\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIограничење\fP +Поставља ограничење коришћења меморије за распакивање са више нити. Ово +може утицати само на број нити; ово никада неће учинити да \fBxz\fP одбије да +распакује датотеке. Ако је \fIограничење\fP превише ниско да омогући било који +рад са више нити, \fIограничење\fP се занемарује а \fBxz\fP ће наставити у режиму +једне нити. Знајте да ако се такође користи \fB\-\-memlimit\-decompress\fP, увек +ће се применити и на режим једне и на режим више нити, и тако да стварно +\fIограничење\fP за више нити никада неће бити више од ограничења постављеног +са \fB\-\-memlimit\-decompress\fP. +.IP "" +У супротности са другим опцијама ограничења коришћења меморије, +\fB\-\-memlimit\-mt\-decompress=\fP\fIограничење\fP има систему специфично основно +\fIограничење\fP. \fBxz \-\-info\-memory\fP се може користити да видите тренутну +вредност. +.IP "" +Ова опција и њена основна вредност постоје јер без икаквог ограничења нитни +распакивач ће завршити са додељивањем неразумног износа меморије са неким +улазним датотекама. Ако је основно \fIограничење\fP превише ниско на вашем +систему, слободно повећајте \fIограничење\fP али га никада не постављајте на +вредност већу од износа употребљивог RAM\-а јер са одговарајућим улазним +датотекама \fBxz\fP ће покушати да користи тај износ меморије чак и са малим +бројем нити. Остајући без меморије или разменом неће се побољшати +учинковитост распакивања. +.IP "" +Видите \fB\-\-memlimit\-compress=\fP\fIограничење\fP за могуће начине за навођење +\fIограничења\fP. Постављање \fIограничења\fP на \fB0\fP враћа \fIограничење\fP на +систему специфичну основну вредност. +.TP +\fB\-M\fP \fIограничење\fP, \fB\-\-memlimit=\fP\fIограничење\fP, \fB\-\-memory=\fP\fIограничење\fP +Ово је исто као и навођење \fB\-\-memlimit\-compress=\fP\fIограничење\fP +\fB\-\-memlimit\-decompress=\fP\fIограничење\fP +\fB\-\-memlimit\-mt\-decompress=\fP\fIограничење\fP. +.TP +\fB\-\-no\-adjust\fP +Приказује грешку и излази ако ограничење коришћења меморије не може бити +задовољено без дотеривања поставки које утичу на запаковани излаз. Тако је, +ово спречава \fBxz\fP да промени шифрера из режима више нити у режим једне нити +и да смањи величину LZMA2 речника. Чак и када се ова опција користи број +нити се може смањити да задовољи ограничење коришћења меморије јер то неће +утицати на запаковани излаз. +.IP "" +Аутоматско дотеривање је увек искључено приликом стварања сирових токова +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fIнити\fP, \fB\-\-threads=\fP\fIнити\fP +Наводи број нити радника за коришћење. Постављање \fIнити\fP на посебну +вредност \fB0\fP чини да \fBxz\fP користи онолико нити колико процесор на систему +подржава. Стварни број нити може бити мањи од \fIнити\fP ако улазна датотека +није довољно велика за нитисање са датим поставкама или ако ће коришћење +више нити премашити ограничење коришћења меморије. +.IP "" +Запакивачи једне нити и више нити дају различите излазе. запакивач једне +нити даће мању величину датотеке али само излаз из запакивача више нити може +бити распакован коришћењем више нити. Постављање \fIнити\fP на \fB1\fP користиће +режим једне нити. Постављање \fIнити\fP на неку другу вредност, укључујући +\fB0\fP, користиће запакивач више нити чак и ако систем подржава само једну нит +хардвера. (\fBxz\fP 5.2.x је користио режим једне нити у овој прилици.) +.IP "" +Да користите вишенитни режим са само једном нити, поставите \fIнити\fP на +\fB+1\fP. Префикс \fB+\fP нема дејства са вредностима које нису \fB1\fP. Ограничење +коришћења меморије може још увек учинити да се \fBxz\fP пребаци на режим једне +нити осим ако се не користи \fB\-\-no\-adjust\fP. Подршка за префикс \fB+\fP је +додата у \fBxz\fP 5.4.0. +.IP "" +Ако је затражен аутоматски број нити и није наведено ограничење коришћења +меморије, тада ће се користити основно меко ограничење специфично за систем +за могуће ограничење броја нити. То је меко ограничење у смислу да се +занемарује ако број нити постане један, дакле меко ограничење никада неће +зауставити \fBxz\fP од запакивања или распакивања. Ово основно меко ограничење +неће учинити да се \fBxz\fP пребаци из режима више нити у режим једне нити. +Активно ограничење се може видети са + \fBxz \-\-info\-memory\fP. +.IP "" +Тренутно једина метода нитисања је да се подели улаз на блокове и да се +запакују независно један од другог. Основна величина блока зависи од нивоа +запакивања и може се преписати опцијом \fB\-\-block\-size=\fP\fIвеличина\fP. +.IP "" +Нитно распакивање ради само на датотекама које садрже више блокова са +информацијом величине у заглављима блока. Све довољно велике датотеке +запаковане у вишенитном режиму задовољавају овај услов, али датотеке +запаковане у једнонитном режиму не чак и ако је коришћено +\fB\-\-block\-size=\fP\fIвеличина\fP. +.IP "" +Основна вредност за \fIнити\fP је \fB0\fP. У \fBxz\fP 5.4.x и старијим основно је +\fB1\fP. +. +.SS "Произвољни ланци филтера запакивача" +Произвољни ланац филтера омогућава детаљно одређивање подешавања сажимања +уместо да се ослања на подешавања повезана са предподешавањима. Када је +произвољни ланац филтера наведен, опције предподешавања (\fB\-0\fP \&...\& \fB\-9\fP +и \fB\-extreme\fP) раније на линији наредби се заборављају. Ако је опција +предподешавања наведена након једне или више опција произвољног ланца +филтера, ново предподешавање ступа на снагу а раније наведене опције +произвољног ланца филтера се заборављају. +.PP +Ланац филтера је упоредив са спојкама на линији наредби. Приликом сажимања, +несажети улаз иде на први филтер, чији излаз иде на следећи филтер (ако фа +има). Излаз последњег филтера бива записан у сажету датотеку. Највећи број +филтера у ланцу је четири, али обично ланац филтера има само један или два +филтера. +.PP +Многи филтери имају ограничења о томе где могу бити у ланцу филтера: неки +филтери могу радити само као последњи филтер у ланцу, неки само као +не\-последњи филтер, а неки раде на било ком месту у ланцу. Овисно о +филтеру, ово ограничење је или својствено дизајну филтера или постоји како +би се спречили проблеми безбедности. +.PP +Произвољни ланац филтера се може навести на два различита начина. Опције +\fB\-\-filters=\fP\fIфилтери\fP и \fB\-\-filters1=\fP\fIфилтери\fP \&...\& +\fB\-\-filters9=\fP\fIфилтери\fP омогућавају навођење читавог ланца опција у једној +опцији коришћењем синтаксу ниске „liblzma“ филтера. Другачије, ланац +филтера се може навести коришћењем једне или више појединачних опција +филтера редом како се траже у ланцу филтера. То је то, редослед +појединачних опција филтера је важан! Приликом дешифровања сирових токова +(\fB\-\-format=raw\fP), ланац филтера мора бити наведен истим редом као када је +био наведен приликом сажимања. Било који појединачни филтер или опције +предподешавања наведене пре опције читавог ланца (\fB\-\-filters=\fP\fIфилтери\fP) +биће заборављене. Појединачни филтери наведени после опције читавог ланца +ће поништити поставку ланца филтера. +.PP +Обе опције и пуног и појединачног филтера узимају филтеру специфичне +\fIопције\fP као зарезом раздвојен списак. Додатни зарези у \fIопцијама\fP се +занемарују. Свака опција има основну вредност, тако да треба да наведете +оне које желите да измените. +.PP +Да видите читав ланац филтера и \fIопције\fP, користите \fBxz \-vv\fP (тако је, +користите \fB\-\-verbose\fP два пута). Ово ради такође за преглед опција ланца +филтера коришћених од стране предподешености. +.TP +\fB\-\-filters=\fP\fIфилтери\fP +Наводи цео ланац филтера или предподешеност у једној опцији. Сваки филтер +се може одвојити размацима или са две цртице (\fB\-\-\fP). \fIФилтери\fP можда +треба да буду под наводницима на линији наредби конзоле тако да се +прослеђују као једна опција. Да означите \fIопције\fP, користите \fB:\fP или +\fB=\fP. Предподешености се може додати префикс \fB\-\fP и може га пратити нула +или још заставица. Једина подржана заставица је \fBe\fP за примену истих +опција као \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIфилтери\fP ... \fB\-\-filters9\fP=\fIфилтери\fP +Наводи до девет додатних ланаца филтера који се могу користити са +\fB\-\-block\-list\fP. +.IP "" +На пример, приликом запакивања архиве са извршним датотекама за којима следе +текстуалне датотеке, извршни део треба да користи ланац филтера са BCJ +филтером а текстуални део само LZMA2 филтер. +.TP +\fB\-\-filters\-help\fP +Приказује поруку помоћи описујући како се наводе предподешавања и произвољни +ланци филтера у опцијама \fB\-\-filters\fP и \fB\-\-filters1=\fP\fIфилтери\fP \&...\& +\fB\-\-filters9=\fP\fIфилтери\fP, и успешно излази. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIопције\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIопције\fP] +.PD +Додаје LZMA1 или LZMA2 филтер у ланац филтера. Ови филтери се могу +користити само као последњи филтер у ланцу. +.IP "" +LZMA1 је стари филтер, који је подржан углавном само због старог формата +\&\fB.lzma\fP датотеке, који подржава само LZMA1. LZMA2 је освежено издање LZMA1 +које поправља неке практичне проблеме LZMA1. \fB.xz\fP формат користи LZMA2 и +не подржава LZMA1 уопште. Брзина запакивања и односи LZMA1 и LZMA2 су +практично исти. +.IP "" +LZMA1 и LZMA2 деле исти скуп \fIопција\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIпредподешавање\fP +Враћа све LZMA1 или LZMA2 \fIопције\fP на \fIпредподешеност\fP. \fIПредпдешеност\fP +се састоји од целог броја, за којим може да следи једнословни измењивач +предподешености. Цео број може бити од \fB0\fP до \fB9\fP, поклапајући опције +линије наредби \fB\-0\fP \&...\& \fB\-9\fP. Једини тренутно подржани измењивач је +\fBe\fP, који се поклапа са \fB\-\-extreme\fP. Ако \fBpreset\fP није наведено, основне +вредности LZMA1 или LZMA2 \fIопција\fP се узимају из предподешености \fB6\fP. +.TP +\fBdict=\fP\fIвеличина\fP +\fIВеличина\fP речника (међумеморија историјата) указује на то колико је +бајтова недавно обрађених нераспакованих података задржано у меморији. +Алгоритам покушава да нађе понављајуће низове бајтова (поклапања) у +нераспакованим подацима, и да их замени са упутама ка подацима који су +тренутно у речнику. Што је већи речник, већа је вероватноћа за налажење +поклапања. Стога, повећање \fIвеличине \fP речника обично побољшава стопу +запакивања, али речник већи од незапаковане датотеке јесте утрошак меморије. +.IP "" +Уобичајена \fIвеличина\fP речника је од 64\ KiB до 64\ MiB. Најмање је 4\ KiB. Највише за запакивање тренутно је 1.5\ GiB (1536\ MiB). Распакивач +већ подржава речнике до једног бајта мање од 4\ GiB, што је максимум за +формате LZMA1 и LZMA2 тока. +.IP "" +\fIВеличина\fP речника и налазач поклапања (\fImf\fP) заједно одређују коришћење +меморије за LZMA1 или LZMA2 шифрере. Иста (или већа) \fIвеличина\fP речника је +потребна за распакивање као она која је коришћена за запаквање, стога се +коришћење меморије дешифрера одређује према величини речника коришћеног за +запакивање. \fB.xz\fP заглавља чувају \fIвеличину\fP речника или као 2^\fIn\fP или +2^\fIn\fP + 2^(\fIn\fP\-1), тако да су те \fIвеличине\fP некако пожељније за +запакивање. Друге \fIвеличине\fP биће заокружене приликом чувања у \fB.xz\fP +заглављима. +.TP +\fBlc=\fP\fIlc\fP +Наводи број битова контекста литерала. Најмање је 0 а највише је 4; основно +је 3. Као додатак, збир \fIlc\fP и \fIlp\fP не сме да премаши 4. +.IP "" +Сви бајтови који се не могу шифровати јер су поклапања шифрована као +литерали. То је то, литерали су једноставно 8\-битни бајтови који су +шифровани један по један. +.IP "" +Кодирање литерала врши претпоставку да највећи \fIlc\fP битови претходног +незапакованог бајта су у узајамној вези са следећим бајтом. На пример, у +уобичајеном енглеском тексту, за великим словом често следи мало слово, а за +малим словом обично следи још једно мало слово. У скупу US\-ASCII знакова, +највиша три бита су 010 за велика слова и 011 за мала слова. Када је \fIlc\fP +барем 3, кодирање литерала може имати предност овог својства у незапакованим +подацима. +.IP "" +Основна вредност (3) је обично добра. Ако желите највеће запакивање, +испробајте \fBlc=4\fP. Некад то мало помогне а некад чини запакивање горим. +Ако га учини горим, испробајте такође \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Наводи број битова положаја литерала. Најмање је 0 а највише је 4; основно +је 0. +.IP "" +\fILp\fP утиче на то која врста поравнања у незапакованим подацима се +подразумева приликом шифровања литерала. Видите \fIpb\fP испод за више +информација о поравнању. +.TP +\fBpb=\fP\fIpb\fP +Наводи број битова положаја. Најмање је 0 а највише је 4; основно је 2. +.IP "" +\fIPb\fP утиче на то која врста поравнања у незапакованим подацима се +подразумева у опште. Основно значи четворобајтно поравнање (2^\fIpb\fP=2^2=4), +што је често добар избор када нема бољег решења. +.IP "" +Када је поравнање познато, постављање одговарајућег \fIpb\fP може мало да смањи +величину датотеке. На пример, са датотекама текста које имају поравнање +једног бајта (US\-ASCII, ISO\-8859\-*, UTF\-8), постављање \fBpb=0\fP може незнатно +да побољша запакивање. За UTF\-16 текст, \fBpb=1\fP је добар избор. Ако је +поравнање непаран број као 3 бајта, \fBpb=0\fP може бити најбољи избор. +.IP "" +Иако се претпостављено поравнање може подесити са \fIpb\fP и \fIlp\fP, LZMA1 и +LZMA2 и даље незнатно фаворизују 16\-бајтно поравнање. То би могло бити +вредно узети у обзир приликом дизајнирања формата датотека које ће вероватно +бити често запаковане са LZMA1 или LZMA2. +.TP +\fBmf=\fP\fImf\fP +Налазач поклапања има главни утицај на брзину шифрера, коришћење меморије и +стопу запакивања. Обично Hash Chain налазачи поклапања су бржи од Binary +Tree налазача поклапања. Основност зависи од \fIпредподешености\fP: 0 користи +\fBhc3\fP, 1\(en3 користи \fBhc4\fP, а остало користи \fBbt4\fP. +.IP "" +Следећи налазачи поклапања су подржани. Формуле коришћења меморије испод су +грубе апроксимације које су ближе стварности када је \fIречник\fP степен +двојке. +.RS +.TP +\fBhc3\fP +Ланац хеша са хеширањем 2\- и 3\-бајта +.br +Најмања вредност за \fIфино\fP: 3 +.br +Коришћење меморије: +.br +\fIречник\fP * 7.5 (ако је \fIречник\fP <= 16 MiB); +.br +\fIречник\fP * 5.5 + 64 MiB (if \fIречник\fP > 16 MiB) +.TP +\fBhc4\fP +Ланац хеша са хеширањем 2\-, 3\- и 4\-бајта +.br +Најмања вредност за \fIфино\fP: 4 +.br +Коришћење меморије: +.br +\fIречник\fP * 7.5 (ако је \fIречник\fP <= 32 MiB); +.br +\fIречник\fP * 6.5 (ако је \fIречник\fP > 32 MiB) +.TP +\fBbt2\fP +Бинарно стабло са 2\-бајта хеширања +.br +Најмања вредност за \fIфино\fP: 2 +.br +Коришћење меморије: \fIречник\fP * 9.5 +.TP +\fBbt3\fP +Бинарно стабло са 2\- и 3\-бајта хеширања +.br +Најмања вредност за \fIфино\fP: 3 +.br +Коришћење меморије: +.br +\fIречник\fP * 11.5 (if \fIречник\fP <= 16 MiB); +.br +\fIречник\fP * 9.5 + 64 MiB (ако је \fIречник\fP > 16 MiB) +.TP +\fBbt4\fP +Бинарно стабло са 2\-, 3\-, и 4\-бајта хеширања +.br +Најмања вредност за \fIфино\fP: 4 +.br +Коришћење меморије: +.br +\fIречник\fP * 11.5 (if \fIречник\fP <= 32 MiB); +.br +\fIречник\fP * 10.5 (if \fIречник\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fIрежим\fP +\fIРежим\fP запакивања наводи методу за анализу података које произведе налазач +поклапања. Подржани \fIрежими\fP су \fBfast\fP и \fBnormal\fP. Подразумева се +\fBfast\fP за \fIпредподешавања\fP 0\(en3 и \fBnormal\fP за \fIпредподешавања\fP 4\(en9. +.IP "" +Обично се \fBfast\fP користи са налазачима Hash Chain поклапања а \fBnormal\fP са +налазачима Binary Tree поклапања. Ово је исто што раде и +\fIпредподешености\fP. +.TP +\fBnice=\fP\fIфино\fP +Наводи оно што се сматра да је фина дужина за поклапање. Када се поклапање +од барем \fInice\fP бајтова нађе, алгоритам зауставља тражење могућих бољих +поклапања. +.IP "" +\fIФино\fP може бити 2\(en273 бајта. Веће вредности теже да дају бољу стопу +запакивања на уштрб брзине. Основно зависи од \fIпредподешавања\fP. +.TP +\fBdepth=\fP\fIдубина\fP +Наводи највећу дубину претраге у налазачу поклапања. Основно је посебна +вредност 0, која чини да запакивач одреди разумљиву \fIдубину\fP из \fImf\fP и +\fInice\fP. +.IP "" +Разумљива \fIдубина\fP за ланце хеша је 4\(en100 и 16\(en1000 за стабло +извршних. Коришћење врло великих вредности за \fIдубину\fP може учинити шифрер +врло спорим са неким датотекама. Избегавајте постављање \fIдубине\fP преко +1000 осим ако нисте спремни да прекинете запакивање у случају да потраје +превише дуго. +.RE +.IP "" +Приликом дешифровања сирових токова (\fB\-\-format=raw\fP), LZMA2 треба само +\fIвеличина\fP речника. LZMA1 треба такође \fIlc\fP, \fIlp\fP и \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIопције\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIопције\fP] +.PD +Додаје „branch/call/jump“ (BCJ) филтер ланцу филтера. Ови филтери могу се +користити само ако нису последњи филтер у ланцу филтера. +.IP "" +BCJ филтер претвара релативне адресе у машинском коду на њихове апсолутне +двојнике. Ово не мења величину података, али повећава сувишност, што може +помоћи LZMA2 да произведе 0\(en15\% мању \fB.xz\fP датотеку. BCJ филтери су +увек реверзибилни, стога коришћење BCJ филтера за погрешну врсту података не +доводи ни до каквог губитка података, мада може да учини степен сажимања +нешто лошијим. BCJ филтери су врло брзи и користе безначајну количину +меморије. +.IP "" +Ови BCJ филтери имају познате проблеме везане за стопу запакивања: +.RS +.IP \(bu 3 +Неке врсте датотека које садрже извршни код (на пример, објектне датотеке, +статичке библиотеке и модули Линукс кернела) имају адресе у упутствима +испуњеним вредностима попуњавача. Ови BCJ филтери и даље ће радити +претварање адресе, што ће запакивање учинити горим са овим датотекама. +.IP \(bu 3 +Ако се BCJ филтер примени на архиву, могуће је да ће учинити стопу +запакивања лошијим него кад се не би користио. На пример, ако постоје +сличне или чак истоветне извршне тада ће филтрирање вероватно учинити +датотеке мање сличним и стога је запакивање лошије. Садржај не\-извршних +датотека у истој архиви је такође важан. У пракси се мора покушати са и без +BCJ филтера да би се видело шта је боље у којој прилици. +.RE +.IP "" +Различити скупови упутстава имају различита поравнања: извршна датотека мора +бити поравната на множилац ове вредности у улазним подацима како би филтер +радио. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Филтер;Поравнање;Напомене +x86;1;32\-бита или 64\-бита x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096\-бита поравнање је најбоље +PowerPC;4;Само велика крајност +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Како су BCJ\-филтрирани подаци обично запаковани са LZMA2, стопа запакивања +може бити незнатно побољшана ако су LZMA2 опције постављене да поклопе +поравнање изабраног BCJ филтера. Примери: +.RS +.IP \(bu 3 +IA\-64 филтер има поравнање 16\-бајта тако да је \fBpb=4,lp=4,lc=0\fP добро са +LZMA2 (2^4=16). +.IP \(bu 3 +RISC\-V код има поравнање од 2 или 4 бајта у зависности од тога да ли +датотека садржи запаковане инструкције од 16 бита (проширење C). Када се +користе инструкције од 16 бита, \fBpb=2,lp=1,lc=3\fP или \fBpb=1,lp=1,lc=3\fP је +добро. Када нема инструкција од 16 бита, \fBpb=2,lp=2,lc=2\fP је најбоље. +\fBreadelf \-h\fP се може користити да се провери да ли се „RVC“ јавља у реду +„Заставице“. +.IP \(bu 3 +ARM64 је увек 4\-бајта поравнат тако да је \fBpb=2,lp=2,lc=2\fP најбоље. +.IP \(bu 3 +Филтер x86 је изузетак. Обично је добро придржавати се LZMA2 основности +(\fBpb=2,lp=0,lc=3\fP) приликом запакивања x86 извршних. +.RE +.IP "" +Сви BCJ филтери подржавају исте \fIопције\fP: +.RS +.TP +\fBstart=\fP\fIпомерај\fP +Наводи \fIпомерај\fP почетка који се користи приликом претварања између +релативних и апсолутних адреса. \fIПомерај\fP мора бити производ поравнања +филтера (видите табелу изнад). Основно је нула. У пракси, основност је +добра; навођење произвољног \fIпомераја\fP скоро никада није од користи. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIопције\fP] +Додаје Delta филтер у ланац филтера. Делта филтер може се користити само +ако није последњи филтер у ланцу филтера. +.IP "" +Тренутно је подржан само једноставан делта прорачун једног по једног бита. +Може бити користан приликом запакивања, на пример, незапакованих битмап +слика или незапакованог PCM звука. Међутим, алгоритми посебне намене могу +дати знатно боље резултате него Delta + LZMA2. Ово је тачно, посебно са +звуком, који се запакује брже и боље, на пример, са \fBflac\fP(1). +.IP "" +Подржане \fIопције\fP: +.RS +.TP +\fBdist=\fP\fIрастојање\fP +Наводи \fIрастојање\fP делта прорачуна у бајтима. \fIРастојање\fP мора бити +1\(en256. Основно је 1. +.IP "" +На пример, са \fBdist=2\fP и осмобајтним улазом A1 B1 A2 B3 A3 B5 A4 B7, излаз +ће бити A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Остале опције" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Потискује упозорења и обавештења. Наведите ово два пута да потиснете и +грешке. Ова опција нема утицаја на стање излаза. Тако је, чак и ако је +упозорење потиснуто, стање излаза које указује на упозорење се и даље +користи. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Бива опширан. Ако је стандардна грешка повезана са терминалом, \fBxz\fP ће +приказати указивач напретка. Навођењем \fB\-\-verbose\fP два пута добија се још +опширнији излаз. +.IP "" +Указивач напредовања показује следеће информације: +.RS +.IP \(bu 3 +Проценат довршености се показује ако је величина улазне датотеке позната. +Тако је, проценат се не може приказати у спојкама. +.IP \(bu 3 +Количина запакованих података проистеклих (запакивање) или утрошених +(распакивање). +.IP \(bu 3 +Количина распакованих података утрошених (запакивање) или проистеклих +(распакивање). +.IP \(bu 3 +Размера паковања, која се израчунава дељењем количине запакованих података +обрађених до сада количином незапакованих података до сада обрађених. +.IP \(bu 3 +Брзина запакивања или распакивања. Ово се мери као количина незапакованих +података утрошених (запакивање) или добијених (распакивање) у секунди. +Приказује се након неколико секунде након што \fBxz\fP започне обраду датотеке. +.IP \(bu 3 +Протекло време у формату М:СС или Ч:ММ:СС. +.IP \(bu 3 +Процењено преостало време се приказује само када је величина улазне датотеке +позната и неколико секунди је већ протекло од кад је \fBxz\fP започео обраду +датотеке. Време се приказује у мање тачном формату које никада нема +двотачке, на пример, 2 мин 30 сек. +.RE +.IP "" +Када стандардна грешка није терминал, \fB\-\-verbose\fP ће учинити да \fBxz\fP +испише назив датотеке, запаковану величину, незапаковану величину, стопу +запакивања и по могућству такође брзину и протекло време на једном реду на +стандардну грешку након запакивања или распакивања датотеке. Брзина и +протекло време су укључени само када радња потраје барем неколико секунде. +Ако се радња не заврши, на пример, услед што корисник прекине, такође се +исписује проценат завршености ако је величина улазне датотеке позната. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Не поставља стање излаза на 2 чак и ако је услов вредан упозорења откривен. +Ова опција не утиче на ниво опширности, стога и \fB\-\-quiet\fP и \fB\-\-no\-warn\fP +треба да се користе да се не приказују упозорења и да се не измени стање +излаза. +.TP +\fB\-\-robot\fP +Исписује поруке у формату обрадивом машинама. Ово је замишљено да олакша +писање челника који желе да користе \fBxz\fP уместо „liblzma“, што може бити +случај са разним скриптама. Излаз са овом опцијом укљученом је замишљен да +буде стабилан кроз \fBxz\fP издања. Видите одељак \fBРЕЖИМ РОБОТА\fP за више о +томе. +.TP +\fB\-\-info\-memory\fP +Приказује, у формату читљивом људима, колико физичке меморије (RAM) и колико +нити процесора \fBxz\fP мисли да систем има и ограничења коришћења меморије за +запакивање и распакивање и излази успешно. +.TP +\fB\-h\fP, \fB\-\-help\fP +Приказује поруку помоћи описујући најчешће коришћених опција, и успешно +излази. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Приказује поруку помоћи описујући све функције \fBxz\fP, и успешно излази +.TP +\fB\-V\fP, \fB\-\-version\fP +Приказује број издања за \fBxz\fP и „liblzma“ у формату читљивом људима. Да +добијете излаз машинама обрадив, наведите \fB\-\-robot\fP пре \fB\-\-version\fP. +. +.SH "РЕЖИМ РОБОТА" +Режим робота се покреће опцијом \fB\-\-robot\fP. Чини да излаз \fBxz\fP буде лакши +за обраду другим програмима. Тренутно \fB\-\-robot\fP је подржано само заједно +са \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, и \fB\-\-version\fP. Биће +подржан за запакивање и распакивање у будућности. +. +.SS "Режим списка" +\fBxz \-\-robot \-\-list\fP користи излаз раздвојен табулатором. Прва колона +сваког реда садржи ниску која указује на врсту информације која се налази у +том реду: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP (назив) +Ово је увек први ред приликом почетка листања датотеке. Друга колона у реду +је назив датотеке. +.TP +\fBfile\fP (датотека) +Овај ред садржи свеукупне информације о \fB.xz\fP датотеци. Овај ред се увек +исписује после реда \fBназив\fP. +.TP +\fBstream\fP (ток) +Ова врста реда се користи само када је \fB\-\-verbose\fP наведено. Има толико +редова \fBтока\fP колико има токова у \fB.xz\fP даатотеци. +.TP +\fBblock\fP (блок) +Ова врста реда се користи само када је \fB\-\-verbose\fP наведено. Има онолико +редова \fBблока\fP колико има блокова у \fB.xz\fP датотеци. Редови \fBблока\fP се +приказују након свих редова \fBтока\fP; различите врсте реда се не преплићу. +.TP +\fBsummary\fP (сажетак) +Ова врста реда се користи само када је \fB\-\-verbose\fP наведено два пута. Овај +ред се исписује након свих редова \fBблока\fP. Као ред \fBдатотека\fP, ред +\fBсажетка\fP садржи преглед информација о \fB.xz\fP датотеци. +.TP +\fBtotals\fP (укупност) +Овај ред је увек последњи ред на списку излаза. Показује укупне збирове и +величине. +.PP +Колоне редова \fBдатотеке\fP: +.PD 0 +.RS +.IP 2. 4 +Број токова у датотеци +.IP 3. 4 +Укупан број блокова у току(овима) +.IP 4. 4 +Величина запаковане датотеке +.IP 5. 4 +Величина незапаковане датотеке +.IP 6. 4 +Размера паковања, на пример, \fB0.123\fP. Ако је размера преко 9.999, три +цртице (\fB\-\-\-\fP) се приказују уместо размере. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Зарезом раздвојен списак назива провера целовитости. Следеће ниске се +користе за познате врсте провера: \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP и \fBSHA\-256\fP. +За непознате врсте провера, користи се \fBUnknown\-\fP\fIN\fP, где је \fIN\fP ИД +провере као децимални број (једна или две цифре). +.IP 8. 4 +Укупна величина попуњавања тока у датотеци +.RE +.PD +.PP +Колоне редова \fBтока\fP: +.PD 0 +.RS +.IP 2. 4 +Број тока (први ток је 1) +.IP 3. 4 +Број блокова у току +.IP 4. 4 +Померај почетка запакованог +.IP 5. 4 +Померај почетка незапаковане +.IP 6. 4 +Величина запакованог (не укључује попуну тока) +.IP 7. 4 +Величина незапаковане +.IP 8. 4 +Размера паковања +.IP 9. 4 +Назив провере целовитости +.IP 10. 4 +Величина попуне тока +.RE +.PD +.PP +Колоне редова \fBблока\fP: +.PD 0 +.RS +.IP 2. 4 +Број тока који садржи овај блок +.IP 3. 4 +Број блока релативан на почетак тока (први блок је 1) +.IP 4. 4 +Број блока релативан на почетак датотеке +.IP 5. 4 +Померај почетка запакованог односан на почетак датотеке +.IP 6. 4 +Померај почетка незапаковане односан на почетак датотеке +.IP 7. 4 +Укупна запакована величина блока (заједно са заглављима) +.IP 8. 4 +Величина незапаковане +.IP 9. 4 +Размера паковања +.IP 10. 4 +Назив провере целовитости +.RE +.PD +.PP +Ако је \fB\-\-verbose\fP наведено два пута, додатне колоне су укључене у редовима +\fBблока\fP. Они се не приказују са једним \fB\-\-verbose\fP, јер добијање ове +информације захтева много тражења и стога може бити споро: +.PD 0 +.RS +.IP 11. 4 +Вредност провере целовитости у хексадецималном облику +.IP 12. 4 +Величина заглавља блока +.IP 13. 4 +Заставице блока: \fBc\fP указује да је величина запакованог присутна, а \fBu\fP +указује да је величина нераспакованог присутна. Ако заставица није +постављена, цртица (\fB\-\fP) се приказује уместо да се настави са поправком +дужине ниске. У будућности нове заставице могу бити додате на крај ниске. +.IP 14. 4 +Величина стварних запакованих података у блоку (ово искључује заглавље +блока, попуњавање блока и поља провере) +.IP 15. 4 +Количина меморије (у бајтовима) потребна за распакивање овог блока са овим +\fBxz\fP издањем +.IP 16. 4 +Ланац филтера. Знајте да већина опција коришћених за време запакивања не +може бити познато, јер се само опције које су потребне за распакивање чувају +у \fB.xz\fP заглављима. +.RE +.PD +.PP +Колоне редова \fBсажетка\fP: +.PD 0 +.RS +.IP 2. 4 +Количина меморије (у бајтовима) потребна за распакивање ове датотеке са овим +\fBxz\fP издањем +.IP 3. 4 +\fByes\fP или \fBno\fP указује да ли сва заглавља блока имају и величину +запакованог и величину незапакованог сачуване у њима +.PP +\fIОд\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Потребно је најмање \fBxz\fP издање за распакивање датотеке +.RE +.PD +.PP +Колоне редова \fBукупности\fP: +.PD 0 +.RS +.IP 2. 4 +Број токова +.IP 3. 4 +Број блокова +.IP 4. 4 +Величина запакованог +.IP 5. 4 +Величина незапаковане +.IP 6. 4 +Просечан степен запакивања +.IP 7. 4 +Списак зарезом раздвојених назива провере целовитости која су била присутна +у датотекама +.IP 8. 4 +Величина попуњавања тока +.IP 9. 4 +Број датотека. Ту се држи поредак ранијих колона исто као у редовима +\fBдатотеке\fP. +.PD +.RE +.PP +Ако је \fB\-\-verbose\fP наведено два пута, додатне колоне су укључене у реду +\fBtotals\fP: +.PD 0 +.RS +.IP 10. 4 +Највећа количина меморије (у бајтима) потребна за распакивање датотеке са +овим \fBxz\fP издањем +.IP 11. 4 +\fByes\fP или \fBno\fP указује да ли сва заглавља блока имају и величину +запакованог и величину незапакованог сачуване у њима +.PP +\fIОд\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Потребно је најмање \fBxz\fP издање за распакивање датотеке +.RE +.PD +.PP +Будућа издања могу додати нове врсте реда и нове колоне се могу додати +постојећим врстама реда, али постојеће колоне се неће променити. +. +.SS "Помоћ филтера" +\fBxz \-\-robot \-\-filters\-help\fP исписује подржане филтере у следећем формату: +.PP +\fIфилтер\fP\fB:\fP\fIопција\fP\fB=<\fP\fIвредност\fP\fB>,\fP\fIопција\fP\fB=<\fP\fIвредност\fP\fB>\fP... +.TP +\fIфилтер\fP +Назив филтера +.TP +\fIопција\fP +Назив филтера специфичне опције +.TP +\fIвредност\fP +Опсези бројевних \fIвредности\fP се јављају као +\fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. \fIВредност\fP ниске избора се приказују +унутар \fB< >\fP и раздвојене су знаком \fB|\fP. +.PP +Сваки филтер се исписује на свом сопственом реду. +. +.SS "Информације о ограничењу меморије" +\fBxz \-\-robot \-\-info\-memory\fP исписује један ред са више колона раздвојених +табулатором: +.IP 1. 4 +Укупна количина физичке меморије (RAM) у бајтима. +.IP 2. 4 +Ограничење коришћења меморије за запакивање у бајтима +(\fB\-\-memlimit\-compress\fP). Специјална вредност \fB0\fP означава основно +подешавање које је за режим једне нити исто као без ограничења. +.IP 3. 4 +Ограничење коришћења меморије за распакивање у бајтима +(\fB\-\-memlimit\-decompress\fP). Специјална вредност \fB0\fP означава основно +подешавање које је за режим једне нити исто као без ограничења. +.IP 4. 4 +Од \fBxz\fP 5.3.4alpha: Коришћење меморије за распакивање са више нити у +бајтима (\fB\-\-memlimit\-mt\-decompress\fP). Ово никада није нула јер систему +специфична основна вредност приказана у колони 5 се користи ако ограничење +није изричито наведено. Такође никада није веће од вредности у колони 3 чак +и ако је наведена већа вредност са \fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Од \fBxz\fP 5.3.4alpha: Систему специфично основно ограничење коришћења +меморије које се користи за ограничавање броја нити приликом запакивања са +аутоматским бројем нити (\fB\-\-threads=0\fP) и без наведеног ограничења +коришћења меморије (\fB\-\-memlimit\-compress\fP). Ово се такође користи као +основна вредност за \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Од \fBxz\fP 5.3.4alpha: Број доступних нити обрађивача. +.PP +У будуће, излаз \fBxz \-\-robot \-\-info\-memory\fP може имати више колона, али +никада више од једног реда. +. +.SS Издање +\fBxz \-\-robot \-\-version\fP исписује број издања за \fBxz\fP и „liblzma“ у следећем +формату: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Главно издање. +.TP +\fIYYY\fP +Споредно издање. Парни бројеви су стабилна а непарни су алфа или бета +издања. +.TP +\fIZZZ\fP +Ниво закрпе за стабилна издања или само бројач за развојна издања. +.TP +\fIS\fP +Стабилност. 0 је алфа, 1 је бета, а 2 је стабилно. \fIS\fP треба увек да буде +2 када је \fIYYY\fP парно. +.PP +\fIXYYYZZZS\fP су исти у оба реда ако су \fBxz\fP и „liblzma“ из истог издања XZ +Utils\-а. +.PP +Примери: 4.999.9beta је \fB49990091\fP и 5.0.0 је \fB50000002\fP. +. +.SH "СТАЊЕ ИЗЛАЗА" +.TP +\fB0\fP +Све је у реду. +.TP +\fB1\fP +Дошло је до грешке. +.TP +\fB2\fP +Десило се нешто вредно упозорења, али није дошло до стварних грешака. +.PP +Обавештења (без упозорења или грешака) исписано на стандардној грешци не +утичу на стање излаза. +. +.SH ОКРУЖЕЊЕ +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP обрађује размаком одвојени списак опција из променљивих окружења +\fBXZ_DEFAULTS\fP и \fBXZ_OPT\fP, тим редом, пре обраде опција са линије наредби. +Знајте да се обрађују само опције из променљивих окружења; све што нису +опције се тихо занемарује. Обрада се ради са \fBgetopt_long\fP(3) која се +користи такође за аргументе линије наредби. +.PP +\fBУпозорење:\fP Постављањем ових променљивих окружења, ефективно мењате +програме и скрипте које покреће \fBxz\fP. У већини случајева је безбедно +поставити ограничење коришћења, број нити и опција паковања путем +променљивих окружења. Међутим, неке опције могу да уруше скрипте. +Очигледан пример је \fB\-\-help\fP која чини да \fBxz\fP прикаже текст помоћи уместо +да запакује или распакује датотеку. Суптилнији примери су \fB\-\-quiet\fP и +\fB\-\-verbose\fP. У многим случајевима добро функционише омогућавање указивача +напредовања коришћењем \fB\-\-verbose\fP, али у неким ситуацијама додатне поруке +стварају проблеме. Ниво опширности такође утиче на понашање \fB\-\-list\fP +.TP +\fBXZ_DEFAULTS\fP +Кориснику специфичне или свеопште системске основне опције. Обично је ово +постављено у скрипти покретања конзоле за укључивање \fBxz\fP ограничавача +коришћења меморије по основи или за постављање основног броја нити. +Искључивање скрипти покретања конзоле и сличних специјалних случајева, +скрипте не смеју никада да поставе или пониште \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Ово је за прослеђивање опција ка \fBxz\fP када није могуће поставити опције +директно на \fBxz\fP линији наредби. Ово је случај када је \fBxz\fP покренут +скриптом или алатом, на пример, са Гну \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Скрипте могу да користе \fBXZ_OPT\fP, на пример, за постављање основних опција +запакивања специфичних скрипти. Још увек се препоручује омогућавање +корисницима да пишу преко \fBXZ_OPT\fP ако је то разумљиво. На пример, у +\fBsh\fP(1) скриптама неко може користити нешто као ово: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "LZMA UTILS САДЕЈСТВЕНОСТ" +Синтакса линије наредби \fBxz\fP је практично супер скуп \fBlzma\fP, \fBunlzma\fP и +\fBlzcat\fP као што се налази у LZMA Utils 4.32.x. У већини случајева, могуће +је заменити LZMA Utils са XZ Utils без оштећења постојећих скрипти. Има +неких несагласности такође, које понекад могу довести до проблема. +. +.SS "Нивои предподешавања запакивања" +Набрајање предподешености нивоа запакивања није исто у \fBxz\fP и LZMA Utils. +Најважнија разлика је у томе како се величине речника мапирају у различитим +предподешеностима. Величина речника је отприлике иста као и коришћење +меморије распакивача. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Ниво;xz;LZMA Utils +\-0;256 KiB;Н/Д +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Разлике величине речника делују такође на коришћење меморије запакивање, али +постоје још неке разлике између LZMA Utils и XZ Utils, што чини разлике још +већим: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Ниво;xz;LZMA Utils 4.32.x +\-0;3 MiB;Н/Д +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Основни ниво предподешености у LZMA Utils је \fB\-7\fP док у XZ Utils је \fB\-6\fP, +тако да оба користе 8 MiB речник по основи. +. +.SS "Токовне наспрам не\-токовних „.lzma“ датотеке" +Незапакована величина датотеке се може чувати у \fB.lzma\fP заглављу. LZMA +Utils то ради приликом запакивања обичних датотека. Алтернатива је да се +означи та незапакована величина као непозната и да се користи означавач +краја утовара да назначи где распакивач треба да стане. LZMA Utils користи +ову методу када незапакована величина није позната, што је случај, на +пример, у спојкама. +.PP +\fBxz\fP подржава распакивање \fB.lzma\fP датотека са или без означавача краја +утовара, али ће све \fB.lzma\fP датотеке направљене са \fBxz\fP користити +означавач краја утовара и означити незапаковану величину непознатом у +\&\fB.lzma\fP заглављу. Ово може бити проблем у неким неуобичајеним +ситуацијама. На пример, \fB.lzma\fP распакивач у угнежденом уређају може +радити само са датотекама које имају незапаковану величину. Ако наиђете на +тај проблем, треба да користите LZMA Utils или LZMA SDK да направите +\&\fB.lzma\fP датотеке са познатом незапакованом величином. +. +.SS "Неподржане „.lzma“ датотеке" +Формат \fB.lzma\fP омогућава \fIlc\fP вредности све до 8, а \fIlp\fP вредности све до +4. LZMA Utils може да распакује датотеке са било којим \fIlc\fP и \fIlp\fP, али +увек прави датотеке са \fBlc=3\fP и \fBlp=0\fP. Прављење датотека са другим \fIlc\fP +и \fIlp\fP је мгуће са \fBxz\fP и са LZMA SDK. +.PP +Примена филтера LZMA1 у „liblzma“ захтева да збир \fIlc\fP и \fIlp\fP не сме да +премаши 4. Стога, \fB.lzma\fP датотеке, које премаше ово ограничење, не могу +да се распакују са \fBxz\fP. +.PP +LZMA Utils прави само \fB.lzma\fP датотеке које имају величину речника од +2^\fIn\fP (степен 2) али прихвата датотеке са било којом величином речника. +„liblzma“ прихвата само \fB.lzma\fP датотеке које имају величину речника од +2^\fIn\fP или 2^\fIn\fP + 2^(\fIn\fP\-1). Ово је да се смање лажни позитивни +резултати приликом откривања \fB.lzma\fP датотека. +.PP +Ова ограничења не би требало да буду проблем у пракси, јер су практично све +\&\fB.lzma\fP датотеке запаковане са поставкама које ће „liblzma“ прихватити. +. +.SS "Пратеће смеће" +Приликом распакивања, LZMA Utils тихо занемарује све после првог \fB.lzma\fP +тока. У већини прилика, ово је грешка. Ово такође значи да LZMA Utils не +подржава распакивање надовезаних \fB.lzma\fP датотека. +.PP +Ако су остали подаци након првог \fB.lzma\fP тока, \fBxz\fP сматра да је датотека +оштећена осим ако је коришћено \fB\-\-single\-stream\fP. Ово може прекинути +нејасне скрипте које су претпоставиле да је пратеће смеће занемарено. +. +.SH НАПОМЕНЕ +. +.SS "Излаз запакованог може бити променљив" +Тачан запаковани излаз добијен из исте незапаковане улазне датотеке може се +разликовати између XZ Utils издања чак и ако су опције запакивања +истоветне. Ово је због тога што шифрер може бити побољшан (брже и боље +запакивање) а да не утиче на формат датотеке. Излаз се може разликовати +између различитих изградњи истог XZ Utils издања, ако су коришћене другачије +опције изградње. +.PP +Ово изнад значи да када се \fB\-\-rsyncable\fP једном примени, резултирајућа +датотека неће неопходно бити r\-ускладива осим ако и стара и нова датотека +нису запаковане истим xz издањем. Овај проблем може бити поправљен ако је +део примене шифрера замрзнут да држи r\-ускладив излаз стабилним кроз xz +издања. +. +.SS "Угнеждени „.xz“ распакивачи" +Примена угнежденог \fB.xz\fP распакивача као што је XZ Embedded неопходно не +подржава датотеке направљене врстама \fIпровере\fP целовитости осим \fBnone\fP и +\fBcrc32\fP. Како је основно \fB\-\-check=crc64\fP, морате да користите +\fB\-\-check=none\fP или \fB\-\-check=crc32\fP када правите датотеке за угнеждене +системе. +.PP +Споља уграђени системи, сви распакивачи \fB.xz\fP формата подржавају све врсте +\fIпровере\fP, или барем могу да распакују датотеку без испитивања провере +целовитости ако одређена \fIпровера\fP није подржана. +.PP +XZ Embedded подржава BCJ филтере, али само са основним померајем почетка. +. +.SH ПРИМЕРИ +. +.SS Основно +Запакује датотеку \fIfoo\fP у \fIfoo.xz\fP користећи основни ниво запакивања +(\fB\-6\fP), и уклања \fIfoo\fP ако је запакивање успешно: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Распакује \fIbar.xz\fP у \fIbar\fP и не уклања \fIbar.xz\fP чак и када је распакивање +успешно: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Ствара \fIbaz.tar.xz\fP са предподешавањем \fB\-4e\fP (\fB\-4 \-\-extreme\fP), које је +спорије него основно \fB\-6\fP, али захтева мање меморије за запакивање и +распакивање (48\ MiB и 5\ MiB): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Мешавина сажетих и несажетих датотека се може распаковати на стандардни +излаз једном наредбом: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Паралелно запакивање више датотека" +На GNU и *BSD, \fBfind\fP(1) и \fBxargs\fP(1) се могу користити за паралелно +запакивање више датотека: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Опција \fB\-P\fP за \fBxargs\fP(1) поставља број паралелних \fBxz\fP процеса. Најбоља +вредност за опцију \fB\-n\fP зависи од тога колико датотека има за запакивање. +Ако има само неколико датотека, вредност би вероватно требала да буде 1; са +више хиљада датотека, 100 или чак и више може бити одговарајуће за смањење +броја \fBxz\fP процеса које би \fBxargs\fP(1) евентуално направио. +.PP +Опција \fB\-T1\fP за \fBxz\fP је ту да га примора на једнонитни режим, јер се +\fBxargs\fP(1) користи за контролу количине паралелизације. +. +.SS "Режим робота" +Израчунава колико је бајтова укупно сачувано након запакивања више датотека: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Скрипта може желети да зна да користи најновији \fBxz\fP. Следећа скрипта +\fBsh\fP(1) проверава да ли је број издања \fBxz\fP алата барем 5.0.0. Ова +метода је сагласна са старим бета издањима која не подржавају \fB\-\-robot\fP +опцију: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Ваш „xz“ је превише стар." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Поставља ограничење коришћења меморије за распакивање коришћењем \fBXZ_OPT\fP, +али ако је ограничење већ постављено, не повећава је: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Произвољни ланци филтера запакивача" +Најједноставнија употреба за произвољне ланце филтера прилагођава LZMA2 +предподешеност. Ово може бити корисно, јер предподешености покривају само +подскуп потенцијално корисних комбинација поставки запакивања. +.PP +Колоне ЗапакЦПЈ у табелама из описа опција \fB\-0\fP ... \fB\-9\fP и \fB\-\-extreme\fP су +корисне приликом прилагођавања LZMA2 предподешености. Овде су значајни +делови прикупљени из те две табеле: +.RS +.PP +.TS +tab(;); +c c +n n. +Преподешеност;ЗапакЦПЈ +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Ако знате да датотека захтева нешто велики речник (на пример, 32 \ MiB) за +добро запакивање, али желите да је запакујете брже него што би то \fBxz \-8\fP +урадио, предподешеност са ниском вредношћу ЗапакМем (на пример, 1) може се +изменити да користи већи речник: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Са одређеним датотекама, горња наредба може бити бржа од \fBxz \-6\fP а +запакивање значајно боље. Међутим, мора бити наглашено да само неке +датотеке имају корист од великог речника док одржавају вредност ЗапакЦПЈ +ниском. Најочигледнија ситуација, у којој велики речник може доста помоћи, +јесте архива која садржи врло сличне датотеке где свака има најмање неколико +мегабајта. Величина речника треба да буде значајно већа од сваке засебне +датотеке да би се омогућило да LZMA2 има потпуну предност од сличности +између узастопних датотека. +.PP +Ако је веома велико коришћење меморије запакивача и распакивача у реду, а +датотека која се запакује је барем неколико стотина мегабајта, може бити +корисно користити још већи речник од 64 MiB који ће \fBxz \-9\fP користити: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Коришћење \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) као у горњем примеру може бити +корисно да се виде захтеви за меморијом запакивача и распакивача. Знајте да +је коришћење речника већег од величине незапаковане датотеке губитак +меморије, тако да горња наредба није корисна за мале датотеке. +.PP +Понекад време запакивања није важно, али коришћење меморије распакивача +треба да се одржава ниским, на пример, да би се учинило могућим распакивање +датотеке на угнежденом систему, Следеће наредбе користе \fB\-6e\fP (\fB\-6 \-\-extreme\fP) као основу и постављају речник на само 64\ KiB. Резултујућа +датотека се може распаковати са XZ Embedded (због тога је ту +\fB\-\-check=crc32\fP) користећи око 100\ KiB меморије. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Ако желите да исцедите што је више могуће бајтова, дотеривање броја битова +контекста литерала (\fIlc\fP) и броја битова положаја (\fIpb\fP) може понекад да +помогне. Дотеривање броја битова положаја литерала (\fIlp\fP) може такође да +помогне, али обично \fIlc\fP и \fIpb\fP су важнији. На пример, архива извора кода +садржи углавном US\-ASCII текст, тако да нешто као следеће може да да +незнатно (око 0.1\ %) мању датотеку него \fBxz \-6e\fP (пробајте такође без +\fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Коришћење још једног филтера заједно са LZMA2 може побољшати запакивање са +одређеним врстама датотека. На пример, за запакивање x86\-32 или x86\-64 +дељене библиотеке коришћењем x86 BCJ филтера: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Знајте да поредак опција филтера има значај. Ако је \fB\-\-x86\fP наведено након +\fB\-\-lzma2\fP, \fBxz\fP ће дати грешку, јер не сме бити никаквог филтера после +LZMA2, и такође зато што се x86 BCJ филтер не може користити као последњи +филтер у ланцу. +.PP +Delta филтер заједно са LZMA2 може дати добре резултате са битмап сликама. +Требало би обично да надјача PNG, који има нешто више напредних филтера него +једноставни делта али користи Deflate за стварно запакивање. +.PP +Слика треба да се сачува у незапакованом формату, на пример, као +незапакована TIFF. Параметар растојања Delta филтера је постављен да се +подудари са бројем бајтова по пикселу у слици. На пример, RGB битмапа од 24 +бита захтева \fBdist=3\fP, а такође је добро проследити \fBpb=0\fP за LZMA2 да се +прилагоди поравнање од три бајта: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Ако је више слика стављено у једну архиву (на пример, \fB.tar\fP), Delta филтер +ће радити на томе такође све док све слике не буду имале исти број бајтова +по пикселу. +. +.SH "ВИДИТЕ ТАКОЂЕ" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzcmp.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzcmp.1 new file mode 100644 index 0000000000000000000000000000000000000000..6c9ef9938e11d68a13510dffa145304439b97e6c --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzcmp.1 @@ -0,0 +1,54 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Serbian translation of xz-man. +.\" Мирослав Николић , 2025. +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 06.03.2025. Tukaani "XZ Utils" +.SH НАЗИВ +xzcmp, xzdiff, lzcmp, lzdiff – упоређује запаковане датотеке +. +.SH САЖЕТАК +\fBxzcmp\fP [\fIопција...\fP] \fIдатотека1\fP [\fIдатотека2\fP] +.br +\fBxzdiff\fP \&... +.br +\fBlzcmp\fP \&... (ЗАСТАРЕЛО) +.br +\fBlzdiff\fP \&... (ЗАСТАРЕЛО) +. +.SH ОПИС +\fBxzcmp\fP и \fBxzdiff\fP пореди незапаковане садржаје две датотеке. +Незапаковани подаци и опције се прослеђују ка \fBcmp\fP(1) или \fBdiff\fP(1) осим +ако није наведено \fB\-\-help\fP or \fB\-\-version\fP. +.PP +Ако су наведене и \fIдатотека1\fP и \fIдатотека2\fP, оне могу бити незапаковане +датотеке или датотеке у форматима које \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), +\fBlzop\fP(1), \fBzstd\fP(1) или \fBlz4\fP(1) могу да распакују. Захтеване наредбе +распакивања се одређују из суфикса назива \fIдатотеке1\fP и \fIдатотеке2\fP. +Датотека са непознатим суфиксом се претпоставља да је незапакована или да је +у формату који \fBxz\fP(1) може да распакује. +.PP +Ако је достављен само један назив датотеке, \fIдатотека1\fP мора да има суфикс +подржаних формата запакивања а назив за \fIдатотеку2\fP се подразумева да је +\fIдатотека1\fP са уклоњеним суфиксом формата запакивања. +.PP +Наредбе \fBlzcmp\fP и \fBlzdiff\fP се достављају зарад назадне сагласности са LZMA +Utils. Застареле су и биће уклоњене у будућем издању. +. +.SH "СТАЊЕ ИЗЛАЗА" +Ако дође до грешке распакивања,излазно стање је \fB2\fP. У супротном излазно +стање од \fBcmp\fP(1) или \fBdiff\fP(1) се користи. +. +.SH "ВИДИТЕ ТАКОЂЕ" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzdiff.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzdiff.1 new file mode 100644 index 0000000000000000000000000000000000000000..6c9ef9938e11d68a13510dffa145304439b97e6c --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzdiff.1 @@ -0,0 +1,54 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Serbian translation of xz-man. +.\" Мирослав Николић , 2025. +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 06.03.2025. Tukaani "XZ Utils" +.SH НАЗИВ +xzcmp, xzdiff, lzcmp, lzdiff – упоређује запаковане датотеке +. +.SH САЖЕТАК +\fBxzcmp\fP [\fIопција...\fP] \fIдатотека1\fP [\fIдатотека2\fP] +.br +\fBxzdiff\fP \&... +.br +\fBlzcmp\fP \&... (ЗАСТАРЕЛО) +.br +\fBlzdiff\fP \&... (ЗАСТАРЕЛО) +. +.SH ОПИС +\fBxzcmp\fP и \fBxzdiff\fP пореди незапаковане садржаје две датотеке. +Незапаковани подаци и опције се прослеђују ка \fBcmp\fP(1) или \fBdiff\fP(1) осим +ако није наведено \fB\-\-help\fP or \fB\-\-version\fP. +.PP +Ако су наведене и \fIдатотека1\fP и \fIдатотека2\fP, оне могу бити незапаковане +датотеке или датотеке у форматима које \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), +\fBlzop\fP(1), \fBzstd\fP(1) или \fBlz4\fP(1) могу да распакују. Захтеване наредбе +распакивања се одређују из суфикса назива \fIдатотеке1\fP и \fIдатотеке2\fP. +Датотека са непознатим суфиксом се претпоставља да је незапакована или да је +у формату који \fBxz\fP(1) може да распакује. +.PP +Ако је достављен само један назив датотеке, \fIдатотека1\fP мора да има суфикс +подржаних формата запакивања а назив за \fIдатотеку2\fP се подразумева да је +\fIдатотека1\fP са уклоњеним суфиксом формата запакивања. +.PP +Наредбе \fBlzcmp\fP и \fBlzdiff\fP се достављају зарад назадне сагласности са LZMA +Utils. Застареле су и биће уклоњене у будућем издању. +. +.SH "СТАЊЕ ИЗЛАЗА" +Ако дође до грешке распакивања,излазно стање је \fB2\fP. У супротном излазно +стање од \fBcmp\fP(1) или \fBdiff\fP(1) се користи. +. +.SH "ВИДИТЕ ТАКОЂЕ" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzegrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzegrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..263fed9983f5d102ed2d439771a6732ae1b767b1 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzegrep.1 @@ -0,0 +1,92 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Serbian translation of xz-man. +.\" Мирослав Николић , 2025. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 06.03.2025. Tukaani "XZ Utils" +.SH НАЗИВ +xzgrep – претражује могуће запаковане датотеке за шаблонима +. +.SH САЖЕТАК +\fBxzgrep\fP [\fIопција...\fP] [\fIсписак_шаблона\fP] [\fIдатотека...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (ЗАСТАРЕЛО) +.br +\fBlzegrep\fP \&... (ЗАСТАРЕЛО) +.br +\fBlzfgrep\fP \&... (ЗАСТАРЕЛО) +. +.SH ОПИС +\fBxzgrep\fP призива \fBgrep\fP(1) на незапакованим садржајима датотека. Формати +\fIдатотека\fP се одређују из суфикса назива датотека. Било која \fIдатотека\fP +са суфиксом подржаним од стране \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), +\fBlzop\fP(1), \fBzstd\fP(1) или \fBlz4\fP(1) биће распакована; све остале датотеке +се подразумевају да нису запаковане. +.PP +Ако \fIдатотеке\fP нису наведене или \fIдатотека\fP је \fB\-\fP тада се чита +стандардни улаз. Приликом читања са стандардног улаза, само датотеке +подржане са \fBxz\fP(1) се распакују. Друге датотеке се подразумева да су већ +у незапакованом облику. +.PP +Већина \fIопција\fP \fBgrep\fP(1) је подржана. Међутим, следеће опције нису +подржане: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIрадња\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIдатотека\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglob\fP +.PP +\fBxzegrep\fP је алијас за \fBxzgrep \-E\fP. \fBxzfgrep\fP је алијас за \fBxzgrep \-F\fP. +.PP +Наредбе \fBlzgrep\fP, \fBlzegrep\fP и \fBlzfgrep\fP се достављају зарад назадне +сагласности са LZMA Utils. Застареле су и биће уклоњене у будућем издању. +. +.SH "СТАЊЕ ИЗЛАЗА" +.TP +0 +Најмање једно поклапање је пронађено из барем једне од улазних датотека. +Није било грешака. +.TP +1 +Никаква поклапања нису пронађена ни из једне од улазних датотека. Није дошло +до грешака. +.TP +>1 +Дошло је до једне или више грешака. Није познато да ли су поклапања нађена. +. +.SH ОКРУЖЕЊЕ +.TP +\fBGREP\fP +Ако је \fBGREP\fP постављено на не\-празну вредност, користи се уместо \fBgrep\fP, +\fBgrep \-E\fP или \fBgrep \-F\fP. +. +.SH "ВИДИТЕ ТАКОЂЕ" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzfgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzfgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..263fed9983f5d102ed2d439771a6732ae1b767b1 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzfgrep.1 @@ -0,0 +1,92 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Serbian translation of xz-man. +.\" Мирослав Николић , 2025. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 06.03.2025. Tukaani "XZ Utils" +.SH НАЗИВ +xzgrep – претражује могуће запаковане датотеке за шаблонима +. +.SH САЖЕТАК +\fBxzgrep\fP [\fIопција...\fP] [\fIсписак_шаблона\fP] [\fIдатотека...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (ЗАСТАРЕЛО) +.br +\fBlzegrep\fP \&... (ЗАСТАРЕЛО) +.br +\fBlzfgrep\fP \&... (ЗАСТАРЕЛО) +. +.SH ОПИС +\fBxzgrep\fP призива \fBgrep\fP(1) на незапакованим садржајима датотека. Формати +\fIдатотека\fP се одређују из суфикса назива датотека. Било која \fIдатотека\fP +са суфиксом подржаним од стране \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), +\fBlzop\fP(1), \fBzstd\fP(1) или \fBlz4\fP(1) биће распакована; све остале датотеке +се подразумевају да нису запаковане. +.PP +Ако \fIдатотеке\fP нису наведене или \fIдатотека\fP је \fB\-\fP тада се чита +стандардни улаз. Приликом читања са стандардног улаза, само датотеке +подржане са \fBxz\fP(1) се распакују. Друге датотеке се подразумева да су већ +у незапакованом облику. +.PP +Већина \fIопција\fP \fBgrep\fP(1) је подржана. Међутим, следеће опције нису +подржане: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIрадња\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIдатотека\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglob\fP +.PP +\fBxzegrep\fP је алијас за \fBxzgrep \-E\fP. \fBxzfgrep\fP је алијас за \fBxzgrep \-F\fP. +.PP +Наредбе \fBlzgrep\fP, \fBlzegrep\fP и \fBlzfgrep\fP се достављају зарад назадне +сагласности са LZMA Utils. Застареле су и биће уклоњене у будућем издању. +. +.SH "СТАЊЕ ИЗЛАЗА" +.TP +0 +Најмање једно поклапање је пронађено из барем једне од улазних датотека. +Није било грешака. +.TP +1 +Никаква поклапања нису пронађена ни из једне од улазних датотека. Није дошло +до грешака. +.TP +>1 +Дошло је до једне или више грешака. Није познато да ли су поклапања нађена. +. +.SH ОКРУЖЕЊЕ +.TP +\fBGREP\fP +Ако је \fBGREP\fP постављено на не\-празну вредност, користи се уместо \fBgrep\fP, +\fBgrep \-E\fP или \fBgrep \-F\fP. +. +.SH "ВИДИТЕ ТАКОЂЕ" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..263fed9983f5d102ed2d439771a6732ae1b767b1 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzgrep.1 @@ -0,0 +1,92 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Serbian translation of xz-man. +.\" Мирослав Николић , 2025. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 06.03.2025. Tukaani "XZ Utils" +.SH НАЗИВ +xzgrep – претражује могуће запаковане датотеке за шаблонима +. +.SH САЖЕТАК +\fBxzgrep\fP [\fIопција...\fP] [\fIсписак_шаблона\fP] [\fIдатотека...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (ЗАСТАРЕЛО) +.br +\fBlzegrep\fP \&... (ЗАСТАРЕЛО) +.br +\fBlzfgrep\fP \&... (ЗАСТАРЕЛО) +. +.SH ОПИС +\fBxzgrep\fP призива \fBgrep\fP(1) на незапакованим садржајима датотека. Формати +\fIдатотека\fP се одређују из суфикса назива датотека. Било која \fIдатотека\fP +са суфиксом подржаним од стране \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), +\fBlzop\fP(1), \fBzstd\fP(1) или \fBlz4\fP(1) биће распакована; све остале датотеке +се подразумевају да нису запаковане. +.PP +Ако \fIдатотеке\fP нису наведене или \fIдатотека\fP је \fB\-\fP тада се чита +стандардни улаз. Приликом читања са стандардног улаза, само датотеке +подржане са \fBxz\fP(1) се распакују. Друге датотеке се подразумева да су већ +у незапакованом облику. +.PP +Већина \fIопција\fP \fBgrep\fP(1) је подржана. Међутим, следеће опције нису +подржане: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIрадња\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIдатотека\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglob\fP +.PP +\fBxzegrep\fP је алијас за \fBxzgrep \-E\fP. \fBxzfgrep\fP је алијас за \fBxzgrep \-F\fP. +.PP +Наредбе \fBlzgrep\fP, \fBlzegrep\fP и \fBlzfgrep\fP се достављају зарад назадне +сагласности са LZMA Utils. Застареле су и биће уклоњене у будућем издању. +. +.SH "СТАЊЕ ИЗЛАЗА" +.TP +0 +Најмање једно поклапање је пронађено из барем једне од улазних датотека. +Није било грешака. +.TP +1 +Никаква поклапања нису пронађена ни из једне од улазних датотека. Није дошло +до грешака. +.TP +>1 +Дошло је до једне или више грешака. Није познато да ли су поклапања нађена. +. +.SH ОКРУЖЕЊЕ +.TP +\fBGREP\fP +Ако је \fBGREP\fP постављено на не\-празну вредност, користи се уместо \fBgrep\fP, +\fBgrep \-E\fP или \fBgrep \-F\fP. +. +.SH "ВИДИТЕ ТАКОЂЕ" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzless.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzless.1 new file mode 100644 index 0000000000000000000000000000000000000000..af9fd3a0e92153e5cc2db427e2cbf48088bbb682 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzless.1 @@ -0,0 +1,47 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" Serbian translation of xz-man. +.\" Мирослав Николић , 2025. +.\" +.\" (Note that this file is not based on gzip's zless.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZLESS 1 06.03.2025. Tukaani "XZ Utils" +.SH НАЗИВ +xzless, lzless – приказује „xz“ или „lzma“ запаковане (текстуалне) датотеке +.SH САЖЕТАК +\fBxzless\fP [\fIдатотека\fP...] +.br +\fBlzless\fP [\fIдатотека\fP...] (ЗАСТАРЕЛО) +.SH ОПИС +\fBxzless\fP је филтер који приказује текст из запакованих датотека у +терминалу. Датотеке које подржава \fBxz\fP(1) се распакују; остале датотеке се +већ подразумева да су у незапакованом облику. Ако није дата ни једна +\fIдатотека\fP, \fBxzless\fP чита са стандардног улаза. +.PP +\fBxzless\fP користи \fBless\fP(1) да представи свој излаз. За разлику од +\fBxzmore\fP, његов избор страничара се не може изменити постављањем променљиве +окружења. Наредбе се заснивају и на \fBmore\fP(1) и на \fBvi\fP(1) и дозвољавају +померање и претрагу назад и напред. Видите упутство \fBless\fP(1) за више +информација. +.PP +Наредба \fBlzless\fP се доставља зарад назадне сагласности са LZMA +Utils. Застарела је и биће уклоњена у будућем издању. +.SH ОКРУЖЕЊЕ +.TP +\fBLESSMETACHARS\fP +Списак знакова нарочитих за шкољку. Поставите са \fBxzless\fP осим ако већ +није постављено у окружењу. +.TP +\fBLESSOPEN\fP +Поставља да линија наредби призове \fBxz\fP(1) распакивач за предобраду улазних +датотека на \fBless\fP(1). +.SH "ВИДИТЕ ТАКОЂЕ" +\fBless\fP(1), \fBxz\fP(1), \fBxzmore\fP(1), \fBzless\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzma.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzma.1 new file mode 100644 index 0000000000000000000000000000000000000000..82d831001e1f400683d876e945d108fa8686a45a --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzma.1 @@ -0,0 +1,1928 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Serbian translation of xz-man. +.\" Мирослав Николић , 2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 08.03.2025. Tukaani "XZ Utils" +. +.SH НАЗИВ +xz, unxz, xzcat, lzma, unlzma, lzcat – Запакује или распакује „.xz“ и „.lzma +датотеке +. +.SH САЖЕТАК +\fBxz\fP [\fIопција...\fP] [\fIдатотека...\fP] +. +.SH "АЛИЈАСИ НАРЕДБЕ" +\fBunxz\fP је исто као и \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP је исто као и \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP је исто као и \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP је исто као и \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP је исто као и \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Приликом писања скрипти које треба да распакују датотеке, препоручује се да +се увек користи назив \fBxz\fP са одговарајућим аргументима (\fBxz \-d\fP или \fBxz \-dc\fP) уместо назива \fBunxz\fP и \fBxzcat\fP. +. +.SH ОПИС +\fBxz\fP је алат опште употребе за запакивање података са синтаксом линије +наредби сличан као \fBgzip\fP(1) и \fBbzip2\fP(1). Изворни формат датотеке је +\&\fB.xz\fP формат, али стари \fB.lzma\fP формат који користи LZMA Utils и сирови +запаковани токови без заглавља формата су такође подржани. Уз то, +распакивање \fB.lz\fP формата који користи \fBlzip\fP је подржано. +.PP +\fBxz\fP запакује или распакује сваку \fIдатотеку\fP у складу са изабраним режимом +рада. Ако није дата ни једна \fIдатотека\fP или је датотека \fIfile\fP \fB\-\fP, +\fBxz\fP чита са стандардног улаза и записује обрађене податке на стандардни +излаз. \fBxz\fP ће одбити (приказаће грешку и прескочити \fIдатотеку\fP) да пише +запаковане податке на стандардни излаз ако је то терминал. Слично, \fBxz\fP ће +одбити да чита запаковане податке са стандардног улаза ако је то терминал. +.PP +Осим ако није наведено \fB\-\-stdout\fP, \fIдатотеке\fP које нису \fB\-\fP се пишу у +нову датотеку чији назив је проистекао из назива изворне \fIдатотеке\fP: +.IP \(bu 3 +Приликом запакивања, суфикс формата циљне датотеке (\fB.xz\fP или \fB.lzma\fP) се +додаје на назив изворне датотеке да би се добио назив циљне датотеке. +.IP \(bu 3 +Приликом распакивања, суфикс \fB.xz\fP, \fB.lzma\fP или \fB.lz\fP се уклања из назива +датотеке да би се добио назив циљне датотеке. \fBxz\fP такође препознаје +суфиксе \fB.txz\fP и \fB.tlz\fP и замењује их суфиксом \fB.tar\fP. +.PP +Ако циљна датотека већ пстоји, приказује се грешка а \fIдатотека\fP се +прескаче. +.PP +Осим ако не пише на стандардни излаз, \fBxz\fP ће приказати упозорење и +прескочити \fIдатотеку\fP ако се нешто од следећег примењује: +.IP \(bu 3 +\fIДатотека\fP није обична датотека. Симболичке везе се не прате, и стога се +не сматра да су обичне датотеке. +.IP \(bu 3 +\fIДатотека\fP има више од једне чврсте везе. +.IP \(bu 3 +\fIДатотека\fP има постављен „setuid, setgid“ или лепљиви бит. +.IP \(bu 3 +Режим рада је постављен на запакивање а \fIдатотека\fP већ има суфикс формата +циљне датотеке (\fB.xz\fP или \fB.txz\fP приликом запакивања у \fB.xz\fP формат, а +\&\fB.lzma\fP или \fB.tlz\fP приликом запакивања у \fB.lzma\fP формат). +.IP \(bu 3 +Режим радње је постављен за распакивање а \fIдатотека\fP нема суфикс ни једног +од подржаних формата датотеке (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP или +\&\fB.lz\fP). +.PP +Након успешног сажимања или распакивања \fIдатотеке\fP, \fBxz\fP умножава +власника, групу, дозволе, време приступа и време измене из изворне +\fIдатотеке\fP у циљну датотеку. Ако умножавање групе не успе, дозволе су +измењене тако да циљна датотека не постане доступна корисницима који нису +имали дозволу за приступ изворној \fIдатотеци\fP. \fBxz\fP не подржава умножавање +других метаподатака попут списка контрола приступа или проширених атрибута. +.PP +Једном када је циљна датотека успешно затворена, изворна \fIдатотека\fP се +уклања осим ако се \fB\-keep\fP не наведе. Изворна \fIдатотека\fP се никада не +уклања ако се излаз пише на стандардни излаз или ако дође до грешке. +.PP +Слање \fBSIGINFO\fP или \fBSIGUSR1\fP ка \fBxz\fP процесу чини да испише информације +напредовања на стандардну грешку. Ово има ограничено коришћење све док +стандардна грешка јесте терминал, коришћење \fB\-\-verbose\fP приказаће +аутоматски указивач напретка освежавања. +. +.SS "Коришћење меморије" +Коришћење меморије \fBxz\fP се мења од неколико стотина килобајта до неколико +гигабајта у зависности од поставки запакивања. Поставке коришћене приликом +запакивања датотеке одређују захтеве меморије распакивача. Обично +распакивачу треба 5\ % до 20\ % количине меморије која је потребна +запакивачу приликом прављења датотеке. На пример, распакивање датотеке +направљене са \fBxz \-9\fP тренутно захтева 65\ MiB меморије. Још увек, могуће +је имати \fB.xz\fP датотеке које захтевају неколико гигабајта меморије за +распакивање. +.PP +Нарочито корисници старијих система могу наћи досадном могућност коришћења +врло велике меморије. Да би се спречила нежељена изненађења, \fBxz\fP има +уграђен ограничавач коришћења меморије, који је искључен по основи. Док +неки оперативни системи пружају начин за ограничавање коришћење меморије за +процесе, ослањање на то сматра се да није довољно прилагодљиво (на пример, +коришћење \fBulimit\fP(1) за ограничавање виртуелне меморије тежи да обогаљи +\fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Ограничавач коришћења меморије се може укључити опцијом линије наредби +\fB\-\-memlimit=\fP\fIограничење\fP. Често је најпогодније укључити ограничавач по +основи постављањем променљиве окружења \fBXZ_DEFAULTS\fP, на пример, +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Могуће је поставити ограничења засебно за +запакивање и распакивање коришћењем \fB\-\-memlimit\-compress=\fP\fIограничење\fP и +\fB\-\-memlimit\-decompress=\fP\fIограничење\fP. Коришћење ове две опције ван +\fBXZ_DEFAULTS\fP је ретко корисно јер једно покретање \fBxz\fP не може да ради и +запакивање и распакивање а \fB\-\-memlimit=\fP\fIограничење\fP (или \fB\-M\fP +\fIограничење\fP) је краће за куцање на линији наредби. +.PP +Ако је прекорачено наведено ограничење коришћења меморије, \fBxz\fP ће +приказати грешку а распакивање датотеке неће успети. Ако је ограничење +прекорачено приликом запакивања, \fBxz\fP ће покушати да умањи поставке тако да +се ограничење више не прекорачује (оси када се користи \fB\-\-format=raw\fP или +\fB\-\-no\-adjust\fP). На тај начин радња неће бити неуспешна осим ако је +ограничење врло мало. Смањење поставке се ради у корацима који се не +подударају са предподешеностима нивоа запакивања, на пример, ако је +ограничење само незнатно мање од износа потребног за \fBxz \-9\fP, поставке ће +бити смањене само мало, а не све до \fBxz \-8\fP. +. +.SS "Надовезивање и попуњавање са „.xz“ датотекама" +Могуће је додати \fB.xz\fP датотеке као то. \fBxz\fP ће распаковати такве +датотеке као да су биле једна \fB.xz\fP датотека. +.PP +Могуће је уметнути попуњавање између придодатих делова или након последњег +дела. Попуњавање мора да се састоји од празних бајтова а величина +попуњавања мора бити умножак четири бајта. Ово може бити корисно, на +пример, ако је \fB.xz\fP датотека смештена на медијуму који мери величине +датотека у блоковима од 512 бајтова. +.PP +Надовезивање и попуњавање нису дозвољени са \fB.lzma\fP датотекама или сировим +токовима. +. +.SH ОПЦИЈЕ +. +.SS "Суфикси целог броја и специјалне вредности" +На већини места где се очекује аргумент целог броја, опционални суфикс је +подржан да би се лако назначили велики цели бројеви. Не сме бити размака +између целог броја и суфикса. +.TP +\fBKiB\fP +Множи цео број са 1.024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP, и \fBKB\fP се +прихватају као синоними за \fBKiB\fP. +.TP +\fBMiB\fP +Множи цео број са 1.048.576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP, и \fBMB\fP се +прихватају као синоними за \fBMiB\fP. +.TP +\fBGiB\fP +Множи цео број са 1.073.741.824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP, и \fBGB\fP се +прихватају као синоними за \fBGiB\fP. +.PP +Посебна вредност \fBmax\fP се може користити да укаже на највећу вредност целог +броја подржану опцијом. +. +.SS "Режим рада" +Ако је дато више опција режима рада, последња има дејства. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Запакује. Ово је основни режим радње када није наведена опција режима радње +и ниједан други режим радње се не подразумева са линије радње (на пример, +\fBunxz\fP подразумева \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Након успешног запакивања, изворна датотека се уклања осим ако се не пише на +стандардни излаз или је наведено \fB\-\-keep\fP. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Распакује. Након успешног распакивања, изворна датотека се уклања осим ако +се не пише на стандардни излаз или је наведено \fB\-\-keep\fP. +.TP +\fB\-t\fP, \fB\-\-test\fP +Тестира целовитост запакованих \fIдатотека\fP. Ова опција је исто што и +\fB\-\-decompress \-\-stdout\fP осим тога што се распаковани подаци одбацују уместо +да се пишу на стандардни излаз. Датотеке се не праве нити уклањају. +.TP +\fB\-l\fP, \fB\-\-list\fP +Исписује информације о запакованим \fIдатотекама\fP. Никакав незапакован излаз +се не добија, а ниједна датотека није направљена или уклоњена. У режиму +списка, програм не може читати запаковане податке са стандардног улаза или +из других нетраживих извора. +.IP "" +Основни списак приказује основне информације о \fIдатотекама\fP, једна датотека +у једном реду. Да добијете подробније информације, користите такође опцију +\fB\-\-verbose\fP. За чак и више информација, користите \fB\-\-verbose\fP два пуа, +али знајте да то може бити споро, јер да би се добиле све додатне +информације потребно је много тражења. Ширина опширног излаза премашује 80 +знакова, тако да преспајање излаза на, на пример, \fBless\ \-S\fP може бити +прикладно ако терминал није довољно широк. +.IP "" +Тачан излаз може варирати између \fBxz\fP издања и различитих језика. За излаз +читљив машинама треба да користите \fB\-\-robot \-\-list\fP. +. +.SS "Измењивачи рада" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Не брише улазне датотеке. +.IP "" +Од \fBxz\fP 5.2.6, ова опција такође чини да \fBxz\fP запакује или распакује чак и +ако је улаз симболичка веза ка обичној датотеци, има више од једне чврсте +везе или има постављен „setuid“, „setgid“ или лепљиви бит. „setuid“, +„setgid“ и лепљиви битови се не умножавају у циљну датотеку. У ранијим +издањима ово се могло урадити само са \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Ова опција има неколико дејстава: +.RS +.IP \(bu 3 +Ако циљна датотека већ постоји, брише је пре запакивања или распакивања. +.IP \(bu 3 +Запакује или распакује чак и ако је улаз симболичка веза ка обичној +датотеци, има више од једне чврсте везе или има постављен „setgid“, „setgid“ +или лепљиви бит. „setgid“, „setgid“ или лепљиви бит се не умножавају у +циљну датотеку. +.IP \(bu 3 +Када се користи са \fB\-\-decompress\fP \fB\-\-stdout\fP и \fBxz\fP не може да препозна +врсту изворне датотеке, умножава изворну датотеку као такву на стандардни +излаз. Ово омогућава да се \fBxzcat\fP \fB\-\-force\fP користи као \fBcat\fP(1) за +датотекекоје нису запаковане са \fBxz\fP. Знајте да ће у будућности, \fBxz\fP +моћи да подржава нове формате запаковане датотеке, који могу учинити да +\fBxz\fP распакује још врста датотека уместо да их умножи какве јесу на +стандардни излаз. \fB\-\-format=\fP\fIформат\fP се може користити да ограничи \fBxz\fP +да распакује само формат једне датотеке. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Пише запаковане или распаковане податке на стандардни излаз уместо у +датотеку, Ово подразумева \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Распакује само први \fB.xz\fP ток, и тихо занемарује могуће преостале улазне +податке који следе ток. Нормално такво пратеће смеће чини да \fBxz\fP прикаже +грешку. +.IP "" +\fBxz\fP никада не распакује више од једног тока из \fB.lzma\fP датотека или +сирових токова, али ова опција чини да \fBxz\fP још увек занемари могуће +пратеће податке након \fB.lzma\fP датотеке или сировог тока. +.IP "" +Ова опција нема дејства ако режим рада није \fB\-\-decompress\fP или \fB\-\-test\fP. +.IP "" +Од \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP подразумева \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Искључује стварање развучених датотека. По основи, ако распакује у обичну +датотеку, \fBxz\fP покушава да учини датотеку развученом ако распаковани подаци +садрже дуге низове бинарних нула. Такође ради приликом писања на стандардни +излаз све док је стандардни излаз повезан са обичном датотеком а одређени +додатни услови су испуњени да је учине безбедном. Стварање развучених +датотека може уштедети простор на диску и убрзати распакивање смањењем +количине У/И диска. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Приликом запакивања, користите \fI.suf\fP као суфикс за циљну датотеку уместо +\&\fB.xz\fP или \fB.lzma\fP. Ако се не пише на стандардни излаз а изворна датотека +већ има суфикс \fI.suf\fP, приказује се упозорење и датотека се прескаче. +.IP "" +Приликом распакивања, препознаје датотеке са суфиксом \fI.suf\fP поред датотека +са суфиксом \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, or \fB.lz\fP. Ако изворна +датотека има суфикс \fI.suf\fP, суфикс се уклања да би се добио назив циљне +датотеке. +.IP "" +Приликом запакивања или распакивања сирових токова (\fB\-\-format=raw\fP), суфикс +мора увек бити наведен осим ако се не пише на стандардни излаз, јер не +постоји основни суфикс за сирове токове. +.TP +\fB\-\-files\fP[\fB=\fP\fIдатотека\fP] +Чита називе датотека за обраду из \fIдатотеке\fP; ако се \fIдатотека\fP изостави, +називи датотека се читају са стандардног улаза. Називи датотека се морају +завршавати знаком новог реда. Цртица (\fB\-\fP) се узима као редован назив +датотеке; а не стандардни улаз. Ако су називи датотека дати такође као +аргументи линије наредби, обрађују се пре него што се називи датотека +прочитају из \fIдатотеке\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIдатотека\fP] +Ово је исто као и \fB\-\-files\fP[\fB=\fP\fIдатотека\fP] изузев тога што сваки назив +датотеке мора да се завршава „null“ знаком. +. +.SS "Основни формат датотеке и опције запакивања" +.TP +\fB\-F\fP \fIформат\fP, \fB\-\-format=\fP\fIформат\fP +Наводи \fIформат\fP датотеке за запакивање или распакивање: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Ово је основно. Приликом запакивања, \fBauto\fP је исто што и \fBxz\fP. Приликом +распакивања, формат улазне датотеке се аутоматски препознаје. Знајте да +сирови токови (направљени са \fB\-\-format=raw\fP) не могу бити аутоматски +препознати. +.TP +\fBxz\fP +Пакује у \fB.xz\fP формат датотеке, или прихвата само \fB.xz\fP датотеке приликом +распакивања. +.TP +\fBlzma\fP, \fBalone\fP +Пакује у стари \fB.lzma\fP формат датотеке, или прихвата само \fB.lzma\fP датотеке +приликом распакивања. Алтернативни назив \fBalone\fP се доставља зарад +повратне сагласности са LZMA помагалима. +.TP +\fBlzip\fP +Прихвата само \fB.lz\fP датотеке приликом распакивања. Запакивање није +подржано. +.IP "" +Формат \fB.lz\fP издања 0 и 1 је подржан. Датотеке издања 0 су настале са +\fBlzip\fP 1.3 и старијим. Такве датотеке нису уобичајене али се могу наћи у +архивама датотека јер је неколико пакета извора издато у овом формату. +Такође можда неко има старе личне датотеке у овом формату. Подршка +распакивања за формат издања 0 је уклоњена у \fBlzip\fP 1.18. \fBlzip\fP 1.4 и +новији ствара датотеке у формату издања 1. +.TP +\fBraw\fP +Запакује или распакује сирови ток (без заглавља). Ово је замишљено само за +напредне кориснике. Да дешифрујете сирове токове, треба да користите +\fB\-\-format=raw\fP и да изричито наведете ланац филтера, што би обично требало +да буде смештено у заглављима контејнера. +.RE +.TP +\fB\-C\fP \fIпровера\fP, \fB\-\-check=\fP\fIпровера\fP +Наводи врсту провере целовитости. Провера се израчунава из незапакованих +података и смештених у \fB.xz\fP датотеци. Ова опција има дејства само +приликом запакивања у \fB.xz\fP формат; \fB.lzma\fP формат не подржава провере +целовитости. Провера целовитости (ако је има) се проверава када је \fB.xz\fP +датотека распакована. +.IP "" +Подржане врсте \fIпровере\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Уопште не израчунава проверу целовитости. Ово је обично лоша идеја. Ово +може бити корисно када се целовитост података ипак проверава на друге +начине. +.TP +\fBcrc32\fP +Израчунава CRC32 користећи полином из IEEE\-802.3 (Етернет). +.TP +\fBcrc64\fP +Израчунава CRC64 користећи полином из ECMA\-182. Ово је основно, јер је +незнатно боље од CRC32 у откривању оштећених датотека а разлика брзине је +занемарљива. +.TP +\fBsha256\fP +Израчунава SHA\-256. Ово је нешто спорије од CRC32 и CRC64. +.RE +.IP "" +Целовитост \fB.xz\fP заглавља се увек проверава са CRC32. Не може се изменити +нити искључити. +.TP +\fB\-\-ignore\-check\fP +Не проверава проверу целовитости запакованих података приликом распакивања. +CRC32 вредности у \fB.xz\fP заглављима биће још увек нормално проверене. +.IP "" +\fBНемојте користити ову опцију осим ако стварно знате шта радите.\fP Могући +разлози за коришћење ове опције: +.RS +.IP \(bu 3 +Покушава да опорави податке из оштећене „.xz“ датотеке. +.IP \(bu 3 +Убрзава распакивање. Ово има значаја углавном са SHA\-256 или са датотекама +које су запаковане стварно добро. Препоручује се да не користите ову опцију +за ову сврху осим ако је целовитост датотеке проверена споља на неки други +начин. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Бира ниво преподешености запакивања. Подразумевано је \fB\-6\fP. Ако је +наведено више нивоа преподешености, последња има дејства. Ако је произвољни +ланац филтера већ наведен, постављање нивоа преподешености запакивања уклања +произвољни ланац филтера. +.IP "" +Разлике између предподешености су још значајније него са \fBgzip\fP(1) и +\fBbzip2\fP(1). Изабране поставке запакивања одређују захтеве меморије +распакивача, стога коришћење превисоког нивоа предподешености може отежати +распакивање датотеле на старом систему са мало RAM\-а. Нарочито, \fBније добра замисао слепо користити \-9 за било шта\fP као што је често са \fBgzip\fP(1) +и \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Ово су некако брзе предподешености. \fB\-0\fP је понекад брже од \fBgzip \-9\fP док +запакује много боље. Оне више често имају брзину упоредиву са \fBbzip2\fP(1) +са упоредивом или бољом стопом запакивања, иако резултати зависе много од +врсте података који се запакују. +.TP +\fB\-4\fP ... \fB\-6\fP +Добро до врло добро запакивање које одржава коришћење меморије распакивача +разумним чак и за старе системе. \fB\-6\fP је основно, што је обично добар +избор за расподелу датотека које треба да могу да се распакују чак и на +системима са само 16\ MiB RAM\-а. (\fB\-5e\fP или \fB\-6e\fP може бити вредно +узимања у обзир. Видите \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Као \fB\-6\fP али са већим захтевима меморије запакивача и распакивача. Корисне +су само приликом запакивања датотека већих од 8\ MiB, 16\ MiB и 32\ MiB. +.RE +.IP "" +На истом хардверу, брзина распакивања је приближно сталан број бајтова +запакованих података у секунди. Другим речима, биће боље запакивање, брже +распакивање. То такође значи да количина незапакованог излаза произведеног +у секунди може много да се разликује. +.IP "" +Следећа табела резимира функције предподешености: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Преподешеност;ВлчРчнка;ЗапакЦПЈ;ЗапакМем;РаспМем +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Описи колона: +.RS +.IP \(bu 3 +ВлчРчнка је величина LZMA2 речника. Коришћење речника већег од величине +незапаковане датотеке је губитак меморије. Зато је добро избегавати +коришћење предподешености \fB\-7\fP ... \fB\-9\fP када за њима нема стварне +потребе. Са \fB\-6\fP и нижим, количина изгубљене меморије је обично довољно +ниска да нема значаја. +.IP \(bu 3 +ЗапакЦПЈ је поједностављено представљање LZMA2 поставки које утичу на брзину +запакивања. Величина речника такође утиче на брзину, тако док је ЗапакЦПЈ +исто за нивое \fB\-6\fP ... \fB\-9\fP, виши нивои још увек теже да буду спорији. Да +добијете још спорије и самим тим можда боље запакивање, видите \fB\-\-extreme\fP. +.IP \(bu 3 +ЗапакМем садржи захтеве меморије запакивача у режиму једне нити. Може +незнатно да се разликује између \fBxz\fP издања. +.IP \(bu 3 +РаспМем садржи захтеве меморије распакивача. Тако је, поставке запакивања +одређују захтеве меморије распакивача. Тачно коришћење меморије распакивача +је незнатно веће од величине LZMA2 речника, али су вредности у табели +заокружене на следећи цео MiB. +.RE +.IP "" +Захтеви меморије режима са више нити су значајно већи него ли режима једне +нити. Са основном вредношћу \fB\-\-block\-size\fP, свакој нити треба 3*3*ВлчРчнка +плус ЗапакМем или РаспМем. На пример, за четири нити са предподешавањем +\fB\-6\fP потребно је 660\(en670\ MiB меморије. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Користите спорију варијанту изабраног нивоа предподешености запакивања +(\fB\-0\fP ... \fB\-9\fP) у нади да ћете добити мало бољу стопу запакивања, али уз +лошу срећу ово је може учинити гором. Не утиче на коришћење меморије +распакивача, али се коришћење меморије запакивача мало повећава на нивоима +предподешености \fB\-0\fP ... \fB\-3\fP. +.IP "" +Како постоје две предподешености са величинама речника од 4\ MiB и 8\ MiB, +предподешености \fB\-3e\fP и \fB\-5e\fP користе незнатно брже поставке (ниже +CompCPU) него \fB\-4e\fP и \fB\-6e\fP. На тај начин нема две истоветне +предподешености. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Преподешеност;ВлчРчнка;ЗапакЦПЈ;ЗапакМем;РаспМем +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +На пример, има укупно четири предподешавања која користе 8\ MiB речник, чији +поредак од најбржег до најспоријег је \fB\-5\fP, \fB\-6\fP, \fB\-5e\fP и \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Ово су помало погрешни алијаси за \fB\-0\fP и \fB\-9\fP. Достављени су само зарад +повратне сагласности са LZMA Utils\-ом. Избегавајте коришћење ових опција. +.TP +\fB\-\-block\-size=\fP\fIвеличина\fP +Приликом запакивања у \fB.xz\fP формат, дели улазне податке на блокове +\fIвеличина\fP бајта. Блокови се запакују независно један од другог, што +помаже у раду са више нити и чини ограничено распакивање насумичног приступа +могућим. Ова опција се обично користи да се препише основна величина блока +у режиму са више нити, али се ова опција може такође користити и у режиму +једне нити. +.IP "" +У режиму више нити око три пута \fIвеличина\fP бајтова биће додељено у свакој +нити за међумеморисање улаза и излаза. Основна \fIвеличина\fP је три пута +величине LZMA2 речника или 1 MiB, шта год да је више. Обично добра вредност +је 2\(en4 пута величина LZMA2 речника или барем 1 MiB. Коришћење +\fIвеличине\fP мање од величине LZMA2 речника је трошење RAM\-а јер тада +међумеморија LZMA2 речника никада неће бити потпуно коришћена. У режиму +више нити, величине блокова се чувају у заглављима блока. Ова информација +величине је потребна за распакивање са више нити. +.IP "" +У режиму једне нити никаква подела блока се не ради по основи. Постављање +ове опције не утиче на коришћење меморије. Никакве информације о величини +се не чувају у заглављима блока, стога датотеке направљене у режиму једне +нити неће бити исте као датотеке направљене у режиму више нити. Недостатак +информација о величини такође значи да \fBxz\fP неће моћи да распакује датотеке +у режиму више нити. +.TP +\fB\-\-block\-list=\fP\fIставке\fP +Приликом запакивања у \fB.xz\fP формат, почиње нови блок са изборним +произвољним ланцем филтера након датих интервала незапакованих података. +.IP "" +\fIСтавке\fP су списак одвојен зарезом. Свака ставка се састоји од изборног +броја ланца филтера између 0 и 9 за којим следи двотачка (\fB:\fP) и захтевана +величина незапакованих података . Изостављање неке ставке (два или више +узастопна зареза) је пречица за коришћење величине и филтера претходне +ставке. +.IP "" +Ако је улазна датотека већа од збира величина у \fIставкама\fP, последња ставка +се понавља све до краја датотеке. Специјална вредност \fB0\fP може се +користити као последња величина да назначи да остатак датотеке треба да буде +шифрован као један блок. +.IP "" +Алтернативни ланац филтера за сваки блок се може навести у комбинацији са +опцијама \fB\-\-filters1=\fP\fIфилтера\fP \&...\& \fB\-\-filters9=\fP\fIфилтери\fP. Ове +опције дефинишу ланце филтера са одредником између 1\(en9. Ланац филтера 0 +се може користити да упућује на основно ланац филтера, који је исти јер се +ланац филтера не наводи. Одредник ланца филтера се може користити пре +незапаковане величине, за којим следи двотачка (\fB:\fP). На пример, ако +наведемо \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP тада ће се за +прављење блокова користити: +.RS +.IP \(bu 3 +Ланац филтера наведен са \fB\-\-filters1\fP и 2 MiB улазом +.IP \(bu 3 +Ланац филтера наведен са \fB\-\-filters3\fP и 2 MiB улазом +.IP \(bu 3 +Ланац филтера наведен са \fB\-\-filters2\fP и 4 MiB улазом +.IP \(bu 3 +Ланац филтера наведен са \fB\-\-filters2\fP и 4 MiB улазом +.IP \(bu 3 +Основни ланац филтера и 2 MiB улаз +.IP \(bu 3 +Основни ланац филтера и 4 MiB улаз за сваки блок до краја улаза. +.RE +.IP "" +Ако наведемо величину која премашује величину блока шифрера (било основну +вредност у режиму нити или вредност наведену са +\fB\-\-block\-size=\fP\fIвеличина\fP), шифрер ће направити додатне блокове док ће +задржати границе наведене у \fIставкама\fP. На пример, ако наведемо +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP а улазна +датотека је 80 MiB, добићемо 11 блокова: 5, 10, 8, 10, 2, 10, 10, 4, 10, 10 +и 1 MiB. +.IP "" +У режиму са више нити величине блокова се чувају у заглављима блока. Ово се +не ради у режиму једне нити, тако да шифровани излаз неће бити истоветан +ономе у режиму са више нити. +.TP +\fB\-\-flush\-timeout=\fP\fIистек_времена\fP +Приликом запакивања, ако је више од \fIвреме_истека\fP милисекунди (позитиван +цео број) прошло од претходног испирања и читање више улаза ће блокирати, +сви заказани улазни подаци се испирају из шифрера и чине доступним у +излазном току. Ово може бити корисно ако је \fBxz\fP коришћен за запакивање +података који су слати преко мреже. Мала вредност \fIвременског_истека\fP чини +податке доступним на пријемни крај са малим закашњењем, али велика вредност +\fIвремена_истека\fP даје бољу стопу запакивања. +.IP "" +Ова функција је искључена по основи. Ако је ова опција наведена више пута, +последња има дејства. Нарочита вредност \fIвременског истека\fP \fB0\fP може се +користити за изричито искључивање ове функције. +.IP "" +Ова функција је доступна само на POSIX системима. +.IP "" +.\" FIXME +\fBОва функција је још увек експериментална.\fP Тренутно \fBxz\fP није погодан за +распакивање тока у реалном времену због начина на који \fBxz\fP ради +међумеморисање. +.TP +\fB\-\-no\-sync\fP +Не усклађује циљну датотеку и њену фасциклу на смештајном уређају пре +уклањања изворне датотеке. Ово може побољшати учинковитост ако се запакује +или распакује много малих датотека. Међутим, ако се систем уруши одмах +након брисања, може бити да циљна датотека не буде уписана на смештајном +уређају али радња брисања јесте. У том случају неће бити доступна ни +оригинална изворна ни циљна датотека. +.IP "" +Ова опција има дејство само када се \fBxz\fP спрема да уклони изворну +датотеку. У осталим случајевима усклађивање се не ради никада. +.IP "" +Синхронизација и \fB\-\-no\-sync\fP су додате у \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIограничење\fP +Поставља ограничење коришћења меморије запакивања. Ако је ова опција +наведена више пута, последња ступа у дејство. +.IP "" +Ако поставке запакивања премаше \fIограничење\fP, \fBxz\fP ће покушати да врати +назад поставке тако да ограничење више није прекорачено и приказаће +обавештење да је урађено аутоматско дотеривање. Дотеривања се раде следећим +редом: смањење броја нити, пребацивање на режим једне нити ако чак и једна +нит у режиму више нити премаши \fIограничење\fP и на крају смањење величине +LZMA2 речника. +.IP "" +Приликом запакивања са \fB\-\-format=raw\fP или ако је наведено \fB\-\-no\-adjust\fP, +само број нити може бити умањен јер може да се уради а да се не делује на +излаз запакованог. +.IP "" +Ако \fIограничење\fP не може бити задовољено чак и са поравнањима описаним +изнад, приказује се грешка и \fBxz\fP ће изаћи са излазним стањем 1. +.IP "" +\fIОграничење\fP се може навести на више начина: +.RS +.IP \(bu 3 +\fIОграничење\fP може бити апсолутна величина у бајтима. Коришћење суфикса +целог броја као \fBMiB\fP може бити корисно. Пример: +\fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +\fIОграничење\fP се може навести као проценат укупне физичке меморије (RAM). +Ово може бити корисно нарочито приликом постављања променљиве окружења +\fBXZ_DEFAULTS\fP у скрпти покретања конзоле која се дели између различитих +рачунара. На тај начин ограничење је аутоматски веће на системима са више +меморије. Пример: \fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +\fIОграничење\fP се може вратити на своју основну вредност његовим постављањем +на \fB0\fP. Ово је тренутно исто што и постављање \fIограничења\fP на \fBmax\fP (без +ограничења коришћења меморије). +.RE +.IP "" +За \fBxz\fP 32\-бита имамо посебан случај: ако \fIограничење\fP треба да буде преко +\fB4020\ MiB\fP, \fIограничење\fP се поставља на \fB4020\ MiB\fP. Али на MIPS32 +користи се \fB2000\ MiB\fP. (На вредности \fB0\fP и \fBmax\fP ово не утиче. Слична +функција не постоји за распакивање.) Ово може бити од помоћи када извршна +од 32\-бита има приступ адресном простору од 4\ GiB (2 GiB на MIPS32) док +срећом не чини ништа лоше у осталим приликама. +.IP "" +Видите такође одељак \fBКоришћење меморије\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIограничење\fP +Поставља ограничење коришћења меморије за распакивање. Ово такође утиче на +\fB\-\-list\fP режим. Ако радња није могућа а да се не премаши \fIограничење\fP, +\fBxz\fP ће приказати грешку а распакивање датотеке неће успети. Видите +\fB\-\-memlimit\-compress=\fP\fIограничење\fP за могуће начине о навођењу +\fIограничења\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIограничење\fP +Поставља ограничење коришћења меморије за распакивање са више нити. Ово +може утицати само на број нити; ово никада неће учинити да \fBxz\fP одбије да +распакује датотеке. Ако је \fIограничење\fP превише ниско да омогући било који +рад са више нити, \fIограничење\fP се занемарује а \fBxz\fP ће наставити у режиму +једне нити. Знајте да ако се такође користи \fB\-\-memlimit\-decompress\fP, увек +ће се применити и на режим једне и на режим више нити, и тако да стварно +\fIограничење\fP за више нити никада неће бити више од ограничења постављеног +са \fB\-\-memlimit\-decompress\fP. +.IP "" +У супротности са другим опцијама ограничења коришћења меморије, +\fB\-\-memlimit\-mt\-decompress=\fP\fIограничење\fP има систему специфично основно +\fIограничење\fP. \fBxz \-\-info\-memory\fP се може користити да видите тренутну +вредност. +.IP "" +Ова опција и њена основна вредност постоје јер без икаквог ограничења нитни +распакивач ће завршити са додељивањем неразумног износа меморије са неким +улазним датотекама. Ако је основно \fIограничење\fP превише ниско на вашем +систему, слободно повећајте \fIограничење\fP али га никада не постављајте на +вредност већу од износа употребљивог RAM\-а јер са одговарајућим улазним +датотекама \fBxz\fP ће покушати да користи тај износ меморије чак и са малим +бројем нити. Остајући без меморије или разменом неће се побољшати +учинковитост распакивања. +.IP "" +Видите \fB\-\-memlimit\-compress=\fP\fIограничење\fP за могуће начине за навођење +\fIограничења\fP. Постављање \fIограничења\fP на \fB0\fP враћа \fIограничење\fP на +систему специфичну основну вредност. +.TP +\fB\-M\fP \fIограничење\fP, \fB\-\-memlimit=\fP\fIограничење\fP, \fB\-\-memory=\fP\fIограничење\fP +Ово је исто као и навођење \fB\-\-memlimit\-compress=\fP\fIограничење\fP +\fB\-\-memlimit\-decompress=\fP\fIограничење\fP +\fB\-\-memlimit\-mt\-decompress=\fP\fIограничење\fP. +.TP +\fB\-\-no\-adjust\fP +Приказује грешку и излази ако ограничење коришћења меморије не може бити +задовољено без дотеривања поставки које утичу на запаковани излаз. Тако је, +ово спречава \fBxz\fP да промени шифрера из режима више нити у режим једне нити +и да смањи величину LZMA2 речника. Чак и када се ова опција користи број +нити се може смањити да задовољи ограничење коришћења меморије јер то неће +утицати на запаковани излаз. +.IP "" +Аутоматско дотеривање је увек искључено приликом стварања сирових токова +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fIнити\fP, \fB\-\-threads=\fP\fIнити\fP +Наводи број нити радника за коришћење. Постављање \fIнити\fP на посебну +вредност \fB0\fP чини да \fBxz\fP користи онолико нити колико процесор на систему +подржава. Стварни број нити може бити мањи од \fIнити\fP ако улазна датотека +није довољно велика за нитисање са датим поставкама или ако ће коришћење +више нити премашити ограничење коришћења меморије. +.IP "" +Запакивачи једне нити и више нити дају различите излазе. запакивач једне +нити даће мању величину датотеке али само излаз из запакивача више нити може +бити распакован коришћењем више нити. Постављање \fIнити\fP на \fB1\fP користиће +режим једне нити. Постављање \fIнити\fP на неку другу вредност, укључујући +\fB0\fP, користиће запакивач више нити чак и ако систем подржава само једну нит +хардвера. (\fBxz\fP 5.2.x је користио режим једне нити у овој прилици.) +.IP "" +Да користите вишенитни режим са само једном нити, поставите \fIнити\fP на +\fB+1\fP. Префикс \fB+\fP нема дејства са вредностима које нису \fB1\fP. Ограничење +коришћења меморије може још увек учинити да се \fBxz\fP пребаци на режим једне +нити осим ако се не користи \fB\-\-no\-adjust\fP. Подршка за префикс \fB+\fP је +додата у \fBxz\fP 5.4.0. +.IP "" +Ако је затражен аутоматски број нити и није наведено ограничење коришћења +меморије, тада ће се користити основно меко ограничење специфично за систем +за могуће ограничење броја нити. То је меко ограничење у смислу да се +занемарује ако број нити постане један, дакле меко ограничење никада неће +зауставити \fBxz\fP од запакивања или распакивања. Ово основно меко ограничење +неће учинити да се \fBxz\fP пребаци из режима више нити у режим једне нити. +Активно ограничење се може видети са + \fBxz \-\-info\-memory\fP. +.IP "" +Тренутно једина метода нитисања је да се подели улаз на блокове и да се +запакују независно један од другог. Основна величина блока зависи од нивоа +запакивања и може се преписати опцијом \fB\-\-block\-size=\fP\fIвеличина\fP. +.IP "" +Нитно распакивање ради само на датотекама које садрже више блокова са +информацијом величине у заглављима блока. Све довољно велике датотеке +запаковане у вишенитном режиму задовољавају овај услов, али датотеке +запаковане у једнонитном режиму не чак и ако је коришћено +\fB\-\-block\-size=\fP\fIвеличина\fP. +.IP "" +Основна вредност за \fIнити\fP је \fB0\fP. У \fBxz\fP 5.4.x и старијим основно је +\fB1\fP. +. +.SS "Произвољни ланци филтера запакивача" +Произвољни ланац филтера омогућава детаљно одређивање подешавања сажимања +уместо да се ослања на подешавања повезана са предподешавањима. Када је +произвољни ланац филтера наведен, опције предподешавања (\fB\-0\fP \&...\& \fB\-9\fP +и \fB\-extreme\fP) раније на линији наредби се заборављају. Ако је опција +предподешавања наведена након једне или више опција произвољног ланца +филтера, ново предподешавање ступа на снагу а раније наведене опције +произвољног ланца филтера се заборављају. +.PP +Ланац филтера је упоредив са спојкама на линији наредби. Приликом сажимања, +несажети улаз иде на први филтер, чији излаз иде на следећи филтер (ако фа +има). Излаз последњег филтера бива записан у сажету датотеку. Највећи број +филтера у ланцу је четири, али обично ланац филтера има само један или два +филтера. +.PP +Многи филтери имају ограничења о томе где могу бити у ланцу филтера: неки +филтери могу радити само као последњи филтер у ланцу, неки само као +не\-последњи филтер, а неки раде на било ком месту у ланцу. Овисно о +филтеру, ово ограничење је или својствено дизајну филтера или постоји како +би се спречили проблеми безбедности. +.PP +Произвољни ланац филтера се може навести на два различита начина. Опције +\fB\-\-filters=\fP\fIфилтери\fP и \fB\-\-filters1=\fP\fIфилтери\fP \&...\& +\fB\-\-filters9=\fP\fIфилтери\fP омогућавају навођење читавог ланца опција у једној +опцији коришћењем синтаксу ниске „liblzma“ филтера. Другачије, ланац +филтера се може навести коришћењем једне или више појединачних опција +филтера редом како се траже у ланцу филтера. То је то, редослед +појединачних опција филтера је важан! Приликом дешифровања сирових токова +(\fB\-\-format=raw\fP), ланац филтера мора бити наведен истим редом као када је +био наведен приликом сажимања. Било који појединачни филтер или опције +предподешавања наведене пре опције читавог ланца (\fB\-\-filters=\fP\fIфилтери\fP) +биће заборављене. Појединачни филтери наведени после опције читавог ланца +ће поништити поставку ланца филтера. +.PP +Обе опције и пуног и појединачног филтера узимају филтеру специфичне +\fIопције\fP као зарезом раздвојен списак. Додатни зарези у \fIопцијама\fP се +занемарују. Свака опција има основну вредност, тако да треба да наведете +оне које желите да измените. +.PP +Да видите читав ланац филтера и \fIопције\fP, користите \fBxz \-vv\fP (тако је, +користите \fB\-\-verbose\fP два пута). Ово ради такође за преглед опција ланца +филтера коришћених од стране предподешености. +.TP +\fB\-\-filters=\fP\fIфилтери\fP +Наводи цео ланац филтера или предподешеност у једној опцији. Сваки филтер +се може одвојити размацима или са две цртице (\fB\-\-\fP). \fIФилтери\fP можда +треба да буду под наводницима на линији наредби конзоле тако да се +прослеђују као једна опција. Да означите \fIопције\fP, користите \fB:\fP или +\fB=\fP. Предподешености се може додати префикс \fB\-\fP и може га пратити нула +или још заставица. Једина подржана заставица је \fBe\fP за примену истих +опција као \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIфилтери\fP ... \fB\-\-filters9\fP=\fIфилтери\fP +Наводи до девет додатних ланаца филтера који се могу користити са +\fB\-\-block\-list\fP. +.IP "" +На пример, приликом запакивања архиве са извршним датотекама за којима следе +текстуалне датотеке, извршни део треба да користи ланац филтера са BCJ +филтером а текстуални део само LZMA2 филтер. +.TP +\fB\-\-filters\-help\fP +Приказује поруку помоћи описујући како се наводе предподешавања и произвољни +ланци филтера у опцијама \fB\-\-filters\fP и \fB\-\-filters1=\fP\fIфилтери\fP \&...\& +\fB\-\-filters9=\fP\fIфилтери\fP, и успешно излази. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIопције\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIопције\fP] +.PD +Додаје LZMA1 или LZMA2 филтер у ланац филтера. Ови филтери се могу +користити само као последњи филтер у ланцу. +.IP "" +LZMA1 је стари филтер, који је подржан углавном само због старог формата +\&\fB.lzma\fP датотеке, који подржава само LZMA1. LZMA2 је освежено издање LZMA1 +које поправља неке практичне проблеме LZMA1. \fB.xz\fP формат користи LZMA2 и +не подржава LZMA1 уопште. Брзина запакивања и односи LZMA1 и LZMA2 су +практично исти. +.IP "" +LZMA1 и LZMA2 деле исти скуп \fIопција\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIпредподешавање\fP +Враћа све LZMA1 или LZMA2 \fIопције\fP на \fIпредподешеност\fP. \fIПредпдешеност\fP +се састоји од целог броја, за којим може да следи једнословни измењивач +предподешености. Цео број може бити од \fB0\fP до \fB9\fP, поклапајући опције +линије наредби \fB\-0\fP \&...\& \fB\-9\fP. Једини тренутно подржани измењивач је +\fBe\fP, који се поклапа са \fB\-\-extreme\fP. Ако \fBpreset\fP није наведено, основне +вредности LZMA1 или LZMA2 \fIопција\fP се узимају из предподешености \fB6\fP. +.TP +\fBdict=\fP\fIвеличина\fP +\fIВеличина\fP речника (међумеморија историјата) указује на то колико је +бајтова недавно обрађених нераспакованих података задржано у меморији. +Алгоритам покушава да нађе понављајуће низове бајтова (поклапања) у +нераспакованим подацима, и да их замени са упутама ка подацима који су +тренутно у речнику. Што је већи речник, већа је вероватноћа за налажење +поклапања. Стога, повећање \fIвеличине \fP речника обично побољшава стопу +запакивања, али речник већи од незапаковане датотеке јесте утрошак меморије. +.IP "" +Уобичајена \fIвеличина\fP речника је од 64\ KiB до 64\ MiB. Најмање је 4\ KiB. Највише за запакивање тренутно је 1.5\ GiB (1536\ MiB). Распакивач +већ подржава речнике до једног бајта мање од 4\ GiB, што је максимум за +формате LZMA1 и LZMA2 тока. +.IP "" +\fIВеличина\fP речника и налазач поклапања (\fImf\fP) заједно одређују коришћење +меморије за LZMA1 или LZMA2 шифрере. Иста (или већа) \fIвеличина\fP речника је +потребна за распакивање као она која је коришћена за запаквање, стога се +коришћење меморије дешифрера одређује према величини речника коришћеног за +запакивање. \fB.xz\fP заглавља чувају \fIвеличину\fP речника или као 2^\fIn\fP или +2^\fIn\fP + 2^(\fIn\fP\-1), тако да су те \fIвеличине\fP некако пожељније за +запакивање. Друге \fIвеличине\fP биће заокружене приликом чувања у \fB.xz\fP +заглављима. +.TP +\fBlc=\fP\fIlc\fP +Наводи број битова контекста литерала. Најмање је 0 а највише је 4; основно +је 3. Као додатак, збир \fIlc\fP и \fIlp\fP не сме да премаши 4. +.IP "" +Сви бајтови који се не могу шифровати јер су поклапања шифрована као +литерали. То је то, литерали су једноставно 8\-битни бајтови који су +шифровани један по један. +.IP "" +Кодирање литерала врши претпоставку да највећи \fIlc\fP битови претходног +незапакованог бајта су у узајамној вези са следећим бајтом. На пример, у +уобичајеном енглеском тексту, за великим словом често следи мало слово, а за +малим словом обично следи још једно мало слово. У скупу US\-ASCII знакова, +највиша три бита су 010 за велика слова и 011 за мала слова. Када је \fIlc\fP +барем 3, кодирање литерала може имати предност овог својства у незапакованим +подацима. +.IP "" +Основна вредност (3) је обично добра. Ако желите највеће запакивање, +испробајте \fBlc=4\fP. Некад то мало помогне а некад чини запакивање горим. +Ако га учини горим, испробајте такође \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Наводи број битова положаја литерала. Најмање је 0 а највише је 4; основно +је 0. +.IP "" +\fILp\fP утиче на то која врста поравнања у незапакованим подацима се +подразумева приликом шифровања литерала. Видите \fIpb\fP испод за више +информација о поравнању. +.TP +\fBpb=\fP\fIpb\fP +Наводи број битова положаја. Најмање је 0 а највише је 4; основно је 2. +.IP "" +\fIPb\fP утиче на то која врста поравнања у незапакованим подацима се +подразумева у опште. Основно значи четворобајтно поравнање (2^\fIpb\fP=2^2=4), +што је често добар избор када нема бољег решења. +.IP "" +Када је поравнање познато, постављање одговарајућег \fIpb\fP може мало да смањи +величину датотеке. На пример, са датотекама текста које имају поравнање +једног бајта (US\-ASCII, ISO\-8859\-*, UTF\-8), постављање \fBpb=0\fP може незнатно +да побољша запакивање. За UTF\-16 текст, \fBpb=1\fP је добар избор. Ако је +поравнање непаран број као 3 бајта, \fBpb=0\fP може бити најбољи избор. +.IP "" +Иако се претпостављено поравнање може подесити са \fIpb\fP и \fIlp\fP, LZMA1 и +LZMA2 и даље незнатно фаворизују 16\-бајтно поравнање. То би могло бити +вредно узети у обзир приликом дизајнирања формата датотека које ће вероватно +бити често запаковане са LZMA1 или LZMA2. +.TP +\fBmf=\fP\fImf\fP +Налазач поклапања има главни утицај на брзину шифрера, коришћење меморије и +стопу запакивања. Обично Hash Chain налазачи поклапања су бржи од Binary +Tree налазача поклапања. Основност зависи од \fIпредподешености\fP: 0 користи +\fBhc3\fP, 1\(en3 користи \fBhc4\fP, а остало користи \fBbt4\fP. +.IP "" +Следећи налазачи поклапања су подржани. Формуле коришћења меморије испод су +грубе апроксимације које су ближе стварности када је \fIречник\fP степен +двојке. +.RS +.TP +\fBhc3\fP +Ланац хеша са хеширањем 2\- и 3\-бајта +.br +Најмања вредност за \fIфино\fP: 3 +.br +Коришћење меморије: +.br +\fIречник\fP * 7.5 (ако је \fIречник\fP <= 16 MiB); +.br +\fIречник\fP * 5.5 + 64 MiB (if \fIречник\fP > 16 MiB) +.TP +\fBhc4\fP +Ланац хеша са хеширањем 2\-, 3\- и 4\-бајта +.br +Најмања вредност за \fIфино\fP: 4 +.br +Коришћење меморије: +.br +\fIречник\fP * 7.5 (ако је \fIречник\fP <= 32 MiB); +.br +\fIречник\fP * 6.5 (ако је \fIречник\fP > 32 MiB) +.TP +\fBbt2\fP +Бинарно стабло са 2\-бајта хеширања +.br +Најмања вредност за \fIфино\fP: 2 +.br +Коришћење меморије: \fIречник\fP * 9.5 +.TP +\fBbt3\fP +Бинарно стабло са 2\- и 3\-бајта хеширања +.br +Најмања вредност за \fIфино\fP: 3 +.br +Коришћење меморије: +.br +\fIречник\fP * 11.5 (if \fIречник\fP <= 16 MiB); +.br +\fIречник\fP * 9.5 + 64 MiB (ако је \fIречник\fP > 16 MiB) +.TP +\fBbt4\fP +Бинарно стабло са 2\-, 3\-, и 4\-бајта хеширања +.br +Најмања вредност за \fIфино\fP: 4 +.br +Коришћење меморије: +.br +\fIречник\fP * 11.5 (if \fIречник\fP <= 32 MiB); +.br +\fIречник\fP * 10.5 (if \fIречник\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fIрежим\fP +\fIРежим\fP запакивања наводи методу за анализу података које произведе налазач +поклапања. Подржани \fIрежими\fP су \fBfast\fP и \fBnormal\fP. Подразумева се +\fBfast\fP за \fIпредподешавања\fP 0\(en3 и \fBnormal\fP за \fIпредподешавања\fP 4\(en9. +.IP "" +Обично се \fBfast\fP користи са налазачима Hash Chain поклапања а \fBnormal\fP са +налазачима Binary Tree поклапања. Ово је исто што раде и +\fIпредподешености\fP. +.TP +\fBnice=\fP\fIфино\fP +Наводи оно што се сматра да је фина дужина за поклапање. Када се поклапање +од барем \fInice\fP бајтова нађе, алгоритам зауставља тражење могућих бољих +поклапања. +.IP "" +\fIФино\fP може бити 2\(en273 бајта. Веће вредности теже да дају бољу стопу +запакивања на уштрб брзине. Основно зависи од \fIпредподешавања\fP. +.TP +\fBdepth=\fP\fIдубина\fP +Наводи највећу дубину претраге у налазачу поклапања. Основно је посебна +вредност 0, која чини да запакивач одреди разумљиву \fIдубину\fP из \fImf\fP и +\fInice\fP. +.IP "" +Разумљива \fIдубина\fP за ланце хеша је 4\(en100 и 16\(en1000 за стабло +извршних. Коришћење врло великих вредности за \fIдубину\fP може учинити шифрер +врло спорим са неким датотекама. Избегавајте постављање \fIдубине\fP преко +1000 осим ако нисте спремни да прекинете запакивање у случају да потраје +превише дуго. +.RE +.IP "" +Приликом дешифровања сирових токова (\fB\-\-format=raw\fP), LZMA2 треба само +\fIвеличина\fP речника. LZMA1 треба такође \fIlc\fP, \fIlp\fP и \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIопције\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIопције\fP] +.PD +Додаје „branch/call/jump“ (BCJ) филтер ланцу филтера. Ови филтери могу се +користити само ако нису последњи филтер у ланцу филтера. +.IP "" +BCJ филтер претвара релативне адресе у машинском коду на њихове апсолутне +двојнике. Ово не мења величину података, али повећава сувишност, што може +помоћи LZMA2 да произведе 0\(en15\% мању \fB.xz\fP датотеку. BCJ филтери су +увек реверзибилни, стога коришћење BCJ филтера за погрешну врсту података не +доводи ни до каквог губитка података, мада може да учини степен сажимања +нешто лошијим. BCJ филтери су врло брзи и користе безначајну количину +меморије. +.IP "" +Ови BCJ филтери имају познате проблеме везане за стопу запакивања: +.RS +.IP \(bu 3 +Неке врсте датотека које садрже извршни код (на пример, објектне датотеке, +статичке библиотеке и модули Линукс кернела) имају адресе у упутствима +испуњеним вредностима попуњавача. Ови BCJ филтери и даље ће радити +претварање адресе, што ће запакивање учинити горим са овим датотекама. +.IP \(bu 3 +Ако се BCJ филтер примени на архиву, могуће је да ће учинити стопу +запакивања лошијим него кад се не би користио. На пример, ако постоје +сличне или чак истоветне извршне тада ће филтрирање вероватно учинити +датотеке мање сличним и стога је запакивање лошије. Садржај не\-извршних +датотека у истој архиви је такође важан. У пракси се мора покушати са и без +BCJ филтера да би се видело шта је боље у којој прилици. +.RE +.IP "" +Различити скупови упутстава имају различита поравнања: извршна датотека мора +бити поравната на множилац ове вредности у улазним подацима како би филтер +радио. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Филтер;Поравнање;Напомене +x86;1;32\-бита или 64\-бита x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096\-бита поравнање је најбоље +PowerPC;4;Само велика крајност +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Како су BCJ\-филтрирани подаци обично запаковани са LZMA2, стопа запакивања +може бити незнатно побољшана ако су LZMA2 опције постављене да поклопе +поравнање изабраног BCJ филтера. Примери: +.RS +.IP \(bu 3 +IA\-64 филтер има поравнање 16\-бајта тако да је \fBpb=4,lp=4,lc=0\fP добро са +LZMA2 (2^4=16). +.IP \(bu 3 +RISC\-V код има поравнање од 2 или 4 бајта у зависности од тога да ли +датотека садржи запаковане инструкције од 16 бита (проширење C). Када се +користе инструкције од 16 бита, \fBpb=2,lp=1,lc=3\fP или \fBpb=1,lp=1,lc=3\fP је +добро. Када нема инструкција од 16 бита, \fBpb=2,lp=2,lc=2\fP је најбоље. +\fBreadelf \-h\fP се може користити да се провери да ли се „RVC“ јавља у реду +„Заставице“. +.IP \(bu 3 +ARM64 је увек 4\-бајта поравнат тако да је \fBpb=2,lp=2,lc=2\fP најбоље. +.IP \(bu 3 +Филтер x86 је изузетак. Обично је добро придржавати се LZMA2 основности +(\fBpb=2,lp=0,lc=3\fP) приликом запакивања x86 извршних. +.RE +.IP "" +Сви BCJ филтери подржавају исте \fIопције\fP: +.RS +.TP +\fBstart=\fP\fIпомерај\fP +Наводи \fIпомерај\fP почетка који се користи приликом претварања између +релативних и апсолутних адреса. \fIПомерај\fP мора бити производ поравнања +филтера (видите табелу изнад). Основно је нула. У пракси, основност је +добра; навођење произвољног \fIпомераја\fP скоро никада није од користи. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIопције\fP] +Додаје Delta филтер у ланац филтера. Делта филтер може се користити само +ако није последњи филтер у ланцу филтера. +.IP "" +Тренутно је подржан само једноставан делта прорачун једног по једног бита. +Може бити користан приликом запакивања, на пример, незапакованих битмап +слика или незапакованог PCM звука. Међутим, алгоритми посебне намене могу +дати знатно боље резултате него Delta + LZMA2. Ово је тачно, посебно са +звуком, који се запакује брже и боље, на пример, са \fBflac\fP(1). +.IP "" +Подржане \fIопције\fP: +.RS +.TP +\fBdist=\fP\fIрастојање\fP +Наводи \fIрастојање\fP делта прорачуна у бајтима. \fIРастојање\fP мора бити +1\(en256. Основно је 1. +.IP "" +На пример, са \fBdist=2\fP и осмобајтним улазом A1 B1 A2 B3 A3 B5 A4 B7, излаз +ће бити A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Остале опције" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Потискује упозорења и обавештења. Наведите ово два пута да потиснете и +грешке. Ова опција нема утицаја на стање излаза. Тако је, чак и ако је +упозорење потиснуто, стање излаза које указује на упозорење се и даље +користи. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Бива опширан. Ако је стандардна грешка повезана са терминалом, \fBxz\fP ће +приказати указивач напретка. Навођењем \fB\-\-verbose\fP два пута добија се још +опширнији излаз. +.IP "" +Указивач напредовања показује следеће информације: +.RS +.IP \(bu 3 +Проценат довршености се показује ако је величина улазне датотеке позната. +Тако је, проценат се не може приказати у спојкама. +.IP \(bu 3 +Количина запакованих података проистеклих (запакивање) или утрошених +(распакивање). +.IP \(bu 3 +Количина распакованих података утрошених (запакивање) или проистеклих +(распакивање). +.IP \(bu 3 +Размера паковања, која се израчунава дељењем количине запакованих података +обрађених до сада количином незапакованих података до сада обрађених. +.IP \(bu 3 +Брзина запакивања или распакивања. Ово се мери као количина незапакованих +података утрошених (запакивање) или добијених (распакивање) у секунди. +Приказује се након неколико секунде након што \fBxz\fP започне обраду датотеке. +.IP \(bu 3 +Протекло време у формату М:СС или Ч:ММ:СС. +.IP \(bu 3 +Процењено преостало време се приказује само када је величина улазне датотеке +позната и неколико секунди је већ протекло од кад је \fBxz\fP започео обраду +датотеке. Време се приказује у мање тачном формату које никада нема +двотачке, на пример, 2 мин 30 сек. +.RE +.IP "" +Када стандардна грешка није терминал, \fB\-\-verbose\fP ће учинити да \fBxz\fP +испише назив датотеке, запаковану величину, незапаковану величину, стопу +запакивања и по могућству такође брзину и протекло време на једном реду на +стандардну грешку након запакивања или распакивања датотеке. Брзина и +протекло време су укључени само када радња потраје барем неколико секунде. +Ако се радња не заврши, на пример, услед што корисник прекине, такође се +исписује проценат завршености ако је величина улазне датотеке позната. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Не поставља стање излаза на 2 чак и ако је услов вредан упозорења откривен. +Ова опција не утиче на ниво опширности, стога и \fB\-\-quiet\fP и \fB\-\-no\-warn\fP +треба да се користе да се не приказују упозорења и да се не измени стање +излаза. +.TP +\fB\-\-robot\fP +Исписује поруке у формату обрадивом машинама. Ово је замишљено да олакша +писање челника који желе да користе \fBxz\fP уместо „liblzma“, што може бити +случај са разним скриптама. Излаз са овом опцијом укљученом је замишљен да +буде стабилан кроз \fBxz\fP издања. Видите одељак \fBРЕЖИМ РОБОТА\fP за више о +томе. +.TP +\fB\-\-info\-memory\fP +Приказује, у формату читљивом људима, колико физичке меморије (RAM) и колико +нити процесора \fBxz\fP мисли да систем има и ограничења коришћења меморије за +запакивање и распакивање и излази успешно. +.TP +\fB\-h\fP, \fB\-\-help\fP +Приказује поруку помоћи описујући најчешће коришћених опција, и успешно +излази. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Приказује поруку помоћи описујући све функције \fBxz\fP, и успешно излази +.TP +\fB\-V\fP, \fB\-\-version\fP +Приказује број издања за \fBxz\fP и „liblzma“ у формату читљивом људима. Да +добијете излаз машинама обрадив, наведите \fB\-\-robot\fP пре \fB\-\-version\fP. +. +.SH "РЕЖИМ РОБОТА" +Режим робота се покреће опцијом \fB\-\-robot\fP. Чини да излаз \fBxz\fP буде лакши +за обраду другим програмима. Тренутно \fB\-\-robot\fP је подржано само заједно +са \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, и \fB\-\-version\fP. Биће +подржан за запакивање и распакивање у будућности. +. +.SS "Режим списка" +\fBxz \-\-robot \-\-list\fP користи излаз раздвојен табулатором. Прва колона +сваког реда садржи ниску која указује на врсту информације која се налази у +том реду: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP (назив) +Ово је увек први ред приликом почетка листања датотеке. Друга колона у реду +је назив датотеке. +.TP +\fBfile\fP (датотека) +Овај ред садржи свеукупне информације о \fB.xz\fP датотеци. Овај ред се увек +исписује после реда \fBназив\fP. +.TP +\fBstream\fP (ток) +Ова врста реда се користи само када је \fB\-\-verbose\fP наведено. Има толико +редова \fBтока\fP колико има токова у \fB.xz\fP даатотеци. +.TP +\fBblock\fP (блок) +Ова врста реда се користи само када је \fB\-\-verbose\fP наведено. Има онолико +редова \fBблока\fP колико има блокова у \fB.xz\fP датотеци. Редови \fBблока\fP се +приказују након свих редова \fBтока\fP; различите врсте реда се не преплићу. +.TP +\fBsummary\fP (сажетак) +Ова врста реда се користи само када је \fB\-\-verbose\fP наведено два пута. Овај +ред се исписује након свих редова \fBблока\fP. Као ред \fBдатотека\fP, ред +\fBсажетка\fP садржи преглед информација о \fB.xz\fP датотеци. +.TP +\fBtotals\fP (укупност) +Овај ред је увек последњи ред на списку излаза. Показује укупне збирове и +величине. +.PP +Колоне редова \fBдатотеке\fP: +.PD 0 +.RS +.IP 2. 4 +Број токова у датотеци +.IP 3. 4 +Укупан број блокова у току(овима) +.IP 4. 4 +Величина запаковане датотеке +.IP 5. 4 +Величина незапаковане датотеке +.IP 6. 4 +Размера паковања, на пример, \fB0.123\fP. Ако је размера преко 9.999, три +цртице (\fB\-\-\-\fP) се приказују уместо размере. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Зарезом раздвојен списак назива провера целовитости. Следеће ниске се +користе за познате врсте провера: \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP и \fBSHA\-256\fP. +За непознате врсте провера, користи се \fBUnknown\-\fP\fIN\fP, где је \fIN\fP ИД +провере као децимални број (једна или две цифре). +.IP 8. 4 +Укупна величина попуњавања тока у датотеци +.RE +.PD +.PP +Колоне редова \fBтока\fP: +.PD 0 +.RS +.IP 2. 4 +Број тока (први ток је 1) +.IP 3. 4 +Број блокова у току +.IP 4. 4 +Померај почетка запакованог +.IP 5. 4 +Померај почетка незапаковане +.IP 6. 4 +Величина запакованог (не укључује попуну тока) +.IP 7. 4 +Величина незапаковане +.IP 8. 4 +Размера паковања +.IP 9. 4 +Назив провере целовитости +.IP 10. 4 +Величина попуне тока +.RE +.PD +.PP +Колоне редова \fBблока\fP: +.PD 0 +.RS +.IP 2. 4 +Број тока који садржи овај блок +.IP 3. 4 +Број блока релативан на почетак тока (први блок је 1) +.IP 4. 4 +Број блока релативан на почетак датотеке +.IP 5. 4 +Померај почетка запакованог односан на почетак датотеке +.IP 6. 4 +Померај почетка незапаковане односан на почетак датотеке +.IP 7. 4 +Укупна запакована величина блока (заједно са заглављима) +.IP 8. 4 +Величина незапаковане +.IP 9. 4 +Размера паковања +.IP 10. 4 +Назив провере целовитости +.RE +.PD +.PP +Ако је \fB\-\-verbose\fP наведено два пута, додатне колоне су укључене у редовима +\fBблока\fP. Они се не приказују са једним \fB\-\-verbose\fP, јер добијање ове +информације захтева много тражења и стога може бити споро: +.PD 0 +.RS +.IP 11. 4 +Вредност провере целовитости у хексадецималном облику +.IP 12. 4 +Величина заглавља блока +.IP 13. 4 +Заставице блока: \fBc\fP указује да је величина запакованог присутна, а \fBu\fP +указује да је величина нераспакованог присутна. Ако заставица није +постављена, цртица (\fB\-\fP) се приказује уместо да се настави са поправком +дужине ниске. У будућности нове заставице могу бити додате на крај ниске. +.IP 14. 4 +Величина стварних запакованих података у блоку (ово искључује заглавље +блока, попуњавање блока и поља провере) +.IP 15. 4 +Количина меморије (у бајтовима) потребна за распакивање овог блока са овим +\fBxz\fP издањем +.IP 16. 4 +Ланац филтера. Знајте да већина опција коришћених за време запакивања не +може бити познато, јер се само опције које су потребне за распакивање чувају +у \fB.xz\fP заглављима. +.RE +.PD +.PP +Колоне редова \fBсажетка\fP: +.PD 0 +.RS +.IP 2. 4 +Количина меморије (у бајтовима) потребна за распакивање ове датотеке са овим +\fBxz\fP издањем +.IP 3. 4 +\fByes\fP или \fBno\fP указује да ли сва заглавља блока имају и величину +запакованог и величину незапакованог сачуване у њима +.PP +\fIОд\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Потребно је најмање \fBxz\fP издање за распакивање датотеке +.RE +.PD +.PP +Колоне редова \fBукупности\fP: +.PD 0 +.RS +.IP 2. 4 +Број токова +.IP 3. 4 +Број блокова +.IP 4. 4 +Величина запакованог +.IP 5. 4 +Величина незапаковане +.IP 6. 4 +Просечан степен запакивања +.IP 7. 4 +Списак зарезом раздвојених назива провере целовитости која су била присутна +у датотекама +.IP 8. 4 +Величина попуњавања тока +.IP 9. 4 +Број датотека. Ту се држи поредак ранијих колона исто као у редовима +\fBдатотеке\fP. +.PD +.RE +.PP +Ако је \fB\-\-verbose\fP наведено два пута, додатне колоне су укључене у реду +\fBtotals\fP: +.PD 0 +.RS +.IP 10. 4 +Највећа количина меморије (у бајтима) потребна за распакивање датотеке са +овим \fBxz\fP издањем +.IP 11. 4 +\fByes\fP или \fBno\fP указује да ли сва заглавља блока имају и величину +запакованог и величину незапакованог сачуване у њима +.PP +\fIОд\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Потребно је најмање \fBxz\fP издање за распакивање датотеке +.RE +.PD +.PP +Будућа издања могу додати нове врсте реда и нове колоне се могу додати +постојећим врстама реда, али постојеће колоне се неће променити. +. +.SS "Помоћ филтера" +\fBxz \-\-robot \-\-filters\-help\fP исписује подржане филтере у следећем формату: +.PP +\fIфилтер\fP\fB:\fP\fIопција\fP\fB=<\fP\fIвредност\fP\fB>,\fP\fIопција\fP\fB=<\fP\fIвредност\fP\fB>\fP... +.TP +\fIфилтер\fP +Назив филтера +.TP +\fIопција\fP +Назив филтера специфичне опције +.TP +\fIвредност\fP +Опсези бројевних \fIвредности\fP се јављају као +\fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. \fIВредност\fP ниске избора се приказују +унутар \fB< >\fP и раздвојене су знаком \fB|\fP. +.PP +Сваки филтер се исписује на свом сопственом реду. +. +.SS "Информације о ограничењу меморије" +\fBxz \-\-robot \-\-info\-memory\fP исписује један ред са више колона раздвојених +табулатором: +.IP 1. 4 +Укупна количина физичке меморије (RAM) у бајтима. +.IP 2. 4 +Ограничење коришћења меморије за запакивање у бајтима +(\fB\-\-memlimit\-compress\fP). Специјална вредност \fB0\fP означава основно +подешавање које је за режим једне нити исто као без ограничења. +.IP 3. 4 +Ограничење коришћења меморије за распакивање у бајтима +(\fB\-\-memlimit\-decompress\fP). Специјална вредност \fB0\fP означава основно +подешавање које је за режим једне нити исто као без ограничења. +.IP 4. 4 +Од \fBxz\fP 5.3.4alpha: Коришћење меморије за распакивање са више нити у +бајтима (\fB\-\-memlimit\-mt\-decompress\fP). Ово никада није нула јер систему +специфична основна вредност приказана у колони 5 се користи ако ограничење +није изричито наведено. Такође никада није веће од вредности у колони 3 чак +и ако је наведена већа вредност са \fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Од \fBxz\fP 5.3.4alpha: Систему специфично основно ограничење коришћења +меморије које се користи за ограничавање броја нити приликом запакивања са +аутоматским бројем нити (\fB\-\-threads=0\fP) и без наведеног ограничења +коришћења меморије (\fB\-\-memlimit\-compress\fP). Ово се такође користи као +основна вредност за \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Од \fBxz\fP 5.3.4alpha: Број доступних нити обрађивача. +.PP +У будуће, излаз \fBxz \-\-robot \-\-info\-memory\fP може имати више колона, али +никада више од једног реда. +. +.SS Издање +\fBxz \-\-robot \-\-version\fP исписује број издања за \fBxz\fP и „liblzma“ у следећем +формату: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Главно издање. +.TP +\fIYYY\fP +Споредно издање. Парни бројеви су стабилна а непарни су алфа или бета +издања. +.TP +\fIZZZ\fP +Ниво закрпе за стабилна издања или само бројач за развојна издања. +.TP +\fIS\fP +Стабилност. 0 је алфа, 1 је бета, а 2 је стабилно. \fIS\fP треба увек да буде +2 када је \fIYYY\fP парно. +.PP +\fIXYYYZZZS\fP су исти у оба реда ако су \fBxz\fP и „liblzma“ из истог издања XZ +Utils\-а. +.PP +Примери: 4.999.9beta је \fB49990091\fP и 5.0.0 је \fB50000002\fP. +. +.SH "СТАЊЕ ИЗЛАЗА" +.TP +\fB0\fP +Све је у реду. +.TP +\fB1\fP +Дошло је до грешке. +.TP +\fB2\fP +Десило се нешто вредно упозорења, али није дошло до стварних грешака. +.PP +Обавештења (без упозорења или грешака) исписано на стандардној грешци не +утичу на стање излаза. +. +.SH ОКРУЖЕЊЕ +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP обрађује размаком одвојени списак опција из променљивих окружења +\fBXZ_DEFAULTS\fP и \fBXZ_OPT\fP, тим редом, пре обраде опција са линије наредби. +Знајте да се обрађују само опције из променљивих окружења; све што нису +опције се тихо занемарује. Обрада се ради са \fBgetopt_long\fP(3) која се +користи такође за аргументе линије наредби. +.PP +\fBУпозорење:\fP Постављањем ових променљивих окружења, ефективно мењате +програме и скрипте које покреће \fBxz\fP. У већини случајева је безбедно +поставити ограничење коришћења, број нити и опција паковања путем +променљивих окружења. Међутим, неке опције могу да уруше скрипте. +Очигледан пример је \fB\-\-help\fP која чини да \fBxz\fP прикаже текст помоћи уместо +да запакује или распакује датотеку. Суптилнији примери су \fB\-\-quiet\fP и +\fB\-\-verbose\fP. У многим случајевима добро функционише омогућавање указивача +напредовања коришћењем \fB\-\-verbose\fP, али у неким ситуацијама додатне поруке +стварају проблеме. Ниво опширности такође утиче на понашање \fB\-\-list\fP +.TP +\fBXZ_DEFAULTS\fP +Кориснику специфичне или свеопште системске основне опције. Обично је ово +постављено у скрипти покретања конзоле за укључивање \fBxz\fP ограничавача +коришћења меморије по основи или за постављање основног броја нити. +Искључивање скрипти покретања конзоле и сличних специјалних случајева, +скрипте не смеју никада да поставе или пониште \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Ово је за прослеђивање опција ка \fBxz\fP када није могуће поставити опције +директно на \fBxz\fP линији наредби. Ово је случај када је \fBxz\fP покренут +скриптом или алатом, на пример, са Гну \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Скрипте могу да користе \fBXZ_OPT\fP, на пример, за постављање основних опција +запакивања специфичних скрипти. Још увек се препоручује омогућавање +корисницима да пишу преко \fBXZ_OPT\fP ако је то разумљиво. На пример, у +\fBsh\fP(1) скриптама неко може користити нешто као ово: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "LZMA UTILS САДЕЈСТВЕНОСТ" +Синтакса линије наредби \fBxz\fP је практично супер скуп \fBlzma\fP, \fBunlzma\fP и +\fBlzcat\fP као што се налази у LZMA Utils 4.32.x. У већини случајева, могуће +је заменити LZMA Utils са XZ Utils без оштећења постојећих скрипти. Има +неких несагласности такође, које понекад могу довести до проблема. +. +.SS "Нивои предподешавања запакивања" +Набрајање предподешености нивоа запакивања није исто у \fBxz\fP и LZMA Utils. +Најважнија разлика је у томе како се величине речника мапирају у различитим +предподешеностима. Величина речника је отприлике иста као и коришћење +меморије распакивача. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Ниво;xz;LZMA Utils +\-0;256 KiB;Н/Д +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Разлике величине речника делују такође на коришћење меморије запакивање, али +постоје још неке разлике између LZMA Utils и XZ Utils, што чини разлике још +већим: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Ниво;xz;LZMA Utils 4.32.x +\-0;3 MiB;Н/Д +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Основни ниво предподешености у LZMA Utils је \fB\-7\fP док у XZ Utils је \fB\-6\fP, +тако да оба користе 8 MiB речник по основи. +. +.SS "Токовне наспрам не\-токовних „.lzma“ датотеке" +Незапакована величина датотеке се може чувати у \fB.lzma\fP заглављу. LZMA +Utils то ради приликом запакивања обичних датотека. Алтернатива је да се +означи та незапакована величина као непозната и да се користи означавач +краја утовара да назначи где распакивач треба да стане. LZMA Utils користи +ову методу када незапакована величина није позната, што је случај, на +пример, у спојкама. +.PP +\fBxz\fP подржава распакивање \fB.lzma\fP датотека са или без означавача краја +утовара, али ће све \fB.lzma\fP датотеке направљене са \fBxz\fP користити +означавач краја утовара и означити незапаковану величину непознатом у +\&\fB.lzma\fP заглављу. Ово може бити проблем у неким неуобичајеним +ситуацијама. На пример, \fB.lzma\fP распакивач у угнежденом уређају може +радити само са датотекама које имају незапаковану величину. Ако наиђете на +тај проблем, треба да користите LZMA Utils или LZMA SDK да направите +\&\fB.lzma\fP датотеке са познатом незапакованом величином. +. +.SS "Неподржане „.lzma“ датотеке" +Формат \fB.lzma\fP омогућава \fIlc\fP вредности све до 8, а \fIlp\fP вредности све до +4. LZMA Utils може да распакује датотеке са било којим \fIlc\fP и \fIlp\fP, али +увек прави датотеке са \fBlc=3\fP и \fBlp=0\fP. Прављење датотека са другим \fIlc\fP +и \fIlp\fP је мгуће са \fBxz\fP и са LZMA SDK. +.PP +Примена филтера LZMA1 у „liblzma“ захтева да збир \fIlc\fP и \fIlp\fP не сме да +премаши 4. Стога, \fB.lzma\fP датотеке, које премаше ово ограничење, не могу +да се распакују са \fBxz\fP. +.PP +LZMA Utils прави само \fB.lzma\fP датотеке које имају величину речника од +2^\fIn\fP (степен 2) али прихвата датотеке са било којом величином речника. +„liblzma“ прихвата само \fB.lzma\fP датотеке које имају величину речника од +2^\fIn\fP или 2^\fIn\fP + 2^(\fIn\fP\-1). Ово је да се смање лажни позитивни +резултати приликом откривања \fB.lzma\fP датотека. +.PP +Ова ограничења не би требало да буду проблем у пракси, јер су практично све +\&\fB.lzma\fP датотеке запаковане са поставкама које ће „liblzma“ прихватити. +. +.SS "Пратеће смеће" +Приликом распакивања, LZMA Utils тихо занемарује све после првог \fB.lzma\fP +тока. У већини прилика, ово је грешка. Ово такође значи да LZMA Utils не +подржава распакивање надовезаних \fB.lzma\fP датотека. +.PP +Ако су остали подаци након првог \fB.lzma\fP тока, \fBxz\fP сматра да је датотека +оштећена осим ако је коришћено \fB\-\-single\-stream\fP. Ово може прекинути +нејасне скрипте које су претпоставиле да је пратеће смеће занемарено. +. +.SH НАПОМЕНЕ +. +.SS "Излаз запакованог може бити променљив" +Тачан запаковани излаз добијен из исте незапаковане улазне датотеке може се +разликовати између XZ Utils издања чак и ако су опције запакивања +истоветне. Ово је због тога што шифрер може бити побољшан (брже и боље +запакивање) а да не утиче на формат датотеке. Излаз се може разликовати +између различитих изградњи истог XZ Utils издања, ако су коришћене другачије +опције изградње. +.PP +Ово изнад значи да када се \fB\-\-rsyncable\fP једном примени, резултирајућа +датотека неће неопходно бити r\-ускладива осим ако и стара и нова датотека +нису запаковане истим xz издањем. Овај проблем може бити поправљен ако је +део примене шифрера замрзнут да држи r\-ускладив излаз стабилним кроз xz +издања. +. +.SS "Угнеждени „.xz“ распакивачи" +Примена угнежденог \fB.xz\fP распакивача као што је XZ Embedded неопходно не +подржава датотеке направљене врстама \fIпровере\fP целовитости осим \fBnone\fP и +\fBcrc32\fP. Како је основно \fB\-\-check=crc64\fP, морате да користите +\fB\-\-check=none\fP или \fB\-\-check=crc32\fP када правите датотеке за угнеждене +системе. +.PP +Споља уграђени системи, сви распакивачи \fB.xz\fP формата подржавају све врсте +\fIпровере\fP, или барем могу да распакују датотеку без испитивања провере +целовитости ако одређена \fIпровера\fP није подржана. +.PP +XZ Embedded подржава BCJ филтере, али само са основним померајем почетка. +. +.SH ПРИМЕРИ +. +.SS Основно +Запакује датотеку \fIfoo\fP у \fIfoo.xz\fP користећи основни ниво запакивања +(\fB\-6\fP), и уклања \fIfoo\fP ако је запакивање успешно: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Распакује \fIbar.xz\fP у \fIbar\fP и не уклања \fIbar.xz\fP чак и када је распакивање +успешно: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Ствара \fIbaz.tar.xz\fP са предподешавањем \fB\-4e\fP (\fB\-4 \-\-extreme\fP), које је +спорије него основно \fB\-6\fP, али захтева мање меморије за запакивање и +распакивање (48\ MiB и 5\ MiB): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Мешавина сажетих и несажетих датотека се може распаковати на стандардни +излаз једном наредбом: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Паралелно запакивање више датотека" +На GNU и *BSD, \fBfind\fP(1) и \fBxargs\fP(1) се могу користити за паралелно +запакивање више датотека: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Опција \fB\-P\fP за \fBxargs\fP(1) поставља број паралелних \fBxz\fP процеса. Најбоља +вредност за опцију \fB\-n\fP зависи од тога колико датотека има за запакивање. +Ако има само неколико датотека, вредност би вероватно требала да буде 1; са +више хиљада датотека, 100 или чак и више може бити одговарајуће за смањење +броја \fBxz\fP процеса које би \fBxargs\fP(1) евентуално направио. +.PP +Опција \fB\-T1\fP за \fBxz\fP је ту да га примора на једнонитни режим, јер се +\fBxargs\fP(1) користи за контролу количине паралелизације. +. +.SS "Режим робота" +Израчунава колико је бајтова укупно сачувано након запакивања више датотека: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Скрипта може желети да зна да користи најновији \fBxz\fP. Следећа скрипта +\fBsh\fP(1) проверава да ли је број издања \fBxz\fP алата барем 5.0.0. Ова +метода је сагласна са старим бета издањима која не подржавају \fB\-\-robot\fP +опцију: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Ваш „xz“ је превише стар." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Поставља ограничење коришћења меморије за распакивање коришћењем \fBXZ_OPT\fP, +али ако је ограничење већ постављено, не повећава је: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Произвољни ланци филтера запакивача" +Најједноставнија употреба за произвољне ланце филтера прилагођава LZMA2 +предподешеност. Ово може бити корисно, јер предподешености покривају само +подскуп потенцијално корисних комбинација поставки запакивања. +.PP +Колоне ЗапакЦПЈ у табелама из описа опција \fB\-0\fP ... \fB\-9\fP и \fB\-\-extreme\fP су +корисне приликом прилагођавања LZMA2 предподешености. Овде су значајни +делови прикупљени из те две табеле: +.RS +.PP +.TS +tab(;); +c c +n n. +Преподешеност;ЗапакЦПЈ +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Ако знате да датотека захтева нешто велики речник (на пример, 32 \ MiB) за +добро запакивање, али желите да је запакујете брже него што би то \fBxz \-8\fP +урадио, предподешеност са ниском вредношћу ЗапакМем (на пример, 1) може се +изменити да користи већи речник: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Са одређеним датотекама, горња наредба може бити бржа од \fBxz \-6\fP а +запакивање значајно боље. Међутим, мора бити наглашено да само неке +датотеке имају корист од великог речника док одржавају вредност ЗапакЦПЈ +ниском. Најочигледнија ситуација, у којој велики речник може доста помоћи, +јесте архива која садржи врло сличне датотеке где свака има најмање неколико +мегабајта. Величина речника треба да буде значајно већа од сваке засебне +датотеке да би се омогућило да LZMA2 има потпуну предност од сличности +између узастопних датотека. +.PP +Ако је веома велико коришћење меморије запакивача и распакивача у реду, а +датотека која се запакује је барем неколико стотина мегабајта, може бити +корисно користити још већи речник од 64 MiB који ће \fBxz \-9\fP користити: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Коришћење \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) као у горњем примеру може бити +корисно да се виде захтеви за меморијом запакивача и распакивача. Знајте да +је коришћење речника већег од величине незапаковане датотеке губитак +меморије, тако да горња наредба није корисна за мале датотеке. +.PP +Понекад време запакивања није важно, али коришћење меморије распакивача +треба да се одржава ниским, на пример, да би се учинило могућим распакивање +датотеке на угнежденом систему, Следеће наредбе користе \fB\-6e\fP (\fB\-6 \-\-extreme\fP) као основу и постављају речник на само 64\ KiB. Резултујућа +датотека се може распаковати са XZ Embedded (због тога је ту +\fB\-\-check=crc32\fP) користећи око 100\ KiB меморије. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Ако желите да исцедите што је више могуће бајтова, дотеривање броја битова +контекста литерала (\fIlc\fP) и броја битова положаја (\fIpb\fP) може понекад да +помогне. Дотеривање броја битова положаја литерала (\fIlp\fP) може такође да +помогне, али обично \fIlc\fP и \fIpb\fP су важнији. На пример, архива извора кода +садржи углавном US\-ASCII текст, тако да нешто као следеће може да да +незнатно (око 0.1\ %) мању датотеку него \fBxz \-6e\fP (пробајте такође без +\fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Коришћење још једног филтера заједно са LZMA2 може побољшати запакивање са +одређеним врстама датотека. На пример, за запакивање x86\-32 или x86\-64 +дељене библиотеке коришћењем x86 BCJ филтера: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Знајте да поредак опција филтера има значај. Ако је \fB\-\-x86\fP наведено након +\fB\-\-lzma2\fP, \fBxz\fP ће дати грешку, јер не сме бити никаквог филтера после +LZMA2, и такође зато што се x86 BCJ филтер не може користити као последњи +филтер у ланцу. +.PP +Delta филтер заједно са LZMA2 може дати добре резултате са битмап сликама. +Требало би обично да надјача PNG, који има нешто више напредних филтера него +једноставни делта али користи Deflate за стварно запакивање. +.PP +Слика треба да се сачува у незапакованом формату, на пример, као +незапакована TIFF. Параметар растојања Delta филтера је постављен да се +подудари са бројем бајтова по пикселу у слици. На пример, RGB битмапа од 24 +бита захтева \fBdist=3\fP, а такође је добро проследити \fBpb=0\fP за LZMA2 да се +прилагоди поравнање од три бајта: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Ако је више слика стављено у једну архиву (на пример, \fB.tar\fP), Delta филтер +ће радити на томе такође све док све слике не буду имале исти број бајтова +по пикселу. +. +.SH "ВИДИТЕ ТАКОЂЕ" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzmadec.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzmadec.1 new file mode 100644 index 0000000000000000000000000000000000000000..c9bbe26f45da0a1add18e35e5a13105c4155b677 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzmadec.1 @@ -0,0 +1,81 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.\" Serbian translation of xz-man. +.\" Мирослав Николић , 2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDEC 1 08.04.2024. Tukaani "XZ Utils" +.SH НАЗИВ +xzdec, lzmadec – Мали „.xz“ и „.lzma“ распакивачи +.SH САЖЕТАК +\fBxzdec\fP [\fIопција...\fP] [\fIдатотека...\fP] +.br +\fBlzmadec\fP [\fIопција...\fP] [\fIдатотека...\fP] +.SH ОПИС +\fBxzdec\fP је алат само за распакивање заснован на „liblzma“ за \fB.xz\fP (и само +\&\fB.xz\fP) датотеке. \fBxzdec\fP је намењен да ради као тренутна замена за +\fBxz\fP(1) у најопштијим ситуацијама где је скрипта написана да користи \fBxz \-\-decompress \-\-stdout\fP (и по могућству још неколико других обично коришћених +опција) за распакивање \fB.xz\fP датотека. \fBlzmadec\fP је истоветна са \fBxzdec\fP +осим што \fBlzmadec\fP подржава \fB.lzma\fP датотеке уместо of \fB.xz\fP датотека. +.PP +За смањење величине извршне, \fBxzdec\fP не подржава више нити или +локализацију, и не чита опције из променљивих окружења \fBXZ_DEFAULTS\fP и +\fBXZ_OPT\fP. \fBxzdec\fP не подржава приказивање посредничких информација +напредовања: слање \fBSIGINFO\fP ка \fBxzdec\fP не ради ништа, али слање +\fBSIGUSR1\fP окончава процес уместо да прикаже информације о напредовању. +.SH ОПЦИЈЕ +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +Занемарено зарад \fBxz\fP(1) сагласности. \fBxzdec\fP подржава само распакивање. +.TP +\fB\-k\fP, \fB\-\-keep\fP +Занемарено зарад \fBxz\fP(1) сагласности. \fBxzdec\fP никада не прави или уклања +датотеке. +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Занемарено зарад \fBxz\fP(1) сагласности. \fBxzdec\fP увек пише распаковане +податке на стандардни излаз. +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Навођењем овога једном не ради ништа јер \fBxzdec\fP никада не приказује +упозорења или обавештења. Наведите ово два пута да потиснете грешке. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Занемарено зарад \fBxz\fP(1) сагласности. \fBxzdec\fP никада не користи излазно +стање 2. +.TP +\fB\-h\fP, \fB\-\-help\fP +Приказује поруку помоћи и излази с успехом. +.TP +\fB\-V\fP, \fB\-\-version\fP +Приказује број издања за \fBxzdec\fP и „liblzma“. +.SH "СТАЊЕ ИЗЛАЗА" +.TP +\fB0\fP +Све беше у реду. +.TP +\fB1\fP +Дошло је до грешке. +.PP +\fBxzdec\fP нема поруке упозорења као што има \fBxz\fP(1), стога \fBxzdec\fP не +користи излазно стање 2. +.SH НАПОМЕНЕ +Користите \fBxz\fP(1) уместо \fBxzdec\fP или \fBlzmadec\fP за обично свакодневно +коришћење. \fBxzdec\fP или \fBlzmadec\fP су замишљени само ситуације у којима је +важно имати мањи распакивач неко потпуно функционалан \fBxz\fP(1). +.PP +\fBxzdec\fP и \fBlzmadec\fP нису баш тако мали. Величина може бити још смањена +одбацивањем функција из „liblzma“ за време превођења, али то не треба обично +да се ради за извршне достављене у типичним не\-угнежденим дистрибуцијама +оперативног система. Ако вам треба стварно мали \fB.xz\fP распакивач, +размотрите коришћење XZ Embedded\-а. +.SH "ВИДИТЕ ТАКОЂЕ" +\fBxz\fP(1) +.PP +XZ Embedded: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzmainfo.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzmainfo.1 new file mode 100644 index 0000000000000000000000000000000000000000..600a0dc79c8899fb6ce0b505e6bb55278e804df8 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzmainfo.1 @@ -0,0 +1,42 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.\" Serbian translation of xz-man. +.\" Мирослав Николић , 2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH LZMAINFO 1 30.06.2013. Tukaani "XZ Utils" +.SH НАЗИВ +lzmainfo – приказује информације смештене у заглављу .lzma датотеке +.SH САЖЕТАК +\fBlzmainfo\fP [\fB\-\-help\fP] [\fB\-\-version\fP] [\fIдатотека...\fP] +.SH ОПИС +\fBlzmainfo\fP приказује информације које се налазе у заглављу \fB.lzma\fP +датотеке. Чита првих 13 бајтова из наведене \fIдатотеке\fP, дешифрује заглавље +и исписује га на стандардни излаз у облику читљивом људима. Ако ни једна +\fIдатотека\fP није дата или је \fIдатотека\fP \fB\-\fP, чита се стандардни улаз. +.PP +Обично најзанимљивије информације су незапакована величина и величина +речника. Незапакована величина може се приказати само ако је датотека у +варијанти формата \fB.lzma\fP која није ток. Количина меморије потребне за +распакивање датотеке је неколико десетина килобајта плус величина речника. +.PP +\fBlzmainfo\fP је садржано у XZ Utils\-у првенствено због повратне сагласности +са LZMA Utils\-ом. +.SH "СТАЊЕ ИЗЛАЗА" +.TP +\fB0\fP +Све је у реду. +.TP +\fB1\fP +Дошло је до грешке. +.SH ГРЕШКЕ +\fBlzmainfo\fP користи \fBMB\fP док тачан суфикс треба да буде \fBMiB\fP (2^20 +бајтова). Ово је зато да би се задржала сагласност излаза са LZMA Utils\-ом. +.SH "ВИДИТЕ ТАКОЂЕ" +\fBxz\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzmore.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzmore.1 new file mode 100644 index 0000000000000000000000000000000000000000..23df9c6cf0402b3ebdac9949ee6d40bcb9db6045 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/lzmore.1 @@ -0,0 +1,49 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" Serbian translation of xz-man. +.\" Мирослав Николић , 2025. +.\" +.\" (Note that this file is based on xzless.1 instead of gzip's zmore.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZMORE 1 06.03.2025. Tukaani "XZ Utils" +.SH НАЗИВ +xzmore, lzmore – приказује „xz“ или „lzma“ запаковане (текстуалне) датотеке +. +.SH САЖЕТАК +\fBxzmore\fP [\fIдатотека\fP...] +.br +\fBlzmore\fP [\fIдатотека\fP...] (ЗАСТАРЕЛО) +. +.SH ОПИС +\fBxzmore\fP приказује текст из запакованих датотека у терминалу користећи +\fBmore\fP(1). Датотеке које подржава \fBxz\fP(1) се распакују; остале датотеке +се подразумева да су већ у незапакованом облику. Ако није дата ни једна +\fIдатотека\fP, \fBxzmore\fP чита са стандардног улаза. Видите упутство +\fBmore\fP(1) за више информација. +.PP +Знајте да клизање уназад можда неће бити могуће у зависности од примене +\fBmore\fP(1). Ово је зато што \fBxzmore\fP користи спојку за прослеђивање +распакованих података ка \fBmore\fP(1). \fBxzless\fP(1) користи \fBless\fP(1) које +обезбеђује напреднијим функцијама. +.PP +Наредба \fBlzmore\fP се доставља зарад назадне сагласности са LZMA +Utils. Застарела је и биће уклоњена у будућем издању. +. +.SH ОКРУЖЕЊЕ +.TP +.\" TRANSLATORS: Don't translate the uppercase PAGER. +.\" It is a name of an environment variable. +\fBPAGER\fP +Ако је \fBPAGER\fP постављено, његова вредност се користи као страничар уместо +\fBmore\fP(1). +. +.SH "ВИДИТЕ ТАКОЂЕ" +\fBmore\fP(1), \fBxz\fP(1), \fBxzless\fP(1), \fBzmore\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/unlzma.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/unlzma.1 new file mode 100644 index 0000000000000000000000000000000000000000..82d831001e1f400683d876e945d108fa8686a45a --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/unlzma.1 @@ -0,0 +1,1928 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Serbian translation of xz-man. +.\" Мирослав Николић , 2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 08.03.2025. Tukaani "XZ Utils" +. +.SH НАЗИВ +xz, unxz, xzcat, lzma, unlzma, lzcat – Запакује или распакује „.xz“ и „.lzma +датотеке +. +.SH САЖЕТАК +\fBxz\fP [\fIопција...\fP] [\fIдатотека...\fP] +. +.SH "АЛИЈАСИ НАРЕДБЕ" +\fBunxz\fP је исто као и \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP је исто као и \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP је исто као и \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP је исто као и \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP је исто као и \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Приликом писања скрипти које треба да распакују датотеке, препоручује се да +се увек користи назив \fBxz\fP са одговарајућим аргументима (\fBxz \-d\fP или \fBxz \-dc\fP) уместо назива \fBunxz\fP и \fBxzcat\fP. +. +.SH ОПИС +\fBxz\fP је алат опште употребе за запакивање података са синтаксом линије +наредби сличан као \fBgzip\fP(1) и \fBbzip2\fP(1). Изворни формат датотеке је +\&\fB.xz\fP формат, али стари \fB.lzma\fP формат који користи LZMA Utils и сирови +запаковани токови без заглавља формата су такође подржани. Уз то, +распакивање \fB.lz\fP формата који користи \fBlzip\fP је подржано. +.PP +\fBxz\fP запакује или распакује сваку \fIдатотеку\fP у складу са изабраним режимом +рада. Ако није дата ни једна \fIдатотека\fP или је датотека \fIfile\fP \fB\-\fP, +\fBxz\fP чита са стандардног улаза и записује обрађене податке на стандардни +излаз. \fBxz\fP ће одбити (приказаће грешку и прескочити \fIдатотеку\fP) да пише +запаковане податке на стандардни излаз ако је то терминал. Слично, \fBxz\fP ће +одбити да чита запаковане податке са стандардног улаза ако је то терминал. +.PP +Осим ако није наведено \fB\-\-stdout\fP, \fIдатотеке\fP које нису \fB\-\fP се пишу у +нову датотеку чији назив је проистекао из назива изворне \fIдатотеке\fP: +.IP \(bu 3 +Приликом запакивања, суфикс формата циљне датотеке (\fB.xz\fP или \fB.lzma\fP) се +додаје на назив изворне датотеке да би се добио назив циљне датотеке. +.IP \(bu 3 +Приликом распакивања, суфикс \fB.xz\fP, \fB.lzma\fP или \fB.lz\fP се уклања из назива +датотеке да би се добио назив циљне датотеке. \fBxz\fP такође препознаје +суфиксе \fB.txz\fP и \fB.tlz\fP и замењује их суфиксом \fB.tar\fP. +.PP +Ако циљна датотека већ пстоји, приказује се грешка а \fIдатотека\fP се +прескаче. +.PP +Осим ако не пише на стандардни излаз, \fBxz\fP ће приказати упозорење и +прескочити \fIдатотеку\fP ако се нешто од следећег примењује: +.IP \(bu 3 +\fIДатотека\fP није обична датотека. Симболичке везе се не прате, и стога се +не сматра да су обичне датотеке. +.IP \(bu 3 +\fIДатотека\fP има више од једне чврсте везе. +.IP \(bu 3 +\fIДатотека\fP има постављен „setuid, setgid“ или лепљиви бит. +.IP \(bu 3 +Режим рада је постављен на запакивање а \fIдатотека\fP већ има суфикс формата +циљне датотеке (\fB.xz\fP или \fB.txz\fP приликом запакивања у \fB.xz\fP формат, а +\&\fB.lzma\fP или \fB.tlz\fP приликом запакивања у \fB.lzma\fP формат). +.IP \(bu 3 +Режим радње је постављен за распакивање а \fIдатотека\fP нема суфикс ни једног +од подржаних формата датотеке (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP или +\&\fB.lz\fP). +.PP +Након успешног сажимања или распакивања \fIдатотеке\fP, \fBxz\fP умножава +власника, групу, дозволе, време приступа и време измене из изворне +\fIдатотеке\fP у циљну датотеку. Ако умножавање групе не успе, дозволе су +измењене тако да циљна датотека не постане доступна корисницима који нису +имали дозволу за приступ изворној \fIдатотеци\fP. \fBxz\fP не подржава умножавање +других метаподатака попут списка контрола приступа или проширених атрибута. +.PP +Једном када је циљна датотека успешно затворена, изворна \fIдатотека\fP се +уклања осим ако се \fB\-keep\fP не наведе. Изворна \fIдатотека\fP се никада не +уклања ако се излаз пише на стандардни излаз или ако дође до грешке. +.PP +Слање \fBSIGINFO\fP или \fBSIGUSR1\fP ка \fBxz\fP процесу чини да испише информације +напредовања на стандардну грешку. Ово има ограничено коришћење све док +стандардна грешка јесте терминал, коришћење \fB\-\-verbose\fP приказаће +аутоматски указивач напретка освежавања. +. +.SS "Коришћење меморије" +Коришћење меморије \fBxz\fP се мења од неколико стотина килобајта до неколико +гигабајта у зависности од поставки запакивања. Поставке коришћене приликом +запакивања датотеке одређују захтеве меморије распакивача. Обично +распакивачу треба 5\ % до 20\ % количине меморије која је потребна +запакивачу приликом прављења датотеке. На пример, распакивање датотеке +направљене са \fBxz \-9\fP тренутно захтева 65\ MiB меморије. Још увек, могуће +је имати \fB.xz\fP датотеке које захтевају неколико гигабајта меморије за +распакивање. +.PP +Нарочито корисници старијих система могу наћи досадном могућност коришћења +врло велике меморије. Да би се спречила нежељена изненађења, \fBxz\fP има +уграђен ограничавач коришћења меморије, који је искључен по основи. Док +неки оперативни системи пружају начин за ограничавање коришћење меморије за +процесе, ослањање на то сматра се да није довољно прилагодљиво (на пример, +коришћење \fBulimit\fP(1) за ограничавање виртуелне меморије тежи да обогаљи +\fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Ограничавач коришћења меморије се може укључити опцијом линије наредби +\fB\-\-memlimit=\fP\fIограничење\fP. Често је најпогодније укључити ограничавач по +основи постављањем променљиве окружења \fBXZ_DEFAULTS\fP, на пример, +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Могуће је поставити ограничења засебно за +запакивање и распакивање коришћењем \fB\-\-memlimit\-compress=\fP\fIограничење\fP и +\fB\-\-memlimit\-decompress=\fP\fIограничење\fP. Коришћење ове две опције ван +\fBXZ_DEFAULTS\fP је ретко корисно јер једно покретање \fBxz\fP не може да ради и +запакивање и распакивање а \fB\-\-memlimit=\fP\fIограничење\fP (или \fB\-M\fP +\fIограничење\fP) је краће за куцање на линији наредби. +.PP +Ако је прекорачено наведено ограничење коришћења меморије, \fBxz\fP ће +приказати грешку а распакивање датотеке неће успети. Ако је ограничење +прекорачено приликом запакивања, \fBxz\fP ће покушати да умањи поставке тако да +се ограничење више не прекорачује (оси када се користи \fB\-\-format=raw\fP или +\fB\-\-no\-adjust\fP). На тај начин радња неће бити неуспешна осим ако је +ограничење врло мало. Смањење поставке се ради у корацима који се не +подударају са предподешеностима нивоа запакивања, на пример, ако је +ограничење само незнатно мање од износа потребног за \fBxz \-9\fP, поставке ће +бити смањене само мало, а не све до \fBxz \-8\fP. +. +.SS "Надовезивање и попуњавање са „.xz“ датотекама" +Могуће је додати \fB.xz\fP датотеке као то. \fBxz\fP ће распаковати такве +датотеке као да су биле једна \fB.xz\fP датотека. +.PP +Могуће је уметнути попуњавање између придодатих делова или након последњег +дела. Попуњавање мора да се састоји од празних бајтова а величина +попуњавања мора бити умножак четири бајта. Ово може бити корисно, на +пример, ако је \fB.xz\fP датотека смештена на медијуму који мери величине +датотека у блоковима од 512 бајтова. +.PP +Надовезивање и попуњавање нису дозвољени са \fB.lzma\fP датотекама или сировим +токовима. +. +.SH ОПЦИЈЕ +. +.SS "Суфикси целог броја и специјалне вредности" +На већини места где се очекује аргумент целог броја, опционални суфикс је +подржан да би се лако назначили велики цели бројеви. Не сме бити размака +између целог броја и суфикса. +.TP +\fBKiB\fP +Множи цео број са 1.024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP, и \fBKB\fP се +прихватају као синоними за \fBKiB\fP. +.TP +\fBMiB\fP +Множи цео број са 1.048.576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP, и \fBMB\fP се +прихватају као синоними за \fBMiB\fP. +.TP +\fBGiB\fP +Множи цео број са 1.073.741.824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP, и \fBGB\fP се +прихватају као синоними за \fBGiB\fP. +.PP +Посебна вредност \fBmax\fP се може користити да укаже на највећу вредност целог +броја подржану опцијом. +. +.SS "Режим рада" +Ако је дато више опција режима рада, последња има дејства. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Запакује. Ово је основни режим радње када није наведена опција режима радње +и ниједан други режим радње се не подразумева са линије радње (на пример, +\fBunxz\fP подразумева \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Након успешног запакивања, изворна датотека се уклања осим ако се не пише на +стандардни излаз или је наведено \fB\-\-keep\fP. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Распакује. Након успешног распакивања, изворна датотека се уклања осим ако +се не пише на стандардни излаз или је наведено \fB\-\-keep\fP. +.TP +\fB\-t\fP, \fB\-\-test\fP +Тестира целовитост запакованих \fIдатотека\fP. Ова опција је исто што и +\fB\-\-decompress \-\-stdout\fP осим тога што се распаковани подаци одбацују уместо +да се пишу на стандардни излаз. Датотеке се не праве нити уклањају. +.TP +\fB\-l\fP, \fB\-\-list\fP +Исписује информације о запакованим \fIдатотекама\fP. Никакав незапакован излаз +се не добија, а ниједна датотека није направљена или уклоњена. У режиму +списка, програм не може читати запаковане податке са стандардног улаза или +из других нетраживих извора. +.IP "" +Основни списак приказује основне информације о \fIдатотекама\fP, једна датотека +у једном реду. Да добијете подробније информације, користите такође опцију +\fB\-\-verbose\fP. За чак и више информација, користите \fB\-\-verbose\fP два пуа, +али знајте да то може бити споро, јер да би се добиле све додатне +информације потребно је много тражења. Ширина опширног излаза премашује 80 +знакова, тако да преспајање излаза на, на пример, \fBless\ \-S\fP може бити +прикладно ако терминал није довољно широк. +.IP "" +Тачан излаз може варирати између \fBxz\fP издања и различитих језика. За излаз +читљив машинама треба да користите \fB\-\-robot \-\-list\fP. +. +.SS "Измењивачи рада" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Не брише улазне датотеке. +.IP "" +Од \fBxz\fP 5.2.6, ова опција такође чини да \fBxz\fP запакује или распакује чак и +ако је улаз симболичка веза ка обичној датотеци, има више од једне чврсте +везе или има постављен „setuid“, „setgid“ или лепљиви бит. „setuid“, +„setgid“ и лепљиви битови се не умножавају у циљну датотеку. У ранијим +издањима ово се могло урадити само са \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Ова опција има неколико дејстава: +.RS +.IP \(bu 3 +Ако циљна датотека већ постоји, брише је пре запакивања или распакивања. +.IP \(bu 3 +Запакује или распакује чак и ако је улаз симболичка веза ка обичној +датотеци, има више од једне чврсте везе или има постављен „setgid“, „setgid“ +или лепљиви бит. „setgid“, „setgid“ или лепљиви бит се не умножавају у +циљну датотеку. +.IP \(bu 3 +Када се користи са \fB\-\-decompress\fP \fB\-\-stdout\fP и \fBxz\fP не може да препозна +врсту изворне датотеке, умножава изворну датотеку као такву на стандардни +излаз. Ово омогућава да се \fBxzcat\fP \fB\-\-force\fP користи као \fBcat\fP(1) за +датотекекоје нису запаковане са \fBxz\fP. Знајте да ће у будућности, \fBxz\fP +моћи да подржава нове формате запаковане датотеке, који могу учинити да +\fBxz\fP распакује још врста датотека уместо да их умножи какве јесу на +стандардни излаз. \fB\-\-format=\fP\fIформат\fP се може користити да ограничи \fBxz\fP +да распакује само формат једне датотеке. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Пише запаковане или распаковане податке на стандардни излаз уместо у +датотеку, Ово подразумева \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Распакује само први \fB.xz\fP ток, и тихо занемарује могуће преостале улазне +податке који следе ток. Нормално такво пратеће смеће чини да \fBxz\fP прикаже +грешку. +.IP "" +\fBxz\fP никада не распакује више од једног тока из \fB.lzma\fP датотека или +сирових токова, али ова опција чини да \fBxz\fP још увек занемари могуће +пратеће податке након \fB.lzma\fP датотеке или сировог тока. +.IP "" +Ова опција нема дејства ако режим рада није \fB\-\-decompress\fP или \fB\-\-test\fP. +.IP "" +Од \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP подразумева \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Искључује стварање развучених датотека. По основи, ако распакује у обичну +датотеку, \fBxz\fP покушава да учини датотеку развученом ако распаковани подаци +садрже дуге низове бинарних нула. Такође ради приликом писања на стандардни +излаз све док је стандардни излаз повезан са обичном датотеком а одређени +додатни услови су испуњени да је учине безбедном. Стварање развучених +датотека може уштедети простор на диску и убрзати распакивање смањењем +количине У/И диска. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Приликом запакивања, користите \fI.suf\fP као суфикс за циљну датотеку уместо +\&\fB.xz\fP или \fB.lzma\fP. Ако се не пише на стандардни излаз а изворна датотека +већ има суфикс \fI.suf\fP, приказује се упозорење и датотека се прескаче. +.IP "" +Приликом распакивања, препознаје датотеке са суфиксом \fI.suf\fP поред датотека +са суфиксом \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, or \fB.lz\fP. Ако изворна +датотека има суфикс \fI.suf\fP, суфикс се уклања да би се добио назив циљне +датотеке. +.IP "" +Приликом запакивања или распакивања сирових токова (\fB\-\-format=raw\fP), суфикс +мора увек бити наведен осим ако се не пише на стандардни излаз, јер не +постоји основни суфикс за сирове токове. +.TP +\fB\-\-files\fP[\fB=\fP\fIдатотека\fP] +Чита називе датотека за обраду из \fIдатотеке\fP; ако се \fIдатотека\fP изостави, +називи датотека се читају са стандардног улаза. Називи датотека се морају +завршавати знаком новог реда. Цртица (\fB\-\fP) се узима као редован назив +датотеке; а не стандардни улаз. Ако су називи датотека дати такође као +аргументи линије наредби, обрађују се пре него што се називи датотека +прочитају из \fIдатотеке\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIдатотека\fP] +Ово је исто као и \fB\-\-files\fP[\fB=\fP\fIдатотека\fP] изузев тога што сваки назив +датотеке мора да се завршава „null“ знаком. +. +.SS "Основни формат датотеке и опције запакивања" +.TP +\fB\-F\fP \fIформат\fP, \fB\-\-format=\fP\fIформат\fP +Наводи \fIформат\fP датотеке за запакивање или распакивање: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Ово је основно. Приликом запакивања, \fBauto\fP је исто што и \fBxz\fP. Приликом +распакивања, формат улазне датотеке се аутоматски препознаје. Знајте да +сирови токови (направљени са \fB\-\-format=raw\fP) не могу бити аутоматски +препознати. +.TP +\fBxz\fP +Пакује у \fB.xz\fP формат датотеке, или прихвата само \fB.xz\fP датотеке приликом +распакивања. +.TP +\fBlzma\fP, \fBalone\fP +Пакује у стари \fB.lzma\fP формат датотеке, или прихвата само \fB.lzma\fP датотеке +приликом распакивања. Алтернативни назив \fBalone\fP се доставља зарад +повратне сагласности са LZMA помагалима. +.TP +\fBlzip\fP +Прихвата само \fB.lz\fP датотеке приликом распакивања. Запакивање није +подржано. +.IP "" +Формат \fB.lz\fP издања 0 и 1 је подржан. Датотеке издања 0 су настале са +\fBlzip\fP 1.3 и старијим. Такве датотеке нису уобичајене али се могу наћи у +архивама датотека јер је неколико пакета извора издато у овом формату. +Такође можда неко има старе личне датотеке у овом формату. Подршка +распакивања за формат издања 0 је уклоњена у \fBlzip\fP 1.18. \fBlzip\fP 1.4 и +новији ствара датотеке у формату издања 1. +.TP +\fBraw\fP +Запакује или распакује сирови ток (без заглавља). Ово је замишљено само за +напредне кориснике. Да дешифрујете сирове токове, треба да користите +\fB\-\-format=raw\fP и да изричито наведете ланац филтера, што би обично требало +да буде смештено у заглављима контејнера. +.RE +.TP +\fB\-C\fP \fIпровера\fP, \fB\-\-check=\fP\fIпровера\fP +Наводи врсту провере целовитости. Провера се израчунава из незапакованих +података и смештених у \fB.xz\fP датотеци. Ова опција има дејства само +приликом запакивања у \fB.xz\fP формат; \fB.lzma\fP формат не подржава провере +целовитости. Провера целовитости (ако је има) се проверава када је \fB.xz\fP +датотека распакована. +.IP "" +Подржане врсте \fIпровере\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Уопште не израчунава проверу целовитости. Ово је обично лоша идеја. Ово +може бити корисно када се целовитост података ипак проверава на друге +начине. +.TP +\fBcrc32\fP +Израчунава CRC32 користећи полином из IEEE\-802.3 (Етернет). +.TP +\fBcrc64\fP +Израчунава CRC64 користећи полином из ECMA\-182. Ово је основно, јер је +незнатно боље од CRC32 у откривању оштећених датотека а разлика брзине је +занемарљива. +.TP +\fBsha256\fP +Израчунава SHA\-256. Ово је нешто спорије од CRC32 и CRC64. +.RE +.IP "" +Целовитост \fB.xz\fP заглавља се увек проверава са CRC32. Не може се изменити +нити искључити. +.TP +\fB\-\-ignore\-check\fP +Не проверава проверу целовитости запакованих података приликом распакивања. +CRC32 вредности у \fB.xz\fP заглављима биће још увек нормално проверене. +.IP "" +\fBНемојте користити ову опцију осим ако стварно знате шта радите.\fP Могући +разлози за коришћење ове опције: +.RS +.IP \(bu 3 +Покушава да опорави податке из оштећене „.xz“ датотеке. +.IP \(bu 3 +Убрзава распакивање. Ово има значаја углавном са SHA\-256 или са датотекама +које су запаковане стварно добро. Препоручује се да не користите ову опцију +за ову сврху осим ако је целовитост датотеке проверена споља на неки други +начин. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Бира ниво преподешености запакивања. Подразумевано је \fB\-6\fP. Ако је +наведено више нивоа преподешености, последња има дејства. Ако је произвољни +ланац филтера већ наведен, постављање нивоа преподешености запакивања уклања +произвољни ланац филтера. +.IP "" +Разлике између предподешености су још значајније него са \fBgzip\fP(1) и +\fBbzip2\fP(1). Изабране поставке запакивања одређују захтеве меморије +распакивача, стога коришћење превисоког нивоа предподешености може отежати +распакивање датотеле на старом систему са мало RAM\-а. Нарочито, \fBније добра замисао слепо користити \-9 за било шта\fP као што је често са \fBgzip\fP(1) +и \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Ово су некако брзе предподешености. \fB\-0\fP је понекад брже од \fBgzip \-9\fP док +запакује много боље. Оне више често имају брзину упоредиву са \fBbzip2\fP(1) +са упоредивом или бољом стопом запакивања, иако резултати зависе много од +врсте података који се запакују. +.TP +\fB\-4\fP ... \fB\-6\fP +Добро до врло добро запакивање које одржава коришћење меморије распакивача +разумним чак и за старе системе. \fB\-6\fP је основно, што је обично добар +избор за расподелу датотека које треба да могу да се распакују чак и на +системима са само 16\ MiB RAM\-а. (\fB\-5e\fP или \fB\-6e\fP може бити вредно +узимања у обзир. Видите \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Као \fB\-6\fP али са већим захтевима меморије запакивача и распакивача. Корисне +су само приликом запакивања датотека већих од 8\ MiB, 16\ MiB и 32\ MiB. +.RE +.IP "" +На истом хардверу, брзина распакивања је приближно сталан број бајтова +запакованих података у секунди. Другим речима, биће боље запакивање, брже +распакивање. То такође значи да количина незапакованог излаза произведеног +у секунди може много да се разликује. +.IP "" +Следећа табела резимира функције предподешености: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Преподешеност;ВлчРчнка;ЗапакЦПЈ;ЗапакМем;РаспМем +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Описи колона: +.RS +.IP \(bu 3 +ВлчРчнка је величина LZMA2 речника. Коришћење речника већег од величине +незапаковане датотеке је губитак меморије. Зато је добро избегавати +коришћење предподешености \fB\-7\fP ... \fB\-9\fP када за њима нема стварне +потребе. Са \fB\-6\fP и нижим, количина изгубљене меморије је обично довољно +ниска да нема значаја. +.IP \(bu 3 +ЗапакЦПЈ је поједностављено представљање LZMA2 поставки које утичу на брзину +запакивања. Величина речника такође утиче на брзину, тако док је ЗапакЦПЈ +исто за нивое \fB\-6\fP ... \fB\-9\fP, виши нивои још увек теже да буду спорији. Да +добијете још спорије и самим тим можда боље запакивање, видите \fB\-\-extreme\fP. +.IP \(bu 3 +ЗапакМем садржи захтеве меморије запакивача у режиму једне нити. Може +незнатно да се разликује између \fBxz\fP издања. +.IP \(bu 3 +РаспМем садржи захтеве меморије распакивача. Тако је, поставке запакивања +одређују захтеве меморије распакивача. Тачно коришћење меморије распакивача +је незнатно веће од величине LZMA2 речника, али су вредности у табели +заокружене на следећи цео MiB. +.RE +.IP "" +Захтеви меморије режима са више нити су значајно већи него ли режима једне +нити. Са основном вредношћу \fB\-\-block\-size\fP, свакој нити треба 3*3*ВлчРчнка +плус ЗапакМем или РаспМем. На пример, за четири нити са предподешавањем +\fB\-6\fP потребно је 660\(en670\ MiB меморије. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Користите спорију варијанту изабраног нивоа предподешености запакивања +(\fB\-0\fP ... \fB\-9\fP) у нади да ћете добити мало бољу стопу запакивања, али уз +лошу срећу ово је може учинити гором. Не утиче на коришћење меморије +распакивача, али се коришћење меморије запакивача мало повећава на нивоима +предподешености \fB\-0\fP ... \fB\-3\fP. +.IP "" +Како постоје две предподешености са величинама речника од 4\ MiB и 8\ MiB, +предподешености \fB\-3e\fP и \fB\-5e\fP користе незнатно брже поставке (ниже +CompCPU) него \fB\-4e\fP и \fB\-6e\fP. На тај начин нема две истоветне +предподешености. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Преподешеност;ВлчРчнка;ЗапакЦПЈ;ЗапакМем;РаспМем +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +На пример, има укупно четири предподешавања која користе 8\ MiB речник, чији +поредак од најбржег до најспоријег је \fB\-5\fP, \fB\-6\fP, \fB\-5e\fP и \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Ово су помало погрешни алијаси за \fB\-0\fP и \fB\-9\fP. Достављени су само зарад +повратне сагласности са LZMA Utils\-ом. Избегавајте коришћење ових опција. +.TP +\fB\-\-block\-size=\fP\fIвеличина\fP +Приликом запакивања у \fB.xz\fP формат, дели улазне податке на блокове +\fIвеличина\fP бајта. Блокови се запакују независно један од другог, што +помаже у раду са више нити и чини ограничено распакивање насумичног приступа +могућим. Ова опција се обично користи да се препише основна величина блока +у режиму са више нити, али се ова опција може такође користити и у режиму +једне нити. +.IP "" +У режиму више нити око три пута \fIвеличина\fP бајтова биће додељено у свакој +нити за међумеморисање улаза и излаза. Основна \fIвеличина\fP је три пута +величине LZMA2 речника или 1 MiB, шта год да је више. Обично добра вредност +је 2\(en4 пута величина LZMA2 речника или барем 1 MiB. Коришћење +\fIвеличине\fP мање од величине LZMA2 речника је трошење RAM\-а јер тада +међумеморија LZMA2 речника никада неће бити потпуно коришћена. У режиму +више нити, величине блокова се чувају у заглављима блока. Ова информација +величине је потребна за распакивање са више нити. +.IP "" +У режиму једне нити никаква подела блока се не ради по основи. Постављање +ове опције не утиче на коришћење меморије. Никакве информације о величини +се не чувају у заглављима блока, стога датотеке направљене у режиму једне +нити неће бити исте као датотеке направљене у режиму више нити. Недостатак +информација о величини такође значи да \fBxz\fP неће моћи да распакује датотеке +у режиму више нити. +.TP +\fB\-\-block\-list=\fP\fIставке\fP +Приликом запакивања у \fB.xz\fP формат, почиње нови блок са изборним +произвољним ланцем филтера након датих интервала незапакованих података. +.IP "" +\fIСтавке\fP су списак одвојен зарезом. Свака ставка се састоји од изборног +броја ланца филтера између 0 и 9 за којим следи двотачка (\fB:\fP) и захтевана +величина незапакованих података . Изостављање неке ставке (два или више +узастопна зареза) је пречица за коришћење величине и филтера претходне +ставке. +.IP "" +Ако је улазна датотека већа од збира величина у \fIставкама\fP, последња ставка +се понавља све до краја датотеке. Специјална вредност \fB0\fP може се +користити као последња величина да назначи да остатак датотеке треба да буде +шифрован као један блок. +.IP "" +Алтернативни ланац филтера за сваки блок се може навести у комбинацији са +опцијама \fB\-\-filters1=\fP\fIфилтера\fP \&...\& \fB\-\-filters9=\fP\fIфилтери\fP. Ове +опције дефинишу ланце филтера са одредником између 1\(en9. Ланац филтера 0 +се може користити да упућује на основно ланац филтера, који је исти јер се +ланац филтера не наводи. Одредник ланца филтера се може користити пре +незапаковане величине, за којим следи двотачка (\fB:\fP). На пример, ако +наведемо \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP тада ће се за +прављење блокова користити: +.RS +.IP \(bu 3 +Ланац филтера наведен са \fB\-\-filters1\fP и 2 MiB улазом +.IP \(bu 3 +Ланац филтера наведен са \fB\-\-filters3\fP и 2 MiB улазом +.IP \(bu 3 +Ланац филтера наведен са \fB\-\-filters2\fP и 4 MiB улазом +.IP \(bu 3 +Ланац филтера наведен са \fB\-\-filters2\fP и 4 MiB улазом +.IP \(bu 3 +Основни ланац филтера и 2 MiB улаз +.IP \(bu 3 +Основни ланац филтера и 4 MiB улаз за сваки блок до краја улаза. +.RE +.IP "" +Ако наведемо величину која премашује величину блока шифрера (било основну +вредност у режиму нити или вредност наведену са +\fB\-\-block\-size=\fP\fIвеличина\fP), шифрер ће направити додатне блокове док ће +задржати границе наведене у \fIставкама\fP. На пример, ако наведемо +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP а улазна +датотека је 80 MiB, добићемо 11 блокова: 5, 10, 8, 10, 2, 10, 10, 4, 10, 10 +и 1 MiB. +.IP "" +У режиму са више нити величине блокова се чувају у заглављима блока. Ово се +не ради у режиму једне нити, тако да шифровани излаз неће бити истоветан +ономе у режиму са више нити. +.TP +\fB\-\-flush\-timeout=\fP\fIистек_времена\fP +Приликом запакивања, ако је више од \fIвреме_истека\fP милисекунди (позитиван +цео број) прошло од претходног испирања и читање више улаза ће блокирати, +сви заказани улазни подаци се испирају из шифрера и чине доступним у +излазном току. Ово може бити корисно ако је \fBxz\fP коришћен за запакивање +података који су слати преко мреже. Мала вредност \fIвременског_истека\fP чини +податке доступним на пријемни крај са малим закашњењем, али велика вредност +\fIвремена_истека\fP даје бољу стопу запакивања. +.IP "" +Ова функција је искључена по основи. Ако је ова опција наведена више пута, +последња има дејства. Нарочита вредност \fIвременског истека\fP \fB0\fP може се +користити за изричито искључивање ове функције. +.IP "" +Ова функција је доступна само на POSIX системима. +.IP "" +.\" FIXME +\fBОва функција је још увек експериментална.\fP Тренутно \fBxz\fP није погодан за +распакивање тока у реалном времену због начина на који \fBxz\fP ради +међумеморисање. +.TP +\fB\-\-no\-sync\fP +Не усклађује циљну датотеку и њену фасциклу на смештајном уређају пре +уклањања изворне датотеке. Ово може побољшати учинковитост ако се запакује +или распакује много малих датотека. Међутим, ако се систем уруши одмах +након брисања, може бити да циљна датотека не буде уписана на смештајном +уређају али радња брисања јесте. У том случају неће бити доступна ни +оригинална изворна ни циљна датотека. +.IP "" +Ова опција има дејство само када се \fBxz\fP спрема да уклони изворну +датотеку. У осталим случајевима усклађивање се не ради никада. +.IP "" +Синхронизација и \fB\-\-no\-sync\fP су додате у \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIограничење\fP +Поставља ограничење коришћења меморије запакивања. Ако је ова опција +наведена више пута, последња ступа у дејство. +.IP "" +Ако поставке запакивања премаше \fIограничење\fP, \fBxz\fP ће покушати да врати +назад поставке тако да ограничење више није прекорачено и приказаће +обавештење да је урађено аутоматско дотеривање. Дотеривања се раде следећим +редом: смањење броја нити, пребацивање на режим једне нити ако чак и једна +нит у режиму више нити премаши \fIограничење\fP и на крају смањење величине +LZMA2 речника. +.IP "" +Приликом запакивања са \fB\-\-format=raw\fP или ако је наведено \fB\-\-no\-adjust\fP, +само број нити може бити умањен јер може да се уради а да се не делује на +излаз запакованог. +.IP "" +Ако \fIограничење\fP не може бити задовољено чак и са поравнањима описаним +изнад, приказује се грешка и \fBxz\fP ће изаћи са излазним стањем 1. +.IP "" +\fIОграничење\fP се може навести на више начина: +.RS +.IP \(bu 3 +\fIОграничење\fP може бити апсолутна величина у бајтима. Коришћење суфикса +целог броја као \fBMiB\fP може бити корисно. Пример: +\fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +\fIОграничење\fP се може навести као проценат укупне физичке меморије (RAM). +Ово може бити корисно нарочито приликом постављања променљиве окружења +\fBXZ_DEFAULTS\fP у скрпти покретања конзоле која се дели између различитих +рачунара. На тај начин ограничење је аутоматски веће на системима са више +меморије. Пример: \fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +\fIОграничење\fP се може вратити на своју основну вредност његовим постављањем +на \fB0\fP. Ово је тренутно исто што и постављање \fIограничења\fP на \fBmax\fP (без +ограничења коришћења меморије). +.RE +.IP "" +За \fBxz\fP 32\-бита имамо посебан случај: ако \fIограничење\fP треба да буде преко +\fB4020\ MiB\fP, \fIограничење\fP се поставља на \fB4020\ MiB\fP. Али на MIPS32 +користи се \fB2000\ MiB\fP. (На вредности \fB0\fP и \fBmax\fP ово не утиче. Слична +функција не постоји за распакивање.) Ово може бити од помоћи када извршна +од 32\-бита има приступ адресном простору од 4\ GiB (2 GiB на MIPS32) док +срећом не чини ништа лоше у осталим приликама. +.IP "" +Видите такође одељак \fBКоришћење меморије\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIограничење\fP +Поставља ограничење коришћења меморије за распакивање. Ово такође утиче на +\fB\-\-list\fP режим. Ако радња није могућа а да се не премаши \fIограничење\fP, +\fBxz\fP ће приказати грешку а распакивање датотеке неће успети. Видите +\fB\-\-memlimit\-compress=\fP\fIограничење\fP за могуће начине о навођењу +\fIограничења\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIограничење\fP +Поставља ограничење коришћења меморије за распакивање са више нити. Ово +може утицати само на број нити; ово никада неће учинити да \fBxz\fP одбије да +распакује датотеке. Ако је \fIограничење\fP превише ниско да омогући било који +рад са више нити, \fIограничење\fP се занемарује а \fBxz\fP ће наставити у режиму +једне нити. Знајте да ако се такође користи \fB\-\-memlimit\-decompress\fP, увек +ће се применити и на режим једне и на режим више нити, и тако да стварно +\fIограничење\fP за више нити никада неће бити више од ограничења постављеног +са \fB\-\-memlimit\-decompress\fP. +.IP "" +У супротности са другим опцијама ограничења коришћења меморије, +\fB\-\-memlimit\-mt\-decompress=\fP\fIограничење\fP има систему специфично основно +\fIограничење\fP. \fBxz \-\-info\-memory\fP се може користити да видите тренутну +вредност. +.IP "" +Ова опција и њена основна вредност постоје јер без икаквог ограничења нитни +распакивач ће завршити са додељивањем неразумног износа меморије са неким +улазним датотекама. Ако је основно \fIограничење\fP превише ниско на вашем +систему, слободно повећајте \fIограничење\fP али га никада не постављајте на +вредност већу од износа употребљивог RAM\-а јер са одговарајућим улазним +датотекама \fBxz\fP ће покушати да користи тај износ меморије чак и са малим +бројем нити. Остајући без меморије или разменом неће се побољшати +учинковитост распакивања. +.IP "" +Видите \fB\-\-memlimit\-compress=\fP\fIограничење\fP за могуће начине за навођење +\fIограничења\fP. Постављање \fIограничења\fP на \fB0\fP враћа \fIограничење\fP на +систему специфичну основну вредност. +.TP +\fB\-M\fP \fIограничење\fP, \fB\-\-memlimit=\fP\fIограничење\fP, \fB\-\-memory=\fP\fIограничење\fP +Ово је исто као и навођење \fB\-\-memlimit\-compress=\fP\fIограничење\fP +\fB\-\-memlimit\-decompress=\fP\fIограничење\fP +\fB\-\-memlimit\-mt\-decompress=\fP\fIограничење\fP. +.TP +\fB\-\-no\-adjust\fP +Приказује грешку и излази ако ограничење коришћења меморије не може бити +задовољено без дотеривања поставки које утичу на запаковани излаз. Тако је, +ово спречава \fBxz\fP да промени шифрера из режима више нити у режим једне нити +и да смањи величину LZMA2 речника. Чак и када се ова опција користи број +нити се може смањити да задовољи ограничење коришћења меморије јер то неће +утицати на запаковани излаз. +.IP "" +Аутоматско дотеривање је увек искључено приликом стварања сирових токова +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fIнити\fP, \fB\-\-threads=\fP\fIнити\fP +Наводи број нити радника за коришћење. Постављање \fIнити\fP на посебну +вредност \fB0\fP чини да \fBxz\fP користи онолико нити колико процесор на систему +подржава. Стварни број нити може бити мањи од \fIнити\fP ако улазна датотека +није довољно велика за нитисање са датим поставкама или ако ће коришћење +више нити премашити ограничење коришћења меморије. +.IP "" +Запакивачи једне нити и више нити дају различите излазе. запакивач једне +нити даће мању величину датотеке али само излаз из запакивача више нити може +бити распакован коришћењем више нити. Постављање \fIнити\fP на \fB1\fP користиће +режим једне нити. Постављање \fIнити\fP на неку другу вредност, укључујући +\fB0\fP, користиће запакивач више нити чак и ако систем подржава само једну нит +хардвера. (\fBxz\fP 5.2.x је користио режим једне нити у овој прилици.) +.IP "" +Да користите вишенитни режим са само једном нити, поставите \fIнити\fP на +\fB+1\fP. Префикс \fB+\fP нема дејства са вредностима које нису \fB1\fP. Ограничење +коришћења меморије може још увек учинити да се \fBxz\fP пребаци на режим једне +нити осим ако се не користи \fB\-\-no\-adjust\fP. Подршка за префикс \fB+\fP је +додата у \fBxz\fP 5.4.0. +.IP "" +Ако је затражен аутоматски број нити и није наведено ограничење коришћења +меморије, тада ће се користити основно меко ограничење специфично за систем +за могуће ограничење броја нити. То је меко ограничење у смислу да се +занемарује ако број нити постане један, дакле меко ограничење никада неће +зауставити \fBxz\fP од запакивања или распакивања. Ово основно меко ограничење +неће учинити да се \fBxz\fP пребаци из режима више нити у режим једне нити. +Активно ограничење се може видети са + \fBxz \-\-info\-memory\fP. +.IP "" +Тренутно једина метода нитисања је да се подели улаз на блокове и да се +запакују независно један од другог. Основна величина блока зависи од нивоа +запакивања и може се преписати опцијом \fB\-\-block\-size=\fP\fIвеличина\fP. +.IP "" +Нитно распакивање ради само на датотекама које садрже више блокова са +информацијом величине у заглављима блока. Све довољно велике датотеке +запаковане у вишенитном режиму задовољавају овај услов, али датотеке +запаковане у једнонитном режиму не чак и ако је коришћено +\fB\-\-block\-size=\fP\fIвеличина\fP. +.IP "" +Основна вредност за \fIнити\fP је \fB0\fP. У \fBxz\fP 5.4.x и старијим основно је +\fB1\fP. +. +.SS "Произвољни ланци филтера запакивача" +Произвољни ланац филтера омогућава детаљно одређивање подешавања сажимања +уместо да се ослања на подешавања повезана са предподешавањима. Када је +произвољни ланац филтера наведен, опције предподешавања (\fB\-0\fP \&...\& \fB\-9\fP +и \fB\-extreme\fP) раније на линији наредби се заборављају. Ако је опција +предподешавања наведена након једне или више опција произвољног ланца +филтера, ново предподешавање ступа на снагу а раније наведене опције +произвољног ланца филтера се заборављају. +.PP +Ланац филтера је упоредив са спојкама на линији наредби. Приликом сажимања, +несажети улаз иде на први филтер, чији излаз иде на следећи филтер (ако фа +има). Излаз последњег филтера бива записан у сажету датотеку. Највећи број +филтера у ланцу је четири, али обично ланац филтера има само један или два +филтера. +.PP +Многи филтери имају ограничења о томе где могу бити у ланцу филтера: неки +филтери могу радити само као последњи филтер у ланцу, неки само као +не\-последњи филтер, а неки раде на било ком месту у ланцу. Овисно о +филтеру, ово ограничење је или својствено дизајну филтера или постоји како +би се спречили проблеми безбедности. +.PP +Произвољни ланац филтера се може навести на два различита начина. Опције +\fB\-\-filters=\fP\fIфилтери\fP и \fB\-\-filters1=\fP\fIфилтери\fP \&...\& +\fB\-\-filters9=\fP\fIфилтери\fP омогућавају навођење читавог ланца опција у једној +опцији коришћењем синтаксу ниске „liblzma“ филтера. Другачије, ланац +филтера се може навести коришћењем једне или више појединачних опција +филтера редом како се траже у ланцу филтера. То је то, редослед +појединачних опција филтера је важан! Приликом дешифровања сирових токова +(\fB\-\-format=raw\fP), ланац филтера мора бити наведен истим редом као када је +био наведен приликом сажимања. Било који појединачни филтер или опције +предподешавања наведене пре опције читавог ланца (\fB\-\-filters=\fP\fIфилтери\fP) +биће заборављене. Појединачни филтери наведени после опције читавог ланца +ће поништити поставку ланца филтера. +.PP +Обе опције и пуног и појединачног филтера узимају филтеру специфичне +\fIопције\fP као зарезом раздвојен списак. Додатни зарези у \fIопцијама\fP се +занемарују. Свака опција има основну вредност, тако да треба да наведете +оне које желите да измените. +.PP +Да видите читав ланац филтера и \fIопције\fP, користите \fBxz \-vv\fP (тако је, +користите \fB\-\-verbose\fP два пута). Ово ради такође за преглед опција ланца +филтера коришћених од стране предподешености. +.TP +\fB\-\-filters=\fP\fIфилтери\fP +Наводи цео ланац филтера или предподешеност у једној опцији. Сваки филтер +се може одвојити размацима или са две цртице (\fB\-\-\fP). \fIФилтери\fP можда +треба да буду под наводницима на линији наредби конзоле тако да се +прослеђују као једна опција. Да означите \fIопције\fP, користите \fB:\fP или +\fB=\fP. Предподешености се може додати префикс \fB\-\fP и може га пратити нула +или још заставица. Једина подржана заставица је \fBe\fP за примену истих +опција као \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIфилтери\fP ... \fB\-\-filters9\fP=\fIфилтери\fP +Наводи до девет додатних ланаца филтера који се могу користити са +\fB\-\-block\-list\fP. +.IP "" +На пример, приликом запакивања архиве са извршним датотекама за којима следе +текстуалне датотеке, извршни део треба да користи ланац филтера са BCJ +филтером а текстуални део само LZMA2 филтер. +.TP +\fB\-\-filters\-help\fP +Приказује поруку помоћи описујући како се наводе предподешавања и произвољни +ланци филтера у опцијама \fB\-\-filters\fP и \fB\-\-filters1=\fP\fIфилтери\fP \&...\& +\fB\-\-filters9=\fP\fIфилтери\fP, и успешно излази. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIопције\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIопције\fP] +.PD +Додаје LZMA1 или LZMA2 филтер у ланац филтера. Ови филтери се могу +користити само као последњи филтер у ланцу. +.IP "" +LZMA1 је стари филтер, који је подржан углавном само због старог формата +\&\fB.lzma\fP датотеке, који подржава само LZMA1. LZMA2 је освежено издање LZMA1 +које поправља неке практичне проблеме LZMA1. \fB.xz\fP формат користи LZMA2 и +не подржава LZMA1 уопште. Брзина запакивања и односи LZMA1 и LZMA2 су +практично исти. +.IP "" +LZMA1 и LZMA2 деле исти скуп \fIопција\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIпредподешавање\fP +Враћа све LZMA1 или LZMA2 \fIопције\fP на \fIпредподешеност\fP. \fIПредпдешеност\fP +се састоји од целог броја, за којим може да следи једнословни измењивач +предподешености. Цео број може бити од \fB0\fP до \fB9\fP, поклапајући опције +линије наредби \fB\-0\fP \&...\& \fB\-9\fP. Једини тренутно подржани измењивач је +\fBe\fP, који се поклапа са \fB\-\-extreme\fP. Ако \fBpreset\fP није наведено, основне +вредности LZMA1 или LZMA2 \fIопција\fP се узимају из предподешености \fB6\fP. +.TP +\fBdict=\fP\fIвеличина\fP +\fIВеличина\fP речника (међумеморија историјата) указује на то колико је +бајтова недавно обрађених нераспакованих података задржано у меморији. +Алгоритам покушава да нађе понављајуће низове бајтова (поклапања) у +нераспакованим подацима, и да их замени са упутама ка подацима који су +тренутно у речнику. Што је већи речник, већа је вероватноћа за налажење +поклапања. Стога, повећање \fIвеличине \fP речника обично побољшава стопу +запакивања, али речник већи од незапаковане датотеке јесте утрошак меморије. +.IP "" +Уобичајена \fIвеличина\fP речника је од 64\ KiB до 64\ MiB. Најмање је 4\ KiB. Највише за запакивање тренутно је 1.5\ GiB (1536\ MiB). Распакивач +већ подржава речнике до једног бајта мање од 4\ GiB, што је максимум за +формате LZMA1 и LZMA2 тока. +.IP "" +\fIВеличина\fP речника и налазач поклапања (\fImf\fP) заједно одређују коришћење +меморије за LZMA1 или LZMA2 шифрере. Иста (или већа) \fIвеличина\fP речника је +потребна за распакивање као она која је коришћена за запаквање, стога се +коришћење меморије дешифрера одређује према величини речника коришћеног за +запакивање. \fB.xz\fP заглавља чувају \fIвеличину\fP речника или као 2^\fIn\fP или +2^\fIn\fP + 2^(\fIn\fP\-1), тако да су те \fIвеличине\fP некако пожељније за +запакивање. Друге \fIвеличине\fP биће заокружене приликом чувања у \fB.xz\fP +заглављима. +.TP +\fBlc=\fP\fIlc\fP +Наводи број битова контекста литерала. Најмање је 0 а највише је 4; основно +је 3. Као додатак, збир \fIlc\fP и \fIlp\fP не сме да премаши 4. +.IP "" +Сви бајтови који се не могу шифровати јер су поклапања шифрована као +литерали. То је то, литерали су једноставно 8\-битни бајтови који су +шифровани један по један. +.IP "" +Кодирање литерала врши претпоставку да највећи \fIlc\fP битови претходног +незапакованог бајта су у узајамној вези са следећим бајтом. На пример, у +уобичајеном енглеском тексту, за великим словом често следи мало слово, а за +малим словом обично следи још једно мало слово. У скупу US\-ASCII знакова, +највиша три бита су 010 за велика слова и 011 за мала слова. Када је \fIlc\fP +барем 3, кодирање литерала може имати предност овог својства у незапакованим +подацима. +.IP "" +Основна вредност (3) је обично добра. Ако желите највеће запакивање, +испробајте \fBlc=4\fP. Некад то мало помогне а некад чини запакивање горим. +Ако га учини горим, испробајте такође \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Наводи број битова положаја литерала. Најмање је 0 а највише је 4; основно +је 0. +.IP "" +\fILp\fP утиче на то која врста поравнања у незапакованим подацима се +подразумева приликом шифровања литерала. Видите \fIpb\fP испод за више +информација о поравнању. +.TP +\fBpb=\fP\fIpb\fP +Наводи број битова положаја. Најмање је 0 а највише је 4; основно је 2. +.IP "" +\fIPb\fP утиче на то која врста поравнања у незапакованим подацима се +подразумева у опште. Основно значи четворобајтно поравнање (2^\fIpb\fP=2^2=4), +што је често добар избор када нема бољег решења. +.IP "" +Када је поравнање познато, постављање одговарајућег \fIpb\fP може мало да смањи +величину датотеке. На пример, са датотекама текста које имају поравнање +једног бајта (US\-ASCII, ISO\-8859\-*, UTF\-8), постављање \fBpb=0\fP може незнатно +да побољша запакивање. За UTF\-16 текст, \fBpb=1\fP је добар избор. Ако је +поравнање непаран број као 3 бајта, \fBpb=0\fP може бити најбољи избор. +.IP "" +Иако се претпостављено поравнање може подесити са \fIpb\fP и \fIlp\fP, LZMA1 и +LZMA2 и даље незнатно фаворизују 16\-бајтно поравнање. То би могло бити +вредно узети у обзир приликом дизајнирања формата датотека које ће вероватно +бити често запаковане са LZMA1 или LZMA2. +.TP +\fBmf=\fP\fImf\fP +Налазач поклапања има главни утицај на брзину шифрера, коришћење меморије и +стопу запакивања. Обично Hash Chain налазачи поклапања су бржи од Binary +Tree налазача поклапања. Основност зависи од \fIпредподешености\fP: 0 користи +\fBhc3\fP, 1\(en3 користи \fBhc4\fP, а остало користи \fBbt4\fP. +.IP "" +Следећи налазачи поклапања су подржани. Формуле коришћења меморије испод су +грубе апроксимације које су ближе стварности када је \fIречник\fP степен +двојке. +.RS +.TP +\fBhc3\fP +Ланац хеша са хеширањем 2\- и 3\-бајта +.br +Најмања вредност за \fIфино\fP: 3 +.br +Коришћење меморије: +.br +\fIречник\fP * 7.5 (ако је \fIречник\fP <= 16 MiB); +.br +\fIречник\fP * 5.5 + 64 MiB (if \fIречник\fP > 16 MiB) +.TP +\fBhc4\fP +Ланац хеша са хеширањем 2\-, 3\- и 4\-бајта +.br +Најмања вредност за \fIфино\fP: 4 +.br +Коришћење меморије: +.br +\fIречник\fP * 7.5 (ако је \fIречник\fP <= 32 MiB); +.br +\fIречник\fP * 6.5 (ако је \fIречник\fP > 32 MiB) +.TP +\fBbt2\fP +Бинарно стабло са 2\-бајта хеширања +.br +Најмања вредност за \fIфино\fP: 2 +.br +Коришћење меморије: \fIречник\fP * 9.5 +.TP +\fBbt3\fP +Бинарно стабло са 2\- и 3\-бајта хеширања +.br +Најмања вредност за \fIфино\fP: 3 +.br +Коришћење меморије: +.br +\fIречник\fP * 11.5 (if \fIречник\fP <= 16 MiB); +.br +\fIречник\fP * 9.5 + 64 MiB (ако је \fIречник\fP > 16 MiB) +.TP +\fBbt4\fP +Бинарно стабло са 2\-, 3\-, и 4\-бајта хеширања +.br +Најмања вредност за \fIфино\fP: 4 +.br +Коришћење меморије: +.br +\fIречник\fP * 11.5 (if \fIречник\fP <= 32 MiB); +.br +\fIречник\fP * 10.5 (if \fIречник\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fIрежим\fP +\fIРежим\fP запакивања наводи методу за анализу података које произведе налазач +поклапања. Подржани \fIрежими\fP су \fBfast\fP и \fBnormal\fP. Подразумева се +\fBfast\fP за \fIпредподешавања\fP 0\(en3 и \fBnormal\fP за \fIпредподешавања\fP 4\(en9. +.IP "" +Обично се \fBfast\fP користи са налазачима Hash Chain поклапања а \fBnormal\fP са +налазачима Binary Tree поклапања. Ово је исто што раде и +\fIпредподешености\fP. +.TP +\fBnice=\fP\fIфино\fP +Наводи оно што се сматра да је фина дужина за поклапање. Када се поклапање +од барем \fInice\fP бајтова нађе, алгоритам зауставља тражење могућих бољих +поклапања. +.IP "" +\fIФино\fP може бити 2\(en273 бајта. Веће вредности теже да дају бољу стопу +запакивања на уштрб брзине. Основно зависи од \fIпредподешавања\fP. +.TP +\fBdepth=\fP\fIдубина\fP +Наводи највећу дубину претраге у налазачу поклапања. Основно је посебна +вредност 0, која чини да запакивач одреди разумљиву \fIдубину\fP из \fImf\fP и +\fInice\fP. +.IP "" +Разумљива \fIдубина\fP за ланце хеша је 4\(en100 и 16\(en1000 за стабло +извршних. Коришћење врло великих вредности за \fIдубину\fP може учинити шифрер +врло спорим са неким датотекама. Избегавајте постављање \fIдубине\fP преко +1000 осим ако нисте спремни да прекинете запакивање у случају да потраје +превише дуго. +.RE +.IP "" +Приликом дешифровања сирових токова (\fB\-\-format=raw\fP), LZMA2 треба само +\fIвеличина\fP речника. LZMA1 треба такође \fIlc\fP, \fIlp\fP и \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIопције\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIопције\fP] +.PD +Додаје „branch/call/jump“ (BCJ) филтер ланцу филтера. Ови филтери могу се +користити само ако нису последњи филтер у ланцу филтера. +.IP "" +BCJ филтер претвара релативне адресе у машинском коду на њихове апсолутне +двојнике. Ово не мења величину података, али повећава сувишност, што може +помоћи LZMA2 да произведе 0\(en15\% мању \fB.xz\fP датотеку. BCJ филтери су +увек реверзибилни, стога коришћење BCJ филтера за погрешну врсту података не +доводи ни до каквог губитка података, мада може да учини степен сажимања +нешто лошијим. BCJ филтери су врло брзи и користе безначајну количину +меморије. +.IP "" +Ови BCJ филтери имају познате проблеме везане за стопу запакивања: +.RS +.IP \(bu 3 +Неке врсте датотека које садрже извршни код (на пример, објектне датотеке, +статичке библиотеке и модули Линукс кернела) имају адресе у упутствима +испуњеним вредностима попуњавача. Ови BCJ филтери и даље ће радити +претварање адресе, што ће запакивање учинити горим са овим датотекама. +.IP \(bu 3 +Ако се BCJ филтер примени на архиву, могуће је да ће учинити стопу +запакивања лошијим него кад се не би користио. На пример, ако постоје +сличне или чак истоветне извршне тада ће филтрирање вероватно учинити +датотеке мање сличним и стога је запакивање лошије. Садржај не\-извршних +датотека у истој архиви је такође важан. У пракси се мора покушати са и без +BCJ филтера да би се видело шта је боље у којој прилици. +.RE +.IP "" +Различити скупови упутстава имају различита поравнања: извршна датотека мора +бити поравната на множилац ове вредности у улазним подацима како би филтер +радио. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Филтер;Поравнање;Напомене +x86;1;32\-бита или 64\-бита x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096\-бита поравнање је најбоље +PowerPC;4;Само велика крајност +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Како су BCJ\-филтрирани подаци обично запаковани са LZMA2, стопа запакивања +може бити незнатно побољшана ако су LZMA2 опције постављене да поклопе +поравнање изабраног BCJ филтера. Примери: +.RS +.IP \(bu 3 +IA\-64 филтер има поравнање 16\-бајта тако да је \fBpb=4,lp=4,lc=0\fP добро са +LZMA2 (2^4=16). +.IP \(bu 3 +RISC\-V код има поравнање од 2 или 4 бајта у зависности од тога да ли +датотека садржи запаковане инструкције од 16 бита (проширење C). Када се +користе инструкције од 16 бита, \fBpb=2,lp=1,lc=3\fP или \fBpb=1,lp=1,lc=3\fP је +добро. Када нема инструкција од 16 бита, \fBpb=2,lp=2,lc=2\fP је најбоље. +\fBreadelf \-h\fP се може користити да се провери да ли се „RVC“ јавља у реду +„Заставице“. +.IP \(bu 3 +ARM64 је увек 4\-бајта поравнат тако да је \fBpb=2,lp=2,lc=2\fP најбоље. +.IP \(bu 3 +Филтер x86 је изузетак. Обично је добро придржавати се LZMA2 основности +(\fBpb=2,lp=0,lc=3\fP) приликом запакивања x86 извршних. +.RE +.IP "" +Сви BCJ филтери подржавају исте \fIопције\fP: +.RS +.TP +\fBstart=\fP\fIпомерај\fP +Наводи \fIпомерај\fP почетка који се користи приликом претварања између +релативних и апсолутних адреса. \fIПомерај\fP мора бити производ поравнања +филтера (видите табелу изнад). Основно је нула. У пракси, основност је +добра; навођење произвољног \fIпомераја\fP скоро никада није од користи. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIопције\fP] +Додаје Delta филтер у ланац филтера. Делта филтер може се користити само +ако није последњи филтер у ланцу филтера. +.IP "" +Тренутно је подржан само једноставан делта прорачун једног по једног бита. +Може бити користан приликом запакивања, на пример, незапакованих битмап +слика или незапакованог PCM звука. Међутим, алгоритми посебне намене могу +дати знатно боље резултате него Delta + LZMA2. Ово је тачно, посебно са +звуком, који се запакује брже и боље, на пример, са \fBflac\fP(1). +.IP "" +Подржане \fIопције\fP: +.RS +.TP +\fBdist=\fP\fIрастојање\fP +Наводи \fIрастојање\fP делта прорачуна у бајтима. \fIРастојање\fP мора бити +1\(en256. Основно је 1. +.IP "" +На пример, са \fBdist=2\fP и осмобајтним улазом A1 B1 A2 B3 A3 B5 A4 B7, излаз +ће бити A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Остале опције" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Потискује упозорења и обавештења. Наведите ово два пута да потиснете и +грешке. Ова опција нема утицаја на стање излаза. Тако је, чак и ако је +упозорење потиснуто, стање излаза које указује на упозорење се и даље +користи. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Бива опширан. Ако је стандардна грешка повезана са терминалом, \fBxz\fP ће +приказати указивач напретка. Навођењем \fB\-\-verbose\fP два пута добија се још +опширнији излаз. +.IP "" +Указивач напредовања показује следеће информације: +.RS +.IP \(bu 3 +Проценат довршености се показује ако је величина улазне датотеке позната. +Тако је, проценат се не може приказати у спојкама. +.IP \(bu 3 +Количина запакованих података проистеклих (запакивање) или утрошених +(распакивање). +.IP \(bu 3 +Количина распакованих података утрошених (запакивање) или проистеклих +(распакивање). +.IP \(bu 3 +Размера паковања, која се израчунава дељењем количине запакованих података +обрађених до сада количином незапакованих података до сада обрађених. +.IP \(bu 3 +Брзина запакивања или распакивања. Ово се мери као количина незапакованих +података утрошених (запакивање) или добијених (распакивање) у секунди. +Приказује се након неколико секунде након што \fBxz\fP започне обраду датотеке. +.IP \(bu 3 +Протекло време у формату М:СС или Ч:ММ:СС. +.IP \(bu 3 +Процењено преостало време се приказује само када је величина улазне датотеке +позната и неколико секунди је већ протекло од кад је \fBxz\fP започео обраду +датотеке. Време се приказује у мање тачном формату које никада нема +двотачке, на пример, 2 мин 30 сек. +.RE +.IP "" +Када стандардна грешка није терминал, \fB\-\-verbose\fP ће учинити да \fBxz\fP +испише назив датотеке, запаковану величину, незапаковану величину, стопу +запакивања и по могућству такође брзину и протекло време на једном реду на +стандардну грешку након запакивања или распакивања датотеке. Брзина и +протекло време су укључени само када радња потраје барем неколико секунде. +Ако се радња не заврши, на пример, услед што корисник прекине, такође се +исписује проценат завршености ако је величина улазне датотеке позната. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Не поставља стање излаза на 2 чак и ако је услов вредан упозорења откривен. +Ова опција не утиче на ниво опширности, стога и \fB\-\-quiet\fP и \fB\-\-no\-warn\fP +треба да се користе да се не приказују упозорења и да се не измени стање +излаза. +.TP +\fB\-\-robot\fP +Исписује поруке у формату обрадивом машинама. Ово је замишљено да олакша +писање челника који желе да користе \fBxz\fP уместо „liblzma“, што може бити +случај са разним скриптама. Излаз са овом опцијом укљученом је замишљен да +буде стабилан кроз \fBxz\fP издања. Видите одељак \fBРЕЖИМ РОБОТА\fP за више о +томе. +.TP +\fB\-\-info\-memory\fP +Приказује, у формату читљивом људима, колико физичке меморије (RAM) и колико +нити процесора \fBxz\fP мисли да систем има и ограничења коришћења меморије за +запакивање и распакивање и излази успешно. +.TP +\fB\-h\fP, \fB\-\-help\fP +Приказује поруку помоћи описујући најчешће коришћених опција, и успешно +излази. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Приказује поруку помоћи описујући све функције \fBxz\fP, и успешно излази +.TP +\fB\-V\fP, \fB\-\-version\fP +Приказује број издања за \fBxz\fP и „liblzma“ у формату читљивом људима. Да +добијете излаз машинама обрадив, наведите \fB\-\-robot\fP пре \fB\-\-version\fP. +. +.SH "РЕЖИМ РОБОТА" +Режим робота се покреће опцијом \fB\-\-robot\fP. Чини да излаз \fBxz\fP буде лакши +за обраду другим програмима. Тренутно \fB\-\-robot\fP је подржано само заједно +са \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, и \fB\-\-version\fP. Биће +подржан за запакивање и распакивање у будућности. +. +.SS "Режим списка" +\fBxz \-\-robot \-\-list\fP користи излаз раздвојен табулатором. Прва колона +сваког реда садржи ниску која указује на врсту информације која се налази у +том реду: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP (назив) +Ово је увек први ред приликом почетка листања датотеке. Друга колона у реду +је назив датотеке. +.TP +\fBfile\fP (датотека) +Овај ред садржи свеукупне информације о \fB.xz\fP датотеци. Овај ред се увек +исписује после реда \fBназив\fP. +.TP +\fBstream\fP (ток) +Ова врста реда се користи само када је \fB\-\-verbose\fP наведено. Има толико +редова \fBтока\fP колико има токова у \fB.xz\fP даатотеци. +.TP +\fBblock\fP (блок) +Ова врста реда се користи само када је \fB\-\-verbose\fP наведено. Има онолико +редова \fBблока\fP колико има блокова у \fB.xz\fP датотеци. Редови \fBблока\fP се +приказују након свих редова \fBтока\fP; различите врсте реда се не преплићу. +.TP +\fBsummary\fP (сажетак) +Ова врста реда се користи само када је \fB\-\-verbose\fP наведено два пута. Овај +ред се исписује након свих редова \fBблока\fP. Као ред \fBдатотека\fP, ред +\fBсажетка\fP садржи преглед информација о \fB.xz\fP датотеци. +.TP +\fBtotals\fP (укупност) +Овај ред је увек последњи ред на списку излаза. Показује укупне збирове и +величине. +.PP +Колоне редова \fBдатотеке\fP: +.PD 0 +.RS +.IP 2. 4 +Број токова у датотеци +.IP 3. 4 +Укупан број блокова у току(овима) +.IP 4. 4 +Величина запаковане датотеке +.IP 5. 4 +Величина незапаковане датотеке +.IP 6. 4 +Размера паковања, на пример, \fB0.123\fP. Ако је размера преко 9.999, три +цртице (\fB\-\-\-\fP) се приказују уместо размере. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Зарезом раздвојен списак назива провера целовитости. Следеће ниске се +користе за познате врсте провера: \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP и \fBSHA\-256\fP. +За непознате врсте провера, користи се \fBUnknown\-\fP\fIN\fP, где је \fIN\fP ИД +провере као децимални број (једна или две цифре). +.IP 8. 4 +Укупна величина попуњавања тока у датотеци +.RE +.PD +.PP +Колоне редова \fBтока\fP: +.PD 0 +.RS +.IP 2. 4 +Број тока (први ток је 1) +.IP 3. 4 +Број блокова у току +.IP 4. 4 +Померај почетка запакованог +.IP 5. 4 +Померај почетка незапаковане +.IP 6. 4 +Величина запакованог (не укључује попуну тока) +.IP 7. 4 +Величина незапаковане +.IP 8. 4 +Размера паковања +.IP 9. 4 +Назив провере целовитости +.IP 10. 4 +Величина попуне тока +.RE +.PD +.PP +Колоне редова \fBблока\fP: +.PD 0 +.RS +.IP 2. 4 +Број тока који садржи овај блок +.IP 3. 4 +Број блока релативан на почетак тока (први блок је 1) +.IP 4. 4 +Број блока релативан на почетак датотеке +.IP 5. 4 +Померај почетка запакованог односан на почетак датотеке +.IP 6. 4 +Померај почетка незапаковане односан на почетак датотеке +.IP 7. 4 +Укупна запакована величина блока (заједно са заглављима) +.IP 8. 4 +Величина незапаковане +.IP 9. 4 +Размера паковања +.IP 10. 4 +Назив провере целовитости +.RE +.PD +.PP +Ако је \fB\-\-verbose\fP наведено два пута, додатне колоне су укључене у редовима +\fBблока\fP. Они се не приказују са једним \fB\-\-verbose\fP, јер добијање ове +информације захтева много тражења и стога може бити споро: +.PD 0 +.RS +.IP 11. 4 +Вредност провере целовитости у хексадецималном облику +.IP 12. 4 +Величина заглавља блока +.IP 13. 4 +Заставице блока: \fBc\fP указује да је величина запакованог присутна, а \fBu\fP +указује да је величина нераспакованог присутна. Ако заставица није +постављена, цртица (\fB\-\fP) се приказује уместо да се настави са поправком +дужине ниске. У будућности нове заставице могу бити додате на крај ниске. +.IP 14. 4 +Величина стварних запакованих података у блоку (ово искључује заглавље +блока, попуњавање блока и поља провере) +.IP 15. 4 +Количина меморије (у бајтовима) потребна за распакивање овог блока са овим +\fBxz\fP издањем +.IP 16. 4 +Ланац филтера. Знајте да већина опција коришћених за време запакивања не +може бити познато, јер се само опције које су потребне за распакивање чувају +у \fB.xz\fP заглављима. +.RE +.PD +.PP +Колоне редова \fBсажетка\fP: +.PD 0 +.RS +.IP 2. 4 +Количина меморије (у бајтовима) потребна за распакивање ове датотеке са овим +\fBxz\fP издањем +.IP 3. 4 +\fByes\fP или \fBno\fP указује да ли сва заглавља блока имају и величину +запакованог и величину незапакованог сачуване у њима +.PP +\fIОд\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Потребно је најмање \fBxz\fP издање за распакивање датотеке +.RE +.PD +.PP +Колоне редова \fBукупности\fP: +.PD 0 +.RS +.IP 2. 4 +Број токова +.IP 3. 4 +Број блокова +.IP 4. 4 +Величина запакованог +.IP 5. 4 +Величина незапаковане +.IP 6. 4 +Просечан степен запакивања +.IP 7. 4 +Списак зарезом раздвојених назива провере целовитости која су била присутна +у датотекама +.IP 8. 4 +Величина попуњавања тока +.IP 9. 4 +Број датотека. Ту се држи поредак ранијих колона исто као у редовима +\fBдатотеке\fP. +.PD +.RE +.PP +Ако је \fB\-\-verbose\fP наведено два пута, додатне колоне су укључене у реду +\fBtotals\fP: +.PD 0 +.RS +.IP 10. 4 +Највећа количина меморије (у бајтима) потребна за распакивање датотеке са +овим \fBxz\fP издањем +.IP 11. 4 +\fByes\fP или \fBno\fP указује да ли сва заглавља блока имају и величину +запакованог и величину незапакованог сачуване у њима +.PP +\fIОд\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Потребно је најмање \fBxz\fP издање за распакивање датотеке +.RE +.PD +.PP +Будућа издања могу додати нове врсте реда и нове колоне се могу додати +постојећим врстама реда, али постојеће колоне се неће променити. +. +.SS "Помоћ филтера" +\fBxz \-\-robot \-\-filters\-help\fP исписује подржане филтере у следећем формату: +.PP +\fIфилтер\fP\fB:\fP\fIопција\fP\fB=<\fP\fIвредност\fP\fB>,\fP\fIопција\fP\fB=<\fP\fIвредност\fP\fB>\fP... +.TP +\fIфилтер\fP +Назив филтера +.TP +\fIопција\fP +Назив филтера специфичне опције +.TP +\fIвредност\fP +Опсези бројевних \fIвредности\fP се јављају као +\fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. \fIВредност\fP ниске избора се приказују +унутар \fB< >\fP и раздвојене су знаком \fB|\fP. +.PP +Сваки филтер се исписује на свом сопственом реду. +. +.SS "Информације о ограничењу меморије" +\fBxz \-\-robot \-\-info\-memory\fP исписује један ред са више колона раздвојених +табулатором: +.IP 1. 4 +Укупна количина физичке меморије (RAM) у бајтима. +.IP 2. 4 +Ограничење коришћења меморије за запакивање у бајтима +(\fB\-\-memlimit\-compress\fP). Специјална вредност \fB0\fP означава основно +подешавање које је за режим једне нити исто као без ограничења. +.IP 3. 4 +Ограничење коришћења меморије за распакивање у бајтима +(\fB\-\-memlimit\-decompress\fP). Специјална вредност \fB0\fP означава основно +подешавање које је за режим једне нити исто као без ограничења. +.IP 4. 4 +Од \fBxz\fP 5.3.4alpha: Коришћење меморије за распакивање са више нити у +бајтима (\fB\-\-memlimit\-mt\-decompress\fP). Ово никада није нула јер систему +специфична основна вредност приказана у колони 5 се користи ако ограничење +није изричито наведено. Такође никада није веће од вредности у колони 3 чак +и ако је наведена већа вредност са \fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Од \fBxz\fP 5.3.4alpha: Систему специфично основно ограничење коришћења +меморије које се користи за ограничавање броја нити приликом запакивања са +аутоматским бројем нити (\fB\-\-threads=0\fP) и без наведеног ограничења +коришћења меморије (\fB\-\-memlimit\-compress\fP). Ово се такође користи као +основна вредност за \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Од \fBxz\fP 5.3.4alpha: Број доступних нити обрађивача. +.PP +У будуће, излаз \fBxz \-\-robot \-\-info\-memory\fP може имати више колона, али +никада више од једног реда. +. +.SS Издање +\fBxz \-\-robot \-\-version\fP исписује број издања за \fBxz\fP и „liblzma“ у следећем +формату: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Главно издање. +.TP +\fIYYY\fP +Споредно издање. Парни бројеви су стабилна а непарни су алфа или бета +издања. +.TP +\fIZZZ\fP +Ниво закрпе за стабилна издања или само бројач за развојна издања. +.TP +\fIS\fP +Стабилност. 0 је алфа, 1 је бета, а 2 је стабилно. \fIS\fP треба увек да буде +2 када је \fIYYY\fP парно. +.PP +\fIXYYYZZZS\fP су исти у оба реда ако су \fBxz\fP и „liblzma“ из истог издања XZ +Utils\-а. +.PP +Примери: 4.999.9beta је \fB49990091\fP и 5.0.0 је \fB50000002\fP. +. +.SH "СТАЊЕ ИЗЛАЗА" +.TP +\fB0\fP +Све је у реду. +.TP +\fB1\fP +Дошло је до грешке. +.TP +\fB2\fP +Десило се нешто вредно упозорења, али није дошло до стварних грешака. +.PP +Обавештења (без упозорења или грешака) исписано на стандардној грешци не +утичу на стање излаза. +. +.SH ОКРУЖЕЊЕ +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP обрађује размаком одвојени списак опција из променљивих окружења +\fBXZ_DEFAULTS\fP и \fBXZ_OPT\fP, тим редом, пре обраде опција са линије наредби. +Знајте да се обрађују само опције из променљивих окружења; све што нису +опције се тихо занемарује. Обрада се ради са \fBgetopt_long\fP(3) која се +користи такође за аргументе линије наредби. +.PP +\fBУпозорење:\fP Постављањем ових променљивих окружења, ефективно мењате +програме и скрипте које покреће \fBxz\fP. У већини случајева је безбедно +поставити ограничење коришћења, број нити и опција паковања путем +променљивих окружења. Међутим, неке опције могу да уруше скрипте. +Очигледан пример је \fB\-\-help\fP која чини да \fBxz\fP прикаже текст помоћи уместо +да запакује или распакује датотеку. Суптилнији примери су \fB\-\-quiet\fP и +\fB\-\-verbose\fP. У многим случајевима добро функционише омогућавање указивача +напредовања коришћењем \fB\-\-verbose\fP, али у неким ситуацијама додатне поруке +стварају проблеме. Ниво опширности такође утиче на понашање \fB\-\-list\fP +.TP +\fBXZ_DEFAULTS\fP +Кориснику специфичне или свеопште системске основне опције. Обично је ово +постављено у скрипти покретања конзоле за укључивање \fBxz\fP ограничавача +коришћења меморије по основи или за постављање основног броја нити. +Искључивање скрипти покретања конзоле и сличних специјалних случајева, +скрипте не смеју никада да поставе или пониште \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Ово је за прослеђивање опција ка \fBxz\fP када није могуће поставити опције +директно на \fBxz\fP линији наредби. Ово је случај када је \fBxz\fP покренут +скриптом или алатом, на пример, са Гну \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Скрипте могу да користе \fBXZ_OPT\fP, на пример, за постављање основних опција +запакивања специфичних скрипти. Још увек се препоручује омогућавање +корисницима да пишу преко \fBXZ_OPT\fP ако је то разумљиво. На пример, у +\fBsh\fP(1) скриптама неко може користити нешто као ово: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "LZMA UTILS САДЕЈСТВЕНОСТ" +Синтакса линије наредби \fBxz\fP је практично супер скуп \fBlzma\fP, \fBunlzma\fP и +\fBlzcat\fP као што се налази у LZMA Utils 4.32.x. У већини случајева, могуће +је заменити LZMA Utils са XZ Utils без оштећења постојећих скрипти. Има +неких несагласности такође, које понекад могу довести до проблема. +. +.SS "Нивои предподешавања запакивања" +Набрајање предподешености нивоа запакивања није исто у \fBxz\fP и LZMA Utils. +Најважнија разлика је у томе како се величине речника мапирају у различитим +предподешеностима. Величина речника је отприлике иста као и коришћење +меморије распакивача. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Ниво;xz;LZMA Utils +\-0;256 KiB;Н/Д +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Разлике величине речника делују такође на коришћење меморије запакивање, али +постоје још неке разлике између LZMA Utils и XZ Utils, што чини разлике још +већим: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Ниво;xz;LZMA Utils 4.32.x +\-0;3 MiB;Н/Д +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Основни ниво предподешености у LZMA Utils је \fB\-7\fP док у XZ Utils је \fB\-6\fP, +тако да оба користе 8 MiB речник по основи. +. +.SS "Токовне наспрам не\-токовних „.lzma“ датотеке" +Незапакована величина датотеке се може чувати у \fB.lzma\fP заглављу. LZMA +Utils то ради приликом запакивања обичних датотека. Алтернатива је да се +означи та незапакована величина као непозната и да се користи означавач +краја утовара да назначи где распакивач треба да стане. LZMA Utils користи +ову методу када незапакована величина није позната, што је случај, на +пример, у спојкама. +.PP +\fBxz\fP подржава распакивање \fB.lzma\fP датотека са или без означавача краја +утовара, али ће све \fB.lzma\fP датотеке направљене са \fBxz\fP користити +означавач краја утовара и означити незапаковану величину непознатом у +\&\fB.lzma\fP заглављу. Ово може бити проблем у неким неуобичајеним +ситуацијама. На пример, \fB.lzma\fP распакивач у угнежденом уређају може +радити само са датотекама које имају незапаковану величину. Ако наиђете на +тај проблем, треба да користите LZMA Utils или LZMA SDK да направите +\&\fB.lzma\fP датотеке са познатом незапакованом величином. +. +.SS "Неподржане „.lzma“ датотеке" +Формат \fB.lzma\fP омогућава \fIlc\fP вредности све до 8, а \fIlp\fP вредности све до +4. LZMA Utils може да распакује датотеке са било којим \fIlc\fP и \fIlp\fP, али +увек прави датотеке са \fBlc=3\fP и \fBlp=0\fP. Прављење датотека са другим \fIlc\fP +и \fIlp\fP је мгуће са \fBxz\fP и са LZMA SDK. +.PP +Примена филтера LZMA1 у „liblzma“ захтева да збир \fIlc\fP и \fIlp\fP не сме да +премаши 4. Стога, \fB.lzma\fP датотеке, које премаше ово ограничење, не могу +да се распакују са \fBxz\fP. +.PP +LZMA Utils прави само \fB.lzma\fP датотеке које имају величину речника од +2^\fIn\fP (степен 2) али прихвата датотеке са било којом величином речника. +„liblzma“ прихвата само \fB.lzma\fP датотеке које имају величину речника од +2^\fIn\fP или 2^\fIn\fP + 2^(\fIn\fP\-1). Ово је да се смање лажни позитивни +резултати приликом откривања \fB.lzma\fP датотека. +.PP +Ова ограничења не би требало да буду проблем у пракси, јер су практично све +\&\fB.lzma\fP датотеке запаковане са поставкама које ће „liblzma“ прихватити. +. +.SS "Пратеће смеће" +Приликом распакивања, LZMA Utils тихо занемарује све после првог \fB.lzma\fP +тока. У већини прилика, ово је грешка. Ово такође значи да LZMA Utils не +подржава распакивање надовезаних \fB.lzma\fP датотека. +.PP +Ако су остали подаци након првог \fB.lzma\fP тока, \fBxz\fP сматра да је датотека +оштећена осим ако је коришћено \fB\-\-single\-stream\fP. Ово може прекинути +нејасне скрипте које су претпоставиле да је пратеће смеће занемарено. +. +.SH НАПОМЕНЕ +. +.SS "Излаз запакованог може бити променљив" +Тачан запаковани излаз добијен из исте незапаковане улазне датотеке може се +разликовати између XZ Utils издања чак и ако су опције запакивања +истоветне. Ово је због тога што шифрер може бити побољшан (брже и боље +запакивање) а да не утиче на формат датотеке. Излаз се може разликовати +између различитих изградњи истог XZ Utils издања, ако су коришћене другачије +опције изградње. +.PP +Ово изнад значи да када се \fB\-\-rsyncable\fP једном примени, резултирајућа +датотека неће неопходно бити r\-ускладива осим ако и стара и нова датотека +нису запаковане истим xz издањем. Овај проблем може бити поправљен ако је +део примене шифрера замрзнут да држи r\-ускладив излаз стабилним кроз xz +издања. +. +.SS "Угнеждени „.xz“ распакивачи" +Примена угнежденог \fB.xz\fP распакивача као што је XZ Embedded неопходно не +подржава датотеке направљене врстама \fIпровере\fP целовитости осим \fBnone\fP и +\fBcrc32\fP. Како је основно \fB\-\-check=crc64\fP, морате да користите +\fB\-\-check=none\fP или \fB\-\-check=crc32\fP када правите датотеке за угнеждене +системе. +.PP +Споља уграђени системи, сви распакивачи \fB.xz\fP формата подржавају све врсте +\fIпровере\fP, или барем могу да распакују датотеку без испитивања провере +целовитости ако одређена \fIпровера\fP није подржана. +.PP +XZ Embedded подржава BCJ филтере, али само са основним померајем почетка. +. +.SH ПРИМЕРИ +. +.SS Основно +Запакује датотеку \fIfoo\fP у \fIfoo.xz\fP користећи основни ниво запакивања +(\fB\-6\fP), и уклања \fIfoo\fP ако је запакивање успешно: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Распакује \fIbar.xz\fP у \fIbar\fP и не уклања \fIbar.xz\fP чак и када је распакивање +успешно: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Ствара \fIbaz.tar.xz\fP са предподешавањем \fB\-4e\fP (\fB\-4 \-\-extreme\fP), које је +спорије него основно \fB\-6\fP, али захтева мање меморије за запакивање и +распакивање (48\ MiB и 5\ MiB): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Мешавина сажетих и несажетих датотека се може распаковати на стандардни +излаз једном наредбом: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Паралелно запакивање више датотека" +На GNU и *BSD, \fBfind\fP(1) и \fBxargs\fP(1) се могу користити за паралелно +запакивање више датотека: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Опција \fB\-P\fP за \fBxargs\fP(1) поставља број паралелних \fBxz\fP процеса. Најбоља +вредност за опцију \fB\-n\fP зависи од тога колико датотека има за запакивање. +Ако има само неколико датотека, вредност би вероватно требала да буде 1; са +више хиљада датотека, 100 или чак и више може бити одговарајуће за смањење +броја \fBxz\fP процеса које би \fBxargs\fP(1) евентуално направио. +.PP +Опција \fB\-T1\fP за \fBxz\fP је ту да га примора на једнонитни режим, јер се +\fBxargs\fP(1) користи за контролу количине паралелизације. +. +.SS "Режим робота" +Израчунава колико је бајтова укупно сачувано након запакивања више датотека: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Скрипта може желети да зна да користи најновији \fBxz\fP. Следећа скрипта +\fBsh\fP(1) проверава да ли је број издања \fBxz\fP алата барем 5.0.0. Ова +метода је сагласна са старим бета издањима која не подржавају \fB\-\-robot\fP +опцију: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Ваш „xz“ је превише стар." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Поставља ограничење коришћења меморије за распакивање коришћењем \fBXZ_OPT\fP, +али ако је ограничење већ постављено, не повећава је: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Произвољни ланци филтера запакивача" +Најједноставнија употреба за произвољне ланце филтера прилагођава LZMA2 +предподешеност. Ово може бити корисно, јер предподешености покривају само +подскуп потенцијално корисних комбинација поставки запакивања. +.PP +Колоне ЗапакЦПЈ у табелама из описа опција \fB\-0\fP ... \fB\-9\fP и \fB\-\-extreme\fP су +корисне приликом прилагођавања LZMA2 предподешености. Овде су значајни +делови прикупљени из те две табеле: +.RS +.PP +.TS +tab(;); +c c +n n. +Преподешеност;ЗапакЦПЈ +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Ако знате да датотека захтева нешто велики речник (на пример, 32 \ MiB) за +добро запакивање, али желите да је запакујете брже него што би то \fBxz \-8\fP +урадио, предподешеност са ниском вредношћу ЗапакМем (на пример, 1) може се +изменити да користи већи речник: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Са одређеним датотекама, горња наредба може бити бржа од \fBxz \-6\fP а +запакивање значајно боље. Међутим, мора бити наглашено да само неке +датотеке имају корист од великог речника док одржавају вредност ЗапакЦПЈ +ниском. Најочигледнија ситуација, у којој велики речник може доста помоћи, +јесте архива која садржи врло сличне датотеке где свака има најмање неколико +мегабајта. Величина речника треба да буде значајно већа од сваке засебне +датотеке да би се омогућило да LZMA2 има потпуну предност од сличности +између узастопних датотека. +.PP +Ако је веома велико коришћење меморије запакивача и распакивача у реду, а +датотека која се запакује је барем неколико стотина мегабајта, може бити +корисно користити још већи речник од 64 MiB који ће \fBxz \-9\fP користити: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Коришћење \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) као у горњем примеру може бити +корисно да се виде захтеви за меморијом запакивача и распакивача. Знајте да +је коришћење речника већег од величине незапаковане датотеке губитак +меморије, тако да горња наредба није корисна за мале датотеке. +.PP +Понекад време запакивања није важно, али коришћење меморије распакивача +треба да се одржава ниским, на пример, да би се учинило могућим распакивање +датотеке на угнежденом систему, Следеће наредбе користе \fB\-6e\fP (\fB\-6 \-\-extreme\fP) као основу и постављају речник на само 64\ KiB. Резултујућа +датотека се може распаковати са XZ Embedded (због тога је ту +\fB\-\-check=crc32\fP) користећи око 100\ KiB меморије. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Ако желите да исцедите што је више могуће бајтова, дотеривање броја битова +контекста литерала (\fIlc\fP) и броја битова положаја (\fIpb\fP) може понекад да +помогне. Дотеривање броја битова положаја литерала (\fIlp\fP) може такође да +помогне, али обично \fIlc\fP и \fIpb\fP су важнији. На пример, архива извора кода +садржи углавном US\-ASCII текст, тако да нешто као следеће може да да +незнатно (око 0.1\ %) мању датотеку него \fBxz \-6e\fP (пробајте такође без +\fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Коришћење још једног филтера заједно са LZMA2 може побољшати запакивање са +одређеним врстама датотека. На пример, за запакивање x86\-32 или x86\-64 +дељене библиотеке коришћењем x86 BCJ филтера: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Знајте да поредак опција филтера има значај. Ако је \fB\-\-x86\fP наведено након +\fB\-\-lzma2\fP, \fBxz\fP ће дати грешку, јер не сме бити никаквог филтера после +LZMA2, и такође зато што се x86 BCJ филтер не може користити као последњи +филтер у ланцу. +.PP +Delta филтер заједно са LZMA2 може дати добре резултате са битмап сликама. +Требало би обично да надјача PNG, који има нешто више напредних филтера него +једноставни делта али користи Deflate за стварно запакивање. +.PP +Слика треба да се сачува у незапакованом формату, на пример, као +незапакована TIFF. Параметар растојања Delta филтера је постављен да се +подудари са бројем бајтова по пикселу у слици. На пример, RGB битмапа од 24 +бита захтева \fBdist=3\fP, а такође је добро проследити \fBpb=0\fP за LZMA2 да се +прилагоди поравнање од три бајта: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Ако је више слика стављено у једну архиву (на пример, \fB.tar\fP), Delta филтер +ће радити на томе такође све док све слике не буду имале исти број бајтова +по пикселу. +. +.SH "ВИДИТЕ ТАКОЂЕ" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/unxz.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/unxz.1 new file mode 100644 index 0000000000000000000000000000000000000000..82d831001e1f400683d876e945d108fa8686a45a --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/unxz.1 @@ -0,0 +1,1928 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Serbian translation of xz-man. +.\" Мирослав Николић , 2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 08.03.2025. Tukaani "XZ Utils" +. +.SH НАЗИВ +xz, unxz, xzcat, lzma, unlzma, lzcat – Запакује или распакује „.xz“ и „.lzma +датотеке +. +.SH САЖЕТАК +\fBxz\fP [\fIопција...\fP] [\fIдатотека...\fP] +. +.SH "АЛИЈАСИ НАРЕДБЕ" +\fBunxz\fP је исто као и \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP је исто као и \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP је исто као и \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP је исто као и \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP је исто као и \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Приликом писања скрипти које треба да распакују датотеке, препоручује се да +се увек користи назив \fBxz\fP са одговарајућим аргументима (\fBxz \-d\fP или \fBxz \-dc\fP) уместо назива \fBunxz\fP и \fBxzcat\fP. +. +.SH ОПИС +\fBxz\fP је алат опште употребе за запакивање података са синтаксом линије +наредби сличан као \fBgzip\fP(1) и \fBbzip2\fP(1). Изворни формат датотеке је +\&\fB.xz\fP формат, али стари \fB.lzma\fP формат који користи LZMA Utils и сирови +запаковани токови без заглавља формата су такође подржани. Уз то, +распакивање \fB.lz\fP формата који користи \fBlzip\fP је подржано. +.PP +\fBxz\fP запакује или распакује сваку \fIдатотеку\fP у складу са изабраним режимом +рада. Ако није дата ни једна \fIдатотека\fP или је датотека \fIfile\fP \fB\-\fP, +\fBxz\fP чита са стандардног улаза и записује обрађене податке на стандардни +излаз. \fBxz\fP ће одбити (приказаће грешку и прескочити \fIдатотеку\fP) да пише +запаковане податке на стандардни излаз ако је то терминал. Слично, \fBxz\fP ће +одбити да чита запаковане податке са стандардног улаза ако је то терминал. +.PP +Осим ако није наведено \fB\-\-stdout\fP, \fIдатотеке\fP које нису \fB\-\fP се пишу у +нову датотеку чији назив је проистекао из назива изворне \fIдатотеке\fP: +.IP \(bu 3 +Приликом запакивања, суфикс формата циљне датотеке (\fB.xz\fP или \fB.lzma\fP) се +додаје на назив изворне датотеке да би се добио назив циљне датотеке. +.IP \(bu 3 +Приликом распакивања, суфикс \fB.xz\fP, \fB.lzma\fP или \fB.lz\fP се уклања из назива +датотеке да би се добио назив циљне датотеке. \fBxz\fP такође препознаје +суфиксе \fB.txz\fP и \fB.tlz\fP и замењује их суфиксом \fB.tar\fP. +.PP +Ако циљна датотека већ пстоји, приказује се грешка а \fIдатотека\fP се +прескаче. +.PP +Осим ако не пише на стандардни излаз, \fBxz\fP ће приказати упозорење и +прескочити \fIдатотеку\fP ако се нешто од следећег примењује: +.IP \(bu 3 +\fIДатотека\fP није обична датотека. Симболичке везе се не прате, и стога се +не сматра да су обичне датотеке. +.IP \(bu 3 +\fIДатотека\fP има више од једне чврсте везе. +.IP \(bu 3 +\fIДатотека\fP има постављен „setuid, setgid“ или лепљиви бит. +.IP \(bu 3 +Режим рада је постављен на запакивање а \fIдатотека\fP већ има суфикс формата +циљне датотеке (\fB.xz\fP или \fB.txz\fP приликом запакивања у \fB.xz\fP формат, а +\&\fB.lzma\fP или \fB.tlz\fP приликом запакивања у \fB.lzma\fP формат). +.IP \(bu 3 +Режим радње је постављен за распакивање а \fIдатотека\fP нема суфикс ни једног +од подржаних формата датотеке (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP или +\&\fB.lz\fP). +.PP +Након успешног сажимања или распакивања \fIдатотеке\fP, \fBxz\fP умножава +власника, групу, дозволе, време приступа и време измене из изворне +\fIдатотеке\fP у циљну датотеку. Ако умножавање групе не успе, дозволе су +измењене тако да циљна датотека не постане доступна корисницима који нису +имали дозволу за приступ изворној \fIдатотеци\fP. \fBxz\fP не подржава умножавање +других метаподатака попут списка контрола приступа или проширених атрибута. +.PP +Једном када је циљна датотека успешно затворена, изворна \fIдатотека\fP се +уклања осим ако се \fB\-keep\fP не наведе. Изворна \fIдатотека\fP се никада не +уклања ако се излаз пише на стандардни излаз или ако дође до грешке. +.PP +Слање \fBSIGINFO\fP или \fBSIGUSR1\fP ка \fBxz\fP процесу чини да испише информације +напредовања на стандардну грешку. Ово има ограничено коришћење све док +стандардна грешка јесте терминал, коришћење \fB\-\-verbose\fP приказаће +аутоматски указивач напретка освежавања. +. +.SS "Коришћење меморије" +Коришћење меморије \fBxz\fP се мења од неколико стотина килобајта до неколико +гигабајта у зависности од поставки запакивања. Поставке коришћене приликом +запакивања датотеке одређују захтеве меморије распакивача. Обично +распакивачу треба 5\ % до 20\ % количине меморије која је потребна +запакивачу приликом прављења датотеке. На пример, распакивање датотеке +направљене са \fBxz \-9\fP тренутно захтева 65\ MiB меморије. Још увек, могуће +је имати \fB.xz\fP датотеке које захтевају неколико гигабајта меморије за +распакивање. +.PP +Нарочито корисници старијих система могу наћи досадном могућност коришћења +врло велике меморије. Да би се спречила нежељена изненађења, \fBxz\fP има +уграђен ограничавач коришћења меморије, који је искључен по основи. Док +неки оперативни системи пружају начин за ограничавање коришћење меморије за +процесе, ослањање на то сматра се да није довољно прилагодљиво (на пример, +коришћење \fBulimit\fP(1) за ограничавање виртуелне меморије тежи да обогаљи +\fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Ограничавач коришћења меморије се може укључити опцијом линије наредби +\fB\-\-memlimit=\fP\fIограничење\fP. Често је најпогодније укључити ограничавач по +основи постављањем променљиве окружења \fBXZ_DEFAULTS\fP, на пример, +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Могуће је поставити ограничења засебно за +запакивање и распакивање коришћењем \fB\-\-memlimit\-compress=\fP\fIограничење\fP и +\fB\-\-memlimit\-decompress=\fP\fIограничење\fP. Коришћење ове две опције ван +\fBXZ_DEFAULTS\fP је ретко корисно јер једно покретање \fBxz\fP не може да ради и +запакивање и распакивање а \fB\-\-memlimit=\fP\fIограничење\fP (или \fB\-M\fP +\fIограничење\fP) је краће за куцање на линији наредби. +.PP +Ако је прекорачено наведено ограничење коришћења меморије, \fBxz\fP ће +приказати грешку а распакивање датотеке неће успети. Ако је ограничење +прекорачено приликом запакивања, \fBxz\fP ће покушати да умањи поставке тако да +се ограничење више не прекорачује (оси када се користи \fB\-\-format=raw\fP или +\fB\-\-no\-adjust\fP). На тај начин радња неће бити неуспешна осим ако је +ограничење врло мало. Смањење поставке се ради у корацима који се не +подударају са предподешеностима нивоа запакивања, на пример, ако је +ограничење само незнатно мање од износа потребног за \fBxz \-9\fP, поставке ће +бити смањене само мало, а не све до \fBxz \-8\fP. +. +.SS "Надовезивање и попуњавање са „.xz“ датотекама" +Могуће је додати \fB.xz\fP датотеке као то. \fBxz\fP ће распаковати такве +датотеке као да су биле једна \fB.xz\fP датотека. +.PP +Могуће је уметнути попуњавање између придодатих делова или након последњег +дела. Попуњавање мора да се састоји од празних бајтова а величина +попуњавања мора бити умножак четири бајта. Ово може бити корисно, на +пример, ако је \fB.xz\fP датотека смештена на медијуму који мери величине +датотека у блоковима од 512 бајтова. +.PP +Надовезивање и попуњавање нису дозвољени са \fB.lzma\fP датотекама или сировим +токовима. +. +.SH ОПЦИЈЕ +. +.SS "Суфикси целог броја и специјалне вредности" +На већини места где се очекује аргумент целог броја, опционални суфикс је +подржан да би се лако назначили велики цели бројеви. Не сме бити размака +између целог броја и суфикса. +.TP +\fBKiB\fP +Множи цео број са 1.024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP, и \fBKB\fP се +прихватају као синоними за \fBKiB\fP. +.TP +\fBMiB\fP +Множи цео број са 1.048.576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP, и \fBMB\fP се +прихватају као синоними за \fBMiB\fP. +.TP +\fBGiB\fP +Множи цео број са 1.073.741.824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP, и \fBGB\fP се +прихватају као синоними за \fBGiB\fP. +.PP +Посебна вредност \fBmax\fP се може користити да укаже на највећу вредност целог +броја подржану опцијом. +. +.SS "Режим рада" +Ако је дато више опција режима рада, последња има дејства. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Запакује. Ово је основни режим радње када није наведена опција режима радње +и ниједан други режим радње се не подразумева са линије радње (на пример, +\fBunxz\fP подразумева \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Након успешног запакивања, изворна датотека се уклања осим ако се не пише на +стандардни излаз или је наведено \fB\-\-keep\fP. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Распакује. Након успешног распакивања, изворна датотека се уклања осим ако +се не пише на стандардни излаз или је наведено \fB\-\-keep\fP. +.TP +\fB\-t\fP, \fB\-\-test\fP +Тестира целовитост запакованих \fIдатотека\fP. Ова опција је исто што и +\fB\-\-decompress \-\-stdout\fP осим тога што се распаковани подаци одбацују уместо +да се пишу на стандардни излаз. Датотеке се не праве нити уклањају. +.TP +\fB\-l\fP, \fB\-\-list\fP +Исписује информације о запакованим \fIдатотекама\fP. Никакав незапакован излаз +се не добија, а ниједна датотека није направљена или уклоњена. У режиму +списка, програм не може читати запаковане податке са стандардног улаза или +из других нетраживих извора. +.IP "" +Основни списак приказује основне информације о \fIдатотекама\fP, једна датотека +у једном реду. Да добијете подробније информације, користите такође опцију +\fB\-\-verbose\fP. За чак и више информација, користите \fB\-\-verbose\fP два пуа, +али знајте да то може бити споро, јер да би се добиле све додатне +информације потребно је много тражења. Ширина опширног излаза премашује 80 +знакова, тако да преспајање излаза на, на пример, \fBless\ \-S\fP може бити +прикладно ако терминал није довољно широк. +.IP "" +Тачан излаз може варирати између \fBxz\fP издања и различитих језика. За излаз +читљив машинама треба да користите \fB\-\-robot \-\-list\fP. +. +.SS "Измењивачи рада" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Не брише улазне датотеке. +.IP "" +Од \fBxz\fP 5.2.6, ова опција такође чини да \fBxz\fP запакује или распакује чак и +ако је улаз симболичка веза ка обичној датотеци, има више од једне чврсте +везе или има постављен „setuid“, „setgid“ или лепљиви бит. „setuid“, +„setgid“ и лепљиви битови се не умножавају у циљну датотеку. У ранијим +издањима ово се могло урадити само са \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Ова опција има неколико дејстава: +.RS +.IP \(bu 3 +Ако циљна датотека већ постоји, брише је пре запакивања или распакивања. +.IP \(bu 3 +Запакује или распакује чак и ако је улаз симболичка веза ка обичној +датотеци, има више од једне чврсте везе или има постављен „setgid“, „setgid“ +или лепљиви бит. „setgid“, „setgid“ или лепљиви бит се не умножавају у +циљну датотеку. +.IP \(bu 3 +Када се користи са \fB\-\-decompress\fP \fB\-\-stdout\fP и \fBxz\fP не може да препозна +врсту изворне датотеке, умножава изворну датотеку као такву на стандардни +излаз. Ово омогућава да се \fBxzcat\fP \fB\-\-force\fP користи као \fBcat\fP(1) за +датотекекоје нису запаковане са \fBxz\fP. Знајте да ће у будућности, \fBxz\fP +моћи да подржава нове формате запаковане датотеке, који могу учинити да +\fBxz\fP распакује још врста датотека уместо да их умножи какве јесу на +стандардни излаз. \fB\-\-format=\fP\fIформат\fP се може користити да ограничи \fBxz\fP +да распакује само формат једне датотеке. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Пише запаковане или распаковане податке на стандардни излаз уместо у +датотеку, Ово подразумева \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Распакује само први \fB.xz\fP ток, и тихо занемарује могуће преостале улазне +податке који следе ток. Нормално такво пратеће смеће чини да \fBxz\fP прикаже +грешку. +.IP "" +\fBxz\fP никада не распакује више од једног тока из \fB.lzma\fP датотека или +сирових токова, али ова опција чини да \fBxz\fP још увек занемари могуће +пратеће податке након \fB.lzma\fP датотеке или сировог тока. +.IP "" +Ова опција нема дејства ако режим рада није \fB\-\-decompress\fP или \fB\-\-test\fP. +.IP "" +Од \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP подразумева \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Искључује стварање развучених датотека. По основи, ако распакује у обичну +датотеку, \fBxz\fP покушава да учини датотеку развученом ако распаковани подаци +садрже дуге низове бинарних нула. Такође ради приликом писања на стандардни +излаз све док је стандардни излаз повезан са обичном датотеком а одређени +додатни услови су испуњени да је учине безбедном. Стварање развучених +датотека може уштедети простор на диску и убрзати распакивање смањењем +количине У/И диска. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Приликом запакивања, користите \fI.suf\fP као суфикс за циљну датотеку уместо +\&\fB.xz\fP или \fB.lzma\fP. Ако се не пише на стандардни излаз а изворна датотека +већ има суфикс \fI.suf\fP, приказује се упозорење и датотека се прескаче. +.IP "" +Приликом распакивања, препознаје датотеке са суфиксом \fI.suf\fP поред датотека +са суфиксом \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, or \fB.lz\fP. Ако изворна +датотека има суфикс \fI.suf\fP, суфикс се уклања да би се добио назив циљне +датотеке. +.IP "" +Приликом запакивања или распакивања сирових токова (\fB\-\-format=raw\fP), суфикс +мора увек бити наведен осим ако се не пише на стандардни излаз, јер не +постоји основни суфикс за сирове токове. +.TP +\fB\-\-files\fP[\fB=\fP\fIдатотека\fP] +Чита називе датотека за обраду из \fIдатотеке\fP; ако се \fIдатотека\fP изостави, +називи датотека се читају са стандардног улаза. Називи датотека се морају +завршавати знаком новог реда. Цртица (\fB\-\fP) се узима као редован назив +датотеке; а не стандардни улаз. Ако су називи датотека дати такође као +аргументи линије наредби, обрађују се пре него што се називи датотека +прочитају из \fIдатотеке\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIдатотека\fP] +Ово је исто као и \fB\-\-files\fP[\fB=\fP\fIдатотека\fP] изузев тога што сваки назив +датотеке мора да се завршава „null“ знаком. +. +.SS "Основни формат датотеке и опције запакивања" +.TP +\fB\-F\fP \fIформат\fP, \fB\-\-format=\fP\fIформат\fP +Наводи \fIформат\fP датотеке за запакивање или распакивање: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Ово је основно. Приликом запакивања, \fBauto\fP је исто што и \fBxz\fP. Приликом +распакивања, формат улазне датотеке се аутоматски препознаје. Знајте да +сирови токови (направљени са \fB\-\-format=raw\fP) не могу бити аутоматски +препознати. +.TP +\fBxz\fP +Пакује у \fB.xz\fP формат датотеке, или прихвата само \fB.xz\fP датотеке приликом +распакивања. +.TP +\fBlzma\fP, \fBalone\fP +Пакује у стари \fB.lzma\fP формат датотеке, или прихвата само \fB.lzma\fP датотеке +приликом распакивања. Алтернативни назив \fBalone\fP се доставља зарад +повратне сагласности са LZMA помагалима. +.TP +\fBlzip\fP +Прихвата само \fB.lz\fP датотеке приликом распакивања. Запакивање није +подржано. +.IP "" +Формат \fB.lz\fP издања 0 и 1 је подржан. Датотеке издања 0 су настале са +\fBlzip\fP 1.3 и старијим. Такве датотеке нису уобичајене али се могу наћи у +архивама датотека јер је неколико пакета извора издато у овом формату. +Такође можда неко има старе личне датотеке у овом формату. Подршка +распакивања за формат издања 0 је уклоњена у \fBlzip\fP 1.18. \fBlzip\fP 1.4 и +новији ствара датотеке у формату издања 1. +.TP +\fBraw\fP +Запакује или распакује сирови ток (без заглавља). Ово је замишљено само за +напредне кориснике. Да дешифрујете сирове токове, треба да користите +\fB\-\-format=raw\fP и да изричито наведете ланац филтера, што би обично требало +да буде смештено у заглављима контејнера. +.RE +.TP +\fB\-C\fP \fIпровера\fP, \fB\-\-check=\fP\fIпровера\fP +Наводи врсту провере целовитости. Провера се израчунава из незапакованих +података и смештених у \fB.xz\fP датотеци. Ова опција има дејства само +приликом запакивања у \fB.xz\fP формат; \fB.lzma\fP формат не подржава провере +целовитости. Провера целовитости (ако је има) се проверава када је \fB.xz\fP +датотека распакована. +.IP "" +Подржане врсте \fIпровере\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Уопште не израчунава проверу целовитости. Ово је обично лоша идеја. Ово +може бити корисно када се целовитост података ипак проверава на друге +начине. +.TP +\fBcrc32\fP +Израчунава CRC32 користећи полином из IEEE\-802.3 (Етернет). +.TP +\fBcrc64\fP +Израчунава CRC64 користећи полином из ECMA\-182. Ово је основно, јер је +незнатно боље од CRC32 у откривању оштећених датотека а разлика брзине је +занемарљива. +.TP +\fBsha256\fP +Израчунава SHA\-256. Ово је нешто спорије од CRC32 и CRC64. +.RE +.IP "" +Целовитост \fB.xz\fP заглавља се увек проверава са CRC32. Не може се изменити +нити искључити. +.TP +\fB\-\-ignore\-check\fP +Не проверава проверу целовитости запакованих података приликом распакивања. +CRC32 вредности у \fB.xz\fP заглављима биће још увек нормално проверене. +.IP "" +\fBНемојте користити ову опцију осим ако стварно знате шта радите.\fP Могући +разлози за коришћење ове опције: +.RS +.IP \(bu 3 +Покушава да опорави податке из оштећене „.xz“ датотеке. +.IP \(bu 3 +Убрзава распакивање. Ово има значаја углавном са SHA\-256 или са датотекама +које су запаковане стварно добро. Препоручује се да не користите ову опцију +за ову сврху осим ако је целовитост датотеке проверена споља на неки други +начин. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Бира ниво преподешености запакивања. Подразумевано је \fB\-6\fP. Ако је +наведено више нивоа преподешености, последња има дејства. Ако је произвољни +ланац филтера већ наведен, постављање нивоа преподешености запакивања уклања +произвољни ланац филтера. +.IP "" +Разлике између предподешености су још значајније него са \fBgzip\fP(1) и +\fBbzip2\fP(1). Изабране поставке запакивања одређују захтеве меморије +распакивача, стога коришћење превисоког нивоа предподешености може отежати +распакивање датотеле на старом систему са мало RAM\-а. Нарочито, \fBније добра замисао слепо користити \-9 за било шта\fP као што је често са \fBgzip\fP(1) +и \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Ово су некако брзе предподешености. \fB\-0\fP је понекад брже од \fBgzip \-9\fP док +запакује много боље. Оне више често имају брзину упоредиву са \fBbzip2\fP(1) +са упоредивом или бољом стопом запакивања, иако резултати зависе много од +врсте података који се запакују. +.TP +\fB\-4\fP ... \fB\-6\fP +Добро до врло добро запакивање које одржава коришћење меморије распакивача +разумним чак и за старе системе. \fB\-6\fP је основно, што је обично добар +избор за расподелу датотека које треба да могу да се распакују чак и на +системима са само 16\ MiB RAM\-а. (\fB\-5e\fP или \fB\-6e\fP може бити вредно +узимања у обзир. Видите \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Као \fB\-6\fP али са већим захтевима меморије запакивача и распакивача. Корисне +су само приликом запакивања датотека већих од 8\ MiB, 16\ MiB и 32\ MiB. +.RE +.IP "" +На истом хардверу, брзина распакивања је приближно сталан број бајтова +запакованих података у секунди. Другим речима, биће боље запакивање, брже +распакивање. То такође значи да количина незапакованог излаза произведеног +у секунди може много да се разликује. +.IP "" +Следећа табела резимира функције предподешености: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Преподешеност;ВлчРчнка;ЗапакЦПЈ;ЗапакМем;РаспМем +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Описи колона: +.RS +.IP \(bu 3 +ВлчРчнка је величина LZMA2 речника. Коришћење речника већег од величине +незапаковане датотеке је губитак меморије. Зато је добро избегавати +коришћење предподешености \fB\-7\fP ... \fB\-9\fP када за њима нема стварне +потребе. Са \fB\-6\fP и нижим, количина изгубљене меморије је обично довољно +ниска да нема значаја. +.IP \(bu 3 +ЗапакЦПЈ је поједностављено представљање LZMA2 поставки које утичу на брзину +запакивања. Величина речника такође утиче на брзину, тако док је ЗапакЦПЈ +исто за нивое \fB\-6\fP ... \fB\-9\fP, виши нивои још увек теже да буду спорији. Да +добијете још спорије и самим тим можда боље запакивање, видите \fB\-\-extreme\fP. +.IP \(bu 3 +ЗапакМем садржи захтеве меморије запакивача у режиму једне нити. Може +незнатно да се разликује између \fBxz\fP издања. +.IP \(bu 3 +РаспМем садржи захтеве меморије распакивача. Тако је, поставке запакивања +одређују захтеве меморије распакивача. Тачно коришћење меморије распакивача +је незнатно веће од величине LZMA2 речника, али су вредности у табели +заокружене на следећи цео MiB. +.RE +.IP "" +Захтеви меморије режима са више нити су значајно већи него ли режима једне +нити. Са основном вредношћу \fB\-\-block\-size\fP, свакој нити треба 3*3*ВлчРчнка +плус ЗапакМем или РаспМем. На пример, за четири нити са предподешавањем +\fB\-6\fP потребно је 660\(en670\ MiB меморије. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Користите спорију варијанту изабраног нивоа предподешености запакивања +(\fB\-0\fP ... \fB\-9\fP) у нади да ћете добити мало бољу стопу запакивања, али уз +лошу срећу ово је може учинити гором. Не утиче на коришћење меморије +распакивача, али се коришћење меморије запакивача мало повећава на нивоима +предподешености \fB\-0\fP ... \fB\-3\fP. +.IP "" +Како постоје две предподешености са величинама речника од 4\ MiB и 8\ MiB, +предподешености \fB\-3e\fP и \fB\-5e\fP користе незнатно брже поставке (ниже +CompCPU) него \fB\-4e\fP и \fB\-6e\fP. На тај начин нема две истоветне +предподешености. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Преподешеност;ВлчРчнка;ЗапакЦПЈ;ЗапакМем;РаспМем +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +На пример, има укупно четири предподешавања која користе 8\ MiB речник, чији +поредак од најбржег до најспоријег је \fB\-5\fP, \fB\-6\fP, \fB\-5e\fP и \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Ово су помало погрешни алијаси за \fB\-0\fP и \fB\-9\fP. Достављени су само зарад +повратне сагласности са LZMA Utils\-ом. Избегавајте коришћење ових опција. +.TP +\fB\-\-block\-size=\fP\fIвеличина\fP +Приликом запакивања у \fB.xz\fP формат, дели улазне податке на блокове +\fIвеличина\fP бајта. Блокови се запакују независно један од другог, што +помаже у раду са више нити и чини ограничено распакивање насумичног приступа +могућим. Ова опција се обично користи да се препише основна величина блока +у режиму са више нити, али се ова опција може такође користити и у режиму +једне нити. +.IP "" +У режиму више нити око три пута \fIвеличина\fP бајтова биће додељено у свакој +нити за међумеморисање улаза и излаза. Основна \fIвеличина\fP је три пута +величине LZMA2 речника или 1 MiB, шта год да је више. Обично добра вредност +је 2\(en4 пута величина LZMA2 речника или барем 1 MiB. Коришћење +\fIвеличине\fP мање од величине LZMA2 речника је трошење RAM\-а јер тада +међумеморија LZMA2 речника никада неће бити потпуно коришћена. У режиму +више нити, величине блокова се чувају у заглављима блока. Ова информација +величине је потребна за распакивање са више нити. +.IP "" +У режиму једне нити никаква подела блока се не ради по основи. Постављање +ове опције не утиче на коришћење меморије. Никакве информације о величини +се не чувају у заглављима блока, стога датотеке направљене у режиму једне +нити неће бити исте као датотеке направљене у режиму више нити. Недостатак +информација о величини такође значи да \fBxz\fP неће моћи да распакује датотеке +у режиму више нити. +.TP +\fB\-\-block\-list=\fP\fIставке\fP +Приликом запакивања у \fB.xz\fP формат, почиње нови блок са изборним +произвољним ланцем филтера након датих интервала незапакованих података. +.IP "" +\fIСтавке\fP су списак одвојен зарезом. Свака ставка се састоји од изборног +броја ланца филтера између 0 и 9 за којим следи двотачка (\fB:\fP) и захтевана +величина незапакованих података . Изостављање неке ставке (два или више +узастопна зареза) је пречица за коришћење величине и филтера претходне +ставке. +.IP "" +Ако је улазна датотека већа од збира величина у \fIставкама\fP, последња ставка +се понавља све до краја датотеке. Специјална вредност \fB0\fP може се +користити као последња величина да назначи да остатак датотеке треба да буде +шифрован као један блок. +.IP "" +Алтернативни ланац филтера за сваки блок се може навести у комбинацији са +опцијама \fB\-\-filters1=\fP\fIфилтера\fP \&...\& \fB\-\-filters9=\fP\fIфилтери\fP. Ове +опције дефинишу ланце филтера са одредником између 1\(en9. Ланац филтера 0 +се може користити да упућује на основно ланац филтера, који је исти јер се +ланац филтера не наводи. Одредник ланца филтера се може користити пре +незапаковане величине, за којим следи двотачка (\fB:\fP). На пример, ако +наведемо \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP тада ће се за +прављење блокова користити: +.RS +.IP \(bu 3 +Ланац филтера наведен са \fB\-\-filters1\fP и 2 MiB улазом +.IP \(bu 3 +Ланац филтера наведен са \fB\-\-filters3\fP и 2 MiB улазом +.IP \(bu 3 +Ланац филтера наведен са \fB\-\-filters2\fP и 4 MiB улазом +.IP \(bu 3 +Ланац филтера наведен са \fB\-\-filters2\fP и 4 MiB улазом +.IP \(bu 3 +Основни ланац филтера и 2 MiB улаз +.IP \(bu 3 +Основни ланац филтера и 4 MiB улаз за сваки блок до краја улаза. +.RE +.IP "" +Ако наведемо величину која премашује величину блока шифрера (било основну +вредност у режиму нити или вредност наведену са +\fB\-\-block\-size=\fP\fIвеличина\fP), шифрер ће направити додатне блокове док ће +задржати границе наведене у \fIставкама\fP. На пример, ако наведемо +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP а улазна +датотека је 80 MiB, добићемо 11 блокова: 5, 10, 8, 10, 2, 10, 10, 4, 10, 10 +и 1 MiB. +.IP "" +У режиму са више нити величине блокова се чувају у заглављима блока. Ово се +не ради у режиму једне нити, тако да шифровани излаз неће бити истоветан +ономе у режиму са више нити. +.TP +\fB\-\-flush\-timeout=\fP\fIистек_времена\fP +Приликом запакивања, ако је више од \fIвреме_истека\fP милисекунди (позитиван +цео број) прошло од претходног испирања и читање више улаза ће блокирати, +сви заказани улазни подаци се испирају из шифрера и чине доступним у +излазном току. Ово може бити корисно ако је \fBxz\fP коришћен за запакивање +података који су слати преко мреже. Мала вредност \fIвременског_истека\fP чини +податке доступним на пријемни крај са малим закашњењем, али велика вредност +\fIвремена_истека\fP даје бољу стопу запакивања. +.IP "" +Ова функција је искључена по основи. Ако је ова опција наведена више пута, +последња има дејства. Нарочита вредност \fIвременског истека\fP \fB0\fP може се +користити за изричито искључивање ове функције. +.IP "" +Ова функција је доступна само на POSIX системима. +.IP "" +.\" FIXME +\fBОва функција је још увек експериментална.\fP Тренутно \fBxz\fP није погодан за +распакивање тока у реалном времену због начина на који \fBxz\fP ради +међумеморисање. +.TP +\fB\-\-no\-sync\fP +Не усклађује циљну датотеку и њену фасциклу на смештајном уређају пре +уклањања изворне датотеке. Ово може побољшати учинковитост ако се запакује +или распакује много малих датотека. Међутим, ако се систем уруши одмах +након брисања, може бити да циљна датотека не буде уписана на смештајном +уређају али радња брисања јесте. У том случају неће бити доступна ни +оригинална изворна ни циљна датотека. +.IP "" +Ова опција има дејство само када се \fBxz\fP спрема да уклони изворну +датотеку. У осталим случајевима усклађивање се не ради никада. +.IP "" +Синхронизација и \fB\-\-no\-sync\fP су додате у \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIограничење\fP +Поставља ограничење коришћења меморије запакивања. Ако је ова опција +наведена више пута, последња ступа у дејство. +.IP "" +Ако поставке запакивања премаше \fIограничење\fP, \fBxz\fP ће покушати да врати +назад поставке тако да ограничење више није прекорачено и приказаће +обавештење да је урађено аутоматско дотеривање. Дотеривања се раде следећим +редом: смањење броја нити, пребацивање на режим једне нити ако чак и једна +нит у режиму више нити премаши \fIограничење\fP и на крају смањење величине +LZMA2 речника. +.IP "" +Приликом запакивања са \fB\-\-format=raw\fP или ако је наведено \fB\-\-no\-adjust\fP, +само број нити може бити умањен јер може да се уради а да се не делује на +излаз запакованог. +.IP "" +Ако \fIограничење\fP не може бити задовољено чак и са поравнањима описаним +изнад, приказује се грешка и \fBxz\fP ће изаћи са излазним стањем 1. +.IP "" +\fIОграничење\fP се може навести на више начина: +.RS +.IP \(bu 3 +\fIОграничење\fP може бити апсолутна величина у бајтима. Коришћење суфикса +целог броја као \fBMiB\fP може бити корисно. Пример: +\fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +\fIОграничење\fP се може навести као проценат укупне физичке меморије (RAM). +Ово може бити корисно нарочито приликом постављања променљиве окружења +\fBXZ_DEFAULTS\fP у скрпти покретања конзоле која се дели између различитих +рачунара. На тај начин ограничење је аутоматски веће на системима са више +меморије. Пример: \fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +\fIОграничење\fP се може вратити на своју основну вредност његовим постављањем +на \fB0\fP. Ово је тренутно исто што и постављање \fIограничења\fP на \fBmax\fP (без +ограничења коришћења меморије). +.RE +.IP "" +За \fBxz\fP 32\-бита имамо посебан случај: ако \fIограничење\fP треба да буде преко +\fB4020\ MiB\fP, \fIограничење\fP се поставља на \fB4020\ MiB\fP. Али на MIPS32 +користи се \fB2000\ MiB\fP. (На вредности \fB0\fP и \fBmax\fP ово не утиче. Слична +функција не постоји за распакивање.) Ово може бити од помоћи када извршна +од 32\-бита има приступ адресном простору од 4\ GiB (2 GiB на MIPS32) док +срећом не чини ништа лоше у осталим приликама. +.IP "" +Видите такође одељак \fBКоришћење меморије\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIограничење\fP +Поставља ограничење коришћења меморије за распакивање. Ово такође утиче на +\fB\-\-list\fP режим. Ако радња није могућа а да се не премаши \fIограничење\fP, +\fBxz\fP ће приказати грешку а распакивање датотеке неће успети. Видите +\fB\-\-memlimit\-compress=\fP\fIограничење\fP за могуће начине о навођењу +\fIограничења\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIограничење\fP +Поставља ограничење коришћења меморије за распакивање са више нити. Ово +може утицати само на број нити; ово никада неће учинити да \fBxz\fP одбије да +распакује датотеке. Ако је \fIограничење\fP превише ниско да омогући било који +рад са више нити, \fIограничење\fP се занемарује а \fBxz\fP ће наставити у режиму +једне нити. Знајте да ако се такође користи \fB\-\-memlimit\-decompress\fP, увек +ће се применити и на режим једне и на режим више нити, и тако да стварно +\fIограничење\fP за више нити никада неће бити више од ограничења постављеног +са \fB\-\-memlimit\-decompress\fP. +.IP "" +У супротности са другим опцијама ограничења коришћења меморије, +\fB\-\-memlimit\-mt\-decompress=\fP\fIограничење\fP има систему специфично основно +\fIограничење\fP. \fBxz \-\-info\-memory\fP се може користити да видите тренутну +вредност. +.IP "" +Ова опција и њена основна вредност постоје јер без икаквог ограничења нитни +распакивач ће завршити са додељивањем неразумног износа меморије са неким +улазним датотекама. Ако је основно \fIограничење\fP превише ниско на вашем +систему, слободно повећајте \fIограничење\fP али га никада не постављајте на +вредност већу од износа употребљивог RAM\-а јер са одговарајућим улазним +датотекама \fBxz\fP ће покушати да користи тај износ меморије чак и са малим +бројем нити. Остајући без меморије или разменом неће се побољшати +учинковитост распакивања. +.IP "" +Видите \fB\-\-memlimit\-compress=\fP\fIограничење\fP за могуће начине за навођење +\fIограничења\fP. Постављање \fIограничења\fP на \fB0\fP враћа \fIограничење\fP на +систему специфичну основну вредност. +.TP +\fB\-M\fP \fIограничење\fP, \fB\-\-memlimit=\fP\fIограничење\fP, \fB\-\-memory=\fP\fIограничење\fP +Ово је исто као и навођење \fB\-\-memlimit\-compress=\fP\fIограничење\fP +\fB\-\-memlimit\-decompress=\fP\fIограничење\fP +\fB\-\-memlimit\-mt\-decompress=\fP\fIограничење\fP. +.TP +\fB\-\-no\-adjust\fP +Приказује грешку и излази ако ограничење коришћења меморије не може бити +задовољено без дотеривања поставки које утичу на запаковани излаз. Тако је, +ово спречава \fBxz\fP да промени шифрера из режима више нити у режим једне нити +и да смањи величину LZMA2 речника. Чак и када се ова опција користи број +нити се може смањити да задовољи ограничење коришћења меморије јер то неће +утицати на запаковани излаз. +.IP "" +Аутоматско дотеривање је увек искључено приликом стварања сирових токова +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fIнити\fP, \fB\-\-threads=\fP\fIнити\fP +Наводи број нити радника за коришћење. Постављање \fIнити\fP на посебну +вредност \fB0\fP чини да \fBxz\fP користи онолико нити колико процесор на систему +подржава. Стварни број нити може бити мањи од \fIнити\fP ако улазна датотека +није довољно велика за нитисање са датим поставкама или ако ће коришћење +више нити премашити ограничење коришћења меморије. +.IP "" +Запакивачи једне нити и више нити дају различите излазе. запакивач једне +нити даће мању величину датотеке али само излаз из запакивача више нити може +бити распакован коришћењем више нити. Постављање \fIнити\fP на \fB1\fP користиће +режим једне нити. Постављање \fIнити\fP на неку другу вредност, укључујући +\fB0\fP, користиће запакивач више нити чак и ако систем подржава само једну нит +хардвера. (\fBxz\fP 5.2.x је користио режим једне нити у овој прилици.) +.IP "" +Да користите вишенитни режим са само једном нити, поставите \fIнити\fP на +\fB+1\fP. Префикс \fB+\fP нема дејства са вредностима које нису \fB1\fP. Ограничење +коришћења меморије може још увек учинити да се \fBxz\fP пребаци на режим једне +нити осим ако се не користи \fB\-\-no\-adjust\fP. Подршка за префикс \fB+\fP је +додата у \fBxz\fP 5.4.0. +.IP "" +Ако је затражен аутоматски број нити и није наведено ограничење коришћења +меморије, тада ће се користити основно меко ограничење специфично за систем +за могуће ограничење броја нити. То је меко ограничење у смислу да се +занемарује ако број нити постане један, дакле меко ограничење никада неће +зауставити \fBxz\fP од запакивања или распакивања. Ово основно меко ограничење +неће учинити да се \fBxz\fP пребаци из режима више нити у режим једне нити. +Активно ограничење се може видети са + \fBxz \-\-info\-memory\fP. +.IP "" +Тренутно једина метода нитисања је да се подели улаз на блокове и да се +запакују независно један од другог. Основна величина блока зависи од нивоа +запакивања и може се преписати опцијом \fB\-\-block\-size=\fP\fIвеличина\fP. +.IP "" +Нитно распакивање ради само на датотекама које садрже више блокова са +информацијом величине у заглављима блока. Све довољно велике датотеке +запаковане у вишенитном режиму задовољавају овај услов, али датотеке +запаковане у једнонитном режиму не чак и ако је коришћено +\fB\-\-block\-size=\fP\fIвеличина\fP. +.IP "" +Основна вредност за \fIнити\fP је \fB0\fP. У \fBxz\fP 5.4.x и старијим основно је +\fB1\fP. +. +.SS "Произвољни ланци филтера запакивача" +Произвољни ланац филтера омогућава детаљно одређивање подешавања сажимања +уместо да се ослања на подешавања повезана са предподешавањима. Када је +произвољни ланац филтера наведен, опције предподешавања (\fB\-0\fP \&...\& \fB\-9\fP +и \fB\-extreme\fP) раније на линији наредби се заборављају. Ако је опција +предподешавања наведена након једне или више опција произвољног ланца +филтера, ново предподешавање ступа на снагу а раније наведене опције +произвољног ланца филтера се заборављају. +.PP +Ланац филтера је упоредив са спојкама на линији наредби. Приликом сажимања, +несажети улаз иде на први филтер, чији излаз иде на следећи филтер (ако фа +има). Излаз последњег филтера бива записан у сажету датотеку. Највећи број +филтера у ланцу је четири, али обично ланац филтера има само један или два +филтера. +.PP +Многи филтери имају ограничења о томе где могу бити у ланцу филтера: неки +филтери могу радити само као последњи филтер у ланцу, неки само као +не\-последњи филтер, а неки раде на било ком месту у ланцу. Овисно о +филтеру, ово ограничење је или својствено дизајну филтера или постоји како +би се спречили проблеми безбедности. +.PP +Произвољни ланац филтера се може навести на два различита начина. Опције +\fB\-\-filters=\fP\fIфилтери\fP и \fB\-\-filters1=\fP\fIфилтери\fP \&...\& +\fB\-\-filters9=\fP\fIфилтери\fP омогућавају навођење читавог ланца опција у једној +опцији коришћењем синтаксу ниске „liblzma“ филтера. Другачије, ланац +филтера се може навести коришћењем једне или више појединачних опција +филтера редом како се траже у ланцу филтера. То је то, редослед +појединачних опција филтера је важан! Приликом дешифровања сирових токова +(\fB\-\-format=raw\fP), ланац филтера мора бити наведен истим редом као када је +био наведен приликом сажимања. Било који појединачни филтер или опције +предподешавања наведене пре опције читавог ланца (\fB\-\-filters=\fP\fIфилтери\fP) +биће заборављене. Појединачни филтери наведени после опције читавог ланца +ће поништити поставку ланца филтера. +.PP +Обе опције и пуног и појединачног филтера узимају филтеру специфичне +\fIопције\fP као зарезом раздвојен списак. Додатни зарези у \fIопцијама\fP се +занемарују. Свака опција има основну вредност, тако да треба да наведете +оне које желите да измените. +.PP +Да видите читав ланац филтера и \fIопције\fP, користите \fBxz \-vv\fP (тако је, +користите \fB\-\-verbose\fP два пута). Ово ради такође за преглед опција ланца +филтера коришћених од стране предподешености. +.TP +\fB\-\-filters=\fP\fIфилтери\fP +Наводи цео ланац филтера или предподешеност у једној опцији. Сваки филтер +се може одвојити размацима или са две цртице (\fB\-\-\fP). \fIФилтери\fP можда +треба да буду под наводницима на линији наредби конзоле тако да се +прослеђују као једна опција. Да означите \fIопције\fP, користите \fB:\fP или +\fB=\fP. Предподешености се може додати префикс \fB\-\fP и може га пратити нула +или још заставица. Једина подржана заставица је \fBe\fP за примену истих +опција као \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIфилтери\fP ... \fB\-\-filters9\fP=\fIфилтери\fP +Наводи до девет додатних ланаца филтера који се могу користити са +\fB\-\-block\-list\fP. +.IP "" +На пример, приликом запакивања архиве са извршним датотекама за којима следе +текстуалне датотеке, извршни део треба да користи ланац филтера са BCJ +филтером а текстуални део само LZMA2 филтер. +.TP +\fB\-\-filters\-help\fP +Приказује поруку помоћи описујући како се наводе предподешавања и произвољни +ланци филтера у опцијама \fB\-\-filters\fP и \fB\-\-filters1=\fP\fIфилтери\fP \&...\& +\fB\-\-filters9=\fP\fIфилтери\fP, и успешно излази. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIопције\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIопције\fP] +.PD +Додаје LZMA1 или LZMA2 филтер у ланац филтера. Ови филтери се могу +користити само као последњи филтер у ланцу. +.IP "" +LZMA1 је стари филтер, који је подржан углавном само због старог формата +\&\fB.lzma\fP датотеке, који подржава само LZMA1. LZMA2 је освежено издање LZMA1 +које поправља неке практичне проблеме LZMA1. \fB.xz\fP формат користи LZMA2 и +не подржава LZMA1 уопште. Брзина запакивања и односи LZMA1 и LZMA2 су +практично исти. +.IP "" +LZMA1 и LZMA2 деле исти скуп \fIопција\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIпредподешавање\fP +Враћа све LZMA1 или LZMA2 \fIопције\fP на \fIпредподешеност\fP. \fIПредпдешеност\fP +се састоји од целог броја, за којим може да следи једнословни измењивач +предподешености. Цео број може бити од \fB0\fP до \fB9\fP, поклапајући опције +линије наредби \fB\-0\fP \&...\& \fB\-9\fP. Једини тренутно подржани измењивач је +\fBe\fP, који се поклапа са \fB\-\-extreme\fP. Ако \fBpreset\fP није наведено, основне +вредности LZMA1 или LZMA2 \fIопција\fP се узимају из предподешености \fB6\fP. +.TP +\fBdict=\fP\fIвеличина\fP +\fIВеличина\fP речника (међумеморија историјата) указује на то колико је +бајтова недавно обрађених нераспакованих података задржано у меморији. +Алгоритам покушава да нађе понављајуће низове бајтова (поклапања) у +нераспакованим подацима, и да их замени са упутама ка подацима који су +тренутно у речнику. Што је већи речник, већа је вероватноћа за налажење +поклапања. Стога, повећање \fIвеличине \fP речника обично побољшава стопу +запакивања, али речник већи од незапаковане датотеке јесте утрошак меморије. +.IP "" +Уобичајена \fIвеличина\fP речника је од 64\ KiB до 64\ MiB. Најмање је 4\ KiB. Највише за запакивање тренутно је 1.5\ GiB (1536\ MiB). Распакивач +већ подржава речнике до једног бајта мање од 4\ GiB, што је максимум за +формате LZMA1 и LZMA2 тока. +.IP "" +\fIВеличина\fP речника и налазач поклапања (\fImf\fP) заједно одређују коришћење +меморије за LZMA1 или LZMA2 шифрере. Иста (или већа) \fIвеличина\fP речника је +потребна за распакивање као она која је коришћена за запаквање, стога се +коришћење меморије дешифрера одређује према величини речника коришћеног за +запакивање. \fB.xz\fP заглавља чувају \fIвеличину\fP речника или као 2^\fIn\fP или +2^\fIn\fP + 2^(\fIn\fP\-1), тако да су те \fIвеличине\fP некако пожељније за +запакивање. Друге \fIвеличине\fP биће заокружене приликом чувања у \fB.xz\fP +заглављима. +.TP +\fBlc=\fP\fIlc\fP +Наводи број битова контекста литерала. Најмање је 0 а највише је 4; основно +је 3. Као додатак, збир \fIlc\fP и \fIlp\fP не сме да премаши 4. +.IP "" +Сви бајтови који се не могу шифровати јер су поклапања шифрована као +литерали. То је то, литерали су једноставно 8\-битни бајтови који су +шифровани један по један. +.IP "" +Кодирање литерала врши претпоставку да највећи \fIlc\fP битови претходног +незапакованог бајта су у узајамној вези са следећим бајтом. На пример, у +уобичајеном енглеском тексту, за великим словом често следи мало слово, а за +малим словом обично следи још једно мало слово. У скупу US\-ASCII знакова, +највиша три бита су 010 за велика слова и 011 за мала слова. Када је \fIlc\fP +барем 3, кодирање литерала може имати предност овог својства у незапакованим +подацима. +.IP "" +Основна вредност (3) је обично добра. Ако желите највеће запакивање, +испробајте \fBlc=4\fP. Некад то мало помогне а некад чини запакивање горим. +Ако га учини горим, испробајте такође \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Наводи број битова положаја литерала. Најмање је 0 а највише је 4; основно +је 0. +.IP "" +\fILp\fP утиче на то која врста поравнања у незапакованим подацима се +подразумева приликом шифровања литерала. Видите \fIpb\fP испод за више +информација о поравнању. +.TP +\fBpb=\fP\fIpb\fP +Наводи број битова положаја. Најмање је 0 а највише је 4; основно је 2. +.IP "" +\fIPb\fP утиче на то која врста поравнања у незапакованим подацима се +подразумева у опште. Основно значи четворобајтно поравнање (2^\fIpb\fP=2^2=4), +што је често добар избор када нема бољег решења. +.IP "" +Када је поравнање познато, постављање одговарајућег \fIpb\fP може мало да смањи +величину датотеке. На пример, са датотекама текста које имају поравнање +једног бајта (US\-ASCII, ISO\-8859\-*, UTF\-8), постављање \fBpb=0\fP може незнатно +да побољша запакивање. За UTF\-16 текст, \fBpb=1\fP је добар избор. Ако је +поравнање непаран број као 3 бајта, \fBpb=0\fP може бити најбољи избор. +.IP "" +Иако се претпостављено поравнање може подесити са \fIpb\fP и \fIlp\fP, LZMA1 и +LZMA2 и даље незнатно фаворизују 16\-бајтно поравнање. То би могло бити +вредно узети у обзир приликом дизајнирања формата датотека које ће вероватно +бити често запаковане са LZMA1 или LZMA2. +.TP +\fBmf=\fP\fImf\fP +Налазач поклапања има главни утицај на брзину шифрера, коришћење меморије и +стопу запакивања. Обично Hash Chain налазачи поклапања су бржи од Binary +Tree налазача поклапања. Основност зависи од \fIпредподешености\fP: 0 користи +\fBhc3\fP, 1\(en3 користи \fBhc4\fP, а остало користи \fBbt4\fP. +.IP "" +Следећи налазачи поклапања су подржани. Формуле коришћења меморије испод су +грубе апроксимације које су ближе стварности када је \fIречник\fP степен +двојке. +.RS +.TP +\fBhc3\fP +Ланац хеша са хеширањем 2\- и 3\-бајта +.br +Најмања вредност за \fIфино\fP: 3 +.br +Коришћење меморије: +.br +\fIречник\fP * 7.5 (ако је \fIречник\fP <= 16 MiB); +.br +\fIречник\fP * 5.5 + 64 MiB (if \fIречник\fP > 16 MiB) +.TP +\fBhc4\fP +Ланац хеша са хеширањем 2\-, 3\- и 4\-бајта +.br +Најмања вредност за \fIфино\fP: 4 +.br +Коришћење меморије: +.br +\fIречник\fP * 7.5 (ако је \fIречник\fP <= 32 MiB); +.br +\fIречник\fP * 6.5 (ако је \fIречник\fP > 32 MiB) +.TP +\fBbt2\fP +Бинарно стабло са 2\-бајта хеширања +.br +Најмања вредност за \fIфино\fP: 2 +.br +Коришћење меморије: \fIречник\fP * 9.5 +.TP +\fBbt3\fP +Бинарно стабло са 2\- и 3\-бајта хеширања +.br +Најмања вредност за \fIфино\fP: 3 +.br +Коришћење меморије: +.br +\fIречник\fP * 11.5 (if \fIречник\fP <= 16 MiB); +.br +\fIречник\fP * 9.5 + 64 MiB (ако је \fIречник\fP > 16 MiB) +.TP +\fBbt4\fP +Бинарно стабло са 2\-, 3\-, и 4\-бајта хеширања +.br +Најмања вредност за \fIфино\fP: 4 +.br +Коришћење меморије: +.br +\fIречник\fP * 11.5 (if \fIречник\fP <= 32 MiB); +.br +\fIречник\fP * 10.5 (if \fIречник\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fIрежим\fP +\fIРежим\fP запакивања наводи методу за анализу података које произведе налазач +поклапања. Подржани \fIрежими\fP су \fBfast\fP и \fBnormal\fP. Подразумева се +\fBfast\fP за \fIпредподешавања\fP 0\(en3 и \fBnormal\fP за \fIпредподешавања\fP 4\(en9. +.IP "" +Обично се \fBfast\fP користи са налазачима Hash Chain поклапања а \fBnormal\fP са +налазачима Binary Tree поклапања. Ово је исто што раде и +\fIпредподешености\fP. +.TP +\fBnice=\fP\fIфино\fP +Наводи оно што се сматра да је фина дужина за поклапање. Када се поклапање +од барем \fInice\fP бајтова нађе, алгоритам зауставља тражење могућих бољих +поклапања. +.IP "" +\fIФино\fP може бити 2\(en273 бајта. Веће вредности теже да дају бољу стопу +запакивања на уштрб брзине. Основно зависи од \fIпредподешавања\fP. +.TP +\fBdepth=\fP\fIдубина\fP +Наводи највећу дубину претраге у налазачу поклапања. Основно је посебна +вредност 0, која чини да запакивач одреди разумљиву \fIдубину\fP из \fImf\fP и +\fInice\fP. +.IP "" +Разумљива \fIдубина\fP за ланце хеша је 4\(en100 и 16\(en1000 за стабло +извршних. Коришћење врло великих вредности за \fIдубину\fP може учинити шифрер +врло спорим са неким датотекама. Избегавајте постављање \fIдубине\fP преко +1000 осим ако нисте спремни да прекинете запакивање у случају да потраје +превише дуго. +.RE +.IP "" +Приликом дешифровања сирових токова (\fB\-\-format=raw\fP), LZMA2 треба само +\fIвеличина\fP речника. LZMA1 треба такође \fIlc\fP, \fIlp\fP и \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIопције\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIопције\fP] +.PD +Додаје „branch/call/jump“ (BCJ) филтер ланцу филтера. Ови филтери могу се +користити само ако нису последњи филтер у ланцу филтера. +.IP "" +BCJ филтер претвара релативне адресе у машинском коду на њихове апсолутне +двојнике. Ово не мења величину података, али повећава сувишност, што може +помоћи LZMA2 да произведе 0\(en15\% мању \fB.xz\fP датотеку. BCJ филтери су +увек реверзибилни, стога коришћење BCJ филтера за погрешну врсту података не +доводи ни до каквог губитка података, мада може да учини степен сажимања +нешто лошијим. BCJ филтери су врло брзи и користе безначајну количину +меморије. +.IP "" +Ови BCJ филтери имају познате проблеме везане за стопу запакивања: +.RS +.IP \(bu 3 +Неке врсте датотека које садрже извршни код (на пример, објектне датотеке, +статичке библиотеке и модули Линукс кернела) имају адресе у упутствима +испуњеним вредностима попуњавача. Ови BCJ филтери и даље ће радити +претварање адресе, што ће запакивање учинити горим са овим датотекама. +.IP \(bu 3 +Ако се BCJ филтер примени на архиву, могуће је да ће учинити стопу +запакивања лошијим него кад се не би користио. На пример, ако постоје +сличне или чак истоветне извршне тада ће филтрирање вероватно учинити +датотеке мање сличним и стога је запакивање лошије. Садржај не\-извршних +датотека у истој архиви је такође важан. У пракси се мора покушати са и без +BCJ филтера да би се видело шта је боље у којој прилици. +.RE +.IP "" +Различити скупови упутстава имају различита поравнања: извршна датотека мора +бити поравната на множилац ове вредности у улазним подацима како би филтер +радио. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Филтер;Поравнање;Напомене +x86;1;32\-бита или 64\-бита x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096\-бита поравнање је најбоље +PowerPC;4;Само велика крајност +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Како су BCJ\-филтрирани подаци обично запаковани са LZMA2, стопа запакивања +може бити незнатно побољшана ако су LZMA2 опције постављене да поклопе +поравнање изабраног BCJ филтера. Примери: +.RS +.IP \(bu 3 +IA\-64 филтер има поравнање 16\-бајта тако да је \fBpb=4,lp=4,lc=0\fP добро са +LZMA2 (2^4=16). +.IP \(bu 3 +RISC\-V код има поравнање од 2 или 4 бајта у зависности од тога да ли +датотека садржи запаковане инструкције од 16 бита (проширење C). Када се +користе инструкције од 16 бита, \fBpb=2,lp=1,lc=3\fP или \fBpb=1,lp=1,lc=3\fP је +добро. Када нема инструкција од 16 бита, \fBpb=2,lp=2,lc=2\fP је најбоље. +\fBreadelf \-h\fP се може користити да се провери да ли се „RVC“ јавља у реду +„Заставице“. +.IP \(bu 3 +ARM64 је увек 4\-бајта поравнат тако да је \fBpb=2,lp=2,lc=2\fP најбоље. +.IP \(bu 3 +Филтер x86 је изузетак. Обично је добро придржавати се LZMA2 основности +(\fBpb=2,lp=0,lc=3\fP) приликом запакивања x86 извршних. +.RE +.IP "" +Сви BCJ филтери подржавају исте \fIопције\fP: +.RS +.TP +\fBstart=\fP\fIпомерај\fP +Наводи \fIпомерај\fP почетка који се користи приликом претварања између +релативних и апсолутних адреса. \fIПомерај\fP мора бити производ поравнања +филтера (видите табелу изнад). Основно је нула. У пракси, основност је +добра; навођење произвољног \fIпомераја\fP скоро никада није од користи. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIопције\fP] +Додаје Delta филтер у ланац филтера. Делта филтер може се користити само +ако није последњи филтер у ланцу филтера. +.IP "" +Тренутно је подржан само једноставан делта прорачун једног по једног бита. +Може бити користан приликом запакивања, на пример, незапакованих битмап +слика или незапакованог PCM звука. Међутим, алгоритми посебне намене могу +дати знатно боље резултате него Delta + LZMA2. Ово је тачно, посебно са +звуком, који се запакује брже и боље, на пример, са \fBflac\fP(1). +.IP "" +Подржане \fIопције\fP: +.RS +.TP +\fBdist=\fP\fIрастојање\fP +Наводи \fIрастојање\fP делта прорачуна у бајтима. \fIРастојање\fP мора бити +1\(en256. Основно је 1. +.IP "" +На пример, са \fBdist=2\fP и осмобајтним улазом A1 B1 A2 B3 A3 B5 A4 B7, излаз +ће бити A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Остале опције" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Потискује упозорења и обавештења. Наведите ово два пута да потиснете и +грешке. Ова опција нема утицаја на стање излаза. Тако је, чак и ако је +упозорење потиснуто, стање излаза које указује на упозорење се и даље +користи. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Бива опширан. Ако је стандардна грешка повезана са терминалом, \fBxz\fP ће +приказати указивач напретка. Навођењем \fB\-\-verbose\fP два пута добија се још +опширнији излаз. +.IP "" +Указивач напредовања показује следеће информације: +.RS +.IP \(bu 3 +Проценат довршености се показује ако је величина улазне датотеке позната. +Тако је, проценат се не може приказати у спојкама. +.IP \(bu 3 +Количина запакованих података проистеклих (запакивање) или утрошених +(распакивање). +.IP \(bu 3 +Количина распакованих података утрошених (запакивање) или проистеклих +(распакивање). +.IP \(bu 3 +Размера паковања, која се израчунава дељењем количине запакованих података +обрађених до сада количином незапакованих података до сада обрађених. +.IP \(bu 3 +Брзина запакивања или распакивања. Ово се мери као количина незапакованих +података утрошених (запакивање) или добијених (распакивање) у секунди. +Приказује се након неколико секунде након што \fBxz\fP започне обраду датотеке. +.IP \(bu 3 +Протекло време у формату М:СС или Ч:ММ:СС. +.IP \(bu 3 +Процењено преостало време се приказује само када је величина улазне датотеке +позната и неколико секунди је већ протекло од кад је \fBxz\fP започео обраду +датотеке. Време се приказује у мање тачном формату које никада нема +двотачке, на пример, 2 мин 30 сек. +.RE +.IP "" +Када стандардна грешка није терминал, \fB\-\-verbose\fP ће учинити да \fBxz\fP +испише назив датотеке, запаковану величину, незапаковану величину, стопу +запакивања и по могућству такође брзину и протекло време на једном реду на +стандардну грешку након запакивања или распакивања датотеке. Брзина и +протекло време су укључени само када радња потраје барем неколико секунде. +Ако се радња не заврши, на пример, услед што корисник прекине, такође се +исписује проценат завршености ако је величина улазне датотеке позната. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Не поставља стање излаза на 2 чак и ако је услов вредан упозорења откривен. +Ова опција не утиче на ниво опширности, стога и \fB\-\-quiet\fP и \fB\-\-no\-warn\fP +треба да се користе да се не приказују упозорења и да се не измени стање +излаза. +.TP +\fB\-\-robot\fP +Исписује поруке у формату обрадивом машинама. Ово је замишљено да олакша +писање челника који желе да користе \fBxz\fP уместо „liblzma“, што може бити +случај са разним скриптама. Излаз са овом опцијом укљученом је замишљен да +буде стабилан кроз \fBxz\fP издања. Видите одељак \fBРЕЖИМ РОБОТА\fP за више о +томе. +.TP +\fB\-\-info\-memory\fP +Приказује, у формату читљивом људима, колико физичке меморије (RAM) и колико +нити процесора \fBxz\fP мисли да систем има и ограничења коришћења меморије за +запакивање и распакивање и излази успешно. +.TP +\fB\-h\fP, \fB\-\-help\fP +Приказује поруку помоћи описујући најчешће коришћених опција, и успешно +излази. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Приказује поруку помоћи описујући све функције \fBxz\fP, и успешно излази +.TP +\fB\-V\fP, \fB\-\-version\fP +Приказује број издања за \fBxz\fP и „liblzma“ у формату читљивом људима. Да +добијете излаз машинама обрадив, наведите \fB\-\-robot\fP пре \fB\-\-version\fP. +. +.SH "РЕЖИМ РОБОТА" +Режим робота се покреће опцијом \fB\-\-robot\fP. Чини да излаз \fBxz\fP буде лакши +за обраду другим програмима. Тренутно \fB\-\-robot\fP је подржано само заједно +са \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, и \fB\-\-version\fP. Биће +подржан за запакивање и распакивање у будућности. +. +.SS "Режим списка" +\fBxz \-\-robot \-\-list\fP користи излаз раздвојен табулатором. Прва колона +сваког реда садржи ниску која указује на врсту информације која се налази у +том реду: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP (назив) +Ово је увек први ред приликом почетка листања датотеке. Друга колона у реду +је назив датотеке. +.TP +\fBfile\fP (датотека) +Овај ред садржи свеукупне информације о \fB.xz\fP датотеци. Овај ред се увек +исписује после реда \fBназив\fP. +.TP +\fBstream\fP (ток) +Ова врста реда се користи само када је \fB\-\-verbose\fP наведено. Има толико +редова \fBтока\fP колико има токова у \fB.xz\fP даатотеци. +.TP +\fBblock\fP (блок) +Ова врста реда се користи само када је \fB\-\-verbose\fP наведено. Има онолико +редова \fBблока\fP колико има блокова у \fB.xz\fP датотеци. Редови \fBблока\fP се +приказују након свих редова \fBтока\fP; различите врсте реда се не преплићу. +.TP +\fBsummary\fP (сажетак) +Ова врста реда се користи само када је \fB\-\-verbose\fP наведено два пута. Овај +ред се исписује након свих редова \fBблока\fP. Као ред \fBдатотека\fP, ред +\fBсажетка\fP садржи преглед информација о \fB.xz\fP датотеци. +.TP +\fBtotals\fP (укупност) +Овај ред је увек последњи ред на списку излаза. Показује укупне збирове и +величине. +.PP +Колоне редова \fBдатотеке\fP: +.PD 0 +.RS +.IP 2. 4 +Број токова у датотеци +.IP 3. 4 +Укупан број блокова у току(овима) +.IP 4. 4 +Величина запаковане датотеке +.IP 5. 4 +Величина незапаковане датотеке +.IP 6. 4 +Размера паковања, на пример, \fB0.123\fP. Ако је размера преко 9.999, три +цртице (\fB\-\-\-\fP) се приказују уместо размере. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Зарезом раздвојен списак назива провера целовитости. Следеће ниске се +користе за познате врсте провера: \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP и \fBSHA\-256\fP. +За непознате врсте провера, користи се \fBUnknown\-\fP\fIN\fP, где је \fIN\fP ИД +провере као децимални број (једна или две цифре). +.IP 8. 4 +Укупна величина попуњавања тока у датотеци +.RE +.PD +.PP +Колоне редова \fBтока\fP: +.PD 0 +.RS +.IP 2. 4 +Број тока (први ток је 1) +.IP 3. 4 +Број блокова у току +.IP 4. 4 +Померај почетка запакованог +.IP 5. 4 +Померај почетка незапаковане +.IP 6. 4 +Величина запакованог (не укључује попуну тока) +.IP 7. 4 +Величина незапаковане +.IP 8. 4 +Размера паковања +.IP 9. 4 +Назив провере целовитости +.IP 10. 4 +Величина попуне тока +.RE +.PD +.PP +Колоне редова \fBблока\fP: +.PD 0 +.RS +.IP 2. 4 +Број тока који садржи овај блок +.IP 3. 4 +Број блока релативан на почетак тока (први блок је 1) +.IP 4. 4 +Број блока релативан на почетак датотеке +.IP 5. 4 +Померај почетка запакованог односан на почетак датотеке +.IP 6. 4 +Померај почетка незапаковане односан на почетак датотеке +.IP 7. 4 +Укупна запакована величина блока (заједно са заглављима) +.IP 8. 4 +Величина незапаковане +.IP 9. 4 +Размера паковања +.IP 10. 4 +Назив провере целовитости +.RE +.PD +.PP +Ако је \fB\-\-verbose\fP наведено два пута, додатне колоне су укључене у редовима +\fBблока\fP. Они се не приказују са једним \fB\-\-verbose\fP, јер добијање ове +информације захтева много тражења и стога може бити споро: +.PD 0 +.RS +.IP 11. 4 +Вредност провере целовитости у хексадецималном облику +.IP 12. 4 +Величина заглавља блока +.IP 13. 4 +Заставице блока: \fBc\fP указује да је величина запакованог присутна, а \fBu\fP +указује да је величина нераспакованог присутна. Ако заставица није +постављена, цртица (\fB\-\fP) се приказује уместо да се настави са поправком +дужине ниске. У будућности нове заставице могу бити додате на крај ниске. +.IP 14. 4 +Величина стварних запакованих података у блоку (ово искључује заглавље +блока, попуњавање блока и поља провере) +.IP 15. 4 +Количина меморије (у бајтовима) потребна за распакивање овог блока са овим +\fBxz\fP издањем +.IP 16. 4 +Ланац филтера. Знајте да већина опција коришћених за време запакивања не +може бити познато, јер се само опције које су потребне за распакивање чувају +у \fB.xz\fP заглављима. +.RE +.PD +.PP +Колоне редова \fBсажетка\fP: +.PD 0 +.RS +.IP 2. 4 +Количина меморије (у бајтовима) потребна за распакивање ове датотеке са овим +\fBxz\fP издањем +.IP 3. 4 +\fByes\fP или \fBno\fP указује да ли сва заглавља блока имају и величину +запакованог и величину незапакованог сачуване у њима +.PP +\fIОд\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Потребно је најмање \fBxz\fP издање за распакивање датотеке +.RE +.PD +.PP +Колоне редова \fBукупности\fP: +.PD 0 +.RS +.IP 2. 4 +Број токова +.IP 3. 4 +Број блокова +.IP 4. 4 +Величина запакованог +.IP 5. 4 +Величина незапаковане +.IP 6. 4 +Просечан степен запакивања +.IP 7. 4 +Списак зарезом раздвојених назива провере целовитости која су била присутна +у датотекама +.IP 8. 4 +Величина попуњавања тока +.IP 9. 4 +Број датотека. Ту се држи поредак ранијих колона исто као у редовима +\fBдатотеке\fP. +.PD +.RE +.PP +Ако је \fB\-\-verbose\fP наведено два пута, додатне колоне су укључене у реду +\fBtotals\fP: +.PD 0 +.RS +.IP 10. 4 +Највећа количина меморије (у бајтима) потребна за распакивање датотеке са +овим \fBxz\fP издањем +.IP 11. 4 +\fByes\fP или \fBno\fP указује да ли сва заглавља блока имају и величину +запакованог и величину незапакованог сачуване у њима +.PP +\fIОд\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Потребно је најмање \fBxz\fP издање за распакивање датотеке +.RE +.PD +.PP +Будућа издања могу додати нове врсте реда и нове колоне се могу додати +постојећим врстама реда, али постојеће колоне се неће променити. +. +.SS "Помоћ филтера" +\fBxz \-\-robot \-\-filters\-help\fP исписује подржане филтере у следећем формату: +.PP +\fIфилтер\fP\fB:\fP\fIопција\fP\fB=<\fP\fIвредност\fP\fB>,\fP\fIопција\fP\fB=<\fP\fIвредност\fP\fB>\fP... +.TP +\fIфилтер\fP +Назив филтера +.TP +\fIопција\fP +Назив филтера специфичне опције +.TP +\fIвредност\fP +Опсези бројевних \fIвредности\fP се јављају као +\fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. \fIВредност\fP ниске избора се приказују +унутар \fB< >\fP и раздвојене су знаком \fB|\fP. +.PP +Сваки филтер се исписује на свом сопственом реду. +. +.SS "Информације о ограничењу меморије" +\fBxz \-\-robot \-\-info\-memory\fP исписује један ред са више колона раздвојених +табулатором: +.IP 1. 4 +Укупна количина физичке меморије (RAM) у бајтима. +.IP 2. 4 +Ограничење коришћења меморије за запакивање у бајтима +(\fB\-\-memlimit\-compress\fP). Специјална вредност \fB0\fP означава основно +подешавање које је за режим једне нити исто као без ограничења. +.IP 3. 4 +Ограничење коришћења меморије за распакивање у бајтима +(\fB\-\-memlimit\-decompress\fP). Специјална вредност \fB0\fP означава основно +подешавање које је за режим једне нити исто као без ограничења. +.IP 4. 4 +Од \fBxz\fP 5.3.4alpha: Коришћење меморије за распакивање са више нити у +бајтима (\fB\-\-memlimit\-mt\-decompress\fP). Ово никада није нула јер систему +специфична основна вредност приказана у колони 5 се користи ако ограничење +није изричито наведено. Такође никада није веће од вредности у колони 3 чак +и ако је наведена већа вредност са \fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Од \fBxz\fP 5.3.4alpha: Систему специфично основно ограничење коришћења +меморије које се користи за ограничавање броја нити приликом запакивања са +аутоматским бројем нити (\fB\-\-threads=0\fP) и без наведеног ограничења +коришћења меморије (\fB\-\-memlimit\-compress\fP). Ово се такође користи као +основна вредност за \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Од \fBxz\fP 5.3.4alpha: Број доступних нити обрађивача. +.PP +У будуће, излаз \fBxz \-\-robot \-\-info\-memory\fP може имати више колона, али +никада више од једног реда. +. +.SS Издање +\fBxz \-\-robot \-\-version\fP исписује број издања за \fBxz\fP и „liblzma“ у следећем +формату: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Главно издање. +.TP +\fIYYY\fP +Споредно издање. Парни бројеви су стабилна а непарни су алфа или бета +издања. +.TP +\fIZZZ\fP +Ниво закрпе за стабилна издања или само бројач за развојна издања. +.TP +\fIS\fP +Стабилност. 0 је алфа, 1 је бета, а 2 је стабилно. \fIS\fP треба увек да буде +2 када је \fIYYY\fP парно. +.PP +\fIXYYYZZZS\fP су исти у оба реда ако су \fBxz\fP и „liblzma“ из истог издања XZ +Utils\-а. +.PP +Примери: 4.999.9beta је \fB49990091\fP и 5.0.0 је \fB50000002\fP. +. +.SH "СТАЊЕ ИЗЛАЗА" +.TP +\fB0\fP +Све је у реду. +.TP +\fB1\fP +Дошло је до грешке. +.TP +\fB2\fP +Десило се нешто вредно упозорења, али није дошло до стварних грешака. +.PP +Обавештења (без упозорења или грешака) исписано на стандардној грешци не +утичу на стање излаза. +. +.SH ОКРУЖЕЊЕ +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP обрађује размаком одвојени списак опција из променљивих окружења +\fBXZ_DEFAULTS\fP и \fBXZ_OPT\fP, тим редом, пре обраде опција са линије наредби. +Знајте да се обрађују само опције из променљивих окружења; све што нису +опције се тихо занемарује. Обрада се ради са \fBgetopt_long\fP(3) која се +користи такође за аргументе линије наредби. +.PP +\fBУпозорење:\fP Постављањем ових променљивих окружења, ефективно мењате +програме и скрипте које покреће \fBxz\fP. У већини случајева је безбедно +поставити ограничење коришћења, број нити и опција паковања путем +променљивих окружења. Међутим, неке опције могу да уруше скрипте. +Очигледан пример је \fB\-\-help\fP која чини да \fBxz\fP прикаже текст помоћи уместо +да запакује или распакује датотеку. Суптилнији примери су \fB\-\-quiet\fP и +\fB\-\-verbose\fP. У многим случајевима добро функционише омогућавање указивача +напредовања коришћењем \fB\-\-verbose\fP, али у неким ситуацијама додатне поруке +стварају проблеме. Ниво опширности такође утиче на понашање \fB\-\-list\fP +.TP +\fBXZ_DEFAULTS\fP +Кориснику специфичне или свеопште системске основне опције. Обично је ово +постављено у скрипти покретања конзоле за укључивање \fBxz\fP ограничавача +коришћења меморије по основи или за постављање основног броја нити. +Искључивање скрипти покретања конзоле и сличних специјалних случајева, +скрипте не смеју никада да поставе или пониште \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Ово је за прослеђивање опција ка \fBxz\fP када није могуће поставити опције +директно на \fBxz\fP линији наредби. Ово је случај када је \fBxz\fP покренут +скриптом или алатом, на пример, са Гну \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Скрипте могу да користе \fBXZ_OPT\fP, на пример, за постављање основних опција +запакивања специфичних скрипти. Још увек се препоручује омогућавање +корисницима да пишу преко \fBXZ_OPT\fP ако је то разумљиво. На пример, у +\fBsh\fP(1) скриптама неко може користити нешто као ово: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "LZMA UTILS САДЕЈСТВЕНОСТ" +Синтакса линије наредби \fBxz\fP је практично супер скуп \fBlzma\fP, \fBunlzma\fP и +\fBlzcat\fP као што се налази у LZMA Utils 4.32.x. У већини случајева, могуће +је заменити LZMA Utils са XZ Utils без оштећења постојећих скрипти. Има +неких несагласности такође, које понекад могу довести до проблема. +. +.SS "Нивои предподешавања запакивања" +Набрајање предподешености нивоа запакивања није исто у \fBxz\fP и LZMA Utils. +Најважнија разлика је у томе како се величине речника мапирају у различитим +предподешеностима. Величина речника је отприлике иста као и коришћење +меморије распакивача. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Ниво;xz;LZMA Utils +\-0;256 KiB;Н/Д +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Разлике величине речника делују такође на коришћење меморије запакивање, али +постоје још неке разлике између LZMA Utils и XZ Utils, што чини разлике још +већим: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Ниво;xz;LZMA Utils 4.32.x +\-0;3 MiB;Н/Д +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Основни ниво предподешености у LZMA Utils је \fB\-7\fP док у XZ Utils је \fB\-6\fP, +тако да оба користе 8 MiB речник по основи. +. +.SS "Токовне наспрам не\-токовних „.lzma“ датотеке" +Незапакована величина датотеке се може чувати у \fB.lzma\fP заглављу. LZMA +Utils то ради приликом запакивања обичних датотека. Алтернатива је да се +означи та незапакована величина као непозната и да се користи означавач +краја утовара да назначи где распакивач треба да стане. LZMA Utils користи +ову методу када незапакована величина није позната, што је случај, на +пример, у спојкама. +.PP +\fBxz\fP подржава распакивање \fB.lzma\fP датотека са или без означавача краја +утовара, али ће све \fB.lzma\fP датотеке направљене са \fBxz\fP користити +означавач краја утовара и означити незапаковану величину непознатом у +\&\fB.lzma\fP заглављу. Ово може бити проблем у неким неуобичајеним +ситуацијама. На пример, \fB.lzma\fP распакивач у угнежденом уређају може +радити само са датотекама које имају незапаковану величину. Ако наиђете на +тај проблем, треба да користите LZMA Utils или LZMA SDK да направите +\&\fB.lzma\fP датотеке са познатом незапакованом величином. +. +.SS "Неподржане „.lzma“ датотеке" +Формат \fB.lzma\fP омогућава \fIlc\fP вредности све до 8, а \fIlp\fP вредности све до +4. LZMA Utils може да распакује датотеке са било којим \fIlc\fP и \fIlp\fP, али +увек прави датотеке са \fBlc=3\fP и \fBlp=0\fP. Прављење датотека са другим \fIlc\fP +и \fIlp\fP је мгуће са \fBxz\fP и са LZMA SDK. +.PP +Примена филтера LZMA1 у „liblzma“ захтева да збир \fIlc\fP и \fIlp\fP не сме да +премаши 4. Стога, \fB.lzma\fP датотеке, које премаше ово ограничење, не могу +да се распакују са \fBxz\fP. +.PP +LZMA Utils прави само \fB.lzma\fP датотеке које имају величину речника од +2^\fIn\fP (степен 2) али прихвата датотеке са било којом величином речника. +„liblzma“ прихвата само \fB.lzma\fP датотеке које имају величину речника од +2^\fIn\fP или 2^\fIn\fP + 2^(\fIn\fP\-1). Ово је да се смање лажни позитивни +резултати приликом откривања \fB.lzma\fP датотека. +.PP +Ова ограничења не би требало да буду проблем у пракси, јер су практично све +\&\fB.lzma\fP датотеке запаковане са поставкама које ће „liblzma“ прихватити. +. +.SS "Пратеће смеће" +Приликом распакивања, LZMA Utils тихо занемарује све после првог \fB.lzma\fP +тока. У већини прилика, ово је грешка. Ово такође значи да LZMA Utils не +подржава распакивање надовезаних \fB.lzma\fP датотека. +.PP +Ако су остали подаци након првог \fB.lzma\fP тока, \fBxz\fP сматра да је датотека +оштећена осим ако је коришћено \fB\-\-single\-stream\fP. Ово може прекинути +нејасне скрипте које су претпоставиле да је пратеће смеће занемарено. +. +.SH НАПОМЕНЕ +. +.SS "Излаз запакованог може бити променљив" +Тачан запаковани излаз добијен из исте незапаковане улазне датотеке може се +разликовати између XZ Utils издања чак и ако су опције запакивања +истоветне. Ово је због тога што шифрер може бити побољшан (брже и боље +запакивање) а да не утиче на формат датотеке. Излаз се може разликовати +између различитих изградњи истог XZ Utils издања, ако су коришћене другачије +опције изградње. +.PP +Ово изнад значи да када се \fB\-\-rsyncable\fP једном примени, резултирајућа +датотека неће неопходно бити r\-ускладива осим ако и стара и нова датотека +нису запаковане истим xz издањем. Овај проблем може бити поправљен ако је +део примене шифрера замрзнут да држи r\-ускладив излаз стабилним кроз xz +издања. +. +.SS "Угнеждени „.xz“ распакивачи" +Примена угнежденог \fB.xz\fP распакивача као што је XZ Embedded неопходно не +подржава датотеке направљене врстама \fIпровере\fP целовитости осим \fBnone\fP и +\fBcrc32\fP. Како је основно \fB\-\-check=crc64\fP, морате да користите +\fB\-\-check=none\fP или \fB\-\-check=crc32\fP када правите датотеке за угнеждене +системе. +.PP +Споља уграђени системи, сви распакивачи \fB.xz\fP формата подржавају све врсте +\fIпровере\fP, или барем могу да распакују датотеку без испитивања провере +целовитости ако одређена \fIпровера\fP није подржана. +.PP +XZ Embedded подржава BCJ филтере, али само са основним померајем почетка. +. +.SH ПРИМЕРИ +. +.SS Основно +Запакује датотеку \fIfoo\fP у \fIfoo.xz\fP користећи основни ниво запакивања +(\fB\-6\fP), и уклања \fIfoo\fP ако је запакивање успешно: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Распакује \fIbar.xz\fP у \fIbar\fP и не уклања \fIbar.xz\fP чак и када је распакивање +успешно: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Ствара \fIbaz.tar.xz\fP са предподешавањем \fB\-4e\fP (\fB\-4 \-\-extreme\fP), које је +спорије него основно \fB\-6\fP, али захтева мање меморије за запакивање и +распакивање (48\ MiB и 5\ MiB): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Мешавина сажетих и несажетих датотека се може распаковати на стандардни +излаз једном наредбом: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Паралелно запакивање више датотека" +На GNU и *BSD, \fBfind\fP(1) и \fBxargs\fP(1) се могу користити за паралелно +запакивање више датотека: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Опција \fB\-P\fP за \fBxargs\fP(1) поставља број паралелних \fBxz\fP процеса. Најбоља +вредност за опцију \fB\-n\fP зависи од тога колико датотека има за запакивање. +Ако има само неколико датотека, вредност би вероватно требала да буде 1; са +више хиљада датотека, 100 или чак и више може бити одговарајуће за смањење +броја \fBxz\fP процеса које би \fBxargs\fP(1) евентуално направио. +.PP +Опција \fB\-T1\fP за \fBxz\fP је ту да га примора на једнонитни режим, јер се +\fBxargs\fP(1) користи за контролу количине паралелизације. +. +.SS "Режим робота" +Израчунава колико је бајтова укупно сачувано након запакивања више датотека: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Скрипта може желети да зна да користи најновији \fBxz\fP. Следећа скрипта +\fBsh\fP(1) проверава да ли је број издања \fBxz\fP алата барем 5.0.0. Ова +метода је сагласна са старим бета издањима која не подржавају \fB\-\-robot\fP +опцију: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Ваш „xz“ је превише стар." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Поставља ограничење коришћења меморије за распакивање коришћењем \fBXZ_OPT\fP, +али ако је ограничење већ постављено, не повећава је: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Произвољни ланци филтера запакивача" +Најједноставнија употреба за произвољне ланце филтера прилагођава LZMA2 +предподешеност. Ово може бити корисно, јер предподешености покривају само +подскуп потенцијално корисних комбинација поставки запакивања. +.PP +Колоне ЗапакЦПЈ у табелама из описа опција \fB\-0\fP ... \fB\-9\fP и \fB\-\-extreme\fP су +корисне приликом прилагођавања LZMA2 предподешености. Овде су значајни +делови прикупљени из те две табеле: +.RS +.PP +.TS +tab(;); +c c +n n. +Преподешеност;ЗапакЦПЈ +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Ако знате да датотека захтева нешто велики речник (на пример, 32 \ MiB) за +добро запакивање, али желите да је запакујете брже него што би то \fBxz \-8\fP +урадио, предподешеност са ниском вредношћу ЗапакМем (на пример, 1) може се +изменити да користи већи речник: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Са одређеним датотекама, горња наредба може бити бржа од \fBxz \-6\fP а +запакивање значајно боље. Међутим, мора бити наглашено да само неке +датотеке имају корист од великог речника док одржавају вредност ЗапакЦПЈ +ниском. Најочигледнија ситуација, у којој велики речник може доста помоћи, +јесте архива која садржи врло сличне датотеке где свака има најмање неколико +мегабајта. Величина речника треба да буде значајно већа од сваке засебне +датотеке да би се омогућило да LZMA2 има потпуну предност од сличности +између узастопних датотека. +.PP +Ако је веома велико коришћење меморије запакивача и распакивача у реду, а +датотека која се запакује је барем неколико стотина мегабајта, може бити +корисно користити још већи речник од 64 MiB који ће \fBxz \-9\fP користити: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Коришћење \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) као у горњем примеру може бити +корисно да се виде захтеви за меморијом запакивача и распакивача. Знајте да +је коришћење речника већег од величине незапаковане датотеке губитак +меморије, тако да горња наредба није корисна за мале датотеке. +.PP +Понекад време запакивања није важно, али коришћење меморије распакивача +треба да се одржава ниским, на пример, да би се учинило могућим распакивање +датотеке на угнежденом систему, Следеће наредбе користе \fB\-6e\fP (\fB\-6 \-\-extreme\fP) као основу и постављају речник на само 64\ KiB. Резултујућа +датотека се може распаковати са XZ Embedded (због тога је ту +\fB\-\-check=crc32\fP) користећи око 100\ KiB меморије. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Ако желите да исцедите што је више могуће бајтова, дотеривање броја битова +контекста литерала (\fIlc\fP) и броја битова положаја (\fIpb\fP) може понекад да +помогне. Дотеривање броја битова положаја литерала (\fIlp\fP) може такође да +помогне, али обично \fIlc\fP и \fIpb\fP су важнији. На пример, архива извора кода +садржи углавном US\-ASCII текст, тако да нешто као следеће може да да +незнатно (око 0.1\ %) мању датотеку него \fBxz \-6e\fP (пробајте такође без +\fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Коришћење још једног филтера заједно са LZMA2 може побољшати запакивање са +одређеним врстама датотека. На пример, за запакивање x86\-32 или x86\-64 +дељене библиотеке коришћењем x86 BCJ филтера: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Знајте да поредак опција филтера има значај. Ако је \fB\-\-x86\fP наведено након +\fB\-\-lzma2\fP, \fBxz\fP ће дати грешку, јер не сме бити никаквог филтера после +LZMA2, и такође зато што се x86 BCJ филтер не може користити као последњи +филтер у ланцу. +.PP +Delta филтер заједно са LZMA2 може дати добре резултате са битмап сликама. +Требало би обично да надјача PNG, који има нешто више напредних филтера него +једноставни делта али користи Deflate за стварно запакивање. +.PP +Слика треба да се сачува у незапакованом формату, на пример, као +незапакована TIFF. Параметар растојања Delta филтера је постављен да се +подудари са бројем бајтова по пикселу у слици. На пример, RGB битмапа од 24 +бита захтева \fBdist=3\fP, а такође је добро проследити \fBpb=0\fP за LZMA2 да се +прилагоди поравнање од три бајта: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Ако је више слика стављено у једну архиву (на пример, \fB.tar\fP), Delta филтер +ће радити на томе такође све док све слике не буду имале исти број бајтова +по пикселу. +. +.SH "ВИДИТЕ ТАКОЂЕ" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xz.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xz.1 new file mode 100644 index 0000000000000000000000000000000000000000..82d831001e1f400683d876e945d108fa8686a45a --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xz.1 @@ -0,0 +1,1928 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Serbian translation of xz-man. +.\" Мирослав Николић , 2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 08.03.2025. Tukaani "XZ Utils" +. +.SH НАЗИВ +xz, unxz, xzcat, lzma, unlzma, lzcat – Запакује или распакује „.xz“ и „.lzma +датотеке +. +.SH САЖЕТАК +\fBxz\fP [\fIопција...\fP] [\fIдатотека...\fP] +. +.SH "АЛИЈАСИ НАРЕДБЕ" +\fBunxz\fP је исто као и \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP је исто као и \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP је исто као и \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP је исто као и \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP је исто као и \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Приликом писања скрипти које треба да распакују датотеке, препоручује се да +се увек користи назив \fBxz\fP са одговарајућим аргументима (\fBxz \-d\fP или \fBxz \-dc\fP) уместо назива \fBunxz\fP и \fBxzcat\fP. +. +.SH ОПИС +\fBxz\fP је алат опште употребе за запакивање података са синтаксом линије +наредби сличан као \fBgzip\fP(1) и \fBbzip2\fP(1). Изворни формат датотеке је +\&\fB.xz\fP формат, али стари \fB.lzma\fP формат који користи LZMA Utils и сирови +запаковани токови без заглавља формата су такође подржани. Уз то, +распакивање \fB.lz\fP формата који користи \fBlzip\fP је подржано. +.PP +\fBxz\fP запакује или распакује сваку \fIдатотеку\fP у складу са изабраним режимом +рада. Ако није дата ни једна \fIдатотека\fP или је датотека \fIfile\fP \fB\-\fP, +\fBxz\fP чита са стандардног улаза и записује обрађене податке на стандардни +излаз. \fBxz\fP ће одбити (приказаће грешку и прескочити \fIдатотеку\fP) да пише +запаковане податке на стандардни излаз ако је то терминал. Слично, \fBxz\fP ће +одбити да чита запаковане податке са стандардног улаза ако је то терминал. +.PP +Осим ако није наведено \fB\-\-stdout\fP, \fIдатотеке\fP које нису \fB\-\fP се пишу у +нову датотеку чији назив је проистекао из назива изворне \fIдатотеке\fP: +.IP \(bu 3 +Приликом запакивања, суфикс формата циљне датотеке (\fB.xz\fP или \fB.lzma\fP) се +додаје на назив изворне датотеке да би се добио назив циљне датотеке. +.IP \(bu 3 +Приликом распакивања, суфикс \fB.xz\fP, \fB.lzma\fP или \fB.lz\fP се уклања из назива +датотеке да би се добио назив циљне датотеке. \fBxz\fP такође препознаје +суфиксе \fB.txz\fP и \fB.tlz\fP и замењује их суфиксом \fB.tar\fP. +.PP +Ако циљна датотека већ пстоји, приказује се грешка а \fIдатотека\fP се +прескаче. +.PP +Осим ако не пише на стандардни излаз, \fBxz\fP ће приказати упозорење и +прескочити \fIдатотеку\fP ако се нешто од следећег примењује: +.IP \(bu 3 +\fIДатотека\fP није обична датотека. Симболичке везе се не прате, и стога се +не сматра да су обичне датотеке. +.IP \(bu 3 +\fIДатотека\fP има више од једне чврсте везе. +.IP \(bu 3 +\fIДатотека\fP има постављен „setuid, setgid“ или лепљиви бит. +.IP \(bu 3 +Режим рада је постављен на запакивање а \fIдатотека\fP већ има суфикс формата +циљне датотеке (\fB.xz\fP или \fB.txz\fP приликом запакивања у \fB.xz\fP формат, а +\&\fB.lzma\fP или \fB.tlz\fP приликом запакивања у \fB.lzma\fP формат). +.IP \(bu 3 +Режим радње је постављен за распакивање а \fIдатотека\fP нема суфикс ни једног +од подржаних формата датотеке (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP или +\&\fB.lz\fP). +.PP +Након успешног сажимања или распакивања \fIдатотеке\fP, \fBxz\fP умножава +власника, групу, дозволе, време приступа и време измене из изворне +\fIдатотеке\fP у циљну датотеку. Ако умножавање групе не успе, дозволе су +измењене тако да циљна датотека не постане доступна корисницима који нису +имали дозволу за приступ изворној \fIдатотеци\fP. \fBxz\fP не подржава умножавање +других метаподатака попут списка контрола приступа или проширених атрибута. +.PP +Једном када је циљна датотека успешно затворена, изворна \fIдатотека\fP се +уклања осим ако се \fB\-keep\fP не наведе. Изворна \fIдатотека\fP се никада не +уклања ако се излаз пише на стандардни излаз или ако дође до грешке. +.PP +Слање \fBSIGINFO\fP или \fBSIGUSR1\fP ка \fBxz\fP процесу чини да испише информације +напредовања на стандардну грешку. Ово има ограничено коришћење све док +стандардна грешка јесте терминал, коришћење \fB\-\-verbose\fP приказаће +аутоматски указивач напретка освежавања. +. +.SS "Коришћење меморије" +Коришћење меморије \fBxz\fP се мења од неколико стотина килобајта до неколико +гигабајта у зависности од поставки запакивања. Поставке коришћене приликом +запакивања датотеке одређују захтеве меморије распакивача. Обично +распакивачу треба 5\ % до 20\ % количине меморије која је потребна +запакивачу приликом прављења датотеке. На пример, распакивање датотеке +направљене са \fBxz \-9\fP тренутно захтева 65\ MiB меморије. Још увек, могуће +је имати \fB.xz\fP датотеке које захтевају неколико гигабајта меморије за +распакивање. +.PP +Нарочито корисници старијих система могу наћи досадном могућност коришћења +врло велике меморије. Да би се спречила нежељена изненађења, \fBxz\fP има +уграђен ограничавач коришћења меморије, који је искључен по основи. Док +неки оперативни системи пружају начин за ограничавање коришћење меморије за +процесе, ослањање на то сматра се да није довољно прилагодљиво (на пример, +коришћење \fBulimit\fP(1) за ограничавање виртуелне меморије тежи да обогаљи +\fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Ограничавач коришћења меморије се може укључити опцијом линије наредби +\fB\-\-memlimit=\fP\fIограничење\fP. Често је најпогодније укључити ограничавач по +основи постављањем променљиве окружења \fBXZ_DEFAULTS\fP, на пример, +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Могуће је поставити ограничења засебно за +запакивање и распакивање коришћењем \fB\-\-memlimit\-compress=\fP\fIограничење\fP и +\fB\-\-memlimit\-decompress=\fP\fIограничење\fP. Коришћење ове две опције ван +\fBXZ_DEFAULTS\fP је ретко корисно јер једно покретање \fBxz\fP не може да ради и +запакивање и распакивање а \fB\-\-memlimit=\fP\fIограничење\fP (или \fB\-M\fP +\fIограничење\fP) је краће за куцање на линији наредби. +.PP +Ако је прекорачено наведено ограничење коришћења меморије, \fBxz\fP ће +приказати грешку а распакивање датотеке неће успети. Ако је ограничење +прекорачено приликом запакивања, \fBxz\fP ће покушати да умањи поставке тако да +се ограничење више не прекорачује (оси када се користи \fB\-\-format=raw\fP или +\fB\-\-no\-adjust\fP). На тај начин радња неће бити неуспешна осим ако је +ограничење врло мало. Смањење поставке се ради у корацима који се не +подударају са предподешеностима нивоа запакивања, на пример, ако је +ограничење само незнатно мање од износа потребног за \fBxz \-9\fP, поставке ће +бити смањене само мало, а не све до \fBxz \-8\fP. +. +.SS "Надовезивање и попуњавање са „.xz“ датотекама" +Могуће је додати \fB.xz\fP датотеке као то. \fBxz\fP ће распаковати такве +датотеке као да су биле једна \fB.xz\fP датотека. +.PP +Могуће је уметнути попуњавање између придодатих делова или након последњег +дела. Попуњавање мора да се састоји од празних бајтова а величина +попуњавања мора бити умножак четири бајта. Ово може бити корисно, на +пример, ако је \fB.xz\fP датотека смештена на медијуму који мери величине +датотека у блоковима од 512 бајтова. +.PP +Надовезивање и попуњавање нису дозвољени са \fB.lzma\fP датотекама или сировим +токовима. +. +.SH ОПЦИЈЕ +. +.SS "Суфикси целог броја и специјалне вредности" +На већини места где се очекује аргумент целог броја, опционални суфикс је +подржан да би се лако назначили велики цели бројеви. Не сме бити размака +између целог броја и суфикса. +.TP +\fBKiB\fP +Множи цео број са 1.024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP, и \fBKB\fP се +прихватају као синоними за \fBKiB\fP. +.TP +\fBMiB\fP +Множи цео број са 1.048.576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP, и \fBMB\fP се +прихватају као синоними за \fBMiB\fP. +.TP +\fBGiB\fP +Множи цео број са 1.073.741.824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP, и \fBGB\fP се +прихватају као синоними за \fBGiB\fP. +.PP +Посебна вредност \fBmax\fP се може користити да укаже на највећу вредност целог +броја подржану опцијом. +. +.SS "Режим рада" +Ако је дато више опција режима рада, последња има дејства. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Запакује. Ово је основни режим радње када није наведена опција режима радње +и ниједан други режим радње се не подразумева са линије радње (на пример, +\fBunxz\fP подразумева \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Након успешног запакивања, изворна датотека се уклања осим ако се не пише на +стандардни излаз или је наведено \fB\-\-keep\fP. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Распакује. Након успешног распакивања, изворна датотека се уклања осим ако +се не пише на стандардни излаз или је наведено \fB\-\-keep\fP. +.TP +\fB\-t\fP, \fB\-\-test\fP +Тестира целовитост запакованих \fIдатотека\fP. Ова опција је исто што и +\fB\-\-decompress \-\-stdout\fP осим тога што се распаковани подаци одбацују уместо +да се пишу на стандардни излаз. Датотеке се не праве нити уклањају. +.TP +\fB\-l\fP, \fB\-\-list\fP +Исписује информације о запакованим \fIдатотекама\fP. Никакав незапакован излаз +се не добија, а ниједна датотека није направљена или уклоњена. У режиму +списка, програм не може читати запаковане податке са стандардног улаза или +из других нетраживих извора. +.IP "" +Основни списак приказује основне информације о \fIдатотекама\fP, једна датотека +у једном реду. Да добијете подробније информације, користите такође опцију +\fB\-\-verbose\fP. За чак и више информација, користите \fB\-\-verbose\fP два пуа, +али знајте да то може бити споро, јер да би се добиле све додатне +информације потребно је много тражења. Ширина опширног излаза премашује 80 +знакова, тако да преспајање излаза на, на пример, \fBless\ \-S\fP може бити +прикладно ако терминал није довољно широк. +.IP "" +Тачан излаз може варирати између \fBxz\fP издања и различитих језика. За излаз +читљив машинама треба да користите \fB\-\-robot \-\-list\fP. +. +.SS "Измењивачи рада" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Не брише улазне датотеке. +.IP "" +Од \fBxz\fP 5.2.6, ова опција такође чини да \fBxz\fP запакује или распакује чак и +ако је улаз симболичка веза ка обичној датотеци, има више од једне чврсте +везе или има постављен „setuid“, „setgid“ или лепљиви бит. „setuid“, +„setgid“ и лепљиви битови се не умножавају у циљну датотеку. У ранијим +издањима ово се могло урадити само са \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Ова опција има неколико дејстава: +.RS +.IP \(bu 3 +Ако циљна датотека већ постоји, брише је пре запакивања или распакивања. +.IP \(bu 3 +Запакује или распакује чак и ако је улаз симболичка веза ка обичној +датотеци, има више од једне чврсте везе или има постављен „setgid“, „setgid“ +или лепљиви бит. „setgid“, „setgid“ или лепљиви бит се не умножавају у +циљну датотеку. +.IP \(bu 3 +Када се користи са \fB\-\-decompress\fP \fB\-\-stdout\fP и \fBxz\fP не може да препозна +врсту изворне датотеке, умножава изворну датотеку као такву на стандардни +излаз. Ово омогућава да се \fBxzcat\fP \fB\-\-force\fP користи као \fBcat\fP(1) за +датотекекоје нису запаковане са \fBxz\fP. Знајте да ће у будућности, \fBxz\fP +моћи да подржава нове формате запаковане датотеке, који могу учинити да +\fBxz\fP распакује још врста датотека уместо да их умножи какве јесу на +стандардни излаз. \fB\-\-format=\fP\fIформат\fP се може користити да ограничи \fBxz\fP +да распакује само формат једне датотеке. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Пише запаковане или распаковане податке на стандардни излаз уместо у +датотеку, Ово подразумева \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Распакује само први \fB.xz\fP ток, и тихо занемарује могуће преостале улазне +податке који следе ток. Нормално такво пратеће смеће чини да \fBxz\fP прикаже +грешку. +.IP "" +\fBxz\fP никада не распакује више од једног тока из \fB.lzma\fP датотека или +сирових токова, али ова опција чини да \fBxz\fP још увек занемари могуће +пратеће податке након \fB.lzma\fP датотеке или сировог тока. +.IP "" +Ова опција нема дејства ако режим рада није \fB\-\-decompress\fP или \fB\-\-test\fP. +.IP "" +Од \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP подразумева \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Искључује стварање развучених датотека. По основи, ако распакује у обичну +датотеку, \fBxz\fP покушава да учини датотеку развученом ако распаковани подаци +садрже дуге низове бинарних нула. Такође ради приликом писања на стандардни +излаз све док је стандардни излаз повезан са обичном датотеком а одређени +додатни услови су испуњени да је учине безбедном. Стварање развучених +датотека може уштедети простор на диску и убрзати распакивање смањењем +количине У/И диска. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Приликом запакивања, користите \fI.suf\fP као суфикс за циљну датотеку уместо +\&\fB.xz\fP или \fB.lzma\fP. Ако се не пише на стандардни излаз а изворна датотека +већ има суфикс \fI.suf\fP, приказује се упозорење и датотека се прескаче. +.IP "" +Приликом распакивања, препознаје датотеке са суфиксом \fI.suf\fP поред датотека +са суфиксом \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, or \fB.lz\fP. Ако изворна +датотека има суфикс \fI.suf\fP, суфикс се уклања да би се добио назив циљне +датотеке. +.IP "" +Приликом запакивања или распакивања сирових токова (\fB\-\-format=raw\fP), суфикс +мора увек бити наведен осим ако се не пише на стандардни излаз, јер не +постоји основни суфикс за сирове токове. +.TP +\fB\-\-files\fP[\fB=\fP\fIдатотека\fP] +Чита називе датотека за обраду из \fIдатотеке\fP; ако се \fIдатотека\fP изостави, +називи датотека се читају са стандардног улаза. Називи датотека се морају +завршавати знаком новог реда. Цртица (\fB\-\fP) се узима као редован назив +датотеке; а не стандардни улаз. Ако су називи датотека дати такође као +аргументи линије наредби, обрађују се пре него што се називи датотека +прочитају из \fIдатотеке\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIдатотека\fP] +Ово је исто као и \fB\-\-files\fP[\fB=\fP\fIдатотека\fP] изузев тога што сваки назив +датотеке мора да се завршава „null“ знаком. +. +.SS "Основни формат датотеке и опције запакивања" +.TP +\fB\-F\fP \fIформат\fP, \fB\-\-format=\fP\fIформат\fP +Наводи \fIформат\fP датотеке за запакивање или распакивање: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Ово је основно. Приликом запакивања, \fBauto\fP је исто што и \fBxz\fP. Приликом +распакивања, формат улазне датотеке се аутоматски препознаје. Знајте да +сирови токови (направљени са \fB\-\-format=raw\fP) не могу бити аутоматски +препознати. +.TP +\fBxz\fP +Пакује у \fB.xz\fP формат датотеке, или прихвата само \fB.xz\fP датотеке приликом +распакивања. +.TP +\fBlzma\fP, \fBalone\fP +Пакује у стари \fB.lzma\fP формат датотеке, или прихвата само \fB.lzma\fP датотеке +приликом распакивања. Алтернативни назив \fBalone\fP се доставља зарад +повратне сагласности са LZMA помагалима. +.TP +\fBlzip\fP +Прихвата само \fB.lz\fP датотеке приликом распакивања. Запакивање није +подржано. +.IP "" +Формат \fB.lz\fP издања 0 и 1 је подржан. Датотеке издања 0 су настале са +\fBlzip\fP 1.3 и старијим. Такве датотеке нису уобичајене али се могу наћи у +архивама датотека јер је неколико пакета извора издато у овом формату. +Такође можда неко има старе личне датотеке у овом формату. Подршка +распакивања за формат издања 0 је уклоњена у \fBlzip\fP 1.18. \fBlzip\fP 1.4 и +новији ствара датотеке у формату издања 1. +.TP +\fBraw\fP +Запакује или распакује сирови ток (без заглавља). Ово је замишљено само за +напредне кориснике. Да дешифрујете сирове токове, треба да користите +\fB\-\-format=raw\fP и да изричито наведете ланац филтера, што би обично требало +да буде смештено у заглављима контејнера. +.RE +.TP +\fB\-C\fP \fIпровера\fP, \fB\-\-check=\fP\fIпровера\fP +Наводи врсту провере целовитости. Провера се израчунава из незапакованих +података и смештених у \fB.xz\fP датотеци. Ова опција има дејства само +приликом запакивања у \fB.xz\fP формат; \fB.lzma\fP формат не подржава провере +целовитости. Провера целовитости (ако је има) се проверава када је \fB.xz\fP +датотека распакована. +.IP "" +Подржане врсте \fIпровере\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Уопште не израчунава проверу целовитости. Ово је обично лоша идеја. Ово +може бити корисно када се целовитост података ипак проверава на друге +начине. +.TP +\fBcrc32\fP +Израчунава CRC32 користећи полином из IEEE\-802.3 (Етернет). +.TP +\fBcrc64\fP +Израчунава CRC64 користећи полином из ECMA\-182. Ово је основно, јер је +незнатно боље од CRC32 у откривању оштећених датотека а разлика брзине је +занемарљива. +.TP +\fBsha256\fP +Израчунава SHA\-256. Ово је нешто спорије од CRC32 и CRC64. +.RE +.IP "" +Целовитост \fB.xz\fP заглавља се увек проверава са CRC32. Не може се изменити +нити искључити. +.TP +\fB\-\-ignore\-check\fP +Не проверава проверу целовитости запакованих података приликом распакивања. +CRC32 вредности у \fB.xz\fP заглављима биће још увек нормално проверене. +.IP "" +\fBНемојте користити ову опцију осим ако стварно знате шта радите.\fP Могући +разлози за коришћење ове опције: +.RS +.IP \(bu 3 +Покушава да опорави податке из оштећене „.xz“ датотеке. +.IP \(bu 3 +Убрзава распакивање. Ово има значаја углавном са SHA\-256 или са датотекама +које су запаковане стварно добро. Препоручује се да не користите ову опцију +за ову сврху осим ако је целовитост датотеке проверена споља на неки други +начин. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Бира ниво преподешености запакивања. Подразумевано је \fB\-6\fP. Ако је +наведено више нивоа преподешености, последња има дејства. Ако је произвољни +ланац филтера већ наведен, постављање нивоа преподешености запакивања уклања +произвољни ланац филтера. +.IP "" +Разлике између предподешености су још значајније него са \fBgzip\fP(1) и +\fBbzip2\fP(1). Изабране поставке запакивања одређују захтеве меморије +распакивача, стога коришћење превисоког нивоа предподешености може отежати +распакивање датотеле на старом систему са мало RAM\-а. Нарочито, \fBније добра замисао слепо користити \-9 за било шта\fP као што је често са \fBgzip\fP(1) +и \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Ово су некако брзе предподешености. \fB\-0\fP је понекад брже од \fBgzip \-9\fP док +запакује много боље. Оне више често имају брзину упоредиву са \fBbzip2\fP(1) +са упоредивом или бољом стопом запакивања, иако резултати зависе много од +врсте података који се запакују. +.TP +\fB\-4\fP ... \fB\-6\fP +Добро до врло добро запакивање које одржава коришћење меморије распакивача +разумним чак и за старе системе. \fB\-6\fP је основно, што је обично добар +избор за расподелу датотека које треба да могу да се распакују чак и на +системима са само 16\ MiB RAM\-а. (\fB\-5e\fP или \fB\-6e\fP може бити вредно +узимања у обзир. Видите \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Као \fB\-6\fP али са већим захтевима меморије запакивача и распакивача. Корисне +су само приликом запакивања датотека већих од 8\ MiB, 16\ MiB и 32\ MiB. +.RE +.IP "" +На истом хардверу, брзина распакивања је приближно сталан број бајтова +запакованих података у секунди. Другим речима, биће боље запакивање, брже +распакивање. То такође значи да количина незапакованог излаза произведеног +у секунди може много да се разликује. +.IP "" +Следећа табела резимира функције предподешености: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Преподешеност;ВлчРчнка;ЗапакЦПЈ;ЗапакМем;РаспМем +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Описи колона: +.RS +.IP \(bu 3 +ВлчРчнка је величина LZMA2 речника. Коришћење речника већег од величине +незапаковане датотеке је губитак меморије. Зато је добро избегавати +коришћење предподешености \fB\-7\fP ... \fB\-9\fP када за њима нема стварне +потребе. Са \fB\-6\fP и нижим, количина изгубљене меморије је обично довољно +ниска да нема значаја. +.IP \(bu 3 +ЗапакЦПЈ је поједностављено представљање LZMA2 поставки које утичу на брзину +запакивања. Величина речника такође утиче на брзину, тако док је ЗапакЦПЈ +исто за нивое \fB\-6\fP ... \fB\-9\fP, виши нивои још увек теже да буду спорији. Да +добијете још спорије и самим тим можда боље запакивање, видите \fB\-\-extreme\fP. +.IP \(bu 3 +ЗапакМем садржи захтеве меморије запакивача у режиму једне нити. Може +незнатно да се разликује између \fBxz\fP издања. +.IP \(bu 3 +РаспМем садржи захтеве меморије распакивача. Тако је, поставке запакивања +одређују захтеве меморије распакивача. Тачно коришћење меморије распакивача +је незнатно веће од величине LZMA2 речника, али су вредности у табели +заокружене на следећи цео MiB. +.RE +.IP "" +Захтеви меморије режима са више нити су значајно већи него ли режима једне +нити. Са основном вредношћу \fB\-\-block\-size\fP, свакој нити треба 3*3*ВлчРчнка +плус ЗапакМем или РаспМем. На пример, за четири нити са предподешавањем +\fB\-6\fP потребно је 660\(en670\ MiB меморије. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Користите спорију варијанту изабраног нивоа предподешености запакивања +(\fB\-0\fP ... \fB\-9\fP) у нади да ћете добити мало бољу стопу запакивања, али уз +лошу срећу ово је може учинити гором. Не утиче на коришћење меморије +распакивача, али се коришћење меморије запакивача мало повећава на нивоима +предподешености \fB\-0\fP ... \fB\-3\fP. +.IP "" +Како постоје две предподешености са величинама речника од 4\ MiB и 8\ MiB, +предподешености \fB\-3e\fP и \fB\-5e\fP користе незнатно брже поставке (ниже +CompCPU) него \fB\-4e\fP и \fB\-6e\fP. На тај начин нема две истоветне +предподешености. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Преподешеност;ВлчРчнка;ЗапакЦПЈ;ЗапакМем;РаспМем +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +На пример, има укупно четири предподешавања која користе 8\ MiB речник, чији +поредак од најбржег до најспоријег је \fB\-5\fP, \fB\-6\fP, \fB\-5e\fP и \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Ово су помало погрешни алијаси за \fB\-0\fP и \fB\-9\fP. Достављени су само зарад +повратне сагласности са LZMA Utils\-ом. Избегавајте коришћење ових опција. +.TP +\fB\-\-block\-size=\fP\fIвеличина\fP +Приликом запакивања у \fB.xz\fP формат, дели улазне податке на блокове +\fIвеличина\fP бајта. Блокови се запакују независно један од другог, што +помаже у раду са више нити и чини ограничено распакивање насумичног приступа +могућим. Ова опција се обично користи да се препише основна величина блока +у режиму са више нити, али се ова опција може такође користити и у режиму +једне нити. +.IP "" +У режиму више нити око три пута \fIвеличина\fP бајтова биће додељено у свакој +нити за међумеморисање улаза и излаза. Основна \fIвеличина\fP је три пута +величине LZMA2 речника или 1 MiB, шта год да је више. Обично добра вредност +је 2\(en4 пута величина LZMA2 речника или барем 1 MiB. Коришћење +\fIвеличине\fP мање од величине LZMA2 речника је трошење RAM\-а јер тада +међумеморија LZMA2 речника никада неће бити потпуно коришћена. У режиму +више нити, величине блокова се чувају у заглављима блока. Ова информација +величине је потребна за распакивање са више нити. +.IP "" +У режиму једне нити никаква подела блока се не ради по основи. Постављање +ове опције не утиче на коришћење меморије. Никакве информације о величини +се не чувају у заглављима блока, стога датотеке направљене у режиму једне +нити неће бити исте као датотеке направљене у режиму више нити. Недостатак +информација о величини такође значи да \fBxz\fP неће моћи да распакује датотеке +у режиму више нити. +.TP +\fB\-\-block\-list=\fP\fIставке\fP +Приликом запакивања у \fB.xz\fP формат, почиње нови блок са изборним +произвољним ланцем филтера након датих интервала незапакованих података. +.IP "" +\fIСтавке\fP су списак одвојен зарезом. Свака ставка се састоји од изборног +броја ланца филтера између 0 и 9 за којим следи двотачка (\fB:\fP) и захтевана +величина незапакованих података . Изостављање неке ставке (два или више +узастопна зареза) је пречица за коришћење величине и филтера претходне +ставке. +.IP "" +Ако је улазна датотека већа од збира величина у \fIставкама\fP, последња ставка +се понавља све до краја датотеке. Специјална вредност \fB0\fP може се +користити као последња величина да назначи да остатак датотеке треба да буде +шифрован као један блок. +.IP "" +Алтернативни ланац филтера за сваки блок се може навести у комбинацији са +опцијама \fB\-\-filters1=\fP\fIфилтера\fP \&...\& \fB\-\-filters9=\fP\fIфилтери\fP. Ове +опције дефинишу ланце филтера са одредником између 1\(en9. Ланац филтера 0 +се може користити да упућује на основно ланац филтера, који је исти јер се +ланац филтера не наводи. Одредник ланца филтера се може користити пре +незапаковане величине, за којим следи двотачка (\fB:\fP). На пример, ако +наведемо \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP тада ће се за +прављење блокова користити: +.RS +.IP \(bu 3 +Ланац филтера наведен са \fB\-\-filters1\fP и 2 MiB улазом +.IP \(bu 3 +Ланац филтера наведен са \fB\-\-filters3\fP и 2 MiB улазом +.IP \(bu 3 +Ланац филтера наведен са \fB\-\-filters2\fP и 4 MiB улазом +.IP \(bu 3 +Ланац филтера наведен са \fB\-\-filters2\fP и 4 MiB улазом +.IP \(bu 3 +Основни ланац филтера и 2 MiB улаз +.IP \(bu 3 +Основни ланац филтера и 4 MiB улаз за сваки блок до краја улаза. +.RE +.IP "" +Ако наведемо величину која премашује величину блока шифрера (било основну +вредност у режиму нити или вредност наведену са +\fB\-\-block\-size=\fP\fIвеличина\fP), шифрер ће направити додатне блокове док ће +задржати границе наведене у \fIставкама\fP. На пример, ако наведемо +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP а улазна +датотека је 80 MiB, добићемо 11 блокова: 5, 10, 8, 10, 2, 10, 10, 4, 10, 10 +и 1 MiB. +.IP "" +У режиму са више нити величине блокова се чувају у заглављима блока. Ово се +не ради у режиму једне нити, тако да шифровани излаз неће бити истоветан +ономе у режиму са више нити. +.TP +\fB\-\-flush\-timeout=\fP\fIистек_времена\fP +Приликом запакивања, ако је више од \fIвреме_истека\fP милисекунди (позитиван +цео број) прошло од претходног испирања и читање више улаза ће блокирати, +сви заказани улазни подаци се испирају из шифрера и чине доступним у +излазном току. Ово може бити корисно ако је \fBxz\fP коришћен за запакивање +података који су слати преко мреже. Мала вредност \fIвременског_истека\fP чини +податке доступним на пријемни крај са малим закашњењем, али велика вредност +\fIвремена_истека\fP даје бољу стопу запакивања. +.IP "" +Ова функција је искључена по основи. Ако је ова опција наведена више пута, +последња има дејства. Нарочита вредност \fIвременског истека\fP \fB0\fP може се +користити за изричито искључивање ове функције. +.IP "" +Ова функција је доступна само на POSIX системима. +.IP "" +.\" FIXME +\fBОва функција је још увек експериментална.\fP Тренутно \fBxz\fP није погодан за +распакивање тока у реалном времену због начина на који \fBxz\fP ради +међумеморисање. +.TP +\fB\-\-no\-sync\fP +Не усклађује циљну датотеку и њену фасциклу на смештајном уређају пре +уклањања изворне датотеке. Ово може побољшати учинковитост ако се запакује +или распакује много малих датотека. Међутим, ако се систем уруши одмах +након брисања, може бити да циљна датотека не буде уписана на смештајном +уређају али радња брисања јесте. У том случају неће бити доступна ни +оригинална изворна ни циљна датотека. +.IP "" +Ова опција има дејство само када се \fBxz\fP спрема да уклони изворну +датотеку. У осталим случајевима усклађивање се не ради никада. +.IP "" +Синхронизација и \fB\-\-no\-sync\fP су додате у \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIограничење\fP +Поставља ограничење коришћења меморије запакивања. Ако је ова опција +наведена више пута, последња ступа у дејство. +.IP "" +Ако поставке запакивања премаше \fIограничење\fP, \fBxz\fP ће покушати да врати +назад поставке тако да ограничење више није прекорачено и приказаће +обавештење да је урађено аутоматско дотеривање. Дотеривања се раде следећим +редом: смањење броја нити, пребацивање на режим једне нити ако чак и једна +нит у режиму више нити премаши \fIограничење\fP и на крају смањење величине +LZMA2 речника. +.IP "" +Приликом запакивања са \fB\-\-format=raw\fP или ако је наведено \fB\-\-no\-adjust\fP, +само број нити може бити умањен јер може да се уради а да се не делује на +излаз запакованог. +.IP "" +Ако \fIограничење\fP не може бити задовољено чак и са поравнањима описаним +изнад, приказује се грешка и \fBxz\fP ће изаћи са излазним стањем 1. +.IP "" +\fIОграничење\fP се може навести на више начина: +.RS +.IP \(bu 3 +\fIОграничење\fP може бити апсолутна величина у бајтима. Коришћење суфикса +целог броја као \fBMiB\fP може бити корисно. Пример: +\fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +\fIОграничење\fP се може навести као проценат укупне физичке меморије (RAM). +Ово може бити корисно нарочито приликом постављања променљиве окружења +\fBXZ_DEFAULTS\fP у скрпти покретања конзоле која се дели између различитих +рачунара. На тај начин ограничење је аутоматски веће на системима са више +меморије. Пример: \fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +\fIОграничење\fP се може вратити на своју основну вредност његовим постављањем +на \fB0\fP. Ово је тренутно исто што и постављање \fIограничења\fP на \fBmax\fP (без +ограничења коришћења меморије). +.RE +.IP "" +За \fBxz\fP 32\-бита имамо посебан случај: ако \fIограничење\fP треба да буде преко +\fB4020\ MiB\fP, \fIограничење\fP се поставља на \fB4020\ MiB\fP. Али на MIPS32 +користи се \fB2000\ MiB\fP. (На вредности \fB0\fP и \fBmax\fP ово не утиче. Слична +функција не постоји за распакивање.) Ово може бити од помоћи када извршна +од 32\-бита има приступ адресном простору од 4\ GiB (2 GiB на MIPS32) док +срећом не чини ништа лоше у осталим приликама. +.IP "" +Видите такође одељак \fBКоришћење меморије\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIограничење\fP +Поставља ограничење коришћења меморије за распакивање. Ово такође утиче на +\fB\-\-list\fP режим. Ако радња није могућа а да се не премаши \fIограничење\fP, +\fBxz\fP ће приказати грешку а распакивање датотеке неће успети. Видите +\fB\-\-memlimit\-compress=\fP\fIограничење\fP за могуће начине о навођењу +\fIограничења\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIограничење\fP +Поставља ограничење коришћења меморије за распакивање са више нити. Ово +може утицати само на број нити; ово никада неће учинити да \fBxz\fP одбије да +распакује датотеке. Ако је \fIограничење\fP превише ниско да омогући било који +рад са више нити, \fIограничење\fP се занемарује а \fBxz\fP ће наставити у режиму +једне нити. Знајте да ако се такође користи \fB\-\-memlimit\-decompress\fP, увек +ће се применити и на режим једне и на режим више нити, и тако да стварно +\fIограничење\fP за више нити никада неће бити више од ограничења постављеног +са \fB\-\-memlimit\-decompress\fP. +.IP "" +У супротности са другим опцијама ограничења коришћења меморије, +\fB\-\-memlimit\-mt\-decompress=\fP\fIограничење\fP има систему специфично основно +\fIограничење\fP. \fBxz \-\-info\-memory\fP се може користити да видите тренутну +вредност. +.IP "" +Ова опција и њена основна вредност постоје јер без икаквог ограничења нитни +распакивач ће завршити са додељивањем неразумног износа меморије са неким +улазним датотекама. Ако је основно \fIограничење\fP превише ниско на вашем +систему, слободно повећајте \fIограничење\fP али га никада не постављајте на +вредност већу од износа употребљивог RAM\-а јер са одговарајућим улазним +датотекама \fBxz\fP ће покушати да користи тај износ меморије чак и са малим +бројем нити. Остајући без меморије или разменом неће се побољшати +учинковитост распакивања. +.IP "" +Видите \fB\-\-memlimit\-compress=\fP\fIограничење\fP за могуће начине за навођење +\fIограничења\fP. Постављање \fIограничења\fP на \fB0\fP враћа \fIограничење\fP на +систему специфичну основну вредност. +.TP +\fB\-M\fP \fIограничење\fP, \fB\-\-memlimit=\fP\fIограничење\fP, \fB\-\-memory=\fP\fIограничење\fP +Ово је исто као и навођење \fB\-\-memlimit\-compress=\fP\fIограничење\fP +\fB\-\-memlimit\-decompress=\fP\fIограничење\fP +\fB\-\-memlimit\-mt\-decompress=\fP\fIограничење\fP. +.TP +\fB\-\-no\-adjust\fP +Приказује грешку и излази ако ограничење коришћења меморије не може бити +задовољено без дотеривања поставки које утичу на запаковани излаз. Тако је, +ово спречава \fBxz\fP да промени шифрера из режима више нити у режим једне нити +и да смањи величину LZMA2 речника. Чак и када се ова опција користи број +нити се може смањити да задовољи ограничење коришћења меморије јер то неће +утицати на запаковани излаз. +.IP "" +Аутоматско дотеривање је увек искључено приликом стварања сирових токова +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fIнити\fP, \fB\-\-threads=\fP\fIнити\fP +Наводи број нити радника за коришћење. Постављање \fIнити\fP на посебну +вредност \fB0\fP чини да \fBxz\fP користи онолико нити колико процесор на систему +подржава. Стварни број нити може бити мањи од \fIнити\fP ако улазна датотека +није довољно велика за нитисање са датим поставкама или ако ће коришћење +више нити премашити ограничење коришћења меморије. +.IP "" +Запакивачи једне нити и више нити дају различите излазе. запакивач једне +нити даће мању величину датотеке али само излаз из запакивача више нити може +бити распакован коришћењем више нити. Постављање \fIнити\fP на \fB1\fP користиће +режим једне нити. Постављање \fIнити\fP на неку другу вредност, укључујући +\fB0\fP, користиће запакивач више нити чак и ако систем подржава само једну нит +хардвера. (\fBxz\fP 5.2.x је користио режим једне нити у овој прилици.) +.IP "" +Да користите вишенитни режим са само једном нити, поставите \fIнити\fP на +\fB+1\fP. Префикс \fB+\fP нема дејства са вредностима које нису \fB1\fP. Ограничење +коришћења меморије може још увек учинити да се \fBxz\fP пребаци на режим једне +нити осим ако се не користи \fB\-\-no\-adjust\fP. Подршка за префикс \fB+\fP је +додата у \fBxz\fP 5.4.0. +.IP "" +Ако је затражен аутоматски број нити и није наведено ограничење коришћења +меморије, тада ће се користити основно меко ограничење специфично за систем +за могуће ограничење броја нити. То је меко ограничење у смислу да се +занемарује ако број нити постане један, дакле меко ограничење никада неће +зауставити \fBxz\fP од запакивања или распакивања. Ово основно меко ограничење +неће учинити да се \fBxz\fP пребаци из режима више нити у режим једне нити. +Активно ограничење се може видети са + \fBxz \-\-info\-memory\fP. +.IP "" +Тренутно једина метода нитисања је да се подели улаз на блокове и да се +запакују независно један од другог. Основна величина блока зависи од нивоа +запакивања и може се преписати опцијом \fB\-\-block\-size=\fP\fIвеличина\fP. +.IP "" +Нитно распакивање ради само на датотекама које садрже више блокова са +информацијом величине у заглављима блока. Све довољно велике датотеке +запаковане у вишенитном режиму задовољавају овај услов, али датотеке +запаковане у једнонитном режиму не чак и ако је коришћено +\fB\-\-block\-size=\fP\fIвеличина\fP. +.IP "" +Основна вредност за \fIнити\fP је \fB0\fP. У \fBxz\fP 5.4.x и старијим основно је +\fB1\fP. +. +.SS "Произвољни ланци филтера запакивача" +Произвољни ланац филтера омогућава детаљно одређивање подешавања сажимања +уместо да се ослања на подешавања повезана са предподешавањима. Када је +произвољни ланац филтера наведен, опције предподешавања (\fB\-0\fP \&...\& \fB\-9\fP +и \fB\-extreme\fP) раније на линији наредби се заборављају. Ако је опција +предподешавања наведена након једне или више опција произвољног ланца +филтера, ново предподешавање ступа на снагу а раније наведене опције +произвољног ланца филтера се заборављају. +.PP +Ланац филтера је упоредив са спојкама на линији наредби. Приликом сажимања, +несажети улаз иде на први филтер, чији излаз иде на следећи филтер (ако фа +има). Излаз последњег филтера бива записан у сажету датотеку. Највећи број +филтера у ланцу је четири, али обично ланац филтера има само један или два +филтера. +.PP +Многи филтери имају ограничења о томе где могу бити у ланцу филтера: неки +филтери могу радити само као последњи филтер у ланцу, неки само као +не\-последњи филтер, а неки раде на било ком месту у ланцу. Овисно о +филтеру, ово ограничење је или својствено дизајну филтера или постоји како +би се спречили проблеми безбедности. +.PP +Произвољни ланац филтера се може навести на два различита начина. Опције +\fB\-\-filters=\fP\fIфилтери\fP и \fB\-\-filters1=\fP\fIфилтери\fP \&...\& +\fB\-\-filters9=\fP\fIфилтери\fP омогућавају навођење читавог ланца опција у једној +опцији коришћењем синтаксу ниске „liblzma“ филтера. Другачије, ланац +филтера се може навести коришћењем једне или више појединачних опција +филтера редом како се траже у ланцу филтера. То је то, редослед +појединачних опција филтера је важан! Приликом дешифровања сирових токова +(\fB\-\-format=raw\fP), ланац филтера мора бити наведен истим редом као када је +био наведен приликом сажимања. Било који појединачни филтер или опције +предподешавања наведене пре опције читавог ланца (\fB\-\-filters=\fP\fIфилтери\fP) +биће заборављене. Појединачни филтери наведени после опције читавог ланца +ће поништити поставку ланца филтера. +.PP +Обе опције и пуног и појединачног филтера узимају филтеру специфичне +\fIопције\fP као зарезом раздвојен списак. Додатни зарези у \fIопцијама\fP се +занемарују. Свака опција има основну вредност, тако да треба да наведете +оне које желите да измените. +.PP +Да видите читав ланац филтера и \fIопције\fP, користите \fBxz \-vv\fP (тако је, +користите \fB\-\-verbose\fP два пута). Ово ради такође за преглед опција ланца +филтера коришћених од стране предподешености. +.TP +\fB\-\-filters=\fP\fIфилтери\fP +Наводи цео ланац филтера или предподешеност у једној опцији. Сваки филтер +се може одвојити размацима или са две цртице (\fB\-\-\fP). \fIФилтери\fP можда +треба да буду под наводницима на линији наредби конзоле тако да се +прослеђују као једна опција. Да означите \fIопције\fP, користите \fB:\fP или +\fB=\fP. Предподешености се може додати префикс \fB\-\fP и може га пратити нула +или још заставица. Једина подржана заставица је \fBe\fP за примену истих +опција као \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIфилтери\fP ... \fB\-\-filters9\fP=\fIфилтери\fP +Наводи до девет додатних ланаца филтера који се могу користити са +\fB\-\-block\-list\fP. +.IP "" +На пример, приликом запакивања архиве са извршним датотекама за којима следе +текстуалне датотеке, извршни део треба да користи ланац филтера са BCJ +филтером а текстуални део само LZMA2 филтер. +.TP +\fB\-\-filters\-help\fP +Приказује поруку помоћи описујући како се наводе предподешавања и произвољни +ланци филтера у опцијама \fB\-\-filters\fP и \fB\-\-filters1=\fP\fIфилтери\fP \&...\& +\fB\-\-filters9=\fP\fIфилтери\fP, и успешно излази. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIопције\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIопције\fP] +.PD +Додаје LZMA1 или LZMA2 филтер у ланац филтера. Ови филтери се могу +користити само као последњи филтер у ланцу. +.IP "" +LZMA1 је стари филтер, који је подржан углавном само због старог формата +\&\fB.lzma\fP датотеке, који подржава само LZMA1. LZMA2 је освежено издање LZMA1 +које поправља неке практичне проблеме LZMA1. \fB.xz\fP формат користи LZMA2 и +не подржава LZMA1 уопште. Брзина запакивања и односи LZMA1 и LZMA2 су +практично исти. +.IP "" +LZMA1 и LZMA2 деле исти скуп \fIопција\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIпредподешавање\fP +Враћа све LZMA1 или LZMA2 \fIопције\fP на \fIпредподешеност\fP. \fIПредпдешеност\fP +се састоји од целог броја, за којим може да следи једнословни измењивач +предподешености. Цео број може бити од \fB0\fP до \fB9\fP, поклапајући опције +линије наредби \fB\-0\fP \&...\& \fB\-9\fP. Једини тренутно подржани измењивач је +\fBe\fP, који се поклапа са \fB\-\-extreme\fP. Ако \fBpreset\fP није наведено, основне +вредности LZMA1 или LZMA2 \fIопција\fP се узимају из предподешености \fB6\fP. +.TP +\fBdict=\fP\fIвеличина\fP +\fIВеличина\fP речника (међумеморија историјата) указује на то колико је +бајтова недавно обрађених нераспакованих података задржано у меморији. +Алгоритам покушава да нађе понављајуће низове бајтова (поклапања) у +нераспакованим подацима, и да их замени са упутама ка подацима који су +тренутно у речнику. Што је већи речник, већа је вероватноћа за налажење +поклапања. Стога, повећање \fIвеличине \fP речника обично побољшава стопу +запакивања, али речник већи од незапаковане датотеке јесте утрошак меморије. +.IP "" +Уобичајена \fIвеличина\fP речника је од 64\ KiB до 64\ MiB. Најмање је 4\ KiB. Највише за запакивање тренутно је 1.5\ GiB (1536\ MiB). Распакивач +већ подржава речнике до једног бајта мање од 4\ GiB, што је максимум за +формате LZMA1 и LZMA2 тока. +.IP "" +\fIВеличина\fP речника и налазач поклапања (\fImf\fP) заједно одређују коришћење +меморије за LZMA1 или LZMA2 шифрере. Иста (или већа) \fIвеличина\fP речника је +потребна за распакивање као она која је коришћена за запаквање, стога се +коришћење меморије дешифрера одређује према величини речника коришћеног за +запакивање. \fB.xz\fP заглавља чувају \fIвеличину\fP речника или као 2^\fIn\fP или +2^\fIn\fP + 2^(\fIn\fP\-1), тако да су те \fIвеличине\fP некако пожељније за +запакивање. Друге \fIвеличине\fP биће заокружене приликом чувања у \fB.xz\fP +заглављима. +.TP +\fBlc=\fP\fIlc\fP +Наводи број битова контекста литерала. Најмање је 0 а највише је 4; основно +је 3. Као додатак, збир \fIlc\fP и \fIlp\fP не сме да премаши 4. +.IP "" +Сви бајтови који се не могу шифровати јер су поклапања шифрована као +литерали. То је то, литерали су једноставно 8\-битни бајтови који су +шифровани један по један. +.IP "" +Кодирање литерала врши претпоставку да највећи \fIlc\fP битови претходног +незапакованог бајта су у узајамној вези са следећим бајтом. На пример, у +уобичајеном енглеском тексту, за великим словом често следи мало слово, а за +малим словом обично следи још једно мало слово. У скупу US\-ASCII знакова, +највиша три бита су 010 за велика слова и 011 за мала слова. Када је \fIlc\fP +барем 3, кодирање литерала може имати предност овог својства у незапакованим +подацима. +.IP "" +Основна вредност (3) је обично добра. Ако желите највеће запакивање, +испробајте \fBlc=4\fP. Некад то мало помогне а некад чини запакивање горим. +Ако га учини горим, испробајте такође \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Наводи број битова положаја литерала. Најмање је 0 а највише је 4; основно +је 0. +.IP "" +\fILp\fP утиче на то која врста поравнања у незапакованим подацима се +подразумева приликом шифровања литерала. Видите \fIpb\fP испод за више +информација о поравнању. +.TP +\fBpb=\fP\fIpb\fP +Наводи број битова положаја. Најмање је 0 а највише је 4; основно је 2. +.IP "" +\fIPb\fP утиче на то која врста поравнања у незапакованим подацима се +подразумева у опште. Основно значи четворобајтно поравнање (2^\fIpb\fP=2^2=4), +што је често добар избор када нема бољег решења. +.IP "" +Када је поравнање познато, постављање одговарајућег \fIpb\fP може мало да смањи +величину датотеке. На пример, са датотекама текста које имају поравнање +једног бајта (US\-ASCII, ISO\-8859\-*, UTF\-8), постављање \fBpb=0\fP може незнатно +да побољша запакивање. За UTF\-16 текст, \fBpb=1\fP је добар избор. Ако је +поравнање непаран број као 3 бајта, \fBpb=0\fP може бити најбољи избор. +.IP "" +Иако се претпостављено поравнање може подесити са \fIpb\fP и \fIlp\fP, LZMA1 и +LZMA2 и даље незнатно фаворизују 16\-бајтно поравнање. То би могло бити +вредно узети у обзир приликом дизајнирања формата датотека које ће вероватно +бити често запаковане са LZMA1 или LZMA2. +.TP +\fBmf=\fP\fImf\fP +Налазач поклапања има главни утицај на брзину шифрера, коришћење меморије и +стопу запакивања. Обично Hash Chain налазачи поклапања су бржи од Binary +Tree налазача поклапања. Основност зависи од \fIпредподешености\fP: 0 користи +\fBhc3\fP, 1\(en3 користи \fBhc4\fP, а остало користи \fBbt4\fP. +.IP "" +Следећи налазачи поклапања су подржани. Формуле коришћења меморије испод су +грубе апроксимације које су ближе стварности када је \fIречник\fP степен +двојке. +.RS +.TP +\fBhc3\fP +Ланац хеша са хеширањем 2\- и 3\-бајта +.br +Најмања вредност за \fIфино\fP: 3 +.br +Коришћење меморије: +.br +\fIречник\fP * 7.5 (ако је \fIречник\fP <= 16 MiB); +.br +\fIречник\fP * 5.5 + 64 MiB (if \fIречник\fP > 16 MiB) +.TP +\fBhc4\fP +Ланац хеша са хеширањем 2\-, 3\- и 4\-бајта +.br +Најмања вредност за \fIфино\fP: 4 +.br +Коришћење меморије: +.br +\fIречник\fP * 7.5 (ако је \fIречник\fP <= 32 MiB); +.br +\fIречник\fP * 6.5 (ако је \fIречник\fP > 32 MiB) +.TP +\fBbt2\fP +Бинарно стабло са 2\-бајта хеширања +.br +Најмања вредност за \fIфино\fP: 2 +.br +Коришћење меморије: \fIречник\fP * 9.5 +.TP +\fBbt3\fP +Бинарно стабло са 2\- и 3\-бајта хеширања +.br +Најмања вредност за \fIфино\fP: 3 +.br +Коришћење меморије: +.br +\fIречник\fP * 11.5 (if \fIречник\fP <= 16 MiB); +.br +\fIречник\fP * 9.5 + 64 MiB (ако је \fIречник\fP > 16 MiB) +.TP +\fBbt4\fP +Бинарно стабло са 2\-, 3\-, и 4\-бајта хеширања +.br +Најмања вредност за \fIфино\fP: 4 +.br +Коришћење меморије: +.br +\fIречник\fP * 11.5 (if \fIречник\fP <= 32 MiB); +.br +\fIречник\fP * 10.5 (if \fIречник\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fIрежим\fP +\fIРежим\fP запакивања наводи методу за анализу података које произведе налазач +поклапања. Подржани \fIрежими\fP су \fBfast\fP и \fBnormal\fP. Подразумева се +\fBfast\fP за \fIпредподешавања\fP 0\(en3 и \fBnormal\fP за \fIпредподешавања\fP 4\(en9. +.IP "" +Обично се \fBfast\fP користи са налазачима Hash Chain поклапања а \fBnormal\fP са +налазачима Binary Tree поклапања. Ово је исто што раде и +\fIпредподешености\fP. +.TP +\fBnice=\fP\fIфино\fP +Наводи оно што се сматра да је фина дужина за поклапање. Када се поклапање +од барем \fInice\fP бајтова нађе, алгоритам зауставља тражење могућих бољих +поклапања. +.IP "" +\fIФино\fP може бити 2\(en273 бајта. Веће вредности теже да дају бољу стопу +запакивања на уштрб брзине. Основно зависи од \fIпредподешавања\fP. +.TP +\fBdepth=\fP\fIдубина\fP +Наводи највећу дубину претраге у налазачу поклапања. Основно је посебна +вредност 0, која чини да запакивач одреди разумљиву \fIдубину\fP из \fImf\fP и +\fInice\fP. +.IP "" +Разумљива \fIдубина\fP за ланце хеша је 4\(en100 и 16\(en1000 за стабло +извршних. Коришћење врло великих вредности за \fIдубину\fP може учинити шифрер +врло спорим са неким датотекама. Избегавајте постављање \fIдубине\fP преко +1000 осим ако нисте спремни да прекинете запакивање у случају да потраје +превише дуго. +.RE +.IP "" +Приликом дешифровања сирових токова (\fB\-\-format=raw\fP), LZMA2 треба само +\fIвеличина\fP речника. LZMA1 треба такође \fIlc\fP, \fIlp\fP и \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIопције\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIопције\fP] +.PD +Додаје „branch/call/jump“ (BCJ) филтер ланцу филтера. Ови филтери могу се +користити само ако нису последњи филтер у ланцу филтера. +.IP "" +BCJ филтер претвара релативне адресе у машинском коду на њихове апсолутне +двојнике. Ово не мења величину података, али повећава сувишност, што може +помоћи LZMA2 да произведе 0\(en15\% мању \fB.xz\fP датотеку. BCJ филтери су +увек реверзибилни, стога коришћење BCJ филтера за погрешну врсту података не +доводи ни до каквог губитка података, мада може да учини степен сажимања +нешто лошијим. BCJ филтери су врло брзи и користе безначајну количину +меморије. +.IP "" +Ови BCJ филтери имају познате проблеме везане за стопу запакивања: +.RS +.IP \(bu 3 +Неке врсте датотека које садрже извршни код (на пример, објектне датотеке, +статичке библиотеке и модули Линукс кернела) имају адресе у упутствима +испуњеним вредностима попуњавача. Ови BCJ филтери и даље ће радити +претварање адресе, што ће запакивање учинити горим са овим датотекама. +.IP \(bu 3 +Ако се BCJ филтер примени на архиву, могуће је да ће учинити стопу +запакивања лошијим него кад се не би користио. На пример, ако постоје +сличне или чак истоветне извршне тада ће филтрирање вероватно учинити +датотеке мање сличним и стога је запакивање лошије. Садржај не\-извршних +датотека у истој архиви је такође важан. У пракси се мора покушати са и без +BCJ филтера да би се видело шта је боље у којој прилици. +.RE +.IP "" +Различити скупови упутстава имају различита поравнања: извршна датотека мора +бити поравната на множилац ове вредности у улазним подацима како би филтер +радио. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Филтер;Поравнање;Напомене +x86;1;32\-бита или 64\-бита x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096\-бита поравнање је најбоље +PowerPC;4;Само велика крајност +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Како су BCJ\-филтрирани подаци обично запаковани са LZMA2, стопа запакивања +може бити незнатно побољшана ако су LZMA2 опције постављене да поклопе +поравнање изабраног BCJ филтера. Примери: +.RS +.IP \(bu 3 +IA\-64 филтер има поравнање 16\-бајта тако да је \fBpb=4,lp=4,lc=0\fP добро са +LZMA2 (2^4=16). +.IP \(bu 3 +RISC\-V код има поравнање од 2 или 4 бајта у зависности од тога да ли +датотека садржи запаковане инструкције од 16 бита (проширење C). Када се +користе инструкције од 16 бита, \fBpb=2,lp=1,lc=3\fP или \fBpb=1,lp=1,lc=3\fP је +добро. Када нема инструкција од 16 бита, \fBpb=2,lp=2,lc=2\fP је најбоље. +\fBreadelf \-h\fP се може користити да се провери да ли се „RVC“ јавља у реду +„Заставице“. +.IP \(bu 3 +ARM64 је увек 4\-бајта поравнат тако да је \fBpb=2,lp=2,lc=2\fP најбоље. +.IP \(bu 3 +Филтер x86 је изузетак. Обично је добро придржавати се LZMA2 основности +(\fBpb=2,lp=0,lc=3\fP) приликом запакивања x86 извршних. +.RE +.IP "" +Сви BCJ филтери подржавају исте \fIопције\fP: +.RS +.TP +\fBstart=\fP\fIпомерај\fP +Наводи \fIпомерај\fP почетка који се користи приликом претварања између +релативних и апсолутних адреса. \fIПомерај\fP мора бити производ поравнања +филтера (видите табелу изнад). Основно је нула. У пракси, основност је +добра; навођење произвољног \fIпомераја\fP скоро никада није од користи. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIопције\fP] +Додаје Delta филтер у ланац филтера. Делта филтер може се користити само +ако није последњи филтер у ланцу филтера. +.IP "" +Тренутно је подржан само једноставан делта прорачун једног по једног бита. +Може бити користан приликом запакивања, на пример, незапакованих битмап +слика или незапакованог PCM звука. Међутим, алгоритми посебне намене могу +дати знатно боље резултате него Delta + LZMA2. Ово је тачно, посебно са +звуком, који се запакује брже и боље, на пример, са \fBflac\fP(1). +.IP "" +Подржане \fIопције\fP: +.RS +.TP +\fBdist=\fP\fIрастојање\fP +Наводи \fIрастојање\fP делта прорачуна у бајтима. \fIРастојање\fP мора бити +1\(en256. Основно је 1. +.IP "" +На пример, са \fBdist=2\fP и осмобајтним улазом A1 B1 A2 B3 A3 B5 A4 B7, излаз +ће бити A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Остале опције" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Потискује упозорења и обавештења. Наведите ово два пута да потиснете и +грешке. Ова опција нема утицаја на стање излаза. Тако је, чак и ако је +упозорење потиснуто, стање излаза које указује на упозорење се и даље +користи. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Бива опширан. Ако је стандардна грешка повезана са терминалом, \fBxz\fP ће +приказати указивач напретка. Навођењем \fB\-\-verbose\fP два пута добија се још +опширнији излаз. +.IP "" +Указивач напредовања показује следеће информације: +.RS +.IP \(bu 3 +Проценат довршености се показује ако је величина улазне датотеке позната. +Тако је, проценат се не може приказати у спојкама. +.IP \(bu 3 +Количина запакованих података проистеклих (запакивање) или утрошених +(распакивање). +.IP \(bu 3 +Количина распакованих података утрошених (запакивање) или проистеклих +(распакивање). +.IP \(bu 3 +Размера паковања, која се израчунава дељењем количине запакованих података +обрађених до сада количином незапакованих података до сада обрађених. +.IP \(bu 3 +Брзина запакивања или распакивања. Ово се мери као количина незапакованих +података утрошених (запакивање) или добијених (распакивање) у секунди. +Приказује се након неколико секунде након што \fBxz\fP започне обраду датотеке. +.IP \(bu 3 +Протекло време у формату М:СС или Ч:ММ:СС. +.IP \(bu 3 +Процењено преостало време се приказује само када је величина улазне датотеке +позната и неколико секунди је већ протекло од кад је \fBxz\fP започео обраду +датотеке. Време се приказује у мање тачном формату које никада нема +двотачке, на пример, 2 мин 30 сек. +.RE +.IP "" +Када стандардна грешка није терминал, \fB\-\-verbose\fP ће учинити да \fBxz\fP +испише назив датотеке, запаковану величину, незапаковану величину, стопу +запакивања и по могућству такође брзину и протекло време на једном реду на +стандардну грешку након запакивања или распакивања датотеке. Брзина и +протекло време су укључени само када радња потраје барем неколико секунде. +Ако се радња не заврши, на пример, услед што корисник прекине, такође се +исписује проценат завршености ако је величина улазне датотеке позната. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Не поставља стање излаза на 2 чак и ако је услов вредан упозорења откривен. +Ова опција не утиче на ниво опширности, стога и \fB\-\-quiet\fP и \fB\-\-no\-warn\fP +треба да се користе да се не приказују упозорења и да се не измени стање +излаза. +.TP +\fB\-\-robot\fP +Исписује поруке у формату обрадивом машинама. Ово је замишљено да олакша +писање челника који желе да користе \fBxz\fP уместо „liblzma“, што може бити +случај са разним скриптама. Излаз са овом опцијом укљученом је замишљен да +буде стабилан кроз \fBxz\fP издања. Видите одељак \fBРЕЖИМ РОБОТА\fP за више о +томе. +.TP +\fB\-\-info\-memory\fP +Приказује, у формату читљивом људима, колико физичке меморије (RAM) и колико +нити процесора \fBxz\fP мисли да систем има и ограничења коришћења меморије за +запакивање и распакивање и излази успешно. +.TP +\fB\-h\fP, \fB\-\-help\fP +Приказује поруку помоћи описујући најчешће коришћених опција, и успешно +излази. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Приказује поруку помоћи описујући све функције \fBxz\fP, и успешно излази +.TP +\fB\-V\fP, \fB\-\-version\fP +Приказује број издања за \fBxz\fP и „liblzma“ у формату читљивом људима. Да +добијете излаз машинама обрадив, наведите \fB\-\-robot\fP пре \fB\-\-version\fP. +. +.SH "РЕЖИМ РОБОТА" +Режим робота се покреће опцијом \fB\-\-robot\fP. Чини да излаз \fBxz\fP буде лакши +за обраду другим програмима. Тренутно \fB\-\-robot\fP је подржано само заједно +са \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, и \fB\-\-version\fP. Биће +подржан за запакивање и распакивање у будућности. +. +.SS "Режим списка" +\fBxz \-\-robot \-\-list\fP користи излаз раздвојен табулатором. Прва колона +сваког реда садржи ниску која указује на врсту информације која се налази у +том реду: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP (назив) +Ово је увек први ред приликом почетка листања датотеке. Друга колона у реду +је назив датотеке. +.TP +\fBfile\fP (датотека) +Овај ред садржи свеукупне информације о \fB.xz\fP датотеци. Овај ред се увек +исписује после реда \fBназив\fP. +.TP +\fBstream\fP (ток) +Ова врста реда се користи само када је \fB\-\-verbose\fP наведено. Има толико +редова \fBтока\fP колико има токова у \fB.xz\fP даатотеци. +.TP +\fBblock\fP (блок) +Ова врста реда се користи само када је \fB\-\-verbose\fP наведено. Има онолико +редова \fBблока\fP колико има блокова у \fB.xz\fP датотеци. Редови \fBблока\fP се +приказују након свих редова \fBтока\fP; различите врсте реда се не преплићу. +.TP +\fBsummary\fP (сажетак) +Ова врста реда се користи само када је \fB\-\-verbose\fP наведено два пута. Овај +ред се исписује након свих редова \fBблока\fP. Као ред \fBдатотека\fP, ред +\fBсажетка\fP садржи преглед информација о \fB.xz\fP датотеци. +.TP +\fBtotals\fP (укупност) +Овај ред је увек последњи ред на списку излаза. Показује укупне збирове и +величине. +.PP +Колоне редова \fBдатотеке\fP: +.PD 0 +.RS +.IP 2. 4 +Број токова у датотеци +.IP 3. 4 +Укупан број блокова у току(овима) +.IP 4. 4 +Величина запаковане датотеке +.IP 5. 4 +Величина незапаковане датотеке +.IP 6. 4 +Размера паковања, на пример, \fB0.123\fP. Ако је размера преко 9.999, три +цртице (\fB\-\-\-\fP) се приказују уместо размере. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Зарезом раздвојен списак назива провера целовитости. Следеће ниске се +користе за познате врсте провера: \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP и \fBSHA\-256\fP. +За непознате врсте провера, користи се \fBUnknown\-\fP\fIN\fP, где је \fIN\fP ИД +провере као децимални број (једна или две цифре). +.IP 8. 4 +Укупна величина попуњавања тока у датотеци +.RE +.PD +.PP +Колоне редова \fBтока\fP: +.PD 0 +.RS +.IP 2. 4 +Број тока (први ток је 1) +.IP 3. 4 +Број блокова у току +.IP 4. 4 +Померај почетка запакованог +.IP 5. 4 +Померај почетка незапаковане +.IP 6. 4 +Величина запакованог (не укључује попуну тока) +.IP 7. 4 +Величина незапаковане +.IP 8. 4 +Размера паковања +.IP 9. 4 +Назив провере целовитости +.IP 10. 4 +Величина попуне тока +.RE +.PD +.PP +Колоне редова \fBблока\fP: +.PD 0 +.RS +.IP 2. 4 +Број тока који садржи овај блок +.IP 3. 4 +Број блока релативан на почетак тока (први блок је 1) +.IP 4. 4 +Број блока релативан на почетак датотеке +.IP 5. 4 +Померај почетка запакованог односан на почетак датотеке +.IP 6. 4 +Померај почетка незапаковане односан на почетак датотеке +.IP 7. 4 +Укупна запакована величина блока (заједно са заглављима) +.IP 8. 4 +Величина незапаковане +.IP 9. 4 +Размера паковања +.IP 10. 4 +Назив провере целовитости +.RE +.PD +.PP +Ако је \fB\-\-verbose\fP наведено два пута, додатне колоне су укључене у редовима +\fBблока\fP. Они се не приказују са једним \fB\-\-verbose\fP, јер добијање ове +информације захтева много тражења и стога може бити споро: +.PD 0 +.RS +.IP 11. 4 +Вредност провере целовитости у хексадецималном облику +.IP 12. 4 +Величина заглавља блока +.IP 13. 4 +Заставице блока: \fBc\fP указује да је величина запакованог присутна, а \fBu\fP +указује да је величина нераспакованог присутна. Ако заставица није +постављена, цртица (\fB\-\fP) се приказује уместо да се настави са поправком +дужине ниске. У будућности нове заставице могу бити додате на крај ниске. +.IP 14. 4 +Величина стварних запакованих података у блоку (ово искључује заглавље +блока, попуњавање блока и поља провере) +.IP 15. 4 +Количина меморије (у бајтовима) потребна за распакивање овог блока са овим +\fBxz\fP издањем +.IP 16. 4 +Ланац филтера. Знајте да већина опција коришћених за време запакивања не +може бити познато, јер се само опције које су потребне за распакивање чувају +у \fB.xz\fP заглављима. +.RE +.PD +.PP +Колоне редова \fBсажетка\fP: +.PD 0 +.RS +.IP 2. 4 +Количина меморије (у бајтовима) потребна за распакивање ове датотеке са овим +\fBxz\fP издањем +.IP 3. 4 +\fByes\fP или \fBno\fP указује да ли сва заглавља блока имају и величину +запакованог и величину незапакованог сачуване у њима +.PP +\fIОд\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Потребно је најмање \fBxz\fP издање за распакивање датотеке +.RE +.PD +.PP +Колоне редова \fBукупности\fP: +.PD 0 +.RS +.IP 2. 4 +Број токова +.IP 3. 4 +Број блокова +.IP 4. 4 +Величина запакованог +.IP 5. 4 +Величина незапаковане +.IP 6. 4 +Просечан степен запакивања +.IP 7. 4 +Списак зарезом раздвојених назива провере целовитости која су била присутна +у датотекама +.IP 8. 4 +Величина попуњавања тока +.IP 9. 4 +Број датотека. Ту се држи поредак ранијих колона исто као у редовима +\fBдатотеке\fP. +.PD +.RE +.PP +Ако је \fB\-\-verbose\fP наведено два пута, додатне колоне су укључене у реду +\fBtotals\fP: +.PD 0 +.RS +.IP 10. 4 +Највећа количина меморије (у бајтима) потребна за распакивање датотеке са +овим \fBxz\fP издањем +.IP 11. 4 +\fByes\fP или \fBno\fP указује да ли сва заглавља блока имају и величину +запакованог и величину незапакованог сачуване у њима +.PP +\fIОд\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Потребно је најмање \fBxz\fP издање за распакивање датотеке +.RE +.PD +.PP +Будућа издања могу додати нове врсте реда и нове колоне се могу додати +постојећим врстама реда, али постојеће колоне се неће променити. +. +.SS "Помоћ филтера" +\fBxz \-\-robot \-\-filters\-help\fP исписује подржане филтере у следећем формату: +.PP +\fIфилтер\fP\fB:\fP\fIопција\fP\fB=<\fP\fIвредност\fP\fB>,\fP\fIопција\fP\fB=<\fP\fIвредност\fP\fB>\fP... +.TP +\fIфилтер\fP +Назив филтера +.TP +\fIопција\fP +Назив филтера специфичне опције +.TP +\fIвредност\fP +Опсези бројевних \fIвредности\fP се јављају као +\fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. \fIВредност\fP ниске избора се приказују +унутар \fB< >\fP и раздвојене су знаком \fB|\fP. +.PP +Сваки филтер се исписује на свом сопственом реду. +. +.SS "Информације о ограничењу меморије" +\fBxz \-\-robot \-\-info\-memory\fP исписује један ред са више колона раздвојених +табулатором: +.IP 1. 4 +Укупна количина физичке меморије (RAM) у бајтима. +.IP 2. 4 +Ограничење коришћења меморије за запакивање у бајтима +(\fB\-\-memlimit\-compress\fP). Специјална вредност \fB0\fP означава основно +подешавање које је за режим једне нити исто као без ограничења. +.IP 3. 4 +Ограничење коришћења меморије за распакивање у бајтима +(\fB\-\-memlimit\-decompress\fP). Специјална вредност \fB0\fP означава основно +подешавање које је за режим једне нити исто као без ограничења. +.IP 4. 4 +Од \fBxz\fP 5.3.4alpha: Коришћење меморије за распакивање са више нити у +бајтима (\fB\-\-memlimit\-mt\-decompress\fP). Ово никада није нула јер систему +специфична основна вредност приказана у колони 5 се користи ако ограничење +није изричито наведено. Такође никада није веће од вредности у колони 3 чак +и ако је наведена већа вредност са \fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Од \fBxz\fP 5.3.4alpha: Систему специфично основно ограничење коришћења +меморије које се користи за ограничавање броја нити приликом запакивања са +аутоматским бројем нити (\fB\-\-threads=0\fP) и без наведеног ограничења +коришћења меморије (\fB\-\-memlimit\-compress\fP). Ово се такође користи као +основна вредност за \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Од \fBxz\fP 5.3.4alpha: Број доступних нити обрађивача. +.PP +У будуће, излаз \fBxz \-\-robot \-\-info\-memory\fP може имати више колона, али +никада више од једног реда. +. +.SS Издање +\fBxz \-\-robot \-\-version\fP исписује број издања за \fBxz\fP и „liblzma“ у следећем +формату: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Главно издање. +.TP +\fIYYY\fP +Споредно издање. Парни бројеви су стабилна а непарни су алфа или бета +издања. +.TP +\fIZZZ\fP +Ниво закрпе за стабилна издања или само бројач за развојна издања. +.TP +\fIS\fP +Стабилност. 0 је алфа, 1 је бета, а 2 је стабилно. \fIS\fP треба увек да буде +2 када је \fIYYY\fP парно. +.PP +\fIXYYYZZZS\fP су исти у оба реда ако су \fBxz\fP и „liblzma“ из истог издања XZ +Utils\-а. +.PP +Примери: 4.999.9beta је \fB49990091\fP и 5.0.0 је \fB50000002\fP. +. +.SH "СТАЊЕ ИЗЛАЗА" +.TP +\fB0\fP +Све је у реду. +.TP +\fB1\fP +Дошло је до грешке. +.TP +\fB2\fP +Десило се нешто вредно упозорења, али није дошло до стварних грешака. +.PP +Обавештења (без упозорења или грешака) исписано на стандардној грешци не +утичу на стање излаза. +. +.SH ОКРУЖЕЊЕ +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP обрађује размаком одвојени списак опција из променљивих окружења +\fBXZ_DEFAULTS\fP и \fBXZ_OPT\fP, тим редом, пре обраде опција са линије наредби. +Знајте да се обрађују само опције из променљивих окружења; све што нису +опције се тихо занемарује. Обрада се ради са \fBgetopt_long\fP(3) која се +користи такође за аргументе линије наредби. +.PP +\fBУпозорење:\fP Постављањем ових променљивих окружења, ефективно мењате +програме и скрипте које покреће \fBxz\fP. У већини случајева је безбедно +поставити ограничење коришћења, број нити и опција паковања путем +променљивих окружења. Међутим, неке опције могу да уруше скрипте. +Очигледан пример је \fB\-\-help\fP која чини да \fBxz\fP прикаже текст помоћи уместо +да запакује или распакује датотеку. Суптилнији примери су \fB\-\-quiet\fP и +\fB\-\-verbose\fP. У многим случајевима добро функционише омогућавање указивача +напредовања коришћењем \fB\-\-verbose\fP, али у неким ситуацијама додатне поруке +стварају проблеме. Ниво опширности такође утиче на понашање \fB\-\-list\fP +.TP +\fBXZ_DEFAULTS\fP +Кориснику специфичне или свеопште системске основне опције. Обично је ово +постављено у скрипти покретања конзоле за укључивање \fBxz\fP ограничавача +коришћења меморије по основи или за постављање основног броја нити. +Искључивање скрипти покретања конзоле и сличних специјалних случајева, +скрипте не смеју никада да поставе или пониште \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Ово је за прослеђивање опција ка \fBxz\fP када није могуће поставити опције +директно на \fBxz\fP линији наредби. Ово је случај када је \fBxz\fP покренут +скриптом или алатом, на пример, са Гну \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Скрипте могу да користе \fBXZ_OPT\fP, на пример, за постављање основних опција +запакивања специфичних скрипти. Још увек се препоручује омогућавање +корисницима да пишу преко \fBXZ_OPT\fP ако је то разумљиво. На пример, у +\fBsh\fP(1) скриптама неко може користити нешто као ово: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "LZMA UTILS САДЕЈСТВЕНОСТ" +Синтакса линије наредби \fBxz\fP је практично супер скуп \fBlzma\fP, \fBunlzma\fP и +\fBlzcat\fP као што се налази у LZMA Utils 4.32.x. У већини случајева, могуће +је заменити LZMA Utils са XZ Utils без оштећења постојећих скрипти. Има +неких несагласности такође, које понекад могу довести до проблема. +. +.SS "Нивои предподешавања запакивања" +Набрајање предподешености нивоа запакивања није исто у \fBxz\fP и LZMA Utils. +Најважнија разлика је у томе како се величине речника мапирају у различитим +предподешеностима. Величина речника је отприлике иста као и коришћење +меморије распакивача. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Ниво;xz;LZMA Utils +\-0;256 KiB;Н/Д +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Разлике величине речника делују такође на коришћење меморије запакивање, али +постоје још неке разлике између LZMA Utils и XZ Utils, што чини разлике још +већим: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Ниво;xz;LZMA Utils 4.32.x +\-0;3 MiB;Н/Д +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Основни ниво предподешености у LZMA Utils је \fB\-7\fP док у XZ Utils је \fB\-6\fP, +тако да оба користе 8 MiB речник по основи. +. +.SS "Токовне наспрам не\-токовних „.lzma“ датотеке" +Незапакована величина датотеке се може чувати у \fB.lzma\fP заглављу. LZMA +Utils то ради приликом запакивања обичних датотека. Алтернатива је да се +означи та незапакована величина као непозната и да се користи означавач +краја утовара да назначи где распакивач треба да стане. LZMA Utils користи +ову методу када незапакована величина није позната, што је случај, на +пример, у спојкама. +.PP +\fBxz\fP подржава распакивање \fB.lzma\fP датотека са или без означавача краја +утовара, али ће све \fB.lzma\fP датотеке направљене са \fBxz\fP користити +означавач краја утовара и означити незапаковану величину непознатом у +\&\fB.lzma\fP заглављу. Ово може бити проблем у неким неуобичајеним +ситуацијама. На пример, \fB.lzma\fP распакивач у угнежденом уређају може +радити само са датотекама које имају незапаковану величину. Ако наиђете на +тај проблем, треба да користите LZMA Utils или LZMA SDK да направите +\&\fB.lzma\fP датотеке са познатом незапакованом величином. +. +.SS "Неподржане „.lzma“ датотеке" +Формат \fB.lzma\fP омогућава \fIlc\fP вредности све до 8, а \fIlp\fP вредности све до +4. LZMA Utils може да распакује датотеке са било којим \fIlc\fP и \fIlp\fP, али +увек прави датотеке са \fBlc=3\fP и \fBlp=0\fP. Прављење датотека са другим \fIlc\fP +и \fIlp\fP је мгуће са \fBxz\fP и са LZMA SDK. +.PP +Примена филтера LZMA1 у „liblzma“ захтева да збир \fIlc\fP и \fIlp\fP не сме да +премаши 4. Стога, \fB.lzma\fP датотеке, које премаше ово ограничење, не могу +да се распакују са \fBxz\fP. +.PP +LZMA Utils прави само \fB.lzma\fP датотеке које имају величину речника од +2^\fIn\fP (степен 2) али прихвата датотеке са било којом величином речника. +„liblzma“ прихвата само \fB.lzma\fP датотеке које имају величину речника од +2^\fIn\fP или 2^\fIn\fP + 2^(\fIn\fP\-1). Ово је да се смање лажни позитивни +резултати приликом откривања \fB.lzma\fP датотека. +.PP +Ова ограничења не би требало да буду проблем у пракси, јер су практично све +\&\fB.lzma\fP датотеке запаковане са поставкама које ће „liblzma“ прихватити. +. +.SS "Пратеће смеће" +Приликом распакивања, LZMA Utils тихо занемарује све после првог \fB.lzma\fP +тока. У већини прилика, ово је грешка. Ово такође значи да LZMA Utils не +подржава распакивање надовезаних \fB.lzma\fP датотека. +.PP +Ако су остали подаци након првог \fB.lzma\fP тока, \fBxz\fP сматра да је датотека +оштећена осим ако је коришћено \fB\-\-single\-stream\fP. Ово може прекинути +нејасне скрипте које су претпоставиле да је пратеће смеће занемарено. +. +.SH НАПОМЕНЕ +. +.SS "Излаз запакованог може бити променљив" +Тачан запаковани излаз добијен из исте незапаковане улазне датотеке може се +разликовати између XZ Utils издања чак и ако су опције запакивања +истоветне. Ово је због тога што шифрер може бити побољшан (брже и боље +запакивање) а да не утиче на формат датотеке. Излаз се може разликовати +између различитих изградњи истог XZ Utils издања, ако су коришћене другачије +опције изградње. +.PP +Ово изнад значи да када се \fB\-\-rsyncable\fP једном примени, резултирајућа +датотека неће неопходно бити r\-ускладива осим ако и стара и нова датотека +нису запаковане истим xz издањем. Овај проблем може бити поправљен ако је +део примене шифрера замрзнут да држи r\-ускладив излаз стабилним кроз xz +издања. +. +.SS "Угнеждени „.xz“ распакивачи" +Примена угнежденог \fB.xz\fP распакивача као што је XZ Embedded неопходно не +подржава датотеке направљене врстама \fIпровере\fP целовитости осим \fBnone\fP и +\fBcrc32\fP. Како је основно \fB\-\-check=crc64\fP, морате да користите +\fB\-\-check=none\fP или \fB\-\-check=crc32\fP када правите датотеке за угнеждене +системе. +.PP +Споља уграђени системи, сви распакивачи \fB.xz\fP формата подржавају све врсте +\fIпровере\fP, или барем могу да распакују датотеку без испитивања провере +целовитости ако одређена \fIпровера\fP није подржана. +.PP +XZ Embedded подржава BCJ филтере, али само са основним померајем почетка. +. +.SH ПРИМЕРИ +. +.SS Основно +Запакује датотеку \fIfoo\fP у \fIfoo.xz\fP користећи основни ниво запакивања +(\fB\-6\fP), и уклања \fIfoo\fP ако је запакивање успешно: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Распакује \fIbar.xz\fP у \fIbar\fP и не уклања \fIbar.xz\fP чак и када је распакивање +успешно: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Ствара \fIbaz.tar.xz\fP са предподешавањем \fB\-4e\fP (\fB\-4 \-\-extreme\fP), које је +спорије него основно \fB\-6\fP, али захтева мање меморије за запакивање и +распакивање (48\ MiB и 5\ MiB): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Мешавина сажетих и несажетих датотека се може распаковати на стандардни +излаз једном наредбом: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Паралелно запакивање више датотека" +На GNU и *BSD, \fBfind\fP(1) и \fBxargs\fP(1) се могу користити за паралелно +запакивање више датотека: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Опција \fB\-P\fP за \fBxargs\fP(1) поставља број паралелних \fBxz\fP процеса. Најбоља +вредност за опцију \fB\-n\fP зависи од тога колико датотека има за запакивање. +Ако има само неколико датотека, вредност би вероватно требала да буде 1; са +више хиљада датотека, 100 или чак и више може бити одговарајуће за смањење +броја \fBxz\fP процеса које би \fBxargs\fP(1) евентуално направио. +.PP +Опција \fB\-T1\fP за \fBxz\fP је ту да га примора на једнонитни режим, јер се +\fBxargs\fP(1) користи за контролу количине паралелизације. +. +.SS "Режим робота" +Израчунава колико је бајтова укупно сачувано након запакивања више датотека: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Скрипта може желети да зна да користи најновији \fBxz\fP. Следећа скрипта +\fBsh\fP(1) проверава да ли је број издања \fBxz\fP алата барем 5.0.0. Ова +метода је сагласна са старим бета издањима која не подржавају \fB\-\-robot\fP +опцију: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Ваш „xz“ је превише стар." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Поставља ограничење коришћења меморије за распакивање коришћењем \fBXZ_OPT\fP, +али ако је ограничење већ постављено, не повећава је: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Произвољни ланци филтера запакивача" +Најједноставнија употреба за произвољне ланце филтера прилагођава LZMA2 +предподешеност. Ово може бити корисно, јер предподешености покривају само +подскуп потенцијално корисних комбинација поставки запакивања. +.PP +Колоне ЗапакЦПЈ у табелама из описа опција \fB\-0\fP ... \fB\-9\fP и \fB\-\-extreme\fP су +корисне приликом прилагођавања LZMA2 предподешености. Овде су значајни +делови прикупљени из те две табеле: +.RS +.PP +.TS +tab(;); +c c +n n. +Преподешеност;ЗапакЦПЈ +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Ако знате да датотека захтева нешто велики речник (на пример, 32 \ MiB) за +добро запакивање, али желите да је запакујете брже него што би то \fBxz \-8\fP +урадио, предподешеност са ниском вредношћу ЗапакМем (на пример, 1) може се +изменити да користи већи речник: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Са одређеним датотекама, горња наредба може бити бржа од \fBxz \-6\fP а +запакивање значајно боље. Међутим, мора бити наглашено да само неке +датотеке имају корист од великог речника док одржавају вредност ЗапакЦПЈ +ниском. Најочигледнија ситуација, у којој велики речник може доста помоћи, +јесте архива која садржи врло сличне датотеке где свака има најмање неколико +мегабајта. Величина речника треба да буде значајно већа од сваке засебне +датотеке да би се омогућило да LZMA2 има потпуну предност од сличности +између узастопних датотека. +.PP +Ако је веома велико коришћење меморије запакивача и распакивача у реду, а +датотека која се запакује је барем неколико стотина мегабајта, може бити +корисно користити још већи речник од 64 MiB који ће \fBxz \-9\fP користити: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Коришћење \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) као у горњем примеру може бити +корисно да се виде захтеви за меморијом запакивача и распакивача. Знајте да +је коришћење речника већег од величине незапаковане датотеке губитак +меморије, тако да горња наредба није корисна за мале датотеке. +.PP +Понекад време запакивања није важно, али коришћење меморије распакивача +треба да се одржава ниским, на пример, да би се учинило могућим распакивање +датотеке на угнежденом систему, Следеће наредбе користе \fB\-6e\fP (\fB\-6 \-\-extreme\fP) као основу и постављају речник на само 64\ KiB. Резултујућа +датотека се може распаковати са XZ Embedded (због тога је ту +\fB\-\-check=crc32\fP) користећи око 100\ KiB меморије. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Ако желите да исцедите што је више могуће бајтова, дотеривање броја битова +контекста литерала (\fIlc\fP) и броја битова положаја (\fIpb\fP) може понекад да +помогне. Дотеривање броја битова положаја литерала (\fIlp\fP) може такође да +помогне, али обично \fIlc\fP и \fIpb\fP су важнији. На пример, архива извора кода +садржи углавном US\-ASCII текст, тако да нешто као следеће може да да +незнатно (око 0.1\ %) мању датотеку него \fBxz \-6e\fP (пробајте такође без +\fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Коришћење још једног филтера заједно са LZMA2 може побољшати запакивање са +одређеним врстама датотека. На пример, за запакивање x86\-32 или x86\-64 +дељене библиотеке коришћењем x86 BCJ филтера: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Знајте да поредак опција филтера има значај. Ако је \fB\-\-x86\fP наведено након +\fB\-\-lzma2\fP, \fBxz\fP ће дати грешку, јер не сме бити никаквог филтера после +LZMA2, и такође зато што се x86 BCJ филтер не може користити као последњи +филтер у ланцу. +.PP +Delta филтер заједно са LZMA2 може дати добре резултате са битмап сликама. +Требало би обично да надјача PNG, који има нешто више напредних филтера него +једноставни делта али користи Deflate за стварно запакивање. +.PP +Слика треба да се сачува у незапакованом формату, на пример, као +незапакована TIFF. Параметар растојања Delta филтера је постављен да се +подудари са бројем бајтова по пикселу у слици. На пример, RGB битмапа од 24 +бита захтева \fBdist=3\fP, а такође је добро проследити \fBpb=0\fP за LZMA2 да се +прилагоди поравнање од три бајта: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Ако је више слика стављено у једну архиву (на пример, \fB.tar\fP), Delta филтер +ће радити на томе такође све док све слике не буду имале исти број бајтова +по пикселу. +. +.SH "ВИДИТЕ ТАКОЂЕ" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xzcat.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xzcat.1 new file mode 100644 index 0000000000000000000000000000000000000000..82d831001e1f400683d876e945d108fa8686a45a --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xzcat.1 @@ -0,0 +1,1928 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Serbian translation of xz-man. +.\" Мирослав Николић , 2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 08.03.2025. Tukaani "XZ Utils" +. +.SH НАЗИВ +xz, unxz, xzcat, lzma, unlzma, lzcat – Запакује или распакује „.xz“ и „.lzma +датотеке +. +.SH САЖЕТАК +\fBxz\fP [\fIопција...\fP] [\fIдатотека...\fP] +. +.SH "АЛИЈАСИ НАРЕДБЕ" +\fBunxz\fP је исто као и \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP је исто као и \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP је исто као и \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP је исто као и \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP је исто као и \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +Приликом писања скрипти које треба да распакују датотеке, препоручује се да +се увек користи назив \fBxz\fP са одговарајућим аргументима (\fBxz \-d\fP или \fBxz \-dc\fP) уместо назива \fBunxz\fP и \fBxzcat\fP. +. +.SH ОПИС +\fBxz\fP је алат опште употребе за запакивање података са синтаксом линије +наредби сличан као \fBgzip\fP(1) и \fBbzip2\fP(1). Изворни формат датотеке је +\&\fB.xz\fP формат, али стари \fB.lzma\fP формат који користи LZMA Utils и сирови +запаковани токови без заглавља формата су такође подржани. Уз то, +распакивање \fB.lz\fP формата који користи \fBlzip\fP је подржано. +.PP +\fBxz\fP запакује или распакује сваку \fIдатотеку\fP у складу са изабраним режимом +рада. Ако није дата ни једна \fIдатотека\fP или је датотека \fIfile\fP \fB\-\fP, +\fBxz\fP чита са стандардног улаза и записује обрађене податке на стандардни +излаз. \fBxz\fP ће одбити (приказаће грешку и прескочити \fIдатотеку\fP) да пише +запаковане податке на стандардни излаз ако је то терминал. Слично, \fBxz\fP ће +одбити да чита запаковане податке са стандардног улаза ако је то терминал. +.PP +Осим ако није наведено \fB\-\-stdout\fP, \fIдатотеке\fP које нису \fB\-\fP се пишу у +нову датотеку чији назив је проистекао из назива изворне \fIдатотеке\fP: +.IP \(bu 3 +Приликом запакивања, суфикс формата циљне датотеке (\fB.xz\fP или \fB.lzma\fP) се +додаје на назив изворне датотеке да би се добио назив циљне датотеке. +.IP \(bu 3 +Приликом распакивања, суфикс \fB.xz\fP, \fB.lzma\fP или \fB.lz\fP се уклања из назива +датотеке да би се добио назив циљне датотеке. \fBxz\fP такође препознаје +суфиксе \fB.txz\fP и \fB.tlz\fP и замењује их суфиксом \fB.tar\fP. +.PP +Ако циљна датотека већ пстоји, приказује се грешка а \fIдатотека\fP се +прескаче. +.PP +Осим ако не пише на стандардни излаз, \fBxz\fP ће приказати упозорење и +прескочити \fIдатотеку\fP ако се нешто од следећег примењује: +.IP \(bu 3 +\fIДатотека\fP није обична датотека. Симболичке везе се не прате, и стога се +не сматра да су обичне датотеке. +.IP \(bu 3 +\fIДатотека\fP има више од једне чврсте везе. +.IP \(bu 3 +\fIДатотека\fP има постављен „setuid, setgid“ или лепљиви бит. +.IP \(bu 3 +Режим рада је постављен на запакивање а \fIдатотека\fP већ има суфикс формата +циљне датотеке (\fB.xz\fP или \fB.txz\fP приликом запакивања у \fB.xz\fP формат, а +\&\fB.lzma\fP или \fB.tlz\fP приликом запакивања у \fB.lzma\fP формат). +.IP \(bu 3 +Режим радње је постављен за распакивање а \fIдатотека\fP нема суфикс ни једног +од подржаних формата датотеке (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP или +\&\fB.lz\fP). +.PP +Након успешног сажимања или распакивања \fIдатотеке\fP, \fBxz\fP умножава +власника, групу, дозволе, време приступа и време измене из изворне +\fIдатотеке\fP у циљну датотеку. Ако умножавање групе не успе, дозволе су +измењене тако да циљна датотека не постане доступна корисницима који нису +имали дозволу за приступ изворној \fIдатотеци\fP. \fBxz\fP не подржава умножавање +других метаподатака попут списка контрола приступа или проширених атрибута. +.PP +Једном када је циљна датотека успешно затворена, изворна \fIдатотека\fP се +уклања осим ако се \fB\-keep\fP не наведе. Изворна \fIдатотека\fP се никада не +уклања ако се излаз пише на стандардни излаз или ако дође до грешке. +.PP +Слање \fBSIGINFO\fP или \fBSIGUSR1\fP ка \fBxz\fP процесу чини да испише информације +напредовања на стандардну грешку. Ово има ограничено коришћење све док +стандардна грешка јесте терминал, коришћење \fB\-\-verbose\fP приказаће +аутоматски указивач напретка освежавања. +. +.SS "Коришћење меморије" +Коришћење меморије \fBxz\fP се мења од неколико стотина килобајта до неколико +гигабајта у зависности од поставки запакивања. Поставке коришћене приликом +запакивања датотеке одређују захтеве меморије распакивача. Обично +распакивачу треба 5\ % до 20\ % количине меморије која је потребна +запакивачу приликом прављења датотеке. На пример, распакивање датотеке +направљене са \fBxz \-9\fP тренутно захтева 65\ MiB меморије. Још увек, могуће +је имати \fB.xz\fP датотеке које захтевају неколико гигабајта меморије за +распакивање. +.PP +Нарочито корисници старијих система могу наћи досадном могућност коришћења +врло велике меморије. Да би се спречила нежељена изненађења, \fBxz\fP има +уграђен ограничавач коришћења меморије, који је искључен по основи. Док +неки оперативни системи пружају начин за ограничавање коришћење меморије за +процесе, ослањање на то сматра се да није довољно прилагодљиво (на пример, +коришћење \fBulimit\fP(1) за ограничавање виртуелне меморије тежи да обогаљи +\fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Ограничавач коришћења меморије се може укључити опцијом линије наредби +\fB\-\-memlimit=\fP\fIограничење\fP. Често је најпогодније укључити ограничавач по +основи постављањем променљиве окружења \fBXZ_DEFAULTS\fP, на пример, +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Могуће је поставити ограничења засебно за +запакивање и распакивање коришћењем \fB\-\-memlimit\-compress=\fP\fIограничење\fP и +\fB\-\-memlimit\-decompress=\fP\fIограничење\fP. Коришћење ове две опције ван +\fBXZ_DEFAULTS\fP је ретко корисно јер једно покретање \fBxz\fP не може да ради и +запакивање и распакивање а \fB\-\-memlimit=\fP\fIограничење\fP (или \fB\-M\fP +\fIограничење\fP) је краће за куцање на линији наредби. +.PP +Ако је прекорачено наведено ограничење коришћења меморије, \fBxz\fP ће +приказати грешку а распакивање датотеке неће успети. Ако је ограничење +прекорачено приликом запакивања, \fBxz\fP ће покушати да умањи поставке тако да +се ограничење више не прекорачује (оси када се користи \fB\-\-format=raw\fP или +\fB\-\-no\-adjust\fP). На тај начин радња неће бити неуспешна осим ако је +ограничење врло мало. Смањење поставке се ради у корацима који се не +подударају са предподешеностима нивоа запакивања, на пример, ако је +ограничење само незнатно мање од износа потребног за \fBxz \-9\fP, поставке ће +бити смањене само мало, а не све до \fBxz \-8\fP. +. +.SS "Надовезивање и попуњавање са „.xz“ датотекама" +Могуће је додати \fB.xz\fP датотеке као то. \fBxz\fP ће распаковати такве +датотеке као да су биле једна \fB.xz\fP датотека. +.PP +Могуће је уметнути попуњавање између придодатих делова или након последњег +дела. Попуњавање мора да се састоји од празних бајтова а величина +попуњавања мора бити умножак четири бајта. Ово може бити корисно, на +пример, ако је \fB.xz\fP датотека смештена на медијуму који мери величине +датотека у блоковима од 512 бајтова. +.PP +Надовезивање и попуњавање нису дозвољени са \fB.lzma\fP датотекама или сировим +токовима. +. +.SH ОПЦИЈЕ +. +.SS "Суфикси целог броја и специјалне вредности" +На већини места где се очекује аргумент целог броја, опционални суфикс је +подржан да би се лако назначили велики цели бројеви. Не сме бити размака +између целог броја и суфикса. +.TP +\fBKiB\fP +Множи цео број са 1.024 (2^10). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP, и \fBKB\fP се +прихватају као синоними за \fBKiB\fP. +.TP +\fBMiB\fP +Множи цео број са 1.048.576 (2^20). \fBMi\fP, \fBm\fP, \fBM\fP, и \fBMB\fP се +прихватају као синоними за \fBMiB\fP. +.TP +\fBGiB\fP +Множи цео број са 1.073.741.824 (2^30). \fBGi\fP, \fBg\fP, \fBG\fP, и \fBGB\fP се +прихватају као синоними за \fBGiB\fP. +.PP +Посебна вредност \fBmax\fP се може користити да укаже на највећу вредност целог +броја подржану опцијом. +. +.SS "Режим рада" +Ако је дато више опција режима рада, последња има дејства. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Запакује. Ово је основни режим радње када није наведена опција режима радње +и ниједан други режим радње се не подразумева са линије радње (на пример, +\fBunxz\fP подразумева \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Након успешног запакивања, изворна датотека се уклања осим ако се не пише на +стандардни излаз или је наведено \fB\-\-keep\fP. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Распакује. Након успешног распакивања, изворна датотека се уклања осим ако +се не пише на стандардни излаз или је наведено \fB\-\-keep\fP. +.TP +\fB\-t\fP, \fB\-\-test\fP +Тестира целовитост запакованих \fIдатотека\fP. Ова опција је исто што и +\fB\-\-decompress \-\-stdout\fP осим тога што се распаковани подаци одбацују уместо +да се пишу на стандардни излаз. Датотеке се не праве нити уклањају. +.TP +\fB\-l\fP, \fB\-\-list\fP +Исписује информације о запакованим \fIдатотекама\fP. Никакав незапакован излаз +се не добија, а ниједна датотека није направљена или уклоњена. У режиму +списка, програм не може читати запаковане податке са стандардног улаза или +из других нетраживих извора. +.IP "" +Основни списак приказује основне информације о \fIдатотекама\fP, једна датотека +у једном реду. Да добијете подробније информације, користите такође опцију +\fB\-\-verbose\fP. За чак и више информација, користите \fB\-\-verbose\fP два пуа, +али знајте да то може бити споро, јер да би се добиле све додатне +информације потребно је много тражења. Ширина опширног излаза премашује 80 +знакова, тако да преспајање излаза на, на пример, \fBless\ \-S\fP може бити +прикладно ако терминал није довољно широк. +.IP "" +Тачан излаз може варирати између \fBxz\fP издања и различитих језика. За излаз +читљив машинама треба да користите \fB\-\-robot \-\-list\fP. +. +.SS "Измењивачи рада" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Не брише улазне датотеке. +.IP "" +Од \fBxz\fP 5.2.6, ова опција такође чини да \fBxz\fP запакује или распакује чак и +ако је улаз симболичка веза ка обичној датотеци, има више од једне чврсте +везе или има постављен „setuid“, „setgid“ или лепљиви бит. „setuid“, +„setgid“ и лепљиви битови се не умножавају у циљну датотеку. У ранијим +издањима ово се могло урадити само са \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Ова опција има неколико дејстава: +.RS +.IP \(bu 3 +Ако циљна датотека већ постоји, брише је пре запакивања или распакивања. +.IP \(bu 3 +Запакује или распакује чак и ако је улаз симболичка веза ка обичној +датотеци, има више од једне чврсте везе или има постављен „setgid“, „setgid“ +или лепљиви бит. „setgid“, „setgid“ или лепљиви бит се не умножавају у +циљну датотеку. +.IP \(bu 3 +Када се користи са \fB\-\-decompress\fP \fB\-\-stdout\fP и \fBxz\fP не може да препозна +врсту изворне датотеке, умножава изворну датотеку као такву на стандардни +излаз. Ово омогућава да се \fBxzcat\fP \fB\-\-force\fP користи као \fBcat\fP(1) за +датотекекоје нису запаковане са \fBxz\fP. Знајте да ће у будућности, \fBxz\fP +моћи да подржава нове формате запаковане датотеке, који могу учинити да +\fBxz\fP распакује још врста датотека уместо да их умножи какве јесу на +стандардни излаз. \fB\-\-format=\fP\fIформат\fP се може користити да ограничи \fBxz\fP +да распакује само формат једне датотеке. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Пише запаковане или распаковане податке на стандардни излаз уместо у +датотеку, Ово подразумева \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Распакује само први \fB.xz\fP ток, и тихо занемарује могуће преостале улазне +податке који следе ток. Нормално такво пратеће смеће чини да \fBxz\fP прикаже +грешку. +.IP "" +\fBxz\fP никада не распакује више од једног тока из \fB.lzma\fP датотека или +сирових токова, али ова опција чини да \fBxz\fP још увек занемари могуће +пратеће податке након \fB.lzma\fP датотеке или сировог тока. +.IP "" +Ова опција нема дејства ако режим рада није \fB\-\-decompress\fP или \fB\-\-test\fP. +.IP "" +Од \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP подразумева \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Искључује стварање развучених датотека. По основи, ако распакује у обичну +датотеку, \fBxz\fP покушава да учини датотеку развученом ако распаковани подаци +садрже дуге низове бинарних нула. Такође ради приликом писања на стандардни +излаз све док је стандардни излаз повезан са обичном датотеком а одређени +додатни услови су испуњени да је учине безбедном. Стварање развучених +датотека може уштедети простор на диску и убрзати распакивање смањењем +количине У/И диска. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Приликом запакивања, користите \fI.suf\fP као суфикс за циљну датотеку уместо +\&\fB.xz\fP или \fB.lzma\fP. Ако се не пише на стандардни излаз а изворна датотека +већ има суфикс \fI.suf\fP, приказује се упозорење и датотека се прескаче. +.IP "" +Приликом распакивања, препознаје датотеке са суфиксом \fI.suf\fP поред датотека +са суфиксом \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP, or \fB.lz\fP. Ако изворна +датотека има суфикс \fI.suf\fP, суфикс се уклања да би се добио назив циљне +датотеке. +.IP "" +Приликом запакивања или распакивања сирових токова (\fB\-\-format=raw\fP), суфикс +мора увек бити наведен осим ако се не пише на стандардни излаз, јер не +постоји основни суфикс за сирове токове. +.TP +\fB\-\-files\fP[\fB=\fP\fIдатотека\fP] +Чита називе датотека за обраду из \fIдатотеке\fP; ако се \fIдатотека\fP изостави, +називи датотека се читају са стандардног улаза. Називи датотека се морају +завршавати знаком новог реда. Цртица (\fB\-\fP) се узима као редован назив +датотеке; а не стандардни улаз. Ако су називи датотека дати такође као +аргументи линије наредби, обрађују се пре него што се називи датотека +прочитају из \fIдатотеке\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIдатотека\fP] +Ово је исто као и \fB\-\-files\fP[\fB=\fP\fIдатотека\fP] изузев тога што сваки назив +датотеке мора да се завршава „null“ знаком. +. +.SS "Основни формат датотеке и опције запакивања" +.TP +\fB\-F\fP \fIформат\fP, \fB\-\-format=\fP\fIформат\fP +Наводи \fIформат\fP датотеке за запакивање или распакивање: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Ово је основно. Приликом запакивања, \fBauto\fP је исто што и \fBxz\fP. Приликом +распакивања, формат улазне датотеке се аутоматски препознаје. Знајте да +сирови токови (направљени са \fB\-\-format=raw\fP) не могу бити аутоматски +препознати. +.TP +\fBxz\fP +Пакује у \fB.xz\fP формат датотеке, или прихвата само \fB.xz\fP датотеке приликом +распакивања. +.TP +\fBlzma\fP, \fBalone\fP +Пакује у стари \fB.lzma\fP формат датотеке, или прихвата само \fB.lzma\fP датотеке +приликом распакивања. Алтернативни назив \fBalone\fP се доставља зарад +повратне сагласности са LZMA помагалима. +.TP +\fBlzip\fP +Прихвата само \fB.lz\fP датотеке приликом распакивања. Запакивање није +подржано. +.IP "" +Формат \fB.lz\fP издања 0 и 1 је подржан. Датотеке издања 0 су настале са +\fBlzip\fP 1.3 и старијим. Такве датотеке нису уобичајене али се могу наћи у +архивама датотека јер је неколико пакета извора издато у овом формату. +Такође можда неко има старе личне датотеке у овом формату. Подршка +распакивања за формат издања 0 је уклоњена у \fBlzip\fP 1.18. \fBlzip\fP 1.4 и +новији ствара датотеке у формату издања 1. +.TP +\fBraw\fP +Запакује или распакује сирови ток (без заглавља). Ово је замишљено само за +напредне кориснике. Да дешифрујете сирове токове, треба да користите +\fB\-\-format=raw\fP и да изричито наведете ланац филтера, што би обично требало +да буде смештено у заглављима контејнера. +.RE +.TP +\fB\-C\fP \fIпровера\fP, \fB\-\-check=\fP\fIпровера\fP +Наводи врсту провере целовитости. Провера се израчунава из незапакованих +података и смештених у \fB.xz\fP датотеци. Ова опција има дејства само +приликом запакивања у \fB.xz\fP формат; \fB.lzma\fP формат не подржава провере +целовитости. Провера целовитости (ако је има) се проверава када је \fB.xz\fP +датотека распакована. +.IP "" +Подржане врсте \fIпровере\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Уопште не израчунава проверу целовитости. Ово је обично лоша идеја. Ово +може бити корисно када се целовитост података ипак проверава на друге +начине. +.TP +\fBcrc32\fP +Израчунава CRC32 користећи полином из IEEE\-802.3 (Етернет). +.TP +\fBcrc64\fP +Израчунава CRC64 користећи полином из ECMA\-182. Ово је основно, јер је +незнатно боље од CRC32 у откривању оштећених датотека а разлика брзине је +занемарљива. +.TP +\fBsha256\fP +Израчунава SHA\-256. Ово је нешто спорије од CRC32 и CRC64. +.RE +.IP "" +Целовитост \fB.xz\fP заглавља се увек проверава са CRC32. Не може се изменити +нити искључити. +.TP +\fB\-\-ignore\-check\fP +Не проверава проверу целовитости запакованих података приликом распакивања. +CRC32 вредности у \fB.xz\fP заглављима биће још увек нормално проверене. +.IP "" +\fBНемојте користити ову опцију осим ако стварно знате шта радите.\fP Могући +разлози за коришћење ове опције: +.RS +.IP \(bu 3 +Покушава да опорави податке из оштећене „.xz“ датотеке. +.IP \(bu 3 +Убрзава распакивање. Ово има значаја углавном са SHA\-256 или са датотекама +које су запаковане стварно добро. Препоручује се да не користите ову опцију +за ову сврху осим ако је целовитост датотеке проверена споља на неки други +начин. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Бира ниво преподешености запакивања. Подразумевано је \fB\-6\fP. Ако је +наведено више нивоа преподешености, последња има дејства. Ако је произвољни +ланац филтера већ наведен, постављање нивоа преподешености запакивања уклања +произвољни ланац филтера. +.IP "" +Разлике између предподешености су још значајније него са \fBgzip\fP(1) и +\fBbzip2\fP(1). Изабране поставке запакивања одређују захтеве меморије +распакивача, стога коришћење превисоког нивоа предподешености може отежати +распакивање датотеле на старом систему са мало RAM\-а. Нарочито, \fBније добра замисао слепо користити \-9 за било шта\fP као што је често са \fBgzip\fP(1) +и \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Ово су некако брзе предподешености. \fB\-0\fP је понекад брже од \fBgzip \-9\fP док +запакује много боље. Оне више често имају брзину упоредиву са \fBbzip2\fP(1) +са упоредивом или бољом стопом запакивања, иако резултати зависе много од +врсте података који се запакују. +.TP +\fB\-4\fP ... \fB\-6\fP +Добро до врло добро запакивање које одржава коришћење меморије распакивача +разумним чак и за старе системе. \fB\-6\fP је основно, што је обично добар +избор за расподелу датотека које треба да могу да се распакују чак и на +системима са само 16\ MiB RAM\-а. (\fB\-5e\fP или \fB\-6e\fP може бити вредно +узимања у обзир. Видите \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Као \fB\-6\fP али са већим захтевима меморије запакивача и распакивача. Корисне +су само приликом запакивања датотека већих од 8\ MiB, 16\ MiB и 32\ MiB. +.RE +.IP "" +На истом хардверу, брзина распакивања је приближно сталан број бајтова +запакованих података у секунди. Другим речима, биће боље запакивање, брже +распакивање. То такође значи да количина незапакованог излаза произведеног +у секунди може много да се разликује. +.IP "" +Следећа табела резимира функције предподешености: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Преподешеност;ВлчРчнка;ЗапакЦПЈ;ЗапакМем;РаспМем +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Описи колона: +.RS +.IP \(bu 3 +ВлчРчнка је величина LZMA2 речника. Коришћење речника већег од величине +незапаковане датотеке је губитак меморије. Зато је добро избегавати +коришћење предподешености \fB\-7\fP ... \fB\-9\fP када за њима нема стварне +потребе. Са \fB\-6\fP и нижим, количина изгубљене меморије је обично довољно +ниска да нема значаја. +.IP \(bu 3 +ЗапакЦПЈ је поједностављено представљање LZMA2 поставки које утичу на брзину +запакивања. Величина речника такође утиче на брзину, тако док је ЗапакЦПЈ +исто за нивое \fB\-6\fP ... \fB\-9\fP, виши нивои још увек теже да буду спорији. Да +добијете још спорије и самим тим можда боље запакивање, видите \fB\-\-extreme\fP. +.IP \(bu 3 +ЗапакМем садржи захтеве меморије запакивача у режиму једне нити. Може +незнатно да се разликује између \fBxz\fP издања. +.IP \(bu 3 +РаспМем садржи захтеве меморије распакивача. Тако је, поставке запакивања +одређују захтеве меморије распакивача. Тачно коришћење меморије распакивача +је незнатно веће од величине LZMA2 речника, али су вредности у табели +заокружене на следећи цео MiB. +.RE +.IP "" +Захтеви меморије режима са више нити су значајно већи него ли режима једне +нити. Са основном вредношћу \fB\-\-block\-size\fP, свакој нити треба 3*3*ВлчРчнка +плус ЗапакМем или РаспМем. На пример, за четири нити са предподешавањем +\fB\-6\fP потребно је 660\(en670\ MiB меморије. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Користите спорију варијанту изабраног нивоа предподешености запакивања +(\fB\-0\fP ... \fB\-9\fP) у нади да ћете добити мало бољу стопу запакивања, али уз +лошу срећу ово је може учинити гором. Не утиче на коришћење меморије +распакивача, али се коришћење меморије запакивача мало повећава на нивоима +предподешености \fB\-0\fP ... \fB\-3\fP. +.IP "" +Како постоје две предподешености са величинама речника од 4\ MiB и 8\ MiB, +предподешености \fB\-3e\fP и \fB\-5e\fP користе незнатно брже поставке (ниже +CompCPU) него \fB\-4e\fP и \fB\-6e\fP. На тај начин нема две истоветне +предподешености. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Преподешеност;ВлчРчнка;ЗапакЦПЈ;ЗапакМем;РаспМем +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +На пример, има укупно четири предподешавања која користе 8\ MiB речник, чији +поредак од најбржег до најспоријег је \fB\-5\fP, \fB\-6\fP, \fB\-5e\fP и \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Ово су помало погрешни алијаси за \fB\-0\fP и \fB\-9\fP. Достављени су само зарад +повратне сагласности са LZMA Utils\-ом. Избегавајте коришћење ових опција. +.TP +\fB\-\-block\-size=\fP\fIвеличина\fP +Приликом запакивања у \fB.xz\fP формат, дели улазне податке на блокове +\fIвеличина\fP бајта. Блокови се запакују независно један од другог, што +помаже у раду са више нити и чини ограничено распакивање насумичног приступа +могућим. Ова опција се обично користи да се препише основна величина блока +у режиму са више нити, али се ова опција може такође користити и у режиму +једне нити. +.IP "" +У режиму више нити око три пута \fIвеличина\fP бајтова биће додељено у свакој +нити за међумеморисање улаза и излаза. Основна \fIвеличина\fP је три пута +величине LZMA2 речника или 1 MiB, шта год да је више. Обично добра вредност +је 2\(en4 пута величина LZMA2 речника или барем 1 MiB. Коришћење +\fIвеличине\fP мање од величине LZMA2 речника је трошење RAM\-а јер тада +међумеморија LZMA2 речника никада неће бити потпуно коришћена. У режиму +више нити, величине блокова се чувају у заглављима блока. Ова информација +величине је потребна за распакивање са више нити. +.IP "" +У режиму једне нити никаква подела блока се не ради по основи. Постављање +ове опције не утиче на коришћење меморије. Никакве информације о величини +се не чувају у заглављима блока, стога датотеке направљене у режиму једне +нити неће бити исте као датотеке направљене у режиму више нити. Недостатак +информација о величини такође значи да \fBxz\fP неће моћи да распакује датотеке +у режиму више нити. +.TP +\fB\-\-block\-list=\fP\fIставке\fP +Приликом запакивања у \fB.xz\fP формат, почиње нови блок са изборним +произвољним ланцем филтера након датих интервала незапакованих података. +.IP "" +\fIСтавке\fP су списак одвојен зарезом. Свака ставка се састоји од изборног +броја ланца филтера између 0 и 9 за којим следи двотачка (\fB:\fP) и захтевана +величина незапакованих података . Изостављање неке ставке (два или више +узастопна зареза) је пречица за коришћење величине и филтера претходне +ставке. +.IP "" +Ако је улазна датотека већа од збира величина у \fIставкама\fP, последња ставка +се понавља све до краја датотеке. Специјална вредност \fB0\fP може се +користити као последња величина да назначи да остатак датотеке треба да буде +шифрован као један блок. +.IP "" +Алтернативни ланац филтера за сваки блок се може навести у комбинацији са +опцијама \fB\-\-filters1=\fP\fIфилтера\fP \&...\& \fB\-\-filters9=\fP\fIфилтери\fP. Ове +опције дефинишу ланце филтера са одредником између 1\(en9. Ланац филтера 0 +се може користити да упућује на основно ланац филтера, који је исти јер се +ланац филтера не наводи. Одредник ланца филтера се може користити пре +незапаковане величине, за којим следи двотачка (\fB:\fP). На пример, ако +наведемо \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP тада ће се за +прављење блокова користити: +.RS +.IP \(bu 3 +Ланац филтера наведен са \fB\-\-filters1\fP и 2 MiB улазом +.IP \(bu 3 +Ланац филтера наведен са \fB\-\-filters3\fP и 2 MiB улазом +.IP \(bu 3 +Ланац филтера наведен са \fB\-\-filters2\fP и 4 MiB улазом +.IP \(bu 3 +Ланац филтера наведен са \fB\-\-filters2\fP и 4 MiB улазом +.IP \(bu 3 +Основни ланац филтера и 2 MiB улаз +.IP \(bu 3 +Основни ланац филтера и 4 MiB улаз за сваки блок до краја улаза. +.RE +.IP "" +Ако наведемо величину која премашује величину блока шифрера (било основну +вредност у режиму нити или вредност наведену са +\fB\-\-block\-size=\fP\fIвеличина\fP), шифрер ће направити додатне блокове док ће +задржати границе наведене у \fIставкама\fP. На пример, ако наведемо +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP а улазна +датотека је 80 MiB, добићемо 11 блокова: 5, 10, 8, 10, 2, 10, 10, 4, 10, 10 +и 1 MiB. +.IP "" +У режиму са више нити величине блокова се чувају у заглављима блока. Ово се +не ради у режиму једне нити, тако да шифровани излаз неће бити истоветан +ономе у режиму са више нити. +.TP +\fB\-\-flush\-timeout=\fP\fIистек_времена\fP +Приликом запакивања, ако је више од \fIвреме_истека\fP милисекунди (позитиван +цео број) прошло од претходног испирања и читање више улаза ће блокирати, +сви заказани улазни подаци се испирају из шифрера и чине доступним у +излазном току. Ово може бити корисно ако је \fBxz\fP коришћен за запакивање +података који су слати преко мреже. Мала вредност \fIвременског_истека\fP чини +податке доступним на пријемни крај са малим закашњењем, али велика вредност +\fIвремена_истека\fP даје бољу стопу запакивања. +.IP "" +Ова функција је искључена по основи. Ако је ова опција наведена више пута, +последња има дејства. Нарочита вредност \fIвременског истека\fP \fB0\fP може се +користити за изричито искључивање ове функције. +.IP "" +Ова функција је доступна само на POSIX системима. +.IP "" +.\" FIXME +\fBОва функција је још увек експериментална.\fP Тренутно \fBxz\fP није погодан за +распакивање тока у реалном времену због начина на који \fBxz\fP ради +међумеморисање. +.TP +\fB\-\-no\-sync\fP +Не усклађује циљну датотеку и њену фасциклу на смештајном уређају пре +уклањања изворне датотеке. Ово може побољшати учинковитост ако се запакује +или распакује много малих датотека. Међутим, ако се систем уруши одмах +након брисања, може бити да циљна датотека не буде уписана на смештајном +уређају али радња брисања јесте. У том случају неће бити доступна ни +оригинална изворна ни циљна датотека. +.IP "" +Ова опција има дејство само када се \fBxz\fP спрема да уклони изворну +датотеку. У осталим случајевима усклађивање се не ради никада. +.IP "" +Синхронизација и \fB\-\-no\-sync\fP су додате у \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIограничење\fP +Поставља ограничење коришћења меморије запакивања. Ако је ова опција +наведена више пута, последња ступа у дејство. +.IP "" +Ако поставке запакивања премаше \fIограничење\fP, \fBxz\fP ће покушати да врати +назад поставке тако да ограничење више није прекорачено и приказаће +обавештење да је урађено аутоматско дотеривање. Дотеривања се раде следећим +редом: смањење броја нити, пребацивање на режим једне нити ако чак и једна +нит у режиму више нити премаши \fIограничење\fP и на крају смањење величине +LZMA2 речника. +.IP "" +Приликом запакивања са \fB\-\-format=raw\fP или ако је наведено \fB\-\-no\-adjust\fP, +само број нити може бити умањен јер може да се уради а да се не делује на +излаз запакованог. +.IP "" +Ако \fIограничење\fP не може бити задовољено чак и са поравнањима описаним +изнад, приказује се грешка и \fBxz\fP ће изаћи са излазним стањем 1. +.IP "" +\fIОграничење\fP се може навести на више начина: +.RS +.IP \(bu 3 +\fIОграничење\fP може бити апсолутна величина у бајтима. Коришћење суфикса +целог броја као \fBMiB\fP може бити корисно. Пример: +\fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +\fIОграничење\fP се може навести као проценат укупне физичке меморије (RAM). +Ово може бити корисно нарочито приликом постављања променљиве окружења +\fBXZ_DEFAULTS\fP у скрпти покретања конзоле која се дели између различитих +рачунара. На тај начин ограничење је аутоматски веће на системима са више +меморије. Пример: \fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +\fIОграничење\fP се може вратити на своју основну вредност његовим постављањем +на \fB0\fP. Ово је тренутно исто што и постављање \fIограничења\fP на \fBmax\fP (без +ограничења коришћења меморије). +.RE +.IP "" +За \fBxz\fP 32\-бита имамо посебан случај: ако \fIограничење\fP треба да буде преко +\fB4020\ MiB\fP, \fIограничење\fP се поставља на \fB4020\ MiB\fP. Али на MIPS32 +користи се \fB2000\ MiB\fP. (На вредности \fB0\fP и \fBmax\fP ово не утиче. Слична +функција не постоји за распакивање.) Ово може бити од помоћи када извршна +од 32\-бита има приступ адресном простору од 4\ GiB (2 GiB на MIPS32) док +срећом не чини ништа лоше у осталим приликама. +.IP "" +Видите такође одељак \fBКоришћење меморије\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIограничење\fP +Поставља ограничење коришћења меморије за распакивање. Ово такође утиче на +\fB\-\-list\fP режим. Ако радња није могућа а да се не премаши \fIограничење\fP, +\fBxz\fP ће приказати грешку а распакивање датотеке неће успети. Видите +\fB\-\-memlimit\-compress=\fP\fIограничење\fP за могуће начине о навођењу +\fIограничења\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIограничење\fP +Поставља ограничење коришћења меморије за распакивање са више нити. Ово +може утицати само на број нити; ово никада неће учинити да \fBxz\fP одбије да +распакује датотеке. Ако је \fIограничење\fP превише ниско да омогући било који +рад са више нити, \fIограничење\fP се занемарује а \fBxz\fP ће наставити у режиму +једне нити. Знајте да ако се такође користи \fB\-\-memlimit\-decompress\fP, увек +ће се применити и на режим једне и на режим више нити, и тако да стварно +\fIограничење\fP за више нити никада неће бити више од ограничења постављеног +са \fB\-\-memlimit\-decompress\fP. +.IP "" +У супротности са другим опцијама ограничења коришћења меморије, +\fB\-\-memlimit\-mt\-decompress=\fP\fIограничење\fP има систему специфично основно +\fIограничење\fP. \fBxz \-\-info\-memory\fP се може користити да видите тренутну +вредност. +.IP "" +Ова опција и њена основна вредност постоје јер без икаквог ограничења нитни +распакивач ће завршити са додељивањем неразумног износа меморије са неким +улазним датотекама. Ако је основно \fIограничење\fP превише ниско на вашем +систему, слободно повећајте \fIограничење\fP али га никада не постављајте на +вредност већу од износа употребљивог RAM\-а јер са одговарајућим улазним +датотекама \fBxz\fP ће покушати да користи тај износ меморије чак и са малим +бројем нити. Остајући без меморије или разменом неће се побољшати +учинковитост распакивања. +.IP "" +Видите \fB\-\-memlimit\-compress=\fP\fIограничење\fP за могуће начине за навођење +\fIограничења\fP. Постављање \fIограничења\fP на \fB0\fP враћа \fIограничење\fP на +систему специфичну основну вредност. +.TP +\fB\-M\fP \fIограничење\fP, \fB\-\-memlimit=\fP\fIограничење\fP, \fB\-\-memory=\fP\fIограничење\fP +Ово је исто као и навођење \fB\-\-memlimit\-compress=\fP\fIограничење\fP +\fB\-\-memlimit\-decompress=\fP\fIограничење\fP +\fB\-\-memlimit\-mt\-decompress=\fP\fIограничење\fP. +.TP +\fB\-\-no\-adjust\fP +Приказује грешку и излази ако ограничење коришћења меморије не може бити +задовољено без дотеривања поставки које утичу на запаковани излаз. Тако је, +ово спречава \fBxz\fP да промени шифрера из режима више нити у режим једне нити +и да смањи величину LZMA2 речника. Чак и када се ова опција користи број +нити се може смањити да задовољи ограничење коришћења меморије јер то неће +утицати на запаковани излаз. +.IP "" +Аутоматско дотеривање је увек искључено приликом стварања сирових токова +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fIнити\fP, \fB\-\-threads=\fP\fIнити\fP +Наводи број нити радника за коришћење. Постављање \fIнити\fP на посебну +вредност \fB0\fP чини да \fBxz\fP користи онолико нити колико процесор на систему +подржава. Стварни број нити може бити мањи од \fIнити\fP ако улазна датотека +није довољно велика за нитисање са датим поставкама или ако ће коришћење +више нити премашити ограничење коришћења меморије. +.IP "" +Запакивачи једне нити и више нити дају различите излазе. запакивач једне +нити даће мању величину датотеке али само излаз из запакивача више нити може +бити распакован коришћењем више нити. Постављање \fIнити\fP на \fB1\fP користиће +режим једне нити. Постављање \fIнити\fP на неку другу вредност, укључујући +\fB0\fP, користиће запакивач више нити чак и ако систем подржава само једну нит +хардвера. (\fBxz\fP 5.2.x је користио режим једне нити у овој прилици.) +.IP "" +Да користите вишенитни режим са само једном нити, поставите \fIнити\fP на +\fB+1\fP. Префикс \fB+\fP нема дејства са вредностима које нису \fB1\fP. Ограничење +коришћења меморије може још увек учинити да се \fBxz\fP пребаци на режим једне +нити осим ако се не користи \fB\-\-no\-adjust\fP. Подршка за префикс \fB+\fP је +додата у \fBxz\fP 5.4.0. +.IP "" +Ако је затражен аутоматски број нити и није наведено ограничење коришћења +меморије, тада ће се користити основно меко ограничење специфично за систем +за могуће ограничење броја нити. То је меко ограничење у смислу да се +занемарује ако број нити постане један, дакле меко ограничење никада неће +зауставити \fBxz\fP од запакивања или распакивања. Ово основно меко ограничење +неће учинити да се \fBxz\fP пребаци из режима више нити у режим једне нити. +Активно ограничење се може видети са + \fBxz \-\-info\-memory\fP. +.IP "" +Тренутно једина метода нитисања је да се подели улаз на блокове и да се +запакују независно један од другог. Основна величина блока зависи од нивоа +запакивања и може се преписати опцијом \fB\-\-block\-size=\fP\fIвеличина\fP. +.IP "" +Нитно распакивање ради само на датотекама које садрже више блокова са +информацијом величине у заглављима блока. Све довољно велике датотеке +запаковане у вишенитном режиму задовољавају овај услов, али датотеке +запаковане у једнонитном режиму не чак и ако је коришћено +\fB\-\-block\-size=\fP\fIвеличина\fP. +.IP "" +Основна вредност за \fIнити\fP је \fB0\fP. У \fBxz\fP 5.4.x и старијим основно је +\fB1\fP. +. +.SS "Произвољни ланци филтера запакивача" +Произвољни ланац филтера омогућава детаљно одређивање подешавања сажимања +уместо да се ослања на подешавања повезана са предподешавањима. Када је +произвољни ланац филтера наведен, опције предподешавања (\fB\-0\fP \&...\& \fB\-9\fP +и \fB\-extreme\fP) раније на линији наредби се заборављају. Ако је опција +предподешавања наведена након једне или више опција произвољног ланца +филтера, ново предподешавање ступа на снагу а раније наведене опције +произвољног ланца филтера се заборављају. +.PP +Ланац филтера је упоредив са спојкама на линији наредби. Приликом сажимања, +несажети улаз иде на први филтер, чији излаз иде на следећи филтер (ако фа +има). Излаз последњег филтера бива записан у сажету датотеку. Највећи број +филтера у ланцу је четири, али обично ланац филтера има само један или два +филтера. +.PP +Многи филтери имају ограничења о томе где могу бити у ланцу филтера: неки +филтери могу радити само као последњи филтер у ланцу, неки само као +не\-последњи филтер, а неки раде на било ком месту у ланцу. Овисно о +филтеру, ово ограничење је или својствено дизајну филтера или постоји како +би се спречили проблеми безбедности. +.PP +Произвољни ланац филтера се може навести на два различита начина. Опције +\fB\-\-filters=\fP\fIфилтери\fP и \fB\-\-filters1=\fP\fIфилтери\fP \&...\& +\fB\-\-filters9=\fP\fIфилтери\fP омогућавају навођење читавог ланца опција у једној +опцији коришћењем синтаксу ниске „liblzma“ филтера. Другачије, ланац +филтера се може навести коришћењем једне или више појединачних опција +филтера редом како се траже у ланцу филтера. То је то, редослед +појединачних опција филтера је важан! Приликом дешифровања сирових токова +(\fB\-\-format=raw\fP), ланац филтера мора бити наведен истим редом као када је +био наведен приликом сажимања. Било који појединачни филтер или опције +предподешавања наведене пре опције читавог ланца (\fB\-\-filters=\fP\fIфилтери\fP) +биће заборављене. Појединачни филтери наведени после опције читавог ланца +ће поништити поставку ланца филтера. +.PP +Обе опције и пуног и појединачног филтера узимају филтеру специфичне +\fIопције\fP као зарезом раздвојен списак. Додатни зарези у \fIопцијама\fP се +занемарују. Свака опција има основну вредност, тако да треба да наведете +оне које желите да измените. +.PP +Да видите читав ланац филтера и \fIопције\fP, користите \fBxz \-vv\fP (тако је, +користите \fB\-\-verbose\fP два пута). Ово ради такође за преглед опција ланца +филтера коришћених од стране предподешености. +.TP +\fB\-\-filters=\fP\fIфилтери\fP +Наводи цео ланац филтера или предподешеност у једној опцији. Сваки филтер +се може одвојити размацима или са две цртице (\fB\-\-\fP). \fIФилтери\fP можда +треба да буду под наводницима на линији наредби конзоле тако да се +прослеђују као једна опција. Да означите \fIопције\fP, користите \fB:\fP или +\fB=\fP. Предподешености се може додати префикс \fB\-\fP и може га пратити нула +или још заставица. Једина подржана заставица је \fBe\fP за примену истих +опција као \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIфилтери\fP ... \fB\-\-filters9\fP=\fIфилтери\fP +Наводи до девет додатних ланаца филтера који се могу користити са +\fB\-\-block\-list\fP. +.IP "" +На пример, приликом запакивања архиве са извршним датотекама за којима следе +текстуалне датотеке, извршни део треба да користи ланац филтера са BCJ +филтером а текстуални део само LZMA2 филтер. +.TP +\fB\-\-filters\-help\fP +Приказује поруку помоћи описујући како се наводе предподешавања и произвољни +ланци филтера у опцијама \fB\-\-filters\fP и \fB\-\-filters1=\fP\fIфилтери\fP \&...\& +\fB\-\-filters9=\fP\fIфилтери\fP, и успешно излази. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIопције\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIопције\fP] +.PD +Додаје LZMA1 или LZMA2 филтер у ланац филтера. Ови филтери се могу +користити само као последњи филтер у ланцу. +.IP "" +LZMA1 је стари филтер, који је подржан углавном само због старог формата +\&\fB.lzma\fP датотеке, који подржава само LZMA1. LZMA2 је освежено издање LZMA1 +које поправља неке практичне проблеме LZMA1. \fB.xz\fP формат користи LZMA2 и +не подржава LZMA1 уопште. Брзина запакивања и односи LZMA1 и LZMA2 су +практично исти. +.IP "" +LZMA1 и LZMA2 деле исти скуп \fIопција\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIпредподешавање\fP +Враћа све LZMA1 или LZMA2 \fIопције\fP на \fIпредподешеност\fP. \fIПредпдешеност\fP +се састоји од целог броја, за којим може да следи једнословни измењивач +предподешености. Цео број може бити од \fB0\fP до \fB9\fP, поклапајући опције +линије наредби \fB\-0\fP \&...\& \fB\-9\fP. Једини тренутно подржани измењивач је +\fBe\fP, који се поклапа са \fB\-\-extreme\fP. Ако \fBpreset\fP није наведено, основне +вредности LZMA1 или LZMA2 \fIопција\fP се узимају из предподешености \fB6\fP. +.TP +\fBdict=\fP\fIвеличина\fP +\fIВеличина\fP речника (међумеморија историјата) указује на то колико је +бајтова недавно обрађених нераспакованих података задржано у меморији. +Алгоритам покушава да нађе понављајуће низове бајтова (поклапања) у +нераспакованим подацима, и да их замени са упутама ка подацима који су +тренутно у речнику. Што је већи речник, већа је вероватноћа за налажење +поклапања. Стога, повећање \fIвеличине \fP речника обично побољшава стопу +запакивања, али речник већи од незапаковане датотеке јесте утрошак меморије. +.IP "" +Уобичајена \fIвеличина\fP речника је од 64\ KiB до 64\ MiB. Најмање је 4\ KiB. Највише за запакивање тренутно је 1.5\ GiB (1536\ MiB). Распакивач +већ подржава речнике до једног бајта мање од 4\ GiB, што је максимум за +формате LZMA1 и LZMA2 тока. +.IP "" +\fIВеличина\fP речника и налазач поклапања (\fImf\fP) заједно одређују коришћење +меморије за LZMA1 или LZMA2 шифрере. Иста (или већа) \fIвеличина\fP речника је +потребна за распакивање као она која је коришћена за запаквање, стога се +коришћење меморије дешифрера одређује према величини речника коришћеног за +запакивање. \fB.xz\fP заглавља чувају \fIвеличину\fP речника или као 2^\fIn\fP или +2^\fIn\fP + 2^(\fIn\fP\-1), тако да су те \fIвеличине\fP некако пожељније за +запакивање. Друге \fIвеличине\fP биће заокружене приликом чувања у \fB.xz\fP +заглављима. +.TP +\fBlc=\fP\fIlc\fP +Наводи број битова контекста литерала. Најмање је 0 а највише је 4; основно +је 3. Као додатак, збир \fIlc\fP и \fIlp\fP не сме да премаши 4. +.IP "" +Сви бајтови који се не могу шифровати јер су поклапања шифрована као +литерали. То је то, литерали су једноставно 8\-битни бајтови који су +шифровани један по један. +.IP "" +Кодирање литерала врши претпоставку да највећи \fIlc\fP битови претходног +незапакованог бајта су у узајамној вези са следећим бајтом. На пример, у +уобичајеном енглеском тексту, за великим словом често следи мало слово, а за +малим словом обично следи још једно мало слово. У скупу US\-ASCII знакова, +највиша три бита су 010 за велика слова и 011 за мала слова. Када је \fIlc\fP +барем 3, кодирање литерала може имати предност овог својства у незапакованим +подацима. +.IP "" +Основна вредност (3) је обично добра. Ако желите највеће запакивање, +испробајте \fBlc=4\fP. Некад то мало помогне а некад чини запакивање горим. +Ако га учини горим, испробајте такође \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Наводи број битова положаја литерала. Најмање је 0 а највише је 4; основно +је 0. +.IP "" +\fILp\fP утиче на то која врста поравнања у незапакованим подацима се +подразумева приликом шифровања литерала. Видите \fIpb\fP испод за више +информација о поравнању. +.TP +\fBpb=\fP\fIpb\fP +Наводи број битова положаја. Најмање је 0 а највише је 4; основно је 2. +.IP "" +\fIPb\fP утиче на то која врста поравнања у незапакованим подацима се +подразумева у опште. Основно значи четворобајтно поравнање (2^\fIpb\fP=2^2=4), +што је често добар избор када нема бољег решења. +.IP "" +Када је поравнање познато, постављање одговарајућег \fIpb\fP може мало да смањи +величину датотеке. На пример, са датотекама текста које имају поравнање +једног бајта (US\-ASCII, ISO\-8859\-*, UTF\-8), постављање \fBpb=0\fP може незнатно +да побољша запакивање. За UTF\-16 текст, \fBpb=1\fP је добар избор. Ако је +поравнање непаран број као 3 бајта, \fBpb=0\fP може бити најбољи избор. +.IP "" +Иако се претпостављено поравнање може подесити са \fIpb\fP и \fIlp\fP, LZMA1 и +LZMA2 и даље незнатно фаворизују 16\-бајтно поравнање. То би могло бити +вредно узети у обзир приликом дизајнирања формата датотека које ће вероватно +бити често запаковане са LZMA1 или LZMA2. +.TP +\fBmf=\fP\fImf\fP +Налазач поклапања има главни утицај на брзину шифрера, коришћење меморије и +стопу запакивања. Обично Hash Chain налазачи поклапања су бржи од Binary +Tree налазача поклапања. Основност зависи од \fIпредподешености\fP: 0 користи +\fBhc3\fP, 1\(en3 користи \fBhc4\fP, а остало користи \fBbt4\fP. +.IP "" +Следећи налазачи поклапања су подржани. Формуле коришћења меморије испод су +грубе апроксимације које су ближе стварности када је \fIречник\fP степен +двојке. +.RS +.TP +\fBhc3\fP +Ланац хеша са хеширањем 2\- и 3\-бајта +.br +Најмања вредност за \fIфино\fP: 3 +.br +Коришћење меморије: +.br +\fIречник\fP * 7.5 (ако је \fIречник\fP <= 16 MiB); +.br +\fIречник\fP * 5.5 + 64 MiB (if \fIречник\fP > 16 MiB) +.TP +\fBhc4\fP +Ланац хеша са хеширањем 2\-, 3\- и 4\-бајта +.br +Најмања вредност за \fIфино\fP: 4 +.br +Коришћење меморије: +.br +\fIречник\fP * 7.5 (ако је \fIречник\fP <= 32 MiB); +.br +\fIречник\fP * 6.5 (ако је \fIречник\fP > 32 MiB) +.TP +\fBbt2\fP +Бинарно стабло са 2\-бајта хеширања +.br +Најмања вредност за \fIфино\fP: 2 +.br +Коришћење меморије: \fIречник\fP * 9.5 +.TP +\fBbt3\fP +Бинарно стабло са 2\- и 3\-бајта хеширања +.br +Најмања вредност за \fIфино\fP: 3 +.br +Коришћење меморије: +.br +\fIречник\fP * 11.5 (if \fIречник\fP <= 16 MiB); +.br +\fIречник\fP * 9.5 + 64 MiB (ако је \fIречник\fP > 16 MiB) +.TP +\fBbt4\fP +Бинарно стабло са 2\-, 3\-, и 4\-бајта хеширања +.br +Најмања вредност за \fIфино\fP: 4 +.br +Коришћење меморије: +.br +\fIречник\fP * 11.5 (if \fIречник\fP <= 32 MiB); +.br +\fIречник\fP * 10.5 (if \fIречник\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fIрежим\fP +\fIРежим\fP запакивања наводи методу за анализу података које произведе налазач +поклапања. Подржани \fIрежими\fP су \fBfast\fP и \fBnormal\fP. Подразумева се +\fBfast\fP за \fIпредподешавања\fP 0\(en3 и \fBnormal\fP за \fIпредподешавања\fP 4\(en9. +.IP "" +Обично се \fBfast\fP користи са налазачима Hash Chain поклапања а \fBnormal\fP са +налазачима Binary Tree поклапања. Ово је исто што раде и +\fIпредподешености\fP. +.TP +\fBnice=\fP\fIфино\fP +Наводи оно што се сматра да је фина дужина за поклапање. Када се поклапање +од барем \fInice\fP бајтова нађе, алгоритам зауставља тражење могућих бољих +поклапања. +.IP "" +\fIФино\fP може бити 2\(en273 бајта. Веће вредности теже да дају бољу стопу +запакивања на уштрб брзине. Основно зависи од \fIпредподешавања\fP. +.TP +\fBdepth=\fP\fIдубина\fP +Наводи највећу дубину претраге у налазачу поклапања. Основно је посебна +вредност 0, која чини да запакивач одреди разумљиву \fIдубину\fP из \fImf\fP и +\fInice\fP. +.IP "" +Разумљива \fIдубина\fP за ланце хеша је 4\(en100 и 16\(en1000 за стабло +извршних. Коришћење врло великих вредности за \fIдубину\fP може учинити шифрер +врло спорим са неким датотекама. Избегавајте постављање \fIдубине\fP преко +1000 осим ако нисте спремни да прекинете запакивање у случају да потраје +превише дуго. +.RE +.IP "" +Приликом дешифровања сирових токова (\fB\-\-format=raw\fP), LZMA2 треба само +\fIвеличина\fP речника. LZMA1 треба такође \fIlc\fP, \fIlp\fP и \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIопције\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIопције\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIопције\fP] +.PD +Додаје „branch/call/jump“ (BCJ) филтер ланцу филтера. Ови филтери могу се +користити само ако нису последњи филтер у ланцу филтера. +.IP "" +BCJ филтер претвара релативне адресе у машинском коду на њихове апсолутне +двојнике. Ово не мења величину података, али повећава сувишност, што може +помоћи LZMA2 да произведе 0\(en15\% мању \fB.xz\fP датотеку. BCJ филтери су +увек реверзибилни, стога коришћење BCJ филтера за погрешну врсту података не +доводи ни до каквог губитка података, мада може да учини степен сажимања +нешто лошијим. BCJ филтери су врло брзи и користе безначајну количину +меморије. +.IP "" +Ови BCJ филтери имају познате проблеме везане за стопу запакивања: +.RS +.IP \(bu 3 +Неке врсте датотека које садрже извршни код (на пример, објектне датотеке, +статичке библиотеке и модули Линукс кернела) имају адресе у упутствима +испуњеним вредностима попуњавача. Ови BCJ филтери и даље ће радити +претварање адресе, што ће запакивање учинити горим са овим датотекама. +.IP \(bu 3 +Ако се BCJ филтер примени на архиву, могуће је да ће учинити стопу +запакивања лошијим него кад се не би користио. На пример, ако постоје +сличне или чак истоветне извршне тада ће филтрирање вероватно учинити +датотеке мање сличним и стога је запакивање лошије. Садржај не\-извршних +датотека у истој архиви је такође важан. У пракси се мора покушати са и без +BCJ филтера да би се видело шта је боље у којој прилици. +.RE +.IP "" +Различити скупови упутстава имају различита поравнања: извршна датотека мора +бити поравната на множилац ове вредности у улазним подацима како би филтер +радио. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Филтер;Поравнање;Напомене +x86;1;32\-бита или 64\-бита x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096\-бита поравнање је најбоље +PowerPC;4;Само велика крајност +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Како су BCJ\-филтрирани подаци обично запаковани са LZMA2, стопа запакивања +може бити незнатно побољшана ако су LZMA2 опције постављене да поклопе +поравнање изабраног BCJ филтера. Примери: +.RS +.IP \(bu 3 +IA\-64 филтер има поравнање 16\-бајта тако да је \fBpb=4,lp=4,lc=0\fP добро са +LZMA2 (2^4=16). +.IP \(bu 3 +RISC\-V код има поравнање од 2 или 4 бајта у зависности од тога да ли +датотека садржи запаковане инструкције од 16 бита (проширење C). Када се +користе инструкције од 16 бита, \fBpb=2,lp=1,lc=3\fP или \fBpb=1,lp=1,lc=3\fP је +добро. Када нема инструкција од 16 бита, \fBpb=2,lp=2,lc=2\fP је најбоље. +\fBreadelf \-h\fP се може користити да се провери да ли се „RVC“ јавља у реду +„Заставице“. +.IP \(bu 3 +ARM64 је увек 4\-бајта поравнат тако да је \fBpb=2,lp=2,lc=2\fP најбоље. +.IP \(bu 3 +Филтер x86 је изузетак. Обично је добро придржавати се LZMA2 основности +(\fBpb=2,lp=0,lc=3\fP) приликом запакивања x86 извршних. +.RE +.IP "" +Сви BCJ филтери подржавају исте \fIопције\fP: +.RS +.TP +\fBstart=\fP\fIпомерај\fP +Наводи \fIпомерај\fP почетка који се користи приликом претварања између +релативних и апсолутних адреса. \fIПомерај\fP мора бити производ поравнања +филтера (видите табелу изнад). Основно је нула. У пракси, основност је +добра; навођење произвољног \fIпомераја\fP скоро никада није од користи. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIопције\fP] +Додаје Delta филтер у ланац филтера. Делта филтер може се користити само +ако није последњи филтер у ланцу филтера. +.IP "" +Тренутно је подржан само једноставан делта прорачун једног по једног бита. +Може бити користан приликом запакивања, на пример, незапакованих битмап +слика или незапакованог PCM звука. Међутим, алгоритми посебне намене могу +дати знатно боље резултате него Delta + LZMA2. Ово је тачно, посебно са +звуком, који се запакује брже и боље, на пример, са \fBflac\fP(1). +.IP "" +Подржане \fIопције\fP: +.RS +.TP +\fBdist=\fP\fIрастојање\fP +Наводи \fIрастојање\fP делта прорачуна у бајтима. \fIРастојање\fP мора бити +1\(en256. Основно је 1. +.IP "" +На пример, са \fBdist=2\fP и осмобајтним улазом A1 B1 A2 B3 A3 B5 A4 B7, излаз +ће бити A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Остале опције" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Потискује упозорења и обавештења. Наведите ово два пута да потиснете и +грешке. Ова опција нема утицаја на стање излаза. Тако је, чак и ако је +упозорење потиснуто, стање излаза које указује на упозорење се и даље +користи. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Бива опширан. Ако је стандардна грешка повезана са терминалом, \fBxz\fP ће +приказати указивач напретка. Навођењем \fB\-\-verbose\fP два пута добија се још +опширнији излаз. +.IP "" +Указивач напредовања показује следеће информације: +.RS +.IP \(bu 3 +Проценат довршености се показује ако је величина улазне датотеке позната. +Тако је, проценат се не може приказати у спојкама. +.IP \(bu 3 +Количина запакованих података проистеклих (запакивање) или утрошених +(распакивање). +.IP \(bu 3 +Количина распакованих података утрошених (запакивање) или проистеклих +(распакивање). +.IP \(bu 3 +Размера паковања, која се израчунава дељењем количине запакованих података +обрађених до сада количином незапакованих података до сада обрађених. +.IP \(bu 3 +Брзина запакивања или распакивања. Ово се мери као количина незапакованих +података утрошених (запакивање) или добијених (распакивање) у секунди. +Приказује се након неколико секунде након што \fBxz\fP започне обраду датотеке. +.IP \(bu 3 +Протекло време у формату М:СС или Ч:ММ:СС. +.IP \(bu 3 +Процењено преостало време се приказује само када је величина улазне датотеке +позната и неколико секунди је већ протекло од кад је \fBxz\fP започео обраду +датотеке. Време се приказује у мање тачном формату које никада нема +двотачке, на пример, 2 мин 30 сек. +.RE +.IP "" +Када стандардна грешка није терминал, \fB\-\-verbose\fP ће учинити да \fBxz\fP +испише назив датотеке, запаковану величину, незапаковану величину, стопу +запакивања и по могућству такође брзину и протекло време на једном реду на +стандардну грешку након запакивања или распакивања датотеке. Брзина и +протекло време су укључени само када радња потраје барем неколико секунде. +Ако се радња не заврши, на пример, услед што корисник прекине, такође се +исписује проценат завршености ако је величина улазне датотеке позната. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Не поставља стање излаза на 2 чак и ако је услов вредан упозорења откривен. +Ова опција не утиче на ниво опширности, стога и \fB\-\-quiet\fP и \fB\-\-no\-warn\fP +треба да се користе да се не приказују упозорења и да се не измени стање +излаза. +.TP +\fB\-\-robot\fP +Исписује поруке у формату обрадивом машинама. Ово је замишљено да олакша +писање челника који желе да користе \fBxz\fP уместо „liblzma“, што може бити +случај са разним скриптама. Излаз са овом опцијом укљученом је замишљен да +буде стабилан кроз \fBxz\fP издања. Видите одељак \fBРЕЖИМ РОБОТА\fP за више о +томе. +.TP +\fB\-\-info\-memory\fP +Приказује, у формату читљивом људима, колико физичке меморије (RAM) и колико +нити процесора \fBxz\fP мисли да систем има и ограничења коришћења меморије за +запакивање и распакивање и излази успешно. +.TP +\fB\-h\fP, \fB\-\-help\fP +Приказује поруку помоћи описујући најчешће коришћених опција, и успешно +излази. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Приказује поруку помоћи описујући све функције \fBxz\fP, и успешно излази +.TP +\fB\-V\fP, \fB\-\-version\fP +Приказује број издања за \fBxz\fP и „liblzma“ у формату читљивом људима. Да +добијете излаз машинама обрадив, наведите \fB\-\-robot\fP пре \fB\-\-version\fP. +. +.SH "РЕЖИМ РОБОТА" +Режим робота се покреће опцијом \fB\-\-robot\fP. Чини да излаз \fBxz\fP буде лакши +за обраду другим програмима. Тренутно \fB\-\-robot\fP је подржано само заједно +са \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP, и \fB\-\-version\fP. Биће +подржан за запакивање и распакивање у будућности. +. +.SS "Режим списка" +\fBxz \-\-robot \-\-list\fP користи излаз раздвојен табулатором. Прва колона +сваког реда садржи ниску која указује на врсту информације која се налази у +том реду: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP (назив) +Ово је увек први ред приликом почетка листања датотеке. Друга колона у реду +је назив датотеке. +.TP +\fBfile\fP (датотека) +Овај ред садржи свеукупне информације о \fB.xz\fP датотеци. Овај ред се увек +исписује после реда \fBназив\fP. +.TP +\fBstream\fP (ток) +Ова врста реда се користи само када је \fB\-\-verbose\fP наведено. Има толико +редова \fBтока\fP колико има токова у \fB.xz\fP даатотеци. +.TP +\fBblock\fP (блок) +Ова врста реда се користи само када је \fB\-\-verbose\fP наведено. Има онолико +редова \fBблока\fP колико има блокова у \fB.xz\fP датотеци. Редови \fBблока\fP се +приказују након свих редова \fBтока\fP; различите врсте реда се не преплићу. +.TP +\fBsummary\fP (сажетак) +Ова врста реда се користи само када је \fB\-\-verbose\fP наведено два пута. Овај +ред се исписује након свих редова \fBблока\fP. Као ред \fBдатотека\fP, ред +\fBсажетка\fP садржи преглед информација о \fB.xz\fP датотеци. +.TP +\fBtotals\fP (укупност) +Овај ред је увек последњи ред на списку излаза. Показује укупне збирове и +величине. +.PP +Колоне редова \fBдатотеке\fP: +.PD 0 +.RS +.IP 2. 4 +Број токова у датотеци +.IP 3. 4 +Укупан број блокова у току(овима) +.IP 4. 4 +Величина запаковане датотеке +.IP 5. 4 +Величина незапаковане датотеке +.IP 6. 4 +Размера паковања, на пример, \fB0.123\fP. Ако је размера преко 9.999, три +цртице (\fB\-\-\-\fP) се приказују уместо размере. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Зарезом раздвојен списак назива провера целовитости. Следеће ниске се +користе за познате врсте провера: \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP и \fBSHA\-256\fP. +За непознате врсте провера, користи се \fBUnknown\-\fP\fIN\fP, где је \fIN\fP ИД +провере као децимални број (једна или две цифре). +.IP 8. 4 +Укупна величина попуњавања тока у датотеци +.RE +.PD +.PP +Колоне редова \fBтока\fP: +.PD 0 +.RS +.IP 2. 4 +Број тока (први ток је 1) +.IP 3. 4 +Број блокова у току +.IP 4. 4 +Померај почетка запакованог +.IP 5. 4 +Померај почетка незапаковане +.IP 6. 4 +Величина запакованог (не укључује попуну тока) +.IP 7. 4 +Величина незапаковане +.IP 8. 4 +Размера паковања +.IP 9. 4 +Назив провере целовитости +.IP 10. 4 +Величина попуне тока +.RE +.PD +.PP +Колоне редова \fBблока\fP: +.PD 0 +.RS +.IP 2. 4 +Број тока који садржи овај блок +.IP 3. 4 +Број блока релативан на почетак тока (први блок је 1) +.IP 4. 4 +Број блока релативан на почетак датотеке +.IP 5. 4 +Померај почетка запакованог односан на почетак датотеке +.IP 6. 4 +Померај почетка незапаковане односан на почетак датотеке +.IP 7. 4 +Укупна запакована величина блока (заједно са заглављима) +.IP 8. 4 +Величина незапаковане +.IP 9. 4 +Размера паковања +.IP 10. 4 +Назив провере целовитости +.RE +.PD +.PP +Ако је \fB\-\-verbose\fP наведено два пута, додатне колоне су укључене у редовима +\fBблока\fP. Они се не приказују са једним \fB\-\-verbose\fP, јер добијање ове +информације захтева много тражења и стога може бити споро: +.PD 0 +.RS +.IP 11. 4 +Вредност провере целовитости у хексадецималном облику +.IP 12. 4 +Величина заглавља блока +.IP 13. 4 +Заставице блока: \fBc\fP указује да је величина запакованог присутна, а \fBu\fP +указује да је величина нераспакованог присутна. Ако заставица није +постављена, цртица (\fB\-\fP) се приказује уместо да се настави са поправком +дужине ниске. У будућности нове заставице могу бити додате на крај ниске. +.IP 14. 4 +Величина стварних запакованих података у блоку (ово искључује заглавље +блока, попуњавање блока и поља провере) +.IP 15. 4 +Количина меморије (у бајтовима) потребна за распакивање овог блока са овим +\fBxz\fP издањем +.IP 16. 4 +Ланац филтера. Знајте да већина опција коришћених за време запакивања не +може бити познато, јер се само опције које су потребне за распакивање чувају +у \fB.xz\fP заглављима. +.RE +.PD +.PP +Колоне редова \fBсажетка\fP: +.PD 0 +.RS +.IP 2. 4 +Количина меморије (у бајтовима) потребна за распакивање ове датотеке са овим +\fBxz\fP издањем +.IP 3. 4 +\fByes\fP или \fBno\fP указује да ли сва заглавља блока имају и величину +запакованог и величину незапакованог сачуване у њима +.PP +\fIОд\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Потребно је најмање \fBxz\fP издање за распакивање датотеке +.RE +.PD +.PP +Колоне редова \fBукупности\fP: +.PD 0 +.RS +.IP 2. 4 +Број токова +.IP 3. 4 +Број блокова +.IP 4. 4 +Величина запакованог +.IP 5. 4 +Величина незапаковане +.IP 6. 4 +Просечан степен запакивања +.IP 7. 4 +Списак зарезом раздвојених назива провере целовитости која су била присутна +у датотекама +.IP 8. 4 +Величина попуњавања тока +.IP 9. 4 +Број датотека. Ту се држи поредак ранијих колона исто као у редовима +\fBдатотеке\fP. +.PD +.RE +.PP +Ако је \fB\-\-verbose\fP наведено два пута, додатне колоне су укључене у реду +\fBtotals\fP: +.PD 0 +.RS +.IP 10. 4 +Највећа количина меморије (у бајтима) потребна за распакивање датотеке са +овим \fBxz\fP издањем +.IP 11. 4 +\fByes\fP или \fBno\fP указује да ли сва заглавља блока имају и величину +запакованог и величину незапакованог сачуване у њима +.PP +\fIОд\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Потребно је најмање \fBxz\fP издање за распакивање датотеке +.RE +.PD +.PP +Будућа издања могу додати нове врсте реда и нове колоне се могу додати +постојећим врстама реда, али постојеће колоне се неће променити. +. +.SS "Помоћ филтера" +\fBxz \-\-robot \-\-filters\-help\fP исписује подржане филтере у следећем формату: +.PP +\fIфилтер\fP\fB:\fP\fIопција\fP\fB=<\fP\fIвредност\fP\fB>,\fP\fIопција\fP\fB=<\fP\fIвредност\fP\fB>\fP... +.TP +\fIфилтер\fP +Назив филтера +.TP +\fIопција\fP +Назив филтера специфичне опције +.TP +\fIвредност\fP +Опсези бројевних \fIвредности\fP се јављају као +\fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. \fIВредност\fP ниске избора се приказују +унутар \fB< >\fP и раздвојене су знаком \fB|\fP. +.PP +Сваки филтер се исписује на свом сопственом реду. +. +.SS "Информације о ограничењу меморије" +\fBxz \-\-robot \-\-info\-memory\fP исписује један ред са више колона раздвојених +табулатором: +.IP 1. 4 +Укупна количина физичке меморије (RAM) у бајтима. +.IP 2. 4 +Ограничење коришћења меморије за запакивање у бајтима +(\fB\-\-memlimit\-compress\fP). Специјална вредност \fB0\fP означава основно +подешавање које је за режим једне нити исто као без ограничења. +.IP 3. 4 +Ограничење коришћења меморије за распакивање у бајтима +(\fB\-\-memlimit\-decompress\fP). Специјална вредност \fB0\fP означава основно +подешавање које је за режим једне нити исто као без ограничења. +.IP 4. 4 +Од \fBxz\fP 5.3.4alpha: Коришћење меморије за распакивање са више нити у +бајтима (\fB\-\-memlimit\-mt\-decompress\fP). Ово никада није нула јер систему +специфична основна вредност приказана у колони 5 се користи ако ограничење +није изричито наведено. Такође никада није веће од вредности у колони 3 чак +и ако је наведена већа вредност са \fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Од \fBxz\fP 5.3.4alpha: Систему специфично основно ограничење коришћења +меморије које се користи за ограничавање броја нити приликом запакивања са +аутоматским бројем нити (\fB\-\-threads=0\fP) и без наведеног ограничења +коришћења меморије (\fB\-\-memlimit\-compress\fP). Ово се такође користи као +основна вредност за \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Од \fBxz\fP 5.3.4alpha: Број доступних нити обрађивача. +.PP +У будуће, излаз \fBxz \-\-robot \-\-info\-memory\fP може имати више колона, али +никада више од једног реда. +. +.SS Издање +\fBxz \-\-robot \-\-version\fP исписује број издања за \fBxz\fP и „liblzma“ у следећем +формату: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Главно издање. +.TP +\fIYYY\fP +Споредно издање. Парни бројеви су стабилна а непарни су алфа или бета +издања. +.TP +\fIZZZ\fP +Ниво закрпе за стабилна издања или само бројач за развојна издања. +.TP +\fIS\fP +Стабилност. 0 је алфа, 1 је бета, а 2 је стабилно. \fIS\fP треба увек да буде +2 када је \fIYYY\fP парно. +.PP +\fIXYYYZZZS\fP су исти у оба реда ако су \fBxz\fP и „liblzma“ из истог издања XZ +Utils\-а. +.PP +Примери: 4.999.9beta је \fB49990091\fP и 5.0.0 је \fB50000002\fP. +. +.SH "СТАЊЕ ИЗЛАЗА" +.TP +\fB0\fP +Све је у реду. +.TP +\fB1\fP +Дошло је до грешке. +.TP +\fB2\fP +Десило се нешто вредно упозорења, али није дошло до стварних грешака. +.PP +Обавештења (без упозорења или грешака) исписано на стандардној грешци не +утичу на стање излаза. +. +.SH ОКРУЖЕЊЕ +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP обрађује размаком одвојени списак опција из променљивих окружења +\fBXZ_DEFAULTS\fP и \fBXZ_OPT\fP, тим редом, пре обраде опција са линије наредби. +Знајте да се обрађују само опције из променљивих окружења; све што нису +опције се тихо занемарује. Обрада се ради са \fBgetopt_long\fP(3) која се +користи такође за аргументе линије наредби. +.PP +\fBУпозорење:\fP Постављањем ових променљивих окружења, ефективно мењате +програме и скрипте које покреће \fBxz\fP. У већини случајева је безбедно +поставити ограничење коришћења, број нити и опција паковања путем +променљивих окружења. Међутим, неке опције могу да уруше скрипте. +Очигледан пример је \fB\-\-help\fP која чини да \fBxz\fP прикаже текст помоћи уместо +да запакује или распакује датотеку. Суптилнији примери су \fB\-\-quiet\fP и +\fB\-\-verbose\fP. У многим случајевима добро функционише омогућавање указивача +напредовања коришћењем \fB\-\-verbose\fP, али у неким ситуацијама додатне поруке +стварају проблеме. Ниво опширности такође утиче на понашање \fB\-\-list\fP +.TP +\fBXZ_DEFAULTS\fP +Кориснику специфичне или свеопште системске основне опције. Обично је ово +постављено у скрипти покретања конзоле за укључивање \fBxz\fP ограничавача +коришћења меморије по основи или за постављање основног броја нити. +Искључивање скрипти покретања конзоле и сличних специјалних случајева, +скрипте не смеју никада да поставе или пониште \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Ово је за прослеђивање опција ка \fBxz\fP када није могуће поставити опције +директно на \fBxz\fP линији наредби. Ово је случај када је \fBxz\fP покренут +скриптом или алатом, на пример, са Гну \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Скрипте могу да користе \fBXZ_OPT\fP, на пример, за постављање основних опција +запакивања специфичних скрипти. Још увек се препоручује омогућавање +корисницима да пишу преко \fBXZ_OPT\fP ако је то разумљиво. На пример, у +\fBsh\fP(1) скриптама неко може користити нешто као ово: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "LZMA UTILS САДЕЈСТВЕНОСТ" +Синтакса линије наредби \fBxz\fP је практично супер скуп \fBlzma\fP, \fBunlzma\fP и +\fBlzcat\fP као што се налази у LZMA Utils 4.32.x. У већини случајева, могуће +је заменити LZMA Utils са XZ Utils без оштећења постојећих скрипти. Има +неких несагласности такође, које понекад могу довести до проблема. +. +.SS "Нивои предподешавања запакивања" +Набрајање предподешености нивоа запакивања није исто у \fBxz\fP и LZMA Utils. +Најважнија разлика је у томе како се величине речника мапирају у различитим +предподешеностима. Величина речника је отприлике иста као и коришћење +меморије распакивача. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Ниво;xz;LZMA Utils +\-0;256 KiB;Н/Д +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Разлике величине речника делују такође на коришћење меморије запакивање, али +постоје још неке разлике између LZMA Utils и XZ Utils, што чини разлике још +већим: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Ниво;xz;LZMA Utils 4.32.x +\-0;3 MiB;Н/Д +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Основни ниво предподешености у LZMA Utils је \fB\-7\fP док у XZ Utils је \fB\-6\fP, +тако да оба користе 8 MiB речник по основи. +. +.SS "Токовне наспрам не\-токовних „.lzma“ датотеке" +Незапакована величина датотеке се може чувати у \fB.lzma\fP заглављу. LZMA +Utils то ради приликом запакивања обичних датотека. Алтернатива је да се +означи та незапакована величина као непозната и да се користи означавач +краја утовара да назначи где распакивач треба да стане. LZMA Utils користи +ову методу када незапакована величина није позната, што је случај, на +пример, у спојкама. +.PP +\fBxz\fP подржава распакивање \fB.lzma\fP датотека са или без означавача краја +утовара, али ће све \fB.lzma\fP датотеке направљене са \fBxz\fP користити +означавач краја утовара и означити незапаковану величину непознатом у +\&\fB.lzma\fP заглављу. Ово може бити проблем у неким неуобичајеним +ситуацијама. На пример, \fB.lzma\fP распакивач у угнежденом уређају може +радити само са датотекама које имају незапаковану величину. Ако наиђете на +тај проблем, треба да користите LZMA Utils или LZMA SDK да направите +\&\fB.lzma\fP датотеке са познатом незапакованом величином. +. +.SS "Неподржане „.lzma“ датотеке" +Формат \fB.lzma\fP омогућава \fIlc\fP вредности све до 8, а \fIlp\fP вредности све до +4. LZMA Utils може да распакује датотеке са било којим \fIlc\fP и \fIlp\fP, али +увек прави датотеке са \fBlc=3\fP и \fBlp=0\fP. Прављење датотека са другим \fIlc\fP +и \fIlp\fP је мгуће са \fBxz\fP и са LZMA SDK. +.PP +Примена филтера LZMA1 у „liblzma“ захтева да збир \fIlc\fP и \fIlp\fP не сме да +премаши 4. Стога, \fB.lzma\fP датотеке, које премаше ово ограничење, не могу +да се распакују са \fBxz\fP. +.PP +LZMA Utils прави само \fB.lzma\fP датотеке које имају величину речника од +2^\fIn\fP (степен 2) али прихвата датотеке са било којом величином речника. +„liblzma“ прихвата само \fB.lzma\fP датотеке које имају величину речника од +2^\fIn\fP или 2^\fIn\fP + 2^(\fIn\fP\-1). Ово је да се смање лажни позитивни +резултати приликом откривања \fB.lzma\fP датотека. +.PP +Ова ограничења не би требало да буду проблем у пракси, јер су практично све +\&\fB.lzma\fP датотеке запаковане са поставкама које ће „liblzma“ прихватити. +. +.SS "Пратеће смеће" +Приликом распакивања, LZMA Utils тихо занемарује све после првог \fB.lzma\fP +тока. У већини прилика, ово је грешка. Ово такође значи да LZMA Utils не +подржава распакивање надовезаних \fB.lzma\fP датотека. +.PP +Ако су остали подаци након првог \fB.lzma\fP тока, \fBxz\fP сматра да је датотека +оштећена осим ако је коришћено \fB\-\-single\-stream\fP. Ово може прекинути +нејасне скрипте које су претпоставиле да је пратеће смеће занемарено. +. +.SH НАПОМЕНЕ +. +.SS "Излаз запакованог може бити променљив" +Тачан запаковани излаз добијен из исте незапаковане улазне датотеке може се +разликовати између XZ Utils издања чак и ако су опције запакивања +истоветне. Ово је због тога што шифрер може бити побољшан (брже и боље +запакивање) а да не утиче на формат датотеке. Излаз се може разликовати +између различитих изградњи истог XZ Utils издања, ако су коришћене другачије +опције изградње. +.PP +Ово изнад значи да када се \fB\-\-rsyncable\fP једном примени, резултирајућа +датотека неће неопходно бити r\-ускладива осим ако и стара и нова датотека +нису запаковане истим xz издањем. Овај проблем може бити поправљен ако је +део примене шифрера замрзнут да држи r\-ускладив излаз стабилним кроз xz +издања. +. +.SS "Угнеждени „.xz“ распакивачи" +Примена угнежденог \fB.xz\fP распакивача као што је XZ Embedded неопходно не +подржава датотеке направљене врстама \fIпровере\fP целовитости осим \fBnone\fP и +\fBcrc32\fP. Како је основно \fB\-\-check=crc64\fP, морате да користите +\fB\-\-check=none\fP или \fB\-\-check=crc32\fP када правите датотеке за угнеждене +системе. +.PP +Споља уграђени системи, сви распакивачи \fB.xz\fP формата подржавају све врсте +\fIпровере\fP, или барем могу да распакују датотеку без испитивања провере +целовитости ако одређена \fIпровера\fP није подржана. +.PP +XZ Embedded подржава BCJ филтере, али само са основним померајем почетка. +. +.SH ПРИМЕРИ +. +.SS Основно +Запакује датотеку \fIfoo\fP у \fIfoo.xz\fP користећи основни ниво запакивања +(\fB\-6\fP), и уклања \fIfoo\fP ако је запакивање успешно: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Распакује \fIbar.xz\fP у \fIbar\fP и не уклања \fIbar.xz\fP чак и када је распакивање +успешно: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Ствара \fIbaz.tar.xz\fP са предподешавањем \fB\-4e\fP (\fB\-4 \-\-extreme\fP), које је +спорије него основно \fB\-6\fP, али захтева мање меморије за запакивање и +распакивање (48\ MiB и 5\ MiB): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Мешавина сажетих и несажетих датотека се може распаковати на стандардни +излаз једном наредбом: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Паралелно запакивање више датотека" +На GNU и *BSD, \fBfind\fP(1) и \fBxargs\fP(1) се могу користити за паралелно +запакивање више датотека: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Опција \fB\-P\fP за \fBxargs\fP(1) поставља број паралелних \fBxz\fP процеса. Најбоља +вредност за опцију \fB\-n\fP зависи од тога колико датотека има за запакивање. +Ако има само неколико датотека, вредност би вероватно требала да буде 1; са +више хиљада датотека, 100 или чак и више може бити одговарајуће за смањење +броја \fBxz\fP процеса које би \fBxargs\fP(1) евентуално направио. +.PP +Опција \fB\-T1\fP за \fBxz\fP је ту да га примора на једнонитни режим, јер се +\fBxargs\fP(1) користи за контролу количине паралелизације. +. +.SS "Режим робота" +Израчунава колико је бајтова укупно сачувано након запакивања више датотека: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Скрипта може желети да зна да користи најновији \fBxz\fP. Следећа скрипта +\fBsh\fP(1) проверава да ли је број издања \fBxz\fP алата барем 5.0.0. Ова +метода је сагласна са старим бета издањима која не подржавају \fB\-\-robot\fP +опцију: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Ваш „xz“ је превише стар." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Поставља ограничење коришћења меморије за распакивање коришћењем \fBXZ_OPT\fP, +али ако је ограничење већ постављено, не повећава је: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Произвољни ланци филтера запакивача" +Најједноставнија употреба за произвољне ланце филтера прилагођава LZMA2 +предподешеност. Ово може бити корисно, јер предподешености покривају само +подскуп потенцијално корисних комбинација поставки запакивања. +.PP +Колоне ЗапакЦПЈ у табелама из описа опција \fB\-0\fP ... \fB\-9\fP и \fB\-\-extreme\fP су +корисне приликом прилагођавања LZMA2 предподешености. Овде су значајни +делови прикупљени из те две табеле: +.RS +.PP +.TS +tab(;); +c c +n n. +Преподешеност;ЗапакЦПЈ +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Ако знате да датотека захтева нешто велики речник (на пример, 32 \ MiB) за +добро запакивање, али желите да је запакујете брже него што би то \fBxz \-8\fP +урадио, предподешеност са ниском вредношћу ЗапакМем (на пример, 1) може се +изменити да користи већи речник: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Са одређеним датотекама, горња наредба може бити бржа од \fBxz \-6\fP а +запакивање значајно боље. Међутим, мора бити наглашено да само неке +датотеке имају корист од великог речника док одржавају вредност ЗапакЦПЈ +ниском. Најочигледнија ситуација, у којој велики речник може доста помоћи, +јесте архива која садржи врло сличне датотеке где свака има најмање неколико +мегабајта. Величина речника треба да буде значајно већа од сваке засебне +датотеке да би се омогућило да LZMA2 има потпуну предност од сличности +између узастопних датотека. +.PP +Ако је веома велико коришћење меморије запакивача и распакивача у реду, а +датотека која се запакује је барем неколико стотина мегабајта, може бити +корисно користити још већи речник од 64 MiB који ће \fBxz \-9\fP користити: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Коришћење \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) као у горњем примеру може бити +корисно да се виде захтеви за меморијом запакивача и распакивача. Знајте да +је коришћење речника већег од величине незапаковане датотеке губитак +меморије, тако да горња наредба није корисна за мале датотеке. +.PP +Понекад време запакивања није важно, али коришћење меморије распакивача +треба да се одржава ниским, на пример, да би се учинило могућим распакивање +датотеке на угнежденом систему, Следеће наредбе користе \fB\-6e\fP (\fB\-6 \-\-extreme\fP) као основу и постављају речник на само 64\ KiB. Резултујућа +датотека се може распаковати са XZ Embedded (због тога је ту +\fB\-\-check=crc32\fP) користећи око 100\ KiB меморије. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Ако желите да исцедите што је више могуће бајтова, дотеривање броја битова +контекста литерала (\fIlc\fP) и броја битова положаја (\fIpb\fP) може понекад да +помогне. Дотеривање броја битова положаја литерала (\fIlp\fP) може такође да +помогне, али обично \fIlc\fP и \fIpb\fP су важнији. На пример, архива извора кода +садржи углавном US\-ASCII текст, тако да нешто као следеће може да да +незнатно (око 0.1\ %) мању датотеку него \fBxz \-6e\fP (пробајте такође без +\fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Коришћење још једног филтера заједно са LZMA2 може побољшати запакивање са +одређеним врстама датотека. На пример, за запакивање x86\-32 или x86\-64 +дељене библиотеке коришћењем x86 BCJ филтера: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Знајте да поредак опција филтера има значај. Ако је \fB\-\-x86\fP наведено након +\fB\-\-lzma2\fP, \fBxz\fP ће дати грешку, јер не сме бити никаквог филтера после +LZMA2, и такође зато што се x86 BCJ филтер не може користити као последњи +филтер у ланцу. +.PP +Delta филтер заједно са LZMA2 може дати добре резултате са битмап сликама. +Требало би обично да надјача PNG, који има нешто више напредних филтера него +једноставни делта али користи Deflate за стварно запакивање. +.PP +Слика треба да се сачува у незапакованом формату, на пример, као +незапакована TIFF. Параметар растојања Delta филтера је постављен да се +подудари са бројем бајтова по пикселу у слици. На пример, RGB битмапа од 24 +бита захтева \fBdist=3\fP, а такође је добро проследити \fBpb=0\fP за LZMA2 да се +прилагоди поравнање од три бајта: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Ако је више слика стављено у једну архиву (на пример, \fB.tar\fP), Delta филтер +ће радити на томе такође све док све слике не буду имале исти број бајтова +по пикселу. +. +.SH "ВИДИТЕ ТАКОЂЕ" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xzcmp.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xzcmp.1 new file mode 100644 index 0000000000000000000000000000000000000000..6c9ef9938e11d68a13510dffa145304439b97e6c --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xzcmp.1 @@ -0,0 +1,54 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Serbian translation of xz-man. +.\" Мирослав Николић , 2025. +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 06.03.2025. Tukaani "XZ Utils" +.SH НАЗИВ +xzcmp, xzdiff, lzcmp, lzdiff – упоређује запаковане датотеке +. +.SH САЖЕТАК +\fBxzcmp\fP [\fIопција...\fP] \fIдатотека1\fP [\fIдатотека2\fP] +.br +\fBxzdiff\fP \&... +.br +\fBlzcmp\fP \&... (ЗАСТАРЕЛО) +.br +\fBlzdiff\fP \&... (ЗАСТАРЕЛО) +. +.SH ОПИС +\fBxzcmp\fP и \fBxzdiff\fP пореди незапаковане садржаје две датотеке. +Незапаковани подаци и опције се прослеђују ка \fBcmp\fP(1) или \fBdiff\fP(1) осим +ако није наведено \fB\-\-help\fP or \fB\-\-version\fP. +.PP +Ако су наведене и \fIдатотека1\fP и \fIдатотека2\fP, оне могу бити незапаковане +датотеке или датотеке у форматима које \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), +\fBlzop\fP(1), \fBzstd\fP(1) или \fBlz4\fP(1) могу да распакују. Захтеване наредбе +распакивања се одређују из суфикса назива \fIдатотеке1\fP и \fIдатотеке2\fP. +Датотека са непознатим суфиксом се претпоставља да је незапакована или да је +у формату који \fBxz\fP(1) може да распакује. +.PP +Ако је достављен само један назив датотеке, \fIдатотека1\fP мора да има суфикс +подржаних формата запакивања а назив за \fIдатотеку2\fP се подразумева да је +\fIдатотека1\fP са уклоњеним суфиксом формата запакивања. +.PP +Наредбе \fBlzcmp\fP и \fBlzdiff\fP се достављају зарад назадне сагласности са LZMA +Utils. Застареле су и биће уклоњене у будућем издању. +. +.SH "СТАЊЕ ИЗЛАЗА" +Ако дође до грешке распакивања,излазно стање је \fB2\fP. У супротном излазно +стање од \fBcmp\fP(1) или \fBdiff\fP(1) се користи. +. +.SH "ВИДИТЕ ТАКОЂЕ" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xzdec.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xzdec.1 new file mode 100644 index 0000000000000000000000000000000000000000..c9bbe26f45da0a1add18e35e5a13105c4155b677 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xzdec.1 @@ -0,0 +1,81 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.\" Serbian translation of xz-man. +.\" Мирослав Николић , 2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDEC 1 08.04.2024. Tukaani "XZ Utils" +.SH НАЗИВ +xzdec, lzmadec – Мали „.xz“ и „.lzma“ распакивачи +.SH САЖЕТАК +\fBxzdec\fP [\fIопција...\fP] [\fIдатотека...\fP] +.br +\fBlzmadec\fP [\fIопција...\fP] [\fIдатотека...\fP] +.SH ОПИС +\fBxzdec\fP је алат само за распакивање заснован на „liblzma“ за \fB.xz\fP (и само +\&\fB.xz\fP) датотеке. \fBxzdec\fP је намењен да ради као тренутна замена за +\fBxz\fP(1) у најопштијим ситуацијама где је скрипта написана да користи \fBxz \-\-decompress \-\-stdout\fP (и по могућству још неколико других обично коришћених +опција) за распакивање \fB.xz\fP датотека. \fBlzmadec\fP је истоветна са \fBxzdec\fP +осим што \fBlzmadec\fP подржава \fB.lzma\fP датотеке уместо of \fB.xz\fP датотека. +.PP +За смањење величине извршне, \fBxzdec\fP не подржава више нити или +локализацију, и не чита опције из променљивих окружења \fBXZ_DEFAULTS\fP и +\fBXZ_OPT\fP. \fBxzdec\fP не подржава приказивање посредничких информација +напредовања: слање \fBSIGINFO\fP ка \fBxzdec\fP не ради ништа, али слање +\fBSIGUSR1\fP окончава процес уместо да прикаже информације о напредовању. +.SH ОПЦИЈЕ +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +Занемарено зарад \fBxz\fP(1) сагласности. \fBxzdec\fP подржава само распакивање. +.TP +\fB\-k\fP, \fB\-\-keep\fP +Занемарено зарад \fBxz\fP(1) сагласности. \fBxzdec\fP никада не прави или уклања +датотеке. +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Занемарено зарад \fBxz\fP(1) сагласности. \fBxzdec\fP увек пише распаковане +податке на стандардни излаз. +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Навођењем овога једном не ради ништа јер \fBxzdec\fP никада не приказује +упозорења или обавештења. Наведите ово два пута да потиснете грешке. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Занемарено зарад \fBxz\fP(1) сагласности. \fBxzdec\fP никада не користи излазно +стање 2. +.TP +\fB\-h\fP, \fB\-\-help\fP +Приказује поруку помоћи и излази с успехом. +.TP +\fB\-V\fP, \fB\-\-version\fP +Приказује број издања за \fBxzdec\fP и „liblzma“. +.SH "СТАЊЕ ИЗЛАЗА" +.TP +\fB0\fP +Све беше у реду. +.TP +\fB1\fP +Дошло је до грешке. +.PP +\fBxzdec\fP нема поруке упозорења као што има \fBxz\fP(1), стога \fBxzdec\fP не +користи излазно стање 2. +.SH НАПОМЕНЕ +Користите \fBxz\fP(1) уместо \fBxzdec\fP или \fBlzmadec\fP за обично свакодневно +коришћење. \fBxzdec\fP или \fBlzmadec\fP су замишљени само ситуације у којима је +важно имати мањи распакивач неко потпуно функционалан \fBxz\fP(1). +.PP +\fBxzdec\fP и \fBlzmadec\fP нису баш тако мали. Величина може бити још смањена +одбацивањем функција из „liblzma“ за време превођења, али то не треба обично +да се ради за извршне достављене у типичним не\-угнежденим дистрибуцијама +оперативног система. Ако вам треба стварно мали \fB.xz\fP распакивач, +размотрите коришћење XZ Embedded\-а. +.SH "ВИДИТЕ ТАКОЂЕ" +\fBxz\fP(1) +.PP +XZ Embedded: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xzdiff.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xzdiff.1 new file mode 100644 index 0000000000000000000000000000000000000000..6c9ef9938e11d68a13510dffa145304439b97e6c --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xzdiff.1 @@ -0,0 +1,54 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Serbian translation of xz-man. +.\" Мирослав Николић , 2025. +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 06.03.2025. Tukaani "XZ Utils" +.SH НАЗИВ +xzcmp, xzdiff, lzcmp, lzdiff – упоређује запаковане датотеке +. +.SH САЖЕТАК +\fBxzcmp\fP [\fIопција...\fP] \fIдатотека1\fP [\fIдатотека2\fP] +.br +\fBxzdiff\fP \&... +.br +\fBlzcmp\fP \&... (ЗАСТАРЕЛО) +.br +\fBlzdiff\fP \&... (ЗАСТАРЕЛО) +. +.SH ОПИС +\fBxzcmp\fP и \fBxzdiff\fP пореди незапаковане садржаје две датотеке. +Незапаковани подаци и опције се прослеђују ка \fBcmp\fP(1) или \fBdiff\fP(1) осим +ако није наведено \fB\-\-help\fP or \fB\-\-version\fP. +.PP +Ако су наведене и \fIдатотека1\fP и \fIдатотека2\fP, оне могу бити незапаковане +датотеке или датотеке у форматима које \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), +\fBlzop\fP(1), \fBzstd\fP(1) или \fBlz4\fP(1) могу да распакују. Захтеване наредбе +распакивања се одређују из суфикса назива \fIдатотеке1\fP и \fIдатотеке2\fP. +Датотека са непознатим суфиксом се претпоставља да је незапакована или да је +у формату који \fBxz\fP(1) може да распакује. +.PP +Ако је достављен само један назив датотеке, \fIдатотека1\fP мора да има суфикс +подржаних формата запакивања а назив за \fIдатотеку2\fP се подразумева да је +\fIдатотека1\fP са уклоњеним суфиксом формата запакивања. +.PP +Наредбе \fBlzcmp\fP и \fBlzdiff\fP се достављају зарад назадне сагласности са LZMA +Utils. Застареле су и биће уклоњене у будућем издању. +. +.SH "СТАЊЕ ИЗЛАЗА" +Ако дође до грешке распакивања,излазно стање је \fB2\fP. У супротном излазно +стање од \fBcmp\fP(1) или \fBdiff\fP(1) се користи. +. +.SH "ВИДИТЕ ТАКОЂЕ" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xzegrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xzegrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..263fed9983f5d102ed2d439771a6732ae1b767b1 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xzegrep.1 @@ -0,0 +1,92 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Serbian translation of xz-man. +.\" Мирослав Николић , 2025. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 06.03.2025. Tukaani "XZ Utils" +.SH НАЗИВ +xzgrep – претражује могуће запаковане датотеке за шаблонима +. +.SH САЖЕТАК +\fBxzgrep\fP [\fIопција...\fP] [\fIсписак_шаблона\fP] [\fIдатотека...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (ЗАСТАРЕЛО) +.br +\fBlzegrep\fP \&... (ЗАСТАРЕЛО) +.br +\fBlzfgrep\fP \&... (ЗАСТАРЕЛО) +. +.SH ОПИС +\fBxzgrep\fP призива \fBgrep\fP(1) на незапакованим садржајима датотека. Формати +\fIдатотека\fP се одређују из суфикса назива датотека. Било која \fIдатотека\fP +са суфиксом подржаним од стране \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), +\fBlzop\fP(1), \fBzstd\fP(1) или \fBlz4\fP(1) биће распакована; све остале датотеке +се подразумевају да нису запаковане. +.PP +Ако \fIдатотеке\fP нису наведене или \fIдатотека\fP је \fB\-\fP тада се чита +стандардни улаз. Приликом читања са стандардног улаза, само датотеке +подржане са \fBxz\fP(1) се распакују. Друге датотеке се подразумева да су већ +у незапакованом облику. +.PP +Већина \fIопција\fP \fBgrep\fP(1) је подржана. Међутим, следеће опције нису +подржане: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIрадња\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIдатотека\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglob\fP +.PP +\fBxzegrep\fP је алијас за \fBxzgrep \-E\fP. \fBxzfgrep\fP је алијас за \fBxzgrep \-F\fP. +.PP +Наредбе \fBlzgrep\fP, \fBlzegrep\fP и \fBlzfgrep\fP се достављају зарад назадне +сагласности са LZMA Utils. Застареле су и биће уклоњене у будућем издању. +. +.SH "СТАЊЕ ИЗЛАЗА" +.TP +0 +Најмање једно поклапање је пронађено из барем једне од улазних датотека. +Није било грешака. +.TP +1 +Никаква поклапања нису пронађена ни из једне од улазних датотека. Није дошло +до грешака. +.TP +>1 +Дошло је до једне или више грешака. Није познато да ли су поклапања нађена. +. +.SH ОКРУЖЕЊЕ +.TP +\fBGREP\fP +Ако је \fBGREP\fP постављено на не\-празну вредност, користи се уместо \fBgrep\fP, +\fBgrep \-E\fP или \fBgrep \-F\fP. +. +.SH "ВИДИТЕ ТАКОЂЕ" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xzfgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xzfgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..263fed9983f5d102ed2d439771a6732ae1b767b1 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xzfgrep.1 @@ -0,0 +1,92 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Serbian translation of xz-man. +.\" Мирослав Николић , 2025. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 06.03.2025. Tukaani "XZ Utils" +.SH НАЗИВ +xzgrep – претражује могуће запаковане датотеке за шаблонима +. +.SH САЖЕТАК +\fBxzgrep\fP [\fIопција...\fP] [\fIсписак_шаблона\fP] [\fIдатотека...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (ЗАСТАРЕЛО) +.br +\fBlzegrep\fP \&... (ЗАСТАРЕЛО) +.br +\fBlzfgrep\fP \&... (ЗАСТАРЕЛО) +. +.SH ОПИС +\fBxzgrep\fP призива \fBgrep\fP(1) на незапакованим садржајима датотека. Формати +\fIдатотека\fP се одређују из суфикса назива датотека. Било која \fIдатотека\fP +са суфиксом подржаним од стране \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), +\fBlzop\fP(1), \fBzstd\fP(1) или \fBlz4\fP(1) биће распакована; све остале датотеке +се подразумевају да нису запаковане. +.PP +Ако \fIдатотеке\fP нису наведене или \fIдатотека\fP је \fB\-\fP тада се чита +стандардни улаз. Приликом читања са стандардног улаза, само датотеке +подржане са \fBxz\fP(1) се распакују. Друге датотеке се подразумева да су већ +у незапакованом облику. +.PP +Већина \fIопција\fP \fBgrep\fP(1) је подржана. Међутим, следеће опције нису +подржане: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIрадња\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIдатотека\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglob\fP +.PP +\fBxzegrep\fP је алијас за \fBxzgrep \-E\fP. \fBxzfgrep\fP је алијас за \fBxzgrep \-F\fP. +.PP +Наредбе \fBlzgrep\fP, \fBlzegrep\fP и \fBlzfgrep\fP се достављају зарад назадне +сагласности са LZMA Utils. Застареле су и биће уклоњене у будућем издању. +. +.SH "СТАЊЕ ИЗЛАЗА" +.TP +0 +Најмање једно поклапање је пронађено из барем једне од улазних датотека. +Није било грешака. +.TP +1 +Никаква поклапања нису пронађена ни из једне од улазних датотека. Није дошло +до грешака. +.TP +>1 +Дошло је до једне или више грешака. Није познато да ли су поклапања нађена. +. +.SH ОКРУЖЕЊЕ +.TP +\fBGREP\fP +Ако је \fBGREP\fP постављено на не\-празну вредност, користи се уместо \fBgrep\fP, +\fBgrep \-E\fP или \fBgrep \-F\fP. +. +.SH "ВИДИТЕ ТАКОЂЕ" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xzgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xzgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..263fed9983f5d102ed2d439771a6732ae1b767b1 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xzgrep.1 @@ -0,0 +1,92 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Serbian translation of xz-man. +.\" Мирослав Николић , 2025. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 06.03.2025. Tukaani "XZ Utils" +.SH НАЗИВ +xzgrep – претражује могуће запаковане датотеке за шаблонима +. +.SH САЖЕТАК +\fBxzgrep\fP [\fIопција...\fP] [\fIсписак_шаблона\fP] [\fIдатотека...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (ЗАСТАРЕЛО) +.br +\fBlzegrep\fP \&... (ЗАСТАРЕЛО) +.br +\fBlzfgrep\fP \&... (ЗАСТАРЕЛО) +. +.SH ОПИС +\fBxzgrep\fP призива \fBgrep\fP(1) на незапакованим садржајима датотека. Формати +\fIдатотека\fP се одређују из суфикса назива датотека. Било која \fIдатотека\fP +са суфиксом подржаним од стране \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), +\fBlzop\fP(1), \fBzstd\fP(1) или \fBlz4\fP(1) биће распакована; све остале датотеке +се подразумевају да нису запаковане. +.PP +Ако \fIдатотеке\fP нису наведене или \fIдатотека\fP је \fB\-\fP тада се чита +стандардни улаз. Приликом читања са стандардног улаза, само датотеке +подржане са \fBxz\fP(1) се распакују. Друге датотеке се подразумева да су већ +у незапакованом облику. +.PP +Већина \fIопција\fP \fBgrep\fP(1) је подржана. Међутим, следеће опције нису +подржане: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIрадња\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIдатотека\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglob\fP +.PP +\fBxzegrep\fP је алијас за \fBxzgrep \-E\fP. \fBxzfgrep\fP је алијас за \fBxzgrep \-F\fP. +.PP +Наредбе \fBlzgrep\fP, \fBlzegrep\fP и \fBlzfgrep\fP се достављају зарад назадне +сагласности са LZMA Utils. Застареле су и биће уклоњене у будућем издању. +. +.SH "СТАЊЕ ИЗЛАЗА" +.TP +0 +Најмање једно поклапање је пронађено из барем једне од улазних датотека. +Није било грешака. +.TP +1 +Никаква поклапања нису пронађена ни из једне од улазних датотека. Није дошло +до грешака. +.TP +>1 +Дошло је до једне или више грешака. Није познато да ли су поклапања нађена. +. +.SH ОКРУЖЕЊЕ +.TP +\fBGREP\fP +Ако је \fBGREP\fP постављено на не\-празну вредност, користи се уместо \fBgrep\fP, +\fBgrep \-E\fP или \fBgrep \-F\fP. +. +.SH "ВИДИТЕ ТАКОЂЕ" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xzless.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xzless.1 new file mode 100644 index 0000000000000000000000000000000000000000..af9fd3a0e92153e5cc2db427e2cbf48088bbb682 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xzless.1 @@ -0,0 +1,47 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" Serbian translation of xz-man. +.\" Мирослав Николић , 2025. +.\" +.\" (Note that this file is not based on gzip's zless.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZLESS 1 06.03.2025. Tukaani "XZ Utils" +.SH НАЗИВ +xzless, lzless – приказује „xz“ или „lzma“ запаковане (текстуалне) датотеке +.SH САЖЕТАК +\fBxzless\fP [\fIдатотека\fP...] +.br +\fBlzless\fP [\fIдатотека\fP...] (ЗАСТАРЕЛО) +.SH ОПИС +\fBxzless\fP је филтер који приказује текст из запакованих датотека у +терминалу. Датотеке које подржава \fBxz\fP(1) се распакују; остале датотеке се +већ подразумева да су у незапакованом облику. Ако није дата ни једна +\fIдатотека\fP, \fBxzless\fP чита са стандардног улаза. +.PP +\fBxzless\fP користи \fBless\fP(1) да представи свој излаз. За разлику од +\fBxzmore\fP, његов избор страничара се не може изменити постављањем променљиве +окружења. Наредбе се заснивају и на \fBmore\fP(1) и на \fBvi\fP(1) и дозвољавају +померање и претрагу назад и напред. Видите упутство \fBless\fP(1) за више +информација. +.PP +Наредба \fBlzless\fP се доставља зарад назадне сагласности са LZMA +Utils. Застарела је и биће уклоњена у будућем издању. +.SH ОКРУЖЕЊЕ +.TP +\fBLESSMETACHARS\fP +Списак знакова нарочитих за шкољку. Поставите са \fBxzless\fP осим ако већ +није постављено у окружењу. +.TP +\fBLESSOPEN\fP +Поставља да линија наредби призове \fBxz\fP(1) распакивач за предобраду улазних +датотека на \fBless\fP(1). +.SH "ВИДИТЕ ТАКОЂЕ" +\fBless\fP(1), \fBxz\fP(1), \fBxzmore\fP(1), \fBzless\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xzmore.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xzmore.1 new file mode 100644 index 0000000000000000000000000000000000000000..23df9c6cf0402b3ebdac9949ee6d40bcb9db6045 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sr/man1/xzmore.1 @@ -0,0 +1,49 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" Serbian translation of xz-man. +.\" Мирослав Николић , 2025. +.\" +.\" (Note that this file is based on xzless.1 instead of gzip's zmore.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZMORE 1 06.03.2025. Tukaani "XZ Utils" +.SH НАЗИВ +xzmore, lzmore – приказује „xz“ или „lzma“ запаковане (текстуалне) датотеке +. +.SH САЖЕТАК +\fBxzmore\fP [\fIдатотека\fP...] +.br +\fBlzmore\fP [\fIдатотека\fP...] (ЗАСТАРЕЛО) +. +.SH ОПИС +\fBxzmore\fP приказује текст из запакованих датотека у терминалу користећи +\fBmore\fP(1). Датотеке које подржава \fBxz\fP(1) се распакују; остале датотеке +се подразумева да су већ у незапакованом облику. Ако није дата ни једна +\fIдатотека\fP, \fBxzmore\fP чита са стандардног улаза. Видите упутство +\fBmore\fP(1) за више информација. +.PP +Знајте да клизање уназад можда неће бити могуће у зависности од примене +\fBmore\fP(1). Ово је зато што \fBxzmore\fP користи спојку за прослеђивање +распакованих података ка \fBmore\fP(1). \fBxzless\fP(1) користи \fBless\fP(1) које +обезбеђује напреднијим функцијама. +.PP +Наредба \fBlzmore\fP се доставља зарад назадне сагласности са LZMA +Utils. Застарела је и биће уклоњена у будућем издању. +. +.SH ОКРУЖЕЊЕ +.TP +.\" TRANSLATORS: Don't translate the uppercase PAGER. +.\" It is a name of an environment variable. +\fBPAGER\fP +Ако је \fBPAGER\fP постављено, његова вредност се користи као страничар уместо +\fBmore\fP(1). +. +.SH "ВИДИТЕ ТАКОЂЕ" +\fBmore\fP(1), \fBxz\fP(1), \fBxzless\fP(1), \fBzmore\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzcat.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzcat.1 new file mode 100644 index 0000000000000000000000000000000000000000..1fb596e1ab328783990b87c362f7f7761d73548e --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzcat.1 @@ -0,0 +1,1954 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Swedish translation of xz-man +.\" Göran Uddeborg , 2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 2025\-03\-08 Tukaani "XZ Utils" +. +.SH NAMN +xz, unxz, xzcat, lzma, unlzma, lzcat — Komprimera eller dekomprimera .xz\- +och .lzma\-filer +. +.SH SYNOPSIS +\fBxz\fP [\fIflagga…\fP] [\fIfil…\fP] +. +.SH KOMMANDOALIAS +\fBunxz\fP är ekvivalent med \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP är ekvivalent med \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP är ekvivalent med \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP är ekvivalent med \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP är ekvivalent med \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +När man skriver skript som behöver dekomprimera filer rekommenderas det att +altid använda namnet \fBxz\fP mäd lämpliga argument (\fBxz \-d\fP eller \fBxz \-dc\fP) +istället för namnen \fBunxz\fP och \fBxzcat\fP. +. +.SH BESKRIVNING +\fBxz\fP är ett datakomprimeringsverktyg för allmänt bruk med en +kommandoradssyntax som liknar \fBgzip\fP(1) och \fBbzip2\fP(1). Det egna +filformatet är formatet \fB.xz\fP, men det föråldrade formatet \fB.lzma\fP som +anändes av LZMA\-verktyg och råa komprimerade strömmar utan huvuden för +behållarformatet stödjs också. Dessutom stödjs dekomprimering av formatet +\&\fB.lz\fP som används av \fBlzip\fP. +.PP +\fBxz\fP komprimerar och dekomprimerar varje \fIfil\fP i enlighet med det valda +arbetsläget. Om inga \fIfiler\fP anges eller \fIfil\fP är \fB\-\fP läser \fBxz\fP från +standard in och skriver den behandade datan på standard ut. \fBxz\fP kommer +vägra (visa ett felmeddelande och hoppa över \fIfilen\fP) att skriva +komprimerad data direkt till standard ut om det är en terminal. På samma +sätt kommer \fBxz\fP vägra att läsa komprimerade data från standard in om det +är en terminal. +.PP +Om inte \fB\-\-stdout\fP anges skrivs andra \fIfiler\fP än \fB\-\fP till en ny fil vars +namn härleds från käll\fIfilens\fP namn: +.IP \(bu 3 +Vid kompringering läggs suffixet till på målfilsformatet (\fB.xz\fP eller +\&\fB.lzma\fP) på slutet av källfilnamnet för att få målfilnamnet. +.IP \(bu 3 +Vid dekomprimering tas suffixet \fB.xz\fP, \fB.lzma\fP eller \fB.lz\fP bort från +filnamnet för att få målfilnamnet. \fBxz\fP känner även igen suffixen \fB.txz\fP +och \fB.tlz\fP, och ersätter dem med suffixet \fB.tar\fP. +.PP +Om målfilen redan finns visas ett felmeddelande och \fIfilen\fP hoppas över. +.PP +Utom när den skriver till standard ut kommer \fBxz\fP visa en varning och hoppa +över \fIfilen\fP om något av följande inträffar: +.IP \(bu 3 +\fIFil\fP är inte en vanlig fil. Symboliska länkar följs inte, och därför anses +de inte vara vanliga filer. +.IP \(bu 3 +\fIFil\fP har mer än en hård länk. +.IP \(bu 3 +\fIFil\fP har biten setuid, setgid eller sticky satt. +.IP \(bu 3 +Arbetsläget är satt till att komprimera och \fIfilen\fP har redan ett suffix +enligt målfilformatet (\fB.xz\fP eller \fB.txz\fP vid komprimering till formatet +\&\fB.xz\fP, och \fB.lzma\fP eller \fB.tlz\fP vid komprimering till formatet \fB.lzma\fP). +.IP \(bu 3 +Arbetsläget är satt till att dekomprimera och \fIfilen\fP har inte ett suffix +enligt något av de stödda filformaten (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP +eller \fB.lz\fP). +.PP +Efter att ha kunnat komprimera eller dekomprimera \fIfilen\fP kopierar \fBxz\fP +ägaren, gruppen, rättigheterna, åtkomsttiden och ändringstiden från +käll\fIfilen\fP till målfilen. Om kopieringen av grupp misslyckas ändras +rättigheterna så att målfilen inte blir åtkomlig för användare som inte har +rättigheter att komma åt käll\fIfilen\fP. \fBxz\fP stödjer inte kopiering av annan +metadata såsom åtkomststyrhingslistor eller utökade attribut ännu. +.PP +När målfilen har stängts framgångsrikt tas käll\fIfilen\fP bort såvida inte +\fB\-\-keep\fP angavs. Käll\fIfilen\fP tas aldrig bort om utdata skrevs till +standard ut eller om något fel inträffade. +.PP +Att skicka \fBSIGINFO\fP eller \fBSIGUSR1\fP till \fBxz\fP\-processen får den att +skriva ut förloppsinformation till standard fel. Detta är bara av begränsat +värde eftersom när standard fel går till en terminal så kommer användning av +\fB\-\-verbose\fP att skriva ut en automatiskt uppdaterande förloppsindikator. +. +.SS Minnesanvändning +\fBxz\fP:s minnesanvändning varierar från några få hundra kilobyte till flera +gigabyte beroende på komprimeringsinställningarna. Inställningen som +användes när en fil komprimerades avgör minnesbehovet hos +dekomprimeraren. Typiskt behöver dekomprimeraren 5\ % till 20\ % av +minnesbehovet som komprimeraren behöver när en fil skapas. Till exempel, att +dekomprimera en fil skapad med \fBxz \-9\fP kräver för närvarande 65\ MiB +minne. Ändå är det möjligt att ha \fB.xz\fP\-filer som behöver flera gigabyte +minne för att dekomprimeras. +.PP +Särskilt användare av äldre system kan finna möjligheten av väldigt stor +minnesanvändning störande. För att förhindra obehagliga överraskningar har +\fBxz\fP en inbyggd minnesanvändningsbegränsare, vilken är avaktiverad som +standard. Även om vissa operativsystem kan tillhandahålla möjligheter att +begränsa minnesanvändningen hos processer bedömdes det inte som flexibelt +nog att lita på det (till exempel, att använda \fBulimit\fP(1) för att begränsa +det virtuella minnet tenderar att hämma \fBmmap\fP(2). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Minnesanvändningsbegränsaren kan aktiveras med kommandoradsflaggan +\fB\-\-memlimit=\fP\fIgräns\fP. Ofta är det bekvämare att aktivera begränsaren som +standard genom att sätta miljövariabeln \fBXZ_DEFAULTS\fP, till exempel, +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Det är möjligt att sätta gränser separat +för komprimering och dekomprimering genom att använda +\fB\-\-memlimit\-compress=\fP\fIlimit\fP och \fB\-\-memlimit\-decompress=\fP\fIlimit\fP. Att +använda dessa två flaggor utanför \fBXZ_DEFAULTS\fP är sällan meningsfullt +eftersom en enskild körning av \fBxz\fP inte kan göra både komprimering och +dekomprimering och and \fB\-\-memlimit=\fP\fIgräns\fP (eller \fB\-M\fP \fIgräns\fP) är +kortare att skriva på kommandoraden. +.PP +Om den angivna minnesanvändningsgränsen överskrid vid dekomprimering kommer +\fBxz\fP visa ett fel och dekomprimeringen av filen misslyckas. Om gröensen +överskrids vid komprimering kommer \fBxz\fP försöka skala ner inställningen så +att gränsen inte längre överskrids (utom när \fB\-\-format=raw\fP eller +\fB\-\-no\-adjust\fP används). På detta sätt kommer åtgärden inte misslyckas om +inte gränsen är väldigt liten. Skalningen av inställningen görs i steg som +inte matchar de förinställda komprimeringsnivåerna, till exempel, om gränsen +endast är något mindre än den mängd som behövs till \fBxz \-9\fP kommer +inställningen bara skalas ner lite, inte hela vägen ner till \fBxz \-8\fP. +. +.SS "Konkatenering och utfyllnad av .xz\-filer" +Det är möjligt att konkatenera \fB.xz\fP\-filer som de är. \fBxz\fP kommer +dekomprimera sådana filer som om de vore en enda \fB.xz\fP\-fil. +.PP +Det är möjligt att infoga utfyllnad mellan de konkatenerade delarna eller +efter den sista delen. Utfyllnaden måste bestå av null\-bytear och storleken +på utfyllnaden måste vara en multipel av fyra byte. Detta kan vara +användbart, till exempel, om \fB.xz\fP\-filen lagras på ett medium som mäter +filstorlekar i 512\-byteblock. +.PP +Konkaternering och utfyllnad är inte tillåtet med \fB.lzma\fP\-filer eller råa +strömmar. +. +.SH FLAGGOR +. +.SS "Heltalssuffix och speciella värden" +På de flesta platser där ett heltalsargument förväntas stödjs ett frivilligt +suffix för att enkelt indikera stora heltal. Det får inte finnas något +mellanrumm mellan heltalet och suffixet. +.TP +\fBKiB\fP +Multiplicera heltalet med 1 024 (2¹⁰). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP och \fBKB\fP är +tillåtna som synomymer till \fBKiB\fP. +.TP +\fBMiB\fP +Multiplicera heltalet med 1 048 576 (2²⁰). \fBMi\fP, \fBm\fP, \fBM\fP och \fBMB\fP är +tillåtna som synomymer till \fBMiB\fP. +.TP +\fBGiB\fP +Multiplicera heltalet med 1 073 741 824 (2³⁰). \fBGi\fP, \fBg\fP, \fBG\fP och \fBGB\fP +är tillåtna som synonymer till \fBGiB\fP. +.PP +Specialvärdet \fBmax\fP kan användas för att indikera det maximala heltalet som +stödjs av flaggan. +. +.SS Arbetsläge +Om flera arbetslägesflaggor ges gäller den sista. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Komprimera. Detta är standardarbetsläget när ingen arbetslägesflagga anges +och inget annat arbetsläge impliceras från kommandonamnet (till exempel +implicerar \fBunxz\fP \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Efter lyckad komprimering källfilen bort såvida man inte skriver till +standard ut eller \fB\-\-keep\fP angavs. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Dekomprimera. Efter lyckad dekomprimering tas källfilen bort såvida man inte +skriver till standard ut eller \fB\-\-keep\fP angavs. +.TP +\fB\-t\fP, \fB\-\-test\fP +Testa integriteten hos komprimerade \fIfiler\fP. Denna flagga är ekvivalent med +\fB\-\-decompress \-\-stdout\fP förutom att den dekomprimerade datan slängs +istället för att skrivas på standard ut. Inga filer skapas eller tas bort. +.TP +\fB\-l\fP, \fB\-\-list\fP +Skriv information om komprimerade \fIfiler\fP. Inge dekomprimeringsutdata +skapas, och inga filer skapas eller tas bort. I listläge kan programmet inte +läsa komprimerad data från standard in eller från andra källor där man inte +kan söka. +.IP "" +Standardlistningen visar grundläggande information om \fIfiler\fP, en fil per +rad. För att få mer detaljerad information, använd även flaggan +\fB\-\-verbose\fP. För ännu mer information, använd \fB\-\-verbose\fP två gånger, men +observera att detta kan vara långsamt, eftersom det behövs många sökningar +får att samla all den extra informationen. Bredden av utförlig utdata +överskrider 80 tecken, så att skicka utdata i ett rör till, till exempel, +\fBless\ \-S\fP kan vara bekvämt om terminalen inte är bred nog. +.IP "" +Den exakta utdatan kan variera mellan versioner av \fBxz\fP och olika +lokaler. För maskinläsbar utdata bör \fB\-\-robot \-\-list\fP användas. +. +.SS Arbetsmodifierare +.TP +\fB\-k\fP, \fB\-\-keep\fP +Ta inte bort indatafilerna. +.IP "" +Från \fBxz\fP 5.2.6 gör denna flagga även att \fBxz\fP komprimerar eller +dekomprimerar även om indatan är en symbolisk länk till en normal fil, har +mer än en hård länk eller har biten setuid, setgid eller sticky +satt. Bitarna setuid, setgid och sticky kopieras inte till målfilen. I +tidigare versioner gjordes detta bara med \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Denna flagga har flera funktioner: +.RS +.IP \(bu 3 +Om målfilen redan finns, radera den före komprimering eller dekomprimering. +.IP \(bu 3 +Komprimera eller dekomprimera även om indatan är en symbolisk länk till en +normal fil, har mer än en hård länk eller har biten setuid, setgid eller +sticky satt. Bitarna setuid, setgid och sticky kopieras inte till målfilen. +.IP \(bu 3 +När den används med \fB\-\-decompress\fP \fB\-\-stdout\fP och \fBxz\fP inte känner igen +typen på källfilen, kopiera källfilen som den är till standard ut. Detta gör +att \fBxzcat\fP \fB\-\-force\fP kan användas som \fBcat\fP(1) för filer som inte har +komprimerats med \fBxz\fP. Observera att i framtiden kan \fBxz\fP komma att stödja +nya komprimeringsfilformat, vilket kan få \fBxz\fP att dekomprimera fler typer +av filer istället för att kopiera dem till standard ut. +\fB\-\-format=\fP\fIformat\fP kan användas för att begränsa \fBxz\fP till att +dekomprimera endast ett enda filformat. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Skriv den komprimerade eller dekomprimerade datan till standard ut istället +för en fil. Detta implicerar \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Dekomprimera endast den första \fB.xz\fP\-strömmen, och ignorera tys eventuella +återstående indata som följer efter strömmen. Normalt får sådant avslutande +skräp \fBxz\fP att visa ett fel. +.IP "" +\fBxz\fP dekomprimerar aldrig mer än en ström från \fB.lzma\fP\-filer eller råa +strömmar, men denna flagga gör ändå att \fBxz\fP ignorerar den möjliga +efterföljande datan efter \fB.lzma\fP\-filen eller den råa strömmen. +.IP "" +Denna flagga har ingen effekt om arbetsläget inte är \fB\-\-decompress\fP eller +\fB\-\-test\fP. +.IP "" +Sedan \fBxz\fP 5.7.1alpha, implicerar \fB\-\-single\-stream\fP \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Avaktivera att glesa filer skapas. Som standard, om den dekomprimerar till +en normal fil, försöker \fBxz\fP att göra filen gles om den dekomprimerade +datan innehåller långa sekvenser av binära nollor. Det fungerar även när den +skriver till standard ut så länga standard ut är kopplad till en normal fil +och vissa ytterligare villkor möts för att göra det säkert. Att skapa glesa +filer kan spara diskutrymme och snabba upp dekomprimeringen genom att +begränsa mängden disk\-I/O. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Vid komprimering, använd \fI.suf\fP som suffixet för målfilen istället för +\&\fB.xz\fP eller \fB.lzma\fP. Om den inte skriver till standard ut och källfilen +redan har suffixet \fI.suf\fP visas en varning och filen hoppas över. +.IP "" +Vid dekomprimering, känn igen filer med suffixet \fI.suf\fP utöver filer +medsuffixen \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP eller \fB.lz\fP. Om källfilen +har suffixet \fI.suf\fP tas suffixet bort för att få målfilnamnet. +.IP "" +Vid komprimering eller dekomprimering av råa strömmar (\fB\-\-format=raw\fP) +måste alltid suffixet anges om den inte skriver till standard ut, eftersom +det inte finns något standardsuffix för råa strömmar. +.TP +\fB\-\-files\fP[\fB=\fP\fIfil\fP] +Läs filnamnen att arbeta på från \fIfil\fP; om \fIfil\fP utelämnas läses filnamn +från standard in. Filnamn måste avslutas med nyradstecknet. Ett bindestreck +(\fB\-\fP) tas som ett vanligt filnamn; det betyder inte standard in. Om filnamn +även anges som kommandoradsargument, bearbetas de före filnamnen som läses +från \fIfil\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIfil\fP] +Detta är identiskt med \fB\-\-files\fP[\fB=\fP\fIfil\fP] förjutom att varje filnamn +måste avslutas med ett nulltecken. +. +.SS "Grundläggande flaggor för filformat och komprimering" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fIformat\fP +Angi filens \fIformat\fP att komprimera eller dekomprimera: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Detta är standard. Vid komprimering är \fBauto\fP ekvivalent med \fBxz\fP. Vid +dekomprimering detekteras automatiskt formatet på indatafilen. Observera att +råa strömmar (skapade med \fB\-\-format=raw\fP inte kan detekteras automatiskt. +.TP +\fBxz\fP +Komprimera till filformatet \fB.xz\fP, eller acceptera endast \fB.xz\fP\-filer vid +dekomprimering. +.TP +\fBlzma\fP, \fBalone\fP +Komprimera till det föråldrade filformatet \fB.lzma\fP, eller acceptera endast +\&\fB.lzma\fP\-filer fid dekomprimering. Det alternativa namnet \fBalone\fP +tillhandahålls för bakåtkompatibilitet med LZMA Utils. +.TP +\fBlzip\fP +Acceptera endast \fB.lz\fP\-filer vid dekomprimering. Komprimering stödjs inte. +.IP "" +\&\fB.lz\fP\-formatet version 0 och 1 stödjs. Version 0\-filer producerades av +\fBlzip\fP 1.3 och tidigare. Sådana filer är inte vanliga men kan hittas från +filarkiv eftersom några källpaket släpptes i detta format. Folk kan ha även +ha gamla personliga filer i detta format. Dekomprimeringsstöd för format +version 0 togs bort i \fBlzip\fP 1.18. \fBlzip\fP 1.4 och senare kan skapa filer i +formatversion 1. +.TP +\fBraw\fP +Komprimera eller dekomprimera en rå ström (inga huvuden). Detta är endast +avsett för avancerade användare. För att avkoda råa strömmar behöver man +använda \fB\-\-format=raw\fP och explicit angi filterkedjan, vilken normalt +skulle ha lagrats i behållarens huvuden. +.RE +.TP +\fB\-C\fP \fIkontroll\fP, \fB\-\-check=\fP\fIkontroll\fP +Ange typen av integritetskontroll. Kontrollen beräknas från den +dekomprimerade datan och lagras i \fB.xz\fP\-filen. Denna flagga har endast +någon inverkan när man komprimerar till formatet \fB.xz\fP; formatet \fB.lzma\fP +stödjer inte integritetskontroller. Integritetskontrollen (om någon) +verifieras när \fB.xz\fP\-filen dekomprimeras. +.IP "" +\fIKontroll\fPtyper som stödjs: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Beräkna inte någon integritetskontroll alls. Detta är normalt en dålig +idé. Det kan vara användbart när datans integritet ändå verifieras på andra +sätt. +.TP +\fBcrc32\fP +Beräkna CRC32 med polynomet från IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Beräkna CRC64 med polynomet från ECMA\-182. Detta är standard, eftersom det +är något bättre än CRC32 på att upptäcka skadade filer och +hastighetsskillnaden är försumbar. +.TP +\fBsha256\fP +Beräkna SHA\-256. Detta är något långsammare än CRC32 och CRC64. +.RE +.IP "" +Integriteten hos \fB.xz\fP\-huvuden verifieras alltid med CRC32. Det är inte +möjligt att ändra eller avaktivera det. +.TP +\fB\-\-ignore\-check\fP +Verifiera inte integritetskontrollen av den komprimerade datan vid +dekomprimering. CRC32\-värden i \fB.xz\fP\-huvudena kommer fortfarande verifieras +normalt +.IP "" +\fBAnvänd inte denna flagga om du inte vet vad du gör.\fP Möjliga anledningar +till att använda denna flagga: +.RS +.IP \(bu 3 +Försöka återvinna data från en trasig .xz\-fil. +.IP \(bu 3 +Snabba upp dekomprimering. Detta har störst betydelse med SHA\-256 eller med +filer som har komprimerats extremt mycket. Det rekommenderas att inte +använda denna flagga för detta ändamål om inte filintegriteten verifieras +externt på något annat sätt. +.RE +.TP +\fB\-0\fP … \fB\-9\fP +Välj en förinställningsnivå för komprimering. Standard är \fB\-6\fP. Om flera +förinställningsnivåer anges gäller den sist angivna. Om en anpassad +fileterkedja redan angivits gör en inställning av en förinställningsnivå för +komprimering att den anpassade filterkedjan töms. +.IP "" +Skillnaden mellan förinställningarna har större betydelse än med \fBgzip\fP(1) +och \fBbzip2\fP(1). Den valda komprimeringsinställningen avgör minneskraven för +dekomprimeraren, att använda en för hög förinställningsnivå kan alltså göra +det plågsamt att dekomprimera filer på ett gammalt system med lite +RAM. Specifikt \fBär det inte en bra ide att blint använda \-9 för allt\fP +liksom det ofta är med \fBgzip\fP(1) och \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP … \fB\-3\fP +Dessa är ganska snabba förinställningar. \fB\-0\fP är ibland snabbare än \fBgzip \-9\fP samtidigt som komprimeringen är mycket bättre. De högre har ofta +hastighet jämförbar med \fBbzip2\fP(1) med jämförbar eller bättre +komprimeringsförhållande, även om resultatet mycket beror på typen av data +som komprimeras. +.TP +\fB\-4\fP … \fB\-6\fP +Bra för väldigt god komprimering samtidigt som dekomprimerarens +minnesanvändning hålls rimlig även på gamla system. \fB\-6\fP är standardvärdet, +vilket vanligen är ett bra val för att distribuera filer so behöver +dekomprimeras även på ssytem med endast 16\ MiB RAM. (\fB\-5e\fP eller \fB\-6e\fP +kan också vara värda att överväga. Se \fB\-\-extreme\fP.) +.TP +\fB\-7 … \-9\fP +Dessa liknar \fB\-6\fP med med högre krav på minne till komprimerare och +dekomprimerare. Dessa är bara användbara vid komprimering av filer större än +8\ MiB, 16\ MiB respektive 32\ MiB. +.RE +.IP "" +På samma hårdvara är dekomprimeringshastigheten ungefär ett konstant antal +byt av komprimerad data per sekund. Med andra ord, ju bättre komprimering, +desto snabbare kommer dekomprimeringen vanligen vara. Detta betyder även att +mängden av okomprimerad utdata skapad per sekund kan variera mycket. +.IP "" +Följande tabell sammanfattar funktionerna hos förinställningarna: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Förinställning;LexStrl;KompCPU;KompMin;DekMin +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Kolumnbeskrivningar: +.RS +.IP \(bu 3 +LexStrl är storleken på LZMA2:s lexikon. Det är slöseri med minne att +använda ett större lexikon än storleken på den okomprimerade filen. Detta är +anledningen till att det är bra att undvika förinställningarna \fB\-7\fP … \fB\-9\fP +när det inte finns något verkligt behov av dem. På \fB\-6\fP och lägre är +mängden bortslösat minne vanligen litet nog att inte ha någon betydelse. +.IP \(bu 3 +KompCPU är en förenklad representation av LZMA2\-inställningar som påverkar +komprimeringshastigheten. Lexikonstorleken påverkar också hastigheten, så +medan KompCPU är samma för nivåerna \fB\-6\fP … \fB\-9\fP tenderar fortfarande högre +nivåer att vara lite långsmmare. För ännu långsammare och möjligen bättre +komprimering, se \fB\-\-extreme\fP. +.IP \(bu 3 +KompMem innehåller komprimerarens minneskrav i enkeltrådat läge. Det kan +variera något mellan versioner av \fBxz\fP. +.IP \(bu 3 +DekMin innehåller dekomprimerarens minneskrav. Det vill säga, komprimerarens +inställningar avgör minneskravet för dekomprimeraren. Den exakta +minnesanvändningen hos dekomprimeraren är något mer än +LZMA2\-lexikonstorleken, men värdena i tabellen har avrundats upp till nästa +nästa hela MiB. +.RE +.IP "" +Minneskravet för det multitrådade läget är signifikant högre än det för +enkeltrådat läge. Med standardvärdet på \fB\-\-block\-size\fP behöver varje tråd +3·3·LexStrl plus KompMin eller DekMin. Till exempel, fyra trådar med +förinställningen behöver 660\(en670 MiB minne. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Använd en långsammare variant av den valda förinställningsnivån för +komprimering (\fB\-0\fP … \fB\-9\fP) för att förhoppningsvis få lite bättre +komprimeringsförhållande, men med otur kan detta även göra det +sämre. Dekomprimerarens minnesanvändning påverkas inte, men komprimerarens +minnesanvändning ökar lite vid förinställningsnivåerna \fB\-0\fP … \fB\-3\fP. +.IP "" +Eftersom det finns två förinställningar med lexikonstorlekar 4\ MiB och 8\ MiB använder förinställningarna \fB\-3e\fP och \fB\-5e\fP något snabbare +inställningar (lägre KompCPU) än \fB\-4e\fP respektive \fB\-6e\fP. På det sättet är +inte två förinställningar identiska. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Förinställning;LexStrl;KompCPU;KompMin;DekMin +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Till exempel finns det totalt fyra förinställningar som använder 8\ MiB +lexikon, vars ordning från den snabbaste till den långsammaste är \fB\-5\fP, +\fB\-6\fP, \fB\-5e\fP och \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Dessa är något missledande alias för \fB\-0\fP respektive \fB\-9\fP. Dessa finns +endast för bakåtkompatibilitet med LZMA\-verktyg. Undvik att använda dessa +flaggor. +.TP +\fB\-\-block\-size=\fP\fIstorlek\fP +Vid komprimering till formatet \fB.xz\fP, dela indatai block med \fIstorlek\fP +bytes. Blocken komprimeras oberoende av varandra, vilket hjälper till vid +multitrådning och gör begränsad random\-access\-dekomprimering möjlig. Denna +flagga används typiskt för att åsidosätta blockstorleken i multitrådat läge, +men denna flagga kan användas även i enkeltrådat läge. +.IP "" +I multitrådat läge kommer ungefär tre gånger \fIstorlek\fP byte att allokeras i +varje tråd för buffring av indata och utdata. Standardvärdet på \fIstorlek\fP +är det större av tre gånger LZMA2\-lexikonstorleken eller 1 MiB. Typiskt är +ett bra värde 2\(en4 gånger storleken på LZMA2\-lexikonet eller åtminstone 1 +MiB. Att använda en \fIstorlek\fP mindre än LZMA2\-lexikonstorleken utgör +slöseri med RAM eftersom LZMA2\-lexikonbufferten då aldrig kommer användas +helt. I multitrådat läge lagras storlekarna på plocken i +blockhuvudena. Denna storleksinformation krävs för multitrådad +dekomprimering. +.IP "" +I singletrådat läge görs som standard ingen uppdelning i block. Att göra +denna inställning påverark inte minnesanvändningen. Ingen +storleksinformation lagras i blockhuvuden, därmed kommer filer som skapas i +enkeltrådat läge inte att vara identiska med filer skapade i multitrådat +läge. Avsaknaden av sotrleksinformation betyder också att \fBxz\fP inte kommer +kunna dekomprimera filerna i multitrådat läge. +.TP +\fB\-\-block\-list=\fP\fIposter\fP +Vid komprimering till formatet \fB.xz\fP, börja ett nytt block med en möjlig +anpassad filterkedja efter de angivna intervallen med okomprimerade data. +.IP "" +\fIPosterna\fP är en kommaseparerad lista. Varje post består av ett möjligt +filterkedjenummer mellan 0 och 9 följt av ett kolon (\fB:\fP) och en +obligatorisk storlek för okomprimerade data. Att utelämna en post (två på +varandra följande komman) är en kortform för att använda storleken och +filtren från föregående post. +.IP "" +Om indatafiler är större än summan av storlekarna i \fIposter\fP repeteras den +sista posten fram till slutet på filen. Ett speciellt värde \fB0\fP kan +användas som den sista storleken för att indikera att resten av filen skall +kodas som ett enda block. +.IP "" +En alternativ filterkedja för varje block kan anges i kombinaton med +flaggorna \fB\-\-filters1=\fP\fIfilter\fP \&…\& \fB\-\-filters9=\fP\fIfilter\fP. Dessa +flaggor definierar filterkedjor med en identifierare mellan +1\(en9. Filterkedja 0 kan användas för att referera till +standardfilterkedjan, vilket är samma sak som att inte ange någon +filterkedja. Filterkedjeidentifierare kan användas före den okomprimerade +sotrleken, följt av ett kolon (\fB:\fP). Till exempel, om man anger +\fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP kommer block skapas med: +.RS +.IP \(bu 3 +Filterkedjan angiven av \fB\-\-filters1\fP och 2 MiB indata +.IP \(bu 3 +Filterkedjan angiven av \fB\-\-filters3\fP och 2 MiB indata +.IP \(bu 3 +Filterkedjan angiven av \fB\-\-filters2\fP och 4 MiB indata +.IP \(bu 3 +Filterkedjan angiven av \fB\-\-filters2\fP och 4 MiB indata +.IP \(bu 3 +Standardfilterkedjan och 2 MiB indata +.IP \(bu 3 +Standardfilterkedjan och 4 MiB indata för varje block till slutet av indata. +.RE +.IP "" +Om man anger en storlek som överskrider kodarens blockstorlek (antingen +standardvärdet i trådat läge eller värdet som anges med +\fB\-\-block\-size=\fP\fIstorlek\fP) kommer kodaren skapa ytterligare block med +hänsyn taget till gränserna som anges i \fIposter\fP. Till exempel, om man +anger \fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP och +indatafilen är 80 MiB kommer man få 11 block: 5, 10, 8, 10, 2, 10, 10, 4, +10, 10 och 1 MiB. +.IP "" +I multitrådat läge lagras storleken på blocken i blockhuvudena. Detta görs +inte i enkeltrådat läge, så den kodade utdatan kommer inte vara identisk med +den från det multitrådade läget. +.TP +\fB\-\-flush\-timeout=\fP\fItidsgräns\fP +Vid komprimering, om mer än \fItidsgräns\fP millisekunder (ett positivt heltal) +har gått sedan den föregånde tömningen och en läsning av mer indata skulle +blockera töms all väntande indata från kodaren och görs tillgänglig i +utdataströmmen. Detta kan vara användbart om \fBxz\fP används för att +komprimera data som strömmas över ett nätverk. Små värden på \fItidsgräns\fP +gör data tillgänglig vid den mottagande änden med en liten fördröjning, men +större värden på \fItidsgräns\fP ger bättre komprimeringsförhållande. +.IP "" +Denna funktion är avaktiverad som standard. Om denna flagga anges mer än en +gång gäller den sista. Dett speciella värdet \fB0\fP på \fItidsgräns\fP kan +användas för att uttryckligen avaktivera denna funktion. +.IP "" +Denna funktion är inte tillgänglig på icke\-POSIX\-system. +.IP "" +.\" FIXME +\fBDenna funktion är fortfarande experimentell.\fP För närvarande är \fBxz\fP +olämplig för dekomprimering av strömmen i realtid på grund av hur \fBxz\fP +buffrar. +.TP +\fB\-\-no\-sync\fP +Synkronisera inte målfilen och dess katalog med lagringsenheten före +källfilen tas bort. Detta kan förbättra prestanda vid komprimering eller +dekomprimering av många små filer. Dock, om systemet kraschar snart efter +raderingen är det möjligt att målfilen inte skrevs till lagringsenheten men +att raderingen gjordes det. I det fallet är varken originalkällfilen eller +målfilen tillgänglig. +.IP "" +Denna flagga har bara någon effekt när \fBxz\fP kommer att ta bort källfilen. I +andra fall görs aldrig någon synkronisering. +.IP "" +Synkroniseringen och \fB\-\-no\-sync\fP lades till i \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIgräns\fP +Sätt en gräns på minnesanvändningen för komprimeringen. Om denna flaggan +anges flera gånger gäller den sista. +.IP "" +Om komprimeringsinställnigarna överskrider \fIgränsen\fP kommer \fBxz\fP försöka +justera inställningarna neråt så att gränsen inte längre överskrids och visa +en notis om att en automatisk justering gjorts. Justeringen görs i denna +ordning: reducera antalet trådar, byta till enkeltrådat läge om även en tråd +i multitrådat läge överskrider \fIgränsen\fP och slutligen reducera +LZMA2\-lexikonstorleken. +.IP "" +Vid komprimering med \fB\-\-format=raw\fP eller om \fB\-\-no\-adjust\fP har angetts kan +endast antalet trådar reduceras eftersom det kan göras utan att påverka den +komprimerade utdatan. +.IP "" +Om \fIgränsen\fP inte kan uppfyllas ens med justeringarna som beskrivs ovan +visas ett felmeddelande och \fBxz\fP kommer avsluta med slutstatus 1. +.IP "" +\fIGränsen\fP kan anges på flera sätt: +.RS +.IP \(bu 3 +\fIGränsen\fP kan vara ett absolut värde i byte. Att använda ett heltalssuffix +som \fBMiB\fP kan vara praktiskt. Exempel: \fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +\fIGränsen\fP kan anges som en procentsats av det totala fysiska minnet +(RAM). Detta kan vara användbart särskilt när man sätter miljövariabeln +\fBXZ_DEFAULTS\fP i ett skalinitieringsskript som delas mellan olika +datorer. På det sättet är gränsen automatiskt större på system med mer +minne. Exempel: \fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +\fIGränsen\fP kan återställas tillbaka till sitt standardvärde genom att sätta +den till \fB0\fP. Detta är för närvarande ekvivalent med att sätta \fIgränsen\fP +till \fBmax\fP (ingen gräns på minnesanvändning). +.RE +.IP "" +För 32\-bitars \fBxz\fP finns det ett specialfall: om \fIgränsen\fP skulle vara +över \fB4020\ MiB\fP sätts \fIgränsen\fP till \fB4020\ MiB\fP. På MIPS32 används +\fB2000\ MiB\fP istället. (Värdena \fB0\fP och \fBmax\fP påverkas inte av detta. En +liknande funktion finns inte för dekomprimering.) Detta kan hjälpa till när +ett 32\-bitarsprogram har tillgång till 4\ GiB adressrymd (2 GiB på MIPS32) +förhoppningsvis utan att göra någon skada i andra situationer. +.IP "" +Se även avsnittet \fBMinnesanvändning\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIgräns\fP +Sätt en gräns för minnesanvnändningen vid dekomprimering. Detta påverkar +även läget \fB\-\-list\fP. Om åtgärden inte är möjlig utan att överskrida +\fIgränsen\fP kommer \fBxz\fP visa ett felmeddelande och dekomprimeringen av filen +kommer misslyckas. Se \fB\-\-memlimit\-compress=\fP\fIgräns\fP för möjliga sätt att +ange \fIgränsen\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIgräns\fP +Sätt en gräns för minnesanvändningen för multitrådad dekomprimering. Detta +kan endast påverka antalet trådar; det kommer aldrig att få \fBxz\fP att vägra +att dekomprimera en fil. Om \fIgränsen\fP är för låg för att tillåta någon +multitrådning ignoreras \fIgränsen\fP och \fBxz\fP kommer gå vidare i enkeltrådat +läge. Observera att om även \fB\-\-memlimit\-decompress\fP används kommer det +alltid att gälla både enkeltrådat och multitrådat läge, och därmed kommer +den gällande \fIgränsen\fP för multitrådning aldrig vara högre än gränsen som +sätts med \fB\-\-memlimit\-decompress\fP. +.IP "" +Till skillnad mot de andra flaggorna för gränser för minnesanvändning har +\fB\-\-memlimit\-mt\-decompress=\fP\fIgräns\fP en systemspecifik +standard\fIgräns\fP. \fBxz \-\-info\-memory\fP kan användas för att se det aktuella +värdet. +.IP "" +Denna flagga och dess standardvärde finns för att utan någon gräns skulle +den trådade dekomprimeraren kunna allokera en vansinnig mängd minne med +några indatafiler. Om standard\fIgränsen\fP är för låg på ditt system, öka då +gärna \fIgränsen\fP men sätt den aldrig till ett större värde än mängden +användbart RAM eftersom att med passande indatafiler kommer \fBxz\fP försöka +använda den mängden av minne även med ett lågt antal trådar. Att få slut på +minne ller växling kommer inte förbättra dekomprimeringsprestandan. +.IP "" +Se \fB\-\-memlimit\-compress=\fP\fIgräns\fP för möjliga sätt att ange \fIgränsen\fP. Att +sätta \fIgräns\fP till \fB0\fP återställer \fIgränsen\fP till sdet systemspecifika +standardvärdet. +.TP +\fB\-M\fP \fIgräns\fP, \fB\-\-memlimit=\fP\fIgräns\fP, \fB\-\-memory=\fP\fIgräns\fP +Detta är ekvivalent med att ange \fB\-\-memlimit\-compress=\fP\fIgräns\fP +\fB\-\-memlimit\-decompress=\fP\fIgräns\fP \fB\-\-memlimit\-mt\-decompress=\fP\fIgräns\fP. +.TP +\fB\-\-no\-adjust\fP +Visa ett fel och avsluta om gränsen för minnesanvändning inte kan mötas utan +att justera inställnigar som påverkar den komprimerade utdatan. Det vill +säga, detta förhindrar att \fBxz\fP byter kodaren från multitrådat läge till +enkeltrådat läge och från att den reducerar LZMA2\-lexikonets storlek. Även +när denna flagga används kan antalet trådar reduceras för att möta gränsen +för minnesanvändning eftersom det inte kommer påverka den komprimerade +utdatan. +.IP "" +Automatisk justering är alltid avaktiverat när råa strömmar skapas +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fItrådar\fP, \fB\-\-threads=\fP\fItrådar\fP +Ange antalet arbetstrådar som skall användas. Att sätta \fItrådar\fP till ett +specialvärde \fB0\fP gör att \fBxz\fP använder så många trådar som processorerna +på systemet stödjer. Det aktuella antalet trådar kan vara färre än \fItrådar\fP +om indatafilen inte är stor nog för trådning med de givna inställningarna +eller om användning av fler trådar skulle överkrida gränsen för +minnesanvändning. +.IP "" +De enkeltrådade och multitrådade komprimerarna producerar olika utdata. Den +enkeltrådade komprimeraren kommer ge den minsta filstorleken men endast +utdata från den multitrådade komprimeraren kan dekomprimeras med flera +trådar. Att sätta \fItrådar\fP till \fB1\fP kommer använda enkeltrådat läge. Att +sätta \fItrådar\fP till något annat värde, inklusive \fB0\fP, kommer använda den +multitrådade komprimeraren även om systemet endast stödjer en hårdvarutråd. +(\fBxz\fP 5.2.x använde enkeltrådat läge i denna situation.) +.IP "" +För att använda multitrådat läge med endast en tråd, sätt \fItrådar\fP till +\fB+1\fP. Prefixet \fB+\fP har ingen påvrekan för andra värden än \fB1\fP. En gräns +för minnesanvändning kan fortfarande göra att \fBxz\fP byter till enkeltrådat +läge såvida inte \fB\-\-no\-adjust\fP används. Stöd för prefixet \fB+\fP lades till i +\fBxz\fP 5.4.0. +.IP "" +Om ett automatiskt antal trådar har begärts och ingen gräns för +minnesanvändning har angivits, då kommer en systemspecifik mjuk +standardgräns användas för att möjligen begränsa antalet trådar. Det är en +mjuk gräns i den meningen att den ignoreras om antalet trådar blir en, +alltså kommer en mjuk gräns aldrig hindra \fBxz\fP från att komprimera eller +dekomprimera. Denna mjuka standardgräns kommer inte göra att \fBxz\fP byter +från multitrådat läge till enkeltrådat läge. De aktiva gränserna kan ses med +\fBxz \-\-info\-memory\fP. +.IP "" +För närvarande är den enda trådningsmetoden att dela indata i block och +komprimera dem oberoende av varandra. Standardstorleken på block beror på +komprimeringsnivån och kan åsidosättas med flaggan +\fB\-\-block\-size=\fP\fIstorlek\fP. +.IP "" +Trådad dekomprimering fungerar bara på filer som innehåller flera block med +storleksinformation i blockhuvuden. Alla tillräckligt stora filer +komprimeras i multitrådat läge för att uppfylla detta villkor, men filer +komprimerade i enkeltrådat läge gör det inte ens om +\fB\-\-block\-size=\fP\fIstorlek\fP har använts. +.IP "" +Standardvärdet på \fItrådar\fP är \fB0\fP. I \fBxz\fP 5.4.x och tidigare är +standardvärdet \fB1\fP. +. +.SS "Anpassade komprimerarfilterkedjor" +Med en anpassad filterkedja kan man specificera kompressionsinställningarna +i detalj istället för att lita på inställningarna som hör till +förinställningarna. När en anpassad filterkedja anges glöms +förinställningsflaggor (\fB\-0\fP \&…\& \fB\-9\fP och \fB\-\-extreme\fP) tidigare på +kommandoraden. Om en förinställningsflagga anges efter en eller flera +flaggor för anpassade filterkedjor gäller den nya förinställningen och de +flaggor för anpassade filterkedjor som angivits tidigare glöms. +.PP +En filterkedja är jämförbar med att skapa rör på kommando. Vid komprimering +skickas den okomprimerade indatan till det första filtret, vars utdata +skickas till nästa filter (om något). Utdatan från det sista filtret blir +skrivet till den komprimerade filen. Det maximala antalet filter i kedjan är +fyra, men typiskt har en filterkedja bara ett ellet två filter. +.PP +Många filter har begränsningar på var de kan finnas i filterkedjan: några +filter kan bara fungera som det sista filtret i kedjan, några bara om de +inte är det sista filtret, och några fungerar i godtycklig position i +kedjan. Beroende på filtret är denna begränsning antingen en egenskap hos +filterdesignen eller finns för att förhindra säkerhetsproblem. +.PP +En anpassad filterkedja kan anges på två olika sätt. Med flaggorna +\fB\-\-filters=\fP\fIfilter\fP och \fB\-\-filters1=\fP\fIfilter\fP \&…\& +\fB\-\-filters9=\fP\fIfilter\fP kan man ange en hel filterkedja med en flagga genom +att använda syntaxen för liblzma\-filtersträngar. Alternativt kan en +filterkedja anges genom att använda en eller flera individuella +filterflaggor i den ordning de önskas i filterkedjan. Det vill säga, +ordningen på de individuella filterflaggorna är signifikant! Vid avkodning +av råa strömmar (\fB\-\-format=raw\fP) måste filterkedjan anges i samma ordning +som den specificerades vid komprimeringen. Eventuella individuella filter\- +eller förinstiällningsflaggor angivna före den fullständiga +filterkedjeflaggan (\fB\-\-filters=\fP\fIfilter\fP) kommer glömmas. Individuella +filter som anges efter den flaggan för en full kedja kommer återställa +filterkedjan. +.PP +Både den fullständiga och de individuella filterflaggorna tar +filterspecifika \fIflaggor\fP som en kommaseparerad lista. Extra komman +\fIflaggor\fP ignoreras. Varje flagga har ett standardvärde, så ange dem du +vill ändra. +.PP +För att se hela filterkedjan och \fIflaggor\fP, använd \fBxz \-vv\fP (det vill +säga, använd \fB\-\-verbose\fP två gånger). Detta fungerar även för att se +flaggorna för filterkedjor som används av förinställningar. +.TP +\fB\-\-filters=\fP\fIfilter\fP +Ange den fullständiga filterkedan eller en förinställning en en enda +flagga. Varje filter kan separeras med blanktecken eller två bindestreck +(\fB\-\-\fP). \fIfilter\fP kan behöva citeras på skalets kommandorad så att det +tolkas som en enda flagga. För att beteckna \fIflaggor\fP, använd \fB:\fP eller +\fB=\fP. En förinställning kan föregås med ett \fB\-\fP och följas av noll eller +flera flaggor. Den enda flaggan som stödjs är \fBe\fP för att tillämpa samma +flaggor som \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIfilter\fP … \fB\-\-filters9\fP=\fIfilter\fP +Ange upp till nio ytterligare filterkedjor som kan användas med +\fB\-\-block\-list\fP. +.IP "" +Till exempel, vid komprimering av ett arkiv med körbara filer följt av +textfiler skulle den körbara delen kunna använda en filterkedja med ett +BCJ\-filter och endast textdelen med LZMA2\-filtret. +.TP +\fB\-\-filters\-help\fP +Visa ett hjälpmeddelande som beskriver hur man anger förinställningar och +anpassade filterkedjor i flaggorna \fB\-\-filters\fP och \fB\-\-filters1=\fP\fIfilter\fP +\&…\& \fB\-\-filters9=\fP\fIfilter\fP, och avsluta rent. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIflaggor\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIflaggor\fP] +.PD +Lägg till LZMA1\- eller LZMA2\-filter till filterkedjan. Dessa filter kan +endast användas som det sista filtret i kedjan. +.IP "" +LZMA1 är ett föråldrat filter, vilket stödjs nästan enbart på grund av det +föråldrade filformatet \fB.lzma\fP, vilket bara stödjer LZMA1. LZMA2 är en +uppdaterad version av LZMA1 för att lösa några praktiska problem med +LZMA1. Formatet \fB.xz\fP använder LZMA2 och stödjer inte LZMA1 +alls. Komprimeringshastigheten och förhållandena för LZMA1 är LZMA2 är +praktiskt taget desamma. +.IP "" +LZMA1 och LZMA2 delar samma uppättning \fIflaggor\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIförinställning\fP +Återställ alla LZMA1\- eller LZMA2\-\fIflaggor\fP till +\fIförinställning\fP. \fIFörinställning\fP består av ett heltal, vilket kan följas +av enskilda bokstäver som modifierar förinställningen. Heltalet kan vara +från \fB0\fP till \fB9\fP, motsvarande kommandoradsflaggorna \fB\-0\fP \&…\& +\fB\-9\fP. Den enda modifierare som stödjs för närvarande är \fBe\fP, vilket +motsvarar \fB\-\-extreme\fP. Om ingen \fBpreset\fP anges tas standardvärden på +LZMA1\- eller LZMA2\-\fIflaggor\fP från förinställningen \fB6\fP. +.TP +\fBdict=\fP\fIstorlek\fP +Ett lexikons (historiebufferts) \fIstorlek\fP indikerar hur många byte med +nyligen bearbetad okomprimerad data som hålls i minnet. Algoritmen försöker +hitta återkommande bytesekvenser (matchningar) i den okomprimerade datan, +och ersätta dem med referenser till datan som för närvarande finns i +lexikonet. Ju större lexikon, desto högre är sannolikheten att hitta en +matchning. Att öka lexikonets \fIstorlek\fP förbättrar alltså vanligen +komprimeringsförhållandet, men ett lexikon som är större än den +okomprimerade filen är ett slöseri med minne. +.IP "" +En typisk \fIstorlek\fP på lexikon är från 64\ KiB till 64\ MiB. Minimum är 4\ KiB. Det maximala för komprimering är för närvarande 1,5\ GiB (1536\ MiB). Dekomprimeraren stödjer redan lexikon upp till en byte mindre än 4\ GiB, vilket är det maximala för strömformaten LZMA1 och LZMA2. +.IP "" +Lexikon\fIstorlek\fP och matchhittaren (\fImf\fP) avgör tillsammans +minnesanvändningen för LZMA1\- eller LZMA2\-kodaren. Ett lika \fIstort\fP (eller +större) lexikon behövs för dekomprimering som det som användes vid +komprimeringen, minnesanvändningen för avkodaren avgörs alltså av +lexikonstorleken vid komprimering. Huvudena i \fB.xz\fP innehåller lexikonets +\fIstorlek\fP antingen som 2^\fIn\fP eller 2^\fIn\fP + 2^(\fIn\fP\-1), så dessa +\fIstorlekar\fP är lite att föredra för komprimering. Andra \fIstorlekar\fP kommer +avrundas uppåt när de lagras i huvuden i \fB.xz\fP. +.TP +\fBlc=\fP\fIlk\fP +Ange antalet literala kontextbitar. Minimum är 0 och maximum är 4; +standardvärdet är 3. Dessutom får inte summan av \fIlk\fP och \fIlp\fP överskrida +4. +.IP "" +Alla byte som inte kan kodas som matchningar kodas som literaler. Det vill +säga, literaler är helt enkelt 8\-bits byte som kodas en åt gången. +.IP "" +Den literala kodningen gör antagandet att de högsta \fIlk\fP bitarna av den +föregående okomprimerade byten korrelerar med nästa byte. Till exempel, i +typisk engelsk text följs ofta en versal bokstav av en gemen bokstav, och en +gemen bokstav följs vanligen av en annan gemen bokstav. I +teckenuppsättningen US\-ASCII är de högsta tre bitarna 010 för versala +bokstäver och 011 för gemena bokstäver. När \fIlk\fP är åtminstone 3 kan den +literala kodningen dra nytta av denna egenskap i den okomprimerade datan. +.IP "" +Standardvärdet (3) är normalt bra. Om man vill ha maximal komprimering, +prova \fBlc=4\fP. Ibland hjälper det lite, och ibland gör det komprimeringen +sämre. Om det gör den sämre, testa också \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Ange antalet literala positionsbitar. Minimum är 0 och maximum är 4; +standardvärdet är 0. +.IP "" +\fILp\fP påverkar vilken sorts justering i den okomprimerade datan som antas +vid kodning av literaler. Se \fIpb\fP nedan för mer information om justering. +.TP +\fBpb=\fP\fIpb\fP +Ange antalet positionsbitar. Minimum är 0 och maximum är 4; standardvärdet +är 2. +.IP "" +\fIPb\fP påverkar vilken sort justering i den okomprimerade datan som antas i +allmänhet. Standardvärdet betyder fyrbytejustering (2^\fIpb\fP=2^2=4), vilket +ofta är ett bra val när det inte finns någon bättre gissning. +.IP "" +När justeringen är känd kan en inställning av \fIpb\fP därefter reducera +filstorleken något. Till exempel, med textfiler som har en\-byte\-justering +(US\-ASCII, ISO\-8859\-*, UTF\-8) kan att sätta \fBpb=0\fP förbättra komprimeringen +något. För UTF\-16\-text är \fBpb=1\fP ett bra val. Om justeringen är ett udda +tal som 3 byte kan \fBpb=0\fP vara det bästa valet. +.IP "" +Även om den antagna justeringen kan anpassas med \fIpb\fP och \fIlp\fP föredrar +LZMA1 och LZMA2 ändå något 16\-byte\-justering. Det kan vara värt att ta med i +beräkningen vid design av filformat som sannolikt ofta kan komma att +komprimeras med LZMA1 eller LZMA2. +.TP +\fBmf=\fP\fIms\fP +Matchsökaren har en stor poverkan på kodarens hastighet, minnesanvändning +och komprimeringsförhållande. Vanligen är Hashkedje\-matchsökare snabbare än +Binärträdsmatchsökare. Standardvärdet beror på \fIföinställningen\fP: 0 +använder \fBhc3\fP, 1\(en3 använder \fBhc4\fP, och resten använder \fBbt4\fP. +.IP "" +Följande matchsökare stödjs. Formlerna för minnesanvändning nedan är grova +uppskattningar, vilka är närmast sanningen när \fIdict\fP är en tvåpotens. +.RS +.TP +\fBhc3\fP +Hashkedja med 2\- och 3\-bytehashning +.br +Minsta värde på \fInice\fP: 3 +.br +Minnesanvändning: +.br +\fIdict\fP · 7.5 (om \fIdict\fP ≤ 16 MiB); +.br +\fIdict\fP · 5,5 + 64 MiB (om \fIdict\fP > 16 MiB) +.TP +\fBhc4\fP +Hashkedja med 2\-, 3\- och 4\-bytehashning +.br +Minsta värde på \fInice\fP: 4 +.br +Minnesanvändning: +.br +\fIdict\fP · 7,5 (om \fIdict\fP ≤ 32 MiB); +.br +\fIdict\fP · 6,5 (om \fIdict\fP > 32 MiB) +.TP +\fBbt2\fP +Binärträd med 2\-bytehashning +.br +Minsta värde på \fInice\fP: 2 +.br +Minnesanvändning: \fIdict\fP · 9,5 +.TP +\fBbt3\fP +Binärträd med 2\- och 3\-bytehashning +.br +Minsta värde på \fInice\fP: 3 +.br +Minnesanvändning: +.br +\fIdict\fP · 11,5 (om \fIdict\fP ≤ 16 MiB); +.br +\fIdict\fP · 9,5 + 64 MiB (om \fIdict\fP > 16 MiB) +.TP +\fBbt4\fP +Binärträd med 2\-, 3\- och 4\-bytehashning +.br +Minsta värde på \fInice\fP: 4 +.br +Minnesanvändning: +.br +\fIdict\fP · 11,5 (om \fIdict\fP ≤ 32 MiB); +.br +\fIdict\fP · 10,5 (om \fIdict\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fIläge\fP +Komprimerings\fIläget\fP anger metoden som används för att analysera data +skapade av matchsökaren. De \fIlägen\fP som stödjs är \fBfast\fP och +\fBnormal\fP. Standardvärdet är \fBfast\fP för \fIförinställningarna\fP 0\(en3 och +\fBnormal\fP för \fIförinställningarna\fP 4\(en9 +.IP "" +Vanligen används \fBfast\fP med Hashkedjematchsökare och \fBnormal\fP med +Binärträdsmatchsökare. Detta är även vad \fIförinställningarna\fP gör. +.TP +\fBnice=\fP\fIlagom\fP +Ange vad som anses vara en lagom längt på en matchning. När en matchning på +åtminstone \fIlagom\fP byte hittats slutar algoritmen söka efter möjliga bättre +matchningar. +.IP "" +\fILagom\fP kan vara 2\(en273 byte. Högre värden tenderar att ge bättre +komprimeringsförhållande på bekostnad av tid. Standardvärdet beror på +\fIförinställningen\fP. +.TP +\fBdepth=\fP\fIdjup\fP +Ange det maximala sökdjupet i matchsökaren. Standardvärdet är specialvärdet +0, vilket får komprimeraren att avgöra ett lämpligt \fIdjup\fP från \fImf\fP och +\fInice\fP. +.IP "" +Lämpligt \fIdjup\fP för Hashkedjor är 4\(en100 och 16\(en1000 för +Binärträd. Att använda väldigt höga värden på \fIdjup\fP kan göra kodaren +extremt långsam för vissa filer. Undvik att sätta \fIdjup\fP över 1000 såvida +du inte är beredd att avbryta komprimeringen om den tar för lång tid. +.RE +.IP "" +Vid avkodning av råa strömmar (\fB\-\-format=raw\fP) behöver LZMA2 endast +lexikonets \fIstorlek\fP. LZMA1 behöver även \fIlc\fP, \fIlp\fP och \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIflaggor\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIflaggor\fP] +.PD +Lägg till gren/anrop/hopp\-filter (branch/call/jump, BCJ) till +filterkedjan. Dessa filter kan inte användas som det sista filtret i +filterkedjan. +.IP "" +Ett BCJ\-filter konverterar relativa adresser i maskinkod till deras absoluta +motsvarigheter. Detta ändrar inte storleken på datan men det ökar +redundansen, vilket kan hjälpa LZMA2 att skapa 0\(en15\ % mindre +\&\fB.xz\fP\-filer. BCJ\-filtren är alltid reversibla, så att använda ett +BCJ\-filter för fel sorts data orsakar inte någon dataförlust, men det kan +göra komprimeringsförhållandet något sämre. BCJ\-filtren är mycket snabba +och använder en obetydling mängd minne. +.IP "" +Dessa BCJ\-filter har kända problem kopplade till komprimeringsförhållandet: +.RS +.IP \(bu 3 +Någr sortes filer som innehåller körbar kod (till exempel, objektfiler, +statiska bibliotek och Linux kärnmoduler) har adresserna i instruktionerna +fyllda med utfyllnadsvärden. Dessa BCJ\-filter kommer ändå göra +adresskonverteringen, vilket kommer göra komprimeringen sämre för dessa +filer. +.IP \(bu 3 +Om ett BCJ\-filter används på ett arkiv är det möjligt att det gör +komprimeringsförhållandet sämre än att inte använda något BCJ\-filter. Till +exempel, om det finns liknande eller till och med identiska körbara kommer +filtreringen sannolikt göra filerna mindre lika och därmed blir +kompressionen sämre. Innehållet i icke körbara filer i samma arkiv kan också +spela en roll. I praktiken måste man prova med och utan ett BCJ\-filter för +att se vilket som är det bästa i varje situation. +.RE +.IP "" +Olika instruktionsuppsättningar har olika justering: den körbara filen måste +vara justerad till en multipel av detta värde i indata för att filtret skall +fungera. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filter;Justering;Kommentarer +x86;1;32\-bitars eller 64\-bitars x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096\-bytesjustering är bäst +PowerPC;4;Endast rak byteordning +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Eftersom BCJ\-filtrerad data vanligen komprimeras med LZMA2 kan +komprimeringsförhållandet förbättras något om LZMA2\-flaggorna sätts till att +matcha justeringen hos det valda BCJ\-filtret. Exempel: +.RS +.IP \(bu 3 +IA\-64\-filter har 16\-bytejustering så \fBpb=4,lp=4,lc=0\fP är bra med LZMA2 +(2⁴=16). +.IP \(bu 3 +RISC\-V\-kod har 2\-byte\- eller 4\-bytejustering beroende på huruvida filen +innehåller 16\-bitars komprimerade instruktioner (utvidgningen C). När +16\-bitarsinstruktioner används är \fBpb=2,lp=1,lc=3\fP eller \fBpb=1,lp=1,lc=3\fP +bra. När det inte finns några 16\-bitsinstruktioner är \fBpb=2,lp=2,lc=2\fP +bäst. \fBreadelf \-h\fP kan användas för att kontrollera om ”RVC” förekommer på +raden ”Flaggor”. +.IP \(bu 3 +ARM64 är alltid 4\-bytejusterad så \fBpb=2,lp=2,lc=2\fP är bäst. +.IP \(bu 3 +Filtret x86 är ett undantag. Det är normalt bra att hålla sig till LZMA2:s +standardvärden (\fBpb=2,lp=0,lc=3\fP) när körbar x86 komprimeras. +.RE +.IP "" +Alla BCJ\-filter stödjer samma \fIflaggor\fP: +.RS +.TP +\fBstart=\fP\fIavstånd\fP +Ange start\fIavståndet\fP som används vid konvertering mellan relativa och +absoluta adresser. \fIAvståndet\fP måste vara en multipel av filtrets justering +(se tabellen ovan). Standardvärdet är noll. I praktiken är standardvärdet +bra; det är nästan aldrig användbart att ange ett anpassat \fIavstånd\fP. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIflaggor\fP] +Lägg till Deltafiltret till filterkedjan. Deltafiltret kan inte användas som +det sista filtret i filterkedjan. +.IP "" +För närvarande stödjs bara enkel byte\-vis deltaberäkning. Det kan vara +användbart vid komprimering, till exempel av okomprimerade +bitavbildningsbilder eller okomprimerad PCM\-audio. Dock kan algoritmer för +särskilda ändamål ge betydligt bättre resultat än Delta + LZMA2. Detta är +särskilt sant med audio, vilket komprimerar snabbare och bättre med till +exempel \fBflac\fP(1). +.IP "" +Stödda \fIflaggor\fP: +.RS +.TP +\fBdist=\fP\fIavstånd\fP +Ange \fIavståndet\fP för deltaberäkningen i byte. \fIAvstånd\fP måste varea +1\(en256. Standardvärdet är 1. +.IP "" +Till exempel, med \fBdist=2\fP och åtta byte indata A1 B1 A2 B3 A3 B5 A4 B7, +kommer utdata vara A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Andra flaggor" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Utelämna varningar och noteringar. Ange detta två gånger för att även +utelämna felmeddelandet. Denna flagga har ingen påverkan på +slutstatusen. Det vill säga, även om en varning utelämnades kommer +slutstatusen fortfarandeindikera att en varning gavs. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Var utförlig. Om standard fel är kopplat till en terminal kommer \fBxz\fP visa +en förloppsmätare. Att ange \fB\-\-verbose\fP två gånger kommer ge än mer +utförlig utmatning. +.IP "" +Förloppsmätaren visar följande information: +.RS +.IP \(bu 3 +Procent färdigt visas om storleken på indatafilen är känd. Det vill säga, +procentsatsen kan inte visas i rör. +.IP \(bu 3 +Mängd komprimerad data som producerats (komprimering) eller konsumerats +(dekomprimering). +.IP \(bu 3 +Mängd okomprimerad data som konsumerats (komprimering) eller producerats +(dekomprimering). +.IP \(bu 3 +Komprimeringsförhållande, vilket beräknas genom att dividera mängden +komprimerad data bearbetad så lång med mängde okomprimerad data bearbetad så +långt. +.IP \(bu 3 +Kompressions eller dekompressionshastighet. Detta mäts som mängden +okomprimerad data konsumerad (komprimering) eller producerad +(dekomprimering) per sekund. Det visas efter att några sekunder har gåt +efter att \fBxz\fP började bearbeta filen. +.IP \(bu 3 +Förfluten tid på formatet MM:SS eller H:MM:SS. +.IP \(bu 3 +Beräknad återstående tid visas endast när storleken på indatafilen är känd +och några sekunder redan gått efter att \fBxz\fP började bearbeta filen. Tiden +visas i ett mindre precist format vilket aldrig har några kolon, till +exempel, 2 min 30 s. +.RE +.IP "" +När standard fel inte är en terminal kommer \fB\-\-verbose\fP göra att \fBxz\fP +skriver filnamnet, komprimerad storlek, okomprimerad storlek, +komprimeringsförhållande och möjligen även hastigheten och den förlupna +tiden på en enda rad till standard fel efter att ha komprimerat eller +dekomprimerat filen. Hastigheten och den förlupna tiden inkluderas endast +när åtgärden tog åtminstone några sekunder. Om åtgärden inte slutfördes, +till exempel för att användaren avbröt, skrivs även den fullbordade +procentsatsen om storleken på indatafilen är känd. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Sätt inte slutstatus till 2 även om ett tillstånd som är värt en varning +upptäcktes. Denna flagga påverkar inte utförlighetsnivån, allts måste både +\fB\-\-quiet\fP och \fB\-\-no\-warn\fP användas för att inte visa varningar och för att +inte ändra slutstatusen. +.TP +\fB\-\-robot\fP +Skriv meddelanden i maskinläsbart form. Detta är avsett att förenkla att +skriva framändar som vill använda \fBxz\fP istället för liblzma, vilken kan +vara fallet i olika skript. Utdatan med denna flagga aktiverad är avsedd att +vara stabil mellan utgåvor av \fBxz\fP. Se avsnitett \fBROBOTLÄGE\fP för detaljer. +.TP +\fB\-\-info\-memory\fP +Visa, på mänskligt läsbar form, hur mycket fysiskt minne (RAM) och hur många +processortrådar \fBxz\fP tror att systemet har och gränserna för +minnesanvändning vid komprimering och dekomprimering, och avsluta. +.TP +\fB\-h\fP, \fB\-\-help\fP +Visa ett hjälpmeddelande som beskriver de vanligast använda flaggorna, och +avsluta. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Visa ett hjälpmeddelande som beskriver alla funktioner i \fBxz\fP, och avsluta +.TP +\fB\-V\fP, \fB\-\-version\fP +Visa versionsnumret för \fBxz\fP och liblzma i mänskligt läsbar form. För att +få maskinläsbar utdata, ange \fB\-\-robot\fP före \fB\-\-version\fP. +. +.SH ROBOTLÄGE +Robotläget aktiveras med flaggan \fB\-\-robot\fP. Det gör att utdata från \fBxz\fP +är enklare att tolka av andra program. För närvarande stödjs \fB\-\-robot\fP +endast tillsammans med \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP och +\fB\-\-version\fP. Den kommer att stödjas för komprimering och dekomprimering i +framtiden. +. +.SS Listläge +\fBxz \-\-robot \-\-list\fP använder tab\-separerad utmatning. Första kolumnen av +varje rad har en sträng som indikerar typen av informationen som finns på +den raden: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Detta är alltid första raden när en fil börjar listas. Den andra kolumen på +raden är filnamnet. +.TP +\fBfile\fP +Denna rad innehåller övergripande information om \fB.xz\fP\-filen. Denna rad +skrivs alltid efter raden \fBname\fP. +.TP +\fBstream\fP +Denna radtyp används endast när \fB\-\-verbose\fP angetts. Det finns lika många +\fBstream\fP\-rader som det finns strömmar i \fB.xz\fP\-filen. +.TP +\fBblock\fP +Denna radtyp används bara när \fB\-\-verbose\fP angetts. Det finns lika många +\fBblock\fP\-rader som det finns block i \fB.xz\fP\-filen. \fBblock\fP\-rader visas +efter alla \fBstream\fP\-raderna; olika radtyper blandas inte. +.TP +\fBsummary\fP +Denna radtyp används bara när \fB\-\-verbose\fP angetts två gånger. Denna rad +skrivs eefter alla \fBblock\fP\-rader. Liksom raden \fBfile\fP inenhåller raden +\fBsummary\fP övergripande information om \fB.xz\fP\-filen. +.TP +\fBtotals\fP +Denna rad är alltid den allra sista raden i listutmatningen. Den visar det +totala antalen och storlekarna. +.PP +Kolumnerna på \fBfile\fP\-raderna: +.PD 0 +.RS +.IP 2. 4 +Antalet strömmar i filen +.IP 3. 4 +Totalt antal block i strömmarna +.IP 4. 4 +Komprimerad storlek på filen +.IP 5. 4 +Okomprimerad storlek på filen +.IP 6. 4 +Komprimeringsförhållande, till exempel \fB0.123\fP. Om förhållandet är över +9.999 visas tre bindestreck (\fB\-\-\-\fP) istället för förhållandet. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Kommaseparerad lista med integritetskontrollnamn. Följande strängar används +för de kända kontrolltyperna: \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP och +\fBSHA\-256\fP. För okända kontrolltyper används \fBUnknown\-\fP\fIN\fP, där \fIN\fP är +kontroll\-ID:t som ett decimalt nummer (en eller två siffror). +.IP 8. 4 +Total storlek på strömutfyllnad i filen +.RE +.PD +.PP +Kolumnerna på \fBstream\fP\-raderna: +.PD 0 +.RS +.IP 2. 4 +Strömnummer (den första strömmen är 1) +.IP 3. 4 +Antal block i strömmen +.IP 4. 4 +Komprimerat startavstånd +.IP 5. 4 +Okomprimerat startavstånd +.IP 6. 4 +Komprimerad storlek (inkluderar inte strömutfyllnad) +.IP 7. 4 +Okomprimerad storlek +.IP 8. 4 +Komprimeringsförhållande +.IP 9. 4 +Namnet på integritetskontrollen +.IP 10. 4 +Storleken på strömutfyllnad +.RE +.PD +.PP +Kolumnerna på \fBblock\fP\-raderna: +.PD 0 +.RS +.IP 2. 4 +Numret på strömmen som innehåller detta block +.IP 3. 4 +Blocknummer relativt början på strömmen (det första blocket är 1) +.IP 4. 4 +Blocknummer relativt början på filen +.IP 5. 4 +Komprimerat startavstånd relativt början av filen +.IP 6. 4 +Okomprimerat startavstånd relativt början av filen +.IP 7. 4 +Total komprimerad storlek på blocket (inkluderar huvuden) +.IP 8. 4 +Okomprimerad storlek +.IP 9. 4 +Komprimeringsförhållande +.IP 10. 4 +Namnet på integritetskontrollen +.RE +.PD +.PP +Om \fB\-\-verbose\fP angavs två gånger inkluderas ytterligare kolumner på +\fBblock\fP\-raderna. Dessa visas inte med bara ett \fB\-\-verbose\fP, eftersom det +för att få fram denna information krävs många sökningar och kan därmed vara +långsamt: +.PD 0 +.RS +.IP 11. 4 +Värdet på integritetskontrollen hexadecimalt +.IP 12. 4 +Blockhuvudstorlek +.IP 13. 4 +Blockflaggor: \fBc\fP indikerar att komprimerad storlek finns, och \fBu\fP +indikerar att okomprimerad storlek finns. Om flaggan inte är satt visas ett +bindestreck (\fB\-\fP) istället för att hålla stränglängden fast. Nya flaggor +kan läggas till i slutet av strängen i frmtiden. +.IP 14. 4 +Storlek på den faktiska komprimerade datan i blocket (detta utelämnar +blockhuvud, blockutfyllnad och kontrollfält) +.IP 15. 4 +Mängd minne (i byte) som behövs för att dekomprimera detta block med denna +version av \fBxz\fP +.IP 16. 4 +Filterkedja. Observera att de flesta av flaggorna som användes vid +komprimeringstillfället inte kan vara kända, eftersom endat de flaggor som +behövs för dekomprimering lagras i \fB.xz\fP\-huvudet. +.RE +.PD +.PP +Kolumnerna på \fBsummary\fP\-raderna: +.PD 0 +.RS +.IP 2. 4 +Mängd minne (i byte) som behövs för att dekomprimera denna fil med denna +version av \fBxz\fP +.IP 3. 4 +\fByes\fP eller \fBno\fP som indikerar om alla blockhuvuden både har komprimerad +storlek och okomprimerad storlek i sig +.PP +\fIFrån\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Minsta version av \fBxz\fP som krävs för att dekomprimera filen +.RE +.PD +.PP +Kolumnerna på \fBtotals\fP\-raden: +.PD 0 +.RS +.IP 2. 4 +Antal strömmar +.IP 3. 4 +Antal block +.IP 4. 4 +Komprimerad storlek +.IP 5. 4 +Okomprimerad storlek +.IP 6. 4 +Genomsnittligt komprimeringsförhållande +.IP 7. 4 +Kommaseparerad lista med integritetskontrollnamn som fanns i filerna +.IP 8. 4 +Strömutfyllnadsstorlek +.IP 9. 4 +Antal filer. Denna finns här för att hålla ordningen av de tidigare +kolumnerna desamma som på \fBfile\fP\-rader. +.PD +.RE +.PP +Om \fB\-\-verbose\fP angavs två gånger inkluderas ytterligare kolumner på +\fBtotals\fP\-raden: +.PD 0 +.RS +.IP 10. 4 +Maximal mängd minne (i byte) som behövs för att dekomprimera filerna med +denna version av \fBxz\fP +.IP 11. 4 +\fByes\fP eller \fBno\fP som indikerar om alla blockhuvuden både har komprimerad +storlek och okomprimerad storlek i sig +.PP +\fIFrån\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Minsta version av \fBxz\fP som krävs för att dekomprimera filen +.RE +.PD +.PP +Framtida versioner kan lägga till fler radtyper och fler kolumner kan läggas +til på de befintliga radtyperna, men de befintliga kolumnerna kommmer inte +ändras. +. +.SS Filterhjälp +\fBxz \-\-robot \-\-filters\-help\fP skriver ut de filter som stödjs i följande +format: +.PP +\fIfilter\fP\fB:\fP\fIflagga\fP\fB=<\fP\fIvärde\fP\fB>,\fP\fIflagga\fP\fB=<\fP\fIvärde\fP\fB>\fP… +.TP +\fIfilter\fP +Namn på filtret +.TP +\fIflagga\fP +Namn på en filterspecifik flagga +.TP +\fIvärde\fP +Numeriska \fIvärde\fPintervall ser ut som +\fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. Sträng\fIvärdes\fP val visas inom \fB< >\fP och separerade med ett \fB|\fP\-tecken. +.PP +Varje filter skrivs på en egen rad. +. +.SS Minnesgränsinformation +\fBxz \-\-robot \-\-info\-memory\fP skriver en rad med flera tab\-separerade +kolumner: +.IP 1. 4 +Total mängd med fysiskt minne (RAM) i byte. +.IP 2. 4 +Minnesanvändningsgräns för komprimering i byte (\fB\-\-memlimit\-compress\fP). Ett +specialvärde \fB0\fP indikerar standardinställningen vilken för enkeltrådat +läge är detsamma som ingen gräns. +.IP 3. 4 +Minnesanvändningsgräns för dekomprimering i byte +(\fB\-\-memlimit\-decompress\fP). Ett specialvärde \fB0\fP indikerar +standdartinställningen vilken för enkeltrådat läge är detsamma som ingen +gräns. +.IP 4. 4 +Från \fBxz\fP 5.3.4alpha: Minnesanvändningen för multitrådad dekomprimering i +byte (\fB\-\-memlimit\-mt\-decompress\fP). Detta är aldrig noll eftersom ett +systemspecifikt standardvärde som visas i kolumn 5 används om ingen gräns +har angivits uttryckligen. Detta är heller aldrig större än värdet i kolumn +3 även om ett större värde har angivits med \fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Från \fBxz\fP 5.3.4alpha: Ett systemspecifikt standardgräns för +minnesanvändning som används för att begränsa antalet trådar vid +komprimering med ett automatiskt antal trådar (\fB\-\-threads=0\fP) och ingen +gräns för minnesanvändning har angivits (\fB\-\-memlimit\-compress\fP). Detta +används även som standardvärdet på \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Från \fBxz\fP 5.3.4alpha: antal tillgängliga processortrådar. +.PP +I framtiden kan utdata från \fBxz \-\-robot \-\-info\-memory\fP ha fler kolumner, +men aldrig mer än en rad. +. +.SS Version +\fBxz \-\-robot \-\-version\fP skriver versionsnumret på \fBxz\fP och liblzma i +följande format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Huvudversion. +.TP +\fIYYY\fP +Underversion. Jämna nummer är stabila. Udda nummer är alfa\- eller +betaversioner. +.TP +\fIZZZ\fP +Rättningsnivå för stabila utgåvor eller bara en räknare för +utvecklingsutgåvor. +.TP +\fIS\fP +Stabilitet. 0 är alfa, 1 beta beta och 2 är stabil. \fIS\fP skall alltid vara +2 när \fIYYY\fP är jämnt. +.PP +\fIXYYYZZZS\fP är samma på båda raderna om \fBxz\fP och liblzma kommer från samma +utgåva av XZ Utils. +.PP +Exempel: 4.999.9beta är \fB49990091\fP och 5.0.0 är \fB50000002\fP. +. +.SH SLUTSTATUS +.TP +\fB0\fP +Allt är bra. +.TP +\fB1\fP +Ett fel uppstod. +.TP +\fB2\fP +Något värt en varning uppstod, men inga faktiska fel uppstod. +.PP +Noteringar (inte varningar eller fel) som skrivs på standard fel påverkar +inte slutstatusen. +. +.SH MILJÖ +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP tolkar mellanrumsseparerade listor av flaggor från miljövariablerna +\fBXZ_DEFAULTS\fP och \fBXZ_OPT\fP, i den ordningen, före flaggorna på +kommandoraden. Observera att endast flaggor tolkas från miljövariablerna; +alla andra argument än flaggor ignoreras tyst. Tolkningen görs med +\fBgetopt_long\fP(3) vilket även används för kommandoradsargumenten. +.PP +\fBVarning:\fP genom att sätta dessa miljövariabler ändrar man i praktiken +program och skript som kör \fBxz\fP. för det mesta är set säkert att sätta +begränsningar på minnesanvändning, antal trådar och komprimeringsflaggor via +miljövariablerna. Några flaggor kan dock göra att skript går sönder. Ett +uppenbart exempel är \fB\-\-help\fP vilket gör att \fBxz\fP visar en hjälptext +istället för att komprimera eller dekomprimera en fil. Mer subtila exempel +är \fB\-\-quiet\fP och \fB\-\-verbose\fP. I många fall fungerar det bra att aktivera +en förloppsindikator med \fB\-\-verbose\fP, men i några fall skapar de extra +meddelandena problem. Utförlighetsnivån påverkar även beteendet hos +\fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Användarspecifika eller systemspecifika standardflaggor. Typiskt sätts detta +i ett initieringsskript för skal för att aktivera \fBxz\fP:s begränsning av +minnesanvändning som standard eller att ställa in ett standardantal +trådar. Med undantag för skalinitieringsskript och liknande specialfall +skall skript aldrig sätta eller ta bort \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Detta är för att skicka flaggor till \fBxz\fP när det inte är möjligt att sätta +flaggorna direkt på kommandoraden för \fBxz\fP. Detta är fallet när \fBxz\fP körs +av ett skript eller verktyg, till exempel, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf apa.tar.xz apa\fR +.fi +.RE +.RE +.IP "" +Skript kan använda \fBXZ_OPT\fP, till exempel, för att sätta skriptspecifika +standardflaggor för komprimering. Det rekommenderas fortfarande att tillåta +användaren att åsidosätta \fBXZ_OPT\fP om det är rimligt. Till exempel, i +\fBsh\fP(1)\-skript kan man använda något i still med detta: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "KOMPATIBILITET MED LZMA UTILS" +Kommandoradssyntaxen för \fBxz\fP är praktiskt taget en utökning av \fBlzma\fP, +\fBunlzma\fP och \fBlzcat\fP så som de kommer från LZMA Utils 4.32.x. I de flesta +fall, är det möjligt att ersätta LZMA Utils med XZ Utils utan att göra +sönder befintliga skript. Det finns dock några inkompatibiliteter, vilka +ibland kan orsaka problem. +. +.SS "Komprimeringens förinställda nivåer" +Numreringen av förinställda nivåer för komprimering är inte identiska i +\fBxz\fP och LZMA Utils. Den viktigaste skillnade är hur lexikonstorlekar +avbildas till olika förinställningar. Lexikonstorleken är i stort sett lika +med dekomprimerarens minnesanvändning. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nivå;xz;LZMA Utils +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Lexikonstorlekens skillnader påverkar komprimerarens minnesanvändning också, +men det finns några andra skillnader mellan LZMA Utils och XZ Utils, vilket +gör skillnaden ännu större: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nivå;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Standardförinställningsninvån i LZMA Utils är \fB\-7\fP medan i XZ Utils är den +\fB\-6\fP, så båda använder ett 8 MiB lexikon som standard. +. +.SS "Strömmade visavi icke strömmade .lzma\-filer" +Den ikomprimerade storleken på filen kan lagras i huvudet i \fB.lzma\fP. LZMA +Utils gör det när den komprimerar normala filer. Alternativet är att markera +att den okomprimerade storleken är okänd och använda en markör för lastslut +för att indikera var dekomprimeraren skall stanna. LZMA Utils använder denna +metod när den okomprimerade storleken inte är känd, vilket är fallet, till +exempel, i rör. +.PP +\fBxz\fP stödjer dekomprimering av \fB.lzma\fP\-filer med eller utan markör för +lastslut, men alla \fB.lzma\fP filer som skapas av \fBxz\fP kommer använda markör +för lastslut och ha den okomprimerade storleken markerad som okänd i +\&\fB.lzma\fP\-huvudet. Detta kan bli ett problem i några ovanliga fall. Till +exempel kan en \fB.lzma\fP\-dekomprimerare i en inbäddad enhet fungera endast +med filer som har en känd okomprimerad storlek. Om man stöter på detta +problem behöver man använda LZMA Utils eller LZMA SDK för att skapa +\&\fB.lzma\fP\-filer med känd okomprimerad storlek. +. +.SS "Ej stödda .lzma\-filer" +Formatet \fB.lzma\fP tillåter värden på \fIlc\fP upp till 8, och värden på \fIlp\fP +upp till 4. LZMA Utils kan dekomprimera filer med godtyckliga \fIlc\fP och +\fIlp\fP, men skapar alltid filer med \fBlc=3\fP och \fBlp=0\fP. Att skapa filer med +andra \fIlc\fP och \fIlp\fP är möjligt med \fBxz\fP och med LZMA SDK. +.PP +Implementationen av LZMA1\-filtret i liblzma kräver att summan av \fIlc\fP och +\fIlp\fP inte överstiger 4. Alltså, \fB.lzma\fP\-filer, vilka överstiger denna +gräns, kan inte dekomprimeras med \fBxz\fP. +.PP +LZMA Utils skapar endast \fB.lzma\fP\-filer som har en lexikonstorlek på 2^\fIn\fP +(en potens av 2) men godtar filer med godtycklig lexikonstorlek. liblzma +godtar endast \fB.lzma\fP\-filer som har en lexikonstorlek på 2^\fIn\fP eller +2^\fIn\fP + 2^(\fIn\fP\-1). Detta är för att minska falska positiva vid detektering +av \fB.lzma\fP\-filer. +.PP +Dessa begränsningar bör inte vara ett problem i praktiken, eftersom +praktiskt taget alla \fB.lzma\fP\-filer har komprimerats med inställningar som +liblzma kommer godta. +. +.SS "Avslutande skräp" +Vid dekomprimering ignorerar LZMA Utils tyst allting efter den första +\&\fB.lzma\fP\-strömmen. I de flesta situationer är detta fel. Detta betyder även +att LZMA Utils inte stödjer dekomprimering av konkatenerade \fB.lzma\fP\-filer. +.PP +Om det finns data kvar efter den första \fB.lzma\fP\-strömmen betraktar \fBxz\fP +filen som trasig om inte \fB\-\-single\-stream\fP användes. Detta kan göra sönder +obskyra skript vilka har antagit att avslutande skräp ignoreras. +. +.SH NOTERINGAR +. +.SS "Den komprimerade utdatan kan variera" +Den exakta komprimerade utdatan som produceras från samma okomprimerade +indatafil kan variera mellan versioner av XZ Utils även om +komprimeringsflaggorna är identiska. Detta beror på att kodaren kan +förbättras (snabbare eller bättre komprimering) utan att påverka +filformatet. Utdatan kan variera även mellan olika byggen av samma version +av XZ Utils, om olika byggflaggor används. +.PP +Ovanstående betyder att när väl \fB\-\-rsyncable\fP har implementerats kommer +inte nödvändigtvis de resulterande filerna vara rsync\-bara om inte både +gamla och nya filer har komprimerats med samma version av xz. Detta problem +kan lösas om en del av kodarimplementeringen fryses för att hålla rsync\-bar +utdata stabil mellan xz\-versioner. +. +.SS "Inbäddade .xz\-dekomprimerare" +Inbäddade implementationer av \fB.xz\fP\-dekomprimerare som XZ Embedded stödjer +inte nödvändigtvis filer som skapas med andra typer av +integritets\fIkontroll\fP än \fBnone\fP och \fBcrc32\fP. Eftersom standardvärdet är +\fB\-\-check=crc64\fP måste man använda \fB\-\-check=none\fP eller \fB\-\-check=crc32\fP +när filer skapas för inbäddade system. +.PP +Utanför inbäddade system stödjer alla dekomprimerare av \fB.xz\fP\-format alla +typerna av \fIkontroller\fP, eller åtminstone kan de dekomprimera filern utan +att verifiera integritetskontrollen om den specifika \fIkontrollen\fP inte +stödjs. +.PP +XZ Embedded stödjer BCJ\-filter, men endast med standard startavstånd. +. +.SH EXEMPEL +. +.SS Grundläggande +Komprimera filen \fIapa\fP till \fIapa.xz\fP med standardkomprimeringsnivån +(\fB\-6\fP), och ta bort \fIapa\fP om komprimeringen lyckas: +.RS +.PP +.nf +\f(CRxz apa\fR +.fi +.RE +.PP +Dekomprimera \fIbepa.xz\fP till \fIbepa\fP och ta inte bort \fIbepa.xz\fP även om +dekomprimeringen lyckas: +.RS +.PP +.nf +\f(CRxz \-dk bepa.xz\fR +.fi +.RE +.PP +Skapa \fIcepa.tar.xz\fP med förinställningen \fB\-4e\fP (\fB\-4 \-\-extreme\fP), vilket +är långsammare än standardvärdet \fB\-6\fP, men behöver mindre minne till +komprimering och dekomprimering (48\ MiB respektive 5\ MiB): +.RS +.PP +.nf +\f(CRtar cf \- cepa | xz \-4e > cepa.tar.xz\fR +.fi +.RE +.PP +En blandning av komprimerade och okomprimerade filer kan dekomprimeras till +standard ut med ett enda kommando: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Parallell komprimering av många filer" +På GNU och *BSD kan \fBfind\fP(1) och \fBxargs\fP(1) användas för att +parallellisera komprimeringen av många filer: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Flaggan \fB\-P\fP till \fBxargs\fP(1) anger antalet parallella \fBxz\fP\-processer. Det +bästa värdet till flaggan \fB\-n\fP beror på hur många filer det finns som skapp +komprimeras. Om det bara finns några stycken filer bör värdet förmodigen +vara 1; med tiotusentals filer kan 100 eller mer vara lämpligt för att +reducera antalet \fBxz\fP\-processer som \fBxargs\fP(1) kommer att skapa. +.PP +Flaggan \fB\-T1\fP till \fBxz\fP finns för att tvinga den till enkeltrådsläge, +eftersom \fBxargs\fP(1) används för att styra mängden parallellisering. +. +.SS Robotläge +Beräkna hur många byt som har sparats totalt efter komprimering av flera +filer: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Ett skript kan vilja veta att det använder en tillräckligt ny +\fBxz\fP. Följande \fBsh\fP(1)\-skript kontrollerar att versionsnumret för +verktyget \fBxz\fP är åtminstone 5.0.0. Denna metod är kompatibel med gamla +betaversioner, vilka inte stödde flaggan \fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Din xz är för gammal." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Ange en gräns för minnesanvändning för dekomprimering med \fBXZ_OPT\fP, men om +en gräns redan har satts, öka den inte: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Anpassade komprimerarfilterkedjor" +Den enklaste användningen av anpassade filterkedjor är att anpassa en +LZMA2\-förinställning. Detta kan vara användbart eftersom förinställningarna +endast täcker en delmängd av de potentiellt användbara kombinationerna av +komprimeringsinställningar. +.PP +Kolumnerna CompCPU i tabellerna från beskrivningen av flaggorna options +\fB\-0\fP ... \fB\-9\fP och \fB\-\-extreme\fP är användbara vid anpassning av +LZMA2\-förinställningar. Här är de relevanta delarna samlade från dessa två +tabeller: +.RS +.PP +.TS +tab(;); +c c +n n. +Förinställning;KompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Om man vet att en fil behöver ett rätt stort lexikon (till exempel, 32\ MiB) +för att komprimeras bra, men man vill komprimera den snabbare än \fBxz \-8\fP +skulle gjort kan en förinställning med ett lågt värde på CompCPU (till +exempel, 1) ändras till att använda ett större lexikon: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB apa.tar\fR +.fi +.RE +.PP +Med vissa filer kan ovanstående kommando vara snabbare än \fBxz \-6\fP samtidigt +som det komprimerar betydligt bättre. Dock måste det påpekas att endast +några filer drar fördel av ett stort lexikon samtidigt som värdet CompCPU +hålls lågt. Den mest uppenbara situationen, är ett stort lexikon kan hälpa +till mycket, är ett arkiv som innehåller väldigt snarlika filer på åtmistone +några megabyte var. Lexikonstorleken måste vara signifikant större än någon +enskild fil för att låta LZMA2 dra full nytta av likheterna mellan på +varandra följande filer. +.PP +Om det går bra med väldigt hög minnesanvändning i komprimeraren och +dekomprimeraren, och filen som komprimeras är åtminstone flera hundra +megabyte, kan det vara användbart att använda ännu större lexikon än de 64 +MiB som \fBxz \-9\fP skulle använda: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB stor_apa.tar\fR +.fi +.RE +.PP +Att använda \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) som i exemplet ovan kan vara +användbart för att se minnesbehoven för komprimeraren och +dekomprimeraren. Kom ihåg att använda ett större lexikon än storleken på den +okomprimerade filen är slöseri med minne, så ovanstående kommando är inte +användbart för små filer. +.PP +Ibland spelar inte dekomprimeringstiden någon roll, men dekomprimerarens +minnesanvändning måste hållas låg, till exempel för att göra det möjligt att +dekomprimera filen på ett inbäddat system. Följande kommando använder \fB\-6e\fP +(\fB\-6 \-\-extreme\fP) som en bas och sätter lexikonstorleken till bara 64\ KiB. Den resulterande filen kan dekomprimeras med XZ Embedded (det är därför +det finns \fB\-\-check=crc32\fP) som använder ungerfär 100\ KiB minne. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB apa\fR +.fi +.RE +.PP +Om man vill krama ur så många byte som möjligt kan justering av antalet +literala kontextbitar (\fIlc\fP) och antalet positionsbitar (\fIpb\fP) ibland +hjälpa. Justering av antalet literala positionsbitar (\fIlp\fP) kan också +hjälpa, men vanligen är \fIlc\fP och \fIpb\fP viktigare. Till exempel innehåller +ett källkodsarkiv huvudsakligen US\-ASCII\-text, så något i stil med följande +kan ge aningen (som 0.1\ %) mindre fil än \fBxz \-6e\fP (försök även utan +\fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 källkod.tar\fR +.fi +.RE +.PP +Att använda ett annat filter tillsammans med LZMA2 kan förbättra +komprimeringen med vissa filtyper. Till exempel, för att komprimera ett +delat x86\-32\- eller x86\-64\-bibliotek med filtret x86 BCJ: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libapa.so\fR +.fi +.RE +.PP +Observera att ordningen på filterflaggorna spelar roll. Om \fB\-\-x86\fP anges +efter \fB\-\-lzma2\fP kommer \fBxz\fP avge ett fel, eftersom det inte kan vara något +filter efter LZMA2, och även för att filtret x86 BCJ inte kan användas som +det sista filtret i kedjan. +.PP +Deltafiltret tillsammans med LZMA2 gan ge bra resultat med +bitkartebilder. Det bör vanligen slå PNG, som har några mer avancerade +filter än enkla delta men använder Deflat för den faktiska komprimeringen. +.PP +Bilden måste sparas i okomprimerat format, till exempel som okomprimerad +TIFF. Avståndsparametern i Deltafiltret sätts till att motsvara natalet byte +per bildpunkt i bilden. Till exempel, 24\-bitars RGB bitkarta behöver +\fBdist=3\fP, och det är även bra att skicka \fBpb=0\fP till LZMA2 för att ge +plats för trebytejustering: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 apa.tiff\fR +.fi +.RE +.PP +Om flera bilder har lagts in i ett gemensamt arkiv (till exempel, \fB.tar\fP) +kommer Deltafiltret fungera på det också så länge alla bilder har samma +antal byte per bildpunkt. +. +.SH "SE ÄVEN" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzcmp.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzcmp.1 new file mode 100644 index 0000000000000000000000000000000000000000..2d1516dcb59720f083abf68f8101c5de6fb19a89 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzcmp.1 @@ -0,0 +1,54 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Swedish translation of xz-man +.\" Göran Uddeborg , 2025. +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 2025\-03\-06 Tukaani "XZ Utils" +.SH NAMN +xzcmp, xzdiff, lzcmp, lzdiff — jämför komprimerade filer +. +.SH SYNOPSIS +\fBxzcmp\fP [\fIflagga…\fP] \fIfil1\fP [\fIfil2\fP] +.br +\fBxzdiff\fP \&… +.br +\fBlzcmp\fP \&… (FÖRÅLDRAT) +.br +\fBlzdiff\fP \&… (FÖRÅLDRAT) +. +.SH BESKRIVNING +\fBxzcmp\fP och \fBxzdiff\fP jämför det okomprimerade innehållet i två +filer. Okomprimerad data skickas till \fBcmp\fP(1) eller \fBdiff\fP(1) såvida inte +\fB\-\-help\fP eller \fB\-\-version\fP anges. +.PP +Om både \fIfil1\fP och \fIfil2\fP anges kan de vara okomprimerade filer eller +filer i format som \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) +eller \fBlz4\fP(1) kan dekomprimera. De nödvändiga dekomprimeringskommandona +avgörs från filnamnsändelsen på \fIfil1\fP och \fIfil2\fP. En fil med en okänd +ändelse antas antingen vara okomprimerad eller i ett format som \fBxz\fP(1) kan +dekomprimera. +.PP +Om endast ett filnamn anges måste \fIfil1\fP ha en ändelse med ett av de stödda +komprimeringsformaten och namnet på \fIfil2\fP antas vara \fIfil1\fP med +komprimeringsformatsändelsen borttagen. +.PP +Kommandona \fBlzcmp\fP och \fBlzdiff\fP finns för bakåtkompatibilitet med LZMA +Utils. De rekommenderas inte och kommer tas bort i en framtida version. +. +.SH SLUTSTATUS +Om ett dekomprimeringsfel uppstår är slutstatus \fB2\fP. Annars används +slutstatusen från \fBcmp\fP(1) respektive \fBdiff\fP(1). +. +.SH "SE ÄVEN" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzdiff.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzdiff.1 new file mode 100644 index 0000000000000000000000000000000000000000..2d1516dcb59720f083abf68f8101c5de6fb19a89 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzdiff.1 @@ -0,0 +1,54 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Swedish translation of xz-man +.\" Göran Uddeborg , 2025. +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 2025\-03\-06 Tukaani "XZ Utils" +.SH NAMN +xzcmp, xzdiff, lzcmp, lzdiff — jämför komprimerade filer +. +.SH SYNOPSIS +\fBxzcmp\fP [\fIflagga…\fP] \fIfil1\fP [\fIfil2\fP] +.br +\fBxzdiff\fP \&… +.br +\fBlzcmp\fP \&… (FÖRÅLDRAT) +.br +\fBlzdiff\fP \&… (FÖRÅLDRAT) +. +.SH BESKRIVNING +\fBxzcmp\fP och \fBxzdiff\fP jämför det okomprimerade innehållet i två +filer. Okomprimerad data skickas till \fBcmp\fP(1) eller \fBdiff\fP(1) såvida inte +\fB\-\-help\fP eller \fB\-\-version\fP anges. +.PP +Om både \fIfil1\fP och \fIfil2\fP anges kan de vara okomprimerade filer eller +filer i format som \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) +eller \fBlz4\fP(1) kan dekomprimera. De nödvändiga dekomprimeringskommandona +avgörs från filnamnsändelsen på \fIfil1\fP och \fIfil2\fP. En fil med en okänd +ändelse antas antingen vara okomprimerad eller i ett format som \fBxz\fP(1) kan +dekomprimera. +.PP +Om endast ett filnamn anges måste \fIfil1\fP ha en ändelse med ett av de stödda +komprimeringsformaten och namnet på \fIfil2\fP antas vara \fIfil1\fP med +komprimeringsformatsändelsen borttagen. +.PP +Kommandona \fBlzcmp\fP och \fBlzdiff\fP finns för bakåtkompatibilitet med LZMA +Utils. De rekommenderas inte och kommer tas bort i en framtida version. +. +.SH SLUTSTATUS +Om ett dekomprimeringsfel uppstår är slutstatus \fB2\fP. Annars används +slutstatusen från \fBcmp\fP(1) respektive \fBdiff\fP(1). +. +.SH "SE ÄVEN" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzegrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzegrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..bf4653d6c7aed44d0f7fc53205f6d44e080f3ddc --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzegrep.1 @@ -0,0 +1,92 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Swedish translation of xz-man +.\" Göran Uddeborg , 2025. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 2025\-03\-06 Tukaani "XZ Utils" +.SH NAMN +xzgrep — sök i eventuellt komprimerade filer efter mönster +. +.SH SYNOPSIS +\fBxzgrep\fP [\fIflagga…\fP] [\fImönsterlista\fP] [\fIfil…\fP] +.br +\fBxzegrep\fP \&… +.br +\fBxzfgrep\fP \&… +.br +\fBlzgrep\fP \&… (FÖRÅLDRAT) +.br +\fBlzegrep\fP \&… (FÖRÅLDRAT) +.br +\fBlzfgrep\fP \&… (FÖRÅLDRAT) +. +.SH BESKRIVNING +\fBxzgrep\fP anropar \fBgrep\fP(1) på det okomprimerade innehållet i +filerna. Formaten på \fIfilerna\fP bestäms utgående från filnamnsändelsen. En +\fIfil\fP med en ändelse som stödjs av \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), +\fBlzop\fP(1), \fBzstd\fP(1) eller \fBlz4\fP(1) kommer att dekomprimeras; alla andra +filer antas vara okomprimerade. +.PP +Om inga \fIfiler\fP anges eller om \fIfil\fP är \fB\-\fP lästes standard in. När +standard in läses är de enda filerna som dekomprimeras de som stödjs av +\fBxz\fP(1). Andra filer antas redan vara i okomprimerad form. +.PP +De flesta \fIflaggor\fP till \fBgrep\fP(1) stödjs. Dock stödjs inte följande +flaggor: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIåtgärd\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIfil\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglob\fP +.PP +\fBxzegrep\fP är ett alias för \fBxzgrep \-E\fP. \fBxzfgrep\fP är ett alias för +\fBxzgrep \-F\fP. +.PP +Kommandona \fBlzgrep\fP, \fBlzegrep\fP och \fBlzfgrep\fP finns för +bakåtkompatibilitet med LZMA Utils. De rekommenderas inte och kommer tas +bort i en framtida version. +. +.SH SLUTSTATUS +.TP +0 +Åtminstone en matchning hittades från åtminstone en av infilerna. Inga fel +uppstod. +.TP +1 +Inga matchningar hittades i någon av infilerna. Inga fel uppstod. +.TP +>1 +Ett eller flera fel uppstod. Det är okänt om några matchningar hittades. +. +.SH MILJÖ +.TP +\fBGREP\fP +Om \fBGREP\fP är satt till något icketomt värde används det istället för +\fBgrep\fP, \fBgrep \-E\fP respektive \fBgrep \-F\fP. +. +.SH "SE ÄVEN" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzfgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzfgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..bf4653d6c7aed44d0f7fc53205f6d44e080f3ddc --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzfgrep.1 @@ -0,0 +1,92 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Swedish translation of xz-man +.\" Göran Uddeborg , 2025. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 2025\-03\-06 Tukaani "XZ Utils" +.SH NAMN +xzgrep — sök i eventuellt komprimerade filer efter mönster +. +.SH SYNOPSIS +\fBxzgrep\fP [\fIflagga…\fP] [\fImönsterlista\fP] [\fIfil…\fP] +.br +\fBxzegrep\fP \&… +.br +\fBxzfgrep\fP \&… +.br +\fBlzgrep\fP \&… (FÖRÅLDRAT) +.br +\fBlzegrep\fP \&… (FÖRÅLDRAT) +.br +\fBlzfgrep\fP \&… (FÖRÅLDRAT) +. +.SH BESKRIVNING +\fBxzgrep\fP anropar \fBgrep\fP(1) på det okomprimerade innehållet i +filerna. Formaten på \fIfilerna\fP bestäms utgående från filnamnsändelsen. En +\fIfil\fP med en ändelse som stödjs av \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), +\fBlzop\fP(1), \fBzstd\fP(1) eller \fBlz4\fP(1) kommer att dekomprimeras; alla andra +filer antas vara okomprimerade. +.PP +Om inga \fIfiler\fP anges eller om \fIfil\fP är \fB\-\fP lästes standard in. När +standard in läses är de enda filerna som dekomprimeras de som stödjs av +\fBxz\fP(1). Andra filer antas redan vara i okomprimerad form. +.PP +De flesta \fIflaggor\fP till \fBgrep\fP(1) stödjs. Dock stödjs inte följande +flaggor: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIåtgärd\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIfil\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglob\fP +.PP +\fBxzegrep\fP är ett alias för \fBxzgrep \-E\fP. \fBxzfgrep\fP är ett alias för +\fBxzgrep \-F\fP. +.PP +Kommandona \fBlzgrep\fP, \fBlzegrep\fP och \fBlzfgrep\fP finns för +bakåtkompatibilitet med LZMA Utils. De rekommenderas inte och kommer tas +bort i en framtida version. +. +.SH SLUTSTATUS +.TP +0 +Åtminstone en matchning hittades från åtminstone en av infilerna. Inga fel +uppstod. +.TP +1 +Inga matchningar hittades i någon av infilerna. Inga fel uppstod. +.TP +>1 +Ett eller flera fel uppstod. Det är okänt om några matchningar hittades. +. +.SH MILJÖ +.TP +\fBGREP\fP +Om \fBGREP\fP är satt till något icketomt värde används det istället för +\fBgrep\fP, \fBgrep \-E\fP respektive \fBgrep \-F\fP. +. +.SH "SE ÄVEN" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..bf4653d6c7aed44d0f7fc53205f6d44e080f3ddc --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzgrep.1 @@ -0,0 +1,92 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Swedish translation of xz-man +.\" Göran Uddeborg , 2025. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 2025\-03\-06 Tukaani "XZ Utils" +.SH NAMN +xzgrep — sök i eventuellt komprimerade filer efter mönster +. +.SH SYNOPSIS +\fBxzgrep\fP [\fIflagga…\fP] [\fImönsterlista\fP] [\fIfil…\fP] +.br +\fBxzegrep\fP \&… +.br +\fBxzfgrep\fP \&… +.br +\fBlzgrep\fP \&… (FÖRÅLDRAT) +.br +\fBlzegrep\fP \&… (FÖRÅLDRAT) +.br +\fBlzfgrep\fP \&… (FÖRÅLDRAT) +. +.SH BESKRIVNING +\fBxzgrep\fP anropar \fBgrep\fP(1) på det okomprimerade innehållet i +filerna. Formaten på \fIfilerna\fP bestäms utgående från filnamnsändelsen. En +\fIfil\fP med en ändelse som stödjs av \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), +\fBlzop\fP(1), \fBzstd\fP(1) eller \fBlz4\fP(1) kommer att dekomprimeras; alla andra +filer antas vara okomprimerade. +.PP +Om inga \fIfiler\fP anges eller om \fIfil\fP är \fB\-\fP lästes standard in. När +standard in läses är de enda filerna som dekomprimeras de som stödjs av +\fBxz\fP(1). Andra filer antas redan vara i okomprimerad form. +.PP +De flesta \fIflaggor\fP till \fBgrep\fP(1) stödjs. Dock stödjs inte följande +flaggor: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIåtgärd\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIfil\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglob\fP +.PP +\fBxzegrep\fP är ett alias för \fBxzgrep \-E\fP. \fBxzfgrep\fP är ett alias för +\fBxzgrep \-F\fP. +.PP +Kommandona \fBlzgrep\fP, \fBlzegrep\fP och \fBlzfgrep\fP finns för +bakåtkompatibilitet med LZMA Utils. De rekommenderas inte och kommer tas +bort i en framtida version. +. +.SH SLUTSTATUS +.TP +0 +Åtminstone en matchning hittades från åtminstone en av infilerna. Inga fel +uppstod. +.TP +1 +Inga matchningar hittades i någon av infilerna. Inga fel uppstod. +.TP +>1 +Ett eller flera fel uppstod. Det är okänt om några matchningar hittades. +. +.SH MILJÖ +.TP +\fBGREP\fP +Om \fBGREP\fP är satt till något icketomt värde används det istället för +\fBgrep\fP, \fBgrep \-E\fP respektive \fBgrep \-F\fP. +. +.SH "SE ÄVEN" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzless.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzless.1 new file mode 100644 index 0000000000000000000000000000000000000000..52b702820a9af7788772d2a30896263902aa1042 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzless.1 @@ -0,0 +1,47 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" Swedish translation of xz-man +.\" Göran Uddeborg , 2025. +.\" +.\" (Note that this file is not based on gzip's zless.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZLESS 1 2025\-03\-06 Tukaani "XZ Utils" +.SH NAMN +xzless, lzless — visa xz\- eller lzma\-komprimerade (text)filer +.SH SYNOPSIS +\fBxzless\fP [\fIfil\fP…] +.br +\fBlzless\fP [\fIfil\fP…] (FÖRÅLDRAT) +.SH BESKRIVNING +\fBxzless\fP är ett filter som visar text från komprimerade filer i en +terminal. Filer som stödjs av \fBxz\fP(1) dekomprimeras; andra filer antas +redan vara i okomprimerad form. Om inga \fIfiler\fP ges läser \fBxzless\fP från +standard in. +.PP +\fBxzless\fP använder \fBless\fP(1) för att visa sin utdata. Till skillnad mot +\fBxzmore\fP kan inte dess val av bläddrare ändras genom att sätta en +miljövariabel. Kommandon är baserade på både \fBmore\fP(1) och \fBvi\fP(1) och +tillåter förflytting fram och tillbaka samt sökning. Se manualen \fBless\fP(1) +för mer information. +.PP +Kommandot som heter \fBlzless\fP finns för bakåtkompatibilitet med LZMA +Utils. Det rekommenderas inte och kommer tas bort i en framtida version. +.SH MILJÖ +.TP +\fBLESSMETACHARS\fP +En lista på tecken som är speciella för skalet. Sätts av \fBxzless\fP om den +inte redan är satt i miljön. +.TP +\fBLESSOPEN\fP +Satt till en kommandorad för att köra dekomprimeraren \fBxz\fP(1) för +förbehandling av infiler till \fBless\fP(1). +.SH "SE ÄVEN" +\fBless\fP(1), \fBxz\fP(1), \fBxzmore\fP(1), \fBzless\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzma.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzma.1 new file mode 100644 index 0000000000000000000000000000000000000000..1fb596e1ab328783990b87c362f7f7761d73548e --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzma.1 @@ -0,0 +1,1954 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Swedish translation of xz-man +.\" Göran Uddeborg , 2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 2025\-03\-08 Tukaani "XZ Utils" +. +.SH NAMN +xz, unxz, xzcat, lzma, unlzma, lzcat — Komprimera eller dekomprimera .xz\- +och .lzma\-filer +. +.SH SYNOPSIS +\fBxz\fP [\fIflagga…\fP] [\fIfil…\fP] +. +.SH KOMMANDOALIAS +\fBunxz\fP är ekvivalent med \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP är ekvivalent med \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP är ekvivalent med \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP är ekvivalent med \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP är ekvivalent med \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +När man skriver skript som behöver dekomprimera filer rekommenderas det att +altid använda namnet \fBxz\fP mäd lämpliga argument (\fBxz \-d\fP eller \fBxz \-dc\fP) +istället för namnen \fBunxz\fP och \fBxzcat\fP. +. +.SH BESKRIVNING +\fBxz\fP är ett datakomprimeringsverktyg för allmänt bruk med en +kommandoradssyntax som liknar \fBgzip\fP(1) och \fBbzip2\fP(1). Det egna +filformatet är formatet \fB.xz\fP, men det föråldrade formatet \fB.lzma\fP som +anändes av LZMA\-verktyg och råa komprimerade strömmar utan huvuden för +behållarformatet stödjs också. Dessutom stödjs dekomprimering av formatet +\&\fB.lz\fP som används av \fBlzip\fP. +.PP +\fBxz\fP komprimerar och dekomprimerar varje \fIfil\fP i enlighet med det valda +arbetsläget. Om inga \fIfiler\fP anges eller \fIfil\fP är \fB\-\fP läser \fBxz\fP från +standard in och skriver den behandade datan på standard ut. \fBxz\fP kommer +vägra (visa ett felmeddelande och hoppa över \fIfilen\fP) att skriva +komprimerad data direkt till standard ut om det är en terminal. På samma +sätt kommer \fBxz\fP vägra att läsa komprimerade data från standard in om det +är en terminal. +.PP +Om inte \fB\-\-stdout\fP anges skrivs andra \fIfiler\fP än \fB\-\fP till en ny fil vars +namn härleds från käll\fIfilens\fP namn: +.IP \(bu 3 +Vid kompringering läggs suffixet till på målfilsformatet (\fB.xz\fP eller +\&\fB.lzma\fP) på slutet av källfilnamnet för att få målfilnamnet. +.IP \(bu 3 +Vid dekomprimering tas suffixet \fB.xz\fP, \fB.lzma\fP eller \fB.lz\fP bort från +filnamnet för att få målfilnamnet. \fBxz\fP känner även igen suffixen \fB.txz\fP +och \fB.tlz\fP, och ersätter dem med suffixet \fB.tar\fP. +.PP +Om målfilen redan finns visas ett felmeddelande och \fIfilen\fP hoppas över. +.PP +Utom när den skriver till standard ut kommer \fBxz\fP visa en varning och hoppa +över \fIfilen\fP om något av följande inträffar: +.IP \(bu 3 +\fIFil\fP är inte en vanlig fil. Symboliska länkar följs inte, och därför anses +de inte vara vanliga filer. +.IP \(bu 3 +\fIFil\fP har mer än en hård länk. +.IP \(bu 3 +\fIFil\fP har biten setuid, setgid eller sticky satt. +.IP \(bu 3 +Arbetsläget är satt till att komprimera och \fIfilen\fP har redan ett suffix +enligt målfilformatet (\fB.xz\fP eller \fB.txz\fP vid komprimering till formatet +\&\fB.xz\fP, och \fB.lzma\fP eller \fB.tlz\fP vid komprimering till formatet \fB.lzma\fP). +.IP \(bu 3 +Arbetsläget är satt till att dekomprimera och \fIfilen\fP har inte ett suffix +enligt något av de stödda filformaten (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP +eller \fB.lz\fP). +.PP +Efter att ha kunnat komprimera eller dekomprimera \fIfilen\fP kopierar \fBxz\fP +ägaren, gruppen, rättigheterna, åtkomsttiden och ändringstiden från +käll\fIfilen\fP till målfilen. Om kopieringen av grupp misslyckas ändras +rättigheterna så att målfilen inte blir åtkomlig för användare som inte har +rättigheter att komma åt käll\fIfilen\fP. \fBxz\fP stödjer inte kopiering av annan +metadata såsom åtkomststyrhingslistor eller utökade attribut ännu. +.PP +När målfilen har stängts framgångsrikt tas käll\fIfilen\fP bort såvida inte +\fB\-\-keep\fP angavs. Käll\fIfilen\fP tas aldrig bort om utdata skrevs till +standard ut eller om något fel inträffade. +.PP +Att skicka \fBSIGINFO\fP eller \fBSIGUSR1\fP till \fBxz\fP\-processen får den att +skriva ut förloppsinformation till standard fel. Detta är bara av begränsat +värde eftersom när standard fel går till en terminal så kommer användning av +\fB\-\-verbose\fP att skriva ut en automatiskt uppdaterande förloppsindikator. +. +.SS Minnesanvändning +\fBxz\fP:s minnesanvändning varierar från några få hundra kilobyte till flera +gigabyte beroende på komprimeringsinställningarna. Inställningen som +användes när en fil komprimerades avgör minnesbehovet hos +dekomprimeraren. Typiskt behöver dekomprimeraren 5\ % till 20\ % av +minnesbehovet som komprimeraren behöver när en fil skapas. Till exempel, att +dekomprimera en fil skapad med \fBxz \-9\fP kräver för närvarande 65\ MiB +minne. Ändå är det möjligt att ha \fB.xz\fP\-filer som behöver flera gigabyte +minne för att dekomprimeras. +.PP +Särskilt användare av äldre system kan finna möjligheten av väldigt stor +minnesanvändning störande. För att förhindra obehagliga överraskningar har +\fBxz\fP en inbyggd minnesanvändningsbegränsare, vilken är avaktiverad som +standard. Även om vissa operativsystem kan tillhandahålla möjligheter att +begränsa minnesanvändningen hos processer bedömdes det inte som flexibelt +nog att lita på det (till exempel, att använda \fBulimit\fP(1) för att begränsa +det virtuella minnet tenderar att hämma \fBmmap\fP(2). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Minnesanvändningsbegränsaren kan aktiveras med kommandoradsflaggan +\fB\-\-memlimit=\fP\fIgräns\fP. Ofta är det bekvämare att aktivera begränsaren som +standard genom att sätta miljövariabeln \fBXZ_DEFAULTS\fP, till exempel, +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Det är möjligt att sätta gränser separat +för komprimering och dekomprimering genom att använda +\fB\-\-memlimit\-compress=\fP\fIlimit\fP och \fB\-\-memlimit\-decompress=\fP\fIlimit\fP. Att +använda dessa två flaggor utanför \fBXZ_DEFAULTS\fP är sällan meningsfullt +eftersom en enskild körning av \fBxz\fP inte kan göra både komprimering och +dekomprimering och and \fB\-\-memlimit=\fP\fIgräns\fP (eller \fB\-M\fP \fIgräns\fP) är +kortare att skriva på kommandoraden. +.PP +Om den angivna minnesanvändningsgränsen överskrid vid dekomprimering kommer +\fBxz\fP visa ett fel och dekomprimeringen av filen misslyckas. Om gröensen +överskrids vid komprimering kommer \fBxz\fP försöka skala ner inställningen så +att gränsen inte längre överskrids (utom när \fB\-\-format=raw\fP eller +\fB\-\-no\-adjust\fP används). På detta sätt kommer åtgärden inte misslyckas om +inte gränsen är väldigt liten. Skalningen av inställningen görs i steg som +inte matchar de förinställda komprimeringsnivåerna, till exempel, om gränsen +endast är något mindre än den mängd som behövs till \fBxz \-9\fP kommer +inställningen bara skalas ner lite, inte hela vägen ner till \fBxz \-8\fP. +. +.SS "Konkatenering och utfyllnad av .xz\-filer" +Det är möjligt att konkatenera \fB.xz\fP\-filer som de är. \fBxz\fP kommer +dekomprimera sådana filer som om de vore en enda \fB.xz\fP\-fil. +.PP +Det är möjligt att infoga utfyllnad mellan de konkatenerade delarna eller +efter den sista delen. Utfyllnaden måste bestå av null\-bytear och storleken +på utfyllnaden måste vara en multipel av fyra byte. Detta kan vara +användbart, till exempel, om \fB.xz\fP\-filen lagras på ett medium som mäter +filstorlekar i 512\-byteblock. +.PP +Konkaternering och utfyllnad är inte tillåtet med \fB.lzma\fP\-filer eller råa +strömmar. +. +.SH FLAGGOR +. +.SS "Heltalssuffix och speciella värden" +På de flesta platser där ett heltalsargument förväntas stödjs ett frivilligt +suffix för att enkelt indikera stora heltal. Det får inte finnas något +mellanrumm mellan heltalet och suffixet. +.TP +\fBKiB\fP +Multiplicera heltalet med 1 024 (2¹⁰). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP och \fBKB\fP är +tillåtna som synomymer till \fBKiB\fP. +.TP +\fBMiB\fP +Multiplicera heltalet med 1 048 576 (2²⁰). \fBMi\fP, \fBm\fP, \fBM\fP och \fBMB\fP är +tillåtna som synomymer till \fBMiB\fP. +.TP +\fBGiB\fP +Multiplicera heltalet med 1 073 741 824 (2³⁰). \fBGi\fP, \fBg\fP, \fBG\fP och \fBGB\fP +är tillåtna som synonymer till \fBGiB\fP. +.PP +Specialvärdet \fBmax\fP kan användas för att indikera det maximala heltalet som +stödjs av flaggan. +. +.SS Arbetsläge +Om flera arbetslägesflaggor ges gäller den sista. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Komprimera. Detta är standardarbetsläget när ingen arbetslägesflagga anges +och inget annat arbetsläge impliceras från kommandonamnet (till exempel +implicerar \fBunxz\fP \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Efter lyckad komprimering källfilen bort såvida man inte skriver till +standard ut eller \fB\-\-keep\fP angavs. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Dekomprimera. Efter lyckad dekomprimering tas källfilen bort såvida man inte +skriver till standard ut eller \fB\-\-keep\fP angavs. +.TP +\fB\-t\fP, \fB\-\-test\fP +Testa integriteten hos komprimerade \fIfiler\fP. Denna flagga är ekvivalent med +\fB\-\-decompress \-\-stdout\fP förutom att den dekomprimerade datan slängs +istället för att skrivas på standard ut. Inga filer skapas eller tas bort. +.TP +\fB\-l\fP, \fB\-\-list\fP +Skriv information om komprimerade \fIfiler\fP. Inge dekomprimeringsutdata +skapas, och inga filer skapas eller tas bort. I listläge kan programmet inte +läsa komprimerad data från standard in eller från andra källor där man inte +kan söka. +.IP "" +Standardlistningen visar grundläggande information om \fIfiler\fP, en fil per +rad. För att få mer detaljerad information, använd även flaggan +\fB\-\-verbose\fP. För ännu mer information, använd \fB\-\-verbose\fP två gånger, men +observera att detta kan vara långsamt, eftersom det behövs många sökningar +får att samla all den extra informationen. Bredden av utförlig utdata +överskrider 80 tecken, så att skicka utdata i ett rör till, till exempel, +\fBless\ \-S\fP kan vara bekvämt om terminalen inte är bred nog. +.IP "" +Den exakta utdatan kan variera mellan versioner av \fBxz\fP och olika +lokaler. För maskinläsbar utdata bör \fB\-\-robot \-\-list\fP användas. +. +.SS Arbetsmodifierare +.TP +\fB\-k\fP, \fB\-\-keep\fP +Ta inte bort indatafilerna. +.IP "" +Från \fBxz\fP 5.2.6 gör denna flagga även att \fBxz\fP komprimerar eller +dekomprimerar även om indatan är en symbolisk länk till en normal fil, har +mer än en hård länk eller har biten setuid, setgid eller sticky +satt. Bitarna setuid, setgid och sticky kopieras inte till målfilen. I +tidigare versioner gjordes detta bara med \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Denna flagga har flera funktioner: +.RS +.IP \(bu 3 +Om målfilen redan finns, radera den före komprimering eller dekomprimering. +.IP \(bu 3 +Komprimera eller dekomprimera även om indatan är en symbolisk länk till en +normal fil, har mer än en hård länk eller har biten setuid, setgid eller +sticky satt. Bitarna setuid, setgid och sticky kopieras inte till målfilen. +.IP \(bu 3 +När den används med \fB\-\-decompress\fP \fB\-\-stdout\fP och \fBxz\fP inte känner igen +typen på källfilen, kopiera källfilen som den är till standard ut. Detta gör +att \fBxzcat\fP \fB\-\-force\fP kan användas som \fBcat\fP(1) för filer som inte har +komprimerats med \fBxz\fP. Observera att i framtiden kan \fBxz\fP komma att stödja +nya komprimeringsfilformat, vilket kan få \fBxz\fP att dekomprimera fler typer +av filer istället för att kopiera dem till standard ut. +\fB\-\-format=\fP\fIformat\fP kan användas för att begränsa \fBxz\fP till att +dekomprimera endast ett enda filformat. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Skriv den komprimerade eller dekomprimerade datan till standard ut istället +för en fil. Detta implicerar \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Dekomprimera endast den första \fB.xz\fP\-strömmen, och ignorera tys eventuella +återstående indata som följer efter strömmen. Normalt får sådant avslutande +skräp \fBxz\fP att visa ett fel. +.IP "" +\fBxz\fP dekomprimerar aldrig mer än en ström från \fB.lzma\fP\-filer eller råa +strömmar, men denna flagga gör ändå att \fBxz\fP ignorerar den möjliga +efterföljande datan efter \fB.lzma\fP\-filen eller den råa strömmen. +.IP "" +Denna flagga har ingen effekt om arbetsläget inte är \fB\-\-decompress\fP eller +\fB\-\-test\fP. +.IP "" +Sedan \fBxz\fP 5.7.1alpha, implicerar \fB\-\-single\-stream\fP \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Avaktivera att glesa filer skapas. Som standard, om den dekomprimerar till +en normal fil, försöker \fBxz\fP att göra filen gles om den dekomprimerade +datan innehåller långa sekvenser av binära nollor. Det fungerar även när den +skriver till standard ut så länga standard ut är kopplad till en normal fil +och vissa ytterligare villkor möts för att göra det säkert. Att skapa glesa +filer kan spara diskutrymme och snabba upp dekomprimeringen genom att +begränsa mängden disk\-I/O. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Vid komprimering, använd \fI.suf\fP som suffixet för målfilen istället för +\&\fB.xz\fP eller \fB.lzma\fP. Om den inte skriver till standard ut och källfilen +redan har suffixet \fI.suf\fP visas en varning och filen hoppas över. +.IP "" +Vid dekomprimering, känn igen filer med suffixet \fI.suf\fP utöver filer +medsuffixen \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP eller \fB.lz\fP. Om källfilen +har suffixet \fI.suf\fP tas suffixet bort för att få målfilnamnet. +.IP "" +Vid komprimering eller dekomprimering av råa strömmar (\fB\-\-format=raw\fP) +måste alltid suffixet anges om den inte skriver till standard ut, eftersom +det inte finns något standardsuffix för råa strömmar. +.TP +\fB\-\-files\fP[\fB=\fP\fIfil\fP] +Läs filnamnen att arbeta på från \fIfil\fP; om \fIfil\fP utelämnas läses filnamn +från standard in. Filnamn måste avslutas med nyradstecknet. Ett bindestreck +(\fB\-\fP) tas som ett vanligt filnamn; det betyder inte standard in. Om filnamn +även anges som kommandoradsargument, bearbetas de före filnamnen som läses +från \fIfil\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIfil\fP] +Detta är identiskt med \fB\-\-files\fP[\fB=\fP\fIfil\fP] förjutom att varje filnamn +måste avslutas med ett nulltecken. +. +.SS "Grundläggande flaggor för filformat och komprimering" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fIformat\fP +Angi filens \fIformat\fP att komprimera eller dekomprimera: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Detta är standard. Vid komprimering är \fBauto\fP ekvivalent med \fBxz\fP. Vid +dekomprimering detekteras automatiskt formatet på indatafilen. Observera att +råa strömmar (skapade med \fB\-\-format=raw\fP inte kan detekteras automatiskt. +.TP +\fBxz\fP +Komprimera till filformatet \fB.xz\fP, eller acceptera endast \fB.xz\fP\-filer vid +dekomprimering. +.TP +\fBlzma\fP, \fBalone\fP +Komprimera till det föråldrade filformatet \fB.lzma\fP, eller acceptera endast +\&\fB.lzma\fP\-filer fid dekomprimering. Det alternativa namnet \fBalone\fP +tillhandahålls för bakåtkompatibilitet med LZMA Utils. +.TP +\fBlzip\fP +Acceptera endast \fB.lz\fP\-filer vid dekomprimering. Komprimering stödjs inte. +.IP "" +\&\fB.lz\fP\-formatet version 0 och 1 stödjs. Version 0\-filer producerades av +\fBlzip\fP 1.3 och tidigare. Sådana filer är inte vanliga men kan hittas från +filarkiv eftersom några källpaket släpptes i detta format. Folk kan ha även +ha gamla personliga filer i detta format. Dekomprimeringsstöd för format +version 0 togs bort i \fBlzip\fP 1.18. \fBlzip\fP 1.4 och senare kan skapa filer i +formatversion 1. +.TP +\fBraw\fP +Komprimera eller dekomprimera en rå ström (inga huvuden). Detta är endast +avsett för avancerade användare. För att avkoda råa strömmar behöver man +använda \fB\-\-format=raw\fP och explicit angi filterkedjan, vilken normalt +skulle ha lagrats i behållarens huvuden. +.RE +.TP +\fB\-C\fP \fIkontroll\fP, \fB\-\-check=\fP\fIkontroll\fP +Ange typen av integritetskontroll. Kontrollen beräknas från den +dekomprimerade datan och lagras i \fB.xz\fP\-filen. Denna flagga har endast +någon inverkan när man komprimerar till formatet \fB.xz\fP; formatet \fB.lzma\fP +stödjer inte integritetskontroller. Integritetskontrollen (om någon) +verifieras när \fB.xz\fP\-filen dekomprimeras. +.IP "" +\fIKontroll\fPtyper som stödjs: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Beräkna inte någon integritetskontroll alls. Detta är normalt en dålig +idé. Det kan vara användbart när datans integritet ändå verifieras på andra +sätt. +.TP +\fBcrc32\fP +Beräkna CRC32 med polynomet från IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Beräkna CRC64 med polynomet från ECMA\-182. Detta är standard, eftersom det +är något bättre än CRC32 på att upptäcka skadade filer och +hastighetsskillnaden är försumbar. +.TP +\fBsha256\fP +Beräkna SHA\-256. Detta är något långsammare än CRC32 och CRC64. +.RE +.IP "" +Integriteten hos \fB.xz\fP\-huvuden verifieras alltid med CRC32. Det är inte +möjligt att ändra eller avaktivera det. +.TP +\fB\-\-ignore\-check\fP +Verifiera inte integritetskontrollen av den komprimerade datan vid +dekomprimering. CRC32\-värden i \fB.xz\fP\-huvudena kommer fortfarande verifieras +normalt +.IP "" +\fBAnvänd inte denna flagga om du inte vet vad du gör.\fP Möjliga anledningar +till att använda denna flagga: +.RS +.IP \(bu 3 +Försöka återvinna data från en trasig .xz\-fil. +.IP \(bu 3 +Snabba upp dekomprimering. Detta har störst betydelse med SHA\-256 eller med +filer som har komprimerats extremt mycket. Det rekommenderas att inte +använda denna flagga för detta ändamål om inte filintegriteten verifieras +externt på något annat sätt. +.RE +.TP +\fB\-0\fP … \fB\-9\fP +Välj en förinställningsnivå för komprimering. Standard är \fB\-6\fP. Om flera +förinställningsnivåer anges gäller den sist angivna. Om en anpassad +fileterkedja redan angivits gör en inställning av en förinställningsnivå för +komprimering att den anpassade filterkedjan töms. +.IP "" +Skillnaden mellan förinställningarna har större betydelse än med \fBgzip\fP(1) +och \fBbzip2\fP(1). Den valda komprimeringsinställningen avgör minneskraven för +dekomprimeraren, att använda en för hög förinställningsnivå kan alltså göra +det plågsamt att dekomprimera filer på ett gammalt system med lite +RAM. Specifikt \fBär det inte en bra ide att blint använda \-9 för allt\fP +liksom det ofta är med \fBgzip\fP(1) och \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP … \fB\-3\fP +Dessa är ganska snabba förinställningar. \fB\-0\fP är ibland snabbare än \fBgzip \-9\fP samtidigt som komprimeringen är mycket bättre. De högre har ofta +hastighet jämförbar med \fBbzip2\fP(1) med jämförbar eller bättre +komprimeringsförhållande, även om resultatet mycket beror på typen av data +som komprimeras. +.TP +\fB\-4\fP … \fB\-6\fP +Bra för väldigt god komprimering samtidigt som dekomprimerarens +minnesanvändning hålls rimlig även på gamla system. \fB\-6\fP är standardvärdet, +vilket vanligen är ett bra val för att distribuera filer so behöver +dekomprimeras även på ssytem med endast 16\ MiB RAM. (\fB\-5e\fP eller \fB\-6e\fP +kan också vara värda att överväga. Se \fB\-\-extreme\fP.) +.TP +\fB\-7 … \-9\fP +Dessa liknar \fB\-6\fP med med högre krav på minne till komprimerare och +dekomprimerare. Dessa är bara användbara vid komprimering av filer större än +8\ MiB, 16\ MiB respektive 32\ MiB. +.RE +.IP "" +På samma hårdvara är dekomprimeringshastigheten ungefär ett konstant antal +byt av komprimerad data per sekund. Med andra ord, ju bättre komprimering, +desto snabbare kommer dekomprimeringen vanligen vara. Detta betyder även att +mängden av okomprimerad utdata skapad per sekund kan variera mycket. +.IP "" +Följande tabell sammanfattar funktionerna hos förinställningarna: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Förinställning;LexStrl;KompCPU;KompMin;DekMin +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Kolumnbeskrivningar: +.RS +.IP \(bu 3 +LexStrl är storleken på LZMA2:s lexikon. Det är slöseri med minne att +använda ett större lexikon än storleken på den okomprimerade filen. Detta är +anledningen till att det är bra att undvika förinställningarna \fB\-7\fP … \fB\-9\fP +när det inte finns något verkligt behov av dem. På \fB\-6\fP och lägre är +mängden bortslösat minne vanligen litet nog att inte ha någon betydelse. +.IP \(bu 3 +KompCPU är en förenklad representation av LZMA2\-inställningar som påverkar +komprimeringshastigheten. Lexikonstorleken påverkar också hastigheten, så +medan KompCPU är samma för nivåerna \fB\-6\fP … \fB\-9\fP tenderar fortfarande högre +nivåer att vara lite långsmmare. För ännu långsammare och möjligen bättre +komprimering, se \fB\-\-extreme\fP. +.IP \(bu 3 +KompMem innehåller komprimerarens minneskrav i enkeltrådat läge. Det kan +variera något mellan versioner av \fBxz\fP. +.IP \(bu 3 +DekMin innehåller dekomprimerarens minneskrav. Det vill säga, komprimerarens +inställningar avgör minneskravet för dekomprimeraren. Den exakta +minnesanvändningen hos dekomprimeraren är något mer än +LZMA2\-lexikonstorleken, men värdena i tabellen har avrundats upp till nästa +nästa hela MiB. +.RE +.IP "" +Minneskravet för det multitrådade läget är signifikant högre än det för +enkeltrådat läge. Med standardvärdet på \fB\-\-block\-size\fP behöver varje tråd +3·3·LexStrl plus KompMin eller DekMin. Till exempel, fyra trådar med +förinställningen behöver 660\(en670 MiB minne. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Använd en långsammare variant av den valda förinställningsnivån för +komprimering (\fB\-0\fP … \fB\-9\fP) för att förhoppningsvis få lite bättre +komprimeringsförhållande, men med otur kan detta även göra det +sämre. Dekomprimerarens minnesanvändning påverkas inte, men komprimerarens +minnesanvändning ökar lite vid förinställningsnivåerna \fB\-0\fP … \fB\-3\fP. +.IP "" +Eftersom det finns två förinställningar med lexikonstorlekar 4\ MiB och 8\ MiB använder förinställningarna \fB\-3e\fP och \fB\-5e\fP något snabbare +inställningar (lägre KompCPU) än \fB\-4e\fP respektive \fB\-6e\fP. På det sättet är +inte två förinställningar identiska. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Förinställning;LexStrl;KompCPU;KompMin;DekMin +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Till exempel finns det totalt fyra förinställningar som använder 8\ MiB +lexikon, vars ordning från den snabbaste till den långsammaste är \fB\-5\fP, +\fB\-6\fP, \fB\-5e\fP och \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Dessa är något missledande alias för \fB\-0\fP respektive \fB\-9\fP. Dessa finns +endast för bakåtkompatibilitet med LZMA\-verktyg. Undvik att använda dessa +flaggor. +.TP +\fB\-\-block\-size=\fP\fIstorlek\fP +Vid komprimering till formatet \fB.xz\fP, dela indatai block med \fIstorlek\fP +bytes. Blocken komprimeras oberoende av varandra, vilket hjälper till vid +multitrådning och gör begränsad random\-access\-dekomprimering möjlig. Denna +flagga används typiskt för att åsidosätta blockstorleken i multitrådat läge, +men denna flagga kan användas även i enkeltrådat läge. +.IP "" +I multitrådat läge kommer ungefär tre gånger \fIstorlek\fP byte att allokeras i +varje tråd för buffring av indata och utdata. Standardvärdet på \fIstorlek\fP +är det större av tre gånger LZMA2\-lexikonstorleken eller 1 MiB. Typiskt är +ett bra värde 2\(en4 gånger storleken på LZMA2\-lexikonet eller åtminstone 1 +MiB. Att använda en \fIstorlek\fP mindre än LZMA2\-lexikonstorleken utgör +slöseri med RAM eftersom LZMA2\-lexikonbufferten då aldrig kommer användas +helt. I multitrådat läge lagras storlekarna på plocken i +blockhuvudena. Denna storleksinformation krävs för multitrådad +dekomprimering. +.IP "" +I singletrådat läge görs som standard ingen uppdelning i block. Att göra +denna inställning påverark inte minnesanvändningen. Ingen +storleksinformation lagras i blockhuvuden, därmed kommer filer som skapas i +enkeltrådat läge inte att vara identiska med filer skapade i multitrådat +läge. Avsaknaden av sotrleksinformation betyder också att \fBxz\fP inte kommer +kunna dekomprimera filerna i multitrådat läge. +.TP +\fB\-\-block\-list=\fP\fIposter\fP +Vid komprimering till formatet \fB.xz\fP, börja ett nytt block med en möjlig +anpassad filterkedja efter de angivna intervallen med okomprimerade data. +.IP "" +\fIPosterna\fP är en kommaseparerad lista. Varje post består av ett möjligt +filterkedjenummer mellan 0 och 9 följt av ett kolon (\fB:\fP) och en +obligatorisk storlek för okomprimerade data. Att utelämna en post (två på +varandra följande komman) är en kortform för att använda storleken och +filtren från föregående post. +.IP "" +Om indatafiler är större än summan av storlekarna i \fIposter\fP repeteras den +sista posten fram till slutet på filen. Ett speciellt värde \fB0\fP kan +användas som den sista storleken för att indikera att resten av filen skall +kodas som ett enda block. +.IP "" +En alternativ filterkedja för varje block kan anges i kombinaton med +flaggorna \fB\-\-filters1=\fP\fIfilter\fP \&…\& \fB\-\-filters9=\fP\fIfilter\fP. Dessa +flaggor definierar filterkedjor med en identifierare mellan +1\(en9. Filterkedja 0 kan användas för att referera till +standardfilterkedjan, vilket är samma sak som att inte ange någon +filterkedja. Filterkedjeidentifierare kan användas före den okomprimerade +sotrleken, följt av ett kolon (\fB:\fP). Till exempel, om man anger +\fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP kommer block skapas med: +.RS +.IP \(bu 3 +Filterkedjan angiven av \fB\-\-filters1\fP och 2 MiB indata +.IP \(bu 3 +Filterkedjan angiven av \fB\-\-filters3\fP och 2 MiB indata +.IP \(bu 3 +Filterkedjan angiven av \fB\-\-filters2\fP och 4 MiB indata +.IP \(bu 3 +Filterkedjan angiven av \fB\-\-filters2\fP och 4 MiB indata +.IP \(bu 3 +Standardfilterkedjan och 2 MiB indata +.IP \(bu 3 +Standardfilterkedjan och 4 MiB indata för varje block till slutet av indata. +.RE +.IP "" +Om man anger en storlek som överskrider kodarens blockstorlek (antingen +standardvärdet i trådat läge eller värdet som anges med +\fB\-\-block\-size=\fP\fIstorlek\fP) kommer kodaren skapa ytterligare block med +hänsyn taget till gränserna som anges i \fIposter\fP. Till exempel, om man +anger \fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP och +indatafilen är 80 MiB kommer man få 11 block: 5, 10, 8, 10, 2, 10, 10, 4, +10, 10 och 1 MiB. +.IP "" +I multitrådat läge lagras storleken på blocken i blockhuvudena. Detta görs +inte i enkeltrådat läge, så den kodade utdatan kommer inte vara identisk med +den från det multitrådade läget. +.TP +\fB\-\-flush\-timeout=\fP\fItidsgräns\fP +Vid komprimering, om mer än \fItidsgräns\fP millisekunder (ett positivt heltal) +har gått sedan den föregånde tömningen och en läsning av mer indata skulle +blockera töms all väntande indata från kodaren och görs tillgänglig i +utdataströmmen. Detta kan vara användbart om \fBxz\fP används för att +komprimera data som strömmas över ett nätverk. Små värden på \fItidsgräns\fP +gör data tillgänglig vid den mottagande änden med en liten fördröjning, men +större värden på \fItidsgräns\fP ger bättre komprimeringsförhållande. +.IP "" +Denna funktion är avaktiverad som standard. Om denna flagga anges mer än en +gång gäller den sista. Dett speciella värdet \fB0\fP på \fItidsgräns\fP kan +användas för att uttryckligen avaktivera denna funktion. +.IP "" +Denna funktion är inte tillgänglig på icke\-POSIX\-system. +.IP "" +.\" FIXME +\fBDenna funktion är fortfarande experimentell.\fP För närvarande är \fBxz\fP +olämplig för dekomprimering av strömmen i realtid på grund av hur \fBxz\fP +buffrar. +.TP +\fB\-\-no\-sync\fP +Synkronisera inte målfilen och dess katalog med lagringsenheten före +källfilen tas bort. Detta kan förbättra prestanda vid komprimering eller +dekomprimering av många små filer. Dock, om systemet kraschar snart efter +raderingen är det möjligt att målfilen inte skrevs till lagringsenheten men +att raderingen gjordes det. I det fallet är varken originalkällfilen eller +målfilen tillgänglig. +.IP "" +Denna flagga har bara någon effekt när \fBxz\fP kommer att ta bort källfilen. I +andra fall görs aldrig någon synkronisering. +.IP "" +Synkroniseringen och \fB\-\-no\-sync\fP lades till i \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIgräns\fP +Sätt en gräns på minnesanvändningen för komprimeringen. Om denna flaggan +anges flera gånger gäller den sista. +.IP "" +Om komprimeringsinställnigarna överskrider \fIgränsen\fP kommer \fBxz\fP försöka +justera inställningarna neråt så att gränsen inte längre överskrids och visa +en notis om att en automatisk justering gjorts. Justeringen görs i denna +ordning: reducera antalet trådar, byta till enkeltrådat läge om även en tråd +i multitrådat läge överskrider \fIgränsen\fP och slutligen reducera +LZMA2\-lexikonstorleken. +.IP "" +Vid komprimering med \fB\-\-format=raw\fP eller om \fB\-\-no\-adjust\fP har angetts kan +endast antalet trådar reduceras eftersom det kan göras utan att påverka den +komprimerade utdatan. +.IP "" +Om \fIgränsen\fP inte kan uppfyllas ens med justeringarna som beskrivs ovan +visas ett felmeddelande och \fBxz\fP kommer avsluta med slutstatus 1. +.IP "" +\fIGränsen\fP kan anges på flera sätt: +.RS +.IP \(bu 3 +\fIGränsen\fP kan vara ett absolut värde i byte. Att använda ett heltalssuffix +som \fBMiB\fP kan vara praktiskt. Exempel: \fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +\fIGränsen\fP kan anges som en procentsats av det totala fysiska minnet +(RAM). Detta kan vara användbart särskilt när man sätter miljövariabeln +\fBXZ_DEFAULTS\fP i ett skalinitieringsskript som delas mellan olika +datorer. På det sättet är gränsen automatiskt större på system med mer +minne. Exempel: \fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +\fIGränsen\fP kan återställas tillbaka till sitt standardvärde genom att sätta +den till \fB0\fP. Detta är för närvarande ekvivalent med att sätta \fIgränsen\fP +till \fBmax\fP (ingen gräns på minnesanvändning). +.RE +.IP "" +För 32\-bitars \fBxz\fP finns det ett specialfall: om \fIgränsen\fP skulle vara +över \fB4020\ MiB\fP sätts \fIgränsen\fP till \fB4020\ MiB\fP. På MIPS32 används +\fB2000\ MiB\fP istället. (Värdena \fB0\fP och \fBmax\fP påverkas inte av detta. En +liknande funktion finns inte för dekomprimering.) Detta kan hjälpa till när +ett 32\-bitarsprogram har tillgång till 4\ GiB adressrymd (2 GiB på MIPS32) +förhoppningsvis utan att göra någon skada i andra situationer. +.IP "" +Se även avsnittet \fBMinnesanvändning\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIgräns\fP +Sätt en gräns för minnesanvnändningen vid dekomprimering. Detta påverkar +även läget \fB\-\-list\fP. Om åtgärden inte är möjlig utan att överskrida +\fIgränsen\fP kommer \fBxz\fP visa ett felmeddelande och dekomprimeringen av filen +kommer misslyckas. Se \fB\-\-memlimit\-compress=\fP\fIgräns\fP för möjliga sätt att +ange \fIgränsen\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIgräns\fP +Sätt en gräns för minnesanvändningen för multitrådad dekomprimering. Detta +kan endast påverka antalet trådar; det kommer aldrig att få \fBxz\fP att vägra +att dekomprimera en fil. Om \fIgränsen\fP är för låg för att tillåta någon +multitrådning ignoreras \fIgränsen\fP och \fBxz\fP kommer gå vidare i enkeltrådat +läge. Observera att om även \fB\-\-memlimit\-decompress\fP används kommer det +alltid att gälla både enkeltrådat och multitrådat läge, och därmed kommer +den gällande \fIgränsen\fP för multitrådning aldrig vara högre än gränsen som +sätts med \fB\-\-memlimit\-decompress\fP. +.IP "" +Till skillnad mot de andra flaggorna för gränser för minnesanvändning har +\fB\-\-memlimit\-mt\-decompress=\fP\fIgräns\fP en systemspecifik +standard\fIgräns\fP. \fBxz \-\-info\-memory\fP kan användas för att se det aktuella +värdet. +.IP "" +Denna flagga och dess standardvärde finns för att utan någon gräns skulle +den trådade dekomprimeraren kunna allokera en vansinnig mängd minne med +några indatafiler. Om standard\fIgränsen\fP är för låg på ditt system, öka då +gärna \fIgränsen\fP men sätt den aldrig till ett större värde än mängden +användbart RAM eftersom att med passande indatafiler kommer \fBxz\fP försöka +använda den mängden av minne även med ett lågt antal trådar. Att få slut på +minne ller växling kommer inte förbättra dekomprimeringsprestandan. +.IP "" +Se \fB\-\-memlimit\-compress=\fP\fIgräns\fP för möjliga sätt att ange \fIgränsen\fP. Att +sätta \fIgräns\fP till \fB0\fP återställer \fIgränsen\fP till sdet systemspecifika +standardvärdet. +.TP +\fB\-M\fP \fIgräns\fP, \fB\-\-memlimit=\fP\fIgräns\fP, \fB\-\-memory=\fP\fIgräns\fP +Detta är ekvivalent med att ange \fB\-\-memlimit\-compress=\fP\fIgräns\fP +\fB\-\-memlimit\-decompress=\fP\fIgräns\fP \fB\-\-memlimit\-mt\-decompress=\fP\fIgräns\fP. +.TP +\fB\-\-no\-adjust\fP +Visa ett fel och avsluta om gränsen för minnesanvändning inte kan mötas utan +att justera inställnigar som påverkar den komprimerade utdatan. Det vill +säga, detta förhindrar att \fBxz\fP byter kodaren från multitrådat läge till +enkeltrådat läge och från att den reducerar LZMA2\-lexikonets storlek. Även +när denna flagga används kan antalet trådar reduceras för att möta gränsen +för minnesanvändning eftersom det inte kommer påverka den komprimerade +utdatan. +.IP "" +Automatisk justering är alltid avaktiverat när råa strömmar skapas +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fItrådar\fP, \fB\-\-threads=\fP\fItrådar\fP +Ange antalet arbetstrådar som skall användas. Att sätta \fItrådar\fP till ett +specialvärde \fB0\fP gör att \fBxz\fP använder så många trådar som processorerna +på systemet stödjer. Det aktuella antalet trådar kan vara färre än \fItrådar\fP +om indatafilen inte är stor nog för trådning med de givna inställningarna +eller om användning av fler trådar skulle överkrida gränsen för +minnesanvändning. +.IP "" +De enkeltrådade och multitrådade komprimerarna producerar olika utdata. Den +enkeltrådade komprimeraren kommer ge den minsta filstorleken men endast +utdata från den multitrådade komprimeraren kan dekomprimeras med flera +trådar. Att sätta \fItrådar\fP till \fB1\fP kommer använda enkeltrådat läge. Att +sätta \fItrådar\fP till något annat värde, inklusive \fB0\fP, kommer använda den +multitrådade komprimeraren även om systemet endast stödjer en hårdvarutråd. +(\fBxz\fP 5.2.x använde enkeltrådat läge i denna situation.) +.IP "" +För att använda multitrådat läge med endast en tråd, sätt \fItrådar\fP till +\fB+1\fP. Prefixet \fB+\fP har ingen påvrekan för andra värden än \fB1\fP. En gräns +för minnesanvändning kan fortfarande göra att \fBxz\fP byter till enkeltrådat +läge såvida inte \fB\-\-no\-adjust\fP används. Stöd för prefixet \fB+\fP lades till i +\fBxz\fP 5.4.0. +.IP "" +Om ett automatiskt antal trådar har begärts och ingen gräns för +minnesanvändning har angivits, då kommer en systemspecifik mjuk +standardgräns användas för att möjligen begränsa antalet trådar. Det är en +mjuk gräns i den meningen att den ignoreras om antalet trådar blir en, +alltså kommer en mjuk gräns aldrig hindra \fBxz\fP från att komprimera eller +dekomprimera. Denna mjuka standardgräns kommer inte göra att \fBxz\fP byter +från multitrådat läge till enkeltrådat läge. De aktiva gränserna kan ses med +\fBxz \-\-info\-memory\fP. +.IP "" +För närvarande är den enda trådningsmetoden att dela indata i block och +komprimera dem oberoende av varandra. Standardstorleken på block beror på +komprimeringsnivån och kan åsidosättas med flaggan +\fB\-\-block\-size=\fP\fIstorlek\fP. +.IP "" +Trådad dekomprimering fungerar bara på filer som innehåller flera block med +storleksinformation i blockhuvuden. Alla tillräckligt stora filer +komprimeras i multitrådat läge för att uppfylla detta villkor, men filer +komprimerade i enkeltrådat läge gör det inte ens om +\fB\-\-block\-size=\fP\fIstorlek\fP har använts. +.IP "" +Standardvärdet på \fItrådar\fP är \fB0\fP. I \fBxz\fP 5.4.x och tidigare är +standardvärdet \fB1\fP. +. +.SS "Anpassade komprimerarfilterkedjor" +Med en anpassad filterkedja kan man specificera kompressionsinställningarna +i detalj istället för att lita på inställningarna som hör till +förinställningarna. När en anpassad filterkedja anges glöms +förinställningsflaggor (\fB\-0\fP \&…\& \fB\-9\fP och \fB\-\-extreme\fP) tidigare på +kommandoraden. Om en förinställningsflagga anges efter en eller flera +flaggor för anpassade filterkedjor gäller den nya förinställningen och de +flaggor för anpassade filterkedjor som angivits tidigare glöms. +.PP +En filterkedja är jämförbar med att skapa rör på kommando. Vid komprimering +skickas den okomprimerade indatan till det första filtret, vars utdata +skickas till nästa filter (om något). Utdatan från det sista filtret blir +skrivet till den komprimerade filen. Det maximala antalet filter i kedjan är +fyra, men typiskt har en filterkedja bara ett ellet två filter. +.PP +Många filter har begränsningar på var de kan finnas i filterkedjan: några +filter kan bara fungera som det sista filtret i kedjan, några bara om de +inte är det sista filtret, och några fungerar i godtycklig position i +kedjan. Beroende på filtret är denna begränsning antingen en egenskap hos +filterdesignen eller finns för att förhindra säkerhetsproblem. +.PP +En anpassad filterkedja kan anges på två olika sätt. Med flaggorna +\fB\-\-filters=\fP\fIfilter\fP och \fB\-\-filters1=\fP\fIfilter\fP \&…\& +\fB\-\-filters9=\fP\fIfilter\fP kan man ange en hel filterkedja med en flagga genom +att använda syntaxen för liblzma\-filtersträngar. Alternativt kan en +filterkedja anges genom att använda en eller flera individuella +filterflaggor i den ordning de önskas i filterkedjan. Det vill säga, +ordningen på de individuella filterflaggorna är signifikant! Vid avkodning +av råa strömmar (\fB\-\-format=raw\fP) måste filterkedjan anges i samma ordning +som den specificerades vid komprimeringen. Eventuella individuella filter\- +eller förinstiällningsflaggor angivna före den fullständiga +filterkedjeflaggan (\fB\-\-filters=\fP\fIfilter\fP) kommer glömmas. Individuella +filter som anges efter den flaggan för en full kedja kommer återställa +filterkedjan. +.PP +Både den fullständiga och de individuella filterflaggorna tar +filterspecifika \fIflaggor\fP som en kommaseparerad lista. Extra komman +\fIflaggor\fP ignoreras. Varje flagga har ett standardvärde, så ange dem du +vill ändra. +.PP +För att se hela filterkedjan och \fIflaggor\fP, använd \fBxz \-vv\fP (det vill +säga, använd \fB\-\-verbose\fP två gånger). Detta fungerar även för att se +flaggorna för filterkedjor som används av förinställningar. +.TP +\fB\-\-filters=\fP\fIfilter\fP +Ange den fullständiga filterkedan eller en förinställning en en enda +flagga. Varje filter kan separeras med blanktecken eller två bindestreck +(\fB\-\-\fP). \fIfilter\fP kan behöva citeras på skalets kommandorad så att det +tolkas som en enda flagga. För att beteckna \fIflaggor\fP, använd \fB:\fP eller +\fB=\fP. En förinställning kan föregås med ett \fB\-\fP och följas av noll eller +flera flaggor. Den enda flaggan som stödjs är \fBe\fP för att tillämpa samma +flaggor som \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIfilter\fP … \fB\-\-filters9\fP=\fIfilter\fP +Ange upp till nio ytterligare filterkedjor som kan användas med +\fB\-\-block\-list\fP. +.IP "" +Till exempel, vid komprimering av ett arkiv med körbara filer följt av +textfiler skulle den körbara delen kunna använda en filterkedja med ett +BCJ\-filter och endast textdelen med LZMA2\-filtret. +.TP +\fB\-\-filters\-help\fP +Visa ett hjälpmeddelande som beskriver hur man anger förinställningar och +anpassade filterkedjor i flaggorna \fB\-\-filters\fP och \fB\-\-filters1=\fP\fIfilter\fP +\&…\& \fB\-\-filters9=\fP\fIfilter\fP, och avsluta rent. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIflaggor\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIflaggor\fP] +.PD +Lägg till LZMA1\- eller LZMA2\-filter till filterkedjan. Dessa filter kan +endast användas som det sista filtret i kedjan. +.IP "" +LZMA1 är ett föråldrat filter, vilket stödjs nästan enbart på grund av det +föråldrade filformatet \fB.lzma\fP, vilket bara stödjer LZMA1. LZMA2 är en +uppdaterad version av LZMA1 för att lösa några praktiska problem med +LZMA1. Formatet \fB.xz\fP använder LZMA2 och stödjer inte LZMA1 +alls. Komprimeringshastigheten och förhållandena för LZMA1 är LZMA2 är +praktiskt taget desamma. +.IP "" +LZMA1 och LZMA2 delar samma uppättning \fIflaggor\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIförinställning\fP +Återställ alla LZMA1\- eller LZMA2\-\fIflaggor\fP till +\fIförinställning\fP. \fIFörinställning\fP består av ett heltal, vilket kan följas +av enskilda bokstäver som modifierar förinställningen. Heltalet kan vara +från \fB0\fP till \fB9\fP, motsvarande kommandoradsflaggorna \fB\-0\fP \&…\& +\fB\-9\fP. Den enda modifierare som stödjs för närvarande är \fBe\fP, vilket +motsvarar \fB\-\-extreme\fP. Om ingen \fBpreset\fP anges tas standardvärden på +LZMA1\- eller LZMA2\-\fIflaggor\fP från förinställningen \fB6\fP. +.TP +\fBdict=\fP\fIstorlek\fP +Ett lexikons (historiebufferts) \fIstorlek\fP indikerar hur många byte med +nyligen bearbetad okomprimerad data som hålls i minnet. Algoritmen försöker +hitta återkommande bytesekvenser (matchningar) i den okomprimerade datan, +och ersätta dem med referenser till datan som för närvarande finns i +lexikonet. Ju större lexikon, desto högre är sannolikheten att hitta en +matchning. Att öka lexikonets \fIstorlek\fP förbättrar alltså vanligen +komprimeringsförhållandet, men ett lexikon som är större än den +okomprimerade filen är ett slöseri med minne. +.IP "" +En typisk \fIstorlek\fP på lexikon är från 64\ KiB till 64\ MiB. Minimum är 4\ KiB. Det maximala för komprimering är för närvarande 1,5\ GiB (1536\ MiB). Dekomprimeraren stödjer redan lexikon upp till en byte mindre än 4\ GiB, vilket är det maximala för strömformaten LZMA1 och LZMA2. +.IP "" +Lexikon\fIstorlek\fP och matchhittaren (\fImf\fP) avgör tillsammans +minnesanvändningen för LZMA1\- eller LZMA2\-kodaren. Ett lika \fIstort\fP (eller +större) lexikon behövs för dekomprimering som det som användes vid +komprimeringen, minnesanvändningen för avkodaren avgörs alltså av +lexikonstorleken vid komprimering. Huvudena i \fB.xz\fP innehåller lexikonets +\fIstorlek\fP antingen som 2^\fIn\fP eller 2^\fIn\fP + 2^(\fIn\fP\-1), så dessa +\fIstorlekar\fP är lite att föredra för komprimering. Andra \fIstorlekar\fP kommer +avrundas uppåt när de lagras i huvuden i \fB.xz\fP. +.TP +\fBlc=\fP\fIlk\fP +Ange antalet literala kontextbitar. Minimum är 0 och maximum är 4; +standardvärdet är 3. Dessutom får inte summan av \fIlk\fP och \fIlp\fP överskrida +4. +.IP "" +Alla byte som inte kan kodas som matchningar kodas som literaler. Det vill +säga, literaler är helt enkelt 8\-bits byte som kodas en åt gången. +.IP "" +Den literala kodningen gör antagandet att de högsta \fIlk\fP bitarna av den +föregående okomprimerade byten korrelerar med nästa byte. Till exempel, i +typisk engelsk text följs ofta en versal bokstav av en gemen bokstav, och en +gemen bokstav följs vanligen av en annan gemen bokstav. I +teckenuppsättningen US\-ASCII är de högsta tre bitarna 010 för versala +bokstäver och 011 för gemena bokstäver. När \fIlk\fP är åtminstone 3 kan den +literala kodningen dra nytta av denna egenskap i den okomprimerade datan. +.IP "" +Standardvärdet (3) är normalt bra. Om man vill ha maximal komprimering, +prova \fBlc=4\fP. Ibland hjälper det lite, och ibland gör det komprimeringen +sämre. Om det gör den sämre, testa också \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Ange antalet literala positionsbitar. Minimum är 0 och maximum är 4; +standardvärdet är 0. +.IP "" +\fILp\fP påverkar vilken sorts justering i den okomprimerade datan som antas +vid kodning av literaler. Se \fIpb\fP nedan för mer information om justering. +.TP +\fBpb=\fP\fIpb\fP +Ange antalet positionsbitar. Minimum är 0 och maximum är 4; standardvärdet +är 2. +.IP "" +\fIPb\fP påverkar vilken sort justering i den okomprimerade datan som antas i +allmänhet. Standardvärdet betyder fyrbytejustering (2^\fIpb\fP=2^2=4), vilket +ofta är ett bra val när det inte finns någon bättre gissning. +.IP "" +När justeringen är känd kan en inställning av \fIpb\fP därefter reducera +filstorleken något. Till exempel, med textfiler som har en\-byte\-justering +(US\-ASCII, ISO\-8859\-*, UTF\-8) kan att sätta \fBpb=0\fP förbättra komprimeringen +något. För UTF\-16\-text är \fBpb=1\fP ett bra val. Om justeringen är ett udda +tal som 3 byte kan \fBpb=0\fP vara det bästa valet. +.IP "" +Även om den antagna justeringen kan anpassas med \fIpb\fP och \fIlp\fP föredrar +LZMA1 och LZMA2 ändå något 16\-byte\-justering. Det kan vara värt att ta med i +beräkningen vid design av filformat som sannolikt ofta kan komma att +komprimeras med LZMA1 eller LZMA2. +.TP +\fBmf=\fP\fIms\fP +Matchsökaren har en stor poverkan på kodarens hastighet, minnesanvändning +och komprimeringsförhållande. Vanligen är Hashkedje\-matchsökare snabbare än +Binärträdsmatchsökare. Standardvärdet beror på \fIföinställningen\fP: 0 +använder \fBhc3\fP, 1\(en3 använder \fBhc4\fP, och resten använder \fBbt4\fP. +.IP "" +Följande matchsökare stödjs. Formlerna för minnesanvändning nedan är grova +uppskattningar, vilka är närmast sanningen när \fIdict\fP är en tvåpotens. +.RS +.TP +\fBhc3\fP +Hashkedja med 2\- och 3\-bytehashning +.br +Minsta värde på \fInice\fP: 3 +.br +Minnesanvändning: +.br +\fIdict\fP · 7.5 (om \fIdict\fP ≤ 16 MiB); +.br +\fIdict\fP · 5,5 + 64 MiB (om \fIdict\fP > 16 MiB) +.TP +\fBhc4\fP +Hashkedja med 2\-, 3\- och 4\-bytehashning +.br +Minsta värde på \fInice\fP: 4 +.br +Minnesanvändning: +.br +\fIdict\fP · 7,5 (om \fIdict\fP ≤ 32 MiB); +.br +\fIdict\fP · 6,5 (om \fIdict\fP > 32 MiB) +.TP +\fBbt2\fP +Binärträd med 2\-bytehashning +.br +Minsta värde på \fInice\fP: 2 +.br +Minnesanvändning: \fIdict\fP · 9,5 +.TP +\fBbt3\fP +Binärträd med 2\- och 3\-bytehashning +.br +Minsta värde på \fInice\fP: 3 +.br +Minnesanvändning: +.br +\fIdict\fP · 11,5 (om \fIdict\fP ≤ 16 MiB); +.br +\fIdict\fP · 9,5 + 64 MiB (om \fIdict\fP > 16 MiB) +.TP +\fBbt4\fP +Binärträd med 2\-, 3\- och 4\-bytehashning +.br +Minsta värde på \fInice\fP: 4 +.br +Minnesanvändning: +.br +\fIdict\fP · 11,5 (om \fIdict\fP ≤ 32 MiB); +.br +\fIdict\fP · 10,5 (om \fIdict\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fIläge\fP +Komprimerings\fIläget\fP anger metoden som används för att analysera data +skapade av matchsökaren. De \fIlägen\fP som stödjs är \fBfast\fP och +\fBnormal\fP. Standardvärdet är \fBfast\fP för \fIförinställningarna\fP 0\(en3 och +\fBnormal\fP för \fIförinställningarna\fP 4\(en9 +.IP "" +Vanligen används \fBfast\fP med Hashkedjematchsökare och \fBnormal\fP med +Binärträdsmatchsökare. Detta är även vad \fIförinställningarna\fP gör. +.TP +\fBnice=\fP\fIlagom\fP +Ange vad som anses vara en lagom längt på en matchning. När en matchning på +åtminstone \fIlagom\fP byte hittats slutar algoritmen söka efter möjliga bättre +matchningar. +.IP "" +\fILagom\fP kan vara 2\(en273 byte. Högre värden tenderar att ge bättre +komprimeringsförhållande på bekostnad av tid. Standardvärdet beror på +\fIförinställningen\fP. +.TP +\fBdepth=\fP\fIdjup\fP +Ange det maximala sökdjupet i matchsökaren. Standardvärdet är specialvärdet +0, vilket får komprimeraren att avgöra ett lämpligt \fIdjup\fP från \fImf\fP och +\fInice\fP. +.IP "" +Lämpligt \fIdjup\fP för Hashkedjor är 4\(en100 och 16\(en1000 för +Binärträd. Att använda väldigt höga värden på \fIdjup\fP kan göra kodaren +extremt långsam för vissa filer. Undvik att sätta \fIdjup\fP över 1000 såvida +du inte är beredd att avbryta komprimeringen om den tar för lång tid. +.RE +.IP "" +Vid avkodning av råa strömmar (\fB\-\-format=raw\fP) behöver LZMA2 endast +lexikonets \fIstorlek\fP. LZMA1 behöver även \fIlc\fP, \fIlp\fP och \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIflaggor\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIflaggor\fP] +.PD +Lägg till gren/anrop/hopp\-filter (branch/call/jump, BCJ) till +filterkedjan. Dessa filter kan inte användas som det sista filtret i +filterkedjan. +.IP "" +Ett BCJ\-filter konverterar relativa adresser i maskinkod till deras absoluta +motsvarigheter. Detta ändrar inte storleken på datan men det ökar +redundansen, vilket kan hjälpa LZMA2 att skapa 0\(en15\ % mindre +\&\fB.xz\fP\-filer. BCJ\-filtren är alltid reversibla, så att använda ett +BCJ\-filter för fel sorts data orsakar inte någon dataförlust, men det kan +göra komprimeringsförhållandet något sämre. BCJ\-filtren är mycket snabba +och använder en obetydling mängd minne. +.IP "" +Dessa BCJ\-filter har kända problem kopplade till komprimeringsförhållandet: +.RS +.IP \(bu 3 +Någr sortes filer som innehåller körbar kod (till exempel, objektfiler, +statiska bibliotek och Linux kärnmoduler) har adresserna i instruktionerna +fyllda med utfyllnadsvärden. Dessa BCJ\-filter kommer ändå göra +adresskonverteringen, vilket kommer göra komprimeringen sämre för dessa +filer. +.IP \(bu 3 +Om ett BCJ\-filter används på ett arkiv är det möjligt att det gör +komprimeringsförhållandet sämre än att inte använda något BCJ\-filter. Till +exempel, om det finns liknande eller till och med identiska körbara kommer +filtreringen sannolikt göra filerna mindre lika och därmed blir +kompressionen sämre. Innehållet i icke körbara filer i samma arkiv kan också +spela en roll. I praktiken måste man prova med och utan ett BCJ\-filter för +att se vilket som är det bästa i varje situation. +.RE +.IP "" +Olika instruktionsuppsättningar har olika justering: den körbara filen måste +vara justerad till en multipel av detta värde i indata för att filtret skall +fungera. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filter;Justering;Kommentarer +x86;1;32\-bitars eller 64\-bitars x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096\-bytesjustering är bäst +PowerPC;4;Endast rak byteordning +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Eftersom BCJ\-filtrerad data vanligen komprimeras med LZMA2 kan +komprimeringsförhållandet förbättras något om LZMA2\-flaggorna sätts till att +matcha justeringen hos det valda BCJ\-filtret. Exempel: +.RS +.IP \(bu 3 +IA\-64\-filter har 16\-bytejustering så \fBpb=4,lp=4,lc=0\fP är bra med LZMA2 +(2⁴=16). +.IP \(bu 3 +RISC\-V\-kod har 2\-byte\- eller 4\-bytejustering beroende på huruvida filen +innehåller 16\-bitars komprimerade instruktioner (utvidgningen C). När +16\-bitarsinstruktioner används är \fBpb=2,lp=1,lc=3\fP eller \fBpb=1,lp=1,lc=3\fP +bra. När det inte finns några 16\-bitsinstruktioner är \fBpb=2,lp=2,lc=2\fP +bäst. \fBreadelf \-h\fP kan användas för att kontrollera om ”RVC” förekommer på +raden ”Flaggor”. +.IP \(bu 3 +ARM64 är alltid 4\-bytejusterad så \fBpb=2,lp=2,lc=2\fP är bäst. +.IP \(bu 3 +Filtret x86 är ett undantag. Det är normalt bra att hålla sig till LZMA2:s +standardvärden (\fBpb=2,lp=0,lc=3\fP) när körbar x86 komprimeras. +.RE +.IP "" +Alla BCJ\-filter stödjer samma \fIflaggor\fP: +.RS +.TP +\fBstart=\fP\fIavstånd\fP +Ange start\fIavståndet\fP som används vid konvertering mellan relativa och +absoluta adresser. \fIAvståndet\fP måste vara en multipel av filtrets justering +(se tabellen ovan). Standardvärdet är noll. I praktiken är standardvärdet +bra; det är nästan aldrig användbart att ange ett anpassat \fIavstånd\fP. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIflaggor\fP] +Lägg till Deltafiltret till filterkedjan. Deltafiltret kan inte användas som +det sista filtret i filterkedjan. +.IP "" +För närvarande stödjs bara enkel byte\-vis deltaberäkning. Det kan vara +användbart vid komprimering, till exempel av okomprimerade +bitavbildningsbilder eller okomprimerad PCM\-audio. Dock kan algoritmer för +särskilda ändamål ge betydligt bättre resultat än Delta + LZMA2. Detta är +särskilt sant med audio, vilket komprimerar snabbare och bättre med till +exempel \fBflac\fP(1). +.IP "" +Stödda \fIflaggor\fP: +.RS +.TP +\fBdist=\fP\fIavstånd\fP +Ange \fIavståndet\fP för deltaberäkningen i byte. \fIAvstånd\fP måste varea +1\(en256. Standardvärdet är 1. +.IP "" +Till exempel, med \fBdist=2\fP och åtta byte indata A1 B1 A2 B3 A3 B5 A4 B7, +kommer utdata vara A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Andra flaggor" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Utelämna varningar och noteringar. Ange detta två gånger för att även +utelämna felmeddelandet. Denna flagga har ingen påverkan på +slutstatusen. Det vill säga, även om en varning utelämnades kommer +slutstatusen fortfarandeindikera att en varning gavs. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Var utförlig. Om standard fel är kopplat till en terminal kommer \fBxz\fP visa +en förloppsmätare. Att ange \fB\-\-verbose\fP två gånger kommer ge än mer +utförlig utmatning. +.IP "" +Förloppsmätaren visar följande information: +.RS +.IP \(bu 3 +Procent färdigt visas om storleken på indatafilen är känd. Det vill säga, +procentsatsen kan inte visas i rör. +.IP \(bu 3 +Mängd komprimerad data som producerats (komprimering) eller konsumerats +(dekomprimering). +.IP \(bu 3 +Mängd okomprimerad data som konsumerats (komprimering) eller producerats +(dekomprimering). +.IP \(bu 3 +Komprimeringsförhållande, vilket beräknas genom att dividera mängden +komprimerad data bearbetad så lång med mängde okomprimerad data bearbetad så +långt. +.IP \(bu 3 +Kompressions eller dekompressionshastighet. Detta mäts som mängden +okomprimerad data konsumerad (komprimering) eller producerad +(dekomprimering) per sekund. Det visas efter att några sekunder har gåt +efter att \fBxz\fP började bearbeta filen. +.IP \(bu 3 +Förfluten tid på formatet MM:SS eller H:MM:SS. +.IP \(bu 3 +Beräknad återstående tid visas endast när storleken på indatafilen är känd +och några sekunder redan gått efter att \fBxz\fP började bearbeta filen. Tiden +visas i ett mindre precist format vilket aldrig har några kolon, till +exempel, 2 min 30 s. +.RE +.IP "" +När standard fel inte är en terminal kommer \fB\-\-verbose\fP göra att \fBxz\fP +skriver filnamnet, komprimerad storlek, okomprimerad storlek, +komprimeringsförhållande och möjligen även hastigheten och den förlupna +tiden på en enda rad till standard fel efter att ha komprimerat eller +dekomprimerat filen. Hastigheten och den förlupna tiden inkluderas endast +när åtgärden tog åtminstone några sekunder. Om åtgärden inte slutfördes, +till exempel för att användaren avbröt, skrivs även den fullbordade +procentsatsen om storleken på indatafilen är känd. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Sätt inte slutstatus till 2 även om ett tillstånd som är värt en varning +upptäcktes. Denna flagga påverkar inte utförlighetsnivån, allts måste både +\fB\-\-quiet\fP och \fB\-\-no\-warn\fP användas för att inte visa varningar och för att +inte ändra slutstatusen. +.TP +\fB\-\-robot\fP +Skriv meddelanden i maskinläsbart form. Detta är avsett att förenkla att +skriva framändar som vill använda \fBxz\fP istället för liblzma, vilken kan +vara fallet i olika skript. Utdatan med denna flagga aktiverad är avsedd att +vara stabil mellan utgåvor av \fBxz\fP. Se avsnitett \fBROBOTLÄGE\fP för detaljer. +.TP +\fB\-\-info\-memory\fP +Visa, på mänskligt läsbar form, hur mycket fysiskt minne (RAM) och hur många +processortrådar \fBxz\fP tror att systemet har och gränserna för +minnesanvändning vid komprimering och dekomprimering, och avsluta. +.TP +\fB\-h\fP, \fB\-\-help\fP +Visa ett hjälpmeddelande som beskriver de vanligast använda flaggorna, och +avsluta. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Visa ett hjälpmeddelande som beskriver alla funktioner i \fBxz\fP, och avsluta +.TP +\fB\-V\fP, \fB\-\-version\fP +Visa versionsnumret för \fBxz\fP och liblzma i mänskligt läsbar form. För att +få maskinläsbar utdata, ange \fB\-\-robot\fP före \fB\-\-version\fP. +. +.SH ROBOTLÄGE +Robotläget aktiveras med flaggan \fB\-\-robot\fP. Det gör att utdata från \fBxz\fP +är enklare att tolka av andra program. För närvarande stödjs \fB\-\-robot\fP +endast tillsammans med \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP och +\fB\-\-version\fP. Den kommer att stödjas för komprimering och dekomprimering i +framtiden. +. +.SS Listläge +\fBxz \-\-robot \-\-list\fP använder tab\-separerad utmatning. Första kolumnen av +varje rad har en sträng som indikerar typen av informationen som finns på +den raden: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Detta är alltid första raden när en fil börjar listas. Den andra kolumen på +raden är filnamnet. +.TP +\fBfile\fP +Denna rad innehåller övergripande information om \fB.xz\fP\-filen. Denna rad +skrivs alltid efter raden \fBname\fP. +.TP +\fBstream\fP +Denna radtyp används endast när \fB\-\-verbose\fP angetts. Det finns lika många +\fBstream\fP\-rader som det finns strömmar i \fB.xz\fP\-filen. +.TP +\fBblock\fP +Denna radtyp används bara när \fB\-\-verbose\fP angetts. Det finns lika många +\fBblock\fP\-rader som det finns block i \fB.xz\fP\-filen. \fBblock\fP\-rader visas +efter alla \fBstream\fP\-raderna; olika radtyper blandas inte. +.TP +\fBsummary\fP +Denna radtyp används bara när \fB\-\-verbose\fP angetts två gånger. Denna rad +skrivs eefter alla \fBblock\fP\-rader. Liksom raden \fBfile\fP inenhåller raden +\fBsummary\fP övergripande information om \fB.xz\fP\-filen. +.TP +\fBtotals\fP +Denna rad är alltid den allra sista raden i listutmatningen. Den visar det +totala antalen och storlekarna. +.PP +Kolumnerna på \fBfile\fP\-raderna: +.PD 0 +.RS +.IP 2. 4 +Antalet strömmar i filen +.IP 3. 4 +Totalt antal block i strömmarna +.IP 4. 4 +Komprimerad storlek på filen +.IP 5. 4 +Okomprimerad storlek på filen +.IP 6. 4 +Komprimeringsförhållande, till exempel \fB0.123\fP. Om förhållandet är över +9.999 visas tre bindestreck (\fB\-\-\-\fP) istället för förhållandet. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Kommaseparerad lista med integritetskontrollnamn. Följande strängar används +för de kända kontrolltyperna: \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP och +\fBSHA\-256\fP. För okända kontrolltyper används \fBUnknown\-\fP\fIN\fP, där \fIN\fP är +kontroll\-ID:t som ett decimalt nummer (en eller två siffror). +.IP 8. 4 +Total storlek på strömutfyllnad i filen +.RE +.PD +.PP +Kolumnerna på \fBstream\fP\-raderna: +.PD 0 +.RS +.IP 2. 4 +Strömnummer (den första strömmen är 1) +.IP 3. 4 +Antal block i strömmen +.IP 4. 4 +Komprimerat startavstånd +.IP 5. 4 +Okomprimerat startavstånd +.IP 6. 4 +Komprimerad storlek (inkluderar inte strömutfyllnad) +.IP 7. 4 +Okomprimerad storlek +.IP 8. 4 +Komprimeringsförhållande +.IP 9. 4 +Namnet på integritetskontrollen +.IP 10. 4 +Storleken på strömutfyllnad +.RE +.PD +.PP +Kolumnerna på \fBblock\fP\-raderna: +.PD 0 +.RS +.IP 2. 4 +Numret på strömmen som innehåller detta block +.IP 3. 4 +Blocknummer relativt början på strömmen (det första blocket är 1) +.IP 4. 4 +Blocknummer relativt början på filen +.IP 5. 4 +Komprimerat startavstånd relativt början av filen +.IP 6. 4 +Okomprimerat startavstånd relativt början av filen +.IP 7. 4 +Total komprimerad storlek på blocket (inkluderar huvuden) +.IP 8. 4 +Okomprimerad storlek +.IP 9. 4 +Komprimeringsförhållande +.IP 10. 4 +Namnet på integritetskontrollen +.RE +.PD +.PP +Om \fB\-\-verbose\fP angavs två gånger inkluderas ytterligare kolumner på +\fBblock\fP\-raderna. Dessa visas inte med bara ett \fB\-\-verbose\fP, eftersom det +för att få fram denna information krävs många sökningar och kan därmed vara +långsamt: +.PD 0 +.RS +.IP 11. 4 +Värdet på integritetskontrollen hexadecimalt +.IP 12. 4 +Blockhuvudstorlek +.IP 13. 4 +Blockflaggor: \fBc\fP indikerar att komprimerad storlek finns, och \fBu\fP +indikerar att okomprimerad storlek finns. Om flaggan inte är satt visas ett +bindestreck (\fB\-\fP) istället för att hålla stränglängden fast. Nya flaggor +kan läggas till i slutet av strängen i frmtiden. +.IP 14. 4 +Storlek på den faktiska komprimerade datan i blocket (detta utelämnar +blockhuvud, blockutfyllnad och kontrollfält) +.IP 15. 4 +Mängd minne (i byte) som behövs för att dekomprimera detta block med denna +version av \fBxz\fP +.IP 16. 4 +Filterkedja. Observera att de flesta av flaggorna som användes vid +komprimeringstillfället inte kan vara kända, eftersom endat de flaggor som +behövs för dekomprimering lagras i \fB.xz\fP\-huvudet. +.RE +.PD +.PP +Kolumnerna på \fBsummary\fP\-raderna: +.PD 0 +.RS +.IP 2. 4 +Mängd minne (i byte) som behövs för att dekomprimera denna fil med denna +version av \fBxz\fP +.IP 3. 4 +\fByes\fP eller \fBno\fP som indikerar om alla blockhuvuden både har komprimerad +storlek och okomprimerad storlek i sig +.PP +\fIFrån\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Minsta version av \fBxz\fP som krävs för att dekomprimera filen +.RE +.PD +.PP +Kolumnerna på \fBtotals\fP\-raden: +.PD 0 +.RS +.IP 2. 4 +Antal strömmar +.IP 3. 4 +Antal block +.IP 4. 4 +Komprimerad storlek +.IP 5. 4 +Okomprimerad storlek +.IP 6. 4 +Genomsnittligt komprimeringsförhållande +.IP 7. 4 +Kommaseparerad lista med integritetskontrollnamn som fanns i filerna +.IP 8. 4 +Strömutfyllnadsstorlek +.IP 9. 4 +Antal filer. Denna finns här för att hålla ordningen av de tidigare +kolumnerna desamma som på \fBfile\fP\-rader. +.PD +.RE +.PP +Om \fB\-\-verbose\fP angavs två gånger inkluderas ytterligare kolumner på +\fBtotals\fP\-raden: +.PD 0 +.RS +.IP 10. 4 +Maximal mängd minne (i byte) som behövs för att dekomprimera filerna med +denna version av \fBxz\fP +.IP 11. 4 +\fByes\fP eller \fBno\fP som indikerar om alla blockhuvuden både har komprimerad +storlek och okomprimerad storlek i sig +.PP +\fIFrån\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Minsta version av \fBxz\fP som krävs för att dekomprimera filen +.RE +.PD +.PP +Framtida versioner kan lägga till fler radtyper och fler kolumner kan läggas +til på de befintliga radtyperna, men de befintliga kolumnerna kommmer inte +ändras. +. +.SS Filterhjälp +\fBxz \-\-robot \-\-filters\-help\fP skriver ut de filter som stödjs i följande +format: +.PP +\fIfilter\fP\fB:\fP\fIflagga\fP\fB=<\fP\fIvärde\fP\fB>,\fP\fIflagga\fP\fB=<\fP\fIvärde\fP\fB>\fP… +.TP +\fIfilter\fP +Namn på filtret +.TP +\fIflagga\fP +Namn på en filterspecifik flagga +.TP +\fIvärde\fP +Numeriska \fIvärde\fPintervall ser ut som +\fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. Sträng\fIvärdes\fP val visas inom \fB< >\fP och separerade med ett \fB|\fP\-tecken. +.PP +Varje filter skrivs på en egen rad. +. +.SS Minnesgränsinformation +\fBxz \-\-robot \-\-info\-memory\fP skriver en rad med flera tab\-separerade +kolumner: +.IP 1. 4 +Total mängd med fysiskt minne (RAM) i byte. +.IP 2. 4 +Minnesanvändningsgräns för komprimering i byte (\fB\-\-memlimit\-compress\fP). Ett +specialvärde \fB0\fP indikerar standardinställningen vilken för enkeltrådat +läge är detsamma som ingen gräns. +.IP 3. 4 +Minnesanvändningsgräns för dekomprimering i byte +(\fB\-\-memlimit\-decompress\fP). Ett specialvärde \fB0\fP indikerar +standdartinställningen vilken för enkeltrådat läge är detsamma som ingen +gräns. +.IP 4. 4 +Från \fBxz\fP 5.3.4alpha: Minnesanvändningen för multitrådad dekomprimering i +byte (\fB\-\-memlimit\-mt\-decompress\fP). Detta är aldrig noll eftersom ett +systemspecifikt standardvärde som visas i kolumn 5 används om ingen gräns +har angivits uttryckligen. Detta är heller aldrig större än värdet i kolumn +3 även om ett större värde har angivits med \fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Från \fBxz\fP 5.3.4alpha: Ett systemspecifikt standardgräns för +minnesanvändning som används för att begränsa antalet trådar vid +komprimering med ett automatiskt antal trådar (\fB\-\-threads=0\fP) och ingen +gräns för minnesanvändning har angivits (\fB\-\-memlimit\-compress\fP). Detta +används även som standardvärdet på \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Från \fBxz\fP 5.3.4alpha: antal tillgängliga processortrådar. +.PP +I framtiden kan utdata från \fBxz \-\-robot \-\-info\-memory\fP ha fler kolumner, +men aldrig mer än en rad. +. +.SS Version +\fBxz \-\-robot \-\-version\fP skriver versionsnumret på \fBxz\fP och liblzma i +följande format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Huvudversion. +.TP +\fIYYY\fP +Underversion. Jämna nummer är stabila. Udda nummer är alfa\- eller +betaversioner. +.TP +\fIZZZ\fP +Rättningsnivå för stabila utgåvor eller bara en räknare för +utvecklingsutgåvor. +.TP +\fIS\fP +Stabilitet. 0 är alfa, 1 beta beta och 2 är stabil. \fIS\fP skall alltid vara +2 när \fIYYY\fP är jämnt. +.PP +\fIXYYYZZZS\fP är samma på båda raderna om \fBxz\fP och liblzma kommer från samma +utgåva av XZ Utils. +.PP +Exempel: 4.999.9beta är \fB49990091\fP och 5.0.0 är \fB50000002\fP. +. +.SH SLUTSTATUS +.TP +\fB0\fP +Allt är bra. +.TP +\fB1\fP +Ett fel uppstod. +.TP +\fB2\fP +Något värt en varning uppstod, men inga faktiska fel uppstod. +.PP +Noteringar (inte varningar eller fel) som skrivs på standard fel påverkar +inte slutstatusen. +. +.SH MILJÖ +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP tolkar mellanrumsseparerade listor av flaggor från miljövariablerna +\fBXZ_DEFAULTS\fP och \fBXZ_OPT\fP, i den ordningen, före flaggorna på +kommandoraden. Observera att endast flaggor tolkas från miljövariablerna; +alla andra argument än flaggor ignoreras tyst. Tolkningen görs med +\fBgetopt_long\fP(3) vilket även används för kommandoradsargumenten. +.PP +\fBVarning:\fP genom att sätta dessa miljövariabler ändrar man i praktiken +program och skript som kör \fBxz\fP. för det mesta är set säkert att sätta +begränsningar på minnesanvändning, antal trådar och komprimeringsflaggor via +miljövariablerna. Några flaggor kan dock göra att skript går sönder. Ett +uppenbart exempel är \fB\-\-help\fP vilket gör att \fBxz\fP visar en hjälptext +istället för att komprimera eller dekomprimera en fil. Mer subtila exempel +är \fB\-\-quiet\fP och \fB\-\-verbose\fP. I många fall fungerar det bra att aktivera +en förloppsindikator med \fB\-\-verbose\fP, men i några fall skapar de extra +meddelandena problem. Utförlighetsnivån påverkar även beteendet hos +\fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Användarspecifika eller systemspecifika standardflaggor. Typiskt sätts detta +i ett initieringsskript för skal för att aktivera \fBxz\fP:s begränsning av +minnesanvändning som standard eller att ställa in ett standardantal +trådar. Med undantag för skalinitieringsskript och liknande specialfall +skall skript aldrig sätta eller ta bort \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Detta är för att skicka flaggor till \fBxz\fP när det inte är möjligt att sätta +flaggorna direkt på kommandoraden för \fBxz\fP. Detta är fallet när \fBxz\fP körs +av ett skript eller verktyg, till exempel, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf apa.tar.xz apa\fR +.fi +.RE +.RE +.IP "" +Skript kan använda \fBXZ_OPT\fP, till exempel, för att sätta skriptspecifika +standardflaggor för komprimering. Det rekommenderas fortfarande att tillåta +användaren att åsidosätta \fBXZ_OPT\fP om det är rimligt. Till exempel, i +\fBsh\fP(1)\-skript kan man använda något i still med detta: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "KOMPATIBILITET MED LZMA UTILS" +Kommandoradssyntaxen för \fBxz\fP är praktiskt taget en utökning av \fBlzma\fP, +\fBunlzma\fP och \fBlzcat\fP så som de kommer från LZMA Utils 4.32.x. I de flesta +fall, är det möjligt att ersätta LZMA Utils med XZ Utils utan att göra +sönder befintliga skript. Det finns dock några inkompatibiliteter, vilka +ibland kan orsaka problem. +. +.SS "Komprimeringens förinställda nivåer" +Numreringen av förinställda nivåer för komprimering är inte identiska i +\fBxz\fP och LZMA Utils. Den viktigaste skillnade är hur lexikonstorlekar +avbildas till olika förinställningar. Lexikonstorleken är i stort sett lika +med dekomprimerarens minnesanvändning. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nivå;xz;LZMA Utils +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Lexikonstorlekens skillnader påverkar komprimerarens minnesanvändning också, +men det finns några andra skillnader mellan LZMA Utils och XZ Utils, vilket +gör skillnaden ännu större: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nivå;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Standardförinställningsninvån i LZMA Utils är \fB\-7\fP medan i XZ Utils är den +\fB\-6\fP, så båda använder ett 8 MiB lexikon som standard. +. +.SS "Strömmade visavi icke strömmade .lzma\-filer" +Den ikomprimerade storleken på filen kan lagras i huvudet i \fB.lzma\fP. LZMA +Utils gör det när den komprimerar normala filer. Alternativet är att markera +att den okomprimerade storleken är okänd och använda en markör för lastslut +för att indikera var dekomprimeraren skall stanna. LZMA Utils använder denna +metod när den okomprimerade storleken inte är känd, vilket är fallet, till +exempel, i rör. +.PP +\fBxz\fP stödjer dekomprimering av \fB.lzma\fP\-filer med eller utan markör för +lastslut, men alla \fB.lzma\fP filer som skapas av \fBxz\fP kommer använda markör +för lastslut och ha den okomprimerade storleken markerad som okänd i +\&\fB.lzma\fP\-huvudet. Detta kan bli ett problem i några ovanliga fall. Till +exempel kan en \fB.lzma\fP\-dekomprimerare i en inbäddad enhet fungera endast +med filer som har en känd okomprimerad storlek. Om man stöter på detta +problem behöver man använda LZMA Utils eller LZMA SDK för att skapa +\&\fB.lzma\fP\-filer med känd okomprimerad storlek. +. +.SS "Ej stödda .lzma\-filer" +Formatet \fB.lzma\fP tillåter värden på \fIlc\fP upp till 8, och värden på \fIlp\fP +upp till 4. LZMA Utils kan dekomprimera filer med godtyckliga \fIlc\fP och +\fIlp\fP, men skapar alltid filer med \fBlc=3\fP och \fBlp=0\fP. Att skapa filer med +andra \fIlc\fP och \fIlp\fP är möjligt med \fBxz\fP och med LZMA SDK. +.PP +Implementationen av LZMA1\-filtret i liblzma kräver att summan av \fIlc\fP och +\fIlp\fP inte överstiger 4. Alltså, \fB.lzma\fP\-filer, vilka överstiger denna +gräns, kan inte dekomprimeras med \fBxz\fP. +.PP +LZMA Utils skapar endast \fB.lzma\fP\-filer som har en lexikonstorlek på 2^\fIn\fP +(en potens av 2) men godtar filer med godtycklig lexikonstorlek. liblzma +godtar endast \fB.lzma\fP\-filer som har en lexikonstorlek på 2^\fIn\fP eller +2^\fIn\fP + 2^(\fIn\fP\-1). Detta är för att minska falska positiva vid detektering +av \fB.lzma\fP\-filer. +.PP +Dessa begränsningar bör inte vara ett problem i praktiken, eftersom +praktiskt taget alla \fB.lzma\fP\-filer har komprimerats med inställningar som +liblzma kommer godta. +. +.SS "Avslutande skräp" +Vid dekomprimering ignorerar LZMA Utils tyst allting efter den första +\&\fB.lzma\fP\-strömmen. I de flesta situationer är detta fel. Detta betyder även +att LZMA Utils inte stödjer dekomprimering av konkatenerade \fB.lzma\fP\-filer. +.PP +Om det finns data kvar efter den första \fB.lzma\fP\-strömmen betraktar \fBxz\fP +filen som trasig om inte \fB\-\-single\-stream\fP användes. Detta kan göra sönder +obskyra skript vilka har antagit att avslutande skräp ignoreras. +. +.SH NOTERINGAR +. +.SS "Den komprimerade utdatan kan variera" +Den exakta komprimerade utdatan som produceras från samma okomprimerade +indatafil kan variera mellan versioner av XZ Utils även om +komprimeringsflaggorna är identiska. Detta beror på att kodaren kan +förbättras (snabbare eller bättre komprimering) utan att påverka +filformatet. Utdatan kan variera även mellan olika byggen av samma version +av XZ Utils, om olika byggflaggor används. +.PP +Ovanstående betyder att när väl \fB\-\-rsyncable\fP har implementerats kommer +inte nödvändigtvis de resulterande filerna vara rsync\-bara om inte både +gamla och nya filer har komprimerats med samma version av xz. Detta problem +kan lösas om en del av kodarimplementeringen fryses för att hålla rsync\-bar +utdata stabil mellan xz\-versioner. +. +.SS "Inbäddade .xz\-dekomprimerare" +Inbäddade implementationer av \fB.xz\fP\-dekomprimerare som XZ Embedded stödjer +inte nödvändigtvis filer som skapas med andra typer av +integritets\fIkontroll\fP än \fBnone\fP och \fBcrc32\fP. Eftersom standardvärdet är +\fB\-\-check=crc64\fP måste man använda \fB\-\-check=none\fP eller \fB\-\-check=crc32\fP +när filer skapas för inbäddade system. +.PP +Utanför inbäddade system stödjer alla dekomprimerare av \fB.xz\fP\-format alla +typerna av \fIkontroller\fP, eller åtminstone kan de dekomprimera filern utan +att verifiera integritetskontrollen om den specifika \fIkontrollen\fP inte +stödjs. +.PP +XZ Embedded stödjer BCJ\-filter, men endast med standard startavstånd. +. +.SH EXEMPEL +. +.SS Grundläggande +Komprimera filen \fIapa\fP till \fIapa.xz\fP med standardkomprimeringsnivån +(\fB\-6\fP), och ta bort \fIapa\fP om komprimeringen lyckas: +.RS +.PP +.nf +\f(CRxz apa\fR +.fi +.RE +.PP +Dekomprimera \fIbepa.xz\fP till \fIbepa\fP och ta inte bort \fIbepa.xz\fP även om +dekomprimeringen lyckas: +.RS +.PP +.nf +\f(CRxz \-dk bepa.xz\fR +.fi +.RE +.PP +Skapa \fIcepa.tar.xz\fP med förinställningen \fB\-4e\fP (\fB\-4 \-\-extreme\fP), vilket +är långsammare än standardvärdet \fB\-6\fP, men behöver mindre minne till +komprimering och dekomprimering (48\ MiB respektive 5\ MiB): +.RS +.PP +.nf +\f(CRtar cf \- cepa | xz \-4e > cepa.tar.xz\fR +.fi +.RE +.PP +En blandning av komprimerade och okomprimerade filer kan dekomprimeras till +standard ut med ett enda kommando: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Parallell komprimering av många filer" +På GNU och *BSD kan \fBfind\fP(1) och \fBxargs\fP(1) användas för att +parallellisera komprimeringen av många filer: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Flaggan \fB\-P\fP till \fBxargs\fP(1) anger antalet parallella \fBxz\fP\-processer. Det +bästa värdet till flaggan \fB\-n\fP beror på hur många filer det finns som skapp +komprimeras. Om det bara finns några stycken filer bör värdet förmodigen +vara 1; med tiotusentals filer kan 100 eller mer vara lämpligt för att +reducera antalet \fBxz\fP\-processer som \fBxargs\fP(1) kommer att skapa. +.PP +Flaggan \fB\-T1\fP till \fBxz\fP finns för att tvinga den till enkeltrådsläge, +eftersom \fBxargs\fP(1) används för att styra mängden parallellisering. +. +.SS Robotläge +Beräkna hur många byt som har sparats totalt efter komprimering av flera +filer: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Ett skript kan vilja veta att det använder en tillräckligt ny +\fBxz\fP. Följande \fBsh\fP(1)\-skript kontrollerar att versionsnumret för +verktyget \fBxz\fP är åtminstone 5.0.0. Denna metod är kompatibel med gamla +betaversioner, vilka inte stödde flaggan \fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Din xz är för gammal." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Ange en gräns för minnesanvändning för dekomprimering med \fBXZ_OPT\fP, men om +en gräns redan har satts, öka den inte: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Anpassade komprimerarfilterkedjor" +Den enklaste användningen av anpassade filterkedjor är att anpassa en +LZMA2\-förinställning. Detta kan vara användbart eftersom förinställningarna +endast täcker en delmängd av de potentiellt användbara kombinationerna av +komprimeringsinställningar. +.PP +Kolumnerna CompCPU i tabellerna från beskrivningen av flaggorna options +\fB\-0\fP ... \fB\-9\fP och \fB\-\-extreme\fP är användbara vid anpassning av +LZMA2\-förinställningar. Här är de relevanta delarna samlade från dessa två +tabeller: +.RS +.PP +.TS +tab(;); +c c +n n. +Förinställning;KompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Om man vet att en fil behöver ett rätt stort lexikon (till exempel, 32\ MiB) +för att komprimeras bra, men man vill komprimera den snabbare än \fBxz \-8\fP +skulle gjort kan en förinställning med ett lågt värde på CompCPU (till +exempel, 1) ändras till att använda ett större lexikon: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB apa.tar\fR +.fi +.RE +.PP +Med vissa filer kan ovanstående kommando vara snabbare än \fBxz \-6\fP samtidigt +som det komprimerar betydligt bättre. Dock måste det påpekas att endast +några filer drar fördel av ett stort lexikon samtidigt som värdet CompCPU +hålls lågt. Den mest uppenbara situationen, är ett stort lexikon kan hälpa +till mycket, är ett arkiv som innehåller väldigt snarlika filer på åtmistone +några megabyte var. Lexikonstorleken måste vara signifikant större än någon +enskild fil för att låta LZMA2 dra full nytta av likheterna mellan på +varandra följande filer. +.PP +Om det går bra med väldigt hög minnesanvändning i komprimeraren och +dekomprimeraren, och filen som komprimeras är åtminstone flera hundra +megabyte, kan det vara användbart att använda ännu större lexikon än de 64 +MiB som \fBxz \-9\fP skulle använda: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB stor_apa.tar\fR +.fi +.RE +.PP +Att använda \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) som i exemplet ovan kan vara +användbart för att se minnesbehoven för komprimeraren och +dekomprimeraren. Kom ihåg att använda ett större lexikon än storleken på den +okomprimerade filen är slöseri med minne, så ovanstående kommando är inte +användbart för små filer. +.PP +Ibland spelar inte dekomprimeringstiden någon roll, men dekomprimerarens +minnesanvändning måste hållas låg, till exempel för att göra det möjligt att +dekomprimera filen på ett inbäddat system. Följande kommando använder \fB\-6e\fP +(\fB\-6 \-\-extreme\fP) som en bas och sätter lexikonstorleken till bara 64\ KiB. Den resulterande filen kan dekomprimeras med XZ Embedded (det är därför +det finns \fB\-\-check=crc32\fP) som använder ungerfär 100\ KiB minne. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB apa\fR +.fi +.RE +.PP +Om man vill krama ur så många byte som möjligt kan justering av antalet +literala kontextbitar (\fIlc\fP) och antalet positionsbitar (\fIpb\fP) ibland +hjälpa. Justering av antalet literala positionsbitar (\fIlp\fP) kan också +hjälpa, men vanligen är \fIlc\fP och \fIpb\fP viktigare. Till exempel innehåller +ett källkodsarkiv huvudsakligen US\-ASCII\-text, så något i stil med följande +kan ge aningen (som 0.1\ %) mindre fil än \fBxz \-6e\fP (försök även utan +\fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 källkod.tar\fR +.fi +.RE +.PP +Att använda ett annat filter tillsammans med LZMA2 kan förbättra +komprimeringen med vissa filtyper. Till exempel, för att komprimera ett +delat x86\-32\- eller x86\-64\-bibliotek med filtret x86 BCJ: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libapa.so\fR +.fi +.RE +.PP +Observera att ordningen på filterflaggorna spelar roll. Om \fB\-\-x86\fP anges +efter \fB\-\-lzma2\fP kommer \fBxz\fP avge ett fel, eftersom det inte kan vara något +filter efter LZMA2, och även för att filtret x86 BCJ inte kan användas som +det sista filtret i kedjan. +.PP +Deltafiltret tillsammans med LZMA2 gan ge bra resultat med +bitkartebilder. Det bör vanligen slå PNG, som har några mer avancerade +filter än enkla delta men använder Deflat för den faktiska komprimeringen. +.PP +Bilden måste sparas i okomprimerat format, till exempel som okomprimerad +TIFF. Avståndsparametern i Deltafiltret sätts till att motsvara natalet byte +per bildpunkt i bilden. Till exempel, 24\-bitars RGB bitkarta behöver +\fBdist=3\fP, och det är även bra att skicka \fBpb=0\fP till LZMA2 för att ge +plats för trebytejustering: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 apa.tiff\fR +.fi +.RE +.PP +Om flera bilder har lagts in i ett gemensamt arkiv (till exempel, \fB.tar\fP) +kommer Deltafiltret fungera på det också så länge alla bilder har samma +antal byte per bildpunkt. +. +.SH "SE ÄVEN" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzmadec.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzmadec.1 new file mode 100644 index 0000000000000000000000000000000000000000..63612b0c437ef25509d89f649853119c5e476786 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzmadec.1 @@ -0,0 +1,87 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.\" Swedish translation of xz-man +.\" Göran Uddeborg , 2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDEC 1 2024\-04\-08 Tukaani "XZ Utils" +.SH NAMN +xzdec, lzmadec \- Små .xz\- och .lzma\-dekomprimerare +.SH SYNOPSIS +\fBxzdec\fP [\fIflagga…\fP] [\fIfil…\fP] +.br +\fBlzmadec\fP [\fIflagga…\fP] [\fIfil…\fP] +.SH BESKRIVNING +\fBxzdec\fP är ett liblzma\-baserat verktyg endast för dekomprimering för \fB.xz\fP +(och endast \fB.xz\fP) filer. \fBxzdec\fP är avsett att fungera som en drop +in\-ersättning för \fBxz\fP(1) i de vanligaste situationerna där ett skript har +skrivits för att använda \fBxz \-\-decompress \-\-stdout\fP (och möjligen några +andra vanliga flaggor) för att dekomprimera \fB.xz\fP\-filer. \fBlzmadec\fP är +identisk med \fBxzdec\fP förutom att \fBlzmadec\fP stödjer \fB.lzma\fP\-filer istället +för \fB.xz\fP\-filer. +.PP +För att reducera storleken på det körbara programmet stödjer inte \fBxzdec\fP +multitrådning eller lokalisering, och läser inte flaggor från +miljövariablerna \fBXZ_DEFAULTS\fP eller \fBXZ_OPT\fP. \fBxzdec\fP stödjer inte att +visa mellanliggande förloppsinformation: att skicka \fBSIGINFO\fP till \fBxzdec\fP +gör ingenting, med att skicka \fBSIGUSR1\fP avslutar processen istället för att +visa förloppsinformation. +.SH FLAGGOR +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +Ignoreras för kompatibilitet med \fBxz\fP(1). \fBxzdec\fP stödjer endast +dekomprimering. +.TP +\fB\-k\fP, \fB\-\-keep\fP +Ignoreras för kompatibilitet med \fBxz\fP(1). \fBxzdec\fP skapar aldrig eller tar +aldrig bort några filer. +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Ignoreras för kompatibilitet med \fBxz\fP(1). \fBxzdec\fP skriver alltid +dekomprimerad data till standard ut. +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Att ange detta en gång gör inget eftersom \fBxzdec\fP aldrig visar några +varningar eller noteringar. Att ange detta två gånger utelämnar +felmeddelanden. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Ignoreras för kompatibilitet med \fBxz\fP(1). \fBxzdec\fP använder aldrig +slutstatus 2. +.TP +\fB\-h\fP, \fB\-\-help\fP +Visa ett hjälpmeddelande och avsluta. +.TP +\fB\-V\fP, \fB\-\-version\fP +Visa versionsnumret på \fBxzdec\fP och liblzma. +.SH SLUTSTATUS +.TP +\fB0\fP +Allt gick bra. +.TP +\fB1\fP +Ett fel uppstod. +.PP +\fBxzdec\fP har inte några varningsmeddelanden så som \fBxz\fP(1) har, och därför +används aldrig slutstatusen 2 av \fBxzdec\fP. +.SH NOTERINGAR +Använd \fBxz\fP(1) istället för \fBxzdec\fP eller \fBlzmadec\fP för dagligt +bruk. \fBxzdec\fP och \fBlzmadec\fP är bara avsedda för situationer där det är +viktigt att ha en mindre dekomprimerare än den fullständiga \fBxz\fP(1). +.PP +\fBxzdec\fP och \fBlzmadec\fP är egentligen inte riktigt så små. Storleken kan +reduceras ytterligare genom att ta bort funktioner från liblzma vid +kompileringstidpunkten, men det skall normalt inte göras för körbara program +som distribueras i en typisk, inte inbäddad, distribution av +operativsystem. Om man behöver en verkligt liten \fB.xz\fP\-dekomprimerare skall +man överväga XZ Embedded. +.SH "SE ÄVEN" +\fBxz\fP(1) +.PP +XZ Embedded: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzmainfo.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzmainfo.1 new file mode 100644 index 0000000000000000000000000000000000000000..bb72d25c53e09a5429dbbb7ea89ccdb7e2b58e95 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzmainfo.1 @@ -0,0 +1,42 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.\" Swedish translation of xz-man +.\" Göran Uddeborg , 2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH LZMAINFO 1 2013\-06\-30 Tukaani "XZ Utils" +.SH NAMN +lzmainfo — visa information lagrad i filhuvudet i .lzma +.SH SYNOPSIS +\fBlzmainfo\fP [\fB\-\-help\fP] [\fB\-\-version\fP] [\fIfil…\fP] +.SH BESKRIVNING +\fBlzmainfo\fP visar information som finns lagrad i filhuvudet i \fB.lzma\fP. Den +läser de första 13 byten från den angivna \fIfilen\fP, avkodar huvudet, och +skriver ut det till standard ut i mänskligt läsbart format. Om inga \fIfiler\fP +anges eller \fIfil\fP är \fB\-\fP, läses standard in. +.PP +Vanligen är den intressantaste informationen den okomprimerade storleken och +lexikonstorleken. Okomprimerad storlek kan endast visas om filen är i den +icke\-strömmande \fB.lzma\fP\-formatvarianten. Mängden minne som krävs för att +dekomprimera filen är några dussin kilobyte plus lexikonstorleken. +.PP +\fBlzmainfo\fP inkluderas i XZ Utils primärt för bakåtkompatibilitet med LZMA +Utils. +.SH SLUTSTATUS +.TP +\fB0\fP +Allt är bra. +.TP +\fB1\fP +Ett fel uppstod. +.SH FEL +\fBlzmainfo\fP använder \fBMB\fP medan det korrekta suffixet vore \fBMiB\fP (2²⁰ +byte). Detta är för att behålla utdata kompatibel med LZMA Utils. +.SH "SE ÄVEN" +\fBxz\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzmore.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzmore.1 new file mode 100644 index 0000000000000000000000000000000000000000..b5bb68d4df784fe5c3fcbdf884e0667ee9fc791e --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/lzmore.1 @@ -0,0 +1,48 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" Swedish translation of xz-man +.\" Göran Uddeborg , 2025. +.\" +.\" (Note that this file is based on xzless.1 instead of gzip's zmore.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZMORE 1 2025\-03\-06 Tukaani "XZ Utils" +.SH NAMN +xzmore, lzmore — visa xz\- eller lzma\-komprimerade (text)filer +. +.SH SYNOPSIS +\fBxzmore\fP [\fIfil\fP…] +.br +\fBlzmore\fP [\fIfil\fP…] (FÖRÅLDRAT) +. +.SH BESKRIVNING +\fBxzmore\fP visar text från komprimerade filer i en terminal med användning av +\fBmore\fP(1). Filer som stödjs av \fBxz\fP(1) dekomprimeras; andra filer antas +redan vara i okomprimerad form. Om inga \fIfiler\fP ges läser \fBxzmore\fP från +standard in. Se manualen för \fBmore\fP(1) för tangentbordskommandona. +.PP +Observera att det kanske inte är möjligt att rulla baklänges, beroende på +implementationen av \fBmore\fP(1). Detta är för att \fBxzmore\fP använder ett rör +för att skicka dekomprimerad data till \fBmore\fP(1). \fBxzless\fP(1) använder +\fBless\fP(1) vilken ger mer avancerade funktioner. +.PP +Kommandot \fBlzmore\fP finns för bakåtkompatibilitet med LZMA Utils. Det +rekommenderas inte och kommer tas bort i en framtida version. +. +.SH MILJÖ +.TP +.\" TRANSLATORS: Don't translate the uppercase PAGER. +.\" It is a name of an environment variable. +\fBPAGER\fP +Om \fBPAGER\fP är satt används dess värde som bläddrare istället för +\fBmore\fP(1). +. +.SH "SE ÄVEN" +\fBmore\fP(1), \fBxz\fP(1), \fBxzless\fP(1), \fBzmore\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/unlzma.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/unlzma.1 new file mode 100644 index 0000000000000000000000000000000000000000..1fb596e1ab328783990b87c362f7f7761d73548e --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/unlzma.1 @@ -0,0 +1,1954 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Swedish translation of xz-man +.\" Göran Uddeborg , 2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 2025\-03\-08 Tukaani "XZ Utils" +. +.SH NAMN +xz, unxz, xzcat, lzma, unlzma, lzcat — Komprimera eller dekomprimera .xz\- +och .lzma\-filer +. +.SH SYNOPSIS +\fBxz\fP [\fIflagga…\fP] [\fIfil…\fP] +. +.SH KOMMANDOALIAS +\fBunxz\fP är ekvivalent med \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP är ekvivalent med \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP är ekvivalent med \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP är ekvivalent med \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP är ekvivalent med \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +När man skriver skript som behöver dekomprimera filer rekommenderas det att +altid använda namnet \fBxz\fP mäd lämpliga argument (\fBxz \-d\fP eller \fBxz \-dc\fP) +istället för namnen \fBunxz\fP och \fBxzcat\fP. +. +.SH BESKRIVNING +\fBxz\fP är ett datakomprimeringsverktyg för allmänt bruk med en +kommandoradssyntax som liknar \fBgzip\fP(1) och \fBbzip2\fP(1). Det egna +filformatet är formatet \fB.xz\fP, men det föråldrade formatet \fB.lzma\fP som +anändes av LZMA\-verktyg och råa komprimerade strömmar utan huvuden för +behållarformatet stödjs också. Dessutom stödjs dekomprimering av formatet +\&\fB.lz\fP som används av \fBlzip\fP. +.PP +\fBxz\fP komprimerar och dekomprimerar varje \fIfil\fP i enlighet med det valda +arbetsläget. Om inga \fIfiler\fP anges eller \fIfil\fP är \fB\-\fP läser \fBxz\fP från +standard in och skriver den behandade datan på standard ut. \fBxz\fP kommer +vägra (visa ett felmeddelande och hoppa över \fIfilen\fP) att skriva +komprimerad data direkt till standard ut om det är en terminal. På samma +sätt kommer \fBxz\fP vägra att läsa komprimerade data från standard in om det +är en terminal. +.PP +Om inte \fB\-\-stdout\fP anges skrivs andra \fIfiler\fP än \fB\-\fP till en ny fil vars +namn härleds från käll\fIfilens\fP namn: +.IP \(bu 3 +Vid kompringering läggs suffixet till på målfilsformatet (\fB.xz\fP eller +\&\fB.lzma\fP) på slutet av källfilnamnet för att få målfilnamnet. +.IP \(bu 3 +Vid dekomprimering tas suffixet \fB.xz\fP, \fB.lzma\fP eller \fB.lz\fP bort från +filnamnet för att få målfilnamnet. \fBxz\fP känner även igen suffixen \fB.txz\fP +och \fB.tlz\fP, och ersätter dem med suffixet \fB.tar\fP. +.PP +Om målfilen redan finns visas ett felmeddelande och \fIfilen\fP hoppas över. +.PP +Utom när den skriver till standard ut kommer \fBxz\fP visa en varning och hoppa +över \fIfilen\fP om något av följande inträffar: +.IP \(bu 3 +\fIFil\fP är inte en vanlig fil. Symboliska länkar följs inte, och därför anses +de inte vara vanliga filer. +.IP \(bu 3 +\fIFil\fP har mer än en hård länk. +.IP \(bu 3 +\fIFil\fP har biten setuid, setgid eller sticky satt. +.IP \(bu 3 +Arbetsläget är satt till att komprimera och \fIfilen\fP har redan ett suffix +enligt målfilformatet (\fB.xz\fP eller \fB.txz\fP vid komprimering till formatet +\&\fB.xz\fP, och \fB.lzma\fP eller \fB.tlz\fP vid komprimering till formatet \fB.lzma\fP). +.IP \(bu 3 +Arbetsläget är satt till att dekomprimera och \fIfilen\fP har inte ett suffix +enligt något av de stödda filformaten (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP +eller \fB.lz\fP). +.PP +Efter att ha kunnat komprimera eller dekomprimera \fIfilen\fP kopierar \fBxz\fP +ägaren, gruppen, rättigheterna, åtkomsttiden och ändringstiden från +käll\fIfilen\fP till målfilen. Om kopieringen av grupp misslyckas ändras +rättigheterna så att målfilen inte blir åtkomlig för användare som inte har +rättigheter att komma åt käll\fIfilen\fP. \fBxz\fP stödjer inte kopiering av annan +metadata såsom åtkomststyrhingslistor eller utökade attribut ännu. +.PP +När målfilen har stängts framgångsrikt tas käll\fIfilen\fP bort såvida inte +\fB\-\-keep\fP angavs. Käll\fIfilen\fP tas aldrig bort om utdata skrevs till +standard ut eller om något fel inträffade. +.PP +Att skicka \fBSIGINFO\fP eller \fBSIGUSR1\fP till \fBxz\fP\-processen får den att +skriva ut förloppsinformation till standard fel. Detta är bara av begränsat +värde eftersom när standard fel går till en terminal så kommer användning av +\fB\-\-verbose\fP att skriva ut en automatiskt uppdaterande förloppsindikator. +. +.SS Minnesanvändning +\fBxz\fP:s minnesanvändning varierar från några få hundra kilobyte till flera +gigabyte beroende på komprimeringsinställningarna. Inställningen som +användes när en fil komprimerades avgör minnesbehovet hos +dekomprimeraren. Typiskt behöver dekomprimeraren 5\ % till 20\ % av +minnesbehovet som komprimeraren behöver när en fil skapas. Till exempel, att +dekomprimera en fil skapad med \fBxz \-9\fP kräver för närvarande 65\ MiB +minne. Ändå är det möjligt att ha \fB.xz\fP\-filer som behöver flera gigabyte +minne för att dekomprimeras. +.PP +Särskilt användare av äldre system kan finna möjligheten av väldigt stor +minnesanvändning störande. För att förhindra obehagliga överraskningar har +\fBxz\fP en inbyggd minnesanvändningsbegränsare, vilken är avaktiverad som +standard. Även om vissa operativsystem kan tillhandahålla möjligheter att +begränsa minnesanvändningen hos processer bedömdes det inte som flexibelt +nog att lita på det (till exempel, att använda \fBulimit\fP(1) för att begränsa +det virtuella minnet tenderar att hämma \fBmmap\fP(2). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Minnesanvändningsbegränsaren kan aktiveras med kommandoradsflaggan +\fB\-\-memlimit=\fP\fIgräns\fP. Ofta är det bekvämare att aktivera begränsaren som +standard genom att sätta miljövariabeln \fBXZ_DEFAULTS\fP, till exempel, +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Det är möjligt att sätta gränser separat +för komprimering och dekomprimering genom att använda +\fB\-\-memlimit\-compress=\fP\fIlimit\fP och \fB\-\-memlimit\-decompress=\fP\fIlimit\fP. Att +använda dessa två flaggor utanför \fBXZ_DEFAULTS\fP är sällan meningsfullt +eftersom en enskild körning av \fBxz\fP inte kan göra både komprimering och +dekomprimering och and \fB\-\-memlimit=\fP\fIgräns\fP (eller \fB\-M\fP \fIgräns\fP) är +kortare att skriva på kommandoraden. +.PP +Om den angivna minnesanvändningsgränsen överskrid vid dekomprimering kommer +\fBxz\fP visa ett fel och dekomprimeringen av filen misslyckas. Om gröensen +överskrids vid komprimering kommer \fBxz\fP försöka skala ner inställningen så +att gränsen inte längre överskrids (utom när \fB\-\-format=raw\fP eller +\fB\-\-no\-adjust\fP används). På detta sätt kommer åtgärden inte misslyckas om +inte gränsen är väldigt liten. Skalningen av inställningen görs i steg som +inte matchar de förinställda komprimeringsnivåerna, till exempel, om gränsen +endast är något mindre än den mängd som behövs till \fBxz \-9\fP kommer +inställningen bara skalas ner lite, inte hela vägen ner till \fBxz \-8\fP. +. +.SS "Konkatenering och utfyllnad av .xz\-filer" +Det är möjligt att konkatenera \fB.xz\fP\-filer som de är. \fBxz\fP kommer +dekomprimera sådana filer som om de vore en enda \fB.xz\fP\-fil. +.PP +Det är möjligt att infoga utfyllnad mellan de konkatenerade delarna eller +efter den sista delen. Utfyllnaden måste bestå av null\-bytear och storleken +på utfyllnaden måste vara en multipel av fyra byte. Detta kan vara +användbart, till exempel, om \fB.xz\fP\-filen lagras på ett medium som mäter +filstorlekar i 512\-byteblock. +.PP +Konkaternering och utfyllnad är inte tillåtet med \fB.lzma\fP\-filer eller råa +strömmar. +. +.SH FLAGGOR +. +.SS "Heltalssuffix och speciella värden" +På de flesta platser där ett heltalsargument förväntas stödjs ett frivilligt +suffix för att enkelt indikera stora heltal. Det får inte finnas något +mellanrumm mellan heltalet och suffixet. +.TP +\fBKiB\fP +Multiplicera heltalet med 1 024 (2¹⁰). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP och \fBKB\fP är +tillåtna som synomymer till \fBKiB\fP. +.TP +\fBMiB\fP +Multiplicera heltalet med 1 048 576 (2²⁰). \fBMi\fP, \fBm\fP, \fBM\fP och \fBMB\fP är +tillåtna som synomymer till \fBMiB\fP. +.TP +\fBGiB\fP +Multiplicera heltalet med 1 073 741 824 (2³⁰). \fBGi\fP, \fBg\fP, \fBG\fP och \fBGB\fP +är tillåtna som synonymer till \fBGiB\fP. +.PP +Specialvärdet \fBmax\fP kan användas för att indikera det maximala heltalet som +stödjs av flaggan. +. +.SS Arbetsläge +Om flera arbetslägesflaggor ges gäller den sista. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Komprimera. Detta är standardarbetsläget när ingen arbetslägesflagga anges +och inget annat arbetsläge impliceras från kommandonamnet (till exempel +implicerar \fBunxz\fP \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Efter lyckad komprimering källfilen bort såvida man inte skriver till +standard ut eller \fB\-\-keep\fP angavs. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Dekomprimera. Efter lyckad dekomprimering tas källfilen bort såvida man inte +skriver till standard ut eller \fB\-\-keep\fP angavs. +.TP +\fB\-t\fP, \fB\-\-test\fP +Testa integriteten hos komprimerade \fIfiler\fP. Denna flagga är ekvivalent med +\fB\-\-decompress \-\-stdout\fP förutom att den dekomprimerade datan slängs +istället för att skrivas på standard ut. Inga filer skapas eller tas bort. +.TP +\fB\-l\fP, \fB\-\-list\fP +Skriv information om komprimerade \fIfiler\fP. Inge dekomprimeringsutdata +skapas, och inga filer skapas eller tas bort. I listläge kan programmet inte +läsa komprimerad data från standard in eller från andra källor där man inte +kan söka. +.IP "" +Standardlistningen visar grundläggande information om \fIfiler\fP, en fil per +rad. För att få mer detaljerad information, använd även flaggan +\fB\-\-verbose\fP. För ännu mer information, använd \fB\-\-verbose\fP två gånger, men +observera att detta kan vara långsamt, eftersom det behövs många sökningar +får att samla all den extra informationen. Bredden av utförlig utdata +överskrider 80 tecken, så att skicka utdata i ett rör till, till exempel, +\fBless\ \-S\fP kan vara bekvämt om terminalen inte är bred nog. +.IP "" +Den exakta utdatan kan variera mellan versioner av \fBxz\fP och olika +lokaler. För maskinläsbar utdata bör \fB\-\-robot \-\-list\fP användas. +. +.SS Arbetsmodifierare +.TP +\fB\-k\fP, \fB\-\-keep\fP +Ta inte bort indatafilerna. +.IP "" +Från \fBxz\fP 5.2.6 gör denna flagga även att \fBxz\fP komprimerar eller +dekomprimerar även om indatan är en symbolisk länk till en normal fil, har +mer än en hård länk eller har biten setuid, setgid eller sticky +satt. Bitarna setuid, setgid och sticky kopieras inte till målfilen. I +tidigare versioner gjordes detta bara med \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Denna flagga har flera funktioner: +.RS +.IP \(bu 3 +Om målfilen redan finns, radera den före komprimering eller dekomprimering. +.IP \(bu 3 +Komprimera eller dekomprimera även om indatan är en symbolisk länk till en +normal fil, har mer än en hård länk eller har biten setuid, setgid eller +sticky satt. Bitarna setuid, setgid och sticky kopieras inte till målfilen. +.IP \(bu 3 +När den används med \fB\-\-decompress\fP \fB\-\-stdout\fP och \fBxz\fP inte känner igen +typen på källfilen, kopiera källfilen som den är till standard ut. Detta gör +att \fBxzcat\fP \fB\-\-force\fP kan användas som \fBcat\fP(1) för filer som inte har +komprimerats med \fBxz\fP. Observera att i framtiden kan \fBxz\fP komma att stödja +nya komprimeringsfilformat, vilket kan få \fBxz\fP att dekomprimera fler typer +av filer istället för att kopiera dem till standard ut. +\fB\-\-format=\fP\fIformat\fP kan användas för att begränsa \fBxz\fP till att +dekomprimera endast ett enda filformat. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Skriv den komprimerade eller dekomprimerade datan till standard ut istället +för en fil. Detta implicerar \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Dekomprimera endast den första \fB.xz\fP\-strömmen, och ignorera tys eventuella +återstående indata som följer efter strömmen. Normalt får sådant avslutande +skräp \fBxz\fP att visa ett fel. +.IP "" +\fBxz\fP dekomprimerar aldrig mer än en ström från \fB.lzma\fP\-filer eller råa +strömmar, men denna flagga gör ändå att \fBxz\fP ignorerar den möjliga +efterföljande datan efter \fB.lzma\fP\-filen eller den råa strömmen. +.IP "" +Denna flagga har ingen effekt om arbetsläget inte är \fB\-\-decompress\fP eller +\fB\-\-test\fP. +.IP "" +Sedan \fBxz\fP 5.7.1alpha, implicerar \fB\-\-single\-stream\fP \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Avaktivera att glesa filer skapas. Som standard, om den dekomprimerar till +en normal fil, försöker \fBxz\fP att göra filen gles om den dekomprimerade +datan innehåller långa sekvenser av binära nollor. Det fungerar även när den +skriver till standard ut så länga standard ut är kopplad till en normal fil +och vissa ytterligare villkor möts för att göra det säkert. Att skapa glesa +filer kan spara diskutrymme och snabba upp dekomprimeringen genom att +begränsa mängden disk\-I/O. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Vid komprimering, använd \fI.suf\fP som suffixet för målfilen istället för +\&\fB.xz\fP eller \fB.lzma\fP. Om den inte skriver till standard ut och källfilen +redan har suffixet \fI.suf\fP visas en varning och filen hoppas över. +.IP "" +Vid dekomprimering, känn igen filer med suffixet \fI.suf\fP utöver filer +medsuffixen \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP eller \fB.lz\fP. Om källfilen +har suffixet \fI.suf\fP tas suffixet bort för att få målfilnamnet. +.IP "" +Vid komprimering eller dekomprimering av råa strömmar (\fB\-\-format=raw\fP) +måste alltid suffixet anges om den inte skriver till standard ut, eftersom +det inte finns något standardsuffix för råa strömmar. +.TP +\fB\-\-files\fP[\fB=\fP\fIfil\fP] +Läs filnamnen att arbeta på från \fIfil\fP; om \fIfil\fP utelämnas läses filnamn +från standard in. Filnamn måste avslutas med nyradstecknet. Ett bindestreck +(\fB\-\fP) tas som ett vanligt filnamn; det betyder inte standard in. Om filnamn +även anges som kommandoradsargument, bearbetas de före filnamnen som läses +från \fIfil\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIfil\fP] +Detta är identiskt med \fB\-\-files\fP[\fB=\fP\fIfil\fP] förjutom att varje filnamn +måste avslutas med ett nulltecken. +. +.SS "Grundläggande flaggor för filformat och komprimering" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fIformat\fP +Angi filens \fIformat\fP att komprimera eller dekomprimera: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Detta är standard. Vid komprimering är \fBauto\fP ekvivalent med \fBxz\fP. Vid +dekomprimering detekteras automatiskt formatet på indatafilen. Observera att +råa strömmar (skapade med \fB\-\-format=raw\fP inte kan detekteras automatiskt. +.TP +\fBxz\fP +Komprimera till filformatet \fB.xz\fP, eller acceptera endast \fB.xz\fP\-filer vid +dekomprimering. +.TP +\fBlzma\fP, \fBalone\fP +Komprimera till det föråldrade filformatet \fB.lzma\fP, eller acceptera endast +\&\fB.lzma\fP\-filer fid dekomprimering. Det alternativa namnet \fBalone\fP +tillhandahålls för bakåtkompatibilitet med LZMA Utils. +.TP +\fBlzip\fP +Acceptera endast \fB.lz\fP\-filer vid dekomprimering. Komprimering stödjs inte. +.IP "" +\&\fB.lz\fP\-formatet version 0 och 1 stödjs. Version 0\-filer producerades av +\fBlzip\fP 1.3 och tidigare. Sådana filer är inte vanliga men kan hittas från +filarkiv eftersom några källpaket släpptes i detta format. Folk kan ha även +ha gamla personliga filer i detta format. Dekomprimeringsstöd för format +version 0 togs bort i \fBlzip\fP 1.18. \fBlzip\fP 1.4 och senare kan skapa filer i +formatversion 1. +.TP +\fBraw\fP +Komprimera eller dekomprimera en rå ström (inga huvuden). Detta är endast +avsett för avancerade användare. För att avkoda råa strömmar behöver man +använda \fB\-\-format=raw\fP och explicit angi filterkedjan, vilken normalt +skulle ha lagrats i behållarens huvuden. +.RE +.TP +\fB\-C\fP \fIkontroll\fP, \fB\-\-check=\fP\fIkontroll\fP +Ange typen av integritetskontroll. Kontrollen beräknas från den +dekomprimerade datan och lagras i \fB.xz\fP\-filen. Denna flagga har endast +någon inverkan när man komprimerar till formatet \fB.xz\fP; formatet \fB.lzma\fP +stödjer inte integritetskontroller. Integritetskontrollen (om någon) +verifieras när \fB.xz\fP\-filen dekomprimeras. +.IP "" +\fIKontroll\fPtyper som stödjs: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Beräkna inte någon integritetskontroll alls. Detta är normalt en dålig +idé. Det kan vara användbart när datans integritet ändå verifieras på andra +sätt. +.TP +\fBcrc32\fP +Beräkna CRC32 med polynomet från IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Beräkna CRC64 med polynomet från ECMA\-182. Detta är standard, eftersom det +är något bättre än CRC32 på att upptäcka skadade filer och +hastighetsskillnaden är försumbar. +.TP +\fBsha256\fP +Beräkna SHA\-256. Detta är något långsammare än CRC32 och CRC64. +.RE +.IP "" +Integriteten hos \fB.xz\fP\-huvuden verifieras alltid med CRC32. Det är inte +möjligt att ändra eller avaktivera det. +.TP +\fB\-\-ignore\-check\fP +Verifiera inte integritetskontrollen av den komprimerade datan vid +dekomprimering. CRC32\-värden i \fB.xz\fP\-huvudena kommer fortfarande verifieras +normalt +.IP "" +\fBAnvänd inte denna flagga om du inte vet vad du gör.\fP Möjliga anledningar +till att använda denna flagga: +.RS +.IP \(bu 3 +Försöka återvinna data från en trasig .xz\-fil. +.IP \(bu 3 +Snabba upp dekomprimering. Detta har störst betydelse med SHA\-256 eller med +filer som har komprimerats extremt mycket. Det rekommenderas att inte +använda denna flagga för detta ändamål om inte filintegriteten verifieras +externt på något annat sätt. +.RE +.TP +\fB\-0\fP … \fB\-9\fP +Välj en förinställningsnivå för komprimering. Standard är \fB\-6\fP. Om flera +förinställningsnivåer anges gäller den sist angivna. Om en anpassad +fileterkedja redan angivits gör en inställning av en förinställningsnivå för +komprimering att den anpassade filterkedjan töms. +.IP "" +Skillnaden mellan förinställningarna har större betydelse än med \fBgzip\fP(1) +och \fBbzip2\fP(1). Den valda komprimeringsinställningen avgör minneskraven för +dekomprimeraren, att använda en för hög förinställningsnivå kan alltså göra +det plågsamt att dekomprimera filer på ett gammalt system med lite +RAM. Specifikt \fBär det inte en bra ide att blint använda \-9 för allt\fP +liksom det ofta är med \fBgzip\fP(1) och \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP … \fB\-3\fP +Dessa är ganska snabba förinställningar. \fB\-0\fP är ibland snabbare än \fBgzip \-9\fP samtidigt som komprimeringen är mycket bättre. De högre har ofta +hastighet jämförbar med \fBbzip2\fP(1) med jämförbar eller bättre +komprimeringsförhållande, även om resultatet mycket beror på typen av data +som komprimeras. +.TP +\fB\-4\fP … \fB\-6\fP +Bra för väldigt god komprimering samtidigt som dekomprimerarens +minnesanvändning hålls rimlig även på gamla system. \fB\-6\fP är standardvärdet, +vilket vanligen är ett bra val för att distribuera filer so behöver +dekomprimeras även på ssytem med endast 16\ MiB RAM. (\fB\-5e\fP eller \fB\-6e\fP +kan också vara värda att överväga. Se \fB\-\-extreme\fP.) +.TP +\fB\-7 … \-9\fP +Dessa liknar \fB\-6\fP med med högre krav på minne till komprimerare och +dekomprimerare. Dessa är bara användbara vid komprimering av filer större än +8\ MiB, 16\ MiB respektive 32\ MiB. +.RE +.IP "" +På samma hårdvara är dekomprimeringshastigheten ungefär ett konstant antal +byt av komprimerad data per sekund. Med andra ord, ju bättre komprimering, +desto snabbare kommer dekomprimeringen vanligen vara. Detta betyder även att +mängden av okomprimerad utdata skapad per sekund kan variera mycket. +.IP "" +Följande tabell sammanfattar funktionerna hos förinställningarna: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Förinställning;LexStrl;KompCPU;KompMin;DekMin +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Kolumnbeskrivningar: +.RS +.IP \(bu 3 +LexStrl är storleken på LZMA2:s lexikon. Det är slöseri med minne att +använda ett större lexikon än storleken på den okomprimerade filen. Detta är +anledningen till att det är bra att undvika förinställningarna \fB\-7\fP … \fB\-9\fP +när det inte finns något verkligt behov av dem. På \fB\-6\fP och lägre är +mängden bortslösat minne vanligen litet nog att inte ha någon betydelse. +.IP \(bu 3 +KompCPU är en förenklad representation av LZMA2\-inställningar som påverkar +komprimeringshastigheten. Lexikonstorleken påverkar också hastigheten, så +medan KompCPU är samma för nivåerna \fB\-6\fP … \fB\-9\fP tenderar fortfarande högre +nivåer att vara lite långsmmare. För ännu långsammare och möjligen bättre +komprimering, se \fB\-\-extreme\fP. +.IP \(bu 3 +KompMem innehåller komprimerarens minneskrav i enkeltrådat läge. Det kan +variera något mellan versioner av \fBxz\fP. +.IP \(bu 3 +DekMin innehåller dekomprimerarens minneskrav. Det vill säga, komprimerarens +inställningar avgör minneskravet för dekomprimeraren. Den exakta +minnesanvändningen hos dekomprimeraren är något mer än +LZMA2\-lexikonstorleken, men värdena i tabellen har avrundats upp till nästa +nästa hela MiB. +.RE +.IP "" +Minneskravet för det multitrådade läget är signifikant högre än det för +enkeltrådat läge. Med standardvärdet på \fB\-\-block\-size\fP behöver varje tråd +3·3·LexStrl plus KompMin eller DekMin. Till exempel, fyra trådar med +förinställningen behöver 660\(en670 MiB minne. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Använd en långsammare variant av den valda förinställningsnivån för +komprimering (\fB\-0\fP … \fB\-9\fP) för att förhoppningsvis få lite bättre +komprimeringsförhållande, men med otur kan detta även göra det +sämre. Dekomprimerarens minnesanvändning påverkas inte, men komprimerarens +minnesanvändning ökar lite vid förinställningsnivåerna \fB\-0\fP … \fB\-3\fP. +.IP "" +Eftersom det finns två förinställningar med lexikonstorlekar 4\ MiB och 8\ MiB använder förinställningarna \fB\-3e\fP och \fB\-5e\fP något snabbare +inställningar (lägre KompCPU) än \fB\-4e\fP respektive \fB\-6e\fP. På det sättet är +inte två förinställningar identiska. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Förinställning;LexStrl;KompCPU;KompMin;DekMin +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Till exempel finns det totalt fyra förinställningar som använder 8\ MiB +lexikon, vars ordning från den snabbaste till den långsammaste är \fB\-5\fP, +\fB\-6\fP, \fB\-5e\fP och \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Dessa är något missledande alias för \fB\-0\fP respektive \fB\-9\fP. Dessa finns +endast för bakåtkompatibilitet med LZMA\-verktyg. Undvik att använda dessa +flaggor. +.TP +\fB\-\-block\-size=\fP\fIstorlek\fP +Vid komprimering till formatet \fB.xz\fP, dela indatai block med \fIstorlek\fP +bytes. Blocken komprimeras oberoende av varandra, vilket hjälper till vid +multitrådning och gör begränsad random\-access\-dekomprimering möjlig. Denna +flagga används typiskt för att åsidosätta blockstorleken i multitrådat läge, +men denna flagga kan användas även i enkeltrådat läge. +.IP "" +I multitrådat läge kommer ungefär tre gånger \fIstorlek\fP byte att allokeras i +varje tråd för buffring av indata och utdata. Standardvärdet på \fIstorlek\fP +är det större av tre gånger LZMA2\-lexikonstorleken eller 1 MiB. Typiskt är +ett bra värde 2\(en4 gånger storleken på LZMA2\-lexikonet eller åtminstone 1 +MiB. Att använda en \fIstorlek\fP mindre än LZMA2\-lexikonstorleken utgör +slöseri med RAM eftersom LZMA2\-lexikonbufferten då aldrig kommer användas +helt. I multitrådat läge lagras storlekarna på plocken i +blockhuvudena. Denna storleksinformation krävs för multitrådad +dekomprimering. +.IP "" +I singletrådat läge görs som standard ingen uppdelning i block. Att göra +denna inställning påverark inte minnesanvändningen. Ingen +storleksinformation lagras i blockhuvuden, därmed kommer filer som skapas i +enkeltrådat läge inte att vara identiska med filer skapade i multitrådat +läge. Avsaknaden av sotrleksinformation betyder också att \fBxz\fP inte kommer +kunna dekomprimera filerna i multitrådat läge. +.TP +\fB\-\-block\-list=\fP\fIposter\fP +Vid komprimering till formatet \fB.xz\fP, börja ett nytt block med en möjlig +anpassad filterkedja efter de angivna intervallen med okomprimerade data. +.IP "" +\fIPosterna\fP är en kommaseparerad lista. Varje post består av ett möjligt +filterkedjenummer mellan 0 och 9 följt av ett kolon (\fB:\fP) och en +obligatorisk storlek för okomprimerade data. Att utelämna en post (två på +varandra följande komman) är en kortform för att använda storleken och +filtren från föregående post. +.IP "" +Om indatafiler är större än summan av storlekarna i \fIposter\fP repeteras den +sista posten fram till slutet på filen. Ett speciellt värde \fB0\fP kan +användas som den sista storleken för att indikera att resten av filen skall +kodas som ett enda block. +.IP "" +En alternativ filterkedja för varje block kan anges i kombinaton med +flaggorna \fB\-\-filters1=\fP\fIfilter\fP \&…\& \fB\-\-filters9=\fP\fIfilter\fP. Dessa +flaggor definierar filterkedjor med en identifierare mellan +1\(en9. Filterkedja 0 kan användas för att referera till +standardfilterkedjan, vilket är samma sak som att inte ange någon +filterkedja. Filterkedjeidentifierare kan användas före den okomprimerade +sotrleken, följt av ett kolon (\fB:\fP). Till exempel, om man anger +\fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP kommer block skapas med: +.RS +.IP \(bu 3 +Filterkedjan angiven av \fB\-\-filters1\fP och 2 MiB indata +.IP \(bu 3 +Filterkedjan angiven av \fB\-\-filters3\fP och 2 MiB indata +.IP \(bu 3 +Filterkedjan angiven av \fB\-\-filters2\fP och 4 MiB indata +.IP \(bu 3 +Filterkedjan angiven av \fB\-\-filters2\fP och 4 MiB indata +.IP \(bu 3 +Standardfilterkedjan och 2 MiB indata +.IP \(bu 3 +Standardfilterkedjan och 4 MiB indata för varje block till slutet av indata. +.RE +.IP "" +Om man anger en storlek som överskrider kodarens blockstorlek (antingen +standardvärdet i trådat läge eller värdet som anges med +\fB\-\-block\-size=\fP\fIstorlek\fP) kommer kodaren skapa ytterligare block med +hänsyn taget till gränserna som anges i \fIposter\fP. Till exempel, om man +anger \fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP och +indatafilen är 80 MiB kommer man få 11 block: 5, 10, 8, 10, 2, 10, 10, 4, +10, 10 och 1 MiB. +.IP "" +I multitrådat läge lagras storleken på blocken i blockhuvudena. Detta görs +inte i enkeltrådat läge, så den kodade utdatan kommer inte vara identisk med +den från det multitrådade läget. +.TP +\fB\-\-flush\-timeout=\fP\fItidsgräns\fP +Vid komprimering, om mer än \fItidsgräns\fP millisekunder (ett positivt heltal) +har gått sedan den föregånde tömningen och en läsning av mer indata skulle +blockera töms all väntande indata från kodaren och görs tillgänglig i +utdataströmmen. Detta kan vara användbart om \fBxz\fP används för att +komprimera data som strömmas över ett nätverk. Små värden på \fItidsgräns\fP +gör data tillgänglig vid den mottagande änden med en liten fördröjning, men +större värden på \fItidsgräns\fP ger bättre komprimeringsförhållande. +.IP "" +Denna funktion är avaktiverad som standard. Om denna flagga anges mer än en +gång gäller den sista. Dett speciella värdet \fB0\fP på \fItidsgräns\fP kan +användas för att uttryckligen avaktivera denna funktion. +.IP "" +Denna funktion är inte tillgänglig på icke\-POSIX\-system. +.IP "" +.\" FIXME +\fBDenna funktion är fortfarande experimentell.\fP För närvarande är \fBxz\fP +olämplig för dekomprimering av strömmen i realtid på grund av hur \fBxz\fP +buffrar. +.TP +\fB\-\-no\-sync\fP +Synkronisera inte målfilen och dess katalog med lagringsenheten före +källfilen tas bort. Detta kan förbättra prestanda vid komprimering eller +dekomprimering av många små filer. Dock, om systemet kraschar snart efter +raderingen är det möjligt att målfilen inte skrevs till lagringsenheten men +att raderingen gjordes det. I det fallet är varken originalkällfilen eller +målfilen tillgänglig. +.IP "" +Denna flagga har bara någon effekt när \fBxz\fP kommer att ta bort källfilen. I +andra fall görs aldrig någon synkronisering. +.IP "" +Synkroniseringen och \fB\-\-no\-sync\fP lades till i \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIgräns\fP +Sätt en gräns på minnesanvändningen för komprimeringen. Om denna flaggan +anges flera gånger gäller den sista. +.IP "" +Om komprimeringsinställnigarna överskrider \fIgränsen\fP kommer \fBxz\fP försöka +justera inställningarna neråt så att gränsen inte längre överskrids och visa +en notis om att en automatisk justering gjorts. Justeringen görs i denna +ordning: reducera antalet trådar, byta till enkeltrådat läge om även en tråd +i multitrådat läge överskrider \fIgränsen\fP och slutligen reducera +LZMA2\-lexikonstorleken. +.IP "" +Vid komprimering med \fB\-\-format=raw\fP eller om \fB\-\-no\-adjust\fP har angetts kan +endast antalet trådar reduceras eftersom det kan göras utan att påverka den +komprimerade utdatan. +.IP "" +Om \fIgränsen\fP inte kan uppfyllas ens med justeringarna som beskrivs ovan +visas ett felmeddelande och \fBxz\fP kommer avsluta med slutstatus 1. +.IP "" +\fIGränsen\fP kan anges på flera sätt: +.RS +.IP \(bu 3 +\fIGränsen\fP kan vara ett absolut värde i byte. Att använda ett heltalssuffix +som \fBMiB\fP kan vara praktiskt. Exempel: \fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +\fIGränsen\fP kan anges som en procentsats av det totala fysiska minnet +(RAM). Detta kan vara användbart särskilt när man sätter miljövariabeln +\fBXZ_DEFAULTS\fP i ett skalinitieringsskript som delas mellan olika +datorer. På det sättet är gränsen automatiskt större på system med mer +minne. Exempel: \fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +\fIGränsen\fP kan återställas tillbaka till sitt standardvärde genom att sätta +den till \fB0\fP. Detta är för närvarande ekvivalent med att sätta \fIgränsen\fP +till \fBmax\fP (ingen gräns på minnesanvändning). +.RE +.IP "" +För 32\-bitars \fBxz\fP finns det ett specialfall: om \fIgränsen\fP skulle vara +över \fB4020\ MiB\fP sätts \fIgränsen\fP till \fB4020\ MiB\fP. På MIPS32 används +\fB2000\ MiB\fP istället. (Värdena \fB0\fP och \fBmax\fP påverkas inte av detta. En +liknande funktion finns inte för dekomprimering.) Detta kan hjälpa till när +ett 32\-bitarsprogram har tillgång till 4\ GiB adressrymd (2 GiB på MIPS32) +förhoppningsvis utan att göra någon skada i andra situationer. +.IP "" +Se även avsnittet \fBMinnesanvändning\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIgräns\fP +Sätt en gräns för minnesanvnändningen vid dekomprimering. Detta påverkar +även läget \fB\-\-list\fP. Om åtgärden inte är möjlig utan att överskrida +\fIgränsen\fP kommer \fBxz\fP visa ett felmeddelande och dekomprimeringen av filen +kommer misslyckas. Se \fB\-\-memlimit\-compress=\fP\fIgräns\fP för möjliga sätt att +ange \fIgränsen\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIgräns\fP +Sätt en gräns för minnesanvändningen för multitrådad dekomprimering. Detta +kan endast påverka antalet trådar; det kommer aldrig att få \fBxz\fP att vägra +att dekomprimera en fil. Om \fIgränsen\fP är för låg för att tillåta någon +multitrådning ignoreras \fIgränsen\fP och \fBxz\fP kommer gå vidare i enkeltrådat +läge. Observera att om även \fB\-\-memlimit\-decompress\fP används kommer det +alltid att gälla både enkeltrådat och multitrådat läge, och därmed kommer +den gällande \fIgränsen\fP för multitrådning aldrig vara högre än gränsen som +sätts med \fB\-\-memlimit\-decompress\fP. +.IP "" +Till skillnad mot de andra flaggorna för gränser för minnesanvändning har +\fB\-\-memlimit\-mt\-decompress=\fP\fIgräns\fP en systemspecifik +standard\fIgräns\fP. \fBxz \-\-info\-memory\fP kan användas för att se det aktuella +värdet. +.IP "" +Denna flagga och dess standardvärde finns för att utan någon gräns skulle +den trådade dekomprimeraren kunna allokera en vansinnig mängd minne med +några indatafiler. Om standard\fIgränsen\fP är för låg på ditt system, öka då +gärna \fIgränsen\fP men sätt den aldrig till ett större värde än mängden +användbart RAM eftersom att med passande indatafiler kommer \fBxz\fP försöka +använda den mängden av minne även med ett lågt antal trådar. Att få slut på +minne ller växling kommer inte förbättra dekomprimeringsprestandan. +.IP "" +Se \fB\-\-memlimit\-compress=\fP\fIgräns\fP för möjliga sätt att ange \fIgränsen\fP. Att +sätta \fIgräns\fP till \fB0\fP återställer \fIgränsen\fP till sdet systemspecifika +standardvärdet. +.TP +\fB\-M\fP \fIgräns\fP, \fB\-\-memlimit=\fP\fIgräns\fP, \fB\-\-memory=\fP\fIgräns\fP +Detta är ekvivalent med att ange \fB\-\-memlimit\-compress=\fP\fIgräns\fP +\fB\-\-memlimit\-decompress=\fP\fIgräns\fP \fB\-\-memlimit\-mt\-decompress=\fP\fIgräns\fP. +.TP +\fB\-\-no\-adjust\fP +Visa ett fel och avsluta om gränsen för minnesanvändning inte kan mötas utan +att justera inställnigar som påverkar den komprimerade utdatan. Det vill +säga, detta förhindrar att \fBxz\fP byter kodaren från multitrådat läge till +enkeltrådat läge och från att den reducerar LZMA2\-lexikonets storlek. Även +när denna flagga används kan antalet trådar reduceras för att möta gränsen +för minnesanvändning eftersom det inte kommer påverka den komprimerade +utdatan. +.IP "" +Automatisk justering är alltid avaktiverat när råa strömmar skapas +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fItrådar\fP, \fB\-\-threads=\fP\fItrådar\fP +Ange antalet arbetstrådar som skall användas. Att sätta \fItrådar\fP till ett +specialvärde \fB0\fP gör att \fBxz\fP använder så många trådar som processorerna +på systemet stödjer. Det aktuella antalet trådar kan vara färre än \fItrådar\fP +om indatafilen inte är stor nog för trådning med de givna inställningarna +eller om användning av fler trådar skulle överkrida gränsen för +minnesanvändning. +.IP "" +De enkeltrådade och multitrådade komprimerarna producerar olika utdata. Den +enkeltrådade komprimeraren kommer ge den minsta filstorleken men endast +utdata från den multitrådade komprimeraren kan dekomprimeras med flera +trådar. Att sätta \fItrådar\fP till \fB1\fP kommer använda enkeltrådat läge. Att +sätta \fItrådar\fP till något annat värde, inklusive \fB0\fP, kommer använda den +multitrådade komprimeraren även om systemet endast stödjer en hårdvarutråd. +(\fBxz\fP 5.2.x använde enkeltrådat läge i denna situation.) +.IP "" +För att använda multitrådat läge med endast en tråd, sätt \fItrådar\fP till +\fB+1\fP. Prefixet \fB+\fP har ingen påvrekan för andra värden än \fB1\fP. En gräns +för minnesanvändning kan fortfarande göra att \fBxz\fP byter till enkeltrådat +läge såvida inte \fB\-\-no\-adjust\fP används. Stöd för prefixet \fB+\fP lades till i +\fBxz\fP 5.4.0. +.IP "" +Om ett automatiskt antal trådar har begärts och ingen gräns för +minnesanvändning har angivits, då kommer en systemspecifik mjuk +standardgräns användas för att möjligen begränsa antalet trådar. Det är en +mjuk gräns i den meningen att den ignoreras om antalet trådar blir en, +alltså kommer en mjuk gräns aldrig hindra \fBxz\fP från att komprimera eller +dekomprimera. Denna mjuka standardgräns kommer inte göra att \fBxz\fP byter +från multitrådat läge till enkeltrådat läge. De aktiva gränserna kan ses med +\fBxz \-\-info\-memory\fP. +.IP "" +För närvarande är den enda trådningsmetoden att dela indata i block och +komprimera dem oberoende av varandra. Standardstorleken på block beror på +komprimeringsnivån och kan åsidosättas med flaggan +\fB\-\-block\-size=\fP\fIstorlek\fP. +.IP "" +Trådad dekomprimering fungerar bara på filer som innehåller flera block med +storleksinformation i blockhuvuden. Alla tillräckligt stora filer +komprimeras i multitrådat läge för att uppfylla detta villkor, men filer +komprimerade i enkeltrådat läge gör det inte ens om +\fB\-\-block\-size=\fP\fIstorlek\fP har använts. +.IP "" +Standardvärdet på \fItrådar\fP är \fB0\fP. I \fBxz\fP 5.4.x och tidigare är +standardvärdet \fB1\fP. +. +.SS "Anpassade komprimerarfilterkedjor" +Med en anpassad filterkedja kan man specificera kompressionsinställningarna +i detalj istället för att lita på inställningarna som hör till +förinställningarna. När en anpassad filterkedja anges glöms +förinställningsflaggor (\fB\-0\fP \&…\& \fB\-9\fP och \fB\-\-extreme\fP) tidigare på +kommandoraden. Om en förinställningsflagga anges efter en eller flera +flaggor för anpassade filterkedjor gäller den nya förinställningen och de +flaggor för anpassade filterkedjor som angivits tidigare glöms. +.PP +En filterkedja är jämförbar med att skapa rör på kommando. Vid komprimering +skickas den okomprimerade indatan till det första filtret, vars utdata +skickas till nästa filter (om något). Utdatan från det sista filtret blir +skrivet till den komprimerade filen. Det maximala antalet filter i kedjan är +fyra, men typiskt har en filterkedja bara ett ellet två filter. +.PP +Många filter har begränsningar på var de kan finnas i filterkedjan: några +filter kan bara fungera som det sista filtret i kedjan, några bara om de +inte är det sista filtret, och några fungerar i godtycklig position i +kedjan. Beroende på filtret är denna begränsning antingen en egenskap hos +filterdesignen eller finns för att förhindra säkerhetsproblem. +.PP +En anpassad filterkedja kan anges på två olika sätt. Med flaggorna +\fB\-\-filters=\fP\fIfilter\fP och \fB\-\-filters1=\fP\fIfilter\fP \&…\& +\fB\-\-filters9=\fP\fIfilter\fP kan man ange en hel filterkedja med en flagga genom +att använda syntaxen för liblzma\-filtersträngar. Alternativt kan en +filterkedja anges genom att använda en eller flera individuella +filterflaggor i den ordning de önskas i filterkedjan. Det vill säga, +ordningen på de individuella filterflaggorna är signifikant! Vid avkodning +av råa strömmar (\fB\-\-format=raw\fP) måste filterkedjan anges i samma ordning +som den specificerades vid komprimeringen. Eventuella individuella filter\- +eller förinstiällningsflaggor angivna före den fullständiga +filterkedjeflaggan (\fB\-\-filters=\fP\fIfilter\fP) kommer glömmas. Individuella +filter som anges efter den flaggan för en full kedja kommer återställa +filterkedjan. +.PP +Både den fullständiga och de individuella filterflaggorna tar +filterspecifika \fIflaggor\fP som en kommaseparerad lista. Extra komman +\fIflaggor\fP ignoreras. Varje flagga har ett standardvärde, så ange dem du +vill ändra. +.PP +För att se hela filterkedjan och \fIflaggor\fP, använd \fBxz \-vv\fP (det vill +säga, använd \fB\-\-verbose\fP två gånger). Detta fungerar även för att se +flaggorna för filterkedjor som används av förinställningar. +.TP +\fB\-\-filters=\fP\fIfilter\fP +Ange den fullständiga filterkedan eller en förinställning en en enda +flagga. Varje filter kan separeras med blanktecken eller två bindestreck +(\fB\-\-\fP). \fIfilter\fP kan behöva citeras på skalets kommandorad så att det +tolkas som en enda flagga. För att beteckna \fIflaggor\fP, använd \fB:\fP eller +\fB=\fP. En förinställning kan föregås med ett \fB\-\fP och följas av noll eller +flera flaggor. Den enda flaggan som stödjs är \fBe\fP för att tillämpa samma +flaggor som \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIfilter\fP … \fB\-\-filters9\fP=\fIfilter\fP +Ange upp till nio ytterligare filterkedjor som kan användas med +\fB\-\-block\-list\fP. +.IP "" +Till exempel, vid komprimering av ett arkiv med körbara filer följt av +textfiler skulle den körbara delen kunna använda en filterkedja med ett +BCJ\-filter och endast textdelen med LZMA2\-filtret. +.TP +\fB\-\-filters\-help\fP +Visa ett hjälpmeddelande som beskriver hur man anger förinställningar och +anpassade filterkedjor i flaggorna \fB\-\-filters\fP och \fB\-\-filters1=\fP\fIfilter\fP +\&…\& \fB\-\-filters9=\fP\fIfilter\fP, och avsluta rent. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIflaggor\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIflaggor\fP] +.PD +Lägg till LZMA1\- eller LZMA2\-filter till filterkedjan. Dessa filter kan +endast användas som det sista filtret i kedjan. +.IP "" +LZMA1 är ett föråldrat filter, vilket stödjs nästan enbart på grund av det +föråldrade filformatet \fB.lzma\fP, vilket bara stödjer LZMA1. LZMA2 är en +uppdaterad version av LZMA1 för att lösa några praktiska problem med +LZMA1. Formatet \fB.xz\fP använder LZMA2 och stödjer inte LZMA1 +alls. Komprimeringshastigheten och förhållandena för LZMA1 är LZMA2 är +praktiskt taget desamma. +.IP "" +LZMA1 och LZMA2 delar samma uppättning \fIflaggor\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIförinställning\fP +Återställ alla LZMA1\- eller LZMA2\-\fIflaggor\fP till +\fIförinställning\fP. \fIFörinställning\fP består av ett heltal, vilket kan följas +av enskilda bokstäver som modifierar förinställningen. Heltalet kan vara +från \fB0\fP till \fB9\fP, motsvarande kommandoradsflaggorna \fB\-0\fP \&…\& +\fB\-9\fP. Den enda modifierare som stödjs för närvarande är \fBe\fP, vilket +motsvarar \fB\-\-extreme\fP. Om ingen \fBpreset\fP anges tas standardvärden på +LZMA1\- eller LZMA2\-\fIflaggor\fP från förinställningen \fB6\fP. +.TP +\fBdict=\fP\fIstorlek\fP +Ett lexikons (historiebufferts) \fIstorlek\fP indikerar hur många byte med +nyligen bearbetad okomprimerad data som hålls i minnet. Algoritmen försöker +hitta återkommande bytesekvenser (matchningar) i den okomprimerade datan, +och ersätta dem med referenser till datan som för närvarande finns i +lexikonet. Ju större lexikon, desto högre är sannolikheten att hitta en +matchning. Att öka lexikonets \fIstorlek\fP förbättrar alltså vanligen +komprimeringsförhållandet, men ett lexikon som är större än den +okomprimerade filen är ett slöseri med minne. +.IP "" +En typisk \fIstorlek\fP på lexikon är från 64\ KiB till 64\ MiB. Minimum är 4\ KiB. Det maximala för komprimering är för närvarande 1,5\ GiB (1536\ MiB). Dekomprimeraren stödjer redan lexikon upp till en byte mindre än 4\ GiB, vilket är det maximala för strömformaten LZMA1 och LZMA2. +.IP "" +Lexikon\fIstorlek\fP och matchhittaren (\fImf\fP) avgör tillsammans +minnesanvändningen för LZMA1\- eller LZMA2\-kodaren. Ett lika \fIstort\fP (eller +större) lexikon behövs för dekomprimering som det som användes vid +komprimeringen, minnesanvändningen för avkodaren avgörs alltså av +lexikonstorleken vid komprimering. Huvudena i \fB.xz\fP innehåller lexikonets +\fIstorlek\fP antingen som 2^\fIn\fP eller 2^\fIn\fP + 2^(\fIn\fP\-1), så dessa +\fIstorlekar\fP är lite att föredra för komprimering. Andra \fIstorlekar\fP kommer +avrundas uppåt när de lagras i huvuden i \fB.xz\fP. +.TP +\fBlc=\fP\fIlk\fP +Ange antalet literala kontextbitar. Minimum är 0 och maximum är 4; +standardvärdet är 3. Dessutom får inte summan av \fIlk\fP och \fIlp\fP överskrida +4. +.IP "" +Alla byte som inte kan kodas som matchningar kodas som literaler. Det vill +säga, literaler är helt enkelt 8\-bits byte som kodas en åt gången. +.IP "" +Den literala kodningen gör antagandet att de högsta \fIlk\fP bitarna av den +föregående okomprimerade byten korrelerar med nästa byte. Till exempel, i +typisk engelsk text följs ofta en versal bokstav av en gemen bokstav, och en +gemen bokstav följs vanligen av en annan gemen bokstav. I +teckenuppsättningen US\-ASCII är de högsta tre bitarna 010 för versala +bokstäver och 011 för gemena bokstäver. När \fIlk\fP är åtminstone 3 kan den +literala kodningen dra nytta av denna egenskap i den okomprimerade datan. +.IP "" +Standardvärdet (3) är normalt bra. Om man vill ha maximal komprimering, +prova \fBlc=4\fP. Ibland hjälper det lite, och ibland gör det komprimeringen +sämre. Om det gör den sämre, testa också \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Ange antalet literala positionsbitar. Minimum är 0 och maximum är 4; +standardvärdet är 0. +.IP "" +\fILp\fP påverkar vilken sorts justering i den okomprimerade datan som antas +vid kodning av literaler. Se \fIpb\fP nedan för mer information om justering. +.TP +\fBpb=\fP\fIpb\fP +Ange antalet positionsbitar. Minimum är 0 och maximum är 4; standardvärdet +är 2. +.IP "" +\fIPb\fP påverkar vilken sort justering i den okomprimerade datan som antas i +allmänhet. Standardvärdet betyder fyrbytejustering (2^\fIpb\fP=2^2=4), vilket +ofta är ett bra val när det inte finns någon bättre gissning. +.IP "" +När justeringen är känd kan en inställning av \fIpb\fP därefter reducera +filstorleken något. Till exempel, med textfiler som har en\-byte\-justering +(US\-ASCII, ISO\-8859\-*, UTF\-8) kan att sätta \fBpb=0\fP förbättra komprimeringen +något. För UTF\-16\-text är \fBpb=1\fP ett bra val. Om justeringen är ett udda +tal som 3 byte kan \fBpb=0\fP vara det bästa valet. +.IP "" +Även om den antagna justeringen kan anpassas med \fIpb\fP och \fIlp\fP föredrar +LZMA1 och LZMA2 ändå något 16\-byte\-justering. Det kan vara värt att ta med i +beräkningen vid design av filformat som sannolikt ofta kan komma att +komprimeras med LZMA1 eller LZMA2. +.TP +\fBmf=\fP\fIms\fP +Matchsökaren har en stor poverkan på kodarens hastighet, minnesanvändning +och komprimeringsförhållande. Vanligen är Hashkedje\-matchsökare snabbare än +Binärträdsmatchsökare. Standardvärdet beror på \fIföinställningen\fP: 0 +använder \fBhc3\fP, 1\(en3 använder \fBhc4\fP, och resten använder \fBbt4\fP. +.IP "" +Följande matchsökare stödjs. Formlerna för minnesanvändning nedan är grova +uppskattningar, vilka är närmast sanningen när \fIdict\fP är en tvåpotens. +.RS +.TP +\fBhc3\fP +Hashkedja med 2\- och 3\-bytehashning +.br +Minsta värde på \fInice\fP: 3 +.br +Minnesanvändning: +.br +\fIdict\fP · 7.5 (om \fIdict\fP ≤ 16 MiB); +.br +\fIdict\fP · 5,5 + 64 MiB (om \fIdict\fP > 16 MiB) +.TP +\fBhc4\fP +Hashkedja med 2\-, 3\- och 4\-bytehashning +.br +Minsta värde på \fInice\fP: 4 +.br +Minnesanvändning: +.br +\fIdict\fP · 7,5 (om \fIdict\fP ≤ 32 MiB); +.br +\fIdict\fP · 6,5 (om \fIdict\fP > 32 MiB) +.TP +\fBbt2\fP +Binärträd med 2\-bytehashning +.br +Minsta värde på \fInice\fP: 2 +.br +Minnesanvändning: \fIdict\fP · 9,5 +.TP +\fBbt3\fP +Binärträd med 2\- och 3\-bytehashning +.br +Minsta värde på \fInice\fP: 3 +.br +Minnesanvändning: +.br +\fIdict\fP · 11,5 (om \fIdict\fP ≤ 16 MiB); +.br +\fIdict\fP · 9,5 + 64 MiB (om \fIdict\fP > 16 MiB) +.TP +\fBbt4\fP +Binärträd med 2\-, 3\- och 4\-bytehashning +.br +Minsta värde på \fInice\fP: 4 +.br +Minnesanvändning: +.br +\fIdict\fP · 11,5 (om \fIdict\fP ≤ 32 MiB); +.br +\fIdict\fP · 10,5 (om \fIdict\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fIläge\fP +Komprimerings\fIläget\fP anger metoden som används för att analysera data +skapade av matchsökaren. De \fIlägen\fP som stödjs är \fBfast\fP och +\fBnormal\fP. Standardvärdet är \fBfast\fP för \fIförinställningarna\fP 0\(en3 och +\fBnormal\fP för \fIförinställningarna\fP 4\(en9 +.IP "" +Vanligen används \fBfast\fP med Hashkedjematchsökare och \fBnormal\fP med +Binärträdsmatchsökare. Detta är även vad \fIförinställningarna\fP gör. +.TP +\fBnice=\fP\fIlagom\fP +Ange vad som anses vara en lagom längt på en matchning. När en matchning på +åtminstone \fIlagom\fP byte hittats slutar algoritmen söka efter möjliga bättre +matchningar. +.IP "" +\fILagom\fP kan vara 2\(en273 byte. Högre värden tenderar att ge bättre +komprimeringsförhållande på bekostnad av tid. Standardvärdet beror på +\fIförinställningen\fP. +.TP +\fBdepth=\fP\fIdjup\fP +Ange det maximala sökdjupet i matchsökaren. Standardvärdet är specialvärdet +0, vilket får komprimeraren att avgöra ett lämpligt \fIdjup\fP från \fImf\fP och +\fInice\fP. +.IP "" +Lämpligt \fIdjup\fP för Hashkedjor är 4\(en100 och 16\(en1000 för +Binärträd. Att använda väldigt höga värden på \fIdjup\fP kan göra kodaren +extremt långsam för vissa filer. Undvik att sätta \fIdjup\fP över 1000 såvida +du inte är beredd att avbryta komprimeringen om den tar för lång tid. +.RE +.IP "" +Vid avkodning av råa strömmar (\fB\-\-format=raw\fP) behöver LZMA2 endast +lexikonets \fIstorlek\fP. LZMA1 behöver även \fIlc\fP, \fIlp\fP och \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIflaggor\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIflaggor\fP] +.PD +Lägg till gren/anrop/hopp\-filter (branch/call/jump, BCJ) till +filterkedjan. Dessa filter kan inte användas som det sista filtret i +filterkedjan. +.IP "" +Ett BCJ\-filter konverterar relativa adresser i maskinkod till deras absoluta +motsvarigheter. Detta ändrar inte storleken på datan men det ökar +redundansen, vilket kan hjälpa LZMA2 att skapa 0\(en15\ % mindre +\&\fB.xz\fP\-filer. BCJ\-filtren är alltid reversibla, så att använda ett +BCJ\-filter för fel sorts data orsakar inte någon dataförlust, men det kan +göra komprimeringsförhållandet något sämre. BCJ\-filtren är mycket snabba +och använder en obetydling mängd minne. +.IP "" +Dessa BCJ\-filter har kända problem kopplade till komprimeringsförhållandet: +.RS +.IP \(bu 3 +Någr sortes filer som innehåller körbar kod (till exempel, objektfiler, +statiska bibliotek och Linux kärnmoduler) har adresserna i instruktionerna +fyllda med utfyllnadsvärden. Dessa BCJ\-filter kommer ändå göra +adresskonverteringen, vilket kommer göra komprimeringen sämre för dessa +filer. +.IP \(bu 3 +Om ett BCJ\-filter används på ett arkiv är det möjligt att det gör +komprimeringsförhållandet sämre än att inte använda något BCJ\-filter. Till +exempel, om det finns liknande eller till och med identiska körbara kommer +filtreringen sannolikt göra filerna mindre lika och därmed blir +kompressionen sämre. Innehållet i icke körbara filer i samma arkiv kan också +spela en roll. I praktiken måste man prova med och utan ett BCJ\-filter för +att se vilket som är det bästa i varje situation. +.RE +.IP "" +Olika instruktionsuppsättningar har olika justering: den körbara filen måste +vara justerad till en multipel av detta värde i indata för att filtret skall +fungera. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filter;Justering;Kommentarer +x86;1;32\-bitars eller 64\-bitars x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096\-bytesjustering är bäst +PowerPC;4;Endast rak byteordning +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Eftersom BCJ\-filtrerad data vanligen komprimeras med LZMA2 kan +komprimeringsförhållandet förbättras något om LZMA2\-flaggorna sätts till att +matcha justeringen hos det valda BCJ\-filtret. Exempel: +.RS +.IP \(bu 3 +IA\-64\-filter har 16\-bytejustering så \fBpb=4,lp=4,lc=0\fP är bra med LZMA2 +(2⁴=16). +.IP \(bu 3 +RISC\-V\-kod har 2\-byte\- eller 4\-bytejustering beroende på huruvida filen +innehåller 16\-bitars komprimerade instruktioner (utvidgningen C). När +16\-bitarsinstruktioner används är \fBpb=2,lp=1,lc=3\fP eller \fBpb=1,lp=1,lc=3\fP +bra. När det inte finns några 16\-bitsinstruktioner är \fBpb=2,lp=2,lc=2\fP +bäst. \fBreadelf \-h\fP kan användas för att kontrollera om ”RVC” förekommer på +raden ”Flaggor”. +.IP \(bu 3 +ARM64 är alltid 4\-bytejusterad så \fBpb=2,lp=2,lc=2\fP är bäst. +.IP \(bu 3 +Filtret x86 är ett undantag. Det är normalt bra att hålla sig till LZMA2:s +standardvärden (\fBpb=2,lp=0,lc=3\fP) när körbar x86 komprimeras. +.RE +.IP "" +Alla BCJ\-filter stödjer samma \fIflaggor\fP: +.RS +.TP +\fBstart=\fP\fIavstånd\fP +Ange start\fIavståndet\fP som används vid konvertering mellan relativa och +absoluta adresser. \fIAvståndet\fP måste vara en multipel av filtrets justering +(se tabellen ovan). Standardvärdet är noll. I praktiken är standardvärdet +bra; det är nästan aldrig användbart att ange ett anpassat \fIavstånd\fP. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIflaggor\fP] +Lägg till Deltafiltret till filterkedjan. Deltafiltret kan inte användas som +det sista filtret i filterkedjan. +.IP "" +För närvarande stödjs bara enkel byte\-vis deltaberäkning. Det kan vara +användbart vid komprimering, till exempel av okomprimerade +bitavbildningsbilder eller okomprimerad PCM\-audio. Dock kan algoritmer för +särskilda ändamål ge betydligt bättre resultat än Delta + LZMA2. Detta är +särskilt sant med audio, vilket komprimerar snabbare och bättre med till +exempel \fBflac\fP(1). +.IP "" +Stödda \fIflaggor\fP: +.RS +.TP +\fBdist=\fP\fIavstånd\fP +Ange \fIavståndet\fP för deltaberäkningen i byte. \fIAvstånd\fP måste varea +1\(en256. Standardvärdet är 1. +.IP "" +Till exempel, med \fBdist=2\fP och åtta byte indata A1 B1 A2 B3 A3 B5 A4 B7, +kommer utdata vara A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Andra flaggor" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Utelämna varningar och noteringar. Ange detta två gånger för att även +utelämna felmeddelandet. Denna flagga har ingen påverkan på +slutstatusen. Det vill säga, även om en varning utelämnades kommer +slutstatusen fortfarandeindikera att en varning gavs. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Var utförlig. Om standard fel är kopplat till en terminal kommer \fBxz\fP visa +en förloppsmätare. Att ange \fB\-\-verbose\fP två gånger kommer ge än mer +utförlig utmatning. +.IP "" +Förloppsmätaren visar följande information: +.RS +.IP \(bu 3 +Procent färdigt visas om storleken på indatafilen är känd. Det vill säga, +procentsatsen kan inte visas i rör. +.IP \(bu 3 +Mängd komprimerad data som producerats (komprimering) eller konsumerats +(dekomprimering). +.IP \(bu 3 +Mängd okomprimerad data som konsumerats (komprimering) eller producerats +(dekomprimering). +.IP \(bu 3 +Komprimeringsförhållande, vilket beräknas genom att dividera mängden +komprimerad data bearbetad så lång med mängde okomprimerad data bearbetad så +långt. +.IP \(bu 3 +Kompressions eller dekompressionshastighet. Detta mäts som mängden +okomprimerad data konsumerad (komprimering) eller producerad +(dekomprimering) per sekund. Det visas efter att några sekunder har gåt +efter att \fBxz\fP började bearbeta filen. +.IP \(bu 3 +Förfluten tid på formatet MM:SS eller H:MM:SS. +.IP \(bu 3 +Beräknad återstående tid visas endast när storleken på indatafilen är känd +och några sekunder redan gått efter att \fBxz\fP började bearbeta filen. Tiden +visas i ett mindre precist format vilket aldrig har några kolon, till +exempel, 2 min 30 s. +.RE +.IP "" +När standard fel inte är en terminal kommer \fB\-\-verbose\fP göra att \fBxz\fP +skriver filnamnet, komprimerad storlek, okomprimerad storlek, +komprimeringsförhållande och möjligen även hastigheten och den förlupna +tiden på en enda rad till standard fel efter att ha komprimerat eller +dekomprimerat filen. Hastigheten och den förlupna tiden inkluderas endast +när åtgärden tog åtminstone några sekunder. Om åtgärden inte slutfördes, +till exempel för att användaren avbröt, skrivs även den fullbordade +procentsatsen om storleken på indatafilen är känd. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Sätt inte slutstatus till 2 även om ett tillstånd som är värt en varning +upptäcktes. Denna flagga påverkar inte utförlighetsnivån, allts måste både +\fB\-\-quiet\fP och \fB\-\-no\-warn\fP användas för att inte visa varningar och för att +inte ändra slutstatusen. +.TP +\fB\-\-robot\fP +Skriv meddelanden i maskinläsbart form. Detta är avsett att förenkla att +skriva framändar som vill använda \fBxz\fP istället för liblzma, vilken kan +vara fallet i olika skript. Utdatan med denna flagga aktiverad är avsedd att +vara stabil mellan utgåvor av \fBxz\fP. Se avsnitett \fBROBOTLÄGE\fP för detaljer. +.TP +\fB\-\-info\-memory\fP +Visa, på mänskligt läsbar form, hur mycket fysiskt minne (RAM) och hur många +processortrådar \fBxz\fP tror att systemet har och gränserna för +minnesanvändning vid komprimering och dekomprimering, och avsluta. +.TP +\fB\-h\fP, \fB\-\-help\fP +Visa ett hjälpmeddelande som beskriver de vanligast använda flaggorna, och +avsluta. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Visa ett hjälpmeddelande som beskriver alla funktioner i \fBxz\fP, och avsluta +.TP +\fB\-V\fP, \fB\-\-version\fP +Visa versionsnumret för \fBxz\fP och liblzma i mänskligt läsbar form. För att +få maskinläsbar utdata, ange \fB\-\-robot\fP före \fB\-\-version\fP. +. +.SH ROBOTLÄGE +Robotläget aktiveras med flaggan \fB\-\-robot\fP. Det gör att utdata från \fBxz\fP +är enklare att tolka av andra program. För närvarande stödjs \fB\-\-robot\fP +endast tillsammans med \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP och +\fB\-\-version\fP. Den kommer att stödjas för komprimering och dekomprimering i +framtiden. +. +.SS Listläge +\fBxz \-\-robot \-\-list\fP använder tab\-separerad utmatning. Första kolumnen av +varje rad har en sträng som indikerar typen av informationen som finns på +den raden: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Detta är alltid första raden när en fil börjar listas. Den andra kolumen på +raden är filnamnet. +.TP +\fBfile\fP +Denna rad innehåller övergripande information om \fB.xz\fP\-filen. Denna rad +skrivs alltid efter raden \fBname\fP. +.TP +\fBstream\fP +Denna radtyp används endast när \fB\-\-verbose\fP angetts. Det finns lika många +\fBstream\fP\-rader som det finns strömmar i \fB.xz\fP\-filen. +.TP +\fBblock\fP +Denna radtyp används bara när \fB\-\-verbose\fP angetts. Det finns lika många +\fBblock\fP\-rader som det finns block i \fB.xz\fP\-filen. \fBblock\fP\-rader visas +efter alla \fBstream\fP\-raderna; olika radtyper blandas inte. +.TP +\fBsummary\fP +Denna radtyp används bara när \fB\-\-verbose\fP angetts två gånger. Denna rad +skrivs eefter alla \fBblock\fP\-rader. Liksom raden \fBfile\fP inenhåller raden +\fBsummary\fP övergripande information om \fB.xz\fP\-filen. +.TP +\fBtotals\fP +Denna rad är alltid den allra sista raden i listutmatningen. Den visar det +totala antalen och storlekarna. +.PP +Kolumnerna på \fBfile\fP\-raderna: +.PD 0 +.RS +.IP 2. 4 +Antalet strömmar i filen +.IP 3. 4 +Totalt antal block i strömmarna +.IP 4. 4 +Komprimerad storlek på filen +.IP 5. 4 +Okomprimerad storlek på filen +.IP 6. 4 +Komprimeringsförhållande, till exempel \fB0.123\fP. Om förhållandet är över +9.999 visas tre bindestreck (\fB\-\-\-\fP) istället för förhållandet. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Kommaseparerad lista med integritetskontrollnamn. Följande strängar används +för de kända kontrolltyperna: \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP och +\fBSHA\-256\fP. För okända kontrolltyper används \fBUnknown\-\fP\fIN\fP, där \fIN\fP är +kontroll\-ID:t som ett decimalt nummer (en eller två siffror). +.IP 8. 4 +Total storlek på strömutfyllnad i filen +.RE +.PD +.PP +Kolumnerna på \fBstream\fP\-raderna: +.PD 0 +.RS +.IP 2. 4 +Strömnummer (den första strömmen är 1) +.IP 3. 4 +Antal block i strömmen +.IP 4. 4 +Komprimerat startavstånd +.IP 5. 4 +Okomprimerat startavstånd +.IP 6. 4 +Komprimerad storlek (inkluderar inte strömutfyllnad) +.IP 7. 4 +Okomprimerad storlek +.IP 8. 4 +Komprimeringsförhållande +.IP 9. 4 +Namnet på integritetskontrollen +.IP 10. 4 +Storleken på strömutfyllnad +.RE +.PD +.PP +Kolumnerna på \fBblock\fP\-raderna: +.PD 0 +.RS +.IP 2. 4 +Numret på strömmen som innehåller detta block +.IP 3. 4 +Blocknummer relativt början på strömmen (det första blocket är 1) +.IP 4. 4 +Blocknummer relativt början på filen +.IP 5. 4 +Komprimerat startavstånd relativt början av filen +.IP 6. 4 +Okomprimerat startavstånd relativt början av filen +.IP 7. 4 +Total komprimerad storlek på blocket (inkluderar huvuden) +.IP 8. 4 +Okomprimerad storlek +.IP 9. 4 +Komprimeringsförhållande +.IP 10. 4 +Namnet på integritetskontrollen +.RE +.PD +.PP +Om \fB\-\-verbose\fP angavs två gånger inkluderas ytterligare kolumner på +\fBblock\fP\-raderna. Dessa visas inte med bara ett \fB\-\-verbose\fP, eftersom det +för att få fram denna information krävs många sökningar och kan därmed vara +långsamt: +.PD 0 +.RS +.IP 11. 4 +Värdet på integritetskontrollen hexadecimalt +.IP 12. 4 +Blockhuvudstorlek +.IP 13. 4 +Blockflaggor: \fBc\fP indikerar att komprimerad storlek finns, och \fBu\fP +indikerar att okomprimerad storlek finns. Om flaggan inte är satt visas ett +bindestreck (\fB\-\fP) istället för att hålla stränglängden fast. Nya flaggor +kan läggas till i slutet av strängen i frmtiden. +.IP 14. 4 +Storlek på den faktiska komprimerade datan i blocket (detta utelämnar +blockhuvud, blockutfyllnad och kontrollfält) +.IP 15. 4 +Mängd minne (i byte) som behövs för att dekomprimera detta block med denna +version av \fBxz\fP +.IP 16. 4 +Filterkedja. Observera att de flesta av flaggorna som användes vid +komprimeringstillfället inte kan vara kända, eftersom endat de flaggor som +behövs för dekomprimering lagras i \fB.xz\fP\-huvudet. +.RE +.PD +.PP +Kolumnerna på \fBsummary\fP\-raderna: +.PD 0 +.RS +.IP 2. 4 +Mängd minne (i byte) som behövs för att dekomprimera denna fil med denna +version av \fBxz\fP +.IP 3. 4 +\fByes\fP eller \fBno\fP som indikerar om alla blockhuvuden både har komprimerad +storlek och okomprimerad storlek i sig +.PP +\fIFrån\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Minsta version av \fBxz\fP som krävs för att dekomprimera filen +.RE +.PD +.PP +Kolumnerna på \fBtotals\fP\-raden: +.PD 0 +.RS +.IP 2. 4 +Antal strömmar +.IP 3. 4 +Antal block +.IP 4. 4 +Komprimerad storlek +.IP 5. 4 +Okomprimerad storlek +.IP 6. 4 +Genomsnittligt komprimeringsförhållande +.IP 7. 4 +Kommaseparerad lista med integritetskontrollnamn som fanns i filerna +.IP 8. 4 +Strömutfyllnadsstorlek +.IP 9. 4 +Antal filer. Denna finns här för att hålla ordningen av de tidigare +kolumnerna desamma som på \fBfile\fP\-rader. +.PD +.RE +.PP +Om \fB\-\-verbose\fP angavs två gånger inkluderas ytterligare kolumner på +\fBtotals\fP\-raden: +.PD 0 +.RS +.IP 10. 4 +Maximal mängd minne (i byte) som behövs för att dekomprimera filerna med +denna version av \fBxz\fP +.IP 11. 4 +\fByes\fP eller \fBno\fP som indikerar om alla blockhuvuden både har komprimerad +storlek och okomprimerad storlek i sig +.PP +\fIFrån\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Minsta version av \fBxz\fP som krävs för att dekomprimera filen +.RE +.PD +.PP +Framtida versioner kan lägga till fler radtyper och fler kolumner kan läggas +til på de befintliga radtyperna, men de befintliga kolumnerna kommmer inte +ändras. +. +.SS Filterhjälp +\fBxz \-\-robot \-\-filters\-help\fP skriver ut de filter som stödjs i följande +format: +.PP +\fIfilter\fP\fB:\fP\fIflagga\fP\fB=<\fP\fIvärde\fP\fB>,\fP\fIflagga\fP\fB=<\fP\fIvärde\fP\fB>\fP… +.TP +\fIfilter\fP +Namn på filtret +.TP +\fIflagga\fP +Namn på en filterspecifik flagga +.TP +\fIvärde\fP +Numeriska \fIvärde\fPintervall ser ut som +\fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. Sträng\fIvärdes\fP val visas inom \fB< >\fP och separerade med ett \fB|\fP\-tecken. +.PP +Varje filter skrivs på en egen rad. +. +.SS Minnesgränsinformation +\fBxz \-\-robot \-\-info\-memory\fP skriver en rad med flera tab\-separerade +kolumner: +.IP 1. 4 +Total mängd med fysiskt minne (RAM) i byte. +.IP 2. 4 +Minnesanvändningsgräns för komprimering i byte (\fB\-\-memlimit\-compress\fP). Ett +specialvärde \fB0\fP indikerar standardinställningen vilken för enkeltrådat +läge är detsamma som ingen gräns. +.IP 3. 4 +Minnesanvändningsgräns för dekomprimering i byte +(\fB\-\-memlimit\-decompress\fP). Ett specialvärde \fB0\fP indikerar +standdartinställningen vilken för enkeltrådat läge är detsamma som ingen +gräns. +.IP 4. 4 +Från \fBxz\fP 5.3.4alpha: Minnesanvändningen för multitrådad dekomprimering i +byte (\fB\-\-memlimit\-mt\-decompress\fP). Detta är aldrig noll eftersom ett +systemspecifikt standardvärde som visas i kolumn 5 används om ingen gräns +har angivits uttryckligen. Detta är heller aldrig större än värdet i kolumn +3 även om ett större värde har angivits med \fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Från \fBxz\fP 5.3.4alpha: Ett systemspecifikt standardgräns för +minnesanvändning som används för att begränsa antalet trådar vid +komprimering med ett automatiskt antal trådar (\fB\-\-threads=0\fP) och ingen +gräns för minnesanvändning har angivits (\fB\-\-memlimit\-compress\fP). Detta +används även som standardvärdet på \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Från \fBxz\fP 5.3.4alpha: antal tillgängliga processortrådar. +.PP +I framtiden kan utdata från \fBxz \-\-robot \-\-info\-memory\fP ha fler kolumner, +men aldrig mer än en rad. +. +.SS Version +\fBxz \-\-robot \-\-version\fP skriver versionsnumret på \fBxz\fP och liblzma i +följande format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Huvudversion. +.TP +\fIYYY\fP +Underversion. Jämna nummer är stabila. Udda nummer är alfa\- eller +betaversioner. +.TP +\fIZZZ\fP +Rättningsnivå för stabila utgåvor eller bara en räknare för +utvecklingsutgåvor. +.TP +\fIS\fP +Stabilitet. 0 är alfa, 1 beta beta och 2 är stabil. \fIS\fP skall alltid vara +2 när \fIYYY\fP är jämnt. +.PP +\fIXYYYZZZS\fP är samma på båda raderna om \fBxz\fP och liblzma kommer från samma +utgåva av XZ Utils. +.PP +Exempel: 4.999.9beta är \fB49990091\fP och 5.0.0 är \fB50000002\fP. +. +.SH SLUTSTATUS +.TP +\fB0\fP +Allt är bra. +.TP +\fB1\fP +Ett fel uppstod. +.TP +\fB2\fP +Något värt en varning uppstod, men inga faktiska fel uppstod. +.PP +Noteringar (inte varningar eller fel) som skrivs på standard fel påverkar +inte slutstatusen. +. +.SH MILJÖ +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP tolkar mellanrumsseparerade listor av flaggor från miljövariablerna +\fBXZ_DEFAULTS\fP och \fBXZ_OPT\fP, i den ordningen, före flaggorna på +kommandoraden. Observera att endast flaggor tolkas från miljövariablerna; +alla andra argument än flaggor ignoreras tyst. Tolkningen görs med +\fBgetopt_long\fP(3) vilket även används för kommandoradsargumenten. +.PP +\fBVarning:\fP genom att sätta dessa miljövariabler ändrar man i praktiken +program och skript som kör \fBxz\fP. för det mesta är set säkert att sätta +begränsningar på minnesanvändning, antal trådar och komprimeringsflaggor via +miljövariablerna. Några flaggor kan dock göra att skript går sönder. Ett +uppenbart exempel är \fB\-\-help\fP vilket gör att \fBxz\fP visar en hjälptext +istället för att komprimera eller dekomprimera en fil. Mer subtila exempel +är \fB\-\-quiet\fP och \fB\-\-verbose\fP. I många fall fungerar det bra att aktivera +en förloppsindikator med \fB\-\-verbose\fP, men i några fall skapar de extra +meddelandena problem. Utförlighetsnivån påverkar även beteendet hos +\fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Användarspecifika eller systemspecifika standardflaggor. Typiskt sätts detta +i ett initieringsskript för skal för att aktivera \fBxz\fP:s begränsning av +minnesanvändning som standard eller att ställa in ett standardantal +trådar. Med undantag för skalinitieringsskript och liknande specialfall +skall skript aldrig sätta eller ta bort \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Detta är för att skicka flaggor till \fBxz\fP när det inte är möjligt att sätta +flaggorna direkt på kommandoraden för \fBxz\fP. Detta är fallet när \fBxz\fP körs +av ett skript eller verktyg, till exempel, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf apa.tar.xz apa\fR +.fi +.RE +.RE +.IP "" +Skript kan använda \fBXZ_OPT\fP, till exempel, för att sätta skriptspecifika +standardflaggor för komprimering. Det rekommenderas fortfarande att tillåta +användaren att åsidosätta \fBXZ_OPT\fP om det är rimligt. Till exempel, i +\fBsh\fP(1)\-skript kan man använda något i still med detta: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "KOMPATIBILITET MED LZMA UTILS" +Kommandoradssyntaxen för \fBxz\fP är praktiskt taget en utökning av \fBlzma\fP, +\fBunlzma\fP och \fBlzcat\fP så som de kommer från LZMA Utils 4.32.x. I de flesta +fall, är det möjligt att ersätta LZMA Utils med XZ Utils utan att göra +sönder befintliga skript. Det finns dock några inkompatibiliteter, vilka +ibland kan orsaka problem. +. +.SS "Komprimeringens förinställda nivåer" +Numreringen av förinställda nivåer för komprimering är inte identiska i +\fBxz\fP och LZMA Utils. Den viktigaste skillnade är hur lexikonstorlekar +avbildas till olika förinställningar. Lexikonstorleken är i stort sett lika +med dekomprimerarens minnesanvändning. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nivå;xz;LZMA Utils +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Lexikonstorlekens skillnader påverkar komprimerarens minnesanvändning också, +men det finns några andra skillnader mellan LZMA Utils och XZ Utils, vilket +gör skillnaden ännu större: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nivå;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Standardförinställningsninvån i LZMA Utils är \fB\-7\fP medan i XZ Utils är den +\fB\-6\fP, så båda använder ett 8 MiB lexikon som standard. +. +.SS "Strömmade visavi icke strömmade .lzma\-filer" +Den ikomprimerade storleken på filen kan lagras i huvudet i \fB.lzma\fP. LZMA +Utils gör det när den komprimerar normala filer. Alternativet är att markera +att den okomprimerade storleken är okänd och använda en markör för lastslut +för att indikera var dekomprimeraren skall stanna. LZMA Utils använder denna +metod när den okomprimerade storleken inte är känd, vilket är fallet, till +exempel, i rör. +.PP +\fBxz\fP stödjer dekomprimering av \fB.lzma\fP\-filer med eller utan markör för +lastslut, men alla \fB.lzma\fP filer som skapas av \fBxz\fP kommer använda markör +för lastslut och ha den okomprimerade storleken markerad som okänd i +\&\fB.lzma\fP\-huvudet. Detta kan bli ett problem i några ovanliga fall. Till +exempel kan en \fB.lzma\fP\-dekomprimerare i en inbäddad enhet fungera endast +med filer som har en känd okomprimerad storlek. Om man stöter på detta +problem behöver man använda LZMA Utils eller LZMA SDK för att skapa +\&\fB.lzma\fP\-filer med känd okomprimerad storlek. +. +.SS "Ej stödda .lzma\-filer" +Formatet \fB.lzma\fP tillåter värden på \fIlc\fP upp till 8, och värden på \fIlp\fP +upp till 4. LZMA Utils kan dekomprimera filer med godtyckliga \fIlc\fP och +\fIlp\fP, men skapar alltid filer med \fBlc=3\fP och \fBlp=0\fP. Att skapa filer med +andra \fIlc\fP och \fIlp\fP är möjligt med \fBxz\fP och med LZMA SDK. +.PP +Implementationen av LZMA1\-filtret i liblzma kräver att summan av \fIlc\fP och +\fIlp\fP inte överstiger 4. Alltså, \fB.lzma\fP\-filer, vilka överstiger denna +gräns, kan inte dekomprimeras med \fBxz\fP. +.PP +LZMA Utils skapar endast \fB.lzma\fP\-filer som har en lexikonstorlek på 2^\fIn\fP +(en potens av 2) men godtar filer med godtycklig lexikonstorlek. liblzma +godtar endast \fB.lzma\fP\-filer som har en lexikonstorlek på 2^\fIn\fP eller +2^\fIn\fP + 2^(\fIn\fP\-1). Detta är för att minska falska positiva vid detektering +av \fB.lzma\fP\-filer. +.PP +Dessa begränsningar bör inte vara ett problem i praktiken, eftersom +praktiskt taget alla \fB.lzma\fP\-filer har komprimerats med inställningar som +liblzma kommer godta. +. +.SS "Avslutande skräp" +Vid dekomprimering ignorerar LZMA Utils tyst allting efter den första +\&\fB.lzma\fP\-strömmen. I de flesta situationer är detta fel. Detta betyder även +att LZMA Utils inte stödjer dekomprimering av konkatenerade \fB.lzma\fP\-filer. +.PP +Om det finns data kvar efter den första \fB.lzma\fP\-strömmen betraktar \fBxz\fP +filen som trasig om inte \fB\-\-single\-stream\fP användes. Detta kan göra sönder +obskyra skript vilka har antagit att avslutande skräp ignoreras. +. +.SH NOTERINGAR +. +.SS "Den komprimerade utdatan kan variera" +Den exakta komprimerade utdatan som produceras från samma okomprimerade +indatafil kan variera mellan versioner av XZ Utils även om +komprimeringsflaggorna är identiska. Detta beror på att kodaren kan +förbättras (snabbare eller bättre komprimering) utan att påverka +filformatet. Utdatan kan variera även mellan olika byggen av samma version +av XZ Utils, om olika byggflaggor används. +.PP +Ovanstående betyder att när väl \fB\-\-rsyncable\fP har implementerats kommer +inte nödvändigtvis de resulterande filerna vara rsync\-bara om inte både +gamla och nya filer har komprimerats med samma version av xz. Detta problem +kan lösas om en del av kodarimplementeringen fryses för att hålla rsync\-bar +utdata stabil mellan xz\-versioner. +. +.SS "Inbäddade .xz\-dekomprimerare" +Inbäddade implementationer av \fB.xz\fP\-dekomprimerare som XZ Embedded stödjer +inte nödvändigtvis filer som skapas med andra typer av +integritets\fIkontroll\fP än \fBnone\fP och \fBcrc32\fP. Eftersom standardvärdet är +\fB\-\-check=crc64\fP måste man använda \fB\-\-check=none\fP eller \fB\-\-check=crc32\fP +när filer skapas för inbäddade system. +.PP +Utanför inbäddade system stödjer alla dekomprimerare av \fB.xz\fP\-format alla +typerna av \fIkontroller\fP, eller åtminstone kan de dekomprimera filern utan +att verifiera integritetskontrollen om den specifika \fIkontrollen\fP inte +stödjs. +.PP +XZ Embedded stödjer BCJ\-filter, men endast med standard startavstånd. +. +.SH EXEMPEL +. +.SS Grundläggande +Komprimera filen \fIapa\fP till \fIapa.xz\fP med standardkomprimeringsnivån +(\fB\-6\fP), och ta bort \fIapa\fP om komprimeringen lyckas: +.RS +.PP +.nf +\f(CRxz apa\fR +.fi +.RE +.PP +Dekomprimera \fIbepa.xz\fP till \fIbepa\fP och ta inte bort \fIbepa.xz\fP även om +dekomprimeringen lyckas: +.RS +.PP +.nf +\f(CRxz \-dk bepa.xz\fR +.fi +.RE +.PP +Skapa \fIcepa.tar.xz\fP med förinställningen \fB\-4e\fP (\fB\-4 \-\-extreme\fP), vilket +är långsammare än standardvärdet \fB\-6\fP, men behöver mindre minne till +komprimering och dekomprimering (48\ MiB respektive 5\ MiB): +.RS +.PP +.nf +\f(CRtar cf \- cepa | xz \-4e > cepa.tar.xz\fR +.fi +.RE +.PP +En blandning av komprimerade och okomprimerade filer kan dekomprimeras till +standard ut med ett enda kommando: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Parallell komprimering av många filer" +På GNU och *BSD kan \fBfind\fP(1) och \fBxargs\fP(1) användas för att +parallellisera komprimeringen av många filer: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Flaggan \fB\-P\fP till \fBxargs\fP(1) anger antalet parallella \fBxz\fP\-processer. Det +bästa värdet till flaggan \fB\-n\fP beror på hur många filer det finns som skapp +komprimeras. Om det bara finns några stycken filer bör värdet förmodigen +vara 1; med tiotusentals filer kan 100 eller mer vara lämpligt för att +reducera antalet \fBxz\fP\-processer som \fBxargs\fP(1) kommer att skapa. +.PP +Flaggan \fB\-T1\fP till \fBxz\fP finns för att tvinga den till enkeltrådsläge, +eftersom \fBxargs\fP(1) används för att styra mängden parallellisering. +. +.SS Robotläge +Beräkna hur många byt som har sparats totalt efter komprimering av flera +filer: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Ett skript kan vilja veta att det använder en tillräckligt ny +\fBxz\fP. Följande \fBsh\fP(1)\-skript kontrollerar att versionsnumret för +verktyget \fBxz\fP är åtminstone 5.0.0. Denna metod är kompatibel med gamla +betaversioner, vilka inte stödde flaggan \fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Din xz är för gammal." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Ange en gräns för minnesanvändning för dekomprimering med \fBXZ_OPT\fP, men om +en gräns redan har satts, öka den inte: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Anpassade komprimerarfilterkedjor" +Den enklaste användningen av anpassade filterkedjor är att anpassa en +LZMA2\-förinställning. Detta kan vara användbart eftersom förinställningarna +endast täcker en delmängd av de potentiellt användbara kombinationerna av +komprimeringsinställningar. +.PP +Kolumnerna CompCPU i tabellerna från beskrivningen av flaggorna options +\fB\-0\fP ... \fB\-9\fP och \fB\-\-extreme\fP är användbara vid anpassning av +LZMA2\-förinställningar. Här är de relevanta delarna samlade från dessa två +tabeller: +.RS +.PP +.TS +tab(;); +c c +n n. +Förinställning;KompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Om man vet att en fil behöver ett rätt stort lexikon (till exempel, 32\ MiB) +för att komprimeras bra, men man vill komprimera den snabbare än \fBxz \-8\fP +skulle gjort kan en förinställning med ett lågt värde på CompCPU (till +exempel, 1) ändras till att använda ett större lexikon: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB apa.tar\fR +.fi +.RE +.PP +Med vissa filer kan ovanstående kommando vara snabbare än \fBxz \-6\fP samtidigt +som det komprimerar betydligt bättre. Dock måste det påpekas att endast +några filer drar fördel av ett stort lexikon samtidigt som värdet CompCPU +hålls lågt. Den mest uppenbara situationen, är ett stort lexikon kan hälpa +till mycket, är ett arkiv som innehåller väldigt snarlika filer på åtmistone +några megabyte var. Lexikonstorleken måste vara signifikant större än någon +enskild fil för att låta LZMA2 dra full nytta av likheterna mellan på +varandra följande filer. +.PP +Om det går bra med väldigt hög minnesanvändning i komprimeraren och +dekomprimeraren, och filen som komprimeras är åtminstone flera hundra +megabyte, kan det vara användbart att använda ännu större lexikon än de 64 +MiB som \fBxz \-9\fP skulle använda: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB stor_apa.tar\fR +.fi +.RE +.PP +Att använda \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) som i exemplet ovan kan vara +användbart för att se minnesbehoven för komprimeraren och +dekomprimeraren. Kom ihåg att använda ett större lexikon än storleken på den +okomprimerade filen är slöseri med minne, så ovanstående kommando är inte +användbart för små filer. +.PP +Ibland spelar inte dekomprimeringstiden någon roll, men dekomprimerarens +minnesanvändning måste hållas låg, till exempel för att göra det möjligt att +dekomprimera filen på ett inbäddat system. Följande kommando använder \fB\-6e\fP +(\fB\-6 \-\-extreme\fP) som en bas och sätter lexikonstorleken till bara 64\ KiB. Den resulterande filen kan dekomprimeras med XZ Embedded (det är därför +det finns \fB\-\-check=crc32\fP) som använder ungerfär 100\ KiB minne. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB apa\fR +.fi +.RE +.PP +Om man vill krama ur så många byte som möjligt kan justering av antalet +literala kontextbitar (\fIlc\fP) och antalet positionsbitar (\fIpb\fP) ibland +hjälpa. Justering av antalet literala positionsbitar (\fIlp\fP) kan också +hjälpa, men vanligen är \fIlc\fP och \fIpb\fP viktigare. Till exempel innehåller +ett källkodsarkiv huvudsakligen US\-ASCII\-text, så något i stil med följande +kan ge aningen (som 0.1\ %) mindre fil än \fBxz \-6e\fP (försök även utan +\fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 källkod.tar\fR +.fi +.RE +.PP +Att använda ett annat filter tillsammans med LZMA2 kan förbättra +komprimeringen med vissa filtyper. Till exempel, för att komprimera ett +delat x86\-32\- eller x86\-64\-bibliotek med filtret x86 BCJ: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libapa.so\fR +.fi +.RE +.PP +Observera att ordningen på filterflaggorna spelar roll. Om \fB\-\-x86\fP anges +efter \fB\-\-lzma2\fP kommer \fBxz\fP avge ett fel, eftersom det inte kan vara något +filter efter LZMA2, och även för att filtret x86 BCJ inte kan användas som +det sista filtret i kedjan. +.PP +Deltafiltret tillsammans med LZMA2 gan ge bra resultat med +bitkartebilder. Det bör vanligen slå PNG, som har några mer avancerade +filter än enkla delta men använder Deflat för den faktiska komprimeringen. +.PP +Bilden måste sparas i okomprimerat format, till exempel som okomprimerad +TIFF. Avståndsparametern i Deltafiltret sätts till att motsvara natalet byte +per bildpunkt i bilden. Till exempel, 24\-bitars RGB bitkarta behöver +\fBdist=3\fP, och det är även bra att skicka \fBpb=0\fP till LZMA2 för att ge +plats för trebytejustering: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 apa.tiff\fR +.fi +.RE +.PP +Om flera bilder har lagts in i ett gemensamt arkiv (till exempel, \fB.tar\fP) +kommer Deltafiltret fungera på det också så länge alla bilder har samma +antal byte per bildpunkt. +. +.SH "SE ÄVEN" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/unxz.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/unxz.1 new file mode 100644 index 0000000000000000000000000000000000000000..1fb596e1ab328783990b87c362f7f7761d73548e --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/unxz.1 @@ -0,0 +1,1954 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Swedish translation of xz-man +.\" Göran Uddeborg , 2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 2025\-03\-08 Tukaani "XZ Utils" +. +.SH NAMN +xz, unxz, xzcat, lzma, unlzma, lzcat — Komprimera eller dekomprimera .xz\- +och .lzma\-filer +. +.SH SYNOPSIS +\fBxz\fP [\fIflagga…\fP] [\fIfil…\fP] +. +.SH KOMMANDOALIAS +\fBunxz\fP är ekvivalent med \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP är ekvivalent med \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP är ekvivalent med \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP är ekvivalent med \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP är ekvivalent med \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +När man skriver skript som behöver dekomprimera filer rekommenderas det att +altid använda namnet \fBxz\fP mäd lämpliga argument (\fBxz \-d\fP eller \fBxz \-dc\fP) +istället för namnen \fBunxz\fP och \fBxzcat\fP. +. +.SH BESKRIVNING +\fBxz\fP är ett datakomprimeringsverktyg för allmänt bruk med en +kommandoradssyntax som liknar \fBgzip\fP(1) och \fBbzip2\fP(1). Det egna +filformatet är formatet \fB.xz\fP, men det föråldrade formatet \fB.lzma\fP som +anändes av LZMA\-verktyg och råa komprimerade strömmar utan huvuden för +behållarformatet stödjs också. Dessutom stödjs dekomprimering av formatet +\&\fB.lz\fP som används av \fBlzip\fP. +.PP +\fBxz\fP komprimerar och dekomprimerar varje \fIfil\fP i enlighet med det valda +arbetsläget. Om inga \fIfiler\fP anges eller \fIfil\fP är \fB\-\fP läser \fBxz\fP från +standard in och skriver den behandade datan på standard ut. \fBxz\fP kommer +vägra (visa ett felmeddelande och hoppa över \fIfilen\fP) att skriva +komprimerad data direkt till standard ut om det är en terminal. På samma +sätt kommer \fBxz\fP vägra att läsa komprimerade data från standard in om det +är en terminal. +.PP +Om inte \fB\-\-stdout\fP anges skrivs andra \fIfiler\fP än \fB\-\fP till en ny fil vars +namn härleds från käll\fIfilens\fP namn: +.IP \(bu 3 +Vid kompringering läggs suffixet till på målfilsformatet (\fB.xz\fP eller +\&\fB.lzma\fP) på slutet av källfilnamnet för att få målfilnamnet. +.IP \(bu 3 +Vid dekomprimering tas suffixet \fB.xz\fP, \fB.lzma\fP eller \fB.lz\fP bort från +filnamnet för att få målfilnamnet. \fBxz\fP känner även igen suffixen \fB.txz\fP +och \fB.tlz\fP, och ersätter dem med suffixet \fB.tar\fP. +.PP +Om målfilen redan finns visas ett felmeddelande och \fIfilen\fP hoppas över. +.PP +Utom när den skriver till standard ut kommer \fBxz\fP visa en varning och hoppa +över \fIfilen\fP om något av följande inträffar: +.IP \(bu 3 +\fIFil\fP är inte en vanlig fil. Symboliska länkar följs inte, och därför anses +de inte vara vanliga filer. +.IP \(bu 3 +\fIFil\fP har mer än en hård länk. +.IP \(bu 3 +\fIFil\fP har biten setuid, setgid eller sticky satt. +.IP \(bu 3 +Arbetsläget är satt till att komprimera och \fIfilen\fP har redan ett suffix +enligt målfilformatet (\fB.xz\fP eller \fB.txz\fP vid komprimering till formatet +\&\fB.xz\fP, och \fB.lzma\fP eller \fB.tlz\fP vid komprimering till formatet \fB.lzma\fP). +.IP \(bu 3 +Arbetsläget är satt till att dekomprimera och \fIfilen\fP har inte ett suffix +enligt något av de stödda filformaten (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP +eller \fB.lz\fP). +.PP +Efter att ha kunnat komprimera eller dekomprimera \fIfilen\fP kopierar \fBxz\fP +ägaren, gruppen, rättigheterna, åtkomsttiden och ändringstiden från +käll\fIfilen\fP till målfilen. Om kopieringen av grupp misslyckas ändras +rättigheterna så att målfilen inte blir åtkomlig för användare som inte har +rättigheter att komma åt käll\fIfilen\fP. \fBxz\fP stödjer inte kopiering av annan +metadata såsom åtkomststyrhingslistor eller utökade attribut ännu. +.PP +När målfilen har stängts framgångsrikt tas käll\fIfilen\fP bort såvida inte +\fB\-\-keep\fP angavs. Käll\fIfilen\fP tas aldrig bort om utdata skrevs till +standard ut eller om något fel inträffade. +.PP +Att skicka \fBSIGINFO\fP eller \fBSIGUSR1\fP till \fBxz\fP\-processen får den att +skriva ut förloppsinformation till standard fel. Detta är bara av begränsat +värde eftersom när standard fel går till en terminal så kommer användning av +\fB\-\-verbose\fP att skriva ut en automatiskt uppdaterande förloppsindikator. +. +.SS Minnesanvändning +\fBxz\fP:s minnesanvändning varierar från några få hundra kilobyte till flera +gigabyte beroende på komprimeringsinställningarna. Inställningen som +användes när en fil komprimerades avgör minnesbehovet hos +dekomprimeraren. Typiskt behöver dekomprimeraren 5\ % till 20\ % av +minnesbehovet som komprimeraren behöver när en fil skapas. Till exempel, att +dekomprimera en fil skapad med \fBxz \-9\fP kräver för närvarande 65\ MiB +minne. Ändå är det möjligt att ha \fB.xz\fP\-filer som behöver flera gigabyte +minne för att dekomprimeras. +.PP +Särskilt användare av äldre system kan finna möjligheten av väldigt stor +minnesanvändning störande. För att förhindra obehagliga överraskningar har +\fBxz\fP en inbyggd minnesanvändningsbegränsare, vilken är avaktiverad som +standard. Även om vissa operativsystem kan tillhandahålla möjligheter att +begränsa minnesanvändningen hos processer bedömdes det inte som flexibelt +nog att lita på det (till exempel, att använda \fBulimit\fP(1) för att begränsa +det virtuella minnet tenderar att hämma \fBmmap\fP(2). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Minnesanvändningsbegränsaren kan aktiveras med kommandoradsflaggan +\fB\-\-memlimit=\fP\fIgräns\fP. Ofta är det bekvämare att aktivera begränsaren som +standard genom att sätta miljövariabeln \fBXZ_DEFAULTS\fP, till exempel, +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Det är möjligt att sätta gränser separat +för komprimering och dekomprimering genom att använda +\fB\-\-memlimit\-compress=\fP\fIlimit\fP och \fB\-\-memlimit\-decompress=\fP\fIlimit\fP. Att +använda dessa två flaggor utanför \fBXZ_DEFAULTS\fP är sällan meningsfullt +eftersom en enskild körning av \fBxz\fP inte kan göra både komprimering och +dekomprimering och and \fB\-\-memlimit=\fP\fIgräns\fP (eller \fB\-M\fP \fIgräns\fP) är +kortare att skriva på kommandoraden. +.PP +Om den angivna minnesanvändningsgränsen överskrid vid dekomprimering kommer +\fBxz\fP visa ett fel och dekomprimeringen av filen misslyckas. Om gröensen +överskrids vid komprimering kommer \fBxz\fP försöka skala ner inställningen så +att gränsen inte längre överskrids (utom när \fB\-\-format=raw\fP eller +\fB\-\-no\-adjust\fP används). På detta sätt kommer åtgärden inte misslyckas om +inte gränsen är väldigt liten. Skalningen av inställningen görs i steg som +inte matchar de förinställda komprimeringsnivåerna, till exempel, om gränsen +endast är något mindre än den mängd som behövs till \fBxz \-9\fP kommer +inställningen bara skalas ner lite, inte hela vägen ner till \fBxz \-8\fP. +. +.SS "Konkatenering och utfyllnad av .xz\-filer" +Det är möjligt att konkatenera \fB.xz\fP\-filer som de är. \fBxz\fP kommer +dekomprimera sådana filer som om de vore en enda \fB.xz\fP\-fil. +.PP +Det är möjligt att infoga utfyllnad mellan de konkatenerade delarna eller +efter den sista delen. Utfyllnaden måste bestå av null\-bytear och storleken +på utfyllnaden måste vara en multipel av fyra byte. Detta kan vara +användbart, till exempel, om \fB.xz\fP\-filen lagras på ett medium som mäter +filstorlekar i 512\-byteblock. +.PP +Konkaternering och utfyllnad är inte tillåtet med \fB.lzma\fP\-filer eller råa +strömmar. +. +.SH FLAGGOR +. +.SS "Heltalssuffix och speciella värden" +På de flesta platser där ett heltalsargument förväntas stödjs ett frivilligt +suffix för att enkelt indikera stora heltal. Det får inte finnas något +mellanrumm mellan heltalet och suffixet. +.TP +\fBKiB\fP +Multiplicera heltalet med 1 024 (2¹⁰). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP och \fBKB\fP är +tillåtna som synomymer till \fBKiB\fP. +.TP +\fBMiB\fP +Multiplicera heltalet med 1 048 576 (2²⁰). \fBMi\fP, \fBm\fP, \fBM\fP och \fBMB\fP är +tillåtna som synomymer till \fBMiB\fP. +.TP +\fBGiB\fP +Multiplicera heltalet med 1 073 741 824 (2³⁰). \fBGi\fP, \fBg\fP, \fBG\fP och \fBGB\fP +är tillåtna som synonymer till \fBGiB\fP. +.PP +Specialvärdet \fBmax\fP kan användas för att indikera det maximala heltalet som +stödjs av flaggan. +. +.SS Arbetsläge +Om flera arbetslägesflaggor ges gäller den sista. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Komprimera. Detta är standardarbetsläget när ingen arbetslägesflagga anges +och inget annat arbetsläge impliceras från kommandonamnet (till exempel +implicerar \fBunxz\fP \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Efter lyckad komprimering källfilen bort såvida man inte skriver till +standard ut eller \fB\-\-keep\fP angavs. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Dekomprimera. Efter lyckad dekomprimering tas källfilen bort såvida man inte +skriver till standard ut eller \fB\-\-keep\fP angavs. +.TP +\fB\-t\fP, \fB\-\-test\fP +Testa integriteten hos komprimerade \fIfiler\fP. Denna flagga är ekvivalent med +\fB\-\-decompress \-\-stdout\fP förutom att den dekomprimerade datan slängs +istället för att skrivas på standard ut. Inga filer skapas eller tas bort. +.TP +\fB\-l\fP, \fB\-\-list\fP +Skriv information om komprimerade \fIfiler\fP. Inge dekomprimeringsutdata +skapas, och inga filer skapas eller tas bort. I listläge kan programmet inte +läsa komprimerad data från standard in eller från andra källor där man inte +kan söka. +.IP "" +Standardlistningen visar grundläggande information om \fIfiler\fP, en fil per +rad. För att få mer detaljerad information, använd även flaggan +\fB\-\-verbose\fP. För ännu mer information, använd \fB\-\-verbose\fP två gånger, men +observera att detta kan vara långsamt, eftersom det behövs många sökningar +får att samla all den extra informationen. Bredden av utförlig utdata +överskrider 80 tecken, så att skicka utdata i ett rör till, till exempel, +\fBless\ \-S\fP kan vara bekvämt om terminalen inte är bred nog. +.IP "" +Den exakta utdatan kan variera mellan versioner av \fBxz\fP och olika +lokaler. För maskinläsbar utdata bör \fB\-\-robot \-\-list\fP användas. +. +.SS Arbetsmodifierare +.TP +\fB\-k\fP, \fB\-\-keep\fP +Ta inte bort indatafilerna. +.IP "" +Från \fBxz\fP 5.2.6 gör denna flagga även att \fBxz\fP komprimerar eller +dekomprimerar även om indatan är en symbolisk länk till en normal fil, har +mer än en hård länk eller har biten setuid, setgid eller sticky +satt. Bitarna setuid, setgid och sticky kopieras inte till målfilen. I +tidigare versioner gjordes detta bara med \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Denna flagga har flera funktioner: +.RS +.IP \(bu 3 +Om målfilen redan finns, radera den före komprimering eller dekomprimering. +.IP \(bu 3 +Komprimera eller dekomprimera även om indatan är en symbolisk länk till en +normal fil, har mer än en hård länk eller har biten setuid, setgid eller +sticky satt. Bitarna setuid, setgid och sticky kopieras inte till målfilen. +.IP \(bu 3 +När den används med \fB\-\-decompress\fP \fB\-\-stdout\fP och \fBxz\fP inte känner igen +typen på källfilen, kopiera källfilen som den är till standard ut. Detta gör +att \fBxzcat\fP \fB\-\-force\fP kan användas som \fBcat\fP(1) för filer som inte har +komprimerats med \fBxz\fP. Observera att i framtiden kan \fBxz\fP komma att stödja +nya komprimeringsfilformat, vilket kan få \fBxz\fP att dekomprimera fler typer +av filer istället för att kopiera dem till standard ut. +\fB\-\-format=\fP\fIformat\fP kan användas för att begränsa \fBxz\fP till att +dekomprimera endast ett enda filformat. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Skriv den komprimerade eller dekomprimerade datan till standard ut istället +för en fil. Detta implicerar \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Dekomprimera endast den första \fB.xz\fP\-strömmen, och ignorera tys eventuella +återstående indata som följer efter strömmen. Normalt får sådant avslutande +skräp \fBxz\fP att visa ett fel. +.IP "" +\fBxz\fP dekomprimerar aldrig mer än en ström från \fB.lzma\fP\-filer eller råa +strömmar, men denna flagga gör ändå att \fBxz\fP ignorerar den möjliga +efterföljande datan efter \fB.lzma\fP\-filen eller den råa strömmen. +.IP "" +Denna flagga har ingen effekt om arbetsläget inte är \fB\-\-decompress\fP eller +\fB\-\-test\fP. +.IP "" +Sedan \fBxz\fP 5.7.1alpha, implicerar \fB\-\-single\-stream\fP \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Avaktivera att glesa filer skapas. Som standard, om den dekomprimerar till +en normal fil, försöker \fBxz\fP att göra filen gles om den dekomprimerade +datan innehåller långa sekvenser av binära nollor. Det fungerar även när den +skriver till standard ut så länga standard ut är kopplad till en normal fil +och vissa ytterligare villkor möts för att göra det säkert. Att skapa glesa +filer kan spara diskutrymme och snabba upp dekomprimeringen genom att +begränsa mängden disk\-I/O. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Vid komprimering, använd \fI.suf\fP som suffixet för målfilen istället för +\&\fB.xz\fP eller \fB.lzma\fP. Om den inte skriver till standard ut och källfilen +redan har suffixet \fI.suf\fP visas en varning och filen hoppas över. +.IP "" +Vid dekomprimering, känn igen filer med suffixet \fI.suf\fP utöver filer +medsuffixen \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP eller \fB.lz\fP. Om källfilen +har suffixet \fI.suf\fP tas suffixet bort för att få målfilnamnet. +.IP "" +Vid komprimering eller dekomprimering av råa strömmar (\fB\-\-format=raw\fP) +måste alltid suffixet anges om den inte skriver till standard ut, eftersom +det inte finns något standardsuffix för råa strömmar. +.TP +\fB\-\-files\fP[\fB=\fP\fIfil\fP] +Läs filnamnen att arbeta på från \fIfil\fP; om \fIfil\fP utelämnas läses filnamn +från standard in. Filnamn måste avslutas med nyradstecknet. Ett bindestreck +(\fB\-\fP) tas som ett vanligt filnamn; det betyder inte standard in. Om filnamn +även anges som kommandoradsargument, bearbetas de före filnamnen som läses +från \fIfil\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIfil\fP] +Detta är identiskt med \fB\-\-files\fP[\fB=\fP\fIfil\fP] förjutom att varje filnamn +måste avslutas med ett nulltecken. +. +.SS "Grundläggande flaggor för filformat och komprimering" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fIformat\fP +Angi filens \fIformat\fP att komprimera eller dekomprimera: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Detta är standard. Vid komprimering är \fBauto\fP ekvivalent med \fBxz\fP. Vid +dekomprimering detekteras automatiskt formatet på indatafilen. Observera att +råa strömmar (skapade med \fB\-\-format=raw\fP inte kan detekteras automatiskt. +.TP +\fBxz\fP +Komprimera till filformatet \fB.xz\fP, eller acceptera endast \fB.xz\fP\-filer vid +dekomprimering. +.TP +\fBlzma\fP, \fBalone\fP +Komprimera till det föråldrade filformatet \fB.lzma\fP, eller acceptera endast +\&\fB.lzma\fP\-filer fid dekomprimering. Det alternativa namnet \fBalone\fP +tillhandahålls för bakåtkompatibilitet med LZMA Utils. +.TP +\fBlzip\fP +Acceptera endast \fB.lz\fP\-filer vid dekomprimering. Komprimering stödjs inte. +.IP "" +\&\fB.lz\fP\-formatet version 0 och 1 stödjs. Version 0\-filer producerades av +\fBlzip\fP 1.3 och tidigare. Sådana filer är inte vanliga men kan hittas från +filarkiv eftersom några källpaket släpptes i detta format. Folk kan ha även +ha gamla personliga filer i detta format. Dekomprimeringsstöd för format +version 0 togs bort i \fBlzip\fP 1.18. \fBlzip\fP 1.4 och senare kan skapa filer i +formatversion 1. +.TP +\fBraw\fP +Komprimera eller dekomprimera en rå ström (inga huvuden). Detta är endast +avsett för avancerade användare. För att avkoda råa strömmar behöver man +använda \fB\-\-format=raw\fP och explicit angi filterkedjan, vilken normalt +skulle ha lagrats i behållarens huvuden. +.RE +.TP +\fB\-C\fP \fIkontroll\fP, \fB\-\-check=\fP\fIkontroll\fP +Ange typen av integritetskontroll. Kontrollen beräknas från den +dekomprimerade datan och lagras i \fB.xz\fP\-filen. Denna flagga har endast +någon inverkan när man komprimerar till formatet \fB.xz\fP; formatet \fB.lzma\fP +stödjer inte integritetskontroller. Integritetskontrollen (om någon) +verifieras när \fB.xz\fP\-filen dekomprimeras. +.IP "" +\fIKontroll\fPtyper som stödjs: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Beräkna inte någon integritetskontroll alls. Detta är normalt en dålig +idé. Det kan vara användbart när datans integritet ändå verifieras på andra +sätt. +.TP +\fBcrc32\fP +Beräkna CRC32 med polynomet från IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Beräkna CRC64 med polynomet från ECMA\-182. Detta är standard, eftersom det +är något bättre än CRC32 på att upptäcka skadade filer och +hastighetsskillnaden är försumbar. +.TP +\fBsha256\fP +Beräkna SHA\-256. Detta är något långsammare än CRC32 och CRC64. +.RE +.IP "" +Integriteten hos \fB.xz\fP\-huvuden verifieras alltid med CRC32. Det är inte +möjligt att ändra eller avaktivera det. +.TP +\fB\-\-ignore\-check\fP +Verifiera inte integritetskontrollen av den komprimerade datan vid +dekomprimering. CRC32\-värden i \fB.xz\fP\-huvudena kommer fortfarande verifieras +normalt +.IP "" +\fBAnvänd inte denna flagga om du inte vet vad du gör.\fP Möjliga anledningar +till att använda denna flagga: +.RS +.IP \(bu 3 +Försöka återvinna data från en trasig .xz\-fil. +.IP \(bu 3 +Snabba upp dekomprimering. Detta har störst betydelse med SHA\-256 eller med +filer som har komprimerats extremt mycket. Det rekommenderas att inte +använda denna flagga för detta ändamål om inte filintegriteten verifieras +externt på något annat sätt. +.RE +.TP +\fB\-0\fP … \fB\-9\fP +Välj en förinställningsnivå för komprimering. Standard är \fB\-6\fP. Om flera +förinställningsnivåer anges gäller den sist angivna. Om en anpassad +fileterkedja redan angivits gör en inställning av en förinställningsnivå för +komprimering att den anpassade filterkedjan töms. +.IP "" +Skillnaden mellan förinställningarna har större betydelse än med \fBgzip\fP(1) +och \fBbzip2\fP(1). Den valda komprimeringsinställningen avgör minneskraven för +dekomprimeraren, att använda en för hög förinställningsnivå kan alltså göra +det plågsamt att dekomprimera filer på ett gammalt system med lite +RAM. Specifikt \fBär det inte en bra ide att blint använda \-9 för allt\fP +liksom det ofta är med \fBgzip\fP(1) och \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP … \fB\-3\fP +Dessa är ganska snabba förinställningar. \fB\-0\fP är ibland snabbare än \fBgzip \-9\fP samtidigt som komprimeringen är mycket bättre. De högre har ofta +hastighet jämförbar med \fBbzip2\fP(1) med jämförbar eller bättre +komprimeringsförhållande, även om resultatet mycket beror på typen av data +som komprimeras. +.TP +\fB\-4\fP … \fB\-6\fP +Bra för väldigt god komprimering samtidigt som dekomprimerarens +minnesanvändning hålls rimlig även på gamla system. \fB\-6\fP är standardvärdet, +vilket vanligen är ett bra val för att distribuera filer so behöver +dekomprimeras även på ssytem med endast 16\ MiB RAM. (\fB\-5e\fP eller \fB\-6e\fP +kan också vara värda att överväga. Se \fB\-\-extreme\fP.) +.TP +\fB\-7 … \-9\fP +Dessa liknar \fB\-6\fP med med högre krav på minne till komprimerare och +dekomprimerare. Dessa är bara användbara vid komprimering av filer större än +8\ MiB, 16\ MiB respektive 32\ MiB. +.RE +.IP "" +På samma hårdvara är dekomprimeringshastigheten ungefär ett konstant antal +byt av komprimerad data per sekund. Med andra ord, ju bättre komprimering, +desto snabbare kommer dekomprimeringen vanligen vara. Detta betyder även att +mängden av okomprimerad utdata skapad per sekund kan variera mycket. +.IP "" +Följande tabell sammanfattar funktionerna hos förinställningarna: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Förinställning;LexStrl;KompCPU;KompMin;DekMin +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Kolumnbeskrivningar: +.RS +.IP \(bu 3 +LexStrl är storleken på LZMA2:s lexikon. Det är slöseri med minne att +använda ett större lexikon än storleken på den okomprimerade filen. Detta är +anledningen till att det är bra att undvika förinställningarna \fB\-7\fP … \fB\-9\fP +när det inte finns något verkligt behov av dem. På \fB\-6\fP och lägre är +mängden bortslösat minne vanligen litet nog att inte ha någon betydelse. +.IP \(bu 3 +KompCPU är en förenklad representation av LZMA2\-inställningar som påverkar +komprimeringshastigheten. Lexikonstorleken påverkar också hastigheten, så +medan KompCPU är samma för nivåerna \fB\-6\fP … \fB\-9\fP tenderar fortfarande högre +nivåer att vara lite långsmmare. För ännu långsammare och möjligen bättre +komprimering, se \fB\-\-extreme\fP. +.IP \(bu 3 +KompMem innehåller komprimerarens minneskrav i enkeltrådat läge. Det kan +variera något mellan versioner av \fBxz\fP. +.IP \(bu 3 +DekMin innehåller dekomprimerarens minneskrav. Det vill säga, komprimerarens +inställningar avgör minneskravet för dekomprimeraren. Den exakta +minnesanvändningen hos dekomprimeraren är något mer än +LZMA2\-lexikonstorleken, men värdena i tabellen har avrundats upp till nästa +nästa hela MiB. +.RE +.IP "" +Minneskravet för det multitrådade läget är signifikant högre än det för +enkeltrådat läge. Med standardvärdet på \fB\-\-block\-size\fP behöver varje tråd +3·3·LexStrl plus KompMin eller DekMin. Till exempel, fyra trådar med +förinställningen behöver 660\(en670 MiB minne. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Använd en långsammare variant av den valda förinställningsnivån för +komprimering (\fB\-0\fP … \fB\-9\fP) för att förhoppningsvis få lite bättre +komprimeringsförhållande, men med otur kan detta även göra det +sämre. Dekomprimerarens minnesanvändning påverkas inte, men komprimerarens +minnesanvändning ökar lite vid förinställningsnivåerna \fB\-0\fP … \fB\-3\fP. +.IP "" +Eftersom det finns två förinställningar med lexikonstorlekar 4\ MiB och 8\ MiB använder förinställningarna \fB\-3e\fP och \fB\-5e\fP något snabbare +inställningar (lägre KompCPU) än \fB\-4e\fP respektive \fB\-6e\fP. På det sättet är +inte två förinställningar identiska. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Förinställning;LexStrl;KompCPU;KompMin;DekMin +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Till exempel finns det totalt fyra förinställningar som använder 8\ MiB +lexikon, vars ordning från den snabbaste till den långsammaste är \fB\-5\fP, +\fB\-6\fP, \fB\-5e\fP och \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Dessa är något missledande alias för \fB\-0\fP respektive \fB\-9\fP. Dessa finns +endast för bakåtkompatibilitet med LZMA\-verktyg. Undvik att använda dessa +flaggor. +.TP +\fB\-\-block\-size=\fP\fIstorlek\fP +Vid komprimering till formatet \fB.xz\fP, dela indatai block med \fIstorlek\fP +bytes. Blocken komprimeras oberoende av varandra, vilket hjälper till vid +multitrådning och gör begränsad random\-access\-dekomprimering möjlig. Denna +flagga används typiskt för att åsidosätta blockstorleken i multitrådat läge, +men denna flagga kan användas även i enkeltrådat läge. +.IP "" +I multitrådat läge kommer ungefär tre gånger \fIstorlek\fP byte att allokeras i +varje tråd för buffring av indata och utdata. Standardvärdet på \fIstorlek\fP +är det större av tre gånger LZMA2\-lexikonstorleken eller 1 MiB. Typiskt är +ett bra värde 2\(en4 gånger storleken på LZMA2\-lexikonet eller åtminstone 1 +MiB. Att använda en \fIstorlek\fP mindre än LZMA2\-lexikonstorleken utgör +slöseri med RAM eftersom LZMA2\-lexikonbufferten då aldrig kommer användas +helt. I multitrådat läge lagras storlekarna på plocken i +blockhuvudena. Denna storleksinformation krävs för multitrådad +dekomprimering. +.IP "" +I singletrådat läge görs som standard ingen uppdelning i block. Att göra +denna inställning påverark inte minnesanvändningen. Ingen +storleksinformation lagras i blockhuvuden, därmed kommer filer som skapas i +enkeltrådat läge inte att vara identiska med filer skapade i multitrådat +läge. Avsaknaden av sotrleksinformation betyder också att \fBxz\fP inte kommer +kunna dekomprimera filerna i multitrådat läge. +.TP +\fB\-\-block\-list=\fP\fIposter\fP +Vid komprimering till formatet \fB.xz\fP, börja ett nytt block med en möjlig +anpassad filterkedja efter de angivna intervallen med okomprimerade data. +.IP "" +\fIPosterna\fP är en kommaseparerad lista. Varje post består av ett möjligt +filterkedjenummer mellan 0 och 9 följt av ett kolon (\fB:\fP) och en +obligatorisk storlek för okomprimerade data. Att utelämna en post (två på +varandra följande komman) är en kortform för att använda storleken och +filtren från föregående post. +.IP "" +Om indatafiler är större än summan av storlekarna i \fIposter\fP repeteras den +sista posten fram till slutet på filen. Ett speciellt värde \fB0\fP kan +användas som den sista storleken för att indikera att resten av filen skall +kodas som ett enda block. +.IP "" +En alternativ filterkedja för varje block kan anges i kombinaton med +flaggorna \fB\-\-filters1=\fP\fIfilter\fP \&…\& \fB\-\-filters9=\fP\fIfilter\fP. Dessa +flaggor definierar filterkedjor med en identifierare mellan +1\(en9. Filterkedja 0 kan användas för att referera till +standardfilterkedjan, vilket är samma sak som att inte ange någon +filterkedja. Filterkedjeidentifierare kan användas före den okomprimerade +sotrleken, följt av ett kolon (\fB:\fP). Till exempel, om man anger +\fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP kommer block skapas med: +.RS +.IP \(bu 3 +Filterkedjan angiven av \fB\-\-filters1\fP och 2 MiB indata +.IP \(bu 3 +Filterkedjan angiven av \fB\-\-filters3\fP och 2 MiB indata +.IP \(bu 3 +Filterkedjan angiven av \fB\-\-filters2\fP och 4 MiB indata +.IP \(bu 3 +Filterkedjan angiven av \fB\-\-filters2\fP och 4 MiB indata +.IP \(bu 3 +Standardfilterkedjan och 2 MiB indata +.IP \(bu 3 +Standardfilterkedjan och 4 MiB indata för varje block till slutet av indata. +.RE +.IP "" +Om man anger en storlek som överskrider kodarens blockstorlek (antingen +standardvärdet i trådat läge eller värdet som anges med +\fB\-\-block\-size=\fP\fIstorlek\fP) kommer kodaren skapa ytterligare block med +hänsyn taget till gränserna som anges i \fIposter\fP. Till exempel, om man +anger \fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP och +indatafilen är 80 MiB kommer man få 11 block: 5, 10, 8, 10, 2, 10, 10, 4, +10, 10 och 1 MiB. +.IP "" +I multitrådat läge lagras storleken på blocken i blockhuvudena. Detta görs +inte i enkeltrådat läge, så den kodade utdatan kommer inte vara identisk med +den från det multitrådade läget. +.TP +\fB\-\-flush\-timeout=\fP\fItidsgräns\fP +Vid komprimering, om mer än \fItidsgräns\fP millisekunder (ett positivt heltal) +har gått sedan den föregånde tömningen och en läsning av mer indata skulle +blockera töms all väntande indata från kodaren och görs tillgänglig i +utdataströmmen. Detta kan vara användbart om \fBxz\fP används för att +komprimera data som strömmas över ett nätverk. Små värden på \fItidsgräns\fP +gör data tillgänglig vid den mottagande änden med en liten fördröjning, men +större värden på \fItidsgräns\fP ger bättre komprimeringsförhållande. +.IP "" +Denna funktion är avaktiverad som standard. Om denna flagga anges mer än en +gång gäller den sista. Dett speciella värdet \fB0\fP på \fItidsgräns\fP kan +användas för att uttryckligen avaktivera denna funktion. +.IP "" +Denna funktion är inte tillgänglig på icke\-POSIX\-system. +.IP "" +.\" FIXME +\fBDenna funktion är fortfarande experimentell.\fP För närvarande är \fBxz\fP +olämplig för dekomprimering av strömmen i realtid på grund av hur \fBxz\fP +buffrar. +.TP +\fB\-\-no\-sync\fP +Synkronisera inte målfilen och dess katalog med lagringsenheten före +källfilen tas bort. Detta kan förbättra prestanda vid komprimering eller +dekomprimering av många små filer. Dock, om systemet kraschar snart efter +raderingen är det möjligt att målfilen inte skrevs till lagringsenheten men +att raderingen gjordes det. I det fallet är varken originalkällfilen eller +målfilen tillgänglig. +.IP "" +Denna flagga har bara någon effekt när \fBxz\fP kommer att ta bort källfilen. I +andra fall görs aldrig någon synkronisering. +.IP "" +Synkroniseringen och \fB\-\-no\-sync\fP lades till i \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIgräns\fP +Sätt en gräns på minnesanvändningen för komprimeringen. Om denna flaggan +anges flera gånger gäller den sista. +.IP "" +Om komprimeringsinställnigarna överskrider \fIgränsen\fP kommer \fBxz\fP försöka +justera inställningarna neråt så att gränsen inte längre överskrids och visa +en notis om att en automatisk justering gjorts. Justeringen görs i denna +ordning: reducera antalet trådar, byta till enkeltrådat läge om även en tråd +i multitrådat läge överskrider \fIgränsen\fP och slutligen reducera +LZMA2\-lexikonstorleken. +.IP "" +Vid komprimering med \fB\-\-format=raw\fP eller om \fB\-\-no\-adjust\fP har angetts kan +endast antalet trådar reduceras eftersom det kan göras utan att påverka den +komprimerade utdatan. +.IP "" +Om \fIgränsen\fP inte kan uppfyllas ens med justeringarna som beskrivs ovan +visas ett felmeddelande och \fBxz\fP kommer avsluta med slutstatus 1. +.IP "" +\fIGränsen\fP kan anges på flera sätt: +.RS +.IP \(bu 3 +\fIGränsen\fP kan vara ett absolut värde i byte. Att använda ett heltalssuffix +som \fBMiB\fP kan vara praktiskt. Exempel: \fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +\fIGränsen\fP kan anges som en procentsats av det totala fysiska minnet +(RAM). Detta kan vara användbart särskilt när man sätter miljövariabeln +\fBXZ_DEFAULTS\fP i ett skalinitieringsskript som delas mellan olika +datorer. På det sättet är gränsen automatiskt större på system med mer +minne. Exempel: \fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +\fIGränsen\fP kan återställas tillbaka till sitt standardvärde genom att sätta +den till \fB0\fP. Detta är för närvarande ekvivalent med att sätta \fIgränsen\fP +till \fBmax\fP (ingen gräns på minnesanvändning). +.RE +.IP "" +För 32\-bitars \fBxz\fP finns det ett specialfall: om \fIgränsen\fP skulle vara +över \fB4020\ MiB\fP sätts \fIgränsen\fP till \fB4020\ MiB\fP. På MIPS32 används +\fB2000\ MiB\fP istället. (Värdena \fB0\fP och \fBmax\fP påverkas inte av detta. En +liknande funktion finns inte för dekomprimering.) Detta kan hjälpa till när +ett 32\-bitarsprogram har tillgång till 4\ GiB adressrymd (2 GiB på MIPS32) +förhoppningsvis utan att göra någon skada i andra situationer. +.IP "" +Se även avsnittet \fBMinnesanvändning\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIgräns\fP +Sätt en gräns för minnesanvnändningen vid dekomprimering. Detta påverkar +även läget \fB\-\-list\fP. Om åtgärden inte är möjlig utan att överskrida +\fIgränsen\fP kommer \fBxz\fP visa ett felmeddelande och dekomprimeringen av filen +kommer misslyckas. Se \fB\-\-memlimit\-compress=\fP\fIgräns\fP för möjliga sätt att +ange \fIgränsen\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIgräns\fP +Sätt en gräns för minnesanvändningen för multitrådad dekomprimering. Detta +kan endast påverka antalet trådar; det kommer aldrig att få \fBxz\fP att vägra +att dekomprimera en fil. Om \fIgränsen\fP är för låg för att tillåta någon +multitrådning ignoreras \fIgränsen\fP och \fBxz\fP kommer gå vidare i enkeltrådat +läge. Observera att om även \fB\-\-memlimit\-decompress\fP används kommer det +alltid att gälla både enkeltrådat och multitrådat läge, och därmed kommer +den gällande \fIgränsen\fP för multitrådning aldrig vara högre än gränsen som +sätts med \fB\-\-memlimit\-decompress\fP. +.IP "" +Till skillnad mot de andra flaggorna för gränser för minnesanvändning har +\fB\-\-memlimit\-mt\-decompress=\fP\fIgräns\fP en systemspecifik +standard\fIgräns\fP. \fBxz \-\-info\-memory\fP kan användas för att se det aktuella +värdet. +.IP "" +Denna flagga och dess standardvärde finns för att utan någon gräns skulle +den trådade dekomprimeraren kunna allokera en vansinnig mängd minne med +några indatafiler. Om standard\fIgränsen\fP är för låg på ditt system, öka då +gärna \fIgränsen\fP men sätt den aldrig till ett större värde än mängden +användbart RAM eftersom att med passande indatafiler kommer \fBxz\fP försöka +använda den mängden av minne även med ett lågt antal trådar. Att få slut på +minne ller växling kommer inte förbättra dekomprimeringsprestandan. +.IP "" +Se \fB\-\-memlimit\-compress=\fP\fIgräns\fP för möjliga sätt att ange \fIgränsen\fP. Att +sätta \fIgräns\fP till \fB0\fP återställer \fIgränsen\fP till sdet systemspecifika +standardvärdet. +.TP +\fB\-M\fP \fIgräns\fP, \fB\-\-memlimit=\fP\fIgräns\fP, \fB\-\-memory=\fP\fIgräns\fP +Detta är ekvivalent med att ange \fB\-\-memlimit\-compress=\fP\fIgräns\fP +\fB\-\-memlimit\-decompress=\fP\fIgräns\fP \fB\-\-memlimit\-mt\-decompress=\fP\fIgräns\fP. +.TP +\fB\-\-no\-adjust\fP +Visa ett fel och avsluta om gränsen för minnesanvändning inte kan mötas utan +att justera inställnigar som påverkar den komprimerade utdatan. Det vill +säga, detta förhindrar att \fBxz\fP byter kodaren från multitrådat läge till +enkeltrådat läge och från att den reducerar LZMA2\-lexikonets storlek. Även +när denna flagga används kan antalet trådar reduceras för att möta gränsen +för minnesanvändning eftersom det inte kommer påverka den komprimerade +utdatan. +.IP "" +Automatisk justering är alltid avaktiverat när råa strömmar skapas +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fItrådar\fP, \fB\-\-threads=\fP\fItrådar\fP +Ange antalet arbetstrådar som skall användas. Att sätta \fItrådar\fP till ett +specialvärde \fB0\fP gör att \fBxz\fP använder så många trådar som processorerna +på systemet stödjer. Det aktuella antalet trådar kan vara färre än \fItrådar\fP +om indatafilen inte är stor nog för trådning med de givna inställningarna +eller om användning av fler trådar skulle överkrida gränsen för +minnesanvändning. +.IP "" +De enkeltrådade och multitrådade komprimerarna producerar olika utdata. Den +enkeltrådade komprimeraren kommer ge den minsta filstorleken men endast +utdata från den multitrådade komprimeraren kan dekomprimeras med flera +trådar. Att sätta \fItrådar\fP till \fB1\fP kommer använda enkeltrådat läge. Att +sätta \fItrådar\fP till något annat värde, inklusive \fB0\fP, kommer använda den +multitrådade komprimeraren även om systemet endast stödjer en hårdvarutråd. +(\fBxz\fP 5.2.x använde enkeltrådat läge i denna situation.) +.IP "" +För att använda multitrådat läge med endast en tråd, sätt \fItrådar\fP till +\fB+1\fP. Prefixet \fB+\fP har ingen påvrekan för andra värden än \fB1\fP. En gräns +för minnesanvändning kan fortfarande göra att \fBxz\fP byter till enkeltrådat +läge såvida inte \fB\-\-no\-adjust\fP används. Stöd för prefixet \fB+\fP lades till i +\fBxz\fP 5.4.0. +.IP "" +Om ett automatiskt antal trådar har begärts och ingen gräns för +minnesanvändning har angivits, då kommer en systemspecifik mjuk +standardgräns användas för att möjligen begränsa antalet trådar. Det är en +mjuk gräns i den meningen att den ignoreras om antalet trådar blir en, +alltså kommer en mjuk gräns aldrig hindra \fBxz\fP från att komprimera eller +dekomprimera. Denna mjuka standardgräns kommer inte göra att \fBxz\fP byter +från multitrådat läge till enkeltrådat läge. De aktiva gränserna kan ses med +\fBxz \-\-info\-memory\fP. +.IP "" +För närvarande är den enda trådningsmetoden att dela indata i block och +komprimera dem oberoende av varandra. Standardstorleken på block beror på +komprimeringsnivån och kan åsidosättas med flaggan +\fB\-\-block\-size=\fP\fIstorlek\fP. +.IP "" +Trådad dekomprimering fungerar bara på filer som innehåller flera block med +storleksinformation i blockhuvuden. Alla tillräckligt stora filer +komprimeras i multitrådat läge för att uppfylla detta villkor, men filer +komprimerade i enkeltrådat läge gör det inte ens om +\fB\-\-block\-size=\fP\fIstorlek\fP har använts. +.IP "" +Standardvärdet på \fItrådar\fP är \fB0\fP. I \fBxz\fP 5.4.x och tidigare är +standardvärdet \fB1\fP. +. +.SS "Anpassade komprimerarfilterkedjor" +Med en anpassad filterkedja kan man specificera kompressionsinställningarna +i detalj istället för att lita på inställningarna som hör till +förinställningarna. När en anpassad filterkedja anges glöms +förinställningsflaggor (\fB\-0\fP \&…\& \fB\-9\fP och \fB\-\-extreme\fP) tidigare på +kommandoraden. Om en förinställningsflagga anges efter en eller flera +flaggor för anpassade filterkedjor gäller den nya förinställningen och de +flaggor för anpassade filterkedjor som angivits tidigare glöms. +.PP +En filterkedja är jämförbar med att skapa rör på kommando. Vid komprimering +skickas den okomprimerade indatan till det första filtret, vars utdata +skickas till nästa filter (om något). Utdatan från det sista filtret blir +skrivet till den komprimerade filen. Det maximala antalet filter i kedjan är +fyra, men typiskt har en filterkedja bara ett ellet två filter. +.PP +Många filter har begränsningar på var de kan finnas i filterkedjan: några +filter kan bara fungera som det sista filtret i kedjan, några bara om de +inte är det sista filtret, och några fungerar i godtycklig position i +kedjan. Beroende på filtret är denna begränsning antingen en egenskap hos +filterdesignen eller finns för att förhindra säkerhetsproblem. +.PP +En anpassad filterkedja kan anges på två olika sätt. Med flaggorna +\fB\-\-filters=\fP\fIfilter\fP och \fB\-\-filters1=\fP\fIfilter\fP \&…\& +\fB\-\-filters9=\fP\fIfilter\fP kan man ange en hel filterkedja med en flagga genom +att använda syntaxen för liblzma\-filtersträngar. Alternativt kan en +filterkedja anges genom att använda en eller flera individuella +filterflaggor i den ordning de önskas i filterkedjan. Det vill säga, +ordningen på de individuella filterflaggorna är signifikant! Vid avkodning +av råa strömmar (\fB\-\-format=raw\fP) måste filterkedjan anges i samma ordning +som den specificerades vid komprimeringen. Eventuella individuella filter\- +eller förinstiällningsflaggor angivna före den fullständiga +filterkedjeflaggan (\fB\-\-filters=\fP\fIfilter\fP) kommer glömmas. Individuella +filter som anges efter den flaggan för en full kedja kommer återställa +filterkedjan. +.PP +Både den fullständiga och de individuella filterflaggorna tar +filterspecifika \fIflaggor\fP som en kommaseparerad lista. Extra komman +\fIflaggor\fP ignoreras. Varje flagga har ett standardvärde, så ange dem du +vill ändra. +.PP +För att se hela filterkedjan och \fIflaggor\fP, använd \fBxz \-vv\fP (det vill +säga, använd \fB\-\-verbose\fP två gånger). Detta fungerar även för att se +flaggorna för filterkedjor som används av förinställningar. +.TP +\fB\-\-filters=\fP\fIfilter\fP +Ange den fullständiga filterkedan eller en förinställning en en enda +flagga. Varje filter kan separeras med blanktecken eller två bindestreck +(\fB\-\-\fP). \fIfilter\fP kan behöva citeras på skalets kommandorad så att det +tolkas som en enda flagga. För att beteckna \fIflaggor\fP, använd \fB:\fP eller +\fB=\fP. En förinställning kan föregås med ett \fB\-\fP och följas av noll eller +flera flaggor. Den enda flaggan som stödjs är \fBe\fP för att tillämpa samma +flaggor som \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIfilter\fP … \fB\-\-filters9\fP=\fIfilter\fP +Ange upp till nio ytterligare filterkedjor som kan användas med +\fB\-\-block\-list\fP. +.IP "" +Till exempel, vid komprimering av ett arkiv med körbara filer följt av +textfiler skulle den körbara delen kunna använda en filterkedja med ett +BCJ\-filter och endast textdelen med LZMA2\-filtret. +.TP +\fB\-\-filters\-help\fP +Visa ett hjälpmeddelande som beskriver hur man anger förinställningar och +anpassade filterkedjor i flaggorna \fB\-\-filters\fP och \fB\-\-filters1=\fP\fIfilter\fP +\&…\& \fB\-\-filters9=\fP\fIfilter\fP, och avsluta rent. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIflaggor\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIflaggor\fP] +.PD +Lägg till LZMA1\- eller LZMA2\-filter till filterkedjan. Dessa filter kan +endast användas som det sista filtret i kedjan. +.IP "" +LZMA1 är ett föråldrat filter, vilket stödjs nästan enbart på grund av det +föråldrade filformatet \fB.lzma\fP, vilket bara stödjer LZMA1. LZMA2 är en +uppdaterad version av LZMA1 för att lösa några praktiska problem med +LZMA1. Formatet \fB.xz\fP använder LZMA2 och stödjer inte LZMA1 +alls. Komprimeringshastigheten och förhållandena för LZMA1 är LZMA2 är +praktiskt taget desamma. +.IP "" +LZMA1 och LZMA2 delar samma uppättning \fIflaggor\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIförinställning\fP +Återställ alla LZMA1\- eller LZMA2\-\fIflaggor\fP till +\fIförinställning\fP. \fIFörinställning\fP består av ett heltal, vilket kan följas +av enskilda bokstäver som modifierar förinställningen. Heltalet kan vara +från \fB0\fP till \fB9\fP, motsvarande kommandoradsflaggorna \fB\-0\fP \&…\& +\fB\-9\fP. Den enda modifierare som stödjs för närvarande är \fBe\fP, vilket +motsvarar \fB\-\-extreme\fP. Om ingen \fBpreset\fP anges tas standardvärden på +LZMA1\- eller LZMA2\-\fIflaggor\fP från förinställningen \fB6\fP. +.TP +\fBdict=\fP\fIstorlek\fP +Ett lexikons (historiebufferts) \fIstorlek\fP indikerar hur många byte med +nyligen bearbetad okomprimerad data som hålls i minnet. Algoritmen försöker +hitta återkommande bytesekvenser (matchningar) i den okomprimerade datan, +och ersätta dem med referenser till datan som för närvarande finns i +lexikonet. Ju större lexikon, desto högre är sannolikheten att hitta en +matchning. Att öka lexikonets \fIstorlek\fP förbättrar alltså vanligen +komprimeringsförhållandet, men ett lexikon som är större än den +okomprimerade filen är ett slöseri med minne. +.IP "" +En typisk \fIstorlek\fP på lexikon är från 64\ KiB till 64\ MiB. Minimum är 4\ KiB. Det maximala för komprimering är för närvarande 1,5\ GiB (1536\ MiB). Dekomprimeraren stödjer redan lexikon upp till en byte mindre än 4\ GiB, vilket är det maximala för strömformaten LZMA1 och LZMA2. +.IP "" +Lexikon\fIstorlek\fP och matchhittaren (\fImf\fP) avgör tillsammans +minnesanvändningen för LZMA1\- eller LZMA2\-kodaren. Ett lika \fIstort\fP (eller +större) lexikon behövs för dekomprimering som det som användes vid +komprimeringen, minnesanvändningen för avkodaren avgörs alltså av +lexikonstorleken vid komprimering. Huvudena i \fB.xz\fP innehåller lexikonets +\fIstorlek\fP antingen som 2^\fIn\fP eller 2^\fIn\fP + 2^(\fIn\fP\-1), så dessa +\fIstorlekar\fP är lite att föredra för komprimering. Andra \fIstorlekar\fP kommer +avrundas uppåt när de lagras i huvuden i \fB.xz\fP. +.TP +\fBlc=\fP\fIlk\fP +Ange antalet literala kontextbitar. Minimum är 0 och maximum är 4; +standardvärdet är 3. Dessutom får inte summan av \fIlk\fP och \fIlp\fP överskrida +4. +.IP "" +Alla byte som inte kan kodas som matchningar kodas som literaler. Det vill +säga, literaler är helt enkelt 8\-bits byte som kodas en åt gången. +.IP "" +Den literala kodningen gör antagandet att de högsta \fIlk\fP bitarna av den +föregående okomprimerade byten korrelerar med nästa byte. Till exempel, i +typisk engelsk text följs ofta en versal bokstav av en gemen bokstav, och en +gemen bokstav följs vanligen av en annan gemen bokstav. I +teckenuppsättningen US\-ASCII är de högsta tre bitarna 010 för versala +bokstäver och 011 för gemena bokstäver. När \fIlk\fP är åtminstone 3 kan den +literala kodningen dra nytta av denna egenskap i den okomprimerade datan. +.IP "" +Standardvärdet (3) är normalt bra. Om man vill ha maximal komprimering, +prova \fBlc=4\fP. Ibland hjälper det lite, och ibland gör det komprimeringen +sämre. Om det gör den sämre, testa också \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Ange antalet literala positionsbitar. Minimum är 0 och maximum är 4; +standardvärdet är 0. +.IP "" +\fILp\fP påverkar vilken sorts justering i den okomprimerade datan som antas +vid kodning av literaler. Se \fIpb\fP nedan för mer information om justering. +.TP +\fBpb=\fP\fIpb\fP +Ange antalet positionsbitar. Minimum är 0 och maximum är 4; standardvärdet +är 2. +.IP "" +\fIPb\fP påverkar vilken sort justering i den okomprimerade datan som antas i +allmänhet. Standardvärdet betyder fyrbytejustering (2^\fIpb\fP=2^2=4), vilket +ofta är ett bra val när det inte finns någon bättre gissning. +.IP "" +När justeringen är känd kan en inställning av \fIpb\fP därefter reducera +filstorleken något. Till exempel, med textfiler som har en\-byte\-justering +(US\-ASCII, ISO\-8859\-*, UTF\-8) kan att sätta \fBpb=0\fP förbättra komprimeringen +något. För UTF\-16\-text är \fBpb=1\fP ett bra val. Om justeringen är ett udda +tal som 3 byte kan \fBpb=0\fP vara det bästa valet. +.IP "" +Även om den antagna justeringen kan anpassas med \fIpb\fP och \fIlp\fP föredrar +LZMA1 och LZMA2 ändå något 16\-byte\-justering. Det kan vara värt att ta med i +beräkningen vid design av filformat som sannolikt ofta kan komma att +komprimeras med LZMA1 eller LZMA2. +.TP +\fBmf=\fP\fIms\fP +Matchsökaren har en stor poverkan på kodarens hastighet, minnesanvändning +och komprimeringsförhållande. Vanligen är Hashkedje\-matchsökare snabbare än +Binärträdsmatchsökare. Standardvärdet beror på \fIföinställningen\fP: 0 +använder \fBhc3\fP, 1\(en3 använder \fBhc4\fP, och resten använder \fBbt4\fP. +.IP "" +Följande matchsökare stödjs. Formlerna för minnesanvändning nedan är grova +uppskattningar, vilka är närmast sanningen när \fIdict\fP är en tvåpotens. +.RS +.TP +\fBhc3\fP +Hashkedja med 2\- och 3\-bytehashning +.br +Minsta värde på \fInice\fP: 3 +.br +Minnesanvändning: +.br +\fIdict\fP · 7.5 (om \fIdict\fP ≤ 16 MiB); +.br +\fIdict\fP · 5,5 + 64 MiB (om \fIdict\fP > 16 MiB) +.TP +\fBhc4\fP +Hashkedja med 2\-, 3\- och 4\-bytehashning +.br +Minsta värde på \fInice\fP: 4 +.br +Minnesanvändning: +.br +\fIdict\fP · 7,5 (om \fIdict\fP ≤ 32 MiB); +.br +\fIdict\fP · 6,5 (om \fIdict\fP > 32 MiB) +.TP +\fBbt2\fP +Binärträd med 2\-bytehashning +.br +Minsta värde på \fInice\fP: 2 +.br +Minnesanvändning: \fIdict\fP · 9,5 +.TP +\fBbt3\fP +Binärträd med 2\- och 3\-bytehashning +.br +Minsta värde på \fInice\fP: 3 +.br +Minnesanvändning: +.br +\fIdict\fP · 11,5 (om \fIdict\fP ≤ 16 MiB); +.br +\fIdict\fP · 9,5 + 64 MiB (om \fIdict\fP > 16 MiB) +.TP +\fBbt4\fP +Binärträd med 2\-, 3\- och 4\-bytehashning +.br +Minsta värde på \fInice\fP: 4 +.br +Minnesanvändning: +.br +\fIdict\fP · 11,5 (om \fIdict\fP ≤ 32 MiB); +.br +\fIdict\fP · 10,5 (om \fIdict\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fIläge\fP +Komprimerings\fIläget\fP anger metoden som används för att analysera data +skapade av matchsökaren. De \fIlägen\fP som stödjs är \fBfast\fP och +\fBnormal\fP. Standardvärdet är \fBfast\fP för \fIförinställningarna\fP 0\(en3 och +\fBnormal\fP för \fIförinställningarna\fP 4\(en9 +.IP "" +Vanligen används \fBfast\fP med Hashkedjematchsökare och \fBnormal\fP med +Binärträdsmatchsökare. Detta är även vad \fIförinställningarna\fP gör. +.TP +\fBnice=\fP\fIlagom\fP +Ange vad som anses vara en lagom längt på en matchning. När en matchning på +åtminstone \fIlagom\fP byte hittats slutar algoritmen söka efter möjliga bättre +matchningar. +.IP "" +\fILagom\fP kan vara 2\(en273 byte. Högre värden tenderar att ge bättre +komprimeringsförhållande på bekostnad av tid. Standardvärdet beror på +\fIförinställningen\fP. +.TP +\fBdepth=\fP\fIdjup\fP +Ange det maximala sökdjupet i matchsökaren. Standardvärdet är specialvärdet +0, vilket får komprimeraren att avgöra ett lämpligt \fIdjup\fP från \fImf\fP och +\fInice\fP. +.IP "" +Lämpligt \fIdjup\fP för Hashkedjor är 4\(en100 och 16\(en1000 för +Binärträd. Att använda väldigt höga värden på \fIdjup\fP kan göra kodaren +extremt långsam för vissa filer. Undvik att sätta \fIdjup\fP över 1000 såvida +du inte är beredd att avbryta komprimeringen om den tar för lång tid. +.RE +.IP "" +Vid avkodning av råa strömmar (\fB\-\-format=raw\fP) behöver LZMA2 endast +lexikonets \fIstorlek\fP. LZMA1 behöver även \fIlc\fP, \fIlp\fP och \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIflaggor\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIflaggor\fP] +.PD +Lägg till gren/anrop/hopp\-filter (branch/call/jump, BCJ) till +filterkedjan. Dessa filter kan inte användas som det sista filtret i +filterkedjan. +.IP "" +Ett BCJ\-filter konverterar relativa adresser i maskinkod till deras absoluta +motsvarigheter. Detta ändrar inte storleken på datan men det ökar +redundansen, vilket kan hjälpa LZMA2 att skapa 0\(en15\ % mindre +\&\fB.xz\fP\-filer. BCJ\-filtren är alltid reversibla, så att använda ett +BCJ\-filter för fel sorts data orsakar inte någon dataförlust, men det kan +göra komprimeringsförhållandet något sämre. BCJ\-filtren är mycket snabba +och använder en obetydling mängd minne. +.IP "" +Dessa BCJ\-filter har kända problem kopplade till komprimeringsförhållandet: +.RS +.IP \(bu 3 +Någr sortes filer som innehåller körbar kod (till exempel, objektfiler, +statiska bibliotek och Linux kärnmoduler) har adresserna i instruktionerna +fyllda med utfyllnadsvärden. Dessa BCJ\-filter kommer ändå göra +adresskonverteringen, vilket kommer göra komprimeringen sämre för dessa +filer. +.IP \(bu 3 +Om ett BCJ\-filter används på ett arkiv är det möjligt att det gör +komprimeringsförhållandet sämre än att inte använda något BCJ\-filter. Till +exempel, om det finns liknande eller till och med identiska körbara kommer +filtreringen sannolikt göra filerna mindre lika och därmed blir +kompressionen sämre. Innehållet i icke körbara filer i samma arkiv kan också +spela en roll. I praktiken måste man prova med och utan ett BCJ\-filter för +att se vilket som är det bästa i varje situation. +.RE +.IP "" +Olika instruktionsuppsättningar har olika justering: den körbara filen måste +vara justerad till en multipel av detta värde i indata för att filtret skall +fungera. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filter;Justering;Kommentarer +x86;1;32\-bitars eller 64\-bitars x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096\-bytesjustering är bäst +PowerPC;4;Endast rak byteordning +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Eftersom BCJ\-filtrerad data vanligen komprimeras med LZMA2 kan +komprimeringsförhållandet förbättras något om LZMA2\-flaggorna sätts till att +matcha justeringen hos det valda BCJ\-filtret. Exempel: +.RS +.IP \(bu 3 +IA\-64\-filter har 16\-bytejustering så \fBpb=4,lp=4,lc=0\fP är bra med LZMA2 +(2⁴=16). +.IP \(bu 3 +RISC\-V\-kod har 2\-byte\- eller 4\-bytejustering beroende på huruvida filen +innehåller 16\-bitars komprimerade instruktioner (utvidgningen C). När +16\-bitarsinstruktioner används är \fBpb=2,lp=1,lc=3\fP eller \fBpb=1,lp=1,lc=3\fP +bra. När det inte finns några 16\-bitsinstruktioner är \fBpb=2,lp=2,lc=2\fP +bäst. \fBreadelf \-h\fP kan användas för att kontrollera om ”RVC” förekommer på +raden ”Flaggor”. +.IP \(bu 3 +ARM64 är alltid 4\-bytejusterad så \fBpb=2,lp=2,lc=2\fP är bäst. +.IP \(bu 3 +Filtret x86 är ett undantag. Det är normalt bra att hålla sig till LZMA2:s +standardvärden (\fBpb=2,lp=0,lc=3\fP) när körbar x86 komprimeras. +.RE +.IP "" +Alla BCJ\-filter stödjer samma \fIflaggor\fP: +.RS +.TP +\fBstart=\fP\fIavstånd\fP +Ange start\fIavståndet\fP som används vid konvertering mellan relativa och +absoluta adresser. \fIAvståndet\fP måste vara en multipel av filtrets justering +(se tabellen ovan). Standardvärdet är noll. I praktiken är standardvärdet +bra; det är nästan aldrig användbart att ange ett anpassat \fIavstånd\fP. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIflaggor\fP] +Lägg till Deltafiltret till filterkedjan. Deltafiltret kan inte användas som +det sista filtret i filterkedjan. +.IP "" +För närvarande stödjs bara enkel byte\-vis deltaberäkning. Det kan vara +användbart vid komprimering, till exempel av okomprimerade +bitavbildningsbilder eller okomprimerad PCM\-audio. Dock kan algoritmer för +särskilda ändamål ge betydligt bättre resultat än Delta + LZMA2. Detta är +särskilt sant med audio, vilket komprimerar snabbare och bättre med till +exempel \fBflac\fP(1). +.IP "" +Stödda \fIflaggor\fP: +.RS +.TP +\fBdist=\fP\fIavstånd\fP +Ange \fIavståndet\fP för deltaberäkningen i byte. \fIAvstånd\fP måste varea +1\(en256. Standardvärdet är 1. +.IP "" +Till exempel, med \fBdist=2\fP och åtta byte indata A1 B1 A2 B3 A3 B5 A4 B7, +kommer utdata vara A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Andra flaggor" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Utelämna varningar och noteringar. Ange detta två gånger för att även +utelämna felmeddelandet. Denna flagga har ingen påverkan på +slutstatusen. Det vill säga, även om en varning utelämnades kommer +slutstatusen fortfarandeindikera att en varning gavs. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Var utförlig. Om standard fel är kopplat till en terminal kommer \fBxz\fP visa +en förloppsmätare. Att ange \fB\-\-verbose\fP två gånger kommer ge än mer +utförlig utmatning. +.IP "" +Förloppsmätaren visar följande information: +.RS +.IP \(bu 3 +Procent färdigt visas om storleken på indatafilen är känd. Det vill säga, +procentsatsen kan inte visas i rör. +.IP \(bu 3 +Mängd komprimerad data som producerats (komprimering) eller konsumerats +(dekomprimering). +.IP \(bu 3 +Mängd okomprimerad data som konsumerats (komprimering) eller producerats +(dekomprimering). +.IP \(bu 3 +Komprimeringsförhållande, vilket beräknas genom att dividera mängden +komprimerad data bearbetad så lång med mängde okomprimerad data bearbetad så +långt. +.IP \(bu 3 +Kompressions eller dekompressionshastighet. Detta mäts som mängden +okomprimerad data konsumerad (komprimering) eller producerad +(dekomprimering) per sekund. Det visas efter att några sekunder har gåt +efter att \fBxz\fP började bearbeta filen. +.IP \(bu 3 +Förfluten tid på formatet MM:SS eller H:MM:SS. +.IP \(bu 3 +Beräknad återstående tid visas endast när storleken på indatafilen är känd +och några sekunder redan gått efter att \fBxz\fP började bearbeta filen. Tiden +visas i ett mindre precist format vilket aldrig har några kolon, till +exempel, 2 min 30 s. +.RE +.IP "" +När standard fel inte är en terminal kommer \fB\-\-verbose\fP göra att \fBxz\fP +skriver filnamnet, komprimerad storlek, okomprimerad storlek, +komprimeringsförhållande och möjligen även hastigheten och den förlupna +tiden på en enda rad till standard fel efter att ha komprimerat eller +dekomprimerat filen. Hastigheten och den förlupna tiden inkluderas endast +när åtgärden tog åtminstone några sekunder. Om åtgärden inte slutfördes, +till exempel för att användaren avbröt, skrivs även den fullbordade +procentsatsen om storleken på indatafilen är känd. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Sätt inte slutstatus till 2 även om ett tillstånd som är värt en varning +upptäcktes. Denna flagga påverkar inte utförlighetsnivån, allts måste både +\fB\-\-quiet\fP och \fB\-\-no\-warn\fP användas för att inte visa varningar och för att +inte ändra slutstatusen. +.TP +\fB\-\-robot\fP +Skriv meddelanden i maskinläsbart form. Detta är avsett att förenkla att +skriva framändar som vill använda \fBxz\fP istället för liblzma, vilken kan +vara fallet i olika skript. Utdatan med denna flagga aktiverad är avsedd att +vara stabil mellan utgåvor av \fBxz\fP. Se avsnitett \fBROBOTLÄGE\fP för detaljer. +.TP +\fB\-\-info\-memory\fP +Visa, på mänskligt läsbar form, hur mycket fysiskt minne (RAM) och hur många +processortrådar \fBxz\fP tror att systemet har och gränserna för +minnesanvändning vid komprimering och dekomprimering, och avsluta. +.TP +\fB\-h\fP, \fB\-\-help\fP +Visa ett hjälpmeddelande som beskriver de vanligast använda flaggorna, och +avsluta. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Visa ett hjälpmeddelande som beskriver alla funktioner i \fBxz\fP, och avsluta +.TP +\fB\-V\fP, \fB\-\-version\fP +Visa versionsnumret för \fBxz\fP och liblzma i mänskligt läsbar form. För att +få maskinläsbar utdata, ange \fB\-\-robot\fP före \fB\-\-version\fP. +. +.SH ROBOTLÄGE +Robotläget aktiveras med flaggan \fB\-\-robot\fP. Det gör att utdata från \fBxz\fP +är enklare att tolka av andra program. För närvarande stödjs \fB\-\-robot\fP +endast tillsammans med \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP och +\fB\-\-version\fP. Den kommer att stödjas för komprimering och dekomprimering i +framtiden. +. +.SS Listläge +\fBxz \-\-robot \-\-list\fP använder tab\-separerad utmatning. Första kolumnen av +varje rad har en sträng som indikerar typen av informationen som finns på +den raden: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Detta är alltid första raden när en fil börjar listas. Den andra kolumen på +raden är filnamnet. +.TP +\fBfile\fP +Denna rad innehåller övergripande information om \fB.xz\fP\-filen. Denna rad +skrivs alltid efter raden \fBname\fP. +.TP +\fBstream\fP +Denna radtyp används endast när \fB\-\-verbose\fP angetts. Det finns lika många +\fBstream\fP\-rader som det finns strömmar i \fB.xz\fP\-filen. +.TP +\fBblock\fP +Denna radtyp används bara när \fB\-\-verbose\fP angetts. Det finns lika många +\fBblock\fP\-rader som det finns block i \fB.xz\fP\-filen. \fBblock\fP\-rader visas +efter alla \fBstream\fP\-raderna; olika radtyper blandas inte. +.TP +\fBsummary\fP +Denna radtyp används bara när \fB\-\-verbose\fP angetts två gånger. Denna rad +skrivs eefter alla \fBblock\fP\-rader. Liksom raden \fBfile\fP inenhåller raden +\fBsummary\fP övergripande information om \fB.xz\fP\-filen. +.TP +\fBtotals\fP +Denna rad är alltid den allra sista raden i listutmatningen. Den visar det +totala antalen och storlekarna. +.PP +Kolumnerna på \fBfile\fP\-raderna: +.PD 0 +.RS +.IP 2. 4 +Antalet strömmar i filen +.IP 3. 4 +Totalt antal block i strömmarna +.IP 4. 4 +Komprimerad storlek på filen +.IP 5. 4 +Okomprimerad storlek på filen +.IP 6. 4 +Komprimeringsförhållande, till exempel \fB0.123\fP. Om förhållandet är över +9.999 visas tre bindestreck (\fB\-\-\-\fP) istället för förhållandet. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Kommaseparerad lista med integritetskontrollnamn. Följande strängar används +för de kända kontrolltyperna: \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP och +\fBSHA\-256\fP. För okända kontrolltyper används \fBUnknown\-\fP\fIN\fP, där \fIN\fP är +kontroll\-ID:t som ett decimalt nummer (en eller två siffror). +.IP 8. 4 +Total storlek på strömutfyllnad i filen +.RE +.PD +.PP +Kolumnerna på \fBstream\fP\-raderna: +.PD 0 +.RS +.IP 2. 4 +Strömnummer (den första strömmen är 1) +.IP 3. 4 +Antal block i strömmen +.IP 4. 4 +Komprimerat startavstånd +.IP 5. 4 +Okomprimerat startavstånd +.IP 6. 4 +Komprimerad storlek (inkluderar inte strömutfyllnad) +.IP 7. 4 +Okomprimerad storlek +.IP 8. 4 +Komprimeringsförhållande +.IP 9. 4 +Namnet på integritetskontrollen +.IP 10. 4 +Storleken på strömutfyllnad +.RE +.PD +.PP +Kolumnerna på \fBblock\fP\-raderna: +.PD 0 +.RS +.IP 2. 4 +Numret på strömmen som innehåller detta block +.IP 3. 4 +Blocknummer relativt början på strömmen (det första blocket är 1) +.IP 4. 4 +Blocknummer relativt början på filen +.IP 5. 4 +Komprimerat startavstånd relativt början av filen +.IP 6. 4 +Okomprimerat startavstånd relativt början av filen +.IP 7. 4 +Total komprimerad storlek på blocket (inkluderar huvuden) +.IP 8. 4 +Okomprimerad storlek +.IP 9. 4 +Komprimeringsförhållande +.IP 10. 4 +Namnet på integritetskontrollen +.RE +.PD +.PP +Om \fB\-\-verbose\fP angavs två gånger inkluderas ytterligare kolumner på +\fBblock\fP\-raderna. Dessa visas inte med bara ett \fB\-\-verbose\fP, eftersom det +för att få fram denna information krävs många sökningar och kan därmed vara +långsamt: +.PD 0 +.RS +.IP 11. 4 +Värdet på integritetskontrollen hexadecimalt +.IP 12. 4 +Blockhuvudstorlek +.IP 13. 4 +Blockflaggor: \fBc\fP indikerar att komprimerad storlek finns, och \fBu\fP +indikerar att okomprimerad storlek finns. Om flaggan inte är satt visas ett +bindestreck (\fB\-\fP) istället för att hålla stränglängden fast. Nya flaggor +kan läggas till i slutet av strängen i frmtiden. +.IP 14. 4 +Storlek på den faktiska komprimerade datan i blocket (detta utelämnar +blockhuvud, blockutfyllnad och kontrollfält) +.IP 15. 4 +Mängd minne (i byte) som behövs för att dekomprimera detta block med denna +version av \fBxz\fP +.IP 16. 4 +Filterkedja. Observera att de flesta av flaggorna som användes vid +komprimeringstillfället inte kan vara kända, eftersom endat de flaggor som +behövs för dekomprimering lagras i \fB.xz\fP\-huvudet. +.RE +.PD +.PP +Kolumnerna på \fBsummary\fP\-raderna: +.PD 0 +.RS +.IP 2. 4 +Mängd minne (i byte) som behövs för att dekomprimera denna fil med denna +version av \fBxz\fP +.IP 3. 4 +\fByes\fP eller \fBno\fP som indikerar om alla blockhuvuden både har komprimerad +storlek och okomprimerad storlek i sig +.PP +\fIFrån\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Minsta version av \fBxz\fP som krävs för att dekomprimera filen +.RE +.PD +.PP +Kolumnerna på \fBtotals\fP\-raden: +.PD 0 +.RS +.IP 2. 4 +Antal strömmar +.IP 3. 4 +Antal block +.IP 4. 4 +Komprimerad storlek +.IP 5. 4 +Okomprimerad storlek +.IP 6. 4 +Genomsnittligt komprimeringsförhållande +.IP 7. 4 +Kommaseparerad lista med integritetskontrollnamn som fanns i filerna +.IP 8. 4 +Strömutfyllnadsstorlek +.IP 9. 4 +Antal filer. Denna finns här för att hålla ordningen av de tidigare +kolumnerna desamma som på \fBfile\fP\-rader. +.PD +.RE +.PP +Om \fB\-\-verbose\fP angavs två gånger inkluderas ytterligare kolumner på +\fBtotals\fP\-raden: +.PD 0 +.RS +.IP 10. 4 +Maximal mängd minne (i byte) som behövs för att dekomprimera filerna med +denna version av \fBxz\fP +.IP 11. 4 +\fByes\fP eller \fBno\fP som indikerar om alla blockhuvuden både har komprimerad +storlek och okomprimerad storlek i sig +.PP +\fIFrån\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Minsta version av \fBxz\fP som krävs för att dekomprimera filen +.RE +.PD +.PP +Framtida versioner kan lägga till fler radtyper och fler kolumner kan läggas +til på de befintliga radtyperna, men de befintliga kolumnerna kommmer inte +ändras. +. +.SS Filterhjälp +\fBxz \-\-robot \-\-filters\-help\fP skriver ut de filter som stödjs i följande +format: +.PP +\fIfilter\fP\fB:\fP\fIflagga\fP\fB=<\fP\fIvärde\fP\fB>,\fP\fIflagga\fP\fB=<\fP\fIvärde\fP\fB>\fP… +.TP +\fIfilter\fP +Namn på filtret +.TP +\fIflagga\fP +Namn på en filterspecifik flagga +.TP +\fIvärde\fP +Numeriska \fIvärde\fPintervall ser ut som +\fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. Sträng\fIvärdes\fP val visas inom \fB< >\fP och separerade med ett \fB|\fP\-tecken. +.PP +Varje filter skrivs på en egen rad. +. +.SS Minnesgränsinformation +\fBxz \-\-robot \-\-info\-memory\fP skriver en rad med flera tab\-separerade +kolumner: +.IP 1. 4 +Total mängd med fysiskt minne (RAM) i byte. +.IP 2. 4 +Minnesanvändningsgräns för komprimering i byte (\fB\-\-memlimit\-compress\fP). Ett +specialvärde \fB0\fP indikerar standardinställningen vilken för enkeltrådat +läge är detsamma som ingen gräns. +.IP 3. 4 +Minnesanvändningsgräns för dekomprimering i byte +(\fB\-\-memlimit\-decompress\fP). Ett specialvärde \fB0\fP indikerar +standdartinställningen vilken för enkeltrådat läge är detsamma som ingen +gräns. +.IP 4. 4 +Från \fBxz\fP 5.3.4alpha: Minnesanvändningen för multitrådad dekomprimering i +byte (\fB\-\-memlimit\-mt\-decompress\fP). Detta är aldrig noll eftersom ett +systemspecifikt standardvärde som visas i kolumn 5 används om ingen gräns +har angivits uttryckligen. Detta är heller aldrig större än värdet i kolumn +3 även om ett större värde har angivits med \fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Från \fBxz\fP 5.3.4alpha: Ett systemspecifikt standardgräns för +minnesanvändning som används för att begränsa antalet trådar vid +komprimering med ett automatiskt antal trådar (\fB\-\-threads=0\fP) och ingen +gräns för minnesanvändning har angivits (\fB\-\-memlimit\-compress\fP). Detta +används även som standardvärdet på \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Från \fBxz\fP 5.3.4alpha: antal tillgängliga processortrådar. +.PP +I framtiden kan utdata från \fBxz \-\-robot \-\-info\-memory\fP ha fler kolumner, +men aldrig mer än en rad. +. +.SS Version +\fBxz \-\-robot \-\-version\fP skriver versionsnumret på \fBxz\fP och liblzma i +följande format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Huvudversion. +.TP +\fIYYY\fP +Underversion. Jämna nummer är stabila. Udda nummer är alfa\- eller +betaversioner. +.TP +\fIZZZ\fP +Rättningsnivå för stabila utgåvor eller bara en räknare för +utvecklingsutgåvor. +.TP +\fIS\fP +Stabilitet. 0 är alfa, 1 beta beta och 2 är stabil. \fIS\fP skall alltid vara +2 när \fIYYY\fP är jämnt. +.PP +\fIXYYYZZZS\fP är samma på båda raderna om \fBxz\fP och liblzma kommer från samma +utgåva av XZ Utils. +.PP +Exempel: 4.999.9beta är \fB49990091\fP och 5.0.0 är \fB50000002\fP. +. +.SH SLUTSTATUS +.TP +\fB0\fP +Allt är bra. +.TP +\fB1\fP +Ett fel uppstod. +.TP +\fB2\fP +Något värt en varning uppstod, men inga faktiska fel uppstod. +.PP +Noteringar (inte varningar eller fel) som skrivs på standard fel påverkar +inte slutstatusen. +. +.SH MILJÖ +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP tolkar mellanrumsseparerade listor av flaggor från miljövariablerna +\fBXZ_DEFAULTS\fP och \fBXZ_OPT\fP, i den ordningen, före flaggorna på +kommandoraden. Observera att endast flaggor tolkas från miljövariablerna; +alla andra argument än flaggor ignoreras tyst. Tolkningen görs med +\fBgetopt_long\fP(3) vilket även används för kommandoradsargumenten. +.PP +\fBVarning:\fP genom att sätta dessa miljövariabler ändrar man i praktiken +program och skript som kör \fBxz\fP. för det mesta är set säkert att sätta +begränsningar på minnesanvändning, antal trådar och komprimeringsflaggor via +miljövariablerna. Några flaggor kan dock göra att skript går sönder. Ett +uppenbart exempel är \fB\-\-help\fP vilket gör att \fBxz\fP visar en hjälptext +istället för att komprimera eller dekomprimera en fil. Mer subtila exempel +är \fB\-\-quiet\fP och \fB\-\-verbose\fP. I många fall fungerar det bra att aktivera +en förloppsindikator med \fB\-\-verbose\fP, men i några fall skapar de extra +meddelandena problem. Utförlighetsnivån påverkar även beteendet hos +\fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Användarspecifika eller systemspecifika standardflaggor. Typiskt sätts detta +i ett initieringsskript för skal för att aktivera \fBxz\fP:s begränsning av +minnesanvändning som standard eller att ställa in ett standardantal +trådar. Med undantag för skalinitieringsskript och liknande specialfall +skall skript aldrig sätta eller ta bort \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Detta är för att skicka flaggor till \fBxz\fP när det inte är möjligt att sätta +flaggorna direkt på kommandoraden för \fBxz\fP. Detta är fallet när \fBxz\fP körs +av ett skript eller verktyg, till exempel, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf apa.tar.xz apa\fR +.fi +.RE +.RE +.IP "" +Skript kan använda \fBXZ_OPT\fP, till exempel, för att sätta skriptspecifika +standardflaggor för komprimering. Det rekommenderas fortfarande att tillåta +användaren att åsidosätta \fBXZ_OPT\fP om det är rimligt. Till exempel, i +\fBsh\fP(1)\-skript kan man använda något i still med detta: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "KOMPATIBILITET MED LZMA UTILS" +Kommandoradssyntaxen för \fBxz\fP är praktiskt taget en utökning av \fBlzma\fP, +\fBunlzma\fP och \fBlzcat\fP så som de kommer från LZMA Utils 4.32.x. I de flesta +fall, är det möjligt att ersätta LZMA Utils med XZ Utils utan att göra +sönder befintliga skript. Det finns dock några inkompatibiliteter, vilka +ibland kan orsaka problem. +. +.SS "Komprimeringens förinställda nivåer" +Numreringen av förinställda nivåer för komprimering är inte identiska i +\fBxz\fP och LZMA Utils. Den viktigaste skillnade är hur lexikonstorlekar +avbildas till olika förinställningar. Lexikonstorleken är i stort sett lika +med dekomprimerarens minnesanvändning. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nivå;xz;LZMA Utils +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Lexikonstorlekens skillnader påverkar komprimerarens minnesanvändning också, +men det finns några andra skillnader mellan LZMA Utils och XZ Utils, vilket +gör skillnaden ännu större: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nivå;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Standardförinställningsninvån i LZMA Utils är \fB\-7\fP medan i XZ Utils är den +\fB\-6\fP, så båda använder ett 8 MiB lexikon som standard. +. +.SS "Strömmade visavi icke strömmade .lzma\-filer" +Den ikomprimerade storleken på filen kan lagras i huvudet i \fB.lzma\fP. LZMA +Utils gör det när den komprimerar normala filer. Alternativet är att markera +att den okomprimerade storleken är okänd och använda en markör för lastslut +för att indikera var dekomprimeraren skall stanna. LZMA Utils använder denna +metod när den okomprimerade storleken inte är känd, vilket är fallet, till +exempel, i rör. +.PP +\fBxz\fP stödjer dekomprimering av \fB.lzma\fP\-filer med eller utan markör för +lastslut, men alla \fB.lzma\fP filer som skapas av \fBxz\fP kommer använda markör +för lastslut och ha den okomprimerade storleken markerad som okänd i +\&\fB.lzma\fP\-huvudet. Detta kan bli ett problem i några ovanliga fall. Till +exempel kan en \fB.lzma\fP\-dekomprimerare i en inbäddad enhet fungera endast +med filer som har en känd okomprimerad storlek. Om man stöter på detta +problem behöver man använda LZMA Utils eller LZMA SDK för att skapa +\&\fB.lzma\fP\-filer med känd okomprimerad storlek. +. +.SS "Ej stödda .lzma\-filer" +Formatet \fB.lzma\fP tillåter värden på \fIlc\fP upp till 8, och värden på \fIlp\fP +upp till 4. LZMA Utils kan dekomprimera filer med godtyckliga \fIlc\fP och +\fIlp\fP, men skapar alltid filer med \fBlc=3\fP och \fBlp=0\fP. Att skapa filer med +andra \fIlc\fP och \fIlp\fP är möjligt med \fBxz\fP och med LZMA SDK. +.PP +Implementationen av LZMA1\-filtret i liblzma kräver att summan av \fIlc\fP och +\fIlp\fP inte överstiger 4. Alltså, \fB.lzma\fP\-filer, vilka överstiger denna +gräns, kan inte dekomprimeras med \fBxz\fP. +.PP +LZMA Utils skapar endast \fB.lzma\fP\-filer som har en lexikonstorlek på 2^\fIn\fP +(en potens av 2) men godtar filer med godtycklig lexikonstorlek. liblzma +godtar endast \fB.lzma\fP\-filer som har en lexikonstorlek på 2^\fIn\fP eller +2^\fIn\fP + 2^(\fIn\fP\-1). Detta är för att minska falska positiva vid detektering +av \fB.lzma\fP\-filer. +.PP +Dessa begränsningar bör inte vara ett problem i praktiken, eftersom +praktiskt taget alla \fB.lzma\fP\-filer har komprimerats med inställningar som +liblzma kommer godta. +. +.SS "Avslutande skräp" +Vid dekomprimering ignorerar LZMA Utils tyst allting efter den första +\&\fB.lzma\fP\-strömmen. I de flesta situationer är detta fel. Detta betyder även +att LZMA Utils inte stödjer dekomprimering av konkatenerade \fB.lzma\fP\-filer. +.PP +Om det finns data kvar efter den första \fB.lzma\fP\-strömmen betraktar \fBxz\fP +filen som trasig om inte \fB\-\-single\-stream\fP användes. Detta kan göra sönder +obskyra skript vilka har antagit att avslutande skräp ignoreras. +. +.SH NOTERINGAR +. +.SS "Den komprimerade utdatan kan variera" +Den exakta komprimerade utdatan som produceras från samma okomprimerade +indatafil kan variera mellan versioner av XZ Utils även om +komprimeringsflaggorna är identiska. Detta beror på att kodaren kan +förbättras (snabbare eller bättre komprimering) utan att påverka +filformatet. Utdatan kan variera även mellan olika byggen av samma version +av XZ Utils, om olika byggflaggor används. +.PP +Ovanstående betyder att när väl \fB\-\-rsyncable\fP har implementerats kommer +inte nödvändigtvis de resulterande filerna vara rsync\-bara om inte både +gamla och nya filer har komprimerats med samma version av xz. Detta problem +kan lösas om en del av kodarimplementeringen fryses för att hålla rsync\-bar +utdata stabil mellan xz\-versioner. +. +.SS "Inbäddade .xz\-dekomprimerare" +Inbäddade implementationer av \fB.xz\fP\-dekomprimerare som XZ Embedded stödjer +inte nödvändigtvis filer som skapas med andra typer av +integritets\fIkontroll\fP än \fBnone\fP och \fBcrc32\fP. Eftersom standardvärdet är +\fB\-\-check=crc64\fP måste man använda \fB\-\-check=none\fP eller \fB\-\-check=crc32\fP +när filer skapas för inbäddade system. +.PP +Utanför inbäddade system stödjer alla dekomprimerare av \fB.xz\fP\-format alla +typerna av \fIkontroller\fP, eller åtminstone kan de dekomprimera filern utan +att verifiera integritetskontrollen om den specifika \fIkontrollen\fP inte +stödjs. +.PP +XZ Embedded stödjer BCJ\-filter, men endast med standard startavstånd. +. +.SH EXEMPEL +. +.SS Grundläggande +Komprimera filen \fIapa\fP till \fIapa.xz\fP med standardkomprimeringsnivån +(\fB\-6\fP), och ta bort \fIapa\fP om komprimeringen lyckas: +.RS +.PP +.nf +\f(CRxz apa\fR +.fi +.RE +.PP +Dekomprimera \fIbepa.xz\fP till \fIbepa\fP och ta inte bort \fIbepa.xz\fP även om +dekomprimeringen lyckas: +.RS +.PP +.nf +\f(CRxz \-dk bepa.xz\fR +.fi +.RE +.PP +Skapa \fIcepa.tar.xz\fP med förinställningen \fB\-4e\fP (\fB\-4 \-\-extreme\fP), vilket +är långsammare än standardvärdet \fB\-6\fP, men behöver mindre minne till +komprimering och dekomprimering (48\ MiB respektive 5\ MiB): +.RS +.PP +.nf +\f(CRtar cf \- cepa | xz \-4e > cepa.tar.xz\fR +.fi +.RE +.PP +En blandning av komprimerade och okomprimerade filer kan dekomprimeras till +standard ut med ett enda kommando: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Parallell komprimering av många filer" +På GNU och *BSD kan \fBfind\fP(1) och \fBxargs\fP(1) användas för att +parallellisera komprimeringen av många filer: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Flaggan \fB\-P\fP till \fBxargs\fP(1) anger antalet parallella \fBxz\fP\-processer. Det +bästa värdet till flaggan \fB\-n\fP beror på hur många filer det finns som skapp +komprimeras. Om det bara finns några stycken filer bör värdet förmodigen +vara 1; med tiotusentals filer kan 100 eller mer vara lämpligt för att +reducera antalet \fBxz\fP\-processer som \fBxargs\fP(1) kommer att skapa. +.PP +Flaggan \fB\-T1\fP till \fBxz\fP finns för att tvinga den till enkeltrådsläge, +eftersom \fBxargs\fP(1) används för att styra mängden parallellisering. +. +.SS Robotläge +Beräkna hur många byt som har sparats totalt efter komprimering av flera +filer: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Ett skript kan vilja veta att det använder en tillräckligt ny +\fBxz\fP. Följande \fBsh\fP(1)\-skript kontrollerar att versionsnumret för +verktyget \fBxz\fP är åtminstone 5.0.0. Denna metod är kompatibel med gamla +betaversioner, vilka inte stödde flaggan \fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Din xz är för gammal." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Ange en gräns för minnesanvändning för dekomprimering med \fBXZ_OPT\fP, men om +en gräns redan har satts, öka den inte: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Anpassade komprimerarfilterkedjor" +Den enklaste användningen av anpassade filterkedjor är att anpassa en +LZMA2\-förinställning. Detta kan vara användbart eftersom förinställningarna +endast täcker en delmängd av de potentiellt användbara kombinationerna av +komprimeringsinställningar. +.PP +Kolumnerna CompCPU i tabellerna från beskrivningen av flaggorna options +\fB\-0\fP ... \fB\-9\fP och \fB\-\-extreme\fP är användbara vid anpassning av +LZMA2\-förinställningar. Här är de relevanta delarna samlade från dessa två +tabeller: +.RS +.PP +.TS +tab(;); +c c +n n. +Förinställning;KompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Om man vet att en fil behöver ett rätt stort lexikon (till exempel, 32\ MiB) +för att komprimeras bra, men man vill komprimera den snabbare än \fBxz \-8\fP +skulle gjort kan en förinställning med ett lågt värde på CompCPU (till +exempel, 1) ändras till att använda ett större lexikon: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB apa.tar\fR +.fi +.RE +.PP +Med vissa filer kan ovanstående kommando vara snabbare än \fBxz \-6\fP samtidigt +som det komprimerar betydligt bättre. Dock måste det påpekas att endast +några filer drar fördel av ett stort lexikon samtidigt som värdet CompCPU +hålls lågt. Den mest uppenbara situationen, är ett stort lexikon kan hälpa +till mycket, är ett arkiv som innehåller väldigt snarlika filer på åtmistone +några megabyte var. Lexikonstorleken måste vara signifikant större än någon +enskild fil för att låta LZMA2 dra full nytta av likheterna mellan på +varandra följande filer. +.PP +Om det går bra med väldigt hög minnesanvändning i komprimeraren och +dekomprimeraren, och filen som komprimeras är åtminstone flera hundra +megabyte, kan det vara användbart att använda ännu större lexikon än de 64 +MiB som \fBxz \-9\fP skulle använda: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB stor_apa.tar\fR +.fi +.RE +.PP +Att använda \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) som i exemplet ovan kan vara +användbart för att se minnesbehoven för komprimeraren och +dekomprimeraren. Kom ihåg att använda ett större lexikon än storleken på den +okomprimerade filen är slöseri med minne, så ovanstående kommando är inte +användbart för små filer. +.PP +Ibland spelar inte dekomprimeringstiden någon roll, men dekomprimerarens +minnesanvändning måste hållas låg, till exempel för att göra det möjligt att +dekomprimera filen på ett inbäddat system. Följande kommando använder \fB\-6e\fP +(\fB\-6 \-\-extreme\fP) som en bas och sätter lexikonstorleken till bara 64\ KiB. Den resulterande filen kan dekomprimeras med XZ Embedded (det är därför +det finns \fB\-\-check=crc32\fP) som använder ungerfär 100\ KiB minne. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB apa\fR +.fi +.RE +.PP +Om man vill krama ur så många byte som möjligt kan justering av antalet +literala kontextbitar (\fIlc\fP) och antalet positionsbitar (\fIpb\fP) ibland +hjälpa. Justering av antalet literala positionsbitar (\fIlp\fP) kan också +hjälpa, men vanligen är \fIlc\fP och \fIpb\fP viktigare. Till exempel innehåller +ett källkodsarkiv huvudsakligen US\-ASCII\-text, så något i stil med följande +kan ge aningen (som 0.1\ %) mindre fil än \fBxz \-6e\fP (försök även utan +\fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 källkod.tar\fR +.fi +.RE +.PP +Att använda ett annat filter tillsammans med LZMA2 kan förbättra +komprimeringen med vissa filtyper. Till exempel, för att komprimera ett +delat x86\-32\- eller x86\-64\-bibliotek med filtret x86 BCJ: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libapa.so\fR +.fi +.RE +.PP +Observera att ordningen på filterflaggorna spelar roll. Om \fB\-\-x86\fP anges +efter \fB\-\-lzma2\fP kommer \fBxz\fP avge ett fel, eftersom det inte kan vara något +filter efter LZMA2, och även för att filtret x86 BCJ inte kan användas som +det sista filtret i kedjan. +.PP +Deltafiltret tillsammans med LZMA2 gan ge bra resultat med +bitkartebilder. Det bör vanligen slå PNG, som har några mer avancerade +filter än enkla delta men använder Deflat för den faktiska komprimeringen. +.PP +Bilden måste sparas i okomprimerat format, till exempel som okomprimerad +TIFF. Avståndsparametern i Deltafiltret sätts till att motsvara natalet byte +per bildpunkt i bilden. Till exempel, 24\-bitars RGB bitkarta behöver +\fBdist=3\fP, och det är även bra att skicka \fBpb=0\fP till LZMA2 för att ge +plats för trebytejustering: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 apa.tiff\fR +.fi +.RE +.PP +Om flera bilder har lagts in i ett gemensamt arkiv (till exempel, \fB.tar\fP) +kommer Deltafiltret fungera på det också så länge alla bilder har samma +antal byte per bildpunkt. +. +.SH "SE ÄVEN" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xz.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xz.1 new file mode 100644 index 0000000000000000000000000000000000000000..1fb596e1ab328783990b87c362f7f7761d73548e --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xz.1 @@ -0,0 +1,1954 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Swedish translation of xz-man +.\" Göran Uddeborg , 2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 2025\-03\-08 Tukaani "XZ Utils" +. +.SH NAMN +xz, unxz, xzcat, lzma, unlzma, lzcat — Komprimera eller dekomprimera .xz\- +och .lzma\-filer +. +.SH SYNOPSIS +\fBxz\fP [\fIflagga…\fP] [\fIfil…\fP] +. +.SH KOMMANDOALIAS +\fBunxz\fP är ekvivalent med \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP är ekvivalent med \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP är ekvivalent med \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP är ekvivalent med \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP är ekvivalent med \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +När man skriver skript som behöver dekomprimera filer rekommenderas det att +altid använda namnet \fBxz\fP mäd lämpliga argument (\fBxz \-d\fP eller \fBxz \-dc\fP) +istället för namnen \fBunxz\fP och \fBxzcat\fP. +. +.SH BESKRIVNING +\fBxz\fP är ett datakomprimeringsverktyg för allmänt bruk med en +kommandoradssyntax som liknar \fBgzip\fP(1) och \fBbzip2\fP(1). Det egna +filformatet är formatet \fB.xz\fP, men det föråldrade formatet \fB.lzma\fP som +anändes av LZMA\-verktyg och råa komprimerade strömmar utan huvuden för +behållarformatet stödjs också. Dessutom stödjs dekomprimering av formatet +\&\fB.lz\fP som används av \fBlzip\fP. +.PP +\fBxz\fP komprimerar och dekomprimerar varje \fIfil\fP i enlighet med det valda +arbetsläget. Om inga \fIfiler\fP anges eller \fIfil\fP är \fB\-\fP läser \fBxz\fP från +standard in och skriver den behandade datan på standard ut. \fBxz\fP kommer +vägra (visa ett felmeddelande och hoppa över \fIfilen\fP) att skriva +komprimerad data direkt till standard ut om det är en terminal. På samma +sätt kommer \fBxz\fP vägra att läsa komprimerade data från standard in om det +är en terminal. +.PP +Om inte \fB\-\-stdout\fP anges skrivs andra \fIfiler\fP än \fB\-\fP till en ny fil vars +namn härleds från käll\fIfilens\fP namn: +.IP \(bu 3 +Vid kompringering läggs suffixet till på målfilsformatet (\fB.xz\fP eller +\&\fB.lzma\fP) på slutet av källfilnamnet för att få målfilnamnet. +.IP \(bu 3 +Vid dekomprimering tas suffixet \fB.xz\fP, \fB.lzma\fP eller \fB.lz\fP bort från +filnamnet för att få målfilnamnet. \fBxz\fP känner även igen suffixen \fB.txz\fP +och \fB.tlz\fP, och ersätter dem med suffixet \fB.tar\fP. +.PP +Om målfilen redan finns visas ett felmeddelande och \fIfilen\fP hoppas över. +.PP +Utom när den skriver till standard ut kommer \fBxz\fP visa en varning och hoppa +över \fIfilen\fP om något av följande inträffar: +.IP \(bu 3 +\fIFil\fP är inte en vanlig fil. Symboliska länkar följs inte, och därför anses +de inte vara vanliga filer. +.IP \(bu 3 +\fIFil\fP har mer än en hård länk. +.IP \(bu 3 +\fIFil\fP har biten setuid, setgid eller sticky satt. +.IP \(bu 3 +Arbetsläget är satt till att komprimera och \fIfilen\fP har redan ett suffix +enligt målfilformatet (\fB.xz\fP eller \fB.txz\fP vid komprimering till formatet +\&\fB.xz\fP, och \fB.lzma\fP eller \fB.tlz\fP vid komprimering till formatet \fB.lzma\fP). +.IP \(bu 3 +Arbetsläget är satt till att dekomprimera och \fIfilen\fP har inte ett suffix +enligt något av de stödda filformaten (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP +eller \fB.lz\fP). +.PP +Efter att ha kunnat komprimera eller dekomprimera \fIfilen\fP kopierar \fBxz\fP +ägaren, gruppen, rättigheterna, åtkomsttiden och ändringstiden från +käll\fIfilen\fP till målfilen. Om kopieringen av grupp misslyckas ändras +rättigheterna så att målfilen inte blir åtkomlig för användare som inte har +rättigheter att komma åt käll\fIfilen\fP. \fBxz\fP stödjer inte kopiering av annan +metadata såsom åtkomststyrhingslistor eller utökade attribut ännu. +.PP +När målfilen har stängts framgångsrikt tas käll\fIfilen\fP bort såvida inte +\fB\-\-keep\fP angavs. Käll\fIfilen\fP tas aldrig bort om utdata skrevs till +standard ut eller om något fel inträffade. +.PP +Att skicka \fBSIGINFO\fP eller \fBSIGUSR1\fP till \fBxz\fP\-processen får den att +skriva ut förloppsinformation till standard fel. Detta är bara av begränsat +värde eftersom när standard fel går till en terminal så kommer användning av +\fB\-\-verbose\fP att skriva ut en automatiskt uppdaterande förloppsindikator. +. +.SS Minnesanvändning +\fBxz\fP:s minnesanvändning varierar från några få hundra kilobyte till flera +gigabyte beroende på komprimeringsinställningarna. Inställningen som +användes när en fil komprimerades avgör minnesbehovet hos +dekomprimeraren. Typiskt behöver dekomprimeraren 5\ % till 20\ % av +minnesbehovet som komprimeraren behöver när en fil skapas. Till exempel, att +dekomprimera en fil skapad med \fBxz \-9\fP kräver för närvarande 65\ MiB +minne. Ändå är det möjligt att ha \fB.xz\fP\-filer som behöver flera gigabyte +minne för att dekomprimeras. +.PP +Särskilt användare av äldre system kan finna möjligheten av väldigt stor +minnesanvändning störande. För att förhindra obehagliga överraskningar har +\fBxz\fP en inbyggd minnesanvändningsbegränsare, vilken är avaktiverad som +standard. Även om vissa operativsystem kan tillhandahålla möjligheter att +begränsa minnesanvändningen hos processer bedömdes det inte som flexibelt +nog att lita på det (till exempel, att använda \fBulimit\fP(1) för att begränsa +det virtuella minnet tenderar att hämma \fBmmap\fP(2). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Minnesanvändningsbegränsaren kan aktiveras med kommandoradsflaggan +\fB\-\-memlimit=\fP\fIgräns\fP. Ofta är det bekvämare att aktivera begränsaren som +standard genom att sätta miljövariabeln \fBXZ_DEFAULTS\fP, till exempel, +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Det är möjligt att sätta gränser separat +för komprimering och dekomprimering genom att använda +\fB\-\-memlimit\-compress=\fP\fIlimit\fP och \fB\-\-memlimit\-decompress=\fP\fIlimit\fP. Att +använda dessa två flaggor utanför \fBXZ_DEFAULTS\fP är sällan meningsfullt +eftersom en enskild körning av \fBxz\fP inte kan göra både komprimering och +dekomprimering och and \fB\-\-memlimit=\fP\fIgräns\fP (eller \fB\-M\fP \fIgräns\fP) är +kortare att skriva på kommandoraden. +.PP +Om den angivna minnesanvändningsgränsen överskrid vid dekomprimering kommer +\fBxz\fP visa ett fel och dekomprimeringen av filen misslyckas. Om gröensen +överskrids vid komprimering kommer \fBxz\fP försöka skala ner inställningen så +att gränsen inte längre överskrids (utom när \fB\-\-format=raw\fP eller +\fB\-\-no\-adjust\fP används). På detta sätt kommer åtgärden inte misslyckas om +inte gränsen är väldigt liten. Skalningen av inställningen görs i steg som +inte matchar de förinställda komprimeringsnivåerna, till exempel, om gränsen +endast är något mindre än den mängd som behövs till \fBxz \-9\fP kommer +inställningen bara skalas ner lite, inte hela vägen ner till \fBxz \-8\fP. +. +.SS "Konkatenering och utfyllnad av .xz\-filer" +Det är möjligt att konkatenera \fB.xz\fP\-filer som de är. \fBxz\fP kommer +dekomprimera sådana filer som om de vore en enda \fB.xz\fP\-fil. +.PP +Det är möjligt att infoga utfyllnad mellan de konkatenerade delarna eller +efter den sista delen. Utfyllnaden måste bestå av null\-bytear och storleken +på utfyllnaden måste vara en multipel av fyra byte. Detta kan vara +användbart, till exempel, om \fB.xz\fP\-filen lagras på ett medium som mäter +filstorlekar i 512\-byteblock. +.PP +Konkaternering och utfyllnad är inte tillåtet med \fB.lzma\fP\-filer eller råa +strömmar. +. +.SH FLAGGOR +. +.SS "Heltalssuffix och speciella värden" +På de flesta platser där ett heltalsargument förväntas stödjs ett frivilligt +suffix för att enkelt indikera stora heltal. Det får inte finnas något +mellanrumm mellan heltalet och suffixet. +.TP +\fBKiB\fP +Multiplicera heltalet med 1 024 (2¹⁰). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP och \fBKB\fP är +tillåtna som synomymer till \fBKiB\fP. +.TP +\fBMiB\fP +Multiplicera heltalet med 1 048 576 (2²⁰). \fBMi\fP, \fBm\fP, \fBM\fP och \fBMB\fP är +tillåtna som synomymer till \fBMiB\fP. +.TP +\fBGiB\fP +Multiplicera heltalet med 1 073 741 824 (2³⁰). \fBGi\fP, \fBg\fP, \fBG\fP och \fBGB\fP +är tillåtna som synonymer till \fBGiB\fP. +.PP +Specialvärdet \fBmax\fP kan användas för att indikera det maximala heltalet som +stödjs av flaggan. +. +.SS Arbetsläge +Om flera arbetslägesflaggor ges gäller den sista. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Komprimera. Detta är standardarbetsläget när ingen arbetslägesflagga anges +och inget annat arbetsläge impliceras från kommandonamnet (till exempel +implicerar \fBunxz\fP \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Efter lyckad komprimering källfilen bort såvida man inte skriver till +standard ut eller \fB\-\-keep\fP angavs. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Dekomprimera. Efter lyckad dekomprimering tas källfilen bort såvida man inte +skriver till standard ut eller \fB\-\-keep\fP angavs. +.TP +\fB\-t\fP, \fB\-\-test\fP +Testa integriteten hos komprimerade \fIfiler\fP. Denna flagga är ekvivalent med +\fB\-\-decompress \-\-stdout\fP förutom att den dekomprimerade datan slängs +istället för att skrivas på standard ut. Inga filer skapas eller tas bort. +.TP +\fB\-l\fP, \fB\-\-list\fP +Skriv information om komprimerade \fIfiler\fP. Inge dekomprimeringsutdata +skapas, och inga filer skapas eller tas bort. I listläge kan programmet inte +läsa komprimerad data från standard in eller från andra källor där man inte +kan söka. +.IP "" +Standardlistningen visar grundläggande information om \fIfiler\fP, en fil per +rad. För att få mer detaljerad information, använd även flaggan +\fB\-\-verbose\fP. För ännu mer information, använd \fB\-\-verbose\fP två gånger, men +observera att detta kan vara långsamt, eftersom det behövs många sökningar +får att samla all den extra informationen. Bredden av utförlig utdata +överskrider 80 tecken, så att skicka utdata i ett rör till, till exempel, +\fBless\ \-S\fP kan vara bekvämt om terminalen inte är bred nog. +.IP "" +Den exakta utdatan kan variera mellan versioner av \fBxz\fP och olika +lokaler. För maskinläsbar utdata bör \fB\-\-robot \-\-list\fP användas. +. +.SS Arbetsmodifierare +.TP +\fB\-k\fP, \fB\-\-keep\fP +Ta inte bort indatafilerna. +.IP "" +Från \fBxz\fP 5.2.6 gör denna flagga även att \fBxz\fP komprimerar eller +dekomprimerar även om indatan är en symbolisk länk till en normal fil, har +mer än en hård länk eller har biten setuid, setgid eller sticky +satt. Bitarna setuid, setgid och sticky kopieras inte till målfilen. I +tidigare versioner gjordes detta bara med \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Denna flagga har flera funktioner: +.RS +.IP \(bu 3 +Om målfilen redan finns, radera den före komprimering eller dekomprimering. +.IP \(bu 3 +Komprimera eller dekomprimera även om indatan är en symbolisk länk till en +normal fil, har mer än en hård länk eller har biten setuid, setgid eller +sticky satt. Bitarna setuid, setgid och sticky kopieras inte till målfilen. +.IP \(bu 3 +När den används med \fB\-\-decompress\fP \fB\-\-stdout\fP och \fBxz\fP inte känner igen +typen på källfilen, kopiera källfilen som den är till standard ut. Detta gör +att \fBxzcat\fP \fB\-\-force\fP kan användas som \fBcat\fP(1) för filer som inte har +komprimerats med \fBxz\fP. Observera att i framtiden kan \fBxz\fP komma att stödja +nya komprimeringsfilformat, vilket kan få \fBxz\fP att dekomprimera fler typer +av filer istället för att kopiera dem till standard ut. +\fB\-\-format=\fP\fIformat\fP kan användas för att begränsa \fBxz\fP till att +dekomprimera endast ett enda filformat. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Skriv den komprimerade eller dekomprimerade datan till standard ut istället +för en fil. Detta implicerar \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Dekomprimera endast den första \fB.xz\fP\-strömmen, och ignorera tys eventuella +återstående indata som följer efter strömmen. Normalt får sådant avslutande +skräp \fBxz\fP att visa ett fel. +.IP "" +\fBxz\fP dekomprimerar aldrig mer än en ström från \fB.lzma\fP\-filer eller råa +strömmar, men denna flagga gör ändå att \fBxz\fP ignorerar den möjliga +efterföljande datan efter \fB.lzma\fP\-filen eller den råa strömmen. +.IP "" +Denna flagga har ingen effekt om arbetsläget inte är \fB\-\-decompress\fP eller +\fB\-\-test\fP. +.IP "" +Sedan \fBxz\fP 5.7.1alpha, implicerar \fB\-\-single\-stream\fP \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Avaktivera att glesa filer skapas. Som standard, om den dekomprimerar till +en normal fil, försöker \fBxz\fP att göra filen gles om den dekomprimerade +datan innehåller långa sekvenser av binära nollor. Det fungerar även när den +skriver till standard ut så länga standard ut är kopplad till en normal fil +och vissa ytterligare villkor möts för att göra det säkert. Att skapa glesa +filer kan spara diskutrymme och snabba upp dekomprimeringen genom att +begränsa mängden disk\-I/O. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Vid komprimering, använd \fI.suf\fP som suffixet för målfilen istället för +\&\fB.xz\fP eller \fB.lzma\fP. Om den inte skriver till standard ut och källfilen +redan har suffixet \fI.suf\fP visas en varning och filen hoppas över. +.IP "" +Vid dekomprimering, känn igen filer med suffixet \fI.suf\fP utöver filer +medsuffixen \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP eller \fB.lz\fP. Om källfilen +har suffixet \fI.suf\fP tas suffixet bort för att få målfilnamnet. +.IP "" +Vid komprimering eller dekomprimering av råa strömmar (\fB\-\-format=raw\fP) +måste alltid suffixet anges om den inte skriver till standard ut, eftersom +det inte finns något standardsuffix för råa strömmar. +.TP +\fB\-\-files\fP[\fB=\fP\fIfil\fP] +Läs filnamnen att arbeta på från \fIfil\fP; om \fIfil\fP utelämnas läses filnamn +från standard in. Filnamn måste avslutas med nyradstecknet. Ett bindestreck +(\fB\-\fP) tas som ett vanligt filnamn; det betyder inte standard in. Om filnamn +även anges som kommandoradsargument, bearbetas de före filnamnen som läses +från \fIfil\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIfil\fP] +Detta är identiskt med \fB\-\-files\fP[\fB=\fP\fIfil\fP] förjutom att varje filnamn +måste avslutas med ett nulltecken. +. +.SS "Grundläggande flaggor för filformat och komprimering" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fIformat\fP +Angi filens \fIformat\fP att komprimera eller dekomprimera: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Detta är standard. Vid komprimering är \fBauto\fP ekvivalent med \fBxz\fP. Vid +dekomprimering detekteras automatiskt formatet på indatafilen. Observera att +råa strömmar (skapade med \fB\-\-format=raw\fP inte kan detekteras automatiskt. +.TP +\fBxz\fP +Komprimera till filformatet \fB.xz\fP, eller acceptera endast \fB.xz\fP\-filer vid +dekomprimering. +.TP +\fBlzma\fP, \fBalone\fP +Komprimera till det föråldrade filformatet \fB.lzma\fP, eller acceptera endast +\&\fB.lzma\fP\-filer fid dekomprimering. Det alternativa namnet \fBalone\fP +tillhandahålls för bakåtkompatibilitet med LZMA Utils. +.TP +\fBlzip\fP +Acceptera endast \fB.lz\fP\-filer vid dekomprimering. Komprimering stödjs inte. +.IP "" +\&\fB.lz\fP\-formatet version 0 och 1 stödjs. Version 0\-filer producerades av +\fBlzip\fP 1.3 och tidigare. Sådana filer är inte vanliga men kan hittas från +filarkiv eftersom några källpaket släpptes i detta format. Folk kan ha även +ha gamla personliga filer i detta format. Dekomprimeringsstöd för format +version 0 togs bort i \fBlzip\fP 1.18. \fBlzip\fP 1.4 och senare kan skapa filer i +formatversion 1. +.TP +\fBraw\fP +Komprimera eller dekomprimera en rå ström (inga huvuden). Detta är endast +avsett för avancerade användare. För att avkoda råa strömmar behöver man +använda \fB\-\-format=raw\fP och explicit angi filterkedjan, vilken normalt +skulle ha lagrats i behållarens huvuden. +.RE +.TP +\fB\-C\fP \fIkontroll\fP, \fB\-\-check=\fP\fIkontroll\fP +Ange typen av integritetskontroll. Kontrollen beräknas från den +dekomprimerade datan och lagras i \fB.xz\fP\-filen. Denna flagga har endast +någon inverkan när man komprimerar till formatet \fB.xz\fP; formatet \fB.lzma\fP +stödjer inte integritetskontroller. Integritetskontrollen (om någon) +verifieras när \fB.xz\fP\-filen dekomprimeras. +.IP "" +\fIKontroll\fPtyper som stödjs: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Beräkna inte någon integritetskontroll alls. Detta är normalt en dålig +idé. Det kan vara användbart när datans integritet ändå verifieras på andra +sätt. +.TP +\fBcrc32\fP +Beräkna CRC32 med polynomet från IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Beräkna CRC64 med polynomet från ECMA\-182. Detta är standard, eftersom det +är något bättre än CRC32 på att upptäcka skadade filer och +hastighetsskillnaden är försumbar. +.TP +\fBsha256\fP +Beräkna SHA\-256. Detta är något långsammare än CRC32 och CRC64. +.RE +.IP "" +Integriteten hos \fB.xz\fP\-huvuden verifieras alltid med CRC32. Det är inte +möjligt att ändra eller avaktivera det. +.TP +\fB\-\-ignore\-check\fP +Verifiera inte integritetskontrollen av den komprimerade datan vid +dekomprimering. CRC32\-värden i \fB.xz\fP\-huvudena kommer fortfarande verifieras +normalt +.IP "" +\fBAnvänd inte denna flagga om du inte vet vad du gör.\fP Möjliga anledningar +till att använda denna flagga: +.RS +.IP \(bu 3 +Försöka återvinna data från en trasig .xz\-fil. +.IP \(bu 3 +Snabba upp dekomprimering. Detta har störst betydelse med SHA\-256 eller med +filer som har komprimerats extremt mycket. Det rekommenderas att inte +använda denna flagga för detta ändamål om inte filintegriteten verifieras +externt på något annat sätt. +.RE +.TP +\fB\-0\fP … \fB\-9\fP +Välj en förinställningsnivå för komprimering. Standard är \fB\-6\fP. Om flera +förinställningsnivåer anges gäller den sist angivna. Om en anpassad +fileterkedja redan angivits gör en inställning av en förinställningsnivå för +komprimering att den anpassade filterkedjan töms. +.IP "" +Skillnaden mellan förinställningarna har större betydelse än med \fBgzip\fP(1) +och \fBbzip2\fP(1). Den valda komprimeringsinställningen avgör minneskraven för +dekomprimeraren, att använda en för hög förinställningsnivå kan alltså göra +det plågsamt att dekomprimera filer på ett gammalt system med lite +RAM. Specifikt \fBär det inte en bra ide att blint använda \-9 för allt\fP +liksom det ofta är med \fBgzip\fP(1) och \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP … \fB\-3\fP +Dessa är ganska snabba förinställningar. \fB\-0\fP är ibland snabbare än \fBgzip \-9\fP samtidigt som komprimeringen är mycket bättre. De högre har ofta +hastighet jämförbar med \fBbzip2\fP(1) med jämförbar eller bättre +komprimeringsförhållande, även om resultatet mycket beror på typen av data +som komprimeras. +.TP +\fB\-4\fP … \fB\-6\fP +Bra för väldigt god komprimering samtidigt som dekomprimerarens +minnesanvändning hålls rimlig även på gamla system. \fB\-6\fP är standardvärdet, +vilket vanligen är ett bra val för att distribuera filer so behöver +dekomprimeras även på ssytem med endast 16\ MiB RAM. (\fB\-5e\fP eller \fB\-6e\fP +kan också vara värda att överväga. Se \fB\-\-extreme\fP.) +.TP +\fB\-7 … \-9\fP +Dessa liknar \fB\-6\fP med med högre krav på minne till komprimerare och +dekomprimerare. Dessa är bara användbara vid komprimering av filer större än +8\ MiB, 16\ MiB respektive 32\ MiB. +.RE +.IP "" +På samma hårdvara är dekomprimeringshastigheten ungefär ett konstant antal +byt av komprimerad data per sekund. Med andra ord, ju bättre komprimering, +desto snabbare kommer dekomprimeringen vanligen vara. Detta betyder även att +mängden av okomprimerad utdata skapad per sekund kan variera mycket. +.IP "" +Följande tabell sammanfattar funktionerna hos förinställningarna: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Förinställning;LexStrl;KompCPU;KompMin;DekMin +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Kolumnbeskrivningar: +.RS +.IP \(bu 3 +LexStrl är storleken på LZMA2:s lexikon. Det är slöseri med minne att +använda ett större lexikon än storleken på den okomprimerade filen. Detta är +anledningen till att det är bra att undvika förinställningarna \fB\-7\fP … \fB\-9\fP +när det inte finns något verkligt behov av dem. På \fB\-6\fP och lägre är +mängden bortslösat minne vanligen litet nog att inte ha någon betydelse. +.IP \(bu 3 +KompCPU är en förenklad representation av LZMA2\-inställningar som påverkar +komprimeringshastigheten. Lexikonstorleken påverkar också hastigheten, så +medan KompCPU är samma för nivåerna \fB\-6\fP … \fB\-9\fP tenderar fortfarande högre +nivåer att vara lite långsmmare. För ännu långsammare och möjligen bättre +komprimering, se \fB\-\-extreme\fP. +.IP \(bu 3 +KompMem innehåller komprimerarens minneskrav i enkeltrådat läge. Det kan +variera något mellan versioner av \fBxz\fP. +.IP \(bu 3 +DekMin innehåller dekomprimerarens minneskrav. Det vill säga, komprimerarens +inställningar avgör minneskravet för dekomprimeraren. Den exakta +minnesanvändningen hos dekomprimeraren är något mer än +LZMA2\-lexikonstorleken, men värdena i tabellen har avrundats upp till nästa +nästa hela MiB. +.RE +.IP "" +Minneskravet för det multitrådade läget är signifikant högre än det för +enkeltrådat läge. Med standardvärdet på \fB\-\-block\-size\fP behöver varje tråd +3·3·LexStrl plus KompMin eller DekMin. Till exempel, fyra trådar med +förinställningen behöver 660\(en670 MiB minne. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Använd en långsammare variant av den valda förinställningsnivån för +komprimering (\fB\-0\fP … \fB\-9\fP) för att förhoppningsvis få lite bättre +komprimeringsförhållande, men med otur kan detta även göra det +sämre. Dekomprimerarens minnesanvändning påverkas inte, men komprimerarens +minnesanvändning ökar lite vid förinställningsnivåerna \fB\-0\fP … \fB\-3\fP. +.IP "" +Eftersom det finns två förinställningar med lexikonstorlekar 4\ MiB och 8\ MiB använder förinställningarna \fB\-3e\fP och \fB\-5e\fP något snabbare +inställningar (lägre KompCPU) än \fB\-4e\fP respektive \fB\-6e\fP. På det sättet är +inte två förinställningar identiska. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Förinställning;LexStrl;KompCPU;KompMin;DekMin +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Till exempel finns det totalt fyra förinställningar som använder 8\ MiB +lexikon, vars ordning från den snabbaste till den långsammaste är \fB\-5\fP, +\fB\-6\fP, \fB\-5e\fP och \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Dessa är något missledande alias för \fB\-0\fP respektive \fB\-9\fP. Dessa finns +endast för bakåtkompatibilitet med LZMA\-verktyg. Undvik att använda dessa +flaggor. +.TP +\fB\-\-block\-size=\fP\fIstorlek\fP +Vid komprimering till formatet \fB.xz\fP, dela indatai block med \fIstorlek\fP +bytes. Blocken komprimeras oberoende av varandra, vilket hjälper till vid +multitrådning och gör begränsad random\-access\-dekomprimering möjlig. Denna +flagga används typiskt för att åsidosätta blockstorleken i multitrådat läge, +men denna flagga kan användas även i enkeltrådat läge. +.IP "" +I multitrådat läge kommer ungefär tre gånger \fIstorlek\fP byte att allokeras i +varje tråd för buffring av indata och utdata. Standardvärdet på \fIstorlek\fP +är det större av tre gånger LZMA2\-lexikonstorleken eller 1 MiB. Typiskt är +ett bra värde 2\(en4 gånger storleken på LZMA2\-lexikonet eller åtminstone 1 +MiB. Att använda en \fIstorlek\fP mindre än LZMA2\-lexikonstorleken utgör +slöseri med RAM eftersom LZMA2\-lexikonbufferten då aldrig kommer användas +helt. I multitrådat läge lagras storlekarna på plocken i +blockhuvudena. Denna storleksinformation krävs för multitrådad +dekomprimering. +.IP "" +I singletrådat läge görs som standard ingen uppdelning i block. Att göra +denna inställning påverark inte minnesanvändningen. Ingen +storleksinformation lagras i blockhuvuden, därmed kommer filer som skapas i +enkeltrådat läge inte att vara identiska med filer skapade i multitrådat +läge. Avsaknaden av sotrleksinformation betyder också att \fBxz\fP inte kommer +kunna dekomprimera filerna i multitrådat läge. +.TP +\fB\-\-block\-list=\fP\fIposter\fP +Vid komprimering till formatet \fB.xz\fP, börja ett nytt block med en möjlig +anpassad filterkedja efter de angivna intervallen med okomprimerade data. +.IP "" +\fIPosterna\fP är en kommaseparerad lista. Varje post består av ett möjligt +filterkedjenummer mellan 0 och 9 följt av ett kolon (\fB:\fP) och en +obligatorisk storlek för okomprimerade data. Att utelämna en post (två på +varandra följande komman) är en kortform för att använda storleken och +filtren från föregående post. +.IP "" +Om indatafiler är större än summan av storlekarna i \fIposter\fP repeteras den +sista posten fram till slutet på filen. Ett speciellt värde \fB0\fP kan +användas som den sista storleken för att indikera att resten av filen skall +kodas som ett enda block. +.IP "" +En alternativ filterkedja för varje block kan anges i kombinaton med +flaggorna \fB\-\-filters1=\fP\fIfilter\fP \&…\& \fB\-\-filters9=\fP\fIfilter\fP. Dessa +flaggor definierar filterkedjor med en identifierare mellan +1\(en9. Filterkedja 0 kan användas för att referera till +standardfilterkedjan, vilket är samma sak som att inte ange någon +filterkedja. Filterkedjeidentifierare kan användas före den okomprimerade +sotrleken, följt av ett kolon (\fB:\fP). Till exempel, om man anger +\fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP kommer block skapas med: +.RS +.IP \(bu 3 +Filterkedjan angiven av \fB\-\-filters1\fP och 2 MiB indata +.IP \(bu 3 +Filterkedjan angiven av \fB\-\-filters3\fP och 2 MiB indata +.IP \(bu 3 +Filterkedjan angiven av \fB\-\-filters2\fP och 4 MiB indata +.IP \(bu 3 +Filterkedjan angiven av \fB\-\-filters2\fP och 4 MiB indata +.IP \(bu 3 +Standardfilterkedjan och 2 MiB indata +.IP \(bu 3 +Standardfilterkedjan och 4 MiB indata för varje block till slutet av indata. +.RE +.IP "" +Om man anger en storlek som överskrider kodarens blockstorlek (antingen +standardvärdet i trådat läge eller värdet som anges med +\fB\-\-block\-size=\fP\fIstorlek\fP) kommer kodaren skapa ytterligare block med +hänsyn taget till gränserna som anges i \fIposter\fP. Till exempel, om man +anger \fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP och +indatafilen är 80 MiB kommer man få 11 block: 5, 10, 8, 10, 2, 10, 10, 4, +10, 10 och 1 MiB. +.IP "" +I multitrådat läge lagras storleken på blocken i blockhuvudena. Detta görs +inte i enkeltrådat läge, så den kodade utdatan kommer inte vara identisk med +den från det multitrådade läget. +.TP +\fB\-\-flush\-timeout=\fP\fItidsgräns\fP +Vid komprimering, om mer än \fItidsgräns\fP millisekunder (ett positivt heltal) +har gått sedan den föregånde tömningen och en läsning av mer indata skulle +blockera töms all väntande indata från kodaren och görs tillgänglig i +utdataströmmen. Detta kan vara användbart om \fBxz\fP används för att +komprimera data som strömmas över ett nätverk. Små värden på \fItidsgräns\fP +gör data tillgänglig vid den mottagande änden med en liten fördröjning, men +större värden på \fItidsgräns\fP ger bättre komprimeringsförhållande. +.IP "" +Denna funktion är avaktiverad som standard. Om denna flagga anges mer än en +gång gäller den sista. Dett speciella värdet \fB0\fP på \fItidsgräns\fP kan +användas för att uttryckligen avaktivera denna funktion. +.IP "" +Denna funktion är inte tillgänglig på icke\-POSIX\-system. +.IP "" +.\" FIXME +\fBDenna funktion är fortfarande experimentell.\fP För närvarande är \fBxz\fP +olämplig för dekomprimering av strömmen i realtid på grund av hur \fBxz\fP +buffrar. +.TP +\fB\-\-no\-sync\fP +Synkronisera inte målfilen och dess katalog med lagringsenheten före +källfilen tas bort. Detta kan förbättra prestanda vid komprimering eller +dekomprimering av många små filer. Dock, om systemet kraschar snart efter +raderingen är det möjligt att målfilen inte skrevs till lagringsenheten men +att raderingen gjordes det. I det fallet är varken originalkällfilen eller +målfilen tillgänglig. +.IP "" +Denna flagga har bara någon effekt när \fBxz\fP kommer att ta bort källfilen. I +andra fall görs aldrig någon synkronisering. +.IP "" +Synkroniseringen och \fB\-\-no\-sync\fP lades till i \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIgräns\fP +Sätt en gräns på minnesanvändningen för komprimeringen. Om denna flaggan +anges flera gånger gäller den sista. +.IP "" +Om komprimeringsinställnigarna överskrider \fIgränsen\fP kommer \fBxz\fP försöka +justera inställningarna neråt så att gränsen inte längre överskrids och visa +en notis om att en automatisk justering gjorts. Justeringen görs i denna +ordning: reducera antalet trådar, byta till enkeltrådat läge om även en tråd +i multitrådat läge överskrider \fIgränsen\fP och slutligen reducera +LZMA2\-lexikonstorleken. +.IP "" +Vid komprimering med \fB\-\-format=raw\fP eller om \fB\-\-no\-adjust\fP har angetts kan +endast antalet trådar reduceras eftersom det kan göras utan att påverka den +komprimerade utdatan. +.IP "" +Om \fIgränsen\fP inte kan uppfyllas ens med justeringarna som beskrivs ovan +visas ett felmeddelande och \fBxz\fP kommer avsluta med slutstatus 1. +.IP "" +\fIGränsen\fP kan anges på flera sätt: +.RS +.IP \(bu 3 +\fIGränsen\fP kan vara ett absolut värde i byte. Att använda ett heltalssuffix +som \fBMiB\fP kan vara praktiskt. Exempel: \fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +\fIGränsen\fP kan anges som en procentsats av det totala fysiska minnet +(RAM). Detta kan vara användbart särskilt när man sätter miljövariabeln +\fBXZ_DEFAULTS\fP i ett skalinitieringsskript som delas mellan olika +datorer. På det sättet är gränsen automatiskt större på system med mer +minne. Exempel: \fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +\fIGränsen\fP kan återställas tillbaka till sitt standardvärde genom att sätta +den till \fB0\fP. Detta är för närvarande ekvivalent med att sätta \fIgränsen\fP +till \fBmax\fP (ingen gräns på minnesanvändning). +.RE +.IP "" +För 32\-bitars \fBxz\fP finns det ett specialfall: om \fIgränsen\fP skulle vara +över \fB4020\ MiB\fP sätts \fIgränsen\fP till \fB4020\ MiB\fP. På MIPS32 används +\fB2000\ MiB\fP istället. (Värdena \fB0\fP och \fBmax\fP påverkas inte av detta. En +liknande funktion finns inte för dekomprimering.) Detta kan hjälpa till när +ett 32\-bitarsprogram har tillgång till 4\ GiB adressrymd (2 GiB på MIPS32) +förhoppningsvis utan att göra någon skada i andra situationer. +.IP "" +Se även avsnittet \fBMinnesanvändning\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIgräns\fP +Sätt en gräns för minnesanvnändningen vid dekomprimering. Detta påverkar +även läget \fB\-\-list\fP. Om åtgärden inte är möjlig utan att överskrida +\fIgränsen\fP kommer \fBxz\fP visa ett felmeddelande och dekomprimeringen av filen +kommer misslyckas. Se \fB\-\-memlimit\-compress=\fP\fIgräns\fP för möjliga sätt att +ange \fIgränsen\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIgräns\fP +Sätt en gräns för minnesanvändningen för multitrådad dekomprimering. Detta +kan endast påverka antalet trådar; det kommer aldrig att få \fBxz\fP att vägra +att dekomprimera en fil. Om \fIgränsen\fP är för låg för att tillåta någon +multitrådning ignoreras \fIgränsen\fP och \fBxz\fP kommer gå vidare i enkeltrådat +läge. Observera att om även \fB\-\-memlimit\-decompress\fP används kommer det +alltid att gälla både enkeltrådat och multitrådat läge, och därmed kommer +den gällande \fIgränsen\fP för multitrådning aldrig vara högre än gränsen som +sätts med \fB\-\-memlimit\-decompress\fP. +.IP "" +Till skillnad mot de andra flaggorna för gränser för minnesanvändning har +\fB\-\-memlimit\-mt\-decompress=\fP\fIgräns\fP en systemspecifik +standard\fIgräns\fP. \fBxz \-\-info\-memory\fP kan användas för att se det aktuella +värdet. +.IP "" +Denna flagga och dess standardvärde finns för att utan någon gräns skulle +den trådade dekomprimeraren kunna allokera en vansinnig mängd minne med +några indatafiler. Om standard\fIgränsen\fP är för låg på ditt system, öka då +gärna \fIgränsen\fP men sätt den aldrig till ett större värde än mängden +användbart RAM eftersom att med passande indatafiler kommer \fBxz\fP försöka +använda den mängden av minne även med ett lågt antal trådar. Att få slut på +minne ller växling kommer inte förbättra dekomprimeringsprestandan. +.IP "" +Se \fB\-\-memlimit\-compress=\fP\fIgräns\fP för möjliga sätt att ange \fIgränsen\fP. Att +sätta \fIgräns\fP till \fB0\fP återställer \fIgränsen\fP till sdet systemspecifika +standardvärdet. +.TP +\fB\-M\fP \fIgräns\fP, \fB\-\-memlimit=\fP\fIgräns\fP, \fB\-\-memory=\fP\fIgräns\fP +Detta är ekvivalent med att ange \fB\-\-memlimit\-compress=\fP\fIgräns\fP +\fB\-\-memlimit\-decompress=\fP\fIgräns\fP \fB\-\-memlimit\-mt\-decompress=\fP\fIgräns\fP. +.TP +\fB\-\-no\-adjust\fP +Visa ett fel och avsluta om gränsen för minnesanvändning inte kan mötas utan +att justera inställnigar som påverkar den komprimerade utdatan. Det vill +säga, detta förhindrar att \fBxz\fP byter kodaren från multitrådat läge till +enkeltrådat läge och från att den reducerar LZMA2\-lexikonets storlek. Även +när denna flagga används kan antalet trådar reduceras för att möta gränsen +för minnesanvändning eftersom det inte kommer påverka den komprimerade +utdatan. +.IP "" +Automatisk justering är alltid avaktiverat när råa strömmar skapas +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fItrådar\fP, \fB\-\-threads=\fP\fItrådar\fP +Ange antalet arbetstrådar som skall användas. Att sätta \fItrådar\fP till ett +specialvärde \fB0\fP gör att \fBxz\fP använder så många trådar som processorerna +på systemet stödjer. Det aktuella antalet trådar kan vara färre än \fItrådar\fP +om indatafilen inte är stor nog för trådning med de givna inställningarna +eller om användning av fler trådar skulle överkrida gränsen för +minnesanvändning. +.IP "" +De enkeltrådade och multitrådade komprimerarna producerar olika utdata. Den +enkeltrådade komprimeraren kommer ge den minsta filstorleken men endast +utdata från den multitrådade komprimeraren kan dekomprimeras med flera +trådar. Att sätta \fItrådar\fP till \fB1\fP kommer använda enkeltrådat läge. Att +sätta \fItrådar\fP till något annat värde, inklusive \fB0\fP, kommer använda den +multitrådade komprimeraren även om systemet endast stödjer en hårdvarutråd. +(\fBxz\fP 5.2.x använde enkeltrådat läge i denna situation.) +.IP "" +För att använda multitrådat läge med endast en tråd, sätt \fItrådar\fP till +\fB+1\fP. Prefixet \fB+\fP har ingen påvrekan för andra värden än \fB1\fP. En gräns +för minnesanvändning kan fortfarande göra att \fBxz\fP byter till enkeltrådat +läge såvida inte \fB\-\-no\-adjust\fP används. Stöd för prefixet \fB+\fP lades till i +\fBxz\fP 5.4.0. +.IP "" +Om ett automatiskt antal trådar har begärts och ingen gräns för +minnesanvändning har angivits, då kommer en systemspecifik mjuk +standardgräns användas för att möjligen begränsa antalet trådar. Det är en +mjuk gräns i den meningen att den ignoreras om antalet trådar blir en, +alltså kommer en mjuk gräns aldrig hindra \fBxz\fP från att komprimera eller +dekomprimera. Denna mjuka standardgräns kommer inte göra att \fBxz\fP byter +från multitrådat läge till enkeltrådat läge. De aktiva gränserna kan ses med +\fBxz \-\-info\-memory\fP. +.IP "" +För närvarande är den enda trådningsmetoden att dela indata i block och +komprimera dem oberoende av varandra. Standardstorleken på block beror på +komprimeringsnivån och kan åsidosättas med flaggan +\fB\-\-block\-size=\fP\fIstorlek\fP. +.IP "" +Trådad dekomprimering fungerar bara på filer som innehåller flera block med +storleksinformation i blockhuvuden. Alla tillräckligt stora filer +komprimeras i multitrådat läge för att uppfylla detta villkor, men filer +komprimerade i enkeltrådat läge gör det inte ens om +\fB\-\-block\-size=\fP\fIstorlek\fP har använts. +.IP "" +Standardvärdet på \fItrådar\fP är \fB0\fP. I \fBxz\fP 5.4.x och tidigare är +standardvärdet \fB1\fP. +. +.SS "Anpassade komprimerarfilterkedjor" +Med en anpassad filterkedja kan man specificera kompressionsinställningarna +i detalj istället för att lita på inställningarna som hör till +förinställningarna. När en anpassad filterkedja anges glöms +förinställningsflaggor (\fB\-0\fP \&…\& \fB\-9\fP och \fB\-\-extreme\fP) tidigare på +kommandoraden. Om en förinställningsflagga anges efter en eller flera +flaggor för anpassade filterkedjor gäller den nya förinställningen och de +flaggor för anpassade filterkedjor som angivits tidigare glöms. +.PP +En filterkedja är jämförbar med att skapa rör på kommando. Vid komprimering +skickas den okomprimerade indatan till det första filtret, vars utdata +skickas till nästa filter (om något). Utdatan från det sista filtret blir +skrivet till den komprimerade filen. Det maximala antalet filter i kedjan är +fyra, men typiskt har en filterkedja bara ett ellet två filter. +.PP +Många filter har begränsningar på var de kan finnas i filterkedjan: några +filter kan bara fungera som det sista filtret i kedjan, några bara om de +inte är det sista filtret, och några fungerar i godtycklig position i +kedjan. Beroende på filtret är denna begränsning antingen en egenskap hos +filterdesignen eller finns för att förhindra säkerhetsproblem. +.PP +En anpassad filterkedja kan anges på två olika sätt. Med flaggorna +\fB\-\-filters=\fP\fIfilter\fP och \fB\-\-filters1=\fP\fIfilter\fP \&…\& +\fB\-\-filters9=\fP\fIfilter\fP kan man ange en hel filterkedja med en flagga genom +att använda syntaxen för liblzma\-filtersträngar. Alternativt kan en +filterkedja anges genom att använda en eller flera individuella +filterflaggor i den ordning de önskas i filterkedjan. Det vill säga, +ordningen på de individuella filterflaggorna är signifikant! Vid avkodning +av råa strömmar (\fB\-\-format=raw\fP) måste filterkedjan anges i samma ordning +som den specificerades vid komprimeringen. Eventuella individuella filter\- +eller förinstiällningsflaggor angivna före den fullständiga +filterkedjeflaggan (\fB\-\-filters=\fP\fIfilter\fP) kommer glömmas. Individuella +filter som anges efter den flaggan för en full kedja kommer återställa +filterkedjan. +.PP +Både den fullständiga och de individuella filterflaggorna tar +filterspecifika \fIflaggor\fP som en kommaseparerad lista. Extra komman +\fIflaggor\fP ignoreras. Varje flagga har ett standardvärde, så ange dem du +vill ändra. +.PP +För att se hela filterkedjan och \fIflaggor\fP, använd \fBxz \-vv\fP (det vill +säga, använd \fB\-\-verbose\fP två gånger). Detta fungerar även för att se +flaggorna för filterkedjor som används av förinställningar. +.TP +\fB\-\-filters=\fP\fIfilter\fP +Ange den fullständiga filterkedan eller en förinställning en en enda +flagga. Varje filter kan separeras med blanktecken eller två bindestreck +(\fB\-\-\fP). \fIfilter\fP kan behöva citeras på skalets kommandorad så att det +tolkas som en enda flagga. För att beteckna \fIflaggor\fP, använd \fB:\fP eller +\fB=\fP. En förinställning kan föregås med ett \fB\-\fP och följas av noll eller +flera flaggor. Den enda flaggan som stödjs är \fBe\fP för att tillämpa samma +flaggor som \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIfilter\fP … \fB\-\-filters9\fP=\fIfilter\fP +Ange upp till nio ytterligare filterkedjor som kan användas med +\fB\-\-block\-list\fP. +.IP "" +Till exempel, vid komprimering av ett arkiv med körbara filer följt av +textfiler skulle den körbara delen kunna använda en filterkedja med ett +BCJ\-filter och endast textdelen med LZMA2\-filtret. +.TP +\fB\-\-filters\-help\fP +Visa ett hjälpmeddelande som beskriver hur man anger förinställningar och +anpassade filterkedjor i flaggorna \fB\-\-filters\fP och \fB\-\-filters1=\fP\fIfilter\fP +\&…\& \fB\-\-filters9=\fP\fIfilter\fP, och avsluta rent. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIflaggor\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIflaggor\fP] +.PD +Lägg till LZMA1\- eller LZMA2\-filter till filterkedjan. Dessa filter kan +endast användas som det sista filtret i kedjan. +.IP "" +LZMA1 är ett föråldrat filter, vilket stödjs nästan enbart på grund av det +föråldrade filformatet \fB.lzma\fP, vilket bara stödjer LZMA1. LZMA2 är en +uppdaterad version av LZMA1 för att lösa några praktiska problem med +LZMA1. Formatet \fB.xz\fP använder LZMA2 och stödjer inte LZMA1 +alls. Komprimeringshastigheten och förhållandena för LZMA1 är LZMA2 är +praktiskt taget desamma. +.IP "" +LZMA1 och LZMA2 delar samma uppättning \fIflaggor\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIförinställning\fP +Återställ alla LZMA1\- eller LZMA2\-\fIflaggor\fP till +\fIförinställning\fP. \fIFörinställning\fP består av ett heltal, vilket kan följas +av enskilda bokstäver som modifierar förinställningen. Heltalet kan vara +från \fB0\fP till \fB9\fP, motsvarande kommandoradsflaggorna \fB\-0\fP \&…\& +\fB\-9\fP. Den enda modifierare som stödjs för närvarande är \fBe\fP, vilket +motsvarar \fB\-\-extreme\fP. Om ingen \fBpreset\fP anges tas standardvärden på +LZMA1\- eller LZMA2\-\fIflaggor\fP från förinställningen \fB6\fP. +.TP +\fBdict=\fP\fIstorlek\fP +Ett lexikons (historiebufferts) \fIstorlek\fP indikerar hur många byte med +nyligen bearbetad okomprimerad data som hålls i minnet. Algoritmen försöker +hitta återkommande bytesekvenser (matchningar) i den okomprimerade datan, +och ersätta dem med referenser till datan som för närvarande finns i +lexikonet. Ju större lexikon, desto högre är sannolikheten att hitta en +matchning. Att öka lexikonets \fIstorlek\fP förbättrar alltså vanligen +komprimeringsförhållandet, men ett lexikon som är större än den +okomprimerade filen är ett slöseri med minne. +.IP "" +En typisk \fIstorlek\fP på lexikon är från 64\ KiB till 64\ MiB. Minimum är 4\ KiB. Det maximala för komprimering är för närvarande 1,5\ GiB (1536\ MiB). Dekomprimeraren stödjer redan lexikon upp till en byte mindre än 4\ GiB, vilket är det maximala för strömformaten LZMA1 och LZMA2. +.IP "" +Lexikon\fIstorlek\fP och matchhittaren (\fImf\fP) avgör tillsammans +minnesanvändningen för LZMA1\- eller LZMA2\-kodaren. Ett lika \fIstort\fP (eller +större) lexikon behövs för dekomprimering som det som användes vid +komprimeringen, minnesanvändningen för avkodaren avgörs alltså av +lexikonstorleken vid komprimering. Huvudena i \fB.xz\fP innehåller lexikonets +\fIstorlek\fP antingen som 2^\fIn\fP eller 2^\fIn\fP + 2^(\fIn\fP\-1), så dessa +\fIstorlekar\fP är lite att föredra för komprimering. Andra \fIstorlekar\fP kommer +avrundas uppåt när de lagras i huvuden i \fB.xz\fP. +.TP +\fBlc=\fP\fIlk\fP +Ange antalet literala kontextbitar. Minimum är 0 och maximum är 4; +standardvärdet är 3. Dessutom får inte summan av \fIlk\fP och \fIlp\fP överskrida +4. +.IP "" +Alla byte som inte kan kodas som matchningar kodas som literaler. Det vill +säga, literaler är helt enkelt 8\-bits byte som kodas en åt gången. +.IP "" +Den literala kodningen gör antagandet att de högsta \fIlk\fP bitarna av den +föregående okomprimerade byten korrelerar med nästa byte. Till exempel, i +typisk engelsk text följs ofta en versal bokstav av en gemen bokstav, och en +gemen bokstav följs vanligen av en annan gemen bokstav. I +teckenuppsättningen US\-ASCII är de högsta tre bitarna 010 för versala +bokstäver och 011 för gemena bokstäver. När \fIlk\fP är åtminstone 3 kan den +literala kodningen dra nytta av denna egenskap i den okomprimerade datan. +.IP "" +Standardvärdet (3) är normalt bra. Om man vill ha maximal komprimering, +prova \fBlc=4\fP. Ibland hjälper det lite, och ibland gör det komprimeringen +sämre. Om det gör den sämre, testa också \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Ange antalet literala positionsbitar. Minimum är 0 och maximum är 4; +standardvärdet är 0. +.IP "" +\fILp\fP påverkar vilken sorts justering i den okomprimerade datan som antas +vid kodning av literaler. Se \fIpb\fP nedan för mer information om justering. +.TP +\fBpb=\fP\fIpb\fP +Ange antalet positionsbitar. Minimum är 0 och maximum är 4; standardvärdet +är 2. +.IP "" +\fIPb\fP påverkar vilken sort justering i den okomprimerade datan som antas i +allmänhet. Standardvärdet betyder fyrbytejustering (2^\fIpb\fP=2^2=4), vilket +ofta är ett bra val när det inte finns någon bättre gissning. +.IP "" +När justeringen är känd kan en inställning av \fIpb\fP därefter reducera +filstorleken något. Till exempel, med textfiler som har en\-byte\-justering +(US\-ASCII, ISO\-8859\-*, UTF\-8) kan att sätta \fBpb=0\fP förbättra komprimeringen +något. För UTF\-16\-text är \fBpb=1\fP ett bra val. Om justeringen är ett udda +tal som 3 byte kan \fBpb=0\fP vara det bästa valet. +.IP "" +Även om den antagna justeringen kan anpassas med \fIpb\fP och \fIlp\fP föredrar +LZMA1 och LZMA2 ändå något 16\-byte\-justering. Det kan vara värt att ta med i +beräkningen vid design av filformat som sannolikt ofta kan komma att +komprimeras med LZMA1 eller LZMA2. +.TP +\fBmf=\fP\fIms\fP +Matchsökaren har en stor poverkan på kodarens hastighet, minnesanvändning +och komprimeringsförhållande. Vanligen är Hashkedje\-matchsökare snabbare än +Binärträdsmatchsökare. Standardvärdet beror på \fIföinställningen\fP: 0 +använder \fBhc3\fP, 1\(en3 använder \fBhc4\fP, och resten använder \fBbt4\fP. +.IP "" +Följande matchsökare stödjs. Formlerna för minnesanvändning nedan är grova +uppskattningar, vilka är närmast sanningen när \fIdict\fP är en tvåpotens. +.RS +.TP +\fBhc3\fP +Hashkedja med 2\- och 3\-bytehashning +.br +Minsta värde på \fInice\fP: 3 +.br +Minnesanvändning: +.br +\fIdict\fP · 7.5 (om \fIdict\fP ≤ 16 MiB); +.br +\fIdict\fP · 5,5 + 64 MiB (om \fIdict\fP > 16 MiB) +.TP +\fBhc4\fP +Hashkedja med 2\-, 3\- och 4\-bytehashning +.br +Minsta värde på \fInice\fP: 4 +.br +Minnesanvändning: +.br +\fIdict\fP · 7,5 (om \fIdict\fP ≤ 32 MiB); +.br +\fIdict\fP · 6,5 (om \fIdict\fP > 32 MiB) +.TP +\fBbt2\fP +Binärträd med 2\-bytehashning +.br +Minsta värde på \fInice\fP: 2 +.br +Minnesanvändning: \fIdict\fP · 9,5 +.TP +\fBbt3\fP +Binärträd med 2\- och 3\-bytehashning +.br +Minsta värde på \fInice\fP: 3 +.br +Minnesanvändning: +.br +\fIdict\fP · 11,5 (om \fIdict\fP ≤ 16 MiB); +.br +\fIdict\fP · 9,5 + 64 MiB (om \fIdict\fP > 16 MiB) +.TP +\fBbt4\fP +Binärträd med 2\-, 3\- och 4\-bytehashning +.br +Minsta värde på \fInice\fP: 4 +.br +Minnesanvändning: +.br +\fIdict\fP · 11,5 (om \fIdict\fP ≤ 32 MiB); +.br +\fIdict\fP · 10,5 (om \fIdict\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fIläge\fP +Komprimerings\fIläget\fP anger metoden som används för att analysera data +skapade av matchsökaren. De \fIlägen\fP som stödjs är \fBfast\fP och +\fBnormal\fP. Standardvärdet är \fBfast\fP för \fIförinställningarna\fP 0\(en3 och +\fBnormal\fP för \fIförinställningarna\fP 4\(en9 +.IP "" +Vanligen används \fBfast\fP med Hashkedjematchsökare och \fBnormal\fP med +Binärträdsmatchsökare. Detta är även vad \fIförinställningarna\fP gör. +.TP +\fBnice=\fP\fIlagom\fP +Ange vad som anses vara en lagom längt på en matchning. När en matchning på +åtminstone \fIlagom\fP byte hittats slutar algoritmen söka efter möjliga bättre +matchningar. +.IP "" +\fILagom\fP kan vara 2\(en273 byte. Högre värden tenderar att ge bättre +komprimeringsförhållande på bekostnad av tid. Standardvärdet beror på +\fIförinställningen\fP. +.TP +\fBdepth=\fP\fIdjup\fP +Ange det maximala sökdjupet i matchsökaren. Standardvärdet är specialvärdet +0, vilket får komprimeraren att avgöra ett lämpligt \fIdjup\fP från \fImf\fP och +\fInice\fP. +.IP "" +Lämpligt \fIdjup\fP för Hashkedjor är 4\(en100 och 16\(en1000 för +Binärträd. Att använda väldigt höga värden på \fIdjup\fP kan göra kodaren +extremt långsam för vissa filer. Undvik att sätta \fIdjup\fP över 1000 såvida +du inte är beredd att avbryta komprimeringen om den tar för lång tid. +.RE +.IP "" +Vid avkodning av råa strömmar (\fB\-\-format=raw\fP) behöver LZMA2 endast +lexikonets \fIstorlek\fP. LZMA1 behöver även \fIlc\fP, \fIlp\fP och \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIflaggor\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIflaggor\fP] +.PD +Lägg till gren/anrop/hopp\-filter (branch/call/jump, BCJ) till +filterkedjan. Dessa filter kan inte användas som det sista filtret i +filterkedjan. +.IP "" +Ett BCJ\-filter konverterar relativa adresser i maskinkod till deras absoluta +motsvarigheter. Detta ändrar inte storleken på datan men det ökar +redundansen, vilket kan hjälpa LZMA2 att skapa 0\(en15\ % mindre +\&\fB.xz\fP\-filer. BCJ\-filtren är alltid reversibla, så att använda ett +BCJ\-filter för fel sorts data orsakar inte någon dataförlust, men det kan +göra komprimeringsförhållandet något sämre. BCJ\-filtren är mycket snabba +och använder en obetydling mängd minne. +.IP "" +Dessa BCJ\-filter har kända problem kopplade till komprimeringsförhållandet: +.RS +.IP \(bu 3 +Någr sortes filer som innehåller körbar kod (till exempel, objektfiler, +statiska bibliotek och Linux kärnmoduler) har adresserna i instruktionerna +fyllda med utfyllnadsvärden. Dessa BCJ\-filter kommer ändå göra +adresskonverteringen, vilket kommer göra komprimeringen sämre för dessa +filer. +.IP \(bu 3 +Om ett BCJ\-filter används på ett arkiv är det möjligt att det gör +komprimeringsförhållandet sämre än att inte använda något BCJ\-filter. Till +exempel, om det finns liknande eller till och med identiska körbara kommer +filtreringen sannolikt göra filerna mindre lika och därmed blir +kompressionen sämre. Innehållet i icke körbara filer i samma arkiv kan också +spela en roll. I praktiken måste man prova med och utan ett BCJ\-filter för +att se vilket som är det bästa i varje situation. +.RE +.IP "" +Olika instruktionsuppsättningar har olika justering: den körbara filen måste +vara justerad till en multipel av detta värde i indata för att filtret skall +fungera. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filter;Justering;Kommentarer +x86;1;32\-bitars eller 64\-bitars x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096\-bytesjustering är bäst +PowerPC;4;Endast rak byteordning +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Eftersom BCJ\-filtrerad data vanligen komprimeras med LZMA2 kan +komprimeringsförhållandet förbättras något om LZMA2\-flaggorna sätts till att +matcha justeringen hos det valda BCJ\-filtret. Exempel: +.RS +.IP \(bu 3 +IA\-64\-filter har 16\-bytejustering så \fBpb=4,lp=4,lc=0\fP är bra med LZMA2 +(2⁴=16). +.IP \(bu 3 +RISC\-V\-kod har 2\-byte\- eller 4\-bytejustering beroende på huruvida filen +innehåller 16\-bitars komprimerade instruktioner (utvidgningen C). När +16\-bitarsinstruktioner används är \fBpb=2,lp=1,lc=3\fP eller \fBpb=1,lp=1,lc=3\fP +bra. När det inte finns några 16\-bitsinstruktioner är \fBpb=2,lp=2,lc=2\fP +bäst. \fBreadelf \-h\fP kan användas för att kontrollera om ”RVC” förekommer på +raden ”Flaggor”. +.IP \(bu 3 +ARM64 är alltid 4\-bytejusterad så \fBpb=2,lp=2,lc=2\fP är bäst. +.IP \(bu 3 +Filtret x86 är ett undantag. Det är normalt bra att hålla sig till LZMA2:s +standardvärden (\fBpb=2,lp=0,lc=3\fP) när körbar x86 komprimeras. +.RE +.IP "" +Alla BCJ\-filter stödjer samma \fIflaggor\fP: +.RS +.TP +\fBstart=\fP\fIavstånd\fP +Ange start\fIavståndet\fP som används vid konvertering mellan relativa och +absoluta adresser. \fIAvståndet\fP måste vara en multipel av filtrets justering +(se tabellen ovan). Standardvärdet är noll. I praktiken är standardvärdet +bra; det är nästan aldrig användbart att ange ett anpassat \fIavstånd\fP. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIflaggor\fP] +Lägg till Deltafiltret till filterkedjan. Deltafiltret kan inte användas som +det sista filtret i filterkedjan. +.IP "" +För närvarande stödjs bara enkel byte\-vis deltaberäkning. Det kan vara +användbart vid komprimering, till exempel av okomprimerade +bitavbildningsbilder eller okomprimerad PCM\-audio. Dock kan algoritmer för +särskilda ändamål ge betydligt bättre resultat än Delta + LZMA2. Detta är +särskilt sant med audio, vilket komprimerar snabbare och bättre med till +exempel \fBflac\fP(1). +.IP "" +Stödda \fIflaggor\fP: +.RS +.TP +\fBdist=\fP\fIavstånd\fP +Ange \fIavståndet\fP för deltaberäkningen i byte. \fIAvstånd\fP måste varea +1\(en256. Standardvärdet är 1. +.IP "" +Till exempel, med \fBdist=2\fP och åtta byte indata A1 B1 A2 B3 A3 B5 A4 B7, +kommer utdata vara A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Andra flaggor" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Utelämna varningar och noteringar. Ange detta två gånger för att även +utelämna felmeddelandet. Denna flagga har ingen påverkan på +slutstatusen. Det vill säga, även om en varning utelämnades kommer +slutstatusen fortfarandeindikera att en varning gavs. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Var utförlig. Om standard fel är kopplat till en terminal kommer \fBxz\fP visa +en förloppsmätare. Att ange \fB\-\-verbose\fP två gånger kommer ge än mer +utförlig utmatning. +.IP "" +Förloppsmätaren visar följande information: +.RS +.IP \(bu 3 +Procent färdigt visas om storleken på indatafilen är känd. Det vill säga, +procentsatsen kan inte visas i rör. +.IP \(bu 3 +Mängd komprimerad data som producerats (komprimering) eller konsumerats +(dekomprimering). +.IP \(bu 3 +Mängd okomprimerad data som konsumerats (komprimering) eller producerats +(dekomprimering). +.IP \(bu 3 +Komprimeringsförhållande, vilket beräknas genom att dividera mängden +komprimerad data bearbetad så lång med mängde okomprimerad data bearbetad så +långt. +.IP \(bu 3 +Kompressions eller dekompressionshastighet. Detta mäts som mängden +okomprimerad data konsumerad (komprimering) eller producerad +(dekomprimering) per sekund. Det visas efter att några sekunder har gåt +efter att \fBxz\fP började bearbeta filen. +.IP \(bu 3 +Förfluten tid på formatet MM:SS eller H:MM:SS. +.IP \(bu 3 +Beräknad återstående tid visas endast när storleken på indatafilen är känd +och några sekunder redan gått efter att \fBxz\fP började bearbeta filen. Tiden +visas i ett mindre precist format vilket aldrig har några kolon, till +exempel, 2 min 30 s. +.RE +.IP "" +När standard fel inte är en terminal kommer \fB\-\-verbose\fP göra att \fBxz\fP +skriver filnamnet, komprimerad storlek, okomprimerad storlek, +komprimeringsförhållande och möjligen även hastigheten och den förlupna +tiden på en enda rad till standard fel efter att ha komprimerat eller +dekomprimerat filen. Hastigheten och den förlupna tiden inkluderas endast +när åtgärden tog åtminstone några sekunder. Om åtgärden inte slutfördes, +till exempel för att användaren avbröt, skrivs även den fullbordade +procentsatsen om storleken på indatafilen är känd. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Sätt inte slutstatus till 2 även om ett tillstånd som är värt en varning +upptäcktes. Denna flagga påverkar inte utförlighetsnivån, allts måste både +\fB\-\-quiet\fP och \fB\-\-no\-warn\fP användas för att inte visa varningar och för att +inte ändra slutstatusen. +.TP +\fB\-\-robot\fP +Skriv meddelanden i maskinläsbart form. Detta är avsett att förenkla att +skriva framändar som vill använda \fBxz\fP istället för liblzma, vilken kan +vara fallet i olika skript. Utdatan med denna flagga aktiverad är avsedd att +vara stabil mellan utgåvor av \fBxz\fP. Se avsnitett \fBROBOTLÄGE\fP för detaljer. +.TP +\fB\-\-info\-memory\fP +Visa, på mänskligt läsbar form, hur mycket fysiskt minne (RAM) och hur många +processortrådar \fBxz\fP tror att systemet har och gränserna för +minnesanvändning vid komprimering och dekomprimering, och avsluta. +.TP +\fB\-h\fP, \fB\-\-help\fP +Visa ett hjälpmeddelande som beskriver de vanligast använda flaggorna, och +avsluta. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Visa ett hjälpmeddelande som beskriver alla funktioner i \fBxz\fP, och avsluta +.TP +\fB\-V\fP, \fB\-\-version\fP +Visa versionsnumret för \fBxz\fP och liblzma i mänskligt läsbar form. För att +få maskinläsbar utdata, ange \fB\-\-robot\fP före \fB\-\-version\fP. +. +.SH ROBOTLÄGE +Robotläget aktiveras med flaggan \fB\-\-robot\fP. Det gör att utdata från \fBxz\fP +är enklare att tolka av andra program. För närvarande stödjs \fB\-\-robot\fP +endast tillsammans med \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP och +\fB\-\-version\fP. Den kommer att stödjas för komprimering och dekomprimering i +framtiden. +. +.SS Listläge +\fBxz \-\-robot \-\-list\fP använder tab\-separerad utmatning. Första kolumnen av +varje rad har en sträng som indikerar typen av informationen som finns på +den raden: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Detta är alltid första raden när en fil börjar listas. Den andra kolumen på +raden är filnamnet. +.TP +\fBfile\fP +Denna rad innehåller övergripande information om \fB.xz\fP\-filen. Denna rad +skrivs alltid efter raden \fBname\fP. +.TP +\fBstream\fP +Denna radtyp används endast när \fB\-\-verbose\fP angetts. Det finns lika många +\fBstream\fP\-rader som det finns strömmar i \fB.xz\fP\-filen. +.TP +\fBblock\fP +Denna radtyp används bara när \fB\-\-verbose\fP angetts. Det finns lika många +\fBblock\fP\-rader som det finns block i \fB.xz\fP\-filen. \fBblock\fP\-rader visas +efter alla \fBstream\fP\-raderna; olika radtyper blandas inte. +.TP +\fBsummary\fP +Denna radtyp används bara när \fB\-\-verbose\fP angetts två gånger. Denna rad +skrivs eefter alla \fBblock\fP\-rader. Liksom raden \fBfile\fP inenhåller raden +\fBsummary\fP övergripande information om \fB.xz\fP\-filen. +.TP +\fBtotals\fP +Denna rad är alltid den allra sista raden i listutmatningen. Den visar det +totala antalen och storlekarna. +.PP +Kolumnerna på \fBfile\fP\-raderna: +.PD 0 +.RS +.IP 2. 4 +Antalet strömmar i filen +.IP 3. 4 +Totalt antal block i strömmarna +.IP 4. 4 +Komprimerad storlek på filen +.IP 5. 4 +Okomprimerad storlek på filen +.IP 6. 4 +Komprimeringsförhållande, till exempel \fB0.123\fP. Om förhållandet är över +9.999 visas tre bindestreck (\fB\-\-\-\fP) istället för förhållandet. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Kommaseparerad lista med integritetskontrollnamn. Följande strängar används +för de kända kontrolltyperna: \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP och +\fBSHA\-256\fP. För okända kontrolltyper används \fBUnknown\-\fP\fIN\fP, där \fIN\fP är +kontroll\-ID:t som ett decimalt nummer (en eller två siffror). +.IP 8. 4 +Total storlek på strömutfyllnad i filen +.RE +.PD +.PP +Kolumnerna på \fBstream\fP\-raderna: +.PD 0 +.RS +.IP 2. 4 +Strömnummer (den första strömmen är 1) +.IP 3. 4 +Antal block i strömmen +.IP 4. 4 +Komprimerat startavstånd +.IP 5. 4 +Okomprimerat startavstånd +.IP 6. 4 +Komprimerad storlek (inkluderar inte strömutfyllnad) +.IP 7. 4 +Okomprimerad storlek +.IP 8. 4 +Komprimeringsförhållande +.IP 9. 4 +Namnet på integritetskontrollen +.IP 10. 4 +Storleken på strömutfyllnad +.RE +.PD +.PP +Kolumnerna på \fBblock\fP\-raderna: +.PD 0 +.RS +.IP 2. 4 +Numret på strömmen som innehåller detta block +.IP 3. 4 +Blocknummer relativt början på strömmen (det första blocket är 1) +.IP 4. 4 +Blocknummer relativt början på filen +.IP 5. 4 +Komprimerat startavstånd relativt början av filen +.IP 6. 4 +Okomprimerat startavstånd relativt början av filen +.IP 7. 4 +Total komprimerad storlek på blocket (inkluderar huvuden) +.IP 8. 4 +Okomprimerad storlek +.IP 9. 4 +Komprimeringsförhållande +.IP 10. 4 +Namnet på integritetskontrollen +.RE +.PD +.PP +Om \fB\-\-verbose\fP angavs två gånger inkluderas ytterligare kolumner på +\fBblock\fP\-raderna. Dessa visas inte med bara ett \fB\-\-verbose\fP, eftersom det +för att få fram denna information krävs många sökningar och kan därmed vara +långsamt: +.PD 0 +.RS +.IP 11. 4 +Värdet på integritetskontrollen hexadecimalt +.IP 12. 4 +Blockhuvudstorlek +.IP 13. 4 +Blockflaggor: \fBc\fP indikerar att komprimerad storlek finns, och \fBu\fP +indikerar att okomprimerad storlek finns. Om flaggan inte är satt visas ett +bindestreck (\fB\-\fP) istället för att hålla stränglängden fast. Nya flaggor +kan läggas till i slutet av strängen i frmtiden. +.IP 14. 4 +Storlek på den faktiska komprimerade datan i blocket (detta utelämnar +blockhuvud, blockutfyllnad och kontrollfält) +.IP 15. 4 +Mängd minne (i byte) som behövs för att dekomprimera detta block med denna +version av \fBxz\fP +.IP 16. 4 +Filterkedja. Observera att de flesta av flaggorna som användes vid +komprimeringstillfället inte kan vara kända, eftersom endat de flaggor som +behövs för dekomprimering lagras i \fB.xz\fP\-huvudet. +.RE +.PD +.PP +Kolumnerna på \fBsummary\fP\-raderna: +.PD 0 +.RS +.IP 2. 4 +Mängd minne (i byte) som behövs för att dekomprimera denna fil med denna +version av \fBxz\fP +.IP 3. 4 +\fByes\fP eller \fBno\fP som indikerar om alla blockhuvuden både har komprimerad +storlek och okomprimerad storlek i sig +.PP +\fIFrån\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Minsta version av \fBxz\fP som krävs för att dekomprimera filen +.RE +.PD +.PP +Kolumnerna på \fBtotals\fP\-raden: +.PD 0 +.RS +.IP 2. 4 +Antal strömmar +.IP 3. 4 +Antal block +.IP 4. 4 +Komprimerad storlek +.IP 5. 4 +Okomprimerad storlek +.IP 6. 4 +Genomsnittligt komprimeringsförhållande +.IP 7. 4 +Kommaseparerad lista med integritetskontrollnamn som fanns i filerna +.IP 8. 4 +Strömutfyllnadsstorlek +.IP 9. 4 +Antal filer. Denna finns här för att hålla ordningen av de tidigare +kolumnerna desamma som på \fBfile\fP\-rader. +.PD +.RE +.PP +Om \fB\-\-verbose\fP angavs två gånger inkluderas ytterligare kolumner på +\fBtotals\fP\-raden: +.PD 0 +.RS +.IP 10. 4 +Maximal mängd minne (i byte) som behövs för att dekomprimera filerna med +denna version av \fBxz\fP +.IP 11. 4 +\fByes\fP eller \fBno\fP som indikerar om alla blockhuvuden både har komprimerad +storlek och okomprimerad storlek i sig +.PP +\fIFrån\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Minsta version av \fBxz\fP som krävs för att dekomprimera filen +.RE +.PD +.PP +Framtida versioner kan lägga till fler radtyper och fler kolumner kan läggas +til på de befintliga radtyperna, men de befintliga kolumnerna kommmer inte +ändras. +. +.SS Filterhjälp +\fBxz \-\-robot \-\-filters\-help\fP skriver ut de filter som stödjs i följande +format: +.PP +\fIfilter\fP\fB:\fP\fIflagga\fP\fB=<\fP\fIvärde\fP\fB>,\fP\fIflagga\fP\fB=<\fP\fIvärde\fP\fB>\fP… +.TP +\fIfilter\fP +Namn på filtret +.TP +\fIflagga\fP +Namn på en filterspecifik flagga +.TP +\fIvärde\fP +Numeriska \fIvärde\fPintervall ser ut som +\fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. Sträng\fIvärdes\fP val visas inom \fB< >\fP och separerade med ett \fB|\fP\-tecken. +.PP +Varje filter skrivs på en egen rad. +. +.SS Minnesgränsinformation +\fBxz \-\-robot \-\-info\-memory\fP skriver en rad med flera tab\-separerade +kolumner: +.IP 1. 4 +Total mängd med fysiskt minne (RAM) i byte. +.IP 2. 4 +Minnesanvändningsgräns för komprimering i byte (\fB\-\-memlimit\-compress\fP). Ett +specialvärde \fB0\fP indikerar standardinställningen vilken för enkeltrådat +läge är detsamma som ingen gräns. +.IP 3. 4 +Minnesanvändningsgräns för dekomprimering i byte +(\fB\-\-memlimit\-decompress\fP). Ett specialvärde \fB0\fP indikerar +standdartinställningen vilken för enkeltrådat läge är detsamma som ingen +gräns. +.IP 4. 4 +Från \fBxz\fP 5.3.4alpha: Minnesanvändningen för multitrådad dekomprimering i +byte (\fB\-\-memlimit\-mt\-decompress\fP). Detta är aldrig noll eftersom ett +systemspecifikt standardvärde som visas i kolumn 5 används om ingen gräns +har angivits uttryckligen. Detta är heller aldrig större än värdet i kolumn +3 även om ett större värde har angivits med \fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Från \fBxz\fP 5.3.4alpha: Ett systemspecifikt standardgräns för +minnesanvändning som används för att begränsa antalet trådar vid +komprimering med ett automatiskt antal trådar (\fB\-\-threads=0\fP) och ingen +gräns för minnesanvändning har angivits (\fB\-\-memlimit\-compress\fP). Detta +används även som standardvärdet på \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Från \fBxz\fP 5.3.4alpha: antal tillgängliga processortrådar. +.PP +I framtiden kan utdata från \fBxz \-\-robot \-\-info\-memory\fP ha fler kolumner, +men aldrig mer än en rad. +. +.SS Version +\fBxz \-\-robot \-\-version\fP skriver versionsnumret på \fBxz\fP och liblzma i +följande format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Huvudversion. +.TP +\fIYYY\fP +Underversion. Jämna nummer är stabila. Udda nummer är alfa\- eller +betaversioner. +.TP +\fIZZZ\fP +Rättningsnivå för stabila utgåvor eller bara en räknare för +utvecklingsutgåvor. +.TP +\fIS\fP +Stabilitet. 0 är alfa, 1 beta beta och 2 är stabil. \fIS\fP skall alltid vara +2 när \fIYYY\fP är jämnt. +.PP +\fIXYYYZZZS\fP är samma på båda raderna om \fBxz\fP och liblzma kommer från samma +utgåva av XZ Utils. +.PP +Exempel: 4.999.9beta är \fB49990091\fP och 5.0.0 är \fB50000002\fP. +. +.SH SLUTSTATUS +.TP +\fB0\fP +Allt är bra. +.TP +\fB1\fP +Ett fel uppstod. +.TP +\fB2\fP +Något värt en varning uppstod, men inga faktiska fel uppstod. +.PP +Noteringar (inte varningar eller fel) som skrivs på standard fel påverkar +inte slutstatusen. +. +.SH MILJÖ +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP tolkar mellanrumsseparerade listor av flaggor från miljövariablerna +\fBXZ_DEFAULTS\fP och \fBXZ_OPT\fP, i den ordningen, före flaggorna på +kommandoraden. Observera att endast flaggor tolkas från miljövariablerna; +alla andra argument än flaggor ignoreras tyst. Tolkningen görs med +\fBgetopt_long\fP(3) vilket även används för kommandoradsargumenten. +.PP +\fBVarning:\fP genom att sätta dessa miljövariabler ändrar man i praktiken +program och skript som kör \fBxz\fP. för det mesta är set säkert att sätta +begränsningar på minnesanvändning, antal trådar och komprimeringsflaggor via +miljövariablerna. Några flaggor kan dock göra att skript går sönder. Ett +uppenbart exempel är \fB\-\-help\fP vilket gör att \fBxz\fP visar en hjälptext +istället för att komprimera eller dekomprimera en fil. Mer subtila exempel +är \fB\-\-quiet\fP och \fB\-\-verbose\fP. I många fall fungerar det bra att aktivera +en förloppsindikator med \fB\-\-verbose\fP, men i några fall skapar de extra +meddelandena problem. Utförlighetsnivån påverkar även beteendet hos +\fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Användarspecifika eller systemspecifika standardflaggor. Typiskt sätts detta +i ett initieringsskript för skal för att aktivera \fBxz\fP:s begränsning av +minnesanvändning som standard eller att ställa in ett standardantal +trådar. Med undantag för skalinitieringsskript och liknande specialfall +skall skript aldrig sätta eller ta bort \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Detta är för att skicka flaggor till \fBxz\fP när det inte är möjligt att sätta +flaggorna direkt på kommandoraden för \fBxz\fP. Detta är fallet när \fBxz\fP körs +av ett skript eller verktyg, till exempel, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf apa.tar.xz apa\fR +.fi +.RE +.RE +.IP "" +Skript kan använda \fBXZ_OPT\fP, till exempel, för att sätta skriptspecifika +standardflaggor för komprimering. Det rekommenderas fortfarande att tillåta +användaren att åsidosätta \fBXZ_OPT\fP om det är rimligt. Till exempel, i +\fBsh\fP(1)\-skript kan man använda något i still med detta: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "KOMPATIBILITET MED LZMA UTILS" +Kommandoradssyntaxen för \fBxz\fP är praktiskt taget en utökning av \fBlzma\fP, +\fBunlzma\fP och \fBlzcat\fP så som de kommer från LZMA Utils 4.32.x. I de flesta +fall, är det möjligt att ersätta LZMA Utils med XZ Utils utan att göra +sönder befintliga skript. Det finns dock några inkompatibiliteter, vilka +ibland kan orsaka problem. +. +.SS "Komprimeringens förinställda nivåer" +Numreringen av förinställda nivåer för komprimering är inte identiska i +\fBxz\fP och LZMA Utils. Den viktigaste skillnade är hur lexikonstorlekar +avbildas till olika förinställningar. Lexikonstorleken är i stort sett lika +med dekomprimerarens minnesanvändning. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nivå;xz;LZMA Utils +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Lexikonstorlekens skillnader påverkar komprimerarens minnesanvändning också, +men det finns några andra skillnader mellan LZMA Utils och XZ Utils, vilket +gör skillnaden ännu större: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nivå;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Standardförinställningsninvån i LZMA Utils är \fB\-7\fP medan i XZ Utils är den +\fB\-6\fP, så båda använder ett 8 MiB lexikon som standard. +. +.SS "Strömmade visavi icke strömmade .lzma\-filer" +Den ikomprimerade storleken på filen kan lagras i huvudet i \fB.lzma\fP. LZMA +Utils gör det när den komprimerar normala filer. Alternativet är att markera +att den okomprimerade storleken är okänd och använda en markör för lastslut +för att indikera var dekomprimeraren skall stanna. LZMA Utils använder denna +metod när den okomprimerade storleken inte är känd, vilket är fallet, till +exempel, i rör. +.PP +\fBxz\fP stödjer dekomprimering av \fB.lzma\fP\-filer med eller utan markör för +lastslut, men alla \fB.lzma\fP filer som skapas av \fBxz\fP kommer använda markör +för lastslut och ha den okomprimerade storleken markerad som okänd i +\&\fB.lzma\fP\-huvudet. Detta kan bli ett problem i några ovanliga fall. Till +exempel kan en \fB.lzma\fP\-dekomprimerare i en inbäddad enhet fungera endast +med filer som har en känd okomprimerad storlek. Om man stöter på detta +problem behöver man använda LZMA Utils eller LZMA SDK för att skapa +\&\fB.lzma\fP\-filer med känd okomprimerad storlek. +. +.SS "Ej stödda .lzma\-filer" +Formatet \fB.lzma\fP tillåter värden på \fIlc\fP upp till 8, och värden på \fIlp\fP +upp till 4. LZMA Utils kan dekomprimera filer med godtyckliga \fIlc\fP och +\fIlp\fP, men skapar alltid filer med \fBlc=3\fP och \fBlp=0\fP. Att skapa filer med +andra \fIlc\fP och \fIlp\fP är möjligt med \fBxz\fP och med LZMA SDK. +.PP +Implementationen av LZMA1\-filtret i liblzma kräver att summan av \fIlc\fP och +\fIlp\fP inte överstiger 4. Alltså, \fB.lzma\fP\-filer, vilka överstiger denna +gräns, kan inte dekomprimeras med \fBxz\fP. +.PP +LZMA Utils skapar endast \fB.lzma\fP\-filer som har en lexikonstorlek på 2^\fIn\fP +(en potens av 2) men godtar filer med godtycklig lexikonstorlek. liblzma +godtar endast \fB.lzma\fP\-filer som har en lexikonstorlek på 2^\fIn\fP eller +2^\fIn\fP + 2^(\fIn\fP\-1). Detta är för att minska falska positiva vid detektering +av \fB.lzma\fP\-filer. +.PP +Dessa begränsningar bör inte vara ett problem i praktiken, eftersom +praktiskt taget alla \fB.lzma\fP\-filer har komprimerats med inställningar som +liblzma kommer godta. +. +.SS "Avslutande skräp" +Vid dekomprimering ignorerar LZMA Utils tyst allting efter den första +\&\fB.lzma\fP\-strömmen. I de flesta situationer är detta fel. Detta betyder även +att LZMA Utils inte stödjer dekomprimering av konkatenerade \fB.lzma\fP\-filer. +.PP +Om det finns data kvar efter den första \fB.lzma\fP\-strömmen betraktar \fBxz\fP +filen som trasig om inte \fB\-\-single\-stream\fP användes. Detta kan göra sönder +obskyra skript vilka har antagit att avslutande skräp ignoreras. +. +.SH NOTERINGAR +. +.SS "Den komprimerade utdatan kan variera" +Den exakta komprimerade utdatan som produceras från samma okomprimerade +indatafil kan variera mellan versioner av XZ Utils även om +komprimeringsflaggorna är identiska. Detta beror på att kodaren kan +förbättras (snabbare eller bättre komprimering) utan att påverka +filformatet. Utdatan kan variera även mellan olika byggen av samma version +av XZ Utils, om olika byggflaggor används. +.PP +Ovanstående betyder att när väl \fB\-\-rsyncable\fP har implementerats kommer +inte nödvändigtvis de resulterande filerna vara rsync\-bara om inte både +gamla och nya filer har komprimerats med samma version av xz. Detta problem +kan lösas om en del av kodarimplementeringen fryses för att hålla rsync\-bar +utdata stabil mellan xz\-versioner. +. +.SS "Inbäddade .xz\-dekomprimerare" +Inbäddade implementationer av \fB.xz\fP\-dekomprimerare som XZ Embedded stödjer +inte nödvändigtvis filer som skapas med andra typer av +integritets\fIkontroll\fP än \fBnone\fP och \fBcrc32\fP. Eftersom standardvärdet är +\fB\-\-check=crc64\fP måste man använda \fB\-\-check=none\fP eller \fB\-\-check=crc32\fP +när filer skapas för inbäddade system. +.PP +Utanför inbäddade system stödjer alla dekomprimerare av \fB.xz\fP\-format alla +typerna av \fIkontroller\fP, eller åtminstone kan de dekomprimera filern utan +att verifiera integritetskontrollen om den specifika \fIkontrollen\fP inte +stödjs. +.PP +XZ Embedded stödjer BCJ\-filter, men endast med standard startavstånd. +. +.SH EXEMPEL +. +.SS Grundläggande +Komprimera filen \fIapa\fP till \fIapa.xz\fP med standardkomprimeringsnivån +(\fB\-6\fP), och ta bort \fIapa\fP om komprimeringen lyckas: +.RS +.PP +.nf +\f(CRxz apa\fR +.fi +.RE +.PP +Dekomprimera \fIbepa.xz\fP till \fIbepa\fP och ta inte bort \fIbepa.xz\fP även om +dekomprimeringen lyckas: +.RS +.PP +.nf +\f(CRxz \-dk bepa.xz\fR +.fi +.RE +.PP +Skapa \fIcepa.tar.xz\fP med förinställningen \fB\-4e\fP (\fB\-4 \-\-extreme\fP), vilket +är långsammare än standardvärdet \fB\-6\fP, men behöver mindre minne till +komprimering och dekomprimering (48\ MiB respektive 5\ MiB): +.RS +.PP +.nf +\f(CRtar cf \- cepa | xz \-4e > cepa.tar.xz\fR +.fi +.RE +.PP +En blandning av komprimerade och okomprimerade filer kan dekomprimeras till +standard ut med ett enda kommando: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Parallell komprimering av många filer" +På GNU och *BSD kan \fBfind\fP(1) och \fBxargs\fP(1) användas för att +parallellisera komprimeringen av många filer: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Flaggan \fB\-P\fP till \fBxargs\fP(1) anger antalet parallella \fBxz\fP\-processer. Det +bästa värdet till flaggan \fB\-n\fP beror på hur många filer det finns som skapp +komprimeras. Om det bara finns några stycken filer bör värdet förmodigen +vara 1; med tiotusentals filer kan 100 eller mer vara lämpligt för att +reducera antalet \fBxz\fP\-processer som \fBxargs\fP(1) kommer att skapa. +.PP +Flaggan \fB\-T1\fP till \fBxz\fP finns för att tvinga den till enkeltrådsläge, +eftersom \fBxargs\fP(1) används för att styra mängden parallellisering. +. +.SS Robotläge +Beräkna hur många byt som har sparats totalt efter komprimering av flera +filer: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Ett skript kan vilja veta att det använder en tillräckligt ny +\fBxz\fP. Följande \fBsh\fP(1)\-skript kontrollerar att versionsnumret för +verktyget \fBxz\fP är åtminstone 5.0.0. Denna metod är kompatibel med gamla +betaversioner, vilka inte stödde flaggan \fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Din xz är för gammal." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Ange en gräns för minnesanvändning för dekomprimering med \fBXZ_OPT\fP, men om +en gräns redan har satts, öka den inte: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Anpassade komprimerarfilterkedjor" +Den enklaste användningen av anpassade filterkedjor är att anpassa en +LZMA2\-förinställning. Detta kan vara användbart eftersom förinställningarna +endast täcker en delmängd av de potentiellt användbara kombinationerna av +komprimeringsinställningar. +.PP +Kolumnerna CompCPU i tabellerna från beskrivningen av flaggorna options +\fB\-0\fP ... \fB\-9\fP och \fB\-\-extreme\fP är användbara vid anpassning av +LZMA2\-förinställningar. Här är de relevanta delarna samlade från dessa två +tabeller: +.RS +.PP +.TS +tab(;); +c c +n n. +Förinställning;KompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Om man vet att en fil behöver ett rätt stort lexikon (till exempel, 32\ MiB) +för att komprimeras bra, men man vill komprimera den snabbare än \fBxz \-8\fP +skulle gjort kan en förinställning med ett lågt värde på CompCPU (till +exempel, 1) ändras till att använda ett större lexikon: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB apa.tar\fR +.fi +.RE +.PP +Med vissa filer kan ovanstående kommando vara snabbare än \fBxz \-6\fP samtidigt +som det komprimerar betydligt bättre. Dock måste det påpekas att endast +några filer drar fördel av ett stort lexikon samtidigt som värdet CompCPU +hålls lågt. Den mest uppenbara situationen, är ett stort lexikon kan hälpa +till mycket, är ett arkiv som innehåller väldigt snarlika filer på åtmistone +några megabyte var. Lexikonstorleken måste vara signifikant större än någon +enskild fil för att låta LZMA2 dra full nytta av likheterna mellan på +varandra följande filer. +.PP +Om det går bra med väldigt hög minnesanvändning i komprimeraren och +dekomprimeraren, och filen som komprimeras är åtminstone flera hundra +megabyte, kan det vara användbart att använda ännu större lexikon än de 64 +MiB som \fBxz \-9\fP skulle använda: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB stor_apa.tar\fR +.fi +.RE +.PP +Att använda \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) som i exemplet ovan kan vara +användbart för att se minnesbehoven för komprimeraren och +dekomprimeraren. Kom ihåg att använda ett större lexikon än storleken på den +okomprimerade filen är slöseri med minne, så ovanstående kommando är inte +användbart för små filer. +.PP +Ibland spelar inte dekomprimeringstiden någon roll, men dekomprimerarens +minnesanvändning måste hållas låg, till exempel för att göra det möjligt att +dekomprimera filen på ett inbäddat system. Följande kommando använder \fB\-6e\fP +(\fB\-6 \-\-extreme\fP) som en bas och sätter lexikonstorleken till bara 64\ KiB. Den resulterande filen kan dekomprimeras med XZ Embedded (det är därför +det finns \fB\-\-check=crc32\fP) som använder ungerfär 100\ KiB minne. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB apa\fR +.fi +.RE +.PP +Om man vill krama ur så många byte som möjligt kan justering av antalet +literala kontextbitar (\fIlc\fP) och antalet positionsbitar (\fIpb\fP) ibland +hjälpa. Justering av antalet literala positionsbitar (\fIlp\fP) kan också +hjälpa, men vanligen är \fIlc\fP och \fIpb\fP viktigare. Till exempel innehåller +ett källkodsarkiv huvudsakligen US\-ASCII\-text, så något i stil med följande +kan ge aningen (som 0.1\ %) mindre fil än \fBxz \-6e\fP (försök även utan +\fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 källkod.tar\fR +.fi +.RE +.PP +Att använda ett annat filter tillsammans med LZMA2 kan förbättra +komprimeringen med vissa filtyper. Till exempel, för att komprimera ett +delat x86\-32\- eller x86\-64\-bibliotek med filtret x86 BCJ: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libapa.so\fR +.fi +.RE +.PP +Observera att ordningen på filterflaggorna spelar roll. Om \fB\-\-x86\fP anges +efter \fB\-\-lzma2\fP kommer \fBxz\fP avge ett fel, eftersom det inte kan vara något +filter efter LZMA2, och även för att filtret x86 BCJ inte kan användas som +det sista filtret i kedjan. +.PP +Deltafiltret tillsammans med LZMA2 gan ge bra resultat med +bitkartebilder. Det bör vanligen slå PNG, som har några mer avancerade +filter än enkla delta men använder Deflat för den faktiska komprimeringen. +.PP +Bilden måste sparas i okomprimerat format, till exempel som okomprimerad +TIFF. Avståndsparametern i Deltafiltret sätts till att motsvara natalet byte +per bildpunkt i bilden. Till exempel, 24\-bitars RGB bitkarta behöver +\fBdist=3\fP, och det är även bra att skicka \fBpb=0\fP till LZMA2 för att ge +plats för trebytejustering: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 apa.tiff\fR +.fi +.RE +.PP +Om flera bilder har lagts in i ett gemensamt arkiv (till exempel, \fB.tar\fP) +kommer Deltafiltret fungera på det också så länge alla bilder har samma +antal byte per bildpunkt. +. +.SH "SE ÄVEN" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xzcat.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xzcat.1 new file mode 100644 index 0000000000000000000000000000000000000000..1fb596e1ab328783990b87c362f7f7761d73548e --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xzcat.1 @@ -0,0 +1,1954 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Swedish translation of xz-man +.\" Göran Uddeborg , 2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 2025\-03\-08 Tukaani "XZ Utils" +. +.SH NAMN +xz, unxz, xzcat, lzma, unlzma, lzcat — Komprimera eller dekomprimera .xz\- +och .lzma\-filer +. +.SH SYNOPSIS +\fBxz\fP [\fIflagga…\fP] [\fIfil…\fP] +. +.SH KOMMANDOALIAS +\fBunxz\fP är ekvivalent med \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP är ekvivalent med \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP är ekvivalent med \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP är ekvivalent med \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP är ekvivalent med \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +När man skriver skript som behöver dekomprimera filer rekommenderas det att +altid använda namnet \fBxz\fP mäd lämpliga argument (\fBxz \-d\fP eller \fBxz \-dc\fP) +istället för namnen \fBunxz\fP och \fBxzcat\fP. +. +.SH BESKRIVNING +\fBxz\fP är ett datakomprimeringsverktyg för allmänt bruk med en +kommandoradssyntax som liknar \fBgzip\fP(1) och \fBbzip2\fP(1). Det egna +filformatet är formatet \fB.xz\fP, men det föråldrade formatet \fB.lzma\fP som +anändes av LZMA\-verktyg och råa komprimerade strömmar utan huvuden för +behållarformatet stödjs också. Dessutom stödjs dekomprimering av formatet +\&\fB.lz\fP som används av \fBlzip\fP. +.PP +\fBxz\fP komprimerar och dekomprimerar varje \fIfil\fP i enlighet med det valda +arbetsläget. Om inga \fIfiler\fP anges eller \fIfil\fP är \fB\-\fP läser \fBxz\fP från +standard in och skriver den behandade datan på standard ut. \fBxz\fP kommer +vägra (visa ett felmeddelande och hoppa över \fIfilen\fP) att skriva +komprimerad data direkt till standard ut om det är en terminal. På samma +sätt kommer \fBxz\fP vägra att läsa komprimerade data från standard in om det +är en terminal. +.PP +Om inte \fB\-\-stdout\fP anges skrivs andra \fIfiler\fP än \fB\-\fP till en ny fil vars +namn härleds från käll\fIfilens\fP namn: +.IP \(bu 3 +Vid kompringering läggs suffixet till på målfilsformatet (\fB.xz\fP eller +\&\fB.lzma\fP) på slutet av källfilnamnet för att få målfilnamnet. +.IP \(bu 3 +Vid dekomprimering tas suffixet \fB.xz\fP, \fB.lzma\fP eller \fB.lz\fP bort från +filnamnet för att få målfilnamnet. \fBxz\fP känner även igen suffixen \fB.txz\fP +och \fB.tlz\fP, och ersätter dem med suffixet \fB.tar\fP. +.PP +Om målfilen redan finns visas ett felmeddelande och \fIfilen\fP hoppas över. +.PP +Utom när den skriver till standard ut kommer \fBxz\fP visa en varning och hoppa +över \fIfilen\fP om något av följande inträffar: +.IP \(bu 3 +\fIFil\fP är inte en vanlig fil. Symboliska länkar följs inte, och därför anses +de inte vara vanliga filer. +.IP \(bu 3 +\fIFil\fP har mer än en hård länk. +.IP \(bu 3 +\fIFil\fP har biten setuid, setgid eller sticky satt. +.IP \(bu 3 +Arbetsläget är satt till att komprimera och \fIfilen\fP har redan ett suffix +enligt målfilformatet (\fB.xz\fP eller \fB.txz\fP vid komprimering till formatet +\&\fB.xz\fP, och \fB.lzma\fP eller \fB.tlz\fP vid komprimering till formatet \fB.lzma\fP). +.IP \(bu 3 +Arbetsläget är satt till att dekomprimera och \fIfilen\fP har inte ett suffix +enligt något av de stödda filformaten (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP +eller \fB.lz\fP). +.PP +Efter att ha kunnat komprimera eller dekomprimera \fIfilen\fP kopierar \fBxz\fP +ägaren, gruppen, rättigheterna, åtkomsttiden och ändringstiden från +käll\fIfilen\fP till målfilen. Om kopieringen av grupp misslyckas ändras +rättigheterna så att målfilen inte blir åtkomlig för användare som inte har +rättigheter att komma åt käll\fIfilen\fP. \fBxz\fP stödjer inte kopiering av annan +metadata såsom åtkomststyrhingslistor eller utökade attribut ännu. +.PP +När målfilen har stängts framgångsrikt tas käll\fIfilen\fP bort såvida inte +\fB\-\-keep\fP angavs. Käll\fIfilen\fP tas aldrig bort om utdata skrevs till +standard ut eller om något fel inträffade. +.PP +Att skicka \fBSIGINFO\fP eller \fBSIGUSR1\fP till \fBxz\fP\-processen får den att +skriva ut förloppsinformation till standard fel. Detta är bara av begränsat +värde eftersom när standard fel går till en terminal så kommer användning av +\fB\-\-verbose\fP att skriva ut en automatiskt uppdaterande förloppsindikator. +. +.SS Minnesanvändning +\fBxz\fP:s minnesanvändning varierar från några få hundra kilobyte till flera +gigabyte beroende på komprimeringsinställningarna. Inställningen som +användes när en fil komprimerades avgör minnesbehovet hos +dekomprimeraren. Typiskt behöver dekomprimeraren 5\ % till 20\ % av +minnesbehovet som komprimeraren behöver när en fil skapas. Till exempel, att +dekomprimera en fil skapad med \fBxz \-9\fP kräver för närvarande 65\ MiB +minne. Ändå är det möjligt att ha \fB.xz\fP\-filer som behöver flera gigabyte +minne för att dekomprimeras. +.PP +Särskilt användare av äldre system kan finna möjligheten av väldigt stor +minnesanvändning störande. För att förhindra obehagliga överraskningar har +\fBxz\fP en inbyggd minnesanvändningsbegränsare, vilken är avaktiverad som +standard. Även om vissa operativsystem kan tillhandahålla möjligheter att +begränsa minnesanvändningen hos processer bedömdes det inte som flexibelt +nog att lita på det (till exempel, att använda \fBulimit\fP(1) för att begränsa +det virtuella minnet tenderar att hämma \fBmmap\fP(2). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Minnesanvändningsbegränsaren kan aktiveras med kommandoradsflaggan +\fB\-\-memlimit=\fP\fIgräns\fP. Ofta är det bekvämare att aktivera begränsaren som +standard genom att sätta miljövariabeln \fBXZ_DEFAULTS\fP, till exempel, +\fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Det är möjligt att sätta gränser separat +för komprimering och dekomprimering genom att använda +\fB\-\-memlimit\-compress=\fP\fIlimit\fP och \fB\-\-memlimit\-decompress=\fP\fIlimit\fP. Att +använda dessa två flaggor utanför \fBXZ_DEFAULTS\fP är sällan meningsfullt +eftersom en enskild körning av \fBxz\fP inte kan göra både komprimering och +dekomprimering och and \fB\-\-memlimit=\fP\fIgräns\fP (eller \fB\-M\fP \fIgräns\fP) är +kortare att skriva på kommandoraden. +.PP +Om den angivna minnesanvändningsgränsen överskrid vid dekomprimering kommer +\fBxz\fP visa ett fel och dekomprimeringen av filen misslyckas. Om gröensen +överskrids vid komprimering kommer \fBxz\fP försöka skala ner inställningen så +att gränsen inte längre överskrids (utom när \fB\-\-format=raw\fP eller +\fB\-\-no\-adjust\fP används). På detta sätt kommer åtgärden inte misslyckas om +inte gränsen är väldigt liten. Skalningen av inställningen görs i steg som +inte matchar de förinställda komprimeringsnivåerna, till exempel, om gränsen +endast är något mindre än den mängd som behövs till \fBxz \-9\fP kommer +inställningen bara skalas ner lite, inte hela vägen ner till \fBxz \-8\fP. +. +.SS "Konkatenering och utfyllnad av .xz\-filer" +Det är möjligt att konkatenera \fB.xz\fP\-filer som de är. \fBxz\fP kommer +dekomprimera sådana filer som om de vore en enda \fB.xz\fP\-fil. +.PP +Det är möjligt att infoga utfyllnad mellan de konkatenerade delarna eller +efter den sista delen. Utfyllnaden måste bestå av null\-bytear och storleken +på utfyllnaden måste vara en multipel av fyra byte. Detta kan vara +användbart, till exempel, om \fB.xz\fP\-filen lagras på ett medium som mäter +filstorlekar i 512\-byteblock. +.PP +Konkaternering och utfyllnad är inte tillåtet med \fB.lzma\fP\-filer eller råa +strömmar. +. +.SH FLAGGOR +. +.SS "Heltalssuffix och speciella värden" +På de flesta platser där ett heltalsargument förväntas stödjs ett frivilligt +suffix för att enkelt indikera stora heltal. Det får inte finnas något +mellanrumm mellan heltalet och suffixet. +.TP +\fBKiB\fP +Multiplicera heltalet med 1 024 (2¹⁰). \fBKi\fP, \fBk\fP, \fBkB\fP, \fBK\fP och \fBKB\fP är +tillåtna som synomymer till \fBKiB\fP. +.TP +\fBMiB\fP +Multiplicera heltalet med 1 048 576 (2²⁰). \fBMi\fP, \fBm\fP, \fBM\fP och \fBMB\fP är +tillåtna som synomymer till \fBMiB\fP. +.TP +\fBGiB\fP +Multiplicera heltalet med 1 073 741 824 (2³⁰). \fBGi\fP, \fBg\fP, \fBG\fP och \fBGB\fP +är tillåtna som synonymer till \fBGiB\fP. +.PP +Specialvärdet \fBmax\fP kan användas för att indikera det maximala heltalet som +stödjs av flaggan. +. +.SS Arbetsläge +Om flera arbetslägesflaggor ges gäller den sista. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Komprimera. Detta är standardarbetsläget när ingen arbetslägesflagga anges +och inget annat arbetsläge impliceras från kommandonamnet (till exempel +implicerar \fBunxz\fP \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Efter lyckad komprimering källfilen bort såvida man inte skriver till +standard ut eller \fB\-\-keep\fP angavs. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Dekomprimera. Efter lyckad dekomprimering tas källfilen bort såvida man inte +skriver till standard ut eller \fB\-\-keep\fP angavs. +.TP +\fB\-t\fP, \fB\-\-test\fP +Testa integriteten hos komprimerade \fIfiler\fP. Denna flagga är ekvivalent med +\fB\-\-decompress \-\-stdout\fP förutom att den dekomprimerade datan slängs +istället för att skrivas på standard ut. Inga filer skapas eller tas bort. +.TP +\fB\-l\fP, \fB\-\-list\fP +Skriv information om komprimerade \fIfiler\fP. Inge dekomprimeringsutdata +skapas, och inga filer skapas eller tas bort. I listläge kan programmet inte +läsa komprimerad data från standard in eller från andra källor där man inte +kan söka. +.IP "" +Standardlistningen visar grundläggande information om \fIfiler\fP, en fil per +rad. För att få mer detaljerad information, använd även flaggan +\fB\-\-verbose\fP. För ännu mer information, använd \fB\-\-verbose\fP två gånger, men +observera att detta kan vara långsamt, eftersom det behövs många sökningar +får att samla all den extra informationen. Bredden av utförlig utdata +överskrider 80 tecken, så att skicka utdata i ett rör till, till exempel, +\fBless\ \-S\fP kan vara bekvämt om terminalen inte är bred nog. +.IP "" +Den exakta utdatan kan variera mellan versioner av \fBxz\fP och olika +lokaler. För maskinläsbar utdata bör \fB\-\-robot \-\-list\fP användas. +. +.SS Arbetsmodifierare +.TP +\fB\-k\fP, \fB\-\-keep\fP +Ta inte bort indatafilerna. +.IP "" +Från \fBxz\fP 5.2.6 gör denna flagga även att \fBxz\fP komprimerar eller +dekomprimerar även om indatan är en symbolisk länk till en normal fil, har +mer än en hård länk eller har biten setuid, setgid eller sticky +satt. Bitarna setuid, setgid och sticky kopieras inte till målfilen. I +tidigare versioner gjordes detta bara med \fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Denna flagga har flera funktioner: +.RS +.IP \(bu 3 +Om målfilen redan finns, radera den före komprimering eller dekomprimering. +.IP \(bu 3 +Komprimera eller dekomprimera även om indatan är en symbolisk länk till en +normal fil, har mer än en hård länk eller har biten setuid, setgid eller +sticky satt. Bitarna setuid, setgid och sticky kopieras inte till målfilen. +.IP \(bu 3 +När den används med \fB\-\-decompress\fP \fB\-\-stdout\fP och \fBxz\fP inte känner igen +typen på källfilen, kopiera källfilen som den är till standard ut. Detta gör +att \fBxzcat\fP \fB\-\-force\fP kan användas som \fBcat\fP(1) för filer som inte har +komprimerats med \fBxz\fP. Observera att i framtiden kan \fBxz\fP komma att stödja +nya komprimeringsfilformat, vilket kan få \fBxz\fP att dekomprimera fler typer +av filer istället för att kopiera dem till standard ut. +\fB\-\-format=\fP\fIformat\fP kan användas för att begränsa \fBxz\fP till att +dekomprimera endast ett enda filformat. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Skriv den komprimerade eller dekomprimerade datan till standard ut istället +för en fil. Detta implicerar \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Dekomprimera endast den första \fB.xz\fP\-strömmen, och ignorera tys eventuella +återstående indata som följer efter strömmen. Normalt får sådant avslutande +skräp \fBxz\fP att visa ett fel. +.IP "" +\fBxz\fP dekomprimerar aldrig mer än en ström från \fB.lzma\fP\-filer eller råa +strömmar, men denna flagga gör ändå att \fBxz\fP ignorerar den möjliga +efterföljande datan efter \fB.lzma\fP\-filen eller den råa strömmen. +.IP "" +Denna flagga har ingen effekt om arbetsläget inte är \fB\-\-decompress\fP eller +\fB\-\-test\fP. +.IP "" +Sedan \fBxz\fP 5.7.1alpha, implicerar \fB\-\-single\-stream\fP \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Avaktivera att glesa filer skapas. Som standard, om den dekomprimerar till +en normal fil, försöker \fBxz\fP att göra filen gles om den dekomprimerade +datan innehåller långa sekvenser av binära nollor. Det fungerar även när den +skriver till standard ut så länga standard ut är kopplad till en normal fil +och vissa ytterligare villkor möts för att göra det säkert. Att skapa glesa +filer kan spara diskutrymme och snabba upp dekomprimeringen genom att +begränsa mängden disk\-I/O. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +Vid komprimering, använd \fI.suf\fP som suffixet för målfilen istället för +\&\fB.xz\fP eller \fB.lzma\fP. Om den inte skriver till standard ut och källfilen +redan har suffixet \fI.suf\fP visas en varning och filen hoppas över. +.IP "" +Vid dekomprimering, känn igen filer med suffixet \fI.suf\fP utöver filer +medsuffixen \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP eller \fB.lz\fP. Om källfilen +har suffixet \fI.suf\fP tas suffixet bort för att få målfilnamnet. +.IP "" +Vid komprimering eller dekomprimering av råa strömmar (\fB\-\-format=raw\fP) +måste alltid suffixet anges om den inte skriver till standard ut, eftersom +det inte finns något standardsuffix för råa strömmar. +.TP +\fB\-\-files\fP[\fB=\fP\fIfil\fP] +Läs filnamnen att arbeta på från \fIfil\fP; om \fIfil\fP utelämnas läses filnamn +från standard in. Filnamn måste avslutas med nyradstecknet. Ett bindestreck +(\fB\-\fP) tas som ett vanligt filnamn; det betyder inte standard in. Om filnamn +även anges som kommandoradsargument, bearbetas de före filnamnen som läses +från \fIfil\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIfil\fP] +Detta är identiskt med \fB\-\-files\fP[\fB=\fP\fIfil\fP] förjutom att varje filnamn +måste avslutas med ett nulltecken. +. +.SS "Grundläggande flaggor för filformat och komprimering" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fIformat\fP +Angi filens \fIformat\fP att komprimera eller dekomprimera: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Detta är standard. Vid komprimering är \fBauto\fP ekvivalent med \fBxz\fP. Vid +dekomprimering detekteras automatiskt formatet på indatafilen. Observera att +råa strömmar (skapade med \fB\-\-format=raw\fP inte kan detekteras automatiskt. +.TP +\fBxz\fP +Komprimera till filformatet \fB.xz\fP, eller acceptera endast \fB.xz\fP\-filer vid +dekomprimering. +.TP +\fBlzma\fP, \fBalone\fP +Komprimera till det föråldrade filformatet \fB.lzma\fP, eller acceptera endast +\&\fB.lzma\fP\-filer fid dekomprimering. Det alternativa namnet \fBalone\fP +tillhandahålls för bakåtkompatibilitet med LZMA Utils. +.TP +\fBlzip\fP +Acceptera endast \fB.lz\fP\-filer vid dekomprimering. Komprimering stödjs inte. +.IP "" +\&\fB.lz\fP\-formatet version 0 och 1 stödjs. Version 0\-filer producerades av +\fBlzip\fP 1.3 och tidigare. Sådana filer är inte vanliga men kan hittas från +filarkiv eftersom några källpaket släpptes i detta format. Folk kan ha även +ha gamla personliga filer i detta format. Dekomprimeringsstöd för format +version 0 togs bort i \fBlzip\fP 1.18. \fBlzip\fP 1.4 och senare kan skapa filer i +formatversion 1. +.TP +\fBraw\fP +Komprimera eller dekomprimera en rå ström (inga huvuden). Detta är endast +avsett för avancerade användare. För att avkoda råa strömmar behöver man +använda \fB\-\-format=raw\fP och explicit angi filterkedjan, vilken normalt +skulle ha lagrats i behållarens huvuden. +.RE +.TP +\fB\-C\fP \fIkontroll\fP, \fB\-\-check=\fP\fIkontroll\fP +Ange typen av integritetskontroll. Kontrollen beräknas från den +dekomprimerade datan och lagras i \fB.xz\fP\-filen. Denna flagga har endast +någon inverkan när man komprimerar till formatet \fB.xz\fP; formatet \fB.lzma\fP +stödjer inte integritetskontroller. Integritetskontrollen (om någon) +verifieras när \fB.xz\fP\-filen dekomprimeras. +.IP "" +\fIKontroll\fPtyper som stödjs: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Beräkna inte någon integritetskontroll alls. Detta är normalt en dålig +idé. Det kan vara användbart när datans integritet ändå verifieras på andra +sätt. +.TP +\fBcrc32\fP +Beräkna CRC32 med polynomet från IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Beräkna CRC64 med polynomet från ECMA\-182. Detta är standard, eftersom det +är något bättre än CRC32 på att upptäcka skadade filer och +hastighetsskillnaden är försumbar. +.TP +\fBsha256\fP +Beräkna SHA\-256. Detta är något långsammare än CRC32 och CRC64. +.RE +.IP "" +Integriteten hos \fB.xz\fP\-huvuden verifieras alltid med CRC32. Det är inte +möjligt att ändra eller avaktivera det. +.TP +\fB\-\-ignore\-check\fP +Verifiera inte integritetskontrollen av den komprimerade datan vid +dekomprimering. CRC32\-värden i \fB.xz\fP\-huvudena kommer fortfarande verifieras +normalt +.IP "" +\fBAnvänd inte denna flagga om du inte vet vad du gör.\fP Möjliga anledningar +till att använda denna flagga: +.RS +.IP \(bu 3 +Försöka återvinna data från en trasig .xz\-fil. +.IP \(bu 3 +Snabba upp dekomprimering. Detta har störst betydelse med SHA\-256 eller med +filer som har komprimerats extremt mycket. Det rekommenderas att inte +använda denna flagga för detta ändamål om inte filintegriteten verifieras +externt på något annat sätt. +.RE +.TP +\fB\-0\fP … \fB\-9\fP +Välj en förinställningsnivå för komprimering. Standard är \fB\-6\fP. Om flera +förinställningsnivåer anges gäller den sist angivna. Om en anpassad +fileterkedja redan angivits gör en inställning av en förinställningsnivå för +komprimering att den anpassade filterkedjan töms. +.IP "" +Skillnaden mellan förinställningarna har större betydelse än med \fBgzip\fP(1) +och \fBbzip2\fP(1). Den valda komprimeringsinställningen avgör minneskraven för +dekomprimeraren, att använda en för hög förinställningsnivå kan alltså göra +det plågsamt att dekomprimera filer på ett gammalt system med lite +RAM. Specifikt \fBär det inte en bra ide att blint använda \-9 för allt\fP +liksom det ofta är med \fBgzip\fP(1) och \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP … \fB\-3\fP +Dessa är ganska snabba förinställningar. \fB\-0\fP är ibland snabbare än \fBgzip \-9\fP samtidigt som komprimeringen är mycket bättre. De högre har ofta +hastighet jämförbar med \fBbzip2\fP(1) med jämförbar eller bättre +komprimeringsförhållande, även om resultatet mycket beror på typen av data +som komprimeras. +.TP +\fB\-4\fP … \fB\-6\fP +Bra för väldigt god komprimering samtidigt som dekomprimerarens +minnesanvändning hålls rimlig även på gamla system. \fB\-6\fP är standardvärdet, +vilket vanligen är ett bra val för att distribuera filer so behöver +dekomprimeras även på ssytem med endast 16\ MiB RAM. (\fB\-5e\fP eller \fB\-6e\fP +kan också vara värda att överväga. Se \fB\-\-extreme\fP.) +.TP +\fB\-7 … \-9\fP +Dessa liknar \fB\-6\fP med med högre krav på minne till komprimerare och +dekomprimerare. Dessa är bara användbara vid komprimering av filer större än +8\ MiB, 16\ MiB respektive 32\ MiB. +.RE +.IP "" +På samma hårdvara är dekomprimeringshastigheten ungefär ett konstant antal +byt av komprimerad data per sekund. Med andra ord, ju bättre komprimering, +desto snabbare kommer dekomprimeringen vanligen vara. Detta betyder även att +mängden av okomprimerad utdata skapad per sekund kan variera mycket. +.IP "" +Följande tabell sammanfattar funktionerna hos förinställningarna: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Förinställning;LexStrl;KompCPU;KompMin;DekMin +\-0;256 KiB;0;3 MiB;1 MiB +\-1;1 MiB;1;9 MiB;2 MiB +\-2;2 MiB;2;17 MiB;3 MiB +\-3;4 MiB;3;32 MiB;5 MiB +\-4;4 MiB;4;48 MiB;5 MiB +\-5;8 MiB;5;94 MiB;9 MiB +\-6;8 MiB;6;94 MiB;9 MiB +\-7;16 MiB;6;186 MiB;17 MiB +\-8;32 MiB;6;370 MiB;33 MiB +\-9;64 MiB;6;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Kolumnbeskrivningar: +.RS +.IP \(bu 3 +LexStrl är storleken på LZMA2:s lexikon. Det är slöseri med minne att +använda ett större lexikon än storleken på den okomprimerade filen. Detta är +anledningen till att det är bra att undvika förinställningarna \fB\-7\fP … \fB\-9\fP +när det inte finns något verkligt behov av dem. På \fB\-6\fP och lägre är +mängden bortslösat minne vanligen litet nog att inte ha någon betydelse. +.IP \(bu 3 +KompCPU är en förenklad representation av LZMA2\-inställningar som påverkar +komprimeringshastigheten. Lexikonstorleken påverkar också hastigheten, så +medan KompCPU är samma för nivåerna \fB\-6\fP … \fB\-9\fP tenderar fortfarande högre +nivåer att vara lite långsmmare. För ännu långsammare och möjligen bättre +komprimering, se \fB\-\-extreme\fP. +.IP \(bu 3 +KompMem innehåller komprimerarens minneskrav i enkeltrådat läge. Det kan +variera något mellan versioner av \fBxz\fP. +.IP \(bu 3 +DekMin innehåller dekomprimerarens minneskrav. Det vill säga, komprimerarens +inställningar avgör minneskravet för dekomprimeraren. Den exakta +minnesanvändningen hos dekomprimeraren är något mer än +LZMA2\-lexikonstorleken, men värdena i tabellen har avrundats upp till nästa +nästa hela MiB. +.RE +.IP "" +Minneskravet för det multitrådade läget är signifikant högre än det för +enkeltrådat läge. Med standardvärdet på \fB\-\-block\-size\fP behöver varje tråd +3·3·LexStrl plus KompMin eller DekMin. Till exempel, fyra trådar med +förinställningen behöver 660\(en670 MiB minne. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Använd en långsammare variant av den valda förinställningsnivån för +komprimering (\fB\-0\fP … \fB\-9\fP) för att förhoppningsvis få lite bättre +komprimeringsförhållande, men med otur kan detta även göra det +sämre. Dekomprimerarens minnesanvändning påverkas inte, men komprimerarens +minnesanvändning ökar lite vid förinställningsnivåerna \fB\-0\fP … \fB\-3\fP. +.IP "" +Eftersom det finns två förinställningar med lexikonstorlekar 4\ MiB och 8\ MiB använder förinställningarna \fB\-3e\fP och \fB\-5e\fP något snabbare +inställningar (lägre KompCPU) än \fB\-4e\fP respektive \fB\-6e\fP. På det sättet är +inte två förinställningar identiska. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Förinställning;LexStrl;KompCPU;KompMin;DekMin +\-0e;256 KiB;8;4 MiB;1 MiB +\-1e;1 MiB;8;13 MiB;2 MiB +\-2e;2 MiB;8;25 MiB;3 MiB +\-3e;4 MiB;7;48 MiB;5 MiB +\-4e;4 MiB;8;48 MiB;5 MiB +\-5e;8 MiB;7;94 MiB;9 MiB +\-6e;8 MiB;8;94 MiB;9 MiB +\-7e;16 MiB;8;186 MiB;17 MiB +\-8e;32 MiB;8;370 MiB;33 MiB +\-9e;64 MiB;8;674 MiB;65 MiB +.TE +.RE +.RE +.IP "" +Till exempel finns det totalt fyra förinställningar som använder 8\ MiB +lexikon, vars ordning från den snabbaste till den långsammaste är \fB\-5\fP, +\fB\-6\fP, \fB\-5e\fP och \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Dessa är något missledande alias för \fB\-0\fP respektive \fB\-9\fP. Dessa finns +endast för bakåtkompatibilitet med LZMA\-verktyg. Undvik att använda dessa +flaggor. +.TP +\fB\-\-block\-size=\fP\fIstorlek\fP +Vid komprimering till formatet \fB.xz\fP, dela indatai block med \fIstorlek\fP +bytes. Blocken komprimeras oberoende av varandra, vilket hjälper till vid +multitrådning och gör begränsad random\-access\-dekomprimering möjlig. Denna +flagga används typiskt för att åsidosätta blockstorleken i multitrådat läge, +men denna flagga kan användas även i enkeltrådat läge. +.IP "" +I multitrådat läge kommer ungefär tre gånger \fIstorlek\fP byte att allokeras i +varje tråd för buffring av indata och utdata. Standardvärdet på \fIstorlek\fP +är det större av tre gånger LZMA2\-lexikonstorleken eller 1 MiB. Typiskt är +ett bra värde 2\(en4 gånger storleken på LZMA2\-lexikonet eller åtminstone 1 +MiB. Att använda en \fIstorlek\fP mindre än LZMA2\-lexikonstorleken utgör +slöseri med RAM eftersom LZMA2\-lexikonbufferten då aldrig kommer användas +helt. I multitrådat läge lagras storlekarna på plocken i +blockhuvudena. Denna storleksinformation krävs för multitrådad +dekomprimering. +.IP "" +I singletrådat läge görs som standard ingen uppdelning i block. Att göra +denna inställning påverark inte minnesanvändningen. Ingen +storleksinformation lagras i blockhuvuden, därmed kommer filer som skapas i +enkeltrådat läge inte att vara identiska med filer skapade i multitrådat +läge. Avsaknaden av sotrleksinformation betyder också att \fBxz\fP inte kommer +kunna dekomprimera filerna i multitrådat läge. +.TP +\fB\-\-block\-list=\fP\fIposter\fP +Vid komprimering till formatet \fB.xz\fP, börja ett nytt block med en möjlig +anpassad filterkedja efter de angivna intervallen med okomprimerade data. +.IP "" +\fIPosterna\fP är en kommaseparerad lista. Varje post består av ett möjligt +filterkedjenummer mellan 0 och 9 följt av ett kolon (\fB:\fP) och en +obligatorisk storlek för okomprimerade data. Att utelämna en post (två på +varandra följande komman) är en kortform för att använda storleken och +filtren från föregående post. +.IP "" +Om indatafiler är större än summan av storlekarna i \fIposter\fP repeteras den +sista posten fram till slutet på filen. Ett speciellt värde \fB0\fP kan +användas som den sista storleken för att indikera att resten av filen skall +kodas som ett enda block. +.IP "" +En alternativ filterkedja för varje block kan anges i kombinaton med +flaggorna \fB\-\-filters1=\fP\fIfilter\fP \&…\& \fB\-\-filters9=\fP\fIfilter\fP. Dessa +flaggor definierar filterkedjor med en identifierare mellan +1\(en9. Filterkedja 0 kan användas för att referera till +standardfilterkedjan, vilket är samma sak som att inte ange någon +filterkedja. Filterkedjeidentifierare kan användas före den okomprimerade +sotrleken, följt av ett kolon (\fB:\fP). Till exempel, om man anger +\fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP kommer block skapas med: +.RS +.IP \(bu 3 +Filterkedjan angiven av \fB\-\-filters1\fP och 2 MiB indata +.IP \(bu 3 +Filterkedjan angiven av \fB\-\-filters3\fP och 2 MiB indata +.IP \(bu 3 +Filterkedjan angiven av \fB\-\-filters2\fP och 4 MiB indata +.IP \(bu 3 +Filterkedjan angiven av \fB\-\-filters2\fP och 4 MiB indata +.IP \(bu 3 +Standardfilterkedjan och 2 MiB indata +.IP \(bu 3 +Standardfilterkedjan och 4 MiB indata för varje block till slutet av indata. +.RE +.IP "" +Om man anger en storlek som överskrider kodarens blockstorlek (antingen +standardvärdet i trådat läge eller värdet som anges med +\fB\-\-block\-size=\fP\fIstorlek\fP) kommer kodaren skapa ytterligare block med +hänsyn taget till gränserna som anges i \fIposter\fP. Till exempel, om man +anger \fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP och +indatafilen är 80 MiB kommer man få 11 block: 5, 10, 8, 10, 2, 10, 10, 4, +10, 10 och 1 MiB. +.IP "" +I multitrådat läge lagras storleken på blocken i blockhuvudena. Detta görs +inte i enkeltrådat läge, så den kodade utdatan kommer inte vara identisk med +den från det multitrådade läget. +.TP +\fB\-\-flush\-timeout=\fP\fItidsgräns\fP +Vid komprimering, om mer än \fItidsgräns\fP millisekunder (ett positivt heltal) +har gått sedan den föregånde tömningen och en läsning av mer indata skulle +blockera töms all väntande indata från kodaren och görs tillgänglig i +utdataströmmen. Detta kan vara användbart om \fBxz\fP används för att +komprimera data som strömmas över ett nätverk. Små värden på \fItidsgräns\fP +gör data tillgänglig vid den mottagande änden med en liten fördröjning, men +större värden på \fItidsgräns\fP ger bättre komprimeringsförhållande. +.IP "" +Denna funktion är avaktiverad som standard. Om denna flagga anges mer än en +gång gäller den sista. Dett speciella värdet \fB0\fP på \fItidsgräns\fP kan +användas för att uttryckligen avaktivera denna funktion. +.IP "" +Denna funktion är inte tillgänglig på icke\-POSIX\-system. +.IP "" +.\" FIXME +\fBDenna funktion är fortfarande experimentell.\fP För närvarande är \fBxz\fP +olämplig för dekomprimering av strömmen i realtid på grund av hur \fBxz\fP +buffrar. +.TP +\fB\-\-no\-sync\fP +Synkronisera inte målfilen och dess katalog med lagringsenheten före +källfilen tas bort. Detta kan förbättra prestanda vid komprimering eller +dekomprimering av många små filer. Dock, om systemet kraschar snart efter +raderingen är det möjligt att målfilen inte skrevs till lagringsenheten men +att raderingen gjordes det. I det fallet är varken originalkällfilen eller +målfilen tillgänglig. +.IP "" +Denna flagga har bara någon effekt när \fBxz\fP kommer att ta bort källfilen. I +andra fall görs aldrig någon synkronisering. +.IP "" +Synkroniseringen och \fB\-\-no\-sync\fP lades till i \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIgräns\fP +Sätt en gräns på minnesanvändningen för komprimeringen. Om denna flaggan +anges flera gånger gäller den sista. +.IP "" +Om komprimeringsinställnigarna överskrider \fIgränsen\fP kommer \fBxz\fP försöka +justera inställningarna neråt så att gränsen inte längre överskrids och visa +en notis om att en automatisk justering gjorts. Justeringen görs i denna +ordning: reducera antalet trådar, byta till enkeltrådat läge om även en tråd +i multitrådat läge överskrider \fIgränsen\fP och slutligen reducera +LZMA2\-lexikonstorleken. +.IP "" +Vid komprimering med \fB\-\-format=raw\fP eller om \fB\-\-no\-adjust\fP har angetts kan +endast antalet trådar reduceras eftersom det kan göras utan att påverka den +komprimerade utdatan. +.IP "" +Om \fIgränsen\fP inte kan uppfyllas ens med justeringarna som beskrivs ovan +visas ett felmeddelande och \fBxz\fP kommer avsluta med slutstatus 1. +.IP "" +\fIGränsen\fP kan anges på flera sätt: +.RS +.IP \(bu 3 +\fIGränsen\fP kan vara ett absolut värde i byte. Att använda ett heltalssuffix +som \fBMiB\fP kan vara praktiskt. Exempel: \fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +\fIGränsen\fP kan anges som en procentsats av det totala fysiska minnet +(RAM). Detta kan vara användbart särskilt när man sätter miljövariabeln +\fBXZ_DEFAULTS\fP i ett skalinitieringsskript som delas mellan olika +datorer. På det sättet är gränsen automatiskt större på system med mer +minne. Exempel: \fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +\fIGränsen\fP kan återställas tillbaka till sitt standardvärde genom att sätta +den till \fB0\fP. Detta är för närvarande ekvivalent med att sätta \fIgränsen\fP +till \fBmax\fP (ingen gräns på minnesanvändning). +.RE +.IP "" +För 32\-bitars \fBxz\fP finns det ett specialfall: om \fIgränsen\fP skulle vara +över \fB4020\ MiB\fP sätts \fIgränsen\fP till \fB4020\ MiB\fP. På MIPS32 används +\fB2000\ MiB\fP istället. (Värdena \fB0\fP och \fBmax\fP påverkas inte av detta. En +liknande funktion finns inte för dekomprimering.) Detta kan hjälpa till när +ett 32\-bitarsprogram har tillgång till 4\ GiB adressrymd (2 GiB på MIPS32) +förhoppningsvis utan att göra någon skada i andra situationer. +.IP "" +Se även avsnittet \fBMinnesanvändning\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIgräns\fP +Sätt en gräns för minnesanvnändningen vid dekomprimering. Detta påverkar +även läget \fB\-\-list\fP. Om åtgärden inte är möjlig utan att överskrida +\fIgränsen\fP kommer \fBxz\fP visa ett felmeddelande och dekomprimeringen av filen +kommer misslyckas. Se \fB\-\-memlimit\-compress=\fP\fIgräns\fP för möjliga sätt att +ange \fIgränsen\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIgräns\fP +Sätt en gräns för minnesanvändningen för multitrådad dekomprimering. Detta +kan endast påverka antalet trådar; det kommer aldrig att få \fBxz\fP att vägra +att dekomprimera en fil. Om \fIgränsen\fP är för låg för att tillåta någon +multitrådning ignoreras \fIgränsen\fP och \fBxz\fP kommer gå vidare i enkeltrådat +läge. Observera att om även \fB\-\-memlimit\-decompress\fP används kommer det +alltid att gälla både enkeltrådat och multitrådat läge, och därmed kommer +den gällande \fIgränsen\fP för multitrådning aldrig vara högre än gränsen som +sätts med \fB\-\-memlimit\-decompress\fP. +.IP "" +Till skillnad mot de andra flaggorna för gränser för minnesanvändning har +\fB\-\-memlimit\-mt\-decompress=\fP\fIgräns\fP en systemspecifik +standard\fIgräns\fP. \fBxz \-\-info\-memory\fP kan användas för att se det aktuella +värdet. +.IP "" +Denna flagga och dess standardvärde finns för att utan någon gräns skulle +den trådade dekomprimeraren kunna allokera en vansinnig mängd minne med +några indatafiler. Om standard\fIgränsen\fP är för låg på ditt system, öka då +gärna \fIgränsen\fP men sätt den aldrig till ett större värde än mängden +användbart RAM eftersom att med passande indatafiler kommer \fBxz\fP försöka +använda den mängden av minne även med ett lågt antal trådar. Att få slut på +minne ller växling kommer inte förbättra dekomprimeringsprestandan. +.IP "" +Se \fB\-\-memlimit\-compress=\fP\fIgräns\fP för möjliga sätt att ange \fIgränsen\fP. Att +sätta \fIgräns\fP till \fB0\fP återställer \fIgränsen\fP till sdet systemspecifika +standardvärdet. +.TP +\fB\-M\fP \fIgräns\fP, \fB\-\-memlimit=\fP\fIgräns\fP, \fB\-\-memory=\fP\fIgräns\fP +Detta är ekvivalent med att ange \fB\-\-memlimit\-compress=\fP\fIgräns\fP +\fB\-\-memlimit\-decompress=\fP\fIgräns\fP \fB\-\-memlimit\-mt\-decompress=\fP\fIgräns\fP. +.TP +\fB\-\-no\-adjust\fP +Visa ett fel och avsluta om gränsen för minnesanvändning inte kan mötas utan +att justera inställnigar som påverkar den komprimerade utdatan. Det vill +säga, detta förhindrar att \fBxz\fP byter kodaren från multitrådat läge till +enkeltrådat läge och från att den reducerar LZMA2\-lexikonets storlek. Även +när denna flagga används kan antalet trådar reduceras för att möta gränsen +för minnesanvändning eftersom det inte kommer påverka den komprimerade +utdatan. +.IP "" +Automatisk justering är alltid avaktiverat när råa strömmar skapas +(\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fItrådar\fP, \fB\-\-threads=\fP\fItrådar\fP +Ange antalet arbetstrådar som skall användas. Att sätta \fItrådar\fP till ett +specialvärde \fB0\fP gör att \fBxz\fP använder så många trådar som processorerna +på systemet stödjer. Det aktuella antalet trådar kan vara färre än \fItrådar\fP +om indatafilen inte är stor nog för trådning med de givna inställningarna +eller om användning av fler trådar skulle överkrida gränsen för +minnesanvändning. +.IP "" +De enkeltrådade och multitrådade komprimerarna producerar olika utdata. Den +enkeltrådade komprimeraren kommer ge den minsta filstorleken men endast +utdata från den multitrådade komprimeraren kan dekomprimeras med flera +trådar. Att sätta \fItrådar\fP till \fB1\fP kommer använda enkeltrådat läge. Att +sätta \fItrådar\fP till något annat värde, inklusive \fB0\fP, kommer använda den +multitrådade komprimeraren även om systemet endast stödjer en hårdvarutråd. +(\fBxz\fP 5.2.x använde enkeltrådat läge i denna situation.) +.IP "" +För att använda multitrådat läge med endast en tråd, sätt \fItrådar\fP till +\fB+1\fP. Prefixet \fB+\fP har ingen påvrekan för andra värden än \fB1\fP. En gräns +för minnesanvändning kan fortfarande göra att \fBxz\fP byter till enkeltrådat +läge såvida inte \fB\-\-no\-adjust\fP används. Stöd för prefixet \fB+\fP lades till i +\fBxz\fP 5.4.0. +.IP "" +Om ett automatiskt antal trådar har begärts och ingen gräns för +minnesanvändning har angivits, då kommer en systemspecifik mjuk +standardgräns användas för att möjligen begränsa antalet trådar. Det är en +mjuk gräns i den meningen att den ignoreras om antalet trådar blir en, +alltså kommer en mjuk gräns aldrig hindra \fBxz\fP från att komprimera eller +dekomprimera. Denna mjuka standardgräns kommer inte göra att \fBxz\fP byter +från multitrådat läge till enkeltrådat läge. De aktiva gränserna kan ses med +\fBxz \-\-info\-memory\fP. +.IP "" +För närvarande är den enda trådningsmetoden att dela indata i block och +komprimera dem oberoende av varandra. Standardstorleken på block beror på +komprimeringsnivån och kan åsidosättas med flaggan +\fB\-\-block\-size=\fP\fIstorlek\fP. +.IP "" +Trådad dekomprimering fungerar bara på filer som innehåller flera block med +storleksinformation i blockhuvuden. Alla tillräckligt stora filer +komprimeras i multitrådat läge för att uppfylla detta villkor, men filer +komprimerade i enkeltrådat läge gör det inte ens om +\fB\-\-block\-size=\fP\fIstorlek\fP har använts. +.IP "" +Standardvärdet på \fItrådar\fP är \fB0\fP. I \fBxz\fP 5.4.x och tidigare är +standardvärdet \fB1\fP. +. +.SS "Anpassade komprimerarfilterkedjor" +Med en anpassad filterkedja kan man specificera kompressionsinställningarna +i detalj istället för att lita på inställningarna som hör till +förinställningarna. När en anpassad filterkedja anges glöms +förinställningsflaggor (\fB\-0\fP \&…\& \fB\-9\fP och \fB\-\-extreme\fP) tidigare på +kommandoraden. Om en förinställningsflagga anges efter en eller flera +flaggor för anpassade filterkedjor gäller den nya förinställningen och de +flaggor för anpassade filterkedjor som angivits tidigare glöms. +.PP +En filterkedja är jämförbar med att skapa rör på kommando. Vid komprimering +skickas den okomprimerade indatan till det första filtret, vars utdata +skickas till nästa filter (om något). Utdatan från det sista filtret blir +skrivet till den komprimerade filen. Det maximala antalet filter i kedjan är +fyra, men typiskt har en filterkedja bara ett ellet två filter. +.PP +Många filter har begränsningar på var de kan finnas i filterkedjan: några +filter kan bara fungera som det sista filtret i kedjan, några bara om de +inte är det sista filtret, och några fungerar i godtycklig position i +kedjan. Beroende på filtret är denna begränsning antingen en egenskap hos +filterdesignen eller finns för att förhindra säkerhetsproblem. +.PP +En anpassad filterkedja kan anges på två olika sätt. Med flaggorna +\fB\-\-filters=\fP\fIfilter\fP och \fB\-\-filters1=\fP\fIfilter\fP \&…\& +\fB\-\-filters9=\fP\fIfilter\fP kan man ange en hel filterkedja med en flagga genom +att använda syntaxen för liblzma\-filtersträngar. Alternativt kan en +filterkedja anges genom att använda en eller flera individuella +filterflaggor i den ordning de önskas i filterkedjan. Det vill säga, +ordningen på de individuella filterflaggorna är signifikant! Vid avkodning +av råa strömmar (\fB\-\-format=raw\fP) måste filterkedjan anges i samma ordning +som den specificerades vid komprimeringen. Eventuella individuella filter\- +eller förinstiällningsflaggor angivna före den fullständiga +filterkedjeflaggan (\fB\-\-filters=\fP\fIfilter\fP) kommer glömmas. Individuella +filter som anges efter den flaggan för en full kedja kommer återställa +filterkedjan. +.PP +Både den fullständiga och de individuella filterflaggorna tar +filterspecifika \fIflaggor\fP som en kommaseparerad lista. Extra komman +\fIflaggor\fP ignoreras. Varje flagga har ett standardvärde, så ange dem du +vill ändra. +.PP +För att se hela filterkedjan och \fIflaggor\fP, använd \fBxz \-vv\fP (det vill +säga, använd \fB\-\-verbose\fP två gånger). Detta fungerar även för att se +flaggorna för filterkedjor som används av förinställningar. +.TP +\fB\-\-filters=\fP\fIfilter\fP +Ange den fullständiga filterkedan eller en förinställning en en enda +flagga. Varje filter kan separeras med blanktecken eller två bindestreck +(\fB\-\-\fP). \fIfilter\fP kan behöva citeras på skalets kommandorad så att det +tolkas som en enda flagga. För att beteckna \fIflaggor\fP, använd \fB:\fP eller +\fB=\fP. En förinställning kan föregås med ett \fB\-\fP och följas av noll eller +flera flaggor. Den enda flaggan som stödjs är \fBe\fP för att tillämpa samma +flaggor som \fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIfilter\fP … \fB\-\-filters9\fP=\fIfilter\fP +Ange upp till nio ytterligare filterkedjor som kan användas med +\fB\-\-block\-list\fP. +.IP "" +Till exempel, vid komprimering av ett arkiv med körbara filer följt av +textfiler skulle den körbara delen kunna använda en filterkedja med ett +BCJ\-filter och endast textdelen med LZMA2\-filtret. +.TP +\fB\-\-filters\-help\fP +Visa ett hjälpmeddelande som beskriver hur man anger förinställningar och +anpassade filterkedjor i flaggorna \fB\-\-filters\fP och \fB\-\-filters1=\fP\fIfilter\fP +\&…\& \fB\-\-filters9=\fP\fIfilter\fP, och avsluta rent. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIflaggor\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIflaggor\fP] +.PD +Lägg till LZMA1\- eller LZMA2\-filter till filterkedjan. Dessa filter kan +endast användas som det sista filtret i kedjan. +.IP "" +LZMA1 är ett föråldrat filter, vilket stödjs nästan enbart på grund av det +föråldrade filformatet \fB.lzma\fP, vilket bara stödjer LZMA1. LZMA2 är en +uppdaterad version av LZMA1 för att lösa några praktiska problem med +LZMA1. Formatet \fB.xz\fP använder LZMA2 och stödjer inte LZMA1 +alls. Komprimeringshastigheten och förhållandena för LZMA1 är LZMA2 är +praktiskt taget desamma. +.IP "" +LZMA1 och LZMA2 delar samma uppättning \fIflaggor\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIförinställning\fP +Återställ alla LZMA1\- eller LZMA2\-\fIflaggor\fP till +\fIförinställning\fP. \fIFörinställning\fP består av ett heltal, vilket kan följas +av enskilda bokstäver som modifierar förinställningen. Heltalet kan vara +från \fB0\fP till \fB9\fP, motsvarande kommandoradsflaggorna \fB\-0\fP \&…\& +\fB\-9\fP. Den enda modifierare som stödjs för närvarande är \fBe\fP, vilket +motsvarar \fB\-\-extreme\fP. Om ingen \fBpreset\fP anges tas standardvärden på +LZMA1\- eller LZMA2\-\fIflaggor\fP från förinställningen \fB6\fP. +.TP +\fBdict=\fP\fIstorlek\fP +Ett lexikons (historiebufferts) \fIstorlek\fP indikerar hur många byte med +nyligen bearbetad okomprimerad data som hålls i minnet. Algoritmen försöker +hitta återkommande bytesekvenser (matchningar) i den okomprimerade datan, +och ersätta dem med referenser till datan som för närvarande finns i +lexikonet. Ju större lexikon, desto högre är sannolikheten att hitta en +matchning. Att öka lexikonets \fIstorlek\fP förbättrar alltså vanligen +komprimeringsförhållandet, men ett lexikon som är större än den +okomprimerade filen är ett slöseri med minne. +.IP "" +En typisk \fIstorlek\fP på lexikon är från 64\ KiB till 64\ MiB. Minimum är 4\ KiB. Det maximala för komprimering är för närvarande 1,5\ GiB (1536\ MiB). Dekomprimeraren stödjer redan lexikon upp till en byte mindre än 4\ GiB, vilket är det maximala för strömformaten LZMA1 och LZMA2. +.IP "" +Lexikon\fIstorlek\fP och matchhittaren (\fImf\fP) avgör tillsammans +minnesanvändningen för LZMA1\- eller LZMA2\-kodaren. Ett lika \fIstort\fP (eller +större) lexikon behövs för dekomprimering som det som användes vid +komprimeringen, minnesanvändningen för avkodaren avgörs alltså av +lexikonstorleken vid komprimering. Huvudena i \fB.xz\fP innehåller lexikonets +\fIstorlek\fP antingen som 2^\fIn\fP eller 2^\fIn\fP + 2^(\fIn\fP\-1), så dessa +\fIstorlekar\fP är lite att föredra för komprimering. Andra \fIstorlekar\fP kommer +avrundas uppåt när de lagras i huvuden i \fB.xz\fP. +.TP +\fBlc=\fP\fIlk\fP +Ange antalet literala kontextbitar. Minimum är 0 och maximum är 4; +standardvärdet är 3. Dessutom får inte summan av \fIlk\fP och \fIlp\fP överskrida +4. +.IP "" +Alla byte som inte kan kodas som matchningar kodas som literaler. Det vill +säga, literaler är helt enkelt 8\-bits byte som kodas en åt gången. +.IP "" +Den literala kodningen gör antagandet att de högsta \fIlk\fP bitarna av den +föregående okomprimerade byten korrelerar med nästa byte. Till exempel, i +typisk engelsk text följs ofta en versal bokstav av en gemen bokstav, och en +gemen bokstav följs vanligen av en annan gemen bokstav. I +teckenuppsättningen US\-ASCII är de högsta tre bitarna 010 för versala +bokstäver och 011 för gemena bokstäver. När \fIlk\fP är åtminstone 3 kan den +literala kodningen dra nytta av denna egenskap i den okomprimerade datan. +.IP "" +Standardvärdet (3) är normalt bra. Om man vill ha maximal komprimering, +prova \fBlc=4\fP. Ibland hjälper det lite, och ibland gör det komprimeringen +sämre. Om det gör den sämre, testa också \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Ange antalet literala positionsbitar. Minimum är 0 och maximum är 4; +standardvärdet är 0. +.IP "" +\fILp\fP påverkar vilken sorts justering i den okomprimerade datan som antas +vid kodning av literaler. Se \fIpb\fP nedan för mer information om justering. +.TP +\fBpb=\fP\fIpb\fP +Ange antalet positionsbitar. Minimum är 0 och maximum är 4; standardvärdet +är 2. +.IP "" +\fIPb\fP påverkar vilken sort justering i den okomprimerade datan som antas i +allmänhet. Standardvärdet betyder fyrbytejustering (2^\fIpb\fP=2^2=4), vilket +ofta är ett bra val när det inte finns någon bättre gissning. +.IP "" +När justeringen är känd kan en inställning av \fIpb\fP därefter reducera +filstorleken något. Till exempel, med textfiler som har en\-byte\-justering +(US\-ASCII, ISO\-8859\-*, UTF\-8) kan att sätta \fBpb=0\fP förbättra komprimeringen +något. För UTF\-16\-text är \fBpb=1\fP ett bra val. Om justeringen är ett udda +tal som 3 byte kan \fBpb=0\fP vara det bästa valet. +.IP "" +Även om den antagna justeringen kan anpassas med \fIpb\fP och \fIlp\fP föredrar +LZMA1 och LZMA2 ändå något 16\-byte\-justering. Det kan vara värt att ta med i +beräkningen vid design av filformat som sannolikt ofta kan komma att +komprimeras med LZMA1 eller LZMA2. +.TP +\fBmf=\fP\fIms\fP +Matchsökaren har en stor poverkan på kodarens hastighet, minnesanvändning +och komprimeringsförhållande. Vanligen är Hashkedje\-matchsökare snabbare än +Binärträdsmatchsökare. Standardvärdet beror på \fIföinställningen\fP: 0 +använder \fBhc3\fP, 1\(en3 använder \fBhc4\fP, och resten använder \fBbt4\fP. +.IP "" +Följande matchsökare stödjs. Formlerna för minnesanvändning nedan är grova +uppskattningar, vilka är närmast sanningen när \fIdict\fP är en tvåpotens. +.RS +.TP +\fBhc3\fP +Hashkedja med 2\- och 3\-bytehashning +.br +Minsta värde på \fInice\fP: 3 +.br +Minnesanvändning: +.br +\fIdict\fP · 7.5 (om \fIdict\fP ≤ 16 MiB); +.br +\fIdict\fP · 5,5 + 64 MiB (om \fIdict\fP > 16 MiB) +.TP +\fBhc4\fP +Hashkedja med 2\-, 3\- och 4\-bytehashning +.br +Minsta värde på \fInice\fP: 4 +.br +Minnesanvändning: +.br +\fIdict\fP · 7,5 (om \fIdict\fP ≤ 32 MiB); +.br +\fIdict\fP · 6,5 (om \fIdict\fP > 32 MiB) +.TP +\fBbt2\fP +Binärträd med 2\-bytehashning +.br +Minsta värde på \fInice\fP: 2 +.br +Minnesanvändning: \fIdict\fP · 9,5 +.TP +\fBbt3\fP +Binärträd med 2\- och 3\-bytehashning +.br +Minsta värde på \fInice\fP: 3 +.br +Minnesanvändning: +.br +\fIdict\fP · 11,5 (om \fIdict\fP ≤ 16 MiB); +.br +\fIdict\fP · 9,5 + 64 MiB (om \fIdict\fP > 16 MiB) +.TP +\fBbt4\fP +Binärträd med 2\-, 3\- och 4\-bytehashning +.br +Minsta värde på \fInice\fP: 4 +.br +Minnesanvändning: +.br +\fIdict\fP · 11,5 (om \fIdict\fP ≤ 32 MiB); +.br +\fIdict\fP · 10,5 (om \fIdict\fP > 32 MiB) +.RE +.TP +\fBmode=\fP\fIläge\fP +Komprimerings\fIläget\fP anger metoden som används för att analysera data +skapade av matchsökaren. De \fIlägen\fP som stödjs är \fBfast\fP och +\fBnormal\fP. Standardvärdet är \fBfast\fP för \fIförinställningarna\fP 0\(en3 och +\fBnormal\fP för \fIförinställningarna\fP 4\(en9 +.IP "" +Vanligen används \fBfast\fP med Hashkedjematchsökare och \fBnormal\fP med +Binärträdsmatchsökare. Detta är även vad \fIförinställningarna\fP gör. +.TP +\fBnice=\fP\fIlagom\fP +Ange vad som anses vara en lagom längt på en matchning. När en matchning på +åtminstone \fIlagom\fP byte hittats slutar algoritmen söka efter möjliga bättre +matchningar. +.IP "" +\fILagom\fP kan vara 2\(en273 byte. Högre värden tenderar att ge bättre +komprimeringsförhållande på bekostnad av tid. Standardvärdet beror på +\fIförinställningen\fP. +.TP +\fBdepth=\fP\fIdjup\fP +Ange det maximala sökdjupet i matchsökaren. Standardvärdet är specialvärdet +0, vilket får komprimeraren att avgöra ett lämpligt \fIdjup\fP från \fImf\fP och +\fInice\fP. +.IP "" +Lämpligt \fIdjup\fP för Hashkedjor är 4\(en100 och 16\(en1000 för +Binärträd. Att använda väldigt höga värden på \fIdjup\fP kan göra kodaren +extremt långsam för vissa filer. Undvik att sätta \fIdjup\fP över 1000 såvida +du inte är beredd att avbryta komprimeringen om den tar för lång tid. +.RE +.IP "" +Vid avkodning av råa strömmar (\fB\-\-format=raw\fP) behöver LZMA2 endast +lexikonets \fIstorlek\fP. LZMA1 behöver även \fIlc\fP, \fIlp\fP och \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIflaggor\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIflaggor\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIflaggor\fP] +.PD +Lägg till gren/anrop/hopp\-filter (branch/call/jump, BCJ) till +filterkedjan. Dessa filter kan inte användas som det sista filtret i +filterkedjan. +.IP "" +Ett BCJ\-filter konverterar relativa adresser i maskinkod till deras absoluta +motsvarigheter. Detta ändrar inte storleken på datan men det ökar +redundansen, vilket kan hjälpa LZMA2 att skapa 0\(en15\ % mindre +\&\fB.xz\fP\-filer. BCJ\-filtren är alltid reversibla, så att använda ett +BCJ\-filter för fel sorts data orsakar inte någon dataförlust, men det kan +göra komprimeringsförhållandet något sämre. BCJ\-filtren är mycket snabba +och använder en obetydling mängd minne. +.IP "" +Dessa BCJ\-filter har kända problem kopplade till komprimeringsförhållandet: +.RS +.IP \(bu 3 +Någr sortes filer som innehåller körbar kod (till exempel, objektfiler, +statiska bibliotek och Linux kärnmoduler) har adresserna i instruktionerna +fyllda med utfyllnadsvärden. Dessa BCJ\-filter kommer ändå göra +adresskonverteringen, vilket kommer göra komprimeringen sämre för dessa +filer. +.IP \(bu 3 +Om ett BCJ\-filter används på ett arkiv är det möjligt att det gör +komprimeringsförhållandet sämre än att inte använda något BCJ\-filter. Till +exempel, om det finns liknande eller till och med identiska körbara kommer +filtreringen sannolikt göra filerna mindre lika och därmed blir +kompressionen sämre. Innehållet i icke körbara filer i samma arkiv kan också +spela en roll. I praktiken måste man prova med och utan ett BCJ\-filter för +att se vilket som är det bästa i varje situation. +.RE +.IP "" +Olika instruktionsuppsättningar har olika justering: den körbara filen måste +vara justerad till en multipel av detta värde i indata för att filtret skall +fungera. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Filter;Justering;Kommentarer +x86;1;32\-bitars eller 64\-bitars x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;4096\-bytesjustering är bäst +PowerPC;4;Endast rak byteordning +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Eftersom BCJ\-filtrerad data vanligen komprimeras med LZMA2 kan +komprimeringsförhållandet förbättras något om LZMA2\-flaggorna sätts till att +matcha justeringen hos det valda BCJ\-filtret. Exempel: +.RS +.IP \(bu 3 +IA\-64\-filter har 16\-bytejustering så \fBpb=4,lp=4,lc=0\fP är bra med LZMA2 +(2⁴=16). +.IP \(bu 3 +RISC\-V\-kod har 2\-byte\- eller 4\-bytejustering beroende på huruvida filen +innehåller 16\-bitars komprimerade instruktioner (utvidgningen C). När +16\-bitarsinstruktioner används är \fBpb=2,lp=1,lc=3\fP eller \fBpb=1,lp=1,lc=3\fP +bra. När det inte finns några 16\-bitsinstruktioner är \fBpb=2,lp=2,lc=2\fP +bäst. \fBreadelf \-h\fP kan användas för att kontrollera om ”RVC” förekommer på +raden ”Flaggor”. +.IP \(bu 3 +ARM64 är alltid 4\-bytejusterad så \fBpb=2,lp=2,lc=2\fP är bäst. +.IP \(bu 3 +Filtret x86 är ett undantag. Det är normalt bra att hålla sig till LZMA2:s +standardvärden (\fBpb=2,lp=0,lc=3\fP) när körbar x86 komprimeras. +.RE +.IP "" +Alla BCJ\-filter stödjer samma \fIflaggor\fP: +.RS +.TP +\fBstart=\fP\fIavstånd\fP +Ange start\fIavståndet\fP som används vid konvertering mellan relativa och +absoluta adresser. \fIAvståndet\fP måste vara en multipel av filtrets justering +(se tabellen ovan). Standardvärdet är noll. I praktiken är standardvärdet +bra; det är nästan aldrig användbart att ange ett anpassat \fIavstånd\fP. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIflaggor\fP] +Lägg till Deltafiltret till filterkedjan. Deltafiltret kan inte användas som +det sista filtret i filterkedjan. +.IP "" +För närvarande stödjs bara enkel byte\-vis deltaberäkning. Det kan vara +användbart vid komprimering, till exempel av okomprimerade +bitavbildningsbilder eller okomprimerad PCM\-audio. Dock kan algoritmer för +särskilda ändamål ge betydligt bättre resultat än Delta + LZMA2. Detta är +särskilt sant med audio, vilket komprimerar snabbare och bättre med till +exempel \fBflac\fP(1). +.IP "" +Stödda \fIflaggor\fP: +.RS +.TP +\fBdist=\fP\fIavstånd\fP +Ange \fIavståndet\fP för deltaberäkningen i byte. \fIAvstånd\fP måste varea +1\(en256. Standardvärdet är 1. +.IP "" +Till exempel, med \fBdist=2\fP och åtta byte indata A1 B1 A2 B3 A3 B5 A4 B7, +kommer utdata vara A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Andra flaggor" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Utelämna varningar och noteringar. Ange detta två gånger för att även +utelämna felmeddelandet. Denna flagga har ingen påverkan på +slutstatusen. Det vill säga, även om en varning utelämnades kommer +slutstatusen fortfarandeindikera att en varning gavs. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Var utförlig. Om standard fel är kopplat till en terminal kommer \fBxz\fP visa +en förloppsmätare. Att ange \fB\-\-verbose\fP två gånger kommer ge än mer +utförlig utmatning. +.IP "" +Förloppsmätaren visar följande information: +.RS +.IP \(bu 3 +Procent färdigt visas om storleken på indatafilen är känd. Det vill säga, +procentsatsen kan inte visas i rör. +.IP \(bu 3 +Mängd komprimerad data som producerats (komprimering) eller konsumerats +(dekomprimering). +.IP \(bu 3 +Mängd okomprimerad data som konsumerats (komprimering) eller producerats +(dekomprimering). +.IP \(bu 3 +Komprimeringsförhållande, vilket beräknas genom att dividera mängden +komprimerad data bearbetad så lång med mängde okomprimerad data bearbetad så +långt. +.IP \(bu 3 +Kompressions eller dekompressionshastighet. Detta mäts som mängden +okomprimerad data konsumerad (komprimering) eller producerad +(dekomprimering) per sekund. Det visas efter att några sekunder har gåt +efter att \fBxz\fP började bearbeta filen. +.IP \(bu 3 +Förfluten tid på formatet MM:SS eller H:MM:SS. +.IP \(bu 3 +Beräknad återstående tid visas endast när storleken på indatafilen är känd +och några sekunder redan gått efter att \fBxz\fP började bearbeta filen. Tiden +visas i ett mindre precist format vilket aldrig har några kolon, till +exempel, 2 min 30 s. +.RE +.IP "" +När standard fel inte är en terminal kommer \fB\-\-verbose\fP göra att \fBxz\fP +skriver filnamnet, komprimerad storlek, okomprimerad storlek, +komprimeringsförhållande och möjligen även hastigheten och den förlupna +tiden på en enda rad till standard fel efter att ha komprimerat eller +dekomprimerat filen. Hastigheten och den förlupna tiden inkluderas endast +när åtgärden tog åtminstone några sekunder. Om åtgärden inte slutfördes, +till exempel för att användaren avbröt, skrivs även den fullbordade +procentsatsen om storleken på indatafilen är känd. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Sätt inte slutstatus till 2 även om ett tillstånd som är värt en varning +upptäcktes. Denna flagga påverkar inte utförlighetsnivån, allts måste både +\fB\-\-quiet\fP och \fB\-\-no\-warn\fP användas för att inte visa varningar och för att +inte ändra slutstatusen. +.TP +\fB\-\-robot\fP +Skriv meddelanden i maskinläsbart form. Detta är avsett att förenkla att +skriva framändar som vill använda \fBxz\fP istället för liblzma, vilken kan +vara fallet i olika skript. Utdatan med denna flagga aktiverad är avsedd att +vara stabil mellan utgåvor av \fBxz\fP. Se avsnitett \fBROBOTLÄGE\fP för detaljer. +.TP +\fB\-\-info\-memory\fP +Visa, på mänskligt läsbar form, hur mycket fysiskt minne (RAM) och hur många +processortrådar \fBxz\fP tror att systemet har och gränserna för +minnesanvändning vid komprimering och dekomprimering, och avsluta. +.TP +\fB\-h\fP, \fB\-\-help\fP +Visa ett hjälpmeddelande som beskriver de vanligast använda flaggorna, och +avsluta. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Visa ett hjälpmeddelande som beskriver alla funktioner i \fBxz\fP, och avsluta +.TP +\fB\-V\fP, \fB\-\-version\fP +Visa versionsnumret för \fBxz\fP och liblzma i mänskligt läsbar form. För att +få maskinläsbar utdata, ange \fB\-\-robot\fP före \fB\-\-version\fP. +. +.SH ROBOTLÄGE +Robotläget aktiveras med flaggan \fB\-\-robot\fP. Det gör att utdata från \fBxz\fP +är enklare att tolka av andra program. För närvarande stödjs \fB\-\-robot\fP +endast tillsammans med \fB\-\-list\fP, \fB\-\-filters\-help\fP, \fB\-\-info\-memory\fP och +\fB\-\-version\fP. Den kommer att stödjas för komprimering och dekomprimering i +framtiden. +. +.SS Listläge +\fBxz \-\-robot \-\-list\fP använder tab\-separerad utmatning. Första kolumnen av +varje rad har en sträng som indikerar typen av informationen som finns på +den raden: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Detta är alltid första raden när en fil börjar listas. Den andra kolumen på +raden är filnamnet. +.TP +\fBfile\fP +Denna rad innehåller övergripande information om \fB.xz\fP\-filen. Denna rad +skrivs alltid efter raden \fBname\fP. +.TP +\fBstream\fP +Denna radtyp används endast när \fB\-\-verbose\fP angetts. Det finns lika många +\fBstream\fP\-rader som det finns strömmar i \fB.xz\fP\-filen. +.TP +\fBblock\fP +Denna radtyp används bara när \fB\-\-verbose\fP angetts. Det finns lika många +\fBblock\fP\-rader som det finns block i \fB.xz\fP\-filen. \fBblock\fP\-rader visas +efter alla \fBstream\fP\-raderna; olika radtyper blandas inte. +.TP +\fBsummary\fP +Denna radtyp används bara när \fB\-\-verbose\fP angetts två gånger. Denna rad +skrivs eefter alla \fBblock\fP\-rader. Liksom raden \fBfile\fP inenhåller raden +\fBsummary\fP övergripande information om \fB.xz\fP\-filen. +.TP +\fBtotals\fP +Denna rad är alltid den allra sista raden i listutmatningen. Den visar det +totala antalen och storlekarna. +.PP +Kolumnerna på \fBfile\fP\-raderna: +.PD 0 +.RS +.IP 2. 4 +Antalet strömmar i filen +.IP 3. 4 +Totalt antal block i strömmarna +.IP 4. 4 +Komprimerad storlek på filen +.IP 5. 4 +Okomprimerad storlek på filen +.IP 6. 4 +Komprimeringsförhållande, till exempel \fB0.123\fP. Om förhållandet är över +9.999 visas tre bindestreck (\fB\-\-\-\fP) istället för förhållandet. +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Kommaseparerad lista med integritetskontrollnamn. Följande strängar används +för de kända kontrolltyperna: \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP och +\fBSHA\-256\fP. För okända kontrolltyper används \fBUnknown\-\fP\fIN\fP, där \fIN\fP är +kontroll\-ID:t som ett decimalt nummer (en eller två siffror). +.IP 8. 4 +Total storlek på strömutfyllnad i filen +.RE +.PD +.PP +Kolumnerna på \fBstream\fP\-raderna: +.PD 0 +.RS +.IP 2. 4 +Strömnummer (den första strömmen är 1) +.IP 3. 4 +Antal block i strömmen +.IP 4. 4 +Komprimerat startavstånd +.IP 5. 4 +Okomprimerat startavstånd +.IP 6. 4 +Komprimerad storlek (inkluderar inte strömutfyllnad) +.IP 7. 4 +Okomprimerad storlek +.IP 8. 4 +Komprimeringsförhållande +.IP 9. 4 +Namnet på integritetskontrollen +.IP 10. 4 +Storleken på strömutfyllnad +.RE +.PD +.PP +Kolumnerna på \fBblock\fP\-raderna: +.PD 0 +.RS +.IP 2. 4 +Numret på strömmen som innehåller detta block +.IP 3. 4 +Blocknummer relativt början på strömmen (det första blocket är 1) +.IP 4. 4 +Blocknummer relativt början på filen +.IP 5. 4 +Komprimerat startavstånd relativt början av filen +.IP 6. 4 +Okomprimerat startavstånd relativt början av filen +.IP 7. 4 +Total komprimerad storlek på blocket (inkluderar huvuden) +.IP 8. 4 +Okomprimerad storlek +.IP 9. 4 +Komprimeringsförhållande +.IP 10. 4 +Namnet på integritetskontrollen +.RE +.PD +.PP +Om \fB\-\-verbose\fP angavs två gånger inkluderas ytterligare kolumner på +\fBblock\fP\-raderna. Dessa visas inte med bara ett \fB\-\-verbose\fP, eftersom det +för att få fram denna information krävs många sökningar och kan därmed vara +långsamt: +.PD 0 +.RS +.IP 11. 4 +Värdet på integritetskontrollen hexadecimalt +.IP 12. 4 +Blockhuvudstorlek +.IP 13. 4 +Blockflaggor: \fBc\fP indikerar att komprimerad storlek finns, och \fBu\fP +indikerar att okomprimerad storlek finns. Om flaggan inte är satt visas ett +bindestreck (\fB\-\fP) istället för att hålla stränglängden fast. Nya flaggor +kan läggas till i slutet av strängen i frmtiden. +.IP 14. 4 +Storlek på den faktiska komprimerade datan i blocket (detta utelämnar +blockhuvud, blockutfyllnad och kontrollfält) +.IP 15. 4 +Mängd minne (i byte) som behövs för att dekomprimera detta block med denna +version av \fBxz\fP +.IP 16. 4 +Filterkedja. Observera att de flesta av flaggorna som användes vid +komprimeringstillfället inte kan vara kända, eftersom endat de flaggor som +behövs för dekomprimering lagras i \fB.xz\fP\-huvudet. +.RE +.PD +.PP +Kolumnerna på \fBsummary\fP\-raderna: +.PD 0 +.RS +.IP 2. 4 +Mängd minne (i byte) som behövs för att dekomprimera denna fil med denna +version av \fBxz\fP +.IP 3. 4 +\fByes\fP eller \fBno\fP som indikerar om alla blockhuvuden både har komprimerad +storlek och okomprimerad storlek i sig +.PP +\fIFrån\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Minsta version av \fBxz\fP som krävs för att dekomprimera filen +.RE +.PD +.PP +Kolumnerna på \fBtotals\fP\-raden: +.PD 0 +.RS +.IP 2. 4 +Antal strömmar +.IP 3. 4 +Antal block +.IP 4. 4 +Komprimerad storlek +.IP 5. 4 +Okomprimerad storlek +.IP 6. 4 +Genomsnittligt komprimeringsförhållande +.IP 7. 4 +Kommaseparerad lista med integritetskontrollnamn som fanns i filerna +.IP 8. 4 +Strömutfyllnadsstorlek +.IP 9. 4 +Antal filer. Denna finns här för att hålla ordningen av de tidigare +kolumnerna desamma som på \fBfile\fP\-rader. +.PD +.RE +.PP +Om \fB\-\-verbose\fP angavs två gånger inkluderas ytterligare kolumner på +\fBtotals\fP\-raden: +.PD 0 +.RS +.IP 10. 4 +Maximal mängd minne (i byte) som behövs för att dekomprimera filerna med +denna version av \fBxz\fP +.IP 11. 4 +\fByes\fP eller \fBno\fP som indikerar om alla blockhuvuden både har komprimerad +storlek och okomprimerad storlek i sig +.PP +\fIFrån\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Minsta version av \fBxz\fP som krävs för att dekomprimera filen +.RE +.PD +.PP +Framtida versioner kan lägga till fler radtyper och fler kolumner kan läggas +til på de befintliga radtyperna, men de befintliga kolumnerna kommmer inte +ändras. +. +.SS Filterhjälp +\fBxz \-\-robot \-\-filters\-help\fP skriver ut de filter som stödjs i följande +format: +.PP +\fIfilter\fP\fB:\fP\fIflagga\fP\fB=<\fP\fIvärde\fP\fB>,\fP\fIflagga\fP\fB=<\fP\fIvärde\fP\fB>\fP… +.TP +\fIfilter\fP +Namn på filtret +.TP +\fIflagga\fP +Namn på en filterspecifik flagga +.TP +\fIvärde\fP +Numeriska \fIvärde\fPintervall ser ut som +\fB<\fP\fImin\fP\fB\-\fP\fImax\fP\fB>\fP. Sträng\fIvärdes\fP val visas inom \fB< >\fP och separerade med ett \fB|\fP\-tecken. +.PP +Varje filter skrivs på en egen rad. +. +.SS Minnesgränsinformation +\fBxz \-\-robot \-\-info\-memory\fP skriver en rad med flera tab\-separerade +kolumner: +.IP 1. 4 +Total mängd med fysiskt minne (RAM) i byte. +.IP 2. 4 +Minnesanvändningsgräns för komprimering i byte (\fB\-\-memlimit\-compress\fP). Ett +specialvärde \fB0\fP indikerar standardinställningen vilken för enkeltrådat +läge är detsamma som ingen gräns. +.IP 3. 4 +Minnesanvändningsgräns för dekomprimering i byte +(\fB\-\-memlimit\-decompress\fP). Ett specialvärde \fB0\fP indikerar +standdartinställningen vilken för enkeltrådat läge är detsamma som ingen +gräns. +.IP 4. 4 +Från \fBxz\fP 5.3.4alpha: Minnesanvändningen för multitrådad dekomprimering i +byte (\fB\-\-memlimit\-mt\-decompress\fP). Detta är aldrig noll eftersom ett +systemspecifikt standardvärde som visas i kolumn 5 används om ingen gräns +har angivits uttryckligen. Detta är heller aldrig större än värdet i kolumn +3 även om ett större värde har angivits med \fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Från \fBxz\fP 5.3.4alpha: Ett systemspecifikt standardgräns för +minnesanvändning som används för att begränsa antalet trådar vid +komprimering med ett automatiskt antal trådar (\fB\-\-threads=0\fP) och ingen +gräns för minnesanvändning har angivits (\fB\-\-memlimit\-compress\fP). Detta +används även som standardvärdet på \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Från \fBxz\fP 5.3.4alpha: antal tillgängliga processortrådar. +.PP +I framtiden kan utdata från \fBxz \-\-robot \-\-info\-memory\fP ha fler kolumner, +men aldrig mer än en rad. +. +.SS Version +\fBxz \-\-robot \-\-version\fP skriver versionsnumret på \fBxz\fP och liblzma i +följande format: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Huvudversion. +.TP +\fIYYY\fP +Underversion. Jämna nummer är stabila. Udda nummer är alfa\- eller +betaversioner. +.TP +\fIZZZ\fP +Rättningsnivå för stabila utgåvor eller bara en räknare för +utvecklingsutgåvor. +.TP +\fIS\fP +Stabilitet. 0 är alfa, 1 beta beta och 2 är stabil. \fIS\fP skall alltid vara +2 när \fIYYY\fP är jämnt. +.PP +\fIXYYYZZZS\fP är samma på båda raderna om \fBxz\fP och liblzma kommer från samma +utgåva av XZ Utils. +.PP +Exempel: 4.999.9beta är \fB49990091\fP och 5.0.0 är \fB50000002\fP. +. +.SH SLUTSTATUS +.TP +\fB0\fP +Allt är bra. +.TP +\fB1\fP +Ett fel uppstod. +.TP +\fB2\fP +Något värt en varning uppstod, men inga faktiska fel uppstod. +.PP +Noteringar (inte varningar eller fel) som skrivs på standard fel påverkar +inte slutstatusen. +. +.SH MILJÖ +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP tolkar mellanrumsseparerade listor av flaggor från miljövariablerna +\fBXZ_DEFAULTS\fP och \fBXZ_OPT\fP, i den ordningen, före flaggorna på +kommandoraden. Observera att endast flaggor tolkas från miljövariablerna; +alla andra argument än flaggor ignoreras tyst. Tolkningen görs med +\fBgetopt_long\fP(3) vilket även används för kommandoradsargumenten. +.PP +\fBVarning:\fP genom att sätta dessa miljövariabler ändrar man i praktiken +program och skript som kör \fBxz\fP. för det mesta är set säkert att sätta +begränsningar på minnesanvändning, antal trådar och komprimeringsflaggor via +miljövariablerna. Några flaggor kan dock göra att skript går sönder. Ett +uppenbart exempel är \fB\-\-help\fP vilket gör att \fBxz\fP visar en hjälptext +istället för att komprimera eller dekomprimera en fil. Mer subtila exempel +är \fB\-\-quiet\fP och \fB\-\-verbose\fP. I många fall fungerar det bra att aktivera +en förloppsindikator med \fB\-\-verbose\fP, men i några fall skapar de extra +meddelandena problem. Utförlighetsnivån påverkar även beteendet hos +\fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Användarspecifika eller systemspecifika standardflaggor. Typiskt sätts detta +i ett initieringsskript för skal för att aktivera \fBxz\fP:s begränsning av +minnesanvändning som standard eller att ställa in ett standardantal +trådar. Med undantag för skalinitieringsskript och liknande specialfall +skall skript aldrig sätta eller ta bort \fBXZ_DEFAULTS\fP. +.TP +\fBXZ_OPT\fP +Detta är för att skicka flaggor till \fBxz\fP när det inte är möjligt att sätta +flaggorna direkt på kommandoraden för \fBxz\fP. Detta är fallet när \fBxz\fP körs +av ett skript eller verktyg, till exempel, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf apa.tar.xz apa\fR +.fi +.RE +.RE +.IP "" +Skript kan använda \fBXZ_OPT\fP, till exempel, för att sätta skriptspecifika +standardflaggor för komprimering. Det rekommenderas fortfarande att tillåta +användaren att åsidosätta \fBXZ_OPT\fP om det är rimligt. Till exempel, i +\fBsh\fP(1)\-skript kan man använda något i still med detta: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "KOMPATIBILITET MED LZMA UTILS" +Kommandoradssyntaxen för \fBxz\fP är praktiskt taget en utökning av \fBlzma\fP, +\fBunlzma\fP och \fBlzcat\fP så som de kommer från LZMA Utils 4.32.x. I de flesta +fall, är det möjligt att ersätta LZMA Utils med XZ Utils utan att göra +sönder befintliga skript. Det finns dock några inkompatibiliteter, vilka +ibland kan orsaka problem. +. +.SS "Komprimeringens förinställda nivåer" +Numreringen av förinställda nivåer för komprimering är inte identiska i +\fBxz\fP och LZMA Utils. Den viktigaste skillnade är hur lexikonstorlekar +avbildas till olika förinställningar. Lexikonstorleken är i stort sett lika +med dekomprimerarens minnesanvändning. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nivå;xz;LZMA Utils +\-0;256 KiB;N/A +\-1;1 MiB;64 KiB +\-2;2 MiB;1 MiB +\-3;4 MiB;512 KiB +\-4;4 MiB;1 MiB +\-5;8 MiB;2 MiB +\-6;8 MiB;4 MiB +\-7;16 MiB;8 MiB +\-8;32 MiB;16 MiB +\-9;64 MiB;32 MiB +.TE +.RE +.PP +Lexikonstorlekens skillnader påverkar komprimerarens minnesanvändning också, +men det finns några andra skillnader mellan LZMA Utils och XZ Utils, vilket +gör skillnaden ännu större: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Nivå;xz;LZMA Utils 4.32.x +\-0;3 MiB;N/A +\-1;9 MiB;2 MiB +\-2;17 MiB;12 MiB +\-3;32 MiB;12 MiB +\-4;48 MiB;16 MiB +\-5;94 MiB;26 MiB +\-6;94 MiB;45 MiB +\-7;186 MiB;83 MiB +\-8;370 MiB;159 MiB +\-9;674 MiB;311 MiB +.TE +.RE +.PP +Standardförinställningsninvån i LZMA Utils är \fB\-7\fP medan i XZ Utils är den +\fB\-6\fP, så båda använder ett 8 MiB lexikon som standard. +. +.SS "Strömmade visavi icke strömmade .lzma\-filer" +Den ikomprimerade storleken på filen kan lagras i huvudet i \fB.lzma\fP. LZMA +Utils gör det när den komprimerar normala filer. Alternativet är att markera +att den okomprimerade storleken är okänd och använda en markör för lastslut +för att indikera var dekomprimeraren skall stanna. LZMA Utils använder denna +metod när den okomprimerade storleken inte är känd, vilket är fallet, till +exempel, i rör. +.PP +\fBxz\fP stödjer dekomprimering av \fB.lzma\fP\-filer med eller utan markör för +lastslut, men alla \fB.lzma\fP filer som skapas av \fBxz\fP kommer använda markör +för lastslut och ha den okomprimerade storleken markerad som okänd i +\&\fB.lzma\fP\-huvudet. Detta kan bli ett problem i några ovanliga fall. Till +exempel kan en \fB.lzma\fP\-dekomprimerare i en inbäddad enhet fungera endast +med filer som har en känd okomprimerad storlek. Om man stöter på detta +problem behöver man använda LZMA Utils eller LZMA SDK för att skapa +\&\fB.lzma\fP\-filer med känd okomprimerad storlek. +. +.SS "Ej stödda .lzma\-filer" +Formatet \fB.lzma\fP tillåter värden på \fIlc\fP upp till 8, och värden på \fIlp\fP +upp till 4. LZMA Utils kan dekomprimera filer med godtyckliga \fIlc\fP och +\fIlp\fP, men skapar alltid filer med \fBlc=3\fP och \fBlp=0\fP. Att skapa filer med +andra \fIlc\fP och \fIlp\fP är möjligt med \fBxz\fP och med LZMA SDK. +.PP +Implementationen av LZMA1\-filtret i liblzma kräver att summan av \fIlc\fP och +\fIlp\fP inte överstiger 4. Alltså, \fB.lzma\fP\-filer, vilka överstiger denna +gräns, kan inte dekomprimeras med \fBxz\fP. +.PP +LZMA Utils skapar endast \fB.lzma\fP\-filer som har en lexikonstorlek på 2^\fIn\fP +(en potens av 2) men godtar filer med godtycklig lexikonstorlek. liblzma +godtar endast \fB.lzma\fP\-filer som har en lexikonstorlek på 2^\fIn\fP eller +2^\fIn\fP + 2^(\fIn\fP\-1). Detta är för att minska falska positiva vid detektering +av \fB.lzma\fP\-filer. +.PP +Dessa begränsningar bör inte vara ett problem i praktiken, eftersom +praktiskt taget alla \fB.lzma\fP\-filer har komprimerats med inställningar som +liblzma kommer godta. +. +.SS "Avslutande skräp" +Vid dekomprimering ignorerar LZMA Utils tyst allting efter den första +\&\fB.lzma\fP\-strömmen. I de flesta situationer är detta fel. Detta betyder även +att LZMA Utils inte stödjer dekomprimering av konkatenerade \fB.lzma\fP\-filer. +.PP +Om det finns data kvar efter den första \fB.lzma\fP\-strömmen betraktar \fBxz\fP +filen som trasig om inte \fB\-\-single\-stream\fP användes. Detta kan göra sönder +obskyra skript vilka har antagit att avslutande skräp ignoreras. +. +.SH NOTERINGAR +. +.SS "Den komprimerade utdatan kan variera" +Den exakta komprimerade utdatan som produceras från samma okomprimerade +indatafil kan variera mellan versioner av XZ Utils även om +komprimeringsflaggorna är identiska. Detta beror på att kodaren kan +förbättras (snabbare eller bättre komprimering) utan att påverka +filformatet. Utdatan kan variera även mellan olika byggen av samma version +av XZ Utils, om olika byggflaggor används. +.PP +Ovanstående betyder att när väl \fB\-\-rsyncable\fP har implementerats kommer +inte nödvändigtvis de resulterande filerna vara rsync\-bara om inte både +gamla och nya filer har komprimerats med samma version av xz. Detta problem +kan lösas om en del av kodarimplementeringen fryses för att hålla rsync\-bar +utdata stabil mellan xz\-versioner. +. +.SS "Inbäddade .xz\-dekomprimerare" +Inbäddade implementationer av \fB.xz\fP\-dekomprimerare som XZ Embedded stödjer +inte nödvändigtvis filer som skapas med andra typer av +integritets\fIkontroll\fP än \fBnone\fP och \fBcrc32\fP. Eftersom standardvärdet är +\fB\-\-check=crc64\fP måste man använda \fB\-\-check=none\fP eller \fB\-\-check=crc32\fP +när filer skapas för inbäddade system. +.PP +Utanför inbäddade system stödjer alla dekomprimerare av \fB.xz\fP\-format alla +typerna av \fIkontroller\fP, eller åtminstone kan de dekomprimera filern utan +att verifiera integritetskontrollen om den specifika \fIkontrollen\fP inte +stödjs. +.PP +XZ Embedded stödjer BCJ\-filter, men endast med standard startavstånd. +. +.SH EXEMPEL +. +.SS Grundläggande +Komprimera filen \fIapa\fP till \fIapa.xz\fP med standardkomprimeringsnivån +(\fB\-6\fP), och ta bort \fIapa\fP om komprimeringen lyckas: +.RS +.PP +.nf +\f(CRxz apa\fR +.fi +.RE +.PP +Dekomprimera \fIbepa.xz\fP till \fIbepa\fP och ta inte bort \fIbepa.xz\fP även om +dekomprimeringen lyckas: +.RS +.PP +.nf +\f(CRxz \-dk bepa.xz\fR +.fi +.RE +.PP +Skapa \fIcepa.tar.xz\fP med förinställningen \fB\-4e\fP (\fB\-4 \-\-extreme\fP), vilket +är långsammare än standardvärdet \fB\-6\fP, men behöver mindre minne till +komprimering och dekomprimering (48\ MiB respektive 5\ MiB): +.RS +.PP +.nf +\f(CRtar cf \- cepa | xz \-4e > cepa.tar.xz\fR +.fi +.RE +.PP +En blandning av komprimerade och okomprimerade filer kan dekomprimeras till +standard ut med ett enda kommando: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Parallell komprimering av många filer" +På GNU och *BSD kan \fBfind\fP(1) och \fBxargs\fP(1) användas för att +parallellisera komprimeringen av många filer: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Flaggan \fB\-P\fP till \fBxargs\fP(1) anger antalet parallella \fBxz\fP\-processer. Det +bästa värdet till flaggan \fB\-n\fP beror på hur många filer det finns som skapp +komprimeras. Om det bara finns några stycken filer bör värdet förmodigen +vara 1; med tiotusentals filer kan 100 eller mer vara lämpligt för att +reducera antalet \fBxz\fP\-processer som \fBxargs\fP(1) kommer att skapa. +.PP +Flaggan \fB\-T1\fP till \fBxz\fP finns för att tvinga den till enkeltrådsläge, +eftersom \fBxargs\fP(1) används för att styra mängden parallellisering. +. +.SS Robotläge +Beräkna hur många byt som har sparats totalt efter komprimering av flera +filer: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Ett skript kan vilja veta att det använder en tillräckligt ny +\fBxz\fP. Följande \fBsh\fP(1)\-skript kontrollerar att versionsnumret för +verktyget \fBxz\fP är åtminstone 5.0.0. Denna metod är kompatibel med gamla +betaversioner, vilka inte stödde flaggan \fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Din xz är för gammal." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Ange en gräns för minnesanvändning för dekomprimering med \fBXZ_OPT\fP, men om +en gräns redan har satts, öka den inte: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Anpassade komprimerarfilterkedjor" +Den enklaste användningen av anpassade filterkedjor är att anpassa en +LZMA2\-förinställning. Detta kan vara användbart eftersom förinställningarna +endast täcker en delmängd av de potentiellt användbara kombinationerna av +komprimeringsinställningar. +.PP +Kolumnerna CompCPU i tabellerna från beskrivningen av flaggorna options +\fB\-0\fP ... \fB\-9\fP och \fB\-\-extreme\fP är användbara vid anpassning av +LZMA2\-förinställningar. Här är de relevanta delarna samlade från dessa två +tabeller: +.RS +.PP +.TS +tab(;); +c c +n n. +Förinställning;KompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Om man vet att en fil behöver ett rätt stort lexikon (till exempel, 32\ MiB) +för att komprimeras bra, men man vill komprimera den snabbare än \fBxz \-8\fP +skulle gjort kan en förinställning med ett lågt värde på CompCPU (till +exempel, 1) ändras till att använda ett större lexikon: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB apa.tar\fR +.fi +.RE +.PP +Med vissa filer kan ovanstående kommando vara snabbare än \fBxz \-6\fP samtidigt +som det komprimerar betydligt bättre. Dock måste det påpekas att endast +några filer drar fördel av ett stort lexikon samtidigt som värdet CompCPU +hålls lågt. Den mest uppenbara situationen, är ett stort lexikon kan hälpa +till mycket, är ett arkiv som innehåller väldigt snarlika filer på åtmistone +några megabyte var. Lexikonstorleken måste vara signifikant större än någon +enskild fil för att låta LZMA2 dra full nytta av likheterna mellan på +varandra följande filer. +.PP +Om det går bra med väldigt hög minnesanvändning i komprimeraren och +dekomprimeraren, och filen som komprimeras är åtminstone flera hundra +megabyte, kan det vara användbart att använda ännu större lexikon än de 64 +MiB som \fBxz \-9\fP skulle använda: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB stor_apa.tar\fR +.fi +.RE +.PP +Att använda \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP) som i exemplet ovan kan vara +användbart för att se minnesbehoven för komprimeraren och +dekomprimeraren. Kom ihåg att använda ett större lexikon än storleken på den +okomprimerade filen är slöseri med minne, så ovanstående kommando är inte +användbart för små filer. +.PP +Ibland spelar inte dekomprimeringstiden någon roll, men dekomprimerarens +minnesanvändning måste hållas låg, till exempel för att göra det möjligt att +dekomprimera filen på ett inbäddat system. Följande kommando använder \fB\-6e\fP +(\fB\-6 \-\-extreme\fP) som en bas och sätter lexikonstorleken till bara 64\ KiB. Den resulterande filen kan dekomprimeras med XZ Embedded (det är därför +det finns \fB\-\-check=crc32\fP) som använder ungerfär 100\ KiB minne. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB apa\fR +.fi +.RE +.PP +Om man vill krama ur så många byte som möjligt kan justering av antalet +literala kontextbitar (\fIlc\fP) och antalet positionsbitar (\fIpb\fP) ibland +hjälpa. Justering av antalet literala positionsbitar (\fIlp\fP) kan också +hjälpa, men vanligen är \fIlc\fP och \fIpb\fP viktigare. Till exempel innehåller +ett källkodsarkiv huvudsakligen US\-ASCII\-text, så något i stil med följande +kan ge aningen (som 0.1\ %) mindre fil än \fBxz \-6e\fP (försök även utan +\fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 källkod.tar\fR +.fi +.RE +.PP +Att använda ett annat filter tillsammans med LZMA2 kan förbättra +komprimeringen med vissa filtyper. Till exempel, för att komprimera ett +delat x86\-32\- eller x86\-64\-bibliotek med filtret x86 BCJ: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libapa.so\fR +.fi +.RE +.PP +Observera att ordningen på filterflaggorna spelar roll. Om \fB\-\-x86\fP anges +efter \fB\-\-lzma2\fP kommer \fBxz\fP avge ett fel, eftersom det inte kan vara något +filter efter LZMA2, och även för att filtret x86 BCJ inte kan användas som +det sista filtret i kedjan. +.PP +Deltafiltret tillsammans med LZMA2 gan ge bra resultat med +bitkartebilder. Det bör vanligen slå PNG, som har några mer avancerade +filter än enkla delta men använder Deflat för den faktiska komprimeringen. +.PP +Bilden måste sparas i okomprimerat format, till exempel som okomprimerad +TIFF. Avståndsparametern i Deltafiltret sätts till att motsvara natalet byte +per bildpunkt i bilden. Till exempel, 24\-bitars RGB bitkarta behöver +\fBdist=3\fP, och det är även bra att skicka \fBpb=0\fP till LZMA2 för att ge +plats för trebytejustering: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 apa.tiff\fR +.fi +.RE +.PP +Om flera bilder har lagts in i ett gemensamt arkiv (till exempel, \fB.tar\fP) +kommer Deltafiltret fungera på det också så länge alla bilder har samma +antal byte per bildpunkt. +. +.SH "SE ÄVEN" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +XZ Embedded: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xzcmp.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xzcmp.1 new file mode 100644 index 0000000000000000000000000000000000000000..2d1516dcb59720f083abf68f8101c5de6fb19a89 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xzcmp.1 @@ -0,0 +1,54 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Swedish translation of xz-man +.\" Göran Uddeborg , 2025. +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 2025\-03\-06 Tukaani "XZ Utils" +.SH NAMN +xzcmp, xzdiff, lzcmp, lzdiff — jämför komprimerade filer +. +.SH SYNOPSIS +\fBxzcmp\fP [\fIflagga…\fP] \fIfil1\fP [\fIfil2\fP] +.br +\fBxzdiff\fP \&… +.br +\fBlzcmp\fP \&… (FÖRÅLDRAT) +.br +\fBlzdiff\fP \&… (FÖRÅLDRAT) +. +.SH BESKRIVNING +\fBxzcmp\fP och \fBxzdiff\fP jämför det okomprimerade innehållet i två +filer. Okomprimerad data skickas till \fBcmp\fP(1) eller \fBdiff\fP(1) såvida inte +\fB\-\-help\fP eller \fB\-\-version\fP anges. +.PP +Om både \fIfil1\fP och \fIfil2\fP anges kan de vara okomprimerade filer eller +filer i format som \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) +eller \fBlz4\fP(1) kan dekomprimera. De nödvändiga dekomprimeringskommandona +avgörs från filnamnsändelsen på \fIfil1\fP och \fIfil2\fP. En fil med en okänd +ändelse antas antingen vara okomprimerad eller i ett format som \fBxz\fP(1) kan +dekomprimera. +.PP +Om endast ett filnamn anges måste \fIfil1\fP ha en ändelse med ett av de stödda +komprimeringsformaten och namnet på \fIfil2\fP antas vara \fIfil1\fP med +komprimeringsformatsändelsen borttagen. +.PP +Kommandona \fBlzcmp\fP och \fBlzdiff\fP finns för bakåtkompatibilitet med LZMA +Utils. De rekommenderas inte och kommer tas bort i en framtida version. +. +.SH SLUTSTATUS +Om ett dekomprimeringsfel uppstår är slutstatus \fB2\fP. Annars används +slutstatusen från \fBcmp\fP(1) respektive \fBdiff\fP(1). +. +.SH "SE ÄVEN" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xzdec.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xzdec.1 new file mode 100644 index 0000000000000000000000000000000000000000..63612b0c437ef25509d89f649853119c5e476786 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xzdec.1 @@ -0,0 +1,87 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.\" Swedish translation of xz-man +.\" Göran Uddeborg , 2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDEC 1 2024\-04\-08 Tukaani "XZ Utils" +.SH NAMN +xzdec, lzmadec \- Små .xz\- och .lzma\-dekomprimerare +.SH SYNOPSIS +\fBxzdec\fP [\fIflagga…\fP] [\fIfil…\fP] +.br +\fBlzmadec\fP [\fIflagga…\fP] [\fIfil…\fP] +.SH BESKRIVNING +\fBxzdec\fP är ett liblzma\-baserat verktyg endast för dekomprimering för \fB.xz\fP +(och endast \fB.xz\fP) filer. \fBxzdec\fP är avsett att fungera som en drop +in\-ersättning för \fBxz\fP(1) i de vanligaste situationerna där ett skript har +skrivits för att använda \fBxz \-\-decompress \-\-stdout\fP (och möjligen några +andra vanliga flaggor) för att dekomprimera \fB.xz\fP\-filer. \fBlzmadec\fP är +identisk med \fBxzdec\fP förutom att \fBlzmadec\fP stödjer \fB.lzma\fP\-filer istället +för \fB.xz\fP\-filer. +.PP +För att reducera storleken på det körbara programmet stödjer inte \fBxzdec\fP +multitrådning eller lokalisering, och läser inte flaggor från +miljövariablerna \fBXZ_DEFAULTS\fP eller \fBXZ_OPT\fP. \fBxzdec\fP stödjer inte att +visa mellanliggande förloppsinformation: att skicka \fBSIGINFO\fP till \fBxzdec\fP +gör ingenting, med att skicka \fBSIGUSR1\fP avslutar processen istället för att +visa förloppsinformation. +.SH FLAGGOR +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +Ignoreras för kompatibilitet med \fBxz\fP(1). \fBxzdec\fP stödjer endast +dekomprimering. +.TP +\fB\-k\fP, \fB\-\-keep\fP +Ignoreras för kompatibilitet med \fBxz\fP(1). \fBxzdec\fP skapar aldrig eller tar +aldrig bort några filer. +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Ignoreras för kompatibilitet med \fBxz\fP(1). \fBxzdec\fP skriver alltid +dekomprimerad data till standard ut. +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Att ange detta en gång gör inget eftersom \fBxzdec\fP aldrig visar några +varningar eller noteringar. Att ange detta två gånger utelämnar +felmeddelanden. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Ignoreras för kompatibilitet med \fBxz\fP(1). \fBxzdec\fP använder aldrig +slutstatus 2. +.TP +\fB\-h\fP, \fB\-\-help\fP +Visa ett hjälpmeddelande och avsluta. +.TP +\fB\-V\fP, \fB\-\-version\fP +Visa versionsnumret på \fBxzdec\fP och liblzma. +.SH SLUTSTATUS +.TP +\fB0\fP +Allt gick bra. +.TP +\fB1\fP +Ett fel uppstod. +.PP +\fBxzdec\fP har inte några varningsmeddelanden så som \fBxz\fP(1) har, och därför +används aldrig slutstatusen 2 av \fBxzdec\fP. +.SH NOTERINGAR +Använd \fBxz\fP(1) istället för \fBxzdec\fP eller \fBlzmadec\fP för dagligt +bruk. \fBxzdec\fP och \fBlzmadec\fP är bara avsedda för situationer där det är +viktigt att ha en mindre dekomprimerare än den fullständiga \fBxz\fP(1). +.PP +\fBxzdec\fP och \fBlzmadec\fP är egentligen inte riktigt så små. Storleken kan +reduceras ytterligare genom att ta bort funktioner från liblzma vid +kompileringstidpunkten, men det skall normalt inte göras för körbara program +som distribueras i en typisk, inte inbäddad, distribution av +operativsystem. Om man behöver en verkligt liten \fB.xz\fP\-dekomprimerare skall +man överväga XZ Embedded. +.SH "SE ÄVEN" +\fBxz\fP(1) +.PP +XZ Embedded: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xzdiff.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xzdiff.1 new file mode 100644 index 0000000000000000000000000000000000000000..2d1516dcb59720f083abf68f8101c5de6fb19a89 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xzdiff.1 @@ -0,0 +1,54 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Swedish translation of xz-man +.\" Göran Uddeborg , 2025. +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 2025\-03\-06 Tukaani "XZ Utils" +.SH NAMN +xzcmp, xzdiff, lzcmp, lzdiff — jämför komprimerade filer +. +.SH SYNOPSIS +\fBxzcmp\fP [\fIflagga…\fP] \fIfil1\fP [\fIfil2\fP] +.br +\fBxzdiff\fP \&… +.br +\fBlzcmp\fP \&… (FÖRÅLDRAT) +.br +\fBlzdiff\fP \&… (FÖRÅLDRAT) +. +.SH BESKRIVNING +\fBxzcmp\fP och \fBxzdiff\fP jämför det okomprimerade innehållet i två +filer. Okomprimerad data skickas till \fBcmp\fP(1) eller \fBdiff\fP(1) såvida inte +\fB\-\-help\fP eller \fB\-\-version\fP anges. +.PP +Om både \fIfil1\fP och \fIfil2\fP anges kan de vara okomprimerade filer eller +filer i format som \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) +eller \fBlz4\fP(1) kan dekomprimera. De nödvändiga dekomprimeringskommandona +avgörs från filnamnsändelsen på \fIfil1\fP och \fIfil2\fP. En fil med en okänd +ändelse antas antingen vara okomprimerad eller i ett format som \fBxz\fP(1) kan +dekomprimera. +.PP +Om endast ett filnamn anges måste \fIfil1\fP ha en ändelse med ett av de stödda +komprimeringsformaten och namnet på \fIfil2\fP antas vara \fIfil1\fP med +komprimeringsformatsändelsen borttagen. +.PP +Kommandona \fBlzcmp\fP och \fBlzdiff\fP finns för bakåtkompatibilitet med LZMA +Utils. De rekommenderas inte och kommer tas bort i en framtida version. +. +.SH SLUTSTATUS +Om ett dekomprimeringsfel uppstår är slutstatus \fB2\fP. Annars används +slutstatusen från \fBcmp\fP(1) respektive \fBdiff\fP(1). +. +.SH "SE ÄVEN" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xzegrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xzegrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..bf4653d6c7aed44d0f7fc53205f6d44e080f3ddc --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xzegrep.1 @@ -0,0 +1,92 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Swedish translation of xz-man +.\" Göran Uddeborg , 2025. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 2025\-03\-06 Tukaani "XZ Utils" +.SH NAMN +xzgrep — sök i eventuellt komprimerade filer efter mönster +. +.SH SYNOPSIS +\fBxzgrep\fP [\fIflagga…\fP] [\fImönsterlista\fP] [\fIfil…\fP] +.br +\fBxzegrep\fP \&… +.br +\fBxzfgrep\fP \&… +.br +\fBlzgrep\fP \&… (FÖRÅLDRAT) +.br +\fBlzegrep\fP \&… (FÖRÅLDRAT) +.br +\fBlzfgrep\fP \&… (FÖRÅLDRAT) +. +.SH BESKRIVNING +\fBxzgrep\fP anropar \fBgrep\fP(1) på det okomprimerade innehållet i +filerna. Formaten på \fIfilerna\fP bestäms utgående från filnamnsändelsen. En +\fIfil\fP med en ändelse som stödjs av \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), +\fBlzop\fP(1), \fBzstd\fP(1) eller \fBlz4\fP(1) kommer att dekomprimeras; alla andra +filer antas vara okomprimerade. +.PP +Om inga \fIfiler\fP anges eller om \fIfil\fP är \fB\-\fP lästes standard in. När +standard in läses är de enda filerna som dekomprimeras de som stödjs av +\fBxz\fP(1). Andra filer antas redan vara i okomprimerad form. +.PP +De flesta \fIflaggor\fP till \fBgrep\fP(1) stödjs. Dock stödjs inte följande +flaggor: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIåtgärd\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIfil\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglob\fP +.PP +\fBxzegrep\fP är ett alias för \fBxzgrep \-E\fP. \fBxzfgrep\fP är ett alias för +\fBxzgrep \-F\fP. +.PP +Kommandona \fBlzgrep\fP, \fBlzegrep\fP och \fBlzfgrep\fP finns för +bakåtkompatibilitet med LZMA Utils. De rekommenderas inte och kommer tas +bort i en framtida version. +. +.SH SLUTSTATUS +.TP +0 +Åtminstone en matchning hittades från åtminstone en av infilerna. Inga fel +uppstod. +.TP +1 +Inga matchningar hittades i någon av infilerna. Inga fel uppstod. +.TP +>1 +Ett eller flera fel uppstod. Det är okänt om några matchningar hittades. +. +.SH MILJÖ +.TP +\fBGREP\fP +Om \fBGREP\fP är satt till något icketomt värde används det istället för +\fBgrep\fP, \fBgrep \-E\fP respektive \fBgrep \-F\fP. +. +.SH "SE ÄVEN" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xzfgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xzfgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..bf4653d6c7aed44d0f7fc53205f6d44e080f3ddc --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xzfgrep.1 @@ -0,0 +1,92 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Swedish translation of xz-man +.\" Göran Uddeborg , 2025. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 2025\-03\-06 Tukaani "XZ Utils" +.SH NAMN +xzgrep — sök i eventuellt komprimerade filer efter mönster +. +.SH SYNOPSIS +\fBxzgrep\fP [\fIflagga…\fP] [\fImönsterlista\fP] [\fIfil…\fP] +.br +\fBxzegrep\fP \&… +.br +\fBxzfgrep\fP \&… +.br +\fBlzgrep\fP \&… (FÖRÅLDRAT) +.br +\fBlzegrep\fP \&… (FÖRÅLDRAT) +.br +\fBlzfgrep\fP \&… (FÖRÅLDRAT) +. +.SH BESKRIVNING +\fBxzgrep\fP anropar \fBgrep\fP(1) på det okomprimerade innehållet i +filerna. Formaten på \fIfilerna\fP bestäms utgående från filnamnsändelsen. En +\fIfil\fP med en ändelse som stödjs av \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), +\fBlzop\fP(1), \fBzstd\fP(1) eller \fBlz4\fP(1) kommer att dekomprimeras; alla andra +filer antas vara okomprimerade. +.PP +Om inga \fIfiler\fP anges eller om \fIfil\fP är \fB\-\fP lästes standard in. När +standard in läses är de enda filerna som dekomprimeras de som stödjs av +\fBxz\fP(1). Andra filer antas redan vara i okomprimerad form. +.PP +De flesta \fIflaggor\fP till \fBgrep\fP(1) stödjs. Dock stödjs inte följande +flaggor: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIåtgärd\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIfil\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglob\fP +.PP +\fBxzegrep\fP är ett alias för \fBxzgrep \-E\fP. \fBxzfgrep\fP är ett alias för +\fBxzgrep \-F\fP. +.PP +Kommandona \fBlzgrep\fP, \fBlzegrep\fP och \fBlzfgrep\fP finns för +bakåtkompatibilitet med LZMA Utils. De rekommenderas inte och kommer tas +bort i en framtida version. +. +.SH SLUTSTATUS +.TP +0 +Åtminstone en matchning hittades från åtminstone en av infilerna. Inga fel +uppstod. +.TP +1 +Inga matchningar hittades i någon av infilerna. Inga fel uppstod. +.TP +>1 +Ett eller flera fel uppstod. Det är okänt om några matchningar hittades. +. +.SH MILJÖ +.TP +\fBGREP\fP +Om \fBGREP\fP är satt till något icketomt värde används det istället för +\fBgrep\fP, \fBgrep \-E\fP respektive \fBgrep \-F\fP. +. +.SH "SE ÄVEN" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xzgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xzgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..bf4653d6c7aed44d0f7fc53205f6d44e080f3ddc --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xzgrep.1 @@ -0,0 +1,92 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Swedish translation of xz-man +.\" Göran Uddeborg , 2025. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 2025\-03\-06 Tukaani "XZ Utils" +.SH NAMN +xzgrep — sök i eventuellt komprimerade filer efter mönster +. +.SH SYNOPSIS +\fBxzgrep\fP [\fIflagga…\fP] [\fImönsterlista\fP] [\fIfil…\fP] +.br +\fBxzegrep\fP \&… +.br +\fBxzfgrep\fP \&… +.br +\fBlzgrep\fP \&… (FÖRÅLDRAT) +.br +\fBlzegrep\fP \&… (FÖRÅLDRAT) +.br +\fBlzfgrep\fP \&… (FÖRÅLDRAT) +. +.SH BESKRIVNING +\fBxzgrep\fP anropar \fBgrep\fP(1) på det okomprimerade innehållet i +filerna. Formaten på \fIfilerna\fP bestäms utgående från filnamnsändelsen. En +\fIfil\fP med en ändelse som stödjs av \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), +\fBlzop\fP(1), \fBzstd\fP(1) eller \fBlz4\fP(1) kommer att dekomprimeras; alla andra +filer antas vara okomprimerade. +.PP +Om inga \fIfiler\fP anges eller om \fIfil\fP är \fB\-\fP lästes standard in. När +standard in läses är de enda filerna som dekomprimeras de som stödjs av +\fBxz\fP(1). Andra filer antas redan vara i okomprimerad form. +.PP +De flesta \fIflaggor\fP till \fBgrep\fP(1) stödjs. Dock stödjs inte följande +flaggor: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIåtgärd\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIfil\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglob\fP +.PP +\fBxzegrep\fP är ett alias för \fBxzgrep \-E\fP. \fBxzfgrep\fP är ett alias för +\fBxzgrep \-F\fP. +.PP +Kommandona \fBlzgrep\fP, \fBlzegrep\fP och \fBlzfgrep\fP finns för +bakåtkompatibilitet med LZMA Utils. De rekommenderas inte och kommer tas +bort i en framtida version. +. +.SH SLUTSTATUS +.TP +0 +Åtminstone en matchning hittades från åtminstone en av infilerna. Inga fel +uppstod. +.TP +1 +Inga matchningar hittades i någon av infilerna. Inga fel uppstod. +.TP +>1 +Ett eller flera fel uppstod. Det är okänt om några matchningar hittades. +. +.SH MILJÖ +.TP +\fBGREP\fP +Om \fBGREP\fP är satt till något icketomt värde används det istället för +\fBgrep\fP, \fBgrep \-E\fP respektive \fBgrep \-F\fP. +. +.SH "SE ÄVEN" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xzless.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xzless.1 new file mode 100644 index 0000000000000000000000000000000000000000..52b702820a9af7788772d2a30896263902aa1042 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xzless.1 @@ -0,0 +1,47 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" Swedish translation of xz-man +.\" Göran Uddeborg , 2025. +.\" +.\" (Note that this file is not based on gzip's zless.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZLESS 1 2025\-03\-06 Tukaani "XZ Utils" +.SH NAMN +xzless, lzless — visa xz\- eller lzma\-komprimerade (text)filer +.SH SYNOPSIS +\fBxzless\fP [\fIfil\fP…] +.br +\fBlzless\fP [\fIfil\fP…] (FÖRÅLDRAT) +.SH BESKRIVNING +\fBxzless\fP är ett filter som visar text från komprimerade filer i en +terminal. Filer som stödjs av \fBxz\fP(1) dekomprimeras; andra filer antas +redan vara i okomprimerad form. Om inga \fIfiler\fP ges läser \fBxzless\fP från +standard in. +.PP +\fBxzless\fP använder \fBless\fP(1) för att visa sin utdata. Till skillnad mot +\fBxzmore\fP kan inte dess val av bläddrare ändras genom att sätta en +miljövariabel. Kommandon är baserade på både \fBmore\fP(1) och \fBvi\fP(1) och +tillåter förflytting fram och tillbaka samt sökning. Se manualen \fBless\fP(1) +för mer information. +.PP +Kommandot som heter \fBlzless\fP finns för bakåtkompatibilitet med LZMA +Utils. Det rekommenderas inte och kommer tas bort i en framtida version. +.SH MILJÖ +.TP +\fBLESSMETACHARS\fP +En lista på tecken som är speciella för skalet. Sätts av \fBxzless\fP om den +inte redan är satt i miljön. +.TP +\fBLESSOPEN\fP +Satt till en kommandorad för att köra dekomprimeraren \fBxz\fP(1) för +förbehandling av infiler till \fBless\fP(1). +.SH "SE ÄVEN" +\fBless\fP(1), \fBxz\fP(1), \fBxzmore\fP(1), \fBzless\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xzmore.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xzmore.1 new file mode 100644 index 0000000000000000000000000000000000000000..b5bb68d4df784fe5c3fcbdf884e0667ee9fc791e --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/sv/man1/xzmore.1 @@ -0,0 +1,48 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" Swedish translation of xz-man +.\" Göran Uddeborg , 2025. +.\" +.\" (Note that this file is based on xzless.1 instead of gzip's zmore.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZMORE 1 2025\-03\-06 Tukaani "XZ Utils" +.SH NAMN +xzmore, lzmore — visa xz\- eller lzma\-komprimerade (text)filer +. +.SH SYNOPSIS +\fBxzmore\fP [\fIfil\fP…] +.br +\fBlzmore\fP [\fIfil\fP…] (FÖRÅLDRAT) +. +.SH BESKRIVNING +\fBxzmore\fP visar text från komprimerade filer i en terminal med användning av +\fBmore\fP(1). Filer som stödjs av \fBxz\fP(1) dekomprimeras; andra filer antas +redan vara i okomprimerad form. Om inga \fIfiler\fP ges läser \fBxzmore\fP från +standard in. Se manualen för \fBmore\fP(1) för tangentbordskommandona. +.PP +Observera att det kanske inte är möjligt att rulla baklänges, beroende på +implementationen av \fBmore\fP(1). Detta är för att \fBxzmore\fP använder ett rör +för att skicka dekomprimerad data till \fBmore\fP(1). \fBxzless\fP(1) använder +\fBless\fP(1) vilken ger mer avancerade funktioner. +.PP +Kommandot \fBlzmore\fP finns för bakåtkompatibilitet med LZMA Utils. Det +rekommenderas inte och kommer tas bort i en framtida version. +. +.SH MILJÖ +.TP +.\" TRANSLATORS: Don't translate the uppercase PAGER. +.\" It is a name of an environment variable. +\fBPAGER\fP +Om \fBPAGER\fP är satt används dess värde som bläddrare istället för +\fBmore\fP(1). +. +.SH "SE ÄVEN" +\fBmore\fP(1), \fBxz\fP(1), \fBxzless\fP(1), \fBzmore\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzcat.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzcat.1 new file mode 100644 index 0000000000000000000000000000000000000000..bff0472c4495c4b8c84495967535bcd7b99dc205 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzcat.1 @@ -0,0 +1,2039 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Ukrainian translation for xz-man. +.\" Yuri Chornoivan , 2019, 2022, 2023, 2024, 2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 "8 березня 2025 року" Tukaani "XZ Utils" +. +.SH НАЗВА +xz, unxz, xzcat, lzma, unlzma, lzcat — стискання та розпаковування файлів +\&.xz і .lzma +. +.SH "КОРОТКИЙ ОПИС" +\fBxz\fP [\fIпараметр...\fP] [\fIфайл...\fP] +. +.SH "СКОРОЧЕННЯ КОМАНД" +\fBunxz\fP є рівноцінним до \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP є рівноцінним до \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP є рівноцінним до \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP є рівноцінним до \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP є рівноцінним до \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +При написанні скриптів, де потрібно розпаковувати файли, рекомендуємо завжди +використовувати \fBxz\fP із відповідними аргументами (\fBxz \-d\fP або \fBxz \-dc\fP), +замість \fBunxz\fP і \fBxzcat\fP. +. +.SH ОПИС +\fBxz\fP інструмент загального призначення для стискання даних із синтаксисом +командного рядка, подібним для \fBgzip\fP(1) і \fBbzip2\fP(1). Власним форматом +файлів є \fB.xz\fP, але передбачено підтримку застарілого формату \fB.lzma\fP, +який було використано у LZMA Utils, та необроблених потоків стиснених даних +без заголовків формату контейнера. Крім того, передбачено підтримку +розпаковування формату \fB.lz\fP, який використано у \fBlzip\fP. +.PP +\fBxz\fP стискає або розпаковує кожен \fIфайл\fP відповідно до вибраного режиму +дій. Якщо \fIфайли\fP не задано або якщо \fIфайлом\fP є \fB\-\fP, \fBxz\fP читатиме дані +зі стандартного джерела вхідних даних і записуватиме оброблені дані до +стандартного виведення. \fBxz\fP відмовить (покаже повідомлення про помилку і +пропустить \fIфайл\fP) у записів стиснених даних до стандартного виведення, +якщо це термінал. Так само, \fBxz\fP відмовить у читанні стиснених даних зі +стандартного джерела вхідних даних, якщо це термінал. +.PP +Якщо не вказано \fB\-\-stdout\fP, \fIфайли\fP, відмінні від \fB\-\fP, буде записано до +нового файла, чию назву буде визначено з назви початкового \fIфайла\fP: +.IP \(bu 3 +При стисканні суфікс формату файла призначення (\fB.xz\fP або \fB.lzma\fP) буде +дописано до назви початкового файла для отримання назви файла призначення. +.IP \(bu 3 +При розпаковуванні суфікс \fB.xz\fP, \fB.lzma\fP або \fB.lz\fP буде вилучено з назви +файла для отримання назви файла призначення. Крім того, \fBxz\fP розпізнає +суфікси \fB.txz\fP і \fB.tlz\fP і замінює їх на суфікс \fB.tar\fP. +.PP +Якщо файл призначення вже існує, буде показано повідомлення про помилку, а +\fIфайл\fP буде пропущено. +.PP +Окрім випадку запису до стандартного виведення, \fBxz\fP покаже попередження і +пропустить обробку \fIфайла\fP, якщо буде виконано будь\-яку з таких умов: +.IP \(bu 3 +\fIФайл\fP не є звичайним файлом. Програма не переходитиме за символічними +посиланнями, а отже, не вважатиме їх звичайними файлами. +.IP \(bu 3 +На \fIфайл\fP існує декілька жорстких посилань. +.IP \(bu 3 +Для \fIфайла\fP встановлено setuid, setgid або «липкий» біт. +.IP \(bu 3 +Режим дій встановлено у значення «стискання», і \fIфайл\fP вже має суфікс назви +формату файла призначення (\fB.xz\fP або \fB.txz\fP при стисканні до формату +\&\fB.xz\fP, і \fB.lzma\fP або \fB.tlz\fP при стисканні до формату \fB.lzma\fP). +.IP \(bu 3 +Режим дій встановлено у значення «розпаковування», і \fIфайл\fP не має суфікса +назви жодного з підтримуваних форматів (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP +або \fB.lz\fP). +.PP +Після успішного стискання або розпаковування \fIфайла\fP, \fBxz\fP копіює дані +щодо власника, групи, прав доступу, часу доступу та моменту внесення змін з +початкового \fIфайла\fP до файла призначення. Якщо копіювання даних щодо групи +зазнає невдачі, права доступу буде змінено так, що файл призначення стане +недоступним для користувачів, які не мають права доступу до початкового +\fIфайла\fP. В \fBxz\fP ще не передбачено підтримки копіювання інших метаданих, +зокрема списків керування доступом або розширених атрибутів. +.PP +Щойно файл призначення буде успішно закрито, початковий \fIфайл\fP буде +вилучено, якщо не вказано параметра \fB\-\-keep\fP. Початковий \fIфайл\fP ніколи не +буде вилучено, якщо виведені дані буде записано до стандартного виведення +або якщо станеться помилка. +.PP +Надсилання \fBSIGINFO\fP або \fBSIGUSR1\fP до процесу \fBxz\fP призводить до +виведення даних щодо поступу до стандартного виведення помилок. Це має лише +обмежене використання, оскільки якщо стандартним виведенням помилок є +термінал, використання \fB\-\-verbose\fP призведе до показу автоматично +оновлюваного індикатора поступу. +. +.SS "Використання пам'яті" +Використання \fBxz\fP пам'яті може бути різним: від декількох сотень кілобайтів +до декількох гігабайтів, залежно від параметрів стискання. Параметри, які +використано при стисканні файла, визначають вимоги до об'єму пам'яті при +розпакуванні. Типово, засобу розпаковування потрібно від 5\ % до 20\ % +об'єму пам'яті, якого засіб стискання потребує при створенні +файла. Наприклад, розпаковування файла, який створено з використанням \fBxz \-9\fP, у поточній версії потребує 65\ МіБ пам'яті. Втім, можливе створення +файлів \fB.xz\fP, які потребуватимуть для розпаковування декількох гігабайтів +пам'яті. +.PP +Ймовірність високого рівня використання пам'яті може бути особливо +дошкульною для користувачів застарілих комп'ютерів. Щоб запобігти прикрим +несподіванкам, у \fBxz\fP передбачено вбудований обмежувач пам'яті, який типово +вимкнено. Хоча у деяких операційних системах передбачено спосіб обмежити +використання пам'яті процесами, сподівання на його ефективність не є аж +надто гнучким (наприклад, використання \fBulimit\fP(1) для обмеження +віртуальної пам'яті призводить до викривлення даних \fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Обмежувач пам'яті можна увімкнути за допомогою параметра командного рядка +\fB\-\-memlimit=\fP\fIобмеження\fP. Часто, зручніше увімкнути обмежувач на типовому +рівні, встановивши значення для змінної середовища \fBXZ_DEFAULTS\fP, +наприклад, \fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Можна встановити обмеження +окремо для стискання і розпакування за допомогою +\fB\-\-memlimit\-compress=\fP\fIlimit\fP and +\fB\-\-memlimit\-decompress=\fP\fIобмеження\fP. Використання цих двох параметрів поза +\fBXZ_DEFAULTS\fP не таке вже і корисне, оскільки одноразовий запуск \fBxz\fP не +може одночасно призводити до стискання та розпаковування, а набрати у +командному рядку \fB\-\-memlimit=\fP\fIобмеження\fP (або \fB\-M\fP \fIобмеження\fP) +набагато швидше. +.PP +Якщо під час розпаковування вказане обмеження буде перевищено, \fBxz\fP покаже +повідомлення про помилку, а розпаковування файла зазнає невдачі. Якщо +обмеження буде перевищено при стисканні, \fBxz\fP спробує масштабувати +параметри так, щоб не перевищувати обмеження (окрім випадків використання +\fB\-\-format=raw\fP або \fB\-\-no\-adjust\fP). Отже, дію буде виконано, якщо обмеження +не є надто жорстким. Масштабування параметрів буде виконано кроками, які не +збігаються із рівнями шаблонів стискання. Наприклад, якщо обмеження лише +трохи не вкладається у об'єм потрібний для \fBxz \-9\fP, параметри буде змінено +лише трохи, не до рівня \fBxz \-8\fP. +. +.SS "Поєднання і заповнення з файлами .xz" +Можна поєднати файли \fB.xz\fP без додаткової обробки. \fBxz\fP розпакує такі +файли так, наче вони є єдиним файлом \fB.xz\fP. +.PP +Можна додати доповнення між з'єднаними частинами або після останньої +частини. Доповнення має складатися із нульових байтів і мати розмір, який є +кратним до чотирьох байтів. Це може бути корисним, наприклад, якщо файл +\&\fB.xz\fP зберігається на носії даних, де розміри файла вимірюються у +512\-байтових блоках. +.PP +Поєднання та заповнення не можна використовувати для файлів \fB.lzma\fP або +потоків необроблених даних. +. +.SH ПАРАМЕТРИ +. +.SS "Цілочисельні суфікси і спеціальні значення" +У більшості місць, де потрібен цілочисельний аргумент, передбачено підтримку +необов'язкового суфікса для простого визначення великих цілих чисел. Між +цілим числом і суфіксом не повинно бути пробілів. +.TP +\fBKiB\fP +Помножити ціле число на 1024 (2^10). Синонімами \fBKiB\fP є \fBKi\fP, \fBk\fP, \fBkB\fP, +\fBK\fP та \fBKB\fP. +.TP +\fBMiB\fP +Помножити ціле число на 1048576 (2^20). Синонімами \fBMiB\fP є B, \fBMi\fP, \fBm\fP, +\fBM\fP та \fBMB\fP. +.TP +\fBGiB\fP +Помножити ціле число на 1073741824 (2^30). Синонімами \fBGiB\fP є B, \fBGi\fP, +\fBg\fP, \fBG\fP та \fBGB\fP. +.PP +Можна скористатися особливим значенням \fBmax\fP для позначення максимального +цілого значення, підтримку якого передбачено для параметра. +. +.SS "Режим операції" +Якщо вказано декілька параметрів режиму дій, буде використано лише останній +з них. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Стиснути. Це типовий режим дій, якщо не вказано параметр режиму дій, а назва +команди неявним чином не визначає іншого режиму дій (наприклад, \fBunxz\fP +неявно визначає \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Після успішного пакування початковий файл буде вилучено, якщо виведення не +відбувається до стандартного виведення або не вказано параметра \fB\-\-keep\fP. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Розпакувати. Після успішного розпаковування початковий файл буде вилучено, +якщо виведення не відбувається до стандартного виведення або не вказано +параметра \fB\-\-keep\fP. +.TP +\fB\-t\fP, \fB\-\-test\fP +Перевірити цілісність стиснених файлів \fIфайли\fP. Цей параметр еквівалентний +до \fB\-\-decompress \-\-stdout\fP, але розпаковані дані буде відкинуто, замість +запису до стандартного виведення. Жодних файлів не буде створено або +вилучено. +.TP +\fB\-l\fP, \fB\-\-list\fP +Вивести відомості щодо стиснених файлів \fIфайли\fP. Розпакування даних не +виконуватиметься, жодних файлів не буде створено або вилучено. У режимі +списку програма не може читати дані зі стандартного введення або з інших +джерел, де неможливе позиціювання. +.IP "" +У типовому списку буде показано базові відомості щодо файлів \fIфайли\fP, по +одному файлу на рядок. Щоб отримати докладніші відомості, скористайтеся +параметром \fB\-\-verbose\fP. Щоб розширити спектр відомостей, скористайтеся +параметром \fB\-\-verbose\fP двічі, але зауважте, що це може призвести до +значного уповільнення роботи, оскільки отримання додаткових відомостей +потребує великої кількості позиціювань. Ширина області докладного виведення +даних перевищує 80 символів, тому передавання конвеєром виведених даних, +наприклад, до \fBless\ \-S\fP, може бути зручним способом перегляду даних, якщо +термінал недостатньо широкий. +.IP "" +Виведені дані залежать від версії \fBxz\fP та використаної локалі. Для +отримання даних, які будуть придатні до обробки комп'ютером, слід +скористатися параметрами \fB\-\-robot \-\-list\fP. +. +.SS "Модифікатори режиму роботи" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Не вилучати вхідні файли. +.IP "" +Починаючи з версії \fBxz\fP 5.2.6, використання цього параметра також наказує +\fBxz\fP виконувати стискання або розпаковування, навіть якщо вхідними даними є +символічне посилання на звичайний файл, файл, який має декілька жорстких +посилань, або файл, для якого встановлено setuid, setgid або липкий +біт. setuid, setgid та липкий біт не буде скопійовано до файла\-результату. У +попередніх версіях, ці дії виконувалися, лише якщо було використано параметр +\fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Результатів використання цього параметра буде декілька: +.RS +.IP \(bu 3 +Якщо файл\-результат вже існує, вилучити його до стискання або +розпаковування. +.IP \(bu 3 +Виконувати стискання або розпаковування, навіть якщо вхідними даними є +символічне посилання на звичайний файл, файл, який має декілька жорстких +посилань, або файл, для якого встановлено setuid, setgid або липкий біт +setuid, setgid та липкий біт не буде скопійовано до файла\-результату. +.IP \(bu 3 +Якщо використано разом із \fB\-\-decompress\fP, \fB\-\-stdout\fP, і \fBxz\fP не зможе +розпізнати тип початкового файла, копіювати початковий файл без змін до +стандартного виведення. Це надає змогу користуватися \fBxzcat\fP \fB\-\-force\fP +подібно до \fBcat\fP(1) для файлів, які не було стиснено за допомогою +\fBxz\fP. Зауважте, що у майбутньому у \fBxz\fP може бути реалізовано підтримку +нових форматів стиснених файлів, замість копіювання їх без змін до +стандартного виведення. Можна скористатися \fB\-\-format=\fP\fIформат\fP для +обмеження стискання у \fBxz\fP єдиним форматом файлів. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Записати стиснені або розпаковані дані до стандартного виведення, а не до +файла. Неявним чином встановлює \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Розпакувати лише перший потік даних \fB.xz\fP і без повідомлень проігнорувати +решту вхідних даних, які слідують за цим потоком. Зазвичай, такі зайві дані +наприкінці файла призводять до показу \fBxz\fP повідомлення про помилку. +.IP "" +\fBxz\fP ніколи не виконуватиме спроби видобути декілька потоків даних з файлів +\&\fB.lzma\fP або необроблених потоків даних, але використання цього параметра +все одно наказує \fBxz\fP ігнорувати можливі кінцеві дані після файла \fB.lzma\fP +або необробленого потоку даних. +.IP "" +Цей параметр нічого не змінює, якщо режимом дій не є \fB\-\-decompress\fP або +\fB\-\-test\fP. +.IP "" +З \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP неявно визначає \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Вимкнути створення розріджених файлів. Типово, якщо видобування виконується +до звичайного файла, \fBxz\fP намагається створити розріджений файл, якщо +розпаковані дані містять довгі послідовності двійкових нулів. Це також +працює, коли виконується запис до стандартного виведення, доки стандартне +виведення з'єднано зі звичайним файлом і виконуються певні додаткові умови, +які убезпечують роботу. Створення розріджених файлів може заощадити місце на +диску і пришвидшити розпаковування шляхом зменшення кількості дій введення +та виведення даних на диску. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +При стисканні використати суфікс \fI.suf\fP для файлів призначення, замість +суфікса \fB.xz\fP або \fB.lzma\fP. Якщо записування виконується не до стандартного +виведення і початковий файл вже має суфікс назви \fI.suf\fP, буде показано +попередження, а файл буде пропущено під час обробки. +.IP "" +При розпаковуванні розпізнавати файли із суфіксом назви \fI.suf\fP, окрім +файлів із суфіксами назв \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP або \fB.lz\fP. Якщо +початковий файл мав суфікс назви \fI.suf\fP, для отримання назви файла +призначення цей суфікс буде вилучено. +.IP "" +При стисканні або розпакуванні необроблених потоків даних (\fB\-\-format=raw\fP) +суфікс слід вказувати завжди, якщо запис не виконується до стандартного +виведення, оскільки типового суфікса назви для необроблених потоків даних не +передбачено. +.TP +\fB\-\-files\fP[\fB=\fP\fIфайл\fP] +Прочитати назви файлів для обробки з файла \fIфайл\fP; якщо \fIfile\fP не вказано, +назви файлів буде прочитано зі стандартного потоку вхідних даних. Назви +файлів має бути відокремлено символом нового рядка. Символ дефіса (\fB\-\fP) +буде оброблено як звичайну назву файла; він не позначатиме стандартного +джерела вхідних даних. Якщо також буде вказано назви файлів у аргументах +рядка команди, файли з цими назвами буде оброблено до обробки файлів, назви +яких було прочитано з файла \fIфайл\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIфайл\fP] +Те саме, що і \fB\-\-files\fP[\fB=\fP\fIфайл\fP], але файли у списку має бути +відокремлено нульовим символом. +. +.SS "Параметри базового формату файлів та стискання" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fIформат\fP +Вказати файл \fIформат\fP для стискання або розпакування: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Типовий варіант. При стисканні \fBauto\fP є еквівалентом \fBxz\fP. При +розпакуванні формат файла вхідних даних буде виявлено автоматично. Зауважте, +що автоматичне виявлення необроблених потоків даних (створених за допомогою +\fB\-\-format=raw\fP) неможливе. +.TP +\fBxz\fP +Стиснути до формату \fB.xz\fP або приймати лише файли \fB.xz\fP при +розпаковуванні. +.TP +\fBlzma\fP, \fBalone\fP +Стиснути дані до застарілого формату файлів \fB.lzma\fP або приймати лише файли +\&\fB.lzma\fP при розпаковуванні. Альтернативну назву \fBalone\fP може бути +використано для зворотної сумісності із LZMA Utils. +.TP +\fBlzip\fP +Приймати лише файли \fB.lz\fP при розпакуванні. Підтримки стискання не +передбачено. +.IP "" +Передбачено підтримку версії формату \fB.lz\fP 0 та 1. Файли версії 0 було +створено \fBlzip\fP 1.3 та старішими версіями. Такі файли не є поширеними, але +їх можна знайти у файлових архівах, оскільки певну незначну кількість +пакунків із початковим кодом було випущено у цьому форматі. Також можуть +існувати особисті файли у цьому форматі. Підтримку розпаковування для +формату версії 0 було вилучено у \fBlzip\fP 1.18. Версія \fBlzip\fP 1.4 і новіші +версії створюють файли у форматі версії 1. +.TP +\fBraw\fP +Стиснути або розпакувати потік необроблених даних (лез заголовків). Цей +параметр призначено лише для досвідчених користувачів. Для розпаковування +необроблених потоків даних слід користуватися параметром \fB\-\-format=raw\fP і +явно вказати ланцюжок фільтрування, який за звичайних умов мало б бути +збережено у заголовках контейнера. +.RE +.TP +\fB\-C\fP \fIперевірка\fP, \fB\-\-check=\fP\fIперевірка\fP +Вказати тип перевірки цілісності. Контрольну суму буде обчислено на основі +нестиснених даних і збережено у файлі \fB.xz\fP. Цей параметр працюватиме, лише +якщо дані стиснено до файла у форматі \fB.xz\fP; для формату файлів \fB.lzma\fP +підтримки перевірки цілісності не передбачено. Перевірку контрольної суми +(якщо така є) буде виконано під час розпаковування файла \fB.xz\fP. +.IP "" +Підтримувані типи \fIперевірок\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Не обчислювати контрольну суму взагалі. Зазвичай, не варто цього робити. Цим +варіантом слід скористатися, якщо цілісність даних буде перевірено в інший +спосіб. +.TP +\fBcrc32\fP +Обчислити CRC32 за допомогою полінома з IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Обчислити CRC64 за допомогою полінома з ECMA\-182. Це типовий варіант, +оскільки він дещо кращий за CRC32 при виявленні пошкоджених файлів, а +різниця у швидкості є незрачною. +.TP +\fBsha256\fP +Обчислити SHA\-256. Цей варіант дещо повільніший за CRC32 і CRC64. +.RE +.IP "" +Цілісність заголовків \fB.xz\fP завжди перевіряють за допомогою CRC32. Таку +перевірку не можна змінити або скасувати. +.TP +\fB\-\-ignore\-check\fP +Не перевіряти цілісність стиснених даних при розпаковуванні. Значення CRC32 +у заголовках \fB.xz\fP буде у звичайний спосіб перевірено попри цей параметр. +.IP "" +\fBНе користуйтеся цим параметром, якщо ви не усвідомлюєте наслідків ваших дій.\fP Можливі причини скористатися цим параметром: +.RS +.IP \(bu 3 +Спроба отримання даних з пошкодженого файла .xz. +.IP \(bu 3 +Пришвидшення розпакування. Це, здебільшого, стосується SHA\-256 або файлів із +надзвичайно високим рівнем пакування. Не рекомендуємо користуватися цим +параметром з цією метою, якщо цілісність файлів не буде перевірено у якийсь +інший спосіб. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Вибрати рівень стискання. Типовим є \fB\-6\fP. Якщо буде вказано декілька рівнів +стискання, програма використає останній вказаний. Якщо вже було вказано +нетиповий ланцюжок фільтрів, встановлення рівня стискання призведе до +нехтування цим нетиповим ланцюжком фільтрів. +.IP "" +Різниця між рівнями є суттєвішою, ніж у \fBgzip\fP(1) і \fBbzip2\fP(1). Вибрані +параметри стискання визначають вимоги до пам'яті під час розпаковування, +отже використання надто високого рівня стискання може призвести до проблем +під час розпаковування файла на застарілих комп'ютерах із невеликим обсягом +оперативної пам'яті. Зокрема, \fBне варто використовувати \-9 для усього\fP, як +це часто буває для \fBgzip\fP(1) і \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Це дещо швидші набори налаштувань. \fB\-0\fP іноді є швидшим за \fBgzip \-9\fP, +забезпечуючи набагато більший коефіцієнт стискання. Вищі рівні часто мають +швидкість, яку можна порівняти з \fBbzip2\fP(1) із подібним або кращим +коефіцієнтом стискання, хоча результати значно залежать від типу даних, які +стискають. +.TP +\fB\-4\fP ... \fB\-6\fP +Стискання від доброго до дуже доброго рівня із одночасним підтриманням +помірного рівня споживання пам'яті засобом розпаковування, навіть для +застарілих системи. Типовим є значення \fB\-6\fP, яке є добрим варіантом для +поширення файлів, які мають бути придатними до розпаковування навіть у +системах із лише 16\ МіБ оперативної пам'яті. (Також можна розглянути +варіанти \fB\-5e\fP і \fB\-6e\fP. Див. \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Ці варіанти подібні до \fB\-6\fP, але із вищими вимогами щодо пам'яті для +стискання і розпаковування. Можуть бути корисними лише для стискання файлів +з розміром, що перевищує 8\ МіБ, 16\ МіБ та 32\ МіБ, відповідно. +.RE +.IP "" +На однаковому обладнанні швидкість розпакування є приблизно сталою кількістю +байтів стиснених даних за секунду. Іншими словами, чим кращим є стискання, +тим швидшим буде, зазвичай, розпаковування. Це також означає, що об'єм +розпакованих виведених даних, які видає програма за секунду, може коливатися +у широкому діапазоні. +.IP "" +У наведеній нижче таблиці підсумовано можливості шаблонів: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Шаблон;DictSize;CompCPU;CompMem;DecMem +\-0;256 КіБ;0;3 МіБ;1 МіБ +\-1;1 МіБ;1;9 МіБ;2 МіБ +\-2;2 МіБ;2;17 МіБ;3 МіБ +\-3;4 МіБ;3;32 МіБ;5 МіБ +\-4;4 МіБ;4;48 МіБ;5 МіБ +\-5;8 МіБ;5;94 МіБ;9 МіБ +\-6;8 МіБ;6;94 МіБ;9 МіБ +\-7;16 МіБ;6;186 МіБ;17 МіБ +\-8;32 МіБ;6;370 МіБ;33 МіБ +\-9;64 МіБ;6;674 МіБ;65 МіБ +.TE +.RE +.RE +.IP "" +Описи стовпчиків: +.RS +.IP \(bu 3 +DictSize є розміром словника LZMA2. Використання словника, розмір якого +перевищує розмір нестисненого файла, — проста витрата пам'яті. Ось чому не +варто використовувати шаблони \fB\-7\fP ... \fB\-9\fP, якщо у них немає реальної +потреби. Для \fB\-6\fP та нижчих рівнів об'єм витраченої пам'яті, зазвичай, +такий низький, що цей фактор ні на що не впливає. +.IP \(bu 3 +CompCPU є спрощеним представленням параметрів LZMA2, які впливають на +швидкість стискання. Розмір словника також впливає на швидкість, тому, хоча +значення CompCPU є однаковим для рівнів \fB\-6\fP ... \fB\-9\fP, обробка на вищих +рівнях все одно є трошки повільнішою. Що отримати повільніше і, ймовірно, +краще стискання, див. \fB\-\-extreme\fP. +.IP \(bu 3 +CompMem містить вимоги до пам'яті засобу стискання у однопотоковому +режимі. Значення можуть бути дещо різними для різних версій \fBxz\fP. +.IP \(bu 3 +У DecMem містяться вимоги до пам'яті при розпаковуванні. Тобто параметри +засобу стискання визначають вимоги до пам'яті при розпаковуванні. Точний +об'єм пам'яті, яка потрібна для розпаковування, дещо перевищує розмір +словника LZMA2, але значення у таблиці було округлено до наступного цілого +значення МіБ. +.RE +.IP "" +Вимоги до пам'яті у багатопотоковому режимі є значно вищими, ніж у +однопотоковому. З типовим значенням \fB\-\-block\-size\fP для кожного потоку треба +3*3*DictSize плюс CompMem або DecMem. Наприклад, для чотирьох потоків з +шаблоном \fB\-6\fP потрібно 660\(en670\ МіБ пам'яті. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Використати повільніший варіант вибраного рівня стискання (\fB\-0\fP ... \fB\-9\fP) +у сподіванні отримати трохи кращий коефіцієнт стискання, але, якщо не +поталанить, можна його і погіршити. Не впливає на використання пам'яті при +розпаковуванні, але використання пам'яті при стисканні дещо збільшиться на +рівнях \fB\-0\fP ... \fB\-3\fP. +.IP "" +Оскільки існує два набори налаштувань із розмірами словників 4\ МіБ та 8\ МіБ, у наборах \fB\-3e\fP і \fB\-5e\fP використано трошки швидші параметри (нижче +CompCPU), ніж у наборах \fB\-4e\fP і \fB\-6e\fP, відповідно. Тому двох однакових +наборів у списку немає. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Шаблон;DictSize;CompCPU;CompMem;DecMem +\-0e;256 КіБ;8;4 МіБ;1 МіБ +\-1e;1 МіБ;8;13 МіБ;2 МіБ +\-2e;2 МіБ;8;25 МіБ;3 МіБ +\-3e;4 МіБ;7;48 МіБ;5 МіБ +\-4e;4 МіБ;8;48 МіБ;5 МіБ +\-5e;8 МіБ;7;94 МіБ;9 МіБ +\-6e;8 МіБ;8;94 МіБ;9 МіБ +\-7e;16 МіБ;8;186 МіБ;17 МіБ +\-8e;32 МіБ;8;370 МіБ;33 МіБ +\-9e;64 МіБ;8;674 МіБ;65 МіБ +.TE +.RE +.RE +.IP "" +Наприклад, передбачено загалом чотири набори налаштувань із використанням +словника у 8\ МіБ, порядок яких від найшвидшого до найповільнішого є таким: +\fB\-5\fP, \fB\-6\fP, \fB\-5e\fP і \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Це дещо оманливі альтернативні варіанти для \fB\-0\fP і \fB\-9\fP, +відповідно. Реалізовано лише для забезпечення зворотної сумісності із LZMA +Utils. Намагайтеся не користуватися цими варіантами параметрів. +.TP +\fB\-\-block\-size=\fP\fIрозмір\fP +При стисканні до формату \fB.xz\fP поділити вхідні дані на блоки у \fIрозмір\fP +байтів. Ці блоки буде стиснуто незалежно один від одного, що допоможе у +багатопотоковій обробці і зробить можливим обмежене розпакування для доступу +до будь\-яких даних. Цим параметром слід типово користуватися для +перевизначення типового розміру блоку у багатопотоковому режимі обробки, але +цим параметром можна також скористатися в однопотоковому режимі обробки. +.IP "" +У багатопотоковому режимі для кожного потоку буде отримано для буферів +вхідних і вихідних даних майже утричі більше за \fIрозмір\fP байтів. Типовий +\fIрозмір\fP утричі більший за розмір словника LZMA2 або дорівнює 1 МіБ, буде +вибрано більше значення. Типовим добрим значенням буде значення, яке у +2\(en4 рази перевищує розмір словника LZMA2 або дорівнює принаймні 1 +МіБ. Використання значення \fIрозмір\fP, яке є меншим за розмір словника LZMA2, +має наслідком марну витрату оперативної пам'яті, оскільки його використання +призводить до того, що буфер словника LZMA2 ніколи не буде використано +повністю. У багатопотоковому режимі розміри блоків зберігатимуться у +заголовках блоків. Ці дані потрібні для багатопотокового розпаковування. +.IP "" +У однопотоковому режимі поділ на блоки типово не +виконуватиметься. Встановлення значення для цього параметра не впливатиме на +використання пам'яті. У заголовках блоків не зберігатимуться дані щодо +розміру, отже файли, які створено в однопотоковому режимі не будуть +ідентичними до файлів, які створено у багатопотоковому режимі. Те, що у +заголовках блоків не зберігатимуться дані щодо розміру також означає, що +\fBxz\fP не зможе розпаковувати такі файли у багатопотоковому режимі. +.TP +\fB\-\-block\-list=\fP\fIзаписи\fP +При стисканні у форматі \fB.xz\fP починати новий блок із необов'язковим +ланцюжком фільтрів після вказаної кількості інтервалів нестиснених даних. +.IP "" +\fIзаписи\fP є списком відокремлених комами значень. Кожен запис складається з +необов'язкового номера ланцюжка фільтрів від 0 до 9, після якого йде +двокрапка (\fB:\fP) і необхідний розмір нестиснутих даних. Пропущення запису +(дві або більше послідовних ком) є скороченим варіантом визначення +використання розміру та фільтрів попереднього запису. +.IP "" +Якщо файл вхідних даних є більшим за розміром за суму розмірів \fIзаписів\fP, +останнє значення у \fIрозмірах\fP буде повторено до кінця файла. Особливе +значення \fB0\fP може бути використано як останній розмір, щоб позначити, що +решту файла має бути закодовано як єдиний блок. +.IP "" +Альтернативний ланцюжок фільтрів для кожного блоку можна вказати в поєднанні +з параметрами \fB\-\-filters1=\fP\fIфільтри\fP \&...\& \fB\-\-filters9=\fP\fIфільтри\fP. Ці +параметри визначають ланцюжки фільтрів з ідентифікатором у діапазоні +1\(en9. Ланцюжок фільтрів 0 можна використовувати для посилання на типовий +ланцюжок фільтрів — це те саме, що не вказувати ланцюжок +фільтрів. Ідентифікатор ланцюжка фільтрів можна використовувати перед +нестисненим розміром, після якого йде двокрапка (\fB:\fP). Наприклад, якщо +вказати \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP, блоки будуть +створені так: +.RS +.IP \(bu 3 +Ланцюжок фільтрів задано \fB\-\-filters1\fP із вхідними даними у 2 МіБ +.IP \(bu 3 +Ланцюжок фільтрів задано \fB\-\-filters3\fP із вхідними даними у 2 МіБ +.IP \(bu 3 +Ланцюжок фільтрів задано \fB\-\-filters2\fP із вхідними даними у 4 МіБ +.IP \(bu 3 +Ланцюжок фільтрів задано \fB\-\-filters2\fP із вхідними даними у 4 МіБ +.IP \(bu 3 +Типовий ланцюжок даних і вхідні дані у 2 МіБ +.IP \(bu 3 +Типовий ланцюжок фільтрів та вхідні дані у 4 МіБ для кожного блоку до кінця +вхідних даних. +.RE +.IP "" +Якщо вказати розмір, який перевищує розмір блоку кодувальника (або типове +значення у режимі із потоками обробки, або значення, яке встановлено за +допомогою \fB\-\-block\-size=\fP\fIрозмір\fP), засіб кодування створить додаткові +блоки, зберігаючи межі, які вказано у \fIзаписах\fP. Наприклад, якщо вказати +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP, а файл +вхідних даних має розмір 80 МіБ, буде отримано такі 11 блоків: 5, 10, 8, 10, +2, 10, 10, 4, 10, 10 і 1 МіБ. +.IP "" +У багатопотоковому режимі розмір блоків буде збережено у заголовках +блоків. Програма не зберігатиме ці дані у однопотоковому режимі, отже +закодований результат не буде ідентичним до отриманого у багатопотоковому +режимі. +.TP +\fB\-\-flush\-timeout=\fP\fIчас_очікування\fP +При стискання, якщо з моменту попереднього витирання мине понад +\fIчас_очікування\fP мілісекунд (додатне ціле значення) і читання додаткових +даних буде заблоковано, усі вхідні дані у черзі обробки буде витерто з +кодувальника і зроблено доступним у потоці вихідних даних. Це може бути +корисним, якщо \fBxz\fP використовують для стискання даних, які передають +потоком мережею. Невеликі значення аргументу \fIчас_очікування\fP зроблять дані +доступними на боці отримання із малою затримкою, а великі значення аргумент +\fIчас_очікування\fP уможливлять кращий коефіцієнт стискання. +.IP "" +Типово, цю можливість вимкнено. Якщо цей параметр вказано декілька разів, +буде використано лише останнє вказане значення. Особливим значенням +аргументу \fIчас_очікування\fP, рівним \fB0\fP, можна скористатися для вимикання +цієї можливості явним чином. +.IP "" +Ця можливість недоступна у системах, які не є системами POSIX. +.IP "" +.\" FIXME +\fBЦя можливість усе ще є експериментальною.\fP У поточній версії, \fBxz\fP не +може розпаковувати потік даних у режимі реального часу через те, у який +спосіб \fBxz\fP виконує буферизацію. +.TP +\fB\-\-no\-sync\fP +Не синхронізувати файл призначення та його каталог із пристроєм зберігання +даних до вилучення початкового файла. Це може підвищити швидкодію, якщо +виконується стискання або розпаковування багатьох малих файлів. Втім, якщо +система аварійно завершує роботу невдовзі після вилучення, можлива ситуація, +коли файл призначення не буде записано на пристрій зберігання даних, а дію з +вилучення буде записано. У цьому випадку буде знищено дані як початкового +файла, так і файла призначення. +.IP "" +Цей параметр матиме хоч який вплив, лише якщо \fBxz\fP вилучає початковий +файл. В інших випадках синхронізація не виконується. +.IP "" +Синхронізацію і \fB\-\-no\-sync\fP було додано у версії \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIобмеження\fP +Встановити обмеження на використання пам'яті при стисканні. Якщо цей +параметр вказано декілька разів, враховано буде лише останнє вказане +значення. +.IP "" +Якщо параметри стискання перевищують \fIобмеження\fP, \fBxz\fP спробує скоригувати +параметри так, щоб обмеження не було перевищено, і покаже повідомлення про +те, що було виконано автоматичне коригування. Коригування буде виконано у +такому порядку: зменшення кількості потоків обробки, перемикання у +однопотоковий режим, якщо хоч в одному потоці багатопотокового режиму буде +перевищено \fIобмеження\fP, і нарешті, зменшення розміру словника LZMA2. +.IP "" +При стисканні з використанням \fB\-\-format=raw\fP, або якщо було вказано +\fB\-\-no\-adjust\fP, може бути зменшена лише кількість потоків обробки, оскільки +це може бути зроблено без впливу на стиснені виведені дані. +.IP "" +Якщо \fIобмеження\fP не може бути виконано за допомогою коригувань, які описано +вище, буде показано повідомлення про помилку, а \fBxz\fP завершить роботу зі +станом виходу 1. +.IP "" +Аргумент \fIобмеження\fP можна вказати у декілька способів: +.RS +.IP \(bu 3 +Значенням \fIобмеження\fP може бути додатне ціле значення у байтах. Можна +скористатися цілочисельним суфіксом, подібним до \fBMiB\fP. Приклад: +\fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +Аргумент \fIобмеження\fP може бути задано у відсотках від загальної фізичної +пам'яті системи (RAM). Це може бути корисним особливо при встановленні +змінної середовища \fBXZ_DEFAULTS\fP у скрипті ініціалізації системи, який є +спільним для різних комп'ютерів. У такий спосіб можна вказати вищий рівень +обмеження для систем із більшим об'ємом пам'яті. Приклад: +\fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +Аргументу \fIобмеження\fP може бути повернуто типове значення встановленням +значення \fB0\fP. У поточній версії це еквівалентно до встановлення значення +аргументу \fIобмеження\fP \fBmax\fP (без обмеження на використання пам'яті). +.RE +.IP "" +Для 32\-бітової версії \fBxz\fP передбачено особливий випадок: якщо \fIобмеження\fP +перевищуватиме \fB4020\ МіБ\fP, для \fIобмеження\fP буде встановлено значення +\fB4020\ MiB\fP. На MIPS32 замість цього буде використано \fB2000\ MiB\fP. (Це не +стосується значень \fB0\fP і \fBmax\fP. Подібної можливості для розпаковування не +існує.) Це може бути корисним, коли 32\-бітовий виконуваний файл має доступ +до простору адрес у 4\ ГіБ (2 GiB на MIPS32), хоча, сподіваємося, не +зашкодить і в інших випадках. +.IP "" +Див. також розділ \fBВикористання пам'яті\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIобмеження\fP +Встановити обмеження пам'яті на розпаковування. це також вплине на режим +\fB\-\-list\fP. Якщо дія є неможливою без перевищення \fIобмеження\fP, \fBxz\fP покаже +повідомлення про помилку і розпаковування файла не +відбудеться. Див. \fB\-\-memlimit\-compress=\fP\fIобмеження\fP, щоб дізнатися більше +про те, як можна задати \fIобмеження\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIобмеження\fP +Встановити обмеження використання пам'яті для багатопотокового +розпаковування. Це може вплинути лише на кількість потоків обробки; це +ніколи не призводитиме до відмови \fBxz\fP у розпаковуванні файла. Якщо +\fIобмеження є надто низьким\fP, щоб уможливити будь\-яку багатопотокову +обробку, \fIобмеження\fP буде проігноровано, і \fBxz\fP продовжить обробку в +однопотоковому режимі. Зауважте, що якщо використано також +\fB\-\-memlimit\-decompress\fP, цей параметр буде застосовано до обох режимів, +однопотокового та багатопотокового, а отже, задіяне \fIобмеження\fP для +багатопотокового режиму ніколи не перевищуватиме обмеження, яке встановлено +за допомогою \fB\-\-memlimit\-decompress\fP. +.IP "" +На відміну від інших параметрів обмеження використання пам'яті, +\fB\-\-memlimit\-mt\-decompress=\fP\fIобмеження\fP містить специфічне для системи +типове значення \fIобмеження\fP. Можна скористатися \fBxz \-\-info\-memory\fP для +перегляду поточного значення. +.IP "" +Цей параметр і його типове значення існують, оскільки без будь\-яких обмежень +засіб розпакування зі підтримкою потокової обробки міг би намагатися +отримати величезний об'єм пам'яті для деяких файлів вхідних даних. Якщо +типове \fIобмеження\fP є надто низьким для вашої системи, не вагайтеся і +збільшуйте \fIобмеження\fP, але ніколи не встановлюйте для нього значення, яке +є більшим за придатний до користування об'єм оперативної пам'яті, оскільки +за відповідних файлів вхідних даних \fBxz\fP спробує скористатися цим об'ємом +пам'яті, навіть із низькою кількістю потоків обробки. Вичерпання об'єму +оперативної пам'яті або використання резервної пам'яті на диску не покращить +швидкодію системи під час розпаковування. +.IP "" +Див. \fB\-\-memlimit\-compress=\fP\fIобмеження\fP, щоб ознайомитися із можливими +способами визначення \fIобмеження\fP. Встановлення для \fIобмеження\fP значення +\fB0\fP відновлює типове специфічне для системи значення \fIобмеження\fP. +.TP +\fB\-M\fP \fIобмеження\fP, \fB\-\-memlimit=\fP\fIобмеження\fP, \fB\-\-memory=\fP\fIобмеження\fP +Є еквівалентом визначення \fB\-\-memlimit\-compress=\fP\fIобмеження\fP +\fB\-\-memlimit\-decompress=\fP\fIобмеження\fP +\fB\-\-memlimit\-mt\-decompress=\fP\fIобмеження\fP. +.TP +\fB\-\-no\-adjust\fP +Показати повідомлення про помилку і завершити роботу, якщо не вдасться +виконати умови щодо обмеження використання пам'яті без коригування +параметрів, які впливають на стиснених виведених даних. Тобто це забороняє +\fBxz\fP перемикати кодувальник з багатопотокового режиму на однопотоковий +режим і зменшувати розмір словника LZMA2. Навіть якщо використано цей +параметр, кількість потоків може бути зменшено для виконання обмеження на +використання пам'яті, оскільки це не вплине на результати стискання. +.IP "" +Автоматичне коригування завжди буде вимкнено при створенні потоків +необроблених даних (\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fIпотоки\fP, \fB\-\-threads=\fP\fIпотоки\fP +Вказати кількість потоків обробки, якими слід скористатися. Встановлення для +аргументу \fIпотоки\fP особливого значення \fB0\fP наказує \fBxz\fP використати не +більше потоків обробки, ніж передбачено підтримку у процесорах +системи. Справжня кількість потоків може бути меншою за значення \fIпотоки\fP, +якщо файл вхідних даних не є достатньо великим для поділу на потоки обробки +при заданих параметрах або якщо використання додаткових потоків призведе до +перевищення обмеження на використання пам'яті. +.IP "" +Засоби стискання в однопотоковому та багатопотоковому режимі дають різні +результати. Однопотоковий засіб стискання дасть найменший розмір файла, але +лише результати роботи багатопотокового засобу стискання може бути +розпаковано з використанням декількох потоків. Встановлення для аргументу +\fIпотоки\fP значення \fB1\fP призведе до використання однопотокового +режиму. Встановлення для аргументу \fIпотоки\fP будь\-якого іншого значення, +включно з \fB0\fP, призведе до використання багатопотокового засобу стискання, +навіть якщо у системі передбачено підтримки лише одного апаратного потоку +обробки даних. (Версія \fBxz\fP 5.2.x у цьому випадку використовувала +однопотоковий режим.) +.IP "" +Щоб скористатися багатопотоковим режимом із лише одним потоком обробки, +встановіть для аргументу \fIпотоки\fP значення \fB+1\fP. Префікс \fB+\fP не впливає +на значення, окрім \fB1\fP. Обмеження на використання пам'яті можуть перемкнути +\fBxz\fP в однопотоковий режим, якщо не використано параметр +\fB\-\-no\-adjust\fP. Підтримку \fB+\fP prefix було додано у версії \fBxz\fP 5.4.0. +.IP "" +Якщо було вказано автоматичне визначення кількості потоків і не вказано +обмеження на використання пам'яті, буде використано специфічне для системи +типове м'яке обмеження для можливого обмеження кількості потоків обробки. Це +обмеження є м'яким у сенсі того, що його буде проігноровано, якщо кількість +потоків зрівняється з одиницею, а отже, м'яке обмеження ніколи не +запобігатиму у \fBxz\fP стисканню або розпаковуванню. Це типове м'яке обмеження +не перемкне \fBxz\fP з багатопотокового режиму на однопотоковий режим. Активні +обмеження можна переглянути за допомогою команди \fBxz \-\-info\-memory\fP. +.IP "" +У поточній версії єдиним способом поділу на потоки обробки є поділ вхідних +даних на блоки і стискання цих блоків незалежно один від одного. Типовий +розмір блоку залежить від рівня стискання. Його може бути перевизначено за +допомогою параметра \fB\-\-block\-size=\fP\fIрозмір\fP. +.IP "" +Розпакування з потоками обробки працює лише для файлів, які містять декілька +блоків із даними щодо розміру у заголовках блоків. Цю умову задовольняють +усі достатньо великі файли, які стиснено у багатопотоковому режимі, але не +задовольняють будь\-які файли, які було стиснуто у однопотоковому режимі, +навіть якщо було використано параметр \fB\-\-block\-size=\fP\fIрозмір\fP. +.IP "" +Типовим значенням для \fIпотоків\fP є \fB0\fP. У \fBxz\fP 5.4.x та старіших версіях +типовим значенням є \fB1\fP. +. +.SS "Нетипові ланцюжки фільтрів засобу стискання" +Нетиповий ланцюжок фільтрування уможливлює докладне визначення параметрів +стискання замість використання параметрів, які пов'язано із наперед +визначеними рівнями стискання. Якщо вказано нетиповий ланцюжок фільтрів, +параметри рівнів стискання (\fB\-0\fP \&...\& \fB\-9\fP і \fB\-\-extreme\fP), які +передують їм у рядку команди, буде знехтувано. Якщо параметр рівня стискання +вказано після одного або декількох параметрів нетипового ланцюжка фільтрів, +буде використано рівень стискання, а попередніми параметрами ланцюжка +фільтрування буде знехтувано. +.PP +Ланцюжок фільтрів можна порівняти із конвеєром у командному рядку. При +стисканні нестиснені вхідні дані потрапляють до першого фільтра, виведені +ним дані йдуть до наступного фільтра (якщо такий є). Виведені останнім +фільтром дані буде записано до стисненого файла. Максимальна кількість +фільтрів у ланцюжку дорівнює чотирьом, але у типовому ланцюжку фільтрів +використовують один або два фільтри. +.PP +У багатьох фільтрів є обмеження на місце перебування у ланцюжку фільтрів: +деякі фільтри можуть працювати, лише якщо вони є останніми у ланцюжку, +деякі, лише якщо не останніми, а деякі працюють у будь\-якій позиції +ланцюжка. Залежно від фільтра, це обмеження є наслідком структури фільтра +або існує для запобігання проблем із захистом. +.PP +Нетиповий ланцюжок фільтрів можна вказати двома різними способами. Параметри +\fB\-\-filters=\fP\fIфільтри\fP і \fB\-\-filters1=\fP\fIфільтри\fP \&...\& +\fB\-\-filters9=\fP\fIфільтри\fP надають змогу вказати цілий ланцюжок фільтрів в +одному варіанті з використанням синтаксису рядків фільтрів liblzma. Крім +того, ланцюжок фільтрів можна вказати за допомогою одного або кількох +окремих параметрів фільтрування у тому порядку, в якому їх слід використати +у ланцюжку фільтрів. Тобто порядок окремих параметрів фільтра є важливим! +Під час декодування необроблених потоків (\fB\-\-format=raw\fP) ланцюжок фільтрів +має бути вказано у тому ж порядку, що й під час стиснення. Будь\-який окремий +фільтр або параметри попереднього налаштування, вказані перед параметром +повного ланцюжка (\fB\-\-filters=\fP\fIфільтри\fP), буде відкинуто. Окремі фільтри, +указані після параметра повного ланцюжка, відновлять типовий ланцюжок +фільтрів. +.PP +І параметр повного і параметр окремого фільтра приймають специфічні для +фільтрів \fIпараметри\fP у форматі списку значень, які відокремлено +комами. Зайві коми у \fIпараметрах\fP буде проігноровано. У кожного параметра є +типове значення, отже, вам слід вказати ті параметри, значення яких ви +хочете змінити. +.PP +Щоб переглянути увесь ланцюжок фільтрів та \fIпараметри\fP, скористайтеся +командою \fBxz \-vv\fP (тобто, скористайтеся \fB\-\-verbose\fP двічі). Це працює +також для перегляду параметрів ланцюжка фільтрів, який використано у рівнях +стискання. +.TP +\fB\-\-filters=\fP\fIфільтри\fP +Визначає повний ланцюжок фільтрів або шаблон у форматі одного +параметра. Кожен фільтр можна відокремити від інших пробілами або двома +дефісами (\fB\-\-\fP). Можливо, \fIфільтри\fP доведеться взяти в лапки в командному +рядку оболонки, щоб їх було оброблено як один параметр. Для позначення +\fIпараметрів\fP скористайтеся \fB:\fP або \fB=\fP. До шаблона можна додати префікс +\fB\-\fP і завершити без прапорців або декількома прапорцями. Єдиним +підтримуваним прапорцем є \fBe\fP для застосування тих самих параметрів, що й +\fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIфільтри\fP ... \fB\-\-filters9\fP=\fIфільтри\fP +Вказати до дев'яти додаткових ланцюжків фільтрів, якими можна скористатися +за допомогою \fB\-\-block\-list\fP. +.IP "" +Наприклад, якщо виконується стискання архіву із виконуваними файлами, за +якими йдуть текстові файли, для виконуваної частини може бути використано +ланцюжок фільтрів з фільтром BCJ, а для текстової частини — лише фільтр +LZMA2. +.TP +\fB\-\-filters\-help\fP +Вивести довідкове повідомлення з описом того, як вказати шаблони та нетипові +ланцюжки фільтрів у параметри \fB\-\-filters\fP і \fB\-\-filters1=\fP\fIфільтри\fP +\&...\& \fB\-\-filters9=\fP\fIфільтри\fP і завершити роботу із кодом успіху. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIпараметри\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIпараметри\fP] +.PD +Додати фільтр LZMA1 або LZMA2 до ланцюжка фільтрів. Ці фільтри може бути +використано лише як останній фільтр у ланцюжку. +.IP "" +LZMA1 є застарілим фільтром, підтримку якого збережено майже лише через +використання формату файлів \fB.lzma\fP, у яких передбачено підтримку лише +LZMA1. LZMA2 є оновленою версією LZMA1, у якій виправлено деякі практичні +вади LZMA1. У форматі \fB.xz\fP використано LZMA2 і взагалі не передбачено +підтримки LZMA1. Швидкість стискання та коефіцієнт стискання для LZMA1 і +LZMA2 є практично однаковими. +.IP "" +LZMA1 і LZMA2 спільно використовують той самий набір \fIпараметрів\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIшаблон\fP +Скинути усі \fIпараметри\fP LZMA1 або LZMA2 до параметрів \fIшаблона\fP. Аргумент +\fIшаблон\fP складається з цілого числа, після якого може бути однолітерний +модифікатор шаблона. Ціле число може належати лише діапазону від \fB0\fP до +\fB9\fP, що відповідає параметрам командного рядка \fB\-0\fP \&...\& \fB\-9\fP. Єдиним +підтримуваним модифікатором у поточній версії є \fBe\fP, щоб відповідає +параметру \fB\-\-extreme\fP. Якщо аргумент \fBшаблон\fP не вказано, типові значення +\fIпараметрів\fP LZMA1 або LZMA2 буде взято із шаблона \fB6\fP. +.TP +\fBdict=\fP\fIрозмір\fP +Параметр \fIрозміру\fP словника (буфера журналу) визначає, скільки байтів +нещодавно оброблених нестиснених даних слід зберігати у пам'яті. Алгоритм +намагається знайти повторювані послідовності байтів (відповідники) у +нестиснених даних і замінити їх на посилання на дані зі словника. Чим +більшим є словник, тим вищою є ймовірність відшукати відповідник. Отже, +збільшення \fIрозміру\fP словника, зазвичай, покращує коефіцієнт стискання, але +використання словника, розмір якого перевищу є розмір нестисненого файла є +простоюю витратою пам'яті. +.IP "" +\fIРозмір\fP типового словника складає від 64\ КіБ до 64\ МіБ. Мінімальним є +розмір 4\ КіБ. Максимальним розміром для стискання у поточній версії 1.5\ ГіБ (1536\ МіБ). У засобі розпаковування вже передбачено підтримку словників +на один байт менших за 4\ ГіБ, що є максимальним значенням для форматів +потоків даних LZMA1 і LZMA2. +.IP "" +Аргумент \fIрозміру\fP словника і засіб пошуку відповідників (\fImf\fP) разом +визначають параметри використання пам'яті для кодувальника LZMA1 або +LZMA2. Для розпаковування потрібен такий самий (або більший) \fIрозмір\fP +словника, що і для стискання, отже, використання пам'яті для засобу +розпаковування буде визначено за розміром словника, який було використано +для стискання. У заголовках \fB.xz\fP зберігається \fIрозмір\fP словника або як +2^\fIn\fP, або як 2^\fIn\fP + 2^(\fIn\fP\-1), отже, ці \fIрозміри\fP є дещо пріоритетними +для стискання. Інші \fIрозміри\fP буде отримано округленням при зберіганні у +заголовках \fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Визначає кількість буквальних контекстних бітів. Мінімальною кількістю є 0, +а максимальною — 4. Типовою кількістю є 3. Крім того, сума \fIlc\fP і \fIlp\fP має +не перевищувати 4. +.IP "" +Усі байти, які не може бути закодовано як відповідності, буде закодовано як +літерали. Тобто літерали є просто 8\-бітовими байтами, які буде закодовано по +одному за раз. +.IP "" +При кодуванні літералів роблять припущення, що найвищі біти \fIlc\fP +попереднього нестисненого байта корелюють із наступним байтом. Наприклад, у +типовому тексті англійською за літерою у верхньому регістрі йде літера у +нижньому регістрі, а за літерою у нижньому регістрі, зазвичай, йде інша +літера у нижньому регістрі. У наборі символів US\-ASCII найвищими трьома +бітами є 010 для літер верхнього регістру і 011 для літер нижнього +регістру. Якщо \fIlc\fP дорівнює принаймні 3, при кодуванні літералів можна +отримати перевагу встановлення цієї властивості для нестиснених даних. +.IP "" +Зазвичай, типового значення (3) достатньо. Якщо вам потрібне максимальне +стискання, спробуйте \fBlc=4\fP. Іноді це трохи допомагає, а іноді, робить +стискання гіршим. Якщо стискання стане гіршим, спробуйте також \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Визначає кількість буквальних позиційних бітів. Мінімальною кількістю є 0, а +максимальною — 4. Типовою кількістю є 0. +.IP "" +\fILp\fP впливає на те, яке вирівнювання у нестиснених даних слід припускати +при кодуванні літералів. Див. \fIpb\fP нижче, щоб дізнатися більше про +вирівнювання. +.TP +\fBpb=\fP\fIpb\fP +Визначає кількість позиційних бітів. Мінімальною кількістю є 0, а +максимальною — 4. Типовою кількістю є 2. +.IP "" +\fIPb\fP впливає на те, який тип вирівнювання загалом припускатиметься для +нестиснених даних. Типовим є чотирибайтове вирівнювання (2^\fIpb\fP=2^2=4), +яке, зазвичай, є добрим варіантом, якщо немає кращих припущень. +.IP "" +Якщо вирівнювання є відомим, встановлення відповідним чином \fIpb\fP може трохи +зменшити розмір файла. Наприклад, у текстових файлах із однобайтовим +вирівнюванням (US\-ASCII, ISO\-8859\-*, UTF\-8), встановлення значення \fBpb=0\fP +може трохи поліпшити стискання. Для тексту UTF\-16 добрим варіантом є +\fBpb=1\fP. Якщо вирівнювання є непарним числом, наприклад 3 байти, найкращим +вибором, ймовірно, є \fBpb=0\fP. +.IP "" +Хоча прогнозоване вирівнювання можна скоригувати за допомогою \fIpb\fP і \fIlp\fP, +у LZMA1 і LZMA2 дещо пріоритетним є 16\-байтове вирівнювання. Це, ймовірно, +слід враховувати при компонуванні форматів файлів, які, ймовірно, часто +будуть стискатися з використанням LZMA1 або LZMA2. +.TP +\fBmf=\fP\fImf\fP +Засіб пошуку відповідників має значний вплив на швидкість, використання +пам'яті та коефіцієнт стискання кодувальника. Зазвичай, засоби пошуку +відповідників на основі ланцюжка хешів є швидшими за засоби пошуку +відповідників на основі двійкового дерева. Типовий засіб залежить від +\fIшаблона\fP: для 0 використовують \fBhc3\fP, для 1\(en3 — \fBhc4\fP, а для решти +використовують \fBbt4\fP. +.IP "" +Передбачено підтримку вказаних нижче засобів пошуку відповідників. Наведені +нижче формули обчислення використання пам'яті є грубими наближеннями, які є +найближчими до реальних значень, якщо значенням \fIсловник\fP є степінь двійки. +.RS +.TP +\fBhc3\fP +Ланцюжок хешів із 2\- та 3\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 3 +.br +Використання пам'яті: +.br +\fIdict\fP * 7.5 (якщо \fIdict\fP <= 16 МіБ); +.br +\fIdict\fP * 5.5 + 64 МіБ (якщо \fIdict\fP > 16 МіБ) +.TP +\fBhc4\fP +Ланцюжок хешів із 2\-, 3\- та 4\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 4 +.br +Використання пам'яті: +.br +\fIdict\fP * 7.5 (якщо \fIdict\fP <= 32 МіБ); +.br +\fIdict\fP * 6.5 (якщо \fIdict\fP > 32 МіБ) +.TP +\fBbt2\fP +Двійкове дерево із 2\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 2 +.br +Використання пам'яті: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Двійкове дерево із 2\- і 3\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 3 +.br +Використання пам'яті: +.br +\fIdict\fP * 11.5 (якщо \fIdict\fP <= 16 МіБ); +.br +\fIdict\fP * 9.5 + 64 МіБ (якщо \fIdict\fP > 16 МіБ) +.TP +\fBbt4\fP +Двійкове дерево із 2\-, 3\- і 4\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 4 +.br +Використання пам'яті: +.br +\fIdict\fP * 11.5 (якщо \fIdict\fP <= 32 МіБ); +.br +\fIdict\fP * 10.5 (якщо \fIdict\fP > 32 МіБ) +.RE +.TP +\fBmode=\fP\fIрежим\fP +Параметр \fIрежиму\fP стискання визначає спосіб, який буде використано для +аналізу даних, які створено засобом пошуку відповідників. Підтримуваними +\fIрежимами\fP є \fBfast\fP (швидкий) і \fBnormal\fP (нормальний). Типовим є режим +\fBfast\fP для \fIшаблонів\fP 0\(en3 і режим \fBnormal\fP для \fIшаблонів\fP 4\(en9. +.IP "" +Зазвичай, із засобом пошуку відповідників на основі ланцюжка хешів +використовують \fBfast\fP, а із засобом пошуку відповідників на основі +двійкового дерева використовують \fBnormal\fP. Так само налаштовано і +\fIшаблони\fP. +.TP +\fBnice=\fP\fIпріоритетність\fP +Вказати, яка довжина є пріоритетною для відповідності. Щойно буде виявлено +відповідність у принаймні \fIпріоритетність\fP байтів, алгоритм зупинятиме +пошук можливих кращих відповідників. +.IP "" +\fIПріоритетністю\fP може бути число до 2\(en273 байтів. Вищі значення дають +кращий коефіцієнт стискання за рахунок швидкості. Типове значення залежить +від \fIшаблона\fP. +.TP +\fBdepth=\fP\fIглибина\fP +Вказати максимальну глибину пошуку у засобі пошуку відповідності. Типовим є +особливе значення 0, яке наказує засобу стискання визначити прийнятну +\fIглибину\fP на основі \fImf\fP і \fIпріоритетності\fP. +.IP "" +Прийнятним значенням \fIглибини\fP для ланцюжків хешів є 4\(en100 і 16\(en1000 +для двійкових дерев. Використання дуже високих значень для \fIглибини\fP може +зробити кодувальник дуже повільним для деяких файлів. Не встановлюйте +значення \fIглибини\fP, що перевищує 1000, якщо ви не готові перервати +стискання, якщо воно триватиме надто довго. +.RE +.IP "" +При декодуванні необроблених потоків даних (\fB\-\-format=raw\fP), LZMA2 потребує +лише \fIрозміру\fP словника. LZMA1 потребує також \fIlc\fP, \fIlp\fP і \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIпараметри\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIпараметри\fP] +.PD +Додати фільтр гілок/викликів/переходів (branch/call/jump або BCJ) до +ланцюжка фільтрів. Цими фільтрами можна скористатися, лише якщо вони не є +останнім фільтром у ланцюжку фільтрів. +.IP "" +Фільтр BCJ перетворює відносні адреси у машинному коді на їхні абсолютні +відповідники. Це не змінює розміру даних, але підвищує резервування, що може +допомогти LZMA2 створити файл \fB.xz\fP на 0\(en15\ % менше. Фільтри BCJ завжди +є придатними до обернення, тому використання фільтра BCJ до помилкового типу +даних не спричинятиме втрати даних, хоча може дещо погіршити коефіцієнт +стискання. Фільтри BCJ є дуже швидкими і такими, що використовують незначний +об'єм пам'яті. +.IP "" +Ці фільтри BCJ мають відомі проблеми, які пов'язано із рівнем стискання: +.RS +.IP \(bu 3 +У деяких типах файлів, де зберігається виконуваний код, (наприклад, в +об'єктних файлах, статичних бібліотеках та модулях ядра Linux) адреси в +інструкціях заповнено значеннями заповнювача. Ці фільтри BCJ виконуватимуть +перетворення адрес, яке зробить стискання для цих файлів гіршим. +.IP \(bu 3 +Якщо фільтр BCJ застосовано до архіву, може так статися, що він погіршить +коефіцієнт стискання порівняно із варіантом без фільтра BCJ. Наприклад, якщо +є подібні або навіть однакові виконувані файли, фільтрування, ймовірно, +зробить ці файли менш подібними, а отже, зробить стискання гіршим. Вміст +файлів, які не є виконуваними, у тому самому архіві також може вплинути на +результат. На практиці, варто спробувати варіанти з фільтром BCJ і без +нього, щоб визначитися із тим, що буде кращим у кожній ситуації. +.RE +.IP "" +Різні набори інструкцій мають різне вирівнювання: виконуваний файл має бути +вирівняно на кратне до цього значення у вхідних даних, щоб фільтр спрацював. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Фільтр;Вирівнювання;Нотатки +x86;1;32\-бітова або 64\-бітова x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;Найкращим є вирівнювання за +;;4096 байтами +PowerPC;4;Лише зворотний порядок байтів +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Оскільки фільтровані BCJ дані, зазвичай, стискають за допомогою LZMA2, +коефіцієнт стискання можна трохи поліпшити, якщо параметри LZMA2 буде +встановлено так, щоб вони відповідали вирівнюванню вибраного фільтра +BCJ. Приклади: +.RS +.IP \(bu 3 +Фільтр IA\-64 має 16\-байтове вирівнювання, отже \fBpb=4,lp=4,lc=0\fP дасть добрі +результати у поєднанні із LZMA2 (2^4=16). +.IP \(bu 3 +Код RISC\-V має 2\-байтове або 4\-байтове вирівнювання залежно від того, чи +містить файл 16\-бітові стислі інструкції (розширення C). Якщо використано +16\-бітові інструкції, добрі результати дасть \fBpb=2,lp=1,lc=3\fP або +\fBpb=1,lp=1,lc=3\fP. Якщо 16\-бітових інструкцій немає, найкращим варіантом є +\fBpb=2,lp=2,lc=2\fP. Можна скористатися \fBreadelf \-h\fP, щоб перевірити, чи є +"RVC" у рядку "Flags". +.IP \(bu 3 +ARM64 завжди вирівняно на 4 байти, тому найкращим варіантом буде +\fBpb=2,lp=2,lc=2\fP. +.IP \(bu 3 +Фільтр x86 є виключенням. Зазвичай, добрі результати дають типові для LZMA2 +значення (\fBpb=2,lp=0,lc=3\fP), якщо стискають виконувані файли x86. +.RE +.IP "" +У всіх фільтрах BCJ передбачено підтримку тих самих \fIпараметрів\fP: +.RS +.TP +\fBstart=\fP\fIзсув\fP +Встановити початковий \fIзсув\fP, який буде використано при перетворенні між +відносною та абсолютною адресами. Значення \fIзсув\fP має бути кратним до +вирівнювання фільтра (див. таблицю вище). Типовим зсувом є нульовий. На +практиці, типове значення є прийнятним; визначення нетипового значення +\fIзсув\fP майже завжди нічого корисного не дає. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIпараметри\fP] +Додати дельта\-фільтр до ланцюжка фільтрів. Дельта\-фільтр може бути +використано, лише якщо він не є останнім у ланцюжку фільтрів. +.IP "" +У поточній версії передбачено підтримку обчислення лише простої побітової +дельти. Це може бути корисним при стисканні, наприклад, нестиснутих +растрових зображень або нестиснутих звукових даних PCM. Втім, спеціалізовані +алгоритми можуть давати значно кращі результати за дельту + LZMA2. Це +правило особливо стосується звукових даних, які стискає швидше і краще, +наприклад, \fBflac\fP(1). +.IP "" +Підтримувані \fIпараметри\fP: +.RS +.TP +\fBdist=\fP\fIвідстань\fP +Вказати \fIвідстань\fP обчислень різниці у байтах. Значення \fIвідстань\fP має +потрапляти у діапазон 1\(en256. Типовим значенням є 1. +.IP "" +Наприклад, з \fBdist=2\fP та восьмибайтовими вхідними даними A1 B1 A2 B3 A3 B5 +A4 B7, результатом буде A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Інші параметри" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Придушити попередження та сповіщення. Вкажіть цей параметр двічі, щоб +придушити також повідомлення про помилки. Цей параметр не впливає на стан +виходу з програми. Тобто, навіть якщо було придушено попередження, стан +виходу вказуватиме на те, що попередження були. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Докладний режим повідомлень. Якщо стандартне виведення помилок з'єднано із +терміналом, \fBxz\fP показуватиме індикатор поступу. Використання \fB\-\-verbose\fP +двічі призведе до ще докладнішого виведення. +.IP "" +Індикатор поступу показує такі дані: +.RS +.IP \(bu 3 +Частку завершеності буде показано, якщо відомий розмір файла вхідних +даних. Тобто, для каналів даних частку не може бути показано. +.IP \(bu 3 +Об'єм стиснених виведених даних (стискання) або оброблених (розпаковування). +.IP \(bu 3 +Об'єм незапакованих даних (стискання) або виведених даних (розпаковування). +.IP \(bu 3 +Коефіцієнт стискання, який обчислено діленням об'єму оброблених стиснутих +даних на об'єм оброблених нестиснутих даних. +.IP \(bu 3 +Швидкість стискання або розпаковування. Обчислюється як об'єм нестиснутих +даних (стискання) або виведених даних (розпаковування) за секунду. Його буде +показано за декілька секунд з моменту, коли \fBxz\fP почала обробляти файл. +.IP \(bu 3 +Витрачений час у форматі Х:СС або Г:ХХ:СС. +.IP \(bu 3 +Оцінку часу, що лишився, буде показано, лише якщо розмір файла вхідних даних +є відомим, і минуло принаймні декілька секунд з моменту, коли \fBxz\fP почала +обробляти файл. Час буде показано у менш точному форматі, без двокрапок, +наприклад, 2 хв. 30 с. +.RE +.IP "" +Якщо стандартним виведенням помилок не є термінал, \fB\-\-verbose\fP призведе до +того, що \fBxz\fP виведе назву файла, стиснений розмір, нестиснений розмір, +коефіцієнт стискання та, можливо, також швидкість та витрачений час у одному +рядку до стандартного виведення помилок після стискання або розпаковування +файла. Швидкість та витрачений час буде включено, лише якщо дія триває +принаймні декілька секунд. Якщо дію не буде завершено, наприклад, через +втручання користувача, буде також виведено частку виконання, якщо відомий +розмір файла вхідних даних. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Не встановлювати стан виходу 2, навіть якщо було виявлено відповідність +умові, яка варта попередження. Цей параметр не впливає на рівень докладності +повідомлень, отже, слід використати \fB\-\-quiet\fP і \fB\-\-no\-warn\fP, щоб програма +не показувала попереджень і не змінювала стан виходу. +.TP +\fB\-\-robot\fP +Виводити повідомлення у придатному для обробки комп'ютером форматі. Цей +формат призначено для полегшення написання оболонок, які використовуватимуть +\fBxz\fP замість liblzma, що може бути зручним для різноманітних +скриптів. Виведені дані з цим параметром має бути стабільним для усіх +випусків \fBxz\fP. Докладніший опис можна знайти у розділі \fBРЕЖИМ РОБОТА\fP. +.TP +\fB\-\-info\-memory\fP +Вивести у придатному для читання людиною форматі, скільки фізичної пам'яті +(RAM) та скільки потоків процесора є за даними \fBxz\fP у системі, обмеження +для стискання та розпаковування, а потім успішно завершити роботу. +.TP +\fB\-h\fP, \fB\-\-help\fP +Вивести повідомлення про помилку з описом найбільш типових використаних +параметрів і успішно завершити роботу. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Вивести довідкове повідомлення з описом усіх можливостей \fBxz\fP і успішно +завершити роботу +.TP +\fB\-V\fP, \fB\-\-version\fP +Вивести номер версії \fBxz\fP та liblzma у зручному для читання форматі. Щоб +отримати дані, зручні для обробки на комп'ютері, вкажіть \fB\-\-robot\fP до +\fB\-\-version\fP. +. +.SH "РЕЖИМ РОБОТА" +Режим робота активують за допомогою параметра \fB\-\-robot\fP. Він спрощує +обробку виведених \fBxz\fP даних іншими програмами. У поточній версії підтримку +\fB\-\-robot\fP передбачено лише разом із \fB\-\-list\fP, \fB\-\-filters\-help\fP, +\fB\-\-info\-memory\fP і \fB\-\-version\fP. У майбутньому підтримку параметра буде +передбачено для стискання та розпаковування. +. +.SS "Режим списку" +У \fBxz \-\-robot \-\-list\fP використано табуляції для поділу виведених +даних. Першим стовпчиком у кожному рядку є рядок, що вказує на тип +відомостей, які можна знайти у цьому рядку: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Це завжди перший рядок на початку списку файла. Другим стовпчиком у рядку є +назва файла. +.TP +\fBfile\fP +У цьому рядку містяться загальні відомості щодо файла \fB.xz\fP. Цей рядок +завжди виводять після рядка \fBname\fP. +.TP +\fBstream\fP +Цей тип рядка використовують, лише якщо було вказано \fB\-\-verbose\fP. Буде +стільки рядків \fBstream\fP, скільки потоків у файлі \fB.xz\fP. +.TP +\fBblock\fP +Цей тип рядка використовують, лише якщо було вказано \fB\-\-verbose\fP. Буде +стільки рядків \fBblock\fP, скільки блоків у файлі \fB.xz\fP. Рядки \fBblock\fP буде +показано після усіх рядків \fBstream\fP; різні типи рядків не перемежовуються. +.TP +\fBsummary\fP +Цей тип рядків використовують, лише якщо \fB\-\-verbose\fP було вказано +двічі. Цей рядок буде виведено після усіх рядків \fBblock\fP. Подібно до рядка +\fBfile\fP, рядок \fBsummary\fP містить загальні відомості щодо файла \fB.xz\fP. +.TP +\fBtotals\fP +Цей рядок завжди є найостаннішим рядком у виведеному списку. У ньому буде +показано загальні кількості та розміри. +.PP +Стовпчики у рядках \fBфайла\fP: +.PD 0 +.RS +.IP 2. 4 +Кількість потоків у файлі +.IP 3. 4 +Загальна кількість блоків у потоках +.IP 4. 4 +Розмір стисненого файла +.IP 5. 4 +Розмір нестисненого файла +.IP 6. 4 +Коефіцієнт стискання, наприклад, \fB0.123\fP. Якщо коефіцієнт перевищує 9.999, +замість коефіцієнта буде показано дефіси (\fB\-\-\-\fP). +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Список відокремлених комами назв перевірок цілісності. Наведені нижче рядки +використовують для відомих типів перевірок: \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP і +\fBSHA\-256\fP. Для невідомих типів перевірок буде використано \fBUnknown\-\fP\fIN\fP, +де \fIN\fP є ідентифікатором перевірки у форматі десяткового числа (одна або +дві цифри). +.IP 8. 4 +Загальний розмір доповнення потоку у файлі +.RE +.PD +.PP +Стовпчики у рядках \fBstream\fP: +.PD 0 +.RS +.IP 2. 4 +Номер потоку (перший потік має номер 1) +.IP 3. 4 +Кількість блоків у потоці +.IP 4. 4 +Зсув початку стисненого +.IP 5. 4 +Зсув початку нестисненого +.IP 6. 4 +Стиснений розмір (не включає доповнення потоку) +.IP 7. 4 +Нестиснутий розмір +.IP 8. 4 +Рівень стискання +.IP 9. 4 +Назва перевірки цілісності +.IP 10. 4 +Розмір доповнення потоку +.RE +.PD +.PP +Стовпчики у рядках \fBblock\fP: +.PD 0 +.RS +.IP 2. 4 +Номер потоку, що містить цей блок +.IP 3. 4 +Номер блоку відносно початку потоку (перший блок має номер 1) +.IP 4. 4 +Номер блоку відносно початку файла +.IP 5. 4 +Зсув початку стисненого відносно початку файла +.IP 6. 4 +Зсув початку нестисненого відносно початку файла +.IP 7. 4 +Загальний стиснений розмір блоку (включено з заголовками) +.IP 8. 4 +Нестиснутий розмір +.IP 9. 4 +Рівень стискання +.IP 10. 4 +Назва перевірки цілісності +.RE +.PD +.PP +Якщо \fB\-\-verbose\fP було вказано двічі, до рядків \fBblock\fP буде включено +додаткові стовпчики. Ці стовпчики не буде показано, якщо вказано одинарний +параметр \fB\-\-verbose\fP, оскільки отримання цих відомостей потребує багатьох +позиціювань, а ця процедура може бути повільною: +.PD 0 +.RS +.IP 11. 4 +Значення перевірки цілісності у шістнадцятковій формі +.IP 12. 4 +Розмір заголовка блоку +.IP 13. 4 +Прапорці блоку: \fBc\fP вказує, що наявний стиснений розмір, а \fBu\fP вказує, що +наявний нестиснений розмір. Якщо прапорець не встановлено, буде показано +(\fB\-\fP) замість підтримання фіксованого розміру рядка. У майбутньому +наприкінці рядка може бути додано нові прапорці. +.IP 14. 4 +Розмір справжніх стиснених даних у блоці (це включає заголовок блоку, +доповнення блоку та поля перевірок) +.IP 15. 4 +Об'єм пам'яті (у байтах), який потрібен для розпаковування цього блоку за +допомогою цієї версії \fBxz\fP +.IP 16. 4 +Ланцюжок фільтрів. Зауважте, що більшість параметрів, які використано під +час стискання, не є наперед відомим, оскільки у заголовках \fB.xz\fP +зберігаються лише параметри, які потрібні для розпаковування. +.RE +.PD +.PP +Стовпчики у рядках \fBsummary\fP: +.PD 0 +.RS +.IP 2. 4 +Об'єм пам'яті (у байтах), який потрібен для розпаковування цього файла за +допомогою цієї версії \fBxz\fP +.IP 3. 4 +\fByes\fP або \fBno\fP вказує, якщо усі заголовки блоків містять одразу стиснений +розмір та розпакований розмір +.PP +\fIПочинаючи з\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Мінімальна версія \fBxz\fP, яка потрібна для розпаковування файла +.RE +.PD +.PP +Стовпчики рядка \fBtotals\fP: +.PD 0 +.RS +.IP 2. 4 +Кількість потоків +.IP 3. 4 +Кількість блоків +.IP 4. 4 +Стиснутий розмір +.IP 5. 4 +Нестиснутий розмір +.IP 6. 4 +Середній коефіцієнт стискання +.IP 7. 4 +Список відокремлених комами назв перевірок цілісності, результати яких +наявні у файлах +.IP 8. 4 +Розмір доповнення потоку +.IP 9. 4 +Кількість файлів. Наявний тут для зберігання такого самого порядку +стовпчиків, що і у попередніх рядках \fBfile\fP. +.PD +.RE +.PP +Якщо \fB\-\-verbose\fP було вказано двічі, до рядка \fBtotals\fP буде включено +додаткові стовпчики: +.PD 0 +.RS +.IP 10. 4 +Максимальний об'єм пам'яті (у байтах), який потрібен для розпаковування +файлів за допомогою цієї версії \fBxz\fP +.IP 11. 4 +\fByes\fP або \fBno\fP вказує, якщо усі заголовки блоків містять одразу стиснений +розмір та розпакований розмір +.PP +\fIПочинаючи з\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Мінімальна версія \fBxz\fP, яка потрібна для розпаковування файла +.RE +.PD +.PP +У майбутніх версіях може бути додано нові типи рядків і нові стовпчики до +наявних типів рядків, але наявні стовпчики мають лишитися незмінними. +. +.SS "Довідка з фільтрування" +\fBxz \-\-robot \-\-filters\-help\fP виведе список підтримуваних фільтрів у такому +форматі: +.PP +\fIфільтр\fP\fB:\fP\fIпараметр\fP\fB=<\fP\fIзначення\fP\fB>,\fP\fIпараметр\fP\fB=<\fP\fIзначення\fP\fB>\fP... +.TP +\fIфільтр\fP +Назва фільтра +.TP +\fIпараметр\fP +Назва специфічного для фільтра параметра +.TP +\fIзначення\fP +Числові діапазони \fIvalue\fP слід вказати у форматі +\fB<\fP\fIмінімум\fP\fB\-\fP\fIмаксимум\fP\fB>\fP. Варіанти рядка \fIзначення\fP +показано у \fB< >\fP і відокремлено символом \fB|\fP. +.PP +Кожен фільтр буде виведено до окремого рядка. +. +.SS "Дані щодо обмеження пам'яті" +\fBxz \-\-robot \-\-info\-memory\fP виводить один рядок з декількома відокремленими +табуляціями стовпчиками: +.IP 1. 4 +Загальний об'єм фізичної пам'яті (RAM) у байтах. +.IP 2. 4 +Обмеження на використання пам'яті для стискання у байтах +(\fB\-\-memlimit\-compress\fP). Особливе значення \fB0\fP вказує на типові +налаштування, якими для однопотокового режиму є налаштування без обмеження +на використання пам'яті. +.IP 3. 4 +Обмеження на використання пам'яті для розпакування у байтах +(\fB\-\-memlimit\-decompress\fP). Особливе значення \fB0\fP вказує на типові +налаштування, якими для однопотокового режиму є налаштування без обмеження +на використання пам'яті. +.IP 4. 4 +Починаючи з \fBxz\fP 5.3.4alpha: використання пам'яті для багатопотокового +розпаковування у байтах (\fB\-\-memlimit\-mt\-decompress\fP). Ніколи не дорівнює +нулеві, оскільки буде використано специфічне для системи типове значення, +яке показано у стовпчику 5, якщо обмеження не встановлено явним чином. Також +ніколи не перевищуватиме значення у стовпчику 3, навіть якщо було вказано +більше значення за допомогою \fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Починаючи з \fBxz\fP 5.3.4alpha: специфічне для системи типове обмеження на +використання пам'яті, яке використовують для обмеження кількості потоків при +стисканні з автоматичною кількістю потоків (\fB\-\-threads=0\fP) і без визначення +обмеження на використання пам'яті (\fB\-\-memlimit\-compress\fP). Це значення +також використовують як типове значення для \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Починаючи з \fBxz\fP 5.3.4alpha: кількість доступних потоків обробки процесора. +.PP +У майбутньому у виведенні \fBxz \-\-robot \-\-info\-memory\fP може бути більше +стовпчиків, але у виведеному буде не більше за один рядок. +. +.SS Версія +\fBxz \-\-robot \-\-version\fP виведе назву версії \fBxz\fP і liblzma у такому +форматі: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Основна версія. +.TP +\fIYYY\fP +Проміжна версія. Непарні номери буде використано для стабільних +версій. Непарні номери є номерами тестових версій. +.TP +\fIZZZ\fP +Рівень латання для стабільних випусків або просто лічильник для випусків, +які перебувають у розробці. +.TP +\fIS\fP +Стабільність. 0 — alpha, 1 — beta, а 2 означає «стабільна версія». \fIS\fP має +завжди дорівнювати 2, якщо \fIYYY\fP є парним. +.PP +\fIXYYYZZZS\fP є тим самим в обох рядках, якщо \fBxz\fP і liblzma належать до +одного випуску XZ Utils. +.PP +Приклади: 4.999.9beta — це \fB49990091\fP, а 5.0.0 — це \fB50000002\fP. +. +.SH "СТАН ВИХОДУ" +.TP +\fB0\fP +Усе добре. +.TP +\fB1\fP +Сталася помилка. +.TP +\fB2\fP +Сталося щось варте попередження, але справжніх помилок не сталося. +.PP +Зауваження (не попередження або помилки), які виведено до стандартного +виведення помилок, не впливають на стан виходу. +. +.SH СЕРЕДОВИЩЕ +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP обробляє списки відокремлених пробілами параметрів зі змінних +середовища \fBXZ_DEFAULTS\fP і \fBXZ_OPT\fP, перш ніж обробляти параметри з рядка +команди. Зауважте, що буде оброблено лише параметри зі змінних середовища; +усі непараметричні записи буде без повідомлень проігноровано. Обробку буде +виконано за допомогою функції \fBgetopt_long\fP(3), яку також використовують +для аргументів рядка команди. +.PP +\fBПопередження:\fP Встановлюючи ці змінні середовища, ви насправді змінюєте +програми та скрипти, які виконують \fBxz\fP. У більшості випадків без проблем +можна встановлювати обмеження на використання пам'яті, кількість потоків і +параметри стиснення за допомогою змінних середовища. Однак деякі параметри +можуть порушити роботу скриптів. Очевидним прикладом є \fB\-\-help\fP, який +змушує \fBxz\fP показувати текст довідки замість стискання або розпаковування +файла. Менш очевидними є приклади \fB\-\-quiet\fP і \fB\-\-verbose\fP. У багатьох +випадках усе працюватиме добре, якщо увімкнути індикатор поступу за +допомогою \fB\-\-verbose\fP, але у деяких ситуаціях додаткові повідомлення +створюють проблеми. Рівень докладності також впливає на поведінку \fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Специфічні для користувача або загальносистемні типові параметри. Зазвичай, +їх встановлюють у скрипті ініціалізації оболонки для типового вмикання +обмеження на використання пам'яті у \fBxz\fP або встановлення типової кількості +потоків обробки. Окрім скриптів ініціалізації оболонки і подібних особливих +випадків, не слід встановлювати або скасовувати встановлення значення +\fBXZ_DEFAULTS\fP у скриптах. +.TP +\fBXZ_OPT\fP +Цю змінну призначено для передавання параметрів до \fBxz\fP, якщо неможливо +встановити параметри безпосередньо у рядку команди \fBxz\fP. Це трапляється, +якщо \fBxz\fP запущено скриптом або інструментом, наприклад, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Скрипти можуть використовувати \fBXZ_OPT\fP, наприклад, для встановлення +специфічних типових параметрів стискання. Втім, рекомендуємо дозволити +користувачам перевизначати \fBXZ_OPT\fP, якщо це має якісь причини. Наприклад, +у скриптах \fBsh\fP(1) можна скористатися чимось таким: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "СУМІСНІСТЬ ІЗ LZMA UTILS" +Синтаксис рядка команди \fBxz\fP практично є надбудовою щодо \fBlzma\fP, \fBunlzma\fP +і \fBlzcat\fP з LZMA Utils 4.32.x. У більшості випадків можна замінити LZMA +Utils XZ Utils без порушення працездатності наявних скриптів. Втім, існують +певні несумісності, які іноді можуть спричиняти проблеми. +. +.SS "Рівні шаблонів стискання" +Нумерація у шаблонах рівнів стискання у \fBxz\fP не є тотожною до нумерації у +LZMA Utils. Найважливішою відмінністю є прив'язка розмірів словника до +різних шаблонів. Розмір словника грубо рівний використанню пам'яті у засобі +розпаковування. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Рівень;xz;LZMA Utils +\-0;256 КіБ;н/д +\-1;1 МіБ;64 КіБ +\-2;2 МіБ;1 МіБ +\-3;4 МіБ;512 КіБ +\-4;4 МіБ;1 МіБ +\-5;8 МіБ;2 МіБ +\-6;8 МіБ;4 МіБ +\-7;16 МіБ;8 МіБ +\-8;32 МіБ;16 МіБ +\-9;64 МіБ;32 МіБ +.TE +.RE +.PP +Відмінності у розмірах словників також впливають на використання пам'яті +засобом стискання, але є і інші відмінності між LZMA Utils і XZ Utils, які +роблять різницю ще помітнішою: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Рівень;xz;LZMA Utils 4.32.x +\-0;3 МіБ;н/д +\-1;9 МіБ;2 МіБ +\-2;17 МіБ;12 МіБ +\-3;32 МіБ;12 МіБ +\-4;48 МіБ;16 МіБ +\-5;94 МіБ;26 МіБ +\-6;94 МіБ;45 МіБ +\-7;186 МіБ;83 МіБ +\-8;370 МіБ;159 МіБ +\-9;674 МіБ;311 МіБ +.TE +.RE +.PP +Типовим рівнем стискання у LZMA Utils є \fB\-7\fP, а у XZ Utils — \fB\-6\fP, отже, +обидва комплекти програм типово використовують словник розміром у 8 МіБ. +. +.SS "Потокові і непотокові файл .lzma" +Розмір нестисненого файла може бути збережено у заголовку \fB.lzma\fP. LZMA +Utils зберігають дані при стисканні звичайних файлів. Альтернативним +підходом є позначення нестисненого розміру як невідомого і використання +позначки кінця вмісту для позначення місця, де засіб розпаковування має +зупинитися. У LZMA Utils цей спосіб використовують, якщо нестиснений розмір +є невідомим, що трапляється, наприклад, для конвеєрів обробки даних. +.PP +У \fBxz\fP передбачено підтримку розпаковування файлів \fB.lzma\fP з позначкою +кінця вмісту та без неї, але усі файли \fB.lzma\fP, які створено за допомогою +\fBxz\fP, використовують позначку кінця вмісту, а нестиснений розмір у +заголовку \fB.lzma\fP позначають як невідомий. Це може призвести до проблем у +деяких нетипових ситуаціях. Наприклад, розпакувальник \fB.lzma\fP у вбудованому +пристрої може працювати лише з файлами, для яких відомий нестиснений +розмір. Якщо ви зіткнулися з цією проблемою, вам слід скористатися LZMA +Utils або LZMA SDK для створення файлів \fB.lzma\fP із відомим розміром +нестиснених даних. +. +.SS "Непідтримувані файли .lzma" +У форматі \fB.lzma\fP можливі значення \fIlc\fP аж до 8 і значення \fIlp\fP аж до +4. LZMA Utils можуть розпаковувати файли із будь\-якими значеннями \fIlc\fP і +\fIlp\fP, але завжди створюють файли з \fBlc=3\fP і \fBlp=0\fP. Створення файлів з +іншими значеннями \fIlc\fP і \fIlp\fP є можливим за допомогою \fBxz\fP і LZMA SDK. +.PP +Реалізація фільтра LZMA1 у liblzma потребує, щоби сума \fIlc\fP і \fIlp\fP не +перевищувала 4. Отже, файли \fB.lzma\fP, у яких перевищено обмеження, не може +бути розпаковано за допомогою \fBxz\fP. +.PP +LZMA Utils створюють лише файли \fB.lzma\fP, які мають розмір словника у 2^\fIn\fP +(степінь 2), але приймають файли із будь\-яким розміром словника. liblzma +приймає лише файли \fB.lzma\fP, які мають розмір словника 2^\fIn\fP або 2^\fIn\fP + +2^(\fIn\fP\-1). Так зроблено для зменшення помилок при виявленні файлів +\&\fB.lzma\fP. +.PP +Ці обмеження не мають призводити до проблем на практиці, оскільки практично +усі файли \fB.lzma\fP було стиснено з використанням параметрів, які приймає +liblzma. +. +.SS "Кінцевий мотлох" +При розпаковуванні LZMA Utils без повідомлень ігнорують усі дані після +першого потоку \fB.lzma\fP. У більшості випадків це пов'язано із вадою у +програмі. Це також означає, що у LZMA Utils не передбачено підтримки +розпаковування з'єднаних файлів \fB.lzma\fP. +.PP +Якщо після першого потоку \fB.lzma\fP лишилися дані, \fBxz\fP вважатиме файл +пошкодженим, якщо не було використано \fB\-\-single\-stream\fP. Це може зашкодити +роботі скриптів, де зроблено припущення, що кінцеві зайві дані буде +проігноровано. +. +.SH ПРИМІТКИ +. +.SS "Стискання даних може бути різним" +Точні стиснені дані, які створено на основі того самого нестисненого файла +вхідних даних, можуть бути різними для різних версій XZ Utils, навіть якщо +використано однакові параметри стискання. Причиною цього є удосконалення у +кодувальнику (пришвидшення або краще стискання) без зміни формату +файлів. Виведені дані можуть бути різними навіть для різних збірок тієї +самої версії XZ Utils, якщо використано різні параметри збирання. +.PP +Написане вище означає, що після реалізації \fB\-\-rsyncable\fP файли\-результати +не обов'язково можна буде синхронізувати за допомогою rsyncable, якщо старий +і новий файли було стиснено за допомогою тієї самої версії xz. Цю проблему +можна усунути, якщо буде заморожено частину реалізації кодувальника, щоб +введені для rsync дані були стабільними між версіями xz. +. +.SS "Вбудовані розпакувальники .xz" +У вбудованих реалізаціях розпакувальника \fB.xz\fP, подібних до XZ Embedded, не +обов'язково передбачено підтримку файлів, які створено із типами +\fIперевірки\fP цілісності, відмінними від \fBnone\fP і \fBcrc32\fP. Оскільки типовим +є \fB\-\-check=crc64\fP, вам слід використовувати \fB\-\-check=none\fP або +\fB\-\-check=crc32\fP при створенні файлів для вбудованих систем. +.PP +Поза вбудованими системами, в усіх засобах розпаковування формату \fB.xz\fP +передбачено підтримку усіх типів \fIперевірок\fP або принаймні можливість +розпакувати файл без перевірки цілісності, якщо підтримки певної +\fIперевірки\fP не передбачено. +.PP +У XZ Embedded передбачено підтримку BCJ, але лише з типовим початковим +зсувом. +. +.SH ПРИКЛАДИ +. +.SS Основи +Стиснути файл \fIfoo\fP до \fIfoo.xz\fP за допомогою типового рівня стискання +(\fB\-6\fP) і вилучити \fIfoo\fP, якщо стискання відбулося успішно: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Розпакувати \fIbar.xz\fP до \fIbar\fP і не вилучати \fIbar.xz\fP, навіть якщо +розпаковування відбулося успішно: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Створити \fIbaz.tar.xz\fP з використанням шаблона \fB\-4e\fP (\fB\-4 \-\-extreme\fP), +який є повільнішими за типовий \fB\-6\fP, але потребує менше пам'яті для +стискання та розпаковування (48\ МіБ та 5\ МіБ, відповідно): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Суміш стиснених і нестиснених файлів можна розпакувати до стандартного +виведення за допомогою єдиної команди: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Паралельне стискання багатьох файлів" +У GNU і *BSD можна скористатися \fBfind\fP(1) і \fBxargs\fP(1) для паралельного +стискання багатьох файлів: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Параметр \fB\-P\fP \fBxargs\fP(1) встановлює кількість паралельних процесів +\fBxz\fP. Найкраще значення параметра \fB\-n\fP залежить від того, скільки файлів +має бути стиснено. Якщо файлів мало, значенням, ймовірно, має бути 1. Якщо +файлів десятки тисяч, може знадобитися значення 100 або навіть більше, щоб +зменшити кількість процесів \fBxz\fP, які врешті створить \fBxargs\fP(1). +.PP +Параметр \fB\-T1\fP для \fBxz\fP тут для примусового встановлення однопотокового +режиму, оскільки для керування рівнем паралелізації використано \fBxargs\fP(1). +. +.SS "Режим робота" +Обчислити скільки байтів було заощаджено загалом після стискання декількох +файлів: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Скрипту можуть знадобитися дані щодо того, що використано достатньо нову +версію \fBxz\fP. У наведеному нижче скрипті \fBsh\fP(1) виконано перевірку того, +що номер версії засобу \fBxz\fP є принаймні рівним 5.0.0. Цей спосіб є сумісним +зі старими тестовими версіями, де не передбачено підтримки параметра +\fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Встановити обмеження на використання пам'яті для розпаковування за допомогою +\fBXZ_OPT\fP, але якщо обмеження вже було встановлено, не збільшувати його: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Нетипові ланцюжки фільтрів засобу стискання" +Найпростішим використанням ланцюжка фільтрів є налаштовування шаблона +LZMA2. Це може бути корисним, оскільки у шаблонах використано лише +підмножину потенційно корисних комбінацій параметрів стискання. +.PP +При налаштовуванні шаблонів LZMA2 корисними є стовпчики CompCPU таблиць з +описів параметрів \fB\-0\fP ... \fB\-9\fP і \fB\-\-extreme\fP. Ось відповідні частини з +цих двох таблиць: +.RS +.PP +.TS +tab(;); +c c +n n. +Шаблон;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Якщо вам відомо, що певний файл потребує дещо більшого словника (наприклад, +32\ МіБ) для якісного стискання, але ви хочете стиснути його швидше за +команду \fBxz \-8\fP, можна внести зміни до шаблона із нижчим значенням CompCPU +(наприклад, 1) для використання більшого словника: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Для певних файлів наведена вище команда може працювати швидше за \fBxz \-6\fP і +стискати дані значно краще. Втім, слід наголосити, переваги більшого +словника з одночасним низьким значенням CompCPU проявляються лише для деяких +файлів. Найочевиднішим випадком, коли великий словник є корисним, є випадок, +коли архів містить дуже подібні файли розміром у принаймні декілька +мегабайтів. Розмір словника має бути значно більшим за будь\-який окремий +файл, щоб у LZMA2 було використано усі переваги подібностей між послідовними +файлами. +.PP +Якщо дуже високий рівень використання пам'яті у засобі стискання або +розпаковування не є проблемою, і файли, який стискають має об'єм у принаймні +декілька десятків мегабайтів, може бути корисним використання навіть +більшого за 64 МіБ словника, який використано у \fBxz \-9\fP: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Використання \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP), подібно до наведеного вище +прикладу, може бути корисним для перегляду вимог з боку засобів стискання та +розпаковування до пам'яті. Пам'ятайте, що використання словника, розмір +якого перевищує розмір файла, який стискають, є простоюю витратою пам'яті, +отже наведену вище команду не варто використовувати для малих файлів. +.PP +Іноді час стискання не має значення, але використання пам'яті засобом +розпаковування має бути низьким для того, щоб, наприклад, уможливити +розпаковування файла у вбудованій системі. У наведеній нижче команді +використано \fB\-6e\fP (\fB\-6 \-\-extreme\fP) як основу і встановлено розмір словника +лише у 64\ КіБ. Файл\-результат можна розпакувати за допомогою XZ Embedded +(ось чому використано \fB\-\-check=crc32\fP) з використанням лише 100\ КіБ +пам'яті. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Якщо вам потрібно витиснути зі стискання максимальну кількість байтів, може +допомогти коригування кількості бітів контексту літералів (\fIlc\fP) та +кількість позиційних бітів (\fIpb\fP). Також може допомогти коригування +кількості бітів позиції літералів (\fIlp\fP), але, зазвичай, важливішими є +\fIlc\fP і \fIpb\fP. Наприклад, в архівах зі початковим кодом міститься +здебільшого текст US\-ASCII, щось подібне до наведеного нижче може дещо (на +щось близьке до 0,1\ %) зменшити файл, порівняно із \fBxz \-6e\fP (спробуйте +також без \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Використання іншого фільтра разом із LZMA2 може покращити стискання для +певних типів файлів. Наприклад, для стискання бібліотеки спільного +користування x86\-32 або x86\-64 з використанням фільтра BCJ x86 скористайтеся +такою командою: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Зауважте, що порядок параметрів фільтрування має значення. Якщо \fB\-\-x86\fP +вказано після \fB\-\-lzma2\fP, \fBxz\fP повідомить про помилку, оскільки після LZMA2 +не може бути жодного фільтра, а також оскільки фільтр BCJ x86 не можна +використовувати як останній фільтр у ланцюжку. +.PP +Фільтр Delta разом із LZMA2 може дати добрі результати для растрових +зображень. Зазвичай, результати є кращими за формат PNG, у якого є декілька +більш досконалих фільтрів, ніж проста дельта, але там використовують для +стискання Deflate. +.PP +Зображення слід берегти у нестисненому форматі, наприклад, як нестиснений +TIFF. Параметр відстані фільтра Delta встановлюють так, щоб він збігався із +кількістю байтів на піксель у зображенні. Наприклад, для 24\-бітового +растрового зображення RGB слід вказати \fBdist=3\fP, а також добре передати +\fBpb=0\fP до LZMA2 для пристосовування до трибайтового вирівнювання: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Якщо в один архів запаковано декілька зображень (наприклад, в архів +\&\fB.tar\fP), фільтр Delta також даватиме добрі результати, якщо у всіх +зображеннях однакова кількість байтів для кожного пікселя. +. +.SH "ДИВ. ТАКОЖ" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +Вбудовуваний XZ: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzcmp.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzcmp.1 new file mode 100644 index 0000000000000000000000000000000000000000..0dd388c06a0fd2c32b4164b145f89739fe369a42 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzcmp.1 @@ -0,0 +1,56 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Ukrainian translation for xz-man. +.\" Yuri Chornoivan , 2019, 2022, 2023, 2024, 2025. +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 "6 березня 2025 року" Tukaani "XZ Utils" +.SH НАЗВА +xzcmp, xzdiff, lzcmp, lzdiff — порівняння стиснених файлів +. +.SH "КОРОТКИЙ ОПИС" +\fBxzcmp\fP [\fIпараметр...\fP] \fIфайл1\fP [\fIфайл2\fP] +.br +\fBxzdiff\fP \&... +.br +\fBlzcmp\fP \&... (ЗАСТАРІЛО) +.br +\fBlzdiff\fP \&... (ЗАСТАРІЛО) +. +.SH ОПИС +\fBxzcmp\fP і \fBxzdiff\fP порівнюють нестиснені дані двох файлів. Нестиснені дані +та параметри буде передано \fBcmp\fP(1) або \fBdiff\fP(1), якщо не вказано +\fB\-\-help\fP або \fB\-\-version\fP. +.PP +Якщо вказано одразу \fIфайл1\fP і \fIфайл2\fP, це можуть бути нестиснені файли або +файли у форматах, які може бути розпаковано за допомогою \fBxz\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) або \fBlz4\fP(1). Потрібні +команди розпаковування визначаються з суфіксів назв файлів \fIфайл1\fP і +\fIфайл2\fP. Файли із невідомими програмі суфіксами вважатимуться або +нестисненими або такими, що мають формат, дані у якому може розпаковувати +\fBxz\fP(1). +.PP +Якщо вказано лише одну назву файла, \fIфайл1\fP повинен мати суфікс +підтримуваного формату стискання, а назвою \fIфайл2\fP має бути назва \fIфайл1\fP +з вилученим суфіксом формату стискання. +.PP +Працездатність команд \fBlzcmp\fP і \fBlzdiff\fP забезпечено для зворотної +сумісності із LZMA Utils. Ці команди вважаються застарілими, їх буде +вилучено у майбутній версії комплекту програм. +. +.SH "СТАН ВИХОДУ" +Якщо станеться помилка розпаковування, станом виходу буде \fB2\fP. Інакше, +станом виходу буде \fBcmp\fP(1) або буде використано \fBdiff\fP(1). +. +.SH "ДИВ. ТАКОЖ" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzdiff.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzdiff.1 new file mode 100644 index 0000000000000000000000000000000000000000..0dd388c06a0fd2c32b4164b145f89739fe369a42 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzdiff.1 @@ -0,0 +1,56 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Ukrainian translation for xz-man. +.\" Yuri Chornoivan , 2019, 2022, 2023, 2024, 2025. +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 "6 березня 2025 року" Tukaani "XZ Utils" +.SH НАЗВА +xzcmp, xzdiff, lzcmp, lzdiff — порівняння стиснених файлів +. +.SH "КОРОТКИЙ ОПИС" +\fBxzcmp\fP [\fIпараметр...\fP] \fIфайл1\fP [\fIфайл2\fP] +.br +\fBxzdiff\fP \&... +.br +\fBlzcmp\fP \&... (ЗАСТАРІЛО) +.br +\fBlzdiff\fP \&... (ЗАСТАРІЛО) +. +.SH ОПИС +\fBxzcmp\fP і \fBxzdiff\fP порівнюють нестиснені дані двох файлів. Нестиснені дані +та параметри буде передано \fBcmp\fP(1) або \fBdiff\fP(1), якщо не вказано +\fB\-\-help\fP або \fB\-\-version\fP. +.PP +Якщо вказано одразу \fIфайл1\fP і \fIфайл2\fP, це можуть бути нестиснені файли або +файли у форматах, які може бути розпаковано за допомогою \fBxz\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) або \fBlz4\fP(1). Потрібні +команди розпаковування визначаються з суфіксів назв файлів \fIфайл1\fP і +\fIфайл2\fP. Файли із невідомими програмі суфіксами вважатимуться або +нестисненими або такими, що мають формат, дані у якому може розпаковувати +\fBxz\fP(1). +.PP +Якщо вказано лише одну назву файла, \fIфайл1\fP повинен мати суфікс +підтримуваного формату стискання, а назвою \fIфайл2\fP має бути назва \fIфайл1\fP +з вилученим суфіксом формату стискання. +.PP +Працездатність команд \fBlzcmp\fP і \fBlzdiff\fP забезпечено для зворотної +сумісності із LZMA Utils. Ці команди вважаються застарілими, їх буде +вилучено у майбутній версії комплекту програм. +. +.SH "СТАН ВИХОДУ" +Якщо станеться помилка розпаковування, станом виходу буде \fB2\fP. Інакше, +станом виходу буде \fBcmp\fP(1) або буде використано \fBdiff\fP(1). +. +.SH "ДИВ. ТАКОЖ" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzegrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzegrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..e88272918dcf5fb875ee3a57c2fcfb1c33dab7ee --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzegrep.1 @@ -0,0 +1,96 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Ukrainian translation for xz-man. +.\" Yuri Chornoivan , 2019, 2022, 2023, 2024, 2025. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 "6 березня 2025 року" Tukaani "XZ Utils" +.SH НАЗВА +xzgrep — пошук взірців у ймовірно стиснених файлах +. +.SH "КОРОТКИЙ ОПИС" +\fBxzgrep\fP [\fIпараметр...\fP] [\fIсписок_взірців\fP] [\fIфайл...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (ЗАСТАРІЛО) +.br +\fBlzegrep\fP \&... (ЗАСТАРІЛО) +.br +\fBlzfgrep\fP \&... (ЗАСТАРІЛО) +. +.SH ОПИС +\fBxzgrep\fP викликає \fBgrep\fP(1) для розпакованих даних файлів. Формати +\fIфайлів\fP визначатимуться з суфіксів назв файлів. Будь\-який \fIфайл\fP із +суфіксом назви, підтримку якого передбачено у \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) або \fBlz4\fP(1), буде розпаковано; усі +інші файли вважатимуться нестисненими. +.PP +Якщо не вказано аргументу \fIфайли\fP або замість \fIфайл\fP вказано \fB\-\fP, дані +буде прочитано зі стандартного джерела вхідних даних. При читанні зі +стандартного джерела буде розпаковано лише файли, підтримку яких передбачено +у \fBxz\fP(1). Інші файли вважатимуться такими, що вже перебувають у +нестисненому форматі. +.PP +Передбачено підтримку більшості \fIпараметрів\fP \fBgrep\fP(1). Втім, підтримки +цих параметрів не передбачено: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIдія\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIфайл\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglob\fP +.PP +\fBxzegrep\fP є альтернативним записом \fBxzgrep \-E\fP. \fBxzfgrep\fP є +альтернативним записом \fBxzgrep \-F\fP. +.PP +Працездатність команд \fBlzgrep\fP, \fBlzegrep\fP і \fBlzfgrep\fP забезпечено для +зворотної сумісності із LZMA Utils. Ці команди вважаються застарілими, їх +буде вилучено у майбутній версії комплекту програм. +. +.SH "СТАН ВИХОДУ" +.TP +0 +В одному з файлів вхідних даних знайдено принаймні одну +відповідність. Помилок не сталося. +.TP +1 +У жодному з файлів вхідних даних не знайдено відповідника. Не сталося ніяких +помилок. +.TP +>1 +Сталася одна або декілька помилок. Невідомо, чи було знайдено відповідники +критерію пошуку. +. +.SH СЕРЕДОВИЩЕ +.TP +\fBGREP\fP +Якщо для змінної середовища \fBGREP\fP встановлено непорожнє значення, його +буде використано замість \fBgrep\fP(1), \fBgrep \-E\fP або \fBgrep \-F\fP. +. +.SH "ДИВ. ТАКОЖ" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzfgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzfgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..e88272918dcf5fb875ee3a57c2fcfb1c33dab7ee --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzfgrep.1 @@ -0,0 +1,96 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Ukrainian translation for xz-man. +.\" Yuri Chornoivan , 2019, 2022, 2023, 2024, 2025. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 "6 березня 2025 року" Tukaani "XZ Utils" +.SH НАЗВА +xzgrep — пошук взірців у ймовірно стиснених файлах +. +.SH "КОРОТКИЙ ОПИС" +\fBxzgrep\fP [\fIпараметр...\fP] [\fIсписок_взірців\fP] [\fIфайл...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (ЗАСТАРІЛО) +.br +\fBlzegrep\fP \&... (ЗАСТАРІЛО) +.br +\fBlzfgrep\fP \&... (ЗАСТАРІЛО) +. +.SH ОПИС +\fBxzgrep\fP викликає \fBgrep\fP(1) для розпакованих даних файлів. Формати +\fIфайлів\fP визначатимуться з суфіксів назв файлів. Будь\-який \fIфайл\fP із +суфіксом назви, підтримку якого передбачено у \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) або \fBlz4\fP(1), буде розпаковано; усі +інші файли вважатимуться нестисненими. +.PP +Якщо не вказано аргументу \fIфайли\fP або замість \fIфайл\fP вказано \fB\-\fP, дані +буде прочитано зі стандартного джерела вхідних даних. При читанні зі +стандартного джерела буде розпаковано лише файли, підтримку яких передбачено +у \fBxz\fP(1). Інші файли вважатимуться такими, що вже перебувають у +нестисненому форматі. +.PP +Передбачено підтримку більшості \fIпараметрів\fP \fBgrep\fP(1). Втім, підтримки +цих параметрів не передбачено: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIдія\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIфайл\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglob\fP +.PP +\fBxzegrep\fP є альтернативним записом \fBxzgrep \-E\fP. \fBxzfgrep\fP є +альтернативним записом \fBxzgrep \-F\fP. +.PP +Працездатність команд \fBlzgrep\fP, \fBlzegrep\fP і \fBlzfgrep\fP забезпечено для +зворотної сумісності із LZMA Utils. Ці команди вважаються застарілими, їх +буде вилучено у майбутній версії комплекту програм. +. +.SH "СТАН ВИХОДУ" +.TP +0 +В одному з файлів вхідних даних знайдено принаймні одну +відповідність. Помилок не сталося. +.TP +1 +У жодному з файлів вхідних даних не знайдено відповідника. Не сталося ніяких +помилок. +.TP +>1 +Сталася одна або декілька помилок. Невідомо, чи було знайдено відповідники +критерію пошуку. +. +.SH СЕРЕДОВИЩЕ +.TP +\fBGREP\fP +Якщо для змінної середовища \fBGREP\fP встановлено непорожнє значення, його +буде використано замість \fBgrep\fP(1), \fBgrep \-E\fP або \fBgrep \-F\fP. +. +.SH "ДИВ. ТАКОЖ" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..e88272918dcf5fb875ee3a57c2fcfb1c33dab7ee --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzgrep.1 @@ -0,0 +1,96 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Ukrainian translation for xz-man. +.\" Yuri Chornoivan , 2019, 2022, 2023, 2024, 2025. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 "6 березня 2025 року" Tukaani "XZ Utils" +.SH НАЗВА +xzgrep — пошук взірців у ймовірно стиснених файлах +. +.SH "КОРОТКИЙ ОПИС" +\fBxzgrep\fP [\fIпараметр...\fP] [\fIсписок_взірців\fP] [\fIфайл...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (ЗАСТАРІЛО) +.br +\fBlzegrep\fP \&... (ЗАСТАРІЛО) +.br +\fBlzfgrep\fP \&... (ЗАСТАРІЛО) +. +.SH ОПИС +\fBxzgrep\fP викликає \fBgrep\fP(1) для розпакованих даних файлів. Формати +\fIфайлів\fP визначатимуться з суфіксів назв файлів. Будь\-який \fIфайл\fP із +суфіксом назви, підтримку якого передбачено у \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) або \fBlz4\fP(1), буде розпаковано; усі +інші файли вважатимуться нестисненими. +.PP +Якщо не вказано аргументу \fIфайли\fP або замість \fIфайл\fP вказано \fB\-\fP, дані +буде прочитано зі стандартного джерела вхідних даних. При читанні зі +стандартного джерела буде розпаковано лише файли, підтримку яких передбачено +у \fBxz\fP(1). Інші файли вважатимуться такими, що вже перебувають у +нестисненому форматі. +.PP +Передбачено підтримку більшості \fIпараметрів\fP \fBgrep\fP(1). Втім, підтримки +цих параметрів не передбачено: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIдія\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIфайл\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglob\fP +.PP +\fBxzegrep\fP є альтернативним записом \fBxzgrep \-E\fP. \fBxzfgrep\fP є +альтернативним записом \fBxzgrep \-F\fP. +.PP +Працездатність команд \fBlzgrep\fP, \fBlzegrep\fP і \fBlzfgrep\fP забезпечено для +зворотної сумісності із LZMA Utils. Ці команди вважаються застарілими, їх +буде вилучено у майбутній версії комплекту програм. +. +.SH "СТАН ВИХОДУ" +.TP +0 +В одному з файлів вхідних даних знайдено принаймні одну +відповідність. Помилок не сталося. +.TP +1 +У жодному з файлів вхідних даних не знайдено відповідника. Не сталося ніяких +помилок. +.TP +>1 +Сталася одна або декілька помилок. Невідомо, чи було знайдено відповідники +критерію пошуку. +. +.SH СЕРЕДОВИЩЕ +.TP +\fBGREP\fP +Якщо для змінної середовища \fBGREP\fP встановлено непорожнє значення, його +буде використано замість \fBgrep\fP(1), \fBgrep \-E\fP або \fBgrep \-F\fP. +. +.SH "ДИВ. ТАКОЖ" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzless.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzless.1 new file mode 100644 index 0000000000000000000000000000000000000000..c3b275d0dcadddd3e60054103f9c2a77a4eec341 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzless.1 @@ -0,0 +1,49 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" Ukrainian translation for xz-man. +.\" Yuri Chornoivan , 2019, 2022, 2023, 2024, 2025. +.\" +.\" (Note that this file is not based on gzip's zless.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZLESS 1 "6 березня 2025 року" Tukaani "XZ Utils" +.SH НАЗВА +xzless, lzless — перегляд стиснених xz або lzma (текстових) файлів +.SH "КОРОТКИЙ ОПИС" +\fBxzless\fP [\fIфайл\fP...] +.br +\fBlzless\fP [\fIфайл\fP...] (ЗАСТАРІЛО) +.SH ОПИС +\fBxzless\fP є фільтром, який показує текст зі стиснених файлів у +терміналі. Файли, підтримку обробки яких передбачено у \fBxz\fP(1), буде +розпаковано; інші файли вважатимуться нестисненими. Якщо не вказано жодного +\fIфайла\fP, \fBxzless\fP читатиме дані зі стандартного джерела вхідних даних. +.PP +Для показу виведених даних \fBxzless\fP використовує \fBless\fP(1). На відміну від +\fBxzmore\fP, вибір програми для поділу на сторінки не можна змінити за +допомогою змінної середовища. Команди засновано на \fBmore\fP(1) і \fBvi\fP(1). За +допомогою команд можна просуватися назад і вперед даними та шукати дані. Щоб +дізнатися більше, ознайомтеся із підручником з \fBless\fP(1). +.PP +Команду \fBlzless\fP реалізовано для забезпечення зворотної сумісності з LZMA +Utils. Ця команда вважається застарілою, її буде вилучено у майбутній версії +комплекту програм. +.SH СЕРЕДОВИЩЕ +.TP +\fBLESSMETACHARS\fP +Список символів, які є особливими символами командної +оболонки. Встановлюється \fBxzless\fP, якщо його ще не встановлено у +середовищі. +.TP +\fBLESSOPEN\fP +Має значення рядка команди для виклику засобу розпаковування \fBxz\fP(1) для +обробки вхідних файлів \fBless\fP(1). +.SH "ДИВ. ТАКОЖ" +\fBless\fP(1), \fBxz\fP(1), \fBxzmore\fP(1), \fBzless\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzma.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzma.1 new file mode 100644 index 0000000000000000000000000000000000000000..bff0472c4495c4b8c84495967535bcd7b99dc205 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzma.1 @@ -0,0 +1,2039 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Ukrainian translation for xz-man. +.\" Yuri Chornoivan , 2019, 2022, 2023, 2024, 2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 "8 березня 2025 року" Tukaani "XZ Utils" +. +.SH НАЗВА +xz, unxz, xzcat, lzma, unlzma, lzcat — стискання та розпаковування файлів +\&.xz і .lzma +. +.SH "КОРОТКИЙ ОПИС" +\fBxz\fP [\fIпараметр...\fP] [\fIфайл...\fP] +. +.SH "СКОРОЧЕННЯ КОМАНД" +\fBunxz\fP є рівноцінним до \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP є рівноцінним до \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP є рівноцінним до \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP є рівноцінним до \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP є рівноцінним до \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +При написанні скриптів, де потрібно розпаковувати файли, рекомендуємо завжди +використовувати \fBxz\fP із відповідними аргументами (\fBxz \-d\fP або \fBxz \-dc\fP), +замість \fBunxz\fP і \fBxzcat\fP. +. +.SH ОПИС +\fBxz\fP інструмент загального призначення для стискання даних із синтаксисом +командного рядка, подібним для \fBgzip\fP(1) і \fBbzip2\fP(1). Власним форматом +файлів є \fB.xz\fP, але передбачено підтримку застарілого формату \fB.lzma\fP, +який було використано у LZMA Utils, та необроблених потоків стиснених даних +без заголовків формату контейнера. Крім того, передбачено підтримку +розпаковування формату \fB.lz\fP, який використано у \fBlzip\fP. +.PP +\fBxz\fP стискає або розпаковує кожен \fIфайл\fP відповідно до вибраного режиму +дій. Якщо \fIфайли\fP не задано або якщо \fIфайлом\fP є \fB\-\fP, \fBxz\fP читатиме дані +зі стандартного джерела вхідних даних і записуватиме оброблені дані до +стандартного виведення. \fBxz\fP відмовить (покаже повідомлення про помилку і +пропустить \fIфайл\fP) у записів стиснених даних до стандартного виведення, +якщо це термінал. Так само, \fBxz\fP відмовить у читанні стиснених даних зі +стандартного джерела вхідних даних, якщо це термінал. +.PP +Якщо не вказано \fB\-\-stdout\fP, \fIфайли\fP, відмінні від \fB\-\fP, буде записано до +нового файла, чию назву буде визначено з назви початкового \fIфайла\fP: +.IP \(bu 3 +При стисканні суфікс формату файла призначення (\fB.xz\fP або \fB.lzma\fP) буде +дописано до назви початкового файла для отримання назви файла призначення. +.IP \(bu 3 +При розпаковуванні суфікс \fB.xz\fP, \fB.lzma\fP або \fB.lz\fP буде вилучено з назви +файла для отримання назви файла призначення. Крім того, \fBxz\fP розпізнає +суфікси \fB.txz\fP і \fB.tlz\fP і замінює їх на суфікс \fB.tar\fP. +.PP +Якщо файл призначення вже існує, буде показано повідомлення про помилку, а +\fIфайл\fP буде пропущено. +.PP +Окрім випадку запису до стандартного виведення, \fBxz\fP покаже попередження і +пропустить обробку \fIфайла\fP, якщо буде виконано будь\-яку з таких умов: +.IP \(bu 3 +\fIФайл\fP не є звичайним файлом. Програма не переходитиме за символічними +посиланнями, а отже, не вважатиме їх звичайними файлами. +.IP \(bu 3 +На \fIфайл\fP існує декілька жорстких посилань. +.IP \(bu 3 +Для \fIфайла\fP встановлено setuid, setgid або «липкий» біт. +.IP \(bu 3 +Режим дій встановлено у значення «стискання», і \fIфайл\fP вже має суфікс назви +формату файла призначення (\fB.xz\fP або \fB.txz\fP при стисканні до формату +\&\fB.xz\fP, і \fB.lzma\fP або \fB.tlz\fP при стисканні до формату \fB.lzma\fP). +.IP \(bu 3 +Режим дій встановлено у значення «розпаковування», і \fIфайл\fP не має суфікса +назви жодного з підтримуваних форматів (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP +або \fB.lz\fP). +.PP +Після успішного стискання або розпаковування \fIфайла\fP, \fBxz\fP копіює дані +щодо власника, групи, прав доступу, часу доступу та моменту внесення змін з +початкового \fIфайла\fP до файла призначення. Якщо копіювання даних щодо групи +зазнає невдачі, права доступу буде змінено так, що файл призначення стане +недоступним для користувачів, які не мають права доступу до початкового +\fIфайла\fP. В \fBxz\fP ще не передбачено підтримки копіювання інших метаданих, +зокрема списків керування доступом або розширених атрибутів. +.PP +Щойно файл призначення буде успішно закрито, початковий \fIфайл\fP буде +вилучено, якщо не вказано параметра \fB\-\-keep\fP. Початковий \fIфайл\fP ніколи не +буде вилучено, якщо виведені дані буде записано до стандартного виведення +або якщо станеться помилка. +.PP +Надсилання \fBSIGINFO\fP або \fBSIGUSR1\fP до процесу \fBxz\fP призводить до +виведення даних щодо поступу до стандартного виведення помилок. Це має лише +обмежене використання, оскільки якщо стандартним виведенням помилок є +термінал, використання \fB\-\-verbose\fP призведе до показу автоматично +оновлюваного індикатора поступу. +. +.SS "Використання пам'яті" +Використання \fBxz\fP пам'яті може бути різним: від декількох сотень кілобайтів +до декількох гігабайтів, залежно від параметрів стискання. Параметри, які +використано при стисканні файла, визначають вимоги до об'єму пам'яті при +розпакуванні. Типово, засобу розпаковування потрібно від 5\ % до 20\ % +об'єму пам'яті, якого засіб стискання потребує при створенні +файла. Наприклад, розпаковування файла, який створено з використанням \fBxz \-9\fP, у поточній версії потребує 65\ МіБ пам'яті. Втім, можливе створення +файлів \fB.xz\fP, які потребуватимуть для розпаковування декількох гігабайтів +пам'яті. +.PP +Ймовірність високого рівня використання пам'яті може бути особливо +дошкульною для користувачів застарілих комп'ютерів. Щоб запобігти прикрим +несподіванкам, у \fBxz\fP передбачено вбудований обмежувач пам'яті, який типово +вимкнено. Хоча у деяких операційних системах передбачено спосіб обмежити +використання пам'яті процесами, сподівання на його ефективність не є аж +надто гнучким (наприклад, використання \fBulimit\fP(1) для обмеження +віртуальної пам'яті призводить до викривлення даних \fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Обмежувач пам'яті можна увімкнути за допомогою параметра командного рядка +\fB\-\-memlimit=\fP\fIобмеження\fP. Часто, зручніше увімкнути обмежувач на типовому +рівні, встановивши значення для змінної середовища \fBXZ_DEFAULTS\fP, +наприклад, \fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Можна встановити обмеження +окремо для стискання і розпакування за допомогою +\fB\-\-memlimit\-compress=\fP\fIlimit\fP and +\fB\-\-memlimit\-decompress=\fP\fIобмеження\fP. Використання цих двох параметрів поза +\fBXZ_DEFAULTS\fP не таке вже і корисне, оскільки одноразовий запуск \fBxz\fP не +може одночасно призводити до стискання та розпаковування, а набрати у +командному рядку \fB\-\-memlimit=\fP\fIобмеження\fP (або \fB\-M\fP \fIобмеження\fP) +набагато швидше. +.PP +Якщо під час розпаковування вказане обмеження буде перевищено, \fBxz\fP покаже +повідомлення про помилку, а розпаковування файла зазнає невдачі. Якщо +обмеження буде перевищено при стисканні, \fBxz\fP спробує масштабувати +параметри так, щоб не перевищувати обмеження (окрім випадків використання +\fB\-\-format=raw\fP або \fB\-\-no\-adjust\fP). Отже, дію буде виконано, якщо обмеження +не є надто жорстким. Масштабування параметрів буде виконано кроками, які не +збігаються із рівнями шаблонів стискання. Наприклад, якщо обмеження лише +трохи не вкладається у об'єм потрібний для \fBxz \-9\fP, параметри буде змінено +лише трохи, не до рівня \fBxz \-8\fP. +. +.SS "Поєднання і заповнення з файлами .xz" +Можна поєднати файли \fB.xz\fP без додаткової обробки. \fBxz\fP розпакує такі +файли так, наче вони є єдиним файлом \fB.xz\fP. +.PP +Можна додати доповнення між з'єднаними частинами або після останньої +частини. Доповнення має складатися із нульових байтів і мати розмір, який є +кратним до чотирьох байтів. Це може бути корисним, наприклад, якщо файл +\&\fB.xz\fP зберігається на носії даних, де розміри файла вимірюються у +512\-байтових блоках. +.PP +Поєднання та заповнення не можна використовувати для файлів \fB.lzma\fP або +потоків необроблених даних. +. +.SH ПАРАМЕТРИ +. +.SS "Цілочисельні суфікси і спеціальні значення" +У більшості місць, де потрібен цілочисельний аргумент, передбачено підтримку +необов'язкового суфікса для простого визначення великих цілих чисел. Між +цілим числом і суфіксом не повинно бути пробілів. +.TP +\fBKiB\fP +Помножити ціле число на 1024 (2^10). Синонімами \fBKiB\fP є \fBKi\fP, \fBk\fP, \fBkB\fP, +\fBK\fP та \fBKB\fP. +.TP +\fBMiB\fP +Помножити ціле число на 1048576 (2^20). Синонімами \fBMiB\fP є B, \fBMi\fP, \fBm\fP, +\fBM\fP та \fBMB\fP. +.TP +\fBGiB\fP +Помножити ціле число на 1073741824 (2^30). Синонімами \fBGiB\fP є B, \fBGi\fP, +\fBg\fP, \fBG\fP та \fBGB\fP. +.PP +Можна скористатися особливим значенням \fBmax\fP для позначення максимального +цілого значення, підтримку якого передбачено для параметра. +. +.SS "Режим операції" +Якщо вказано декілька параметрів режиму дій, буде використано лише останній +з них. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Стиснути. Це типовий режим дій, якщо не вказано параметр режиму дій, а назва +команди неявним чином не визначає іншого режиму дій (наприклад, \fBunxz\fP +неявно визначає \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Після успішного пакування початковий файл буде вилучено, якщо виведення не +відбувається до стандартного виведення або не вказано параметра \fB\-\-keep\fP. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Розпакувати. Після успішного розпаковування початковий файл буде вилучено, +якщо виведення не відбувається до стандартного виведення або не вказано +параметра \fB\-\-keep\fP. +.TP +\fB\-t\fP, \fB\-\-test\fP +Перевірити цілісність стиснених файлів \fIфайли\fP. Цей параметр еквівалентний +до \fB\-\-decompress \-\-stdout\fP, але розпаковані дані буде відкинуто, замість +запису до стандартного виведення. Жодних файлів не буде створено або +вилучено. +.TP +\fB\-l\fP, \fB\-\-list\fP +Вивести відомості щодо стиснених файлів \fIфайли\fP. Розпакування даних не +виконуватиметься, жодних файлів не буде створено або вилучено. У режимі +списку програма не може читати дані зі стандартного введення або з інших +джерел, де неможливе позиціювання. +.IP "" +У типовому списку буде показано базові відомості щодо файлів \fIфайли\fP, по +одному файлу на рядок. Щоб отримати докладніші відомості, скористайтеся +параметром \fB\-\-verbose\fP. Щоб розширити спектр відомостей, скористайтеся +параметром \fB\-\-verbose\fP двічі, але зауважте, що це може призвести до +значного уповільнення роботи, оскільки отримання додаткових відомостей +потребує великої кількості позиціювань. Ширина області докладного виведення +даних перевищує 80 символів, тому передавання конвеєром виведених даних, +наприклад, до \fBless\ \-S\fP, може бути зручним способом перегляду даних, якщо +термінал недостатньо широкий. +.IP "" +Виведені дані залежать від версії \fBxz\fP та використаної локалі. Для +отримання даних, які будуть придатні до обробки комп'ютером, слід +скористатися параметрами \fB\-\-robot \-\-list\fP. +. +.SS "Модифікатори режиму роботи" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Не вилучати вхідні файли. +.IP "" +Починаючи з версії \fBxz\fP 5.2.6, використання цього параметра також наказує +\fBxz\fP виконувати стискання або розпаковування, навіть якщо вхідними даними є +символічне посилання на звичайний файл, файл, який має декілька жорстких +посилань, або файл, для якого встановлено setuid, setgid або липкий +біт. setuid, setgid та липкий біт не буде скопійовано до файла\-результату. У +попередніх версіях, ці дії виконувалися, лише якщо було використано параметр +\fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Результатів використання цього параметра буде декілька: +.RS +.IP \(bu 3 +Якщо файл\-результат вже існує, вилучити його до стискання або +розпаковування. +.IP \(bu 3 +Виконувати стискання або розпаковування, навіть якщо вхідними даними є +символічне посилання на звичайний файл, файл, який має декілька жорстких +посилань, або файл, для якого встановлено setuid, setgid або липкий біт +setuid, setgid та липкий біт не буде скопійовано до файла\-результату. +.IP \(bu 3 +Якщо використано разом із \fB\-\-decompress\fP, \fB\-\-stdout\fP, і \fBxz\fP не зможе +розпізнати тип початкового файла, копіювати початковий файл без змін до +стандартного виведення. Це надає змогу користуватися \fBxzcat\fP \fB\-\-force\fP +подібно до \fBcat\fP(1) для файлів, які не було стиснено за допомогою +\fBxz\fP. Зауважте, що у майбутньому у \fBxz\fP може бути реалізовано підтримку +нових форматів стиснених файлів, замість копіювання їх без змін до +стандартного виведення. Можна скористатися \fB\-\-format=\fP\fIформат\fP для +обмеження стискання у \fBxz\fP єдиним форматом файлів. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Записати стиснені або розпаковані дані до стандартного виведення, а не до +файла. Неявним чином встановлює \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Розпакувати лише перший потік даних \fB.xz\fP і без повідомлень проігнорувати +решту вхідних даних, які слідують за цим потоком. Зазвичай, такі зайві дані +наприкінці файла призводять до показу \fBxz\fP повідомлення про помилку. +.IP "" +\fBxz\fP ніколи не виконуватиме спроби видобути декілька потоків даних з файлів +\&\fB.lzma\fP або необроблених потоків даних, але використання цього параметра +все одно наказує \fBxz\fP ігнорувати можливі кінцеві дані після файла \fB.lzma\fP +або необробленого потоку даних. +.IP "" +Цей параметр нічого не змінює, якщо режимом дій не є \fB\-\-decompress\fP або +\fB\-\-test\fP. +.IP "" +З \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP неявно визначає \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Вимкнути створення розріджених файлів. Типово, якщо видобування виконується +до звичайного файла, \fBxz\fP намагається створити розріджений файл, якщо +розпаковані дані містять довгі послідовності двійкових нулів. Це також +працює, коли виконується запис до стандартного виведення, доки стандартне +виведення з'єднано зі звичайним файлом і виконуються певні додаткові умови, +які убезпечують роботу. Створення розріджених файлів може заощадити місце на +диску і пришвидшити розпаковування шляхом зменшення кількості дій введення +та виведення даних на диску. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +При стисканні використати суфікс \fI.suf\fP для файлів призначення, замість +суфікса \fB.xz\fP або \fB.lzma\fP. Якщо записування виконується не до стандартного +виведення і початковий файл вже має суфікс назви \fI.suf\fP, буде показано +попередження, а файл буде пропущено під час обробки. +.IP "" +При розпаковуванні розпізнавати файли із суфіксом назви \fI.suf\fP, окрім +файлів із суфіксами назв \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP або \fB.lz\fP. Якщо +початковий файл мав суфікс назви \fI.suf\fP, для отримання назви файла +призначення цей суфікс буде вилучено. +.IP "" +При стисканні або розпакуванні необроблених потоків даних (\fB\-\-format=raw\fP) +суфікс слід вказувати завжди, якщо запис не виконується до стандартного +виведення, оскільки типового суфікса назви для необроблених потоків даних не +передбачено. +.TP +\fB\-\-files\fP[\fB=\fP\fIфайл\fP] +Прочитати назви файлів для обробки з файла \fIфайл\fP; якщо \fIfile\fP не вказано, +назви файлів буде прочитано зі стандартного потоку вхідних даних. Назви +файлів має бути відокремлено символом нового рядка. Символ дефіса (\fB\-\fP) +буде оброблено як звичайну назву файла; він не позначатиме стандартного +джерела вхідних даних. Якщо також буде вказано назви файлів у аргументах +рядка команди, файли з цими назвами буде оброблено до обробки файлів, назви +яких було прочитано з файла \fIфайл\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIфайл\fP] +Те саме, що і \fB\-\-files\fP[\fB=\fP\fIфайл\fP], але файли у списку має бути +відокремлено нульовим символом. +. +.SS "Параметри базового формату файлів та стискання" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fIформат\fP +Вказати файл \fIформат\fP для стискання або розпакування: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Типовий варіант. При стисканні \fBauto\fP є еквівалентом \fBxz\fP. При +розпакуванні формат файла вхідних даних буде виявлено автоматично. Зауважте, +що автоматичне виявлення необроблених потоків даних (створених за допомогою +\fB\-\-format=raw\fP) неможливе. +.TP +\fBxz\fP +Стиснути до формату \fB.xz\fP або приймати лише файли \fB.xz\fP при +розпаковуванні. +.TP +\fBlzma\fP, \fBalone\fP +Стиснути дані до застарілого формату файлів \fB.lzma\fP або приймати лише файли +\&\fB.lzma\fP при розпаковуванні. Альтернативну назву \fBalone\fP може бути +використано для зворотної сумісності із LZMA Utils. +.TP +\fBlzip\fP +Приймати лише файли \fB.lz\fP при розпакуванні. Підтримки стискання не +передбачено. +.IP "" +Передбачено підтримку версії формату \fB.lz\fP 0 та 1. Файли версії 0 було +створено \fBlzip\fP 1.3 та старішими версіями. Такі файли не є поширеними, але +їх можна знайти у файлових архівах, оскільки певну незначну кількість +пакунків із початковим кодом було випущено у цьому форматі. Також можуть +існувати особисті файли у цьому форматі. Підтримку розпаковування для +формату версії 0 було вилучено у \fBlzip\fP 1.18. Версія \fBlzip\fP 1.4 і новіші +версії створюють файли у форматі версії 1. +.TP +\fBraw\fP +Стиснути або розпакувати потік необроблених даних (лез заголовків). Цей +параметр призначено лише для досвідчених користувачів. Для розпаковування +необроблених потоків даних слід користуватися параметром \fB\-\-format=raw\fP і +явно вказати ланцюжок фільтрування, який за звичайних умов мало б бути +збережено у заголовках контейнера. +.RE +.TP +\fB\-C\fP \fIперевірка\fP, \fB\-\-check=\fP\fIперевірка\fP +Вказати тип перевірки цілісності. Контрольну суму буде обчислено на основі +нестиснених даних і збережено у файлі \fB.xz\fP. Цей параметр працюватиме, лише +якщо дані стиснено до файла у форматі \fB.xz\fP; для формату файлів \fB.lzma\fP +підтримки перевірки цілісності не передбачено. Перевірку контрольної суми +(якщо така є) буде виконано під час розпаковування файла \fB.xz\fP. +.IP "" +Підтримувані типи \fIперевірок\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Не обчислювати контрольну суму взагалі. Зазвичай, не варто цього робити. Цим +варіантом слід скористатися, якщо цілісність даних буде перевірено в інший +спосіб. +.TP +\fBcrc32\fP +Обчислити CRC32 за допомогою полінома з IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Обчислити CRC64 за допомогою полінома з ECMA\-182. Це типовий варіант, +оскільки він дещо кращий за CRC32 при виявленні пошкоджених файлів, а +різниця у швидкості є незрачною. +.TP +\fBsha256\fP +Обчислити SHA\-256. Цей варіант дещо повільніший за CRC32 і CRC64. +.RE +.IP "" +Цілісність заголовків \fB.xz\fP завжди перевіряють за допомогою CRC32. Таку +перевірку не можна змінити або скасувати. +.TP +\fB\-\-ignore\-check\fP +Не перевіряти цілісність стиснених даних при розпаковуванні. Значення CRC32 +у заголовках \fB.xz\fP буде у звичайний спосіб перевірено попри цей параметр. +.IP "" +\fBНе користуйтеся цим параметром, якщо ви не усвідомлюєте наслідків ваших дій.\fP Можливі причини скористатися цим параметром: +.RS +.IP \(bu 3 +Спроба отримання даних з пошкодженого файла .xz. +.IP \(bu 3 +Пришвидшення розпакування. Це, здебільшого, стосується SHA\-256 або файлів із +надзвичайно високим рівнем пакування. Не рекомендуємо користуватися цим +параметром з цією метою, якщо цілісність файлів не буде перевірено у якийсь +інший спосіб. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Вибрати рівень стискання. Типовим є \fB\-6\fP. Якщо буде вказано декілька рівнів +стискання, програма використає останній вказаний. Якщо вже було вказано +нетиповий ланцюжок фільтрів, встановлення рівня стискання призведе до +нехтування цим нетиповим ланцюжком фільтрів. +.IP "" +Різниця між рівнями є суттєвішою, ніж у \fBgzip\fP(1) і \fBbzip2\fP(1). Вибрані +параметри стискання визначають вимоги до пам'яті під час розпаковування, +отже використання надто високого рівня стискання може призвести до проблем +під час розпаковування файла на застарілих комп'ютерах із невеликим обсягом +оперативної пам'яті. Зокрема, \fBне варто використовувати \-9 для усього\fP, як +це часто буває для \fBgzip\fP(1) і \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Це дещо швидші набори налаштувань. \fB\-0\fP іноді є швидшим за \fBgzip \-9\fP, +забезпечуючи набагато більший коефіцієнт стискання. Вищі рівні часто мають +швидкість, яку можна порівняти з \fBbzip2\fP(1) із подібним або кращим +коефіцієнтом стискання, хоча результати значно залежать від типу даних, які +стискають. +.TP +\fB\-4\fP ... \fB\-6\fP +Стискання від доброго до дуже доброго рівня із одночасним підтриманням +помірного рівня споживання пам'яті засобом розпаковування, навіть для +застарілих системи. Типовим є значення \fB\-6\fP, яке є добрим варіантом для +поширення файлів, які мають бути придатними до розпаковування навіть у +системах із лише 16\ МіБ оперативної пам'яті. (Також можна розглянути +варіанти \fB\-5e\fP і \fB\-6e\fP. Див. \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Ці варіанти подібні до \fB\-6\fP, але із вищими вимогами щодо пам'яті для +стискання і розпаковування. Можуть бути корисними лише для стискання файлів +з розміром, що перевищує 8\ МіБ, 16\ МіБ та 32\ МіБ, відповідно. +.RE +.IP "" +На однаковому обладнанні швидкість розпакування є приблизно сталою кількістю +байтів стиснених даних за секунду. Іншими словами, чим кращим є стискання, +тим швидшим буде, зазвичай, розпаковування. Це також означає, що об'єм +розпакованих виведених даних, які видає програма за секунду, може коливатися +у широкому діапазоні. +.IP "" +У наведеній нижче таблиці підсумовано можливості шаблонів: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Шаблон;DictSize;CompCPU;CompMem;DecMem +\-0;256 КіБ;0;3 МіБ;1 МіБ +\-1;1 МіБ;1;9 МіБ;2 МіБ +\-2;2 МіБ;2;17 МіБ;3 МіБ +\-3;4 МіБ;3;32 МіБ;5 МіБ +\-4;4 МіБ;4;48 МіБ;5 МіБ +\-5;8 МіБ;5;94 МіБ;9 МіБ +\-6;8 МіБ;6;94 МіБ;9 МіБ +\-7;16 МіБ;6;186 МіБ;17 МіБ +\-8;32 МіБ;6;370 МіБ;33 МіБ +\-9;64 МіБ;6;674 МіБ;65 МіБ +.TE +.RE +.RE +.IP "" +Описи стовпчиків: +.RS +.IP \(bu 3 +DictSize є розміром словника LZMA2. Використання словника, розмір якого +перевищує розмір нестисненого файла, — проста витрата пам'яті. Ось чому не +варто використовувати шаблони \fB\-7\fP ... \fB\-9\fP, якщо у них немає реальної +потреби. Для \fB\-6\fP та нижчих рівнів об'єм витраченої пам'яті, зазвичай, +такий низький, що цей фактор ні на що не впливає. +.IP \(bu 3 +CompCPU є спрощеним представленням параметрів LZMA2, які впливають на +швидкість стискання. Розмір словника також впливає на швидкість, тому, хоча +значення CompCPU є однаковим для рівнів \fB\-6\fP ... \fB\-9\fP, обробка на вищих +рівнях все одно є трошки повільнішою. Що отримати повільніше і, ймовірно, +краще стискання, див. \fB\-\-extreme\fP. +.IP \(bu 3 +CompMem містить вимоги до пам'яті засобу стискання у однопотоковому +режимі. Значення можуть бути дещо різними для різних версій \fBxz\fP. +.IP \(bu 3 +У DecMem містяться вимоги до пам'яті при розпаковуванні. Тобто параметри +засобу стискання визначають вимоги до пам'яті при розпаковуванні. Точний +об'єм пам'яті, яка потрібна для розпаковування, дещо перевищує розмір +словника LZMA2, але значення у таблиці було округлено до наступного цілого +значення МіБ. +.RE +.IP "" +Вимоги до пам'яті у багатопотоковому режимі є значно вищими, ніж у +однопотоковому. З типовим значенням \fB\-\-block\-size\fP для кожного потоку треба +3*3*DictSize плюс CompMem або DecMem. Наприклад, для чотирьох потоків з +шаблоном \fB\-6\fP потрібно 660\(en670\ МіБ пам'яті. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Використати повільніший варіант вибраного рівня стискання (\fB\-0\fP ... \fB\-9\fP) +у сподіванні отримати трохи кращий коефіцієнт стискання, але, якщо не +поталанить, можна його і погіршити. Не впливає на використання пам'яті при +розпаковуванні, але використання пам'яті при стисканні дещо збільшиться на +рівнях \fB\-0\fP ... \fB\-3\fP. +.IP "" +Оскільки існує два набори налаштувань із розмірами словників 4\ МіБ та 8\ МіБ, у наборах \fB\-3e\fP і \fB\-5e\fP використано трошки швидші параметри (нижче +CompCPU), ніж у наборах \fB\-4e\fP і \fB\-6e\fP, відповідно. Тому двох однакових +наборів у списку немає. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Шаблон;DictSize;CompCPU;CompMem;DecMem +\-0e;256 КіБ;8;4 МіБ;1 МіБ +\-1e;1 МіБ;8;13 МіБ;2 МіБ +\-2e;2 МіБ;8;25 МіБ;3 МіБ +\-3e;4 МіБ;7;48 МіБ;5 МіБ +\-4e;4 МіБ;8;48 МіБ;5 МіБ +\-5e;8 МіБ;7;94 МіБ;9 МіБ +\-6e;8 МіБ;8;94 МіБ;9 МіБ +\-7e;16 МіБ;8;186 МіБ;17 МіБ +\-8e;32 МіБ;8;370 МіБ;33 МіБ +\-9e;64 МіБ;8;674 МіБ;65 МіБ +.TE +.RE +.RE +.IP "" +Наприклад, передбачено загалом чотири набори налаштувань із використанням +словника у 8\ МіБ, порядок яких від найшвидшого до найповільнішого є таким: +\fB\-5\fP, \fB\-6\fP, \fB\-5e\fP і \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Це дещо оманливі альтернативні варіанти для \fB\-0\fP і \fB\-9\fP, +відповідно. Реалізовано лише для забезпечення зворотної сумісності із LZMA +Utils. Намагайтеся не користуватися цими варіантами параметрів. +.TP +\fB\-\-block\-size=\fP\fIрозмір\fP +При стисканні до формату \fB.xz\fP поділити вхідні дані на блоки у \fIрозмір\fP +байтів. Ці блоки буде стиснуто незалежно один від одного, що допоможе у +багатопотоковій обробці і зробить можливим обмежене розпакування для доступу +до будь\-яких даних. Цим параметром слід типово користуватися для +перевизначення типового розміру блоку у багатопотоковому режимі обробки, але +цим параметром можна також скористатися в однопотоковому режимі обробки. +.IP "" +У багатопотоковому режимі для кожного потоку буде отримано для буферів +вхідних і вихідних даних майже утричі більше за \fIрозмір\fP байтів. Типовий +\fIрозмір\fP утричі більший за розмір словника LZMA2 або дорівнює 1 МіБ, буде +вибрано більше значення. Типовим добрим значенням буде значення, яке у +2\(en4 рази перевищує розмір словника LZMA2 або дорівнює принаймні 1 +МіБ. Використання значення \fIрозмір\fP, яке є меншим за розмір словника LZMA2, +має наслідком марну витрату оперативної пам'яті, оскільки його використання +призводить до того, що буфер словника LZMA2 ніколи не буде використано +повністю. У багатопотоковому режимі розміри блоків зберігатимуться у +заголовках блоків. Ці дані потрібні для багатопотокового розпаковування. +.IP "" +У однопотоковому режимі поділ на блоки типово не +виконуватиметься. Встановлення значення для цього параметра не впливатиме на +використання пам'яті. У заголовках блоків не зберігатимуться дані щодо +розміру, отже файли, які створено в однопотоковому режимі не будуть +ідентичними до файлів, які створено у багатопотоковому режимі. Те, що у +заголовках блоків не зберігатимуться дані щодо розміру також означає, що +\fBxz\fP не зможе розпаковувати такі файли у багатопотоковому режимі. +.TP +\fB\-\-block\-list=\fP\fIзаписи\fP +При стисканні у форматі \fB.xz\fP починати новий блок із необов'язковим +ланцюжком фільтрів після вказаної кількості інтервалів нестиснених даних. +.IP "" +\fIзаписи\fP є списком відокремлених комами значень. Кожен запис складається з +необов'язкового номера ланцюжка фільтрів від 0 до 9, після якого йде +двокрапка (\fB:\fP) і необхідний розмір нестиснутих даних. Пропущення запису +(дві або більше послідовних ком) є скороченим варіантом визначення +використання розміру та фільтрів попереднього запису. +.IP "" +Якщо файл вхідних даних є більшим за розміром за суму розмірів \fIзаписів\fP, +останнє значення у \fIрозмірах\fP буде повторено до кінця файла. Особливе +значення \fB0\fP може бути використано як останній розмір, щоб позначити, що +решту файла має бути закодовано як єдиний блок. +.IP "" +Альтернативний ланцюжок фільтрів для кожного блоку можна вказати в поєднанні +з параметрами \fB\-\-filters1=\fP\fIфільтри\fP \&...\& \fB\-\-filters9=\fP\fIфільтри\fP. Ці +параметри визначають ланцюжки фільтрів з ідентифікатором у діапазоні +1\(en9. Ланцюжок фільтрів 0 можна використовувати для посилання на типовий +ланцюжок фільтрів — це те саме, що не вказувати ланцюжок +фільтрів. Ідентифікатор ланцюжка фільтрів можна використовувати перед +нестисненим розміром, після якого йде двокрапка (\fB:\fP). Наприклад, якщо +вказати \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP, блоки будуть +створені так: +.RS +.IP \(bu 3 +Ланцюжок фільтрів задано \fB\-\-filters1\fP із вхідними даними у 2 МіБ +.IP \(bu 3 +Ланцюжок фільтрів задано \fB\-\-filters3\fP із вхідними даними у 2 МіБ +.IP \(bu 3 +Ланцюжок фільтрів задано \fB\-\-filters2\fP із вхідними даними у 4 МіБ +.IP \(bu 3 +Ланцюжок фільтрів задано \fB\-\-filters2\fP із вхідними даними у 4 МіБ +.IP \(bu 3 +Типовий ланцюжок даних і вхідні дані у 2 МіБ +.IP \(bu 3 +Типовий ланцюжок фільтрів та вхідні дані у 4 МіБ для кожного блоку до кінця +вхідних даних. +.RE +.IP "" +Якщо вказати розмір, який перевищує розмір блоку кодувальника (або типове +значення у режимі із потоками обробки, або значення, яке встановлено за +допомогою \fB\-\-block\-size=\fP\fIрозмір\fP), засіб кодування створить додаткові +блоки, зберігаючи межі, які вказано у \fIзаписах\fP. Наприклад, якщо вказати +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP, а файл +вхідних даних має розмір 80 МіБ, буде отримано такі 11 блоків: 5, 10, 8, 10, +2, 10, 10, 4, 10, 10 і 1 МіБ. +.IP "" +У багатопотоковому режимі розмір блоків буде збережено у заголовках +блоків. Програма не зберігатиме ці дані у однопотоковому режимі, отже +закодований результат не буде ідентичним до отриманого у багатопотоковому +режимі. +.TP +\fB\-\-flush\-timeout=\fP\fIчас_очікування\fP +При стискання, якщо з моменту попереднього витирання мине понад +\fIчас_очікування\fP мілісекунд (додатне ціле значення) і читання додаткових +даних буде заблоковано, усі вхідні дані у черзі обробки буде витерто з +кодувальника і зроблено доступним у потоці вихідних даних. Це може бути +корисним, якщо \fBxz\fP використовують для стискання даних, які передають +потоком мережею. Невеликі значення аргументу \fIчас_очікування\fP зроблять дані +доступними на боці отримання із малою затримкою, а великі значення аргумент +\fIчас_очікування\fP уможливлять кращий коефіцієнт стискання. +.IP "" +Типово, цю можливість вимкнено. Якщо цей параметр вказано декілька разів, +буде використано лише останнє вказане значення. Особливим значенням +аргументу \fIчас_очікування\fP, рівним \fB0\fP, можна скористатися для вимикання +цієї можливості явним чином. +.IP "" +Ця можливість недоступна у системах, які не є системами POSIX. +.IP "" +.\" FIXME +\fBЦя можливість усе ще є експериментальною.\fP У поточній версії, \fBxz\fP не +може розпаковувати потік даних у режимі реального часу через те, у який +спосіб \fBxz\fP виконує буферизацію. +.TP +\fB\-\-no\-sync\fP +Не синхронізувати файл призначення та його каталог із пристроєм зберігання +даних до вилучення початкового файла. Це може підвищити швидкодію, якщо +виконується стискання або розпаковування багатьох малих файлів. Втім, якщо +система аварійно завершує роботу невдовзі після вилучення, можлива ситуація, +коли файл призначення не буде записано на пристрій зберігання даних, а дію з +вилучення буде записано. У цьому випадку буде знищено дані як початкового +файла, так і файла призначення. +.IP "" +Цей параметр матиме хоч який вплив, лише якщо \fBxz\fP вилучає початковий +файл. В інших випадках синхронізація не виконується. +.IP "" +Синхронізацію і \fB\-\-no\-sync\fP було додано у версії \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIобмеження\fP +Встановити обмеження на використання пам'яті при стисканні. Якщо цей +параметр вказано декілька разів, враховано буде лише останнє вказане +значення. +.IP "" +Якщо параметри стискання перевищують \fIобмеження\fP, \fBxz\fP спробує скоригувати +параметри так, щоб обмеження не було перевищено, і покаже повідомлення про +те, що було виконано автоматичне коригування. Коригування буде виконано у +такому порядку: зменшення кількості потоків обробки, перемикання у +однопотоковий режим, якщо хоч в одному потоці багатопотокового режиму буде +перевищено \fIобмеження\fP, і нарешті, зменшення розміру словника LZMA2. +.IP "" +При стисканні з використанням \fB\-\-format=raw\fP, або якщо було вказано +\fB\-\-no\-adjust\fP, може бути зменшена лише кількість потоків обробки, оскільки +це може бути зроблено без впливу на стиснені виведені дані. +.IP "" +Якщо \fIобмеження\fP не може бути виконано за допомогою коригувань, які описано +вище, буде показано повідомлення про помилку, а \fBxz\fP завершить роботу зі +станом виходу 1. +.IP "" +Аргумент \fIобмеження\fP можна вказати у декілька способів: +.RS +.IP \(bu 3 +Значенням \fIобмеження\fP може бути додатне ціле значення у байтах. Можна +скористатися цілочисельним суфіксом, подібним до \fBMiB\fP. Приклад: +\fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +Аргумент \fIобмеження\fP може бути задано у відсотках від загальної фізичної +пам'яті системи (RAM). Це може бути корисним особливо при встановленні +змінної середовища \fBXZ_DEFAULTS\fP у скрипті ініціалізації системи, який є +спільним для різних комп'ютерів. У такий спосіб можна вказати вищий рівень +обмеження для систем із більшим об'ємом пам'яті. Приклад: +\fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +Аргументу \fIобмеження\fP може бути повернуто типове значення встановленням +значення \fB0\fP. У поточній версії це еквівалентно до встановлення значення +аргументу \fIобмеження\fP \fBmax\fP (без обмеження на використання пам'яті). +.RE +.IP "" +Для 32\-бітової версії \fBxz\fP передбачено особливий випадок: якщо \fIобмеження\fP +перевищуватиме \fB4020\ МіБ\fP, для \fIобмеження\fP буде встановлено значення +\fB4020\ MiB\fP. На MIPS32 замість цього буде використано \fB2000\ MiB\fP. (Це не +стосується значень \fB0\fP і \fBmax\fP. Подібної можливості для розпаковування не +існує.) Це може бути корисним, коли 32\-бітовий виконуваний файл має доступ +до простору адрес у 4\ ГіБ (2 GiB на MIPS32), хоча, сподіваємося, не +зашкодить і в інших випадках. +.IP "" +Див. також розділ \fBВикористання пам'яті\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIобмеження\fP +Встановити обмеження пам'яті на розпаковування. це також вплине на режим +\fB\-\-list\fP. Якщо дія є неможливою без перевищення \fIобмеження\fP, \fBxz\fP покаже +повідомлення про помилку і розпаковування файла не +відбудеться. Див. \fB\-\-memlimit\-compress=\fP\fIобмеження\fP, щоб дізнатися більше +про те, як можна задати \fIобмеження\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIобмеження\fP +Встановити обмеження використання пам'яті для багатопотокового +розпаковування. Це може вплинути лише на кількість потоків обробки; це +ніколи не призводитиме до відмови \fBxz\fP у розпаковуванні файла. Якщо +\fIобмеження є надто низьким\fP, щоб уможливити будь\-яку багатопотокову +обробку, \fIобмеження\fP буде проігноровано, і \fBxz\fP продовжить обробку в +однопотоковому режимі. Зауважте, що якщо використано також +\fB\-\-memlimit\-decompress\fP, цей параметр буде застосовано до обох режимів, +однопотокового та багатопотокового, а отже, задіяне \fIобмеження\fP для +багатопотокового режиму ніколи не перевищуватиме обмеження, яке встановлено +за допомогою \fB\-\-memlimit\-decompress\fP. +.IP "" +На відміну від інших параметрів обмеження використання пам'яті, +\fB\-\-memlimit\-mt\-decompress=\fP\fIобмеження\fP містить специфічне для системи +типове значення \fIобмеження\fP. Можна скористатися \fBxz \-\-info\-memory\fP для +перегляду поточного значення. +.IP "" +Цей параметр і його типове значення існують, оскільки без будь\-яких обмежень +засіб розпакування зі підтримкою потокової обробки міг би намагатися +отримати величезний об'єм пам'яті для деяких файлів вхідних даних. Якщо +типове \fIобмеження\fP є надто низьким для вашої системи, не вагайтеся і +збільшуйте \fIобмеження\fP, але ніколи не встановлюйте для нього значення, яке +є більшим за придатний до користування об'єм оперативної пам'яті, оскільки +за відповідних файлів вхідних даних \fBxz\fP спробує скористатися цим об'ємом +пам'яті, навіть із низькою кількістю потоків обробки. Вичерпання об'єму +оперативної пам'яті або використання резервної пам'яті на диску не покращить +швидкодію системи під час розпаковування. +.IP "" +Див. \fB\-\-memlimit\-compress=\fP\fIобмеження\fP, щоб ознайомитися із можливими +способами визначення \fIобмеження\fP. Встановлення для \fIобмеження\fP значення +\fB0\fP відновлює типове специфічне для системи значення \fIобмеження\fP. +.TP +\fB\-M\fP \fIобмеження\fP, \fB\-\-memlimit=\fP\fIобмеження\fP, \fB\-\-memory=\fP\fIобмеження\fP +Є еквівалентом визначення \fB\-\-memlimit\-compress=\fP\fIобмеження\fP +\fB\-\-memlimit\-decompress=\fP\fIобмеження\fP +\fB\-\-memlimit\-mt\-decompress=\fP\fIобмеження\fP. +.TP +\fB\-\-no\-adjust\fP +Показати повідомлення про помилку і завершити роботу, якщо не вдасться +виконати умови щодо обмеження використання пам'яті без коригування +параметрів, які впливають на стиснених виведених даних. Тобто це забороняє +\fBxz\fP перемикати кодувальник з багатопотокового режиму на однопотоковий +режим і зменшувати розмір словника LZMA2. Навіть якщо використано цей +параметр, кількість потоків може бути зменшено для виконання обмеження на +використання пам'яті, оскільки це не вплине на результати стискання. +.IP "" +Автоматичне коригування завжди буде вимкнено при створенні потоків +необроблених даних (\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fIпотоки\fP, \fB\-\-threads=\fP\fIпотоки\fP +Вказати кількість потоків обробки, якими слід скористатися. Встановлення для +аргументу \fIпотоки\fP особливого значення \fB0\fP наказує \fBxz\fP використати не +більше потоків обробки, ніж передбачено підтримку у процесорах +системи. Справжня кількість потоків може бути меншою за значення \fIпотоки\fP, +якщо файл вхідних даних не є достатньо великим для поділу на потоки обробки +при заданих параметрах або якщо використання додаткових потоків призведе до +перевищення обмеження на використання пам'яті. +.IP "" +Засоби стискання в однопотоковому та багатопотоковому режимі дають різні +результати. Однопотоковий засіб стискання дасть найменший розмір файла, але +лише результати роботи багатопотокового засобу стискання може бути +розпаковано з використанням декількох потоків. Встановлення для аргументу +\fIпотоки\fP значення \fB1\fP призведе до використання однопотокового +режиму. Встановлення для аргументу \fIпотоки\fP будь\-якого іншого значення, +включно з \fB0\fP, призведе до використання багатопотокового засобу стискання, +навіть якщо у системі передбачено підтримки лише одного апаратного потоку +обробки даних. (Версія \fBxz\fP 5.2.x у цьому випадку використовувала +однопотоковий режим.) +.IP "" +Щоб скористатися багатопотоковим режимом із лише одним потоком обробки, +встановіть для аргументу \fIпотоки\fP значення \fB+1\fP. Префікс \fB+\fP не впливає +на значення, окрім \fB1\fP. Обмеження на використання пам'яті можуть перемкнути +\fBxz\fP в однопотоковий режим, якщо не використано параметр +\fB\-\-no\-adjust\fP. Підтримку \fB+\fP prefix було додано у версії \fBxz\fP 5.4.0. +.IP "" +Якщо було вказано автоматичне визначення кількості потоків і не вказано +обмеження на використання пам'яті, буде використано специфічне для системи +типове м'яке обмеження для можливого обмеження кількості потоків обробки. Це +обмеження є м'яким у сенсі того, що його буде проігноровано, якщо кількість +потоків зрівняється з одиницею, а отже, м'яке обмеження ніколи не +запобігатиму у \fBxz\fP стисканню або розпаковуванню. Це типове м'яке обмеження +не перемкне \fBxz\fP з багатопотокового режиму на однопотоковий режим. Активні +обмеження можна переглянути за допомогою команди \fBxz \-\-info\-memory\fP. +.IP "" +У поточній версії єдиним способом поділу на потоки обробки є поділ вхідних +даних на блоки і стискання цих блоків незалежно один від одного. Типовий +розмір блоку залежить від рівня стискання. Його може бути перевизначено за +допомогою параметра \fB\-\-block\-size=\fP\fIрозмір\fP. +.IP "" +Розпакування з потоками обробки працює лише для файлів, які містять декілька +блоків із даними щодо розміру у заголовках блоків. Цю умову задовольняють +усі достатньо великі файли, які стиснено у багатопотоковому режимі, але не +задовольняють будь\-які файли, які було стиснуто у однопотоковому режимі, +навіть якщо було використано параметр \fB\-\-block\-size=\fP\fIрозмір\fP. +.IP "" +Типовим значенням для \fIпотоків\fP є \fB0\fP. У \fBxz\fP 5.4.x та старіших версіях +типовим значенням є \fB1\fP. +. +.SS "Нетипові ланцюжки фільтрів засобу стискання" +Нетиповий ланцюжок фільтрування уможливлює докладне визначення параметрів +стискання замість використання параметрів, які пов'язано із наперед +визначеними рівнями стискання. Якщо вказано нетиповий ланцюжок фільтрів, +параметри рівнів стискання (\fB\-0\fP \&...\& \fB\-9\fP і \fB\-\-extreme\fP), які +передують їм у рядку команди, буде знехтувано. Якщо параметр рівня стискання +вказано після одного або декількох параметрів нетипового ланцюжка фільтрів, +буде використано рівень стискання, а попередніми параметрами ланцюжка +фільтрування буде знехтувано. +.PP +Ланцюжок фільтрів можна порівняти із конвеєром у командному рядку. При +стисканні нестиснені вхідні дані потрапляють до першого фільтра, виведені +ним дані йдуть до наступного фільтра (якщо такий є). Виведені останнім +фільтром дані буде записано до стисненого файла. Максимальна кількість +фільтрів у ланцюжку дорівнює чотирьом, але у типовому ланцюжку фільтрів +використовують один або два фільтри. +.PP +У багатьох фільтрів є обмеження на місце перебування у ланцюжку фільтрів: +деякі фільтри можуть працювати, лише якщо вони є останніми у ланцюжку, +деякі, лише якщо не останніми, а деякі працюють у будь\-якій позиції +ланцюжка. Залежно від фільтра, це обмеження є наслідком структури фільтра +або існує для запобігання проблем із захистом. +.PP +Нетиповий ланцюжок фільтрів можна вказати двома різними способами. Параметри +\fB\-\-filters=\fP\fIфільтри\fP і \fB\-\-filters1=\fP\fIфільтри\fP \&...\& +\fB\-\-filters9=\fP\fIфільтри\fP надають змогу вказати цілий ланцюжок фільтрів в +одному варіанті з використанням синтаксису рядків фільтрів liblzma. Крім +того, ланцюжок фільтрів можна вказати за допомогою одного або кількох +окремих параметрів фільтрування у тому порядку, в якому їх слід використати +у ланцюжку фільтрів. Тобто порядок окремих параметрів фільтра є важливим! +Під час декодування необроблених потоків (\fB\-\-format=raw\fP) ланцюжок фільтрів +має бути вказано у тому ж порядку, що й під час стиснення. Будь\-який окремий +фільтр або параметри попереднього налаштування, вказані перед параметром +повного ланцюжка (\fB\-\-filters=\fP\fIфільтри\fP), буде відкинуто. Окремі фільтри, +указані після параметра повного ланцюжка, відновлять типовий ланцюжок +фільтрів. +.PP +І параметр повного і параметр окремого фільтра приймають специфічні для +фільтрів \fIпараметри\fP у форматі списку значень, які відокремлено +комами. Зайві коми у \fIпараметрах\fP буде проігноровано. У кожного параметра є +типове значення, отже, вам слід вказати ті параметри, значення яких ви +хочете змінити. +.PP +Щоб переглянути увесь ланцюжок фільтрів та \fIпараметри\fP, скористайтеся +командою \fBxz \-vv\fP (тобто, скористайтеся \fB\-\-verbose\fP двічі). Це працює +також для перегляду параметрів ланцюжка фільтрів, який використано у рівнях +стискання. +.TP +\fB\-\-filters=\fP\fIфільтри\fP +Визначає повний ланцюжок фільтрів або шаблон у форматі одного +параметра. Кожен фільтр можна відокремити від інших пробілами або двома +дефісами (\fB\-\-\fP). Можливо, \fIфільтри\fP доведеться взяти в лапки в командному +рядку оболонки, щоб їх було оброблено як один параметр. Для позначення +\fIпараметрів\fP скористайтеся \fB:\fP або \fB=\fP. До шаблона можна додати префікс +\fB\-\fP і завершити без прапорців або декількома прапорцями. Єдиним +підтримуваним прапорцем є \fBe\fP для застосування тих самих параметрів, що й +\fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIфільтри\fP ... \fB\-\-filters9\fP=\fIфільтри\fP +Вказати до дев'яти додаткових ланцюжків фільтрів, якими можна скористатися +за допомогою \fB\-\-block\-list\fP. +.IP "" +Наприклад, якщо виконується стискання архіву із виконуваними файлами, за +якими йдуть текстові файли, для виконуваної частини може бути використано +ланцюжок фільтрів з фільтром BCJ, а для текстової частини — лише фільтр +LZMA2. +.TP +\fB\-\-filters\-help\fP +Вивести довідкове повідомлення з описом того, як вказати шаблони та нетипові +ланцюжки фільтрів у параметри \fB\-\-filters\fP і \fB\-\-filters1=\fP\fIфільтри\fP +\&...\& \fB\-\-filters9=\fP\fIфільтри\fP і завершити роботу із кодом успіху. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIпараметри\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIпараметри\fP] +.PD +Додати фільтр LZMA1 або LZMA2 до ланцюжка фільтрів. Ці фільтри може бути +використано лише як останній фільтр у ланцюжку. +.IP "" +LZMA1 є застарілим фільтром, підтримку якого збережено майже лише через +використання формату файлів \fB.lzma\fP, у яких передбачено підтримку лише +LZMA1. LZMA2 є оновленою версією LZMA1, у якій виправлено деякі практичні +вади LZMA1. У форматі \fB.xz\fP використано LZMA2 і взагалі не передбачено +підтримки LZMA1. Швидкість стискання та коефіцієнт стискання для LZMA1 і +LZMA2 є практично однаковими. +.IP "" +LZMA1 і LZMA2 спільно використовують той самий набір \fIпараметрів\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIшаблон\fP +Скинути усі \fIпараметри\fP LZMA1 або LZMA2 до параметрів \fIшаблона\fP. Аргумент +\fIшаблон\fP складається з цілого числа, після якого може бути однолітерний +модифікатор шаблона. Ціле число може належати лише діапазону від \fB0\fP до +\fB9\fP, що відповідає параметрам командного рядка \fB\-0\fP \&...\& \fB\-9\fP. Єдиним +підтримуваним модифікатором у поточній версії є \fBe\fP, щоб відповідає +параметру \fB\-\-extreme\fP. Якщо аргумент \fBшаблон\fP не вказано, типові значення +\fIпараметрів\fP LZMA1 або LZMA2 буде взято із шаблона \fB6\fP. +.TP +\fBdict=\fP\fIрозмір\fP +Параметр \fIрозміру\fP словника (буфера журналу) визначає, скільки байтів +нещодавно оброблених нестиснених даних слід зберігати у пам'яті. Алгоритм +намагається знайти повторювані послідовності байтів (відповідники) у +нестиснених даних і замінити їх на посилання на дані зі словника. Чим +більшим є словник, тим вищою є ймовірність відшукати відповідник. Отже, +збільшення \fIрозміру\fP словника, зазвичай, покращує коефіцієнт стискання, але +використання словника, розмір якого перевищу є розмір нестисненого файла є +простоюю витратою пам'яті. +.IP "" +\fIРозмір\fP типового словника складає від 64\ КіБ до 64\ МіБ. Мінімальним є +розмір 4\ КіБ. Максимальним розміром для стискання у поточній версії 1.5\ ГіБ (1536\ МіБ). У засобі розпаковування вже передбачено підтримку словників +на один байт менших за 4\ ГіБ, що є максимальним значенням для форматів +потоків даних LZMA1 і LZMA2. +.IP "" +Аргумент \fIрозміру\fP словника і засіб пошуку відповідників (\fImf\fP) разом +визначають параметри використання пам'яті для кодувальника LZMA1 або +LZMA2. Для розпаковування потрібен такий самий (або більший) \fIрозмір\fP +словника, що і для стискання, отже, використання пам'яті для засобу +розпаковування буде визначено за розміром словника, який було використано +для стискання. У заголовках \fB.xz\fP зберігається \fIрозмір\fP словника або як +2^\fIn\fP, або як 2^\fIn\fP + 2^(\fIn\fP\-1), отже, ці \fIрозміри\fP є дещо пріоритетними +для стискання. Інші \fIрозміри\fP буде отримано округленням при зберіганні у +заголовках \fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Визначає кількість буквальних контекстних бітів. Мінімальною кількістю є 0, +а максимальною — 4. Типовою кількістю є 3. Крім того, сума \fIlc\fP і \fIlp\fP має +не перевищувати 4. +.IP "" +Усі байти, які не може бути закодовано як відповідності, буде закодовано як +літерали. Тобто літерали є просто 8\-бітовими байтами, які буде закодовано по +одному за раз. +.IP "" +При кодуванні літералів роблять припущення, що найвищі біти \fIlc\fP +попереднього нестисненого байта корелюють із наступним байтом. Наприклад, у +типовому тексті англійською за літерою у верхньому регістрі йде літера у +нижньому регістрі, а за літерою у нижньому регістрі, зазвичай, йде інша +літера у нижньому регістрі. У наборі символів US\-ASCII найвищими трьома +бітами є 010 для літер верхнього регістру і 011 для літер нижнього +регістру. Якщо \fIlc\fP дорівнює принаймні 3, при кодуванні літералів можна +отримати перевагу встановлення цієї властивості для нестиснених даних. +.IP "" +Зазвичай, типового значення (3) достатньо. Якщо вам потрібне максимальне +стискання, спробуйте \fBlc=4\fP. Іноді це трохи допомагає, а іноді, робить +стискання гіршим. Якщо стискання стане гіршим, спробуйте також \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Визначає кількість буквальних позиційних бітів. Мінімальною кількістю є 0, а +максимальною — 4. Типовою кількістю є 0. +.IP "" +\fILp\fP впливає на те, яке вирівнювання у нестиснених даних слід припускати +при кодуванні літералів. Див. \fIpb\fP нижче, щоб дізнатися більше про +вирівнювання. +.TP +\fBpb=\fP\fIpb\fP +Визначає кількість позиційних бітів. Мінімальною кількістю є 0, а +максимальною — 4. Типовою кількістю є 2. +.IP "" +\fIPb\fP впливає на те, який тип вирівнювання загалом припускатиметься для +нестиснених даних. Типовим є чотирибайтове вирівнювання (2^\fIpb\fP=2^2=4), +яке, зазвичай, є добрим варіантом, якщо немає кращих припущень. +.IP "" +Якщо вирівнювання є відомим, встановлення відповідним чином \fIpb\fP може трохи +зменшити розмір файла. Наприклад, у текстових файлах із однобайтовим +вирівнюванням (US\-ASCII, ISO\-8859\-*, UTF\-8), встановлення значення \fBpb=0\fP +може трохи поліпшити стискання. Для тексту UTF\-16 добрим варіантом є +\fBpb=1\fP. Якщо вирівнювання є непарним числом, наприклад 3 байти, найкращим +вибором, ймовірно, є \fBpb=0\fP. +.IP "" +Хоча прогнозоване вирівнювання можна скоригувати за допомогою \fIpb\fP і \fIlp\fP, +у LZMA1 і LZMA2 дещо пріоритетним є 16\-байтове вирівнювання. Це, ймовірно, +слід враховувати при компонуванні форматів файлів, які, ймовірно, часто +будуть стискатися з використанням LZMA1 або LZMA2. +.TP +\fBmf=\fP\fImf\fP +Засіб пошуку відповідників має значний вплив на швидкість, використання +пам'яті та коефіцієнт стискання кодувальника. Зазвичай, засоби пошуку +відповідників на основі ланцюжка хешів є швидшими за засоби пошуку +відповідників на основі двійкового дерева. Типовий засіб залежить від +\fIшаблона\fP: для 0 використовують \fBhc3\fP, для 1\(en3 — \fBhc4\fP, а для решти +використовують \fBbt4\fP. +.IP "" +Передбачено підтримку вказаних нижче засобів пошуку відповідників. Наведені +нижче формули обчислення використання пам'яті є грубими наближеннями, які є +найближчими до реальних значень, якщо значенням \fIсловник\fP є степінь двійки. +.RS +.TP +\fBhc3\fP +Ланцюжок хешів із 2\- та 3\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 3 +.br +Використання пам'яті: +.br +\fIdict\fP * 7.5 (якщо \fIdict\fP <= 16 МіБ); +.br +\fIdict\fP * 5.5 + 64 МіБ (якщо \fIdict\fP > 16 МіБ) +.TP +\fBhc4\fP +Ланцюжок хешів із 2\-, 3\- та 4\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 4 +.br +Використання пам'яті: +.br +\fIdict\fP * 7.5 (якщо \fIdict\fP <= 32 МіБ); +.br +\fIdict\fP * 6.5 (якщо \fIdict\fP > 32 МіБ) +.TP +\fBbt2\fP +Двійкове дерево із 2\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 2 +.br +Використання пам'яті: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Двійкове дерево із 2\- і 3\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 3 +.br +Використання пам'яті: +.br +\fIdict\fP * 11.5 (якщо \fIdict\fP <= 16 МіБ); +.br +\fIdict\fP * 9.5 + 64 МіБ (якщо \fIdict\fP > 16 МіБ) +.TP +\fBbt4\fP +Двійкове дерево із 2\-, 3\- і 4\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 4 +.br +Використання пам'яті: +.br +\fIdict\fP * 11.5 (якщо \fIdict\fP <= 32 МіБ); +.br +\fIdict\fP * 10.5 (якщо \fIdict\fP > 32 МіБ) +.RE +.TP +\fBmode=\fP\fIрежим\fP +Параметр \fIрежиму\fP стискання визначає спосіб, який буде використано для +аналізу даних, які створено засобом пошуку відповідників. Підтримуваними +\fIрежимами\fP є \fBfast\fP (швидкий) і \fBnormal\fP (нормальний). Типовим є режим +\fBfast\fP для \fIшаблонів\fP 0\(en3 і режим \fBnormal\fP для \fIшаблонів\fP 4\(en9. +.IP "" +Зазвичай, із засобом пошуку відповідників на основі ланцюжка хешів +використовують \fBfast\fP, а із засобом пошуку відповідників на основі +двійкового дерева використовують \fBnormal\fP. Так само налаштовано і +\fIшаблони\fP. +.TP +\fBnice=\fP\fIпріоритетність\fP +Вказати, яка довжина є пріоритетною для відповідності. Щойно буде виявлено +відповідність у принаймні \fIпріоритетність\fP байтів, алгоритм зупинятиме +пошук можливих кращих відповідників. +.IP "" +\fIПріоритетністю\fP може бути число до 2\(en273 байтів. Вищі значення дають +кращий коефіцієнт стискання за рахунок швидкості. Типове значення залежить +від \fIшаблона\fP. +.TP +\fBdepth=\fP\fIглибина\fP +Вказати максимальну глибину пошуку у засобі пошуку відповідності. Типовим є +особливе значення 0, яке наказує засобу стискання визначити прийнятну +\fIглибину\fP на основі \fImf\fP і \fIпріоритетності\fP. +.IP "" +Прийнятним значенням \fIглибини\fP для ланцюжків хешів є 4\(en100 і 16\(en1000 +для двійкових дерев. Використання дуже високих значень для \fIглибини\fP може +зробити кодувальник дуже повільним для деяких файлів. Не встановлюйте +значення \fIглибини\fP, що перевищує 1000, якщо ви не готові перервати +стискання, якщо воно триватиме надто довго. +.RE +.IP "" +При декодуванні необроблених потоків даних (\fB\-\-format=raw\fP), LZMA2 потребує +лише \fIрозміру\fP словника. LZMA1 потребує також \fIlc\fP, \fIlp\fP і \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIпараметри\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIпараметри\fP] +.PD +Додати фільтр гілок/викликів/переходів (branch/call/jump або BCJ) до +ланцюжка фільтрів. Цими фільтрами можна скористатися, лише якщо вони не є +останнім фільтром у ланцюжку фільтрів. +.IP "" +Фільтр BCJ перетворює відносні адреси у машинному коді на їхні абсолютні +відповідники. Це не змінює розміру даних, але підвищує резервування, що може +допомогти LZMA2 створити файл \fB.xz\fP на 0\(en15\ % менше. Фільтри BCJ завжди +є придатними до обернення, тому використання фільтра BCJ до помилкового типу +даних не спричинятиме втрати даних, хоча може дещо погіршити коефіцієнт +стискання. Фільтри BCJ є дуже швидкими і такими, що використовують незначний +об'єм пам'яті. +.IP "" +Ці фільтри BCJ мають відомі проблеми, які пов'язано із рівнем стискання: +.RS +.IP \(bu 3 +У деяких типах файлів, де зберігається виконуваний код, (наприклад, в +об'єктних файлах, статичних бібліотеках та модулях ядра Linux) адреси в +інструкціях заповнено значеннями заповнювача. Ці фільтри BCJ виконуватимуть +перетворення адрес, яке зробить стискання для цих файлів гіршим. +.IP \(bu 3 +Якщо фільтр BCJ застосовано до архіву, може так статися, що він погіршить +коефіцієнт стискання порівняно із варіантом без фільтра BCJ. Наприклад, якщо +є подібні або навіть однакові виконувані файли, фільтрування, ймовірно, +зробить ці файли менш подібними, а отже, зробить стискання гіршим. Вміст +файлів, які не є виконуваними, у тому самому архіві також може вплинути на +результат. На практиці, варто спробувати варіанти з фільтром BCJ і без +нього, щоб визначитися із тим, що буде кращим у кожній ситуації. +.RE +.IP "" +Різні набори інструкцій мають різне вирівнювання: виконуваний файл має бути +вирівняно на кратне до цього значення у вхідних даних, щоб фільтр спрацював. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Фільтр;Вирівнювання;Нотатки +x86;1;32\-бітова або 64\-бітова x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;Найкращим є вирівнювання за +;;4096 байтами +PowerPC;4;Лише зворотний порядок байтів +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Оскільки фільтровані BCJ дані, зазвичай, стискають за допомогою LZMA2, +коефіцієнт стискання можна трохи поліпшити, якщо параметри LZMA2 буде +встановлено так, щоб вони відповідали вирівнюванню вибраного фільтра +BCJ. Приклади: +.RS +.IP \(bu 3 +Фільтр IA\-64 має 16\-байтове вирівнювання, отже \fBpb=4,lp=4,lc=0\fP дасть добрі +результати у поєднанні із LZMA2 (2^4=16). +.IP \(bu 3 +Код RISC\-V має 2\-байтове або 4\-байтове вирівнювання залежно від того, чи +містить файл 16\-бітові стислі інструкції (розширення C). Якщо використано +16\-бітові інструкції, добрі результати дасть \fBpb=2,lp=1,lc=3\fP або +\fBpb=1,lp=1,lc=3\fP. Якщо 16\-бітових інструкцій немає, найкращим варіантом є +\fBpb=2,lp=2,lc=2\fP. Можна скористатися \fBreadelf \-h\fP, щоб перевірити, чи є +"RVC" у рядку "Flags". +.IP \(bu 3 +ARM64 завжди вирівняно на 4 байти, тому найкращим варіантом буде +\fBpb=2,lp=2,lc=2\fP. +.IP \(bu 3 +Фільтр x86 є виключенням. Зазвичай, добрі результати дають типові для LZMA2 +значення (\fBpb=2,lp=0,lc=3\fP), якщо стискають виконувані файли x86. +.RE +.IP "" +У всіх фільтрах BCJ передбачено підтримку тих самих \fIпараметрів\fP: +.RS +.TP +\fBstart=\fP\fIзсув\fP +Встановити початковий \fIзсув\fP, який буде використано при перетворенні між +відносною та абсолютною адресами. Значення \fIзсув\fP має бути кратним до +вирівнювання фільтра (див. таблицю вище). Типовим зсувом є нульовий. На +практиці, типове значення є прийнятним; визначення нетипового значення +\fIзсув\fP майже завжди нічого корисного не дає. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIпараметри\fP] +Додати дельта\-фільтр до ланцюжка фільтрів. Дельта\-фільтр може бути +використано, лише якщо він не є останнім у ланцюжку фільтрів. +.IP "" +У поточній версії передбачено підтримку обчислення лише простої побітової +дельти. Це може бути корисним при стисканні, наприклад, нестиснутих +растрових зображень або нестиснутих звукових даних PCM. Втім, спеціалізовані +алгоритми можуть давати значно кращі результати за дельту + LZMA2. Це +правило особливо стосується звукових даних, які стискає швидше і краще, +наприклад, \fBflac\fP(1). +.IP "" +Підтримувані \fIпараметри\fP: +.RS +.TP +\fBdist=\fP\fIвідстань\fP +Вказати \fIвідстань\fP обчислень різниці у байтах. Значення \fIвідстань\fP має +потрапляти у діапазон 1\(en256. Типовим значенням є 1. +.IP "" +Наприклад, з \fBdist=2\fP та восьмибайтовими вхідними даними A1 B1 A2 B3 A3 B5 +A4 B7, результатом буде A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Інші параметри" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Придушити попередження та сповіщення. Вкажіть цей параметр двічі, щоб +придушити також повідомлення про помилки. Цей параметр не впливає на стан +виходу з програми. Тобто, навіть якщо було придушено попередження, стан +виходу вказуватиме на те, що попередження були. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Докладний режим повідомлень. Якщо стандартне виведення помилок з'єднано із +терміналом, \fBxz\fP показуватиме індикатор поступу. Використання \fB\-\-verbose\fP +двічі призведе до ще докладнішого виведення. +.IP "" +Індикатор поступу показує такі дані: +.RS +.IP \(bu 3 +Частку завершеності буде показано, якщо відомий розмір файла вхідних +даних. Тобто, для каналів даних частку не може бути показано. +.IP \(bu 3 +Об'єм стиснених виведених даних (стискання) або оброблених (розпаковування). +.IP \(bu 3 +Об'єм незапакованих даних (стискання) або виведених даних (розпаковування). +.IP \(bu 3 +Коефіцієнт стискання, який обчислено діленням об'єму оброблених стиснутих +даних на об'єм оброблених нестиснутих даних. +.IP \(bu 3 +Швидкість стискання або розпаковування. Обчислюється як об'єм нестиснутих +даних (стискання) або виведених даних (розпаковування) за секунду. Його буде +показано за декілька секунд з моменту, коли \fBxz\fP почала обробляти файл. +.IP \(bu 3 +Витрачений час у форматі Х:СС або Г:ХХ:СС. +.IP \(bu 3 +Оцінку часу, що лишився, буде показано, лише якщо розмір файла вхідних даних +є відомим, і минуло принаймні декілька секунд з моменту, коли \fBxz\fP почала +обробляти файл. Час буде показано у менш точному форматі, без двокрапок, +наприклад, 2 хв. 30 с. +.RE +.IP "" +Якщо стандартним виведенням помилок не є термінал, \fB\-\-verbose\fP призведе до +того, що \fBxz\fP виведе назву файла, стиснений розмір, нестиснений розмір, +коефіцієнт стискання та, можливо, також швидкість та витрачений час у одному +рядку до стандартного виведення помилок після стискання або розпаковування +файла. Швидкість та витрачений час буде включено, лише якщо дія триває +принаймні декілька секунд. Якщо дію не буде завершено, наприклад, через +втручання користувача, буде також виведено частку виконання, якщо відомий +розмір файла вхідних даних. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Не встановлювати стан виходу 2, навіть якщо було виявлено відповідність +умові, яка варта попередження. Цей параметр не впливає на рівень докладності +повідомлень, отже, слід використати \fB\-\-quiet\fP і \fB\-\-no\-warn\fP, щоб програма +не показувала попереджень і не змінювала стан виходу. +.TP +\fB\-\-robot\fP +Виводити повідомлення у придатному для обробки комп'ютером форматі. Цей +формат призначено для полегшення написання оболонок, які використовуватимуть +\fBxz\fP замість liblzma, що може бути зручним для різноманітних +скриптів. Виведені дані з цим параметром має бути стабільним для усіх +випусків \fBxz\fP. Докладніший опис можна знайти у розділі \fBРЕЖИМ РОБОТА\fP. +.TP +\fB\-\-info\-memory\fP +Вивести у придатному для читання людиною форматі, скільки фізичної пам'яті +(RAM) та скільки потоків процесора є за даними \fBxz\fP у системі, обмеження +для стискання та розпаковування, а потім успішно завершити роботу. +.TP +\fB\-h\fP, \fB\-\-help\fP +Вивести повідомлення про помилку з описом найбільш типових використаних +параметрів і успішно завершити роботу. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Вивести довідкове повідомлення з описом усіх можливостей \fBxz\fP і успішно +завершити роботу +.TP +\fB\-V\fP, \fB\-\-version\fP +Вивести номер версії \fBxz\fP та liblzma у зручному для читання форматі. Щоб +отримати дані, зручні для обробки на комп'ютері, вкажіть \fB\-\-robot\fP до +\fB\-\-version\fP. +. +.SH "РЕЖИМ РОБОТА" +Режим робота активують за допомогою параметра \fB\-\-robot\fP. Він спрощує +обробку виведених \fBxz\fP даних іншими програмами. У поточній версії підтримку +\fB\-\-robot\fP передбачено лише разом із \fB\-\-list\fP, \fB\-\-filters\-help\fP, +\fB\-\-info\-memory\fP і \fB\-\-version\fP. У майбутньому підтримку параметра буде +передбачено для стискання та розпаковування. +. +.SS "Режим списку" +У \fBxz \-\-robot \-\-list\fP використано табуляції для поділу виведених +даних. Першим стовпчиком у кожному рядку є рядок, що вказує на тип +відомостей, які можна знайти у цьому рядку: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Це завжди перший рядок на початку списку файла. Другим стовпчиком у рядку є +назва файла. +.TP +\fBfile\fP +У цьому рядку містяться загальні відомості щодо файла \fB.xz\fP. Цей рядок +завжди виводять після рядка \fBname\fP. +.TP +\fBstream\fP +Цей тип рядка використовують, лише якщо було вказано \fB\-\-verbose\fP. Буде +стільки рядків \fBstream\fP, скільки потоків у файлі \fB.xz\fP. +.TP +\fBblock\fP +Цей тип рядка використовують, лише якщо було вказано \fB\-\-verbose\fP. Буде +стільки рядків \fBblock\fP, скільки блоків у файлі \fB.xz\fP. Рядки \fBblock\fP буде +показано після усіх рядків \fBstream\fP; різні типи рядків не перемежовуються. +.TP +\fBsummary\fP +Цей тип рядків використовують, лише якщо \fB\-\-verbose\fP було вказано +двічі. Цей рядок буде виведено після усіх рядків \fBblock\fP. Подібно до рядка +\fBfile\fP, рядок \fBsummary\fP містить загальні відомості щодо файла \fB.xz\fP. +.TP +\fBtotals\fP +Цей рядок завжди є найостаннішим рядком у виведеному списку. У ньому буде +показано загальні кількості та розміри. +.PP +Стовпчики у рядках \fBфайла\fP: +.PD 0 +.RS +.IP 2. 4 +Кількість потоків у файлі +.IP 3. 4 +Загальна кількість блоків у потоках +.IP 4. 4 +Розмір стисненого файла +.IP 5. 4 +Розмір нестисненого файла +.IP 6. 4 +Коефіцієнт стискання, наприклад, \fB0.123\fP. Якщо коефіцієнт перевищує 9.999, +замість коефіцієнта буде показано дефіси (\fB\-\-\-\fP). +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Список відокремлених комами назв перевірок цілісності. Наведені нижче рядки +використовують для відомих типів перевірок: \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP і +\fBSHA\-256\fP. Для невідомих типів перевірок буде використано \fBUnknown\-\fP\fIN\fP, +де \fIN\fP є ідентифікатором перевірки у форматі десяткового числа (одна або +дві цифри). +.IP 8. 4 +Загальний розмір доповнення потоку у файлі +.RE +.PD +.PP +Стовпчики у рядках \fBstream\fP: +.PD 0 +.RS +.IP 2. 4 +Номер потоку (перший потік має номер 1) +.IP 3. 4 +Кількість блоків у потоці +.IP 4. 4 +Зсув початку стисненого +.IP 5. 4 +Зсув початку нестисненого +.IP 6. 4 +Стиснений розмір (не включає доповнення потоку) +.IP 7. 4 +Нестиснутий розмір +.IP 8. 4 +Рівень стискання +.IP 9. 4 +Назва перевірки цілісності +.IP 10. 4 +Розмір доповнення потоку +.RE +.PD +.PP +Стовпчики у рядках \fBblock\fP: +.PD 0 +.RS +.IP 2. 4 +Номер потоку, що містить цей блок +.IP 3. 4 +Номер блоку відносно початку потоку (перший блок має номер 1) +.IP 4. 4 +Номер блоку відносно початку файла +.IP 5. 4 +Зсув початку стисненого відносно початку файла +.IP 6. 4 +Зсув початку нестисненого відносно початку файла +.IP 7. 4 +Загальний стиснений розмір блоку (включено з заголовками) +.IP 8. 4 +Нестиснутий розмір +.IP 9. 4 +Рівень стискання +.IP 10. 4 +Назва перевірки цілісності +.RE +.PD +.PP +Якщо \fB\-\-verbose\fP було вказано двічі, до рядків \fBblock\fP буде включено +додаткові стовпчики. Ці стовпчики не буде показано, якщо вказано одинарний +параметр \fB\-\-verbose\fP, оскільки отримання цих відомостей потребує багатьох +позиціювань, а ця процедура може бути повільною: +.PD 0 +.RS +.IP 11. 4 +Значення перевірки цілісності у шістнадцятковій формі +.IP 12. 4 +Розмір заголовка блоку +.IP 13. 4 +Прапорці блоку: \fBc\fP вказує, що наявний стиснений розмір, а \fBu\fP вказує, що +наявний нестиснений розмір. Якщо прапорець не встановлено, буде показано +(\fB\-\fP) замість підтримання фіксованого розміру рядка. У майбутньому +наприкінці рядка може бути додано нові прапорці. +.IP 14. 4 +Розмір справжніх стиснених даних у блоці (це включає заголовок блоку, +доповнення блоку та поля перевірок) +.IP 15. 4 +Об'єм пам'яті (у байтах), який потрібен для розпаковування цього блоку за +допомогою цієї версії \fBxz\fP +.IP 16. 4 +Ланцюжок фільтрів. Зауважте, що більшість параметрів, які використано під +час стискання, не є наперед відомим, оскільки у заголовках \fB.xz\fP +зберігаються лише параметри, які потрібні для розпаковування. +.RE +.PD +.PP +Стовпчики у рядках \fBsummary\fP: +.PD 0 +.RS +.IP 2. 4 +Об'єм пам'яті (у байтах), який потрібен для розпаковування цього файла за +допомогою цієї версії \fBxz\fP +.IP 3. 4 +\fByes\fP або \fBno\fP вказує, якщо усі заголовки блоків містять одразу стиснений +розмір та розпакований розмір +.PP +\fIПочинаючи з\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Мінімальна версія \fBxz\fP, яка потрібна для розпаковування файла +.RE +.PD +.PP +Стовпчики рядка \fBtotals\fP: +.PD 0 +.RS +.IP 2. 4 +Кількість потоків +.IP 3. 4 +Кількість блоків +.IP 4. 4 +Стиснутий розмір +.IP 5. 4 +Нестиснутий розмір +.IP 6. 4 +Середній коефіцієнт стискання +.IP 7. 4 +Список відокремлених комами назв перевірок цілісності, результати яких +наявні у файлах +.IP 8. 4 +Розмір доповнення потоку +.IP 9. 4 +Кількість файлів. Наявний тут для зберігання такого самого порядку +стовпчиків, що і у попередніх рядках \fBfile\fP. +.PD +.RE +.PP +Якщо \fB\-\-verbose\fP було вказано двічі, до рядка \fBtotals\fP буде включено +додаткові стовпчики: +.PD 0 +.RS +.IP 10. 4 +Максимальний об'єм пам'яті (у байтах), який потрібен для розпаковування +файлів за допомогою цієї версії \fBxz\fP +.IP 11. 4 +\fByes\fP або \fBno\fP вказує, якщо усі заголовки блоків містять одразу стиснений +розмір та розпакований розмір +.PP +\fIПочинаючи з\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Мінімальна версія \fBxz\fP, яка потрібна для розпаковування файла +.RE +.PD +.PP +У майбутніх версіях може бути додано нові типи рядків і нові стовпчики до +наявних типів рядків, але наявні стовпчики мають лишитися незмінними. +. +.SS "Довідка з фільтрування" +\fBxz \-\-robot \-\-filters\-help\fP виведе список підтримуваних фільтрів у такому +форматі: +.PP +\fIфільтр\fP\fB:\fP\fIпараметр\fP\fB=<\fP\fIзначення\fP\fB>,\fP\fIпараметр\fP\fB=<\fP\fIзначення\fP\fB>\fP... +.TP +\fIфільтр\fP +Назва фільтра +.TP +\fIпараметр\fP +Назва специфічного для фільтра параметра +.TP +\fIзначення\fP +Числові діапазони \fIvalue\fP слід вказати у форматі +\fB<\fP\fIмінімум\fP\fB\-\fP\fIмаксимум\fP\fB>\fP. Варіанти рядка \fIзначення\fP +показано у \fB< >\fP і відокремлено символом \fB|\fP. +.PP +Кожен фільтр буде виведено до окремого рядка. +. +.SS "Дані щодо обмеження пам'яті" +\fBxz \-\-robot \-\-info\-memory\fP виводить один рядок з декількома відокремленими +табуляціями стовпчиками: +.IP 1. 4 +Загальний об'єм фізичної пам'яті (RAM) у байтах. +.IP 2. 4 +Обмеження на використання пам'яті для стискання у байтах +(\fB\-\-memlimit\-compress\fP). Особливе значення \fB0\fP вказує на типові +налаштування, якими для однопотокового режиму є налаштування без обмеження +на використання пам'яті. +.IP 3. 4 +Обмеження на використання пам'яті для розпакування у байтах +(\fB\-\-memlimit\-decompress\fP). Особливе значення \fB0\fP вказує на типові +налаштування, якими для однопотокового режиму є налаштування без обмеження +на використання пам'яті. +.IP 4. 4 +Починаючи з \fBxz\fP 5.3.4alpha: використання пам'яті для багатопотокового +розпаковування у байтах (\fB\-\-memlimit\-mt\-decompress\fP). Ніколи не дорівнює +нулеві, оскільки буде використано специфічне для системи типове значення, +яке показано у стовпчику 5, якщо обмеження не встановлено явним чином. Також +ніколи не перевищуватиме значення у стовпчику 3, навіть якщо було вказано +більше значення за допомогою \fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Починаючи з \fBxz\fP 5.3.4alpha: специфічне для системи типове обмеження на +використання пам'яті, яке використовують для обмеження кількості потоків при +стисканні з автоматичною кількістю потоків (\fB\-\-threads=0\fP) і без визначення +обмеження на використання пам'яті (\fB\-\-memlimit\-compress\fP). Це значення +також використовують як типове значення для \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Починаючи з \fBxz\fP 5.3.4alpha: кількість доступних потоків обробки процесора. +.PP +У майбутньому у виведенні \fBxz \-\-robot \-\-info\-memory\fP може бути більше +стовпчиків, але у виведеному буде не більше за один рядок. +. +.SS Версія +\fBxz \-\-robot \-\-version\fP виведе назву версії \fBxz\fP і liblzma у такому +форматі: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Основна версія. +.TP +\fIYYY\fP +Проміжна версія. Непарні номери буде використано для стабільних +версій. Непарні номери є номерами тестових версій. +.TP +\fIZZZ\fP +Рівень латання для стабільних випусків або просто лічильник для випусків, +які перебувають у розробці. +.TP +\fIS\fP +Стабільність. 0 — alpha, 1 — beta, а 2 означає «стабільна версія». \fIS\fP має +завжди дорівнювати 2, якщо \fIYYY\fP є парним. +.PP +\fIXYYYZZZS\fP є тим самим в обох рядках, якщо \fBxz\fP і liblzma належать до +одного випуску XZ Utils. +.PP +Приклади: 4.999.9beta — це \fB49990091\fP, а 5.0.0 — це \fB50000002\fP. +. +.SH "СТАН ВИХОДУ" +.TP +\fB0\fP +Усе добре. +.TP +\fB1\fP +Сталася помилка. +.TP +\fB2\fP +Сталося щось варте попередження, але справжніх помилок не сталося. +.PP +Зауваження (не попередження або помилки), які виведено до стандартного +виведення помилок, не впливають на стан виходу. +. +.SH СЕРЕДОВИЩЕ +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP обробляє списки відокремлених пробілами параметрів зі змінних +середовища \fBXZ_DEFAULTS\fP і \fBXZ_OPT\fP, перш ніж обробляти параметри з рядка +команди. Зауважте, що буде оброблено лише параметри зі змінних середовища; +усі непараметричні записи буде без повідомлень проігноровано. Обробку буде +виконано за допомогою функції \fBgetopt_long\fP(3), яку також використовують +для аргументів рядка команди. +.PP +\fBПопередження:\fP Встановлюючи ці змінні середовища, ви насправді змінюєте +програми та скрипти, які виконують \fBxz\fP. У більшості випадків без проблем +можна встановлювати обмеження на використання пам'яті, кількість потоків і +параметри стиснення за допомогою змінних середовища. Однак деякі параметри +можуть порушити роботу скриптів. Очевидним прикладом є \fB\-\-help\fP, який +змушує \fBxz\fP показувати текст довідки замість стискання або розпаковування +файла. Менш очевидними є приклади \fB\-\-quiet\fP і \fB\-\-verbose\fP. У багатьох +випадках усе працюватиме добре, якщо увімкнути індикатор поступу за +допомогою \fB\-\-verbose\fP, але у деяких ситуаціях додаткові повідомлення +створюють проблеми. Рівень докладності також впливає на поведінку \fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Специфічні для користувача або загальносистемні типові параметри. Зазвичай, +їх встановлюють у скрипті ініціалізації оболонки для типового вмикання +обмеження на використання пам'яті у \fBxz\fP або встановлення типової кількості +потоків обробки. Окрім скриптів ініціалізації оболонки і подібних особливих +випадків, не слід встановлювати або скасовувати встановлення значення +\fBXZ_DEFAULTS\fP у скриптах. +.TP +\fBXZ_OPT\fP +Цю змінну призначено для передавання параметрів до \fBxz\fP, якщо неможливо +встановити параметри безпосередньо у рядку команди \fBxz\fP. Це трапляється, +якщо \fBxz\fP запущено скриптом або інструментом, наприклад, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Скрипти можуть використовувати \fBXZ_OPT\fP, наприклад, для встановлення +специфічних типових параметрів стискання. Втім, рекомендуємо дозволити +користувачам перевизначати \fBXZ_OPT\fP, якщо це має якісь причини. Наприклад, +у скриптах \fBsh\fP(1) можна скористатися чимось таким: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "СУМІСНІСТЬ ІЗ LZMA UTILS" +Синтаксис рядка команди \fBxz\fP практично є надбудовою щодо \fBlzma\fP, \fBunlzma\fP +і \fBlzcat\fP з LZMA Utils 4.32.x. У більшості випадків можна замінити LZMA +Utils XZ Utils без порушення працездатності наявних скриптів. Втім, існують +певні несумісності, які іноді можуть спричиняти проблеми. +. +.SS "Рівні шаблонів стискання" +Нумерація у шаблонах рівнів стискання у \fBxz\fP не є тотожною до нумерації у +LZMA Utils. Найважливішою відмінністю є прив'язка розмірів словника до +різних шаблонів. Розмір словника грубо рівний використанню пам'яті у засобі +розпаковування. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Рівень;xz;LZMA Utils +\-0;256 КіБ;н/д +\-1;1 МіБ;64 КіБ +\-2;2 МіБ;1 МіБ +\-3;4 МіБ;512 КіБ +\-4;4 МіБ;1 МіБ +\-5;8 МіБ;2 МіБ +\-6;8 МіБ;4 МіБ +\-7;16 МіБ;8 МіБ +\-8;32 МіБ;16 МіБ +\-9;64 МіБ;32 МіБ +.TE +.RE +.PP +Відмінності у розмірах словників також впливають на використання пам'яті +засобом стискання, але є і інші відмінності між LZMA Utils і XZ Utils, які +роблять різницю ще помітнішою: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Рівень;xz;LZMA Utils 4.32.x +\-0;3 МіБ;н/д +\-1;9 МіБ;2 МіБ +\-2;17 МіБ;12 МіБ +\-3;32 МіБ;12 МіБ +\-4;48 МіБ;16 МіБ +\-5;94 МіБ;26 МіБ +\-6;94 МіБ;45 МіБ +\-7;186 МіБ;83 МіБ +\-8;370 МіБ;159 МіБ +\-9;674 МіБ;311 МіБ +.TE +.RE +.PP +Типовим рівнем стискання у LZMA Utils є \fB\-7\fP, а у XZ Utils — \fB\-6\fP, отже, +обидва комплекти програм типово використовують словник розміром у 8 МіБ. +. +.SS "Потокові і непотокові файл .lzma" +Розмір нестисненого файла може бути збережено у заголовку \fB.lzma\fP. LZMA +Utils зберігають дані при стисканні звичайних файлів. Альтернативним +підходом є позначення нестисненого розміру як невідомого і використання +позначки кінця вмісту для позначення місця, де засіб розпаковування має +зупинитися. У LZMA Utils цей спосіб використовують, якщо нестиснений розмір +є невідомим, що трапляється, наприклад, для конвеєрів обробки даних. +.PP +У \fBxz\fP передбачено підтримку розпаковування файлів \fB.lzma\fP з позначкою +кінця вмісту та без неї, але усі файли \fB.lzma\fP, які створено за допомогою +\fBxz\fP, використовують позначку кінця вмісту, а нестиснений розмір у +заголовку \fB.lzma\fP позначають як невідомий. Це може призвести до проблем у +деяких нетипових ситуаціях. Наприклад, розпакувальник \fB.lzma\fP у вбудованому +пристрої може працювати лише з файлами, для яких відомий нестиснений +розмір. Якщо ви зіткнулися з цією проблемою, вам слід скористатися LZMA +Utils або LZMA SDK для створення файлів \fB.lzma\fP із відомим розміром +нестиснених даних. +. +.SS "Непідтримувані файли .lzma" +У форматі \fB.lzma\fP можливі значення \fIlc\fP аж до 8 і значення \fIlp\fP аж до +4. LZMA Utils можуть розпаковувати файли із будь\-якими значеннями \fIlc\fP і +\fIlp\fP, але завжди створюють файли з \fBlc=3\fP і \fBlp=0\fP. Створення файлів з +іншими значеннями \fIlc\fP і \fIlp\fP є можливим за допомогою \fBxz\fP і LZMA SDK. +.PP +Реалізація фільтра LZMA1 у liblzma потребує, щоби сума \fIlc\fP і \fIlp\fP не +перевищувала 4. Отже, файли \fB.lzma\fP, у яких перевищено обмеження, не може +бути розпаковано за допомогою \fBxz\fP. +.PP +LZMA Utils створюють лише файли \fB.lzma\fP, які мають розмір словника у 2^\fIn\fP +(степінь 2), але приймають файли із будь\-яким розміром словника. liblzma +приймає лише файли \fB.lzma\fP, які мають розмір словника 2^\fIn\fP або 2^\fIn\fP + +2^(\fIn\fP\-1). Так зроблено для зменшення помилок при виявленні файлів +\&\fB.lzma\fP. +.PP +Ці обмеження не мають призводити до проблем на практиці, оскільки практично +усі файли \fB.lzma\fP було стиснено з використанням параметрів, які приймає +liblzma. +. +.SS "Кінцевий мотлох" +При розпаковуванні LZMA Utils без повідомлень ігнорують усі дані після +першого потоку \fB.lzma\fP. У більшості випадків це пов'язано із вадою у +програмі. Це також означає, що у LZMA Utils не передбачено підтримки +розпаковування з'єднаних файлів \fB.lzma\fP. +.PP +Якщо після першого потоку \fB.lzma\fP лишилися дані, \fBxz\fP вважатиме файл +пошкодженим, якщо не було використано \fB\-\-single\-stream\fP. Це може зашкодити +роботі скриптів, де зроблено припущення, що кінцеві зайві дані буде +проігноровано. +. +.SH ПРИМІТКИ +. +.SS "Стискання даних може бути різним" +Точні стиснені дані, які створено на основі того самого нестисненого файла +вхідних даних, можуть бути різними для різних версій XZ Utils, навіть якщо +використано однакові параметри стискання. Причиною цього є удосконалення у +кодувальнику (пришвидшення або краще стискання) без зміни формату +файлів. Виведені дані можуть бути різними навіть для різних збірок тієї +самої версії XZ Utils, якщо використано різні параметри збирання. +.PP +Написане вище означає, що після реалізації \fB\-\-rsyncable\fP файли\-результати +не обов'язково можна буде синхронізувати за допомогою rsyncable, якщо старий +і новий файли було стиснено за допомогою тієї самої версії xz. Цю проблему +можна усунути, якщо буде заморожено частину реалізації кодувальника, щоб +введені для rsync дані були стабільними між версіями xz. +. +.SS "Вбудовані розпакувальники .xz" +У вбудованих реалізаціях розпакувальника \fB.xz\fP, подібних до XZ Embedded, не +обов'язково передбачено підтримку файлів, які створено із типами +\fIперевірки\fP цілісності, відмінними від \fBnone\fP і \fBcrc32\fP. Оскільки типовим +є \fB\-\-check=crc64\fP, вам слід використовувати \fB\-\-check=none\fP або +\fB\-\-check=crc32\fP при створенні файлів для вбудованих систем. +.PP +Поза вбудованими системами, в усіх засобах розпаковування формату \fB.xz\fP +передбачено підтримку усіх типів \fIперевірок\fP або принаймні можливість +розпакувати файл без перевірки цілісності, якщо підтримки певної +\fIперевірки\fP не передбачено. +.PP +У XZ Embedded передбачено підтримку BCJ, але лише з типовим початковим +зсувом. +. +.SH ПРИКЛАДИ +. +.SS Основи +Стиснути файл \fIfoo\fP до \fIfoo.xz\fP за допомогою типового рівня стискання +(\fB\-6\fP) і вилучити \fIfoo\fP, якщо стискання відбулося успішно: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Розпакувати \fIbar.xz\fP до \fIbar\fP і не вилучати \fIbar.xz\fP, навіть якщо +розпаковування відбулося успішно: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Створити \fIbaz.tar.xz\fP з використанням шаблона \fB\-4e\fP (\fB\-4 \-\-extreme\fP), +який є повільнішими за типовий \fB\-6\fP, але потребує менше пам'яті для +стискання та розпаковування (48\ МіБ та 5\ МіБ, відповідно): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Суміш стиснених і нестиснених файлів можна розпакувати до стандартного +виведення за допомогою єдиної команди: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Паралельне стискання багатьох файлів" +У GNU і *BSD можна скористатися \fBfind\fP(1) і \fBxargs\fP(1) для паралельного +стискання багатьох файлів: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Параметр \fB\-P\fP \fBxargs\fP(1) встановлює кількість паралельних процесів +\fBxz\fP. Найкраще значення параметра \fB\-n\fP залежить від того, скільки файлів +має бути стиснено. Якщо файлів мало, значенням, ймовірно, має бути 1. Якщо +файлів десятки тисяч, може знадобитися значення 100 або навіть більше, щоб +зменшити кількість процесів \fBxz\fP, які врешті створить \fBxargs\fP(1). +.PP +Параметр \fB\-T1\fP для \fBxz\fP тут для примусового встановлення однопотокового +режиму, оскільки для керування рівнем паралелізації використано \fBxargs\fP(1). +. +.SS "Режим робота" +Обчислити скільки байтів було заощаджено загалом після стискання декількох +файлів: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Скрипту можуть знадобитися дані щодо того, що використано достатньо нову +версію \fBxz\fP. У наведеному нижче скрипті \fBsh\fP(1) виконано перевірку того, +що номер версії засобу \fBxz\fP є принаймні рівним 5.0.0. Цей спосіб є сумісним +зі старими тестовими версіями, де не передбачено підтримки параметра +\fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Встановити обмеження на використання пам'яті для розпаковування за допомогою +\fBXZ_OPT\fP, але якщо обмеження вже було встановлено, не збільшувати його: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Нетипові ланцюжки фільтрів засобу стискання" +Найпростішим використанням ланцюжка фільтрів є налаштовування шаблона +LZMA2. Це може бути корисним, оскільки у шаблонах використано лише +підмножину потенційно корисних комбінацій параметрів стискання. +.PP +При налаштовуванні шаблонів LZMA2 корисними є стовпчики CompCPU таблиць з +описів параметрів \fB\-0\fP ... \fB\-9\fP і \fB\-\-extreme\fP. Ось відповідні частини з +цих двох таблиць: +.RS +.PP +.TS +tab(;); +c c +n n. +Шаблон;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Якщо вам відомо, що певний файл потребує дещо більшого словника (наприклад, +32\ МіБ) для якісного стискання, але ви хочете стиснути його швидше за +команду \fBxz \-8\fP, можна внести зміни до шаблона із нижчим значенням CompCPU +(наприклад, 1) для використання більшого словника: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Для певних файлів наведена вище команда може працювати швидше за \fBxz \-6\fP і +стискати дані значно краще. Втім, слід наголосити, переваги більшого +словника з одночасним низьким значенням CompCPU проявляються лише для деяких +файлів. Найочевиднішим випадком, коли великий словник є корисним, є випадок, +коли архів містить дуже подібні файли розміром у принаймні декілька +мегабайтів. Розмір словника має бути значно більшим за будь\-який окремий +файл, щоб у LZMA2 було використано усі переваги подібностей між послідовними +файлами. +.PP +Якщо дуже високий рівень використання пам'яті у засобі стискання або +розпаковування не є проблемою, і файли, який стискають має об'єм у принаймні +декілька десятків мегабайтів, може бути корисним використання навіть +більшого за 64 МіБ словника, який використано у \fBxz \-9\fP: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Використання \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP), подібно до наведеного вище +прикладу, може бути корисним для перегляду вимог з боку засобів стискання та +розпаковування до пам'яті. Пам'ятайте, що використання словника, розмір +якого перевищує розмір файла, який стискають, є простоюю витратою пам'яті, +отже наведену вище команду не варто використовувати для малих файлів. +.PP +Іноді час стискання не має значення, але використання пам'яті засобом +розпаковування має бути низьким для того, щоб, наприклад, уможливити +розпаковування файла у вбудованій системі. У наведеній нижче команді +використано \fB\-6e\fP (\fB\-6 \-\-extreme\fP) як основу і встановлено розмір словника +лише у 64\ КіБ. Файл\-результат можна розпакувати за допомогою XZ Embedded +(ось чому використано \fB\-\-check=crc32\fP) з використанням лише 100\ КіБ +пам'яті. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Якщо вам потрібно витиснути зі стискання максимальну кількість байтів, може +допомогти коригування кількості бітів контексту літералів (\fIlc\fP) та +кількість позиційних бітів (\fIpb\fP). Також може допомогти коригування +кількості бітів позиції літералів (\fIlp\fP), але, зазвичай, важливішими є +\fIlc\fP і \fIpb\fP. Наприклад, в архівах зі початковим кодом міститься +здебільшого текст US\-ASCII, щось подібне до наведеного нижче може дещо (на +щось близьке до 0,1\ %) зменшити файл, порівняно із \fBxz \-6e\fP (спробуйте +також без \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Використання іншого фільтра разом із LZMA2 може покращити стискання для +певних типів файлів. Наприклад, для стискання бібліотеки спільного +користування x86\-32 або x86\-64 з використанням фільтра BCJ x86 скористайтеся +такою командою: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Зауважте, що порядок параметрів фільтрування має значення. Якщо \fB\-\-x86\fP +вказано після \fB\-\-lzma2\fP, \fBxz\fP повідомить про помилку, оскільки після LZMA2 +не може бути жодного фільтра, а також оскільки фільтр BCJ x86 не можна +використовувати як останній фільтр у ланцюжку. +.PP +Фільтр Delta разом із LZMA2 може дати добрі результати для растрових +зображень. Зазвичай, результати є кращими за формат PNG, у якого є декілька +більш досконалих фільтрів, ніж проста дельта, але там використовують для +стискання Deflate. +.PP +Зображення слід берегти у нестисненому форматі, наприклад, як нестиснений +TIFF. Параметр відстані фільтра Delta встановлюють так, щоб він збігався із +кількістю байтів на піксель у зображенні. Наприклад, для 24\-бітового +растрового зображення RGB слід вказати \fBdist=3\fP, а також добре передати +\fBpb=0\fP до LZMA2 для пристосовування до трибайтового вирівнювання: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Якщо в один архів запаковано декілька зображень (наприклад, в архів +\&\fB.tar\fP), фільтр Delta також даватиме добрі результати, якщо у всіх +зображеннях однакова кількість байтів для кожного пікселя. +. +.SH "ДИВ. ТАКОЖ" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +Вбудовуваний XZ: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzmadec.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzmadec.1 new file mode 100644 index 0000000000000000000000000000000000000000..85a82215945dbd97edde051df4a2009126bc4b21 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzmadec.1 @@ -0,0 +1,85 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.\" Ukrainian translation for xz-man. +.\" Yuri Chornoivan , 2019, 2022, 2023, 2024, 2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDEC 1 "8 квітня 2024 року" Tukaani "XZ Utils" +.SH НАЗВА +xzdec, lzmadec — невеличкі розпакувальники .xz і .lzma +.SH "КОРОТКИЙ ОПИС" +\fBxzdec\fP [\fIпараметр...\fP] [\fIфайл...\fP] +.br +\fBlzmadec\fP [\fIпараметр...\fP] [\fIфайл...\fP] +.SH ОПИС +\fBxzdec\fP є інструментом на основі liblzma, який призначено лише для +розпаковування файлів \fB.xz\fP (і лише файлів \fB.xz\fP). \fBxzdec\fP призначено для +того, щоб працювати як повноцінний замінник \fBxz\fP(1) у більшості типових +ситуацій, де скрипт було написано для використання \fBxz \-\-decompress \-\-stdout\fP (і, можливо, декількох інших типових параметрів), для +розпаковування файлів \fB.xz\fP. \fBlzmadec\fP є тотожним до \fBxzdec\fP, але у +\fBlzmadec\fP передбачено підтримку файлів \fB.lzma\fP, замість файлів \fB.xz\fP. +.PP +Щоб зменшити розмір виконуваного файла, у \fBxzdec\fP не передбачено підтримки +багатопотокової обробки та локалізації, а також читання параметрів зі +змінних середовища \fBXZ_DEFAULTS\fP і \fBXZ_OPT\fP. У \fBxzdec\fP не передбачено +підтримки показу проміжних даних щодо поступу: надсилання \fBSIGINFO\fP до +\fBxzdec\fP не призводить ні до яких наслідків, але надсилання \fBSIGUSR1\fP +перериває процес, замість показу даних щодо поступу. +.SH ПАРАМЕТРИ +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +Буде проігноровано для сумісності з \fBxz\fP(1). У \fBxzdec\fP передбачено +підтримку лише розпаковування. +.TP +\fB\-k\fP, \fB\-\-keep\fP +Буде проігноровано. Призначено для сумісності з \fBxz\fP(1). \fBxzdec\fP ніколи не +створюватиме і ніколи не вилучатиме ці файли. +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Буде проігноровано. Для сумісності з \fBxz\fP(1). \fBxzdec\fP завжди записує +розпаковані дані до стандартного виведення. +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Якщо цей параметр вказано один раз, нічого не станеться, оскільки \fBxzdec\fP +ніколи не показуватиме жодних попереджень або нотаток. Вкажіть параметр +двічі, щоб придушити повідомлення про помилки. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Буде проігноровано для сумісності із \fBxz\fP(1). \fBxzdec\fP ніколи не +використовує стан виходу 2. +.TP +\fB\-h\fP, \fB\-\-help\fP +Вивести довідкове повідомлення і успішно завершити роботу. +.TP +\fB\-V\fP, \fB\-\-version\fP +Вивести номер версії \fBxzdec\fP та liblzma. +.SH "СТАН ВИХОДУ" +.TP +\fB0\fP +Усе добре. +.TP +\fB1\fP +Сталася помилка. +.PP +\fBxzdec\fP не має жодних повідомлень із попередженнями, на відміну від +\fBxz\fP(1), тому у \fBxzdec\fP стан виходу 2 не використовується. +.SH ПРИМІТКИ +Користуйтеся \fBxz\fP(1), замість \fBxzdec\fP або \fBlzmadec\fP, для щоденних +потреб. \fBxzdec\fP та \fBlzmadec\fP призначено лише для тих ситуацій, коли +важливо мати меншу програму для розпаковування, ніж \fBxz\fP(1). +.PP +\fBxzdec\fP і \fBlzmadec\fP не такі вже і малі програми. Їхній розмір можна +зменшити викиданням можливостей з liblzma під час збирання, але цього +зазвичай не роблять для виконуваних файлів, які поширюються у типових, не +вбудованих, дистрибутивах операційних систем. Якщо вам потрібний дуже мала +програма для розпаковування \fB.xz\fP, варто скористатися XZ Embedded. +.SH "ДИВ. ТАКОЖ" +\fBxz\fP(1) +.PP +Вбудовуваний XZ: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzmainfo.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzmainfo.1 new file mode 100644 index 0000000000000000000000000000000000000000..fea640b06d1d782db41bc75f432a790d6d54908e --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzmainfo.1 @@ -0,0 +1,45 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.\" Ukrainian translation for xz-man. +.\" Yuri Chornoivan , 2019, 2022, 2023, 2024, 2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH LZMAINFO 1 "30 червня 2013 року" Tukaani "XZ Utils" +.SH НАЗВА +lzmainfo — показ відомостей, які зберігаються у заголовку файла .lzma +.SH "КОРОТКИЙ ОПИС" +\fBlzmainfo\fP [\fB\-\-help\fP] [\fB\-\-version\fP] [\fIфайл...\fP] +.SH ОПИС +\fBlzmainfo\fP показує дані, що зберігаються у заголовку файла \fB.lzma\fP. Вона +читає перші 13 байтів із вказаного \fIфайла\fP, розкодовує заголовок і виводить +його до стандартного виведення у зручному для читання форматі. Якщо не +вказано жодного \fIфайла\fP або замість \fIфайла\fP вказано \fB\-\fP, дані буде +прочитано зі стандартного вхідного джерела даних. +.PP +Зазвичай, найцікавішою інформацією є розпакований розмір та розмір +словника. Розпакований розмір може бути показано, лише якщо файл записано у +непотоковому варіанті формату \fB.lzma\fP. Об'єм пам'яті, потрібний для +розпаковування файла, складає декілька десятків кілобайтів плюс розмір +словника. +.PP +\fBlzmainfo\fP включено до XZ Utils в основному для зворотної сумісності із +LZMA Utils. +.SH "СТАН ВИХОДУ" +.TP +\fB0\fP +Усе добре. +.TP +\fB1\fP +Сталася помилка. +.SH ВАДИ +\fBlzmainfo\fP використовує \fBMB\fP, хоча правильним суфіксом мав би бути \fBMiB\fP +(2^20 байтів). Так зроблено, щоб зберегти сумісність виведених даних із LZMA +Utils. +.SH "ДИВ. ТАКОЖ" +\fBxz\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzmore.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzmore.1 new file mode 100644 index 0000000000000000000000000000000000000000..bf320be54129079b0f7310ac7f4d733a9f4d9945 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/lzmore.1 @@ -0,0 +1,51 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" Ukrainian translation for xz-man. +.\" Yuri Chornoivan , 2019, 2022, 2023, 2024, 2025. +.\" +.\" (Note that this file is based on xzless.1 instead of gzip's zmore.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZMORE 1 "6 березня 2025 року" Tukaani "XZ Utils" +.SH НАЗВА +xzmore, lzmore — перегляд стиснених xz або lzma (текстових) файлів +. +.SH "КОРОТКИЙ ОПИС" +\fBxzmore\fP [\fIфайл\fP...] +.br +\fBlzmore\fP [\fIфайл\fP...] (ЗАСТАРІЛО) +. +.SH ОПИС +\fBxzmore\fP показує текст зі стиснених файлів у терміналі за допомогою +\fBmore\fP(1). Файли, підтримку яких передбачено у \fBxz\fP(1), буде розпаковано; +інші файли вважатимуться вже наданими у розпакованій формі. Якщо не вказано +аргументу \fIфайли\fP, \fBxzmore\fP читатиме дані зі стандартного джерела +даних. Див. підручник з \fBmore\fP(1), щоб дізнатися більше про клавіатурні +команди. +.PP +Зауважте, що гортання у зворотному напрямку може бути неможливим через +реалізацію \fBmore\fP(1). Причиною є те, що \fBxzmore\fP використовує канал для +передавання розпакованих даних \fBmore\fP(1). \fBxzless\fP(1) використовує +\fBless\fP(1), можливості якої є ширшими. +.PP +Команду \fBlzmore\fP реалізовано для забезпечення зворотної сумісності з LZMA +Utils. Ця команда вважається застарілою, її буде вилучено у майбутній версії +комплекту програм. +. +.SH СЕРЕДОВИЩЕ +.TP +.\" TRANSLATORS: Don't translate the uppercase PAGER. +.\" It is a name of an environment variable. +\fBPAGER\fP +Якщо встановлено значення \fBPAGER\fP, значення буде використано для засобу +поділу на сторінки, замість \fBmore\fP(1). +. +.SH "ДИВ. ТАКОЖ" +\fBmore\fP(1), \fBxz\fP(1), \fBxzless\fP(1), \fBzmore\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/unlzma.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/unlzma.1 new file mode 100644 index 0000000000000000000000000000000000000000..bff0472c4495c4b8c84495967535bcd7b99dc205 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/unlzma.1 @@ -0,0 +1,2039 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Ukrainian translation for xz-man. +.\" Yuri Chornoivan , 2019, 2022, 2023, 2024, 2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 "8 березня 2025 року" Tukaani "XZ Utils" +. +.SH НАЗВА +xz, unxz, xzcat, lzma, unlzma, lzcat — стискання та розпаковування файлів +\&.xz і .lzma +. +.SH "КОРОТКИЙ ОПИС" +\fBxz\fP [\fIпараметр...\fP] [\fIфайл...\fP] +. +.SH "СКОРОЧЕННЯ КОМАНД" +\fBunxz\fP є рівноцінним до \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP є рівноцінним до \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP є рівноцінним до \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP є рівноцінним до \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP є рівноцінним до \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +При написанні скриптів, де потрібно розпаковувати файли, рекомендуємо завжди +використовувати \fBxz\fP із відповідними аргументами (\fBxz \-d\fP або \fBxz \-dc\fP), +замість \fBunxz\fP і \fBxzcat\fP. +. +.SH ОПИС +\fBxz\fP інструмент загального призначення для стискання даних із синтаксисом +командного рядка, подібним для \fBgzip\fP(1) і \fBbzip2\fP(1). Власним форматом +файлів є \fB.xz\fP, але передбачено підтримку застарілого формату \fB.lzma\fP, +який було використано у LZMA Utils, та необроблених потоків стиснених даних +без заголовків формату контейнера. Крім того, передбачено підтримку +розпаковування формату \fB.lz\fP, який використано у \fBlzip\fP. +.PP +\fBxz\fP стискає або розпаковує кожен \fIфайл\fP відповідно до вибраного режиму +дій. Якщо \fIфайли\fP не задано або якщо \fIфайлом\fP є \fB\-\fP, \fBxz\fP читатиме дані +зі стандартного джерела вхідних даних і записуватиме оброблені дані до +стандартного виведення. \fBxz\fP відмовить (покаже повідомлення про помилку і +пропустить \fIфайл\fP) у записів стиснених даних до стандартного виведення, +якщо це термінал. Так само, \fBxz\fP відмовить у читанні стиснених даних зі +стандартного джерела вхідних даних, якщо це термінал. +.PP +Якщо не вказано \fB\-\-stdout\fP, \fIфайли\fP, відмінні від \fB\-\fP, буде записано до +нового файла, чию назву буде визначено з назви початкового \fIфайла\fP: +.IP \(bu 3 +При стисканні суфікс формату файла призначення (\fB.xz\fP або \fB.lzma\fP) буде +дописано до назви початкового файла для отримання назви файла призначення. +.IP \(bu 3 +При розпаковуванні суфікс \fB.xz\fP, \fB.lzma\fP або \fB.lz\fP буде вилучено з назви +файла для отримання назви файла призначення. Крім того, \fBxz\fP розпізнає +суфікси \fB.txz\fP і \fB.tlz\fP і замінює їх на суфікс \fB.tar\fP. +.PP +Якщо файл призначення вже існує, буде показано повідомлення про помилку, а +\fIфайл\fP буде пропущено. +.PP +Окрім випадку запису до стандартного виведення, \fBxz\fP покаже попередження і +пропустить обробку \fIфайла\fP, якщо буде виконано будь\-яку з таких умов: +.IP \(bu 3 +\fIФайл\fP не є звичайним файлом. Програма не переходитиме за символічними +посиланнями, а отже, не вважатиме їх звичайними файлами. +.IP \(bu 3 +На \fIфайл\fP існує декілька жорстких посилань. +.IP \(bu 3 +Для \fIфайла\fP встановлено setuid, setgid або «липкий» біт. +.IP \(bu 3 +Режим дій встановлено у значення «стискання», і \fIфайл\fP вже має суфікс назви +формату файла призначення (\fB.xz\fP або \fB.txz\fP при стисканні до формату +\&\fB.xz\fP, і \fB.lzma\fP або \fB.tlz\fP при стисканні до формату \fB.lzma\fP). +.IP \(bu 3 +Режим дій встановлено у значення «розпаковування», і \fIфайл\fP не має суфікса +назви жодного з підтримуваних форматів (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP +або \fB.lz\fP). +.PP +Після успішного стискання або розпаковування \fIфайла\fP, \fBxz\fP копіює дані +щодо власника, групи, прав доступу, часу доступу та моменту внесення змін з +початкового \fIфайла\fP до файла призначення. Якщо копіювання даних щодо групи +зазнає невдачі, права доступу буде змінено так, що файл призначення стане +недоступним для користувачів, які не мають права доступу до початкового +\fIфайла\fP. В \fBxz\fP ще не передбачено підтримки копіювання інших метаданих, +зокрема списків керування доступом або розширених атрибутів. +.PP +Щойно файл призначення буде успішно закрито, початковий \fIфайл\fP буде +вилучено, якщо не вказано параметра \fB\-\-keep\fP. Початковий \fIфайл\fP ніколи не +буде вилучено, якщо виведені дані буде записано до стандартного виведення +або якщо станеться помилка. +.PP +Надсилання \fBSIGINFO\fP або \fBSIGUSR1\fP до процесу \fBxz\fP призводить до +виведення даних щодо поступу до стандартного виведення помилок. Це має лише +обмежене використання, оскільки якщо стандартним виведенням помилок є +термінал, використання \fB\-\-verbose\fP призведе до показу автоматично +оновлюваного індикатора поступу. +. +.SS "Використання пам'яті" +Використання \fBxz\fP пам'яті може бути різним: від декількох сотень кілобайтів +до декількох гігабайтів, залежно від параметрів стискання. Параметри, які +використано при стисканні файла, визначають вимоги до об'єму пам'яті при +розпакуванні. Типово, засобу розпаковування потрібно від 5\ % до 20\ % +об'єму пам'яті, якого засіб стискання потребує при створенні +файла. Наприклад, розпаковування файла, який створено з використанням \fBxz \-9\fP, у поточній версії потребує 65\ МіБ пам'яті. Втім, можливе створення +файлів \fB.xz\fP, які потребуватимуть для розпаковування декількох гігабайтів +пам'яті. +.PP +Ймовірність високого рівня використання пам'яті може бути особливо +дошкульною для користувачів застарілих комп'ютерів. Щоб запобігти прикрим +несподіванкам, у \fBxz\fP передбачено вбудований обмежувач пам'яті, який типово +вимкнено. Хоча у деяких операційних системах передбачено спосіб обмежити +використання пам'яті процесами, сподівання на його ефективність не є аж +надто гнучким (наприклад, використання \fBulimit\fP(1) для обмеження +віртуальної пам'яті призводить до викривлення даних \fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Обмежувач пам'яті можна увімкнути за допомогою параметра командного рядка +\fB\-\-memlimit=\fP\fIобмеження\fP. Часто, зручніше увімкнути обмежувач на типовому +рівні, встановивши значення для змінної середовища \fBXZ_DEFAULTS\fP, +наприклад, \fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Можна встановити обмеження +окремо для стискання і розпакування за допомогою +\fB\-\-memlimit\-compress=\fP\fIlimit\fP and +\fB\-\-memlimit\-decompress=\fP\fIобмеження\fP. Використання цих двох параметрів поза +\fBXZ_DEFAULTS\fP не таке вже і корисне, оскільки одноразовий запуск \fBxz\fP не +може одночасно призводити до стискання та розпаковування, а набрати у +командному рядку \fB\-\-memlimit=\fP\fIобмеження\fP (або \fB\-M\fP \fIобмеження\fP) +набагато швидше. +.PP +Якщо під час розпаковування вказане обмеження буде перевищено, \fBxz\fP покаже +повідомлення про помилку, а розпаковування файла зазнає невдачі. Якщо +обмеження буде перевищено при стисканні, \fBxz\fP спробує масштабувати +параметри так, щоб не перевищувати обмеження (окрім випадків використання +\fB\-\-format=raw\fP або \fB\-\-no\-adjust\fP). Отже, дію буде виконано, якщо обмеження +не є надто жорстким. Масштабування параметрів буде виконано кроками, які не +збігаються із рівнями шаблонів стискання. Наприклад, якщо обмеження лише +трохи не вкладається у об'єм потрібний для \fBxz \-9\fP, параметри буде змінено +лише трохи, не до рівня \fBxz \-8\fP. +. +.SS "Поєднання і заповнення з файлами .xz" +Можна поєднати файли \fB.xz\fP без додаткової обробки. \fBxz\fP розпакує такі +файли так, наче вони є єдиним файлом \fB.xz\fP. +.PP +Можна додати доповнення між з'єднаними частинами або після останньої +частини. Доповнення має складатися із нульових байтів і мати розмір, який є +кратним до чотирьох байтів. Це може бути корисним, наприклад, якщо файл +\&\fB.xz\fP зберігається на носії даних, де розміри файла вимірюються у +512\-байтових блоках. +.PP +Поєднання та заповнення не можна використовувати для файлів \fB.lzma\fP або +потоків необроблених даних. +. +.SH ПАРАМЕТРИ +. +.SS "Цілочисельні суфікси і спеціальні значення" +У більшості місць, де потрібен цілочисельний аргумент, передбачено підтримку +необов'язкового суфікса для простого визначення великих цілих чисел. Між +цілим числом і суфіксом не повинно бути пробілів. +.TP +\fBKiB\fP +Помножити ціле число на 1024 (2^10). Синонімами \fBKiB\fP є \fBKi\fP, \fBk\fP, \fBkB\fP, +\fBK\fP та \fBKB\fP. +.TP +\fBMiB\fP +Помножити ціле число на 1048576 (2^20). Синонімами \fBMiB\fP є B, \fBMi\fP, \fBm\fP, +\fBM\fP та \fBMB\fP. +.TP +\fBGiB\fP +Помножити ціле число на 1073741824 (2^30). Синонімами \fBGiB\fP є B, \fBGi\fP, +\fBg\fP, \fBG\fP та \fBGB\fP. +.PP +Можна скористатися особливим значенням \fBmax\fP для позначення максимального +цілого значення, підтримку якого передбачено для параметра. +. +.SS "Режим операції" +Якщо вказано декілька параметрів режиму дій, буде використано лише останній +з них. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Стиснути. Це типовий режим дій, якщо не вказано параметр режиму дій, а назва +команди неявним чином не визначає іншого режиму дій (наприклад, \fBunxz\fP +неявно визначає \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Після успішного пакування початковий файл буде вилучено, якщо виведення не +відбувається до стандартного виведення або не вказано параметра \fB\-\-keep\fP. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Розпакувати. Після успішного розпаковування початковий файл буде вилучено, +якщо виведення не відбувається до стандартного виведення або не вказано +параметра \fB\-\-keep\fP. +.TP +\fB\-t\fP, \fB\-\-test\fP +Перевірити цілісність стиснених файлів \fIфайли\fP. Цей параметр еквівалентний +до \fB\-\-decompress \-\-stdout\fP, але розпаковані дані буде відкинуто, замість +запису до стандартного виведення. Жодних файлів не буде створено або +вилучено. +.TP +\fB\-l\fP, \fB\-\-list\fP +Вивести відомості щодо стиснених файлів \fIфайли\fP. Розпакування даних не +виконуватиметься, жодних файлів не буде створено або вилучено. У режимі +списку програма не може читати дані зі стандартного введення або з інших +джерел, де неможливе позиціювання. +.IP "" +У типовому списку буде показано базові відомості щодо файлів \fIфайли\fP, по +одному файлу на рядок. Щоб отримати докладніші відомості, скористайтеся +параметром \fB\-\-verbose\fP. Щоб розширити спектр відомостей, скористайтеся +параметром \fB\-\-verbose\fP двічі, але зауважте, що це може призвести до +значного уповільнення роботи, оскільки отримання додаткових відомостей +потребує великої кількості позиціювань. Ширина області докладного виведення +даних перевищує 80 символів, тому передавання конвеєром виведених даних, +наприклад, до \fBless\ \-S\fP, може бути зручним способом перегляду даних, якщо +термінал недостатньо широкий. +.IP "" +Виведені дані залежать від версії \fBxz\fP та використаної локалі. Для +отримання даних, які будуть придатні до обробки комп'ютером, слід +скористатися параметрами \fB\-\-robot \-\-list\fP. +. +.SS "Модифікатори режиму роботи" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Не вилучати вхідні файли. +.IP "" +Починаючи з версії \fBxz\fP 5.2.6, використання цього параметра також наказує +\fBxz\fP виконувати стискання або розпаковування, навіть якщо вхідними даними є +символічне посилання на звичайний файл, файл, який має декілька жорстких +посилань, або файл, для якого встановлено setuid, setgid або липкий +біт. setuid, setgid та липкий біт не буде скопійовано до файла\-результату. У +попередніх версіях, ці дії виконувалися, лише якщо було використано параметр +\fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Результатів використання цього параметра буде декілька: +.RS +.IP \(bu 3 +Якщо файл\-результат вже існує, вилучити його до стискання або +розпаковування. +.IP \(bu 3 +Виконувати стискання або розпаковування, навіть якщо вхідними даними є +символічне посилання на звичайний файл, файл, який має декілька жорстких +посилань, або файл, для якого встановлено setuid, setgid або липкий біт +setuid, setgid та липкий біт не буде скопійовано до файла\-результату. +.IP \(bu 3 +Якщо використано разом із \fB\-\-decompress\fP, \fB\-\-stdout\fP, і \fBxz\fP не зможе +розпізнати тип початкового файла, копіювати початковий файл без змін до +стандартного виведення. Це надає змогу користуватися \fBxzcat\fP \fB\-\-force\fP +подібно до \fBcat\fP(1) для файлів, які не було стиснено за допомогою +\fBxz\fP. Зауважте, що у майбутньому у \fBxz\fP може бути реалізовано підтримку +нових форматів стиснених файлів, замість копіювання їх без змін до +стандартного виведення. Можна скористатися \fB\-\-format=\fP\fIформат\fP для +обмеження стискання у \fBxz\fP єдиним форматом файлів. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Записати стиснені або розпаковані дані до стандартного виведення, а не до +файла. Неявним чином встановлює \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Розпакувати лише перший потік даних \fB.xz\fP і без повідомлень проігнорувати +решту вхідних даних, які слідують за цим потоком. Зазвичай, такі зайві дані +наприкінці файла призводять до показу \fBxz\fP повідомлення про помилку. +.IP "" +\fBxz\fP ніколи не виконуватиме спроби видобути декілька потоків даних з файлів +\&\fB.lzma\fP або необроблених потоків даних, але використання цього параметра +все одно наказує \fBxz\fP ігнорувати можливі кінцеві дані після файла \fB.lzma\fP +або необробленого потоку даних. +.IP "" +Цей параметр нічого не змінює, якщо режимом дій не є \fB\-\-decompress\fP або +\fB\-\-test\fP. +.IP "" +З \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP неявно визначає \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Вимкнути створення розріджених файлів. Типово, якщо видобування виконується +до звичайного файла, \fBxz\fP намагається створити розріджений файл, якщо +розпаковані дані містять довгі послідовності двійкових нулів. Це також +працює, коли виконується запис до стандартного виведення, доки стандартне +виведення з'єднано зі звичайним файлом і виконуються певні додаткові умови, +які убезпечують роботу. Створення розріджених файлів може заощадити місце на +диску і пришвидшити розпаковування шляхом зменшення кількості дій введення +та виведення даних на диску. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +При стисканні використати суфікс \fI.suf\fP для файлів призначення, замість +суфікса \fB.xz\fP або \fB.lzma\fP. Якщо записування виконується не до стандартного +виведення і початковий файл вже має суфікс назви \fI.suf\fP, буде показано +попередження, а файл буде пропущено під час обробки. +.IP "" +При розпаковуванні розпізнавати файли із суфіксом назви \fI.suf\fP, окрім +файлів із суфіксами назв \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP або \fB.lz\fP. Якщо +початковий файл мав суфікс назви \fI.suf\fP, для отримання назви файла +призначення цей суфікс буде вилучено. +.IP "" +При стисканні або розпакуванні необроблених потоків даних (\fB\-\-format=raw\fP) +суфікс слід вказувати завжди, якщо запис не виконується до стандартного +виведення, оскільки типового суфікса назви для необроблених потоків даних не +передбачено. +.TP +\fB\-\-files\fP[\fB=\fP\fIфайл\fP] +Прочитати назви файлів для обробки з файла \fIфайл\fP; якщо \fIfile\fP не вказано, +назви файлів буде прочитано зі стандартного потоку вхідних даних. Назви +файлів має бути відокремлено символом нового рядка. Символ дефіса (\fB\-\fP) +буде оброблено як звичайну назву файла; він не позначатиме стандартного +джерела вхідних даних. Якщо також буде вказано назви файлів у аргументах +рядка команди, файли з цими назвами буде оброблено до обробки файлів, назви +яких було прочитано з файла \fIфайл\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIфайл\fP] +Те саме, що і \fB\-\-files\fP[\fB=\fP\fIфайл\fP], але файли у списку має бути +відокремлено нульовим символом. +. +.SS "Параметри базового формату файлів та стискання" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fIформат\fP +Вказати файл \fIформат\fP для стискання або розпакування: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Типовий варіант. При стисканні \fBauto\fP є еквівалентом \fBxz\fP. При +розпакуванні формат файла вхідних даних буде виявлено автоматично. Зауважте, +що автоматичне виявлення необроблених потоків даних (створених за допомогою +\fB\-\-format=raw\fP) неможливе. +.TP +\fBxz\fP +Стиснути до формату \fB.xz\fP або приймати лише файли \fB.xz\fP при +розпаковуванні. +.TP +\fBlzma\fP, \fBalone\fP +Стиснути дані до застарілого формату файлів \fB.lzma\fP або приймати лише файли +\&\fB.lzma\fP при розпаковуванні. Альтернативну назву \fBalone\fP може бути +використано для зворотної сумісності із LZMA Utils. +.TP +\fBlzip\fP +Приймати лише файли \fB.lz\fP при розпакуванні. Підтримки стискання не +передбачено. +.IP "" +Передбачено підтримку версії формату \fB.lz\fP 0 та 1. Файли версії 0 було +створено \fBlzip\fP 1.3 та старішими версіями. Такі файли не є поширеними, але +їх можна знайти у файлових архівах, оскільки певну незначну кількість +пакунків із початковим кодом було випущено у цьому форматі. Також можуть +існувати особисті файли у цьому форматі. Підтримку розпаковування для +формату версії 0 було вилучено у \fBlzip\fP 1.18. Версія \fBlzip\fP 1.4 і новіші +версії створюють файли у форматі версії 1. +.TP +\fBraw\fP +Стиснути або розпакувати потік необроблених даних (лез заголовків). Цей +параметр призначено лише для досвідчених користувачів. Для розпаковування +необроблених потоків даних слід користуватися параметром \fB\-\-format=raw\fP і +явно вказати ланцюжок фільтрування, який за звичайних умов мало б бути +збережено у заголовках контейнера. +.RE +.TP +\fB\-C\fP \fIперевірка\fP, \fB\-\-check=\fP\fIперевірка\fP +Вказати тип перевірки цілісності. Контрольну суму буде обчислено на основі +нестиснених даних і збережено у файлі \fB.xz\fP. Цей параметр працюватиме, лише +якщо дані стиснено до файла у форматі \fB.xz\fP; для формату файлів \fB.lzma\fP +підтримки перевірки цілісності не передбачено. Перевірку контрольної суми +(якщо така є) буде виконано під час розпаковування файла \fB.xz\fP. +.IP "" +Підтримувані типи \fIперевірок\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Не обчислювати контрольну суму взагалі. Зазвичай, не варто цього робити. Цим +варіантом слід скористатися, якщо цілісність даних буде перевірено в інший +спосіб. +.TP +\fBcrc32\fP +Обчислити CRC32 за допомогою полінома з IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Обчислити CRC64 за допомогою полінома з ECMA\-182. Це типовий варіант, +оскільки він дещо кращий за CRC32 при виявленні пошкоджених файлів, а +різниця у швидкості є незрачною. +.TP +\fBsha256\fP +Обчислити SHA\-256. Цей варіант дещо повільніший за CRC32 і CRC64. +.RE +.IP "" +Цілісність заголовків \fB.xz\fP завжди перевіряють за допомогою CRC32. Таку +перевірку не можна змінити або скасувати. +.TP +\fB\-\-ignore\-check\fP +Не перевіряти цілісність стиснених даних при розпаковуванні. Значення CRC32 +у заголовках \fB.xz\fP буде у звичайний спосіб перевірено попри цей параметр. +.IP "" +\fBНе користуйтеся цим параметром, якщо ви не усвідомлюєте наслідків ваших дій.\fP Можливі причини скористатися цим параметром: +.RS +.IP \(bu 3 +Спроба отримання даних з пошкодженого файла .xz. +.IP \(bu 3 +Пришвидшення розпакування. Це, здебільшого, стосується SHA\-256 або файлів із +надзвичайно високим рівнем пакування. Не рекомендуємо користуватися цим +параметром з цією метою, якщо цілісність файлів не буде перевірено у якийсь +інший спосіб. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Вибрати рівень стискання. Типовим є \fB\-6\fP. Якщо буде вказано декілька рівнів +стискання, програма використає останній вказаний. Якщо вже було вказано +нетиповий ланцюжок фільтрів, встановлення рівня стискання призведе до +нехтування цим нетиповим ланцюжком фільтрів. +.IP "" +Різниця між рівнями є суттєвішою, ніж у \fBgzip\fP(1) і \fBbzip2\fP(1). Вибрані +параметри стискання визначають вимоги до пам'яті під час розпаковування, +отже використання надто високого рівня стискання може призвести до проблем +під час розпаковування файла на застарілих комп'ютерах із невеликим обсягом +оперативної пам'яті. Зокрема, \fBне варто використовувати \-9 для усього\fP, як +це часто буває для \fBgzip\fP(1) і \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Це дещо швидші набори налаштувань. \fB\-0\fP іноді є швидшим за \fBgzip \-9\fP, +забезпечуючи набагато більший коефіцієнт стискання. Вищі рівні часто мають +швидкість, яку можна порівняти з \fBbzip2\fP(1) із подібним або кращим +коефіцієнтом стискання, хоча результати значно залежать від типу даних, які +стискають. +.TP +\fB\-4\fP ... \fB\-6\fP +Стискання від доброго до дуже доброго рівня із одночасним підтриманням +помірного рівня споживання пам'яті засобом розпаковування, навіть для +застарілих системи. Типовим є значення \fB\-6\fP, яке є добрим варіантом для +поширення файлів, які мають бути придатними до розпаковування навіть у +системах із лише 16\ МіБ оперативної пам'яті. (Також можна розглянути +варіанти \fB\-5e\fP і \fB\-6e\fP. Див. \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Ці варіанти подібні до \fB\-6\fP, але із вищими вимогами щодо пам'яті для +стискання і розпаковування. Можуть бути корисними лише для стискання файлів +з розміром, що перевищує 8\ МіБ, 16\ МіБ та 32\ МіБ, відповідно. +.RE +.IP "" +На однаковому обладнанні швидкість розпакування є приблизно сталою кількістю +байтів стиснених даних за секунду. Іншими словами, чим кращим є стискання, +тим швидшим буде, зазвичай, розпаковування. Це також означає, що об'єм +розпакованих виведених даних, які видає програма за секунду, може коливатися +у широкому діапазоні. +.IP "" +У наведеній нижче таблиці підсумовано можливості шаблонів: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Шаблон;DictSize;CompCPU;CompMem;DecMem +\-0;256 КіБ;0;3 МіБ;1 МіБ +\-1;1 МіБ;1;9 МіБ;2 МіБ +\-2;2 МіБ;2;17 МіБ;3 МіБ +\-3;4 МіБ;3;32 МіБ;5 МіБ +\-4;4 МіБ;4;48 МіБ;5 МіБ +\-5;8 МіБ;5;94 МіБ;9 МіБ +\-6;8 МіБ;6;94 МіБ;9 МіБ +\-7;16 МіБ;6;186 МіБ;17 МіБ +\-8;32 МіБ;6;370 МіБ;33 МіБ +\-9;64 МіБ;6;674 МіБ;65 МіБ +.TE +.RE +.RE +.IP "" +Описи стовпчиків: +.RS +.IP \(bu 3 +DictSize є розміром словника LZMA2. Використання словника, розмір якого +перевищує розмір нестисненого файла, — проста витрата пам'яті. Ось чому не +варто використовувати шаблони \fB\-7\fP ... \fB\-9\fP, якщо у них немає реальної +потреби. Для \fB\-6\fP та нижчих рівнів об'єм витраченої пам'яті, зазвичай, +такий низький, що цей фактор ні на що не впливає. +.IP \(bu 3 +CompCPU є спрощеним представленням параметрів LZMA2, які впливають на +швидкість стискання. Розмір словника також впливає на швидкість, тому, хоча +значення CompCPU є однаковим для рівнів \fB\-6\fP ... \fB\-9\fP, обробка на вищих +рівнях все одно є трошки повільнішою. Що отримати повільніше і, ймовірно, +краще стискання, див. \fB\-\-extreme\fP. +.IP \(bu 3 +CompMem містить вимоги до пам'яті засобу стискання у однопотоковому +режимі. Значення можуть бути дещо різними для різних версій \fBxz\fP. +.IP \(bu 3 +У DecMem містяться вимоги до пам'яті при розпаковуванні. Тобто параметри +засобу стискання визначають вимоги до пам'яті при розпаковуванні. Точний +об'єм пам'яті, яка потрібна для розпаковування, дещо перевищує розмір +словника LZMA2, але значення у таблиці було округлено до наступного цілого +значення МіБ. +.RE +.IP "" +Вимоги до пам'яті у багатопотоковому режимі є значно вищими, ніж у +однопотоковому. З типовим значенням \fB\-\-block\-size\fP для кожного потоку треба +3*3*DictSize плюс CompMem або DecMem. Наприклад, для чотирьох потоків з +шаблоном \fB\-6\fP потрібно 660\(en670\ МіБ пам'яті. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Використати повільніший варіант вибраного рівня стискання (\fB\-0\fP ... \fB\-9\fP) +у сподіванні отримати трохи кращий коефіцієнт стискання, але, якщо не +поталанить, можна його і погіршити. Не впливає на використання пам'яті при +розпаковуванні, але використання пам'яті при стисканні дещо збільшиться на +рівнях \fB\-0\fP ... \fB\-3\fP. +.IP "" +Оскільки існує два набори налаштувань із розмірами словників 4\ МіБ та 8\ МіБ, у наборах \fB\-3e\fP і \fB\-5e\fP використано трошки швидші параметри (нижче +CompCPU), ніж у наборах \fB\-4e\fP і \fB\-6e\fP, відповідно. Тому двох однакових +наборів у списку немає. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Шаблон;DictSize;CompCPU;CompMem;DecMem +\-0e;256 КіБ;8;4 МіБ;1 МіБ +\-1e;1 МіБ;8;13 МіБ;2 МіБ +\-2e;2 МіБ;8;25 МіБ;3 МіБ +\-3e;4 МіБ;7;48 МіБ;5 МіБ +\-4e;4 МіБ;8;48 МіБ;5 МіБ +\-5e;8 МіБ;7;94 МіБ;9 МіБ +\-6e;8 МіБ;8;94 МіБ;9 МіБ +\-7e;16 МіБ;8;186 МіБ;17 МіБ +\-8e;32 МіБ;8;370 МіБ;33 МіБ +\-9e;64 МіБ;8;674 МіБ;65 МіБ +.TE +.RE +.RE +.IP "" +Наприклад, передбачено загалом чотири набори налаштувань із використанням +словника у 8\ МіБ, порядок яких від найшвидшого до найповільнішого є таким: +\fB\-5\fP, \fB\-6\fP, \fB\-5e\fP і \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Це дещо оманливі альтернативні варіанти для \fB\-0\fP і \fB\-9\fP, +відповідно. Реалізовано лише для забезпечення зворотної сумісності із LZMA +Utils. Намагайтеся не користуватися цими варіантами параметрів. +.TP +\fB\-\-block\-size=\fP\fIрозмір\fP +При стисканні до формату \fB.xz\fP поділити вхідні дані на блоки у \fIрозмір\fP +байтів. Ці блоки буде стиснуто незалежно один від одного, що допоможе у +багатопотоковій обробці і зробить можливим обмежене розпакування для доступу +до будь\-яких даних. Цим параметром слід типово користуватися для +перевизначення типового розміру блоку у багатопотоковому режимі обробки, але +цим параметром можна також скористатися в однопотоковому режимі обробки. +.IP "" +У багатопотоковому режимі для кожного потоку буде отримано для буферів +вхідних і вихідних даних майже утричі більше за \fIрозмір\fP байтів. Типовий +\fIрозмір\fP утричі більший за розмір словника LZMA2 або дорівнює 1 МіБ, буде +вибрано більше значення. Типовим добрим значенням буде значення, яке у +2\(en4 рази перевищує розмір словника LZMA2 або дорівнює принаймні 1 +МіБ. Використання значення \fIрозмір\fP, яке є меншим за розмір словника LZMA2, +має наслідком марну витрату оперативної пам'яті, оскільки його використання +призводить до того, що буфер словника LZMA2 ніколи не буде використано +повністю. У багатопотоковому режимі розміри блоків зберігатимуться у +заголовках блоків. Ці дані потрібні для багатопотокового розпаковування. +.IP "" +У однопотоковому режимі поділ на блоки типово не +виконуватиметься. Встановлення значення для цього параметра не впливатиме на +використання пам'яті. У заголовках блоків не зберігатимуться дані щодо +розміру, отже файли, які створено в однопотоковому режимі не будуть +ідентичними до файлів, які створено у багатопотоковому режимі. Те, що у +заголовках блоків не зберігатимуться дані щодо розміру також означає, що +\fBxz\fP не зможе розпаковувати такі файли у багатопотоковому режимі. +.TP +\fB\-\-block\-list=\fP\fIзаписи\fP +При стисканні у форматі \fB.xz\fP починати новий блок із необов'язковим +ланцюжком фільтрів після вказаної кількості інтервалів нестиснених даних. +.IP "" +\fIзаписи\fP є списком відокремлених комами значень. Кожен запис складається з +необов'язкового номера ланцюжка фільтрів від 0 до 9, після якого йде +двокрапка (\fB:\fP) і необхідний розмір нестиснутих даних. Пропущення запису +(дві або більше послідовних ком) є скороченим варіантом визначення +використання розміру та фільтрів попереднього запису. +.IP "" +Якщо файл вхідних даних є більшим за розміром за суму розмірів \fIзаписів\fP, +останнє значення у \fIрозмірах\fP буде повторено до кінця файла. Особливе +значення \fB0\fP може бути використано як останній розмір, щоб позначити, що +решту файла має бути закодовано як єдиний блок. +.IP "" +Альтернативний ланцюжок фільтрів для кожного блоку можна вказати в поєднанні +з параметрами \fB\-\-filters1=\fP\fIфільтри\fP \&...\& \fB\-\-filters9=\fP\fIфільтри\fP. Ці +параметри визначають ланцюжки фільтрів з ідентифікатором у діапазоні +1\(en9. Ланцюжок фільтрів 0 можна використовувати для посилання на типовий +ланцюжок фільтрів — це те саме, що не вказувати ланцюжок +фільтрів. Ідентифікатор ланцюжка фільтрів можна використовувати перед +нестисненим розміром, після якого йде двокрапка (\fB:\fP). Наприклад, якщо +вказати \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP, блоки будуть +створені так: +.RS +.IP \(bu 3 +Ланцюжок фільтрів задано \fB\-\-filters1\fP із вхідними даними у 2 МіБ +.IP \(bu 3 +Ланцюжок фільтрів задано \fB\-\-filters3\fP із вхідними даними у 2 МіБ +.IP \(bu 3 +Ланцюжок фільтрів задано \fB\-\-filters2\fP із вхідними даними у 4 МіБ +.IP \(bu 3 +Ланцюжок фільтрів задано \fB\-\-filters2\fP із вхідними даними у 4 МіБ +.IP \(bu 3 +Типовий ланцюжок даних і вхідні дані у 2 МіБ +.IP \(bu 3 +Типовий ланцюжок фільтрів та вхідні дані у 4 МіБ для кожного блоку до кінця +вхідних даних. +.RE +.IP "" +Якщо вказати розмір, який перевищує розмір блоку кодувальника (або типове +значення у режимі із потоками обробки, або значення, яке встановлено за +допомогою \fB\-\-block\-size=\fP\fIрозмір\fP), засіб кодування створить додаткові +блоки, зберігаючи межі, які вказано у \fIзаписах\fP. Наприклад, якщо вказати +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP, а файл +вхідних даних має розмір 80 МіБ, буде отримано такі 11 блоків: 5, 10, 8, 10, +2, 10, 10, 4, 10, 10 і 1 МіБ. +.IP "" +У багатопотоковому режимі розмір блоків буде збережено у заголовках +блоків. Програма не зберігатиме ці дані у однопотоковому режимі, отже +закодований результат не буде ідентичним до отриманого у багатопотоковому +режимі. +.TP +\fB\-\-flush\-timeout=\fP\fIчас_очікування\fP +При стискання, якщо з моменту попереднього витирання мине понад +\fIчас_очікування\fP мілісекунд (додатне ціле значення) і читання додаткових +даних буде заблоковано, усі вхідні дані у черзі обробки буде витерто з +кодувальника і зроблено доступним у потоці вихідних даних. Це може бути +корисним, якщо \fBxz\fP використовують для стискання даних, які передають +потоком мережею. Невеликі значення аргументу \fIчас_очікування\fP зроблять дані +доступними на боці отримання із малою затримкою, а великі значення аргумент +\fIчас_очікування\fP уможливлять кращий коефіцієнт стискання. +.IP "" +Типово, цю можливість вимкнено. Якщо цей параметр вказано декілька разів, +буде використано лише останнє вказане значення. Особливим значенням +аргументу \fIчас_очікування\fP, рівним \fB0\fP, можна скористатися для вимикання +цієї можливості явним чином. +.IP "" +Ця можливість недоступна у системах, які не є системами POSIX. +.IP "" +.\" FIXME +\fBЦя можливість усе ще є експериментальною.\fP У поточній версії, \fBxz\fP не +може розпаковувати потік даних у режимі реального часу через те, у який +спосіб \fBxz\fP виконує буферизацію. +.TP +\fB\-\-no\-sync\fP +Не синхронізувати файл призначення та його каталог із пристроєм зберігання +даних до вилучення початкового файла. Це може підвищити швидкодію, якщо +виконується стискання або розпаковування багатьох малих файлів. Втім, якщо +система аварійно завершує роботу невдовзі після вилучення, можлива ситуація, +коли файл призначення не буде записано на пристрій зберігання даних, а дію з +вилучення буде записано. У цьому випадку буде знищено дані як початкового +файла, так і файла призначення. +.IP "" +Цей параметр матиме хоч який вплив, лише якщо \fBxz\fP вилучає початковий +файл. В інших випадках синхронізація не виконується. +.IP "" +Синхронізацію і \fB\-\-no\-sync\fP було додано у версії \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIобмеження\fP +Встановити обмеження на використання пам'яті при стисканні. Якщо цей +параметр вказано декілька разів, враховано буде лише останнє вказане +значення. +.IP "" +Якщо параметри стискання перевищують \fIобмеження\fP, \fBxz\fP спробує скоригувати +параметри так, щоб обмеження не було перевищено, і покаже повідомлення про +те, що було виконано автоматичне коригування. Коригування буде виконано у +такому порядку: зменшення кількості потоків обробки, перемикання у +однопотоковий режим, якщо хоч в одному потоці багатопотокового режиму буде +перевищено \fIобмеження\fP, і нарешті, зменшення розміру словника LZMA2. +.IP "" +При стисканні з використанням \fB\-\-format=raw\fP, або якщо було вказано +\fB\-\-no\-adjust\fP, може бути зменшена лише кількість потоків обробки, оскільки +це може бути зроблено без впливу на стиснені виведені дані. +.IP "" +Якщо \fIобмеження\fP не може бути виконано за допомогою коригувань, які описано +вище, буде показано повідомлення про помилку, а \fBxz\fP завершить роботу зі +станом виходу 1. +.IP "" +Аргумент \fIобмеження\fP можна вказати у декілька способів: +.RS +.IP \(bu 3 +Значенням \fIобмеження\fP може бути додатне ціле значення у байтах. Можна +скористатися цілочисельним суфіксом, подібним до \fBMiB\fP. Приклад: +\fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +Аргумент \fIобмеження\fP може бути задано у відсотках від загальної фізичної +пам'яті системи (RAM). Це може бути корисним особливо при встановленні +змінної середовища \fBXZ_DEFAULTS\fP у скрипті ініціалізації системи, який є +спільним для різних комп'ютерів. У такий спосіб можна вказати вищий рівень +обмеження для систем із більшим об'ємом пам'яті. Приклад: +\fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +Аргументу \fIобмеження\fP може бути повернуто типове значення встановленням +значення \fB0\fP. У поточній версії це еквівалентно до встановлення значення +аргументу \fIобмеження\fP \fBmax\fP (без обмеження на використання пам'яті). +.RE +.IP "" +Для 32\-бітової версії \fBxz\fP передбачено особливий випадок: якщо \fIобмеження\fP +перевищуватиме \fB4020\ МіБ\fP, для \fIобмеження\fP буде встановлено значення +\fB4020\ MiB\fP. На MIPS32 замість цього буде використано \fB2000\ MiB\fP. (Це не +стосується значень \fB0\fP і \fBmax\fP. Подібної можливості для розпаковування не +існує.) Це може бути корисним, коли 32\-бітовий виконуваний файл має доступ +до простору адрес у 4\ ГіБ (2 GiB на MIPS32), хоча, сподіваємося, не +зашкодить і в інших випадках. +.IP "" +Див. також розділ \fBВикористання пам'яті\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIобмеження\fP +Встановити обмеження пам'яті на розпаковування. це також вплине на режим +\fB\-\-list\fP. Якщо дія є неможливою без перевищення \fIобмеження\fP, \fBxz\fP покаже +повідомлення про помилку і розпаковування файла не +відбудеться. Див. \fB\-\-memlimit\-compress=\fP\fIобмеження\fP, щоб дізнатися більше +про те, як можна задати \fIобмеження\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIобмеження\fP +Встановити обмеження використання пам'яті для багатопотокового +розпаковування. Це може вплинути лише на кількість потоків обробки; це +ніколи не призводитиме до відмови \fBxz\fP у розпаковуванні файла. Якщо +\fIобмеження є надто низьким\fP, щоб уможливити будь\-яку багатопотокову +обробку, \fIобмеження\fP буде проігноровано, і \fBxz\fP продовжить обробку в +однопотоковому режимі. Зауважте, що якщо використано також +\fB\-\-memlimit\-decompress\fP, цей параметр буде застосовано до обох режимів, +однопотокового та багатопотокового, а отже, задіяне \fIобмеження\fP для +багатопотокового режиму ніколи не перевищуватиме обмеження, яке встановлено +за допомогою \fB\-\-memlimit\-decompress\fP. +.IP "" +На відміну від інших параметрів обмеження використання пам'яті, +\fB\-\-memlimit\-mt\-decompress=\fP\fIобмеження\fP містить специфічне для системи +типове значення \fIобмеження\fP. Можна скористатися \fBxz \-\-info\-memory\fP для +перегляду поточного значення. +.IP "" +Цей параметр і його типове значення існують, оскільки без будь\-яких обмежень +засіб розпакування зі підтримкою потокової обробки міг би намагатися +отримати величезний об'єм пам'яті для деяких файлів вхідних даних. Якщо +типове \fIобмеження\fP є надто низьким для вашої системи, не вагайтеся і +збільшуйте \fIобмеження\fP, але ніколи не встановлюйте для нього значення, яке +є більшим за придатний до користування об'єм оперативної пам'яті, оскільки +за відповідних файлів вхідних даних \fBxz\fP спробує скористатися цим об'ємом +пам'яті, навіть із низькою кількістю потоків обробки. Вичерпання об'єму +оперативної пам'яті або використання резервної пам'яті на диску не покращить +швидкодію системи під час розпаковування. +.IP "" +Див. \fB\-\-memlimit\-compress=\fP\fIобмеження\fP, щоб ознайомитися із можливими +способами визначення \fIобмеження\fP. Встановлення для \fIобмеження\fP значення +\fB0\fP відновлює типове специфічне для системи значення \fIобмеження\fP. +.TP +\fB\-M\fP \fIобмеження\fP, \fB\-\-memlimit=\fP\fIобмеження\fP, \fB\-\-memory=\fP\fIобмеження\fP +Є еквівалентом визначення \fB\-\-memlimit\-compress=\fP\fIобмеження\fP +\fB\-\-memlimit\-decompress=\fP\fIобмеження\fP +\fB\-\-memlimit\-mt\-decompress=\fP\fIобмеження\fP. +.TP +\fB\-\-no\-adjust\fP +Показати повідомлення про помилку і завершити роботу, якщо не вдасться +виконати умови щодо обмеження використання пам'яті без коригування +параметрів, які впливають на стиснених виведених даних. Тобто це забороняє +\fBxz\fP перемикати кодувальник з багатопотокового режиму на однопотоковий +режим і зменшувати розмір словника LZMA2. Навіть якщо використано цей +параметр, кількість потоків може бути зменшено для виконання обмеження на +використання пам'яті, оскільки це не вплине на результати стискання. +.IP "" +Автоматичне коригування завжди буде вимкнено при створенні потоків +необроблених даних (\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fIпотоки\fP, \fB\-\-threads=\fP\fIпотоки\fP +Вказати кількість потоків обробки, якими слід скористатися. Встановлення для +аргументу \fIпотоки\fP особливого значення \fB0\fP наказує \fBxz\fP використати не +більше потоків обробки, ніж передбачено підтримку у процесорах +системи. Справжня кількість потоків може бути меншою за значення \fIпотоки\fP, +якщо файл вхідних даних не є достатньо великим для поділу на потоки обробки +при заданих параметрах або якщо використання додаткових потоків призведе до +перевищення обмеження на використання пам'яті. +.IP "" +Засоби стискання в однопотоковому та багатопотоковому режимі дають різні +результати. Однопотоковий засіб стискання дасть найменший розмір файла, але +лише результати роботи багатопотокового засобу стискання може бути +розпаковано з використанням декількох потоків. Встановлення для аргументу +\fIпотоки\fP значення \fB1\fP призведе до використання однопотокового +режиму. Встановлення для аргументу \fIпотоки\fP будь\-якого іншого значення, +включно з \fB0\fP, призведе до використання багатопотокового засобу стискання, +навіть якщо у системі передбачено підтримки лише одного апаратного потоку +обробки даних. (Версія \fBxz\fP 5.2.x у цьому випадку використовувала +однопотоковий режим.) +.IP "" +Щоб скористатися багатопотоковим режимом із лише одним потоком обробки, +встановіть для аргументу \fIпотоки\fP значення \fB+1\fP. Префікс \fB+\fP не впливає +на значення, окрім \fB1\fP. Обмеження на використання пам'яті можуть перемкнути +\fBxz\fP в однопотоковий режим, якщо не використано параметр +\fB\-\-no\-adjust\fP. Підтримку \fB+\fP prefix було додано у версії \fBxz\fP 5.4.0. +.IP "" +Якщо було вказано автоматичне визначення кількості потоків і не вказано +обмеження на використання пам'яті, буде використано специфічне для системи +типове м'яке обмеження для можливого обмеження кількості потоків обробки. Це +обмеження є м'яким у сенсі того, що його буде проігноровано, якщо кількість +потоків зрівняється з одиницею, а отже, м'яке обмеження ніколи не +запобігатиму у \fBxz\fP стисканню або розпаковуванню. Це типове м'яке обмеження +не перемкне \fBxz\fP з багатопотокового режиму на однопотоковий режим. Активні +обмеження можна переглянути за допомогою команди \fBxz \-\-info\-memory\fP. +.IP "" +У поточній версії єдиним способом поділу на потоки обробки є поділ вхідних +даних на блоки і стискання цих блоків незалежно один від одного. Типовий +розмір блоку залежить від рівня стискання. Його може бути перевизначено за +допомогою параметра \fB\-\-block\-size=\fP\fIрозмір\fP. +.IP "" +Розпакування з потоками обробки працює лише для файлів, які містять декілька +блоків із даними щодо розміру у заголовках блоків. Цю умову задовольняють +усі достатньо великі файли, які стиснено у багатопотоковому режимі, але не +задовольняють будь\-які файли, які було стиснуто у однопотоковому режимі, +навіть якщо було використано параметр \fB\-\-block\-size=\fP\fIрозмір\fP. +.IP "" +Типовим значенням для \fIпотоків\fP є \fB0\fP. У \fBxz\fP 5.4.x та старіших версіях +типовим значенням є \fB1\fP. +. +.SS "Нетипові ланцюжки фільтрів засобу стискання" +Нетиповий ланцюжок фільтрування уможливлює докладне визначення параметрів +стискання замість використання параметрів, які пов'язано із наперед +визначеними рівнями стискання. Якщо вказано нетиповий ланцюжок фільтрів, +параметри рівнів стискання (\fB\-0\fP \&...\& \fB\-9\fP і \fB\-\-extreme\fP), які +передують їм у рядку команди, буде знехтувано. Якщо параметр рівня стискання +вказано після одного або декількох параметрів нетипового ланцюжка фільтрів, +буде використано рівень стискання, а попередніми параметрами ланцюжка +фільтрування буде знехтувано. +.PP +Ланцюжок фільтрів можна порівняти із конвеєром у командному рядку. При +стисканні нестиснені вхідні дані потрапляють до першого фільтра, виведені +ним дані йдуть до наступного фільтра (якщо такий є). Виведені останнім +фільтром дані буде записано до стисненого файла. Максимальна кількість +фільтрів у ланцюжку дорівнює чотирьом, але у типовому ланцюжку фільтрів +використовують один або два фільтри. +.PP +У багатьох фільтрів є обмеження на місце перебування у ланцюжку фільтрів: +деякі фільтри можуть працювати, лише якщо вони є останніми у ланцюжку, +деякі, лише якщо не останніми, а деякі працюють у будь\-якій позиції +ланцюжка. Залежно від фільтра, це обмеження є наслідком структури фільтра +або існує для запобігання проблем із захистом. +.PP +Нетиповий ланцюжок фільтрів можна вказати двома різними способами. Параметри +\fB\-\-filters=\fP\fIфільтри\fP і \fB\-\-filters1=\fP\fIфільтри\fP \&...\& +\fB\-\-filters9=\fP\fIфільтри\fP надають змогу вказати цілий ланцюжок фільтрів в +одному варіанті з використанням синтаксису рядків фільтрів liblzma. Крім +того, ланцюжок фільтрів можна вказати за допомогою одного або кількох +окремих параметрів фільтрування у тому порядку, в якому їх слід використати +у ланцюжку фільтрів. Тобто порядок окремих параметрів фільтра є важливим! +Під час декодування необроблених потоків (\fB\-\-format=raw\fP) ланцюжок фільтрів +має бути вказано у тому ж порядку, що й під час стиснення. Будь\-який окремий +фільтр або параметри попереднього налаштування, вказані перед параметром +повного ланцюжка (\fB\-\-filters=\fP\fIфільтри\fP), буде відкинуто. Окремі фільтри, +указані після параметра повного ланцюжка, відновлять типовий ланцюжок +фільтрів. +.PP +І параметр повного і параметр окремого фільтра приймають специфічні для +фільтрів \fIпараметри\fP у форматі списку значень, які відокремлено +комами. Зайві коми у \fIпараметрах\fP буде проігноровано. У кожного параметра є +типове значення, отже, вам слід вказати ті параметри, значення яких ви +хочете змінити. +.PP +Щоб переглянути увесь ланцюжок фільтрів та \fIпараметри\fP, скористайтеся +командою \fBxz \-vv\fP (тобто, скористайтеся \fB\-\-verbose\fP двічі). Це працює +також для перегляду параметрів ланцюжка фільтрів, який використано у рівнях +стискання. +.TP +\fB\-\-filters=\fP\fIфільтри\fP +Визначає повний ланцюжок фільтрів або шаблон у форматі одного +параметра. Кожен фільтр можна відокремити від інших пробілами або двома +дефісами (\fB\-\-\fP). Можливо, \fIфільтри\fP доведеться взяти в лапки в командному +рядку оболонки, щоб їх було оброблено як один параметр. Для позначення +\fIпараметрів\fP скористайтеся \fB:\fP або \fB=\fP. До шаблона можна додати префікс +\fB\-\fP і завершити без прапорців або декількома прапорцями. Єдиним +підтримуваним прапорцем є \fBe\fP для застосування тих самих параметрів, що й +\fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIфільтри\fP ... \fB\-\-filters9\fP=\fIфільтри\fP +Вказати до дев'яти додаткових ланцюжків фільтрів, якими можна скористатися +за допомогою \fB\-\-block\-list\fP. +.IP "" +Наприклад, якщо виконується стискання архіву із виконуваними файлами, за +якими йдуть текстові файли, для виконуваної частини може бути використано +ланцюжок фільтрів з фільтром BCJ, а для текстової частини — лише фільтр +LZMA2. +.TP +\fB\-\-filters\-help\fP +Вивести довідкове повідомлення з описом того, як вказати шаблони та нетипові +ланцюжки фільтрів у параметри \fB\-\-filters\fP і \fB\-\-filters1=\fP\fIфільтри\fP +\&...\& \fB\-\-filters9=\fP\fIфільтри\fP і завершити роботу із кодом успіху. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIпараметри\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIпараметри\fP] +.PD +Додати фільтр LZMA1 або LZMA2 до ланцюжка фільтрів. Ці фільтри може бути +використано лише як останній фільтр у ланцюжку. +.IP "" +LZMA1 є застарілим фільтром, підтримку якого збережено майже лише через +використання формату файлів \fB.lzma\fP, у яких передбачено підтримку лише +LZMA1. LZMA2 є оновленою версією LZMA1, у якій виправлено деякі практичні +вади LZMA1. У форматі \fB.xz\fP використано LZMA2 і взагалі не передбачено +підтримки LZMA1. Швидкість стискання та коефіцієнт стискання для LZMA1 і +LZMA2 є практично однаковими. +.IP "" +LZMA1 і LZMA2 спільно використовують той самий набір \fIпараметрів\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIшаблон\fP +Скинути усі \fIпараметри\fP LZMA1 або LZMA2 до параметрів \fIшаблона\fP. Аргумент +\fIшаблон\fP складається з цілого числа, після якого може бути однолітерний +модифікатор шаблона. Ціле число може належати лише діапазону від \fB0\fP до +\fB9\fP, що відповідає параметрам командного рядка \fB\-0\fP \&...\& \fB\-9\fP. Єдиним +підтримуваним модифікатором у поточній версії є \fBe\fP, щоб відповідає +параметру \fB\-\-extreme\fP. Якщо аргумент \fBшаблон\fP не вказано, типові значення +\fIпараметрів\fP LZMA1 або LZMA2 буде взято із шаблона \fB6\fP. +.TP +\fBdict=\fP\fIрозмір\fP +Параметр \fIрозміру\fP словника (буфера журналу) визначає, скільки байтів +нещодавно оброблених нестиснених даних слід зберігати у пам'яті. Алгоритм +намагається знайти повторювані послідовності байтів (відповідники) у +нестиснених даних і замінити їх на посилання на дані зі словника. Чим +більшим є словник, тим вищою є ймовірність відшукати відповідник. Отже, +збільшення \fIрозміру\fP словника, зазвичай, покращує коефіцієнт стискання, але +використання словника, розмір якого перевищу є розмір нестисненого файла є +простоюю витратою пам'яті. +.IP "" +\fIРозмір\fP типового словника складає від 64\ КіБ до 64\ МіБ. Мінімальним є +розмір 4\ КіБ. Максимальним розміром для стискання у поточній версії 1.5\ ГіБ (1536\ МіБ). У засобі розпаковування вже передбачено підтримку словників +на один байт менших за 4\ ГіБ, що є максимальним значенням для форматів +потоків даних LZMA1 і LZMA2. +.IP "" +Аргумент \fIрозміру\fP словника і засіб пошуку відповідників (\fImf\fP) разом +визначають параметри використання пам'яті для кодувальника LZMA1 або +LZMA2. Для розпаковування потрібен такий самий (або більший) \fIрозмір\fP +словника, що і для стискання, отже, використання пам'яті для засобу +розпаковування буде визначено за розміром словника, який було використано +для стискання. У заголовках \fB.xz\fP зберігається \fIрозмір\fP словника або як +2^\fIn\fP, або як 2^\fIn\fP + 2^(\fIn\fP\-1), отже, ці \fIрозміри\fP є дещо пріоритетними +для стискання. Інші \fIрозміри\fP буде отримано округленням при зберіганні у +заголовках \fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Визначає кількість буквальних контекстних бітів. Мінімальною кількістю є 0, +а максимальною — 4. Типовою кількістю є 3. Крім того, сума \fIlc\fP і \fIlp\fP має +не перевищувати 4. +.IP "" +Усі байти, які не може бути закодовано як відповідності, буде закодовано як +літерали. Тобто літерали є просто 8\-бітовими байтами, які буде закодовано по +одному за раз. +.IP "" +При кодуванні літералів роблять припущення, що найвищі біти \fIlc\fP +попереднього нестисненого байта корелюють із наступним байтом. Наприклад, у +типовому тексті англійською за літерою у верхньому регістрі йде літера у +нижньому регістрі, а за літерою у нижньому регістрі, зазвичай, йде інша +літера у нижньому регістрі. У наборі символів US\-ASCII найвищими трьома +бітами є 010 для літер верхнього регістру і 011 для літер нижнього +регістру. Якщо \fIlc\fP дорівнює принаймні 3, при кодуванні літералів можна +отримати перевагу встановлення цієї властивості для нестиснених даних. +.IP "" +Зазвичай, типового значення (3) достатньо. Якщо вам потрібне максимальне +стискання, спробуйте \fBlc=4\fP. Іноді це трохи допомагає, а іноді, робить +стискання гіршим. Якщо стискання стане гіршим, спробуйте також \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Визначає кількість буквальних позиційних бітів. Мінімальною кількістю є 0, а +максимальною — 4. Типовою кількістю є 0. +.IP "" +\fILp\fP впливає на те, яке вирівнювання у нестиснених даних слід припускати +при кодуванні літералів. Див. \fIpb\fP нижче, щоб дізнатися більше про +вирівнювання. +.TP +\fBpb=\fP\fIpb\fP +Визначає кількість позиційних бітів. Мінімальною кількістю є 0, а +максимальною — 4. Типовою кількістю є 2. +.IP "" +\fIPb\fP впливає на те, який тип вирівнювання загалом припускатиметься для +нестиснених даних. Типовим є чотирибайтове вирівнювання (2^\fIpb\fP=2^2=4), +яке, зазвичай, є добрим варіантом, якщо немає кращих припущень. +.IP "" +Якщо вирівнювання є відомим, встановлення відповідним чином \fIpb\fP може трохи +зменшити розмір файла. Наприклад, у текстових файлах із однобайтовим +вирівнюванням (US\-ASCII, ISO\-8859\-*, UTF\-8), встановлення значення \fBpb=0\fP +може трохи поліпшити стискання. Для тексту UTF\-16 добрим варіантом є +\fBpb=1\fP. Якщо вирівнювання є непарним числом, наприклад 3 байти, найкращим +вибором, ймовірно, є \fBpb=0\fP. +.IP "" +Хоча прогнозоване вирівнювання можна скоригувати за допомогою \fIpb\fP і \fIlp\fP, +у LZMA1 і LZMA2 дещо пріоритетним є 16\-байтове вирівнювання. Це, ймовірно, +слід враховувати при компонуванні форматів файлів, які, ймовірно, часто +будуть стискатися з використанням LZMA1 або LZMA2. +.TP +\fBmf=\fP\fImf\fP +Засіб пошуку відповідників має значний вплив на швидкість, використання +пам'яті та коефіцієнт стискання кодувальника. Зазвичай, засоби пошуку +відповідників на основі ланцюжка хешів є швидшими за засоби пошуку +відповідників на основі двійкового дерева. Типовий засіб залежить від +\fIшаблона\fP: для 0 використовують \fBhc3\fP, для 1\(en3 — \fBhc4\fP, а для решти +використовують \fBbt4\fP. +.IP "" +Передбачено підтримку вказаних нижче засобів пошуку відповідників. Наведені +нижче формули обчислення використання пам'яті є грубими наближеннями, які є +найближчими до реальних значень, якщо значенням \fIсловник\fP є степінь двійки. +.RS +.TP +\fBhc3\fP +Ланцюжок хешів із 2\- та 3\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 3 +.br +Використання пам'яті: +.br +\fIdict\fP * 7.5 (якщо \fIdict\fP <= 16 МіБ); +.br +\fIdict\fP * 5.5 + 64 МіБ (якщо \fIdict\fP > 16 МіБ) +.TP +\fBhc4\fP +Ланцюжок хешів із 2\-, 3\- та 4\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 4 +.br +Використання пам'яті: +.br +\fIdict\fP * 7.5 (якщо \fIdict\fP <= 32 МіБ); +.br +\fIdict\fP * 6.5 (якщо \fIdict\fP > 32 МіБ) +.TP +\fBbt2\fP +Двійкове дерево із 2\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 2 +.br +Використання пам'яті: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Двійкове дерево із 2\- і 3\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 3 +.br +Використання пам'яті: +.br +\fIdict\fP * 11.5 (якщо \fIdict\fP <= 16 МіБ); +.br +\fIdict\fP * 9.5 + 64 МіБ (якщо \fIdict\fP > 16 МіБ) +.TP +\fBbt4\fP +Двійкове дерево із 2\-, 3\- і 4\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 4 +.br +Використання пам'яті: +.br +\fIdict\fP * 11.5 (якщо \fIdict\fP <= 32 МіБ); +.br +\fIdict\fP * 10.5 (якщо \fIdict\fP > 32 МіБ) +.RE +.TP +\fBmode=\fP\fIрежим\fP +Параметр \fIрежиму\fP стискання визначає спосіб, який буде використано для +аналізу даних, які створено засобом пошуку відповідників. Підтримуваними +\fIрежимами\fP є \fBfast\fP (швидкий) і \fBnormal\fP (нормальний). Типовим є режим +\fBfast\fP для \fIшаблонів\fP 0\(en3 і режим \fBnormal\fP для \fIшаблонів\fP 4\(en9. +.IP "" +Зазвичай, із засобом пошуку відповідників на основі ланцюжка хешів +використовують \fBfast\fP, а із засобом пошуку відповідників на основі +двійкового дерева використовують \fBnormal\fP. Так само налаштовано і +\fIшаблони\fP. +.TP +\fBnice=\fP\fIпріоритетність\fP +Вказати, яка довжина є пріоритетною для відповідності. Щойно буде виявлено +відповідність у принаймні \fIпріоритетність\fP байтів, алгоритм зупинятиме +пошук можливих кращих відповідників. +.IP "" +\fIПріоритетністю\fP може бути число до 2\(en273 байтів. Вищі значення дають +кращий коефіцієнт стискання за рахунок швидкості. Типове значення залежить +від \fIшаблона\fP. +.TP +\fBdepth=\fP\fIглибина\fP +Вказати максимальну глибину пошуку у засобі пошуку відповідності. Типовим є +особливе значення 0, яке наказує засобу стискання визначити прийнятну +\fIглибину\fP на основі \fImf\fP і \fIпріоритетності\fP. +.IP "" +Прийнятним значенням \fIглибини\fP для ланцюжків хешів є 4\(en100 і 16\(en1000 +для двійкових дерев. Використання дуже високих значень для \fIглибини\fP може +зробити кодувальник дуже повільним для деяких файлів. Не встановлюйте +значення \fIглибини\fP, що перевищує 1000, якщо ви не готові перервати +стискання, якщо воно триватиме надто довго. +.RE +.IP "" +При декодуванні необроблених потоків даних (\fB\-\-format=raw\fP), LZMA2 потребує +лише \fIрозміру\fP словника. LZMA1 потребує також \fIlc\fP, \fIlp\fP і \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIпараметри\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIпараметри\fP] +.PD +Додати фільтр гілок/викликів/переходів (branch/call/jump або BCJ) до +ланцюжка фільтрів. Цими фільтрами можна скористатися, лише якщо вони не є +останнім фільтром у ланцюжку фільтрів. +.IP "" +Фільтр BCJ перетворює відносні адреси у машинному коді на їхні абсолютні +відповідники. Це не змінює розміру даних, але підвищує резервування, що може +допомогти LZMA2 створити файл \fB.xz\fP на 0\(en15\ % менше. Фільтри BCJ завжди +є придатними до обернення, тому використання фільтра BCJ до помилкового типу +даних не спричинятиме втрати даних, хоча може дещо погіршити коефіцієнт +стискання. Фільтри BCJ є дуже швидкими і такими, що використовують незначний +об'єм пам'яті. +.IP "" +Ці фільтри BCJ мають відомі проблеми, які пов'язано із рівнем стискання: +.RS +.IP \(bu 3 +У деяких типах файлів, де зберігається виконуваний код, (наприклад, в +об'єктних файлах, статичних бібліотеках та модулях ядра Linux) адреси в +інструкціях заповнено значеннями заповнювача. Ці фільтри BCJ виконуватимуть +перетворення адрес, яке зробить стискання для цих файлів гіршим. +.IP \(bu 3 +Якщо фільтр BCJ застосовано до архіву, може так статися, що він погіршить +коефіцієнт стискання порівняно із варіантом без фільтра BCJ. Наприклад, якщо +є подібні або навіть однакові виконувані файли, фільтрування, ймовірно, +зробить ці файли менш подібними, а отже, зробить стискання гіршим. Вміст +файлів, які не є виконуваними, у тому самому архіві також може вплинути на +результат. На практиці, варто спробувати варіанти з фільтром BCJ і без +нього, щоб визначитися із тим, що буде кращим у кожній ситуації. +.RE +.IP "" +Різні набори інструкцій мають різне вирівнювання: виконуваний файл має бути +вирівняно на кратне до цього значення у вхідних даних, щоб фільтр спрацював. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Фільтр;Вирівнювання;Нотатки +x86;1;32\-бітова або 64\-бітова x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;Найкращим є вирівнювання за +;;4096 байтами +PowerPC;4;Лише зворотний порядок байтів +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Оскільки фільтровані BCJ дані, зазвичай, стискають за допомогою LZMA2, +коефіцієнт стискання можна трохи поліпшити, якщо параметри LZMA2 буде +встановлено так, щоб вони відповідали вирівнюванню вибраного фільтра +BCJ. Приклади: +.RS +.IP \(bu 3 +Фільтр IA\-64 має 16\-байтове вирівнювання, отже \fBpb=4,lp=4,lc=0\fP дасть добрі +результати у поєднанні із LZMA2 (2^4=16). +.IP \(bu 3 +Код RISC\-V має 2\-байтове або 4\-байтове вирівнювання залежно від того, чи +містить файл 16\-бітові стислі інструкції (розширення C). Якщо використано +16\-бітові інструкції, добрі результати дасть \fBpb=2,lp=1,lc=3\fP або +\fBpb=1,lp=1,lc=3\fP. Якщо 16\-бітових інструкцій немає, найкращим варіантом є +\fBpb=2,lp=2,lc=2\fP. Можна скористатися \fBreadelf \-h\fP, щоб перевірити, чи є +"RVC" у рядку "Flags". +.IP \(bu 3 +ARM64 завжди вирівняно на 4 байти, тому найкращим варіантом буде +\fBpb=2,lp=2,lc=2\fP. +.IP \(bu 3 +Фільтр x86 є виключенням. Зазвичай, добрі результати дають типові для LZMA2 +значення (\fBpb=2,lp=0,lc=3\fP), якщо стискають виконувані файли x86. +.RE +.IP "" +У всіх фільтрах BCJ передбачено підтримку тих самих \fIпараметрів\fP: +.RS +.TP +\fBstart=\fP\fIзсув\fP +Встановити початковий \fIзсув\fP, який буде використано при перетворенні між +відносною та абсолютною адресами. Значення \fIзсув\fP має бути кратним до +вирівнювання фільтра (див. таблицю вище). Типовим зсувом є нульовий. На +практиці, типове значення є прийнятним; визначення нетипового значення +\fIзсув\fP майже завжди нічого корисного не дає. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIпараметри\fP] +Додати дельта\-фільтр до ланцюжка фільтрів. Дельта\-фільтр може бути +використано, лише якщо він не є останнім у ланцюжку фільтрів. +.IP "" +У поточній версії передбачено підтримку обчислення лише простої побітової +дельти. Це може бути корисним при стисканні, наприклад, нестиснутих +растрових зображень або нестиснутих звукових даних PCM. Втім, спеціалізовані +алгоритми можуть давати значно кращі результати за дельту + LZMA2. Це +правило особливо стосується звукових даних, які стискає швидше і краще, +наприклад, \fBflac\fP(1). +.IP "" +Підтримувані \fIпараметри\fP: +.RS +.TP +\fBdist=\fP\fIвідстань\fP +Вказати \fIвідстань\fP обчислень різниці у байтах. Значення \fIвідстань\fP має +потрапляти у діапазон 1\(en256. Типовим значенням є 1. +.IP "" +Наприклад, з \fBdist=2\fP та восьмибайтовими вхідними даними A1 B1 A2 B3 A3 B5 +A4 B7, результатом буде A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Інші параметри" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Придушити попередження та сповіщення. Вкажіть цей параметр двічі, щоб +придушити також повідомлення про помилки. Цей параметр не впливає на стан +виходу з програми. Тобто, навіть якщо було придушено попередження, стан +виходу вказуватиме на те, що попередження були. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Докладний режим повідомлень. Якщо стандартне виведення помилок з'єднано із +терміналом, \fBxz\fP показуватиме індикатор поступу. Використання \fB\-\-verbose\fP +двічі призведе до ще докладнішого виведення. +.IP "" +Індикатор поступу показує такі дані: +.RS +.IP \(bu 3 +Частку завершеності буде показано, якщо відомий розмір файла вхідних +даних. Тобто, для каналів даних частку не може бути показано. +.IP \(bu 3 +Об'єм стиснених виведених даних (стискання) або оброблених (розпаковування). +.IP \(bu 3 +Об'єм незапакованих даних (стискання) або виведених даних (розпаковування). +.IP \(bu 3 +Коефіцієнт стискання, який обчислено діленням об'єму оброблених стиснутих +даних на об'єм оброблених нестиснутих даних. +.IP \(bu 3 +Швидкість стискання або розпаковування. Обчислюється як об'єм нестиснутих +даних (стискання) або виведених даних (розпаковування) за секунду. Його буде +показано за декілька секунд з моменту, коли \fBxz\fP почала обробляти файл. +.IP \(bu 3 +Витрачений час у форматі Х:СС або Г:ХХ:СС. +.IP \(bu 3 +Оцінку часу, що лишився, буде показано, лише якщо розмір файла вхідних даних +є відомим, і минуло принаймні декілька секунд з моменту, коли \fBxz\fP почала +обробляти файл. Час буде показано у менш точному форматі, без двокрапок, +наприклад, 2 хв. 30 с. +.RE +.IP "" +Якщо стандартним виведенням помилок не є термінал, \fB\-\-verbose\fP призведе до +того, що \fBxz\fP виведе назву файла, стиснений розмір, нестиснений розмір, +коефіцієнт стискання та, можливо, також швидкість та витрачений час у одному +рядку до стандартного виведення помилок після стискання або розпаковування +файла. Швидкість та витрачений час буде включено, лише якщо дія триває +принаймні декілька секунд. Якщо дію не буде завершено, наприклад, через +втручання користувача, буде також виведено частку виконання, якщо відомий +розмір файла вхідних даних. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Не встановлювати стан виходу 2, навіть якщо було виявлено відповідність +умові, яка варта попередження. Цей параметр не впливає на рівень докладності +повідомлень, отже, слід використати \fB\-\-quiet\fP і \fB\-\-no\-warn\fP, щоб програма +не показувала попереджень і не змінювала стан виходу. +.TP +\fB\-\-robot\fP +Виводити повідомлення у придатному для обробки комп'ютером форматі. Цей +формат призначено для полегшення написання оболонок, які використовуватимуть +\fBxz\fP замість liblzma, що може бути зручним для різноманітних +скриптів. Виведені дані з цим параметром має бути стабільним для усіх +випусків \fBxz\fP. Докладніший опис можна знайти у розділі \fBРЕЖИМ РОБОТА\fP. +.TP +\fB\-\-info\-memory\fP +Вивести у придатному для читання людиною форматі, скільки фізичної пам'яті +(RAM) та скільки потоків процесора є за даними \fBxz\fP у системі, обмеження +для стискання та розпаковування, а потім успішно завершити роботу. +.TP +\fB\-h\fP, \fB\-\-help\fP +Вивести повідомлення про помилку з описом найбільш типових використаних +параметрів і успішно завершити роботу. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Вивести довідкове повідомлення з описом усіх можливостей \fBxz\fP і успішно +завершити роботу +.TP +\fB\-V\fP, \fB\-\-version\fP +Вивести номер версії \fBxz\fP та liblzma у зручному для читання форматі. Щоб +отримати дані, зручні для обробки на комп'ютері, вкажіть \fB\-\-robot\fP до +\fB\-\-version\fP. +. +.SH "РЕЖИМ РОБОТА" +Режим робота активують за допомогою параметра \fB\-\-robot\fP. Він спрощує +обробку виведених \fBxz\fP даних іншими програмами. У поточній версії підтримку +\fB\-\-robot\fP передбачено лише разом із \fB\-\-list\fP, \fB\-\-filters\-help\fP, +\fB\-\-info\-memory\fP і \fB\-\-version\fP. У майбутньому підтримку параметра буде +передбачено для стискання та розпаковування. +. +.SS "Режим списку" +У \fBxz \-\-robot \-\-list\fP використано табуляції для поділу виведених +даних. Першим стовпчиком у кожному рядку є рядок, що вказує на тип +відомостей, які можна знайти у цьому рядку: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Це завжди перший рядок на початку списку файла. Другим стовпчиком у рядку є +назва файла. +.TP +\fBfile\fP +У цьому рядку містяться загальні відомості щодо файла \fB.xz\fP. Цей рядок +завжди виводять після рядка \fBname\fP. +.TP +\fBstream\fP +Цей тип рядка використовують, лише якщо було вказано \fB\-\-verbose\fP. Буде +стільки рядків \fBstream\fP, скільки потоків у файлі \fB.xz\fP. +.TP +\fBblock\fP +Цей тип рядка використовують, лише якщо було вказано \fB\-\-verbose\fP. Буде +стільки рядків \fBblock\fP, скільки блоків у файлі \fB.xz\fP. Рядки \fBblock\fP буде +показано після усіх рядків \fBstream\fP; різні типи рядків не перемежовуються. +.TP +\fBsummary\fP +Цей тип рядків використовують, лише якщо \fB\-\-verbose\fP було вказано +двічі. Цей рядок буде виведено після усіх рядків \fBblock\fP. Подібно до рядка +\fBfile\fP, рядок \fBsummary\fP містить загальні відомості щодо файла \fB.xz\fP. +.TP +\fBtotals\fP +Цей рядок завжди є найостаннішим рядком у виведеному списку. У ньому буде +показано загальні кількості та розміри. +.PP +Стовпчики у рядках \fBфайла\fP: +.PD 0 +.RS +.IP 2. 4 +Кількість потоків у файлі +.IP 3. 4 +Загальна кількість блоків у потоках +.IP 4. 4 +Розмір стисненого файла +.IP 5. 4 +Розмір нестисненого файла +.IP 6. 4 +Коефіцієнт стискання, наприклад, \fB0.123\fP. Якщо коефіцієнт перевищує 9.999, +замість коефіцієнта буде показано дефіси (\fB\-\-\-\fP). +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Список відокремлених комами назв перевірок цілісності. Наведені нижче рядки +використовують для відомих типів перевірок: \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP і +\fBSHA\-256\fP. Для невідомих типів перевірок буде використано \fBUnknown\-\fP\fIN\fP, +де \fIN\fP є ідентифікатором перевірки у форматі десяткового числа (одна або +дві цифри). +.IP 8. 4 +Загальний розмір доповнення потоку у файлі +.RE +.PD +.PP +Стовпчики у рядках \fBstream\fP: +.PD 0 +.RS +.IP 2. 4 +Номер потоку (перший потік має номер 1) +.IP 3. 4 +Кількість блоків у потоці +.IP 4. 4 +Зсув початку стисненого +.IP 5. 4 +Зсув початку нестисненого +.IP 6. 4 +Стиснений розмір (не включає доповнення потоку) +.IP 7. 4 +Нестиснутий розмір +.IP 8. 4 +Рівень стискання +.IP 9. 4 +Назва перевірки цілісності +.IP 10. 4 +Розмір доповнення потоку +.RE +.PD +.PP +Стовпчики у рядках \fBblock\fP: +.PD 0 +.RS +.IP 2. 4 +Номер потоку, що містить цей блок +.IP 3. 4 +Номер блоку відносно початку потоку (перший блок має номер 1) +.IP 4. 4 +Номер блоку відносно початку файла +.IP 5. 4 +Зсув початку стисненого відносно початку файла +.IP 6. 4 +Зсув початку нестисненого відносно початку файла +.IP 7. 4 +Загальний стиснений розмір блоку (включено з заголовками) +.IP 8. 4 +Нестиснутий розмір +.IP 9. 4 +Рівень стискання +.IP 10. 4 +Назва перевірки цілісності +.RE +.PD +.PP +Якщо \fB\-\-verbose\fP було вказано двічі, до рядків \fBblock\fP буде включено +додаткові стовпчики. Ці стовпчики не буде показано, якщо вказано одинарний +параметр \fB\-\-verbose\fP, оскільки отримання цих відомостей потребує багатьох +позиціювань, а ця процедура може бути повільною: +.PD 0 +.RS +.IP 11. 4 +Значення перевірки цілісності у шістнадцятковій формі +.IP 12. 4 +Розмір заголовка блоку +.IP 13. 4 +Прапорці блоку: \fBc\fP вказує, що наявний стиснений розмір, а \fBu\fP вказує, що +наявний нестиснений розмір. Якщо прапорець не встановлено, буде показано +(\fB\-\fP) замість підтримання фіксованого розміру рядка. У майбутньому +наприкінці рядка може бути додано нові прапорці. +.IP 14. 4 +Розмір справжніх стиснених даних у блоці (це включає заголовок блоку, +доповнення блоку та поля перевірок) +.IP 15. 4 +Об'єм пам'яті (у байтах), який потрібен для розпаковування цього блоку за +допомогою цієї версії \fBxz\fP +.IP 16. 4 +Ланцюжок фільтрів. Зауважте, що більшість параметрів, які використано під +час стискання, не є наперед відомим, оскільки у заголовках \fB.xz\fP +зберігаються лише параметри, які потрібні для розпаковування. +.RE +.PD +.PP +Стовпчики у рядках \fBsummary\fP: +.PD 0 +.RS +.IP 2. 4 +Об'єм пам'яті (у байтах), який потрібен для розпаковування цього файла за +допомогою цієї версії \fBxz\fP +.IP 3. 4 +\fByes\fP або \fBno\fP вказує, якщо усі заголовки блоків містять одразу стиснений +розмір та розпакований розмір +.PP +\fIПочинаючи з\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Мінімальна версія \fBxz\fP, яка потрібна для розпаковування файла +.RE +.PD +.PP +Стовпчики рядка \fBtotals\fP: +.PD 0 +.RS +.IP 2. 4 +Кількість потоків +.IP 3. 4 +Кількість блоків +.IP 4. 4 +Стиснутий розмір +.IP 5. 4 +Нестиснутий розмір +.IP 6. 4 +Середній коефіцієнт стискання +.IP 7. 4 +Список відокремлених комами назв перевірок цілісності, результати яких +наявні у файлах +.IP 8. 4 +Розмір доповнення потоку +.IP 9. 4 +Кількість файлів. Наявний тут для зберігання такого самого порядку +стовпчиків, що і у попередніх рядках \fBfile\fP. +.PD +.RE +.PP +Якщо \fB\-\-verbose\fP було вказано двічі, до рядка \fBtotals\fP буде включено +додаткові стовпчики: +.PD 0 +.RS +.IP 10. 4 +Максимальний об'єм пам'яті (у байтах), який потрібен для розпаковування +файлів за допомогою цієї версії \fBxz\fP +.IP 11. 4 +\fByes\fP або \fBno\fP вказує, якщо усі заголовки блоків містять одразу стиснений +розмір та розпакований розмір +.PP +\fIПочинаючи з\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Мінімальна версія \fBxz\fP, яка потрібна для розпаковування файла +.RE +.PD +.PP +У майбутніх версіях може бути додано нові типи рядків і нові стовпчики до +наявних типів рядків, але наявні стовпчики мають лишитися незмінними. +. +.SS "Довідка з фільтрування" +\fBxz \-\-robot \-\-filters\-help\fP виведе список підтримуваних фільтрів у такому +форматі: +.PP +\fIфільтр\fP\fB:\fP\fIпараметр\fP\fB=<\fP\fIзначення\fP\fB>,\fP\fIпараметр\fP\fB=<\fP\fIзначення\fP\fB>\fP... +.TP +\fIфільтр\fP +Назва фільтра +.TP +\fIпараметр\fP +Назва специфічного для фільтра параметра +.TP +\fIзначення\fP +Числові діапазони \fIvalue\fP слід вказати у форматі +\fB<\fP\fIмінімум\fP\fB\-\fP\fIмаксимум\fP\fB>\fP. Варіанти рядка \fIзначення\fP +показано у \fB< >\fP і відокремлено символом \fB|\fP. +.PP +Кожен фільтр буде виведено до окремого рядка. +. +.SS "Дані щодо обмеження пам'яті" +\fBxz \-\-robot \-\-info\-memory\fP виводить один рядок з декількома відокремленими +табуляціями стовпчиками: +.IP 1. 4 +Загальний об'єм фізичної пам'яті (RAM) у байтах. +.IP 2. 4 +Обмеження на використання пам'яті для стискання у байтах +(\fB\-\-memlimit\-compress\fP). Особливе значення \fB0\fP вказує на типові +налаштування, якими для однопотокового режиму є налаштування без обмеження +на використання пам'яті. +.IP 3. 4 +Обмеження на використання пам'яті для розпакування у байтах +(\fB\-\-memlimit\-decompress\fP). Особливе значення \fB0\fP вказує на типові +налаштування, якими для однопотокового режиму є налаштування без обмеження +на використання пам'яті. +.IP 4. 4 +Починаючи з \fBxz\fP 5.3.4alpha: використання пам'яті для багатопотокового +розпаковування у байтах (\fB\-\-memlimit\-mt\-decompress\fP). Ніколи не дорівнює +нулеві, оскільки буде використано специфічне для системи типове значення, +яке показано у стовпчику 5, якщо обмеження не встановлено явним чином. Також +ніколи не перевищуватиме значення у стовпчику 3, навіть якщо було вказано +більше значення за допомогою \fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Починаючи з \fBxz\fP 5.3.4alpha: специфічне для системи типове обмеження на +використання пам'яті, яке використовують для обмеження кількості потоків при +стисканні з автоматичною кількістю потоків (\fB\-\-threads=0\fP) і без визначення +обмеження на використання пам'яті (\fB\-\-memlimit\-compress\fP). Це значення +також використовують як типове значення для \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Починаючи з \fBxz\fP 5.3.4alpha: кількість доступних потоків обробки процесора. +.PP +У майбутньому у виведенні \fBxz \-\-robot \-\-info\-memory\fP може бути більше +стовпчиків, але у виведеному буде не більше за один рядок. +. +.SS Версія +\fBxz \-\-robot \-\-version\fP виведе назву версії \fBxz\fP і liblzma у такому +форматі: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Основна версія. +.TP +\fIYYY\fP +Проміжна версія. Непарні номери буде використано для стабільних +версій. Непарні номери є номерами тестових версій. +.TP +\fIZZZ\fP +Рівень латання для стабільних випусків або просто лічильник для випусків, +які перебувають у розробці. +.TP +\fIS\fP +Стабільність. 0 — alpha, 1 — beta, а 2 означає «стабільна версія». \fIS\fP має +завжди дорівнювати 2, якщо \fIYYY\fP є парним. +.PP +\fIXYYYZZZS\fP є тим самим в обох рядках, якщо \fBxz\fP і liblzma належать до +одного випуску XZ Utils. +.PP +Приклади: 4.999.9beta — це \fB49990091\fP, а 5.0.0 — це \fB50000002\fP. +. +.SH "СТАН ВИХОДУ" +.TP +\fB0\fP +Усе добре. +.TP +\fB1\fP +Сталася помилка. +.TP +\fB2\fP +Сталося щось варте попередження, але справжніх помилок не сталося. +.PP +Зауваження (не попередження або помилки), які виведено до стандартного +виведення помилок, не впливають на стан виходу. +. +.SH СЕРЕДОВИЩЕ +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP обробляє списки відокремлених пробілами параметрів зі змінних +середовища \fBXZ_DEFAULTS\fP і \fBXZ_OPT\fP, перш ніж обробляти параметри з рядка +команди. Зауважте, що буде оброблено лише параметри зі змінних середовища; +усі непараметричні записи буде без повідомлень проігноровано. Обробку буде +виконано за допомогою функції \fBgetopt_long\fP(3), яку також використовують +для аргументів рядка команди. +.PP +\fBПопередження:\fP Встановлюючи ці змінні середовища, ви насправді змінюєте +програми та скрипти, які виконують \fBxz\fP. У більшості випадків без проблем +можна встановлювати обмеження на використання пам'яті, кількість потоків і +параметри стиснення за допомогою змінних середовища. Однак деякі параметри +можуть порушити роботу скриптів. Очевидним прикладом є \fB\-\-help\fP, який +змушує \fBxz\fP показувати текст довідки замість стискання або розпаковування +файла. Менш очевидними є приклади \fB\-\-quiet\fP і \fB\-\-verbose\fP. У багатьох +випадках усе працюватиме добре, якщо увімкнути індикатор поступу за +допомогою \fB\-\-verbose\fP, але у деяких ситуаціях додаткові повідомлення +створюють проблеми. Рівень докладності також впливає на поведінку \fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Специфічні для користувача або загальносистемні типові параметри. Зазвичай, +їх встановлюють у скрипті ініціалізації оболонки для типового вмикання +обмеження на використання пам'яті у \fBxz\fP або встановлення типової кількості +потоків обробки. Окрім скриптів ініціалізації оболонки і подібних особливих +випадків, не слід встановлювати або скасовувати встановлення значення +\fBXZ_DEFAULTS\fP у скриптах. +.TP +\fBXZ_OPT\fP +Цю змінну призначено для передавання параметрів до \fBxz\fP, якщо неможливо +встановити параметри безпосередньо у рядку команди \fBxz\fP. Це трапляється, +якщо \fBxz\fP запущено скриптом або інструментом, наприклад, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Скрипти можуть використовувати \fBXZ_OPT\fP, наприклад, для встановлення +специфічних типових параметрів стискання. Втім, рекомендуємо дозволити +користувачам перевизначати \fBXZ_OPT\fP, якщо це має якісь причини. Наприклад, +у скриптах \fBsh\fP(1) можна скористатися чимось таким: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "СУМІСНІСТЬ ІЗ LZMA UTILS" +Синтаксис рядка команди \fBxz\fP практично є надбудовою щодо \fBlzma\fP, \fBunlzma\fP +і \fBlzcat\fP з LZMA Utils 4.32.x. У більшості випадків можна замінити LZMA +Utils XZ Utils без порушення працездатності наявних скриптів. Втім, існують +певні несумісності, які іноді можуть спричиняти проблеми. +. +.SS "Рівні шаблонів стискання" +Нумерація у шаблонах рівнів стискання у \fBxz\fP не є тотожною до нумерації у +LZMA Utils. Найважливішою відмінністю є прив'язка розмірів словника до +різних шаблонів. Розмір словника грубо рівний використанню пам'яті у засобі +розпаковування. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Рівень;xz;LZMA Utils +\-0;256 КіБ;н/д +\-1;1 МіБ;64 КіБ +\-2;2 МіБ;1 МіБ +\-3;4 МіБ;512 КіБ +\-4;4 МіБ;1 МіБ +\-5;8 МіБ;2 МіБ +\-6;8 МіБ;4 МіБ +\-7;16 МіБ;8 МіБ +\-8;32 МіБ;16 МіБ +\-9;64 МіБ;32 МіБ +.TE +.RE +.PP +Відмінності у розмірах словників також впливають на використання пам'яті +засобом стискання, але є і інші відмінності між LZMA Utils і XZ Utils, які +роблять різницю ще помітнішою: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Рівень;xz;LZMA Utils 4.32.x +\-0;3 МіБ;н/д +\-1;9 МіБ;2 МіБ +\-2;17 МіБ;12 МіБ +\-3;32 МіБ;12 МіБ +\-4;48 МіБ;16 МіБ +\-5;94 МіБ;26 МіБ +\-6;94 МіБ;45 МіБ +\-7;186 МіБ;83 МіБ +\-8;370 МіБ;159 МіБ +\-9;674 МіБ;311 МіБ +.TE +.RE +.PP +Типовим рівнем стискання у LZMA Utils є \fB\-7\fP, а у XZ Utils — \fB\-6\fP, отже, +обидва комплекти програм типово використовують словник розміром у 8 МіБ. +. +.SS "Потокові і непотокові файл .lzma" +Розмір нестисненого файла може бути збережено у заголовку \fB.lzma\fP. LZMA +Utils зберігають дані при стисканні звичайних файлів. Альтернативним +підходом є позначення нестисненого розміру як невідомого і використання +позначки кінця вмісту для позначення місця, де засіб розпаковування має +зупинитися. У LZMA Utils цей спосіб використовують, якщо нестиснений розмір +є невідомим, що трапляється, наприклад, для конвеєрів обробки даних. +.PP +У \fBxz\fP передбачено підтримку розпаковування файлів \fB.lzma\fP з позначкою +кінця вмісту та без неї, але усі файли \fB.lzma\fP, які створено за допомогою +\fBxz\fP, використовують позначку кінця вмісту, а нестиснений розмір у +заголовку \fB.lzma\fP позначають як невідомий. Це може призвести до проблем у +деяких нетипових ситуаціях. Наприклад, розпакувальник \fB.lzma\fP у вбудованому +пристрої може працювати лише з файлами, для яких відомий нестиснений +розмір. Якщо ви зіткнулися з цією проблемою, вам слід скористатися LZMA +Utils або LZMA SDK для створення файлів \fB.lzma\fP із відомим розміром +нестиснених даних. +. +.SS "Непідтримувані файли .lzma" +У форматі \fB.lzma\fP можливі значення \fIlc\fP аж до 8 і значення \fIlp\fP аж до +4. LZMA Utils можуть розпаковувати файли із будь\-якими значеннями \fIlc\fP і +\fIlp\fP, але завжди створюють файли з \fBlc=3\fP і \fBlp=0\fP. Створення файлів з +іншими значеннями \fIlc\fP і \fIlp\fP є можливим за допомогою \fBxz\fP і LZMA SDK. +.PP +Реалізація фільтра LZMA1 у liblzma потребує, щоби сума \fIlc\fP і \fIlp\fP не +перевищувала 4. Отже, файли \fB.lzma\fP, у яких перевищено обмеження, не може +бути розпаковано за допомогою \fBxz\fP. +.PP +LZMA Utils створюють лише файли \fB.lzma\fP, які мають розмір словника у 2^\fIn\fP +(степінь 2), але приймають файли із будь\-яким розміром словника. liblzma +приймає лише файли \fB.lzma\fP, які мають розмір словника 2^\fIn\fP або 2^\fIn\fP + +2^(\fIn\fP\-1). Так зроблено для зменшення помилок при виявленні файлів +\&\fB.lzma\fP. +.PP +Ці обмеження не мають призводити до проблем на практиці, оскільки практично +усі файли \fB.lzma\fP було стиснено з використанням параметрів, які приймає +liblzma. +. +.SS "Кінцевий мотлох" +При розпаковуванні LZMA Utils без повідомлень ігнорують усі дані після +першого потоку \fB.lzma\fP. У більшості випадків це пов'язано із вадою у +програмі. Це також означає, що у LZMA Utils не передбачено підтримки +розпаковування з'єднаних файлів \fB.lzma\fP. +.PP +Якщо після першого потоку \fB.lzma\fP лишилися дані, \fBxz\fP вважатиме файл +пошкодженим, якщо не було використано \fB\-\-single\-stream\fP. Це може зашкодити +роботі скриптів, де зроблено припущення, що кінцеві зайві дані буде +проігноровано. +. +.SH ПРИМІТКИ +. +.SS "Стискання даних може бути різним" +Точні стиснені дані, які створено на основі того самого нестисненого файла +вхідних даних, можуть бути різними для різних версій XZ Utils, навіть якщо +використано однакові параметри стискання. Причиною цього є удосконалення у +кодувальнику (пришвидшення або краще стискання) без зміни формату +файлів. Виведені дані можуть бути різними навіть для різних збірок тієї +самої версії XZ Utils, якщо використано різні параметри збирання. +.PP +Написане вище означає, що після реалізації \fB\-\-rsyncable\fP файли\-результати +не обов'язково можна буде синхронізувати за допомогою rsyncable, якщо старий +і новий файли було стиснено за допомогою тієї самої версії xz. Цю проблему +можна усунути, якщо буде заморожено частину реалізації кодувальника, щоб +введені для rsync дані були стабільними між версіями xz. +. +.SS "Вбудовані розпакувальники .xz" +У вбудованих реалізаціях розпакувальника \fB.xz\fP, подібних до XZ Embedded, не +обов'язково передбачено підтримку файлів, які створено із типами +\fIперевірки\fP цілісності, відмінними від \fBnone\fP і \fBcrc32\fP. Оскільки типовим +є \fB\-\-check=crc64\fP, вам слід використовувати \fB\-\-check=none\fP або +\fB\-\-check=crc32\fP при створенні файлів для вбудованих систем. +.PP +Поза вбудованими системами, в усіх засобах розпаковування формату \fB.xz\fP +передбачено підтримку усіх типів \fIперевірок\fP або принаймні можливість +розпакувати файл без перевірки цілісності, якщо підтримки певної +\fIперевірки\fP не передбачено. +.PP +У XZ Embedded передбачено підтримку BCJ, але лише з типовим початковим +зсувом. +. +.SH ПРИКЛАДИ +. +.SS Основи +Стиснути файл \fIfoo\fP до \fIfoo.xz\fP за допомогою типового рівня стискання +(\fB\-6\fP) і вилучити \fIfoo\fP, якщо стискання відбулося успішно: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Розпакувати \fIbar.xz\fP до \fIbar\fP і не вилучати \fIbar.xz\fP, навіть якщо +розпаковування відбулося успішно: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Створити \fIbaz.tar.xz\fP з використанням шаблона \fB\-4e\fP (\fB\-4 \-\-extreme\fP), +який є повільнішими за типовий \fB\-6\fP, але потребує менше пам'яті для +стискання та розпаковування (48\ МіБ та 5\ МіБ, відповідно): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Суміш стиснених і нестиснених файлів можна розпакувати до стандартного +виведення за допомогою єдиної команди: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Паралельне стискання багатьох файлів" +У GNU і *BSD можна скористатися \fBfind\fP(1) і \fBxargs\fP(1) для паралельного +стискання багатьох файлів: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Параметр \fB\-P\fP \fBxargs\fP(1) встановлює кількість паралельних процесів +\fBxz\fP. Найкраще значення параметра \fB\-n\fP залежить від того, скільки файлів +має бути стиснено. Якщо файлів мало, значенням, ймовірно, має бути 1. Якщо +файлів десятки тисяч, може знадобитися значення 100 або навіть більше, щоб +зменшити кількість процесів \fBxz\fP, які врешті створить \fBxargs\fP(1). +.PP +Параметр \fB\-T1\fP для \fBxz\fP тут для примусового встановлення однопотокового +режиму, оскільки для керування рівнем паралелізації використано \fBxargs\fP(1). +. +.SS "Режим робота" +Обчислити скільки байтів було заощаджено загалом після стискання декількох +файлів: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Скрипту можуть знадобитися дані щодо того, що використано достатньо нову +версію \fBxz\fP. У наведеному нижче скрипті \fBsh\fP(1) виконано перевірку того, +що номер версії засобу \fBxz\fP є принаймні рівним 5.0.0. Цей спосіб є сумісним +зі старими тестовими версіями, де не передбачено підтримки параметра +\fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Встановити обмеження на використання пам'яті для розпаковування за допомогою +\fBXZ_OPT\fP, але якщо обмеження вже було встановлено, не збільшувати його: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Нетипові ланцюжки фільтрів засобу стискання" +Найпростішим використанням ланцюжка фільтрів є налаштовування шаблона +LZMA2. Це може бути корисним, оскільки у шаблонах використано лише +підмножину потенційно корисних комбінацій параметрів стискання. +.PP +При налаштовуванні шаблонів LZMA2 корисними є стовпчики CompCPU таблиць з +описів параметрів \fB\-0\fP ... \fB\-9\fP і \fB\-\-extreme\fP. Ось відповідні частини з +цих двох таблиць: +.RS +.PP +.TS +tab(;); +c c +n n. +Шаблон;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Якщо вам відомо, що певний файл потребує дещо більшого словника (наприклад, +32\ МіБ) для якісного стискання, але ви хочете стиснути його швидше за +команду \fBxz \-8\fP, можна внести зміни до шаблона із нижчим значенням CompCPU +(наприклад, 1) для використання більшого словника: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Для певних файлів наведена вище команда може працювати швидше за \fBxz \-6\fP і +стискати дані значно краще. Втім, слід наголосити, переваги більшого +словника з одночасним низьким значенням CompCPU проявляються лише для деяких +файлів. Найочевиднішим випадком, коли великий словник є корисним, є випадок, +коли архів містить дуже подібні файли розміром у принаймні декілька +мегабайтів. Розмір словника має бути значно більшим за будь\-який окремий +файл, щоб у LZMA2 було використано усі переваги подібностей між послідовними +файлами. +.PP +Якщо дуже високий рівень використання пам'яті у засобі стискання або +розпаковування не є проблемою, і файли, який стискають має об'єм у принаймні +декілька десятків мегабайтів, може бути корисним використання навіть +більшого за 64 МіБ словника, який використано у \fBxz \-9\fP: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Використання \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP), подібно до наведеного вище +прикладу, може бути корисним для перегляду вимог з боку засобів стискання та +розпаковування до пам'яті. Пам'ятайте, що використання словника, розмір +якого перевищує розмір файла, який стискають, є простоюю витратою пам'яті, +отже наведену вище команду не варто використовувати для малих файлів. +.PP +Іноді час стискання не має значення, але використання пам'яті засобом +розпаковування має бути низьким для того, щоб, наприклад, уможливити +розпаковування файла у вбудованій системі. У наведеній нижче команді +використано \fB\-6e\fP (\fB\-6 \-\-extreme\fP) як основу і встановлено розмір словника +лише у 64\ КіБ. Файл\-результат можна розпакувати за допомогою XZ Embedded +(ось чому використано \fB\-\-check=crc32\fP) з використанням лише 100\ КіБ +пам'яті. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Якщо вам потрібно витиснути зі стискання максимальну кількість байтів, може +допомогти коригування кількості бітів контексту літералів (\fIlc\fP) та +кількість позиційних бітів (\fIpb\fP). Також може допомогти коригування +кількості бітів позиції літералів (\fIlp\fP), але, зазвичай, важливішими є +\fIlc\fP і \fIpb\fP. Наприклад, в архівах зі початковим кодом міститься +здебільшого текст US\-ASCII, щось подібне до наведеного нижче може дещо (на +щось близьке до 0,1\ %) зменшити файл, порівняно із \fBxz \-6e\fP (спробуйте +також без \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Використання іншого фільтра разом із LZMA2 може покращити стискання для +певних типів файлів. Наприклад, для стискання бібліотеки спільного +користування x86\-32 або x86\-64 з використанням фільтра BCJ x86 скористайтеся +такою командою: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Зауважте, що порядок параметрів фільтрування має значення. Якщо \fB\-\-x86\fP +вказано після \fB\-\-lzma2\fP, \fBxz\fP повідомить про помилку, оскільки після LZMA2 +не може бути жодного фільтра, а також оскільки фільтр BCJ x86 не можна +використовувати як останній фільтр у ланцюжку. +.PP +Фільтр Delta разом із LZMA2 може дати добрі результати для растрових +зображень. Зазвичай, результати є кращими за формат PNG, у якого є декілька +більш досконалих фільтрів, ніж проста дельта, але там використовують для +стискання Deflate. +.PP +Зображення слід берегти у нестисненому форматі, наприклад, як нестиснений +TIFF. Параметр відстані фільтра Delta встановлюють так, щоб він збігався із +кількістю байтів на піксель у зображенні. Наприклад, для 24\-бітового +растрового зображення RGB слід вказати \fBdist=3\fP, а також добре передати +\fBpb=0\fP до LZMA2 для пристосовування до трибайтового вирівнювання: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Якщо в один архів запаковано декілька зображень (наприклад, в архів +\&\fB.tar\fP), фільтр Delta також даватиме добрі результати, якщо у всіх +зображеннях однакова кількість байтів для кожного пікселя. +. +.SH "ДИВ. ТАКОЖ" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +Вбудовуваний XZ: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/unxz.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/unxz.1 new file mode 100644 index 0000000000000000000000000000000000000000..bff0472c4495c4b8c84495967535bcd7b99dc205 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/unxz.1 @@ -0,0 +1,2039 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Ukrainian translation for xz-man. +.\" Yuri Chornoivan , 2019, 2022, 2023, 2024, 2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 "8 березня 2025 року" Tukaani "XZ Utils" +. +.SH НАЗВА +xz, unxz, xzcat, lzma, unlzma, lzcat — стискання та розпаковування файлів +\&.xz і .lzma +. +.SH "КОРОТКИЙ ОПИС" +\fBxz\fP [\fIпараметр...\fP] [\fIфайл...\fP] +. +.SH "СКОРОЧЕННЯ КОМАНД" +\fBunxz\fP є рівноцінним до \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP є рівноцінним до \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP є рівноцінним до \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP є рівноцінним до \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP є рівноцінним до \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +При написанні скриптів, де потрібно розпаковувати файли, рекомендуємо завжди +використовувати \fBxz\fP із відповідними аргументами (\fBxz \-d\fP або \fBxz \-dc\fP), +замість \fBunxz\fP і \fBxzcat\fP. +. +.SH ОПИС +\fBxz\fP інструмент загального призначення для стискання даних із синтаксисом +командного рядка, подібним для \fBgzip\fP(1) і \fBbzip2\fP(1). Власним форматом +файлів є \fB.xz\fP, але передбачено підтримку застарілого формату \fB.lzma\fP, +який було використано у LZMA Utils, та необроблених потоків стиснених даних +без заголовків формату контейнера. Крім того, передбачено підтримку +розпаковування формату \fB.lz\fP, який використано у \fBlzip\fP. +.PP +\fBxz\fP стискає або розпаковує кожен \fIфайл\fP відповідно до вибраного режиму +дій. Якщо \fIфайли\fP не задано або якщо \fIфайлом\fP є \fB\-\fP, \fBxz\fP читатиме дані +зі стандартного джерела вхідних даних і записуватиме оброблені дані до +стандартного виведення. \fBxz\fP відмовить (покаже повідомлення про помилку і +пропустить \fIфайл\fP) у записів стиснених даних до стандартного виведення, +якщо це термінал. Так само, \fBxz\fP відмовить у читанні стиснених даних зі +стандартного джерела вхідних даних, якщо це термінал. +.PP +Якщо не вказано \fB\-\-stdout\fP, \fIфайли\fP, відмінні від \fB\-\fP, буде записано до +нового файла, чию назву буде визначено з назви початкового \fIфайла\fP: +.IP \(bu 3 +При стисканні суфікс формату файла призначення (\fB.xz\fP або \fB.lzma\fP) буде +дописано до назви початкового файла для отримання назви файла призначення. +.IP \(bu 3 +При розпаковуванні суфікс \fB.xz\fP, \fB.lzma\fP або \fB.lz\fP буде вилучено з назви +файла для отримання назви файла призначення. Крім того, \fBxz\fP розпізнає +суфікси \fB.txz\fP і \fB.tlz\fP і замінює їх на суфікс \fB.tar\fP. +.PP +Якщо файл призначення вже існує, буде показано повідомлення про помилку, а +\fIфайл\fP буде пропущено. +.PP +Окрім випадку запису до стандартного виведення, \fBxz\fP покаже попередження і +пропустить обробку \fIфайла\fP, якщо буде виконано будь\-яку з таких умов: +.IP \(bu 3 +\fIФайл\fP не є звичайним файлом. Програма не переходитиме за символічними +посиланнями, а отже, не вважатиме їх звичайними файлами. +.IP \(bu 3 +На \fIфайл\fP існує декілька жорстких посилань. +.IP \(bu 3 +Для \fIфайла\fP встановлено setuid, setgid або «липкий» біт. +.IP \(bu 3 +Режим дій встановлено у значення «стискання», і \fIфайл\fP вже має суфікс назви +формату файла призначення (\fB.xz\fP або \fB.txz\fP при стисканні до формату +\&\fB.xz\fP, і \fB.lzma\fP або \fB.tlz\fP при стисканні до формату \fB.lzma\fP). +.IP \(bu 3 +Режим дій встановлено у значення «розпаковування», і \fIфайл\fP не має суфікса +назви жодного з підтримуваних форматів (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP +або \fB.lz\fP). +.PP +Після успішного стискання або розпаковування \fIфайла\fP, \fBxz\fP копіює дані +щодо власника, групи, прав доступу, часу доступу та моменту внесення змін з +початкового \fIфайла\fP до файла призначення. Якщо копіювання даних щодо групи +зазнає невдачі, права доступу буде змінено так, що файл призначення стане +недоступним для користувачів, які не мають права доступу до початкового +\fIфайла\fP. В \fBxz\fP ще не передбачено підтримки копіювання інших метаданих, +зокрема списків керування доступом або розширених атрибутів. +.PP +Щойно файл призначення буде успішно закрито, початковий \fIфайл\fP буде +вилучено, якщо не вказано параметра \fB\-\-keep\fP. Початковий \fIфайл\fP ніколи не +буде вилучено, якщо виведені дані буде записано до стандартного виведення +або якщо станеться помилка. +.PP +Надсилання \fBSIGINFO\fP або \fBSIGUSR1\fP до процесу \fBxz\fP призводить до +виведення даних щодо поступу до стандартного виведення помилок. Це має лише +обмежене використання, оскільки якщо стандартним виведенням помилок є +термінал, використання \fB\-\-verbose\fP призведе до показу автоматично +оновлюваного індикатора поступу. +. +.SS "Використання пам'яті" +Використання \fBxz\fP пам'яті може бути різним: від декількох сотень кілобайтів +до декількох гігабайтів, залежно від параметрів стискання. Параметри, які +використано при стисканні файла, визначають вимоги до об'єму пам'яті при +розпакуванні. Типово, засобу розпаковування потрібно від 5\ % до 20\ % +об'єму пам'яті, якого засіб стискання потребує при створенні +файла. Наприклад, розпаковування файла, який створено з використанням \fBxz \-9\fP, у поточній версії потребує 65\ МіБ пам'яті. Втім, можливе створення +файлів \fB.xz\fP, які потребуватимуть для розпаковування декількох гігабайтів +пам'яті. +.PP +Ймовірність високого рівня використання пам'яті може бути особливо +дошкульною для користувачів застарілих комп'ютерів. Щоб запобігти прикрим +несподіванкам, у \fBxz\fP передбачено вбудований обмежувач пам'яті, який типово +вимкнено. Хоча у деяких операційних системах передбачено спосіб обмежити +використання пам'яті процесами, сподівання на його ефективність не є аж +надто гнучким (наприклад, використання \fBulimit\fP(1) для обмеження +віртуальної пам'яті призводить до викривлення даних \fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Обмежувач пам'яті можна увімкнути за допомогою параметра командного рядка +\fB\-\-memlimit=\fP\fIобмеження\fP. Часто, зручніше увімкнути обмежувач на типовому +рівні, встановивши значення для змінної середовища \fBXZ_DEFAULTS\fP, +наприклад, \fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Можна встановити обмеження +окремо для стискання і розпакування за допомогою +\fB\-\-memlimit\-compress=\fP\fIlimit\fP and +\fB\-\-memlimit\-decompress=\fP\fIобмеження\fP. Використання цих двох параметрів поза +\fBXZ_DEFAULTS\fP не таке вже і корисне, оскільки одноразовий запуск \fBxz\fP не +може одночасно призводити до стискання та розпаковування, а набрати у +командному рядку \fB\-\-memlimit=\fP\fIобмеження\fP (або \fB\-M\fP \fIобмеження\fP) +набагато швидше. +.PP +Якщо під час розпаковування вказане обмеження буде перевищено, \fBxz\fP покаже +повідомлення про помилку, а розпаковування файла зазнає невдачі. Якщо +обмеження буде перевищено при стисканні, \fBxz\fP спробує масштабувати +параметри так, щоб не перевищувати обмеження (окрім випадків використання +\fB\-\-format=raw\fP або \fB\-\-no\-adjust\fP). Отже, дію буде виконано, якщо обмеження +не є надто жорстким. Масштабування параметрів буде виконано кроками, які не +збігаються із рівнями шаблонів стискання. Наприклад, якщо обмеження лише +трохи не вкладається у об'єм потрібний для \fBxz \-9\fP, параметри буде змінено +лише трохи, не до рівня \fBxz \-8\fP. +. +.SS "Поєднання і заповнення з файлами .xz" +Можна поєднати файли \fB.xz\fP без додаткової обробки. \fBxz\fP розпакує такі +файли так, наче вони є єдиним файлом \fB.xz\fP. +.PP +Можна додати доповнення між з'єднаними частинами або після останньої +частини. Доповнення має складатися із нульових байтів і мати розмір, який є +кратним до чотирьох байтів. Це може бути корисним, наприклад, якщо файл +\&\fB.xz\fP зберігається на носії даних, де розміри файла вимірюються у +512\-байтових блоках. +.PP +Поєднання та заповнення не можна використовувати для файлів \fB.lzma\fP або +потоків необроблених даних. +. +.SH ПАРАМЕТРИ +. +.SS "Цілочисельні суфікси і спеціальні значення" +У більшості місць, де потрібен цілочисельний аргумент, передбачено підтримку +необов'язкового суфікса для простого визначення великих цілих чисел. Між +цілим числом і суфіксом не повинно бути пробілів. +.TP +\fBKiB\fP +Помножити ціле число на 1024 (2^10). Синонімами \fBKiB\fP є \fBKi\fP, \fBk\fP, \fBkB\fP, +\fBK\fP та \fBKB\fP. +.TP +\fBMiB\fP +Помножити ціле число на 1048576 (2^20). Синонімами \fBMiB\fP є B, \fBMi\fP, \fBm\fP, +\fBM\fP та \fBMB\fP. +.TP +\fBGiB\fP +Помножити ціле число на 1073741824 (2^30). Синонімами \fBGiB\fP є B, \fBGi\fP, +\fBg\fP, \fBG\fP та \fBGB\fP. +.PP +Можна скористатися особливим значенням \fBmax\fP для позначення максимального +цілого значення, підтримку якого передбачено для параметра. +. +.SS "Режим операції" +Якщо вказано декілька параметрів режиму дій, буде використано лише останній +з них. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Стиснути. Це типовий режим дій, якщо не вказано параметр режиму дій, а назва +команди неявним чином не визначає іншого режиму дій (наприклад, \fBunxz\fP +неявно визначає \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Після успішного пакування початковий файл буде вилучено, якщо виведення не +відбувається до стандартного виведення або не вказано параметра \fB\-\-keep\fP. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Розпакувати. Після успішного розпаковування початковий файл буде вилучено, +якщо виведення не відбувається до стандартного виведення або не вказано +параметра \fB\-\-keep\fP. +.TP +\fB\-t\fP, \fB\-\-test\fP +Перевірити цілісність стиснених файлів \fIфайли\fP. Цей параметр еквівалентний +до \fB\-\-decompress \-\-stdout\fP, але розпаковані дані буде відкинуто, замість +запису до стандартного виведення. Жодних файлів не буде створено або +вилучено. +.TP +\fB\-l\fP, \fB\-\-list\fP +Вивести відомості щодо стиснених файлів \fIфайли\fP. Розпакування даних не +виконуватиметься, жодних файлів не буде створено або вилучено. У режимі +списку програма не може читати дані зі стандартного введення або з інших +джерел, де неможливе позиціювання. +.IP "" +У типовому списку буде показано базові відомості щодо файлів \fIфайли\fP, по +одному файлу на рядок. Щоб отримати докладніші відомості, скористайтеся +параметром \fB\-\-verbose\fP. Щоб розширити спектр відомостей, скористайтеся +параметром \fB\-\-verbose\fP двічі, але зауважте, що це може призвести до +значного уповільнення роботи, оскільки отримання додаткових відомостей +потребує великої кількості позиціювань. Ширина області докладного виведення +даних перевищує 80 символів, тому передавання конвеєром виведених даних, +наприклад, до \fBless\ \-S\fP, може бути зручним способом перегляду даних, якщо +термінал недостатньо широкий. +.IP "" +Виведені дані залежать від версії \fBxz\fP та використаної локалі. Для +отримання даних, які будуть придатні до обробки комп'ютером, слід +скористатися параметрами \fB\-\-robot \-\-list\fP. +. +.SS "Модифікатори режиму роботи" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Не вилучати вхідні файли. +.IP "" +Починаючи з версії \fBxz\fP 5.2.6, використання цього параметра також наказує +\fBxz\fP виконувати стискання або розпаковування, навіть якщо вхідними даними є +символічне посилання на звичайний файл, файл, який має декілька жорстких +посилань, або файл, для якого встановлено setuid, setgid або липкий +біт. setuid, setgid та липкий біт не буде скопійовано до файла\-результату. У +попередніх версіях, ці дії виконувалися, лише якщо було використано параметр +\fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Результатів використання цього параметра буде декілька: +.RS +.IP \(bu 3 +Якщо файл\-результат вже існує, вилучити його до стискання або +розпаковування. +.IP \(bu 3 +Виконувати стискання або розпаковування, навіть якщо вхідними даними є +символічне посилання на звичайний файл, файл, який має декілька жорстких +посилань, або файл, для якого встановлено setuid, setgid або липкий біт +setuid, setgid та липкий біт не буде скопійовано до файла\-результату. +.IP \(bu 3 +Якщо використано разом із \fB\-\-decompress\fP, \fB\-\-stdout\fP, і \fBxz\fP не зможе +розпізнати тип початкового файла, копіювати початковий файл без змін до +стандартного виведення. Це надає змогу користуватися \fBxzcat\fP \fB\-\-force\fP +подібно до \fBcat\fP(1) для файлів, які не було стиснено за допомогою +\fBxz\fP. Зауважте, що у майбутньому у \fBxz\fP може бути реалізовано підтримку +нових форматів стиснених файлів, замість копіювання їх без змін до +стандартного виведення. Можна скористатися \fB\-\-format=\fP\fIформат\fP для +обмеження стискання у \fBxz\fP єдиним форматом файлів. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Записати стиснені або розпаковані дані до стандартного виведення, а не до +файла. Неявним чином встановлює \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Розпакувати лише перший потік даних \fB.xz\fP і без повідомлень проігнорувати +решту вхідних даних, які слідують за цим потоком. Зазвичай, такі зайві дані +наприкінці файла призводять до показу \fBxz\fP повідомлення про помилку. +.IP "" +\fBxz\fP ніколи не виконуватиме спроби видобути декілька потоків даних з файлів +\&\fB.lzma\fP або необроблених потоків даних, але використання цього параметра +все одно наказує \fBxz\fP ігнорувати можливі кінцеві дані після файла \fB.lzma\fP +або необробленого потоку даних. +.IP "" +Цей параметр нічого не змінює, якщо режимом дій не є \fB\-\-decompress\fP або +\fB\-\-test\fP. +.IP "" +З \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP неявно визначає \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Вимкнути створення розріджених файлів. Типово, якщо видобування виконується +до звичайного файла, \fBxz\fP намагається створити розріджений файл, якщо +розпаковані дані містять довгі послідовності двійкових нулів. Це також +працює, коли виконується запис до стандартного виведення, доки стандартне +виведення з'єднано зі звичайним файлом і виконуються певні додаткові умови, +які убезпечують роботу. Створення розріджених файлів може заощадити місце на +диску і пришвидшити розпаковування шляхом зменшення кількості дій введення +та виведення даних на диску. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +При стисканні використати суфікс \fI.suf\fP для файлів призначення, замість +суфікса \fB.xz\fP або \fB.lzma\fP. Якщо записування виконується не до стандартного +виведення і початковий файл вже має суфікс назви \fI.suf\fP, буде показано +попередження, а файл буде пропущено під час обробки. +.IP "" +При розпаковуванні розпізнавати файли із суфіксом назви \fI.suf\fP, окрім +файлів із суфіксами назв \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP або \fB.lz\fP. Якщо +початковий файл мав суфікс назви \fI.suf\fP, для отримання назви файла +призначення цей суфікс буде вилучено. +.IP "" +При стисканні або розпакуванні необроблених потоків даних (\fB\-\-format=raw\fP) +суфікс слід вказувати завжди, якщо запис не виконується до стандартного +виведення, оскільки типового суфікса назви для необроблених потоків даних не +передбачено. +.TP +\fB\-\-files\fP[\fB=\fP\fIфайл\fP] +Прочитати назви файлів для обробки з файла \fIфайл\fP; якщо \fIfile\fP не вказано, +назви файлів буде прочитано зі стандартного потоку вхідних даних. Назви +файлів має бути відокремлено символом нового рядка. Символ дефіса (\fB\-\fP) +буде оброблено як звичайну назву файла; він не позначатиме стандартного +джерела вхідних даних. Якщо також буде вказано назви файлів у аргументах +рядка команди, файли з цими назвами буде оброблено до обробки файлів, назви +яких було прочитано з файла \fIфайл\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIфайл\fP] +Те саме, що і \fB\-\-files\fP[\fB=\fP\fIфайл\fP], але файли у списку має бути +відокремлено нульовим символом. +. +.SS "Параметри базового формату файлів та стискання" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fIформат\fP +Вказати файл \fIформат\fP для стискання або розпакування: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Типовий варіант. При стисканні \fBauto\fP є еквівалентом \fBxz\fP. При +розпакуванні формат файла вхідних даних буде виявлено автоматично. Зауважте, +що автоматичне виявлення необроблених потоків даних (створених за допомогою +\fB\-\-format=raw\fP) неможливе. +.TP +\fBxz\fP +Стиснути до формату \fB.xz\fP або приймати лише файли \fB.xz\fP при +розпаковуванні. +.TP +\fBlzma\fP, \fBalone\fP +Стиснути дані до застарілого формату файлів \fB.lzma\fP або приймати лише файли +\&\fB.lzma\fP при розпаковуванні. Альтернативну назву \fBalone\fP може бути +використано для зворотної сумісності із LZMA Utils. +.TP +\fBlzip\fP +Приймати лише файли \fB.lz\fP при розпакуванні. Підтримки стискання не +передбачено. +.IP "" +Передбачено підтримку версії формату \fB.lz\fP 0 та 1. Файли версії 0 було +створено \fBlzip\fP 1.3 та старішими версіями. Такі файли не є поширеними, але +їх можна знайти у файлових архівах, оскільки певну незначну кількість +пакунків із початковим кодом було випущено у цьому форматі. Також можуть +існувати особисті файли у цьому форматі. Підтримку розпаковування для +формату версії 0 було вилучено у \fBlzip\fP 1.18. Версія \fBlzip\fP 1.4 і новіші +версії створюють файли у форматі версії 1. +.TP +\fBraw\fP +Стиснути або розпакувати потік необроблених даних (лез заголовків). Цей +параметр призначено лише для досвідчених користувачів. Для розпаковування +необроблених потоків даних слід користуватися параметром \fB\-\-format=raw\fP і +явно вказати ланцюжок фільтрування, який за звичайних умов мало б бути +збережено у заголовках контейнера. +.RE +.TP +\fB\-C\fP \fIперевірка\fP, \fB\-\-check=\fP\fIперевірка\fP +Вказати тип перевірки цілісності. Контрольну суму буде обчислено на основі +нестиснених даних і збережено у файлі \fB.xz\fP. Цей параметр працюватиме, лише +якщо дані стиснено до файла у форматі \fB.xz\fP; для формату файлів \fB.lzma\fP +підтримки перевірки цілісності не передбачено. Перевірку контрольної суми +(якщо така є) буде виконано під час розпаковування файла \fB.xz\fP. +.IP "" +Підтримувані типи \fIперевірок\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Не обчислювати контрольну суму взагалі. Зазвичай, не варто цього робити. Цим +варіантом слід скористатися, якщо цілісність даних буде перевірено в інший +спосіб. +.TP +\fBcrc32\fP +Обчислити CRC32 за допомогою полінома з IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Обчислити CRC64 за допомогою полінома з ECMA\-182. Це типовий варіант, +оскільки він дещо кращий за CRC32 при виявленні пошкоджених файлів, а +різниця у швидкості є незрачною. +.TP +\fBsha256\fP +Обчислити SHA\-256. Цей варіант дещо повільніший за CRC32 і CRC64. +.RE +.IP "" +Цілісність заголовків \fB.xz\fP завжди перевіряють за допомогою CRC32. Таку +перевірку не можна змінити або скасувати. +.TP +\fB\-\-ignore\-check\fP +Не перевіряти цілісність стиснених даних при розпаковуванні. Значення CRC32 +у заголовках \fB.xz\fP буде у звичайний спосіб перевірено попри цей параметр. +.IP "" +\fBНе користуйтеся цим параметром, якщо ви не усвідомлюєте наслідків ваших дій.\fP Можливі причини скористатися цим параметром: +.RS +.IP \(bu 3 +Спроба отримання даних з пошкодженого файла .xz. +.IP \(bu 3 +Пришвидшення розпакування. Це, здебільшого, стосується SHA\-256 або файлів із +надзвичайно високим рівнем пакування. Не рекомендуємо користуватися цим +параметром з цією метою, якщо цілісність файлів не буде перевірено у якийсь +інший спосіб. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Вибрати рівень стискання. Типовим є \fB\-6\fP. Якщо буде вказано декілька рівнів +стискання, програма використає останній вказаний. Якщо вже було вказано +нетиповий ланцюжок фільтрів, встановлення рівня стискання призведе до +нехтування цим нетиповим ланцюжком фільтрів. +.IP "" +Різниця між рівнями є суттєвішою, ніж у \fBgzip\fP(1) і \fBbzip2\fP(1). Вибрані +параметри стискання визначають вимоги до пам'яті під час розпаковування, +отже використання надто високого рівня стискання може призвести до проблем +під час розпаковування файла на застарілих комп'ютерах із невеликим обсягом +оперативної пам'яті. Зокрема, \fBне варто використовувати \-9 для усього\fP, як +це часто буває для \fBgzip\fP(1) і \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Це дещо швидші набори налаштувань. \fB\-0\fP іноді є швидшим за \fBgzip \-9\fP, +забезпечуючи набагато більший коефіцієнт стискання. Вищі рівні часто мають +швидкість, яку можна порівняти з \fBbzip2\fP(1) із подібним або кращим +коефіцієнтом стискання, хоча результати значно залежать від типу даних, які +стискають. +.TP +\fB\-4\fP ... \fB\-6\fP +Стискання від доброго до дуже доброго рівня із одночасним підтриманням +помірного рівня споживання пам'яті засобом розпаковування, навіть для +застарілих системи. Типовим є значення \fB\-6\fP, яке є добрим варіантом для +поширення файлів, які мають бути придатними до розпаковування навіть у +системах із лише 16\ МіБ оперативної пам'яті. (Також можна розглянути +варіанти \fB\-5e\fP і \fB\-6e\fP. Див. \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Ці варіанти подібні до \fB\-6\fP, але із вищими вимогами щодо пам'яті для +стискання і розпаковування. Можуть бути корисними лише для стискання файлів +з розміром, що перевищує 8\ МіБ, 16\ МіБ та 32\ МіБ, відповідно. +.RE +.IP "" +На однаковому обладнанні швидкість розпакування є приблизно сталою кількістю +байтів стиснених даних за секунду. Іншими словами, чим кращим є стискання, +тим швидшим буде, зазвичай, розпаковування. Це також означає, що об'єм +розпакованих виведених даних, які видає програма за секунду, може коливатися +у широкому діапазоні. +.IP "" +У наведеній нижче таблиці підсумовано можливості шаблонів: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Шаблон;DictSize;CompCPU;CompMem;DecMem +\-0;256 КіБ;0;3 МіБ;1 МіБ +\-1;1 МіБ;1;9 МіБ;2 МіБ +\-2;2 МіБ;2;17 МіБ;3 МіБ +\-3;4 МіБ;3;32 МіБ;5 МіБ +\-4;4 МіБ;4;48 МіБ;5 МіБ +\-5;8 МіБ;5;94 МіБ;9 МіБ +\-6;8 МіБ;6;94 МіБ;9 МіБ +\-7;16 МіБ;6;186 МіБ;17 МіБ +\-8;32 МіБ;6;370 МіБ;33 МіБ +\-9;64 МіБ;6;674 МіБ;65 МіБ +.TE +.RE +.RE +.IP "" +Описи стовпчиків: +.RS +.IP \(bu 3 +DictSize є розміром словника LZMA2. Використання словника, розмір якого +перевищує розмір нестисненого файла, — проста витрата пам'яті. Ось чому не +варто використовувати шаблони \fB\-7\fP ... \fB\-9\fP, якщо у них немає реальної +потреби. Для \fB\-6\fP та нижчих рівнів об'єм витраченої пам'яті, зазвичай, +такий низький, що цей фактор ні на що не впливає. +.IP \(bu 3 +CompCPU є спрощеним представленням параметрів LZMA2, які впливають на +швидкість стискання. Розмір словника також впливає на швидкість, тому, хоча +значення CompCPU є однаковим для рівнів \fB\-6\fP ... \fB\-9\fP, обробка на вищих +рівнях все одно є трошки повільнішою. Що отримати повільніше і, ймовірно, +краще стискання, див. \fB\-\-extreme\fP. +.IP \(bu 3 +CompMem містить вимоги до пам'яті засобу стискання у однопотоковому +режимі. Значення можуть бути дещо різними для різних версій \fBxz\fP. +.IP \(bu 3 +У DecMem містяться вимоги до пам'яті при розпаковуванні. Тобто параметри +засобу стискання визначають вимоги до пам'яті при розпаковуванні. Точний +об'єм пам'яті, яка потрібна для розпаковування, дещо перевищує розмір +словника LZMA2, але значення у таблиці було округлено до наступного цілого +значення МіБ. +.RE +.IP "" +Вимоги до пам'яті у багатопотоковому режимі є значно вищими, ніж у +однопотоковому. З типовим значенням \fB\-\-block\-size\fP для кожного потоку треба +3*3*DictSize плюс CompMem або DecMem. Наприклад, для чотирьох потоків з +шаблоном \fB\-6\fP потрібно 660\(en670\ МіБ пам'яті. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Використати повільніший варіант вибраного рівня стискання (\fB\-0\fP ... \fB\-9\fP) +у сподіванні отримати трохи кращий коефіцієнт стискання, але, якщо не +поталанить, можна його і погіршити. Не впливає на використання пам'яті при +розпаковуванні, але використання пам'яті при стисканні дещо збільшиться на +рівнях \fB\-0\fP ... \fB\-3\fP. +.IP "" +Оскільки існує два набори налаштувань із розмірами словників 4\ МіБ та 8\ МіБ, у наборах \fB\-3e\fP і \fB\-5e\fP використано трошки швидші параметри (нижче +CompCPU), ніж у наборах \fB\-4e\fP і \fB\-6e\fP, відповідно. Тому двох однакових +наборів у списку немає. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Шаблон;DictSize;CompCPU;CompMem;DecMem +\-0e;256 КіБ;8;4 МіБ;1 МіБ +\-1e;1 МіБ;8;13 МіБ;2 МіБ +\-2e;2 МіБ;8;25 МіБ;3 МіБ +\-3e;4 МіБ;7;48 МіБ;5 МіБ +\-4e;4 МіБ;8;48 МіБ;5 МіБ +\-5e;8 МіБ;7;94 МіБ;9 МіБ +\-6e;8 МіБ;8;94 МіБ;9 МіБ +\-7e;16 МіБ;8;186 МіБ;17 МіБ +\-8e;32 МіБ;8;370 МіБ;33 МіБ +\-9e;64 МіБ;8;674 МіБ;65 МіБ +.TE +.RE +.RE +.IP "" +Наприклад, передбачено загалом чотири набори налаштувань із використанням +словника у 8\ МіБ, порядок яких від найшвидшого до найповільнішого є таким: +\fB\-5\fP, \fB\-6\fP, \fB\-5e\fP і \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Це дещо оманливі альтернативні варіанти для \fB\-0\fP і \fB\-9\fP, +відповідно. Реалізовано лише для забезпечення зворотної сумісності із LZMA +Utils. Намагайтеся не користуватися цими варіантами параметрів. +.TP +\fB\-\-block\-size=\fP\fIрозмір\fP +При стисканні до формату \fB.xz\fP поділити вхідні дані на блоки у \fIрозмір\fP +байтів. Ці блоки буде стиснуто незалежно один від одного, що допоможе у +багатопотоковій обробці і зробить можливим обмежене розпакування для доступу +до будь\-яких даних. Цим параметром слід типово користуватися для +перевизначення типового розміру блоку у багатопотоковому режимі обробки, але +цим параметром можна також скористатися в однопотоковому режимі обробки. +.IP "" +У багатопотоковому режимі для кожного потоку буде отримано для буферів +вхідних і вихідних даних майже утричі більше за \fIрозмір\fP байтів. Типовий +\fIрозмір\fP утричі більший за розмір словника LZMA2 або дорівнює 1 МіБ, буде +вибрано більше значення. Типовим добрим значенням буде значення, яке у +2\(en4 рази перевищує розмір словника LZMA2 або дорівнює принаймні 1 +МіБ. Використання значення \fIрозмір\fP, яке є меншим за розмір словника LZMA2, +має наслідком марну витрату оперативної пам'яті, оскільки його використання +призводить до того, що буфер словника LZMA2 ніколи не буде використано +повністю. У багатопотоковому режимі розміри блоків зберігатимуться у +заголовках блоків. Ці дані потрібні для багатопотокового розпаковування. +.IP "" +У однопотоковому режимі поділ на блоки типово не +виконуватиметься. Встановлення значення для цього параметра не впливатиме на +використання пам'яті. У заголовках блоків не зберігатимуться дані щодо +розміру, отже файли, які створено в однопотоковому режимі не будуть +ідентичними до файлів, які створено у багатопотоковому режимі. Те, що у +заголовках блоків не зберігатимуться дані щодо розміру також означає, що +\fBxz\fP не зможе розпаковувати такі файли у багатопотоковому режимі. +.TP +\fB\-\-block\-list=\fP\fIзаписи\fP +При стисканні у форматі \fB.xz\fP починати новий блок із необов'язковим +ланцюжком фільтрів після вказаної кількості інтервалів нестиснених даних. +.IP "" +\fIзаписи\fP є списком відокремлених комами значень. Кожен запис складається з +необов'язкового номера ланцюжка фільтрів від 0 до 9, після якого йде +двокрапка (\fB:\fP) і необхідний розмір нестиснутих даних. Пропущення запису +(дві або більше послідовних ком) є скороченим варіантом визначення +використання розміру та фільтрів попереднього запису. +.IP "" +Якщо файл вхідних даних є більшим за розміром за суму розмірів \fIзаписів\fP, +останнє значення у \fIрозмірах\fP буде повторено до кінця файла. Особливе +значення \fB0\fP може бути використано як останній розмір, щоб позначити, що +решту файла має бути закодовано як єдиний блок. +.IP "" +Альтернативний ланцюжок фільтрів для кожного блоку можна вказати в поєднанні +з параметрами \fB\-\-filters1=\fP\fIфільтри\fP \&...\& \fB\-\-filters9=\fP\fIфільтри\fP. Ці +параметри визначають ланцюжки фільтрів з ідентифікатором у діапазоні +1\(en9. Ланцюжок фільтрів 0 можна використовувати для посилання на типовий +ланцюжок фільтрів — це те саме, що не вказувати ланцюжок +фільтрів. Ідентифікатор ланцюжка фільтрів можна використовувати перед +нестисненим розміром, після якого йде двокрапка (\fB:\fP). Наприклад, якщо +вказати \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP, блоки будуть +створені так: +.RS +.IP \(bu 3 +Ланцюжок фільтрів задано \fB\-\-filters1\fP із вхідними даними у 2 МіБ +.IP \(bu 3 +Ланцюжок фільтрів задано \fB\-\-filters3\fP із вхідними даними у 2 МіБ +.IP \(bu 3 +Ланцюжок фільтрів задано \fB\-\-filters2\fP із вхідними даними у 4 МіБ +.IP \(bu 3 +Ланцюжок фільтрів задано \fB\-\-filters2\fP із вхідними даними у 4 МіБ +.IP \(bu 3 +Типовий ланцюжок даних і вхідні дані у 2 МіБ +.IP \(bu 3 +Типовий ланцюжок фільтрів та вхідні дані у 4 МіБ для кожного блоку до кінця +вхідних даних. +.RE +.IP "" +Якщо вказати розмір, який перевищує розмір блоку кодувальника (або типове +значення у режимі із потоками обробки, або значення, яке встановлено за +допомогою \fB\-\-block\-size=\fP\fIрозмір\fP), засіб кодування створить додаткові +блоки, зберігаючи межі, які вказано у \fIзаписах\fP. Наприклад, якщо вказати +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP, а файл +вхідних даних має розмір 80 МіБ, буде отримано такі 11 блоків: 5, 10, 8, 10, +2, 10, 10, 4, 10, 10 і 1 МіБ. +.IP "" +У багатопотоковому режимі розмір блоків буде збережено у заголовках +блоків. Програма не зберігатиме ці дані у однопотоковому режимі, отже +закодований результат не буде ідентичним до отриманого у багатопотоковому +режимі. +.TP +\fB\-\-flush\-timeout=\fP\fIчас_очікування\fP +При стискання, якщо з моменту попереднього витирання мине понад +\fIчас_очікування\fP мілісекунд (додатне ціле значення) і читання додаткових +даних буде заблоковано, усі вхідні дані у черзі обробки буде витерто з +кодувальника і зроблено доступним у потоці вихідних даних. Це може бути +корисним, якщо \fBxz\fP використовують для стискання даних, які передають +потоком мережею. Невеликі значення аргументу \fIчас_очікування\fP зроблять дані +доступними на боці отримання із малою затримкою, а великі значення аргумент +\fIчас_очікування\fP уможливлять кращий коефіцієнт стискання. +.IP "" +Типово, цю можливість вимкнено. Якщо цей параметр вказано декілька разів, +буде використано лише останнє вказане значення. Особливим значенням +аргументу \fIчас_очікування\fP, рівним \fB0\fP, можна скористатися для вимикання +цієї можливості явним чином. +.IP "" +Ця можливість недоступна у системах, які не є системами POSIX. +.IP "" +.\" FIXME +\fBЦя можливість усе ще є експериментальною.\fP У поточній версії, \fBxz\fP не +може розпаковувати потік даних у режимі реального часу через те, у який +спосіб \fBxz\fP виконує буферизацію. +.TP +\fB\-\-no\-sync\fP +Не синхронізувати файл призначення та його каталог із пристроєм зберігання +даних до вилучення початкового файла. Це може підвищити швидкодію, якщо +виконується стискання або розпаковування багатьох малих файлів. Втім, якщо +система аварійно завершує роботу невдовзі після вилучення, можлива ситуація, +коли файл призначення не буде записано на пристрій зберігання даних, а дію з +вилучення буде записано. У цьому випадку буде знищено дані як початкового +файла, так і файла призначення. +.IP "" +Цей параметр матиме хоч який вплив, лише якщо \fBxz\fP вилучає початковий +файл. В інших випадках синхронізація не виконується. +.IP "" +Синхронізацію і \fB\-\-no\-sync\fP було додано у версії \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIобмеження\fP +Встановити обмеження на використання пам'яті при стисканні. Якщо цей +параметр вказано декілька разів, враховано буде лише останнє вказане +значення. +.IP "" +Якщо параметри стискання перевищують \fIобмеження\fP, \fBxz\fP спробує скоригувати +параметри так, щоб обмеження не було перевищено, і покаже повідомлення про +те, що було виконано автоматичне коригування. Коригування буде виконано у +такому порядку: зменшення кількості потоків обробки, перемикання у +однопотоковий режим, якщо хоч в одному потоці багатопотокового режиму буде +перевищено \fIобмеження\fP, і нарешті, зменшення розміру словника LZMA2. +.IP "" +При стисканні з використанням \fB\-\-format=raw\fP, або якщо було вказано +\fB\-\-no\-adjust\fP, може бути зменшена лише кількість потоків обробки, оскільки +це може бути зроблено без впливу на стиснені виведені дані. +.IP "" +Якщо \fIобмеження\fP не може бути виконано за допомогою коригувань, які описано +вище, буде показано повідомлення про помилку, а \fBxz\fP завершить роботу зі +станом виходу 1. +.IP "" +Аргумент \fIобмеження\fP можна вказати у декілька способів: +.RS +.IP \(bu 3 +Значенням \fIобмеження\fP може бути додатне ціле значення у байтах. Можна +скористатися цілочисельним суфіксом, подібним до \fBMiB\fP. Приклад: +\fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +Аргумент \fIобмеження\fP може бути задано у відсотках від загальної фізичної +пам'яті системи (RAM). Це може бути корисним особливо при встановленні +змінної середовища \fBXZ_DEFAULTS\fP у скрипті ініціалізації системи, який є +спільним для різних комп'ютерів. У такий спосіб можна вказати вищий рівень +обмеження для систем із більшим об'ємом пам'яті. Приклад: +\fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +Аргументу \fIобмеження\fP може бути повернуто типове значення встановленням +значення \fB0\fP. У поточній версії це еквівалентно до встановлення значення +аргументу \fIобмеження\fP \fBmax\fP (без обмеження на використання пам'яті). +.RE +.IP "" +Для 32\-бітової версії \fBxz\fP передбачено особливий випадок: якщо \fIобмеження\fP +перевищуватиме \fB4020\ МіБ\fP, для \fIобмеження\fP буде встановлено значення +\fB4020\ MiB\fP. На MIPS32 замість цього буде використано \fB2000\ MiB\fP. (Це не +стосується значень \fB0\fP і \fBmax\fP. Подібної можливості для розпаковування не +існує.) Це може бути корисним, коли 32\-бітовий виконуваний файл має доступ +до простору адрес у 4\ ГіБ (2 GiB на MIPS32), хоча, сподіваємося, не +зашкодить і в інших випадках. +.IP "" +Див. також розділ \fBВикористання пам'яті\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIобмеження\fP +Встановити обмеження пам'яті на розпаковування. це також вплине на режим +\fB\-\-list\fP. Якщо дія є неможливою без перевищення \fIобмеження\fP, \fBxz\fP покаже +повідомлення про помилку і розпаковування файла не +відбудеться. Див. \fB\-\-memlimit\-compress=\fP\fIобмеження\fP, щоб дізнатися більше +про те, як можна задати \fIобмеження\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIобмеження\fP +Встановити обмеження використання пам'яті для багатопотокового +розпаковування. Це може вплинути лише на кількість потоків обробки; це +ніколи не призводитиме до відмови \fBxz\fP у розпаковуванні файла. Якщо +\fIобмеження є надто низьким\fP, щоб уможливити будь\-яку багатопотокову +обробку, \fIобмеження\fP буде проігноровано, і \fBxz\fP продовжить обробку в +однопотоковому режимі. Зауважте, що якщо використано також +\fB\-\-memlimit\-decompress\fP, цей параметр буде застосовано до обох режимів, +однопотокового та багатопотокового, а отже, задіяне \fIобмеження\fP для +багатопотокового режиму ніколи не перевищуватиме обмеження, яке встановлено +за допомогою \fB\-\-memlimit\-decompress\fP. +.IP "" +На відміну від інших параметрів обмеження використання пам'яті, +\fB\-\-memlimit\-mt\-decompress=\fP\fIобмеження\fP містить специфічне для системи +типове значення \fIобмеження\fP. Можна скористатися \fBxz \-\-info\-memory\fP для +перегляду поточного значення. +.IP "" +Цей параметр і його типове значення існують, оскільки без будь\-яких обмежень +засіб розпакування зі підтримкою потокової обробки міг би намагатися +отримати величезний об'єм пам'яті для деяких файлів вхідних даних. Якщо +типове \fIобмеження\fP є надто низьким для вашої системи, не вагайтеся і +збільшуйте \fIобмеження\fP, але ніколи не встановлюйте для нього значення, яке +є більшим за придатний до користування об'єм оперативної пам'яті, оскільки +за відповідних файлів вхідних даних \fBxz\fP спробує скористатися цим об'ємом +пам'яті, навіть із низькою кількістю потоків обробки. Вичерпання об'єму +оперативної пам'яті або використання резервної пам'яті на диску не покращить +швидкодію системи під час розпаковування. +.IP "" +Див. \fB\-\-memlimit\-compress=\fP\fIобмеження\fP, щоб ознайомитися із можливими +способами визначення \fIобмеження\fP. Встановлення для \fIобмеження\fP значення +\fB0\fP відновлює типове специфічне для системи значення \fIобмеження\fP. +.TP +\fB\-M\fP \fIобмеження\fP, \fB\-\-memlimit=\fP\fIобмеження\fP, \fB\-\-memory=\fP\fIобмеження\fP +Є еквівалентом визначення \fB\-\-memlimit\-compress=\fP\fIобмеження\fP +\fB\-\-memlimit\-decompress=\fP\fIобмеження\fP +\fB\-\-memlimit\-mt\-decompress=\fP\fIобмеження\fP. +.TP +\fB\-\-no\-adjust\fP +Показати повідомлення про помилку і завершити роботу, якщо не вдасться +виконати умови щодо обмеження використання пам'яті без коригування +параметрів, які впливають на стиснених виведених даних. Тобто це забороняє +\fBxz\fP перемикати кодувальник з багатопотокового режиму на однопотоковий +режим і зменшувати розмір словника LZMA2. Навіть якщо використано цей +параметр, кількість потоків може бути зменшено для виконання обмеження на +використання пам'яті, оскільки це не вплине на результати стискання. +.IP "" +Автоматичне коригування завжди буде вимкнено при створенні потоків +необроблених даних (\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fIпотоки\fP, \fB\-\-threads=\fP\fIпотоки\fP +Вказати кількість потоків обробки, якими слід скористатися. Встановлення для +аргументу \fIпотоки\fP особливого значення \fB0\fP наказує \fBxz\fP використати не +більше потоків обробки, ніж передбачено підтримку у процесорах +системи. Справжня кількість потоків може бути меншою за значення \fIпотоки\fP, +якщо файл вхідних даних не є достатньо великим для поділу на потоки обробки +при заданих параметрах або якщо використання додаткових потоків призведе до +перевищення обмеження на використання пам'яті. +.IP "" +Засоби стискання в однопотоковому та багатопотоковому режимі дають різні +результати. Однопотоковий засіб стискання дасть найменший розмір файла, але +лише результати роботи багатопотокового засобу стискання може бути +розпаковано з використанням декількох потоків. Встановлення для аргументу +\fIпотоки\fP значення \fB1\fP призведе до використання однопотокового +режиму. Встановлення для аргументу \fIпотоки\fP будь\-якого іншого значення, +включно з \fB0\fP, призведе до використання багатопотокового засобу стискання, +навіть якщо у системі передбачено підтримки лише одного апаратного потоку +обробки даних. (Версія \fBxz\fP 5.2.x у цьому випадку використовувала +однопотоковий режим.) +.IP "" +Щоб скористатися багатопотоковим режимом із лише одним потоком обробки, +встановіть для аргументу \fIпотоки\fP значення \fB+1\fP. Префікс \fB+\fP не впливає +на значення, окрім \fB1\fP. Обмеження на використання пам'яті можуть перемкнути +\fBxz\fP в однопотоковий режим, якщо не використано параметр +\fB\-\-no\-adjust\fP. Підтримку \fB+\fP prefix було додано у версії \fBxz\fP 5.4.0. +.IP "" +Якщо було вказано автоматичне визначення кількості потоків і не вказано +обмеження на використання пам'яті, буде використано специфічне для системи +типове м'яке обмеження для можливого обмеження кількості потоків обробки. Це +обмеження є м'яким у сенсі того, що його буде проігноровано, якщо кількість +потоків зрівняється з одиницею, а отже, м'яке обмеження ніколи не +запобігатиму у \fBxz\fP стисканню або розпаковуванню. Це типове м'яке обмеження +не перемкне \fBxz\fP з багатопотокового режиму на однопотоковий режим. Активні +обмеження можна переглянути за допомогою команди \fBxz \-\-info\-memory\fP. +.IP "" +У поточній версії єдиним способом поділу на потоки обробки є поділ вхідних +даних на блоки і стискання цих блоків незалежно один від одного. Типовий +розмір блоку залежить від рівня стискання. Його може бути перевизначено за +допомогою параметра \fB\-\-block\-size=\fP\fIрозмір\fP. +.IP "" +Розпакування з потоками обробки працює лише для файлів, які містять декілька +блоків із даними щодо розміру у заголовках блоків. Цю умову задовольняють +усі достатньо великі файли, які стиснено у багатопотоковому режимі, але не +задовольняють будь\-які файли, які було стиснуто у однопотоковому режимі, +навіть якщо було використано параметр \fB\-\-block\-size=\fP\fIрозмір\fP. +.IP "" +Типовим значенням для \fIпотоків\fP є \fB0\fP. У \fBxz\fP 5.4.x та старіших версіях +типовим значенням є \fB1\fP. +. +.SS "Нетипові ланцюжки фільтрів засобу стискання" +Нетиповий ланцюжок фільтрування уможливлює докладне визначення параметрів +стискання замість використання параметрів, які пов'язано із наперед +визначеними рівнями стискання. Якщо вказано нетиповий ланцюжок фільтрів, +параметри рівнів стискання (\fB\-0\fP \&...\& \fB\-9\fP і \fB\-\-extreme\fP), які +передують їм у рядку команди, буде знехтувано. Якщо параметр рівня стискання +вказано після одного або декількох параметрів нетипового ланцюжка фільтрів, +буде використано рівень стискання, а попередніми параметрами ланцюжка +фільтрування буде знехтувано. +.PP +Ланцюжок фільтрів можна порівняти із конвеєром у командному рядку. При +стисканні нестиснені вхідні дані потрапляють до першого фільтра, виведені +ним дані йдуть до наступного фільтра (якщо такий є). Виведені останнім +фільтром дані буде записано до стисненого файла. Максимальна кількість +фільтрів у ланцюжку дорівнює чотирьом, але у типовому ланцюжку фільтрів +використовують один або два фільтри. +.PP +У багатьох фільтрів є обмеження на місце перебування у ланцюжку фільтрів: +деякі фільтри можуть працювати, лише якщо вони є останніми у ланцюжку, +деякі, лише якщо не останніми, а деякі працюють у будь\-якій позиції +ланцюжка. Залежно від фільтра, це обмеження є наслідком структури фільтра +або існує для запобігання проблем із захистом. +.PP +Нетиповий ланцюжок фільтрів можна вказати двома різними способами. Параметри +\fB\-\-filters=\fP\fIфільтри\fP і \fB\-\-filters1=\fP\fIфільтри\fP \&...\& +\fB\-\-filters9=\fP\fIфільтри\fP надають змогу вказати цілий ланцюжок фільтрів в +одному варіанті з використанням синтаксису рядків фільтрів liblzma. Крім +того, ланцюжок фільтрів можна вказати за допомогою одного або кількох +окремих параметрів фільтрування у тому порядку, в якому їх слід використати +у ланцюжку фільтрів. Тобто порядок окремих параметрів фільтра є важливим! +Під час декодування необроблених потоків (\fB\-\-format=raw\fP) ланцюжок фільтрів +має бути вказано у тому ж порядку, що й під час стиснення. Будь\-який окремий +фільтр або параметри попереднього налаштування, вказані перед параметром +повного ланцюжка (\fB\-\-filters=\fP\fIфільтри\fP), буде відкинуто. Окремі фільтри, +указані після параметра повного ланцюжка, відновлять типовий ланцюжок +фільтрів. +.PP +І параметр повного і параметр окремого фільтра приймають специфічні для +фільтрів \fIпараметри\fP у форматі списку значень, які відокремлено +комами. Зайві коми у \fIпараметрах\fP буде проігноровано. У кожного параметра є +типове значення, отже, вам слід вказати ті параметри, значення яких ви +хочете змінити. +.PP +Щоб переглянути увесь ланцюжок фільтрів та \fIпараметри\fP, скористайтеся +командою \fBxz \-vv\fP (тобто, скористайтеся \fB\-\-verbose\fP двічі). Це працює +також для перегляду параметрів ланцюжка фільтрів, який використано у рівнях +стискання. +.TP +\fB\-\-filters=\fP\fIфільтри\fP +Визначає повний ланцюжок фільтрів або шаблон у форматі одного +параметра. Кожен фільтр можна відокремити від інших пробілами або двома +дефісами (\fB\-\-\fP). Можливо, \fIфільтри\fP доведеться взяти в лапки в командному +рядку оболонки, щоб їх було оброблено як один параметр. Для позначення +\fIпараметрів\fP скористайтеся \fB:\fP або \fB=\fP. До шаблона можна додати префікс +\fB\-\fP і завершити без прапорців або декількома прапорцями. Єдиним +підтримуваним прапорцем є \fBe\fP для застосування тих самих параметрів, що й +\fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIфільтри\fP ... \fB\-\-filters9\fP=\fIфільтри\fP +Вказати до дев'яти додаткових ланцюжків фільтрів, якими можна скористатися +за допомогою \fB\-\-block\-list\fP. +.IP "" +Наприклад, якщо виконується стискання архіву із виконуваними файлами, за +якими йдуть текстові файли, для виконуваної частини може бути використано +ланцюжок фільтрів з фільтром BCJ, а для текстової частини — лише фільтр +LZMA2. +.TP +\fB\-\-filters\-help\fP +Вивести довідкове повідомлення з описом того, як вказати шаблони та нетипові +ланцюжки фільтрів у параметри \fB\-\-filters\fP і \fB\-\-filters1=\fP\fIфільтри\fP +\&...\& \fB\-\-filters9=\fP\fIфільтри\fP і завершити роботу із кодом успіху. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIпараметри\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIпараметри\fP] +.PD +Додати фільтр LZMA1 або LZMA2 до ланцюжка фільтрів. Ці фільтри може бути +використано лише як останній фільтр у ланцюжку. +.IP "" +LZMA1 є застарілим фільтром, підтримку якого збережено майже лише через +використання формату файлів \fB.lzma\fP, у яких передбачено підтримку лише +LZMA1. LZMA2 є оновленою версією LZMA1, у якій виправлено деякі практичні +вади LZMA1. У форматі \fB.xz\fP використано LZMA2 і взагалі не передбачено +підтримки LZMA1. Швидкість стискання та коефіцієнт стискання для LZMA1 і +LZMA2 є практично однаковими. +.IP "" +LZMA1 і LZMA2 спільно використовують той самий набір \fIпараметрів\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIшаблон\fP +Скинути усі \fIпараметри\fP LZMA1 або LZMA2 до параметрів \fIшаблона\fP. Аргумент +\fIшаблон\fP складається з цілого числа, після якого може бути однолітерний +модифікатор шаблона. Ціле число може належати лише діапазону від \fB0\fP до +\fB9\fP, що відповідає параметрам командного рядка \fB\-0\fP \&...\& \fB\-9\fP. Єдиним +підтримуваним модифікатором у поточній версії є \fBe\fP, щоб відповідає +параметру \fB\-\-extreme\fP. Якщо аргумент \fBшаблон\fP не вказано, типові значення +\fIпараметрів\fP LZMA1 або LZMA2 буде взято із шаблона \fB6\fP. +.TP +\fBdict=\fP\fIрозмір\fP +Параметр \fIрозміру\fP словника (буфера журналу) визначає, скільки байтів +нещодавно оброблених нестиснених даних слід зберігати у пам'яті. Алгоритм +намагається знайти повторювані послідовності байтів (відповідники) у +нестиснених даних і замінити їх на посилання на дані зі словника. Чим +більшим є словник, тим вищою є ймовірність відшукати відповідник. Отже, +збільшення \fIрозміру\fP словника, зазвичай, покращує коефіцієнт стискання, але +використання словника, розмір якого перевищу є розмір нестисненого файла є +простоюю витратою пам'яті. +.IP "" +\fIРозмір\fP типового словника складає від 64\ КіБ до 64\ МіБ. Мінімальним є +розмір 4\ КіБ. Максимальним розміром для стискання у поточній версії 1.5\ ГіБ (1536\ МіБ). У засобі розпаковування вже передбачено підтримку словників +на один байт менших за 4\ ГіБ, що є максимальним значенням для форматів +потоків даних LZMA1 і LZMA2. +.IP "" +Аргумент \fIрозміру\fP словника і засіб пошуку відповідників (\fImf\fP) разом +визначають параметри використання пам'яті для кодувальника LZMA1 або +LZMA2. Для розпаковування потрібен такий самий (або більший) \fIрозмір\fP +словника, що і для стискання, отже, використання пам'яті для засобу +розпаковування буде визначено за розміром словника, який було використано +для стискання. У заголовках \fB.xz\fP зберігається \fIрозмір\fP словника або як +2^\fIn\fP, або як 2^\fIn\fP + 2^(\fIn\fP\-1), отже, ці \fIрозміри\fP є дещо пріоритетними +для стискання. Інші \fIрозміри\fP буде отримано округленням при зберіганні у +заголовках \fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Визначає кількість буквальних контекстних бітів. Мінімальною кількістю є 0, +а максимальною — 4. Типовою кількістю є 3. Крім того, сума \fIlc\fP і \fIlp\fP має +не перевищувати 4. +.IP "" +Усі байти, які не може бути закодовано як відповідності, буде закодовано як +літерали. Тобто літерали є просто 8\-бітовими байтами, які буде закодовано по +одному за раз. +.IP "" +При кодуванні літералів роблять припущення, що найвищі біти \fIlc\fP +попереднього нестисненого байта корелюють із наступним байтом. Наприклад, у +типовому тексті англійською за літерою у верхньому регістрі йде літера у +нижньому регістрі, а за літерою у нижньому регістрі, зазвичай, йде інша +літера у нижньому регістрі. У наборі символів US\-ASCII найвищими трьома +бітами є 010 для літер верхнього регістру і 011 для літер нижнього +регістру. Якщо \fIlc\fP дорівнює принаймні 3, при кодуванні літералів можна +отримати перевагу встановлення цієї властивості для нестиснених даних. +.IP "" +Зазвичай, типового значення (3) достатньо. Якщо вам потрібне максимальне +стискання, спробуйте \fBlc=4\fP. Іноді це трохи допомагає, а іноді, робить +стискання гіршим. Якщо стискання стане гіршим, спробуйте також \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Визначає кількість буквальних позиційних бітів. Мінімальною кількістю є 0, а +максимальною — 4. Типовою кількістю є 0. +.IP "" +\fILp\fP впливає на те, яке вирівнювання у нестиснених даних слід припускати +при кодуванні літералів. Див. \fIpb\fP нижче, щоб дізнатися більше про +вирівнювання. +.TP +\fBpb=\fP\fIpb\fP +Визначає кількість позиційних бітів. Мінімальною кількістю є 0, а +максимальною — 4. Типовою кількістю є 2. +.IP "" +\fIPb\fP впливає на те, який тип вирівнювання загалом припускатиметься для +нестиснених даних. Типовим є чотирибайтове вирівнювання (2^\fIpb\fP=2^2=4), +яке, зазвичай, є добрим варіантом, якщо немає кращих припущень. +.IP "" +Якщо вирівнювання є відомим, встановлення відповідним чином \fIpb\fP може трохи +зменшити розмір файла. Наприклад, у текстових файлах із однобайтовим +вирівнюванням (US\-ASCII, ISO\-8859\-*, UTF\-8), встановлення значення \fBpb=0\fP +може трохи поліпшити стискання. Для тексту UTF\-16 добрим варіантом є +\fBpb=1\fP. Якщо вирівнювання є непарним числом, наприклад 3 байти, найкращим +вибором, ймовірно, є \fBpb=0\fP. +.IP "" +Хоча прогнозоване вирівнювання можна скоригувати за допомогою \fIpb\fP і \fIlp\fP, +у LZMA1 і LZMA2 дещо пріоритетним є 16\-байтове вирівнювання. Це, ймовірно, +слід враховувати при компонуванні форматів файлів, які, ймовірно, часто +будуть стискатися з використанням LZMA1 або LZMA2. +.TP +\fBmf=\fP\fImf\fP +Засіб пошуку відповідників має значний вплив на швидкість, використання +пам'яті та коефіцієнт стискання кодувальника. Зазвичай, засоби пошуку +відповідників на основі ланцюжка хешів є швидшими за засоби пошуку +відповідників на основі двійкового дерева. Типовий засіб залежить від +\fIшаблона\fP: для 0 використовують \fBhc3\fP, для 1\(en3 — \fBhc4\fP, а для решти +використовують \fBbt4\fP. +.IP "" +Передбачено підтримку вказаних нижче засобів пошуку відповідників. Наведені +нижче формули обчислення використання пам'яті є грубими наближеннями, які є +найближчими до реальних значень, якщо значенням \fIсловник\fP є степінь двійки. +.RS +.TP +\fBhc3\fP +Ланцюжок хешів із 2\- та 3\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 3 +.br +Використання пам'яті: +.br +\fIdict\fP * 7.5 (якщо \fIdict\fP <= 16 МіБ); +.br +\fIdict\fP * 5.5 + 64 МіБ (якщо \fIdict\fP > 16 МіБ) +.TP +\fBhc4\fP +Ланцюжок хешів із 2\-, 3\- та 4\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 4 +.br +Використання пам'яті: +.br +\fIdict\fP * 7.5 (якщо \fIdict\fP <= 32 МіБ); +.br +\fIdict\fP * 6.5 (якщо \fIdict\fP > 32 МіБ) +.TP +\fBbt2\fP +Двійкове дерево із 2\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 2 +.br +Використання пам'яті: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Двійкове дерево із 2\- і 3\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 3 +.br +Використання пам'яті: +.br +\fIdict\fP * 11.5 (якщо \fIdict\fP <= 16 МіБ); +.br +\fIdict\fP * 9.5 + 64 МіБ (якщо \fIdict\fP > 16 МіБ) +.TP +\fBbt4\fP +Двійкове дерево із 2\-, 3\- і 4\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 4 +.br +Використання пам'яті: +.br +\fIdict\fP * 11.5 (якщо \fIdict\fP <= 32 МіБ); +.br +\fIdict\fP * 10.5 (якщо \fIdict\fP > 32 МіБ) +.RE +.TP +\fBmode=\fP\fIрежим\fP +Параметр \fIрежиму\fP стискання визначає спосіб, який буде використано для +аналізу даних, які створено засобом пошуку відповідників. Підтримуваними +\fIрежимами\fP є \fBfast\fP (швидкий) і \fBnormal\fP (нормальний). Типовим є режим +\fBfast\fP для \fIшаблонів\fP 0\(en3 і режим \fBnormal\fP для \fIшаблонів\fP 4\(en9. +.IP "" +Зазвичай, із засобом пошуку відповідників на основі ланцюжка хешів +використовують \fBfast\fP, а із засобом пошуку відповідників на основі +двійкового дерева використовують \fBnormal\fP. Так само налаштовано і +\fIшаблони\fP. +.TP +\fBnice=\fP\fIпріоритетність\fP +Вказати, яка довжина є пріоритетною для відповідності. Щойно буде виявлено +відповідність у принаймні \fIпріоритетність\fP байтів, алгоритм зупинятиме +пошук можливих кращих відповідників. +.IP "" +\fIПріоритетністю\fP може бути число до 2\(en273 байтів. Вищі значення дають +кращий коефіцієнт стискання за рахунок швидкості. Типове значення залежить +від \fIшаблона\fP. +.TP +\fBdepth=\fP\fIглибина\fP +Вказати максимальну глибину пошуку у засобі пошуку відповідності. Типовим є +особливе значення 0, яке наказує засобу стискання визначити прийнятну +\fIглибину\fP на основі \fImf\fP і \fIпріоритетності\fP. +.IP "" +Прийнятним значенням \fIглибини\fP для ланцюжків хешів є 4\(en100 і 16\(en1000 +для двійкових дерев. Використання дуже високих значень для \fIглибини\fP може +зробити кодувальник дуже повільним для деяких файлів. Не встановлюйте +значення \fIглибини\fP, що перевищує 1000, якщо ви не готові перервати +стискання, якщо воно триватиме надто довго. +.RE +.IP "" +При декодуванні необроблених потоків даних (\fB\-\-format=raw\fP), LZMA2 потребує +лише \fIрозміру\fP словника. LZMA1 потребує також \fIlc\fP, \fIlp\fP і \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIпараметри\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIпараметри\fP] +.PD +Додати фільтр гілок/викликів/переходів (branch/call/jump або BCJ) до +ланцюжка фільтрів. Цими фільтрами можна скористатися, лише якщо вони не є +останнім фільтром у ланцюжку фільтрів. +.IP "" +Фільтр BCJ перетворює відносні адреси у машинному коді на їхні абсолютні +відповідники. Це не змінює розміру даних, але підвищує резервування, що може +допомогти LZMA2 створити файл \fB.xz\fP на 0\(en15\ % менше. Фільтри BCJ завжди +є придатними до обернення, тому використання фільтра BCJ до помилкового типу +даних не спричинятиме втрати даних, хоча може дещо погіршити коефіцієнт +стискання. Фільтри BCJ є дуже швидкими і такими, що використовують незначний +об'єм пам'яті. +.IP "" +Ці фільтри BCJ мають відомі проблеми, які пов'язано із рівнем стискання: +.RS +.IP \(bu 3 +У деяких типах файлів, де зберігається виконуваний код, (наприклад, в +об'єктних файлах, статичних бібліотеках та модулях ядра Linux) адреси в +інструкціях заповнено значеннями заповнювача. Ці фільтри BCJ виконуватимуть +перетворення адрес, яке зробить стискання для цих файлів гіршим. +.IP \(bu 3 +Якщо фільтр BCJ застосовано до архіву, може так статися, що він погіршить +коефіцієнт стискання порівняно із варіантом без фільтра BCJ. Наприклад, якщо +є подібні або навіть однакові виконувані файли, фільтрування, ймовірно, +зробить ці файли менш подібними, а отже, зробить стискання гіршим. Вміст +файлів, які не є виконуваними, у тому самому архіві також може вплинути на +результат. На практиці, варто спробувати варіанти з фільтром BCJ і без +нього, щоб визначитися із тим, що буде кращим у кожній ситуації. +.RE +.IP "" +Різні набори інструкцій мають різне вирівнювання: виконуваний файл має бути +вирівняно на кратне до цього значення у вхідних даних, щоб фільтр спрацював. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Фільтр;Вирівнювання;Нотатки +x86;1;32\-бітова або 64\-бітова x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;Найкращим є вирівнювання за +;;4096 байтами +PowerPC;4;Лише зворотний порядок байтів +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Оскільки фільтровані BCJ дані, зазвичай, стискають за допомогою LZMA2, +коефіцієнт стискання можна трохи поліпшити, якщо параметри LZMA2 буде +встановлено так, щоб вони відповідали вирівнюванню вибраного фільтра +BCJ. Приклади: +.RS +.IP \(bu 3 +Фільтр IA\-64 має 16\-байтове вирівнювання, отже \fBpb=4,lp=4,lc=0\fP дасть добрі +результати у поєднанні із LZMA2 (2^4=16). +.IP \(bu 3 +Код RISC\-V має 2\-байтове або 4\-байтове вирівнювання залежно від того, чи +містить файл 16\-бітові стислі інструкції (розширення C). Якщо використано +16\-бітові інструкції, добрі результати дасть \fBpb=2,lp=1,lc=3\fP або +\fBpb=1,lp=1,lc=3\fP. Якщо 16\-бітових інструкцій немає, найкращим варіантом є +\fBpb=2,lp=2,lc=2\fP. Можна скористатися \fBreadelf \-h\fP, щоб перевірити, чи є +"RVC" у рядку "Flags". +.IP \(bu 3 +ARM64 завжди вирівняно на 4 байти, тому найкращим варіантом буде +\fBpb=2,lp=2,lc=2\fP. +.IP \(bu 3 +Фільтр x86 є виключенням. Зазвичай, добрі результати дають типові для LZMA2 +значення (\fBpb=2,lp=0,lc=3\fP), якщо стискають виконувані файли x86. +.RE +.IP "" +У всіх фільтрах BCJ передбачено підтримку тих самих \fIпараметрів\fP: +.RS +.TP +\fBstart=\fP\fIзсув\fP +Встановити початковий \fIзсув\fP, який буде використано при перетворенні між +відносною та абсолютною адресами. Значення \fIзсув\fP має бути кратним до +вирівнювання фільтра (див. таблицю вище). Типовим зсувом є нульовий. На +практиці, типове значення є прийнятним; визначення нетипового значення +\fIзсув\fP майже завжди нічого корисного не дає. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIпараметри\fP] +Додати дельта\-фільтр до ланцюжка фільтрів. Дельта\-фільтр може бути +використано, лише якщо він не є останнім у ланцюжку фільтрів. +.IP "" +У поточній версії передбачено підтримку обчислення лише простої побітової +дельти. Це може бути корисним при стисканні, наприклад, нестиснутих +растрових зображень або нестиснутих звукових даних PCM. Втім, спеціалізовані +алгоритми можуть давати значно кращі результати за дельту + LZMA2. Це +правило особливо стосується звукових даних, які стискає швидше і краще, +наприклад, \fBflac\fP(1). +.IP "" +Підтримувані \fIпараметри\fP: +.RS +.TP +\fBdist=\fP\fIвідстань\fP +Вказати \fIвідстань\fP обчислень різниці у байтах. Значення \fIвідстань\fP має +потрапляти у діапазон 1\(en256. Типовим значенням є 1. +.IP "" +Наприклад, з \fBdist=2\fP та восьмибайтовими вхідними даними A1 B1 A2 B3 A3 B5 +A4 B7, результатом буде A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Інші параметри" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Придушити попередження та сповіщення. Вкажіть цей параметр двічі, щоб +придушити також повідомлення про помилки. Цей параметр не впливає на стан +виходу з програми. Тобто, навіть якщо було придушено попередження, стан +виходу вказуватиме на те, що попередження були. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Докладний режим повідомлень. Якщо стандартне виведення помилок з'єднано із +терміналом, \fBxz\fP показуватиме індикатор поступу. Використання \fB\-\-verbose\fP +двічі призведе до ще докладнішого виведення. +.IP "" +Індикатор поступу показує такі дані: +.RS +.IP \(bu 3 +Частку завершеності буде показано, якщо відомий розмір файла вхідних +даних. Тобто, для каналів даних частку не може бути показано. +.IP \(bu 3 +Об'єм стиснених виведених даних (стискання) або оброблених (розпаковування). +.IP \(bu 3 +Об'єм незапакованих даних (стискання) або виведених даних (розпаковування). +.IP \(bu 3 +Коефіцієнт стискання, який обчислено діленням об'єму оброблених стиснутих +даних на об'єм оброблених нестиснутих даних. +.IP \(bu 3 +Швидкість стискання або розпаковування. Обчислюється як об'єм нестиснутих +даних (стискання) або виведених даних (розпаковування) за секунду. Його буде +показано за декілька секунд з моменту, коли \fBxz\fP почала обробляти файл. +.IP \(bu 3 +Витрачений час у форматі Х:СС або Г:ХХ:СС. +.IP \(bu 3 +Оцінку часу, що лишився, буде показано, лише якщо розмір файла вхідних даних +є відомим, і минуло принаймні декілька секунд з моменту, коли \fBxz\fP почала +обробляти файл. Час буде показано у менш точному форматі, без двокрапок, +наприклад, 2 хв. 30 с. +.RE +.IP "" +Якщо стандартним виведенням помилок не є термінал, \fB\-\-verbose\fP призведе до +того, що \fBxz\fP виведе назву файла, стиснений розмір, нестиснений розмір, +коефіцієнт стискання та, можливо, також швидкість та витрачений час у одному +рядку до стандартного виведення помилок після стискання або розпаковування +файла. Швидкість та витрачений час буде включено, лише якщо дія триває +принаймні декілька секунд. Якщо дію не буде завершено, наприклад, через +втручання користувача, буде також виведено частку виконання, якщо відомий +розмір файла вхідних даних. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Не встановлювати стан виходу 2, навіть якщо було виявлено відповідність +умові, яка варта попередження. Цей параметр не впливає на рівень докладності +повідомлень, отже, слід використати \fB\-\-quiet\fP і \fB\-\-no\-warn\fP, щоб програма +не показувала попереджень і не змінювала стан виходу. +.TP +\fB\-\-robot\fP +Виводити повідомлення у придатному для обробки комп'ютером форматі. Цей +формат призначено для полегшення написання оболонок, які використовуватимуть +\fBxz\fP замість liblzma, що може бути зручним для різноманітних +скриптів. Виведені дані з цим параметром має бути стабільним для усіх +випусків \fBxz\fP. Докладніший опис можна знайти у розділі \fBРЕЖИМ РОБОТА\fP. +.TP +\fB\-\-info\-memory\fP +Вивести у придатному для читання людиною форматі, скільки фізичної пам'яті +(RAM) та скільки потоків процесора є за даними \fBxz\fP у системі, обмеження +для стискання та розпаковування, а потім успішно завершити роботу. +.TP +\fB\-h\fP, \fB\-\-help\fP +Вивести повідомлення про помилку з описом найбільш типових використаних +параметрів і успішно завершити роботу. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Вивести довідкове повідомлення з описом усіх можливостей \fBxz\fP і успішно +завершити роботу +.TP +\fB\-V\fP, \fB\-\-version\fP +Вивести номер версії \fBxz\fP та liblzma у зручному для читання форматі. Щоб +отримати дані, зручні для обробки на комп'ютері, вкажіть \fB\-\-robot\fP до +\fB\-\-version\fP. +. +.SH "РЕЖИМ РОБОТА" +Режим робота активують за допомогою параметра \fB\-\-robot\fP. Він спрощує +обробку виведених \fBxz\fP даних іншими програмами. У поточній версії підтримку +\fB\-\-robot\fP передбачено лише разом із \fB\-\-list\fP, \fB\-\-filters\-help\fP, +\fB\-\-info\-memory\fP і \fB\-\-version\fP. У майбутньому підтримку параметра буде +передбачено для стискання та розпаковування. +. +.SS "Режим списку" +У \fBxz \-\-robot \-\-list\fP використано табуляції для поділу виведених +даних. Першим стовпчиком у кожному рядку є рядок, що вказує на тип +відомостей, які можна знайти у цьому рядку: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Це завжди перший рядок на початку списку файла. Другим стовпчиком у рядку є +назва файла. +.TP +\fBfile\fP +У цьому рядку містяться загальні відомості щодо файла \fB.xz\fP. Цей рядок +завжди виводять після рядка \fBname\fP. +.TP +\fBstream\fP +Цей тип рядка використовують, лише якщо було вказано \fB\-\-verbose\fP. Буде +стільки рядків \fBstream\fP, скільки потоків у файлі \fB.xz\fP. +.TP +\fBblock\fP +Цей тип рядка використовують, лише якщо було вказано \fB\-\-verbose\fP. Буде +стільки рядків \fBblock\fP, скільки блоків у файлі \fB.xz\fP. Рядки \fBblock\fP буде +показано після усіх рядків \fBstream\fP; різні типи рядків не перемежовуються. +.TP +\fBsummary\fP +Цей тип рядків використовують, лише якщо \fB\-\-verbose\fP було вказано +двічі. Цей рядок буде виведено після усіх рядків \fBblock\fP. Подібно до рядка +\fBfile\fP, рядок \fBsummary\fP містить загальні відомості щодо файла \fB.xz\fP. +.TP +\fBtotals\fP +Цей рядок завжди є найостаннішим рядком у виведеному списку. У ньому буде +показано загальні кількості та розміри. +.PP +Стовпчики у рядках \fBфайла\fP: +.PD 0 +.RS +.IP 2. 4 +Кількість потоків у файлі +.IP 3. 4 +Загальна кількість блоків у потоках +.IP 4. 4 +Розмір стисненого файла +.IP 5. 4 +Розмір нестисненого файла +.IP 6. 4 +Коефіцієнт стискання, наприклад, \fB0.123\fP. Якщо коефіцієнт перевищує 9.999, +замість коефіцієнта буде показано дефіси (\fB\-\-\-\fP). +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Список відокремлених комами назв перевірок цілісності. Наведені нижче рядки +використовують для відомих типів перевірок: \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP і +\fBSHA\-256\fP. Для невідомих типів перевірок буде використано \fBUnknown\-\fP\fIN\fP, +де \fIN\fP є ідентифікатором перевірки у форматі десяткового числа (одна або +дві цифри). +.IP 8. 4 +Загальний розмір доповнення потоку у файлі +.RE +.PD +.PP +Стовпчики у рядках \fBstream\fP: +.PD 0 +.RS +.IP 2. 4 +Номер потоку (перший потік має номер 1) +.IP 3. 4 +Кількість блоків у потоці +.IP 4. 4 +Зсув початку стисненого +.IP 5. 4 +Зсув початку нестисненого +.IP 6. 4 +Стиснений розмір (не включає доповнення потоку) +.IP 7. 4 +Нестиснутий розмір +.IP 8. 4 +Рівень стискання +.IP 9. 4 +Назва перевірки цілісності +.IP 10. 4 +Розмір доповнення потоку +.RE +.PD +.PP +Стовпчики у рядках \fBblock\fP: +.PD 0 +.RS +.IP 2. 4 +Номер потоку, що містить цей блок +.IP 3. 4 +Номер блоку відносно початку потоку (перший блок має номер 1) +.IP 4. 4 +Номер блоку відносно початку файла +.IP 5. 4 +Зсув початку стисненого відносно початку файла +.IP 6. 4 +Зсув початку нестисненого відносно початку файла +.IP 7. 4 +Загальний стиснений розмір блоку (включено з заголовками) +.IP 8. 4 +Нестиснутий розмір +.IP 9. 4 +Рівень стискання +.IP 10. 4 +Назва перевірки цілісності +.RE +.PD +.PP +Якщо \fB\-\-verbose\fP було вказано двічі, до рядків \fBblock\fP буде включено +додаткові стовпчики. Ці стовпчики не буде показано, якщо вказано одинарний +параметр \fB\-\-verbose\fP, оскільки отримання цих відомостей потребує багатьох +позиціювань, а ця процедура може бути повільною: +.PD 0 +.RS +.IP 11. 4 +Значення перевірки цілісності у шістнадцятковій формі +.IP 12. 4 +Розмір заголовка блоку +.IP 13. 4 +Прапорці блоку: \fBc\fP вказує, що наявний стиснений розмір, а \fBu\fP вказує, що +наявний нестиснений розмір. Якщо прапорець не встановлено, буде показано +(\fB\-\fP) замість підтримання фіксованого розміру рядка. У майбутньому +наприкінці рядка може бути додано нові прапорці. +.IP 14. 4 +Розмір справжніх стиснених даних у блоці (це включає заголовок блоку, +доповнення блоку та поля перевірок) +.IP 15. 4 +Об'єм пам'яті (у байтах), який потрібен для розпаковування цього блоку за +допомогою цієї версії \fBxz\fP +.IP 16. 4 +Ланцюжок фільтрів. Зауважте, що більшість параметрів, які використано під +час стискання, не є наперед відомим, оскільки у заголовках \fB.xz\fP +зберігаються лише параметри, які потрібні для розпаковування. +.RE +.PD +.PP +Стовпчики у рядках \fBsummary\fP: +.PD 0 +.RS +.IP 2. 4 +Об'єм пам'яті (у байтах), який потрібен для розпаковування цього файла за +допомогою цієї версії \fBxz\fP +.IP 3. 4 +\fByes\fP або \fBno\fP вказує, якщо усі заголовки блоків містять одразу стиснений +розмір та розпакований розмір +.PP +\fIПочинаючи з\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Мінімальна версія \fBxz\fP, яка потрібна для розпаковування файла +.RE +.PD +.PP +Стовпчики рядка \fBtotals\fP: +.PD 0 +.RS +.IP 2. 4 +Кількість потоків +.IP 3. 4 +Кількість блоків +.IP 4. 4 +Стиснутий розмір +.IP 5. 4 +Нестиснутий розмір +.IP 6. 4 +Середній коефіцієнт стискання +.IP 7. 4 +Список відокремлених комами назв перевірок цілісності, результати яких +наявні у файлах +.IP 8. 4 +Розмір доповнення потоку +.IP 9. 4 +Кількість файлів. Наявний тут для зберігання такого самого порядку +стовпчиків, що і у попередніх рядках \fBfile\fP. +.PD +.RE +.PP +Якщо \fB\-\-verbose\fP було вказано двічі, до рядка \fBtotals\fP буде включено +додаткові стовпчики: +.PD 0 +.RS +.IP 10. 4 +Максимальний об'єм пам'яті (у байтах), який потрібен для розпаковування +файлів за допомогою цієї версії \fBxz\fP +.IP 11. 4 +\fByes\fP або \fBno\fP вказує, якщо усі заголовки блоків містять одразу стиснений +розмір та розпакований розмір +.PP +\fIПочинаючи з\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Мінімальна версія \fBxz\fP, яка потрібна для розпаковування файла +.RE +.PD +.PP +У майбутніх версіях може бути додано нові типи рядків і нові стовпчики до +наявних типів рядків, але наявні стовпчики мають лишитися незмінними. +. +.SS "Довідка з фільтрування" +\fBxz \-\-robot \-\-filters\-help\fP виведе список підтримуваних фільтрів у такому +форматі: +.PP +\fIфільтр\fP\fB:\fP\fIпараметр\fP\fB=<\fP\fIзначення\fP\fB>,\fP\fIпараметр\fP\fB=<\fP\fIзначення\fP\fB>\fP... +.TP +\fIфільтр\fP +Назва фільтра +.TP +\fIпараметр\fP +Назва специфічного для фільтра параметра +.TP +\fIзначення\fP +Числові діапазони \fIvalue\fP слід вказати у форматі +\fB<\fP\fIмінімум\fP\fB\-\fP\fIмаксимум\fP\fB>\fP. Варіанти рядка \fIзначення\fP +показано у \fB< >\fP і відокремлено символом \fB|\fP. +.PP +Кожен фільтр буде виведено до окремого рядка. +. +.SS "Дані щодо обмеження пам'яті" +\fBxz \-\-robot \-\-info\-memory\fP виводить один рядок з декількома відокремленими +табуляціями стовпчиками: +.IP 1. 4 +Загальний об'єм фізичної пам'яті (RAM) у байтах. +.IP 2. 4 +Обмеження на використання пам'яті для стискання у байтах +(\fB\-\-memlimit\-compress\fP). Особливе значення \fB0\fP вказує на типові +налаштування, якими для однопотокового режиму є налаштування без обмеження +на використання пам'яті. +.IP 3. 4 +Обмеження на використання пам'яті для розпакування у байтах +(\fB\-\-memlimit\-decompress\fP). Особливе значення \fB0\fP вказує на типові +налаштування, якими для однопотокового режиму є налаштування без обмеження +на використання пам'яті. +.IP 4. 4 +Починаючи з \fBxz\fP 5.3.4alpha: використання пам'яті для багатопотокового +розпаковування у байтах (\fB\-\-memlimit\-mt\-decompress\fP). Ніколи не дорівнює +нулеві, оскільки буде використано специфічне для системи типове значення, +яке показано у стовпчику 5, якщо обмеження не встановлено явним чином. Також +ніколи не перевищуватиме значення у стовпчику 3, навіть якщо було вказано +більше значення за допомогою \fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Починаючи з \fBxz\fP 5.3.4alpha: специфічне для системи типове обмеження на +використання пам'яті, яке використовують для обмеження кількості потоків при +стисканні з автоматичною кількістю потоків (\fB\-\-threads=0\fP) і без визначення +обмеження на використання пам'яті (\fB\-\-memlimit\-compress\fP). Це значення +також використовують як типове значення для \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Починаючи з \fBxz\fP 5.3.4alpha: кількість доступних потоків обробки процесора. +.PP +У майбутньому у виведенні \fBxz \-\-robot \-\-info\-memory\fP може бути більше +стовпчиків, але у виведеному буде не більше за один рядок. +. +.SS Версія +\fBxz \-\-robot \-\-version\fP виведе назву версії \fBxz\fP і liblzma у такому +форматі: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Основна версія. +.TP +\fIYYY\fP +Проміжна версія. Непарні номери буде використано для стабільних +версій. Непарні номери є номерами тестових версій. +.TP +\fIZZZ\fP +Рівень латання для стабільних випусків або просто лічильник для випусків, +які перебувають у розробці. +.TP +\fIS\fP +Стабільність. 0 — alpha, 1 — beta, а 2 означає «стабільна версія». \fIS\fP має +завжди дорівнювати 2, якщо \fIYYY\fP є парним. +.PP +\fIXYYYZZZS\fP є тим самим в обох рядках, якщо \fBxz\fP і liblzma належать до +одного випуску XZ Utils. +.PP +Приклади: 4.999.9beta — це \fB49990091\fP, а 5.0.0 — це \fB50000002\fP. +. +.SH "СТАН ВИХОДУ" +.TP +\fB0\fP +Усе добре. +.TP +\fB1\fP +Сталася помилка. +.TP +\fB2\fP +Сталося щось варте попередження, але справжніх помилок не сталося. +.PP +Зауваження (не попередження або помилки), які виведено до стандартного +виведення помилок, не впливають на стан виходу. +. +.SH СЕРЕДОВИЩЕ +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP обробляє списки відокремлених пробілами параметрів зі змінних +середовища \fBXZ_DEFAULTS\fP і \fBXZ_OPT\fP, перш ніж обробляти параметри з рядка +команди. Зауважте, що буде оброблено лише параметри зі змінних середовища; +усі непараметричні записи буде без повідомлень проігноровано. Обробку буде +виконано за допомогою функції \fBgetopt_long\fP(3), яку також використовують +для аргументів рядка команди. +.PP +\fBПопередження:\fP Встановлюючи ці змінні середовища, ви насправді змінюєте +програми та скрипти, які виконують \fBxz\fP. У більшості випадків без проблем +можна встановлювати обмеження на використання пам'яті, кількість потоків і +параметри стиснення за допомогою змінних середовища. Однак деякі параметри +можуть порушити роботу скриптів. Очевидним прикладом є \fB\-\-help\fP, який +змушує \fBxz\fP показувати текст довідки замість стискання або розпаковування +файла. Менш очевидними є приклади \fB\-\-quiet\fP і \fB\-\-verbose\fP. У багатьох +випадках усе працюватиме добре, якщо увімкнути індикатор поступу за +допомогою \fB\-\-verbose\fP, але у деяких ситуаціях додаткові повідомлення +створюють проблеми. Рівень докладності також впливає на поведінку \fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Специфічні для користувача або загальносистемні типові параметри. Зазвичай, +їх встановлюють у скрипті ініціалізації оболонки для типового вмикання +обмеження на використання пам'яті у \fBxz\fP або встановлення типової кількості +потоків обробки. Окрім скриптів ініціалізації оболонки і подібних особливих +випадків, не слід встановлювати або скасовувати встановлення значення +\fBXZ_DEFAULTS\fP у скриптах. +.TP +\fBXZ_OPT\fP +Цю змінну призначено для передавання параметрів до \fBxz\fP, якщо неможливо +встановити параметри безпосередньо у рядку команди \fBxz\fP. Це трапляється, +якщо \fBxz\fP запущено скриптом або інструментом, наприклад, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Скрипти можуть використовувати \fBXZ_OPT\fP, наприклад, для встановлення +специфічних типових параметрів стискання. Втім, рекомендуємо дозволити +користувачам перевизначати \fBXZ_OPT\fP, якщо це має якісь причини. Наприклад, +у скриптах \fBsh\fP(1) можна скористатися чимось таким: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "СУМІСНІСТЬ ІЗ LZMA UTILS" +Синтаксис рядка команди \fBxz\fP практично є надбудовою щодо \fBlzma\fP, \fBunlzma\fP +і \fBlzcat\fP з LZMA Utils 4.32.x. У більшості випадків можна замінити LZMA +Utils XZ Utils без порушення працездатності наявних скриптів. Втім, існують +певні несумісності, які іноді можуть спричиняти проблеми. +. +.SS "Рівні шаблонів стискання" +Нумерація у шаблонах рівнів стискання у \fBxz\fP не є тотожною до нумерації у +LZMA Utils. Найважливішою відмінністю є прив'язка розмірів словника до +різних шаблонів. Розмір словника грубо рівний використанню пам'яті у засобі +розпаковування. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Рівень;xz;LZMA Utils +\-0;256 КіБ;н/д +\-1;1 МіБ;64 КіБ +\-2;2 МіБ;1 МіБ +\-3;4 МіБ;512 КіБ +\-4;4 МіБ;1 МіБ +\-5;8 МіБ;2 МіБ +\-6;8 МіБ;4 МіБ +\-7;16 МіБ;8 МіБ +\-8;32 МіБ;16 МіБ +\-9;64 МіБ;32 МіБ +.TE +.RE +.PP +Відмінності у розмірах словників також впливають на використання пам'яті +засобом стискання, але є і інші відмінності між LZMA Utils і XZ Utils, які +роблять різницю ще помітнішою: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Рівень;xz;LZMA Utils 4.32.x +\-0;3 МіБ;н/д +\-1;9 МіБ;2 МіБ +\-2;17 МіБ;12 МіБ +\-3;32 МіБ;12 МіБ +\-4;48 МіБ;16 МіБ +\-5;94 МіБ;26 МіБ +\-6;94 МіБ;45 МіБ +\-7;186 МіБ;83 МіБ +\-8;370 МіБ;159 МіБ +\-9;674 МіБ;311 МіБ +.TE +.RE +.PP +Типовим рівнем стискання у LZMA Utils є \fB\-7\fP, а у XZ Utils — \fB\-6\fP, отже, +обидва комплекти програм типово використовують словник розміром у 8 МіБ. +. +.SS "Потокові і непотокові файл .lzma" +Розмір нестисненого файла може бути збережено у заголовку \fB.lzma\fP. LZMA +Utils зберігають дані при стисканні звичайних файлів. Альтернативним +підходом є позначення нестисненого розміру як невідомого і використання +позначки кінця вмісту для позначення місця, де засіб розпаковування має +зупинитися. У LZMA Utils цей спосіб використовують, якщо нестиснений розмір +є невідомим, що трапляється, наприклад, для конвеєрів обробки даних. +.PP +У \fBxz\fP передбачено підтримку розпаковування файлів \fB.lzma\fP з позначкою +кінця вмісту та без неї, але усі файли \fB.lzma\fP, які створено за допомогою +\fBxz\fP, використовують позначку кінця вмісту, а нестиснений розмір у +заголовку \fB.lzma\fP позначають як невідомий. Це може призвести до проблем у +деяких нетипових ситуаціях. Наприклад, розпакувальник \fB.lzma\fP у вбудованому +пристрої може працювати лише з файлами, для яких відомий нестиснений +розмір. Якщо ви зіткнулися з цією проблемою, вам слід скористатися LZMA +Utils або LZMA SDK для створення файлів \fB.lzma\fP із відомим розміром +нестиснених даних. +. +.SS "Непідтримувані файли .lzma" +У форматі \fB.lzma\fP можливі значення \fIlc\fP аж до 8 і значення \fIlp\fP аж до +4. LZMA Utils можуть розпаковувати файли із будь\-якими значеннями \fIlc\fP і +\fIlp\fP, але завжди створюють файли з \fBlc=3\fP і \fBlp=0\fP. Створення файлів з +іншими значеннями \fIlc\fP і \fIlp\fP є можливим за допомогою \fBxz\fP і LZMA SDK. +.PP +Реалізація фільтра LZMA1 у liblzma потребує, щоби сума \fIlc\fP і \fIlp\fP не +перевищувала 4. Отже, файли \fB.lzma\fP, у яких перевищено обмеження, не може +бути розпаковано за допомогою \fBxz\fP. +.PP +LZMA Utils створюють лише файли \fB.lzma\fP, які мають розмір словника у 2^\fIn\fP +(степінь 2), але приймають файли із будь\-яким розміром словника. liblzma +приймає лише файли \fB.lzma\fP, які мають розмір словника 2^\fIn\fP або 2^\fIn\fP + +2^(\fIn\fP\-1). Так зроблено для зменшення помилок при виявленні файлів +\&\fB.lzma\fP. +.PP +Ці обмеження не мають призводити до проблем на практиці, оскільки практично +усі файли \fB.lzma\fP було стиснено з використанням параметрів, які приймає +liblzma. +. +.SS "Кінцевий мотлох" +При розпаковуванні LZMA Utils без повідомлень ігнорують усі дані після +першого потоку \fB.lzma\fP. У більшості випадків це пов'язано із вадою у +програмі. Це також означає, що у LZMA Utils не передбачено підтримки +розпаковування з'єднаних файлів \fB.lzma\fP. +.PP +Якщо після першого потоку \fB.lzma\fP лишилися дані, \fBxz\fP вважатиме файл +пошкодженим, якщо не було використано \fB\-\-single\-stream\fP. Це може зашкодити +роботі скриптів, де зроблено припущення, що кінцеві зайві дані буде +проігноровано. +. +.SH ПРИМІТКИ +. +.SS "Стискання даних може бути різним" +Точні стиснені дані, які створено на основі того самого нестисненого файла +вхідних даних, можуть бути різними для різних версій XZ Utils, навіть якщо +використано однакові параметри стискання. Причиною цього є удосконалення у +кодувальнику (пришвидшення або краще стискання) без зміни формату +файлів. Виведені дані можуть бути різними навіть для різних збірок тієї +самої версії XZ Utils, якщо використано різні параметри збирання. +.PP +Написане вище означає, що після реалізації \fB\-\-rsyncable\fP файли\-результати +не обов'язково можна буде синхронізувати за допомогою rsyncable, якщо старий +і новий файли було стиснено за допомогою тієї самої версії xz. Цю проблему +можна усунути, якщо буде заморожено частину реалізації кодувальника, щоб +введені для rsync дані були стабільними між версіями xz. +. +.SS "Вбудовані розпакувальники .xz" +У вбудованих реалізаціях розпакувальника \fB.xz\fP, подібних до XZ Embedded, не +обов'язково передбачено підтримку файлів, які створено із типами +\fIперевірки\fP цілісності, відмінними від \fBnone\fP і \fBcrc32\fP. Оскільки типовим +є \fB\-\-check=crc64\fP, вам слід використовувати \fB\-\-check=none\fP або +\fB\-\-check=crc32\fP при створенні файлів для вбудованих систем. +.PP +Поза вбудованими системами, в усіх засобах розпаковування формату \fB.xz\fP +передбачено підтримку усіх типів \fIперевірок\fP або принаймні можливість +розпакувати файл без перевірки цілісності, якщо підтримки певної +\fIперевірки\fP не передбачено. +.PP +У XZ Embedded передбачено підтримку BCJ, але лише з типовим початковим +зсувом. +. +.SH ПРИКЛАДИ +. +.SS Основи +Стиснути файл \fIfoo\fP до \fIfoo.xz\fP за допомогою типового рівня стискання +(\fB\-6\fP) і вилучити \fIfoo\fP, якщо стискання відбулося успішно: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Розпакувати \fIbar.xz\fP до \fIbar\fP і не вилучати \fIbar.xz\fP, навіть якщо +розпаковування відбулося успішно: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Створити \fIbaz.tar.xz\fP з використанням шаблона \fB\-4e\fP (\fB\-4 \-\-extreme\fP), +який є повільнішими за типовий \fB\-6\fP, але потребує менше пам'яті для +стискання та розпаковування (48\ МіБ та 5\ МіБ, відповідно): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Суміш стиснених і нестиснених файлів можна розпакувати до стандартного +виведення за допомогою єдиної команди: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Паралельне стискання багатьох файлів" +У GNU і *BSD можна скористатися \fBfind\fP(1) і \fBxargs\fP(1) для паралельного +стискання багатьох файлів: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Параметр \fB\-P\fP \fBxargs\fP(1) встановлює кількість паралельних процесів +\fBxz\fP. Найкраще значення параметра \fB\-n\fP залежить від того, скільки файлів +має бути стиснено. Якщо файлів мало, значенням, ймовірно, має бути 1. Якщо +файлів десятки тисяч, може знадобитися значення 100 або навіть більше, щоб +зменшити кількість процесів \fBxz\fP, які врешті створить \fBxargs\fP(1). +.PP +Параметр \fB\-T1\fP для \fBxz\fP тут для примусового встановлення однопотокового +режиму, оскільки для керування рівнем паралелізації використано \fBxargs\fP(1). +. +.SS "Режим робота" +Обчислити скільки байтів було заощаджено загалом після стискання декількох +файлів: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Скрипту можуть знадобитися дані щодо того, що використано достатньо нову +версію \fBxz\fP. У наведеному нижче скрипті \fBsh\fP(1) виконано перевірку того, +що номер версії засобу \fBxz\fP є принаймні рівним 5.0.0. Цей спосіб є сумісним +зі старими тестовими версіями, де не передбачено підтримки параметра +\fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Встановити обмеження на використання пам'яті для розпаковування за допомогою +\fBXZ_OPT\fP, але якщо обмеження вже було встановлено, не збільшувати його: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Нетипові ланцюжки фільтрів засобу стискання" +Найпростішим використанням ланцюжка фільтрів є налаштовування шаблона +LZMA2. Це може бути корисним, оскільки у шаблонах використано лише +підмножину потенційно корисних комбінацій параметрів стискання. +.PP +При налаштовуванні шаблонів LZMA2 корисними є стовпчики CompCPU таблиць з +описів параметрів \fB\-0\fP ... \fB\-9\fP і \fB\-\-extreme\fP. Ось відповідні частини з +цих двох таблиць: +.RS +.PP +.TS +tab(;); +c c +n n. +Шаблон;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Якщо вам відомо, що певний файл потребує дещо більшого словника (наприклад, +32\ МіБ) для якісного стискання, але ви хочете стиснути його швидше за +команду \fBxz \-8\fP, можна внести зміни до шаблона із нижчим значенням CompCPU +(наприклад, 1) для використання більшого словника: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Для певних файлів наведена вище команда може працювати швидше за \fBxz \-6\fP і +стискати дані значно краще. Втім, слід наголосити, переваги більшого +словника з одночасним низьким значенням CompCPU проявляються лише для деяких +файлів. Найочевиднішим випадком, коли великий словник є корисним, є випадок, +коли архів містить дуже подібні файли розміром у принаймні декілька +мегабайтів. Розмір словника має бути значно більшим за будь\-який окремий +файл, щоб у LZMA2 було використано усі переваги подібностей між послідовними +файлами. +.PP +Якщо дуже високий рівень використання пам'яті у засобі стискання або +розпаковування не є проблемою, і файли, який стискають має об'єм у принаймні +декілька десятків мегабайтів, може бути корисним використання навіть +більшого за 64 МіБ словника, який використано у \fBxz \-9\fP: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Використання \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP), подібно до наведеного вище +прикладу, може бути корисним для перегляду вимог з боку засобів стискання та +розпаковування до пам'яті. Пам'ятайте, що використання словника, розмір +якого перевищує розмір файла, який стискають, є простоюю витратою пам'яті, +отже наведену вище команду не варто використовувати для малих файлів. +.PP +Іноді час стискання не має значення, але використання пам'яті засобом +розпаковування має бути низьким для того, щоб, наприклад, уможливити +розпаковування файла у вбудованій системі. У наведеній нижче команді +використано \fB\-6e\fP (\fB\-6 \-\-extreme\fP) як основу і встановлено розмір словника +лише у 64\ КіБ. Файл\-результат можна розпакувати за допомогою XZ Embedded +(ось чому використано \fB\-\-check=crc32\fP) з використанням лише 100\ КіБ +пам'яті. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Якщо вам потрібно витиснути зі стискання максимальну кількість байтів, може +допомогти коригування кількості бітів контексту літералів (\fIlc\fP) та +кількість позиційних бітів (\fIpb\fP). Також може допомогти коригування +кількості бітів позиції літералів (\fIlp\fP), але, зазвичай, важливішими є +\fIlc\fP і \fIpb\fP. Наприклад, в архівах зі початковим кодом міститься +здебільшого текст US\-ASCII, щось подібне до наведеного нижче може дещо (на +щось близьке до 0,1\ %) зменшити файл, порівняно із \fBxz \-6e\fP (спробуйте +також без \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Використання іншого фільтра разом із LZMA2 може покращити стискання для +певних типів файлів. Наприклад, для стискання бібліотеки спільного +користування x86\-32 або x86\-64 з використанням фільтра BCJ x86 скористайтеся +такою командою: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Зауважте, що порядок параметрів фільтрування має значення. Якщо \fB\-\-x86\fP +вказано після \fB\-\-lzma2\fP, \fBxz\fP повідомить про помилку, оскільки після LZMA2 +не може бути жодного фільтра, а також оскільки фільтр BCJ x86 не можна +використовувати як останній фільтр у ланцюжку. +.PP +Фільтр Delta разом із LZMA2 може дати добрі результати для растрових +зображень. Зазвичай, результати є кращими за формат PNG, у якого є декілька +більш досконалих фільтрів, ніж проста дельта, але там використовують для +стискання Deflate. +.PP +Зображення слід берегти у нестисненому форматі, наприклад, як нестиснений +TIFF. Параметр відстані фільтра Delta встановлюють так, щоб він збігався із +кількістю байтів на піксель у зображенні. Наприклад, для 24\-бітового +растрового зображення RGB слід вказати \fBdist=3\fP, а також добре передати +\fBpb=0\fP до LZMA2 для пристосовування до трибайтового вирівнювання: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Якщо в один архів запаковано декілька зображень (наприклад, в архів +\&\fB.tar\fP), фільтр Delta також даватиме добрі результати, якщо у всіх +зображеннях однакова кількість байтів для кожного пікселя. +. +.SH "ДИВ. ТАКОЖ" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +Вбудовуваний XZ: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xz.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xz.1 new file mode 100644 index 0000000000000000000000000000000000000000..bff0472c4495c4b8c84495967535bcd7b99dc205 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xz.1 @@ -0,0 +1,2039 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Ukrainian translation for xz-man. +.\" Yuri Chornoivan , 2019, 2022, 2023, 2024, 2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 "8 березня 2025 року" Tukaani "XZ Utils" +. +.SH НАЗВА +xz, unxz, xzcat, lzma, unlzma, lzcat — стискання та розпаковування файлів +\&.xz і .lzma +. +.SH "КОРОТКИЙ ОПИС" +\fBxz\fP [\fIпараметр...\fP] [\fIфайл...\fP] +. +.SH "СКОРОЧЕННЯ КОМАНД" +\fBunxz\fP є рівноцінним до \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP є рівноцінним до \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP є рівноцінним до \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP є рівноцінним до \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP є рівноцінним до \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +При написанні скриптів, де потрібно розпаковувати файли, рекомендуємо завжди +використовувати \fBxz\fP із відповідними аргументами (\fBxz \-d\fP або \fBxz \-dc\fP), +замість \fBunxz\fP і \fBxzcat\fP. +. +.SH ОПИС +\fBxz\fP інструмент загального призначення для стискання даних із синтаксисом +командного рядка, подібним для \fBgzip\fP(1) і \fBbzip2\fP(1). Власним форматом +файлів є \fB.xz\fP, але передбачено підтримку застарілого формату \fB.lzma\fP, +який було використано у LZMA Utils, та необроблених потоків стиснених даних +без заголовків формату контейнера. Крім того, передбачено підтримку +розпаковування формату \fB.lz\fP, який використано у \fBlzip\fP. +.PP +\fBxz\fP стискає або розпаковує кожен \fIфайл\fP відповідно до вибраного режиму +дій. Якщо \fIфайли\fP не задано або якщо \fIфайлом\fP є \fB\-\fP, \fBxz\fP читатиме дані +зі стандартного джерела вхідних даних і записуватиме оброблені дані до +стандартного виведення. \fBxz\fP відмовить (покаже повідомлення про помилку і +пропустить \fIфайл\fP) у записів стиснених даних до стандартного виведення, +якщо це термінал. Так само, \fBxz\fP відмовить у читанні стиснених даних зі +стандартного джерела вхідних даних, якщо це термінал. +.PP +Якщо не вказано \fB\-\-stdout\fP, \fIфайли\fP, відмінні від \fB\-\fP, буде записано до +нового файла, чию назву буде визначено з назви початкового \fIфайла\fP: +.IP \(bu 3 +При стисканні суфікс формату файла призначення (\fB.xz\fP або \fB.lzma\fP) буде +дописано до назви початкового файла для отримання назви файла призначення. +.IP \(bu 3 +При розпаковуванні суфікс \fB.xz\fP, \fB.lzma\fP або \fB.lz\fP буде вилучено з назви +файла для отримання назви файла призначення. Крім того, \fBxz\fP розпізнає +суфікси \fB.txz\fP і \fB.tlz\fP і замінює їх на суфікс \fB.tar\fP. +.PP +Якщо файл призначення вже існує, буде показано повідомлення про помилку, а +\fIфайл\fP буде пропущено. +.PP +Окрім випадку запису до стандартного виведення, \fBxz\fP покаже попередження і +пропустить обробку \fIфайла\fP, якщо буде виконано будь\-яку з таких умов: +.IP \(bu 3 +\fIФайл\fP не є звичайним файлом. Програма не переходитиме за символічними +посиланнями, а отже, не вважатиме їх звичайними файлами. +.IP \(bu 3 +На \fIфайл\fP існує декілька жорстких посилань. +.IP \(bu 3 +Для \fIфайла\fP встановлено setuid, setgid або «липкий» біт. +.IP \(bu 3 +Режим дій встановлено у значення «стискання», і \fIфайл\fP вже має суфікс назви +формату файла призначення (\fB.xz\fP або \fB.txz\fP при стисканні до формату +\&\fB.xz\fP, і \fB.lzma\fP або \fB.tlz\fP при стисканні до формату \fB.lzma\fP). +.IP \(bu 3 +Режим дій встановлено у значення «розпаковування», і \fIфайл\fP не має суфікса +назви жодного з підтримуваних форматів (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP +або \fB.lz\fP). +.PP +Після успішного стискання або розпаковування \fIфайла\fP, \fBxz\fP копіює дані +щодо власника, групи, прав доступу, часу доступу та моменту внесення змін з +початкового \fIфайла\fP до файла призначення. Якщо копіювання даних щодо групи +зазнає невдачі, права доступу буде змінено так, що файл призначення стане +недоступним для користувачів, які не мають права доступу до початкового +\fIфайла\fP. В \fBxz\fP ще не передбачено підтримки копіювання інших метаданих, +зокрема списків керування доступом або розширених атрибутів. +.PP +Щойно файл призначення буде успішно закрито, початковий \fIфайл\fP буде +вилучено, якщо не вказано параметра \fB\-\-keep\fP. Початковий \fIфайл\fP ніколи не +буде вилучено, якщо виведені дані буде записано до стандартного виведення +або якщо станеться помилка. +.PP +Надсилання \fBSIGINFO\fP або \fBSIGUSR1\fP до процесу \fBxz\fP призводить до +виведення даних щодо поступу до стандартного виведення помилок. Це має лише +обмежене використання, оскільки якщо стандартним виведенням помилок є +термінал, використання \fB\-\-verbose\fP призведе до показу автоматично +оновлюваного індикатора поступу. +. +.SS "Використання пам'яті" +Використання \fBxz\fP пам'яті може бути різним: від декількох сотень кілобайтів +до декількох гігабайтів, залежно від параметрів стискання. Параметри, які +використано при стисканні файла, визначають вимоги до об'єму пам'яті при +розпакуванні. Типово, засобу розпаковування потрібно від 5\ % до 20\ % +об'єму пам'яті, якого засіб стискання потребує при створенні +файла. Наприклад, розпаковування файла, який створено з використанням \fBxz \-9\fP, у поточній версії потребує 65\ МіБ пам'яті. Втім, можливе створення +файлів \fB.xz\fP, які потребуватимуть для розпаковування декількох гігабайтів +пам'яті. +.PP +Ймовірність високого рівня використання пам'яті може бути особливо +дошкульною для користувачів застарілих комп'ютерів. Щоб запобігти прикрим +несподіванкам, у \fBxz\fP передбачено вбудований обмежувач пам'яті, який типово +вимкнено. Хоча у деяких операційних системах передбачено спосіб обмежити +використання пам'яті процесами, сподівання на його ефективність не є аж +надто гнучким (наприклад, використання \fBulimit\fP(1) для обмеження +віртуальної пам'яті призводить до викривлення даних \fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Обмежувач пам'яті можна увімкнути за допомогою параметра командного рядка +\fB\-\-memlimit=\fP\fIобмеження\fP. Часто, зручніше увімкнути обмежувач на типовому +рівні, встановивши значення для змінної середовища \fBXZ_DEFAULTS\fP, +наприклад, \fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Можна встановити обмеження +окремо для стискання і розпакування за допомогою +\fB\-\-memlimit\-compress=\fP\fIlimit\fP and +\fB\-\-memlimit\-decompress=\fP\fIобмеження\fP. Використання цих двох параметрів поза +\fBXZ_DEFAULTS\fP не таке вже і корисне, оскільки одноразовий запуск \fBxz\fP не +може одночасно призводити до стискання та розпаковування, а набрати у +командному рядку \fB\-\-memlimit=\fP\fIобмеження\fP (або \fB\-M\fP \fIобмеження\fP) +набагато швидше. +.PP +Якщо під час розпаковування вказане обмеження буде перевищено, \fBxz\fP покаже +повідомлення про помилку, а розпаковування файла зазнає невдачі. Якщо +обмеження буде перевищено при стисканні, \fBxz\fP спробує масштабувати +параметри так, щоб не перевищувати обмеження (окрім випадків використання +\fB\-\-format=raw\fP або \fB\-\-no\-adjust\fP). Отже, дію буде виконано, якщо обмеження +не є надто жорстким. Масштабування параметрів буде виконано кроками, які не +збігаються із рівнями шаблонів стискання. Наприклад, якщо обмеження лише +трохи не вкладається у об'єм потрібний для \fBxz \-9\fP, параметри буде змінено +лише трохи, не до рівня \fBxz \-8\fP. +. +.SS "Поєднання і заповнення з файлами .xz" +Можна поєднати файли \fB.xz\fP без додаткової обробки. \fBxz\fP розпакує такі +файли так, наче вони є єдиним файлом \fB.xz\fP. +.PP +Можна додати доповнення між з'єднаними частинами або після останньої +частини. Доповнення має складатися із нульових байтів і мати розмір, який є +кратним до чотирьох байтів. Це може бути корисним, наприклад, якщо файл +\&\fB.xz\fP зберігається на носії даних, де розміри файла вимірюються у +512\-байтових блоках. +.PP +Поєднання та заповнення не можна використовувати для файлів \fB.lzma\fP або +потоків необроблених даних. +. +.SH ПАРАМЕТРИ +. +.SS "Цілочисельні суфікси і спеціальні значення" +У більшості місць, де потрібен цілочисельний аргумент, передбачено підтримку +необов'язкового суфікса для простого визначення великих цілих чисел. Між +цілим числом і суфіксом не повинно бути пробілів. +.TP +\fBKiB\fP +Помножити ціле число на 1024 (2^10). Синонімами \fBKiB\fP є \fBKi\fP, \fBk\fP, \fBkB\fP, +\fBK\fP та \fBKB\fP. +.TP +\fBMiB\fP +Помножити ціле число на 1048576 (2^20). Синонімами \fBMiB\fP є B, \fBMi\fP, \fBm\fP, +\fBM\fP та \fBMB\fP. +.TP +\fBGiB\fP +Помножити ціле число на 1073741824 (2^30). Синонімами \fBGiB\fP є B, \fBGi\fP, +\fBg\fP, \fBG\fP та \fBGB\fP. +.PP +Можна скористатися особливим значенням \fBmax\fP для позначення максимального +цілого значення, підтримку якого передбачено для параметра. +. +.SS "Режим операції" +Якщо вказано декілька параметрів режиму дій, буде використано лише останній +з них. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Стиснути. Це типовий режим дій, якщо не вказано параметр режиму дій, а назва +команди неявним чином не визначає іншого режиму дій (наприклад, \fBunxz\fP +неявно визначає \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Після успішного пакування початковий файл буде вилучено, якщо виведення не +відбувається до стандартного виведення або не вказано параметра \fB\-\-keep\fP. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Розпакувати. Після успішного розпаковування початковий файл буде вилучено, +якщо виведення не відбувається до стандартного виведення або не вказано +параметра \fB\-\-keep\fP. +.TP +\fB\-t\fP, \fB\-\-test\fP +Перевірити цілісність стиснених файлів \fIфайли\fP. Цей параметр еквівалентний +до \fB\-\-decompress \-\-stdout\fP, але розпаковані дані буде відкинуто, замість +запису до стандартного виведення. Жодних файлів не буде створено або +вилучено. +.TP +\fB\-l\fP, \fB\-\-list\fP +Вивести відомості щодо стиснених файлів \fIфайли\fP. Розпакування даних не +виконуватиметься, жодних файлів не буде створено або вилучено. У режимі +списку програма не може читати дані зі стандартного введення або з інших +джерел, де неможливе позиціювання. +.IP "" +У типовому списку буде показано базові відомості щодо файлів \fIфайли\fP, по +одному файлу на рядок. Щоб отримати докладніші відомості, скористайтеся +параметром \fB\-\-verbose\fP. Щоб розширити спектр відомостей, скористайтеся +параметром \fB\-\-verbose\fP двічі, але зауважте, що це може призвести до +значного уповільнення роботи, оскільки отримання додаткових відомостей +потребує великої кількості позиціювань. Ширина області докладного виведення +даних перевищує 80 символів, тому передавання конвеєром виведених даних, +наприклад, до \fBless\ \-S\fP, може бути зручним способом перегляду даних, якщо +термінал недостатньо широкий. +.IP "" +Виведені дані залежать від версії \fBxz\fP та використаної локалі. Для +отримання даних, які будуть придатні до обробки комп'ютером, слід +скористатися параметрами \fB\-\-robot \-\-list\fP. +. +.SS "Модифікатори режиму роботи" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Не вилучати вхідні файли. +.IP "" +Починаючи з версії \fBxz\fP 5.2.6, використання цього параметра також наказує +\fBxz\fP виконувати стискання або розпаковування, навіть якщо вхідними даними є +символічне посилання на звичайний файл, файл, який має декілька жорстких +посилань, або файл, для якого встановлено setuid, setgid або липкий +біт. setuid, setgid та липкий біт не буде скопійовано до файла\-результату. У +попередніх версіях, ці дії виконувалися, лише якщо було використано параметр +\fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Результатів використання цього параметра буде декілька: +.RS +.IP \(bu 3 +Якщо файл\-результат вже існує, вилучити його до стискання або +розпаковування. +.IP \(bu 3 +Виконувати стискання або розпаковування, навіть якщо вхідними даними є +символічне посилання на звичайний файл, файл, який має декілька жорстких +посилань, або файл, для якого встановлено setuid, setgid або липкий біт +setuid, setgid та липкий біт не буде скопійовано до файла\-результату. +.IP \(bu 3 +Якщо використано разом із \fB\-\-decompress\fP, \fB\-\-stdout\fP, і \fBxz\fP не зможе +розпізнати тип початкового файла, копіювати початковий файл без змін до +стандартного виведення. Це надає змогу користуватися \fBxzcat\fP \fB\-\-force\fP +подібно до \fBcat\fP(1) для файлів, які не було стиснено за допомогою +\fBxz\fP. Зауважте, що у майбутньому у \fBxz\fP може бути реалізовано підтримку +нових форматів стиснених файлів, замість копіювання їх без змін до +стандартного виведення. Можна скористатися \fB\-\-format=\fP\fIформат\fP для +обмеження стискання у \fBxz\fP єдиним форматом файлів. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Записати стиснені або розпаковані дані до стандартного виведення, а не до +файла. Неявним чином встановлює \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Розпакувати лише перший потік даних \fB.xz\fP і без повідомлень проігнорувати +решту вхідних даних, які слідують за цим потоком. Зазвичай, такі зайві дані +наприкінці файла призводять до показу \fBxz\fP повідомлення про помилку. +.IP "" +\fBxz\fP ніколи не виконуватиме спроби видобути декілька потоків даних з файлів +\&\fB.lzma\fP або необроблених потоків даних, але використання цього параметра +все одно наказує \fBxz\fP ігнорувати можливі кінцеві дані після файла \fB.lzma\fP +або необробленого потоку даних. +.IP "" +Цей параметр нічого не змінює, якщо режимом дій не є \fB\-\-decompress\fP або +\fB\-\-test\fP. +.IP "" +З \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP неявно визначає \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Вимкнути створення розріджених файлів. Типово, якщо видобування виконується +до звичайного файла, \fBxz\fP намагається створити розріджений файл, якщо +розпаковані дані містять довгі послідовності двійкових нулів. Це також +працює, коли виконується запис до стандартного виведення, доки стандартне +виведення з'єднано зі звичайним файлом і виконуються певні додаткові умови, +які убезпечують роботу. Створення розріджених файлів може заощадити місце на +диску і пришвидшити розпаковування шляхом зменшення кількості дій введення +та виведення даних на диску. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +При стисканні використати суфікс \fI.suf\fP для файлів призначення, замість +суфікса \fB.xz\fP або \fB.lzma\fP. Якщо записування виконується не до стандартного +виведення і початковий файл вже має суфікс назви \fI.suf\fP, буде показано +попередження, а файл буде пропущено під час обробки. +.IP "" +При розпаковуванні розпізнавати файли із суфіксом назви \fI.suf\fP, окрім +файлів із суфіксами назв \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP або \fB.lz\fP. Якщо +початковий файл мав суфікс назви \fI.suf\fP, для отримання назви файла +призначення цей суфікс буде вилучено. +.IP "" +При стисканні або розпакуванні необроблених потоків даних (\fB\-\-format=raw\fP) +суфікс слід вказувати завжди, якщо запис не виконується до стандартного +виведення, оскільки типового суфікса назви для необроблених потоків даних не +передбачено. +.TP +\fB\-\-files\fP[\fB=\fP\fIфайл\fP] +Прочитати назви файлів для обробки з файла \fIфайл\fP; якщо \fIfile\fP не вказано, +назви файлів буде прочитано зі стандартного потоку вхідних даних. Назви +файлів має бути відокремлено символом нового рядка. Символ дефіса (\fB\-\fP) +буде оброблено як звичайну назву файла; він не позначатиме стандартного +джерела вхідних даних. Якщо також буде вказано назви файлів у аргументах +рядка команди, файли з цими назвами буде оброблено до обробки файлів, назви +яких було прочитано з файла \fIфайл\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIфайл\fP] +Те саме, що і \fB\-\-files\fP[\fB=\fP\fIфайл\fP], але файли у списку має бути +відокремлено нульовим символом. +. +.SS "Параметри базового формату файлів та стискання" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fIформат\fP +Вказати файл \fIформат\fP для стискання або розпакування: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Типовий варіант. При стисканні \fBauto\fP є еквівалентом \fBxz\fP. При +розпакуванні формат файла вхідних даних буде виявлено автоматично. Зауважте, +що автоматичне виявлення необроблених потоків даних (створених за допомогою +\fB\-\-format=raw\fP) неможливе. +.TP +\fBxz\fP +Стиснути до формату \fB.xz\fP або приймати лише файли \fB.xz\fP при +розпаковуванні. +.TP +\fBlzma\fP, \fBalone\fP +Стиснути дані до застарілого формату файлів \fB.lzma\fP або приймати лише файли +\&\fB.lzma\fP при розпаковуванні. Альтернативну назву \fBalone\fP може бути +використано для зворотної сумісності із LZMA Utils. +.TP +\fBlzip\fP +Приймати лише файли \fB.lz\fP при розпакуванні. Підтримки стискання не +передбачено. +.IP "" +Передбачено підтримку версії формату \fB.lz\fP 0 та 1. Файли версії 0 було +створено \fBlzip\fP 1.3 та старішими версіями. Такі файли не є поширеними, але +їх можна знайти у файлових архівах, оскільки певну незначну кількість +пакунків із початковим кодом було випущено у цьому форматі. Також можуть +існувати особисті файли у цьому форматі. Підтримку розпаковування для +формату версії 0 було вилучено у \fBlzip\fP 1.18. Версія \fBlzip\fP 1.4 і новіші +версії створюють файли у форматі версії 1. +.TP +\fBraw\fP +Стиснути або розпакувати потік необроблених даних (лез заголовків). Цей +параметр призначено лише для досвідчених користувачів. Для розпаковування +необроблених потоків даних слід користуватися параметром \fB\-\-format=raw\fP і +явно вказати ланцюжок фільтрування, який за звичайних умов мало б бути +збережено у заголовках контейнера. +.RE +.TP +\fB\-C\fP \fIперевірка\fP, \fB\-\-check=\fP\fIперевірка\fP +Вказати тип перевірки цілісності. Контрольну суму буде обчислено на основі +нестиснених даних і збережено у файлі \fB.xz\fP. Цей параметр працюватиме, лише +якщо дані стиснено до файла у форматі \fB.xz\fP; для формату файлів \fB.lzma\fP +підтримки перевірки цілісності не передбачено. Перевірку контрольної суми +(якщо така є) буде виконано під час розпаковування файла \fB.xz\fP. +.IP "" +Підтримувані типи \fIперевірок\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Не обчислювати контрольну суму взагалі. Зазвичай, не варто цього робити. Цим +варіантом слід скористатися, якщо цілісність даних буде перевірено в інший +спосіб. +.TP +\fBcrc32\fP +Обчислити CRC32 за допомогою полінома з IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Обчислити CRC64 за допомогою полінома з ECMA\-182. Це типовий варіант, +оскільки він дещо кращий за CRC32 при виявленні пошкоджених файлів, а +різниця у швидкості є незрачною. +.TP +\fBsha256\fP +Обчислити SHA\-256. Цей варіант дещо повільніший за CRC32 і CRC64. +.RE +.IP "" +Цілісність заголовків \fB.xz\fP завжди перевіряють за допомогою CRC32. Таку +перевірку не можна змінити або скасувати. +.TP +\fB\-\-ignore\-check\fP +Не перевіряти цілісність стиснених даних при розпаковуванні. Значення CRC32 +у заголовках \fB.xz\fP буде у звичайний спосіб перевірено попри цей параметр. +.IP "" +\fBНе користуйтеся цим параметром, якщо ви не усвідомлюєте наслідків ваших дій.\fP Можливі причини скористатися цим параметром: +.RS +.IP \(bu 3 +Спроба отримання даних з пошкодженого файла .xz. +.IP \(bu 3 +Пришвидшення розпакування. Це, здебільшого, стосується SHA\-256 або файлів із +надзвичайно високим рівнем пакування. Не рекомендуємо користуватися цим +параметром з цією метою, якщо цілісність файлів не буде перевірено у якийсь +інший спосіб. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Вибрати рівень стискання. Типовим є \fB\-6\fP. Якщо буде вказано декілька рівнів +стискання, програма використає останній вказаний. Якщо вже було вказано +нетиповий ланцюжок фільтрів, встановлення рівня стискання призведе до +нехтування цим нетиповим ланцюжком фільтрів. +.IP "" +Різниця між рівнями є суттєвішою, ніж у \fBgzip\fP(1) і \fBbzip2\fP(1). Вибрані +параметри стискання визначають вимоги до пам'яті під час розпаковування, +отже використання надто високого рівня стискання може призвести до проблем +під час розпаковування файла на застарілих комп'ютерах із невеликим обсягом +оперативної пам'яті. Зокрема, \fBне варто використовувати \-9 для усього\fP, як +це часто буває для \fBgzip\fP(1) і \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Це дещо швидші набори налаштувань. \fB\-0\fP іноді є швидшим за \fBgzip \-9\fP, +забезпечуючи набагато більший коефіцієнт стискання. Вищі рівні часто мають +швидкість, яку можна порівняти з \fBbzip2\fP(1) із подібним або кращим +коефіцієнтом стискання, хоча результати значно залежать від типу даних, які +стискають. +.TP +\fB\-4\fP ... \fB\-6\fP +Стискання від доброго до дуже доброго рівня із одночасним підтриманням +помірного рівня споживання пам'яті засобом розпаковування, навіть для +застарілих системи. Типовим є значення \fB\-6\fP, яке є добрим варіантом для +поширення файлів, які мають бути придатними до розпаковування навіть у +системах із лише 16\ МіБ оперативної пам'яті. (Також можна розглянути +варіанти \fB\-5e\fP і \fB\-6e\fP. Див. \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Ці варіанти подібні до \fB\-6\fP, але із вищими вимогами щодо пам'яті для +стискання і розпаковування. Можуть бути корисними лише для стискання файлів +з розміром, що перевищує 8\ МіБ, 16\ МіБ та 32\ МіБ, відповідно. +.RE +.IP "" +На однаковому обладнанні швидкість розпакування є приблизно сталою кількістю +байтів стиснених даних за секунду. Іншими словами, чим кращим є стискання, +тим швидшим буде, зазвичай, розпаковування. Це також означає, що об'єм +розпакованих виведених даних, які видає програма за секунду, може коливатися +у широкому діапазоні. +.IP "" +У наведеній нижче таблиці підсумовано можливості шаблонів: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Шаблон;DictSize;CompCPU;CompMem;DecMem +\-0;256 КіБ;0;3 МіБ;1 МіБ +\-1;1 МіБ;1;9 МіБ;2 МіБ +\-2;2 МіБ;2;17 МіБ;3 МіБ +\-3;4 МіБ;3;32 МіБ;5 МіБ +\-4;4 МіБ;4;48 МіБ;5 МіБ +\-5;8 МіБ;5;94 МіБ;9 МіБ +\-6;8 МіБ;6;94 МіБ;9 МіБ +\-7;16 МіБ;6;186 МіБ;17 МіБ +\-8;32 МіБ;6;370 МіБ;33 МіБ +\-9;64 МіБ;6;674 МіБ;65 МіБ +.TE +.RE +.RE +.IP "" +Описи стовпчиків: +.RS +.IP \(bu 3 +DictSize є розміром словника LZMA2. Використання словника, розмір якого +перевищує розмір нестисненого файла, — проста витрата пам'яті. Ось чому не +варто використовувати шаблони \fB\-7\fP ... \fB\-9\fP, якщо у них немає реальної +потреби. Для \fB\-6\fP та нижчих рівнів об'єм витраченої пам'яті, зазвичай, +такий низький, що цей фактор ні на що не впливає. +.IP \(bu 3 +CompCPU є спрощеним представленням параметрів LZMA2, які впливають на +швидкість стискання. Розмір словника також впливає на швидкість, тому, хоча +значення CompCPU є однаковим для рівнів \fB\-6\fP ... \fB\-9\fP, обробка на вищих +рівнях все одно є трошки повільнішою. Що отримати повільніше і, ймовірно, +краще стискання, див. \fB\-\-extreme\fP. +.IP \(bu 3 +CompMem містить вимоги до пам'яті засобу стискання у однопотоковому +режимі. Значення можуть бути дещо різними для різних версій \fBxz\fP. +.IP \(bu 3 +У DecMem містяться вимоги до пам'яті при розпаковуванні. Тобто параметри +засобу стискання визначають вимоги до пам'яті при розпаковуванні. Точний +об'єм пам'яті, яка потрібна для розпаковування, дещо перевищує розмір +словника LZMA2, але значення у таблиці було округлено до наступного цілого +значення МіБ. +.RE +.IP "" +Вимоги до пам'яті у багатопотоковому режимі є значно вищими, ніж у +однопотоковому. З типовим значенням \fB\-\-block\-size\fP для кожного потоку треба +3*3*DictSize плюс CompMem або DecMem. Наприклад, для чотирьох потоків з +шаблоном \fB\-6\fP потрібно 660\(en670\ МіБ пам'яті. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Використати повільніший варіант вибраного рівня стискання (\fB\-0\fP ... \fB\-9\fP) +у сподіванні отримати трохи кращий коефіцієнт стискання, але, якщо не +поталанить, можна його і погіршити. Не впливає на використання пам'яті при +розпаковуванні, але використання пам'яті при стисканні дещо збільшиться на +рівнях \fB\-0\fP ... \fB\-3\fP. +.IP "" +Оскільки існує два набори налаштувань із розмірами словників 4\ МіБ та 8\ МіБ, у наборах \fB\-3e\fP і \fB\-5e\fP використано трошки швидші параметри (нижче +CompCPU), ніж у наборах \fB\-4e\fP і \fB\-6e\fP, відповідно. Тому двох однакових +наборів у списку немає. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Шаблон;DictSize;CompCPU;CompMem;DecMem +\-0e;256 КіБ;8;4 МіБ;1 МіБ +\-1e;1 МіБ;8;13 МіБ;2 МіБ +\-2e;2 МіБ;8;25 МіБ;3 МіБ +\-3e;4 МіБ;7;48 МіБ;5 МіБ +\-4e;4 МіБ;8;48 МіБ;5 МіБ +\-5e;8 МіБ;7;94 МіБ;9 МіБ +\-6e;8 МіБ;8;94 МіБ;9 МіБ +\-7e;16 МіБ;8;186 МіБ;17 МіБ +\-8e;32 МіБ;8;370 МіБ;33 МіБ +\-9e;64 МіБ;8;674 МіБ;65 МіБ +.TE +.RE +.RE +.IP "" +Наприклад, передбачено загалом чотири набори налаштувань із використанням +словника у 8\ МіБ, порядок яких від найшвидшого до найповільнішого є таким: +\fB\-5\fP, \fB\-6\fP, \fB\-5e\fP і \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Це дещо оманливі альтернативні варіанти для \fB\-0\fP і \fB\-9\fP, +відповідно. Реалізовано лише для забезпечення зворотної сумісності із LZMA +Utils. Намагайтеся не користуватися цими варіантами параметрів. +.TP +\fB\-\-block\-size=\fP\fIрозмір\fP +При стисканні до формату \fB.xz\fP поділити вхідні дані на блоки у \fIрозмір\fP +байтів. Ці блоки буде стиснуто незалежно один від одного, що допоможе у +багатопотоковій обробці і зробить можливим обмежене розпакування для доступу +до будь\-яких даних. Цим параметром слід типово користуватися для +перевизначення типового розміру блоку у багатопотоковому режимі обробки, але +цим параметром можна також скористатися в однопотоковому режимі обробки. +.IP "" +У багатопотоковому режимі для кожного потоку буде отримано для буферів +вхідних і вихідних даних майже утричі більше за \fIрозмір\fP байтів. Типовий +\fIрозмір\fP утричі більший за розмір словника LZMA2 або дорівнює 1 МіБ, буде +вибрано більше значення. Типовим добрим значенням буде значення, яке у +2\(en4 рази перевищує розмір словника LZMA2 або дорівнює принаймні 1 +МіБ. Використання значення \fIрозмір\fP, яке є меншим за розмір словника LZMA2, +має наслідком марну витрату оперативної пам'яті, оскільки його використання +призводить до того, що буфер словника LZMA2 ніколи не буде використано +повністю. У багатопотоковому режимі розміри блоків зберігатимуться у +заголовках блоків. Ці дані потрібні для багатопотокового розпаковування. +.IP "" +У однопотоковому режимі поділ на блоки типово не +виконуватиметься. Встановлення значення для цього параметра не впливатиме на +використання пам'яті. У заголовках блоків не зберігатимуться дані щодо +розміру, отже файли, які створено в однопотоковому режимі не будуть +ідентичними до файлів, які створено у багатопотоковому режимі. Те, що у +заголовках блоків не зберігатимуться дані щодо розміру також означає, що +\fBxz\fP не зможе розпаковувати такі файли у багатопотоковому режимі. +.TP +\fB\-\-block\-list=\fP\fIзаписи\fP +При стисканні у форматі \fB.xz\fP починати новий блок із необов'язковим +ланцюжком фільтрів після вказаної кількості інтервалів нестиснених даних. +.IP "" +\fIзаписи\fP є списком відокремлених комами значень. Кожен запис складається з +необов'язкового номера ланцюжка фільтрів від 0 до 9, після якого йде +двокрапка (\fB:\fP) і необхідний розмір нестиснутих даних. Пропущення запису +(дві або більше послідовних ком) є скороченим варіантом визначення +використання розміру та фільтрів попереднього запису. +.IP "" +Якщо файл вхідних даних є більшим за розміром за суму розмірів \fIзаписів\fP, +останнє значення у \fIрозмірах\fP буде повторено до кінця файла. Особливе +значення \fB0\fP може бути використано як останній розмір, щоб позначити, що +решту файла має бути закодовано як єдиний блок. +.IP "" +Альтернативний ланцюжок фільтрів для кожного блоку можна вказати в поєднанні +з параметрами \fB\-\-filters1=\fP\fIфільтри\fP \&...\& \fB\-\-filters9=\fP\fIфільтри\fP. Ці +параметри визначають ланцюжки фільтрів з ідентифікатором у діапазоні +1\(en9. Ланцюжок фільтрів 0 можна використовувати для посилання на типовий +ланцюжок фільтрів — це те саме, що не вказувати ланцюжок +фільтрів. Ідентифікатор ланцюжка фільтрів можна використовувати перед +нестисненим розміром, після якого йде двокрапка (\fB:\fP). Наприклад, якщо +вказати \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP, блоки будуть +створені так: +.RS +.IP \(bu 3 +Ланцюжок фільтрів задано \fB\-\-filters1\fP із вхідними даними у 2 МіБ +.IP \(bu 3 +Ланцюжок фільтрів задано \fB\-\-filters3\fP із вхідними даними у 2 МіБ +.IP \(bu 3 +Ланцюжок фільтрів задано \fB\-\-filters2\fP із вхідними даними у 4 МіБ +.IP \(bu 3 +Ланцюжок фільтрів задано \fB\-\-filters2\fP із вхідними даними у 4 МіБ +.IP \(bu 3 +Типовий ланцюжок даних і вхідні дані у 2 МіБ +.IP \(bu 3 +Типовий ланцюжок фільтрів та вхідні дані у 4 МіБ для кожного блоку до кінця +вхідних даних. +.RE +.IP "" +Якщо вказати розмір, який перевищує розмір блоку кодувальника (або типове +значення у режимі із потоками обробки, або значення, яке встановлено за +допомогою \fB\-\-block\-size=\fP\fIрозмір\fP), засіб кодування створить додаткові +блоки, зберігаючи межі, які вказано у \fIзаписах\fP. Наприклад, якщо вказати +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP, а файл +вхідних даних має розмір 80 МіБ, буде отримано такі 11 блоків: 5, 10, 8, 10, +2, 10, 10, 4, 10, 10 і 1 МіБ. +.IP "" +У багатопотоковому режимі розмір блоків буде збережено у заголовках +блоків. Програма не зберігатиме ці дані у однопотоковому режимі, отже +закодований результат не буде ідентичним до отриманого у багатопотоковому +режимі. +.TP +\fB\-\-flush\-timeout=\fP\fIчас_очікування\fP +При стискання, якщо з моменту попереднього витирання мине понад +\fIчас_очікування\fP мілісекунд (додатне ціле значення) і читання додаткових +даних буде заблоковано, усі вхідні дані у черзі обробки буде витерто з +кодувальника і зроблено доступним у потоці вихідних даних. Це може бути +корисним, якщо \fBxz\fP використовують для стискання даних, які передають +потоком мережею. Невеликі значення аргументу \fIчас_очікування\fP зроблять дані +доступними на боці отримання із малою затримкою, а великі значення аргумент +\fIчас_очікування\fP уможливлять кращий коефіцієнт стискання. +.IP "" +Типово, цю можливість вимкнено. Якщо цей параметр вказано декілька разів, +буде використано лише останнє вказане значення. Особливим значенням +аргументу \fIчас_очікування\fP, рівним \fB0\fP, можна скористатися для вимикання +цієї можливості явним чином. +.IP "" +Ця можливість недоступна у системах, які не є системами POSIX. +.IP "" +.\" FIXME +\fBЦя можливість усе ще є експериментальною.\fP У поточній версії, \fBxz\fP не +може розпаковувати потік даних у режимі реального часу через те, у який +спосіб \fBxz\fP виконує буферизацію. +.TP +\fB\-\-no\-sync\fP +Не синхронізувати файл призначення та його каталог із пристроєм зберігання +даних до вилучення початкового файла. Це може підвищити швидкодію, якщо +виконується стискання або розпаковування багатьох малих файлів. Втім, якщо +система аварійно завершує роботу невдовзі після вилучення, можлива ситуація, +коли файл призначення не буде записано на пристрій зберігання даних, а дію з +вилучення буде записано. У цьому випадку буде знищено дані як початкового +файла, так і файла призначення. +.IP "" +Цей параметр матиме хоч який вплив, лише якщо \fBxz\fP вилучає початковий +файл. В інших випадках синхронізація не виконується. +.IP "" +Синхронізацію і \fB\-\-no\-sync\fP було додано у версії \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIобмеження\fP +Встановити обмеження на використання пам'яті при стисканні. Якщо цей +параметр вказано декілька разів, враховано буде лише останнє вказане +значення. +.IP "" +Якщо параметри стискання перевищують \fIобмеження\fP, \fBxz\fP спробує скоригувати +параметри так, щоб обмеження не було перевищено, і покаже повідомлення про +те, що було виконано автоматичне коригування. Коригування буде виконано у +такому порядку: зменшення кількості потоків обробки, перемикання у +однопотоковий режим, якщо хоч в одному потоці багатопотокового режиму буде +перевищено \fIобмеження\fP, і нарешті, зменшення розміру словника LZMA2. +.IP "" +При стисканні з використанням \fB\-\-format=raw\fP, або якщо було вказано +\fB\-\-no\-adjust\fP, може бути зменшена лише кількість потоків обробки, оскільки +це може бути зроблено без впливу на стиснені виведені дані. +.IP "" +Якщо \fIобмеження\fP не може бути виконано за допомогою коригувань, які описано +вище, буде показано повідомлення про помилку, а \fBxz\fP завершить роботу зі +станом виходу 1. +.IP "" +Аргумент \fIобмеження\fP можна вказати у декілька способів: +.RS +.IP \(bu 3 +Значенням \fIобмеження\fP може бути додатне ціле значення у байтах. Можна +скористатися цілочисельним суфіксом, подібним до \fBMiB\fP. Приклад: +\fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +Аргумент \fIобмеження\fP може бути задано у відсотках від загальної фізичної +пам'яті системи (RAM). Це може бути корисним особливо при встановленні +змінної середовища \fBXZ_DEFAULTS\fP у скрипті ініціалізації системи, який є +спільним для різних комп'ютерів. У такий спосіб можна вказати вищий рівень +обмеження для систем із більшим об'ємом пам'яті. Приклад: +\fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +Аргументу \fIобмеження\fP може бути повернуто типове значення встановленням +значення \fB0\fP. У поточній версії це еквівалентно до встановлення значення +аргументу \fIобмеження\fP \fBmax\fP (без обмеження на використання пам'яті). +.RE +.IP "" +Для 32\-бітової версії \fBxz\fP передбачено особливий випадок: якщо \fIобмеження\fP +перевищуватиме \fB4020\ МіБ\fP, для \fIобмеження\fP буде встановлено значення +\fB4020\ MiB\fP. На MIPS32 замість цього буде використано \fB2000\ MiB\fP. (Це не +стосується значень \fB0\fP і \fBmax\fP. Подібної можливості для розпаковування не +існує.) Це може бути корисним, коли 32\-бітовий виконуваний файл має доступ +до простору адрес у 4\ ГіБ (2 GiB на MIPS32), хоча, сподіваємося, не +зашкодить і в інших випадках. +.IP "" +Див. також розділ \fBВикористання пам'яті\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIобмеження\fP +Встановити обмеження пам'яті на розпаковування. це також вплине на режим +\fB\-\-list\fP. Якщо дія є неможливою без перевищення \fIобмеження\fP, \fBxz\fP покаже +повідомлення про помилку і розпаковування файла не +відбудеться. Див. \fB\-\-memlimit\-compress=\fP\fIобмеження\fP, щоб дізнатися більше +про те, як можна задати \fIобмеження\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIобмеження\fP +Встановити обмеження використання пам'яті для багатопотокового +розпаковування. Це може вплинути лише на кількість потоків обробки; це +ніколи не призводитиме до відмови \fBxz\fP у розпаковуванні файла. Якщо +\fIобмеження є надто низьким\fP, щоб уможливити будь\-яку багатопотокову +обробку, \fIобмеження\fP буде проігноровано, і \fBxz\fP продовжить обробку в +однопотоковому режимі. Зауважте, що якщо використано також +\fB\-\-memlimit\-decompress\fP, цей параметр буде застосовано до обох режимів, +однопотокового та багатопотокового, а отже, задіяне \fIобмеження\fP для +багатопотокового режиму ніколи не перевищуватиме обмеження, яке встановлено +за допомогою \fB\-\-memlimit\-decompress\fP. +.IP "" +На відміну від інших параметрів обмеження використання пам'яті, +\fB\-\-memlimit\-mt\-decompress=\fP\fIобмеження\fP містить специфічне для системи +типове значення \fIобмеження\fP. Можна скористатися \fBxz \-\-info\-memory\fP для +перегляду поточного значення. +.IP "" +Цей параметр і його типове значення існують, оскільки без будь\-яких обмежень +засіб розпакування зі підтримкою потокової обробки міг би намагатися +отримати величезний об'єм пам'яті для деяких файлів вхідних даних. Якщо +типове \fIобмеження\fP є надто низьким для вашої системи, не вагайтеся і +збільшуйте \fIобмеження\fP, але ніколи не встановлюйте для нього значення, яке +є більшим за придатний до користування об'єм оперативної пам'яті, оскільки +за відповідних файлів вхідних даних \fBxz\fP спробує скористатися цим об'ємом +пам'яті, навіть із низькою кількістю потоків обробки. Вичерпання об'єму +оперативної пам'яті або використання резервної пам'яті на диску не покращить +швидкодію системи під час розпаковування. +.IP "" +Див. \fB\-\-memlimit\-compress=\fP\fIобмеження\fP, щоб ознайомитися із можливими +способами визначення \fIобмеження\fP. Встановлення для \fIобмеження\fP значення +\fB0\fP відновлює типове специфічне для системи значення \fIобмеження\fP. +.TP +\fB\-M\fP \fIобмеження\fP, \fB\-\-memlimit=\fP\fIобмеження\fP, \fB\-\-memory=\fP\fIобмеження\fP +Є еквівалентом визначення \fB\-\-memlimit\-compress=\fP\fIобмеження\fP +\fB\-\-memlimit\-decompress=\fP\fIобмеження\fP +\fB\-\-memlimit\-mt\-decompress=\fP\fIобмеження\fP. +.TP +\fB\-\-no\-adjust\fP +Показати повідомлення про помилку і завершити роботу, якщо не вдасться +виконати умови щодо обмеження використання пам'яті без коригування +параметрів, які впливають на стиснених виведених даних. Тобто це забороняє +\fBxz\fP перемикати кодувальник з багатопотокового режиму на однопотоковий +режим і зменшувати розмір словника LZMA2. Навіть якщо використано цей +параметр, кількість потоків може бути зменшено для виконання обмеження на +використання пам'яті, оскільки це не вплине на результати стискання. +.IP "" +Автоматичне коригування завжди буде вимкнено при створенні потоків +необроблених даних (\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fIпотоки\fP, \fB\-\-threads=\fP\fIпотоки\fP +Вказати кількість потоків обробки, якими слід скористатися. Встановлення для +аргументу \fIпотоки\fP особливого значення \fB0\fP наказує \fBxz\fP використати не +більше потоків обробки, ніж передбачено підтримку у процесорах +системи. Справжня кількість потоків може бути меншою за значення \fIпотоки\fP, +якщо файл вхідних даних не є достатньо великим для поділу на потоки обробки +при заданих параметрах або якщо використання додаткових потоків призведе до +перевищення обмеження на використання пам'яті. +.IP "" +Засоби стискання в однопотоковому та багатопотоковому режимі дають різні +результати. Однопотоковий засіб стискання дасть найменший розмір файла, але +лише результати роботи багатопотокового засобу стискання може бути +розпаковано з використанням декількох потоків. Встановлення для аргументу +\fIпотоки\fP значення \fB1\fP призведе до використання однопотокового +режиму. Встановлення для аргументу \fIпотоки\fP будь\-якого іншого значення, +включно з \fB0\fP, призведе до використання багатопотокового засобу стискання, +навіть якщо у системі передбачено підтримки лише одного апаратного потоку +обробки даних. (Версія \fBxz\fP 5.2.x у цьому випадку використовувала +однопотоковий режим.) +.IP "" +Щоб скористатися багатопотоковим режимом із лише одним потоком обробки, +встановіть для аргументу \fIпотоки\fP значення \fB+1\fP. Префікс \fB+\fP не впливає +на значення, окрім \fB1\fP. Обмеження на використання пам'яті можуть перемкнути +\fBxz\fP в однопотоковий режим, якщо не використано параметр +\fB\-\-no\-adjust\fP. Підтримку \fB+\fP prefix було додано у версії \fBxz\fP 5.4.0. +.IP "" +Якщо було вказано автоматичне визначення кількості потоків і не вказано +обмеження на використання пам'яті, буде використано специфічне для системи +типове м'яке обмеження для можливого обмеження кількості потоків обробки. Це +обмеження є м'яким у сенсі того, що його буде проігноровано, якщо кількість +потоків зрівняється з одиницею, а отже, м'яке обмеження ніколи не +запобігатиму у \fBxz\fP стисканню або розпаковуванню. Це типове м'яке обмеження +не перемкне \fBxz\fP з багатопотокового режиму на однопотоковий режим. Активні +обмеження можна переглянути за допомогою команди \fBxz \-\-info\-memory\fP. +.IP "" +У поточній версії єдиним способом поділу на потоки обробки є поділ вхідних +даних на блоки і стискання цих блоків незалежно один від одного. Типовий +розмір блоку залежить від рівня стискання. Його може бути перевизначено за +допомогою параметра \fB\-\-block\-size=\fP\fIрозмір\fP. +.IP "" +Розпакування з потоками обробки працює лише для файлів, які містять декілька +блоків із даними щодо розміру у заголовках блоків. Цю умову задовольняють +усі достатньо великі файли, які стиснено у багатопотоковому режимі, але не +задовольняють будь\-які файли, які було стиснуто у однопотоковому режимі, +навіть якщо було використано параметр \fB\-\-block\-size=\fP\fIрозмір\fP. +.IP "" +Типовим значенням для \fIпотоків\fP є \fB0\fP. У \fBxz\fP 5.4.x та старіших версіях +типовим значенням є \fB1\fP. +. +.SS "Нетипові ланцюжки фільтрів засобу стискання" +Нетиповий ланцюжок фільтрування уможливлює докладне визначення параметрів +стискання замість використання параметрів, які пов'язано із наперед +визначеними рівнями стискання. Якщо вказано нетиповий ланцюжок фільтрів, +параметри рівнів стискання (\fB\-0\fP \&...\& \fB\-9\fP і \fB\-\-extreme\fP), які +передують їм у рядку команди, буде знехтувано. Якщо параметр рівня стискання +вказано після одного або декількох параметрів нетипового ланцюжка фільтрів, +буде використано рівень стискання, а попередніми параметрами ланцюжка +фільтрування буде знехтувано. +.PP +Ланцюжок фільтрів можна порівняти із конвеєром у командному рядку. При +стисканні нестиснені вхідні дані потрапляють до першого фільтра, виведені +ним дані йдуть до наступного фільтра (якщо такий є). Виведені останнім +фільтром дані буде записано до стисненого файла. Максимальна кількість +фільтрів у ланцюжку дорівнює чотирьом, але у типовому ланцюжку фільтрів +використовують один або два фільтри. +.PP +У багатьох фільтрів є обмеження на місце перебування у ланцюжку фільтрів: +деякі фільтри можуть працювати, лише якщо вони є останніми у ланцюжку, +деякі, лише якщо не останніми, а деякі працюють у будь\-якій позиції +ланцюжка. Залежно від фільтра, це обмеження є наслідком структури фільтра +або існує для запобігання проблем із захистом. +.PP +Нетиповий ланцюжок фільтрів можна вказати двома різними способами. Параметри +\fB\-\-filters=\fP\fIфільтри\fP і \fB\-\-filters1=\fP\fIфільтри\fP \&...\& +\fB\-\-filters9=\fP\fIфільтри\fP надають змогу вказати цілий ланцюжок фільтрів в +одному варіанті з використанням синтаксису рядків фільтрів liblzma. Крім +того, ланцюжок фільтрів можна вказати за допомогою одного або кількох +окремих параметрів фільтрування у тому порядку, в якому їх слід використати +у ланцюжку фільтрів. Тобто порядок окремих параметрів фільтра є важливим! +Під час декодування необроблених потоків (\fB\-\-format=raw\fP) ланцюжок фільтрів +має бути вказано у тому ж порядку, що й під час стиснення. Будь\-який окремий +фільтр або параметри попереднього налаштування, вказані перед параметром +повного ланцюжка (\fB\-\-filters=\fP\fIфільтри\fP), буде відкинуто. Окремі фільтри, +указані після параметра повного ланцюжка, відновлять типовий ланцюжок +фільтрів. +.PP +І параметр повного і параметр окремого фільтра приймають специфічні для +фільтрів \fIпараметри\fP у форматі списку значень, які відокремлено +комами. Зайві коми у \fIпараметрах\fP буде проігноровано. У кожного параметра є +типове значення, отже, вам слід вказати ті параметри, значення яких ви +хочете змінити. +.PP +Щоб переглянути увесь ланцюжок фільтрів та \fIпараметри\fP, скористайтеся +командою \fBxz \-vv\fP (тобто, скористайтеся \fB\-\-verbose\fP двічі). Це працює +також для перегляду параметрів ланцюжка фільтрів, який використано у рівнях +стискання. +.TP +\fB\-\-filters=\fP\fIфільтри\fP +Визначає повний ланцюжок фільтрів або шаблон у форматі одного +параметра. Кожен фільтр можна відокремити від інших пробілами або двома +дефісами (\fB\-\-\fP). Можливо, \fIфільтри\fP доведеться взяти в лапки в командному +рядку оболонки, щоб їх було оброблено як один параметр. Для позначення +\fIпараметрів\fP скористайтеся \fB:\fP або \fB=\fP. До шаблона можна додати префікс +\fB\-\fP і завершити без прапорців або декількома прапорцями. Єдиним +підтримуваним прапорцем є \fBe\fP для застосування тих самих параметрів, що й +\fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIфільтри\fP ... \fB\-\-filters9\fP=\fIфільтри\fP +Вказати до дев'яти додаткових ланцюжків фільтрів, якими можна скористатися +за допомогою \fB\-\-block\-list\fP. +.IP "" +Наприклад, якщо виконується стискання архіву із виконуваними файлами, за +якими йдуть текстові файли, для виконуваної частини може бути використано +ланцюжок фільтрів з фільтром BCJ, а для текстової частини — лише фільтр +LZMA2. +.TP +\fB\-\-filters\-help\fP +Вивести довідкове повідомлення з описом того, як вказати шаблони та нетипові +ланцюжки фільтрів у параметри \fB\-\-filters\fP і \fB\-\-filters1=\fP\fIфільтри\fP +\&...\& \fB\-\-filters9=\fP\fIфільтри\fP і завершити роботу із кодом успіху. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIпараметри\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIпараметри\fP] +.PD +Додати фільтр LZMA1 або LZMA2 до ланцюжка фільтрів. Ці фільтри може бути +використано лише як останній фільтр у ланцюжку. +.IP "" +LZMA1 є застарілим фільтром, підтримку якого збережено майже лише через +використання формату файлів \fB.lzma\fP, у яких передбачено підтримку лише +LZMA1. LZMA2 є оновленою версією LZMA1, у якій виправлено деякі практичні +вади LZMA1. У форматі \fB.xz\fP використано LZMA2 і взагалі не передбачено +підтримки LZMA1. Швидкість стискання та коефіцієнт стискання для LZMA1 і +LZMA2 є практично однаковими. +.IP "" +LZMA1 і LZMA2 спільно використовують той самий набір \fIпараметрів\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIшаблон\fP +Скинути усі \fIпараметри\fP LZMA1 або LZMA2 до параметрів \fIшаблона\fP. Аргумент +\fIшаблон\fP складається з цілого числа, після якого може бути однолітерний +модифікатор шаблона. Ціле число може належати лише діапазону від \fB0\fP до +\fB9\fP, що відповідає параметрам командного рядка \fB\-0\fP \&...\& \fB\-9\fP. Єдиним +підтримуваним модифікатором у поточній версії є \fBe\fP, щоб відповідає +параметру \fB\-\-extreme\fP. Якщо аргумент \fBшаблон\fP не вказано, типові значення +\fIпараметрів\fP LZMA1 або LZMA2 буде взято із шаблона \fB6\fP. +.TP +\fBdict=\fP\fIрозмір\fP +Параметр \fIрозміру\fP словника (буфера журналу) визначає, скільки байтів +нещодавно оброблених нестиснених даних слід зберігати у пам'яті. Алгоритм +намагається знайти повторювані послідовності байтів (відповідники) у +нестиснених даних і замінити їх на посилання на дані зі словника. Чим +більшим є словник, тим вищою є ймовірність відшукати відповідник. Отже, +збільшення \fIрозміру\fP словника, зазвичай, покращує коефіцієнт стискання, але +використання словника, розмір якого перевищу є розмір нестисненого файла є +простоюю витратою пам'яті. +.IP "" +\fIРозмір\fP типового словника складає від 64\ КіБ до 64\ МіБ. Мінімальним є +розмір 4\ КіБ. Максимальним розміром для стискання у поточній версії 1.5\ ГіБ (1536\ МіБ). У засобі розпаковування вже передбачено підтримку словників +на один байт менших за 4\ ГіБ, що є максимальним значенням для форматів +потоків даних LZMA1 і LZMA2. +.IP "" +Аргумент \fIрозміру\fP словника і засіб пошуку відповідників (\fImf\fP) разом +визначають параметри використання пам'яті для кодувальника LZMA1 або +LZMA2. Для розпаковування потрібен такий самий (або більший) \fIрозмір\fP +словника, що і для стискання, отже, використання пам'яті для засобу +розпаковування буде визначено за розміром словника, який було використано +для стискання. У заголовках \fB.xz\fP зберігається \fIрозмір\fP словника або як +2^\fIn\fP, або як 2^\fIn\fP + 2^(\fIn\fP\-1), отже, ці \fIрозміри\fP є дещо пріоритетними +для стискання. Інші \fIрозміри\fP буде отримано округленням при зберіганні у +заголовках \fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Визначає кількість буквальних контекстних бітів. Мінімальною кількістю є 0, +а максимальною — 4. Типовою кількістю є 3. Крім того, сума \fIlc\fP і \fIlp\fP має +не перевищувати 4. +.IP "" +Усі байти, які не може бути закодовано як відповідності, буде закодовано як +літерали. Тобто літерали є просто 8\-бітовими байтами, які буде закодовано по +одному за раз. +.IP "" +При кодуванні літералів роблять припущення, що найвищі біти \fIlc\fP +попереднього нестисненого байта корелюють із наступним байтом. Наприклад, у +типовому тексті англійською за літерою у верхньому регістрі йде літера у +нижньому регістрі, а за літерою у нижньому регістрі, зазвичай, йде інша +літера у нижньому регістрі. У наборі символів US\-ASCII найвищими трьома +бітами є 010 для літер верхнього регістру і 011 для літер нижнього +регістру. Якщо \fIlc\fP дорівнює принаймні 3, при кодуванні літералів можна +отримати перевагу встановлення цієї властивості для нестиснених даних. +.IP "" +Зазвичай, типового значення (3) достатньо. Якщо вам потрібне максимальне +стискання, спробуйте \fBlc=4\fP. Іноді це трохи допомагає, а іноді, робить +стискання гіршим. Якщо стискання стане гіршим, спробуйте також \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Визначає кількість буквальних позиційних бітів. Мінімальною кількістю є 0, а +максимальною — 4. Типовою кількістю є 0. +.IP "" +\fILp\fP впливає на те, яке вирівнювання у нестиснених даних слід припускати +при кодуванні літералів. Див. \fIpb\fP нижче, щоб дізнатися більше про +вирівнювання. +.TP +\fBpb=\fP\fIpb\fP +Визначає кількість позиційних бітів. Мінімальною кількістю є 0, а +максимальною — 4. Типовою кількістю є 2. +.IP "" +\fIPb\fP впливає на те, який тип вирівнювання загалом припускатиметься для +нестиснених даних. Типовим є чотирибайтове вирівнювання (2^\fIpb\fP=2^2=4), +яке, зазвичай, є добрим варіантом, якщо немає кращих припущень. +.IP "" +Якщо вирівнювання є відомим, встановлення відповідним чином \fIpb\fP може трохи +зменшити розмір файла. Наприклад, у текстових файлах із однобайтовим +вирівнюванням (US\-ASCII, ISO\-8859\-*, UTF\-8), встановлення значення \fBpb=0\fP +може трохи поліпшити стискання. Для тексту UTF\-16 добрим варіантом є +\fBpb=1\fP. Якщо вирівнювання є непарним числом, наприклад 3 байти, найкращим +вибором, ймовірно, є \fBpb=0\fP. +.IP "" +Хоча прогнозоване вирівнювання можна скоригувати за допомогою \fIpb\fP і \fIlp\fP, +у LZMA1 і LZMA2 дещо пріоритетним є 16\-байтове вирівнювання. Це, ймовірно, +слід враховувати при компонуванні форматів файлів, які, ймовірно, часто +будуть стискатися з використанням LZMA1 або LZMA2. +.TP +\fBmf=\fP\fImf\fP +Засіб пошуку відповідників має значний вплив на швидкість, використання +пам'яті та коефіцієнт стискання кодувальника. Зазвичай, засоби пошуку +відповідників на основі ланцюжка хешів є швидшими за засоби пошуку +відповідників на основі двійкового дерева. Типовий засіб залежить від +\fIшаблона\fP: для 0 використовують \fBhc3\fP, для 1\(en3 — \fBhc4\fP, а для решти +використовують \fBbt4\fP. +.IP "" +Передбачено підтримку вказаних нижче засобів пошуку відповідників. Наведені +нижче формули обчислення використання пам'яті є грубими наближеннями, які є +найближчими до реальних значень, якщо значенням \fIсловник\fP є степінь двійки. +.RS +.TP +\fBhc3\fP +Ланцюжок хешів із 2\- та 3\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 3 +.br +Використання пам'яті: +.br +\fIdict\fP * 7.5 (якщо \fIdict\fP <= 16 МіБ); +.br +\fIdict\fP * 5.5 + 64 МіБ (якщо \fIdict\fP > 16 МіБ) +.TP +\fBhc4\fP +Ланцюжок хешів із 2\-, 3\- та 4\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 4 +.br +Використання пам'яті: +.br +\fIdict\fP * 7.5 (якщо \fIdict\fP <= 32 МіБ); +.br +\fIdict\fP * 6.5 (якщо \fIdict\fP > 32 МіБ) +.TP +\fBbt2\fP +Двійкове дерево із 2\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 2 +.br +Використання пам'яті: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Двійкове дерево із 2\- і 3\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 3 +.br +Використання пам'яті: +.br +\fIdict\fP * 11.5 (якщо \fIdict\fP <= 16 МіБ); +.br +\fIdict\fP * 9.5 + 64 МіБ (якщо \fIdict\fP > 16 МіБ) +.TP +\fBbt4\fP +Двійкове дерево із 2\-, 3\- і 4\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 4 +.br +Використання пам'яті: +.br +\fIdict\fP * 11.5 (якщо \fIdict\fP <= 32 МіБ); +.br +\fIdict\fP * 10.5 (якщо \fIdict\fP > 32 МіБ) +.RE +.TP +\fBmode=\fP\fIрежим\fP +Параметр \fIрежиму\fP стискання визначає спосіб, який буде використано для +аналізу даних, які створено засобом пошуку відповідників. Підтримуваними +\fIрежимами\fP є \fBfast\fP (швидкий) і \fBnormal\fP (нормальний). Типовим є режим +\fBfast\fP для \fIшаблонів\fP 0\(en3 і режим \fBnormal\fP для \fIшаблонів\fP 4\(en9. +.IP "" +Зазвичай, із засобом пошуку відповідників на основі ланцюжка хешів +використовують \fBfast\fP, а із засобом пошуку відповідників на основі +двійкового дерева використовують \fBnormal\fP. Так само налаштовано і +\fIшаблони\fP. +.TP +\fBnice=\fP\fIпріоритетність\fP +Вказати, яка довжина є пріоритетною для відповідності. Щойно буде виявлено +відповідність у принаймні \fIпріоритетність\fP байтів, алгоритм зупинятиме +пошук можливих кращих відповідників. +.IP "" +\fIПріоритетністю\fP може бути число до 2\(en273 байтів. Вищі значення дають +кращий коефіцієнт стискання за рахунок швидкості. Типове значення залежить +від \fIшаблона\fP. +.TP +\fBdepth=\fP\fIглибина\fP +Вказати максимальну глибину пошуку у засобі пошуку відповідності. Типовим є +особливе значення 0, яке наказує засобу стискання визначити прийнятну +\fIглибину\fP на основі \fImf\fP і \fIпріоритетності\fP. +.IP "" +Прийнятним значенням \fIглибини\fP для ланцюжків хешів є 4\(en100 і 16\(en1000 +для двійкових дерев. Використання дуже високих значень для \fIглибини\fP може +зробити кодувальник дуже повільним для деяких файлів. Не встановлюйте +значення \fIглибини\fP, що перевищує 1000, якщо ви не готові перервати +стискання, якщо воно триватиме надто довго. +.RE +.IP "" +При декодуванні необроблених потоків даних (\fB\-\-format=raw\fP), LZMA2 потребує +лише \fIрозміру\fP словника. LZMA1 потребує також \fIlc\fP, \fIlp\fP і \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIпараметри\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIпараметри\fP] +.PD +Додати фільтр гілок/викликів/переходів (branch/call/jump або BCJ) до +ланцюжка фільтрів. Цими фільтрами можна скористатися, лише якщо вони не є +останнім фільтром у ланцюжку фільтрів. +.IP "" +Фільтр BCJ перетворює відносні адреси у машинному коді на їхні абсолютні +відповідники. Це не змінює розміру даних, але підвищує резервування, що може +допомогти LZMA2 створити файл \fB.xz\fP на 0\(en15\ % менше. Фільтри BCJ завжди +є придатними до обернення, тому використання фільтра BCJ до помилкового типу +даних не спричинятиме втрати даних, хоча може дещо погіршити коефіцієнт +стискання. Фільтри BCJ є дуже швидкими і такими, що використовують незначний +об'єм пам'яті. +.IP "" +Ці фільтри BCJ мають відомі проблеми, які пов'язано із рівнем стискання: +.RS +.IP \(bu 3 +У деяких типах файлів, де зберігається виконуваний код, (наприклад, в +об'єктних файлах, статичних бібліотеках та модулях ядра Linux) адреси в +інструкціях заповнено значеннями заповнювача. Ці фільтри BCJ виконуватимуть +перетворення адрес, яке зробить стискання для цих файлів гіршим. +.IP \(bu 3 +Якщо фільтр BCJ застосовано до архіву, може так статися, що він погіршить +коефіцієнт стискання порівняно із варіантом без фільтра BCJ. Наприклад, якщо +є подібні або навіть однакові виконувані файли, фільтрування, ймовірно, +зробить ці файли менш подібними, а отже, зробить стискання гіршим. Вміст +файлів, які не є виконуваними, у тому самому архіві також може вплинути на +результат. На практиці, варто спробувати варіанти з фільтром BCJ і без +нього, щоб визначитися із тим, що буде кращим у кожній ситуації. +.RE +.IP "" +Різні набори інструкцій мають різне вирівнювання: виконуваний файл має бути +вирівняно на кратне до цього значення у вхідних даних, щоб фільтр спрацював. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Фільтр;Вирівнювання;Нотатки +x86;1;32\-бітова або 64\-бітова x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;Найкращим є вирівнювання за +;;4096 байтами +PowerPC;4;Лише зворотний порядок байтів +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Оскільки фільтровані BCJ дані, зазвичай, стискають за допомогою LZMA2, +коефіцієнт стискання можна трохи поліпшити, якщо параметри LZMA2 буде +встановлено так, щоб вони відповідали вирівнюванню вибраного фільтра +BCJ. Приклади: +.RS +.IP \(bu 3 +Фільтр IA\-64 має 16\-байтове вирівнювання, отже \fBpb=4,lp=4,lc=0\fP дасть добрі +результати у поєднанні із LZMA2 (2^4=16). +.IP \(bu 3 +Код RISC\-V має 2\-байтове або 4\-байтове вирівнювання залежно від того, чи +містить файл 16\-бітові стислі інструкції (розширення C). Якщо використано +16\-бітові інструкції, добрі результати дасть \fBpb=2,lp=1,lc=3\fP або +\fBpb=1,lp=1,lc=3\fP. Якщо 16\-бітових інструкцій немає, найкращим варіантом є +\fBpb=2,lp=2,lc=2\fP. Можна скористатися \fBreadelf \-h\fP, щоб перевірити, чи є +"RVC" у рядку "Flags". +.IP \(bu 3 +ARM64 завжди вирівняно на 4 байти, тому найкращим варіантом буде +\fBpb=2,lp=2,lc=2\fP. +.IP \(bu 3 +Фільтр x86 є виключенням. Зазвичай, добрі результати дають типові для LZMA2 +значення (\fBpb=2,lp=0,lc=3\fP), якщо стискають виконувані файли x86. +.RE +.IP "" +У всіх фільтрах BCJ передбачено підтримку тих самих \fIпараметрів\fP: +.RS +.TP +\fBstart=\fP\fIзсув\fP +Встановити початковий \fIзсув\fP, який буде використано при перетворенні між +відносною та абсолютною адресами. Значення \fIзсув\fP має бути кратним до +вирівнювання фільтра (див. таблицю вище). Типовим зсувом є нульовий. На +практиці, типове значення є прийнятним; визначення нетипового значення +\fIзсув\fP майже завжди нічого корисного не дає. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIпараметри\fP] +Додати дельта\-фільтр до ланцюжка фільтрів. Дельта\-фільтр може бути +використано, лише якщо він не є останнім у ланцюжку фільтрів. +.IP "" +У поточній версії передбачено підтримку обчислення лише простої побітової +дельти. Це може бути корисним при стисканні, наприклад, нестиснутих +растрових зображень або нестиснутих звукових даних PCM. Втім, спеціалізовані +алгоритми можуть давати значно кращі результати за дельту + LZMA2. Це +правило особливо стосується звукових даних, які стискає швидше і краще, +наприклад, \fBflac\fP(1). +.IP "" +Підтримувані \fIпараметри\fP: +.RS +.TP +\fBdist=\fP\fIвідстань\fP +Вказати \fIвідстань\fP обчислень різниці у байтах. Значення \fIвідстань\fP має +потрапляти у діапазон 1\(en256. Типовим значенням є 1. +.IP "" +Наприклад, з \fBdist=2\fP та восьмибайтовими вхідними даними A1 B1 A2 B3 A3 B5 +A4 B7, результатом буде A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Інші параметри" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Придушити попередження та сповіщення. Вкажіть цей параметр двічі, щоб +придушити також повідомлення про помилки. Цей параметр не впливає на стан +виходу з програми. Тобто, навіть якщо було придушено попередження, стан +виходу вказуватиме на те, що попередження були. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Докладний режим повідомлень. Якщо стандартне виведення помилок з'єднано із +терміналом, \fBxz\fP показуватиме індикатор поступу. Використання \fB\-\-verbose\fP +двічі призведе до ще докладнішого виведення. +.IP "" +Індикатор поступу показує такі дані: +.RS +.IP \(bu 3 +Частку завершеності буде показано, якщо відомий розмір файла вхідних +даних. Тобто, для каналів даних частку не може бути показано. +.IP \(bu 3 +Об'єм стиснених виведених даних (стискання) або оброблених (розпаковування). +.IP \(bu 3 +Об'єм незапакованих даних (стискання) або виведених даних (розпаковування). +.IP \(bu 3 +Коефіцієнт стискання, який обчислено діленням об'єму оброблених стиснутих +даних на об'єм оброблених нестиснутих даних. +.IP \(bu 3 +Швидкість стискання або розпаковування. Обчислюється як об'єм нестиснутих +даних (стискання) або виведених даних (розпаковування) за секунду. Його буде +показано за декілька секунд з моменту, коли \fBxz\fP почала обробляти файл. +.IP \(bu 3 +Витрачений час у форматі Х:СС або Г:ХХ:СС. +.IP \(bu 3 +Оцінку часу, що лишився, буде показано, лише якщо розмір файла вхідних даних +є відомим, і минуло принаймні декілька секунд з моменту, коли \fBxz\fP почала +обробляти файл. Час буде показано у менш точному форматі, без двокрапок, +наприклад, 2 хв. 30 с. +.RE +.IP "" +Якщо стандартним виведенням помилок не є термінал, \fB\-\-verbose\fP призведе до +того, що \fBxz\fP виведе назву файла, стиснений розмір, нестиснений розмір, +коефіцієнт стискання та, можливо, також швидкість та витрачений час у одному +рядку до стандартного виведення помилок після стискання або розпаковування +файла. Швидкість та витрачений час буде включено, лише якщо дія триває +принаймні декілька секунд. Якщо дію не буде завершено, наприклад, через +втручання користувача, буде також виведено частку виконання, якщо відомий +розмір файла вхідних даних. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Не встановлювати стан виходу 2, навіть якщо було виявлено відповідність +умові, яка варта попередження. Цей параметр не впливає на рівень докладності +повідомлень, отже, слід використати \fB\-\-quiet\fP і \fB\-\-no\-warn\fP, щоб програма +не показувала попереджень і не змінювала стан виходу. +.TP +\fB\-\-robot\fP +Виводити повідомлення у придатному для обробки комп'ютером форматі. Цей +формат призначено для полегшення написання оболонок, які використовуватимуть +\fBxz\fP замість liblzma, що може бути зручним для різноманітних +скриптів. Виведені дані з цим параметром має бути стабільним для усіх +випусків \fBxz\fP. Докладніший опис можна знайти у розділі \fBРЕЖИМ РОБОТА\fP. +.TP +\fB\-\-info\-memory\fP +Вивести у придатному для читання людиною форматі, скільки фізичної пам'яті +(RAM) та скільки потоків процесора є за даними \fBxz\fP у системі, обмеження +для стискання та розпаковування, а потім успішно завершити роботу. +.TP +\fB\-h\fP, \fB\-\-help\fP +Вивести повідомлення про помилку з описом найбільш типових використаних +параметрів і успішно завершити роботу. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Вивести довідкове повідомлення з описом усіх можливостей \fBxz\fP і успішно +завершити роботу +.TP +\fB\-V\fP, \fB\-\-version\fP +Вивести номер версії \fBxz\fP та liblzma у зручному для читання форматі. Щоб +отримати дані, зручні для обробки на комп'ютері, вкажіть \fB\-\-robot\fP до +\fB\-\-version\fP. +. +.SH "РЕЖИМ РОБОТА" +Режим робота активують за допомогою параметра \fB\-\-robot\fP. Він спрощує +обробку виведених \fBxz\fP даних іншими програмами. У поточній версії підтримку +\fB\-\-robot\fP передбачено лише разом із \fB\-\-list\fP, \fB\-\-filters\-help\fP, +\fB\-\-info\-memory\fP і \fB\-\-version\fP. У майбутньому підтримку параметра буде +передбачено для стискання та розпаковування. +. +.SS "Режим списку" +У \fBxz \-\-robot \-\-list\fP використано табуляції для поділу виведених +даних. Першим стовпчиком у кожному рядку є рядок, що вказує на тип +відомостей, які можна знайти у цьому рядку: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Це завжди перший рядок на початку списку файла. Другим стовпчиком у рядку є +назва файла. +.TP +\fBfile\fP +У цьому рядку містяться загальні відомості щодо файла \fB.xz\fP. Цей рядок +завжди виводять після рядка \fBname\fP. +.TP +\fBstream\fP +Цей тип рядка використовують, лише якщо було вказано \fB\-\-verbose\fP. Буде +стільки рядків \fBstream\fP, скільки потоків у файлі \fB.xz\fP. +.TP +\fBblock\fP +Цей тип рядка використовують, лише якщо було вказано \fB\-\-verbose\fP. Буде +стільки рядків \fBblock\fP, скільки блоків у файлі \fB.xz\fP. Рядки \fBblock\fP буде +показано після усіх рядків \fBstream\fP; різні типи рядків не перемежовуються. +.TP +\fBsummary\fP +Цей тип рядків використовують, лише якщо \fB\-\-verbose\fP було вказано +двічі. Цей рядок буде виведено після усіх рядків \fBblock\fP. Подібно до рядка +\fBfile\fP, рядок \fBsummary\fP містить загальні відомості щодо файла \fB.xz\fP. +.TP +\fBtotals\fP +Цей рядок завжди є найостаннішим рядком у виведеному списку. У ньому буде +показано загальні кількості та розміри. +.PP +Стовпчики у рядках \fBфайла\fP: +.PD 0 +.RS +.IP 2. 4 +Кількість потоків у файлі +.IP 3. 4 +Загальна кількість блоків у потоках +.IP 4. 4 +Розмір стисненого файла +.IP 5. 4 +Розмір нестисненого файла +.IP 6. 4 +Коефіцієнт стискання, наприклад, \fB0.123\fP. Якщо коефіцієнт перевищує 9.999, +замість коефіцієнта буде показано дефіси (\fB\-\-\-\fP). +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Список відокремлених комами назв перевірок цілісності. Наведені нижче рядки +використовують для відомих типів перевірок: \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP і +\fBSHA\-256\fP. Для невідомих типів перевірок буде використано \fBUnknown\-\fP\fIN\fP, +де \fIN\fP є ідентифікатором перевірки у форматі десяткового числа (одна або +дві цифри). +.IP 8. 4 +Загальний розмір доповнення потоку у файлі +.RE +.PD +.PP +Стовпчики у рядках \fBstream\fP: +.PD 0 +.RS +.IP 2. 4 +Номер потоку (перший потік має номер 1) +.IP 3. 4 +Кількість блоків у потоці +.IP 4. 4 +Зсув початку стисненого +.IP 5. 4 +Зсув початку нестисненого +.IP 6. 4 +Стиснений розмір (не включає доповнення потоку) +.IP 7. 4 +Нестиснутий розмір +.IP 8. 4 +Рівень стискання +.IP 9. 4 +Назва перевірки цілісності +.IP 10. 4 +Розмір доповнення потоку +.RE +.PD +.PP +Стовпчики у рядках \fBblock\fP: +.PD 0 +.RS +.IP 2. 4 +Номер потоку, що містить цей блок +.IP 3. 4 +Номер блоку відносно початку потоку (перший блок має номер 1) +.IP 4. 4 +Номер блоку відносно початку файла +.IP 5. 4 +Зсув початку стисненого відносно початку файла +.IP 6. 4 +Зсув початку нестисненого відносно початку файла +.IP 7. 4 +Загальний стиснений розмір блоку (включено з заголовками) +.IP 8. 4 +Нестиснутий розмір +.IP 9. 4 +Рівень стискання +.IP 10. 4 +Назва перевірки цілісності +.RE +.PD +.PP +Якщо \fB\-\-verbose\fP було вказано двічі, до рядків \fBblock\fP буде включено +додаткові стовпчики. Ці стовпчики не буде показано, якщо вказано одинарний +параметр \fB\-\-verbose\fP, оскільки отримання цих відомостей потребує багатьох +позиціювань, а ця процедура може бути повільною: +.PD 0 +.RS +.IP 11. 4 +Значення перевірки цілісності у шістнадцятковій формі +.IP 12. 4 +Розмір заголовка блоку +.IP 13. 4 +Прапорці блоку: \fBc\fP вказує, що наявний стиснений розмір, а \fBu\fP вказує, що +наявний нестиснений розмір. Якщо прапорець не встановлено, буде показано +(\fB\-\fP) замість підтримання фіксованого розміру рядка. У майбутньому +наприкінці рядка може бути додано нові прапорці. +.IP 14. 4 +Розмір справжніх стиснених даних у блоці (це включає заголовок блоку, +доповнення блоку та поля перевірок) +.IP 15. 4 +Об'єм пам'яті (у байтах), який потрібен для розпаковування цього блоку за +допомогою цієї версії \fBxz\fP +.IP 16. 4 +Ланцюжок фільтрів. Зауважте, що більшість параметрів, які використано під +час стискання, не є наперед відомим, оскільки у заголовках \fB.xz\fP +зберігаються лише параметри, які потрібні для розпаковування. +.RE +.PD +.PP +Стовпчики у рядках \fBsummary\fP: +.PD 0 +.RS +.IP 2. 4 +Об'єм пам'яті (у байтах), який потрібен для розпаковування цього файла за +допомогою цієї версії \fBxz\fP +.IP 3. 4 +\fByes\fP або \fBno\fP вказує, якщо усі заголовки блоків містять одразу стиснений +розмір та розпакований розмір +.PP +\fIПочинаючи з\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Мінімальна версія \fBxz\fP, яка потрібна для розпаковування файла +.RE +.PD +.PP +Стовпчики рядка \fBtotals\fP: +.PD 0 +.RS +.IP 2. 4 +Кількість потоків +.IP 3. 4 +Кількість блоків +.IP 4. 4 +Стиснутий розмір +.IP 5. 4 +Нестиснутий розмір +.IP 6. 4 +Середній коефіцієнт стискання +.IP 7. 4 +Список відокремлених комами назв перевірок цілісності, результати яких +наявні у файлах +.IP 8. 4 +Розмір доповнення потоку +.IP 9. 4 +Кількість файлів. Наявний тут для зберігання такого самого порядку +стовпчиків, що і у попередніх рядках \fBfile\fP. +.PD +.RE +.PP +Якщо \fB\-\-verbose\fP було вказано двічі, до рядка \fBtotals\fP буде включено +додаткові стовпчики: +.PD 0 +.RS +.IP 10. 4 +Максимальний об'єм пам'яті (у байтах), який потрібен для розпаковування +файлів за допомогою цієї версії \fBxz\fP +.IP 11. 4 +\fByes\fP або \fBno\fP вказує, якщо усі заголовки блоків містять одразу стиснений +розмір та розпакований розмір +.PP +\fIПочинаючи з\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Мінімальна версія \fBxz\fP, яка потрібна для розпаковування файла +.RE +.PD +.PP +У майбутніх версіях може бути додано нові типи рядків і нові стовпчики до +наявних типів рядків, але наявні стовпчики мають лишитися незмінними. +. +.SS "Довідка з фільтрування" +\fBxz \-\-robot \-\-filters\-help\fP виведе список підтримуваних фільтрів у такому +форматі: +.PP +\fIфільтр\fP\fB:\fP\fIпараметр\fP\fB=<\fP\fIзначення\fP\fB>,\fP\fIпараметр\fP\fB=<\fP\fIзначення\fP\fB>\fP... +.TP +\fIфільтр\fP +Назва фільтра +.TP +\fIпараметр\fP +Назва специфічного для фільтра параметра +.TP +\fIзначення\fP +Числові діапазони \fIvalue\fP слід вказати у форматі +\fB<\fP\fIмінімум\fP\fB\-\fP\fIмаксимум\fP\fB>\fP. Варіанти рядка \fIзначення\fP +показано у \fB< >\fP і відокремлено символом \fB|\fP. +.PP +Кожен фільтр буде виведено до окремого рядка. +. +.SS "Дані щодо обмеження пам'яті" +\fBxz \-\-robot \-\-info\-memory\fP виводить один рядок з декількома відокремленими +табуляціями стовпчиками: +.IP 1. 4 +Загальний об'єм фізичної пам'яті (RAM) у байтах. +.IP 2. 4 +Обмеження на використання пам'яті для стискання у байтах +(\fB\-\-memlimit\-compress\fP). Особливе значення \fB0\fP вказує на типові +налаштування, якими для однопотокового режиму є налаштування без обмеження +на використання пам'яті. +.IP 3. 4 +Обмеження на використання пам'яті для розпакування у байтах +(\fB\-\-memlimit\-decompress\fP). Особливе значення \fB0\fP вказує на типові +налаштування, якими для однопотокового режиму є налаштування без обмеження +на використання пам'яті. +.IP 4. 4 +Починаючи з \fBxz\fP 5.3.4alpha: використання пам'яті для багатопотокового +розпаковування у байтах (\fB\-\-memlimit\-mt\-decompress\fP). Ніколи не дорівнює +нулеві, оскільки буде використано специфічне для системи типове значення, +яке показано у стовпчику 5, якщо обмеження не встановлено явним чином. Також +ніколи не перевищуватиме значення у стовпчику 3, навіть якщо було вказано +більше значення за допомогою \fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Починаючи з \fBxz\fP 5.3.4alpha: специфічне для системи типове обмеження на +використання пам'яті, яке використовують для обмеження кількості потоків при +стисканні з автоматичною кількістю потоків (\fB\-\-threads=0\fP) і без визначення +обмеження на використання пам'яті (\fB\-\-memlimit\-compress\fP). Це значення +також використовують як типове значення для \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Починаючи з \fBxz\fP 5.3.4alpha: кількість доступних потоків обробки процесора. +.PP +У майбутньому у виведенні \fBxz \-\-robot \-\-info\-memory\fP може бути більше +стовпчиків, але у виведеному буде не більше за один рядок. +. +.SS Версія +\fBxz \-\-robot \-\-version\fP виведе назву версії \fBxz\fP і liblzma у такому +форматі: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Основна версія. +.TP +\fIYYY\fP +Проміжна версія. Непарні номери буде використано для стабільних +версій. Непарні номери є номерами тестових версій. +.TP +\fIZZZ\fP +Рівень латання для стабільних випусків або просто лічильник для випусків, +які перебувають у розробці. +.TP +\fIS\fP +Стабільність. 0 — alpha, 1 — beta, а 2 означає «стабільна версія». \fIS\fP має +завжди дорівнювати 2, якщо \fIYYY\fP є парним. +.PP +\fIXYYYZZZS\fP є тим самим в обох рядках, якщо \fBxz\fP і liblzma належать до +одного випуску XZ Utils. +.PP +Приклади: 4.999.9beta — це \fB49990091\fP, а 5.0.0 — це \fB50000002\fP. +. +.SH "СТАН ВИХОДУ" +.TP +\fB0\fP +Усе добре. +.TP +\fB1\fP +Сталася помилка. +.TP +\fB2\fP +Сталося щось варте попередження, але справжніх помилок не сталося. +.PP +Зауваження (не попередження або помилки), які виведено до стандартного +виведення помилок, не впливають на стан виходу. +. +.SH СЕРЕДОВИЩЕ +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP обробляє списки відокремлених пробілами параметрів зі змінних +середовища \fBXZ_DEFAULTS\fP і \fBXZ_OPT\fP, перш ніж обробляти параметри з рядка +команди. Зауважте, що буде оброблено лише параметри зі змінних середовища; +усі непараметричні записи буде без повідомлень проігноровано. Обробку буде +виконано за допомогою функції \fBgetopt_long\fP(3), яку також використовують +для аргументів рядка команди. +.PP +\fBПопередження:\fP Встановлюючи ці змінні середовища, ви насправді змінюєте +програми та скрипти, які виконують \fBxz\fP. У більшості випадків без проблем +можна встановлювати обмеження на використання пам'яті, кількість потоків і +параметри стиснення за допомогою змінних середовища. Однак деякі параметри +можуть порушити роботу скриптів. Очевидним прикладом є \fB\-\-help\fP, який +змушує \fBxz\fP показувати текст довідки замість стискання або розпаковування +файла. Менш очевидними є приклади \fB\-\-quiet\fP і \fB\-\-verbose\fP. У багатьох +випадках усе працюватиме добре, якщо увімкнути індикатор поступу за +допомогою \fB\-\-verbose\fP, але у деяких ситуаціях додаткові повідомлення +створюють проблеми. Рівень докладності також впливає на поведінку \fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Специфічні для користувача або загальносистемні типові параметри. Зазвичай, +їх встановлюють у скрипті ініціалізації оболонки для типового вмикання +обмеження на використання пам'яті у \fBxz\fP або встановлення типової кількості +потоків обробки. Окрім скриптів ініціалізації оболонки і подібних особливих +випадків, не слід встановлювати або скасовувати встановлення значення +\fBXZ_DEFAULTS\fP у скриптах. +.TP +\fBXZ_OPT\fP +Цю змінну призначено для передавання параметрів до \fBxz\fP, якщо неможливо +встановити параметри безпосередньо у рядку команди \fBxz\fP. Це трапляється, +якщо \fBxz\fP запущено скриптом або інструментом, наприклад, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Скрипти можуть використовувати \fBXZ_OPT\fP, наприклад, для встановлення +специфічних типових параметрів стискання. Втім, рекомендуємо дозволити +користувачам перевизначати \fBXZ_OPT\fP, якщо це має якісь причини. Наприклад, +у скриптах \fBsh\fP(1) можна скористатися чимось таким: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "СУМІСНІСТЬ ІЗ LZMA UTILS" +Синтаксис рядка команди \fBxz\fP практично є надбудовою щодо \fBlzma\fP, \fBunlzma\fP +і \fBlzcat\fP з LZMA Utils 4.32.x. У більшості випадків можна замінити LZMA +Utils XZ Utils без порушення працездатності наявних скриптів. Втім, існують +певні несумісності, які іноді можуть спричиняти проблеми. +. +.SS "Рівні шаблонів стискання" +Нумерація у шаблонах рівнів стискання у \fBxz\fP не є тотожною до нумерації у +LZMA Utils. Найважливішою відмінністю є прив'язка розмірів словника до +різних шаблонів. Розмір словника грубо рівний використанню пам'яті у засобі +розпаковування. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Рівень;xz;LZMA Utils +\-0;256 КіБ;н/д +\-1;1 МіБ;64 КіБ +\-2;2 МіБ;1 МіБ +\-3;4 МіБ;512 КіБ +\-4;4 МіБ;1 МіБ +\-5;8 МіБ;2 МіБ +\-6;8 МіБ;4 МіБ +\-7;16 МіБ;8 МіБ +\-8;32 МіБ;16 МіБ +\-9;64 МіБ;32 МіБ +.TE +.RE +.PP +Відмінності у розмірах словників також впливають на використання пам'яті +засобом стискання, але є і інші відмінності між LZMA Utils і XZ Utils, які +роблять різницю ще помітнішою: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Рівень;xz;LZMA Utils 4.32.x +\-0;3 МіБ;н/д +\-1;9 МіБ;2 МіБ +\-2;17 МіБ;12 МіБ +\-3;32 МіБ;12 МіБ +\-4;48 МіБ;16 МіБ +\-5;94 МіБ;26 МіБ +\-6;94 МіБ;45 МіБ +\-7;186 МіБ;83 МіБ +\-8;370 МіБ;159 МіБ +\-9;674 МіБ;311 МіБ +.TE +.RE +.PP +Типовим рівнем стискання у LZMA Utils є \fB\-7\fP, а у XZ Utils — \fB\-6\fP, отже, +обидва комплекти програм типово використовують словник розміром у 8 МіБ. +. +.SS "Потокові і непотокові файл .lzma" +Розмір нестисненого файла може бути збережено у заголовку \fB.lzma\fP. LZMA +Utils зберігають дані при стисканні звичайних файлів. Альтернативним +підходом є позначення нестисненого розміру як невідомого і використання +позначки кінця вмісту для позначення місця, де засіб розпаковування має +зупинитися. У LZMA Utils цей спосіб використовують, якщо нестиснений розмір +є невідомим, що трапляється, наприклад, для конвеєрів обробки даних. +.PP +У \fBxz\fP передбачено підтримку розпаковування файлів \fB.lzma\fP з позначкою +кінця вмісту та без неї, але усі файли \fB.lzma\fP, які створено за допомогою +\fBxz\fP, використовують позначку кінця вмісту, а нестиснений розмір у +заголовку \fB.lzma\fP позначають як невідомий. Це може призвести до проблем у +деяких нетипових ситуаціях. Наприклад, розпакувальник \fB.lzma\fP у вбудованому +пристрої може працювати лише з файлами, для яких відомий нестиснений +розмір. Якщо ви зіткнулися з цією проблемою, вам слід скористатися LZMA +Utils або LZMA SDK для створення файлів \fB.lzma\fP із відомим розміром +нестиснених даних. +. +.SS "Непідтримувані файли .lzma" +У форматі \fB.lzma\fP можливі значення \fIlc\fP аж до 8 і значення \fIlp\fP аж до +4. LZMA Utils можуть розпаковувати файли із будь\-якими значеннями \fIlc\fP і +\fIlp\fP, але завжди створюють файли з \fBlc=3\fP і \fBlp=0\fP. Створення файлів з +іншими значеннями \fIlc\fP і \fIlp\fP є можливим за допомогою \fBxz\fP і LZMA SDK. +.PP +Реалізація фільтра LZMA1 у liblzma потребує, щоби сума \fIlc\fP і \fIlp\fP не +перевищувала 4. Отже, файли \fB.lzma\fP, у яких перевищено обмеження, не може +бути розпаковано за допомогою \fBxz\fP. +.PP +LZMA Utils створюють лише файли \fB.lzma\fP, які мають розмір словника у 2^\fIn\fP +(степінь 2), але приймають файли із будь\-яким розміром словника. liblzma +приймає лише файли \fB.lzma\fP, які мають розмір словника 2^\fIn\fP або 2^\fIn\fP + +2^(\fIn\fP\-1). Так зроблено для зменшення помилок при виявленні файлів +\&\fB.lzma\fP. +.PP +Ці обмеження не мають призводити до проблем на практиці, оскільки практично +усі файли \fB.lzma\fP було стиснено з використанням параметрів, які приймає +liblzma. +. +.SS "Кінцевий мотлох" +При розпаковуванні LZMA Utils без повідомлень ігнорують усі дані після +першого потоку \fB.lzma\fP. У більшості випадків це пов'язано із вадою у +програмі. Це також означає, що у LZMA Utils не передбачено підтримки +розпаковування з'єднаних файлів \fB.lzma\fP. +.PP +Якщо після першого потоку \fB.lzma\fP лишилися дані, \fBxz\fP вважатиме файл +пошкодженим, якщо не було використано \fB\-\-single\-stream\fP. Це може зашкодити +роботі скриптів, де зроблено припущення, що кінцеві зайві дані буде +проігноровано. +. +.SH ПРИМІТКИ +. +.SS "Стискання даних може бути різним" +Точні стиснені дані, які створено на основі того самого нестисненого файла +вхідних даних, можуть бути різними для різних версій XZ Utils, навіть якщо +використано однакові параметри стискання. Причиною цього є удосконалення у +кодувальнику (пришвидшення або краще стискання) без зміни формату +файлів. Виведені дані можуть бути різними навіть для різних збірок тієї +самої версії XZ Utils, якщо використано різні параметри збирання. +.PP +Написане вище означає, що після реалізації \fB\-\-rsyncable\fP файли\-результати +не обов'язково можна буде синхронізувати за допомогою rsyncable, якщо старий +і новий файли було стиснено за допомогою тієї самої версії xz. Цю проблему +можна усунути, якщо буде заморожено частину реалізації кодувальника, щоб +введені для rsync дані були стабільними між версіями xz. +. +.SS "Вбудовані розпакувальники .xz" +У вбудованих реалізаціях розпакувальника \fB.xz\fP, подібних до XZ Embedded, не +обов'язково передбачено підтримку файлів, які створено із типами +\fIперевірки\fP цілісності, відмінними від \fBnone\fP і \fBcrc32\fP. Оскільки типовим +є \fB\-\-check=crc64\fP, вам слід використовувати \fB\-\-check=none\fP або +\fB\-\-check=crc32\fP при створенні файлів для вбудованих систем. +.PP +Поза вбудованими системами, в усіх засобах розпаковування формату \fB.xz\fP +передбачено підтримку усіх типів \fIперевірок\fP або принаймні можливість +розпакувати файл без перевірки цілісності, якщо підтримки певної +\fIперевірки\fP не передбачено. +.PP +У XZ Embedded передбачено підтримку BCJ, але лише з типовим початковим +зсувом. +. +.SH ПРИКЛАДИ +. +.SS Основи +Стиснути файл \fIfoo\fP до \fIfoo.xz\fP за допомогою типового рівня стискання +(\fB\-6\fP) і вилучити \fIfoo\fP, якщо стискання відбулося успішно: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Розпакувати \fIbar.xz\fP до \fIbar\fP і не вилучати \fIbar.xz\fP, навіть якщо +розпаковування відбулося успішно: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Створити \fIbaz.tar.xz\fP з використанням шаблона \fB\-4e\fP (\fB\-4 \-\-extreme\fP), +який є повільнішими за типовий \fB\-6\fP, але потребує менше пам'яті для +стискання та розпаковування (48\ МіБ та 5\ МіБ, відповідно): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Суміш стиснених і нестиснених файлів можна розпакувати до стандартного +виведення за допомогою єдиної команди: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Паралельне стискання багатьох файлів" +У GNU і *BSD можна скористатися \fBfind\fP(1) і \fBxargs\fP(1) для паралельного +стискання багатьох файлів: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Параметр \fB\-P\fP \fBxargs\fP(1) встановлює кількість паралельних процесів +\fBxz\fP. Найкраще значення параметра \fB\-n\fP залежить від того, скільки файлів +має бути стиснено. Якщо файлів мало, значенням, ймовірно, має бути 1. Якщо +файлів десятки тисяч, може знадобитися значення 100 або навіть більше, щоб +зменшити кількість процесів \fBxz\fP, які врешті створить \fBxargs\fP(1). +.PP +Параметр \fB\-T1\fP для \fBxz\fP тут для примусового встановлення однопотокового +режиму, оскільки для керування рівнем паралелізації використано \fBxargs\fP(1). +. +.SS "Режим робота" +Обчислити скільки байтів було заощаджено загалом після стискання декількох +файлів: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Скрипту можуть знадобитися дані щодо того, що використано достатньо нову +версію \fBxz\fP. У наведеному нижче скрипті \fBsh\fP(1) виконано перевірку того, +що номер версії засобу \fBxz\fP є принаймні рівним 5.0.0. Цей спосіб є сумісним +зі старими тестовими версіями, де не передбачено підтримки параметра +\fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Встановити обмеження на використання пам'яті для розпаковування за допомогою +\fBXZ_OPT\fP, але якщо обмеження вже було встановлено, не збільшувати його: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Нетипові ланцюжки фільтрів засобу стискання" +Найпростішим використанням ланцюжка фільтрів є налаштовування шаблона +LZMA2. Це може бути корисним, оскільки у шаблонах використано лише +підмножину потенційно корисних комбінацій параметрів стискання. +.PP +При налаштовуванні шаблонів LZMA2 корисними є стовпчики CompCPU таблиць з +описів параметрів \fB\-0\fP ... \fB\-9\fP і \fB\-\-extreme\fP. Ось відповідні частини з +цих двох таблиць: +.RS +.PP +.TS +tab(;); +c c +n n. +Шаблон;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Якщо вам відомо, що певний файл потребує дещо більшого словника (наприклад, +32\ МіБ) для якісного стискання, але ви хочете стиснути його швидше за +команду \fBxz \-8\fP, можна внести зміни до шаблона із нижчим значенням CompCPU +(наприклад, 1) для використання більшого словника: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Для певних файлів наведена вище команда може працювати швидше за \fBxz \-6\fP і +стискати дані значно краще. Втім, слід наголосити, переваги більшого +словника з одночасним низьким значенням CompCPU проявляються лише для деяких +файлів. Найочевиднішим випадком, коли великий словник є корисним, є випадок, +коли архів містить дуже подібні файли розміром у принаймні декілька +мегабайтів. Розмір словника має бути значно більшим за будь\-який окремий +файл, щоб у LZMA2 було використано усі переваги подібностей між послідовними +файлами. +.PP +Якщо дуже високий рівень використання пам'яті у засобі стискання або +розпаковування не є проблемою, і файли, який стискають має об'єм у принаймні +декілька десятків мегабайтів, може бути корисним використання навіть +більшого за 64 МіБ словника, який використано у \fBxz \-9\fP: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Використання \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP), подібно до наведеного вище +прикладу, може бути корисним для перегляду вимог з боку засобів стискання та +розпаковування до пам'яті. Пам'ятайте, що використання словника, розмір +якого перевищує розмір файла, який стискають, є простоюю витратою пам'яті, +отже наведену вище команду не варто використовувати для малих файлів. +.PP +Іноді час стискання не має значення, але використання пам'яті засобом +розпаковування має бути низьким для того, щоб, наприклад, уможливити +розпаковування файла у вбудованій системі. У наведеній нижче команді +використано \fB\-6e\fP (\fB\-6 \-\-extreme\fP) як основу і встановлено розмір словника +лише у 64\ КіБ. Файл\-результат можна розпакувати за допомогою XZ Embedded +(ось чому використано \fB\-\-check=crc32\fP) з використанням лише 100\ КіБ +пам'яті. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Якщо вам потрібно витиснути зі стискання максимальну кількість байтів, може +допомогти коригування кількості бітів контексту літералів (\fIlc\fP) та +кількість позиційних бітів (\fIpb\fP). Також може допомогти коригування +кількості бітів позиції літералів (\fIlp\fP), але, зазвичай, важливішими є +\fIlc\fP і \fIpb\fP. Наприклад, в архівах зі початковим кодом міститься +здебільшого текст US\-ASCII, щось подібне до наведеного нижче може дещо (на +щось близьке до 0,1\ %) зменшити файл, порівняно із \fBxz \-6e\fP (спробуйте +також без \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Використання іншого фільтра разом із LZMA2 може покращити стискання для +певних типів файлів. Наприклад, для стискання бібліотеки спільного +користування x86\-32 або x86\-64 з використанням фільтра BCJ x86 скористайтеся +такою командою: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Зауважте, що порядок параметрів фільтрування має значення. Якщо \fB\-\-x86\fP +вказано після \fB\-\-lzma2\fP, \fBxz\fP повідомить про помилку, оскільки після LZMA2 +не може бути жодного фільтра, а також оскільки фільтр BCJ x86 не можна +використовувати як останній фільтр у ланцюжку. +.PP +Фільтр Delta разом із LZMA2 може дати добрі результати для растрових +зображень. Зазвичай, результати є кращими за формат PNG, у якого є декілька +більш досконалих фільтрів, ніж проста дельта, але там використовують для +стискання Deflate. +.PP +Зображення слід берегти у нестисненому форматі, наприклад, як нестиснений +TIFF. Параметр відстані фільтра Delta встановлюють так, щоб він збігався із +кількістю байтів на піксель у зображенні. Наприклад, для 24\-бітового +растрового зображення RGB слід вказати \fBdist=3\fP, а також добре передати +\fBpb=0\fP до LZMA2 для пристосовування до трибайтового вирівнювання: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Якщо в один архів запаковано декілька зображень (наприклад, в архів +\&\fB.tar\fP), фільтр Delta також даватиме добрі результати, якщо у всіх +зображеннях однакова кількість байтів для кожного пікселя. +. +.SH "ДИВ. ТАКОЖ" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +Вбудовуваний XZ: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xzcat.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xzcat.1 new file mode 100644 index 0000000000000000000000000000000000000000..bff0472c4495c4b8c84495967535bcd7b99dc205 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xzcat.1 @@ -0,0 +1,2039 @@ +'\" t +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Ukrainian translation for xz-man. +.\" Yuri Chornoivan , 2019, 2022, 2023, 2024, 2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZ 1 "8 березня 2025 року" Tukaani "XZ Utils" +. +.SH НАЗВА +xz, unxz, xzcat, lzma, unlzma, lzcat — стискання та розпаковування файлів +\&.xz і .lzma +. +.SH "КОРОТКИЙ ОПИС" +\fBxz\fP [\fIпараметр...\fP] [\fIфайл...\fP] +. +.SH "СКОРОЧЕННЯ КОМАНД" +\fBunxz\fP є рівноцінним до \fBxz \-\-decompress\fP. +.br +\fBxzcat\fP є рівноцінним до \fBxz \-\-decompress \-\-stdout\fP. +.br +\fBlzma\fP є рівноцінним до \fBxz \-\-format=lzma\fP. +.br +\fBunlzma\fP є рівноцінним до \fBxz \-\-format=lzma \-\-decompress\fP. +.br +\fBlzcat\fP є рівноцінним до \fBxz \-\-format=lzma \-\-decompress \-\-stdout\fP. +.PP +При написанні скриптів, де потрібно розпаковувати файли, рекомендуємо завжди +використовувати \fBxz\fP із відповідними аргументами (\fBxz \-d\fP або \fBxz \-dc\fP), +замість \fBunxz\fP і \fBxzcat\fP. +. +.SH ОПИС +\fBxz\fP інструмент загального призначення для стискання даних із синтаксисом +командного рядка, подібним для \fBgzip\fP(1) і \fBbzip2\fP(1). Власним форматом +файлів є \fB.xz\fP, але передбачено підтримку застарілого формату \fB.lzma\fP, +який було використано у LZMA Utils, та необроблених потоків стиснених даних +без заголовків формату контейнера. Крім того, передбачено підтримку +розпаковування формату \fB.lz\fP, який використано у \fBlzip\fP. +.PP +\fBxz\fP стискає або розпаковує кожен \fIфайл\fP відповідно до вибраного режиму +дій. Якщо \fIфайли\fP не задано або якщо \fIфайлом\fP є \fB\-\fP, \fBxz\fP читатиме дані +зі стандартного джерела вхідних даних і записуватиме оброблені дані до +стандартного виведення. \fBxz\fP відмовить (покаже повідомлення про помилку і +пропустить \fIфайл\fP) у записів стиснених даних до стандартного виведення, +якщо це термінал. Так само, \fBxz\fP відмовить у читанні стиснених даних зі +стандартного джерела вхідних даних, якщо це термінал. +.PP +Якщо не вказано \fB\-\-stdout\fP, \fIфайли\fP, відмінні від \fB\-\fP, буде записано до +нового файла, чию назву буде визначено з назви початкового \fIфайла\fP: +.IP \(bu 3 +При стисканні суфікс формату файла призначення (\fB.xz\fP або \fB.lzma\fP) буде +дописано до назви початкового файла для отримання назви файла призначення. +.IP \(bu 3 +При розпаковуванні суфікс \fB.xz\fP, \fB.lzma\fP або \fB.lz\fP буде вилучено з назви +файла для отримання назви файла призначення. Крім того, \fBxz\fP розпізнає +суфікси \fB.txz\fP і \fB.tlz\fP і замінює їх на суфікс \fB.tar\fP. +.PP +Якщо файл призначення вже існує, буде показано повідомлення про помилку, а +\fIфайл\fP буде пропущено. +.PP +Окрім випадку запису до стандартного виведення, \fBxz\fP покаже попередження і +пропустить обробку \fIфайла\fP, якщо буде виконано будь\-яку з таких умов: +.IP \(bu 3 +\fIФайл\fP не є звичайним файлом. Програма не переходитиме за символічними +посиланнями, а отже, не вважатиме їх звичайними файлами. +.IP \(bu 3 +На \fIфайл\fP існує декілька жорстких посилань. +.IP \(bu 3 +Для \fIфайла\fP встановлено setuid, setgid або «липкий» біт. +.IP \(bu 3 +Режим дій встановлено у значення «стискання», і \fIфайл\fP вже має суфікс назви +формату файла призначення (\fB.xz\fP або \fB.txz\fP при стисканні до формату +\&\fB.xz\fP, і \fB.lzma\fP або \fB.tlz\fP при стисканні до формату \fB.lzma\fP). +.IP \(bu 3 +Режим дій встановлено у значення «розпаковування», і \fIфайл\fP не має суфікса +назви жодного з підтримуваних форматів (\fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP +або \fB.lz\fP). +.PP +Після успішного стискання або розпаковування \fIфайла\fP, \fBxz\fP копіює дані +щодо власника, групи, прав доступу, часу доступу та моменту внесення змін з +початкового \fIфайла\fP до файла призначення. Якщо копіювання даних щодо групи +зазнає невдачі, права доступу буде змінено так, що файл призначення стане +недоступним для користувачів, які не мають права доступу до початкового +\fIфайла\fP. В \fBxz\fP ще не передбачено підтримки копіювання інших метаданих, +зокрема списків керування доступом або розширених атрибутів. +.PP +Щойно файл призначення буде успішно закрито, початковий \fIфайл\fP буде +вилучено, якщо не вказано параметра \fB\-\-keep\fP. Початковий \fIфайл\fP ніколи не +буде вилучено, якщо виведені дані буде записано до стандартного виведення +або якщо станеться помилка. +.PP +Надсилання \fBSIGINFO\fP або \fBSIGUSR1\fP до процесу \fBxz\fP призводить до +виведення даних щодо поступу до стандартного виведення помилок. Це має лише +обмежене використання, оскільки якщо стандартним виведенням помилок є +термінал, використання \fB\-\-verbose\fP призведе до показу автоматично +оновлюваного індикатора поступу. +. +.SS "Використання пам'яті" +Використання \fBxz\fP пам'яті може бути різним: від декількох сотень кілобайтів +до декількох гігабайтів, залежно від параметрів стискання. Параметри, які +використано при стисканні файла, визначають вимоги до об'єму пам'яті при +розпакуванні. Типово, засобу розпаковування потрібно від 5\ % до 20\ % +об'єму пам'яті, якого засіб стискання потребує при створенні +файла. Наприклад, розпаковування файла, який створено з використанням \fBxz \-9\fP, у поточній версії потребує 65\ МіБ пам'яті. Втім, можливе створення +файлів \fB.xz\fP, які потребуватимуть для розпаковування декількох гігабайтів +пам'яті. +.PP +Ймовірність високого рівня використання пам'яті може бути особливо +дошкульною для користувачів застарілих комп'ютерів. Щоб запобігти прикрим +несподіванкам, у \fBxz\fP передбачено вбудований обмежувач пам'яті, який типово +вимкнено. Хоча у деяких операційних системах передбачено спосіб обмежити +використання пам'яті процесами, сподівання на його ефективність не є аж +надто гнучким (наприклад, використання \fBulimit\fP(1) для обмеження +віртуальної пам'яті призводить до викривлення даних \fBmmap\fP(2)). +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS. +.\" It's a name of an environment variable. +Обмежувач пам'яті можна увімкнути за допомогою параметра командного рядка +\fB\-\-memlimit=\fP\fIобмеження\fP. Часто, зручніше увімкнути обмежувач на типовому +рівні, встановивши значення для змінної середовища \fBXZ_DEFAULTS\fP, +наприклад, \fBXZ_DEFAULTS=\-\-memlimit=150MiB\fP. Можна встановити обмеження +окремо для стискання і розпакування за допомогою +\fB\-\-memlimit\-compress=\fP\fIlimit\fP and +\fB\-\-memlimit\-decompress=\fP\fIобмеження\fP. Використання цих двох параметрів поза +\fBXZ_DEFAULTS\fP не таке вже і корисне, оскільки одноразовий запуск \fBxz\fP не +може одночасно призводити до стискання та розпаковування, а набрати у +командному рядку \fB\-\-memlimit=\fP\fIобмеження\fP (або \fB\-M\fP \fIобмеження\fP) +набагато швидше. +.PP +Якщо під час розпаковування вказане обмеження буде перевищено, \fBxz\fP покаже +повідомлення про помилку, а розпаковування файла зазнає невдачі. Якщо +обмеження буде перевищено при стисканні, \fBxz\fP спробує масштабувати +параметри так, щоб не перевищувати обмеження (окрім випадків використання +\fB\-\-format=raw\fP або \fB\-\-no\-adjust\fP). Отже, дію буде виконано, якщо обмеження +не є надто жорстким. Масштабування параметрів буде виконано кроками, які не +збігаються із рівнями шаблонів стискання. Наприклад, якщо обмеження лише +трохи не вкладається у об'єм потрібний для \fBxz \-9\fP, параметри буде змінено +лише трохи, не до рівня \fBxz \-8\fP. +. +.SS "Поєднання і заповнення з файлами .xz" +Можна поєднати файли \fB.xz\fP без додаткової обробки. \fBxz\fP розпакує такі +файли так, наче вони є єдиним файлом \fB.xz\fP. +.PP +Можна додати доповнення між з'єднаними частинами або після останньої +частини. Доповнення має складатися із нульових байтів і мати розмір, який є +кратним до чотирьох байтів. Це може бути корисним, наприклад, якщо файл +\&\fB.xz\fP зберігається на носії даних, де розміри файла вимірюються у +512\-байтових блоках. +.PP +Поєднання та заповнення не можна використовувати для файлів \fB.lzma\fP або +потоків необроблених даних. +. +.SH ПАРАМЕТРИ +. +.SS "Цілочисельні суфікси і спеціальні значення" +У більшості місць, де потрібен цілочисельний аргумент, передбачено підтримку +необов'язкового суфікса для простого визначення великих цілих чисел. Між +цілим числом і суфіксом не повинно бути пробілів. +.TP +\fBKiB\fP +Помножити ціле число на 1024 (2^10). Синонімами \fBKiB\fP є \fBKi\fP, \fBk\fP, \fBkB\fP, +\fBK\fP та \fBKB\fP. +.TP +\fBMiB\fP +Помножити ціле число на 1048576 (2^20). Синонімами \fBMiB\fP є B, \fBMi\fP, \fBm\fP, +\fBM\fP та \fBMB\fP. +.TP +\fBGiB\fP +Помножити ціле число на 1073741824 (2^30). Синонімами \fBGiB\fP є B, \fBGi\fP, +\fBg\fP, \fBG\fP та \fBGB\fP. +.PP +Можна скористатися особливим значенням \fBmax\fP для позначення максимального +цілого значення, підтримку якого передбачено для параметра. +. +.SS "Режим операції" +Якщо вказано декілька параметрів режиму дій, буде використано лише останній +з них. +.TP +\fB\-z\fP, \fB\-\-compress\fP +Стиснути. Це типовий режим дій, якщо не вказано параметр режиму дій, а назва +команди неявним чином не визначає іншого режиму дій (наприклад, \fBunxz\fP +неявно визначає \fB\-\-decompress\fP). +.IP "" +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Після успішного пакування початковий файл буде вилучено, якщо виведення не +відбувається до стандартного виведення або не вказано параметра \fB\-\-keep\fP. +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +.\" The DESCRIPTION section already says this but it's good to repeat it +.\" here because the default behavior is a bit dangerous and new users +.\" in a hurry may skip reading the DESCRIPTION section. +Розпакувати. Після успішного розпаковування початковий файл буде вилучено, +якщо виведення не відбувається до стандартного виведення або не вказано +параметра \fB\-\-keep\fP. +.TP +\fB\-t\fP, \fB\-\-test\fP +Перевірити цілісність стиснених файлів \fIфайли\fP. Цей параметр еквівалентний +до \fB\-\-decompress \-\-stdout\fP, але розпаковані дані буде відкинуто, замість +запису до стандартного виведення. Жодних файлів не буде створено або +вилучено. +.TP +\fB\-l\fP, \fB\-\-list\fP +Вивести відомості щодо стиснених файлів \fIфайли\fP. Розпакування даних не +виконуватиметься, жодних файлів не буде створено або вилучено. У режимі +списку програма не може читати дані зі стандартного введення або з інших +джерел, де неможливе позиціювання. +.IP "" +У типовому списку буде показано базові відомості щодо файлів \fIфайли\fP, по +одному файлу на рядок. Щоб отримати докладніші відомості, скористайтеся +параметром \fB\-\-verbose\fP. Щоб розширити спектр відомостей, скористайтеся +параметром \fB\-\-verbose\fP двічі, але зауважте, що це може призвести до +значного уповільнення роботи, оскільки отримання додаткових відомостей +потребує великої кількості позиціювань. Ширина області докладного виведення +даних перевищує 80 символів, тому передавання конвеєром виведених даних, +наприклад, до \fBless\ \-S\fP, може бути зручним способом перегляду даних, якщо +термінал недостатньо широкий. +.IP "" +Виведені дані залежать від версії \fBxz\fP та використаної локалі. Для +отримання даних, які будуть придатні до обробки комп'ютером, слід +скористатися параметрами \fB\-\-robot \-\-list\fP. +. +.SS "Модифікатори режиму роботи" +.TP +\fB\-k\fP, \fB\-\-keep\fP +Не вилучати вхідні файли. +.IP "" +Починаючи з версії \fBxz\fP 5.2.6, використання цього параметра також наказує +\fBxz\fP виконувати стискання або розпаковування, навіть якщо вхідними даними є +символічне посилання на звичайний файл, файл, який має декілька жорстких +посилань, або файл, для якого встановлено setuid, setgid або липкий +біт. setuid, setgid та липкий біт не буде скопійовано до файла\-результату. У +попередніх версіях, ці дії виконувалися, лише якщо було використано параметр +\fB\-\-force\fP. +.TP +\fB\-f\fP, \fB\-\-force\fP +Результатів використання цього параметра буде декілька: +.RS +.IP \(bu 3 +Якщо файл\-результат вже існує, вилучити його до стискання або +розпаковування. +.IP \(bu 3 +Виконувати стискання або розпаковування, навіть якщо вхідними даними є +символічне посилання на звичайний файл, файл, який має декілька жорстких +посилань, або файл, для якого встановлено setuid, setgid або липкий біт +setuid, setgid та липкий біт не буде скопійовано до файла\-результату. +.IP \(bu 3 +Якщо використано разом із \fB\-\-decompress\fP, \fB\-\-stdout\fP, і \fBxz\fP не зможе +розпізнати тип початкового файла, копіювати початковий файл без змін до +стандартного виведення. Це надає змогу користуватися \fBxzcat\fP \fB\-\-force\fP +подібно до \fBcat\fP(1) для файлів, які не було стиснено за допомогою +\fBxz\fP. Зауважте, що у майбутньому у \fBxz\fP може бути реалізовано підтримку +нових форматів стиснених файлів, замість копіювання їх без змін до +стандартного виведення. Можна скористатися \fB\-\-format=\fP\fIформат\fP для +обмеження стискання у \fBxz\fP єдиним форматом файлів. +.RE +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Записати стиснені або розпаковані дані до стандартного виведення, а не до +файла. Неявним чином встановлює \fB\-\-keep\fP. +.TP +\fB\-\-single\-stream\fP +Розпакувати лише перший потік даних \fB.xz\fP і без повідомлень проігнорувати +решту вхідних даних, які слідують за цим потоком. Зазвичай, такі зайві дані +наприкінці файла призводять до показу \fBxz\fP повідомлення про помилку. +.IP "" +\fBxz\fP ніколи не виконуватиме спроби видобути декілька потоків даних з файлів +\&\fB.lzma\fP або необроблених потоків даних, але використання цього параметра +все одно наказує \fBxz\fP ігнорувати можливі кінцеві дані після файла \fB.lzma\fP +або необробленого потоку даних. +.IP "" +Цей параметр нічого не змінює, якщо режимом дій не є \fB\-\-decompress\fP або +\fB\-\-test\fP. +.IP "" +З \fBxz\fP 5.7.1alpha, \fB\-\-single\-stream\fP неявно визначає \fB\-\-keep\fP. +.TP +\fB\-\-no\-sparse\fP +Вимкнути створення розріджених файлів. Типово, якщо видобування виконується +до звичайного файла, \fBxz\fP намагається створити розріджений файл, якщо +розпаковані дані містять довгі послідовності двійкових нулів. Це також +працює, коли виконується запис до стандартного виведення, доки стандартне +виведення з'єднано зі звичайним файлом і виконуються певні додаткові умови, +які убезпечують роботу. Створення розріджених файлів може заощадити місце на +диску і пришвидшити розпаковування шляхом зменшення кількості дій введення +та виведення даних на диску. +.TP +\fB\-S\fP \fI.suf\fP, \fB\-\-suffix=\fP\fI.suf\fP +При стисканні використати суфікс \fI.suf\fP для файлів призначення, замість +суфікса \fB.xz\fP або \fB.lzma\fP. Якщо записування виконується не до стандартного +виведення і початковий файл вже має суфікс назви \fI.suf\fP, буде показано +попередження, а файл буде пропущено під час обробки. +.IP "" +При розпаковуванні розпізнавати файли із суфіксом назви \fI.suf\fP, окрім +файлів із суфіксами назв \fB.xz\fP, \fB.txz\fP, \fB.lzma\fP, \fB.tlz\fP або \fB.lz\fP. Якщо +початковий файл мав суфікс назви \fI.suf\fP, для отримання назви файла +призначення цей суфікс буде вилучено. +.IP "" +При стисканні або розпакуванні необроблених потоків даних (\fB\-\-format=raw\fP) +суфікс слід вказувати завжди, якщо запис не виконується до стандартного +виведення, оскільки типового суфікса назви для необроблених потоків даних не +передбачено. +.TP +\fB\-\-files\fP[\fB=\fP\fIфайл\fP] +Прочитати назви файлів для обробки з файла \fIфайл\fP; якщо \fIfile\fP не вказано, +назви файлів буде прочитано зі стандартного потоку вхідних даних. Назви +файлів має бути відокремлено символом нового рядка. Символ дефіса (\fB\-\fP) +буде оброблено як звичайну назву файла; він не позначатиме стандартного +джерела вхідних даних. Якщо також буде вказано назви файлів у аргументах +рядка команди, файли з цими назвами буде оброблено до обробки файлів, назви +яких було прочитано з файла \fIфайл\fP. +.TP +\fB\-\-files0\fP[\fB=\fP\fIфайл\fP] +Те саме, що і \fB\-\-files\fP[\fB=\fP\fIфайл\fP], але файли у списку має бути +відокремлено нульовим символом. +. +.SS "Параметри базового формату файлів та стискання" +.TP +\fB\-F\fP \fIformat\fP, \fB\-\-format=\fP\fIформат\fP +Вказати файл \fIформат\fP для стискання або розпакування: +.RS +.TP +.\" TRANSLATORS: Don't translate bold string B. +\fBauto\fP +Типовий варіант. При стисканні \fBauto\fP є еквівалентом \fBxz\fP. При +розпакуванні формат файла вхідних даних буде виявлено автоматично. Зауважте, +що автоматичне виявлення необроблених потоків даних (створених за допомогою +\fB\-\-format=raw\fP) неможливе. +.TP +\fBxz\fP +Стиснути до формату \fB.xz\fP або приймати лише файли \fB.xz\fP при +розпаковуванні. +.TP +\fBlzma\fP, \fBalone\fP +Стиснути дані до застарілого формату файлів \fB.lzma\fP або приймати лише файли +\&\fB.lzma\fP при розпаковуванні. Альтернативну назву \fBalone\fP може бути +використано для зворотної сумісності із LZMA Utils. +.TP +\fBlzip\fP +Приймати лише файли \fB.lz\fP при розпакуванні. Підтримки стискання не +передбачено. +.IP "" +Передбачено підтримку версії формату \fB.lz\fP 0 та 1. Файли версії 0 було +створено \fBlzip\fP 1.3 та старішими версіями. Такі файли не є поширеними, але +їх можна знайти у файлових архівах, оскільки певну незначну кількість +пакунків із початковим кодом було випущено у цьому форматі. Також можуть +існувати особисті файли у цьому форматі. Підтримку розпаковування для +формату версії 0 було вилучено у \fBlzip\fP 1.18. Версія \fBlzip\fP 1.4 і новіші +версії створюють файли у форматі версії 1. +.TP +\fBraw\fP +Стиснути або розпакувати потік необроблених даних (лез заголовків). Цей +параметр призначено лише для досвідчених користувачів. Для розпаковування +необроблених потоків даних слід користуватися параметром \fB\-\-format=raw\fP і +явно вказати ланцюжок фільтрування, який за звичайних умов мало б бути +збережено у заголовках контейнера. +.RE +.TP +\fB\-C\fP \fIперевірка\fP, \fB\-\-check=\fP\fIперевірка\fP +Вказати тип перевірки цілісності. Контрольну суму буде обчислено на основі +нестиснених даних і збережено у файлі \fB.xz\fP. Цей параметр працюватиме, лише +якщо дані стиснено до файла у форматі \fB.xz\fP; для формату файлів \fB.lzma\fP +підтримки перевірки цілісності не передбачено. Перевірку контрольної суми +(якщо така є) буде виконано під час розпаковування файла \fB.xz\fP. +.IP "" +Підтримувані типи \fIперевірок\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, and B. The command line option --check accepts +.\" only the untranslated strings. +\fBnone\fP +Не обчислювати контрольну суму взагалі. Зазвичай, не варто цього робити. Цим +варіантом слід скористатися, якщо цілісність даних буде перевірено в інший +спосіб. +.TP +\fBcrc32\fP +Обчислити CRC32 за допомогою полінома з IEEE\-802.3 (Ethernet). +.TP +\fBcrc64\fP +Обчислити CRC64 за допомогою полінома з ECMA\-182. Це типовий варіант, +оскільки він дещо кращий за CRC32 при виявленні пошкоджених файлів, а +різниця у швидкості є незрачною. +.TP +\fBsha256\fP +Обчислити SHA\-256. Цей варіант дещо повільніший за CRC32 і CRC64. +.RE +.IP "" +Цілісність заголовків \fB.xz\fP завжди перевіряють за допомогою CRC32. Таку +перевірку не можна змінити або скасувати. +.TP +\fB\-\-ignore\-check\fP +Не перевіряти цілісність стиснених даних при розпаковуванні. Значення CRC32 +у заголовках \fB.xz\fP буде у звичайний спосіб перевірено попри цей параметр. +.IP "" +\fBНе користуйтеся цим параметром, якщо ви не усвідомлюєте наслідків ваших дій.\fP Можливі причини скористатися цим параметром: +.RS +.IP \(bu 3 +Спроба отримання даних з пошкодженого файла .xz. +.IP \(bu 3 +Пришвидшення розпакування. Це, здебільшого, стосується SHA\-256 або файлів із +надзвичайно високим рівнем пакування. Не рекомендуємо користуватися цим +параметром з цією метою, якщо цілісність файлів не буде перевірено у якийсь +інший спосіб. +.RE +.TP +\fB\-0\fP ... \fB\-9\fP +Вибрати рівень стискання. Типовим є \fB\-6\fP. Якщо буде вказано декілька рівнів +стискання, програма використає останній вказаний. Якщо вже було вказано +нетиповий ланцюжок фільтрів, встановлення рівня стискання призведе до +нехтування цим нетиповим ланцюжком фільтрів. +.IP "" +Різниця між рівнями є суттєвішою, ніж у \fBgzip\fP(1) і \fBbzip2\fP(1). Вибрані +параметри стискання визначають вимоги до пам'яті під час розпаковування, +отже використання надто високого рівня стискання може призвести до проблем +під час розпаковування файла на застарілих комп'ютерах із невеликим обсягом +оперативної пам'яті. Зокрема, \fBне варто використовувати \-9 для усього\fP, як +це часто буває для \fBgzip\fP(1) і \fBbzip2\fP(1). +.RS +.TP +\fB\-0\fP ... \fB\-3\fP +Це дещо швидші набори налаштувань. \fB\-0\fP іноді є швидшим за \fBgzip \-9\fP, +забезпечуючи набагато більший коефіцієнт стискання. Вищі рівні часто мають +швидкість, яку можна порівняти з \fBbzip2\fP(1) із подібним або кращим +коефіцієнтом стискання, хоча результати значно залежать від типу даних, які +стискають. +.TP +\fB\-4\fP ... \fB\-6\fP +Стискання від доброго до дуже доброго рівня із одночасним підтриманням +помірного рівня споживання пам'яті засобом розпаковування, навіть для +застарілих системи. Типовим є значення \fB\-6\fP, яке є добрим варіантом для +поширення файлів, які мають бути придатними до розпаковування навіть у +системах із лише 16\ МіБ оперативної пам'яті. (Також можна розглянути +варіанти \fB\-5e\fP і \fB\-6e\fP. Див. \fB\-\-extreme\fP.) +.TP +\fB\-7 ... \-9\fP +Ці варіанти подібні до \fB\-6\fP, але із вищими вимогами щодо пам'яті для +стискання і розпаковування. Можуть бути корисними лише для стискання файлів +з розміром, що перевищує 8\ МіБ, 16\ МіБ та 32\ МіБ, відповідно. +.RE +.IP "" +На однаковому обладнанні швидкість розпакування є приблизно сталою кількістю +байтів стиснених даних за секунду. Іншими словами, чим кращим є стискання, +тим швидшим буде, зазвичай, розпаковування. Це також означає, що об'єм +розпакованих виведених даних, які видає програма за секунду, може коливатися +у широкому діапазоні. +.IP "" +У наведеній нижче таблиці підсумовано можливості шаблонів: +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Шаблон;DictSize;CompCPU;CompMem;DecMem +\-0;256 КіБ;0;3 МіБ;1 МіБ +\-1;1 МіБ;1;9 МіБ;2 МіБ +\-2;2 МіБ;2;17 МіБ;3 МіБ +\-3;4 МіБ;3;32 МіБ;5 МіБ +\-4;4 МіБ;4;48 МіБ;5 МіБ +\-5;8 МіБ;5;94 МіБ;9 МіБ +\-6;8 МіБ;6;94 МіБ;9 МіБ +\-7;16 МіБ;6;186 МіБ;17 МіБ +\-8;32 МіБ;6;370 МіБ;33 МіБ +\-9;64 МіБ;6;674 МіБ;65 МіБ +.TE +.RE +.RE +.IP "" +Описи стовпчиків: +.RS +.IP \(bu 3 +DictSize є розміром словника LZMA2. Використання словника, розмір якого +перевищує розмір нестисненого файла, — проста витрата пам'яті. Ось чому не +варто використовувати шаблони \fB\-7\fP ... \fB\-9\fP, якщо у них немає реальної +потреби. Для \fB\-6\fP та нижчих рівнів об'єм витраченої пам'яті, зазвичай, +такий низький, що цей фактор ні на що не впливає. +.IP \(bu 3 +CompCPU є спрощеним представленням параметрів LZMA2, які впливають на +швидкість стискання. Розмір словника також впливає на швидкість, тому, хоча +значення CompCPU є однаковим для рівнів \fB\-6\fP ... \fB\-9\fP, обробка на вищих +рівнях все одно є трошки повільнішою. Що отримати повільніше і, ймовірно, +краще стискання, див. \fB\-\-extreme\fP. +.IP \(bu 3 +CompMem містить вимоги до пам'яті засобу стискання у однопотоковому +режимі. Значення можуть бути дещо різними для різних версій \fBxz\fP. +.IP \(bu 3 +У DecMem містяться вимоги до пам'яті при розпаковуванні. Тобто параметри +засобу стискання визначають вимоги до пам'яті при розпаковуванні. Точний +об'єм пам'яті, яка потрібна для розпаковування, дещо перевищує розмір +словника LZMA2, але значення у таблиці було округлено до наступного цілого +значення МіБ. +.RE +.IP "" +Вимоги до пам'яті у багатопотоковому режимі є значно вищими, ніж у +однопотоковому. З типовим значенням \fB\-\-block\-size\fP для кожного потоку треба +3*3*DictSize плюс CompMem або DecMem. Наприклад, для чотирьох потоків з +шаблоном \fB\-6\fP потрібно 660\(en670\ МіБ пам'яті. +.TP +\fB\-e\fP, \fB\-\-extreme\fP +Використати повільніший варіант вибраного рівня стискання (\fB\-0\fP ... \fB\-9\fP) +у сподіванні отримати трохи кращий коефіцієнт стискання, але, якщо не +поталанить, можна його і погіршити. Не впливає на використання пам'яті при +розпаковуванні, але використання пам'яті при стисканні дещо збільшиться на +рівнях \fB\-0\fP ... \fB\-3\fP. +.IP "" +Оскільки існує два набори налаштувань із розмірами словників 4\ МіБ та 8\ МіБ, у наборах \fB\-3e\fP і \fB\-5e\fP використано трошки швидші параметри (нижче +CompCPU), ніж у наборах \fB\-4e\fP і \fB\-6e\fP, відповідно. Тому двох однакових +наборів у списку немає. +.RS +.RS +.PP +.TS +tab(;); +c c c c c +n n n n n. +Шаблон;DictSize;CompCPU;CompMem;DecMem +\-0e;256 КіБ;8;4 МіБ;1 МіБ +\-1e;1 МіБ;8;13 МіБ;2 МіБ +\-2e;2 МіБ;8;25 МіБ;3 МіБ +\-3e;4 МіБ;7;48 МіБ;5 МіБ +\-4e;4 МіБ;8;48 МіБ;5 МіБ +\-5e;8 МіБ;7;94 МіБ;9 МіБ +\-6e;8 МіБ;8;94 МіБ;9 МіБ +\-7e;16 МіБ;8;186 МіБ;17 МіБ +\-8e;32 МіБ;8;370 МіБ;33 МіБ +\-9e;64 МіБ;8;674 МіБ;65 МіБ +.TE +.RE +.RE +.IP "" +Наприклад, передбачено загалом чотири набори налаштувань із використанням +словника у 8\ МіБ, порядок яких від найшвидшого до найповільнішого є таким: +\fB\-5\fP, \fB\-6\fP, \fB\-5e\fP і \fB\-6e\fP. +.TP +\fB\-\-fast\fP +.PD 0 +.TP +\fB\-\-best\fP +.PD +Це дещо оманливі альтернативні варіанти для \fB\-0\fP і \fB\-9\fP, +відповідно. Реалізовано лише для забезпечення зворотної сумісності із LZMA +Utils. Намагайтеся не користуватися цими варіантами параметрів. +.TP +\fB\-\-block\-size=\fP\fIрозмір\fP +При стисканні до формату \fB.xz\fP поділити вхідні дані на блоки у \fIрозмір\fP +байтів. Ці блоки буде стиснуто незалежно один від одного, що допоможе у +багатопотоковій обробці і зробить можливим обмежене розпакування для доступу +до будь\-яких даних. Цим параметром слід типово користуватися для +перевизначення типового розміру блоку у багатопотоковому режимі обробки, але +цим параметром можна також скористатися в однопотоковому режимі обробки. +.IP "" +У багатопотоковому режимі для кожного потоку буде отримано для буферів +вхідних і вихідних даних майже утричі більше за \fIрозмір\fP байтів. Типовий +\fIрозмір\fP утричі більший за розмір словника LZMA2 або дорівнює 1 МіБ, буде +вибрано більше значення. Типовим добрим значенням буде значення, яке у +2\(en4 рази перевищує розмір словника LZMA2 або дорівнює принаймні 1 +МіБ. Використання значення \fIрозмір\fP, яке є меншим за розмір словника LZMA2, +має наслідком марну витрату оперативної пам'яті, оскільки його використання +призводить до того, що буфер словника LZMA2 ніколи не буде використано +повністю. У багатопотоковому режимі розміри блоків зберігатимуться у +заголовках блоків. Ці дані потрібні для багатопотокового розпаковування. +.IP "" +У однопотоковому режимі поділ на блоки типово не +виконуватиметься. Встановлення значення для цього параметра не впливатиме на +використання пам'яті. У заголовках блоків не зберігатимуться дані щодо +розміру, отже файли, які створено в однопотоковому режимі не будуть +ідентичними до файлів, які створено у багатопотоковому режимі. Те, що у +заголовках блоків не зберігатимуться дані щодо розміру також означає, що +\fBxz\fP не зможе розпаковувати такі файли у багатопотоковому режимі. +.TP +\fB\-\-block\-list=\fP\fIзаписи\fP +При стисканні у форматі \fB.xz\fP починати новий блок із необов'язковим +ланцюжком фільтрів після вказаної кількості інтервалів нестиснених даних. +.IP "" +\fIзаписи\fP є списком відокремлених комами значень. Кожен запис складається з +необов'язкового номера ланцюжка фільтрів від 0 до 9, після якого йде +двокрапка (\fB:\fP) і необхідний розмір нестиснутих даних. Пропущення запису +(дві або більше послідовних ком) є скороченим варіантом визначення +використання розміру та фільтрів попереднього запису. +.IP "" +Якщо файл вхідних даних є більшим за розміром за суму розмірів \fIзаписів\fP, +останнє значення у \fIрозмірах\fP буде повторено до кінця файла. Особливе +значення \fB0\fP може бути використано як останній розмір, щоб позначити, що +решту файла має бути закодовано як єдиний блок. +.IP "" +Альтернативний ланцюжок фільтрів для кожного блоку можна вказати в поєднанні +з параметрами \fB\-\-filters1=\fP\fIфільтри\fP \&...\& \fB\-\-filters9=\fP\fIфільтри\fP. Ці +параметри визначають ланцюжки фільтрів з ідентифікатором у діапазоні +1\(en9. Ланцюжок фільтрів 0 можна використовувати для посилання на типовий +ланцюжок фільтрів — це те саме, що не вказувати ланцюжок +фільтрів. Ідентифікатор ланцюжка фільтрів можна використовувати перед +нестисненим розміром, після якого йде двокрапка (\fB:\fP). Наприклад, якщо +вказати \fB\-\-block\-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB\fP, блоки будуть +створені так: +.RS +.IP \(bu 3 +Ланцюжок фільтрів задано \fB\-\-filters1\fP із вхідними даними у 2 МіБ +.IP \(bu 3 +Ланцюжок фільтрів задано \fB\-\-filters3\fP із вхідними даними у 2 МіБ +.IP \(bu 3 +Ланцюжок фільтрів задано \fB\-\-filters2\fP із вхідними даними у 4 МіБ +.IP \(bu 3 +Ланцюжок фільтрів задано \fB\-\-filters2\fP із вхідними даними у 4 МіБ +.IP \(bu 3 +Типовий ланцюжок даних і вхідні дані у 2 МіБ +.IP \(bu 3 +Типовий ланцюжок фільтрів та вхідні дані у 4 МіБ для кожного блоку до кінця +вхідних даних. +.RE +.IP "" +Якщо вказати розмір, який перевищує розмір блоку кодувальника (або типове +значення у режимі із потоками обробки, або значення, яке встановлено за +допомогою \fB\-\-block\-size=\fP\fIрозмір\fP), засіб кодування створить додаткові +блоки, зберігаючи межі, які вказано у \fIзаписах\fP. Наприклад, якщо вказати +\fB\-\-block\-size=10MiB\fP \fB\-\-block\-list=5MiB,10MiB,8MiB,12MiB,24MiB\fP, а файл +вхідних даних має розмір 80 МіБ, буде отримано такі 11 блоків: 5, 10, 8, 10, +2, 10, 10, 4, 10, 10 і 1 МіБ. +.IP "" +У багатопотоковому режимі розмір блоків буде збережено у заголовках +блоків. Програма не зберігатиме ці дані у однопотоковому режимі, отже +закодований результат не буде ідентичним до отриманого у багатопотоковому +режимі. +.TP +\fB\-\-flush\-timeout=\fP\fIчас_очікування\fP +При стискання, якщо з моменту попереднього витирання мине понад +\fIчас_очікування\fP мілісекунд (додатне ціле значення) і читання додаткових +даних буде заблоковано, усі вхідні дані у черзі обробки буде витерто з +кодувальника і зроблено доступним у потоці вихідних даних. Це може бути +корисним, якщо \fBxz\fP використовують для стискання даних, які передають +потоком мережею. Невеликі значення аргументу \fIчас_очікування\fP зроблять дані +доступними на боці отримання із малою затримкою, а великі значення аргумент +\fIчас_очікування\fP уможливлять кращий коефіцієнт стискання. +.IP "" +Типово, цю можливість вимкнено. Якщо цей параметр вказано декілька разів, +буде використано лише останнє вказане значення. Особливим значенням +аргументу \fIчас_очікування\fP, рівним \fB0\fP, можна скористатися для вимикання +цієї можливості явним чином. +.IP "" +Ця можливість недоступна у системах, які не є системами POSIX. +.IP "" +.\" FIXME +\fBЦя можливість усе ще є експериментальною.\fP У поточній версії, \fBxz\fP не +може розпаковувати потік даних у режимі реального часу через те, у який +спосіб \fBxz\fP виконує буферизацію. +.TP +\fB\-\-no\-sync\fP +Не синхронізувати файл призначення та його каталог із пристроєм зберігання +даних до вилучення початкового файла. Це може підвищити швидкодію, якщо +виконується стискання або розпаковування багатьох малих файлів. Втім, якщо +система аварійно завершує роботу невдовзі після вилучення, можлива ситуація, +коли файл призначення не буде записано на пристрій зберігання даних, а дію з +вилучення буде записано. У цьому випадку буде знищено дані як початкового +файла, так і файла призначення. +.IP "" +Цей параметр матиме хоч який вплив, лише якщо \fBxz\fP вилучає початковий +файл. В інших випадках синхронізація не виконується. +.IP "" +Синхронізацію і \fB\-\-no\-sync\fP було додано у версії \fBxz\fP 5.7.1alpha. +.TP +\fB\-\-memlimit\-compress=\fP\fIобмеження\fP +Встановити обмеження на використання пам'яті при стисканні. Якщо цей +параметр вказано декілька разів, враховано буде лише останнє вказане +значення. +.IP "" +Якщо параметри стискання перевищують \fIобмеження\fP, \fBxz\fP спробує скоригувати +параметри так, щоб обмеження не було перевищено, і покаже повідомлення про +те, що було виконано автоматичне коригування. Коригування буде виконано у +такому порядку: зменшення кількості потоків обробки, перемикання у +однопотоковий режим, якщо хоч в одному потоці багатопотокового режиму буде +перевищено \fIобмеження\fP, і нарешті, зменшення розміру словника LZMA2. +.IP "" +При стисканні з використанням \fB\-\-format=raw\fP, або якщо було вказано +\fB\-\-no\-adjust\fP, може бути зменшена лише кількість потоків обробки, оскільки +це може бути зроблено без впливу на стиснені виведені дані. +.IP "" +Якщо \fIобмеження\fP не може бути виконано за допомогою коригувань, які описано +вище, буде показано повідомлення про помилку, а \fBxz\fP завершить роботу зі +станом виходу 1. +.IP "" +Аргумент \fIобмеження\fP можна вказати у декілька способів: +.RS +.IP \(bu 3 +Значенням \fIобмеження\fP може бути додатне ціле значення у байтах. Можна +скористатися цілочисельним суфіксом, подібним до \fBMiB\fP. Приклад: +\fB\-\-memlimit\-compress=80MiB\fP +.IP \(bu 3 +Аргумент \fIобмеження\fP може бути задано у відсотках від загальної фізичної +пам'яті системи (RAM). Це може бути корисним особливо при встановленні +змінної середовища \fBXZ_DEFAULTS\fP у скрипті ініціалізації системи, який є +спільним для різних комп'ютерів. У такий спосіб можна вказати вищий рівень +обмеження для систем із більшим об'ємом пам'яті. Приклад: +\fB\-\-memlimit\-compress=70%\fP +.IP \(bu 3 +Аргументу \fIобмеження\fP може бути повернуто типове значення встановленням +значення \fB0\fP. У поточній версії це еквівалентно до встановлення значення +аргументу \fIобмеження\fP \fBmax\fP (без обмеження на використання пам'яті). +.RE +.IP "" +Для 32\-бітової версії \fBxz\fP передбачено особливий випадок: якщо \fIобмеження\fP +перевищуватиме \fB4020\ МіБ\fP, для \fIобмеження\fP буде встановлено значення +\fB4020\ MiB\fP. На MIPS32 замість цього буде використано \fB2000\ MiB\fP. (Це не +стосується значень \fB0\fP і \fBmax\fP. Подібної можливості для розпаковування не +існує.) Це може бути корисним, коли 32\-бітовий виконуваний файл має доступ +до простору адрес у 4\ ГіБ (2 GiB на MIPS32), хоча, сподіваємося, не +зашкодить і в інших випадках. +.IP "" +Див. також розділ \fBВикористання пам'яті\fP. +.TP +\fB\-\-memlimit\-decompress=\fP\fIобмеження\fP +Встановити обмеження пам'яті на розпаковування. це також вплине на режим +\fB\-\-list\fP. Якщо дія є неможливою без перевищення \fIобмеження\fP, \fBxz\fP покаже +повідомлення про помилку і розпаковування файла не +відбудеться. Див. \fB\-\-memlimit\-compress=\fP\fIобмеження\fP, щоб дізнатися більше +про те, як можна задати \fIобмеження\fP. +.TP +\fB\-\-memlimit\-mt\-decompress=\fP\fIобмеження\fP +Встановити обмеження використання пам'яті для багатопотокового +розпаковування. Це може вплинути лише на кількість потоків обробки; це +ніколи не призводитиме до відмови \fBxz\fP у розпаковуванні файла. Якщо +\fIобмеження є надто низьким\fP, щоб уможливити будь\-яку багатопотокову +обробку, \fIобмеження\fP буде проігноровано, і \fBxz\fP продовжить обробку в +однопотоковому режимі. Зауважте, що якщо використано також +\fB\-\-memlimit\-decompress\fP, цей параметр буде застосовано до обох режимів, +однопотокового та багатопотокового, а отже, задіяне \fIобмеження\fP для +багатопотокового режиму ніколи не перевищуватиме обмеження, яке встановлено +за допомогою \fB\-\-memlimit\-decompress\fP. +.IP "" +На відміну від інших параметрів обмеження використання пам'яті, +\fB\-\-memlimit\-mt\-decompress=\fP\fIобмеження\fP містить специфічне для системи +типове значення \fIобмеження\fP. Можна скористатися \fBxz \-\-info\-memory\fP для +перегляду поточного значення. +.IP "" +Цей параметр і його типове значення існують, оскільки без будь\-яких обмежень +засіб розпакування зі підтримкою потокової обробки міг би намагатися +отримати величезний об'єм пам'яті для деяких файлів вхідних даних. Якщо +типове \fIобмеження\fP є надто низьким для вашої системи, не вагайтеся і +збільшуйте \fIобмеження\fP, але ніколи не встановлюйте для нього значення, яке +є більшим за придатний до користування об'єм оперативної пам'яті, оскільки +за відповідних файлів вхідних даних \fBxz\fP спробує скористатися цим об'ємом +пам'яті, навіть із низькою кількістю потоків обробки. Вичерпання об'єму +оперативної пам'яті або використання резервної пам'яті на диску не покращить +швидкодію системи під час розпаковування. +.IP "" +Див. \fB\-\-memlimit\-compress=\fP\fIобмеження\fP, щоб ознайомитися із можливими +способами визначення \fIобмеження\fP. Встановлення для \fIобмеження\fP значення +\fB0\fP відновлює типове специфічне для системи значення \fIобмеження\fP. +.TP +\fB\-M\fP \fIобмеження\fP, \fB\-\-memlimit=\fP\fIобмеження\fP, \fB\-\-memory=\fP\fIобмеження\fP +Є еквівалентом визначення \fB\-\-memlimit\-compress=\fP\fIобмеження\fP +\fB\-\-memlimit\-decompress=\fP\fIобмеження\fP +\fB\-\-memlimit\-mt\-decompress=\fP\fIобмеження\fP. +.TP +\fB\-\-no\-adjust\fP +Показати повідомлення про помилку і завершити роботу, якщо не вдасться +виконати умови щодо обмеження використання пам'яті без коригування +параметрів, які впливають на стиснених виведених даних. Тобто це забороняє +\fBxz\fP перемикати кодувальник з багатопотокового режиму на однопотоковий +режим і зменшувати розмір словника LZMA2. Навіть якщо використано цей +параметр, кількість потоків може бути зменшено для виконання обмеження на +використання пам'яті, оскільки це не вплине на результати стискання. +.IP "" +Автоматичне коригування завжди буде вимкнено при створенні потоків +необроблених даних (\fB\-\-format=raw\fP). +.TP +\fB\-T\fP \fIпотоки\fP, \fB\-\-threads=\fP\fIпотоки\fP +Вказати кількість потоків обробки, якими слід скористатися. Встановлення для +аргументу \fIпотоки\fP особливого значення \fB0\fP наказує \fBxz\fP використати не +більше потоків обробки, ніж передбачено підтримку у процесорах +системи. Справжня кількість потоків може бути меншою за значення \fIпотоки\fP, +якщо файл вхідних даних не є достатньо великим для поділу на потоки обробки +при заданих параметрах або якщо використання додаткових потоків призведе до +перевищення обмеження на використання пам'яті. +.IP "" +Засоби стискання в однопотоковому та багатопотоковому режимі дають різні +результати. Однопотоковий засіб стискання дасть найменший розмір файла, але +лише результати роботи багатопотокового засобу стискання може бути +розпаковано з використанням декількох потоків. Встановлення для аргументу +\fIпотоки\fP значення \fB1\fP призведе до використання однопотокового +режиму. Встановлення для аргументу \fIпотоки\fP будь\-якого іншого значення, +включно з \fB0\fP, призведе до використання багатопотокового засобу стискання, +навіть якщо у системі передбачено підтримки лише одного апаратного потоку +обробки даних. (Версія \fBxz\fP 5.2.x у цьому випадку використовувала +однопотоковий режим.) +.IP "" +Щоб скористатися багатопотоковим режимом із лише одним потоком обробки, +встановіть для аргументу \fIпотоки\fP значення \fB+1\fP. Префікс \fB+\fP не впливає +на значення, окрім \fB1\fP. Обмеження на використання пам'яті можуть перемкнути +\fBxz\fP в однопотоковий режим, якщо не використано параметр +\fB\-\-no\-adjust\fP. Підтримку \fB+\fP prefix було додано у версії \fBxz\fP 5.4.0. +.IP "" +Якщо було вказано автоматичне визначення кількості потоків і не вказано +обмеження на використання пам'яті, буде використано специфічне для системи +типове м'яке обмеження для можливого обмеження кількості потоків обробки. Це +обмеження є м'яким у сенсі того, що його буде проігноровано, якщо кількість +потоків зрівняється з одиницею, а отже, м'яке обмеження ніколи не +запобігатиму у \fBxz\fP стисканню або розпаковуванню. Це типове м'яке обмеження +не перемкне \fBxz\fP з багатопотокового режиму на однопотоковий режим. Активні +обмеження можна переглянути за допомогою команди \fBxz \-\-info\-memory\fP. +.IP "" +У поточній версії єдиним способом поділу на потоки обробки є поділ вхідних +даних на блоки і стискання цих блоків незалежно один від одного. Типовий +розмір блоку залежить від рівня стискання. Його може бути перевизначено за +допомогою параметра \fB\-\-block\-size=\fP\fIрозмір\fP. +.IP "" +Розпакування з потоками обробки працює лише для файлів, які містять декілька +блоків із даними щодо розміру у заголовках блоків. Цю умову задовольняють +усі достатньо великі файли, які стиснено у багатопотоковому режимі, але не +задовольняють будь\-які файли, які було стиснуто у однопотоковому режимі, +навіть якщо було використано параметр \fB\-\-block\-size=\fP\fIрозмір\fP. +.IP "" +Типовим значенням для \fIпотоків\fP є \fB0\fP. У \fBxz\fP 5.4.x та старіших версіях +типовим значенням є \fB1\fP. +. +.SS "Нетипові ланцюжки фільтрів засобу стискання" +Нетиповий ланцюжок фільтрування уможливлює докладне визначення параметрів +стискання замість використання параметрів, які пов'язано із наперед +визначеними рівнями стискання. Якщо вказано нетиповий ланцюжок фільтрів, +параметри рівнів стискання (\fB\-0\fP \&...\& \fB\-9\fP і \fB\-\-extreme\fP), які +передують їм у рядку команди, буде знехтувано. Якщо параметр рівня стискання +вказано після одного або декількох параметрів нетипового ланцюжка фільтрів, +буде використано рівень стискання, а попередніми параметрами ланцюжка +фільтрування буде знехтувано. +.PP +Ланцюжок фільтрів можна порівняти із конвеєром у командному рядку. При +стисканні нестиснені вхідні дані потрапляють до першого фільтра, виведені +ним дані йдуть до наступного фільтра (якщо такий є). Виведені останнім +фільтром дані буде записано до стисненого файла. Максимальна кількість +фільтрів у ланцюжку дорівнює чотирьом, але у типовому ланцюжку фільтрів +використовують один або два фільтри. +.PP +У багатьох фільтрів є обмеження на місце перебування у ланцюжку фільтрів: +деякі фільтри можуть працювати, лише якщо вони є останніми у ланцюжку, +деякі, лише якщо не останніми, а деякі працюють у будь\-якій позиції +ланцюжка. Залежно від фільтра, це обмеження є наслідком структури фільтра +або існує для запобігання проблем із захистом. +.PP +Нетиповий ланцюжок фільтрів можна вказати двома різними способами. Параметри +\fB\-\-filters=\fP\fIфільтри\fP і \fB\-\-filters1=\fP\fIфільтри\fP \&...\& +\fB\-\-filters9=\fP\fIфільтри\fP надають змогу вказати цілий ланцюжок фільтрів в +одному варіанті з використанням синтаксису рядків фільтрів liblzma. Крім +того, ланцюжок фільтрів можна вказати за допомогою одного або кількох +окремих параметрів фільтрування у тому порядку, в якому їх слід використати +у ланцюжку фільтрів. Тобто порядок окремих параметрів фільтра є важливим! +Під час декодування необроблених потоків (\fB\-\-format=raw\fP) ланцюжок фільтрів +має бути вказано у тому ж порядку, що й під час стиснення. Будь\-який окремий +фільтр або параметри попереднього налаштування, вказані перед параметром +повного ланцюжка (\fB\-\-filters=\fP\fIфільтри\fP), буде відкинуто. Окремі фільтри, +указані після параметра повного ланцюжка, відновлять типовий ланцюжок +фільтрів. +.PP +І параметр повного і параметр окремого фільтра приймають специфічні для +фільтрів \fIпараметри\fP у форматі списку значень, які відокремлено +комами. Зайві коми у \fIпараметрах\fP буде проігноровано. У кожного параметра є +типове значення, отже, вам слід вказати ті параметри, значення яких ви +хочете змінити. +.PP +Щоб переглянути увесь ланцюжок фільтрів та \fIпараметри\fP, скористайтеся +командою \fBxz \-vv\fP (тобто, скористайтеся \fB\-\-verbose\fP двічі). Це працює +також для перегляду параметрів ланцюжка фільтрів, який використано у рівнях +стискання. +.TP +\fB\-\-filters=\fP\fIфільтри\fP +Визначає повний ланцюжок фільтрів або шаблон у форматі одного +параметра. Кожен фільтр можна відокремити від інших пробілами або двома +дефісами (\fB\-\-\fP). Можливо, \fIфільтри\fP доведеться взяти в лапки в командному +рядку оболонки, щоб їх було оброблено як один параметр. Для позначення +\fIпараметрів\fP скористайтеся \fB:\fP або \fB=\fP. До шаблона можна додати префікс +\fB\-\fP і завершити без прапорців або декількома прапорцями. Єдиним +підтримуваним прапорцем є \fBe\fP для застосування тих самих параметрів, що й +\fB\-\-extreme\fP. +.TP +\fB\-\-filters1\fP=\fIфільтри\fP ... \fB\-\-filters9\fP=\fIфільтри\fP +Вказати до дев'яти додаткових ланцюжків фільтрів, якими можна скористатися +за допомогою \fB\-\-block\-list\fP. +.IP "" +Наприклад, якщо виконується стискання архіву із виконуваними файлами, за +якими йдуть текстові файли, для виконуваної частини може бути використано +ланцюжок фільтрів з фільтром BCJ, а для текстової частини — лише фільтр +LZMA2. +.TP +\fB\-\-filters\-help\fP +Вивести довідкове повідомлення з описом того, як вказати шаблони та нетипові +ланцюжки фільтрів у параметри \fB\-\-filters\fP і \fB\-\-filters1=\fP\fIфільтри\fP +\&...\& \fB\-\-filters9=\fP\fIфільтри\fP і завершити роботу із кодом успіху. +.TP +\fB\-\-lzma1\fP[\fB=\fP\fIпараметри\fP] +.PD 0 +.TP +\fB\-\-lzma2\fP[\fB=\fP\fIпараметри\fP] +.PD +Додати фільтр LZMA1 або LZMA2 до ланцюжка фільтрів. Ці фільтри може бути +використано лише як останній фільтр у ланцюжку. +.IP "" +LZMA1 є застарілим фільтром, підтримку якого збережено майже лише через +використання формату файлів \fB.lzma\fP, у яких передбачено підтримку лише +LZMA1. LZMA2 є оновленою версією LZMA1, у якій виправлено деякі практичні +вади LZMA1. У форматі \fB.xz\fP використано LZMA2 і взагалі не передбачено +підтримки LZMA1. Швидкість стискання та коефіцієнт стискання для LZMA1 і +LZMA2 є практично однаковими. +.IP "" +LZMA1 і LZMA2 спільно використовують той самий набір \fIпараметрів\fP: +.RS +.TP +.\" TRANSLATORS: Don't translate bold strings like B, B, +.\" B, B, B, or B because those are command line +.\" options. On the other hand, do translate the italic strings like +.\" I, I, and I, because such italic strings are +.\" placeholders which a user replaces with an actual value. +\fBpreset=\fP\fIшаблон\fP +Скинути усі \fIпараметри\fP LZMA1 або LZMA2 до параметрів \fIшаблона\fP. Аргумент +\fIшаблон\fP складається з цілого числа, після якого може бути однолітерний +модифікатор шаблона. Ціле число може належати лише діапазону від \fB0\fP до +\fB9\fP, що відповідає параметрам командного рядка \fB\-0\fP \&...\& \fB\-9\fP. Єдиним +підтримуваним модифікатором у поточній версії є \fBe\fP, щоб відповідає +параметру \fB\-\-extreme\fP. Якщо аргумент \fBшаблон\fP не вказано, типові значення +\fIпараметрів\fP LZMA1 або LZMA2 буде взято із шаблона \fB6\fP. +.TP +\fBdict=\fP\fIрозмір\fP +Параметр \fIрозміру\fP словника (буфера журналу) визначає, скільки байтів +нещодавно оброблених нестиснених даних слід зберігати у пам'яті. Алгоритм +намагається знайти повторювані послідовності байтів (відповідники) у +нестиснених даних і замінити їх на посилання на дані зі словника. Чим +більшим є словник, тим вищою є ймовірність відшукати відповідник. Отже, +збільшення \fIрозміру\fP словника, зазвичай, покращує коефіцієнт стискання, але +використання словника, розмір якого перевищу є розмір нестисненого файла є +простоюю витратою пам'яті. +.IP "" +\fIРозмір\fP типового словника складає від 64\ КіБ до 64\ МіБ. Мінімальним є +розмір 4\ КіБ. Максимальним розміром для стискання у поточній версії 1.5\ ГіБ (1536\ МіБ). У засобі розпаковування вже передбачено підтримку словників +на один байт менших за 4\ ГіБ, що є максимальним значенням для форматів +потоків даних LZMA1 і LZMA2. +.IP "" +Аргумент \fIрозміру\fP словника і засіб пошуку відповідників (\fImf\fP) разом +визначають параметри використання пам'яті для кодувальника LZMA1 або +LZMA2. Для розпаковування потрібен такий самий (або більший) \fIрозмір\fP +словника, що і для стискання, отже, використання пам'яті для засобу +розпаковування буде визначено за розміром словника, який було використано +для стискання. У заголовках \fB.xz\fP зберігається \fIрозмір\fP словника або як +2^\fIn\fP, або як 2^\fIn\fP + 2^(\fIn\fP\-1), отже, ці \fIрозміри\fP є дещо пріоритетними +для стискання. Інші \fIрозміри\fP буде отримано округленням при зберіганні у +заголовках \fB.xz\fP. +.TP +\fBlc=\fP\fIlc\fP +Визначає кількість буквальних контекстних бітів. Мінімальною кількістю є 0, +а максимальною — 4. Типовою кількістю є 3. Крім того, сума \fIlc\fP і \fIlp\fP має +не перевищувати 4. +.IP "" +Усі байти, які не може бути закодовано як відповідності, буде закодовано як +літерали. Тобто літерали є просто 8\-бітовими байтами, які буде закодовано по +одному за раз. +.IP "" +При кодуванні літералів роблять припущення, що найвищі біти \fIlc\fP +попереднього нестисненого байта корелюють із наступним байтом. Наприклад, у +типовому тексті англійською за літерою у верхньому регістрі йде літера у +нижньому регістрі, а за літерою у нижньому регістрі, зазвичай, йде інша +літера у нижньому регістрі. У наборі символів US\-ASCII найвищими трьома +бітами є 010 для літер верхнього регістру і 011 для літер нижнього +регістру. Якщо \fIlc\fP дорівнює принаймні 3, при кодуванні літералів можна +отримати перевагу встановлення цієї властивості для нестиснених даних. +.IP "" +Зазвичай, типового значення (3) достатньо. Якщо вам потрібне максимальне +стискання, спробуйте \fBlc=4\fP. Іноді це трохи допомагає, а іноді, робить +стискання гіршим. Якщо стискання стане гіршим, спробуйте також \fBlc=2\fP. +.TP +\fBlp=\fP\fIlp\fP +Визначає кількість буквальних позиційних бітів. Мінімальною кількістю є 0, а +максимальною — 4. Типовою кількістю є 0. +.IP "" +\fILp\fP впливає на те, яке вирівнювання у нестиснених даних слід припускати +при кодуванні літералів. Див. \fIpb\fP нижче, щоб дізнатися більше про +вирівнювання. +.TP +\fBpb=\fP\fIpb\fP +Визначає кількість позиційних бітів. Мінімальною кількістю є 0, а +максимальною — 4. Типовою кількістю є 2. +.IP "" +\fIPb\fP впливає на те, який тип вирівнювання загалом припускатиметься для +нестиснених даних. Типовим є чотирибайтове вирівнювання (2^\fIpb\fP=2^2=4), +яке, зазвичай, є добрим варіантом, якщо немає кращих припущень. +.IP "" +Якщо вирівнювання є відомим, встановлення відповідним чином \fIpb\fP може трохи +зменшити розмір файла. Наприклад, у текстових файлах із однобайтовим +вирівнюванням (US\-ASCII, ISO\-8859\-*, UTF\-8), встановлення значення \fBpb=0\fP +може трохи поліпшити стискання. Для тексту UTF\-16 добрим варіантом є +\fBpb=1\fP. Якщо вирівнювання є непарним числом, наприклад 3 байти, найкращим +вибором, ймовірно, є \fBpb=0\fP. +.IP "" +Хоча прогнозоване вирівнювання можна скоригувати за допомогою \fIpb\fP і \fIlp\fP, +у LZMA1 і LZMA2 дещо пріоритетним є 16\-байтове вирівнювання. Це, ймовірно, +слід враховувати при компонуванні форматів файлів, які, ймовірно, часто +будуть стискатися з використанням LZMA1 або LZMA2. +.TP +\fBmf=\fP\fImf\fP +Засіб пошуку відповідників має значний вплив на швидкість, використання +пам'яті та коефіцієнт стискання кодувальника. Зазвичай, засоби пошуку +відповідників на основі ланцюжка хешів є швидшими за засоби пошуку +відповідників на основі двійкового дерева. Типовий засіб залежить від +\fIшаблона\fP: для 0 використовують \fBhc3\fP, для 1\(en3 — \fBhc4\fP, а для решти +використовують \fBbt4\fP. +.IP "" +Передбачено підтримку вказаних нижче засобів пошуку відповідників. Наведені +нижче формули обчислення використання пам'яті є грубими наближеннями, які є +найближчими до реальних значень, якщо значенням \fIсловник\fP є степінь двійки. +.RS +.TP +\fBhc3\fP +Ланцюжок хешів із 2\- та 3\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 3 +.br +Використання пам'яті: +.br +\fIdict\fP * 7.5 (якщо \fIdict\fP <= 16 МіБ); +.br +\fIdict\fP * 5.5 + 64 МіБ (якщо \fIdict\fP > 16 МіБ) +.TP +\fBhc4\fP +Ланцюжок хешів із 2\-, 3\- та 4\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 4 +.br +Використання пам'яті: +.br +\fIdict\fP * 7.5 (якщо \fIdict\fP <= 32 МіБ); +.br +\fIdict\fP * 6.5 (якщо \fIdict\fP > 32 МіБ) +.TP +\fBbt2\fP +Двійкове дерево із 2\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 2 +.br +Використання пам'яті: \fIdict\fP * 9.5 +.TP +\fBbt3\fP +Двійкове дерево із 2\- і 3\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 3 +.br +Використання пам'яті: +.br +\fIdict\fP * 11.5 (якщо \fIdict\fP <= 16 МіБ); +.br +\fIdict\fP * 9.5 + 64 МіБ (якщо \fIdict\fP > 16 МіБ) +.TP +\fBbt4\fP +Двійкове дерево із 2\-, 3\- і 4\-байтовим хешуванням +.br +Мінімальне значення \fIпріоритетності\fP: 4 +.br +Використання пам'яті: +.br +\fIdict\fP * 11.5 (якщо \fIdict\fP <= 32 МіБ); +.br +\fIdict\fP * 10.5 (якщо \fIdict\fP > 32 МіБ) +.RE +.TP +\fBmode=\fP\fIрежим\fP +Параметр \fIрежиму\fP стискання визначає спосіб, який буде використано для +аналізу даних, які створено засобом пошуку відповідників. Підтримуваними +\fIрежимами\fP є \fBfast\fP (швидкий) і \fBnormal\fP (нормальний). Типовим є режим +\fBfast\fP для \fIшаблонів\fP 0\(en3 і режим \fBnormal\fP для \fIшаблонів\fP 4\(en9. +.IP "" +Зазвичай, із засобом пошуку відповідників на основі ланцюжка хешів +використовують \fBfast\fP, а із засобом пошуку відповідників на основі +двійкового дерева використовують \fBnormal\fP. Так само налаштовано і +\fIшаблони\fP. +.TP +\fBnice=\fP\fIпріоритетність\fP +Вказати, яка довжина є пріоритетною для відповідності. Щойно буде виявлено +відповідність у принаймні \fIпріоритетність\fP байтів, алгоритм зупинятиме +пошук можливих кращих відповідників. +.IP "" +\fIПріоритетністю\fP може бути число до 2\(en273 байтів. Вищі значення дають +кращий коефіцієнт стискання за рахунок швидкості. Типове значення залежить +від \fIшаблона\fP. +.TP +\fBdepth=\fP\fIглибина\fP +Вказати максимальну глибину пошуку у засобі пошуку відповідності. Типовим є +особливе значення 0, яке наказує засобу стискання визначити прийнятну +\fIглибину\fP на основі \fImf\fP і \fIпріоритетності\fP. +.IP "" +Прийнятним значенням \fIглибини\fP для ланцюжків хешів є 4\(en100 і 16\(en1000 +для двійкових дерев. Використання дуже високих значень для \fIглибини\fP може +зробити кодувальник дуже повільним для деяких файлів. Не встановлюйте +значення \fIглибини\fP, що перевищує 1000, якщо ви не готові перервати +стискання, якщо воно триватиме надто довго. +.RE +.IP "" +При декодуванні необроблених потоків даних (\fB\-\-format=raw\fP), LZMA2 потребує +лише \fIрозміру\fP словника. LZMA1 потребує також \fIlc\fP, \fIlp\fP і \fIpb\fP. +.TP +\fB\-\-x86\fP[\fB=\fP\fIпараметри\fP] +.PD 0 +.TP +\fB\-\-arm\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-armthumb\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-arm64\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-powerpc\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-ia64\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-sparc\fP[\fB=\fP\fIпараметри\fP] +.TP +\fB\-\-riscv\fP[\fB=\fP\fIпараметри\fP] +.PD +Додати фільтр гілок/викликів/переходів (branch/call/jump або BCJ) до +ланцюжка фільтрів. Цими фільтрами можна скористатися, лише якщо вони не є +останнім фільтром у ланцюжку фільтрів. +.IP "" +Фільтр BCJ перетворює відносні адреси у машинному коді на їхні абсолютні +відповідники. Це не змінює розміру даних, але підвищує резервування, що може +допомогти LZMA2 створити файл \fB.xz\fP на 0\(en15\ % менше. Фільтри BCJ завжди +є придатними до обернення, тому використання фільтра BCJ до помилкового типу +даних не спричинятиме втрати даних, хоча може дещо погіршити коефіцієнт +стискання. Фільтри BCJ є дуже швидкими і такими, що використовують незначний +об'єм пам'яті. +.IP "" +Ці фільтри BCJ мають відомі проблеми, які пов'язано із рівнем стискання: +.RS +.IP \(bu 3 +У деяких типах файлів, де зберігається виконуваний код, (наприклад, в +об'єктних файлах, статичних бібліотеках та модулях ядра Linux) адреси в +інструкціях заповнено значеннями заповнювача. Ці фільтри BCJ виконуватимуть +перетворення адрес, яке зробить стискання для цих файлів гіршим. +.IP \(bu 3 +Якщо фільтр BCJ застосовано до архіву, може так статися, що він погіршить +коефіцієнт стискання порівняно із варіантом без фільтра BCJ. Наприклад, якщо +є подібні або навіть однакові виконувані файли, фільтрування, ймовірно, +зробить ці файли менш подібними, а отже, зробить стискання гіршим. Вміст +файлів, які не є виконуваними, у тому самому архіві також може вплинути на +результат. На практиці, варто спробувати варіанти з фільтром BCJ і без +нього, щоб визначитися із тим, що буде кращим у кожній ситуації. +.RE +.IP "" +Різні набори інструкцій мають різне вирівнювання: виконуваний файл має бути +вирівняно на кратне до цього значення у вхідних даних, щоб фільтр спрацював. +.RS +.RS +.PP +.TS +tab(;); +l n l +l n l. +Фільтр;Вирівнювання;Нотатки +x86;1;32\-бітова або 64\-бітова x86 +ARM;4; +ARM\-Thumb;2; +ARM64;4;Найкращим є вирівнювання за +;;4096 байтами +PowerPC;4;Лише зворотний порядок байтів +IA\-64;16;Itanium +SPARC;4; +RISC\-V;2; +.TE +.RE +.RE +.IP "" +Оскільки фільтровані BCJ дані, зазвичай, стискають за допомогою LZMA2, +коефіцієнт стискання можна трохи поліпшити, якщо параметри LZMA2 буде +встановлено так, щоб вони відповідали вирівнюванню вибраного фільтра +BCJ. Приклади: +.RS +.IP \(bu 3 +Фільтр IA\-64 має 16\-байтове вирівнювання, отже \fBpb=4,lp=4,lc=0\fP дасть добрі +результати у поєднанні із LZMA2 (2^4=16). +.IP \(bu 3 +Код RISC\-V має 2\-байтове або 4\-байтове вирівнювання залежно від того, чи +містить файл 16\-бітові стислі інструкції (розширення C). Якщо використано +16\-бітові інструкції, добрі результати дасть \fBpb=2,lp=1,lc=3\fP або +\fBpb=1,lp=1,lc=3\fP. Якщо 16\-бітових інструкцій немає, найкращим варіантом є +\fBpb=2,lp=2,lc=2\fP. Можна скористатися \fBreadelf \-h\fP, щоб перевірити, чи є +"RVC" у рядку "Flags". +.IP \(bu 3 +ARM64 завжди вирівняно на 4 байти, тому найкращим варіантом буде +\fBpb=2,lp=2,lc=2\fP. +.IP \(bu 3 +Фільтр x86 є виключенням. Зазвичай, добрі результати дають типові для LZMA2 +значення (\fBpb=2,lp=0,lc=3\fP), якщо стискають виконувані файли x86. +.RE +.IP "" +У всіх фільтрах BCJ передбачено підтримку тих самих \fIпараметрів\fP: +.RS +.TP +\fBstart=\fP\fIзсув\fP +Встановити початковий \fIзсув\fP, який буде використано при перетворенні між +відносною та абсолютною адресами. Значення \fIзсув\fP має бути кратним до +вирівнювання фільтра (див. таблицю вище). Типовим зсувом є нульовий. На +практиці, типове значення є прийнятним; визначення нетипового значення +\fIзсув\fP майже завжди нічого корисного не дає. +.RE +.TP +\fB\-\-delta\fP[\fB=\fP\fIпараметри\fP] +Додати дельта\-фільтр до ланцюжка фільтрів. Дельта\-фільтр може бути +використано, лише якщо він не є останнім у ланцюжку фільтрів. +.IP "" +У поточній версії передбачено підтримку обчислення лише простої побітової +дельти. Це може бути корисним при стисканні, наприклад, нестиснутих +растрових зображень або нестиснутих звукових даних PCM. Втім, спеціалізовані +алгоритми можуть давати значно кращі результати за дельту + LZMA2. Це +правило особливо стосується звукових даних, які стискає швидше і краще, +наприклад, \fBflac\fP(1). +.IP "" +Підтримувані \fIпараметри\fP: +.RS +.TP +\fBdist=\fP\fIвідстань\fP +Вказати \fIвідстань\fP обчислень різниці у байтах. Значення \fIвідстань\fP має +потрапляти у діапазон 1\(en256. Типовим значенням є 1. +.IP "" +Наприклад, з \fBdist=2\fP та восьмибайтовими вхідними даними A1 B1 A2 B3 A3 B5 +A4 B7, результатом буде A1 B1 01 02 01 02 01 02. +.RE +. +.SS "Інші параметри" +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Придушити попередження та сповіщення. Вкажіть цей параметр двічі, щоб +придушити також повідомлення про помилки. Цей параметр не впливає на стан +виходу з програми. Тобто, навіть якщо було придушено попередження, стан +виходу вказуватиме на те, що попередження були. +.TP +\fB\-v\fP, \fB\-\-verbose\fP +Докладний режим повідомлень. Якщо стандартне виведення помилок з'єднано із +терміналом, \fBxz\fP показуватиме індикатор поступу. Використання \fB\-\-verbose\fP +двічі призведе до ще докладнішого виведення. +.IP "" +Індикатор поступу показує такі дані: +.RS +.IP \(bu 3 +Частку завершеності буде показано, якщо відомий розмір файла вхідних +даних. Тобто, для каналів даних частку не може бути показано. +.IP \(bu 3 +Об'єм стиснених виведених даних (стискання) або оброблених (розпаковування). +.IP \(bu 3 +Об'єм незапакованих даних (стискання) або виведених даних (розпаковування). +.IP \(bu 3 +Коефіцієнт стискання, який обчислено діленням об'єму оброблених стиснутих +даних на об'єм оброблених нестиснутих даних. +.IP \(bu 3 +Швидкість стискання або розпаковування. Обчислюється як об'єм нестиснутих +даних (стискання) або виведених даних (розпаковування) за секунду. Його буде +показано за декілька секунд з моменту, коли \fBxz\fP почала обробляти файл. +.IP \(bu 3 +Витрачений час у форматі Х:СС або Г:ХХ:СС. +.IP \(bu 3 +Оцінку часу, що лишився, буде показано, лише якщо розмір файла вхідних даних +є відомим, і минуло принаймні декілька секунд з моменту, коли \fBxz\fP почала +обробляти файл. Час буде показано у менш точному форматі, без двокрапок, +наприклад, 2 хв. 30 с. +.RE +.IP "" +Якщо стандартним виведенням помилок не є термінал, \fB\-\-verbose\fP призведе до +того, що \fBxz\fP виведе назву файла, стиснений розмір, нестиснений розмір, +коефіцієнт стискання та, можливо, також швидкість та витрачений час у одному +рядку до стандартного виведення помилок після стискання або розпаковування +файла. Швидкість та витрачений час буде включено, лише якщо дія триває +принаймні декілька секунд. Якщо дію не буде завершено, наприклад, через +втручання користувача, буде також виведено частку виконання, якщо відомий +розмір файла вхідних даних. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Не встановлювати стан виходу 2, навіть якщо було виявлено відповідність +умові, яка варта попередження. Цей параметр не впливає на рівень докладності +повідомлень, отже, слід використати \fB\-\-quiet\fP і \fB\-\-no\-warn\fP, щоб програма +не показувала попереджень і не змінювала стан виходу. +.TP +\fB\-\-robot\fP +Виводити повідомлення у придатному для обробки комп'ютером форматі. Цей +формат призначено для полегшення написання оболонок, які використовуватимуть +\fBxz\fP замість liblzma, що може бути зручним для різноманітних +скриптів. Виведені дані з цим параметром має бути стабільним для усіх +випусків \fBxz\fP. Докладніший опис можна знайти у розділі \fBРЕЖИМ РОБОТА\fP. +.TP +\fB\-\-info\-memory\fP +Вивести у придатному для читання людиною форматі, скільки фізичної пам'яті +(RAM) та скільки потоків процесора є за даними \fBxz\fP у системі, обмеження +для стискання та розпаковування, а потім успішно завершити роботу. +.TP +\fB\-h\fP, \fB\-\-help\fP +Вивести повідомлення про помилку з описом найбільш типових використаних +параметрів і успішно завершити роботу. +.TP +\fB\-H\fP, \fB\-\-long\-help\fP +Вивести довідкове повідомлення з описом усіх можливостей \fBxz\fP і успішно +завершити роботу +.TP +\fB\-V\fP, \fB\-\-version\fP +Вивести номер версії \fBxz\fP та liblzma у зручному для читання форматі. Щоб +отримати дані, зручні для обробки на комп'ютері, вкажіть \fB\-\-robot\fP до +\fB\-\-version\fP. +. +.SH "РЕЖИМ РОБОТА" +Режим робота активують за допомогою параметра \fB\-\-robot\fP. Він спрощує +обробку виведених \fBxz\fP даних іншими програмами. У поточній версії підтримку +\fB\-\-robot\fP передбачено лише разом із \fB\-\-list\fP, \fB\-\-filters\-help\fP, +\fB\-\-info\-memory\fP і \fB\-\-version\fP. У майбутньому підтримку параметра буде +передбачено для стискання та розпаковування. +. +.SS "Режим списку" +У \fBxz \-\-robot \-\-list\fP використано табуляції для поділу виведених +даних. Першим стовпчиком у кожному рядку є рядок, що вказує на тип +відомостей, які можна знайти у цьому рядку: +.TP +.\" TRANSLATORS: The bold strings B, B, B, B, +.\" B, and B are produced by the xz tool for scripts to +.\" parse, thus the untranslated strings must be included in the translated +.\" man page. It may be useful to provide a translated string in parenthesis +.\" without bold, for example: "B (nimi)" +\fBname\fP +Це завжди перший рядок на початку списку файла. Другим стовпчиком у рядку є +назва файла. +.TP +\fBfile\fP +У цьому рядку містяться загальні відомості щодо файла \fB.xz\fP. Цей рядок +завжди виводять після рядка \fBname\fP. +.TP +\fBstream\fP +Цей тип рядка використовують, лише якщо було вказано \fB\-\-verbose\fP. Буде +стільки рядків \fBstream\fP, скільки потоків у файлі \fB.xz\fP. +.TP +\fBblock\fP +Цей тип рядка використовують, лише якщо було вказано \fB\-\-verbose\fP. Буде +стільки рядків \fBblock\fP, скільки блоків у файлі \fB.xz\fP. Рядки \fBblock\fP буде +показано після усіх рядків \fBstream\fP; різні типи рядків не перемежовуються. +.TP +\fBsummary\fP +Цей тип рядків використовують, лише якщо \fB\-\-verbose\fP було вказано +двічі. Цей рядок буде виведено після усіх рядків \fBblock\fP. Подібно до рядка +\fBfile\fP, рядок \fBsummary\fP містить загальні відомості щодо файла \fB.xz\fP. +.TP +\fBtotals\fP +Цей рядок завжди є найостаннішим рядком у виведеному списку. У ньому буде +показано загальні кількості та розміри. +.PP +Стовпчики у рядках \fBфайла\fP: +.PD 0 +.RS +.IP 2. 4 +Кількість потоків у файлі +.IP 3. 4 +Загальна кількість блоків у потоках +.IP 4. 4 +Розмір стисненого файла +.IP 5. 4 +Розмір нестисненого файла +.IP 6. 4 +Коефіцієнт стискання, наприклад, \fB0.123\fP. Якщо коефіцієнт перевищує 9.999, +замість коефіцієнта буде показано дефіси (\fB\-\-\-\fP). +.IP 7. 4 +.\" TRANSLATORS: Don't translate the bold strings B, B, +.\" B, B, or B here. In robot mode, xz produces +.\" them in untranslated form for scripts to parse. +Список відокремлених комами назв перевірок цілісності. Наведені нижче рядки +використовують для відомих типів перевірок: \fBNone\fP, \fBCRC32\fP, \fBCRC64\fP і +\fBSHA\-256\fP. Для невідомих типів перевірок буде використано \fBUnknown\-\fP\fIN\fP, +де \fIN\fP є ідентифікатором перевірки у форматі десяткового числа (одна або +дві цифри). +.IP 8. 4 +Загальний розмір доповнення потоку у файлі +.RE +.PD +.PP +Стовпчики у рядках \fBstream\fP: +.PD 0 +.RS +.IP 2. 4 +Номер потоку (перший потік має номер 1) +.IP 3. 4 +Кількість блоків у потоці +.IP 4. 4 +Зсув початку стисненого +.IP 5. 4 +Зсув початку нестисненого +.IP 6. 4 +Стиснений розмір (не включає доповнення потоку) +.IP 7. 4 +Нестиснутий розмір +.IP 8. 4 +Рівень стискання +.IP 9. 4 +Назва перевірки цілісності +.IP 10. 4 +Розмір доповнення потоку +.RE +.PD +.PP +Стовпчики у рядках \fBblock\fP: +.PD 0 +.RS +.IP 2. 4 +Номер потоку, що містить цей блок +.IP 3. 4 +Номер блоку відносно початку потоку (перший блок має номер 1) +.IP 4. 4 +Номер блоку відносно початку файла +.IP 5. 4 +Зсув початку стисненого відносно початку файла +.IP 6. 4 +Зсув початку нестисненого відносно початку файла +.IP 7. 4 +Загальний стиснений розмір блоку (включено з заголовками) +.IP 8. 4 +Нестиснутий розмір +.IP 9. 4 +Рівень стискання +.IP 10. 4 +Назва перевірки цілісності +.RE +.PD +.PP +Якщо \fB\-\-verbose\fP було вказано двічі, до рядків \fBblock\fP буде включено +додаткові стовпчики. Ці стовпчики не буде показано, якщо вказано одинарний +параметр \fB\-\-verbose\fP, оскільки отримання цих відомостей потребує багатьох +позиціювань, а ця процедура може бути повільною: +.PD 0 +.RS +.IP 11. 4 +Значення перевірки цілісності у шістнадцятковій формі +.IP 12. 4 +Розмір заголовка блоку +.IP 13. 4 +Прапорці блоку: \fBc\fP вказує, що наявний стиснений розмір, а \fBu\fP вказує, що +наявний нестиснений розмір. Якщо прапорець не встановлено, буде показано +(\fB\-\fP) замість підтримання фіксованого розміру рядка. У майбутньому +наприкінці рядка може бути додано нові прапорці. +.IP 14. 4 +Розмір справжніх стиснених даних у блоці (це включає заголовок блоку, +доповнення блоку та поля перевірок) +.IP 15. 4 +Об'єм пам'яті (у байтах), який потрібен для розпаковування цього блоку за +допомогою цієї версії \fBxz\fP +.IP 16. 4 +Ланцюжок фільтрів. Зауважте, що більшість параметрів, які використано під +час стискання, не є наперед відомим, оскільки у заголовках \fB.xz\fP +зберігаються лише параметри, які потрібні для розпаковування. +.RE +.PD +.PP +Стовпчики у рядках \fBsummary\fP: +.PD 0 +.RS +.IP 2. 4 +Об'єм пам'яті (у байтах), який потрібен для розпаковування цього файла за +допомогою цієї версії \fBxz\fP +.IP 3. 4 +\fByes\fP або \fBno\fP вказує, якщо усі заголовки блоків містять одразу стиснений +розмір та розпакований розмір +.PP +\fIПочинаючи з\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 4. 4 +Мінімальна версія \fBxz\fP, яка потрібна для розпаковування файла +.RE +.PD +.PP +Стовпчики рядка \fBtotals\fP: +.PD 0 +.RS +.IP 2. 4 +Кількість потоків +.IP 3. 4 +Кількість блоків +.IP 4. 4 +Стиснутий розмір +.IP 5. 4 +Нестиснутий розмір +.IP 6. 4 +Середній коефіцієнт стискання +.IP 7. 4 +Список відокремлених комами назв перевірок цілісності, результати яких +наявні у файлах +.IP 8. 4 +Розмір доповнення потоку +.IP 9. 4 +Кількість файлів. Наявний тут для зберігання такого самого порядку +стовпчиків, що і у попередніх рядках \fBfile\fP. +.PD +.RE +.PP +Якщо \fB\-\-verbose\fP було вказано двічі, до рядка \fBtotals\fP буде включено +додаткові стовпчики: +.PD 0 +.RS +.IP 10. 4 +Максимальний об'єм пам'яті (у байтах), який потрібен для розпаковування +файлів за допомогою цієї версії \fBxz\fP +.IP 11. 4 +\fByes\fP або \fBno\fP вказує, якщо усі заголовки блоків містять одразу стиснений +розмір та розпакований розмір +.PP +\fIПочинаючи з\fP \fBxz\fP \fI5.1.2alpha:\fP +.IP 12. 4 +Мінімальна версія \fBxz\fP, яка потрібна для розпаковування файла +.RE +.PD +.PP +У майбутніх версіях може бути додано нові типи рядків і нові стовпчики до +наявних типів рядків, але наявні стовпчики мають лишитися незмінними. +. +.SS "Довідка з фільтрування" +\fBxz \-\-robot \-\-filters\-help\fP виведе список підтримуваних фільтрів у такому +форматі: +.PP +\fIфільтр\fP\fB:\fP\fIпараметр\fP\fB=<\fP\fIзначення\fP\fB>,\fP\fIпараметр\fP\fB=<\fP\fIзначення\fP\fB>\fP... +.TP +\fIфільтр\fP +Назва фільтра +.TP +\fIпараметр\fP +Назва специфічного для фільтра параметра +.TP +\fIзначення\fP +Числові діапазони \fIvalue\fP слід вказати у форматі +\fB<\fP\fIмінімум\fP\fB\-\fP\fIмаксимум\fP\fB>\fP. Варіанти рядка \fIзначення\fP +показано у \fB< >\fP і відокремлено символом \fB|\fP. +.PP +Кожен фільтр буде виведено до окремого рядка. +. +.SS "Дані щодо обмеження пам'яті" +\fBxz \-\-robot \-\-info\-memory\fP виводить один рядок з декількома відокремленими +табуляціями стовпчиками: +.IP 1. 4 +Загальний об'єм фізичної пам'яті (RAM) у байтах. +.IP 2. 4 +Обмеження на використання пам'яті для стискання у байтах +(\fB\-\-memlimit\-compress\fP). Особливе значення \fB0\fP вказує на типові +налаштування, якими для однопотокового режиму є налаштування без обмеження +на використання пам'яті. +.IP 3. 4 +Обмеження на використання пам'яті для розпакування у байтах +(\fB\-\-memlimit\-decompress\fP). Особливе значення \fB0\fP вказує на типові +налаштування, якими для однопотокового режиму є налаштування без обмеження +на використання пам'яті. +.IP 4. 4 +Починаючи з \fBxz\fP 5.3.4alpha: використання пам'яті для багатопотокового +розпаковування у байтах (\fB\-\-memlimit\-mt\-decompress\fP). Ніколи не дорівнює +нулеві, оскільки буде використано специфічне для системи типове значення, +яке показано у стовпчику 5, якщо обмеження не встановлено явним чином. Також +ніколи не перевищуватиме значення у стовпчику 3, навіть якщо було вказано +більше значення за допомогою \fB\-\-memlimit\-mt\-decompress\fP. +.IP 5. 4 +Починаючи з \fBxz\fP 5.3.4alpha: специфічне для системи типове обмеження на +використання пам'яті, яке використовують для обмеження кількості потоків при +стисканні з автоматичною кількістю потоків (\fB\-\-threads=0\fP) і без визначення +обмеження на використання пам'яті (\fB\-\-memlimit\-compress\fP). Це значення +також використовують як типове значення для \fB\-\-memlimit\-mt\-decompress\fP. +.IP 6. 4 +Починаючи з \fBxz\fP 5.3.4alpha: кількість доступних потоків обробки процесора. +.PP +У майбутньому у виведенні \fBxz \-\-robot \-\-info\-memory\fP може бути більше +стовпчиків, але у виведеному буде не більше за один рядок. +. +.SS Версія +\fBxz \-\-robot \-\-version\fP виведе назву версії \fBxz\fP і liblzma у такому +форматі: +.PP +.\" TRANSLATORS: Don't translate the uppercase XZ_VERSION or LIBLZMA_VERSION. +\fBXZ_VERSION=\fP\fIXYYYZZZS\fP +.br +\fBLIBLZMA_VERSION=\fP\fIXYYYZZZS\fP +.TP +\fIX\fP +Основна версія. +.TP +\fIYYY\fP +Проміжна версія. Непарні номери буде використано для стабільних +версій. Непарні номери є номерами тестових версій. +.TP +\fIZZZ\fP +Рівень латання для стабільних випусків або просто лічильник для випусків, +які перебувають у розробці. +.TP +\fIS\fP +Стабільність. 0 — alpha, 1 — beta, а 2 означає «стабільна версія». \fIS\fP має +завжди дорівнювати 2, якщо \fIYYY\fP є парним. +.PP +\fIXYYYZZZS\fP є тим самим в обох рядках, якщо \fBxz\fP і liblzma належать до +одного випуску XZ Utils. +.PP +Приклади: 4.999.9beta — це \fB49990091\fP, а 5.0.0 — це \fB50000002\fP. +. +.SH "СТАН ВИХОДУ" +.TP +\fB0\fP +Усе добре. +.TP +\fB1\fP +Сталася помилка. +.TP +\fB2\fP +Сталося щось варте попередження, але справжніх помилок не сталося. +.PP +Зауваження (не попередження або помилки), які виведено до стандартного +виведення помилок, не впливають на стан виходу. +. +.SH СЕРЕДОВИЩЕ +.\" TRANSLATORS: Don't translate the uppercase XZ_DEFAULTS or XZ_OPT. +.\" They are names of environment variables. +\fBxz\fP обробляє списки відокремлених пробілами параметрів зі змінних +середовища \fBXZ_DEFAULTS\fP і \fBXZ_OPT\fP, перш ніж обробляти параметри з рядка +команди. Зауважте, що буде оброблено лише параметри зі змінних середовища; +усі непараметричні записи буде без повідомлень проігноровано. Обробку буде +виконано за допомогою функції \fBgetopt_long\fP(3), яку також використовують +для аргументів рядка команди. +.PP +\fBПопередження:\fP Встановлюючи ці змінні середовища, ви насправді змінюєте +програми та скрипти, які виконують \fBxz\fP. У більшості випадків без проблем +можна встановлювати обмеження на використання пам'яті, кількість потоків і +параметри стиснення за допомогою змінних середовища. Однак деякі параметри +можуть порушити роботу скриптів. Очевидним прикладом є \fB\-\-help\fP, який +змушує \fBxz\fP показувати текст довідки замість стискання або розпаковування +файла. Менш очевидними є приклади \fB\-\-quiet\fP і \fB\-\-verbose\fP. У багатьох +випадках усе працюватиме добре, якщо увімкнути індикатор поступу за +допомогою \fB\-\-verbose\fP, але у деяких ситуаціях додаткові повідомлення +створюють проблеми. Рівень докладності також впливає на поведінку \fB\-\-list\fP. +.TP +\fBXZ_DEFAULTS\fP +Специфічні для користувача або загальносистемні типові параметри. Зазвичай, +їх встановлюють у скрипті ініціалізації оболонки для типового вмикання +обмеження на використання пам'яті у \fBxz\fP або встановлення типової кількості +потоків обробки. Окрім скриптів ініціалізації оболонки і подібних особливих +випадків, не слід встановлювати або скасовувати встановлення значення +\fBXZ_DEFAULTS\fP у скриптах. +.TP +\fBXZ_OPT\fP +Цю змінну призначено для передавання параметрів до \fBxz\fP, якщо неможливо +встановити параметри безпосередньо у рядку команди \fBxz\fP. Це трапляється, +якщо \fBxz\fP запущено скриптом або інструментом, наприклад, GNU \fBtar\fP(1): +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=\-2v tar caf foo.tar.xz foo\fR +.fi +.RE +.RE +.IP "" +Скрипти можуть використовувати \fBXZ_OPT\fP, наприклад, для встановлення +специфічних типових параметрів стискання. Втім, рекомендуємо дозволити +користувачам перевизначати \fBXZ_OPT\fP, якщо це має якісь причини. Наприклад, +у скриптах \fBsh\fP(1) можна скористатися чимось таким: +.RS +.RS +.PP +.nf +\f(CRXZ_OPT=${XZ_OPT\-"\-7e"} +export XZ_OPT\fR +.fi +.RE +.RE +. +.SH "СУМІСНІСТЬ ІЗ LZMA UTILS" +Синтаксис рядка команди \fBxz\fP практично є надбудовою щодо \fBlzma\fP, \fBunlzma\fP +і \fBlzcat\fP з LZMA Utils 4.32.x. У більшості випадків можна замінити LZMA +Utils XZ Utils без порушення працездатності наявних скриптів. Втім, існують +певні несумісності, які іноді можуть спричиняти проблеми. +. +.SS "Рівні шаблонів стискання" +Нумерація у шаблонах рівнів стискання у \fBxz\fP не є тотожною до нумерації у +LZMA Utils. Найважливішою відмінністю є прив'язка розмірів словника до +різних шаблонів. Розмір словника грубо рівний використанню пам'яті у засобі +розпаковування. +.RS +.PP +.TS +tab(;); +c c c +c n n. +Рівень;xz;LZMA Utils +\-0;256 КіБ;н/д +\-1;1 МіБ;64 КіБ +\-2;2 МіБ;1 МіБ +\-3;4 МіБ;512 КіБ +\-4;4 МіБ;1 МіБ +\-5;8 МіБ;2 МіБ +\-6;8 МіБ;4 МіБ +\-7;16 МіБ;8 МіБ +\-8;32 МіБ;16 МіБ +\-9;64 МіБ;32 МіБ +.TE +.RE +.PP +Відмінності у розмірах словників також впливають на використання пам'яті +засобом стискання, але є і інші відмінності між LZMA Utils і XZ Utils, які +роблять різницю ще помітнішою: +.RS +.PP +.TS +tab(;); +c c c +c n n. +Рівень;xz;LZMA Utils 4.32.x +\-0;3 МіБ;н/д +\-1;9 МіБ;2 МіБ +\-2;17 МіБ;12 МіБ +\-3;32 МіБ;12 МіБ +\-4;48 МіБ;16 МіБ +\-5;94 МіБ;26 МіБ +\-6;94 МіБ;45 МіБ +\-7;186 МіБ;83 МіБ +\-8;370 МіБ;159 МіБ +\-9;674 МіБ;311 МіБ +.TE +.RE +.PP +Типовим рівнем стискання у LZMA Utils є \fB\-7\fP, а у XZ Utils — \fB\-6\fP, отже, +обидва комплекти програм типово використовують словник розміром у 8 МіБ. +. +.SS "Потокові і непотокові файл .lzma" +Розмір нестисненого файла може бути збережено у заголовку \fB.lzma\fP. LZMA +Utils зберігають дані при стисканні звичайних файлів. Альтернативним +підходом є позначення нестисненого розміру як невідомого і використання +позначки кінця вмісту для позначення місця, де засіб розпаковування має +зупинитися. У LZMA Utils цей спосіб використовують, якщо нестиснений розмір +є невідомим, що трапляється, наприклад, для конвеєрів обробки даних. +.PP +У \fBxz\fP передбачено підтримку розпаковування файлів \fB.lzma\fP з позначкою +кінця вмісту та без неї, але усі файли \fB.lzma\fP, які створено за допомогою +\fBxz\fP, використовують позначку кінця вмісту, а нестиснений розмір у +заголовку \fB.lzma\fP позначають як невідомий. Це може призвести до проблем у +деяких нетипових ситуаціях. Наприклад, розпакувальник \fB.lzma\fP у вбудованому +пристрої може працювати лише з файлами, для яких відомий нестиснений +розмір. Якщо ви зіткнулися з цією проблемою, вам слід скористатися LZMA +Utils або LZMA SDK для створення файлів \fB.lzma\fP із відомим розміром +нестиснених даних. +. +.SS "Непідтримувані файли .lzma" +У форматі \fB.lzma\fP можливі значення \fIlc\fP аж до 8 і значення \fIlp\fP аж до +4. LZMA Utils можуть розпаковувати файли із будь\-якими значеннями \fIlc\fP і +\fIlp\fP, але завжди створюють файли з \fBlc=3\fP і \fBlp=0\fP. Створення файлів з +іншими значеннями \fIlc\fP і \fIlp\fP є можливим за допомогою \fBxz\fP і LZMA SDK. +.PP +Реалізація фільтра LZMA1 у liblzma потребує, щоби сума \fIlc\fP і \fIlp\fP не +перевищувала 4. Отже, файли \fB.lzma\fP, у яких перевищено обмеження, не може +бути розпаковано за допомогою \fBxz\fP. +.PP +LZMA Utils створюють лише файли \fB.lzma\fP, які мають розмір словника у 2^\fIn\fP +(степінь 2), але приймають файли із будь\-яким розміром словника. liblzma +приймає лише файли \fB.lzma\fP, які мають розмір словника 2^\fIn\fP або 2^\fIn\fP + +2^(\fIn\fP\-1). Так зроблено для зменшення помилок при виявленні файлів +\&\fB.lzma\fP. +.PP +Ці обмеження не мають призводити до проблем на практиці, оскільки практично +усі файли \fB.lzma\fP було стиснено з використанням параметрів, які приймає +liblzma. +. +.SS "Кінцевий мотлох" +При розпаковуванні LZMA Utils без повідомлень ігнорують усі дані після +першого потоку \fB.lzma\fP. У більшості випадків це пов'язано із вадою у +програмі. Це також означає, що у LZMA Utils не передбачено підтримки +розпаковування з'єднаних файлів \fB.lzma\fP. +.PP +Якщо після першого потоку \fB.lzma\fP лишилися дані, \fBxz\fP вважатиме файл +пошкодженим, якщо не було використано \fB\-\-single\-stream\fP. Це може зашкодити +роботі скриптів, де зроблено припущення, що кінцеві зайві дані буде +проігноровано. +. +.SH ПРИМІТКИ +. +.SS "Стискання даних може бути різним" +Точні стиснені дані, які створено на основі того самого нестисненого файла +вхідних даних, можуть бути різними для різних версій XZ Utils, навіть якщо +використано однакові параметри стискання. Причиною цього є удосконалення у +кодувальнику (пришвидшення або краще стискання) без зміни формату +файлів. Виведені дані можуть бути різними навіть для різних збірок тієї +самої версії XZ Utils, якщо використано різні параметри збирання. +.PP +Написане вище означає, що після реалізації \fB\-\-rsyncable\fP файли\-результати +не обов'язково можна буде синхронізувати за допомогою rsyncable, якщо старий +і новий файли було стиснено за допомогою тієї самої версії xz. Цю проблему +можна усунути, якщо буде заморожено частину реалізації кодувальника, щоб +введені для rsync дані були стабільними між версіями xz. +. +.SS "Вбудовані розпакувальники .xz" +У вбудованих реалізаціях розпакувальника \fB.xz\fP, подібних до XZ Embedded, не +обов'язково передбачено підтримку файлів, які створено із типами +\fIперевірки\fP цілісності, відмінними від \fBnone\fP і \fBcrc32\fP. Оскільки типовим +є \fB\-\-check=crc64\fP, вам слід використовувати \fB\-\-check=none\fP або +\fB\-\-check=crc32\fP при створенні файлів для вбудованих систем. +.PP +Поза вбудованими системами, в усіх засобах розпаковування формату \fB.xz\fP +передбачено підтримку усіх типів \fIперевірок\fP або принаймні можливість +розпакувати файл без перевірки цілісності, якщо підтримки певної +\fIперевірки\fP не передбачено. +.PP +У XZ Embedded передбачено підтримку BCJ, але лише з типовим початковим +зсувом. +. +.SH ПРИКЛАДИ +. +.SS Основи +Стиснути файл \fIfoo\fP до \fIfoo.xz\fP за допомогою типового рівня стискання +(\fB\-6\fP) і вилучити \fIfoo\fP, якщо стискання відбулося успішно: +.RS +.PP +.nf +\f(CRxz foo\fR +.fi +.RE +.PP +Розпакувати \fIbar.xz\fP до \fIbar\fP і не вилучати \fIbar.xz\fP, навіть якщо +розпаковування відбулося успішно: +.RS +.PP +.nf +\f(CRxz \-dk bar.xz\fR +.fi +.RE +.PP +Створити \fIbaz.tar.xz\fP з використанням шаблона \fB\-4e\fP (\fB\-4 \-\-extreme\fP), +який є повільнішими за типовий \fB\-6\fP, але потребує менше пам'яті для +стискання та розпаковування (48\ МіБ та 5\ МіБ, відповідно): +.RS +.PP +.nf +\f(CRtar cf \- baz | xz \-4e > baz.tar.xz\fR +.fi +.RE +.PP +Суміш стиснених і нестиснених файлів можна розпакувати до стандартного +виведення за допомогою єдиної команди: +.RS +.PP +.nf +\f(CRxz \-dcf a.txt b.txt.xz c.txt d.txt.lzma > abcd.txt\fR +.fi +.RE +. +.SS "Паралельне стискання багатьох файлів" +У GNU і *BSD можна скористатися \fBfind\fP(1) і \fBxargs\fP(1) для паралельного +стискання багатьох файлів: +.RS +.PP +.nf +\f(CRfind . \-type f \e! \-name '*.xz' \-print0 \e + | xargs \-0r \-P4 \-n16 xz \-T1\fR +.fi +.RE +.PP +Параметр \fB\-P\fP \fBxargs\fP(1) встановлює кількість паралельних процесів +\fBxz\fP. Найкраще значення параметра \fB\-n\fP залежить від того, скільки файлів +має бути стиснено. Якщо файлів мало, значенням, ймовірно, має бути 1. Якщо +файлів десятки тисяч, може знадобитися значення 100 або навіть більше, щоб +зменшити кількість процесів \fBxz\fP, які врешті створить \fBxargs\fP(1). +.PP +Параметр \fB\-T1\fP для \fBxz\fP тут для примусового встановлення однопотокового +режиму, оскільки для керування рівнем паралелізації використано \fBxargs\fP(1). +. +.SS "Режим робота" +Обчислити скільки байтів було заощаджено загалом після стискання декількох +файлів: +.RS +.PP +.nf +\f(CRxz \-\-robot \-\-list *.xz | awk '/^totals/{print $5\-$4}'\fR +.fi +.RE +.PP +Скрипту можуть знадобитися дані щодо того, що використано достатньо нову +версію \fBxz\fP. У наведеному нижче скрипті \fBsh\fP(1) виконано перевірку того, +що номер версії засобу \fBxz\fP є принаймні рівним 5.0.0. Цей спосіб є сумісним +зі старими тестовими версіями, де не передбачено підтримки параметра +\fB\-\-robot\fP: +.RS +.PP +.nf +\f(CRif ! eval "$(xz \-\-robot \-\-version 2> /dev/null)" || + [ "$XZ_VERSION" \-lt 50000002 ]; then + echo "Your xz is too old." +fi +unset XZ_VERSION LIBLZMA_VERSION\fR +.fi +.RE +.PP +Встановити обмеження на використання пам'яті для розпаковування за допомогою +\fBXZ_OPT\fP, але якщо обмеження вже було встановлено, не збільшувати його: +.RS +.PP +.nf +\f(CRNEWLIM=$((123 << 20))\ \ # 123 MiB +OLDLIM=$(xz \-\-robot \-\-info\-memory | cut \-f3) +if [ $OLDLIM \-eq 0 \-o $OLDLIM \-gt $NEWLIM ]; then + XZ_OPT="$XZ_OPT \-\-memlimit\-decompress=$NEWLIM" + export XZ_OPT +fi\fR +.fi +.RE +. +.SS "Нетипові ланцюжки фільтрів засобу стискання" +Найпростішим використанням ланцюжка фільтрів є налаштовування шаблона +LZMA2. Це може бути корисним, оскільки у шаблонах використано лише +підмножину потенційно корисних комбінацій параметрів стискання. +.PP +При налаштовуванні шаблонів LZMA2 корисними є стовпчики CompCPU таблиць з +описів параметрів \fB\-0\fP ... \fB\-9\fP і \fB\-\-extreme\fP. Ось відповідні частини з +цих двох таблиць: +.RS +.PP +.TS +tab(;); +c c +n n. +Шаблон;CompCPU +\-0;0 +\-1;1 +\-2;2 +\-3;3 +\-4;4 +\-5;5 +\-6;6 +\-5e;7 +\-6e;8 +.TE +.RE +.PP +Якщо вам відомо, що певний файл потребує дещо більшого словника (наприклад, +32\ МіБ) для якісного стискання, але ви хочете стиснути його швидше за +команду \fBxz \-8\fP, можна внести зміни до шаблона із нижчим значенням CompCPU +(наприклад, 1) для використання більшого словника: +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=1,dict=32MiB foo.tar\fR +.fi +.RE +.PP +Для певних файлів наведена вище команда може працювати швидше за \fBxz \-6\fP і +стискати дані значно краще. Втім, слід наголосити, переваги більшого +словника з одночасним низьким значенням CompCPU проявляються лише для деяких +файлів. Найочевиднішим випадком, коли великий словник є корисним, є випадок, +коли архів містить дуже подібні файли розміром у принаймні декілька +мегабайтів. Розмір словника має бути значно більшим за будь\-який окремий +файл, щоб у LZMA2 було використано усі переваги подібностей між послідовними +файлами. +.PP +Якщо дуже високий рівень використання пам'яті у засобі стискання або +розпаковування не є проблемою, і файли, який стискають має об'єм у принаймні +декілька десятків мегабайтів, може бути корисним використання навіть +більшого за 64 МіБ словника, який використано у \fBxz \-9\fP: +.RS +.PP +.nf +\f(CRxz \-vv \-\-lzma2=dict=192MiB big_foo.tar\fR +.fi +.RE +.PP +Використання \fB\-vv\fP (\fB\-\-verbose \-\-verbose\fP), подібно до наведеного вище +прикладу, може бути корисним для перегляду вимог з боку засобів стискання та +розпаковування до пам'яті. Пам'ятайте, що використання словника, розмір +якого перевищує розмір файла, який стискають, є простоюю витратою пам'яті, +отже наведену вище команду не варто використовувати для малих файлів. +.PP +Іноді час стискання не має значення, але використання пам'яті засобом +розпаковування має бути низьким для того, щоб, наприклад, уможливити +розпаковування файла у вбудованій системі. У наведеній нижче команді +використано \fB\-6e\fP (\fB\-6 \-\-extreme\fP) як основу і встановлено розмір словника +лише у 64\ КіБ. Файл\-результат можна розпакувати за допомогою XZ Embedded +(ось чому використано \fB\-\-check=crc32\fP) з використанням лише 100\ КіБ +пам'яті. +.RS +.PP +.nf +\f(CRxz \-\-check=crc32 \-\-lzma2=preset=6e,dict=64KiB foo\fR +.fi +.RE +.PP +Якщо вам потрібно витиснути зі стискання максимальну кількість байтів, може +допомогти коригування кількості бітів контексту літералів (\fIlc\fP) та +кількість позиційних бітів (\fIpb\fP). Також може допомогти коригування +кількості бітів позиції літералів (\fIlp\fP), але, зазвичай, важливішими є +\fIlc\fP і \fIpb\fP. Наприклад, в архівах зі початковим кодом міститься +здебільшого текст US\-ASCII, щось подібне до наведеного нижче може дещо (на +щось близьке до 0,1\ %) зменшити файл, порівняно із \fBxz \-6e\fP (спробуйте +також без \fBlc=4\fP): +.RS +.PP +.nf +\f(CRxz \-\-lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR +.fi +.RE +.PP +Використання іншого фільтра разом із LZMA2 може покращити стискання для +певних типів файлів. Наприклад, для стискання бібліотеки спільного +користування x86\-32 або x86\-64 з використанням фільтра BCJ x86 скористайтеся +такою командою: +.RS +.PP +.nf +\f(CRxz \-\-x86 \-\-lzma2 libfoo.so\fR +.fi +.RE +.PP +Зауважте, що порядок параметрів фільтрування має значення. Якщо \fB\-\-x86\fP +вказано після \fB\-\-lzma2\fP, \fBxz\fP повідомить про помилку, оскільки після LZMA2 +не може бути жодного фільтра, а також оскільки фільтр BCJ x86 не можна +використовувати як останній фільтр у ланцюжку. +.PP +Фільтр Delta разом із LZMA2 може дати добрі результати для растрових +зображень. Зазвичай, результати є кращими за формат PNG, у якого є декілька +більш досконалих фільтрів, ніж проста дельта, але там використовують для +стискання Deflate. +.PP +Зображення слід берегти у нестисненому форматі, наприклад, як нестиснений +TIFF. Параметр відстані фільтра Delta встановлюють так, щоб він збігався із +кількістю байтів на піксель у зображенні. Наприклад, для 24\-бітового +растрового зображення RGB слід вказати \fBdist=3\fP, а також добре передати +\fBpb=0\fP до LZMA2 для пристосовування до трибайтового вирівнювання: +.RS +.PP +.nf +\f(CRxz \-\-delta=dist=3 \-\-lzma2=pb=0 foo.tiff\fR +.fi +.RE +.PP +Якщо в один архів запаковано декілька зображень (наприклад, в архів +\&\fB.tar\fP), фільтр Delta також даватиме добрі результати, якщо у всіх +зображеннях однакова кількість байтів для кожного пікселя. +. +.SH "ДИВ. ТАКОЖ" +\fBxzdec\fP(1), \fBxzdiff\fP(1), \fBxzgrep\fP(1), \fBxzless\fP(1), \fBxzmore\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fB7z\fP(1) +.PP +XZ Utils: +.br +Вбудовуваний XZ: +.br +LZMA SDK: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xzcmp.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xzcmp.1 new file mode 100644 index 0000000000000000000000000000000000000000..0dd388c06a0fd2c32b4164b145f89739fe369a42 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xzcmp.1 @@ -0,0 +1,56 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Ukrainian translation for xz-man. +.\" Yuri Chornoivan , 2019, 2022, 2023, 2024, 2025. +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 "6 березня 2025 року" Tukaani "XZ Utils" +.SH НАЗВА +xzcmp, xzdiff, lzcmp, lzdiff — порівняння стиснених файлів +. +.SH "КОРОТКИЙ ОПИС" +\fBxzcmp\fP [\fIпараметр...\fP] \fIфайл1\fP [\fIфайл2\fP] +.br +\fBxzdiff\fP \&... +.br +\fBlzcmp\fP \&... (ЗАСТАРІЛО) +.br +\fBlzdiff\fP \&... (ЗАСТАРІЛО) +. +.SH ОПИС +\fBxzcmp\fP і \fBxzdiff\fP порівнюють нестиснені дані двох файлів. Нестиснені дані +та параметри буде передано \fBcmp\fP(1) або \fBdiff\fP(1), якщо не вказано +\fB\-\-help\fP або \fB\-\-version\fP. +.PP +Якщо вказано одразу \fIфайл1\fP і \fIфайл2\fP, це можуть бути нестиснені файли або +файли у форматах, які може бути розпаковано за допомогою \fBxz\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) або \fBlz4\fP(1). Потрібні +команди розпаковування визначаються з суфіксів назв файлів \fIфайл1\fP і +\fIфайл2\fP. Файли із невідомими програмі суфіксами вважатимуться або +нестисненими або такими, що мають формат, дані у якому може розпаковувати +\fBxz\fP(1). +.PP +Якщо вказано лише одну назву файла, \fIфайл1\fP повинен мати суфікс +підтримуваного формату стискання, а назвою \fIфайл2\fP має бути назва \fIфайл1\fP +з вилученим суфіксом формату стискання. +.PP +Працездатність команд \fBlzcmp\fP і \fBlzdiff\fP забезпечено для зворотної +сумісності із LZMA Utils. Ці команди вважаються застарілими, їх буде +вилучено у майбутній версії комплекту програм. +. +.SH "СТАН ВИХОДУ" +Якщо станеться помилка розпаковування, станом виходу буде \fB2\fP. Інакше, +станом виходу буде \fBcmp\fP(1) або буде використано \fBdiff\fP(1). +. +.SH "ДИВ. ТАКОЖ" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xzdec.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xzdec.1 new file mode 100644 index 0000000000000000000000000000000000000000..85a82215945dbd97edde051df4a2009126bc4b21 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xzdec.1 @@ -0,0 +1,85 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Author: Lasse Collin +.\" +.\" Ukrainian translation for xz-man. +.\" Yuri Chornoivan , 2019, 2022, 2023, 2024, 2025. +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDEC 1 "8 квітня 2024 року" Tukaani "XZ Utils" +.SH НАЗВА +xzdec, lzmadec — невеличкі розпакувальники .xz і .lzma +.SH "КОРОТКИЙ ОПИС" +\fBxzdec\fP [\fIпараметр...\fP] [\fIфайл...\fP] +.br +\fBlzmadec\fP [\fIпараметр...\fP] [\fIфайл...\fP] +.SH ОПИС +\fBxzdec\fP є інструментом на основі liblzma, який призначено лише для +розпаковування файлів \fB.xz\fP (і лише файлів \fB.xz\fP). \fBxzdec\fP призначено для +того, щоб працювати як повноцінний замінник \fBxz\fP(1) у більшості типових +ситуацій, де скрипт було написано для використання \fBxz \-\-decompress \-\-stdout\fP (і, можливо, декількох інших типових параметрів), для +розпаковування файлів \fB.xz\fP. \fBlzmadec\fP є тотожним до \fBxzdec\fP, але у +\fBlzmadec\fP передбачено підтримку файлів \fB.lzma\fP, замість файлів \fB.xz\fP. +.PP +Щоб зменшити розмір виконуваного файла, у \fBxzdec\fP не передбачено підтримки +багатопотокової обробки та локалізації, а також читання параметрів зі +змінних середовища \fBXZ_DEFAULTS\fP і \fBXZ_OPT\fP. У \fBxzdec\fP не передбачено +підтримки показу проміжних даних щодо поступу: надсилання \fBSIGINFO\fP до +\fBxzdec\fP не призводить ні до яких наслідків, але надсилання \fBSIGUSR1\fP +перериває процес, замість показу даних щодо поступу. +.SH ПАРАМЕТРИ +.TP +\fB\-d\fP, \fB\-\-decompress\fP, \fB\-\-uncompress\fP +Буде проігноровано для сумісності з \fBxz\fP(1). У \fBxzdec\fP передбачено +підтримку лише розпаковування. +.TP +\fB\-k\fP, \fB\-\-keep\fP +Буде проігноровано. Призначено для сумісності з \fBxz\fP(1). \fBxzdec\fP ніколи не +створюватиме і ніколи не вилучатиме ці файли. +.TP +\fB\-c\fP, \fB\-\-stdout\fP, \fB\-\-to\-stdout\fP +Буде проігноровано. Для сумісності з \fBxz\fP(1). \fBxzdec\fP завжди записує +розпаковані дані до стандартного виведення. +.TP +\fB\-q\fP, \fB\-\-quiet\fP +Якщо цей параметр вказано один раз, нічого не станеться, оскільки \fBxzdec\fP +ніколи не показуватиме жодних попереджень або нотаток. Вкажіть параметр +двічі, щоб придушити повідомлення про помилки. +.TP +\fB\-Q\fP, \fB\-\-no\-warn\fP +Буде проігноровано для сумісності із \fBxz\fP(1). \fBxzdec\fP ніколи не +використовує стан виходу 2. +.TP +\fB\-h\fP, \fB\-\-help\fP +Вивести довідкове повідомлення і успішно завершити роботу. +.TP +\fB\-V\fP, \fB\-\-version\fP +Вивести номер версії \fBxzdec\fP та liblzma. +.SH "СТАН ВИХОДУ" +.TP +\fB0\fP +Усе добре. +.TP +\fB1\fP +Сталася помилка. +.PP +\fBxzdec\fP не має жодних повідомлень із попередженнями, на відміну від +\fBxz\fP(1), тому у \fBxzdec\fP стан виходу 2 не використовується. +.SH ПРИМІТКИ +Користуйтеся \fBxz\fP(1), замість \fBxzdec\fP або \fBlzmadec\fP, для щоденних +потреб. \fBxzdec\fP та \fBlzmadec\fP призначено лише для тих ситуацій, коли +важливо мати меншу програму для розпаковування, ніж \fBxz\fP(1). +.PP +\fBxzdec\fP і \fBlzmadec\fP не такі вже і малі програми. Їхній розмір можна +зменшити викиданням можливостей з liblzma під час збирання, але цього +зазвичай не роблять для виконуваних файлів, які поширюються у типових, не +вбудованих, дистрибутивах операційних систем. Якщо вам потрібний дуже мала +програма для розпаковування \fB.xz\fP, варто скористатися XZ Embedded. +.SH "ДИВ. ТАКОЖ" +\fBxz\fP(1) +.PP +Вбудовуваний XZ: diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xzdiff.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xzdiff.1 new file mode 100644 index 0000000000000000000000000000000000000000..0dd388c06a0fd2c32b4164b145f89739fe369a42 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xzdiff.1 @@ -0,0 +1,56 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Ukrainian translation for xz-man. +.\" Yuri Chornoivan , 2019, 2022, 2023, 2024, 2025. +.\" +.\" (Note that this file is not based on gzip's zdiff.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZDIFF 1 "6 березня 2025 року" Tukaani "XZ Utils" +.SH НАЗВА +xzcmp, xzdiff, lzcmp, lzdiff — порівняння стиснених файлів +. +.SH "КОРОТКИЙ ОПИС" +\fBxzcmp\fP [\fIпараметр...\fP] \fIфайл1\fP [\fIфайл2\fP] +.br +\fBxzdiff\fP \&... +.br +\fBlzcmp\fP \&... (ЗАСТАРІЛО) +.br +\fBlzdiff\fP \&... (ЗАСТАРІЛО) +. +.SH ОПИС +\fBxzcmp\fP і \fBxzdiff\fP порівнюють нестиснені дані двох файлів. Нестиснені дані +та параметри буде передано \fBcmp\fP(1) або \fBdiff\fP(1), якщо не вказано +\fB\-\-help\fP або \fB\-\-version\fP. +.PP +Якщо вказано одразу \fIфайл1\fP і \fIфайл2\fP, це можуть бути нестиснені файли або +файли у форматах, які може бути розпаковано за допомогою \fBxz\fP(1), +\fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) або \fBlz4\fP(1). Потрібні +команди розпаковування визначаються з суфіксів назв файлів \fIфайл1\fP і +\fIфайл2\fP. Файли із невідомими програмі суфіксами вважатимуться або +нестисненими або такими, що мають формат, дані у якому може розпаковувати +\fBxz\fP(1). +.PP +Якщо вказано лише одну назву файла, \fIфайл1\fP повинен мати суфікс +підтримуваного формату стискання, а назвою \fIфайл2\fP має бути назва \fIфайл1\fP +з вилученим суфіксом формату стискання. +.PP +Працездатність команд \fBlzcmp\fP і \fBlzdiff\fP забезпечено для зворотної +сумісності із LZMA Utils. Ці команди вважаються застарілими, їх буде +вилучено у майбутній версії комплекту програм. +. +.SH "СТАН ВИХОДУ" +Якщо станеться помилка розпаковування, станом виходу буде \fB2\fP. Інакше, +станом виходу буде \fBcmp\fP(1) або буде використано \fBdiff\fP(1). +. +.SH "ДИВ. ТАКОЖ" +\fBcmp\fP(1), \fBdiff\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), +\fBzstd\fP(1), \fBlz4\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xzegrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xzegrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..e88272918dcf5fb875ee3a57c2fcfb1c33dab7ee --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xzegrep.1 @@ -0,0 +1,96 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Ukrainian translation for xz-man. +.\" Yuri Chornoivan , 2019, 2022, 2023, 2024, 2025. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 "6 березня 2025 року" Tukaani "XZ Utils" +.SH НАЗВА +xzgrep — пошук взірців у ймовірно стиснених файлах +. +.SH "КОРОТКИЙ ОПИС" +\fBxzgrep\fP [\fIпараметр...\fP] [\fIсписок_взірців\fP] [\fIфайл...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (ЗАСТАРІЛО) +.br +\fBlzegrep\fP \&... (ЗАСТАРІЛО) +.br +\fBlzfgrep\fP \&... (ЗАСТАРІЛО) +. +.SH ОПИС +\fBxzgrep\fP викликає \fBgrep\fP(1) для розпакованих даних файлів. Формати +\fIфайлів\fP визначатимуться з суфіксів назв файлів. Будь\-який \fIфайл\fP із +суфіксом назви, підтримку якого передбачено у \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) або \fBlz4\fP(1), буде розпаковано; усі +інші файли вважатимуться нестисненими. +.PP +Якщо не вказано аргументу \fIфайли\fP або замість \fIфайл\fP вказано \fB\-\fP, дані +буде прочитано зі стандартного джерела вхідних даних. При читанні зі +стандартного джерела буде розпаковано лише файли, підтримку яких передбачено +у \fBxz\fP(1). Інші файли вважатимуться такими, що вже перебувають у +нестисненому форматі. +.PP +Передбачено підтримку більшості \fIпараметрів\fP \fBgrep\fP(1). Втім, підтримки +цих параметрів не передбачено: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIдія\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIфайл\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglob\fP +.PP +\fBxzegrep\fP є альтернативним записом \fBxzgrep \-E\fP. \fBxzfgrep\fP є +альтернативним записом \fBxzgrep \-F\fP. +.PP +Працездатність команд \fBlzgrep\fP, \fBlzegrep\fP і \fBlzfgrep\fP забезпечено для +зворотної сумісності із LZMA Utils. Ці команди вважаються застарілими, їх +буде вилучено у майбутній версії комплекту програм. +. +.SH "СТАН ВИХОДУ" +.TP +0 +В одному з файлів вхідних даних знайдено принаймні одну +відповідність. Помилок не сталося. +.TP +1 +У жодному з файлів вхідних даних не знайдено відповідника. Не сталося ніяких +помилок. +.TP +>1 +Сталася одна або декілька помилок. Невідомо, чи було знайдено відповідники +критерію пошуку. +. +.SH СЕРЕДОВИЩЕ +.TP +\fBGREP\fP +Якщо для змінної середовища \fBGREP\fP встановлено непорожнє значення, його +буде використано замість \fBgrep\fP(1), \fBgrep \-E\fP або \fBgrep \-F\fP. +. +.SH "ДИВ. ТАКОЖ" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xzfgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xzfgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..e88272918dcf5fb875ee3a57c2fcfb1c33dab7ee --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xzfgrep.1 @@ -0,0 +1,96 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Ukrainian translation for xz-man. +.\" Yuri Chornoivan , 2019, 2022, 2023, 2024, 2025. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 "6 березня 2025 року" Tukaani "XZ Utils" +.SH НАЗВА +xzgrep — пошук взірців у ймовірно стиснених файлах +. +.SH "КОРОТКИЙ ОПИС" +\fBxzgrep\fP [\fIпараметр...\fP] [\fIсписок_взірців\fP] [\fIфайл...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (ЗАСТАРІЛО) +.br +\fBlzegrep\fP \&... (ЗАСТАРІЛО) +.br +\fBlzfgrep\fP \&... (ЗАСТАРІЛО) +. +.SH ОПИС +\fBxzgrep\fP викликає \fBgrep\fP(1) для розпакованих даних файлів. Формати +\fIфайлів\fP визначатимуться з суфіксів назв файлів. Будь\-який \fIфайл\fP із +суфіксом назви, підтримку якого передбачено у \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) або \fBlz4\fP(1), буде розпаковано; усі +інші файли вважатимуться нестисненими. +.PP +Якщо не вказано аргументу \fIфайли\fP або замість \fIфайл\fP вказано \fB\-\fP, дані +буде прочитано зі стандартного джерела вхідних даних. При читанні зі +стандартного джерела буде розпаковано лише файли, підтримку яких передбачено +у \fBxz\fP(1). Інші файли вважатимуться такими, що вже перебувають у +нестисненому форматі. +.PP +Передбачено підтримку більшості \fIпараметрів\fP \fBgrep\fP(1). Втім, підтримки +цих параметрів не передбачено: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIдія\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIфайл\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglob\fP +.PP +\fBxzegrep\fP є альтернативним записом \fBxzgrep \-E\fP. \fBxzfgrep\fP є +альтернативним записом \fBxzgrep \-F\fP. +.PP +Працездатність команд \fBlzgrep\fP, \fBlzegrep\fP і \fBlzfgrep\fP забезпечено для +зворотної сумісності із LZMA Utils. Ці команди вважаються застарілими, їх +буде вилучено у майбутній версії комплекту програм. +. +.SH "СТАН ВИХОДУ" +.TP +0 +В одному з файлів вхідних даних знайдено принаймні одну +відповідність. Помилок не сталося. +.TP +1 +У жодному з файлів вхідних даних не знайдено відповідника. Не сталося ніяких +помилок. +.TP +>1 +Сталася одна або декілька помилок. Невідомо, чи було знайдено відповідники +критерію пошуку. +. +.SH СЕРЕДОВИЩЕ +.TP +\fBGREP\fP +Якщо для змінної середовища \fBGREP\fP встановлено непорожнє значення, його +буде використано замість \fBgrep\fP(1), \fBgrep \-E\fP або \fBgrep \-F\fP. +. +.SH "ДИВ. ТАКОЖ" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xzgrep.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xzgrep.1 new file mode 100644 index 0000000000000000000000000000000000000000..e88272918dcf5fb875ee3a57c2fcfb1c33dab7ee --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xzgrep.1 @@ -0,0 +1,96 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Lasse Collin +.\" Jia Tan +.\" +.\" Ukrainian translation for xz-man. +.\" Yuri Chornoivan , 2019, 2022, 2023, 2024, 2025. +.\" +.\" (Note that this file is not based on gzip's zgrep.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZGREP 1 "6 березня 2025 року" Tukaani "XZ Utils" +.SH НАЗВА +xzgrep — пошук взірців у ймовірно стиснених файлах +. +.SH "КОРОТКИЙ ОПИС" +\fBxzgrep\fP [\fIпараметр...\fP] [\fIсписок_взірців\fP] [\fIфайл...\fP] +.br +\fBxzegrep\fP \&... +.br +\fBxzfgrep\fP \&... +.br +\fBlzgrep\fP \&... (ЗАСТАРІЛО) +.br +\fBlzegrep\fP \&... (ЗАСТАРІЛО) +.br +\fBlzfgrep\fP \&... (ЗАСТАРІЛО) +. +.SH ОПИС +\fBxzgrep\fP викликає \fBgrep\fP(1) для розпакованих даних файлів. Формати +\fIфайлів\fP визначатимуться з суфіксів назв файлів. Будь\-який \fIфайл\fP із +суфіксом назви, підтримку якого передбачено у \fBxz\fP(1), \fBgzip\fP(1), +\fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1) або \fBlz4\fP(1), буде розпаковано; усі +інші файли вважатимуться нестисненими. +.PP +Якщо не вказано аргументу \fIфайли\fP або замість \fIфайл\fP вказано \fB\-\fP, дані +буде прочитано зі стандартного джерела вхідних даних. При читанні зі +стандартного джерела буде розпаковано лише файли, підтримку яких передбачено +у \fBxz\fP(1). Інші файли вважатимуться такими, що вже перебувають у +нестисненому форматі. +.PP +Передбачено підтримку більшості \fIпараметрів\fP \fBgrep\fP(1). Втім, підтримки +цих параметрів не передбачено: +.IP "" 4 +\fB\-r\fP, \fB\-\-recursive\fP +.IP "" 4 +\fB\-R\fP, \fB\-\-dereference\-recursive\fP +.IP "" 4 +\fB\-d\fP, \fB\-\-directories=\fP\fIдія\fP +.IP "" 4 +\fB\-Z\fP, \fB\-\-null\fP +.IP "" 4 +\fB\-z\fP, \fB\-\-null\-data\fP +.IP "" 4 +\fB\-\-include=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude=\fP\fIglob\fP +.IP "" 4 +\fB\-\-exclude\-from=\fP\fIфайл\fP +.IP "" 4 +\fB\-\-exclude\-dir=\fP\fIglob\fP +.PP +\fBxzegrep\fP є альтернативним записом \fBxzgrep \-E\fP. \fBxzfgrep\fP є +альтернативним записом \fBxzgrep \-F\fP. +.PP +Працездатність команд \fBlzgrep\fP, \fBlzegrep\fP і \fBlzfgrep\fP забезпечено для +зворотної сумісності із LZMA Utils. Ці команди вважаються застарілими, їх +буде вилучено у майбутній версії комплекту програм. +. +.SH "СТАН ВИХОДУ" +.TP +0 +В одному з файлів вхідних даних знайдено принаймні одну +відповідність. Помилок не сталося. +.TP +1 +У жодному з файлів вхідних даних не знайдено відповідника. Не сталося ніяких +помилок. +.TP +>1 +Сталася одна або декілька помилок. Невідомо, чи було знайдено відповідники +критерію пошуку. +. +.SH СЕРЕДОВИЩЕ +.TP +\fBGREP\fP +Якщо для змінної середовища \fBGREP\fP встановлено непорожнє значення, його +буде використано замість \fBgrep\fP(1), \fBgrep \-E\fP або \fBgrep \-F\fP. +. +.SH "ДИВ. ТАКОЖ" +\fBgrep\fP(1), \fBxz\fP(1), \fBgzip\fP(1), \fBbzip2\fP(1), \fBlzop\fP(1), \fBzstd\fP(1), +\fBlz4\fP(1), \fBzgrep\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xzless.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xzless.1 new file mode 100644 index 0000000000000000000000000000000000000000..c3b275d0dcadddd3e60054103f9c2a77a4eec341 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xzless.1 @@ -0,0 +1,49 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" Ukrainian translation for xz-man. +.\" Yuri Chornoivan , 2019, 2022, 2023, 2024, 2025. +.\" +.\" (Note that this file is not based on gzip's zless.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZLESS 1 "6 березня 2025 року" Tukaani "XZ Utils" +.SH НАЗВА +xzless, lzless — перегляд стиснених xz або lzma (текстових) файлів +.SH "КОРОТКИЙ ОПИС" +\fBxzless\fP [\fIфайл\fP...] +.br +\fBlzless\fP [\fIфайл\fP...] (ЗАСТАРІЛО) +.SH ОПИС +\fBxzless\fP є фільтром, який показує текст зі стиснених файлів у +терміналі. Файли, підтримку обробки яких передбачено у \fBxz\fP(1), буде +розпаковано; інші файли вважатимуться нестисненими. Якщо не вказано жодного +\fIфайла\fP, \fBxzless\fP читатиме дані зі стандартного джерела вхідних даних. +.PP +Для показу виведених даних \fBxzless\fP використовує \fBless\fP(1). На відміну від +\fBxzmore\fP, вибір програми для поділу на сторінки не можна змінити за +допомогою змінної середовища. Команди засновано на \fBmore\fP(1) і \fBvi\fP(1). За +допомогою команд можна просуватися назад і вперед даними та шукати дані. Щоб +дізнатися більше, ознайомтеся із підручником з \fBless\fP(1). +.PP +Команду \fBlzless\fP реалізовано для забезпечення зворотної сумісності з LZMA +Utils. Ця команда вважається застарілою, її буде вилучено у майбутній версії +комплекту програм. +.SH СЕРЕДОВИЩЕ +.TP +\fBLESSMETACHARS\fP +Список символів, які є особливими символами командної +оболонки. Встановлюється \fBxzless\fP, якщо його ще не встановлено у +середовищі. +.TP +\fBLESSOPEN\fP +Має значення рядка команди для виклику засобу розпаковування \fBxz\fP(1) для +обробки вхідних файлів \fBless\fP(1). +.SH "ДИВ. ТАКОЖ" +\fBless\fP(1), \fBxz\fP(1), \fBxzmore\fP(1), \fBzless\fP(1) diff --git a/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xzmore.1 b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xzmore.1 new file mode 100644 index 0000000000000000000000000000000000000000..bf320be54129079b0f7310ac7f4d733a9f4d9945 --- /dev/null +++ b/miniconda3/pkgs/xz-5.8.2-h448239c_0/share/man/uk/man1/xzmore.1 @@ -0,0 +1,51 @@ +.\" SPDX-License-Identifier: 0BSD +.\" +.\" Authors: Andrew Dudman +.\" Lasse Collin +.\" +.\" Ukrainian translation for xz-man. +.\" Yuri Chornoivan , 2019, 2022, 2023, 2024, 2025. +.\" +.\" (Note that this file is based on xzless.1 instead of gzip's zmore.1.) +.\" +.\"******************************************************************* +.\" +.\" This file was generated with po4a. Translate the source file. +.\" +.\"******************************************************************* +.TH XZMORE 1 "6 березня 2025 року" Tukaani "XZ Utils" +.SH НАЗВА +xzmore, lzmore — перегляд стиснених xz або lzma (текстових) файлів +. +.SH "КОРОТКИЙ ОПИС" +\fBxzmore\fP [\fIфайл\fP...] +.br +\fBlzmore\fP [\fIфайл\fP...] (ЗАСТАРІЛО) +. +.SH ОПИС +\fBxzmore\fP показує текст зі стиснених файлів у терміналі за допомогою +\fBmore\fP(1). Файли, підтримку яких передбачено у \fBxz\fP(1), буде розпаковано; +інші файли вважатимуться вже наданими у розпакованій формі. Якщо не вказано +аргументу \fIфайли\fP, \fBxzmore\fP читатиме дані зі стандартного джерела +даних. Див. підручник з \fBmore\fP(1), щоб дізнатися більше про клавіатурні +команди. +.PP +Зауважте, що гортання у зворотному напрямку може бути неможливим через +реалізацію \fBmore\fP(1). Причиною є те, що \fBxzmore\fP використовує канал для +передавання розпакованих даних \fBmore\fP(1). \fBxzless\fP(1) використовує +\fBless\fP(1), можливості якої є ширшими. +.PP +Команду \fBlzmore\fP реалізовано для забезпечення зворотної сумісності з LZMA +Utils. Ця команда вважається застарілою, її буде вилучено у майбутній версії +комплекту програм. +. +.SH СЕРЕДОВИЩЕ +.TP +.\" TRANSLATORS: Don't translate the uppercase PAGER. +.\" It is a name of an environment variable. +\fBPAGER\fP +Якщо встановлено значення \fBPAGER\fP, значення буде використано для засобу +поділу на сторінки, замість \fBmore\fP(1). +. +.SH "ДИВ. ТАКОЖ" +\fBmore\fP(1), \fBxz\fP(1), \fBxzless\fP(1), \fBzmore\fP(1) diff --git a/miniconda3/pkgs/yaml-cpp-0.8.0-h6a678d5_1/include/gmock/gmock-actions.h b/miniconda3/pkgs/yaml-cpp-0.8.0-h6a678d5_1/include/gmock/gmock-actions.h new file mode 100644 index 0000000000000000000000000000000000000000..f2393bd3afadaba8506261b18a32040395a28267 --- /dev/null +++ b/miniconda3/pkgs/yaml-cpp-0.8.0-h6a678d5_1/include/gmock/gmock-actions.h @@ -0,0 +1,1687 @@ +// Copyright 2007, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +// Google Mock - a framework for writing C++ mock classes. +// +// The ACTION* family of macros can be used in a namespace scope to +// define custom actions easily. The syntax: +// +// ACTION(name) { statements; } +// +// will define an action with the given name that executes the +// statements. The value returned by the statements will be used as +// the return value of the action. Inside the statements, you can +// refer to the K-th (0-based) argument of the mock function by +// 'argK', and refer to its type by 'argK_type'. For example: +// +// ACTION(IncrementArg1) { +// arg1_type temp = arg1; +// return ++(*temp); +// } +// +// allows you to write +// +// ...WillOnce(IncrementArg1()); +// +// You can also refer to the entire argument tuple and its type by +// 'args' and 'args_type', and refer to the mock function type and its +// return type by 'function_type' and 'return_type'. +// +// Note that you don't need to specify the types of the mock function +// arguments. However rest assured that your code is still type-safe: +// you'll get a compiler error if *arg1 doesn't support the ++ +// operator, or if the type of ++(*arg1) isn't compatible with the +// mock function's return type, for example. +// +// Sometimes you'll want to parameterize the action. For that you can use +// another macro: +// +// ACTION_P(name, param_name) { statements; } +// +// For example: +// +// ACTION_P(Add, n) { return arg0 + n; } +// +// will allow you to write: +// +// ...WillOnce(Add(5)); +// +// Note that you don't need to provide the type of the parameter +// either. If you need to reference the type of a parameter named +// 'foo', you can write 'foo_type'. For example, in the body of +// ACTION_P(Add, n) above, you can write 'n_type' to refer to the type +// of 'n'. +// +// We also provide ACTION_P2, ACTION_P3, ..., up to ACTION_P10 to support +// multi-parameter actions. +// +// For the purpose of typing, you can view +// +// ACTION_Pk(Foo, p1, ..., pk) { ... } +// +// as shorthand for +// +// template +// FooActionPk Foo(p1_type p1, ..., pk_type pk) { ... } +// +// In particular, you can provide the template type arguments +// explicitly when invoking Foo(), as in Foo(5, false); +// although usually you can rely on the compiler to infer the types +// for you automatically. You can assign the result of expression +// Foo(p1, ..., pk) to a variable of type FooActionPk. This can be useful when composing actions. +// +// You can also overload actions with different numbers of parameters: +// +// ACTION_P(Plus, a) { ... } +// ACTION_P2(Plus, a, b) { ... } +// +// While it's tempting to always use the ACTION* macros when defining +// a new action, you should also consider implementing ActionInterface +// or using MakePolymorphicAction() instead, especially if you need to +// use the action a lot. While these approaches require more work, +// they give you more control on the types of the mock function +// arguments and the action parameters, which in general leads to +// better compiler error messages that pay off in the long run. They +// also allow overloading actions based on parameter types (as opposed +// to just based on the number of parameters). +// +// CAVEAT: +// +// ACTION*() can only be used in a namespace scope as templates cannot be +// declared inside of a local class. +// Users can, however, define any local functors (e.g. a lambda) that +// can be used as actions. +// +// MORE INFORMATION: +// +// To learn more about using these macros, please search for 'ACTION' on +// https://github.com/google/googletest/blob/master/docs/gmock_cook_book.md + +// GOOGLETEST_CM0002 DO NOT DELETE + +#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ +#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ + +#ifndef _WIN32_WCE +# include +#endif + +#include +#include +#include +#include +#include +#include +#include + +#include "gmock/internal/gmock-internal-utils.h" +#include "gmock/internal/gmock-port.h" +#include "gmock/internal/gmock-pp.h" + +#ifdef _MSC_VER +# pragma warning(push) +# pragma warning(disable:4100) +#endif + +namespace testing { + +// To implement an action Foo, define: +// 1. a class FooAction that implements the ActionInterface interface, and +// 2. a factory function that creates an Action object from a +// const FooAction*. +// +// The two-level delegation design follows that of Matcher, providing +// consistency for extension developers. It also eases ownership +// management as Action objects can now be copied like plain values. + +namespace internal { + +// BuiltInDefaultValueGetter::Get() returns a +// default-constructed T value. BuiltInDefaultValueGetter::Get() crashes with an error. +// +// This primary template is used when kDefaultConstructible is true. +template +struct BuiltInDefaultValueGetter { + static T Get() { return T(); } +}; +template +struct BuiltInDefaultValueGetter { + static T Get() { + Assert(false, __FILE__, __LINE__, + "Default action undefined for the function return type."); + return internal::Invalid(); + // The above statement will never be reached, but is required in + // order for this function to compile. + } +}; + +// BuiltInDefaultValue::Get() returns the "built-in" default value +// for type T, which is NULL when T is a raw pointer type, 0 when T is +// a numeric type, false when T is bool, or "" when T is string or +// std::string. In addition, in C++11 and above, it turns a +// default-constructed T value if T is default constructible. For any +// other type T, the built-in default T value is undefined, and the +// function will abort the process. +template +class BuiltInDefaultValue { + public: + // This function returns true if and only if type T has a built-in default + // value. + static bool Exists() { + return ::std::is_default_constructible::value; + } + + static T Get() { + return BuiltInDefaultValueGetter< + T, ::std::is_default_constructible::value>::Get(); + } +}; + +// This partial specialization says that we use the same built-in +// default value for T and const T. +template +class BuiltInDefaultValue { + public: + static bool Exists() { return BuiltInDefaultValue::Exists(); } + static T Get() { return BuiltInDefaultValue::Get(); } +}; + +// This partial specialization defines the default values for pointer +// types. +template +class BuiltInDefaultValue { + public: + static bool Exists() { return true; } + static T* Get() { return nullptr; } +}; + +// The following specializations define the default values for +// specific types we care about. +#define GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(type, value) \ + template <> \ + class BuiltInDefaultValue { \ + public: \ + static bool Exists() { return true; } \ + static type Get() { return value; } \ + } + +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(void, ); // NOLINT +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(::std::string, ""); +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(bool, false); +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned char, '\0'); +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed char, '\0'); +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(char, '\0'); + +// There's no need for a default action for signed wchar_t, as that +// type is the same as wchar_t for gcc, and invalid for MSVC. +// +// There's also no need for a default action for unsigned wchar_t, as +// that type is the same as unsigned int for gcc, and invalid for +// MSVC. +#if GMOCK_WCHAR_T_IS_NATIVE_ +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(wchar_t, 0U); // NOLINT +#endif + +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned short, 0U); // NOLINT +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed short, 0); // NOLINT +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned int, 0U); +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed int, 0); +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long, 0UL); // NOLINT +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long, 0L); // NOLINT +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long long, 0); // NOLINT +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long long, 0); // NOLINT +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(float, 0); +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(double, 0); + +#undef GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ + +// Simple two-arg form of std::disjunction. +template +using disjunction = typename ::std::conditional::type; + +} // namespace internal + +// When an unexpected function call is encountered, Google Mock will +// let it return a default value if the user has specified one for its +// return type, or if the return type has a built-in default value; +// otherwise Google Mock won't know what value to return and will have +// to abort the process. +// +// The DefaultValue class allows a user to specify the +// default value for a type T that is both copyable and publicly +// destructible (i.e. anything that can be used as a function return +// type). The usage is: +// +// // Sets the default value for type T to be foo. +// DefaultValue::Set(foo); +template +class DefaultValue { + public: + // Sets the default value for type T; requires T to be + // copy-constructable and have a public destructor. + static void Set(T x) { + delete producer_; + producer_ = new FixedValueProducer(x); + } + + // Provides a factory function to be called to generate the default value. + // This method can be used even if T is only move-constructible, but it is not + // limited to that case. + typedef T (*FactoryFunction)(); + static void SetFactory(FactoryFunction factory) { + delete producer_; + producer_ = new FactoryValueProducer(factory); + } + + // Unsets the default value for type T. + static void Clear() { + delete producer_; + producer_ = nullptr; + } + + // Returns true if and only if the user has set the default value for type T. + static bool IsSet() { return producer_ != nullptr; } + + // Returns true if T has a default return value set by the user or there + // exists a built-in default value. + static bool Exists() { + return IsSet() || internal::BuiltInDefaultValue::Exists(); + } + + // Returns the default value for type T if the user has set one; + // otherwise returns the built-in default value. Requires that Exists() + // is true, which ensures that the return value is well-defined. + static T Get() { + return producer_ == nullptr ? internal::BuiltInDefaultValue::Get() + : producer_->Produce(); + } + + private: + class ValueProducer { + public: + virtual ~ValueProducer() {} + virtual T Produce() = 0; + }; + + class FixedValueProducer : public ValueProducer { + public: + explicit FixedValueProducer(T value) : value_(value) {} + T Produce() override { return value_; } + + private: + const T value_; + GTEST_DISALLOW_COPY_AND_ASSIGN_(FixedValueProducer); + }; + + class FactoryValueProducer : public ValueProducer { + public: + explicit FactoryValueProducer(FactoryFunction factory) + : factory_(factory) {} + T Produce() override { return factory_(); } + + private: + const FactoryFunction factory_; + GTEST_DISALLOW_COPY_AND_ASSIGN_(FactoryValueProducer); + }; + + static ValueProducer* producer_; +}; + +// This partial specialization allows a user to set default values for +// reference types. +template +class DefaultValue { + public: + // Sets the default value for type T&. + static void Set(T& x) { // NOLINT + address_ = &x; + } + + // Unsets the default value for type T&. + static void Clear() { address_ = nullptr; } + + // Returns true if and only if the user has set the default value for type T&. + static bool IsSet() { return address_ != nullptr; } + + // Returns true if T has a default return value set by the user or there + // exists a built-in default value. + static bool Exists() { + return IsSet() || internal::BuiltInDefaultValue::Exists(); + } + + // Returns the default value for type T& if the user has set one; + // otherwise returns the built-in default value if there is one; + // otherwise aborts the process. + static T& Get() { + return address_ == nullptr ? internal::BuiltInDefaultValue::Get() + : *address_; + } + + private: + static T* address_; +}; + +// This specialization allows DefaultValue::Get() to +// compile. +template <> +class DefaultValue { + public: + static bool Exists() { return true; } + static void Get() {} +}; + +// Points to the user-set default value for type T. +template +typename DefaultValue::ValueProducer* DefaultValue::producer_ = nullptr; + +// Points to the user-set default value for type T&. +template +T* DefaultValue::address_ = nullptr; + +// Implement this interface to define an action for function type F. +template +class ActionInterface { + public: + typedef typename internal::Function::Result Result; + typedef typename internal::Function::ArgumentTuple ArgumentTuple; + + ActionInterface() {} + virtual ~ActionInterface() {} + + // Performs the action. This method is not const, as in general an + // action can have side effects and be stateful. For example, a + // get-the-next-element-from-the-collection action will need to + // remember the current element. + virtual Result Perform(const ArgumentTuple& args) = 0; + + private: + GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionInterface); +}; + +// An Action is a copyable and IMMUTABLE (except by assignment) +// object that represents an action to be taken when a mock function +// of type F is called. The implementation of Action is just a +// std::shared_ptr to const ActionInterface. Don't inherit from Action! +// You can view an object implementing ActionInterface as a +// concrete action (including its current state), and an Action +// object as a handle to it. +template +class Action { + // Adapter class to allow constructing Action from a legacy ActionInterface. + // New code should create Actions from functors instead. + struct ActionAdapter { + // Adapter must be copyable to satisfy std::function requirements. + ::std::shared_ptr> impl_; + + template + typename internal::Function::Result operator()(Args&&... args) { + return impl_->Perform( + ::std::forward_as_tuple(::std::forward(args)...)); + } + }; + + template + using IsCompatibleFunctor = std::is_constructible, G>; + + public: + typedef typename internal::Function::Result Result; + typedef typename internal::Function::ArgumentTuple ArgumentTuple; + + // Constructs a null Action. Needed for storing Action objects in + // STL containers. + Action() {} + + // Construct an Action from a specified callable. + // This cannot take std::function directly, because then Action would not be + // directly constructible from lambda (it would require two conversions). + template < + typename G, + typename = typename std::enable_if, std::is_constructible, + G>>::value>::type> + Action(G&& fun) { // NOLINT + Init(::std::forward(fun), IsCompatibleFunctor()); + } + + // Constructs an Action from its implementation. + explicit Action(ActionInterface* impl) + : fun_(ActionAdapter{::std::shared_ptr>(impl)}) {} + + // This constructor allows us to turn an Action object into an + // Action, as long as F's arguments can be implicitly converted + // to Func's and Func's return type can be implicitly converted to F's. + template + explicit Action(const Action& action) : fun_(action.fun_) {} + + // Returns true if and only if this is the DoDefault() action. + bool IsDoDefault() const { return fun_ == nullptr; } + + // Performs the action. Note that this method is const even though + // the corresponding method in ActionInterface is not. The reason + // is that a const Action means that it cannot be re-bound to + // another concrete action, not that the concrete action it binds to + // cannot change state. (Think of the difference between a const + // pointer and a pointer to const.) + Result Perform(ArgumentTuple args) const { + if (IsDoDefault()) { + internal::IllegalDoDefault(__FILE__, __LINE__); + } + return internal::Apply(fun_, ::std::move(args)); + } + + private: + template + friend class Action; + + template + void Init(G&& g, ::std::true_type) { + fun_ = ::std::forward(g); + } + + template + void Init(G&& g, ::std::false_type) { + fun_ = IgnoreArgs::type>{::std::forward(g)}; + } + + template + struct IgnoreArgs { + template + Result operator()(const Args&...) const { + return function_impl(); + } + + FunctionImpl function_impl; + }; + + // fun_ is an empty function if and only if this is the DoDefault() action. + ::std::function fun_; +}; + +// The PolymorphicAction class template makes it easy to implement a +// polymorphic action (i.e. an action that can be used in mock +// functions of than one type, e.g. Return()). +// +// To define a polymorphic action, a user first provides a COPYABLE +// implementation class that has a Perform() method template: +// +// class FooAction { +// public: +// template +// Result Perform(const ArgumentTuple& args) const { +// // Processes the arguments and returns a result, using +// // std::get(args) to get the N-th (0-based) argument in the tuple. +// } +// ... +// }; +// +// Then the user creates the polymorphic action using +// MakePolymorphicAction(object) where object has type FooAction. See +// the definition of Return(void) and SetArgumentPointee(value) for +// complete examples. +template +class PolymorphicAction { + public: + explicit PolymorphicAction(const Impl& impl) : impl_(impl) {} + + template + operator Action() const { + return Action(new MonomorphicImpl(impl_)); + } + + private: + template + class MonomorphicImpl : public ActionInterface { + public: + typedef typename internal::Function::Result Result; + typedef typename internal::Function::ArgumentTuple ArgumentTuple; + + explicit MonomorphicImpl(const Impl& impl) : impl_(impl) {} + + Result Perform(const ArgumentTuple& args) override { + return impl_.template Perform(args); + } + + private: + Impl impl_; + }; + + Impl impl_; +}; + +// Creates an Action from its implementation and returns it. The +// created Action object owns the implementation. +template +Action MakeAction(ActionInterface* impl) { + return Action(impl); +} + +// Creates a polymorphic action from its implementation. This is +// easier to use than the PolymorphicAction constructor as it +// doesn't require you to explicitly write the template argument, e.g. +// +// MakePolymorphicAction(foo); +// vs +// PolymorphicAction(foo); +template +inline PolymorphicAction MakePolymorphicAction(const Impl& impl) { + return PolymorphicAction(impl); +} + +namespace internal { + +// Helper struct to specialize ReturnAction to execute a move instead of a copy +// on return. Useful for move-only types, but could be used on any type. +template +struct ByMoveWrapper { + explicit ByMoveWrapper(T value) : payload(std::move(value)) {} + T payload; +}; + +// Implements the polymorphic Return(x) action, which can be used in +// any function that returns the type of x, regardless of the argument +// types. +// +// Note: The value passed into Return must be converted into +// Function::Result when this action is cast to Action rather than +// when that action is performed. This is important in scenarios like +// +// MOCK_METHOD1(Method, T(U)); +// ... +// { +// Foo foo; +// X x(&foo); +// EXPECT_CALL(mock, Method(_)).WillOnce(Return(x)); +// } +// +// In the example above the variable x holds reference to foo which leaves +// scope and gets destroyed. If copying X just copies a reference to foo, +// that copy will be left with a hanging reference. If conversion to T +// makes a copy of foo, the above code is safe. To support that scenario, we +// need to make sure that the type conversion happens inside the EXPECT_CALL +// statement, and conversion of the result of Return to Action is a +// good place for that. +// +// The real life example of the above scenario happens when an invocation +// of gtl::Container() is passed into Return. +// +template +class ReturnAction { + public: + // Constructs a ReturnAction object from the value to be returned. + // 'value' is passed by value instead of by const reference in order + // to allow Return("string literal") to compile. + explicit ReturnAction(R value) : value_(new R(std::move(value))) {} + + // This template type conversion operator allows Return(x) to be + // used in ANY function that returns x's type. + template + operator Action() const { // NOLINT + // Assert statement belongs here because this is the best place to verify + // conditions on F. It produces the clearest error messages + // in most compilers. + // Impl really belongs in this scope as a local class but can't + // because MSVC produces duplicate symbols in different translation units + // in this case. Until MS fixes that bug we put Impl into the class scope + // and put the typedef both here (for use in assert statement) and + // in the Impl class. But both definitions must be the same. + typedef typename Function::Result Result; + GTEST_COMPILE_ASSERT_( + !std::is_reference::value, + use_ReturnRef_instead_of_Return_to_return_a_reference); + static_assert(!std::is_void::value, + "Can't use Return() on an action expected to return `void`."); + return Action(new Impl(value_)); + } + + private: + // Implements the Return(x) action for a particular function type F. + template + class Impl : public ActionInterface { + public: + typedef typename Function::Result Result; + typedef typename Function::ArgumentTuple ArgumentTuple; + + // The implicit cast is necessary when Result has more than one + // single-argument constructor (e.g. Result is std::vector) and R + // has a type conversion operator template. In that case, value_(value) + // won't compile as the compiler doesn't known which constructor of + // Result to call. ImplicitCast_ forces the compiler to convert R to + // Result without considering explicit constructors, thus resolving the + // ambiguity. value_ is then initialized using its copy constructor. + explicit Impl(const std::shared_ptr& value) + : value_before_cast_(*value), + value_(ImplicitCast_(value_before_cast_)) {} + + Result Perform(const ArgumentTuple&) override { return value_; } + + private: + GTEST_COMPILE_ASSERT_(!std::is_reference::value, + Result_cannot_be_a_reference_type); + // We save the value before casting just in case it is being cast to a + // wrapper type. + R value_before_cast_; + Result value_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl); + }; + + // Partially specialize for ByMoveWrapper. This version of ReturnAction will + // move its contents instead. + template + class Impl, F> : public ActionInterface { + public: + typedef typename Function::Result Result; + typedef typename Function::ArgumentTuple ArgumentTuple; + + explicit Impl(const std::shared_ptr& wrapper) + : performed_(false), wrapper_(wrapper) {} + + Result Perform(const ArgumentTuple&) override { + GTEST_CHECK_(!performed_) + << "A ByMove() action should only be performed once."; + performed_ = true; + return std::move(wrapper_->payload); + } + + private: + bool performed_; + const std::shared_ptr wrapper_; + }; + + const std::shared_ptr value_; +}; + +// Implements the ReturnNull() action. +class ReturnNullAction { + public: + // Allows ReturnNull() to be used in any pointer-returning function. In C++11 + // this is enforced by returning nullptr, and in non-C++11 by asserting a + // pointer type on compile time. + template + static Result Perform(const ArgumentTuple&) { + return nullptr; + } +}; + +// Implements the Return() action. +class ReturnVoidAction { + public: + // Allows Return() to be used in any void-returning function. + template + static void Perform(const ArgumentTuple&) { + static_assert(std::is_void::value, "Result should be void."); + } +}; + +// Implements the polymorphic ReturnRef(x) action, which can be used +// in any function that returns a reference to the type of x, +// regardless of the argument types. +template +class ReturnRefAction { + public: + // Constructs a ReturnRefAction object from the reference to be returned. + explicit ReturnRefAction(T& ref) : ref_(ref) {} // NOLINT + + // This template type conversion operator allows ReturnRef(x) to be + // used in ANY function that returns a reference to x's type. + template + operator Action() const { + typedef typename Function::Result Result; + // Asserts that the function return type is a reference. This + // catches the user error of using ReturnRef(x) when Return(x) + // should be used, and generates some helpful error message. + GTEST_COMPILE_ASSERT_(std::is_reference::value, + use_Return_instead_of_ReturnRef_to_return_a_value); + return Action(new Impl(ref_)); + } + + private: + // Implements the ReturnRef(x) action for a particular function type F. + template + class Impl : public ActionInterface { + public: + typedef typename Function::Result Result; + typedef typename Function::ArgumentTuple ArgumentTuple; + + explicit Impl(T& ref) : ref_(ref) {} // NOLINT + + Result Perform(const ArgumentTuple&) override { return ref_; } + + private: + T& ref_; + }; + + T& ref_; +}; + +// Implements the polymorphic ReturnRefOfCopy(x) action, which can be +// used in any function that returns a reference to the type of x, +// regardless of the argument types. +template +class ReturnRefOfCopyAction { + public: + // Constructs a ReturnRefOfCopyAction object from the reference to + // be returned. + explicit ReturnRefOfCopyAction(const T& value) : value_(value) {} // NOLINT + + // This template type conversion operator allows ReturnRefOfCopy(x) to be + // used in ANY function that returns a reference to x's type. + template + operator Action() const { + typedef typename Function::Result Result; + // Asserts that the function return type is a reference. This + // catches the user error of using ReturnRefOfCopy(x) when Return(x) + // should be used, and generates some helpful error message. + GTEST_COMPILE_ASSERT_( + std::is_reference::value, + use_Return_instead_of_ReturnRefOfCopy_to_return_a_value); + return Action(new Impl(value_)); + } + + private: + // Implements the ReturnRefOfCopy(x) action for a particular function type F. + template + class Impl : public ActionInterface { + public: + typedef typename Function::Result Result; + typedef typename Function::ArgumentTuple ArgumentTuple; + + explicit Impl(const T& value) : value_(value) {} // NOLINT + + Result Perform(const ArgumentTuple&) override { return value_; } + + private: + T value_; + }; + + const T value_; +}; + +// Implements the polymorphic ReturnRoundRobin(v) action, which can be +// used in any function that returns the element_type of v. +template +class ReturnRoundRobinAction { + public: + explicit ReturnRoundRobinAction(std::vector values) { + GTEST_CHECK_(!values.empty()) + << "ReturnRoundRobin requires at least one element."; + state_->values = std::move(values); + } + + template + T operator()(Args&&...) const { + return state_->Next(); + } + + private: + struct State { + T Next() { + T ret_val = values[i++]; + if (i == values.size()) i = 0; + return ret_val; + } + + std::vector values; + size_t i = 0; + }; + std::shared_ptr state_ = std::make_shared(); +}; + +// Implements the polymorphic DoDefault() action. +class DoDefaultAction { + public: + // This template type conversion operator allows DoDefault() to be + // used in any function. + template + operator Action() const { return Action(); } // NOLINT +}; + +// Implements the Assign action to set a given pointer referent to a +// particular value. +template +class AssignAction { + public: + AssignAction(T1* ptr, T2 value) : ptr_(ptr), value_(value) {} + + template + void Perform(const ArgumentTuple& /* args */) const { + *ptr_ = value_; + } + + private: + T1* const ptr_; + const T2 value_; +}; + +#if !GTEST_OS_WINDOWS_MOBILE + +// Implements the SetErrnoAndReturn action to simulate return from +// various system calls and libc functions. +template +class SetErrnoAndReturnAction { + public: + SetErrnoAndReturnAction(int errno_value, T result) + : errno_(errno_value), + result_(result) {} + template + Result Perform(const ArgumentTuple& /* args */) const { + errno = errno_; + return result_; + } + + private: + const int errno_; + const T result_; +}; + +#endif // !GTEST_OS_WINDOWS_MOBILE + +// Implements the SetArgumentPointee(x) action for any function +// whose N-th argument (0-based) is a pointer to x's type. +template +struct SetArgumentPointeeAction { + A value; + + template + void operator()(const Args&... args) const { + *::std::get(std::tie(args...)) = value; + } +}; + +// Implements the Invoke(object_ptr, &Class::Method) action. +template +struct InvokeMethodAction { + Class* const obj_ptr; + const MethodPtr method_ptr; + + template + auto operator()(Args&&... args) const + -> decltype((obj_ptr->*method_ptr)(std::forward(args)...)) { + return (obj_ptr->*method_ptr)(std::forward(args)...); + } +}; + +// Implements the InvokeWithoutArgs(f) action. The template argument +// FunctionImpl is the implementation type of f, which can be either a +// function pointer or a functor. InvokeWithoutArgs(f) can be used as an +// Action as long as f's type is compatible with F. +template +struct InvokeWithoutArgsAction { + FunctionImpl function_impl; + + // Allows InvokeWithoutArgs(f) to be used as any action whose type is + // compatible with f. + template + auto operator()(const Args&...) -> decltype(function_impl()) { + return function_impl(); + } +}; + +// Implements the InvokeWithoutArgs(object_ptr, &Class::Method) action. +template +struct InvokeMethodWithoutArgsAction { + Class* const obj_ptr; + const MethodPtr method_ptr; + + using ReturnType = + decltype((std::declval()->*std::declval())()); + + template + ReturnType operator()(const Args&...) const { + return (obj_ptr->*method_ptr)(); + } +}; + +// Implements the IgnoreResult(action) action. +template +class IgnoreResultAction { + public: + explicit IgnoreResultAction(const A& action) : action_(action) {} + + template + operator Action() const { + // Assert statement belongs here because this is the best place to verify + // conditions on F. It produces the clearest error messages + // in most compilers. + // Impl really belongs in this scope as a local class but can't + // because MSVC produces duplicate symbols in different translation units + // in this case. Until MS fixes that bug we put Impl into the class scope + // and put the typedef both here (for use in assert statement) and + // in the Impl class. But both definitions must be the same. + typedef typename internal::Function::Result Result; + + // Asserts at compile time that F returns void. + static_assert(std::is_void::value, "Result type should be void."); + + return Action(new Impl(action_)); + } + + private: + template + class Impl : public ActionInterface { + public: + typedef typename internal::Function::Result Result; + typedef typename internal::Function::ArgumentTuple ArgumentTuple; + + explicit Impl(const A& action) : action_(action) {} + + void Perform(const ArgumentTuple& args) override { + // Performs the action and ignores its result. + action_.Perform(args); + } + + private: + // Type OriginalFunction is the same as F except that its return + // type is IgnoredValue. + typedef typename internal::Function::MakeResultIgnoredValue + OriginalFunction; + + const Action action_; + }; + + const A action_; +}; + +template +struct WithArgsAction { + InnerAction action; + + // The inner action could be anything convertible to Action. + // We use the conversion operator to detect the signature of the inner Action. + template + operator Action() const { // NOLINT + using TupleType = std::tuple; + Action::type...)> + converted(action); + + return [converted](Args... args) -> R { + return converted.Perform(std::forward_as_tuple( + std::get(std::forward_as_tuple(std::forward(args)...))...)); + }; + } +}; + +template +struct DoAllAction { + private: + template + using NonFinalType = + typename std::conditional::value, T, const T&>::type; + + template + std::vector Convert(IndexSequence) const { + return {ActionT(std::get(actions))...}; + } + + public: + std::tuple actions; + + template + operator Action() const { // NOLINT + struct Op { + std::vector...)>> converted; + Action last; + R operator()(Args... args) const { + auto tuple_args = std::forward_as_tuple(std::forward(args)...); + for (auto& a : converted) { + a.Perform(tuple_args); + } + return last.Perform(std::move(tuple_args)); + } + }; + return Op{Convert...)>>( + MakeIndexSequence()), + std::get(actions)}; + } +}; + +template +struct ReturnNewAction { + T* operator()() const { + return internal::Apply( + [](const Params&... unpacked_params) { + return new T(unpacked_params...); + }, + params); + } + std::tuple params; +}; + +template +struct ReturnArgAction { + template + auto operator()(const Args&... args) const -> + typename std::tuple_element>::type { + return std::get(std::tie(args...)); + } +}; + +template +struct SaveArgAction { + Ptr pointer; + + template + void operator()(const Args&... args) const { + *pointer = std::get(std::tie(args...)); + } +}; + +template +struct SaveArgPointeeAction { + Ptr pointer; + + template + void operator()(const Args&... args) const { + *pointer = *std::get(std::tie(args...)); + } +}; + +template +struct SetArgRefereeAction { + T value; + + template + void operator()(Args&&... args) const { + using argk_type = + typename ::std::tuple_element>::type; + static_assert(std::is_lvalue_reference::value, + "Argument must be a reference type."); + std::get(std::tie(args...)) = value; + } +}; + +template +struct SetArrayArgumentAction { + I1 first; + I2 last; + + template + void operator()(const Args&... args) const { + auto value = std::get(std::tie(args...)); + for (auto it = first; it != last; ++it, (void)++value) { + *value = *it; + } + } +}; + +template +struct DeleteArgAction { + template + void operator()(const Args&... args) const { + delete std::get(std::tie(args...)); + } +}; + +template +struct ReturnPointeeAction { + Ptr pointer; + template + auto operator()(const Args&...) const -> decltype(*pointer) { + return *pointer; + } +}; + +#if GTEST_HAS_EXCEPTIONS +template +struct ThrowAction { + T exception; + // We use a conversion operator to adapt to any return type. + template + operator Action() const { // NOLINT + T copy = exception; + return [copy](Args...) -> R { throw copy; }; + } +}; +#endif // GTEST_HAS_EXCEPTIONS + +} // namespace internal + +// An Unused object can be implicitly constructed from ANY value. +// This is handy when defining actions that ignore some or all of the +// mock function arguments. For example, given +// +// MOCK_METHOD3(Foo, double(const string& label, double x, double y)); +// MOCK_METHOD3(Bar, double(int index, double x, double y)); +// +// instead of +// +// double DistanceToOriginWithLabel(const string& label, double x, double y) { +// return sqrt(x*x + y*y); +// } +// double DistanceToOriginWithIndex(int index, double x, double y) { +// return sqrt(x*x + y*y); +// } +// ... +// EXPECT_CALL(mock, Foo("abc", _, _)) +// .WillOnce(Invoke(DistanceToOriginWithLabel)); +// EXPECT_CALL(mock, Bar(5, _, _)) +// .WillOnce(Invoke(DistanceToOriginWithIndex)); +// +// you could write +// +// // We can declare any uninteresting argument as Unused. +// double DistanceToOrigin(Unused, double x, double y) { +// return sqrt(x*x + y*y); +// } +// ... +// EXPECT_CALL(mock, Foo("abc", _, _)).WillOnce(Invoke(DistanceToOrigin)); +// EXPECT_CALL(mock, Bar(5, _, _)).WillOnce(Invoke(DistanceToOrigin)); +typedef internal::IgnoredValue Unused; + +// Creates an action that does actions a1, a2, ..., sequentially in +// each invocation. All but the last action will have a readonly view of the +// arguments. +template +internal::DoAllAction::type...> DoAll( + Action&&... action) { + return {std::forward_as_tuple(std::forward(action)...)}; +} + +// WithArg(an_action) creates an action that passes the k-th +// (0-based) argument of the mock function to an_action and performs +// it. It adapts an action accepting one argument to one that accepts +// multiple arguments. For convenience, we also provide +// WithArgs(an_action) (defined below) as a synonym. +template +internal::WithArgsAction::type, k> +WithArg(InnerAction&& action) { + return {std::forward(action)}; +} + +// WithArgs(an_action) creates an action that passes +// the selected arguments of the mock function to an_action and +// performs it. It serves as an adaptor between actions with +// different argument lists. +template +internal::WithArgsAction::type, k, ks...> +WithArgs(InnerAction&& action) { + return {std::forward(action)}; +} + +// WithoutArgs(inner_action) can be used in a mock function with a +// non-empty argument list to perform inner_action, which takes no +// argument. In other words, it adapts an action accepting no +// argument to one that accepts (and ignores) arguments. +template +internal::WithArgsAction::type> +WithoutArgs(InnerAction&& action) { + return {std::forward(action)}; +} + +// Creates an action that returns 'value'. 'value' is passed by value +// instead of const reference - otherwise Return("string literal") +// will trigger a compiler error about using array as initializer. +template +internal::ReturnAction Return(R value) { + return internal::ReturnAction(std::move(value)); +} + +// Creates an action that returns NULL. +inline PolymorphicAction ReturnNull() { + return MakePolymorphicAction(internal::ReturnNullAction()); +} + +// Creates an action that returns from a void function. +inline PolymorphicAction Return() { + return MakePolymorphicAction(internal::ReturnVoidAction()); +} + +// Creates an action that returns the reference to a variable. +template +inline internal::ReturnRefAction ReturnRef(R& x) { // NOLINT + return internal::ReturnRefAction(x); +} + +// Prevent using ReturnRef on reference to temporary. +template +internal::ReturnRefAction ReturnRef(R&&) = delete; + +// Creates an action that returns the reference to a copy of the +// argument. The copy is created when the action is constructed and +// lives as long as the action. +template +inline internal::ReturnRefOfCopyAction ReturnRefOfCopy(const R& x) { + return internal::ReturnRefOfCopyAction(x); +} + +// Modifies the parent action (a Return() action) to perform a move of the +// argument instead of a copy. +// Return(ByMove()) actions can only be executed once and will assert this +// invariant. +template +internal::ByMoveWrapper ByMove(R x) { + return internal::ByMoveWrapper(std::move(x)); +} + +// Creates an action that returns an element of `vals`. Calling this action will +// repeatedly return the next value from `vals` until it reaches the end and +// will restart from the beginning. +template +internal::ReturnRoundRobinAction ReturnRoundRobin(std::vector vals) { + return internal::ReturnRoundRobinAction(std::move(vals)); +} + +// Creates an action that returns an element of `vals`. Calling this action will +// repeatedly return the next value from `vals` until it reaches the end and +// will restart from the beginning. +template +internal::ReturnRoundRobinAction ReturnRoundRobin( + std::initializer_list vals) { + return internal::ReturnRoundRobinAction(std::vector(vals)); +} + +// Creates an action that does the default action for the give mock function. +inline internal::DoDefaultAction DoDefault() { + return internal::DoDefaultAction(); +} + +// Creates an action that sets the variable pointed by the N-th +// (0-based) function argument to 'value'. +template +internal::SetArgumentPointeeAction SetArgPointee(T value) { + return {std::move(value)}; +} + +// The following version is DEPRECATED. +template +internal::SetArgumentPointeeAction SetArgumentPointee(T value) { + return {std::move(value)}; +} + +// Creates an action that sets a pointer referent to a given value. +template +PolymorphicAction > Assign(T1* ptr, T2 val) { + return MakePolymorphicAction(internal::AssignAction(ptr, val)); +} + +#if !GTEST_OS_WINDOWS_MOBILE + +// Creates an action that sets errno and returns the appropriate error. +template +PolymorphicAction > +SetErrnoAndReturn(int errval, T result) { + return MakePolymorphicAction( + internal::SetErrnoAndReturnAction(errval, result)); +} + +#endif // !GTEST_OS_WINDOWS_MOBILE + +// Various overloads for Invoke(). + +// Legacy function. +// Actions can now be implicitly constructed from callables. No need to create +// wrapper objects. +// This function exists for backwards compatibility. +template +typename std::decay::type Invoke(FunctionImpl&& function_impl) { + return std::forward(function_impl); +} + +// Creates an action that invokes the given method on the given object +// with the mock function's arguments. +template +internal::InvokeMethodAction Invoke(Class* obj_ptr, + MethodPtr method_ptr) { + return {obj_ptr, method_ptr}; +} + +// Creates an action that invokes 'function_impl' with no argument. +template +internal::InvokeWithoutArgsAction::type> +InvokeWithoutArgs(FunctionImpl function_impl) { + return {std::move(function_impl)}; +} + +// Creates an action that invokes the given method on the given object +// with no argument. +template +internal::InvokeMethodWithoutArgsAction InvokeWithoutArgs( + Class* obj_ptr, MethodPtr method_ptr) { + return {obj_ptr, method_ptr}; +} + +// Creates an action that performs an_action and throws away its +// result. In other words, it changes the return type of an_action to +// void. an_action MUST NOT return void, or the code won't compile. +template +inline internal::IgnoreResultAction IgnoreResult(const A& an_action) { + return internal::IgnoreResultAction(an_action); +} + +// Creates a reference wrapper for the given L-value. If necessary, +// you can explicitly specify the type of the reference. For example, +// suppose 'derived' is an object of type Derived, ByRef(derived) +// would wrap a Derived&. If you want to wrap a const Base& instead, +// where Base is a base class of Derived, just write: +// +// ByRef(derived) +// +// N.B. ByRef is redundant with std::ref, std::cref and std::reference_wrapper. +// However, it may still be used for consistency with ByMove(). +template +inline ::std::reference_wrapper ByRef(T& l_value) { // NOLINT + return ::std::reference_wrapper(l_value); +} + +// The ReturnNew(a1, a2, ..., a_k) action returns a pointer to a new +// instance of type T, constructed on the heap with constructor arguments +// a1, a2, ..., and a_k. The caller assumes ownership of the returned value. +template +internal::ReturnNewAction::type...> ReturnNew( + Params&&... params) { + return {std::forward_as_tuple(std::forward(params)...)}; +} + +// Action ReturnArg() returns the k-th argument of the mock function. +template +internal::ReturnArgAction ReturnArg() { + return {}; +} + +// Action SaveArg(pointer) saves the k-th (0-based) argument of the +// mock function to *pointer. +template +internal::SaveArgAction SaveArg(Ptr pointer) { + return {pointer}; +} + +// Action SaveArgPointee(pointer) saves the value pointed to +// by the k-th (0-based) argument of the mock function to *pointer. +template +internal::SaveArgPointeeAction SaveArgPointee(Ptr pointer) { + return {pointer}; +} + +// Action SetArgReferee(value) assigns 'value' to the variable +// referenced by the k-th (0-based) argument of the mock function. +template +internal::SetArgRefereeAction::type> SetArgReferee( + T&& value) { + return {std::forward(value)}; +} + +// Action SetArrayArgument(first, last) copies the elements in +// source range [first, last) to the array pointed to by the k-th +// (0-based) argument, which can be either a pointer or an +// iterator. The action does not take ownership of the elements in the +// source range. +template +internal::SetArrayArgumentAction SetArrayArgument(I1 first, + I2 last) { + return {first, last}; +} + +// Action DeleteArg() deletes the k-th (0-based) argument of the mock +// function. +template +internal::DeleteArgAction DeleteArg() { + return {}; +} + +// This action returns the value pointed to by 'pointer'. +template +internal::ReturnPointeeAction ReturnPointee(Ptr pointer) { + return {pointer}; +} + +// Action Throw(exception) can be used in a mock function of any type +// to throw the given exception. Any copyable value can be thrown. +#if GTEST_HAS_EXCEPTIONS +template +internal::ThrowAction::type> Throw(T&& exception) { + return {std::forward(exception)}; +} +#endif // GTEST_HAS_EXCEPTIONS + +namespace internal { + +// A macro from the ACTION* family (defined later in gmock-generated-actions.h) +// defines an action that can be used in a mock function. Typically, +// these actions only care about a subset of the arguments of the mock +// function. For example, if such an action only uses the second +// argument, it can be used in any mock function that takes >= 2 +// arguments where the type of the second argument is compatible. +// +// Therefore, the action implementation must be prepared to take more +// arguments than it needs. The ExcessiveArg type is used to +// represent those excessive arguments. In order to keep the compiler +// error messages tractable, we define it in the testing namespace +// instead of testing::internal. However, this is an INTERNAL TYPE +// and subject to change without notice, so a user MUST NOT USE THIS +// TYPE DIRECTLY. +struct ExcessiveArg {}; + +// Builds an implementation of an Action<> for some particular signature, using +// a class defined by an ACTION* macro. +template struct ActionImpl; + +template +struct ImplBase { + struct Holder { + // Allows each copy of the Action<> to get to the Impl. + explicit operator const Impl&() const { return *ptr; } + std::shared_ptr ptr; + }; + using type = typename std::conditional::value, + Impl, Holder>::type; +}; + +template +struct ActionImpl : ImplBase::type { + using Base = typename ImplBase::type; + using function_type = R(Args...); + using args_type = std::tuple; + + ActionImpl() = default; // Only defined if appropriate for Base. + explicit ActionImpl(std::shared_ptr impl) : Base{std::move(impl)} { } + + R operator()(Args&&... arg) const { + static constexpr size_t kMaxArgs = + sizeof...(Args) <= 10 ? sizeof...(Args) : 10; + return Apply(MakeIndexSequence{}, + MakeIndexSequence<10 - kMaxArgs>{}, + args_type{std::forward(arg)...}); + } + + template + R Apply(IndexSequence, IndexSequence, + const args_type& args) const { + // Impl need not be specific to the signature of action being implemented; + // only the implementing function body needs to have all of the specific + // types instantiated. Up to 10 of the args that are provided by the + // args_type get passed, followed by a dummy of unspecified type for the + // remainder up to 10 explicit args. + static constexpr ExcessiveArg kExcessArg{}; + return static_cast(*this).template gmock_PerformImpl< + /*function_type=*/function_type, /*return_type=*/R, + /*args_type=*/args_type, + /*argN_type=*/typename std::tuple_element::type...>( + /*args=*/args, std::get(args)..., + ((void)excess_id, kExcessArg)...); + } +}; + +// Stores a default-constructed Impl as part of the Action<>'s +// std::function<>. The Impl should be trivial to copy. +template +::testing::Action MakeAction() { + return ::testing::Action(ActionImpl()); +} + +// Stores just the one given instance of Impl. +template +::testing::Action MakeAction(std::shared_ptr impl) { + return ::testing::Action(ActionImpl(std::move(impl))); +} + +#define GMOCK_INTERNAL_ARG_UNUSED(i, data, el) \ + , const arg##i##_type& arg##i GTEST_ATTRIBUTE_UNUSED_ +#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_ \ + const args_type& args GTEST_ATTRIBUTE_UNUSED_ GMOCK_PP_REPEAT( \ + GMOCK_INTERNAL_ARG_UNUSED, , 10) + +#define GMOCK_INTERNAL_ARG(i, data, el) , const arg##i##_type& arg##i +#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_ \ + const args_type& args GMOCK_PP_REPEAT(GMOCK_INTERNAL_ARG, , 10) + +#define GMOCK_INTERNAL_TEMPLATE_ARG(i, data, el) , typename arg##i##_type +#define GMOCK_ACTION_TEMPLATE_ARGS_NAMES_ \ + GMOCK_PP_TAIL(GMOCK_PP_REPEAT(GMOCK_INTERNAL_TEMPLATE_ARG, , 10)) + +#define GMOCK_INTERNAL_TYPENAME_PARAM(i, data, param) , typename param##_type +#define GMOCK_ACTION_TYPENAME_PARAMS_(params) \ + GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPENAME_PARAM, , params)) + +#define GMOCK_INTERNAL_TYPE_PARAM(i, data, param) , param##_type +#define GMOCK_ACTION_TYPE_PARAMS_(params) \ + GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_PARAM, , params)) + +#define GMOCK_INTERNAL_TYPE_GVALUE_PARAM(i, data, param) \ + , param##_type gmock_p##i +#define GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params) \ + GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_GVALUE_PARAM, , params)) + +#define GMOCK_INTERNAL_GVALUE_PARAM(i, data, param) \ + , std::forward(gmock_p##i) +#define GMOCK_ACTION_GVALUE_PARAMS_(params) \ + GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GVALUE_PARAM, , params)) + +#define GMOCK_INTERNAL_INIT_PARAM(i, data, param) \ + , param(::std::forward(gmock_p##i)) +#define GMOCK_ACTION_INIT_PARAMS_(params) \ + GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_INIT_PARAM, , params)) + +#define GMOCK_INTERNAL_FIELD_PARAM(i, data, param) param##_type param; +#define GMOCK_ACTION_FIELD_PARAMS_(params) \ + GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_FIELD_PARAM, , params) + +#define GMOCK_INTERNAL_ACTION(name, full_name, params) \ + template \ + class full_name { \ + public: \ + explicit full_name(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) \ + : impl_(std::make_shared( \ + GMOCK_ACTION_GVALUE_PARAMS_(params))) { } \ + full_name(const full_name&) = default; \ + full_name(full_name&&) noexcept = default; \ + template \ + operator ::testing::Action() const { \ + return ::testing::internal::MakeAction(impl_); \ + } \ + private: \ + class gmock_Impl { \ + public: \ + explicit gmock_Impl(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) \ + : GMOCK_ACTION_INIT_PARAMS_(params) {} \ + template \ + return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \ + GMOCK_ACTION_FIELD_PARAMS_(params) \ + }; \ + std::shared_ptr impl_; \ + }; \ + template \ + inline full_name name( \ + GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) { \ + return full_name( \ + GMOCK_ACTION_GVALUE_PARAMS_(params)); \ + } \ + template \ + template \ + return_type full_name::gmock_Impl:: \ + gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const + +} // namespace internal + +// Similar to GMOCK_INTERNAL_ACTION, but no bound parameters are stored. +#define ACTION(name) \ + class name##Action { \ + public: \ + explicit name##Action() noexcept {} \ + name##Action(const name##Action&) noexcept {} \ + template \ + operator ::testing::Action() const { \ + return ::testing::internal::MakeAction(); \ + } \ + private: \ + class gmock_Impl { \ + public: \ + template \ + return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \ + }; \ + }; \ + inline name##Action name() GTEST_MUST_USE_RESULT_; \ + inline name##Action name() { return name##Action(); } \ + template \ + return_type name##Action::gmock_Impl::gmock_PerformImpl( \ + GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const + +#define ACTION_P(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP, (__VA_ARGS__)) + +#define ACTION_P2(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP2, (__VA_ARGS__)) + +#define ACTION_P3(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP3, (__VA_ARGS__)) + +#define ACTION_P4(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP4, (__VA_ARGS__)) + +#define ACTION_P5(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP5, (__VA_ARGS__)) + +#define ACTION_P6(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP6, (__VA_ARGS__)) + +#define ACTION_P7(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP7, (__VA_ARGS__)) + +#define ACTION_P8(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP8, (__VA_ARGS__)) + +#define ACTION_P9(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP9, (__VA_ARGS__)) + +#define ACTION_P10(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP10, (__VA_ARGS__)) + +} // namespace testing + +#ifdef _MSC_VER +# pragma warning(pop) +#endif + +#endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ diff --git a/miniconda3/pkgs/yaml-cpp-0.8.0-h6a678d5_1/include/gmock/gmock-cardinalities.h b/miniconda3/pkgs/yaml-cpp-0.8.0-h6a678d5_1/include/gmock/gmock-cardinalities.h new file mode 100644 index 0000000000000000000000000000000000000000..fc7f803a7a6515c21e3fbf9b505b0a76e8b9c670 --- /dev/null +++ b/miniconda3/pkgs/yaml-cpp-0.8.0-h6a678d5_1/include/gmock/gmock-cardinalities.h @@ -0,0 +1,157 @@ +// Copyright 2007, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +// Google Mock - a framework for writing C++ mock classes. +// +// This file implements some commonly used cardinalities. More +// cardinalities can be defined by the user implementing the +// CardinalityInterface interface if necessary. + +// GOOGLETEST_CM0002 DO NOT DELETE + +#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_ +#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_ + +#include +#include +#include // NOLINT +#include "gmock/internal/gmock-port.h" +#include "gtest/gtest.h" + +GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \ +/* class A needs to have dll-interface to be used by clients of class B */) + +namespace testing { + +// To implement a cardinality Foo, define: +// 1. a class FooCardinality that implements the +// CardinalityInterface interface, and +// 2. a factory function that creates a Cardinality object from a +// const FooCardinality*. +// +// The two-level delegation design follows that of Matcher, providing +// consistency for extension developers. It also eases ownership +// management as Cardinality objects can now be copied like plain values. + +// The implementation of a cardinality. +class CardinalityInterface { + public: + virtual ~CardinalityInterface() {} + + // Conservative estimate on the lower/upper bound of the number of + // calls allowed. + virtual int ConservativeLowerBound() const { return 0; } + virtual int ConservativeUpperBound() const { return INT_MAX; } + + // Returns true if and only if call_count calls will satisfy this + // cardinality. + virtual bool IsSatisfiedByCallCount(int call_count) const = 0; + + // Returns true if and only if call_count calls will saturate this + // cardinality. + virtual bool IsSaturatedByCallCount(int call_count) const = 0; + + // Describes self to an ostream. + virtual void DescribeTo(::std::ostream* os) const = 0; +}; + +// A Cardinality is a copyable and IMMUTABLE (except by assignment) +// object that specifies how many times a mock function is expected to +// be called. The implementation of Cardinality is just a std::shared_ptr +// to const CardinalityInterface. Don't inherit from Cardinality! +class GTEST_API_ Cardinality { + public: + // Constructs a null cardinality. Needed for storing Cardinality + // objects in STL containers. + Cardinality() {} + + // Constructs a Cardinality from its implementation. + explicit Cardinality(const CardinalityInterface* impl) : impl_(impl) {} + + // Conservative estimate on the lower/upper bound of the number of + // calls allowed. + int ConservativeLowerBound() const { return impl_->ConservativeLowerBound(); } + int ConservativeUpperBound() const { return impl_->ConservativeUpperBound(); } + + // Returns true if and only if call_count calls will satisfy this + // cardinality. + bool IsSatisfiedByCallCount(int call_count) const { + return impl_->IsSatisfiedByCallCount(call_count); + } + + // Returns true if and only if call_count calls will saturate this + // cardinality. + bool IsSaturatedByCallCount(int call_count) const { + return impl_->IsSaturatedByCallCount(call_count); + } + + // Returns true if and only if call_count calls will over-saturate this + // cardinality, i.e. exceed the maximum number of allowed calls. + bool IsOverSaturatedByCallCount(int call_count) const { + return impl_->IsSaturatedByCallCount(call_count) && + !impl_->IsSatisfiedByCallCount(call_count); + } + + // Describes self to an ostream + void DescribeTo(::std::ostream* os) const { impl_->DescribeTo(os); } + + // Describes the given actual call count to an ostream. + static void DescribeActualCallCountTo(int actual_call_count, + ::std::ostream* os); + + private: + std::shared_ptr impl_; +}; + +// Creates a cardinality that allows at least n calls. +GTEST_API_ Cardinality AtLeast(int n); + +// Creates a cardinality that allows at most n calls. +GTEST_API_ Cardinality AtMost(int n); + +// Creates a cardinality that allows any number of calls. +GTEST_API_ Cardinality AnyNumber(); + +// Creates a cardinality that allows between min and max calls. +GTEST_API_ Cardinality Between(int min, int max); + +// Creates a cardinality that allows exactly n calls. +GTEST_API_ Cardinality Exactly(int n); + +// Creates a cardinality from its implementation. +inline Cardinality MakeCardinality(const CardinalityInterface* c) { + return Cardinality(c); +} + +} // namespace testing + +GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 + +#endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_ diff --git a/miniconda3/pkgs/yaml-cpp-0.8.0-h6a678d5_1/include/gmock/gmock-function-mocker.h b/miniconda3/pkgs/yaml-cpp-0.8.0-h6a678d5_1/include/gmock/gmock-function-mocker.h new file mode 100644 index 0000000000000000000000000000000000000000..0fc6f6f3f13ccdaf94a4d055783879a57dcf8dc5 --- /dev/null +++ b/miniconda3/pkgs/yaml-cpp-0.8.0-h6a678d5_1/include/gmock/gmock-function-mocker.h @@ -0,0 +1,479 @@ +// Copyright 2007, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Google Mock - a framework for writing C++ mock classes. +// +// This file implements MOCK_METHOD. + +// GOOGLETEST_CM0002 DO NOT DELETE + +#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_ // NOLINT +#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_ // NOLINT + +#include // IWYU pragma: keep +#include // IWYU pragma: keep + +#include "gmock/gmock-spec-builders.h" +#include "gmock/internal/gmock-internal-utils.h" +#include "gmock/internal/gmock-pp.h" + +namespace testing { +namespace internal { +template +using identity_t = T; + +template +struct ThisRefAdjuster { + template + using AdjustT = typename std::conditional< + std::is_const::type>::value, + typename std::conditional::value, + const T&, const T&&>::type, + typename std::conditional::value, T&, + T&&>::type>::type; + + template + static AdjustT Adjust(const MockType& mock) { + return static_cast>(const_cast(mock)); + } +}; + +} // namespace internal + +// The style guide prohibits "using" statements in a namespace scope +// inside a header file. However, the FunctionMocker class template +// is meant to be defined in the ::testing namespace. The following +// line is just a trick for working around a bug in MSVC 8.0, which +// cannot handle it if we define FunctionMocker in ::testing. +using internal::FunctionMocker; +} // namespace testing + +#define MOCK_METHOD(...) \ + GMOCK_PP_VARIADIC_CALL(GMOCK_INTERNAL_MOCK_METHOD_ARG_, __VA_ARGS__) + +#define GMOCK_INTERNAL_MOCK_METHOD_ARG_1(...) \ + GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) + +#define GMOCK_INTERNAL_MOCK_METHOD_ARG_2(...) \ + GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) + +#define GMOCK_INTERNAL_MOCK_METHOD_ARG_3(_Ret, _MethodName, _Args) \ + GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, ()) + +#define GMOCK_INTERNAL_MOCK_METHOD_ARG_4(_Ret, _MethodName, _Args, _Spec) \ + GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Args); \ + GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Spec); \ + GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE( \ + GMOCK_PP_NARG0 _Args, GMOCK_INTERNAL_SIGNATURE(_Ret, _Args)); \ + GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec) \ + GMOCK_INTERNAL_MOCK_METHOD_IMPL( \ + GMOCK_PP_NARG0 _Args, _MethodName, GMOCK_INTERNAL_HAS_CONST(_Spec), \ + GMOCK_INTERNAL_HAS_OVERRIDE(_Spec), GMOCK_INTERNAL_HAS_FINAL(_Spec), \ + GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Spec), \ + GMOCK_INTERNAL_GET_CALLTYPE(_Spec), GMOCK_INTERNAL_GET_REF_SPEC(_Spec), \ + (GMOCK_INTERNAL_SIGNATURE(_Ret, _Args))) + +#define GMOCK_INTERNAL_MOCK_METHOD_ARG_5(...) \ + GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) + +#define GMOCK_INTERNAL_MOCK_METHOD_ARG_6(...) \ + GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) + +#define GMOCK_INTERNAL_MOCK_METHOD_ARG_7(...) \ + GMOCK_INTERNAL_WRONG_ARITY(__VA_ARGS__) + +#define GMOCK_INTERNAL_WRONG_ARITY(...) \ + static_assert( \ + false, \ + "MOCK_METHOD must be called with 3 or 4 arguments. _Ret, " \ + "_MethodName, _Args and optionally _Spec. _Args and _Spec must be " \ + "enclosed in parentheses. If _Ret is a type with unprotected commas, " \ + "it must also be enclosed in parentheses.") + +#define GMOCK_INTERNAL_ASSERT_PARENTHESIS(_Tuple) \ + static_assert( \ + GMOCK_PP_IS_ENCLOSED_PARENS(_Tuple), \ + GMOCK_PP_STRINGIZE(_Tuple) " should be enclosed in parentheses.") + +#define GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE(_N, ...) \ + static_assert( \ + std::is_function<__VA_ARGS__>::value, \ + "Signature must be a function type, maybe return type contains " \ + "unprotected comma."); \ + static_assert( \ + ::testing::tuple_size::ArgumentTuple>::value == _N, \ + "This method does not take " GMOCK_PP_STRINGIZE( \ + _N) " arguments. Parenthesize all types with unprotected commas.") + +#define GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec) \ + GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT, ~, _Spec) + +#define GMOCK_INTERNAL_MOCK_METHOD_IMPL(_N, _MethodName, _Constness, \ + _Override, _Final, _NoexceptSpec, \ + _CallType, _RefSpec, _Signature) \ + typename ::testing::internal::Function::Result \ + GMOCK_INTERNAL_EXPAND(_CallType) \ + _MethodName(GMOCK_PP_REPEAT(GMOCK_INTERNAL_PARAMETER, _Signature, _N)) \ + GMOCK_PP_IF(_Constness, const, ) _RefSpec _NoexceptSpec \ + GMOCK_PP_IF(_Override, override, ) GMOCK_PP_IF(_Final, final, ) { \ + GMOCK_MOCKER_(_N, _Constness, _MethodName) \ + .SetOwnerAndName(this, #_MethodName); \ + return GMOCK_MOCKER_(_N, _Constness, _MethodName) \ + .Invoke(GMOCK_PP_REPEAT(GMOCK_INTERNAL_FORWARD_ARG, _Signature, _N)); \ + } \ + ::testing::MockSpec gmock_##_MethodName( \ + GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_PARAMETER, _Signature, _N)) \ + GMOCK_PP_IF(_Constness, const, ) _RefSpec { \ + GMOCK_MOCKER_(_N, _Constness, _MethodName).RegisterOwner(this); \ + return GMOCK_MOCKER_(_N, _Constness, _MethodName) \ + .With(GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_ARGUMENT, , _N)); \ + } \ + ::testing::MockSpec gmock_##_MethodName( \ + const ::testing::internal::WithoutMatchers&, \ + GMOCK_PP_IF(_Constness, const, )::testing::internal::Function< \ + GMOCK_PP_REMOVE_PARENS(_Signature)>*) const _RefSpec _NoexceptSpec { \ + return ::testing::internal::ThisRefAdjuster::Adjust(*this) \ + .gmock_##_MethodName(GMOCK_PP_REPEAT( \ + GMOCK_INTERNAL_A_MATCHER_ARGUMENT, _Signature, _N)); \ + } \ + mutable ::testing::FunctionMocker \ + GMOCK_MOCKER_(_N, _Constness, _MethodName) + +#define GMOCK_INTERNAL_EXPAND(...) __VA_ARGS__ + +// Five Valid modifiers. +#define GMOCK_INTERNAL_HAS_CONST(_Tuple) \ + GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_CONST, ~, _Tuple)) + +#define GMOCK_INTERNAL_HAS_OVERRIDE(_Tuple) \ + GMOCK_PP_HAS_COMMA( \ + GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_OVERRIDE, ~, _Tuple)) + +#define GMOCK_INTERNAL_HAS_FINAL(_Tuple) \ + GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_FINAL, ~, _Tuple)) + +#define GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Tuple) \ + GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_NOEXCEPT_SPEC_IF_NOEXCEPT, ~, _Tuple) + +#define GMOCK_INTERNAL_NOEXCEPT_SPEC_IF_NOEXCEPT(_i, _, _elem) \ + GMOCK_PP_IF( \ + GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)), \ + _elem, ) + +#define GMOCK_INTERNAL_GET_REF_SPEC(_Tuple) \ + GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_REF_SPEC_IF_REF, ~, _Tuple) + +#define GMOCK_INTERNAL_REF_SPEC_IF_REF(_i, _, _elem) \ + GMOCK_PP_IF(GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)), \ + GMOCK_PP_CAT(GMOCK_INTERNAL_UNPACK_, _elem), ) + +#define GMOCK_INTERNAL_GET_CALLTYPE(_Tuple) \ + GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_CALLTYPE_IMPL, ~, _Tuple) + +#define GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT(_i, _, _elem) \ + static_assert( \ + (GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem)) + \ + GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem)) + \ + GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem)) + \ + GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)) + \ + GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)) + \ + GMOCK_INTERNAL_IS_CALLTYPE(_elem)) == 1, \ + GMOCK_PP_STRINGIZE( \ + _elem) " cannot be recognized as a valid specification modifier."); + +// Modifiers implementation. +#define GMOCK_INTERNAL_DETECT_CONST(_i, _, _elem) \ + GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_CONST_I_, _elem) + +#define GMOCK_INTERNAL_DETECT_CONST_I_const , + +#define GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem) \ + GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_OVERRIDE_I_, _elem) + +#define GMOCK_INTERNAL_DETECT_OVERRIDE_I_override , + +#define GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem) \ + GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_FINAL_I_, _elem) + +#define GMOCK_INTERNAL_DETECT_FINAL_I_final , + +#define GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem) \ + GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_NOEXCEPT_I_, _elem) + +#define GMOCK_INTERNAL_DETECT_NOEXCEPT_I_noexcept , + +#define GMOCK_INTERNAL_DETECT_REF(_i, _, _elem) \ + GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_REF_I_, _elem) + +#define GMOCK_INTERNAL_DETECT_REF_I_ref , + +#define GMOCK_INTERNAL_UNPACK_ref(x) x + +#define GMOCK_INTERNAL_GET_CALLTYPE_IMPL(_i, _, _elem) \ + GMOCK_PP_IF(GMOCK_INTERNAL_IS_CALLTYPE(_elem), \ + GMOCK_INTERNAL_GET_VALUE_CALLTYPE, GMOCK_PP_EMPTY) \ + (_elem) + +// TODO(iserna): GMOCK_INTERNAL_IS_CALLTYPE and +// GMOCK_INTERNAL_GET_VALUE_CALLTYPE needed more expansions to work on windows +// maybe they can be simplified somehow. +#define GMOCK_INTERNAL_IS_CALLTYPE(_arg) \ + GMOCK_INTERNAL_IS_CALLTYPE_I( \ + GMOCK_PP_CAT(GMOCK_INTERNAL_IS_CALLTYPE_HELPER_, _arg)) +#define GMOCK_INTERNAL_IS_CALLTYPE_I(_arg) GMOCK_PP_IS_ENCLOSED_PARENS(_arg) + +#define GMOCK_INTERNAL_GET_VALUE_CALLTYPE(_arg) \ + GMOCK_INTERNAL_GET_VALUE_CALLTYPE_I( \ + GMOCK_PP_CAT(GMOCK_INTERNAL_IS_CALLTYPE_HELPER_, _arg)) +#define GMOCK_INTERNAL_GET_VALUE_CALLTYPE_I(_arg) \ + GMOCK_PP_IDENTITY _arg + +#define GMOCK_INTERNAL_IS_CALLTYPE_HELPER_Calltype + +// Note: The use of `identity_t` here allows _Ret to represent return types that +// would normally need to be specified in a different way. For example, a method +// returning a function pointer must be written as +// +// fn_ptr_return_t (*method(method_args_t...))(fn_ptr_args_t...) +// +// But we only support placing the return type at the beginning. To handle this, +// we wrap all calls in identity_t, so that a declaration will be expanded to +// +// identity_t method(method_args_t...) +// +// This allows us to work around the syntactic oddities of function/method +// types. +#define GMOCK_INTERNAL_SIGNATURE(_Ret, _Args) \ + ::testing::internal::identity_t( \ + GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_TYPE, _, _Args)) + +#define GMOCK_INTERNAL_GET_TYPE(_i, _, _elem) \ + GMOCK_PP_COMMA_IF(_i) \ + GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_elem), GMOCK_PP_REMOVE_PARENS, \ + GMOCK_PP_IDENTITY) \ + (_elem) + +#define GMOCK_INTERNAL_PARAMETER(_i, _Signature, _) \ + GMOCK_PP_COMMA_IF(_i) \ + GMOCK_INTERNAL_ARG_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \ + gmock_a##_i + +#define GMOCK_INTERNAL_FORWARD_ARG(_i, _Signature, _) \ + GMOCK_PP_COMMA_IF(_i) \ + ::std::forward(gmock_a##_i) + +#define GMOCK_INTERNAL_MATCHER_PARAMETER(_i, _Signature, _) \ + GMOCK_PP_COMMA_IF(_i) \ + GMOCK_INTERNAL_MATCHER_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \ + gmock_a##_i + +#define GMOCK_INTERNAL_MATCHER_ARGUMENT(_i, _1, _2) \ + GMOCK_PP_COMMA_IF(_i) \ + gmock_a##_i + +#define GMOCK_INTERNAL_A_MATCHER_ARGUMENT(_i, _Signature, _) \ + GMOCK_PP_COMMA_IF(_i) \ + ::testing::A() + +#define GMOCK_INTERNAL_ARG_O(_i, ...) \ + typename ::testing::internal::Function<__VA_ARGS__>::template Arg<_i>::type + +#define GMOCK_INTERNAL_MATCHER_O(_i, ...) \ + const ::testing::Matcher::template Arg<_i>::type>& + +#define MOCK_METHOD0(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 0, __VA_ARGS__) +#define MOCK_METHOD1(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 1, __VA_ARGS__) +#define MOCK_METHOD2(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 2, __VA_ARGS__) +#define MOCK_METHOD3(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 3, __VA_ARGS__) +#define MOCK_METHOD4(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 4, __VA_ARGS__) +#define MOCK_METHOD5(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 5, __VA_ARGS__) +#define MOCK_METHOD6(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 6, __VA_ARGS__) +#define MOCK_METHOD7(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 7, __VA_ARGS__) +#define MOCK_METHOD8(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 8, __VA_ARGS__) +#define MOCK_METHOD9(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 9, __VA_ARGS__) +#define MOCK_METHOD10(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, , m, 10, __VA_ARGS__) + +#define MOCK_CONST_METHOD0(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 0, __VA_ARGS__) +#define MOCK_CONST_METHOD1(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 1, __VA_ARGS__) +#define MOCK_CONST_METHOD2(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 2, __VA_ARGS__) +#define MOCK_CONST_METHOD3(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 3, __VA_ARGS__) +#define MOCK_CONST_METHOD4(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 4, __VA_ARGS__) +#define MOCK_CONST_METHOD5(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 5, __VA_ARGS__) +#define MOCK_CONST_METHOD6(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 6, __VA_ARGS__) +#define MOCK_CONST_METHOD7(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 7, __VA_ARGS__) +#define MOCK_CONST_METHOD8(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 8, __VA_ARGS__) +#define MOCK_CONST_METHOD9(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 9, __VA_ARGS__) +#define MOCK_CONST_METHOD10(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 10, __VA_ARGS__) + +#define MOCK_METHOD0_T(m, ...) MOCK_METHOD0(m, __VA_ARGS__) +#define MOCK_METHOD1_T(m, ...) MOCK_METHOD1(m, __VA_ARGS__) +#define MOCK_METHOD2_T(m, ...) MOCK_METHOD2(m, __VA_ARGS__) +#define MOCK_METHOD3_T(m, ...) MOCK_METHOD3(m, __VA_ARGS__) +#define MOCK_METHOD4_T(m, ...) MOCK_METHOD4(m, __VA_ARGS__) +#define MOCK_METHOD5_T(m, ...) MOCK_METHOD5(m, __VA_ARGS__) +#define MOCK_METHOD6_T(m, ...) MOCK_METHOD6(m, __VA_ARGS__) +#define MOCK_METHOD7_T(m, ...) MOCK_METHOD7(m, __VA_ARGS__) +#define MOCK_METHOD8_T(m, ...) MOCK_METHOD8(m, __VA_ARGS__) +#define MOCK_METHOD9_T(m, ...) MOCK_METHOD9(m, __VA_ARGS__) +#define MOCK_METHOD10_T(m, ...) MOCK_METHOD10(m, __VA_ARGS__) + +#define MOCK_CONST_METHOD0_T(m, ...) MOCK_CONST_METHOD0(m, __VA_ARGS__) +#define MOCK_CONST_METHOD1_T(m, ...) MOCK_CONST_METHOD1(m, __VA_ARGS__) +#define MOCK_CONST_METHOD2_T(m, ...) MOCK_CONST_METHOD2(m, __VA_ARGS__) +#define MOCK_CONST_METHOD3_T(m, ...) MOCK_CONST_METHOD3(m, __VA_ARGS__) +#define MOCK_CONST_METHOD4_T(m, ...) MOCK_CONST_METHOD4(m, __VA_ARGS__) +#define MOCK_CONST_METHOD5_T(m, ...) MOCK_CONST_METHOD5(m, __VA_ARGS__) +#define MOCK_CONST_METHOD6_T(m, ...) MOCK_CONST_METHOD6(m, __VA_ARGS__) +#define MOCK_CONST_METHOD7_T(m, ...) MOCK_CONST_METHOD7(m, __VA_ARGS__) +#define MOCK_CONST_METHOD8_T(m, ...) MOCK_CONST_METHOD8(m, __VA_ARGS__) +#define MOCK_CONST_METHOD9_T(m, ...) MOCK_CONST_METHOD9(m, __VA_ARGS__) +#define MOCK_CONST_METHOD10_T(m, ...) MOCK_CONST_METHOD10(m, __VA_ARGS__) + +#define MOCK_METHOD0_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 0, __VA_ARGS__) +#define MOCK_METHOD1_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 1, __VA_ARGS__) +#define MOCK_METHOD2_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 2, __VA_ARGS__) +#define MOCK_METHOD3_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 3, __VA_ARGS__) +#define MOCK_METHOD4_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 4, __VA_ARGS__) +#define MOCK_METHOD5_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 5, __VA_ARGS__) +#define MOCK_METHOD6_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 6, __VA_ARGS__) +#define MOCK_METHOD7_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 7, __VA_ARGS__) +#define MOCK_METHOD8_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 8, __VA_ARGS__) +#define MOCK_METHOD9_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 9, __VA_ARGS__) +#define MOCK_METHOD10_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 10, __VA_ARGS__) + +#define MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 0, __VA_ARGS__) +#define MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 1, __VA_ARGS__) +#define MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 2, __VA_ARGS__) +#define MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 3, __VA_ARGS__) +#define MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 4, __VA_ARGS__) +#define MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 5, __VA_ARGS__) +#define MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 6, __VA_ARGS__) +#define MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 7, __VA_ARGS__) +#define MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 8, __VA_ARGS__) +#define MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 9, __VA_ARGS__) +#define MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 10, __VA_ARGS__) + +#define MOCK_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__) + +#define MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__) + +#define GMOCK_INTERNAL_MOCK_METHODN(constness, ct, Method, args_num, ...) \ + GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE( \ + args_num, ::testing::internal::identity_t<__VA_ARGS__>); \ + GMOCK_INTERNAL_MOCK_METHOD_IMPL( \ + args_num, Method, GMOCK_PP_NARG0(constness), 0, 0, , ct, , \ + (::testing::internal::identity_t<__VA_ARGS__>)) + +#define GMOCK_MOCKER_(arity, constness, Method) \ + GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__) + +#endif // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_ diff --git a/miniconda3/pkgs/yaml-cpp-0.8.0-h6a678d5_1/include/gmock/gmock-matchers.h b/miniconda3/pkgs/yaml-cpp-0.8.0-h6a678d5_1/include/gmock/gmock-matchers.h new file mode 100644 index 0000000000000000000000000000000000000000..86be9c176ebcaf8e8e373626d851f4be2f4687c9 --- /dev/null +++ b/miniconda3/pkgs/yaml-cpp-0.8.0-h6a678d5_1/include/gmock/gmock-matchers.h @@ -0,0 +1,5392 @@ +// Copyright 2007, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +// Google Mock - a framework for writing C++ mock classes. +// +// The MATCHER* family of macros can be used in a namespace scope to +// define custom matchers easily. +// +// Basic Usage +// =========== +// +// The syntax +// +// MATCHER(name, description_string) { statements; } +// +// defines a matcher with the given name that executes the statements, +// which must return a bool to indicate if the match succeeds. Inside +// the statements, you can refer to the value being matched by 'arg', +// and refer to its type by 'arg_type'. +// +// The description string documents what the matcher does, and is used +// to generate the failure message when the match fails. Since a +// MATCHER() is usually defined in a header file shared by multiple +// C++ source files, we require the description to be a C-string +// literal to avoid possible side effects. It can be empty, in which +// case we'll use the sequence of words in the matcher name as the +// description. +// +// For example: +// +// MATCHER(IsEven, "") { return (arg % 2) == 0; } +// +// allows you to write +// +// // Expects mock_foo.Bar(n) to be called where n is even. +// EXPECT_CALL(mock_foo, Bar(IsEven())); +// +// or, +// +// // Verifies that the value of some_expression is even. +// EXPECT_THAT(some_expression, IsEven()); +// +// If the above assertion fails, it will print something like: +// +// Value of: some_expression +// Expected: is even +// Actual: 7 +// +// where the description "is even" is automatically calculated from the +// matcher name IsEven. +// +// Argument Type +// ============= +// +// Note that the type of the value being matched (arg_type) is +// determined by the context in which you use the matcher and is +// supplied to you by the compiler, so you don't need to worry about +// declaring it (nor can you). This allows the matcher to be +// polymorphic. For example, IsEven() can be used to match any type +// where the value of "(arg % 2) == 0" can be implicitly converted to +// a bool. In the "Bar(IsEven())" example above, if method Bar() +// takes an int, 'arg_type' will be int; if it takes an unsigned long, +// 'arg_type' will be unsigned long; and so on. +// +// Parameterizing Matchers +// ======================= +// +// Sometimes you'll want to parameterize the matcher. For that you +// can use another macro: +// +// MATCHER_P(name, param_name, description_string) { statements; } +// +// For example: +// +// MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; } +// +// will allow you to write: +// +// EXPECT_THAT(Blah("a"), HasAbsoluteValue(n)); +// +// which may lead to this message (assuming n is 10): +// +// Value of: Blah("a") +// Expected: has absolute value 10 +// Actual: -9 +// +// Note that both the matcher description and its parameter are +// printed, making the message human-friendly. +// +// In the matcher definition body, you can write 'foo_type' to +// reference the type of a parameter named 'foo'. For example, in the +// body of MATCHER_P(HasAbsoluteValue, value) above, you can write +// 'value_type' to refer to the type of 'value'. +// +// We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P$n to +// support multi-parameter matchers. +// +// Describing Parameterized Matchers +// ================================= +// +// The last argument to MATCHER*() is a string-typed expression. The +// expression can reference all of the matcher's parameters and a +// special bool-typed variable named 'negation'. When 'negation' is +// false, the expression should evaluate to the matcher's description; +// otherwise it should evaluate to the description of the negation of +// the matcher. For example, +// +// using testing::PrintToString; +// +// MATCHER_P2(InClosedRange, low, hi, +// std::string(negation ? "is not" : "is") + " in range [" + +// PrintToString(low) + ", " + PrintToString(hi) + "]") { +// return low <= arg && arg <= hi; +// } +// ... +// EXPECT_THAT(3, InClosedRange(4, 6)); +// EXPECT_THAT(3, Not(InClosedRange(2, 4))); +// +// would generate two failures that contain the text: +// +// Expected: is in range [4, 6] +// ... +// Expected: is not in range [2, 4] +// +// If you specify "" as the description, the failure message will +// contain the sequence of words in the matcher name followed by the +// parameter values printed as a tuple. For example, +// +// MATCHER_P2(InClosedRange, low, hi, "") { ... } +// ... +// EXPECT_THAT(3, InClosedRange(4, 6)); +// EXPECT_THAT(3, Not(InClosedRange(2, 4))); +// +// would generate two failures that contain the text: +// +// Expected: in closed range (4, 6) +// ... +// Expected: not (in closed range (2, 4)) +// +// Types of Matcher Parameters +// =========================== +// +// For the purpose of typing, you can view +// +// MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... } +// +// as shorthand for +// +// template +// FooMatcherPk +// Foo(p1_type p1, ..., pk_type pk) { ... } +// +// When you write Foo(v1, ..., vk), the compiler infers the types of +// the parameters v1, ..., and vk for you. If you are not happy with +// the result of the type inference, you can specify the types by +// explicitly instantiating the template, as in Foo(5, +// false). As said earlier, you don't get to (or need to) specify +// 'arg_type' as that's determined by the context in which the matcher +// is used. You can assign the result of expression Foo(p1, ..., pk) +// to a variable of type FooMatcherPk. This +// can be useful when composing matchers. +// +// While you can instantiate a matcher template with reference types, +// passing the parameters by pointer usually makes your code more +// readable. If, however, you still want to pass a parameter by +// reference, be aware that in the failure message generated by the +// matcher you will see the value of the referenced object but not its +// address. +// +// Explaining Match Results +// ======================== +// +// Sometimes the matcher description alone isn't enough to explain why +// the match has failed or succeeded. For example, when expecting a +// long string, it can be very helpful to also print the diff between +// the expected string and the actual one. To achieve that, you can +// optionally stream additional information to a special variable +// named result_listener, whose type is a pointer to class +// MatchResultListener: +// +// MATCHER_P(EqualsLongString, str, "") { +// if (arg == str) return true; +// +// *result_listener << "the difference: " +/// << DiffStrings(str, arg); +// return false; +// } +// +// Overloading Matchers +// ==================== +// +// You can overload matchers with different numbers of parameters: +// +// MATCHER_P(Blah, a, description_string1) { ... } +// MATCHER_P2(Blah, a, b, description_string2) { ... } +// +// Caveats +// ======= +// +// When defining a new matcher, you should also consider implementing +// MatcherInterface or using MakePolymorphicMatcher(). These +// approaches require more work than the MATCHER* macros, but also +// give you more control on the types of the value being matched and +// the matcher parameters, which may leads to better compiler error +// messages when the matcher is used wrong. They also allow +// overloading matchers based on parameter types (as opposed to just +// based on the number of parameters). +// +// MATCHER*() can only be used in a namespace scope as templates cannot be +// declared inside of a local class. +// +// More Information +// ================ +// +// To learn more about using these macros, please search for 'MATCHER' +// on +// https://github.com/google/googletest/blob/master/docs/gmock_cook_book.md +// +// This file also implements some commonly used argument matchers. More +// matchers can be defined by the user implementing the +// MatcherInterface interface if necessary. +// +// See googletest/include/gtest/gtest-matchers.h for the definition of class +// Matcher, class MatcherInterface, and others. + +// GOOGLETEST_CM0002 DO NOT DELETE + +#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_ +#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_ + +#include +#include +#include +#include +#include +#include +#include // NOLINT +#include +#include +#include +#include +#include + +#include "gmock/internal/gmock-internal-utils.h" +#include "gmock/internal/gmock-port.h" +#include "gmock/internal/gmock-pp.h" +#include "gtest/gtest.h" + +// MSVC warning C5046 is new as of VS2017 version 15.8. +#if defined(_MSC_VER) && _MSC_VER >= 1915 +#define GMOCK_MAYBE_5046_ 5046 +#else +#define GMOCK_MAYBE_5046_ +#endif + +GTEST_DISABLE_MSC_WARNINGS_PUSH_( + 4251 GMOCK_MAYBE_5046_ /* class A needs to have dll-interface to be used by + clients of class B */ + /* Symbol involving type with internal linkage not defined */) + +namespace testing { + +// To implement a matcher Foo for type T, define: +// 1. a class FooMatcherImpl that implements the +// MatcherInterface interface, and +// 2. a factory function that creates a Matcher object from a +// FooMatcherImpl*. +// +// The two-level delegation design makes it possible to allow a user +// to write "v" instead of "Eq(v)" where a Matcher is expected, which +// is impossible if we pass matchers by pointers. It also eases +// ownership management as Matcher objects can now be copied like +// plain values. + +// A match result listener that stores the explanation in a string. +class StringMatchResultListener : public MatchResultListener { + public: + StringMatchResultListener() : MatchResultListener(&ss_) {} + + // Returns the explanation accumulated so far. + std::string str() const { return ss_.str(); } + + // Clears the explanation accumulated so far. + void Clear() { ss_.str(""); } + + private: + ::std::stringstream ss_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(StringMatchResultListener); +}; + +// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION +// and MUST NOT BE USED IN USER CODE!!! +namespace internal { + +// The MatcherCastImpl class template is a helper for implementing +// MatcherCast(). We need this helper in order to partially +// specialize the implementation of MatcherCast() (C++ allows +// class/struct templates to be partially specialized, but not +// function templates.). + +// This general version is used when MatcherCast()'s argument is a +// polymorphic matcher (i.e. something that can be converted to a +// Matcher but is not one yet; for example, Eq(value)) or a value (for +// example, "hello"). +template +class MatcherCastImpl { + public: + static Matcher Cast(const M& polymorphic_matcher_or_value) { + // M can be a polymorphic matcher, in which case we want to use + // its conversion operator to create Matcher. Or it can be a value + // that should be passed to the Matcher's constructor. + // + // We can't call Matcher(polymorphic_matcher_or_value) when M is a + // polymorphic matcher because it'll be ambiguous if T has an implicit + // constructor from M (this usually happens when T has an implicit + // constructor from any type). + // + // It won't work to unconditionally implicit_cast + // polymorphic_matcher_or_value to Matcher because it won't trigger + // a user-defined conversion from M to T if one exists (assuming M is + // a value). + return CastImpl(polymorphic_matcher_or_value, + std::is_convertible>{}, + std::is_convertible{}); + } + + private: + template + static Matcher CastImpl(const M& polymorphic_matcher_or_value, + std::true_type /* convertible_to_matcher */, + std::integral_constant) { + // M is implicitly convertible to Matcher, which means that either + // M is a polymorphic matcher or Matcher has an implicit constructor + // from M. In both cases using the implicit conversion will produce a + // matcher. + // + // Even if T has an implicit constructor from M, it won't be called because + // creating Matcher would require a chain of two user-defined conversions + // (first to create T from M and then to create Matcher from T). + return polymorphic_matcher_or_value; + } + + // M can't be implicitly converted to Matcher, so M isn't a polymorphic + // matcher. It's a value of a type implicitly convertible to T. Use direct + // initialization to create a matcher. + static Matcher CastImpl(const M& value, + std::false_type /* convertible_to_matcher */, + std::true_type /* convertible_to_T */) { + return Matcher(ImplicitCast_(value)); + } + + // M can't be implicitly converted to either Matcher or T. Attempt to use + // polymorphic matcher Eq(value) in this case. + // + // Note that we first attempt to perform an implicit cast on the value and + // only fall back to the polymorphic Eq() matcher afterwards because the + // latter calls bool operator==(const Lhs& lhs, const Rhs& rhs) in the end + // which might be undefined even when Rhs is implicitly convertible to Lhs + // (e.g. std::pair vs. std::pair). + // + // We don't define this method inline as we need the declaration of Eq(). + static Matcher CastImpl(const M& value, + std::false_type /* convertible_to_matcher */, + std::false_type /* convertible_to_T */); +}; + +// This more specialized version is used when MatcherCast()'s argument +// is already a Matcher. This only compiles when type T can be +// statically converted to type U. +template +class MatcherCastImpl > { + public: + static Matcher Cast(const Matcher& source_matcher) { + return Matcher(new Impl(source_matcher)); + } + + private: + class Impl : public MatcherInterface { + public: + explicit Impl(const Matcher& source_matcher) + : source_matcher_(source_matcher) {} + + // We delegate the matching logic to the source matcher. + bool MatchAndExplain(T x, MatchResultListener* listener) const override { + using FromType = typename std::remove_cv::type>::type>::type; + using ToType = typename std::remove_cv::type>::type>::type; + // Do not allow implicitly converting base*/& to derived*/&. + static_assert( + // Do not trigger if only one of them is a pointer. That implies a + // regular conversion and not a down_cast. + (std::is_pointer::type>::value != + std::is_pointer::type>::value) || + std::is_same::value || + !std::is_base_of::value, + "Can't implicitly convert from to "); + + // Do the cast to `U` explicitly if necessary. + // Otherwise, let implicit conversions do the trick. + using CastType = + typename std::conditional::value, + T&, U>::type; + + return source_matcher_.MatchAndExplain(static_cast(x), + listener); + } + + void DescribeTo(::std::ostream* os) const override { + source_matcher_.DescribeTo(os); + } + + void DescribeNegationTo(::std::ostream* os) const override { + source_matcher_.DescribeNegationTo(os); + } + + private: + const Matcher source_matcher_; + }; +}; + +// This even more specialized version is used for efficiently casting +// a matcher to its own type. +template +class MatcherCastImpl > { + public: + static Matcher Cast(const Matcher& matcher) { return matcher; } +}; + +// Template specialization for parameterless Matcher. +template +class MatcherBaseImpl { + public: + MatcherBaseImpl() = default; + + template + operator ::testing::Matcher() const { // NOLINT(runtime/explicit) + return ::testing::Matcher(new + typename Derived::template gmock_Impl()); + } +}; + +// Template specialization for Matcher with parameters. +template